id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
17,300
|
test_hr_bbcode.py
|
rafalp_Misago/misago/markup/tests/test_hr_bbcode.py
|
from ..parser import parse
def test_hr_bbcode_is_replaced_if_its_alone_in_paragraph(request_mock, user, snapshot):
text = """
Lorem ipsum dolor met.
[hr]
Sit amet elit.
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_hr_bbcode_is_skipped_if_its_part_of_paragraph(request_mock, user, snapshot):
text = "Lorem ipsum[hr]dolor met."
result = parse(text, request_mock, user)
assert result["parsed_text"] == "<p>Lorem ipsum[hr]dolor met.</p>"
| 512
|
Python
|
.py
| 13
| 36.230769
| 87
| 0.707071
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,301
|
test_inline_bbcode.py
|
rafalp_Misago/misago/markup/tests/test_inline_bbcode.py
|
from ..parser import parse
def test_bold_bbcode(request_mock, user, snapshot):
text = "Lorem [b]ipsum[/b]!"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_italics_bbcode(request_mock, user, snapshot):
text = "Lorem [i]ipsum[/i]!"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_underline_bbcode(request_mock, user, snapshot):
text = "Lorem [u]ipsum[/u]!"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_simple_inline_bbcode_is_escaped(request_mock, user, snapshot):
text = 'Lorem [b]ips <script language="application/javascript"> um[/b]!'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_inline_bbcode_can_be_mixed(request_mock, user, snapshot):
text = "Lorem [b][u]ipsum[/u][/b]!"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_inline_bbcode_can_be_mixed_with_markdown(request_mock, user, snapshot):
text = "Lorem [b]**ipsum**[/b]!"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_image_bbcode(request_mock, user, snapshot):
text = "Lorem [img]https://dummyimage.com/g/1200/500[/img] ipsum"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_image_bbcode_is_escaped(request_mock, user, snapshot):
text = 'Lorem [img]<script language="application/javascript">[/img] ipsum'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_image_bbcode_is_case_insensitive(request_mock, user, snapshot):
text = "Lorem [iMg]https://dummyimage.com/g/1200/500[/ImG] ipsum"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_url_bbcode(request_mock, user, snapshot):
text = "Lorem [url]https://dummyimage.com/g/1200/500[/url] ipsum"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_url_bbcode_is_escaped(request_mock, user, snapshot):
text = 'Lorem [url]<script language="application/javascript">[/url] ipsum'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_url_bbcode_with_link_text(request_mock, user, snapshot):
text = "Lorem [url=https://dummyimage.com/g/1200/500]dolor[/url] ipsum"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_url_bbcode_with_long_link_text(request_mock, user, snapshot):
text = "Lorem [url=https://dummyimage.com/g/1200/500]dolor met[/url] ipsum"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_url_bbcode_with_quotes_and_link_text(request_mock, user, snapshot):
text = 'Lorem [url="https://dummyimage.com/g/1200/500"]dolor[/url] ipsum'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_url_bbcode_with_quotes_and_long_link_text(request_mock, user, snapshot):
text = 'Lorem [url="https://dummyimage.com/g/1200/500"]dolor met[/url] ipsum'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_url_bbcode_link_text_is_escaped(request_mock, user, snapshot):
text = (
'Lorem [url=<script language="application/javascript">]'
'<script language="application/javascript">'
"[/url] ipsum"
)
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
| 3,652
|
Python
|
.py
| 69
| 48.26087
| 81
| 0.7
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,302
|
test_quote_bbcode.py
|
rafalp_Misago/misago/markup/tests/test_quote_bbcode.py
|
from ..parser import parse
def test_single_line_quote(request_mock, user, snapshot):
text = "[quote]Sit amet elit.[/quote]"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_single_line_authored_quote(request_mock, user, snapshot):
text = '[quote="@Bob"]Sit amet elit.[/quote]'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_single_line_authored_quote_without_quotations(request_mock, user, snapshot):
text = "[quote=@Bob]Sit amet elit.[/quote]"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_quote_can_contain_bbcode_or_markdown(request_mock, user, snapshot):
text = "[quote]Sit **amet** [u]elit[/u].[/quote]"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_multi_line_quote(request_mock, user, snapshot):
text = """
[quote]
Sit amet elit.
Another line.
[/quote]
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_quotes_can_be_nested(request_mock, user, snapshot):
text = """
[quote]
Sit amet elit.
[quote]Nested quote[/quote]
[/quote]
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
# Regression test for weird edge case in which hr gets moved outside of quote
def test_quotes_can_contain_hr_markdown(request_mock, user, snapshot):
text = """
[quote]
Sit amet elit.
- - - - -
Another line.
[/quote]
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
| 1,641
|
Python
|
.py
| 46
| 32.521739
| 85
| 0.699367
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,303
|
test_escaping.py
|
rafalp_Misago/misago/markup/tests/test_escaping.py
|
# Bunch of tests for unsafe/malicious contents escaping
from ..parser import parse
def test_text_is_escaped(request_mock, user, snapshot):
text = '<script>alert("!")</script>'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_inline_code_is_escaped(request_mock, user, snapshot):
text = '`<script>alert("!")</script>`'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_code_in_quote_markdown_is_escaped(request_mock, user, snapshot):
text = '> <script>alert("!")</script>'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_code_in_quote_bbcode_is_escaped(request_mock, user, snapshot):
text = '[quote]<script>alert("!")</script>[/quote]'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_code_in_quote_bbcode_header_is_escaped(request_mock, user, snapshot):
text = '[quote="@Us"><script>alert("!")</script>er"]Test[/quote]'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
| 1,140
|
Python
|
.py
| 22
| 47.636364
| 78
| 0.693141
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,304
|
test_code_bbcode.py
|
rafalp_Misago/misago/markup/tests/test_code_bbcode.py
|
from ..parser import parse
def test_single_line_code(request_mock, user, snapshot):
text = '[code]echo("Hello!");[/code]'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_multi_line_code(request_mock, user, snapshot):
text = """
[code]
<script>
alert("!")
</script>
[/code]
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_code_with_language_parameter(request_mock, user, snapshot):
text = '[code=php]echo("Hello!");[/code]'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_code_with_quoted_language_parameter(request_mock, user, snapshot):
text = '[code="php"]echo("Hello!");[/code]'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_code_block_disables_parsing(request_mock, user, snapshot):
text = "[code]Dolor [b]met.[/b][/code]"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
| 1,061
|
Python
|
.py
| 27
| 35.555556
| 75
| 0.681641
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,305
|
test_link_handling.py
|
rafalp_Misago/misago/markup/tests/test_link_handling.py
|
from ..parser import parse
def test_parser_converts_unmarked_links_to_hrefs(request_mock, user, snapshot):
text = "Lorem ipsum http://test.com"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_parser_skips_links_in_inline_code_markdown(request_mock, user, snapshot):
text = "Lorem ipsum `http://test.com`"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_parser_skips_links_in_inline_code_bbcode(request_mock, user, snapshot):
text = "Lorem ipsum [code]http://test.com[/code]"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_parser_skips_links_in_code_bbcode(request_mock, user, snapshot):
text = """
[code]
http://test.com
[/code]
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_absolute_link_to_site_is_changed_to_relative_link(
request_mock, user, snapshot
):
text = "clean_links step cleans http://example.com"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_absolute_link_to_site_is_added_to_internal_links_list(request_mock, user):
text = "clean_links step cleans http://example.com"
result = parse(text, request_mock, user)
assert result["internal_links"] == ["/"]
def test_absolute_link_to_site_without_schema_is_changed_to_relative_link(
request_mock, user, snapshot
):
text = "clean_links step cleans example.com"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_absolute_link_to_site_without_schema_is_added_to_internal_links_list(
request_mock, user
):
text = "clean_links step cleans example.com"
result = parse(text, request_mock, user)
assert result["internal_links"] == ["/"]
def test_absolute_link_with_path_to_site_is_changed_to_relative_link(
request_mock, user, snapshot
):
text = "clean_links step cleans http://example.com/somewhere-something/"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_absolute_link_with_path_to_site_is_added_to_internal_links_list(
request_mock, user
):
text = "clean_links step cleans http://example.com/somewhere-something/"
result = parse(text, request_mock, user)
assert result["internal_links"] == ["/somewhere-something/"]
def test_full_link_with_path_text_is_set_to_domain_and_path(request_mock, user):
text = "clean_links step cleans http://example.com/somewhere-something/"
result = parse(text, request_mock, user)
assert ">example.com/somewhere-something/<" in result["parsed_text"]
def test_outgoing_link_is_added_to_outgoing_links_list(request_mock, user):
text = "clean_links step cleans https://other.com"
result = parse(text, request_mock, user)
assert result["outgoing_links"] == ["other.com"]
def test_outgoing_llink_includes_external_nofollow_and_noopener(request_mock, user):
text = "Lorem [url]https://dummyimage.com/g/1200/500[/url] ipsum"
result = parse(text, request_mock, user)
assert 'rel="external nofollow noopener"' in result["parsed_text"]
def test_outgoing_link_without_scheme_is_added_to_outgoing_links_list(
request_mock, user
):
text = "clean_links step cleans other.com"
result = parse(text, request_mock, user)
assert result["outgoing_links"] == ["other.com"]
def test_outgoing_link_with_path_is_added_to_outgoing_links_list(request_mock, user):
text = "clean_links step cleans other.com/some/path/"
result = parse(text, request_mock, user)
assert result["outgoing_links"] == ["other.com/some/path/"]
def test_local_image_is_changed_to_relative_link(request_mock, user, snapshot):
text = "clean_links step cleans !(example.com/media/img.png)"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_local_image_is_added_to_images_list(request_mock, user):
text = "clean_links step cleans !(example.com/media/img.png)"
result = parse(text, request_mock, user)
assert result["images"] == ["/media/img.png"]
def test_remote_image_is_added_to_images_list(request_mock, user):
text = "clean_links step cleans !(other.com/media/img.png)"
result = parse(text, request_mock, user)
assert result["images"] == ["other.com/media/img.png"]
def test_local_image_link_is_added_to_images_and_links_lists(request_mock, user):
text = "clean_links step cleans [!(example.com/media/img.png)](example.com/test/)"
result = parse(text, request_mock, user)
assert result["internal_links"] == ["/test/"]
assert result["images"] == ["/media/img.png"]
def test_remote_image_link_is_added_to_images_and_links_lists(request_mock, user):
text = "clean_links step cleans [!(other.com/media/img.png)](other.com/test/)"
result = parse(text, request_mock, user)
assert result["outgoing_links"] == ["other.com/test/"]
assert result["images"] == ["other.com/media/img.png"]
def test_parser_adds_shva_to_attachment_link_querystring_if_force_option_is_enabled(
request_mock, user
):
text = "clean_links step cleans "
result = parse(text, request_mock, user, force_shva=True)
assert "/a/thumb/test/43/?shva=1" in result["parsed_text"]
def test_parser_skips_shva_in_attachment_link_querystring_if_force_option_is_omitted(
request_mock, user
):
text = "clean_links step cleans "
result = parse(text, request_mock, user)
assert "?shva=1" not in result["parsed_text"]
| 5,688
|
Python
|
.py
| 111
| 47.072072
| 86
| 0.712091
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,306
|
test_spoiler_bbcode.py
|
rafalp_Misago/misago/markup/tests/test_spoiler_bbcode.py
|
from ..parser import parse
def test_single_line_spoiler(request_mock, user, snapshot):
text = "[spoiler]Daenerys and Jon live happily ever after![/spoiler]"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_spoiler_can_contain_bbcode_or_markdown(request_mock, user, snapshot):
text = "[spoiler]Sit **amet** [u]elit[/u].[/spoiler]"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_multi_line_spoiler(request_mock, user, snapshot):
text = """
[spoiler]
Sit amet elit.
Another line.
[/spoiler]
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_spoilers_can_be_nested(request_mock, user, snapshot):
text = """
[spoiler]
Sit amet elit.
[spoiler]Nested spoiler[/spoiler]
[/spoiler]
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
# Regression test for weird edge case in which hr gets moved outside of spoiler
def test_spoilers_can_contain_hr_markdown(request_mock, user, snapshot):
text = """
[spoiler]
Sit amet elit.
- - - - -
Another line.
[/spoiler]
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
| 1,271
|
Python
|
.py
| 38
| 30.578947
| 79
| 0.709493
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,307
|
test_code_md.py
|
rafalp_Misago/misago/markup/tests/test_code_md.py
|
from ..parser import parse
def test_single_line_code_markdown(request_mock, user, snapshot):
text = '```<script>alert("!")</script>```'
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_multi_line_code_markdown(request_mock, user, snapshot):
text = """
```
<script>
alert("!")
</script>
```
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
def test_multi_line_code_markdown_with_language(request_mock, user, snapshot):
text = """
```javascript
<script>
alert("!")
</script>
```
"""
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
| 692
|
Python
|
.py
| 25
| 24.68
| 78
| 0.665658
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,308
|
test_checksums.py
|
rafalp_Misago/misago/markup/tests/test_checksums.py
|
from ..checksums import is_checksum_valid, make_checksum
message = "Test message."
post_pk = 123
def test_checksum_can_be_generated_for_post_message_and_pk():
assert make_checksum(message, [post_pk])
def test_valid_message_checksum_is_checked():
checksum = make_checksum(message, [post_pk])
assert is_checksum_valid(message, checksum, [post_pk])
def test_checksum_invalidates_if_message_is_changed():
checksum = make_checksum(message, [post_pk])
assert not is_checksum_valid("Changed message.", checksum, [post_pk])
def test_checksum_invalidates_if_pk_is_changed():
checksum = make_checksum(message, [post_pk])
assert not is_checksum_valid(message, checksum, [post_pk + 1])
| 711
|
Python
|
.py
| 14
| 47.142857
| 73
| 0.741279
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,309
|
test_finalization.py
|
rafalp_Misago/misago/markup/tests/test_finalization.py
|
from ..finalize import finalize_markup
def test_finalization_sets_translation_strings_in_empty_quotes_headings(snapshot):
test_text = '<div class="quote-heading" data-noquote="1">Lorem ipsum</div>'
finalized_text = finalize_markup(test_text)
assert snapshot == finalized_text
def test_finalization_sets_translation_strings_in_empty_quotes_headings(snapshot):
test_text = '<div class="quote-heading" data-noquote="1"></div>'
finalized_text = finalize_markup(test_text)
assert snapshot == finalized_text
def test_finalization_sets_translation_strings_in_spoilers_buttons(snapshot):
test_text = '<button class="spoiler-reveal" type="button"></button>'
finalized_text = finalize_markup(test_text)
assert snapshot == finalized_text
| 769
|
Python
|
.py
| 13
| 54.923077
| 82
| 0.757333
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,310
|
test_htmlparser.py
|
rafalp_Misago/misago/markup/tests/test_htmlparser.py
|
from ..htmlparser import parse_html_string, print_html_string
def test_parser_handles_simple_html():
root_node = parse_html_string("<p>Hello World!</p>")
assert print_html_string(root_node) == "<p>Hello World!</p>"
def test_parser_handles_html_with_brs():
root_node = parse_html_string("<p>Hello<br />World!</p>")
assert print_html_string(root_node) == "<p>Hello<br />World!</p>"
def test_parser_handles_html_with_hrs():
root_node = parse_html_string("<p>Hello</p><hr /><p>World!</p>")
assert print_html_string(root_node) == "<p>Hello</p><hr /><p>World!</p>"
def test_parser_escapes_html_in_text_nodes():
root_node = parse_html_string("<span>Hello <br> World!</span>")
assert print_html_string(root_node) == "<span>Hello <br> World!</span>"
def test_parser_escapes_quotes_in_text_nodes():
root_node = parse_html_string('<span>Hello "World"!</span>')
assert print_html_string(root_node) == "<span>Hello "World"!</span>"
def test_parser_handles_attributes():
root_node = parse_html_string('<a href="/hello-world/">Hello World!</a>')
assert print_html_string(root_node) == '<a href="/hello-world/">Hello World!</a>'
def test_parser_escapes_html_in_attributes_names():
root_node = parse_html_string('<span data-a<tt>r="<br>">Hello!</span>')
assert print_html_string(root_node) == (
"<span data-a<tt>r="<br />">Hello!</span>"
)
def test_parser_escapes_quotes_in_attributes_names():
root_node = parse_html_string('<span "data-attr"="br">Hello!</span>')
assert print_html_string(root_node) == (
'<span "data-attr"="br">Hello!</span>'
)
def test_parser_escapes_html_in_attributes_values():
root_node = parse_html_string('<span data-attr="<br>">Hello!</span>')
assert print_html_string(root_node) == (
'<span data-attr="<br>">Hello!</span>'
)
def test_parser_handles_escaped_attribute_values():
root_node = parse_html_string('<span data-attr="<br>">Hello!</span>')
assert print_html_string(root_node) == (
'<span data-attr="<br>">Hello!</span>'
)
def test_parser_escapes_quotes_in_attributes_values():
root_node = parse_html_string('<span data-attr="\'">Hello!</span>')
assert print_html_string(root_node) == ('<span data-attr="'">Hello!</span>')
def test_parser_handles_bool_attributes():
root_node = parse_html_string("<button disabled>Hello World!</button>")
assert print_html_string(root_node) == "<button disabled>Hello World!</button>"
| 2,572
|
Python
|
.py
| 45
| 52.422222
| 85
| 0.664403
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,311
|
test_pipeline_hooks.py
|
rafalp_Misago/misago/markup/tests/test_pipeline_hooks.py
|
from unittest.mock import ANY
from ..pipeline import pipeline
def test_markdown_extensions_hook_is_called_by_pipeline(mocker):
plugin = mocker.Mock()
mocker.patch("misago.markup.pipeline.hooks.markdown_extensions", [plugin])
pipeline.extend_markdown(mocker.Mock())
plugin.asssert_called_once_with(ANY)
def test_parsing_result_processors_hook_is_called_by_pipeline(mocker):
plugin = mocker.Mock()
mocker.patch("misago.markup.pipeline.hooks.parsing_result_processors", [plugin])
pipeline.extend_markdown(mocker.Mock())
plugin.asssert_called_once_with(ANY, ANY)
| 596
|
Python
|
.py
| 12
| 45.583333
| 84
| 0.770294
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,312
|
test_strikethrough_markdown.py
|
rafalp_Misago/misago/markup/tests/test_strikethrough_markdown.py
|
from ..parser import parse
def test_strikethrough_markdown(request_mock, user, snapshot):
text = "Lorem ~~ipsum~~ dolor met!"
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
| 222
|
Python
|
.py
| 5
| 40.6
| 62
| 0.716279
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,313
|
test_short_image_markdown.py
|
rafalp_Misago/misago/markup/tests/test_short_image_markdown.py
|
import pytest
from ..parser import parse
@pytest.mark.parametrize(
"text",
[
pytest.param("!(http://somewhere.com/image.jpg)", id="base"),
pytest.param("! (space)", id="space-one-word"),
pytest.param("! (space with other words)", id="space-multiple-words"),
pytest.param(
"Text before exclamation mark!(http://somewhere.com/image.jpg)",
id="text-before-mark",
),
pytest.param(
"Text before with space in between! (sometext)", id="text-before-with-space"
),
],
)
def test_short_image_markdown(request_mock, user, snapshot, text):
result = parse(text, request_mock, user)
assert snapshot == result["parsed_text"]
| 726
|
Python
|
.py
| 20
| 29.55
| 88
| 0.618777
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,314
|
test_mentions.py
|
rafalp_Misago/misago/markup/tests/test_mentions.py
|
from ..htmlparser import parse_html_string, print_html_string
from ..mentions import add_mentions
def test_util_replaces_mention_with_link_to_user_profile_in_parsed_text(user):
parsing_result = {"parsed_text": f"<p>Hello, @{user.username}!</p>", "mentions": []}
root_node = parse_html_string(parsing_result["parsed_text"])
add_mentions(parsing_result, root_node)
parsing_result["parsed_text"] = print_html_string(root_node)
assert parsing_result["parsed_text"] == (
f'<p>Hello, <a href="{user.get_absolute_url()}" '
f'data-quote="@{user.username}">@{user.username}</a>!</p>'
)
def test_util_adds_mention_to_parsig_result(user):
parsing_result = {"parsed_text": f"<p>Hello, @{user.username}!</p>", "mentions": []}
root_node = parse_html_string(parsing_result["parsed_text"])
add_mentions(parsing_result, root_node)
parsing_result["parsed_text"] = print_html_string(root_node)
assert parsing_result["mentions"] == [user.id]
def test_mentions_arent_added_for_nonexisting_user(user):
parsing_result = {"parsed_text": f"<p>Hello, @Aerith!</p>", "mentions": []}
root_node = parse_html_string(parsing_result["parsed_text"])
add_mentions(parsing_result, root_node)
parsing_result["parsed_text"] = print_html_string(root_node)
assert parsing_result["parsed_text"] == "<p>Hello, @Aerith!</p>"
def test_util_replaces_multiple_mentions_with_link_to_user_profiles_in_parsed_text(
user, other_user
):
parsing_result = {
"parsed_text": f"<p>Hello, @{user.username} and @{other_user.username}!</p>",
"mentions": [],
}
root_node = parse_html_string(parsing_result["parsed_text"])
add_mentions(parsing_result, root_node)
parsing_result["parsed_text"] = print_html_string(root_node)
assert (
f'<a href="{user.get_absolute_url()}" '
f'data-quote="@{user.username}">@{user.username}</a>'
) in parsing_result["parsed_text"]
assert (
f'<a href="{other_user.get_absolute_url()}" '
f'data-quote="@{other_user.username}">@{other_user.username}</a>'
) in parsing_result["parsed_text"]
def test_util_adds_multiple_mentions_to_parsing_result(user, other_user):
parsing_result = {
"parsed_text": f"<p>Hello, @{user.username} and @{other_user.username}!</p>",
"mentions": [],
}
root_node = parse_html_string(parsing_result["parsed_text"])
add_mentions(parsing_result, root_node)
parsing_result["parsed_text"] = print_html_string(root_node)
assert sorted(parsing_result["mentions"]) == sorted([user.id, other_user.id])
def test_util_handles_repeated_mentions_of_same_user(user):
parsing_result = {
"parsed_text": f"<p>Hello, @{user.username} and @{user.username}!</p>",
"mentions": [],
}
root_node = parse_html_string(parsing_result["parsed_text"])
add_mentions(parsing_result, root_node)
parsing_result["parsed_text"] = print_html_string(root_node)
assert parsing_result["mentions"] == [user.id]
def test_util_skips_mentions_in_links(user, snapshot):
parsing_result = {
"parsed_text": f'<p>Hello, <a href="/">@{user.username}</a></p>',
"mentions": [],
}
root_node = parse_html_string(parsing_result["parsed_text"])
add_mentions(parsing_result, root_node)
parsing_result["parsed_text"] = print_html_string(root_node)
assert parsing_result["parsed_text"] == (
f'<p>Hello, <a href="/">@{user.username}</a></p>'
)
assert parsing_result["mentions"] == []
def test_util_handles_text_without_mentions(db):
parsing_result = {"parsed_text": f"<p>Hello, world!</p>", "mentions": []}
root_node = parse_html_string(parsing_result["parsed_text"])
add_mentions(parsing_result, root_node)
parsing_result["parsed_text"] = print_html_string(root_node)
assert parsing_result["parsed_text"] == ("<p>Hello, world!</p>")
assert parsing_result["mentions"] == []
| 3,969
|
Python
|
.py
| 78
| 45.269231
| 88
| 0.661311
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,315
|
inline.py
|
rafalp_Misago/misago/markup/bbcode/inline.py
|
"""
Supported inline BBCodes: b, u, i
"""
import re
from xml.etree.ElementTree import Element
from markdown.inlinepatterns import (
ImageInlineProcessor,
LinkInlineProcessor,
Pattern,
SimpleTagPattern,
dequote,
)
class SimpleBBCodePattern(SimpleTagPattern):
"""
Case insensitive simple BBCode
"""
def __init__(self, bbcode, tag=None): # pylint: disable=super-init-not-called
self.pattern = r"(\[%s\](.*?)\[/%s\])" % (bbcode, bbcode)
self.compiled_re = re.compile(
"^(.*?)%s(.*?)$" % self.pattern, re.DOTALL | re.UNICODE | re.IGNORECASE
)
# Api for Markdown to pass safe_mode into instance
self.safe_mode = False
# Store tag
self.tag = tag or bbcode.lower()
bold = SimpleBBCodePattern("b")
italics = SimpleBBCodePattern("i")
underline = SimpleBBCodePattern("u")
class BBcodeProcessor(Pattern):
def __init__(self, pattern, md=None):
self.pattern = pattern
self.compiled_re = re.compile(
"^(.*?)%s(.*)$" % pattern, re.DOTALL | re.UNICODE | re.IGNORECASE
)
self.safe_mode = False
if md:
self.md = md
class BBCodeImageProcessor(BBcodeProcessor, ImageInlineProcessor):
def handleMatch(self, m, _):
el = Element("img")
src = m.group("content").strip()
el.set("src", self.unescape(src))
alt_text = src.replace('"', """)
if alt_text.lower()[:6] == "https:":
alt_text = alt_text[6:]
elif alt_text.lower()[:5] == "http:":
alt_text = alt_text[5:]
alt_text = alt_text.lstrip("/")
el.set("alt", alt_text)
return el, m.start("open"), m.end("close")
IMAGE_PATTERN = r"(?P<open>\[img\])(?P<content>.*?)(?P<close>\[/img\])"
def image(md):
return BBCodeImageProcessor(IMAGE_PATTERN, md)
class BBCodeUrlPattern(BBcodeProcessor, LinkInlineProcessor):
def handleMatch(self, m, _):
el = Element("a")
if m.group("arg"):
el.text = m.group("content")
href = m.group("arg")
else:
el.text = m.group("content").strip()
href = m.group("content")
if href:
el.set("href", self.unescape(href.strip()))
else:
el.set("href", "")
return el, m.start("open"), m.end("close")
URL_PATTERN = r'(?P<open>(\[url=("?)(?P<arg>.*?)("?)\])|(\[url\]))(?P<content>.*?)(?P<close>\[/url\])'
def url(md):
return BBCodeUrlPattern(URL_PATTERN, md)
| 2,536
|
Python
|
.py
| 70
| 29
| 102
| 0.58258
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,316
|
quote.py
|
rafalp_Misago/misago/markup/bbcode/quote.py
|
import re
from xml.etree.ElementTree import SubElement
import markdown
from django.utils.crypto import get_random_string
from markdown.blockprocessors import BlockProcessor
from markdown.preprocessors import Preprocessor
QUOTE_START = get_random_string(32)
QUOTE_END = get_random_string(32)
class QuoteExtension(markdown.Extension):
def extendMarkdown(self, md):
md.registerExtension(self)
md.preprocessors.register(QuotePreprocessor(md), "misago_bbcode_quote", 200)
md.parser.blockprocessors.register(
QuoteBlockProcessor(md.parser), "misago_bbcode_quote", 90
)
class QuotePreprocessor(Preprocessor):
QUOTE_BLOCK_RE = re.compile(
r"""
\[quote\](?P<text>.*?)\[/quote\]
""".strip(),
re.IGNORECASE | re.MULTILINE | re.DOTALL,
)
QUOTE_BLOCK_TITLE_RE = re.compile(
r"""
\[quote=("?)(?P<title>.*?)("?)](?P<text>.*?)\[/quote\]
""".strip(),
re.IGNORECASE | re.MULTILINE | re.DOTALL,
)
def run(self, lines):
text = "\n".join(lines)
while self.QUOTE_BLOCK_RE.search(text):
text = self.QUOTE_BLOCK_RE.sub(self.replace, text)
while self.QUOTE_BLOCK_TITLE_RE.search(text):
text = self.QUOTE_BLOCK_TITLE_RE.sub(self.replace_titled, text)
return text.split("\n")
def replace(self, matchobj):
text = matchobj.group("text")
return "\n\n%s\n\n%s\n\n%s\n\n" % (QUOTE_START, text, QUOTE_END)
def replace_titled(self, matchobj):
title = matchobj.group("title").strip()
text = matchobj.group("text")
if title:
return "\n\n%s%s\n\n%s\n\n%s\n\n" % (QUOTE_START, title, text, QUOTE_END)
return "\n\n%s\n\n%s\n\n%s\n\n" % (QUOTE_START, text, QUOTE_END)
class QuoteBlockProcessor(BlockProcessor):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._title = None
self._quote = 0
self._children = []
def test(self, parent, block):
return block.strip().startswith(QUOTE_START) or self._quote
def run(self, parent, blocks):
block = blocks.pop(0)
if block.strip().startswith(QUOTE_START):
self._quote += 1
if self._quote == 1:
self._title = block[len(QUOTE_START) :].strip() or None
self._children.append(block)
if block.strip() == QUOTE_END:
self._quote -= 1
if not self._quote:
children, self._children = self._children[1:-1], []
title, self._title = self._title, None
aside = SubElement(parent, "aside")
aside.set("class", "quote-block")
heading = SubElement(aside, "div")
heading.set("class", "quote-heading")
heading.set("data-noquote", "1")
blockquote = SubElement(aside, "blockquote")
blockquote.set("class", "quote-body")
blockquote.set("data-block", "quote")
if title:
blockquote.set("data-author", title)
if title:
heading.text = title
self.parser.parseBlocks(blockquote, children)
| 3,166
|
Python
|
.py
| 77
| 32.584416
| 85
| 0.604894
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,317
|
code.py
|
rafalp_Misago/misago/markup/bbcode/code.py
|
import re
import markdown
from markdown.extensions.attr_list import AttrListExtension
from markdown.extensions.fenced_code import FencedBlockPreprocessor
from markdown.extensions.codehilite import CodeHilite, CodeHiliteExtension
from markdown.serializers import _escape_attrib_html
class CodeBlockExtension(markdown.Extension):
def extendMarkdown(self, md):
md.registerExtension(self)
md.preprocessors.register(
CodeBlockPreprocessor(md, self.getConfigs()), "misago_code_bbcode", 24
)
class CodeBlockPreprocessor(FencedBlockPreprocessor):
FENCED_BLOCK_RE = re.compile(
r"""
\[code(=("?)(?P<lang>.*?)("?))?](([ ]*\n)+)?(?P<code>.*?)((\s|\n)+)?\[/code\]
""",
re.IGNORECASE | re.MULTILINE | re.DOTALL | re.VERBOSE,
)
def run(self, lines):
"""Match and store Fenced Code Blocks in the HtmlStash."""
# Check for dependent extensions
if not self.checked_for_deps:
for ext in self.md.registeredExtensions:
if isinstance(ext, CodeHiliteExtension):
self.codehilite_conf = ext.getConfigs()
if isinstance(ext, AttrListExtension):
self.use_attr_list = True
self.checked_for_deps = True
text = "\n".join(lines)
while 1:
m = self.FENCED_BLOCK_RE.search(text)
if m:
lang, id, classes, config = None, "", [], {}
if m.group("lang"):
lang = m.group("lang")
# If config is not empty, then the codehighlite extension
# is enabled, so we call it to highlight the code
if (
self.codehilite_conf
and self.codehilite_conf["use_pygments"]
and config.get("use_pygments", True)
):
local_config = self.codehilite_conf.copy()
local_config.update(config)
# Combine classes with cssclass. Ensure cssclass is at end
# as pygments appends a suffix under certain circumstances.
# Ignore ID as Pygments does not offer an option to set it.
if classes:
local_config["css_class"] = "{} {}".format(
" ".join(classes), local_config["css_class"]
)
highliter = CodeHilite(
m.group("code"),
lang=lang,
style=local_config.pop("pygments_style", "default"),
**local_config,
)
code = highliter.hilite(shebang=False)
else:
id_attr = lang_attr = class_attr = kv_pairs = ""
if lang:
lang_attr = f' class="language-{_escape_attrib_html(lang)}"'
if classes:
class_attr = (
f' class="{_escape_attrib_html(" ".join(classes))}"'
)
if id:
id_attr = f' id="{_escape_attrib_html(id)}"'
if (
self.use_attr_list
and config
and not config.get("use_pygments", False)
):
# Only assign key/value pairs to code element if attr_list ext is enabled, key/value pairs
# were defined on the code block, and the `use_pygments` key was not set to True. The
# `use_pygments` key could be either set to False or not defined. It is omitted from output.
kv_pairs = "".join(
f' {k}="{_escape_attrib_html(v)}"'
for k, v in config.items()
if k != "use_pygments"
)
code = self._escape(m.group("code"))
code = f"<pre{id_attr}{class_attr}><code{lang_attr}{kv_pairs}>{code}</code></pre>"
placeholder = self.md.htmlStash.store(code)
text = f"{text[:m.start()]}\n{placeholder}\n{text[m.end():]}"
else:
break
return text.split("\n")
| 4,360
|
Python
|
.py
| 89
| 32.11236
| 116
| 0.499295
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,318
|
spoiler.py
|
rafalp_Misago/misago/markup/bbcode/spoiler.py
|
import re
from xml.etree.ElementTree import SubElement
import markdown
from django.utils.crypto import get_random_string
from markdown.blockprocessors import BlockProcessor
from markdown.preprocessors import Preprocessor
SPOILER_START = get_random_string(32)
SPOILER_END = get_random_string(32)
class SpoilerExtension(markdown.Extension):
def extendMarkdown(self, md):
md.registerExtension(self)
md.preprocessors.register(SpoilerPreprocessor(md), "misago_bbcode_spoiler", 200)
md.parser.blockprocessors.register(
SpoilerBlockProcessor(md.parser), "misago_bbcode_spoiler", 85
)
class SpoilerPreprocessor(Preprocessor):
SPOILER_BLOCK_RE = re.compile(
r"""
\[spoiler\](?P<text>.*?)\[/spoiler\]
""".strip(),
re.IGNORECASE | re.MULTILINE | re.DOTALL,
)
def run(self, lines):
text = "\n".join(lines)
while self.SPOILER_BLOCK_RE.search(text):
text = self.SPOILER_BLOCK_RE.sub(self.replace, text)
return text.split("\n")
def replace(self, matchobj):
text = matchobj.group("text")
return "\n\n%s\n\n%s\n\n%s\n\n" % (SPOILER_START, text, SPOILER_END)
class SpoilerBlockProcessor(BlockProcessor):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._spoiler = 0
self._children = []
def test(self, parent, block):
return block.strip().startswith(SPOILER_START) or self._spoiler
def run(self, parent, blocks):
block = blocks.pop(0)
if block.strip().startswith(SPOILER_START):
self._spoiler += 1
self._children.append(block)
if block.strip() == SPOILER_END:
self._spoiler -= 1
if not self._spoiler:
children, self._children = self._children[1:-1], []
aside = SubElement(parent, "aside")
aside.set("class", "spoiler-block")
blockquote = SubElement(aside, "blockquote")
blockquote.set("class", "spoiler-body")
blockquote.set("data-block", "spoiler")
overlay = SubElement(aside, "div")
overlay.set("class", "spoiler-overlay")
overlay.set("data-noquote", "1")
reveal_btn = SubElement(overlay, "button")
reveal_btn.set("class", "spoiler-reveal")
reveal_btn.set("type", "button")
self.parser.parseBlocks(blockquote, children)
| 2,447
|
Python
|
.py
| 58
| 34
| 88
| 0.637247
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,319
|
hr.py
|
rafalp_Misago/misago/markup/bbcode/hr.py
|
import re
from markdown.blockprocessors import HRProcessor
class BBCodeHRProcessor(HRProcessor):
RE = r"^\[hr\]*"
# Detect hr on any line of a block.
SEARCH_RE = re.compile(RE, re.MULTILINE | re.IGNORECASE)
| 223
|
Python
|
.py
| 6
| 33.5
| 60
| 0.737089
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,320
|
urls.py
|
rafalp_Misago/misago/analytics/urls.py
|
from django.urls import path
from .views import google_site_verification
urlpatterns = [
path(
"google<slug:token>.html",
google_site_verification,
name="google-site-verification",
)
]
| 219
|
Python
|
.py
| 9
| 19.555556
| 43
| 0.6875
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,321
|
views.py
|
rafalp_Misago/misago/analytics/views.py
|
from django.http import Http404, HttpResponse
def google_site_verification(request, token):
if token != request.settings.google_site_verification:
raise Http404()
return HttpResponse("google-site-verification: google%s.html" % token)
| 253
|
Python
|
.py
| 5
| 45.8
| 74
| 0.767347
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,322
|
test_google_verification_page.py
|
rafalp_Misago/misago/analytics/tests/test_google_verification_page.py
|
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...test import assert_contains
@override_dynamic_settings(google_site_verification=None)
def test_verification_page_returns_404_if_verification_token_is_not_set(db, client):
response = client.get("/googlet0k3n.html")
assert response.status_code == 404
@override_dynamic_settings(google_site_verification="t0k3n")
def test_verification_page_returns_404_if_verification_token_is_invalid(db, client):
response = client.get("/googleinv4l1d.html")
assert response.status_code == 404
@override_dynamic_settings(google_site_verification="t0k3n")
def test_verification_page_returns_google_verification_token(db, client):
response = client.get("/googlet0k3n.html")
assert response.status_code == 200
assert_contains(response, f"google-site-verification: googlet0k3n.html")
| 887
|
Python
|
.py
| 16
| 52.25
| 84
| 0.789352
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,323
|
test_google_analytics_html.py
|
rafalp_Misago/misago/analytics/tests/test_google_analytics_html.py
|
from ...conf.test import override_dynamic_settings
from ...test import assert_contains, assert_not_contains
@override_dynamic_settings(google_tracking_id=None)
def test_tracking_script_is_not_included_if_tracking_id_is_not_set(db, client):
response = client.get("/")
assert_not_contains(response, "googletagmanager.com/gtag/js")
@override_dynamic_settings(google_tracking_id="UA-TEST")
def test_tracking_script_is_included_if_tracking_id_is_not_set(db, client):
response = client.get("/")
assert_contains(response, "googletagmanager.com/gtag/js")
assert_contains(response, "UA-TEST")
| 608
|
Python
|
.py
| 11
| 52.090909
| 79
| 0.765599
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,324
|
path.py
|
rafalp_Misago/misago/context_processors/path.py
|
from django.http import HttpRequest
def full_path(request: HttpRequest) -> dict:
return {
"path": request.path_info,
"full_path": request.get_full_path_info(),
}
| 188
|
Python
|
.py
| 6
| 26
| 50
| 0.661111
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,325
|
apps.py
|
rafalp_Misago/misago/context_processors/apps.py
|
from django.apps import AppConfig
class MisagoContextProcessorsConfig(AppConfig):
name = "misago.context_processors"
label = "misago_context_processors"
verbose_name = "Misago Context Processors"
| 210
|
Python
|
.py
| 5
| 38.2
| 47
| 0.793103
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,326
|
metatags.py
|
rafalp_Misago/misago/context_processors/metatags.py
|
from django.http import HttpRequest
from ..metatags.metatags import get_default_metatags
def default_metatags(request: HttpRequest) -> dict:
return {"default_metatags": get_default_metatags(request)}
| 207
|
Python
|
.py
| 4
| 49
| 62
| 0.805
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,327
|
permissions.py
|
rafalp_Misago/misago/context_processors/permissions.py
|
from django.http import HttpRequest
def user_permissions(request: HttpRequest) -> dict:
return {"user_permissions": request.user_permissions}
| 148
|
Python
|
.py
| 3
| 46.333333
| 57
| 0.797203
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,328
|
categories.py
|
rafalp_Misago/misago/context_processors/categories.py
|
from django.http import HttpRequest
def categories(request: HttpRequest) -> dict:
request.frontend_context.update(
{"categories_menu": request.categories.get_categories_menu()}
)
return {"categories": request.categories}
| 244
|
Python
|
.py
| 6
| 35.833333
| 69
| 0.744681
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,329
|
htmx.py
|
rafalp_Misago/misago/context_processors/htmx.py
|
from django.http import HttpRequest
def is_request_htmx(request: HttpRequest) -> dict:
return {"is_request_htmx": request.is_htmx}
| 137
|
Python
|
.py
| 3
| 42.666667
| 50
| 0.765152
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,330
|
forumindex.py
|
rafalp_Misago/misago/context_processors/forumindex.py
|
from django.http import HttpRequest
from ..forumindex.menus import get_main_menu_items
from ..menus.menu import BoundMenuItem
def main_menu(request: HttpRequest) -> dict:
main_menu = get_main_menu_items(request)
request.frontend_context.update(
{"main_menu": list(map(serialize_menu_item, main_menu))}
)
return {
"main_menu": main_menu,
"main_menu_index": main_menu[0],
}
def serialize_menu_item(item: BoundMenuItem) -> dict:
return {
"key": item.key,
"url": item.url,
"label": item.label,
}
| 575
|
Python
|
.py
| 18
| 26.333333
| 64
| 0.656364
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,331
|
test_path.py
|
rafalp_Misago/misago/context_processors/tests/test_path.py
|
from ..path import full_path
def test_full_path_context_processor_returns_full_path(rf):
request = rf.get("/full/path/?query=string")
context = full_path(request)
assert context == {
"path": "/full/path/",
"full_path": "/full/path/?query=string",
}
| 283
|
Python
|
.py
| 8
| 30.125
| 59
| 0.641026
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,332
|
test_metatags.py
|
rafalp_Misago/misago/context_processors/tests/test_metatags.py
|
from ...metatags.metatags import get_default_metatags
from ...test import assert_contains
from ..metatags import default_metatags
def test_default_metatags_context_processor_returns_default_metatags(
rf, dynamic_settings
):
request = rf.get("/")
request.settings = dynamic_settings
context = default_metatags(request)
assert "og:site_name" in context["default_metatags"]
def test_default_metatags_are_rendered_in_response_html(rf, dynamic_settings, client):
request = rf.get("/")
request.settings = dynamic_settings
default_metatags = get_default_metatags(request)
response = client.get("/")
for metatag in default_metatags.values():
assert_contains(response, metatag.as_html())
| 733
|
Python
|
.py
| 17
| 38.941176
| 86
| 0.746479
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,333
|
urls.py
|
rafalp_Misago/misago/healthcheck/urls.py
|
from django.urls import path
from .views import healthcheck
urlpatterns = [path("healthcheck/", healthcheck, name="healthcheck")]
| 132
|
Python
|
.py
| 3
| 42.333333
| 69
| 0.80315
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,334
|
tests.py
|
rafalp_Misago/misago/healthcheck/tests.py
|
from django.urls import reverse
def test_healtcheck_returns_200_response(db, client):
response = client.get(reverse("misago:healthcheck"))
assert response.status_code == 200
| 184
|
Python
|
.py
| 4
| 42.5
| 56
| 0.775281
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,335
|
views.py
|
rafalp_Misago/misago/healthcheck/views.py
|
from django.http import JsonResponse
from rest_framework.decorators import action
@action(methods=["get"], detail=True)
def healthcheck(request):
return JsonResponse({"status": "OK"})
| 190
|
Python
|
.py
| 5
| 35.8
| 44
| 0.786885
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,336
|
signals.py
|
rafalp_Misago/misago/users/signals.py
|
from datetime import timedelta
from django.contrib.auth import get_user_model
from django.db.models import Q
from django.dispatch import Signal, receiver
from django.utils import timezone
from django.utils.translation import pgettext
from .models import AuditTrail
from .profilefields import profilefields
User = get_user_model()
anonymize_user_data = Signal()
archive_user_data = Signal()
delete_user_content = Signal()
remove_old_ips = Signal()
username_changed = Signal()
@receiver(archive_user_data)
def archive_user_details(sender, archive=None, **kwargs):
archive.add_dict(
"details",
{
pgettext("archived user details", "Username"): sender.username,
pgettext("archived user details", "E-mail"): sender.email,
pgettext("archived user details", "Joined on"): sender.joined_on,
pgettext("archived user details", "Joined from IP"): (
sender.joined_from_ip or "unavailable"
),
},
)
@receiver(archive_user_data)
def archive_user_profile_fields(sender, archive=None, **kwargs):
clean_profile_fields = {}
for profile_fields_group in profilefields.get_fields_groups():
for profile_field in profile_fields_group["fields"]:
if sender.profile_fields.get(profile_field.fieldname):
field_value = sender.profile_fields[profile_field.fieldname]
clean_profile_fields[str(profile_field.label)] = field_value
if clean_profile_fields:
archive.add_dict("profile_fields", clean_profile_fields)
@receiver(archive_user_data)
def archive_user_avatar(sender, archive=None, **kwargs):
archive.add_model_file(sender.avatar_tmp, directory="avatar", prefix="tmp")
archive.add_model_file(sender.avatar_src, directory="avatar", prefix="src")
for avatar in sender.avatar_set.iterator(chunk_size=50):
archive.add_model_file(avatar.image, directory="avatar", prefix=avatar.size)
@receiver(archive_user_data)
def archive_user_audit_trail(sender, archive=None, **kwargs):
for audit_trail in sender.audittrail_set.order_by("id").iterator(chunk_size=50):
item_name = audit_trail.created_on.strftime("%H%M%S-audit-trail")
archive.add_text(item_name, audit_trail.ip_address, date=audit_trail.created_on)
@receiver(archive_user_data)
def archive_user_name_history(sender, archive=None, **kwargs):
for name_change in sender.namechanges.order_by("id").iterator(chunk_size=50):
item_name = name_change.changed_on.strftime("%H%M%S-name-change")
archive.add_dict(
item_name,
{
pgettext(
"archived username history", "New username"
): name_change.new_username,
pgettext(
"archived username history", "Old username"
): name_change.old_username,
},
date=name_change.changed_on,
)
@receiver(username_changed)
def handle_name_change(sender, **kwargs):
sender.user_renames.update(changed_by_username=sender.username)
@receiver(remove_old_ips)
def remove_old_registrations_ips(sender, *, ip_storage_time, **kwargs):
datetime_cutoff = timezone.now() - timedelta(days=ip_storage_time)
ip_is_too_new = Q(joined_on__gt=datetime_cutoff)
ip_is_already_removed = Q(joined_from_ip__isnull=True)
queryset = User.objects.exclude(ip_is_too_new | ip_is_already_removed)
queryset.update(joined_from_ip=None)
@receiver(remove_old_ips)
def remove_old_audit_trails(sender, *, ip_storage_time, **kwargs):
removal_cutoff = timezone.now() - timedelta(days=ip_storage_time)
AuditTrail.objects.filter(created_on__lte=removal_cutoff).delete()
@receiver(anonymize_user_data)
def delete_data_downloads(sender, **kwargs):
for data_download in sender.datadownload_set.iterator(chunk_size=50):
data_download.delete()
| 3,911
|
Python
|
.py
| 82
| 40.987805
| 88
| 0.696978
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,337
|
enums.py
|
rafalp_Misago/misago/users/enums.py
|
from enum import IntEnum
CUSTOM_GROUP_ID_START = 100
class DefaultGroupId(IntEnum):
ADMINS = 1
MODERATORS = 2
MEMBERS = 3
GUESTS = 4
| 152
|
Python
|
.py
| 7
| 18
| 30
| 0.711268
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,338
|
authbackends.py
|
rafalp_Misago/misago/users/authbackends.py
|
from django.contrib.auth import get_user_model
from django.contrib.auth.backends import ModelBackend
User = get_user_model()
class MisagoBackend(ModelBackend):
def authenticate(self, request, username=None, password=None, **kwargs):
if kwargs.get("email"):
username = kwargs["email"] # Bias to email if it was passed explictly
if not username or not password:
# If no username or password was given, skip rest of this auth
# This may happen if we are during different auth flow (eg. OAuth/JWT)
return None
try:
user = User.objects.get_by_username_or_email(username)
except User.DoesNotExist:
# Run the default password hasher once to reduce the timing
# difference between an existing and a non-existing user (#20760).
User().set_password(password)
else:
if user.check_password(password) and self.user_can_authenticate(user):
return user
def get_user(self, pk):
try:
manager = User._default_manager
relations = ("rank", "online_tracker", "ban_cache")
user = manager.select_related(*relations).get(pk=pk)
except User.DoesNotExist:
return None
return user if self.user_can_authenticate(user) else None
| 1,351
|
Python
|
.py
| 28
| 38.321429
| 82
| 0.646166
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,339
|
signatures.py
|
rafalp_Misago/misago/users/signatures.py
|
from ..markup import checksums, signature_flavour
def set_user_signature(request, user, user_acl, signature):
user.signature = signature
if signature:
user.signature_parsed = signature_flavour(request, user, user_acl, signature)
user.signature_checksum = make_signature_checksum(user.signature_parsed, user)
else:
user.signature_parsed = ""
user.signature_checksum = ""
def is_user_signature_valid(user):
if user.signature:
valid_checksum = make_signature_checksum(user.signature_parsed, user)
return user.signature_checksum == valid_checksum
return False
def make_signature_checksum(parsed_signature, user):
return checksums.make_checksum(parsed_signature, [user.pk])
| 748
|
Python
|
.py
| 16
| 40.8125
| 86
| 0.733793
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,340
|
test.py
|
rafalp_Misago/misago/users/test.py
|
from django.contrib.auth import get_user_model
from django.test import TestCase
from .models import AnonymousUser, Online
User = get_user_model()
class UserTestCase(TestCase):
USER_PASSWORD = "Pass.123"
USER_IP = "127.0.0.1"
def setUp(self):
super().setUp()
self.get_initial_user()
def get_initial_user(self):
self.user = self.get_anonymous_user()
def get_anonymous_user(self):
return AnonymousUser()
def get_authenticated_user(self):
return create_test_user(
"TestUser", "test@user.com", self.USER_PASSWORD, joined_from_ip=self.USER_IP
)
def get_superuser(self):
return create_test_superuser(
"TestSuperUser",
"test@superuser.com",
self.USER_PASSWORD,
joined_from_ip=self.USER_IP,
)
def login_user(self, user, password=None):
self.client.force_login(user)
def logout_user(self):
if self.user.is_authenticated:
Online.objects.filter(user=self.user).delete()
self.client.logout()
class AuthenticatedUserTestCase(UserTestCase):
def get_initial_user(self):
self.user = self.get_authenticated_user()
self.login_user(self.user)
def reload_user(self):
self.user.refresh_from_db()
class SuperUserTestCase(AuthenticatedUserTestCase):
def get_initial_user(self):
self.user = self.get_superuser()
self.login_user(self.user)
def create_test_user(username, email, password=None, **extra_fields):
"""Faster alternative to regular `create_user` followed by `setup_new_user`"""
if "avatars" not in extra_fields:
extra_fields["avatars"] = user_placeholder_avatars
return User.objects.create_user(username, email, password, **extra_fields)
def create_test_superuser(username, email, password=None, **extra_fields):
"""Faster alternative to regular `create_superuser` followed by `setup_new_user`"""
if "avatars" not in extra_fields:
extra_fields["avatars"] = user_placeholder_avatars
return User.objects.create_superuser(username, email, password, **extra_fields)
user_placeholder_avatars = [
{"size": 400, "url": "http://dummyimage.com/400/400"},
{"size": 200, "url": "http://dummyimage.com/200/200"},
{"size": 100, "url": "http://dummyimage.com/100/100"},
]
| 2,367
|
Python
|
.py
| 56
| 35.482143
| 88
| 0.67512
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,341
|
tokens.py
|
rafalp_Misago/misago/users/tokens.py
|
"""
Token creation
Token is base encoded string containing three values:
- days since unix epoch (so we can validate token expiration)
- hash unique for current state of user model
- token checksum for discovering manipulations
"""
import base64
from hashlib import sha256
from time import time
from django.conf import settings
from django.utils.encoding import force_bytes
def make(user, token_type):
user_hash = _make_hash(user, token_type)
creation_day = _days_since_epoch()
obfuscated = base64.b64encode(
force_bytes("%s%s" % (user_hash, creation_day))
).decode()
obfuscated = obfuscated.rstrip("=")
checksum = _make_checksum(obfuscated)
return "%s%s" % (checksum, obfuscated)
def is_valid(user, token_type, token):
checksum = token[:8]
obfuscated = token[8:]
if checksum != _make_checksum(obfuscated):
return False
unobfuscated = base64.b64decode(obfuscated + "=" * (-len(obfuscated) % 4)).decode()
user_hash = unobfuscated[:8]
if user_hash != _make_hash(user, token_type):
return False
creation_day = int(unobfuscated[8:])
return creation_day + 5 >= _days_since_epoch()
def _make_hash(user, token_type):
seeds = [
user.pk,
user.email,
user.password,
user.last_login.replace(microsecond=0, tzinfo=None),
token_type,
settings.SECRET_KEY,
]
return sha256(force_bytes("+".join([str(s) for s in seeds]))).hexdigest()[:8]
def _days_since_epoch():
return int(time() / (25 * 3600))
def _make_checksum(obfuscated):
return sha256(force_bytes("%s:%s" % (settings.SECRET_KEY, obfuscated))).hexdigest()[
:8
]
ACTIVATION_TOKEN = "activation"
def make_activation_token(user):
return make(user, ACTIVATION_TOKEN)
def is_activation_token_valid(user, token):
return is_valid(user, ACTIVATION_TOKEN, token)
PASSWORD_CHANGE_TOKEN = "change_password"
def make_password_change_token(user):
return make(user, PASSWORD_CHANGE_TOKEN)
def is_password_change_token_valid(user, token):
return is_valid(user, PASSWORD_CHANGE_TOKEN, token)
| 2,129
|
Python
|
.py
| 58
| 32.034483
| 88
| 0.698234
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,342
|
registration.py
|
rafalp_Misago/misago/users/registration.py
|
from django.utils.translation import pgettext
from ..core.mail import mail_user
from ..legal.models import Agreement
from ..legal.utils import save_user_agreement_acceptance
from .tokens import make_activation_token
def send_welcome_email(request, user):
settings = request.settings
mail_subject = pgettext(
"welcome email subject", "Welcome on %(forum_name)s forums!"
)
mail_subject = mail_subject % {"forum_name": settings.forum_name}
if not user.requires_activation:
mail_user(
user,
mail_subject,
"misago/emails/register/complete",
context={"settings": settings},
)
return
activation_token = make_activation_token(user)
activation_by_admin = user.requires_activation_by_admin
activation_by_user = user.requires_activation_by_user
mail_user(
user,
mail_subject,
"misago/emails/register/inactive",
context={
"activation_token": activation_token,
"activation_by_admin": activation_by_admin,
"activation_by_user": activation_by_user,
"settings": settings,
},
)
def save_user_agreements(user, form):
if not form.agreements:
return
for field_name in form.agreements.keys():
agreement_id = form.cleaned_data[field_name]
agreement = Agreement.objects.get(id=agreement_id)
save_user_agreement_acceptance(user, agreement)
user.save(update_fields=["agreements"])
def get_registration_result_json(user):
activation_method = "active"
if user.requires_activation_by_admin:
activation_method = "admin"
elif user.requires_activation_by_user:
activation_method = "user"
return {
"activation": activation_method,
"email": user.email,
"username": user.username,
}
| 1,876
|
Python
|
.py
| 52
| 28.788462
| 69
| 0.665008
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,343
|
audittrail.py
|
rafalp_Misago/misago/users/audittrail.py
|
from django.db import models
def create_audit_trail(request, obj):
return create_user_audit_trail(request.user, request.user_ip, obj)
def create_user_audit_trail(user, ip_address, obj):
if not isinstance(obj, models.Model):
raise ValueError("obj must be a valid Django model instance")
if user.is_anonymous:
return None
return user.audittrail_set.create(
user=user, ip_address=ip_address, content_object=obj
)
| 460
|
Python
|
.py
| 11
| 36.272727
| 70
| 0.724605
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,344
|
deletesrecord.py
|
rafalp_Misago/misago/users/deletesrecord.py
|
from .models import DeletedUser
def record_user_deleted_by_self():
return DeletedUser.objects.create(deleted_by=DeletedUser.DELETED_BY_SELF)
def record_user_deleted_by_staff():
return DeletedUser.objects.create(deleted_by=DeletedUser.DELETED_BY_STAFF)
def record_user_deleted_by_system():
return DeletedUser.objects.create(deleted_by=DeletedUser.DELETED_BY_SYSTEM)
| 383
|
Python
|
.py
| 7
| 51.142857
| 79
| 0.810811
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,345
|
search.py
|
rafalp_Misago/misago/users/search.py
|
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext, pgettext_lazy
from ..search import SearchProvider
from .serializers import UserCardSerializer
from .utils import slugify_username
HEAD_RESULTS = 8
TAIL_RESULTS = 8
User = get_user_model()
class SearchUsers(SearchProvider):
name = pgettext_lazy("search provider", "Users")
icon = "people"
url = "users"
def allow_search(self):
if not self.request.user_acl["can_search_users"]:
raise PermissionDenied(
pgettext("search users", "You don't have permission to search users.")
)
def search(self, query, page=1):
if query:
results = search_users(
search_deactivated=self.request.user.is_misago_admin, username=query
)
else:
results = []
return {
"results": UserCardSerializer(results, many=True).data,
"count": len(results),
}
def search_users(**filters):
queryset = User.objects.order_by("slug").select_related(
"rank", "ban_cache", "online_tracker"
)
if not filters.get("search_deactivated", False):
queryset = queryset.filter(is_active=True)
username = slugify_username(filters.get("username", ""))
results = []
# lets grab head and tail results:
results += list(queryset.filter(slug__startswith=username)[:HEAD_RESULTS])
results += list(
queryset.filter(slug__contains=username).exclude(
pk__in=[r.pk for r in results]
)[:TAIL_RESULTS]
)
return results
| 1,671
|
Python
|
.py
| 45
| 30.022222
| 86
| 0.656735
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,346
|
credentialchange.py
|
rafalp_Misago/misago/users/credentialchange.py
|
"""
Changed credentials service
Stores new e-mail and password in cache
"""
from hashlib import sha256
from django.conf import settings
from django.utils.encoding import force_bytes
def store_new_credential(request, credential_type, credential_value):
credential_key = "new_credential_%s" % credential_type
token = _make_change_token(request.user, credential_type)
request.session[credential_key] = {
"user_pk": request.user.pk,
"credential": credential_value,
"token": token,
}
return token
def read_new_credential(request, credential_type, link_token):
try:
credential_key = "new_credential_%s" % credential_type
new_credential = request.session.pop(credential_key)
except KeyError:
return None
if new_credential["user_pk"] != request.user.pk:
return None
current_token = _make_change_token(request.user, credential_type)
if link_token != current_token:
return None
if new_credential["token"] != current_token:
return None
return new_credential["credential"]
def _make_change_token(user, token_type):
seeds = (
user.pk,
user.email,
user.password,
user.last_login.replace(microsecond=0, tzinfo=None),
settings.SECRET_KEY,
str(token_type),
)
return sha256(force_bytes("+".join([str(s) for s in seeds]))).hexdigest()
| 1,411
|
Python
|
.py
| 40
| 29.4
| 77
| 0.683628
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,347
|
tasks.py
|
rafalp_Misago/misago/users/tasks.py
|
from celery import shared_task
from django.contrib.auth import get_user_model
from ..conf.shortcuts import get_dynamic_settings
from ..permissions.permissionsid import get_permissions_id
from .deletesrecord import record_user_deleted_by_self
NOTIFY_CHUNK_SIZE = 20
User = get_user_model()
@shared_task(name="users.remove-group", serializer="json")
def remove_group_from_users_groups_ids(group_id: int):
queryset = User.objects.filter(groups_ids__contains=[group_id])
for user in queryset.iterator(chunk_size=50):
user.groups_ids.remove(group_id)
user.permissions_id = get_permissions_id(user.groups_ids)
user.save(update_fields=["groups_ids", "permissions_id"])
@shared_task(name="users.delete", serializer="json")
def delete_user(user_id: int):
user = User.objects.filter(id=user_id).first()
if not user:
return
record_user_deleted_by_self()
settings = get_dynamic_settings()
user.delete(anonymous_username=settings.anonymous_username)
| 1,006
|
Python
|
.py
| 22
| 41.590909
| 67
| 0.749744
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,348
|
apps.py
|
rafalp_Misago/misago/users/apps.py
|
from django.apps import AppConfig
from django.utils.translation import pgettext_lazy
from .pages import user_profile, users_list
class MisagoUsersConfig(AppConfig):
name = "misago.users"
label = "misago_users"
verbose_name = "Misago Users"
def ready(self):
from . import signals as _
from .admin import tasks # pylint: disable=unused-import
self.register_default_users_list_pages()
self.register_default_user_profile_pages()
def register_default_users_list_pages(self):
users_list.add_section(
link="misago:users-active-posters",
component="active-posters",
name=pgettext_lazy("users lists page", "Top posters"),
)
def register_default_user_profile_pages(self):
def can_see_names_history(request, profile):
if request.user.is_authenticated:
is_account_owner = profile.pk == request.user.pk
has_permission = request.user_acl["can_see_users_name_history"]
return is_account_owner or has_permission
return False
def can_see_ban_details(request, profile):
if request.user.is_authenticated:
if request.user_acl["can_see_ban_details"]:
from .bans import get_user_ban
return bool(get_user_ban(profile, request.cache_versions))
return False
return False
user_profile.add_section(
link="misago:user-posts",
name=pgettext_lazy("user profile page", "Posts"),
icon="message",
component="posts",
)
user_profile.add_section(
link="misago:user-threads",
name=pgettext_lazy("user profile page", "Threads"),
icon="forum",
component="threads",
)
user_profile.add_section(
link="misago:user-followers",
name=pgettext_lazy("user profile page", "Followers"),
icon="favorite",
component="followers",
)
user_profile.add_section(
link="misago:user-follows",
name=pgettext_lazy("user profile page", "Follows"),
icon="favorite_border",
component="follows",
)
user_profile.add_section(
link="misago:user-details",
name=pgettext_lazy("user profile page", "Details"),
icon="person_outline",
component="details",
)
user_profile.add_section(
link="misago:username-history",
name=pgettext_lazy("user profile page", "Username history"),
icon="card_membership",
component="username-history",
visible_if=can_see_names_history,
)
user_profile.add_section(
link="misago:user-ban",
name=pgettext_lazy("user profile page", "Ban details"),
icon="remove_circle_outline",
component="ban-details",
visible_if=can_see_ban_details,
)
| 3,064
|
Python
|
.py
| 76
| 29.131579
| 79
| 0.58865
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,349
|
context_processors.py
|
rafalp_Misago/misago/users/context_processors.py
|
from django.urls import reverse
from .pages import user_profile, users_list
from .serializers import AnonymousUserSerializer, AuthenticatedUserSerializer
from .usersmenus import get_users_menus
def user_links(request):
if request.include_frontend_context:
request.frontend_context.update(
{
"REQUEST_ACTIVATION_URL": reverse("misago:request-activation"),
"FORGOTTEN_PASSWORD_URL": reverse("misago:forgotten-password"),
"BANNED_URL": reverse("misago:banned"),
"USERS_LIST_URL": reverse("misago:users"),
"AUTH_API": reverse("misago:api:auth"),
"AUTH_CRITERIA_API": reverse("misago:api:auth-criteria"),
"USERS_API": reverse("misago:api:user-list"),
"CAPTCHA_API": reverse("misago:api:captcha-question"),
"USERNAME_CHANGES_API": reverse("misago:api:usernamechange-list"),
"MENTION_API": reverse("misago:api:mention-suggestions"),
}
)
return {
"USERS_LIST_URL": users_list.get_default_link(),
"USER_PROFILE_URL": user_profile.get_default_link(),
}
def preload_user_json(request):
if not request.include_frontend_context:
return {}
request.frontend_context.update(
{"isAuthenticated": bool(request.user.is_authenticated)}
)
if request.user.is_authenticated:
serializer = AuthenticatedUserSerializer
else:
serializer = AnonymousUserSerializer
serialized_user = serializer(request.user, context={"acl": request.user_acl}).data
request.frontend_context["user"] = serialized_user
request.frontend_context.update(get_users_menus(request))
return {}
| 1,745
|
Python
|
.py
| 38
| 36.842105
| 86
| 0.659198
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,350
|
bans.py
|
rafalp_Misago/misago/users/bans.py
|
"""
API for checking values for bans
Calling this instead of Ban.objects.find_ban is preffered, if you don't want
to use validate_X_banned validators
"""
from datetime import timedelta
from django.utils import timezone
from django.utils.dateparse import parse_datetime
from . import BANS_CACHE
from .models import Ban, BanCache
CACHE_SESSION_KEY = "misago_ip_check"
def get_username_ban(username, registration_only=False):
try:
return Ban.objects.get_username_ban(username, registration_only)
except Ban.DoesNotExist:
return None
def get_email_ban(email, registration_only=False):
try:
return Ban.objects.get_email_ban(email, registration_only)
except Ban.DoesNotExist:
return None
def get_ip_ban(ip, registration_only=False):
try:
return Ban.objects.get_ip_ban(ip, registration_only)
except Ban.DoesNotExist:
return None
def get_user_ban(user, cache_versions):
"""
This function checks if user is banned
When user model is available, this is preferred to calling
get_email_ban(user.email) and get_username_ban(user.username)
because it sets ban cache on user model
"""
try:
ban_cache = user.ban_cache
if not ban_cache.is_valid(cache_versions):
_set_user_ban_cache(user, cache_versions)
except BanCache.DoesNotExist:
user.ban_cache = BanCache(user=user)
user.ban_cache = _set_user_ban_cache(user, cache_versions)
if user.ban_cache.ban:
return user.ban_cache
def _set_user_ban_cache(user, cache_versions):
ban_cache = user.ban_cache
ban_cache.cache_version = cache_versions[BANS_CACHE]
try:
user_ban = Ban.objects.get_ban(
username=user.username, email=user.email, registration_only=False
)
ban_cache.ban = user_ban
ban_cache.expires_on = user_ban.expires_on
ban_cache.user_message = user_ban.user_message
ban_cache.staff_message = user_ban.staff_message
except Ban.DoesNotExist:
ban_cache.ban = None
ban_cache.expires_on = None
ban_cache.user_message = None
ban_cache.staff_message = None
ban_cache.save()
return ban_cache
def get_request_ip_ban(request):
"""
Utility for checking if request came from banned IP
This check may be performed frequently, which is why there is extra
boilerplate that caches ban check result in session
"""
session_ban_cache = _get_session_bancache(request)
if session_ban_cache:
if session_ban_cache["is_banned"]:
return session_ban_cache
return False
found_ban = get_ip_ban(request.user_ip)
ban_cache = request.session[CACHE_SESSION_KEY] = {
"version": request.cache_versions[BANS_CACHE],
"ip": request.user_ip,
}
if found_ban:
if found_ban.expires_on:
ban_cache["expires_on"] = found_ban.expires_on.isoformat()
else:
ban_cache["expires_on"] = None
ban_cache.update({"is_banned": True, "message": found_ban.user_message})
request.session[CACHE_SESSION_KEY] = ban_cache
return _hydrate_session_cache(request.session[CACHE_SESSION_KEY])
ban_cache["is_banned"] = False
request.session[CACHE_SESSION_KEY] = ban_cache
def _get_session_bancache(request):
try:
ban_cache = request.session[CACHE_SESSION_KEY]
ban_cache = _hydrate_session_cache(ban_cache)
if ban_cache["ip"] != request.user_ip:
return None
if ban_cache["version"] != request.cache_versions[BANS_CACHE]:
return None
if ban_cache.get("expires_on"):
if ban_cache["expires_on"] < timezone.today():
return None
return ban_cache
except KeyError:
return None
def _hydrate_session_cache(ban_cache):
hydrated = ban_cache.copy()
if hydrated.get("expires_on"):
hydrated["expires_on"] = parse_datetime(hydrated["expires_on"])
return hydrated
# Utilities for front-end based bans
def ban_user(user, user_message=None, staff_message=None, length=None, expires_on=None):
if not expires_on and length:
expires_on = timezone.now() + timedelta(**length)
ban = Ban.objects.create(
banned_value=user.username.lower(),
user_message=user_message,
staff_message=staff_message,
expires_on=expires_on,
)
Ban.objects.invalidate_cache()
return ban
def ban_ip(ip, user_message=None, staff_message=None, length=None, expires_on=None):
if not expires_on and length:
expires_on = timezone.now() + timedelta(**length)
ban = Ban.objects.create(
check_type=Ban.IP,
banned_value=ip,
user_message=user_message,
staff_message=staff_message,
expires_on=expires_on,
)
Ban.objects.invalidate_cache()
return ban
| 4,900
|
Python
|
.py
| 129
| 31.248062
| 88
| 0.675333
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,351
|
activepostersranking.py
|
rafalp_Misago/misago/users/activepostersranking.py
|
from datetime import timedelta
from django.contrib.auth import get_user_model
from django.db.models import Count
from django.utils import timezone
from ..categories.models import Category
from ..conf.shortcuts import get_dynamic_settings
from .models import ActivityRanking
User = get_user_model()
def get_active_posters_ranking():
users = []
queryset = ActivityRanking.objects.select_related("user", "user__rank")
for ranking in queryset.order_by("-score"):
ranking.user.score = ranking.score
users.append(ranking.user)
return {"users": users, "users_count": len(users)}
def build_active_posters_ranking() -> list[ActivityRanking]:
settings = get_dynamic_settings()
tracked_period = settings.top_posters_ranking_length
tracked_since = timezone.now() - timedelta(days=tracked_period)
ActivityRanking.objects.all().delete()
ranked_categories = []
for category in Category.objects.all_categories():
ranked_categories.append(category.pk)
queryset = (
User.objects.filter(
is_active=True,
post__is_event=False,
post__posted_on__gte=tracked_since,
post__category__in=ranked_categories,
)
.annotate(score=Count("post"))
.filter(score__gt=0)
.order_by("-score")
)[: settings.top_posters_ranking_size]
new_ranking = []
for ranking in queryset.iterator(chunk_size=50):
new_ranking.append(ActivityRanking(user=ranking, score=ranking.score))
ActivityRanking.objects.bulk_create(new_ranking)
return new_ranking
| 1,598
|
Python
|
.py
| 39
| 34.871795
| 78
| 0.704016
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,352
|
captcha.py
|
rafalp_Misago/misago/users/captcha.py
|
import requests
from django.core.exceptions import ValidationError
from django.utils.translation import pgettext
def recaptcha_test(request):
r = requests.post(
"https://www.google.com/recaptcha/api/siteverify",
data={
"secret": request.settings.recaptcha_secret_key,
"response": request.data.get("captcha"),
"remoteip": request.user_ip,
},
)
if r.status_code == 200:
response_json = r.json()
if not response_json.get("success"):
raise ValidationError(pgettext("recaptcha check", "Please try again."))
else:
raise ValidationError(
pgettext("recaptcha check", "Failed to contact reCAPTCHA API.")
)
def qacaptcha_test(request):
answer = request.data.get("captcha", "").lower().strip()
valid_answers = get_valid_qacaptcha_answers(request.settings)
if answer not in valid_answers:
raise ValidationError(
pgettext("qacaptcha check", "Entered answer is incorrect.")
)
def get_valid_qacaptcha_answers(settings):
valid_answers = [i.strip() for i in settings.qa_answers.lower().splitlines()]
return filter(len, valid_answers)
def nocaptcha_test(request):
return # no captcha means no validation
CAPTCHA_TESTS = {"re": recaptcha_test, "qa": qacaptcha_test, "no": nocaptcha_test}
def test_request(request):
CAPTCHA_TESTS[request.settings.captcha_type](request)
| 1,452
|
Python
|
.py
| 35
| 34.742857
| 83
| 0.679487
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,353
|
utils.py
|
rafalp_Misago/misago/users/utils.py
|
import hashlib
def hash_email(email: str) -> str:
return hashlib.md5(email.lower().encode()).hexdigest()
def slugify_username(username: str) -> str:
return username.lower().strip().replace("_", "-")
| 211
|
Python
|
.py
| 5
| 38.8
| 58
| 0.693069
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,354
|
usersmenus.py
|
rafalp_Misago/misago/users/usersmenus.py
|
from typing import List
from django.urls import reverse
from ..account.menus import account_settings_menu
from .models import Rank
from .pages import users_list
def get_users_menus(request) -> dict:
return {
"userOptions": get_user_options_pages(request),
"usersLists": get_users_lists(request),
}
def get_user_options_pages(request) -> List[dict]:
links = []
if not request.user.is_authenticated:
return links
for item in account_settings_menu.bind_to_request(request).items:
if item.key == "delete":
continue
links.append(
{
"icon": item.icon,
"name": item.label,
"url": item.url,
}
)
return links
def get_users_lists(request) -> List[dict]:
links = []
for section in users_list.get_sections(request):
links.append({"name": str(section["name"]), "url": reverse(section["link"])})
ranks_queryset = (
Rank.objects.filter(is_tab=True).order_by("order").values("id", "name", "slug")
)
for rank in ranks_queryset:
links.append(
{
"name": rank["name"],
"url": reverse("misago:users-rank", kwargs={"slug": rank["slug"]}),
}
)
return links
| 1,318
|
Python
|
.py
| 40
| 24.85
| 87
| 0.586371
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,355
|
namechanges.py
|
rafalp_Misago/misago/users/namechanges.py
|
"""
Service for tracking namechanges
"""
from datetime import timedelta
from django.utils import timezone
def get_username_options(settings, user, user_acl):
changes_left = get_left_namechanges(user, user_acl)
next_on = get_next_available_namechange(user, user_acl, changes_left)
return {
"changes_left": changes_left,
"next_on": next_on,
"length_min": settings.username_length_min,
"length_max": settings.username_length_max,
}
def get_left_namechanges(user, user_acl):
name_changes_allowed = user_acl["name_changes_allowed"]
if not name_changes_allowed:
return 0
valid_changes = get_valid_changes_queryset(user, user_acl)
used_changes = valid_changes.count()
if name_changes_allowed <= used_changes:
return 0
return name_changes_allowed - used_changes
def get_next_available_namechange(user, user_acl, changes_left):
name_changes_expire = user_acl["name_changes_expire"]
if changes_left or not name_changes_expire:
return None
valid_changes = get_valid_changes_queryset(user, user_acl)
name_last_changed_on = valid_changes.latest().changed_on
return name_last_changed_on + timedelta(days=name_changes_expire)
def get_valid_changes_queryset(user, user_acl):
name_changes_expire = user_acl["name_changes_expire"]
queryset = user.namechanges.filter(changed_by=user)
if user_acl["name_changes_expire"]:
cutoff = timezone.now() - timedelta(days=name_changes_expire)
return queryset.filter(changed_on__gte=cutoff)
return queryset
| 1,587
|
Python
|
.py
| 37
| 37.540541
| 73
| 0.718282
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,356
|
validators.py
|
rafalp_Misago/misago/users/validators.py
|
import json
import logging
import re
import requests
from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError
from django.core.validators import EmailValidator
from django.utils.encoding import force_str
from django.utils.module_loading import import_string
from django.utils.translation import npgettext, pgettext_lazy
from requests.exceptions import RequestException
from .. import hooks
from ..conf import settings
from .bans import get_email_ban, get_username_ban
USERNAME_RE = re.compile(r"^[0-9a-z_]+$", re.IGNORECASE)
USERNAME_LATIN_ALPHA_RE = re.compile(r"[0-9a-z]", re.IGNORECASE)
logger = logging.getLogger("misago.users.validators")
User = get_user_model()
# E-mail validators
dj_validate_email = EmailValidator(
message=pgettext_lazy("email validator", "Enter a valid e-mail address.")
)
def validate_email(value, exclude=None):
"""shortcut function that does complete validation of email"""
dj_validate_email(value)
validate_email_available(value, exclude)
validate_email_banned(value)
def validate_email_available(value, exclude=None):
try:
user = User.objects.get_by_email(value)
if not exclude or user.pk != exclude.pk:
raise ValidationError(
pgettext_lazy(
"user email validator", "This e-mail address is not available."
)
)
except User.DoesNotExist:
pass
def validate_email_banned(value):
ban = get_email_ban(value, registration_only=True)
if ban:
if ban.user_message:
raise ValidationError(ban.user_message)
else:
raise ValidationError(
pgettext_lazy(
"user email validator", "This e-mail address is not allowed."
)
)
# Username validators
def validate_username(settings, value, exclude=None):
"""shortcut function that does complete validation of username"""
validate_username_length(settings, value)
validate_username_content(value)
validate_username_available(value, exclude)
validate_username_banned(value)
def validate_username_available(value, exclude=None):
try:
user = User.objects.get_by_username(value)
if not exclude or user.pk != exclude.pk:
raise ValidationError(
pgettext_lazy("username validator", "This username is not available.")
)
except User.DoesNotExist:
pass
def validate_username_banned(value):
ban = get_username_ban(value, registration_only=True)
if ban:
if ban.user_message:
raise ValidationError(ban.user_message)
else:
raise ValidationError(
pgettext_lazy("username validator", "This username is not allowed.")
)
def validate_username_content(value):
if not USERNAME_RE.match(value):
raise ValidationError(
pgettext_lazy(
"username validator",
"Username can only contain Latin alphabet letters, digits, and an underscore sign.",
)
)
if not USERNAME_LATIN_ALPHA_RE.search(value):
raise ValidationError(
pgettext_lazy(
"username validator",
"Username must contain Latin alphabet letters or digits.",
)
)
def validate_username_length(settings, value):
if len(value) < settings.username_length_min:
message = npgettext(
"username length validator",
"Username must be at least %(limit_value)s character long.",
"Username must be at least %(limit_value)s characters long.",
settings.username_length_min,
)
raise ValidationError(message % {"limit_value": settings.username_length_min})
if len(value) > settings.username_length_max:
message = npgettext(
"username length validator",
"Username cannot be longer than %(limit_value)s characters.",
"Username cannot be longer than %(limit_value)s characters.",
settings.username_length_max,
)
raise ValidationError(message % {"limit_value": settings.username_length_max})
# New account validators
SFS_API_URL = (
"http://api.stopforumspam.org/api?email=%(email)s&ip=%(ip)s&f=json&confidence"
)
def validate_with_sfs(request, cleaned_data, add_error):
if request.settings.enable_stop_forum_spam and cleaned_data.get("email"):
try:
_real_validate_with_sfs(
request.user_ip,
cleaned_data["email"],
request.settings.stop_forum_spam_confidence,
)
except RequestException as error:
logger.exception(error, exc_info=error)
def _real_validate_with_sfs(ip, email, confidence):
r = requests.get(SFS_API_URL % {"email": email, "ip": ip}, timeout=5)
r.raise_for_status()
api_response = json.loads(force_str(r.content))
ip_score = api_response.get("ip", {}).get("confidence", 0)
email_score = api_response.get("email", {}).get("confidence", 0)
api_score = max((ip_score, email_score))
if api_score > confidence:
raise ValidationError(
pgettext_lazy(
"stop forum spam validator",
"Data entered was found in spammers database.",
)
)
def validate_gmail_email(request, cleaned_data, add_error):
email = cleaned_data.get("email", "")
if "@" not in email:
return
username, domain = email.lower().split("@")
if domain == "gmail.com" and username.count(".") > 5:
add_error(
"email",
ValidationError(
pgettext_lazy("gmail email validator", "This e-mail is not allowed.")
),
)
# Registration validation
validators_list = settings.MISAGO_NEW_REGISTRATIONS_VALIDATORS
REGISTRATION_VALIDATORS = list(map(import_string, validators_list))
def raise_validation_error(*_):
raise ValidationError("") # Raised when message content can be discarded
def validate_new_registration(request, cleaned_data, add_error=None, validators=None):
validators = validators or REGISTRATION_VALIDATORS
add_error = add_error or raise_validation_error
for validator in validators:
validator(request, cleaned_data, add_error)
for validator in hooks.new_registrations_validators:
validator(request, cleaned_data, add_error)
| 6,493
|
Python
|
.py
| 158
| 33.170886
| 100
| 0.662744
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,357
|
middleware.py
|
rafalp_Misago/misago/users/middleware.py
|
from django.contrib.auth import logout
from django.utils.deprecation import MiddlewareMixin
from .bans import get_request_ip_ban, get_user_ban
from .models import AnonymousUser, Online
from .online import tracker
class RealIPMiddleware(MiddlewareMixin):
def process_request(self, request):
x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")
if x_forwarded_for:
request.user_ip = x_forwarded_for.split(",")[0]
else:
request.user_ip = request.META.get("REMOTE_ADDR")
class UserMiddleware(MiddlewareMixin):
def process_request(self, request):
if request.user.is_anonymous:
request.user = AnonymousUser()
elif not request.user.is_misago_admin:
if get_request_ip_ban(request) or get_user_ban(
request.user, request.cache_versions
):
logout(request)
request.user = AnonymousUser()
class OnlineTrackerMiddleware(MiddlewareMixin):
def process_request(self, request):
if request.user.is_authenticated:
try:
request._misago_online_tracker = request.user.online_tracker
except Online.DoesNotExist:
tracker.start_tracking(request, request.user)
else:
request._misago_online_tracker = None
def process_response(self, request, response):
if hasattr(request, "_misago_online_tracker"):
online_tracker = request._misago_online_tracker
if online_tracker:
if request.user.is_anonymous:
tracker.stop_tracking(request, online_tracker)
else:
tracker.update_tracker(request, online_tracker)
return response
| 1,763
|
Python
|
.py
| 40
| 33.825
| 76
| 0.649737
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,358
|
groups.py
|
rafalp_Misago/misago/users/groups.py
|
from django.contrib.auth import get_user_model
from django.http import HttpRequest
from ..core.utils import slugify
from ..permissions.models import CategoryGroupPermission, Moderator
from ..postgres.delete import delete_all, delete_one
from ..postgres.execute import execute_fetch_all
from .hooks import (
create_group_hook,
delete_group_hook,
set_default_group_hook,
update_group_hook,
update_group_description_hook,
)
from .models import Group, GroupDescription
from .tasks import remove_group_from_users_groups_ids
__all__ = [
"count_groups_members",
"create_group",
"delete_group",
"set_default_group",
]
User = get_user_model()
def create_group(**kwargs) -> Group:
if not kwargs.get("name"):
raise ValueError("The 'name' named argument is required.")
kwargs.setdefault("request", None)
kwargs.setdefault("form", None)
kwargs.setdefault("plugin_data", {})
return create_group_hook(_create_group_action, **kwargs)
def _create_group_action(**kwargs) -> Group:
ordering = (
Group.objects.order_by("-ordering").values_list("ordering", flat=True).first()
)
kwargs["ordering"] = ordering + 1
if not kwargs.get("slug"):
kwargs["slug"] = slugify(kwargs["name"])
if "request" in kwargs:
kwargs.pop("request")
if "form" in kwargs:
kwargs.pop("form")
group = Group.objects.create(**kwargs)
group.description = GroupDescription.objects.create(group=group)
return group
def update_group(group: Group, **kwargs) -> Group:
kwargs.setdefault("request", None)
kwargs.setdefault("form", None)
return update_group_hook(_update_group_action, group, **kwargs)
GROUP_FIELDS = tuple(field.name for field in Group._meta.get_fields())
def _update_group_action(group: Group, **kwargs) -> Group:
if "request" in kwargs:
kwargs.pop("request")
if "form" in kwargs:
kwargs.pop("form")
if "slug" in kwargs and not kwargs["slug"]:
if kwargs.get("name"):
kwargs["slug"] = slugify(kwargs["name"])
else:
kwargs["slug"] = slugify(group.name)
elif kwargs.get("name") and not kwargs.get("slug"):
kwargs["slug"] = slugify(kwargs["name"])
for attr_name, value in kwargs.items():
if attr_name not in GROUP_FIELDS:
raise TypeError(f"cannot set '{attr_name}' attribute on 'Group'")
setattr(group, attr_name, None if value == "" else value)
group.save()
return group
GROUP_DESCRIPTION_FIELDS = tuple(
field.name for field in GroupDescription._meta.get_fields()
)
def update_group_description(group: Group, **kwargs) -> Group:
kwargs.setdefault("request", None)
kwargs.setdefault("form", None)
return update_group_description_hook(
_update_group_description_action, group, **kwargs
)
def _update_group_description_action(group: Group, **kwargs) -> Group:
if "request" in kwargs:
kwargs.pop("request")
if "form" in kwargs:
kwargs.pop("form")
for attr_name, value in kwargs.items():
if attr_name not in GROUP_DESCRIPTION_FIELDS:
raise TypeError(f"cannot set '{attr_name}' attribute on 'GroupDescription'")
setattr(group.description, attr_name, None if value == "" else value)
group.description.save()
return group
def count_groups_members() -> list[tuple[int, int]]:
"""Returns a list of (group id, members count) tuples.
Excludes groups without any members from results.
"""
user_table = User._meta.db_table
result = execute_fetch_all(
f'SELECT UNNEST("groups_ids") AS "gid", COUNT(*) FROM "{user_table}" GROUP BY "gid";'
)
return list(map(tuple, result))
def set_default_group(group: Group, request: HttpRequest | None = None):
"""Sets group as default"""
set_default_group_hook(_set_default_group_action, group, HttpRequest)
def _set_default_group_action(group: Group, request: HttpRequest | None = None):
Group.objects.filter(id=group.id).update(is_default=True)
Group.objects.exclude(id=group.id).update(is_default=False)
def delete_group(group: Group, request: HttpRequest | None = None):
"""Deletes group with its relations from the database, bypassing the Django ORM."""
delete_group_hook(_delete_group_action, group, request)
def _delete_group_action(group: Group, request: HttpRequest | None = None):
delete_all(CategoryGroupPermission, group_id=group.id)
delete_all(Moderator, group_id=group.id)
delete_all(GroupDescription, group_id=group.id)
delete_one(group)
remove_group_from_users_groups_ids.delay(group.id)
| 4,663
|
Python
|
.py
| 110
| 37.018182
| 93
| 0.690772
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,359
|
pages.py
|
rafalp_Misago/misago/users/pages.py
|
from ..core.page import Page
users_list = Page("users list")
user_profile = Page("user profile")
| 98
|
Python
|
.py
| 3
| 31.333333
| 35
| 0.744681
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,360
|
decorators.py
|
rafalp_Misago/misago/users/decorators.py
|
from functools import wraps
from django.conf import settings
from django.core.exceptions import PermissionDenied
from django.shortcuts import redirect
from django.utils.translation import pgettext
from ..core.exceptions import Banned
from .bans import get_request_ip_ban
from .models import Ban
def deny_authenticated(f):
@wraps(f)
def decorator(request, *args, **kwargs):
if request.user.is_authenticated:
raise PermissionDenied(
pgettext(
"block authenticated decorator",
"This page is not available to signed in users.",
)
)
else:
return f(request, *args, **kwargs)
return decorator
def deny_banned_ips(f):
@wraps(f)
def decorator(request, *args, **kwargs):
ban = get_request_ip_ban(request)
if ban:
hydrated_ban = Ban(
check_type=Ban.IP,
user_message=ban["message"],
expires_on=ban["expires_on"],
)
raise Banned(hydrated_ban)
else:
return f(request, *args, **kwargs)
return decorator
| 1,164
|
Python
|
.py
| 35
| 24.371429
| 69
| 0.611954
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,361
|
setupnewuser.py
|
rafalp_Misago/misago/users/setupnewuser.py
|
from .audittrail import create_user_audit_trail
from .avatars import set_default_avatar, set_default_avatar_from_url
from .models import User
def setup_new_user(settings, user, *, avatar_url=None):
set_default_subscription_options(settings, user)
set_default_notifications_options(settings, user)
if avatar_url:
set_default_avatar_from_url(user, avatar_url)
else:
set_default_avatar(
user, settings.default_avatar, settings.default_gravatar_fallback
)
if user.joined_from_ip:
create_user_audit_trail(user, user.joined_from_ip, user)
SUBSCRIPTION_CHOICES = {
"no": User.SUBSCRIPTION_NONE,
"watch": User.SUBSCRIPTION_NOTIFY,
"watch_email": User.SUBSCRIPTION_ALL,
}
def set_default_subscription_options(settings, user):
started_threads = SUBSCRIPTION_CHOICES[settings.subscribe_start]
user.subscribe_to_started_threads = started_threads
replied_threads = SUBSCRIPTION_CHOICES[settings.subscribe_reply]
user.subscribe_to_replied_threads = replied_threads
user.save(
update_fields=["subscribe_to_replied_threads", "subscribe_to_replied_threads"]
)
def set_default_notifications_options(settings, user: User):
user.watch_started_threads = settings.watch_started_threads
user.watch_replied_threads = settings.watch_replied_threads
user.watch_new_private_threads_by_followed = (
settings.watch_new_private_threads_by_followed
)
user.watch_new_private_threads_by_other_users = (
settings.watch_new_private_threads_by_other_users
)
user.notify_new_private_threads_by_followed = (
settings.notify_new_private_threads_by_followed
)
user.notify_new_private_threads_by_other_users = (
settings.notify_new_private_threads_by_other_users
)
user.save(
update_fields=[
"watch_started_threads",
"watch_replied_threads",
"watch_new_private_threads_by_followed",
"watch_new_private_threads_by_other_users",
"notify_new_private_threads_by_followed",
"notify_new_private_threads_by_other_users",
]
)
| 2,166
|
Python
|
.py
| 52
| 35.096154
| 86
| 0.708234
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,362
|
datadownload.py
|
rafalp_Misago/misago/users/models/datadownload.py
|
from hashlib import md5
from django.conf import settings
from django.db import models
from django.utils import timezone
from django.utils.crypto import get_random_string
from django.utils.translation import pgettext_lazy
def get_data_upload_to(instance, filename):
user_id_hexdigest = md5(str(instance.user_id).encode()).hexdigest()
return "data-downloads/%s/%s/%s.zip" % (
user_id_hexdigest,
get_random_string(64),
instance.user.slug,
)
class DataDownload(models.Model):
STATUS_PENDING = 0
STATUS_PROCESSING = 1
STATUS_READY = 2
STATUS_EXPIRED = 3
STATUS_CHOICES = [
(
STATUS_PENDING,
pgettext_lazy("user data download status", "Pending"),
),
(
STATUS_PROCESSING,
pgettext_lazy("user data download status", "Processing"),
),
(
STATUS_READY,
pgettext_lazy("user data download status", "Ready"),
),
(
STATUS_EXPIRED,
pgettext_lazy("user data download status", "Expired"),
),
]
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
status = models.PositiveIntegerField(
default=STATUS_PENDING, choices=STATUS_CHOICES, db_index=True
)
requester = models.ForeignKey(
settings.AUTH_USER_MODEL,
related_name="+",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
requester_name = models.CharField(max_length=255)
requested_on = models.DateTimeField(default=timezone.now, db_index=True)
expires_on = models.DateTimeField(default=timezone.now)
file = models.FileField(
upload_to=get_data_upload_to, max_length=255, null=True, blank=True
)
class Meta:
ordering = ["-pk"]
@property
def is_ready(self):
return self.status == DataDownload.STATUS_READY
@property
def is_expired(self):
return self.status == DataDownload.STATUS_EXPIRED
def delete(self, *args, **kwargs):
if self.file:
self.file.delete(save=False)
super().delete(*args, **kwargs)
| 2,160
|
Python
|
.py
| 65
| 26.030769
| 80
| 0.642035
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,363
|
ban.py
|
rafalp_Misago/misago/users/models/ban.py
|
import re
from django.conf import settings
from django.db import IntegrityError, models
from django.utils import timezone
from django.utils.translation import pgettext_lazy
from .. import BANS_CACHE
from ...cache.versions import invalidate_cache
class BansManager(models.Manager):
def get_ip_ban(self, ip, registration_only=False):
return self.get_ban(ip=ip, registration_only=registration_only)
def get_username_ban(self, username, registration_only=False):
return self.get_ban(username=username, registration_only=registration_only)
def get_email_ban(self, email, registration_only=False):
return self.get_ban(email=email, registration_only=registration_only)
def invalidate_cache(self):
invalidate_cache(BANS_CACHE)
def get_ban(self, username=None, email=None, ip=None, registration_only=False):
checks = []
if username:
username = username.lower()
checks.append(self.model.USERNAME)
if email:
email = email.lower()
checks.append(self.model.EMAIL)
if ip:
checks.append(self.model.IP)
queryset = self.filter(is_checked=True)
if not registration_only:
queryset = self.filter(registration_only=False)
if len(checks) == 1:
queryset = queryset.filter(check_type=checks[0])
elif checks:
queryset = queryset.filter(check_type__in=checks)
for ban in queryset.iterator(chunk_size=50):
if ban.is_expired:
continue
elif (
ban.check_type == self.model.USERNAME
and username
and ban.check_value(username)
):
return ban
elif (
ban.check_type == self.model.EMAIL and email and ban.check_value(email)
):
return ban
elif ban.check_type == self.model.IP and ip and ban.check_value(ip):
return ban
raise Ban.DoesNotExist("specified values are not banned")
class Ban(models.Model):
USERNAME = 0
EMAIL = 1
IP = 2
CHOICES = [
(USERNAME, pgettext_lazy("ban type choice", "Username")),
(EMAIL, pgettext_lazy("ban type choice", "E-mail address")),
(IP, pgettext_lazy("ban type choice", "IP address")),
]
check_type = models.PositiveIntegerField(
default=USERNAME, choices=CHOICES, db_index=True
)
registration_only = models.BooleanField(default=False, db_index=True)
banned_value = models.CharField(max_length=255, db_index=True)
user_message = models.TextField(null=True, blank=True)
staff_message = models.TextField(null=True, blank=True)
expires_on = models.DateTimeField(null=True, blank=True, db_index=True)
is_checked = models.BooleanField(default=True, db_index=True)
objects = BansManager()
def save(self, *args, **kwargs):
self.banned_value = self.banned_value.lower()
self.is_checked = not self.is_expired
return super().save(*args, **kwargs)
def get_serialized_message(self):
from ..serializers import BanMessageSerializer
return BanMessageSerializer(self).data
@property
def name(self):
return self.banned_value
@property
def is_expired(self):
if self.expires_on:
return self.expires_on < timezone.now()
return False
def check_value(self, value):
if "*" in self.banned_value:
regex = re.escape(self.banned_value).replace(r"\*", r"(.*?)")
return re.search("^%s$" % regex, value, re.IGNORECASE) is not None
return self.banned_value.lower() == value.lower()
def lift(self):
self.expires_on = timezone.now()
class BanCache(models.Model):
user = models.OneToOneField(
settings.AUTH_USER_MODEL,
primary_key=True,
related_name="ban_cache",
on_delete=models.CASCADE,
)
ban = models.ForeignKey(Ban, null=True, blank=True, on_delete=models.SET_NULL)
cache_version = models.CharField(max_length=8)
user_message = models.TextField(null=True, blank=True)
staff_message = models.TextField(null=True, blank=True)
expires_on = models.DateTimeField(null=True, blank=True)
def save(self, *args, **kwargs):
try:
super().save(*args, **kwargs)
except IntegrityError:
pass # first come is first serve with ban cache
def get_serialized_message(self):
from ..serializers import BanMessageSerializer
temp_ban = Ban(
id=1,
check_type=Ban.USERNAME,
user_message=self.user_message,
staff_message=self.staff_message,
expires_on=self.expires_on,
)
return BanMessageSerializer(temp_ban).data
@property
def is_banned(self):
return bool(self.ban)
def is_valid(self, cache_versions):
is_versioned = self.cache_version == cache_versions[BANS_CACHE]
is_expired = self.expires_on and self.expires_on < timezone.now()
return is_versioned and not is_expired
| 5,160
|
Python
|
.py
| 124
| 32.951613
| 87
| 0.645342
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,364
|
user.py
|
rafalp_Misago/misago/users/models/user.py
|
from hashlib import md5
from typing import Optional, Union
from django.contrib.auth.models import AbstractBaseUser
from django.contrib.auth.models import AnonymousUser as DjangoAnonymousUser
from django.contrib.auth.models import PermissionsMixin
from django.contrib.auth.models import UserManager as BaseUserManager
from django.contrib.postgres.fields import ArrayField, HStoreField
from django.contrib.postgres.indexes import GinIndex
from django.core.mail import send_mail
from django.db import models
from django.db.models import Q
from django.urls import reverse
from django.utils import timezone
from django.utils.translation import pgettext, pgettext_lazy
from ...acl.models import Role
from ...conf import settings
from ...core.utils import slugify
from ...notifications.threads import ThreadNotifications
from ...permissions.permissionsid import get_permissions_id
from ...plugins.models import PluginDataModel
from ..avatars import store as avatars_store, delete_avatar
from ..enums import DefaultGroupId
from ..signatures import is_user_signature_valid
from ..utils import hash_email
from .group import Group
from .online import Online
from .rank import Rank
class UserManager(BaseUserManager):
def _create_user(self, username, email, password, **extra_fields):
"""
Create and save a user with the given username, email, and password.
"""
if not username:
raise ValueError("User must have an username.")
if not email:
raise ValueError("User must have an email address.")
if not extra_fields.get("rank"):
extra_fields["rank"] = Rank.objects.get_default()
if (
extra_fields.get("group")
and extra_fields.get("group_id")
and extra_fields.get("group").id != extra_fields.get("group_id")
):
raise ValueError(
"'group' and 'group_id' arguments can't be used simultaneously."
)
if extra_fields.get("group"):
extra_fields["group_id"] = extra_fields.pop("group").id
elif not extra_fields.get("group_id"):
# Find default group's ID in database or fall back to the hardcoded one
extra_fields["group_id"] = (
Group.objects.filter(is_default=True)
.values_list("id", flat=True)
.first()
) or DefaultGroupId.MEMBERS
if extra_fields.get("secondary_groups") and extra_fields.get(
"secondary_groups_ids"
):
raise ValueError(
"'secondary_groups' and 'secondary_groups_ids' arguments can't be "
"used simultaneously."
)
if extra_fields.get("groups_id"):
raise ValueError(
"'groups_id' value is calculated from 'group' and 'secondary_groups' "
"and can't be set as an argument."
)
if extra_fields.get("permissions_id"):
raise ValueError(
"'permissions_id' value is calculated from user's groups and can't be "
"set as an argument."
)
secondary_groups = extra_fields.pop("secondary_groups", None)
secondary_groups_ids = extra_fields.pop("secondary_groups_ids", None)
groups_ids = [extra_fields["group_id"]]
if secondary_groups:
groups_ids += [group.id for group in secondary_groups]
elif secondary_groups_ids:
groups_ids += secondary_groups_ids
extra_fields["groups_ids"] = sorted(set(groups_ids))
extra_fields["permissions_id"] = get_permissions_id(extra_fields["groups_ids"])
user = self.model(**extra_fields)
user.set_username(username)
user.set_email(email)
user.set_password(password)
now = extra_fields.get("joined_on", timezone.now())
user.last_login = now
user.joined_on = now
user.save(using=self._db)
self._assert_user_has_authenticated_role(user)
Online.objects.create(user=user, last_click=now)
return user
def _assert_user_has_authenticated_role(self, user):
authenticated_role = Role.objects.get(special_role="authenticated")
if authenticated_role not in user.roles.all():
user.roles.add(authenticated_role)
user.update_acl_key()
user.save(update_fields=["acl_key"])
def create_user(self, username, email=None, password=None, **extra_fields):
extra_fields.setdefault("is_staff", False)
extra_fields.setdefault("is_superuser", False)
extra_fields.setdefault("is_misago_root", False)
return self._create_user(username, email, password, **extra_fields)
def create_superuser(self, username, email, password=None, **extra_fields):
extra_fields.setdefault("is_staff", True)
extra_fields.setdefault("is_superuser", True)
extra_fields.setdefault("is_misago_root", True)
if extra_fields.get("is_staff") is not True:
raise ValueError("Superuser must have is_staff=True.")
if extra_fields.get("is_superuser") is not True:
raise ValueError("Superuser must have is_superuser=True.")
if extra_fields.get("is_misago_root") is not True:
raise ValueError("Superuser must have is_misago_root=True.")
try:
if not extra_fields.get("rank"):
forum_team_rank = Rank.objects.get(
name=pgettext("default rank", "Forum team")
)
if forum_team_rank:
extra_fields["rank"] = forum_team_rank
except Rank.DoesNotExist:
pass
if not extra_fields.get("group_id"):
extra_fields["group_id"] = DefaultGroupId.ADMINS.value
return self._create_user(username, email, password, **extra_fields)
def get_by_username(self, username):
return self.get(slug=slugify(username))
def get_by_email(self, email):
return self.get(email_hash=hash_email(email))
def get_by_username_or_email(self, login):
if "@" in login:
return self.get(email_hash=hash_email(login))
return self.get(slug=slugify(login))
class User(AbstractBaseUser, PluginDataModel, PermissionsMixin):
ACTIVATION_NONE = 0
ACTIVATION_USER = 1
ACTIVATION_ADMIN = 2
SUBSCRIPTION_NONE = 0
SUBSCRIPTION_NOTIFY = 1
SUBSCRIPTION_ALL = 2
SUBSCRIPTION_CHOICES = [
(
SUBSCRIPTION_NONE,
pgettext_lazy("user default subscription choice", "No"),
),
(
SUBSCRIPTION_NOTIFY,
pgettext_lazy("user default subscription choice", "Notify"),
),
(
SUBSCRIPTION_ALL,
pgettext_lazy("user default subscription choice", "Notify with e-mail"),
),
]
LIMIT_INVITES_TO_NONE = 0
LIMIT_INVITES_TO_FOLLOWED = 1
LIMIT_INVITES_TO_NOBODY = 2
LIMIT_INVITES_TO_CHOICES = [
(
LIMIT_INVITES_TO_NONE,
pgettext_lazy("user default invites choice", "Everybody"),
),
(
LIMIT_INVITES_TO_FOLLOWED,
pgettext_lazy("user default invites choice", "Users I follow"),
),
(
LIMIT_INVITES_TO_NOBODY,
pgettext_lazy("user default invites choice", "Nobody"),
),
]
# Note that "username" field is purely for shows.
# When searching users by their names, always use lowercased string
# and slug field instead that is normalized around DB engines
# differences in case handling.
username = models.CharField(max_length=30)
slug = models.CharField(max_length=30, unique=True)
# Misago stores user email in two fields:
# "email" holds normalized email address
# "email_hash" is lowercase hash of email address used to identify account
# as well as enforcing on database level that no more than one user can be
# using one email address
email = models.EmailField(max_length=255, db_index=True)
email_hash = models.CharField(max_length=32, unique=True)
joined_on = models.DateTimeField(
pgettext_lazy("user", "joined on"), default=timezone.now, db_index=True
)
joined_from_ip = models.GenericIPAddressField(null=True, blank=True)
is_hiding_presence = models.BooleanField(default=False)
rank = models.ForeignKey(
"Rank", null=True, blank=True, on_delete=models.deletion.PROTECT
)
group = models.ForeignKey("misago_users.Group", on_delete=models.deletion.PROTECT)
groups_ids = ArrayField(models.PositiveIntegerField(), default=list)
permissions_id = models.CharField(max_length=12)
# Misago's root admin status
# Root admin can do everything in Misago's admin panel but has no power in
# Django's admin panel.
is_misago_root = models.BooleanField(default=False)
title = models.CharField(max_length=255, null=True, blank=True)
requires_activation = models.PositiveIntegerField(default=ACTIVATION_NONE)
# Controls user access to the Django site (not used by Misago)
# This field is hardcoded in Django's admin logic, so we can't delete it.
is_staff = models.BooleanField(
pgettext_lazy("user", "staff status"),
default=False,
help_text=pgettext_lazy(
"user", "Designates whether the user can log into admin sites."
),
)
roles = models.ManyToManyField("misago_acl.Role")
acl_key = models.CharField(max_length=12, null=True, blank=True)
is_active = models.BooleanField(
pgettext_lazy("user", "active"),
db_index=True,
default=True,
help_text=pgettext_lazy(
"user",
"Designates whether this user should be treated as active. Unselect this instead of deleting accounts.",
),
)
is_active_staff_message = models.TextField(null=True, blank=True)
is_deleting_account = models.BooleanField(default=False)
avatar_tmp = models.ImageField(
max_length=255, upload_to=avatars_store.upload_to, null=True, blank=True
)
avatar_src = models.ImageField(
max_length=255, upload_to=avatars_store.upload_to, null=True, blank=True
)
avatar_crop = models.CharField(max_length=255, null=True, blank=True)
avatars = models.JSONField(null=True, blank=True)
is_avatar_locked = models.BooleanField(default=False)
avatar_lock_user_message = models.TextField(null=True, blank=True)
avatar_lock_staff_message = models.TextField(null=True, blank=True)
signature = models.TextField(null=True, blank=True)
signature_parsed = models.TextField(null=True, blank=True)
signature_checksum = models.CharField(max_length=64, null=True, blank=True)
is_signature_locked = models.BooleanField(default=False)
signature_lock_user_message = models.TextField(null=True, blank=True)
signature_lock_staff_message = models.TextField(null=True, blank=True)
followers = models.PositiveIntegerField(default=0)
following = models.PositiveIntegerField(default=0)
follows = models.ManyToManyField(
"self", related_name="followed_by", symmetrical=False
)
blocks = models.ManyToManyField(
"self", related_name="blocked_by", symmetrical=False
)
limits_private_thread_invites_to = models.PositiveIntegerField(
default=LIMIT_INVITES_TO_NONE, choices=LIMIT_INVITES_TO_CHOICES
)
unread_private_threads = models.PositiveIntegerField(default=0)
sync_unread_private_threads = models.BooleanField(default=False)
subscribe_to_started_threads = models.PositiveIntegerField(
default=SUBSCRIPTION_NONE, choices=SUBSCRIPTION_CHOICES
)
subscribe_to_replied_threads = models.PositiveIntegerField(
default=SUBSCRIPTION_NONE, choices=SUBSCRIPTION_CHOICES
)
unread_notifications = models.PositiveIntegerField(default=0)
watch_started_threads = models.PositiveIntegerField(
default=ThreadNotifications.SITE_AND_EMAIL,
choices=ThreadNotifications.choices,
)
watch_replied_threads = models.PositiveIntegerField(
default=ThreadNotifications.SITE_AND_EMAIL,
choices=ThreadNotifications.choices,
)
watch_new_private_threads_by_followed = models.PositiveIntegerField(
default=ThreadNotifications.SITE_AND_EMAIL,
choices=ThreadNotifications.choices,
)
watch_new_private_threads_by_other_users = models.PositiveIntegerField(
default=ThreadNotifications.SITE_AND_EMAIL,
choices=ThreadNotifications.choices,
)
notify_new_private_threads_by_followed = models.PositiveIntegerField(
default=ThreadNotifications.SITE_AND_EMAIL,
choices=ThreadNotifications.choices,
)
notify_new_private_threads_by_other_users = models.PositiveIntegerField(
default=ThreadNotifications.SITE_AND_EMAIL,
choices=ThreadNotifications.choices,
)
threads = models.PositiveIntegerField(default=0)
posts = models.PositiveIntegerField(default=0, db_index=True)
last_posted_on = models.DateTimeField(null=True, blank=True)
profile_fields = HStoreField(default=dict)
agreements = ArrayField(models.PositiveIntegerField(), default=list)
USERNAME_FIELD = "slug"
REQUIRED_FIELDS = ["email"]
objects = UserManager()
class Meta:
indexes = [
*PluginDataModel.Meta.indexes,
models.Index(
name="misago_user_is_staff_part",
fields=["is_staff"],
condition=Q(is_staff=True),
),
models.Index(
name="misago_user_requires_acti_part",
fields=["requires_activation"],
condition=Q(requires_activation__gt=0),
),
models.Index(
name="misago_user_is_deleting_a_part",
fields=["is_deleting_account"],
condition=Q(is_deleting_account=True),
),
models.Index(
name="misago_user_is_misago_root",
fields=["is_misago_root"],
condition=Q(is_misago_root=True),
),
GinIndex(
name="misago_user_groups_ids",
fields=["groups_ids"],
),
]
def clean(self):
self.username = self.normalize_username(self.username)
self.email = UserManager.normalize_email(self.email)
def lock(self):
"""locks user in DB, shortcut for locking user model in views"""
return User.objects.select_for_update().get(pk=self.pk)
def delete(self, *args, **kwargs):
if kwargs.pop("delete_content", False):
self.delete_content()
username = kwargs.pop("anonymous_username", None)
if username:
self.anonymize_data(username)
else:
raise ValueError("user.delete() requires 'anonymous_username' argument")
delete_avatar(self)
return super().delete(*args, **kwargs)
def delete_content(self):
from ..signals import delete_user_content
delete_user_content.send(sender=self)
def mark_for_delete(self):
self.is_active = False
self.is_deleting_account = True
self.save(update_fields=["is_active", "is_deleting_account"])
def anonymize_data(self, anonymous_username):
"""Replaces username with anonymized one, then send anonymization signal.
Items associated with this user then anonymize their user-specific data
like username or IP addresses.
"""
self.username = anonymous_username
self.slug = slugify(self.username)
from ..signals import anonymize_user_data
anonymize_user_data.send(sender=self)
@property
def is_misago_admin(self):
return self.is_misago_root or DefaultGroupId.ADMINS in self.groups_ids
@property
def requires_activation_by_admin(self):
return self.requires_activation == self.ACTIVATION_ADMIN
@property
def requires_activation_by_user(self):
return self.requires_activation == self.ACTIVATION_USER
@property
def can_be_messaged_by_everyone(self):
preference = self.limits_private_thread_invites_to
return preference == self.LIMIT_INVITES_TO_NONE
@property
def can_be_messaged_by_followed(self):
preference = self.limits_private_thread_invites_to
return preference == self.LIMIT_INVITES_TO_FOLLOWED
@property
def can_be_messaged_by_nobody(self):
preference = self.limits_private_thread_invites_to
return preference == self.LIMIT_INVITES_TO_NOBODY
@property
def has_valid_signature(self):
return is_user_signature_valid(self)
def get_absolute_url(self):
return reverse("misago:user", kwargs={"slug": self.slug, "pk": self.pk})
def get_username(self):
"""dirty hack: return real username instead of normalized slug"""
return self.username
def get_full_name(self):
return self.username
def get_short_name(self):
return self.username
def get_real_name(self):
# Bug: https://github.com/rafalp/Misago/issues/1352
# On some very rare cases self.profile_fields is deserialized as string
# by Django's ORM. I am unable to reproduce this, but in case when this
# bug occurs, this code branch will print extra information about it
if not isinstance(self.profile_fields, dict):
from django.db import connections
from django.db.backends.signals import connection_created
from django.contrib.postgres.signals import get_hstore_oids
receivers = ", ".join([str(r[1]()) for r in connection_created.receivers])
dead_receivers = "TRUE" if connection_created._dead_receivers else "FALSE"
valid_oids = None
cached_oids = get_hstore_oids("default")
with connections["default"].cursor() as cursor:
cursor.execute(
"SELECT t.oid, typarray "
"FROM pg_type t "
"JOIN pg_namespace ns ON typnamespace = ns.oid "
"WHERE typname = 'hstore'"
)
oids = []
array_oids = []
for row in cursor:
oids.append(row[0])
array_oids.append(row[1])
valid_oids = tuple(oids), tuple(array_oids)
raise RuntimeError(
f"'profile_fields' has wrong type! Please post this WHOLE message on https://github.com/rafalp/Misago/issues/1352 "
f"OID: '{cached_oids}' (valid: '{valid_oids}') "
f"Receivers: '{receivers}' (has dead: {dead_receivers}) "
f"Repr: {repr(self.profile_fields)}"
)
return self.profile_fields.get("real_name")
def set_username(self, new_username, changed_by=None):
new_username = self.normalize_username(new_username)
if new_username != self.username:
old_username = self.username
self.username = new_username
self.slug = slugify(new_username)
if self.pk:
changed_by = changed_by or self
namechange = self.record_name_change(
changed_by, new_username, old_username
)
from ..signals import username_changed
username_changed.send(sender=self)
return namechange
def record_name_change(self, changed_by, new_username, old_username):
return self.namechanges.create(
new_username=new_username,
old_username=old_username,
changed_by=changed_by,
changed_by_username=changed_by.username,
)
def set_email(self, new_email):
self.email = UserManager.normalize_email(new_email)
self.email_hash = hash_email(new_email)
def set_groups(self, group: Group, secondary_groups: list[Group] | None = None):
self.group = group
groups_ids = [group.id]
if secondary_groups:
groups_ids += [secondary_group.id for secondary_group in secondary_groups]
self.groups_ids = sorted(set(groups_ids))
self.permissions_id = get_permissions_id(self.groups_ids)
def get_any_title(self):
if self.title:
return self.title
if self.rank.title:
return self.rank.title
return str(self.rank)
def get_roles(self):
roles_pks = []
roles_dict = {}
for role in self.roles.all():
roles_pks.append(role.pk)
role.origin = self
roles_dict[role.pk] = role
if self.rank:
for role in self.rank.roles.all():
if role.pk not in roles_pks:
role.origin = self.rank
roles_pks.append(role.pk)
roles_dict[role.pk] = role
return [roles_dict[r] for r in sorted(roles_pks)]
def update_acl_key(self):
roles_pks = []
for role in self.get_roles():
if role.origin == "self":
roles_pks.append("u%s" % role.pk)
else:
roles_pks.append("%s:%s" % (self.rank.pk, role.pk))
self.acl_key = md5(",".join(roles_pks).encode()).hexdigest()[:12]
def email_user(self, subject, message, from_email=None, **kwargs):
"""sends an email to this user (for compat with Django)"""
send_mail(subject, message, from_email, [self.email], **kwargs)
def is_following(self, user_or_id: Union["User", int]) -> bool:
if isinstance(user_or_id, int):
user_id = user_or_id
elif isinstance(user_or_id, User):
user_id = user_or_id.id
else:
raise ValueError("'user_or_id' argument must be an int or User instance")
return self.follows.filter(id=user_id).exists()
def is_blocking(self, user_or_id: Union["User", int]) -> bool:
if isinstance(user_or_id, int):
user_id = user_or_id
elif isinstance(user_or_id, User):
user_id = user_or_id.id
else:
raise ValueError("'user_or_id' argument must be an int or User instance")
return self.blocks.filter(id=user_id).exists()
def get_unread_notifications_for_display(self) -> Optional[str]:
if not self.unread_notifications:
return None
if self.unread_notifications > settings.MISAGO_UNREAD_NOTIFICATIONS_LIMIT:
return f"{settings.MISAGO_UNREAD_NOTIFICATIONS_LIMIT}+"
return str(self.unread_notifications)
def clear_unread_private_threads(self):
if self.unread_private_threads or self.sync_unread_private_threads:
self.unread_private_threads = 0
self.sync_unread_private_threads = False
self.save(
update_fields=["unread_private_threads", "sync_unread_private_threads"]
)
class UsernameChange(models.Model):
user = models.ForeignKey(
settings.AUTH_USER_MODEL, related_name="namechanges", on_delete=models.CASCADE
)
changed_by = models.ForeignKey(
settings.AUTH_USER_MODEL,
null=True,
blank=True,
related_name="user_renames",
on_delete=models.SET_NULL,
)
changed_by_username = models.CharField(max_length=30)
changed_on = models.DateTimeField(default=timezone.now)
new_username = models.CharField(max_length=255)
old_username = models.CharField(max_length=255)
class Meta:
get_latest_by = "changed_on"
def set_change_author(self, user):
self.changed_by = user
self.changed_by_username = user.username
class AnonymousUser(DjangoAnonymousUser):
is_misago_admin = False
is_misago_root = False
acl_key = "anonymous"
@property
def acl_cache(self):
raise Exception("AnonymousUser.acl_cache has been removed")
@acl_cache.setter
def acl_cache(self, value):
raise TypeError("AnonymousUser instances can't be made ACL aware")
def get_roles(self):
try:
return [Role.objects.get(special_role="anonymous")]
except Role.DoesNotExist:
raise RuntimeError("Anonymous user role not found.")
def update_acl_key(self):
raise TypeError("Can't update ACL key on anonymous users")
| 24,519
|
Python
|
.py
| 546
| 35.661172
| 131
| 0.647545
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,365
|
avatar.py
|
rafalp_Misago/misago/users/models/avatar.py
|
from django.conf import settings
from django.db import models
from ..avatars import store
class Avatar(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
size = models.PositiveIntegerField(default=0)
image = models.ImageField(max_length=255, upload_to=store.upload_to)
@property
def url(self):
return self.image.url
| 389
|
Python
|
.py
| 10
| 34.7
| 80
| 0.762667
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,366
|
audittrail.py
|
rafalp_Misago/misago/users/models/audittrail.py
|
from django.conf import settings
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db import models
from django.utils import timezone
class AuditTrail(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
created_on = models.DateTimeField(db_index=True, default=timezone.now)
ip_address = models.GenericIPAddressField()
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey("content_type", "object_id")
class Meta:
ordering = ["-pk"]
| 693
|
Python
|
.py
| 14
| 45.642857
| 80
| 0.78963
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,367
|
activityranking.py
|
rafalp_Misago/misago/users/models/activityranking.py
|
from django.conf import settings
from django.db import models
class ActivityRanking(models.Model):
user = models.ForeignKey(
settings.AUTH_USER_MODEL, related_name="+", on_delete=models.CASCADE
)
score = models.PositiveIntegerField(default=0, db_index=True)
| 280
|
Python
|
.py
| 7
| 35.857143
| 76
| 0.760148
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,368
|
deleteduser.py
|
rafalp_Misago/misago/users/models/deleteduser.py
|
from django.db import models
from django.utils import timezone
from django.utils.translation import pgettext_lazy
class DeletedUser(models.Model):
DELETED_BY_SELF = 1
DELETED_BY_STAFF = 2
DELETED_BY_SYSTEM = 3
DELETED_BY_CHOICES = (
(DELETED_BY_SELF, pgettext_lazy("user deleted by", "By self")),
(DELETED_BY_STAFF, pgettext_lazy("user deleted by", "By staff")),
(DELETED_BY_SYSTEM, pgettext_lazy("user deleted by", "By system")),
)
deleted_on = models.DateTimeField(default=timezone.now, db_index=True)
deleted_by = models.PositiveIntegerField(choices=DELETED_BY_CHOICES, db_index=True)
class Meta:
ordering = ["-id"]
| 688
|
Python
|
.py
| 16
| 37.6875
| 87
| 0.701649
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,369
|
rank.py
|
rafalp_Misago/misago/users/models/rank.py
|
from django.db import models, transaction
from django.urls import reverse
from django.utils.translation import pgettext
from ...acl.cache import clear_acl_cache
from ...core.utils import slugify
class RankManager(models.Manager):
def get_default(self):
return self.get(is_default=True)
def make_rank_default(self, rank):
with transaction.atomic():
self.filter(is_default=True).update(is_default=False)
rank.is_default = True
rank.save(update_fields=["is_default"])
class Rank(models.Model):
name = models.CharField(max_length=255)
slug = models.CharField(unique=True, max_length=255)
description = models.TextField(null=True, blank=True)
title = models.CharField(max_length=255, null=True, blank=True)
roles = models.ManyToManyField("misago_acl.Role", blank=True)
css_class = models.CharField(max_length=255, null=True, blank=True)
is_default = models.BooleanField(default=False)
is_tab = models.BooleanField(default=False)
order = models.IntegerField(default=0)
objects = RankManager()
class Meta:
get_latest_by = "order"
def __str__(self):
return pgettext("rank name", self.name)
def save(self, *args, **kwargs):
if not self.pk:
self.set_order()
else:
clear_acl_cache()
if not self.slug:
self.slug = slugify(self.name)
return super().save(*args, **kwargs)
def delete(self, *args, **kwargs):
clear_acl_cache()
return super().delete(*args, **kwargs)
def get_absolute_url(self):
return reverse("misago:users-rank", kwargs={"slug": self.slug})
def set_name(self, name):
self.name = name
self.slug = slugify(name)
def set_order(self):
try:
self.order = Rank.objects.latest("order").order + 1
except Rank.DoesNotExist:
self.order = 0
| 1,936
|
Python
|
.py
| 49
| 32.265306
| 71
| 0.655099
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,370
|
__init__.py
|
rafalp_Misago/misago/users/models/__init__.py
|
from .rank import Rank
from .group import Group, GroupDescription
from .online import Online
from .user import AnonymousUser, User, UsernameChange
from .activityranking import ActivityRanking
from .avatar import Avatar
from .audittrail import AuditTrail
from .avatargallery import AvatarGallery
from .ban import Ban, BanCache
from .datadownload import DataDownload
from .deleteduser import DeletedUser
| 402
|
Python
|
.py
| 11
| 35.545455
| 53
| 0.867008
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,371
|
online.py
|
rafalp_Misago/misago/users/models/online.py
|
from django.conf import settings
from django.db import IntegrityError, models
from django.utils import timezone
class Online(models.Model):
user = models.OneToOneField(
settings.AUTH_USER_MODEL,
primary_key=True,
related_name="online_tracker",
on_delete=models.CASCADE,
)
last_click = models.DateTimeField(default=timezone.now)
def save(self, *args, **kwargs):
try:
super().save(*args, **kwargs)
except IntegrityError:
pass # first come is first serve in online tracker
| 562
|
Python
|
.py
| 16
| 28.4375
| 63
| 0.679558
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,372
|
group.py
|
rafalp_Misago/misago/users/models/group.py
|
from django.db import models
from django.utils.translation import pgettext
from ...plugins.models import PluginDataModel
from ..enums import CUSTOM_GROUP_ID_START, DefaultGroupId
class Group(PluginDataModel):
name = models.CharField(max_length=150)
slug = models.CharField(max_length=150, unique=True)
user_title = models.CharField(max_length=150, null=True, blank=True)
color = models.CharField(max_length=7, null=True, blank=True)
icon = models.CharField(max_length=50, null=True, blank=True)
css_suffix = models.CharField(max_length=50, null=True, blank=True)
is_page = models.BooleanField(default=False)
is_hidden = models.BooleanField(default=False)
is_default = models.BooleanField(default=False)
ordering = models.PositiveIntegerField(default=0)
can_use_private_threads = models.BooleanField(default=False)
can_start_private_threads = models.BooleanField(default=False)
private_thread_users_limit = models.PositiveIntegerField(default=1)
can_change_username = models.BooleanField(default=False)
username_changes_limit = models.PositiveIntegerField(default=0)
username_changes_expire = models.PositiveIntegerField(default=0)
username_changes_span = models.PositiveIntegerField(default=0)
can_see_user_profiles = models.BooleanField(default=False)
class Meta:
indexes = PluginDataModel.Meta.indexes
ordering = ["ordering"]
def __str__(self) -> str:
return pgettext("default user group", self.name)
@property
def is_admin(self):
return self.id == DefaultGroupId.ADMINS
@property
def is_protected(self):
return self.id < CUSTOM_GROUP_ID_START
def translated_user_title(self) -> str | None:
if self.user_title:
return pgettext("default user group", self.user_title)
return None
class GroupDescription(PluginDataModel):
group = models.OneToOneField(
Group,
on_delete=models.PROTECT,
primary_key=True,
related_name="description",
)
markdown = models.TextField(null=True, blank=True)
html = models.TextField(null=True, blank=True)
meta = models.TextField(null=True, blank=True)
| 2,213
|
Python
|
.py
| 48
| 40.1875
| 72
| 0.730572
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,373
|
avatargallery.py
|
rafalp_Misago/misago/users/models/avatargallery.py
|
from django.db import models
from ..avatars import store
class AvatarGallery(models.Model):
gallery = models.CharField(max_length=255)
image = models.ImageField(max_length=255, upload_to=store.upload_to)
class Meta:
ordering = ["gallery", "pk"]
@property
def url(self):
return self.image.url
| 333
|
Python
|
.py
| 10
| 28.2
| 72
| 0.707547
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,374
|
misago_avatars.py
|
rafalp_Misago/misago/users/templatetags/misago_avatars.py
|
from django import template
register = template.Library()
@register.filter(name="avatar")
def avatar(user, size=200):
found_avatar = user.avatars[0]
for user_avatar in user.avatars:
if user_avatar["size"] >= size:
found_avatar = user_avatar
return found_avatar["url"]
| 303
|
Python
|
.py
| 9
| 28.777778
| 39
| 0.690722
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,375
|
dataarchive.py
|
rafalp_Misago/misago/users/datadownloads/dataarchive.py
|
import os
import shutil
from django.core.files import File
from django.utils import timezone
from django.utils.crypto import get_random_string
from ...core.utils import slugify
FILENAME_MAX_LEN = 50
class DataArchive:
def __init__(self, user, working_dir_path):
self.user = user
self.working_dir_path = working_dir_path
self.tmp_dir_path = None
self.data_dir_path = None
self.file_path = None
self.file = None
def __enter__(self):
self.tmp_dir_path = self.create_tmp_dir()
self.data_dir_path = self.create_data_dir()
return self
def __exit__(self, *args):
self.delete_file()
self.delete_tmp_dir()
def create_tmp_dir(self):
tmp_dir_name = get_tmp_filename(self.user)
tmp_dir_path = os.path.join(self.working_dir_path, tmp_dir_name)
os.mkdir(tmp_dir_path)
return tmp_dir_path
def create_data_dir(self):
data_dir_name = get_tmp_filename(self.user)
data_dir_path = os.path.join(self.tmp_dir_path, data_dir_name)
os.mkdir(data_dir_path)
return data_dir_path
def delete_tmp_dir(self):
if self.tmp_dir_path:
shutil.rmtree(self.tmp_dir_path)
self.tmp_dir_path = None
self.data_dir_path = None
def get_file(self):
file_name = get_tmp_filename(self.user)
file_path = os.path.join(self.working_dir_path, file_name)
self.file_path = shutil.make_archive(file_path, "zip", self.tmp_dir_path)
self.file = open(self.file_path, "rb")
return File(self.file)
def delete_file(self):
if self.file:
self.file.close()
self.file = None
if self.file_path:
os.remove(self.file_path)
self.file_path = None
def add_text(self, name, value, date=None, directory=None):
clean_filename = slugify(str(name))
file_dir_path = self.make_final_path(date=date, directory=directory)
file_path = os.path.join(file_dir_path, "%s.txt" % clean_filename)
with open(file_path, "w") as fp:
fp.write(str(value))
return file_path
def add_dict(self, name, value, date=None, directory=None):
text_lines = []
for key, item in value.items():
text_lines.append("%s: %s" % (key, item))
text = "\n".join(text_lines)
return self.add_text(name, text, date=date, directory=directory)
def add_model_file(self, model_file, prefix=None, date=None, directory=None):
if not model_file:
return None
target_dir_path = self.make_final_path(date=date, directory=directory)
filename = os.path.basename(model_file.name)
if prefix:
prefixed_filename = "%s-%s" % (prefix, filename)
clean_filename = trim_long_filename(prefixed_filename)
target_path = os.path.join(target_dir_path, clean_filename)
else:
clean_filename = trim_long_filename(filename)
target_path = os.path.join(target_dir_path, clean_filename)
with open(target_path, "wb") as fp:
for chunk in model_file.chunks():
fp.write(chunk)
return target_path
def make_final_path(self, date=None, directory=None):
# fixme: os.path.isdir test can be avoided in py37k
if date and directory:
raise ValueError("date and directory arguments are mutually exclusive")
data_dir_path = self.data_dir_path
if date:
final_path = data_dir_path
path_items = [date.strftime("%Y"), date.strftime("%m"), date.strftime("%d")]
for path_item in path_items:
final_path = os.path.join(final_path, str(path_item))
if not os.path.isdir(final_path):
os.mkdir(final_path)
return final_path
if directory:
final_path = os.path.join(data_dir_path, str(directory))
if not os.path.isdir(final_path):
os.mkdir(final_path)
return final_path
return data_dir_path
def get_tmp_filename(user):
filename_bits = [
user.slug,
timezone.now().strftime("%Y%m%d-%H%M%S"),
get_random_string(6),
]
return "-".join(filename_bits)
def trim_long_filename(filename):
# fixme: consider moving this utility to better place?
# eg. to trim too long attachment filenames on upload
if len(filename) < FILENAME_MAX_LEN:
return filename
name, extension = os.path.splitext(filename)
name_len = FILENAME_MAX_LEN - len(extension)
return "%s%s" % (name[:name_len], extension)
| 4,722
|
Python
|
.py
| 113
| 32.610619
| 88
| 0.614795
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,376
|
__init__.py
|
rafalp_Misago/misago/users/datadownloads/__init__.py
|
from datetime import timedelta
from django.utils import timezone
from ...conf import settings
from ..models import DataDownload
from ..signals import archive_user_data
from .dataarchive import DataArchive
STATUS_REQUEST = (DataDownload.STATUS_PENDING, DataDownload.STATUS_PROCESSING)
def user_has_data_download_request(user):
queryset = DataDownload.objects.filter(user=user, status__in=STATUS_REQUEST)
return queryset.exists()
def request_user_data_download(user, requester=None):
requester = requester or user
return DataDownload.objects.create(
user=user, requester=requester, requester_name=requester.username
)
def prepare_user_data_download(download, expires_in, logger=None):
working_dir = settings.MISAGO_USER_DATA_DOWNLOADS_WORKING_DIR
user = download.user
with DataArchive(user, working_dir) as archive:
try:
archive_user_data.send(user, archive=archive)
download.status = DataDownload.STATUS_READY
download.expires_on = timezone.now() + timedelta(hours=expires_in)
download.file = archive.get_file()
download.save()
# todo: send an e-mail with download link
return True
except Exception as e: # pylint: disable=broad-except
if logger:
logger.exception(e, exc_info=e)
return False
def expire_user_data_download(download):
download.status = DataDownload.STATUS_EXPIRED
if download.file:
download.file.delete(save=False)
download.save()
| 1,560
|
Python
|
.py
| 36
| 36.388889
| 80
| 0.715232
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,377
|
0015_user_agreements.py
|
rafalp_Misago/misago/users/migrations/0015_user_agreements.py
|
# Generated by Django 1.11.15 on 2018-08-16 17:29
import django.contrib.postgres.fields
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_users", "0014_datadownload")]
operations = [
migrations.AddField(
model_name="user",
name="agreements",
field=django.contrib.postgres.fields.ArrayField(
base_field=models.PositiveIntegerField(), default=list, size=None
),
)
]
| 514
|
Python
|
.py
| 14
| 28.928571
| 81
| 0.655936
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,378
|
0019_remove_custom_partial_indexes.py
|
rafalp_Misago/misago/users/migrations/0019_remove_custom_partial_indexes.py
|
# Generated by Django 2.2.1 on 2019-05-18 16:31
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_users", "0018_auto_20190511_2051")]
operations = [
migrations.RunSQL("DROP INDEX IF EXISTS misago_user_is_staf_bf68aa_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_user_require_05204a_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_user_is_dele_2798b0_part"),
]
| 463
|
Python
|
.py
| 9
| 46
| 82
| 0.724444
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,379
|
0017_move_bans_to_cache_version.py
|
rafalp_Misago/misago/users/migrations/0017_move_bans_to_cache_version.py
|
# Generated by Django 1.11.16 on 2018-11-29 20:28
from django.db import migrations, models
from .. import BANS_CACHE
def populate_cache_version(apps, _):
BanCache = apps.get_model("misago_users", "BanCache")
BanCache.objects.all().delete()
class Migration(migrations.Migration):
dependencies = [("misago_users", "0016_cache_version")]
operations = [
migrations.RemoveField(model_name="bancache", name="bans_version"),
migrations.RunPython(populate_cache_version, migrations.RunPython.noop),
migrations.AddField(
model_name="bancache",
name="cache_version",
field=models.CharField(max_length=8),
),
]
| 694
|
Python
|
.py
| 17
| 34.294118
| 80
| 0.681073
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,380
|
0011_auto_20180331_2208.py
|
rafalp_Misago/misago/users/migrations/0011_auto_20180331_2208.py
|
# Generated by Django 1.11.11 on 2018-03-31 22:08
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_users", "0010_user_profile_fields")]
operations = [
migrations.AddField(
model_name="user",
name="is_deleting_account",
field=models.BooleanField(default=False),
)
]
| 388
|
Python
|
.py
| 11
| 28.181818
| 65
| 0.652406
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,381
|
0010_user_profile_fields.py
|
rafalp_Misago/misago/users/migrations/0010_user_profile_fields.py
|
# Generated by Django 1.11.1 on 2017-06-03 22:15
import django.contrib.postgres.fields
from django.contrib.postgres.operations import HStoreExtension
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_users", "0009_redo_partial_indexes")]
operations = [
HStoreExtension(),
migrations.AddField(
model_name="user",
name="profile_fields",
field=django.contrib.postgres.fields.HStoreField(default=dict),
),
]
| 526
|
Python
|
.py
| 14
| 31.214286
| 75
| 0.701375
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,382
|
0026_plugin_data.py
|
rafalp_Misago/misago/users/migrations/0026_plugin_data.py
|
# Generated by Django 4.2.7 on 2023-12-05 19:22
import django.contrib.postgres.indexes
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("misago_users", "0025_alter_user_rank"),
]
operations = [
migrations.AddField(
model_name="user",
name="plugin_data",
field=models.JSONField(default=dict),
),
migrations.AddIndex(
model_name="user",
index=django.contrib.postgres.indexes.GinIndex(
fields=["plugin_data"], name="misago_user_plugin__c45a32_gin"
),
),
]
| 650
|
Python
|
.py
| 20
| 24.1
| 77
| 0.603834
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,383
|
0024_user_notifications.py
|
rafalp_Misago/misago/users/migrations/0024_user_notifications.py
|
# Generated by Django 3.2.15 on 2023-04-06 18:04
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("misago_users", "0023_remove_user_sso_id"),
]
operations = [
migrations.AddField(
model_name="user",
name="notify_new_private_threads_by_followed",
field=models.PositiveIntegerField(
choices=[
(0, "Don't notify"),
(1, "Notify on site only"),
(2, "Notify on site and with e-mail"),
],
default=2,
),
),
migrations.AddField(
model_name="user",
name="notify_new_private_threads_by_other_users",
field=models.PositiveIntegerField(
choices=[
(0, "Don't notify"),
(1, "Notify on site only"),
(2, "Notify on site and with e-mail"),
],
default=2,
),
),
migrations.AddField(
model_name="user",
name="unread_notifications",
field=models.PositiveIntegerField(default=0),
),
migrations.AddField(
model_name="user",
name="watch_new_private_threads_by_followed",
field=models.PositiveIntegerField(
choices=[
(0, "Don't notify"),
(1, "Notify on site only"),
(2, "Notify on site and with e-mail"),
],
default=2,
),
),
migrations.AddField(
model_name="user",
name="watch_new_private_threads_by_other_users",
field=models.PositiveIntegerField(
choices=[
(0, "Don't notify"),
(1, "Notify on site only"),
(2, "Notify on site and with e-mail"),
],
default=2,
),
),
migrations.AddField(
model_name="user",
name="watch_replied_threads",
field=models.PositiveIntegerField(
choices=[
(0, "Don't notify"),
(1, "Notify on site only"),
(2, "Notify on site and with e-mail"),
],
default=2,
),
),
migrations.AddField(
model_name="user",
name="watch_started_threads",
field=models.PositiveIntegerField(
choices=[
(0, "Don't notify"),
(1, "Notify on site only"),
(2, "Notify on site and with e-mail"),
],
default=2,
),
),
]
| 2,850
|
Python
|
.py
| 85
| 19.447059
| 61
| 0.442955
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,384
|
0009_redo_partial_indexes.py
|
rafalp_Misago/misago/users/migrations/0009_redo_partial_indexes.py
|
# Generated by Django 1.11.1 on 2017-05-26 21:56
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_users", "0008_ban_registration_only")]
operations = []
| 212
|
Python
|
.py
| 5
| 39.2
| 67
| 0.745098
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,385
|
0025_alter_user_rank.py
|
rafalp_Misago/misago/users/migrations/0025_alter_user_rank.py
|
# Generated by Django 4.2.7 on 2023-11-13 19:08
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
("misago_users", "0024_user_notifications"),
]
operations = [
migrations.AlterField(
model_name="user",
name="rank",
field=models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.PROTECT,
to="misago_users.rank",
),
),
]
| 576
|
Python
|
.py
| 19
| 21.105263
| 60
| 0.571429
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,386
|
0005_dj_19_update.py
|
rafalp_Misago/misago/users/migrations/0005_dj_19_update.py
|
# Generated by Django 1.9.7 on 2016-07-17 02:05
from django.db import migrations, models
import misago.users.models.user
class Migration(migrations.Migration):
dependencies = [("misago_users", "0004_default_ranks")]
operations = [
migrations.AlterModelManagers(
name="user", managers=[("objects", misago.users.models.user.UserManager())]
),
migrations.AlterField(
model_name="rank",
name="roles",
field=models.ManyToManyField(blank=True, to="misago_acl.Role"),
),
migrations.AlterField(
model_name="user",
name="groups",
field=models.ManyToManyField(
blank=True,
help_text="The groups this user belongs to. A user will get all permissions granted to each of their groups.",
related_name="user_set",
related_query_name="user",
to="auth.Group",
verbose_name="groups",
),
),
]
| 1,030
|
Python
|
.py
| 27
| 27.666667
| 126
| 0.582583
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,387
|
0029_users_permissions_nonnull.py
|
rafalp_Misago/misago/users/migrations/0029_users_permissions_nonnull.py
|
# Generated by Django 4.2.7 on 2023-12-21 21:33
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
("misago_users", "0028_default_groups"),
]
operations = [
migrations.AlterField(
model_name="user",
name="group",
field=models.ForeignKey(
on_delete=django.db.models.deletion.PROTECT, to="misago_users.group"
),
),
migrations.AlterField(
model_name="user",
name="permissions_id",
field=models.CharField(max_length=12),
),
]
| 661
|
Python
|
.py
| 21
| 22.857143
| 84
| 0.59434
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,388
|
0001_initial.py
|
rafalp_Misago/misago/users/migrations/0001_initial.py
|
import django.db.models.deletion
import django.utils.timezone
from django.conf import settings
from django.db import migrations, models
import misago.users.avatars.store
class Migration(migrations.Migration):
initial = True
dependencies = [("auth", "0001_initial"), ("misago_acl", "0001_initial")]
operations = [
migrations.CreateModel(
name="User",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("password", models.CharField(max_length=128, verbose_name="password")),
(
"last_login",
models.DateTimeField(
null=True, blank=True, verbose_name="last login"
),
),
("username", models.CharField(max_length=30)),
("slug", models.CharField(unique=True, max_length=30)),
("email", models.EmailField(max_length=255, db_index=True)),
("email_hash", models.CharField(unique=True, max_length=32)),
(
"joined_on",
models.DateTimeField(
default=django.utils.timezone.now, verbose_name="joined on"
),
),
("joined_from_ip", models.GenericIPAddressField()),
("last_ip", models.GenericIPAddressField(null=True, blank=True)),
("is_hiding_presence", models.BooleanField(default=False)),
("title", models.CharField(max_length=255, null=True, blank=True)),
("requires_activation", models.PositiveIntegerField(default=0)),
(
"is_staff",
models.BooleanField(
default=False,
help_text="Designates whether the user can log into admin sites.",
verbose_name="staff status",
),
),
(
"is_superuser",
models.BooleanField(
default=False,
help_text="Designates that this user has all permissions without explicitly assigning them.",
verbose_name="superuser status",
),
),
("acl_key", models.CharField(max_length=12, null=True, blank=True)),
(
"is_active",
models.BooleanField(
db_index=True,
default=True,
verbose_name="active",
help_text=(
"Designates whether this user should be treated as active. Unselect this instead of deleting "
"accounts."
),
),
),
("is_active_staff_message", models.TextField(null=True, blank=True)),
(
"groups",
models.ManyToManyField(
related_query_name="user",
related_name="user_set",
to="auth.Group",
blank=True,
help_text="The groups this user belongs to. A user will get all permissions granted to each of his/her group.",
verbose_name="groups",
),
),
("roles", models.ManyToManyField(to="misago_acl.Role")),
(
"user_permissions",
models.ManyToManyField(
related_query_name="user",
related_name="user_set",
to="auth.Permission",
blank=True,
help_text="Specific permissions for this user.",
verbose_name="user permissions",
),
),
(
"avatar_tmp",
models.ImageField(
max_length=255,
upload_to=misago.users.avatars.store.upload_to,
null=True,
blank=True,
),
),
(
"avatar_src",
models.ImageField(
max_length=255,
upload_to=misago.users.avatars.store.upload_to,
null=True,
blank=True,
),
),
(
"avatar_crop",
models.CharField(max_length=255, null=True, blank=True),
),
("avatars", models.JSONField(null=True, blank=True)),
("is_avatar_locked", models.BooleanField(default=False)),
("avatar_lock_user_message", models.TextField(null=True, blank=True)),
("avatar_lock_staff_message", models.TextField(null=True, blank=True)),
("signature", models.TextField(null=True, blank=True)),
("signature_parsed", models.TextField(null=True, blank=True)),
(
"signature_checksum",
models.CharField(max_length=64, null=True, blank=True),
),
("is_signature_locked", models.BooleanField(default=False)),
(
"signature_lock_user_message",
models.TextField(null=True, blank=True),
),
(
"signature_lock_staff_message",
models.TextField(null=True, blank=True),
),
("following", models.PositiveIntegerField(default=0)),
("followers", models.PositiveIntegerField(default=0)),
(
"limits_private_thread_invites_to",
models.PositiveIntegerField(default=0),
),
("unread_private_threads", models.PositiveIntegerField(default=0)),
("sync_unread_private_threads", models.BooleanField(default=False)),
(
"subscribe_to_started_threads",
models.PositiveIntegerField(default=0),
),
(
"subscribe_to_replied_threads",
models.PositiveIntegerField(default=0),
),
("threads", models.PositiveIntegerField(default=0)),
("posts", models.PositiveIntegerField(default=0, db_index=True)),
("last_posted_on", models.DateTimeField(null=True, blank=True)),
],
options={"abstract": False},
bases=(models.Model,),
),
migrations.CreateModel(
name="Online",
fields=[
("current_ip", models.GenericIPAddressField()),
("last_click", models.DateTimeField(default=django.utils.timezone.now)),
(
"user",
models.OneToOneField(
related_name="online_tracker",
on_delete=django.db.models.deletion.CASCADE,
primary_key=True,
serialize=False,
to=settings.AUTH_USER_MODEL,
),
),
],
options={},
bases=(models.Model,),
),
migrations.CreateModel(
name="UsernameChange",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("changed_by_username", models.CharField(max_length=30)),
("changed_on", models.DateTimeField(default=django.utils.timezone.now)),
("new_username", models.CharField(max_length=255)),
("old_username", models.CharField(max_length=255)),
(
"changed_by",
models.ForeignKey(
related_name="user_renames",
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to=settings.AUTH_USER_MODEL,
null=True,
),
),
(
"user",
models.ForeignKey(
related_name="namechanges",
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
],
options={"get_latest_by": "changed_on"},
bases=(models.Model,),
),
migrations.CreateModel(
name="Rank",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("name", models.CharField(max_length=255)),
("slug", models.CharField(unique=True, max_length=255)),
("description", models.TextField(null=True, blank=True)),
("title", models.CharField(max_length=255, null=True, blank=True)),
("css_class", models.CharField(max_length=255, null=True, blank=True)),
("is_default", models.BooleanField(default=False)),
("is_tab", models.BooleanField(default=False)),
("order", models.IntegerField(default=0)),
(
"roles",
models.ManyToManyField(to="misago_acl.Role", null=True, blank=True),
),
],
options={"get_latest_by": "order"},
bases=(models.Model,),
),
migrations.AddField(
model_name="user",
name="rank",
field=models.ForeignKey(
on_delete=django.db.models.deletion.PROTECT,
to_field="id",
blank=True,
to="misago_users.Rank",
null=True,
),
preserve_default=True,
),
migrations.AddField(
model_name="user",
name="follows",
field=models.ManyToManyField(
related_name="followed_by", to=settings.AUTH_USER_MODEL
),
preserve_default=True,
),
migrations.AddField(
model_name="user",
name="blocks",
field=models.ManyToManyField(
related_name="blocked_by", to=settings.AUTH_USER_MODEL
),
preserve_default=True,
),
migrations.CreateModel(
name="ActivityRanking",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"user",
models.ForeignKey(
related_name="+",
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
("score", models.PositiveIntegerField(default=0, db_index=True)),
],
options={},
bases=(models.Model,),
),
migrations.CreateModel(
name="Avatar",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
("size", models.PositiveIntegerField(default=0)),
(
"image",
models.ImageField(
max_length=255, upload_to=misago.users.avatars.store.upload_to
),
),
],
),
migrations.CreateModel(
name="AvatarGallery",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("gallery", models.CharField(max_length=255)),
(
"image",
models.ImageField(
max_length=255, upload_to=misago.users.avatars.store.upload_to
),
),
],
options={"ordering": ["gallery", "pk"]},
),
migrations.CreateModel(
name="Ban",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("check_type", models.PositiveIntegerField(default=0, db_index=True)),
("banned_value", models.CharField(max_length=255, db_index=True)),
("user_message", models.TextField(null=True, blank=True)),
("staff_message", models.TextField(null=True, blank=True)),
(
"expires_on",
models.DateTimeField(null=True, blank=True, db_index=True),
),
("is_checked", models.BooleanField(default=True, db_index=True)),
],
bases=(models.Model,),
),
migrations.CreateModel(
name="BanCache",
fields=[
("user_message", models.TextField(null=True, blank=True)),
("staff_message", models.TextField(null=True, blank=True)),
("bans_version", models.PositiveIntegerField(default=0)),
("expires_on", models.DateTimeField(null=True, blank=True)),
(
"ban",
models.ForeignKey(
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to="misago_users.Ban",
null=True,
),
),
(
"user",
models.OneToOneField(
related_name="ban_cache",
on_delete=django.db.models.deletion.CASCADE,
primary_key=True,
serialize=False,
to=settings.AUTH_USER_MODEL,
),
),
],
options={},
bases=(models.Model,),
),
]
| 16,069
|
Python
|
.py
| 403
| 21.48139
| 135
| 0.424047
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,389
|
0012_audittrail.py
|
rafalp_Misago/misago/users/migrations/0012_audittrail.py
|
# Generated by Django 1.11.13 on 2018-06-03 18:46
import django.db.models.deletion
import django.utils.timezone
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("contenttypes", "0002_remove_content_type_name"),
("misago_users", "0011_auto_20180331_2208"),
]
operations = [
migrations.CreateModel(
name="AuditTrail",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("object_id", models.PositiveIntegerField()),
(
"created_on",
models.DateTimeField(
db_index=True, default=django.utils.timezone.now
),
),
("ip_address", models.GenericIPAddressField()),
(
"content_type",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="contenttypes.ContentType",
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
],
options={"ordering": ["-pk"]},
)
]
| 1,680
|
Python
|
.py
| 49
| 18.693878
| 72
| 0.437346
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,390
|
0014_datadownload.py
|
rafalp_Misago/misago/users/migrations/0014_datadownload.py
|
# Generated by Django 1.11.13 on 2018-06-24 00:13
import django.db.models.deletion
import django.utils.timezone
from django.conf import settings
from django.db import migrations, models
import misago.users.models.datadownload
class Migration(migrations.Migration):
dependencies = [("misago_users", "0013_auto_20180609_1523")]
operations = [
migrations.CreateModel(
name="DataDownload",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
(
"status",
models.PositiveIntegerField(
choices=[
(0, "Pending"),
(1, "Processing"),
(2, "Ready"),
(3, "Expired"),
],
db_index=True,
default=0,
),
),
("requester_name", models.CharField(max_length=255)),
(
"requested_on",
models.DateTimeField(default=django.utils.timezone.now),
),
("expires_on", models.DateTimeField(default=django.utils.timezone.now)),
(
"file",
models.FileField(
blank=True,
max_length=255,
null=True,
upload_to=misago.users.models.datadownload.get_data_upload_to,
),
),
(
"requester",
models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
related_name="+",
to=settings.AUTH_USER_MODEL,
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.PROTECT,
to=settings.AUTH_USER_MODEL,
),
),
],
options={"ordering": ["-pk"]},
)
]
| 2,507
|
Python
|
.py
| 70
| 17.5
| 88
| 0.388409
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,391
|
0022_deleteduser.py
|
rafalp_Misago/misago/users/migrations/0022_deleteduser.py
|
# Generated by Django 2.2.3 on 2019-09-28 21:34
from django.db import migrations, models
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [("misago_users", "0021_user_sso_id")]
operations = [
migrations.CreateModel(
name="DeletedUser",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
(
"deleted_on",
models.DateTimeField(
db_index=True, default=django.utils.timezone.now
),
),
(
"deleted_by",
models.PositiveIntegerField(
choices=[(1, "By self"), (2, "By staff"), (3, "By system")],
db_index=True,
),
),
],
options={"ordering": ["-id"]},
)
]
| 1,166
|
Python
|
.py
| 35
| 17.342857
| 84
| 0.398403
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,392
|
0006_update_settings.py
|
rafalp_Misago/misago/users/migrations/0006_update_settings.py
|
# Generated by Django 1.10.5 on 2017-02-05 14:34
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_users", "0005_dj_19_update")]
operations = []
| 203
|
Python
|
.py
| 5
| 37.4
| 58
| 0.733333
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,393
|
0018_auto_20190511_2051.py
|
rafalp_Misago/misago/users/migrations/0018_auto_20190511_2051.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.11.20 on 2019-05-11 20:51
from __future__ import unicode_literals
from django.db import migrations, models
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [("misago_users", "0017_move_bans_to_cache_version")]
operations = [
migrations.AlterField(
model_name="datadownload",
name="requested_on",
field=models.DateTimeField(
db_index=True, default=django.utils.timezone.now
),
),
migrations.AlterField(
model_name="user",
name="joined_on",
field=models.DateTimeField(
db_index=True,
default=django.utils.timezone.now,
verbose_name="joined on",
),
),
]
| 841
|
Python
|
.py
| 25
| 24.32
| 72
| 0.586207
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,394
|
0016_cache_version.py
|
rafalp_Misago/misago/users/migrations/0016_cache_version.py
|
# Generated by Django 1.11.16 on 2018-11-25 15:31
from django.db import migrations
from ...cache.operations import StartCacheVersioning
class Migration(migrations.Migration):
dependencies = [
("misago_users", "0015_user_agreements"),
("misago_cache", "0001_initial"),
]
operations = [StartCacheVersioning("bans")]
| 346
|
Python
|
.py
| 9
| 33.888889
| 52
| 0.717718
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,395
|
0020_set_dj_partial_indexes.py
|
rafalp_Misago/misago/users/migrations/0020_set_dj_partial_indexes.py
|
# Generated by Django 2.2.1 on 2019-05-18 16:59
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_users", "0019_remove_custom_partial_indexes")]
operations = [
migrations.AddIndex(
model_name="user",
index=models.Index(
condition=models.Q(is_staff=True),
fields=["is_staff"],
name="misago_user_is_staff_part",
),
),
migrations.AddIndex(
model_name="user",
index=models.Index(
condition=models.Q(requires_activation__gt=0),
fields=["requires_activation"],
name="misago_user_requires_acti_part",
),
),
migrations.AddIndex(
model_name="user",
index=models.Index(
condition=models.Q(is_deleting_account=True),
fields=["is_deleting_account"],
name="misago_user_is_deleting_a_part",
),
),
]
| 1,056
|
Python
|
.py
| 30
| 23.666667
| 75
| 0.53816
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,396
|
0021_user_sso_id.py
|
rafalp_Misago/misago/users/migrations/0021_user_sso_id.py
|
# Generated by Django 2.2.3 on 2019-08-15 16:58
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_users", "0020_set_dj_partial_indexes")]
operations = [
migrations.AddField(
model_name="user",
name="sso_id",
field=models.PositiveIntegerField(blank=True, null=True, unique=True),
)
]
| 406
|
Python
|
.py
| 11
| 29.727273
| 82
| 0.652174
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,397
|
0023_remove_user_sso_id.py
|
rafalp_Misago/misago/users/migrations/0023_remove_user_sso_id.py
|
# Generated by Django 3.2.15 on 2023-01-04 12:38
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
("misago_users", "0022_deleteduser"),
("misago_oauth2", "0002_copy_sso_subjects"),
]
operations = [
migrations.RemoveField(
model_name="user",
name="sso_id",
),
]
| 377
|
Python
|
.py
| 13
| 22.153846
| 52
| 0.605556
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,398
|
0028_default_groups.py
|
rafalp_Misago/misago/users/migrations/0028_default_groups.py
|
# Generated by Django 4.2.7 on 2023-12-21 21:10
from django.db import migrations
from ...permissions.permissionsid import get_permissions_id
from ..enums import CUSTOM_GROUP_ID_START, DefaultGroupId
def pgettext(context: str, message: str):
return message
def create_default_groups(apps, schema_editor):
Group = apps.get_model("misago_users", "Group")
groups = Group.objects.bulk_create(
[
Group(
id=DefaultGroupId.ADMINS,
name=pgettext("default user group", "Administrators"),
slug="administrators",
user_title=pgettext("default user group", "Admin"),
color="#6554C0",
icon="fas fa-shield",
css_suffix="admin",
is_page=True,
ordering=0,
# Permissions
can_use_private_threads=True,
can_start_private_threads=True,
private_thread_users_limit=20,
can_change_username=True,
can_see_user_profiles=True,
),
Group(
id=DefaultGroupId.MODERATORS,
name=pgettext("default user group", "Moderators"),
slug="moderators",
user_title=pgettext("default user group", "Moderator"),
color="#00875A",
icon="fas fa-shield",
css_suffix="moderator",
is_page=True,
ordering=1,
# Permissions
can_use_private_threads=True,
can_start_private_threads=True,
private_thread_users_limit=20,
can_change_username=True,
can_see_user_profiles=True,
),
Group(
id=DefaultGroupId.MEMBERS,
name=pgettext("default user group", "Members"),
slug="members",
is_hidden=True,
is_default=True,
ordering=2,
# Permissions
can_use_private_threads=True,
can_start_private_threads=True,
private_thread_users_limit=5,
can_change_username=True,
username_changes_limit=5,
username_changes_expire=4,
username_changes_span=1,
can_see_user_profiles=True,
),
Group(
id=DefaultGroupId.GUESTS,
name=pgettext("default user group", "Guests"),
slug="guests",
is_hidden=True,
ordering=3,
# Permissions
can_see_user_profiles=True,
),
]
)
GroupDescription = apps.get_model("misago_users", "GroupDescription")
GroupDescription.objects.bulk_create(
[GroupDescription(group=group) for group in groups]
)
def set_users_default_groups(apps, schema_editor):
User = apps.get_model("misago_users", "User")
# Put all staff users in admins group
User.objects.filter(is_staff=True).update(
group_id=DefaultGroupId.ADMINS,
groups_ids=[DefaultGroupId.ADMINS],
permissions_id=get_permissions_id([DefaultGroupId.ADMINS.value]),
)
# Set all superusers as root admins
User.objects.filter(is_superuser=True).update(is_misago_root=True)
# Put all non-staff users in members group
User.objects.filter(is_staff=False).update(
group_id=DefaultGroupId.MEMBERS,
groups_ids=[DefaultGroupId.MEMBERS],
permissions_id=get_permissions_id([DefaultGroupId.MEMBERS.value]),
)
class Migration(migrations.Migration):
dependencies = [
("misago_users", "0027_new_permissions"),
]
operations = [
migrations.RunPython(
create_default_groups,
migrations.RunPython.noop,
),
migrations.RunPython(
set_users_default_groups,
migrations.RunPython.noop,
),
migrations.RunSQL(
f"ALTER SEQUENCE misago_users_group_id_seq RESTART WITH {CUSTOM_GROUP_ID_START};",
migrations.RunSQL.noop,
),
]
| 4,201
|
Python
|
.py
| 110
| 26.072727
| 94
| 0.564524
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,399
|
0003_bans_version_tracker.py
|
rafalp_Misago/misago/users/migrations/0003_bans_version_tracker.py
|
from django.db import migrations
class Migration(migrations.Migration):
"""Migration superseded by 0016"""
dependencies = [
("misago_users", "0002_users_settings"),
("misago_core", "0001_initial"),
]
operations = []
| 252
|
Python
|
.py
| 8
| 26
| 48
| 0.654167
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|