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,500
|
test_decorators.py
|
rafalp_Misago/misago/users/tests/test_decorators.py
|
from django.urls import reverse
from ...core.utils import encode_json_html
from ..models import Ban
from ..test import UserTestCase
class DenyAuthenticatedTests(UserTestCase):
def test_success(self):
"""deny_authenticated decorator allowed guest request"""
response = self.client.post(reverse("misago:request-activation"))
self.assertEqual(response.status_code, 200)
def test_fail(self):
"""deny_authenticated decorator denied authenticated request"""
self.login_user(self.get_authenticated_user())
response = self.client.post(reverse("misago:request-activation"))
self.assertEqual(response.status_code, 403)
class DenyBannedIPTests(UserTestCase):
def test_success(self):
"""deny_banned_ips decorator allowed unbanned request"""
Ban.objects.create(
check_type=Ban.IP, banned_value="83.*", user_message="Ya got banned!"
)
response = self.client.post(reverse("misago:request-activation"))
self.assertEqual(response.status_code, 200)
def test_fail(self):
"""deny_banned_ips decorator denied banned request"""
Ban.objects.create(
check_type=Ban.IP, banned_value="127.*", user_message="Ya got banned!"
)
response = self.client.post(reverse("misago:request-activation"))
self.assertContains(
response, encode_json_html("<p>Ya got banned!</p>"), status_code=403
)
| 1,463
|
Python
|
.py
| 31
| 39.548387
| 82
| 0.686357
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,501
|
test_users_api.py
|
rafalp_Misago/misago/users/tests/test_users_api.py
|
import json
from datetime import timedelta
import pytest
from django.contrib.auth import get_user_model
from django.urls import reverse
from ...acl.test import patch_user_acl
from ...categories.models import Category
from ...conf.test import override_dynamic_settings
from ...threads.models import Post, Thread
from ...threads.test import post_thread
from ..activepostersranking import build_active_posters_ranking
from ..models import Ban, DeletedUser, Rank
from ..test import AuthenticatedUserTestCase, create_test_user
User = get_user_model()
class ActivePostersListTests(AuthenticatedUserTestCase):
"""tests for active posters list (GET /users/?list=active)"""
def setUp(self):
super().setUp()
self.link = "/api/users/?list=active"
self.category = Category.objects.all_categories()[:1][0]
self.category.labels = []
def test_empty_list(self):
"""empty list is served"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, self.user.username)
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, self.user.username)
def test_filled_list(self):
"""filled list is served"""
post_thread(self.category, poster=self.user)
self.user.posts = 1
self.user.save()
build_active_posters_ranking()
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.user.username)
self.assertContains(response, '"is_online":true')
self.assertContains(response, '"is_offline":false')
self.logout_user()
build_active_posters_ranking()
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.user.username)
self.assertContains(response, '"is_online":false')
self.assertContains(response, '"is_offline":true')
class FollowersListTests(AuthenticatedUserTestCase):
"""tests for generic list (GET /users/) filtered by followers"""
def setUp(self):
super().setUp()
self.link = "/api/users/%s/followers/"
def test_nonexistent_user(self):
"""list for non-existing user returns 404"""
response = self.client.get(self.link % 31242)
self.assertEqual(response.status_code, 404)
def test_empty_list(self):
"""user without followers returns 200"""
response = self.client.get(self.link % self.user.pk)
self.assertEqual(response.status_code, 200)
def test_filled_list(self):
"""user with followers returns 200"""
follower = create_test_user("TestFollower", "test@follower.com")
self.user.followed_by.add(follower)
response = self.client.get(self.link % self.user.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, follower.username)
def test_filled_list_search(self):
"""followers list is searchable"""
follower = create_test_user("TestFollower", "test@follower.com")
self.user.followed_by.add(follower)
api_link = self.link % self.user.pk
response = self.client.get("%s?search=%s" % (api_link, "test"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, follower.username)
class FollowsListTests(AuthenticatedUserTestCase):
"""tests for generic list (GET /users/) filtered by follows"""
def setUp(self):
super().setUp()
self.link = "/api/users/%s/follows/"
def test_nonexistent_user(self):
"""list for non-existing user returns 404"""
response = self.client.get(self.link % 1321)
self.assertEqual(response.status_code, 404)
def test_empty_list(self):
"""user without follows returns 200"""
response = self.client.get(self.link % self.user.pk)
self.assertEqual(response.status_code, 200)
def test_filled_list(self):
"""user with follows returns 200"""
follower = create_test_user("TestFollower", "test@follower.com")
self.user.follows.add(follower)
response = self.client.get(self.link % self.user.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, follower.username)
def test_filled_list_search(self):
"""follows list is searchable"""
follower = create_test_user("TestFollower", "test@follower.com")
self.user.follows.add(follower)
api_link = self.link % self.user.pk
response = self.client.get("%s?search=%s" % (api_link, "test"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, follower.username)
def test_users_api_rank_filter_returns_404_for_not_existing_rank(client, db):
response = client.get("/api/users/?rank=404")
assert response.status_code == 404
def test_users_api_rank_filter_returns_404_if_rank_tab_is_disabled(client, db):
rank = Rank.objects.create(name="Test rank", slug="test-rank", is_tab=False)
response = client.get(f"/api/users/?rank={rank.id}")
assert response.status_code == 404
def test_users_api_rank_filter_returns_empty_list(client, other_user):
rank = Rank.objects.create(name="Test rank", slug="test-rank", is_tab=True)
response = client.get(f"/api/users/?rank={rank.id}")
assert json.loads(response.content)["results"] == []
def test_users_api_rank_filter_returns_list_with_rank_user(client, other_user):
rank = Rank.objects.create(name="Test rank", slug="test-rank", is_tab=True)
other_user.rank = rank
other_user.save()
response = client.get(f"/api/users/?rank={rank.id}")
assert json.loads(response.content)["results"][0]["id"] == other_user.id
def test_users_api_rank_filter_returns_excluded_deactivated_users(
client, inactive_user
):
rank = Rank.objects.create(name="Test rank", slug="test-rank", is_tab=True)
inactive_user.rank = rank
inactive_user.save()
response = client.get(f"/api/users/?rank={rank.id}")
assert json.loads(response.content)["results"] == []
def test_users_api_rank_filter_returns_deactivated_users_for_admin(
admin_client, inactive_user
):
rank = Rank.objects.create(name="Test rank", slug="test-rank", is_tab=True)
inactive_user.rank = rank
inactive_user.save()
response = admin_client.get(f"/api/users/?rank={rank.id}")
assert json.loads(response.content)["results"][0]["id"] == inactive_user.id
class SearchNamesListTests(AuthenticatedUserTestCase):
"""tests for generic list (GET /users/) filtered by username disallowing searches"""
def setUp(self):
super().setUp()
self.link = "/api/users/?&name="
def test_empty_list(self):
"""empty list returns 404"""
response = self.client.get(self.link + "this-user-is-fake")
self.assertEqual(response.status_code, 404)
def test_filled_list(self):
"""results list returns 404"""
response = self.client.get(self.link + self.user.slug)
self.assertEqual(response.status_code, 404)
def test_user_api_returns_404_for_nonexisting_user(client, db):
response = client.get(reverse("misago:api:user-detail", kwargs={"pk": 404}))
assert response.status_code == 404
def test_user_api_returns_user_data(client, user):
response = client.get(reverse("misago:api:user-detail", kwargs={"pk": user.id}))
assert response.status_code == 200
assert json.loads(response.content)["id"] == user.id
def test_user_api_returns_404_for_deactivated_user(client, inactive_user):
response = client.get(
reverse("misago:api:user-detail", kwargs={"pk": inactive_user.id})
)
assert response.status_code == 404
def test_user_api_returns_deactivated_user_data_for_admins(admin_client, inactive_user):
response = admin_client.get(
reverse("misago:api:user-detail", kwargs={"pk": inactive_user.id})
)
assert json.loads(response.content)["id"] == inactive_user.id
class UserFollowTests(AuthenticatedUserTestCase):
"""tests for user follow RPC (POST to /api/users/1/follow/)"""
def setUp(self):
super().setUp()
self.other_user = create_test_user("Other_User", "otheruser@example.com")
self.link = "/api/users/%s/follow/" % self.other_user.pk
def test_follow_unauthenticated(self):
"""you have to sign in to follow users"""
self.logout_user()
response = self.client.post(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "This action is not available to guests."}
)
def test_follow_myself(self):
"""you can't follow yourself"""
response = self.client.post("/api/users/%s/follow/" % self.user.pk)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You can't add yourself to followed."}
)
@patch_user_acl({"can_follow_users": 0})
def test_cant_follow(self):
"""no permission to follow users"""
response = self.client.post(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(response.json(), {"detail": "You can't follow other users."})
def test_follow(self):
"""follow and unfollow other user"""
response = self.client.post(self.link)
self.assertEqual(response.status_code, 200)
self.user.refresh_from_db()
self.assertEqual(self.user.followers, 0)
self.assertEqual(self.user.following, 1)
self.assertEqual(self.user.follows.count(), 1)
self.assertEqual(self.user.followed_by.count(), 0)
self.other_user.refresh_from_db()
self.assertEqual(self.other_user.followers, 1)
self.assertEqual(self.other_user.following, 0)
self.assertEqual(self.other_user.follows.count(), 0)
self.assertEqual(self.other_user.followed_by.count(), 1)
response = self.client.post(self.link)
self.assertEqual(response.status_code, 200)
self.user.refresh_from_db()
self.assertEqual(self.user.followers, 0)
self.assertEqual(self.user.following, 0)
self.assertEqual(self.user.follows.count(), 0)
self.assertEqual(self.user.followed_by.count(), 0)
self.other_user.refresh_from_db()
self.assertEqual(self.other_user.followers, 0)
self.assertEqual(self.other_user.following, 0)
self.assertEqual(self.other_user.follows.count(), 0)
self.assertEqual(self.other_user.followed_by.count(), 0)
class UserBanTests(AuthenticatedUserTestCase):
"""tests for ban endpoint (GET to /api/users/1/ban/)"""
def setUp(self):
super().setUp()
self.other_user = create_test_user("Other_User", "otheruser@example.com")
self.link = "/api/users/%s/ban/" % self.other_user.pk
@patch_user_acl({"can_see_ban_details": 0})
def test_no_permission(self):
"""user has no permission to access ban"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You can't see users bans details."}
)
@patch_user_acl({"can_see_ban_details": 1})
def test_no_ban(self):
"""api returns empty json"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), {})
@patch_user_acl({"can_see_ban_details": 1})
def test_ban_details(self):
"""api returns ban json"""
Ban.objects.create(
check_type=Ban.USERNAME,
banned_value=self.other_user.username,
user_message="Nope!",
)
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
ban_json = response.json()
self.assertEqual(ban_json["user_message"]["plain"], "Nope!")
self.assertEqual(ban_json["user_message"]["html"], "<p>Nope!</p>")
def test_user_delete_api_prevents_deletion_if_user_no_permission(
user_client, other_user
):
response = user_client.post(f"/api/users/{other_user.id}/delete/")
assert response.status_code == 403
assert json.loads(response.content) == {"detail": "You can't delete users."}
@patch_user_acl(
{"can_delete_users_newer_than": 5, "can_delete_users_with_less_posts_than": 0}
)
def test_user_delete_api_prevents_deletion_if_user_is_too_old(user_client, other_user):
other_user.joined_on -= timedelta(days=6)
other_user.save()
response = user_client.post(f"/api/users/{other_user.id}/delete/")
assert response.status_code == 403
assert json.loads(response.content) == {
"detail": "You can't delete users that are members for more than 5 days.",
}
@patch_user_acl(
{"can_delete_users_newer_than": 10, "can_delete_users_with_less_posts_than": 5}
)
def test_user_delete_api_prevents_deletion_if_user_has_too_many_posts(
user_client, other_user
):
other_user.posts = 6
other_user.save()
response = user_client.post(f"/api/users/{other_user.id}/delete/")
assert response.status_code == 403
assert json.loads(response.content) == {
"detail": "You can't delete users that made more than 5 posts.",
}
@patch_user_acl(
{"can_delete_users_newer_than": 10, "can_delete_users_with_less_posts_than": 5}
)
def test_user_delete_api_prevents_deletion_if_user_is_staff(user_client, staffuser):
response = user_client.post(f"/api/users/{staffuser.id}/delete/")
assert response.status_code == 403
assert json.loads(response.content) == {
"detail": "Django staff users can't be deleted.",
}
@patch_user_acl(
{"can_delete_users_newer_than": 10, "can_delete_users_with_less_posts_than": 5}
)
def test_user_delete_api_prevents_deletion_if_user_is_admin(user_client, admin):
response = user_client.post(f"/api/users/{admin.id}/delete/")
assert response.status_code == 403
assert json.loads(response.content) == {
"detail": "Administrators can't be deleted.",
}
@patch_user_acl(
{"can_delete_users_newer_than": 10, "can_delete_users_with_less_posts_than": 5}
)
def test_user_delete_api_prevents_deletion_if_user_is_root_admin(
user_client, root_admin
):
response = user_client.post(f"/api/users/{root_admin.id}/delete/")
assert response.status_code == 403
assert json.loads(response.content) == {
"detail": "Administrators can't be deleted.",
}
@patch_user_acl(
{"can_delete_users_newer_than": 10, "can_delete_users_with_less_posts_than": 5}
)
def test_user_delete_api_prevents_deletion_if_user_is_self(user_client, user):
response = user_client.post(f"/api/users/{user.id}/delete/")
assert response.status_code == 403
assert json.loads(response.content) == {
"detail": "You can't delete your account.",
}
@patch_user_acl(
{"can_delete_users_newer_than": 10, "can_delete_users_with_less_posts_than": 5}
)
def test_user_delete_api_deletes_user_with_content(
user_client, default_category, other_user
):
thread = post_thread(default_category, poster=other_user)
response = user_client.post(
f"/api/users/{other_user.id}/delete/",
json={"with_content": True},
)
assert response.status_code == 200
with pytest.raises(User.DoesNotExist):
other_user.refresh_from_db()
with pytest.raises(Thread.DoesNotExist):
thread.refresh_from_db()
@patch_user_acl(
{"can_delete_users_newer_than": 10, "can_delete_users_with_less_posts_than": 5}
)
def test_user_delete_api_deletes_user_without_content(
user_client, default_category, other_user
):
thread = post_thread(default_category, poster=other_user)
response = user_client.post(
f"/api/users/{other_user.id}/delete/",
json={"with_content": False},
)
assert response.status_code == 200
with pytest.raises(User.DoesNotExist):
other_user.refresh_from_db()
thread.refresh_from_db()
@patch_user_acl(
{"can_delete_users_newer_than": 10, "can_delete_users_with_less_posts_than": 10}
)
def test_user_delete_api_creates_deleted_user_entry(user_client, other_user):
response = user_client.post(f"/api/users/{other_user.id}/delete/")
assert response.status_code == 200
DeletedUser.objects.get(deleted_by=DeletedUser.DELETED_BY_STAFF)
| 16,631
|
Python
|
.py
| 358
| 39.969274
| 88
| 0.679874
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,502
|
test_invalidatebans.py
|
rafalp_Misago/misago/users/tests/test_invalidatebans.py
|
from datetime import timedelta
from io import StringIO
from django.core.management import call_command
from django.test import TestCase
from django.utils import timezone
from ...cache.versions import get_cache_versions
from ...users import bans
from ..management.commands import invalidatebans
from ..models import Ban, BanCache
from ..test import create_test_user
class InvalidateBansTests(TestCase):
def test_expired_bans_handling(self):
"""expired bans are flagged as such"""
# create 5 bans then update their valid date to past one
for _ in range(5):
Ban.objects.create(banned_value="abcd")
expired_date = timezone.now() - timedelta(days=10)
Ban.objects.all().update(expires_on=expired_date, is_checked=True)
self.assertEqual(Ban.objects.filter(is_checked=True).count(), 5)
command = invalidatebans.Command()
out = StringIO()
call_command(command, stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Bans invalidated: 5")
self.assertEqual(Ban.objects.filter(is_checked=True).count(), 0)
def test_bans_caches_updates(self):
"""ban caches are updated"""
user = create_test_user("User", "user@example.com")
# ban user
Ban.objects.create(banned_value="user")
user_ban = bans.get_user_ban(user, get_cache_versions())
self.assertIsNotNone(user_ban)
self.assertEqual(Ban.objects.filter(is_checked=True).count(), 1)
# first call didn't touch ban
command = invalidatebans.Command()
out = StringIO()
call_command(command, stdout=out)
command_output = out.getvalue().splitlines()[1].strip()
self.assertEqual(command_output, "Ban caches emptied: 0")
self.assertEqual(Ban.objects.filter(is_checked=True).count(), 1)
# expire bans
expired_date = timezone.now() - timedelta(days=10)
Ban.objects.all().update(expires_on=expired_date, is_checked=True)
BanCache.objects.all().update(expires_on=expired_date)
# invalidate expired ban cache
out = StringIO()
call_command(command, stdout=out)
command_output = out.getvalue().splitlines()[1].strip()
self.assertEqual(command_output, "Ban caches emptied: 1")
self.assertEqual(Ban.objects.filter(is_checked=True).count(), 0)
# see if user is banned anymore
user.ban_cache = None
self.assertIsNone(bans.get_user_ban(user, get_cache_versions()))
| 2,575
|
Python
|
.py
| 53
| 40.962264
| 74
| 0.681582
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,503
|
test_auth_backend.py
|
rafalp_Misago/misago/users/tests/test_auth_backend.py
|
from django.test import TestCase
from ..authbackends import MisagoBackend
from ..test import create_test_user
backend = MisagoBackend()
class MisagoBackendTests(TestCase):
def setUp(self):
self.password = "password"
self.user = create_test_user("User", "user@example.com", self.password)
def test_authenticate_username(self):
"""auth authenticates with username"""
user = backend.authenticate(
None, username=self.user.username, password=self.password
)
self.assertEqual(user, self.user)
def test_authenticate_email(self):
"""auth authenticates with email instead of username"""
user = backend.authenticate(
None, username=self.user.email, password=self.password
)
self.assertEqual(user, self.user)
def test_authenticate_username_and_email(self):
"""auth authenticates with email and skips username"""
user = backend.authenticate(
None,
username=self.user.username,
password=self.password,
email=self.user.email,
)
self.assertEqual(user, self.user)
def test_authenticate_wrong_username_and_email(self):
"""auth authenticates with email and invalid username"""
user = backend.authenticate(
None,
username="skipped-username",
password=self.password,
email=self.user.email,
)
self.assertEqual(user, self.user)
def test_authenticate_invalid_credential(self):
"""auth handles invalid credentials"""
user = backend.authenticate(
None, username="InvalidCredential", password=self.password
)
self.assertIsNone(user)
def test_authenticate_invalid_password(self):
"""auth validates password"""
user = backend.authenticate(None, username=self.user.email, password="Invalid")
self.assertIsNone(user)
def test_authenticate_disabled_user(self):
"""auth validates disabled state"""
self.user.is_active = False
self.user.save()
user = backend.authenticate(
None, username=self.user.email, password=self.password
)
self.assertIsNone(user)
def test_authenticate_no_data(self):
"""auth has no errors if no recognised credentials are provided"""
self.user.is_active = False
self.user.save()
user = backend.authenticate(None)
self.assertIsNone(user)
def test_get_user_valid_pk(self):
"""auth backend returns active user for pk given"""
self.assertEqual(backend.get_user(self.user.pk), self.user)
def test_get_user_invalid_pk(self):
"""auth backend returns none for invalid pk"""
self.assertIsNone(backend.get_user(self.user.pk + 1))
def test_get_user_disabled(self):
"""auth backend returns none for disabled user"""
self.user.is_active = False
self.user.save()
self.assertIsNone(backend.get_user(self.user.pk))
| 3,061
|
Python
|
.py
| 73
| 33.123288
| 87
| 0.655976
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,504
|
test_delete_group.py
|
rafalp_Misago/misago/users/tests/test_delete_group.py
|
from unittest.mock import patch
import pytest
from ..groups import delete_group
from ..models import Group
@patch("misago.users.groups.remove_group_from_users_groups_ids")
def test_delete_group_deletes_group_with_its_relations(
mock_remove_group_from_users_groups_ids, members_group
):
delete_group(members_group)
with pytest.raises(Group.DoesNotExist):
members_group.refresh_from_db()
@patch("misago.users.groups.remove_group_from_users_groups_ids")
def test_delete_group_calls_cleanup_task(
mock_remove_group_from_users_groups_ids, members_group
):
delete_group(members_group)
mock_remove_group_from_users_groups_ids.delay.assert_called_once_with(
members_group.id
)
| 721
|
Python
|
.py
| 19
| 34.210526
| 74
| 0.770893
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,505
|
test_lists_views.py
|
rafalp_Misago/misago/users/tests/test_lists_views.py
|
from django.urls import reverse
from ...acl.test import patch_user_acl
from ...categories.models import Category
from ...test import assert_contains, assert_not_contains
from ...threads.test import post_thread
from ..activepostersranking import build_active_posters_ranking
from ..models import Rank
from ..test import AuthenticatedUserTestCase, create_test_user
class UsersListTestCase(AuthenticatedUserTestCase):
pass
class UsersListLanderTests(UsersListTestCase):
@patch_user_acl({"can_browse_users_list": 0})
def test_lander_no_permission(self):
"""lander returns 403 if user has no permission"""
response = self.client.get(reverse("misago:users"))
self.assertEqual(response.status_code, 403)
def test_lander_redirect(self):
"""lander returns redirect to valid page if user has permission"""
response = self.client.get(reverse("misago:users"))
self.assertEqual(response.status_code, 302)
self.assertTrue(
response["location"].endswith(reverse("misago:users-active-posters"))
)
class ActivePostersTests(UsersListTestCase):
def test_empty_active_posters_list(self):
"""empty active posters page has no showstoppers"""
view_link = reverse("misago:users-active-posters")
response = self.client.get(view_link)
self.assertEqual(response.status_code, 200)
def test_active_posters_list(self):
"""active posters page has no showstoppers"""
category = Category.objects.get(slug="first-category")
view_link = reverse("misago:users-active-posters")
response = self.client.get(view_link)
self.assertEqual(response.status_code, 200)
# Create 50 test users and see if errors appeared
for i in range(50):
user = create_test_user("Bob%s" % i, "m%s@te.com" % i, posts=12345)
post_thread(category, poster=user)
build_active_posters_ranking()
response = self.client.get(view_link)
self.assertEqual(response.status_code, 200)
def test_rank_users_list_is_not_available_if_rank_is_not_tab(client, other_user):
rank = Rank.objects.create(name="Test Rank", is_tab=False)
other_user.rank = rank
other_user.save()
response = client.get(reverse("misago:users-rank", kwargs={"slug": rank.slug}))
assert response.status_code == 404
def test_rank_users_list_displays_rank_users_if_rank_is_tab(client, other_user):
rank = Rank.objects.create(name="Test Rank", is_tab=True)
other_user.rank = rank
other_user.save()
response = client.get(reverse("misago:users-rank", kwargs={"slug": rank.slug}))
assert_contains(response, other_user.get_absolute_url())
def test_rank_users_list_excludes_deactivated_users(client, inactive_user):
rank = Rank.objects.create(name="Test Rank", is_tab=True)
inactive_user.rank = rank
inactive_user.save()
response = client.get(reverse("misago:users-rank", kwargs={"slug": rank.slug}))
assert_not_contains(response, inactive_user.get_absolute_url())
def test_rank_users_list_displays_deactivated_users_for_admin(
admin_client, inactive_user
):
rank = Rank.objects.create(name="Test Rank", is_tab=True)
inactive_user.rank = rank
inactive_user.save()
response = admin_client.get(
reverse("misago:users-rank", kwargs={"slug": rank.slug})
)
assert_contains(response, inactive_user.get_absolute_url())
| 3,457
|
Python
|
.py
| 70
| 43.214286
| 83
| 0.70986
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,506
|
test_count_group_members.py
|
rafalp_Misago/misago/users/tests/test_count_group_members.py
|
from ..enums import DefaultGroupId
from ..groups import count_groups_members
def test_count_groups_members_returns_all_groups_with_members(
admin, other_admin, secondary_admin, user
):
results = count_groups_members()
results_dict = {group_id: members for group_id, members in results}
assert results_dict == {
DefaultGroupId.ADMINS: 3,
DefaultGroupId.MEMBERS: 2,
}
def test_count_groups_members_counts_secondary_groups(
user, members_group, moderators_group
):
user.set_groups(members_group, [moderators_group])
user.save()
results = count_groups_members()
results_dict = {group_id: members for group_id, members in results}
assert results_dict == {
DefaultGroupId.MODERATORS: 1,
DefaultGroupId.MEMBERS: 1,
}
| 795
|
Python
|
.py
| 22
| 31.272727
| 71
| 0.714844
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,507
|
test_avatars.py
|
rafalp_Misago/misago/users/tests/test_avatars.py
|
from pathlib import Path
from unittest.mock import Mock
from django.core.exceptions import ValidationError
from django.test import TestCase
from django.utils.crypto import get_random_string
from PIL import Image
from ...conf import settings
from ..avatars import (
downloaded,
dynamic,
gallery,
gravatar,
set_default_avatar,
set_default_avatar_from_url,
store,
uploaded,
)
from ..models import Avatar, AvatarGallery
from ..test import create_test_user
class AvatarsStoreTests(TestCase):
def test_store(self):
"""store successfully stores and deletes avatar"""
user = create_test_user("User", "user@example.com")
test_image = Image.new("RGBA", (100, 100), 0)
store.store_new_avatar(user, test_image)
# reload user
user.refresh_from_db()
# assert that avatars were stored in media
avatars_dict = {}
for avatar in user.avatar_set.all():
self.assertTrue(avatar.image.url)
self.assertEqual(avatar.url, avatar.image.url)
avatars_dict[avatar.size] = avatar
# asserts that user.avatars cache was set
self.assertEqual(len(avatars_dict), len(settings.MISAGO_AVATARS_SIZES))
self.assertEqual(len(user.avatars), len(settings.MISAGO_AVATARS_SIZES))
self.assertEqual(len(user.avatars), len(avatars_dict))
for avatar in user.avatars:
self.assertIn(avatar["size"], settings.MISAGO_AVATARS_SIZES)
self.assertEqual(avatar["url"], avatars_dict[avatar["size"]].url)
# another avatar change deleted old avatars
store.store_new_avatar(user, test_image)
for old_avatar in avatars_dict.values():
avatar_path = Path(old_avatar.image.path)
self.assertFalse(avatar_path.exists())
self.assertFalse(avatar_path.is_file())
with self.assertRaises(Avatar.DoesNotExist):
Avatar.objects.get(pk=old_avatar.pk)
# and updated user avatars again
new_avatars_dict = {}
for size in settings.MISAGO_AVATARS_SIZES:
avatar = user.avatar_set.get(size=size)
self.assertTrue(avatar.image.url)
self.assertEqual(avatar.url, avatar.image.url)
new_avatars_dict[size] = avatar
self.assertTrue(avatars_dict != new_avatars_dict)
# asserts that user.avatars cache was updated
self.assertEqual(len(user.avatars), len(settings.MISAGO_AVATARS_SIZES))
for avatar in user.avatars:
self.assertIn(avatar["size"], settings.MISAGO_AVATARS_SIZES)
self.assertEqual(avatar["url"], new_avatars_dict[avatar["size"]].url)
# delete avatar
store.delete_avatar(user)
for removed_avatar in new_avatars_dict.values():
avatar_path = Path(removed_avatar.image.path)
self.assertFalse(avatar_path.exists())
self.assertFalse(avatar_path.is_file())
with self.assertRaises(Avatar.DoesNotExist):
Avatar.objects.get(pk=removed_avatar.pk)
class AvatarSetterTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com", avatars=None)
def tearDown(self):
store.delete_avatar(self.user)
def get_current_user(self):
self.user.refresh_from_db()
return self.user
def assertNoAvatarIsSet(self):
user = self.get_current_user()
self.assertFalse(user.avatars)
def assertAvatarWasSet(self):
user = self.get_current_user()
avatars_dict = {}
for avatar in user.avatar_set.all():
avatar_path = Path(avatar.image.path)
self.assertTrue(avatar_path.exists())
self.assertTrue(avatar_path.is_file())
avatars_dict[avatar.size] = avatar
self.assertEqual(len(user.avatars), len(avatars_dict))
self.assertEqual(len(user.avatars), len(settings.MISAGO_AVATARS_SIZES))
def test_dynamic_avatar(self):
"""dynamic avatar gets created"""
self.assertNoAvatarIsSet()
dynamic.set_avatar(self.user)
self.assertAvatarWasSet()
def test_random_gallery_avatar_no_gallery(self):
"""runtime error is raised when no gallery exists"""
with self.assertRaises(RuntimeError):
gallery.set_random_avatar(self.user)
def test_random_gallery_avatar(self):
"""dynamic avatar gets created"""
gallery.load_avatar_galleries()
self.assertNoAvatarIsSet()
gallery.set_random_avatar(self.user)
self.assertAvatarWasSet()
def test_selected_gallery_avatar(self):
"""dynamic avatar gets created"""
gallery.load_avatar_galleries()
self.assertNoAvatarIsSet()
test_avatar = AvatarGallery.objects.order_by("id").last()
gallery.set_avatar(self.user, test_avatar)
self.assertAvatarWasSet()
def test_downloaded(self):
"""specific image is downloaded"""
self.assertNoAvatarIsSet()
downloaded.set_avatar(self.user, "http://dummyimage.com/500/500")
self.assertAvatarWasSet()
def test_downloaded_width_greater_than_height(self):
"""specific image is downloaded and cropped into square"""
self.assertNoAvatarIsSet()
downloaded.set_avatar(self.user, "http://dummyimage.com/700/500")
self.assertAvatarWasSet()
def test_downloaded_height_greater_than_width(self):
"""specific image is downloaded and cropped into square"""
self.assertNoAvatarIsSet()
downloaded.set_avatar(self.user, "http://dummyimage.com/500/700")
self.assertAvatarWasSet()
def test_default_avatar_downloaded(self):
"""default downloaded avatar is set"""
self.assertNoAvatarIsSet()
set_default_avatar_from_url(self.user, "http://dummyimage.com/500/500")
self.assertAvatarWasSet()
def test_default_avatar_downloaded(self):
"""default download fails but fallback dynamic works"""
self.assertNoAvatarIsSet()
set_default_avatar_from_url(self.user, "https://example.com/404")
self.assertAvatarWasSet()
def test_gravatar(self):
"""gravatar is downloaded"""
self.assertNoAvatarIsSet()
self.user.set_email("rafio.xudb@gmail.com")
gravatar.set_avatar(self.user)
self.assertAvatarWasSet()
def test_default_avatar_gravatar(self):
"""default gravatar gets set"""
self.assertNoAvatarIsSet()
set_default_avatar(self.user, "gravatar", "dynamic")
self.assertAvatarWasSet()
def test_default_avatar_gravatar_fallback_dynamic(self):
"""default gravatar fails but fallback dynamic works"""
gibberish_email = "%s@%s.%s" % (
get_random_string(6),
get_random_string(6),
get_random_string(3),
)
self.user.set_email(gibberish_email)
self.user.save()
self.assertNoAvatarIsSet()
set_default_avatar(self.user, "gravatar", "dynamic")
self.assertAvatarWasSet()
def test_default_avatar_gravatar_fallback_empty_gallery(self):
"""default both gravatar and fallback fail set"""
gibberish_email = "%s@%s.%s" % (
get_random_string(6),
get_random_string(6),
get_random_string(3),
)
self.user.set_email(gibberish_email)
self.user.save()
self.assertNoAvatarIsSet()
self.user.save()
set_default_avatar(self.user, "gravatar", "gallery")
self.assertAvatarWasSet()
class MockAvatarFile:
def __init__(self, size=None, name=None, mime=None):
self.size = size
self.name = name
self.content_type = mime
class UploadedAvatarTests(TestCase):
def test_clean_crop(self):
"""crop validation and cleaning"""
image = Image.new("RGBA", (200, 200), 0)
with self.assertRaises(ValidationError):
uploaded.clean_crop(image, "abc")
with self.assertRaises(ValidationError):
uploaded.clean_crop(image, {})
with self.assertRaises(ValidationError):
uploaded.clean_crop(image, {"offset": {"x": "ugabuga"}})
with self.assertRaises(ValidationError):
uploaded.clean_crop(image, {"offset": {"x": 0, "y": 0}, "zoom": -2})
with self.assertRaises(ValidationError):
uploaded.clean_crop(image, {"offset": {"x": 0, "y": 0}, "zoom": 2})
def test_uploaded_image_size_validation(self):
"""uploaded image size is validated"""
settings = Mock(avatar_upload_limit=1) # no. of MBs
image = MockAvatarFile(size=1025)
with self.assertRaises(ValidationError):
uploaded.validate_file_size(settings, image)
image = MockAvatarFile(size=1024)
uploaded.validate_file_size(settings, image)
def test_uploaded_image_extension_validation(self):
"""uploaded image extension is validated"""
for invalid_extension in (".txt", ".zip", ".py", ".tiff"):
with self.assertRaises(ValidationError):
image = MockAvatarFile(name="test%s" % invalid_extension)
uploaded.validate_extension(image)
for valid_extension in uploaded.ALLOWED_EXTENSIONS:
image = MockAvatarFile(name="test%s" % valid_extension)
uploaded.validate_extension(image)
def test_uploaded_image_mime_validation(self):
"""uploaded image mime type is validated"""
image = MockAvatarFile(mime="fake/mime")
with self.assertRaises(ValidationError):
uploaded.validate_mime(image)
for valid_mime in uploaded.ALLOWED_MIME_TYPES:
image = MockAvatarFile(mime=valid_mime)
uploaded.validate_mime(image)
| 9,834
|
Python
|
.py
| 217
| 36.262673
| 81
| 0.654808
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,508
|
test_getting_user_status.py
|
rafalp_Misago/misago/users/tests/test_getting_user_status.py
|
from unittest.mock import Mock
from ..online.utils import get_user_status
from ..test import AuthenticatedUserTestCase, create_test_user
class GetUserStatusTests(AuthenticatedUserTestCase):
def setUp(self):
super().setUp()
self.other_user = create_test_user("Other_User", "otheruser@example.com")
def test_get_visible_user_status_returns_online(self):
request = Mock(
user=self.user,
user_acl={"can_see_hidden_users": False},
cache_versions={"bans": "abcdefgh"},
)
assert get_user_status(request, self.other_user)["is_online"]
def test_get_hidden_user_status_without_seeing_hidden_permission_returns_offline(
self,
):
"""get_user_status has no showstopper for hidden user"""
self.other_user.is_hiding_presence = True
self.other_user.save()
request = Mock(
user=self.user,
user_acl={"can_see_hidden_users": False},
cache_versions={"bans": "abcdefgh"},
)
assert get_user_status(request, self.other_user)["is_hidden"]
def test_get_hidden_user_status_with_seeing_hidden_permission_returns_online_hidden(
self,
):
self.other_user.is_hiding_presence = True
self.other_user.save()
request = Mock(
user=self.user,
user_acl={"can_see_hidden_users": True},
cache_versions={"bans": "abcdefgh"},
)
assert get_user_status(request, self.other_user)["is_online_hidden"]
| 1,539
|
Python
|
.py
| 37
| 32.918919
| 88
| 0.635207
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,509
|
test_datadownloads_dataarchive.py
|
rafalp_Misago/misago/users/tests/test_datadownloads_dataarchive.py
|
import os
from collections import OrderedDict
from django.core.files import File
from django.test import TestCase
from django.utils import timezone
from ...conf import settings
from ..datadownloads.dataarchive import (
FILENAME_MAX_LEN,
DataArchive,
trim_long_filename,
)
from ..test import AuthenticatedUserTestCase
DATA_DOWNLOADS_WORKING_DIR = settings.MISAGO_USER_DATA_DOWNLOADS_WORKING_DIR
TESTFILES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "testfiles")
TEST_AVATAR_PATH = os.path.join(TESTFILES_DIR, "avatar.png")
class DataArchiveTests(AuthenticatedUserTestCase):
def test_enter_without_dirs(self):
"""data archive doesn't touch filesystem on init"""
archive = DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR)
self.assertEqual(archive.user, self.user)
self.assertEqual(archive.working_dir_path, DATA_DOWNLOADS_WORKING_DIR)
self.assertIsNone(archive.tmp_dir_path)
self.assertIsNone(archive.data_dir_path)
def test_context_life_cycle(self):
"""object creates valid tmp directory on enter and cleans on exit"""
tmp_dir_path = None
data_dir_path = None
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
self.assertTrue(os.path.exists(archive.tmp_dir_path))
self.assertTrue(os.path.exists(archive.data_dir_path))
working_dir = str(DATA_DOWNLOADS_WORKING_DIR)
tmp_dir_path = str(archive.tmp_dir_path)
data_dir_path = str(archive.data_dir_path)
self.assertTrue(tmp_dir_path.startswith(working_dir))
self.assertTrue(data_dir_path.startswith(working_dir))
self.assertTrue(data_dir_path.startswith(working_dir))
self.assertTrue(data_dir_path.startswith(tmp_dir_path))
self.assertIsNone(archive.tmp_dir_path)
self.assertIsNone(archive.data_dir_path)
self.assertFalse(os.path.exists(tmp_dir_path))
self.assertFalse(os.path.exists(data_dir_path))
def test_add_text_str(self):
"""add_dict method creates text file with string"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
data_to_write = "Hello, łorld!"
file_path = archive.add_text("testfile", data_to_write)
self.assertTrue(os.path.isfile(file_path))
valid_output_path = os.path.join(archive.data_dir_path, "testfile.txt")
self.assertEqual(file_path, valid_output_path)
with open(file_path, "r") as fp:
saved_data = fp.read().strip()
self.assertEqual(saved_data, data_to_write)
def test_add_text_int(self):
"""add_dict method creates text file with int"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
data_to_write = 1234
file_path = archive.add_text("testfile", data_to_write)
self.assertTrue(os.path.isfile(file_path))
valid_output_path = os.path.join(archive.data_dir_path, "testfile.txt")
self.assertEqual(file_path, valid_output_path)
with open(file_path, "r") as fp:
saved_data = fp.read().strip()
self.assertEqual(saved_data, str(data_to_write))
def test_add_dict(self):
"""add_dict method creates text file from dict"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
data_to_write = {"first": "łorld!", "second": "łup!"}
file_path = archive.add_dict("testfile", data_to_write)
self.assertTrue(os.path.isfile(file_path))
valid_output_path = os.path.join(archive.data_dir_path, "testfile.txt")
self.assertEqual(file_path, valid_output_path)
with open(file_path, "r") as fp:
saved_data = fp.read().strip()
# order of dict items in py<3.6 is non-deterministic
# making testing for exact match a mistake
self.assertIn("first: łorld!", saved_data)
self.assertIn("second: łup!", saved_data)
def test_add_dict_ordered(self):
"""add_dict method creates text file form ordered dict"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
data_to_write = OrderedDict((("first", "łorld!"), ("second", "łup!")))
file_path = archive.add_dict("testfile", data_to_write)
self.assertTrue(os.path.isfile(file_path))
valid_output_path = os.path.join(archive.data_dir_path, "testfile.txt")
self.assertEqual(file_path, valid_output_path)
with open(file_path, "r") as fp:
saved_data = fp.read().strip()
self.assertEqual(saved_data, "first: łorld!\nsecond: łup!")
def test_add_model_file(self):
"""add_model_file method adds model file"""
with open(TEST_AVATAR_PATH, "rb") as avatar:
self.user.avatar_tmp = File(avatar)
self.user.save()
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
file_path = archive.add_model_file(self.user.avatar_tmp)
self.assertTrue(os.path.isfile(file_path))
data_dir_path = str(archive.data_dir_path)
self.assertTrue(str(file_path).startswith(data_dir_path))
def test_add_model_file_empty(self):
"""add_model_file method is noop if model field is empty"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
file_path = archive.add_model_file(self.user.avatar_tmp)
self.assertIsNone(file_path)
self.assertFalse(os.listdir(archive.data_dir_path))
def test_add_model_file_prefixed(self):
"""add_model_file method adds model file with prefix"""
with open(TEST_AVATAR_PATH, "rb") as avatar:
self.user.avatar_tmp = File(avatar)
self.user.save()
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
file_path = archive.add_model_file(self.user.avatar_tmp, prefix="prefix")
self.assertTrue(os.path.isfile(file_path))
data_dir_path = str(archive.data_dir_path)
self.assertTrue(str(file_path).startswith(data_dir_path))
filename = os.path.basename(self.user.avatar_tmp.name)
target_filename = "prefix-%s" % filename
self.assertTrue(str(file_path).endswith(target_filename))
def test_make_final_path_no_kwargs(self):
"""make_final_path returns data_dir_path if no kwargs are set"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
final_path = archive.make_final_path()
self.assertEqual(final_path, archive.data_dir_path)
def test_make_final_path_directory(self):
"""make_final_path returns path including directory name"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
final_path = archive.make_final_path(directory="test-directory")
valid_path = os.path.join(archive.data_dir_path, "test-directory")
self.assertEqual(final_path, valid_path)
def test_make_final_path_date(self):
"""make_final_path returns path including date segments"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
now = timezone.now().date()
final_path = archive.make_final_path(date=now)
valid_path = os.path.join(
archive.data_dir_path,
now.strftime("%Y"),
now.strftime("%m"),
now.strftime("%d"),
)
self.assertEqual(final_path, valid_path)
def test_make_final_path_datetime(self):
"""make_final_path returns path including date segments"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
now = timezone.now()
final_path = archive.make_final_path(date=now)
valid_path = os.path.join(
archive.data_dir_path,
now.strftime("%Y"),
now.strftime("%m"),
now.strftime("%d"),
)
self.assertEqual(final_path, valid_path)
def test_make_final_path_both_kwargs(self):
"""make_final_path raises value error if both date and directory are set"""
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
expected_message = "date and directory arguments are mutually exclusive"
with self.assertRaisesMessage(ValueError, expected_message):
archive.make_final_path(date=timezone.now(), directory="test")
def test_get_file(self):
"""get_file returns django file"""
django_file = None
with open(TEST_AVATAR_PATH, "rb") as avatar:
self.user.avatar_tmp = File(avatar)
self.user.save()
with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:
archive.add_model_file(self.user.avatar_tmp)
django_file = archive.get_file()
archive_path = archive.file_path
self.assertIsNotNone(archive_path)
self.assertEqual(django_file.name, archive.file_path)
self.assertFalse(django_file.closed)
self.assertIsNone(archive.file)
self.assertIsNone(archive.file_path)
self.assertTrue(django_file.closed)
class TrimLongFilenameTests(TestCase):
def test_trim_short_filename(self):
"""trim_too_long_filename returns short filename as it is"""
filename = "filename.jpg"
trimmed_filename = trim_long_filename(filename)
self.assertEqual(trimmed_filename, filename)
def test_trim_too_long_filename(self):
"""trim_too_long_filename trims filename if its longer than allowed"""
filename = "filename"
extension = ".jpg"
long_filename = "%s%s" % (filename * 10, extension)
trimmed_filename = trim_long_filename(long_filename)
self.assertEqual(len(trimmed_filename), FILENAME_MAX_LEN)
self.assertTrue(trimmed_filename.startswith(filename))
self.assertTrue(trimmed_filename.endswith(extension))
| 10,288
|
Python
|
.py
| 189
| 43.645503
| 85
| 0.645171
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,510
|
profilefields.py
|
rafalp_Misago/misago/users/tests/testfiles/profilefields.py
|
class NofieldnameField:
pass
class FieldnameField:
fieldname = "hello"
class RepeatedFieldnameField(FieldnameField):
pass
| 138
|
Python
|
.py
| 6
| 19.333333
| 45
| 0.804688
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,511
|
populateonlinetracker.py
|
rafalp_Misago/misago/users/management/commands/populateonlinetracker.py
|
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from ...models import Online
User = get_user_model()
class Command(BaseCommand):
help = "Populates online tracker for user accounts that lack it."
def handle(self, *args, **options):
entries_created = 0
queryset = User.objects.filter(online_tracker__isnull=True)
for user in queryset.iterator(chunk_size=50):
Online.objects.create(user=user, last_click=user.last_login)
entries_created += 1
self.stdout.write("Tracker entries created: %s" % entries_created)
| 627
|
Python
|
.py
| 13
| 41.846154
| 74
| 0.713816
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,512
|
deleteprofilefield.py
|
rafalp_Misago/misago/users/management/commands/deleteprofilefield.py
|
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
User = get_user_model()
class Command(BaseCommand):
help = "Deletes specified profile field from database."
def add_arguments(self, parser):
parser.add_argument("fieldname", help="field to delete", nargs="?")
def handle(self, *args, **options):
fieldname = options["fieldname"]
if not fieldname:
self.stderr.write("Specify fieldname to delete.")
return
fields_deleted = 0
queryset = User.objects.filter(profile_fields__has_keys=[fieldname])
for user in queryset.iterator(chunk_size=50):
if fieldname in user.profile_fields.keys():
user.profile_fields.pop(fieldname)
user.save(update_fields=["profile_fields"])
fields_deleted += 1
self.stdout.write(
'"%s" profile field has been deleted from %s users.'
% (fieldname, fields_deleted)
)
| 1,026
|
Python
|
.py
| 23
| 35.217391
| 76
| 0.639839
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,513
|
expireuserdatadownloads.py
|
rafalp_Misago/misago/users/management/commands/expireuserdatadownloads.py
|
from django.core.management.base import BaseCommand
from django.utils import timezone
from ...datadownloads import expire_user_data_download
from ...models import DataDownload
class Command(BaseCommand):
help = "Expires old user data downloads."
def handle(self, *args, **options):
downloads_expired = 0
queryset = DataDownload.objects.select_related("user")
queryset = queryset.filter(
status=DataDownload.STATUS_READY,
expires_on__lte=timezone.now(),
)
for data_download in queryset.iterator(chunk_size=50):
expire_user_data_download(data_download)
downloads_expired += 1
self.stdout.write("Data downloads expired: %s" % downloads_expired)
| 752
|
Python
|
.py
| 17
| 36.764706
| 75
| 0.695473
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,514
|
listusedprofilefields.py
|
rafalp_Misago/misago/users/management/commands/listusedprofilefields.py
|
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
User = get_user_model()
class Command(BaseCommand):
help = "Lists all profile fields in use."
def handle(self, *args, **options):
keys = {}
for user in User.objects.order_by("id").iterator(chunk_size=100):
for key in user.profile_fields:
keys.setdefault(key, 0)
keys[key] += 1
if keys:
max_len = max([len(k) for k in keys])
for key in sorted(keys):
space = " " * (max_len + 1 - len(key))
self.stdout.write("%s:%s%s" % (key, space, keys[key]))
else:
self.stdout.write("No profile fields are currently in use.")
| 767
|
Python
|
.py
| 18
| 32.833333
| 73
| 0.578735
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,515
|
removeoldips.py
|
rafalp_Misago/misago/users/management/commands/removeoldips.py
|
from django.core.management import BaseCommand
from ....conf.shortcuts import get_dynamic_settings
from ...signals import remove_old_ips
class Command(BaseCommand):
help = "Removes users IPs stored for longer than configured by administrator."
def handle(self, *args, **options):
settings = get_dynamic_settings()
if not settings.ip_storage_time:
self.stdout.write("Old IP removal is disabled.")
return
remove_old_ips.send(sender=self, ip_storage_time=settings.ip_storage_time)
self.stdout.write(
"IP addresses older than %s days have been removed."
% settings.ip_storage_time
)
| 681
|
Python
|
.py
| 15
| 37.6
| 82
| 0.684848
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,516
|
loadavatargallery.py
|
rafalp_Misago/misago/users/management/commands/loadavatargallery.py
|
from django.core.management.base import BaseCommand
from ....conf import settings
from ...avatars.gallery import load_avatar_galleries
from ...models import AvatarGallery
class Command(BaseCommand):
help = "Overwrites avatar gallery with contents of your gallery directory."
def handle(self, *args, **options):
# Empty existing gallery
for avatar in AvatarGallery.objects.all():
avatar.image.delete(False)
AvatarGallery.objects.all().delete()
if not settings.MISAGO_AVATAR_GALLERY:
self.stdout.write(
"No directory to load has been configured. "
"Avatars gallery has been emptied."
)
return
# Populate it with new items
if load_avatar_galleries():
self.stdout.write("New galleries have been loaded.")
else:
self.stdout.write(
"No galleries to load have been found. "
"Avatars gallery has been emptied."
)
| 1,023
|
Python
|
.py
| 25
| 31.2
| 79
| 0.633065
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,517
|
synchronizeusers.py
|
rafalp_Misago/misago/users/management/commands/synchronizeusers.py
|
import time
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from ....categories.models import Category
from ....core.management.progressbar import show_progress
User = get_user_model()
class Command(BaseCommand):
help = "Synchronizes users"
def handle(self, *args, **options):
users_to_sync = User.objects.count()
if not users_to_sync:
self.stdout.write("\n\nNo users were found")
else:
self.sync_users(users_to_sync)
def sync_users(self, users_to_sync):
categories = Category.objects.root_category().get_descendants()
self.stdout.write("Synchronizing %s users...\n" % users_to_sync)
synchronized_count = 0
show_progress(self, synchronized_count, users_to_sync)
start_time = time.time()
for user in User.objects.iterator(chunk_size=50):
user.threads = user.thread_set.filter(
category__in=categories, is_hidden=False, is_unapproved=False
).count()
user.posts = user.post_set.filter(
category__in=categories, is_event=False, is_unapproved=False
).count()
user.followers = user.followed_by.count()
user.following = user.follows.count()
user.save()
synchronized_count += 1
show_progress(self, synchronized_count, users_to_sync, start_time)
self.stdout.write("\n\nSynchronized %s users" % synchronized_count)
| 1,528
|
Python
|
.py
| 33
| 37.060606
| 78
| 0.650439
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,518
|
buildactivepostersranking.py
|
rafalp_Misago/misago/users/management/commands/buildactivepostersranking.py
|
from time import time
from django.core.management.base import BaseCommand
from ...activepostersranking import build_active_posters_ranking
class Command(BaseCommand):
help = "Builds active posters ranking"
def handle(self, *args, **options):
self.stdout.write("\nBuilding active posters ranking...")
start_time = time()
build_active_posters_ranking()
end_time = time() - start_time
self.stdout.write("Finished after %.2fs" % end_time)
| 490
|
Python
|
.py
| 11
| 38.545455
| 65
| 0.709746
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,519
|
prepareuserdatadownloads.py
|
rafalp_Misago/misago/users/management/commands/prepareuserdatadownloads.py
|
import logging
from django.core.management.base import BaseCommand
from django.utils.translation import pgettext
from ....conf import settings
from ....conf.shortcuts import get_dynamic_settings
from ....core.mail import mail_user
from ...datadownloads import prepare_user_data_download
from ...models import DataDownload
logger = logging.getLogger("misago.users.datadownloads")
class Command(BaseCommand):
help = "Prepares user data downloads."
leave_locale_alone = True
def handle(self, *args, **options):
working_dir = settings.MISAGO_USER_DATA_DOWNLOADS_WORKING_DIR
if not working_dir:
self.stdout.write(
"MISAGO_USER_DATA_DOWNLOADS_WORKING_DIR has to be set in order for "
"this feature to work."
)
return
dynamic_settings = get_dynamic_settings()
expires_in = dynamic_settings.data_downloads_expiration
downloads_prepared = 0
queryset = DataDownload.objects.select_related("user")
queryset = queryset.filter(status=DataDownload.STATUS_PENDING)
for data_download in queryset.iterator(chunk_size=50):
if prepare_user_data_download(data_download, expires_in, logger):
subject = pgettext(
"data download ready email subject",
"%(user)s, your data download is ready",
) % {"user": data_download.user}
mail_user(
data_download.user,
subject,
"misago/emails/data_download",
context={
"data_download": data_download,
"expires_in": expires_in,
"settings": dynamic_settings,
},
)
downloads_prepared += 1
self.stdout.write("Data downloads prepared: %s" % downloads_prepared)
| 1,937
|
Python
|
.py
| 43
| 33.186047
| 84
| 0.606479
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,520
|
createsuperuser.py
|
rafalp_Misago/misago/users/management/commands/createsuperuser.py
|
"""
Misago-native rehash of Django's createsuperuser command that
works with double authentication fields on user model
"""
import sys
from getpass import getpass
from django.contrib.auth import get_user_model
from django.contrib.auth.password_validation import validate_password
from django.core.exceptions import ValidationError
from django.core.management.base import BaseCommand
from django.db import DEFAULT_DB_ALIAS, IntegrityError
from django.utils.encoding import force_str
from ....conf.shortcuts import get_dynamic_settings
from ...setupnewuser import setup_new_user
from ...validators import validate_email, validate_username
User = get_user_model()
class NotRunningInTTYException(Exception):
pass
class Command(BaseCommand):
help = "Used to create a superuser."
def add_arguments(self, parser):
parser.add_argument(
"--username",
dest="username",
default=None,
help="Specifies the username for the superuser.",
)
parser.add_argument(
"--email",
dest="email",
default=None,
help="Specifies the e-mail for the superuser.",
)
parser.add_argument(
"--password",
dest="password",
default=None,
help="Specifies the password for the superuser.",
)
parser.add_argument(
"--noinput",
"--no-input",
action="store_false",
dest="interactive",
default=True,
help=(
"Tells Misago to NOT prompt the user for input "
"of any kind. You must use --username with "
"--noinput, along with an option for any other "
"required field. Superusers created with "
"--noinput will not be able to log in until "
"they're given a valid password."
),
)
parser.add_argument(
"--database",
action="store",
dest="database",
default=DEFAULT_DB_ALIAS,
help=('Specifies the database to use. Default is "default".'),
)
def execute(self, *args, **options):
self.stdin = options.get("stdin", sys.stdin) # Used for testing
return super().execute(*args, **options)
def handle(
self, *args, **options
): # pylint: disable=too-many-branches, too-many-locals
username = options.get("username")
email = options.get("email")
password = options.get("password")
interactive = options.get("interactive")
verbosity = int(options.get("verbosity", 1))
settings = get_dynamic_settings()
# Validate initial inputs
if username is not None:
try:
username = username.strip()
validate_username(settings, username)
except ValidationError as e:
self.stderr.write("\n".join(e.messages))
username = None
if email is not None:
try:
email = email.strip()
validate_email(email)
except ValidationError as e:
self.stderr.write("\n".join(e.messages))
email = None
if password is not None:
password = password.strip()
if password == "":
self.stderr.write("Error: Blank passwords aren't allowed.")
if not interactive:
if username and email and password:
# Call User manager's create_superuser using our wrapper
self.create_superuser(username, email, password, settings, verbosity)
else:
try:
if hasattr(self.stdin, "isatty") and not self.stdin.isatty():
raise NotRunningInTTYException("Not running in a TTY")
# Prompt for username/password, and any other required fields.
# Enclose this whole thing in a try/except to trap for a
# keyboard interrupt and exit gracefully.
while not username:
try:
message = force_str("Enter displayed username: ")
raw_value = input(message).strip()
validate_username(settings, raw_value)
username = raw_value
except ValidationError as e:
self.stderr.write("\n".join(e.messages))
while not email:
try:
raw_value = input("Enter e-mail address: ").strip()
validate_email(raw_value)
email = raw_value
except ValidationError as e:
self.stderr.write("\n".join(e.messages))
while not password:
raw_value = getpass("Enter password: ")
password_repeat = getpass("Repeat password:")
if raw_value != password_repeat:
self.stderr.write("Error: Your passwords didn't match.")
# Don't validate passwords that don't match.
continue
if raw_value.strip() == "":
self.stderr.write("Error: Blank passwords aren't allowed.")
# Don't validate blank passwords.
continue
try:
validate_password(
raw_value, user=User(username=username, email=email)
)
except ValidationError as e:
self.stderr.write("\n".join(e.messages))
response = input(
"Bypass password validation and create user anyway? [y/N]: "
)
if response.lower() != "y":
continue
password = raw_value
# Call User manager's create_superuser using our wrapper
self.create_superuser(username, email, password, settings, verbosity)
except KeyboardInterrupt:
self.stderr.write("\nOperation cancelled.")
sys.exit(1)
except NotRunningInTTYException:
self.stdout.write(
"Superuser creation skipped due to not running in a TTY. "
"You can run `manage.py createsuperuser` in your project "
"to create one manually."
)
def create_superuser(self, username, email, password, settings, verbosity):
try:
user = User.objects.create_superuser(username, email, password)
setup_new_user(settings, user)
if verbosity >= 1:
message = "Superuser #%s has been created successfully."
self.stdout.write(message % user.pk)
except ValidationError as e:
self.stderr.write(e.messages[0])
except IntegrityError as e:
self.stderr.write(e.messages[0])
| 7,175
|
Python
|
.py
| 163
| 29.871166
| 88
| 0.547002
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,521
|
deletemarkedusers.py
|
rafalp_Misago/misago/users/management/commands/deletemarkedusers.py
|
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from ....conf.shortcuts import get_dynamic_settings
from ...deletesrecord import record_user_deleted_by_self
from ...permissions import can_delete_own_account
User = get_user_model()
class Command(BaseCommand):
help = (
"Deletes accounts of users that have requested it. "
"Leaves their content behind, but anonymises it."
)
def handle(self, *args, **options):
users_deleted = 0
settings = get_dynamic_settings()
queryset = User.objects.filter(is_deleting_account=True)
for user in queryset.iterator(chunk_size=50):
if can_delete_own_account(settings, user, user):
user.delete(anonymous_username=settings.anonymous_username)
record_user_deleted_by_self()
users_deleted += 1
self.stdout.write("Deleted users: %s" % users_deleted)
| 964
|
Python
|
.py
| 21
| 38.428571
| 75
| 0.68877
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,522
|
invalidatebans.py
|
rafalp_Misago/misago/users/management/commands/invalidatebans.py
|
from django.core.management.base import BaseCommand
from django.utils import timezone
from ....cache.versions import get_cache_versions
from ....users import BANS_CACHE
from ...models import Ban, BanCache
class Command(BaseCommand):
help = (
"Runs maintenance on Misago bans system, "
"invalidating expired bans and pruning caches."
)
def handle(self, *args, **options):
self.handle_expired_bans()
self.handle_bans_caches()
def handle_expired_bans(self):
queryset = Ban.objects.filter(is_checked=True)
queryset = queryset.filter(expires_on__lt=timezone.now())
expired_count = queryset.update(is_checked=False)
self.stdout.write("Bans invalidated: %s" % expired_count)
def handle_bans_caches(self):
queryset = BanCache.objects.filter(expires_on__lt=timezone.now())
expired_count = queryset.count()
queryset.delete()
cache_versions = get_cache_versions()
queryset = BanCache.objects.exclude(cache_version=cache_versions[BANS_CACHE])
expired_count += queryset.count()
queryset.delete()
self.stdout.write("Ban caches emptied: %s" % expired_count)
| 1,202
|
Python
|
.py
| 27
| 37.62963
| 85
| 0.691581
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,523
|
deleteinactiveusers.py
|
rafalp_Misago/misago/users/management/commands/deleteinactiveusers.py
|
from datetime import timedelta
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from django.utils import timezone
from ....conf.shortcuts import get_dynamic_settings
from ...deletesrecord import record_user_deleted_by_system
User = get_user_model()
class Command(BaseCommand):
help = "Deletes inactive user accounts older than set time."
def handle(self, *args, **options):
settings = get_dynamic_settings()
if not settings.new_inactive_accounts_delete:
self.stdout.write(
"Automatic deletion of inactive user accounts is currently disabled."
)
return
users_deleted = 0
joined_on_cutoff = timezone.now() - timedelta(
days=settings.new_inactive_accounts_delete
)
queryset = User.objects.filter(
requires_activation__gt=User.ACTIVATION_NONE,
joined_on__lt=joined_on_cutoff,
)
for user in queryset.iterator(chunk_size=50):
user.delete(anonymous_username=settings.anonymous_username)
record_user_deleted_by_system()
users_deleted += 1
self.stdout.write("Deleted inactive user accounts: %s" % users_deleted)
| 1,268
|
Python
|
.py
| 29
| 35.310345
| 85
| 0.679153
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,524
|
utils.py
|
rafalp_Misago/misago/users/online/utils.py
|
from datetime import timedelta
from django.utils import timezone
from ..bans import get_user_ban
from ..models import BanCache, Online
ACTIVITY_CUTOFF = timedelta(minutes=2)
def make_users_status_aware(request, users, fetch_state=False):
users_dict = {}
for user in users:
users_dict[user.pk] = user
if fetch_state:
# Fill ban cache on users
for ban_cache in BanCache.objects.filter(user__in=users_dict.keys()):
users_dict[ban_cache.user_id].ban_cache = ban_cache
# Fill user online trackers
for online_tracker in Online.objects.filter(user__in=users_dict.keys()):
users_dict[online_tracker.user_id].online_tracker = online_tracker
# Fill user states
for user in users:
user.status = get_user_status(request, user)
def get_user_status(request, user):
user_status = {
"is_banned": False,
"is_hidden": user.is_hiding_presence,
"is_online_hidden": False,
"is_offline_hidden": False,
"is_online": False,
"is_offline": False,
"banned_until": None,
"last_click": user.last_login or user.joined_on,
}
user_ban = get_user_ban(user, request.cache_versions)
if user_ban:
user_status["is_banned"] = True
user_status["banned_until"] = user_ban.expires_on
try:
online_tracker = user.online_tracker
is_hidden = (
user.is_hiding_presence and not request.user_acl["can_see_hidden_users"]
)
if online_tracker and not is_hidden:
if online_tracker.last_click >= timezone.now() - ACTIVITY_CUTOFF:
user_status["is_online"] = True
user_status["last_click"] = online_tracker.last_click
except Online.DoesNotExist:
pass
if user_status["is_hidden"]:
if request.user_acl["can_see_hidden_users"]:
user_status["is_hidden"] = False
if user_status["is_online"]:
user_status["is_online_hidden"] = True
user_status["is_online"] = False
else:
user_status["is_offline_hidden"] = True
user_status["is_offline"] = False
else:
user_status["is_hidden"] = True
else:
if user_status["is_online"]:
user_status["is_online"] = True
else:
user_status["is_offline"] = True
return user_status
| 2,434
|
Python
|
.py
| 62
| 30.403226
| 84
| 0.610946
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,525
|
tracker.py
|
rafalp_Misago/misago/users/online/tracker.py
|
from django.utils import timezone
from rest_framework.request import Request
from ..models import Online
def mute_tracker(request):
request._misago_online_tracker = None
def start_tracking(request, user):
online_tracker = Online.objects.create(user=user)
request.user.online_tracker = online_tracker
request._misago_online_tracker = online_tracker
def update_tracker(request, tracker):
tracker.last_click = timezone.now()
tracker.save(update_fields=["last_click"])
def stop_tracking(request, tracker):
user = tracker.user
user.last_login = tracker.last_click
user.save(update_fields=["last_login"])
tracker.delete()
def clear_tracking(request):
if isinstance(request, Request):
request = request._request # Fugly unwrap restframework's request
request._misago_online_tracker = None
| 853
|
Python
|
.py
| 21
| 36.285714
| 74
| 0.755501
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,526
|
tasks.py
|
rafalp_Misago/misago/users/admin/tasks.py
|
from celery import shared_task
from django.contrib.auth import get_user_model
from ...conf.shortcuts import get_dynamic_settings
from ..deletesrecord import record_user_deleted_by_staff
User = get_user_model()
@shared_task
def delete_user_with_content(id):
try:
user = User.objects.get(id=id)
except User.DoesNotExist:
return
if not user.is_misago_admin and not user.is_staff:
settings = get_dynamic_settings()
user.delete(anonymous_username=settings.anonymous_username, delete_content=True)
record_user_deleted_by_staff()
| 580
|
Python
|
.py
| 15
| 33.866667
| 88
| 0.742857
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,527
|
djangoadmin.py
|
rafalp_Misago/misago/users/admin/djangoadmin.py
|
from django.contrib.admin import ModelAdmin
from django.urls import reverse
from django.utils.html import format_html
from django.utils.translation import gettext as _
class UserAdminModel(ModelAdmin):
"""
The model should be used for interaction of third party django apps with
Misago's `User`.
Removes `new` and `delete` actions (use Misago admin for that).
Registration call is placed in :mod:`misago.users.admin`.
The tests are in :mod:`misago.users.tests.test_djangoadmin_user`.
"""
list_display = (
"username",
"email",
"rank",
"is_staff",
"is_superuser",
"get_edit_from_misago_url",
)
search_fields = ("username", "email")
list_filter = ("groups", "rank", "is_staff", "is_superuser")
actions = None
readonly_fields = (
"username",
"email",
"joined_on",
"last_login",
"rank",
"is_staff",
"is_superuser",
"get_edit_from_misago_url",
)
fieldsets = (
(
_("Misago user data"),
{
"fields": (
"username",
"email",
"joined_on",
"last_login",
"rank",
"is_staff",
"is_superuser",
"get_edit_from_misago_url",
)
},
),
(_("Edit permissions and groups"), {"fields": ("groups", "user_permissions")}),
)
def has_add_permission(self, request):
return False
def has_delete_permission(self, request, obj=None):
return False
def get_edit_from_misago_url(self, user_instance):
return format_html(
'<a href="{link}" class="{cls}" target="blank">{text}</a>',
link=reverse(
viewname="misago:admin:users:edit", kwargs={"pk": user_instance.pk}
),
cls="changelink",
text=_("Edit"),
)
get_edit_from_misago_url.short_description = _(
"Edit the user from Misago admin panel"
)
| 2,128
|
Python
|
.py
| 67
| 22.19403
| 87
| 0.531936
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,528
|
__init__.py
|
rafalp_Misago/misago/users/admin/__init__.py
|
from django.urls import path
from django.contrib import admin as djadmin
from django.contrib.auth import get_user_model
from django.utils.translation import pgettext_lazy
from .djangoadmin import UserAdminModel
from .views.bans import BansList, DeleteBan, EditBan, NewBan
from .views.datadownloads import DataDownloadsList, RequestDataDownloads
from .views.ranks import (
DefaultRank,
DeleteRank,
EditRank,
MoveDownRank,
MoveUpRank,
NewRank,
RanksList,
RankUsers,
)
from .views.users import EditUser, NewUser, UsersList
djadmin.site.register(model_or_iterable=get_user_model(), admin_class=UserAdminModel)
class MisagoAdminExtension:
def register_urlpatterns(self, urlpatterns):
# Users section
urlpatterns.namespace("users/", "users")
# Accounts
urlpatterns.patterns(
"users",
path("", UsersList.as_view(), name="index"),
path("<int:page>/", UsersList.as_view(), name="index"),
path("new/", NewUser.as_view(), name="new"),
path("edit/<int:pk>/", EditUser.as_view(), name="edit"),
)
# Bans
urlpatterns.namespace("bans/", "bans", "users")
urlpatterns.patterns(
"users:bans",
path("", BansList.as_view(), name="index"),
path("<int:page>/", BansList.as_view(), name="index"),
path("new/", NewBan.as_view(), name="new"),
path("edit/<int:pk>/", EditBan.as_view(), name="edit"),
path("delete/<int:pk>/", DeleteBan.as_view(), name="delete"),
)
# Data Downloads
urlpatterns.namespace("data-downloads/", "data-downloads", "users")
urlpatterns.patterns(
"users:data-downloads",
path("", DataDownloadsList.as_view(), name="index"),
path("<int:page>/", DataDownloadsList.as_view(), name="index"),
path("request/", RequestDataDownloads.as_view(), name="request"),
)
# Ranks
urlpatterns.namespace("ranks/", "ranks")
urlpatterns.patterns(
"ranks",
path("", RanksList.as_view(), name="index"),
path("new/", NewRank.as_view(), name="new"),
path("edit/<int:pk>/", EditRank.as_view(), name="edit"),
path("default/<int:pk>/", DefaultRank.as_view(), name="default"),
path("move/down/<int:pk>/", MoveDownRank.as_view(), name="down"),
path("move/up/<int:pk>/", MoveUpRank.as_view(), name="up"),
path("users/<int:pk>/", RankUsers.as_view(), name="users"),
path("delete/<int:pk>/", DeleteRank.as_view(), name="delete"),
)
def register_navigation_nodes(self, site):
site.add_node(
name=pgettext_lazy("admin node", "Users"),
icon="fa fa-users",
after="index",
namespace="users",
)
site.add_node(
name=pgettext_lazy("admin node", "Bans"),
parent="users",
namespace="bans",
)
site.add_node(
name=pgettext_lazy("admin node", "Data downloads"),
parent="users",
after="bans:index",
namespace="data-downloads",
)
site.add_node(
name=pgettext_lazy("admin node", "Ranks"),
icon="fas fa-shield-alt",
after="groups:index",
namespace="ranks",
)
| 3,427
|
Python
|
.py
| 86
| 30.476744
| 85
| 0.580054
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,529
|
users.py
|
rafalp_Misago/misago/users/admin/views/users.py
|
from django.contrib import messages
from django.contrib.auth import get_user_model, update_session_auth_hash
from django.shortcuts import redirect
from django.utils.decorators import method_decorator
from django.utils.translation import pgettext, pgettext_lazy
from django.views.decorators.debug import sensitive_post_parameters
from ....acl.useracl import get_user_acl
from ....admin.auth import authorize_admin
from ....admin.views import generic
from ....core.mail import mail_users
from ...avatars.dynamic import set_avatar as set_dynamic_avatar
from ...datadownloads import request_user_data_download, user_has_data_download_request
from ...deletesrecord import record_user_deleted_by_staff
from ...models import Ban
from ...profilefields import profilefields
from ...setupnewuser import setup_new_user
from ...signatures import set_user_signature
from ..forms.users import (
BanUsersForm,
EditUserForm,
NewUserForm,
create_filter_users_form,
user_form_factory,
)
from ..tasks import delete_user_with_content
User = get_user_model()
class UserAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:users:index"
templates_dir = "misago/admin/users"
model = User
def get_form_class(self, request, target):
return user_form_factory(self.form_class, target)
class UsersList(UserAdmin, generic.ListView):
items_per_page = 24
ordering = [
("-id", pgettext_lazy("admin users ordering choice", "From newest")),
("id", pgettext_lazy("admin users ordering choice", "From oldest")),
("slug", pgettext_lazy("admin users ordering choice", "A to z")),
("-slug", pgettext_lazy("admin users ordering choice", "Z to a")),
("-posts", pgettext_lazy("admin users ordering choice", "Biggest posters")),
("posts", pgettext_lazy("admin users ordering choice", "Smallest posters")),
]
selection_label = pgettext_lazy("admin users", "With users: 0")
empty_selection_label = pgettext_lazy("admin users", "Select users")
mass_actions = [
{
"action": "activate",
"name": pgettext_lazy("admin users", "Activate accounts"),
},
{
"action": "ban",
"name": pgettext_lazy("admin users", "Ban users"),
"icon": "fa fa-lock",
},
{
"action": "request_data_download",
"name": pgettext_lazy("admin users", "Request data download"),
},
{
"action": "delete_accounts",
"name": pgettext_lazy("admin users", "Delete accounts"),
"confirmation": pgettext_lazy(
"admin users", "Are you sure you want to delete selected users?"
),
},
{
"action": "delete_all",
"name": pgettext_lazy("admin users", "Delete with content"),
"confirmation": pgettext_lazy(
"admin users",
"Are you sure you want to delete selected users? This will also delete all content associated with their accounts.",
),
"is_atomic": False,
},
]
def get_queryset(self):
qs = super().get_queryset()
return qs.prefetch_related("rank", "group")
def get_filter_form(self, request):
return create_filter_users_form()
def action_activate(self, request, users):
inactive_users = []
for user in users:
if user.requires_activation:
inactive_users.append(user)
if not inactive_users:
message = pgettext("admin users", "You have to select inactive users.")
raise generic.MassActionError(message)
else:
activated_users_pks = [u.pk for u in inactive_users]
queryset = User.objects.filter(pk__in=activated_users_pks)
queryset.update(requires_activation=User.ACTIVATION_NONE)
subject = pgettext(
"account activated email subject",
"Your account on %(forum_name)s forums has been activated",
)
mail_subject = subject % {"forum_name": request.settings.forum_name}
mail_users(
inactive_users,
mail_subject,
"misago/emails/activation/by_admin",
context={"settings": request.settings},
)
messages.success(
request,
pgettext("admin users", "Selected users accounts have been activated."),
)
def action_ban(
self, request, users
): # pylint: disable=too-many-locals, too-many-nested-blocks, too-many-branches
users = users.order_by("slug")
for user in users:
if user.is_staff:
message = pgettext(
"admin users", "%(user)s is admin and can't be banned."
)
mesage = message % {"user": user.username}
raise generic.MassActionError(mesage)
form = BanUsersForm(users=users)
if "finalize" in request.POST:
form = BanUsersForm(request.POST, users=users)
if form.is_valid():
cleaned_data = form.cleaned_data
banned_values = []
ban_kwargs = {
"user_message": cleaned_data.get("user_message"),
"staff_message": cleaned_data.get("staff_message"),
"expires_on": cleaned_data.get("expires_on"),
}
for user in users:
for ban in cleaned_data["ban_type"]:
banned_value = None
if ban == "usernames":
check_type = Ban.USERNAME
banned_value = user.username.lower()
if ban == "emails":
check_type = Ban.EMAIL
banned_value = user.email.lower()
if ban == "domains":
check_type = Ban.EMAIL
banned_value = user.email.lower()
at_pos = banned_value.find("@")
banned_value = "*%s" % banned_value[at_pos:]
if ban == "ip" and user.joined_from_ip:
check_type = Ban.IP
banned_value = user.joined_from_ip
if ban in ("ip_first", "ip_two") and user.joined_from_ip:
check_type = Ban.IP
if ":" in user.joined_from_ip:
ip_separator = ":"
if "." in user.joined_from_ip:
ip_separator = "."
bits = user.joined_from_ip.split(ip_separator)
if ban == "ip_first":
formats = (bits[0], ip_separator)
if ban == "ip_two":
formats = (bits[0], ip_separator, bits[1], ip_separator)
banned_value = "%s*" % ("".join(formats))
if banned_value and banned_value not in banned_values:
ban_kwargs.update(
{"check_type": check_type, "banned_value": banned_value}
)
Ban.objects.create(**ban_kwargs)
banned_values.append(banned_value)
Ban.objects.invalidate_cache()
messages.success(
request, pgettext("admin users", "Selected users have been banned.")
)
return None
return self.render(
request,
{"users": users, "form": form},
template_name="misago/admin/users/ban.html",
)
def action_request_data_download(self, request, users):
for user in users:
if not user_has_data_download_request(user):
request_user_data_download(user, requester=request.user)
messages.success(
request,
pgettext(
"admin users",
"Data download requests have been placed for selected users.",
),
)
def action_delete_accounts(self, request, users):
for user in users:
if user == request.user:
raise generic.MassActionError(
pgettext("admin users", "You can't delete yourself.")
)
if user.is_misago_admin:
raise generic.MassActionError(
pgettext(
"admin users",
"%(user)s can't be deleted because they are a Misago administrator.",
)
% {"user": user.username}
)
if user.is_staff:
raise generic.MassActionError(
pgettext(
"admin users",
"%(user)s can't be deleted because they are a Django staff.",
)
% {"user": user.username}
)
for user in users:
user.delete(anonymous_username=request.settings.anonymous_username)
record_user_deleted_by_staff()
messages.success(
request, pgettext("admin users", "Selected users have been deleted.")
)
def action_delete_all(self, request, users):
for user in users:
if user == request.user:
raise generic.MassActionError(
pgettext("admin users", "You can't delete yourself.")
)
if user.is_misago_admin:
raise generic.MassActionError(
pgettext(
"admin users",
"%(user)s can't be deleted because they are a Misago administrator.",
)
% {"user": user.username}
)
if user.is_staff:
raise generic.MassActionError(
pgettext(
"admin users",
"%(user)s can't be deleted because they are a Django staff.",
)
% {"user": user.username}
)
for user in users:
user.is_active = False
user.save()
delete_user_with_content.delay(user.pk)
messages.success(
request,
pgettext(
"admin users",
"Selected users have been disabled and queued for deletion together with their content.",
),
)
class NewUser(UserAdmin, generic.ModelFormView):
form_class = NewUserForm
template_name = "new.html"
message_submit = pgettext_lazy(
"admin users", 'New user "%(user)s" has been registered.'
)
@method_decorator(sensitive_post_parameters("new_password"))
def dispatch(self, request, *args, **kwargs):
return super().dispatch(request, *args, **kwargs)
def get_form(self, form_class, request, target):
if request.method == "POST":
return form_class(
request.POST, request.FILES, instance=target, request=request
)
return form_class(instance=target, request=request)
def handle_form(self, form, request, target):
new_user = User.objects.create_user(
form.cleaned_data["username"],
form.cleaned_data["email"],
form.cleaned_data["new_password"],
group=form.cleaned_data["group"],
secondary_groups=form.cleaned_data["secondary_groups"],
title=form.cleaned_data["title"],
rank=form.cleaned_data.get("rank"),
joined_from_ip=request.user_ip,
)
if form.cleaned_data.get("roles"):
new_user.roles.add(*form.cleaned_data["roles"])
new_user.update_acl_key()
setup_new_user(request.settings, new_user)
messages.success(request, self.message_submit % {"user": target.username})
return redirect("misago:admin:users:edit", pk=new_user.pk)
class EditUser(UserAdmin, generic.ModelFormView):
form_class = EditUserForm
template_name = "edit.html"
message_submit = pgettext_lazy("admin users", 'User "%(user)s" has been edited.')
@method_decorator(sensitive_post_parameters("new_password"))
def dispatch(self, request, *args, **kwargs):
return super().dispatch(request, *args, **kwargs)
def real_dispatch(self, request, target):
target.old_username = target.username
target.old_is_avatar_locked = target.is_avatar_locked
return super().real_dispatch(request, target)
def get_form(self, form_class, request, target):
if request.method == "POST":
return form_class(
request.POST, request.FILES, instance=target, request=request
)
return form_class(instance=target, request=request)
def handle_form(self, form, request, target):
target.username = target.old_username
if target.username != form.cleaned_data["username"]:
target.set_username(form.cleaned_data["username"], changed_by=request.user)
if form.cleaned_data.get("new_password"):
target.set_password(form.cleaned_data["new_password"])
if form.cleaned_data.get("email"):
target.set_email(form.cleaned_data["email"])
if form.cleaned_data.get("is_avatar_locked"):
if not target.old_is_avatar_locked:
set_dynamic_avatar(target)
if not form.fields["is_misago_root"].disabled:
target.is_misago_root = form.cleaned_data["is_misago_root"]
if not form.fields["is_active"].disabled:
target.is_active = form.cleaned_data["is_active"]
if not form.fields["is_active_staff_message"].disabled:
target.is_active_staff_message = form.cleaned_data.get(
"is_active_staff_message"
)
target.set_groups(
form.cleaned_data["group"],
form.cleaned_data["secondary_groups"],
)
target.rank = form.cleaned_data.get("rank")
target.roles.clear()
target.roles.add(*form.cleaned_data["roles"])
target_acl = get_user_acl(target, request.cache_versions)
set_user_signature(
request, target, target_acl, form.cleaned_data.get("signature")
)
profilefields.update_user_profile_fields(request, target, form)
target.update_acl_key()
target.save()
if target.pk == request.user.pk:
authorize_admin(request)
update_session_auth_hash(request, target)
messages.success(request, self.message_submit % {"user": target.username})
| 14,996
|
Python
|
.py
| 332
| 31.915663
| 132
| 0.556849
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,530
|
bans.py
|
rafalp_Misago/misago/users/admin/views/bans.py
|
from django.contrib import messages
from django.utils.translation import pgettext, pgettext_lazy
from ....admin.views import generic
from ...models import Ban
from ..forms.bans import BanForm, FilterBansForm
class BanAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:users:bans:index"
model = Ban
form_class = BanForm
templates_dir = "misago/admin/bans"
message_404 = pgettext_lazy("admin bans", "Requested ban does not exist.")
def handle_form(self, form, request, target):
super().handle_form(form, request, target)
Ban.objects.invalidate_cache()
class BansList(BanAdmin, generic.ListView):
items_per_page = 30
ordering = [
("-id", pgettext_lazy("admin bans ordering choice", "From newest")),
("id", pgettext_lazy("admin bans ordering choice", "From oldest")),
("banned_value", pgettext_lazy("admin bans ordering choice", "A to z")),
("-banned_value", pgettext_lazy("admin bans ordering choice", "Z to a")),
]
filter_form = FilterBansForm
selection_label = pgettext_lazy("admin bans", "With bans: 0")
empty_selection_label = pgettext_lazy("admin bans", "Select bans")
mass_actions = [
{
"action": "delete",
"name": pgettext_lazy("admin bans", "Remove bans"),
"confirmation": pgettext_lazy(
"admin bans", "Are you sure you want to remove those bans?"
),
}
]
def action_delete(self, request, items):
items.delete()
Ban.objects.invalidate_cache()
messages.success(
request, pgettext("admin bans", "Selected bans have been removed.")
)
class NewBan(BanAdmin, generic.ModelFormView):
message_submit = pgettext_lazy("admin bans", 'New ban "%(name)s" has been saved.')
class EditBan(BanAdmin, generic.ModelFormView):
message_submit = pgettext_lazy("admin bans", 'Ban "%(name)s" has been edited.')
class DeleteBan(BanAdmin, generic.ButtonView):
def button_action(self, request, target):
target.delete()
Ban.objects.invalidate_cache()
message = pgettext("admin bans", 'Ban "%(name)s" has been removed.')
messages.success(request, message % {"name": target.name})
| 2,252
|
Python
|
.py
| 50
| 38.26
| 86
| 0.661946
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,531
|
ranks.py
|
rafalp_Misago/misago/users/admin/views/ranks.py
|
from django.contrib import messages
from django.shortcuts import redirect
from django.urls import reverse
from django.utils.translation import pgettext, pgettext_lazy
from ....admin.views import generic
from ...models import Rank
from ..forms.ranks import RankForm
class RankAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:ranks:index"
model = Rank
form_class = RankForm
templates_dir = "misago/admin/ranks"
message_404 = pgettext_lazy("admin ranks", "Requested rank does not exist.")
def update_roles(self, target, roles):
target.roles.clear()
if roles:
target.roles.add(*roles)
def handle_form(self, form, request, target):
super().handle_form(form, request, target)
self.update_roles(target, form.cleaned_data["roles"])
class RanksList(RankAdmin, generic.ListView):
ordering = (("order", None),)
class NewRank(RankAdmin, generic.ModelFormView):
message_submit = pgettext_lazy("admin ranks", 'New rank "%(name)s" has been saved.')
class EditRank(RankAdmin, generic.ModelFormView):
message_submit = pgettext_lazy("admin ranks", 'Rank "%(name)s" has been edited.')
class DeleteRank(RankAdmin, generic.ButtonView):
def check_permissions(self, request, target):
message_format = {"name": target.name}
if target.is_default:
message = pgettext(
"admin ranks", 'Rank "%(name)s" is default rank and can\'t be deleted.'
)
return message % message_format
if target.user_set.exists():
message = pgettext(
"admin ranks",
'Rank "%(name)s" is assigned to users and can\'t be deleted.',
)
return message % message_format
def button_action(self, request, target):
target.delete()
message = pgettext("admin ranks", 'Rank "%(name)s" has been deleted.')
messages.success(request, message % {"name": target.name})
class MoveDownRank(RankAdmin, generic.ButtonView):
def button_action(self, request, target):
try:
other_target = Rank.objects.filter(order__gt=target.order)
other_target = other_target.earliest("order")
except Rank.DoesNotExist:
other_target = None
if other_target:
other_target.order, target.order = target.order, other_target.order
other_target.save(update_fields=["order"])
target.save(update_fields=["order"])
message = pgettext(
"admin ranks", 'Rank "%(name)s" has been moved below "%(other)s".'
)
targets_names = {"name": target.name, "other": other_target.name}
messages.success(request, message % targets_names)
class MoveUpRank(RankAdmin, generic.ButtonView):
def button_action(self, request, target):
try:
other_target = Rank.objects.filter(order__lt=target.order)
other_target = other_target.latest("order")
except Rank.DoesNotExist:
other_target = None
if other_target:
other_target.order, target.order = target.order, other_target.order
other_target.save(update_fields=["order"])
target.save(update_fields=["order"])
message = pgettext(
"admin ranks", 'Rank "%(name)s" has been moved above "%(other)s".'
)
targets_names = {"name": target.name, "other": other_target.name}
messages.success(request, message % targets_names)
class RankUsers(RankAdmin, generic.TargetedView):
def real_dispatch(self, request, target):
redirect_url = reverse("misago:admin:users:index")
return redirect("%s?rank=%s" % (redirect_url, target.pk))
class DefaultRank(RankAdmin, generic.ButtonView):
def check_permissions(self, request, target):
if target.is_default:
message = pgettext("admin ranks", 'Rank "%(name)s" is already default.')
return message % {"name": target.name}
def button_action(self, request, target):
Rank.objects.make_rank_default(target)
message = pgettext("admin ranks", 'Rank "%(name)s" has been made default.')
messages.success(request, message % {"name": target.name})
| 4,287
|
Python
|
.py
| 89
| 39.314607
| 88
| 0.646128
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,532
|
datadownloads.py
|
rafalp_Misago/misago/users/admin/views/datadownloads.py
|
from django.contrib import messages
from django.utils.translation import pgettext, pgettext_lazy
from ....admin.views import generic
from ...datadownloads import (
expire_user_data_download,
request_user_data_download,
user_has_data_download_request,
)
from ...models import DataDownload
from ..forms.datadownloads import RequestDataDownloadsForm, FilterDataDownloadsForm
class DataDownloadAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:users:data-downloads:index"
templates_dir = "misago/admin/datadownloads"
model = DataDownload
class DataDownloadsList(DataDownloadAdmin, generic.ListView):
items_per_page = 30
ordering = [
("-id", pgettext_lazy("admin data downloads ordering choice ", "From newest")),
("id", pgettext_lazy("admin data downloads ordering choice ", "From oldest")),
]
selection_label = pgettext_lazy("admin data downloads", "With data downloads: 0")
empty_selection_label = pgettext_lazy(
"admin data downloads", "Select data downloads"
)
mass_actions = [
{
"action": "expire",
"name": pgettext_lazy("admin data downloads", "Expire downloads"),
"confirmation": pgettext_lazy(
"admin data downloads",
"Are you sure you want to set selected data downloads as expired?",
),
},
{
"action": "delete",
"name": pgettext_lazy("admin data downloads", "Delete downloads"),
"confirmation": pgettext_lazy(
"admin data downloads",
"Are you sure you want to delete selected data downloads?",
),
},
]
filter_form = FilterDataDownloadsForm
def get_queryset(self):
qs = super().get_queryset()
return qs.select_related("user", "requester")
def action_expire(self, request, data_downloads):
for data_download in data_downloads:
expire_user_data_download(data_download)
messages.success(
request,
pgettext(
"admin data downloads",
"Selected data downloads have been set as expired.",
),
)
def action_delete(self, request, data_downloads):
for data_download in data_downloads:
data_download.delete()
messages.success(
request,
pgettext(
"admin data downloads", "Selected data downloads have been deleted."
),
)
class RequestDataDownloads(DataDownloadAdmin, generic.FormView):
form_class = RequestDataDownloadsForm
def handle_form(self, form, request):
for user in form.cleaned_data["users"]:
if not user_has_data_download_request(user):
request_user_data_download(user, requester=request.user)
messages.success(
request,
pgettext(
"admin data downloads",
"Data downloads have been requested for specified users.",
),
)
| 3,065
|
Python
|
.py
| 78
| 30.115385
| 87
| 0.628322
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,533
|
users.py
|
rafalp_Misago/misago/users/admin/forms/users.py
|
from typing import Type
from django import forms
from django.contrib.auth import get_user_model
from django.contrib.auth.password_validation import validate_password
from django.db.models import Q
from django.utils.translation import npgettext, pgettext, pgettext_lazy
from ....acl.models import Role
from ....admin.forms import IsoDateTimeField, YesNoSwitch
from ....notifications.threads import ThreadNotifications
from ....search.filter_queryset import filter_queryset
from ...enums import DefaultGroupId
from ...models import Group, Rank
from ...profilefields import profilefields
from ...utils import slugify_username
from ...validators import validate_email, validate_username
User = get_user_model()
class BaseUserForm(forms.ModelForm):
groups_dict: dict[int, Group]
username = forms.CharField(label=pgettext_lazy("admin user form", "Username"))
title = forms.CharField(
label=pgettext_lazy("admin user form", "Custom title"),
required=False,
)
email = forms.EmailField(label=pgettext_lazy("admin user form", "E-mail address"))
class Meta:
model = User
fields = ["username", "email", "title"]
def __init__(self, *args, **kwargs):
self.request = kwargs.pop("request")
self.settings = self.request.settings
super().__init__(*args, **kwargs)
def clean_username(self):
data = self.cleaned_data["username"]
validate_username(self.settings, data, exclude=self.instance)
return data
def clean_email(self):
data = self.cleaned_data["email"]
validate_email(data, exclude=self.instance)
return data
def clean_new_password(self):
data = self.cleaned_data["new_password"]
if data:
validate_password(data, user=self.instance)
return data
def clean_group(self):
data = self.cleaned_data["group"]
return self.groups_dict[data]
def clean_secondary_groups(self):
data = self.cleaned_data["secondary_groups"]
return [self.groups_dict[item] for item in data]
def clean_roles(self):
data = self.cleaned_data["roles"]
for role in data:
if role.special_role == "authenticated":
break
else:
message = pgettext(
"admin user form", 'All registered members must have a "Member" role.'
)
raise forms.ValidationError(message)
return data
class NewUserForm(BaseUserForm):
new_password = forms.CharField(
label=pgettext_lazy("admin user form", "Password"),
strip=False,
widget=forms.PasswordInput,
)
class Meta:
model = User
fields = ["username", "email", "title"]
def clean_group(self):
data = self.cleaned_data["group"]
group = self.groups_dict[data]
if not self.request.user.is_misago_root and data == DefaultGroupId.ADMINS:
raise forms.ValidationError(
pgettext(
"admin user form",
"You must be a root administrator to set this user's main group to the %(group)s.",
)
% {"group": group}
)
return group
def clean_secondary_groups(self):
data = self.cleaned_data["secondary_groups"]
if not self.request.user.is_misago_root and DefaultGroupId.ADMINS in data:
admins_group = self.groups_dict[DefaultGroupId.ADMINS]
raise forms.ValidationError(
pgettext(
"admin user form",
"You must be a root administrator to add this user to the %(group)s group.",
)
% {"group": admins_group}
)
return [self.groups_dict[item] for item in data]
class EditUserForm(BaseUserForm):
new_password = forms.CharField(
label=pgettext_lazy("admin user form", "New password"),
strip=False,
widget=forms.PasswordInput,
required=False,
)
is_misago_root = YesNoSwitch(
label=pgettext_lazy("admin user form", "Is root administrator"),
help_text=pgettext_lazy(
"admin user form",
"Root administrators can sign in to the Misago Admin Control Panel and change other users' admin status. You need to be a root administrator to change this field.",
),
disabled=True,
)
is_active = YesNoSwitch(
label=pgettext_lazy("admin user form", "Is active"),
help_text=pgettext_lazy(
"admin user form",
"Designates whether this user should be treated as active. Turning this off is non-destructible way to remove user accounts.",
),
)
is_active_staff_message = forms.CharField(
label=pgettext_lazy("admin user form", "Staff message"),
help_text=pgettext_lazy(
"admin user form",
"Optional message for forum team members explaining why user's account has been disabled.",
),
widget=forms.Textarea(attrs={"rows": 3}),
required=False,
)
is_avatar_locked = YesNoSwitch(
label=pgettext_lazy("admin user form", "Lock avatar changes"),
help_text=pgettext_lazy(
"admin user form",
"Setting this to yes will stop user from changing their avatar, and will reset their avatar to procedurally generated one.",
),
)
avatar_lock_user_message = forms.CharField(
label=pgettext_lazy("admin user form", "User message"),
help_text=pgettext_lazy(
"admin user form",
"Optional message for user explaining why they are banned form changing avatar.",
),
widget=forms.Textarea(attrs={"rows": 3}),
required=False,
)
avatar_lock_staff_message = forms.CharField(
label=pgettext_lazy("admin user form", "Staff message"),
help_text=pgettext_lazy(
"admin user form",
"Optional message for forum team members explaining why user is banned form changing avatar.",
),
widget=forms.Textarea(attrs={"rows": 3}),
required=False,
)
signature = forms.CharField(
label=pgettext_lazy("admin user form", "Signature contents"),
widget=forms.Textarea(attrs={"rows": 3}),
required=False,
)
is_signature_locked = YesNoSwitch(
label=pgettext_lazy("admin user form", "Lock signature changes"),
help_text=pgettext_lazy(
"admin user form",
"Setting this to yes will stop user from making changes to his/her signature.",
),
)
signature_lock_user_message = forms.CharField(
label=pgettext_lazy("admin user form", "User message"),
help_text=pgettext_lazy(
"admin user form",
"Optional message to user explaining why his/hers signature is locked.",
),
widget=forms.Textarea(attrs={"rows": 3}),
required=False,
)
signature_lock_staff_message = forms.CharField(
label=pgettext_lazy("admin user form", "Staff message"),
help_text=pgettext_lazy(
"admin user form",
"Optional message to team members explaining why user signature is locked.",
),
widget=forms.Textarea(attrs={"rows": 3}),
required=False,
)
is_hiding_presence = YesNoSwitch(
label=pgettext_lazy("admin user form", "Hides presence")
)
limits_private_thread_invites_to = forms.TypedChoiceField(
label=pgettext_lazy("admin user form", "Who can add user to private threads"),
coerce=int,
choices=User.LIMIT_INVITES_TO_CHOICES,
)
subscribe_to_started_threads = forms.TypedChoiceField(
label=pgettext_lazy("admin user form", "Started threads"),
coerce=int,
choices=User.SUBSCRIPTION_CHOICES,
)
subscribe_to_replied_threads = forms.TypedChoiceField(
label=pgettext_lazy("admin user form", "Replied threads"),
coerce=int,
choices=User.SUBSCRIPTION_CHOICES,
)
watch_started_threads = forms.TypedChoiceField(
label=pgettext_lazy(
"admin user form",
"Automatically watch threads that the user has started",
),
coerce=int,
choices=ThreadNotifications.choices,
)
watch_replied_threads = forms.TypedChoiceField(
label=pgettext_lazy(
"admin user form",
"Automatically watch threads that the user has replied to",
),
coerce=int,
choices=ThreadNotifications.choices,
)
watch_new_private_threads_by_followed = forms.TypedChoiceField(
label=pgettext_lazy(
"admin user form",
"Automatically watch private threads that the user was invited to by users they are following",
),
coerce=int,
choices=ThreadNotifications.choices,
)
watch_new_private_threads_by_other_users = forms.TypedChoiceField(
label=pgettext_lazy(
"admin user form",
"Automatically watch private threads that the user was invited to by other users",
),
coerce=int,
choices=ThreadNotifications.choices,
)
notify_new_private_threads_by_followed = forms.TypedChoiceField(
label=pgettext_lazy(
"admin user form",
"Notify about new private thread invitations from users this user is following",
),
coerce=int,
choices=ThreadNotifications.choices,
)
notify_new_private_threads_by_other_users = forms.TypedChoiceField(
label=pgettext_lazy(
"admin user form",
"Notify about new private thread invitations from other users",
),
coerce=int,
choices=ThreadNotifications.choices,
)
class Meta:
model = User
fields = [
"username",
"email",
"title",
"is_misago_root",
"is_active",
"is_active_staff_message",
"is_avatar_locked",
"avatar_lock_user_message",
"avatar_lock_staff_message",
"signature",
"is_signature_locked",
"is_hiding_presence",
"limits_private_thread_invites_to",
"signature_lock_user_message",
"signature_lock_staff_message",
"subscribe_to_started_threads",
"subscribe_to_replied_threads",
"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",
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
request_user = kwargs["request"].user
if request_user.is_misago_root and request_user != self.instance:
self.fields["is_misago_root"].disabled = False
if self.instance.is_misago_admin and not (
request_user.is_misago_root or request_user == self.instance
):
self.credentials_require_root = True
self.fields["new_password"].disabled = True
self.fields["email"].disabled = True
else:
self.credentials_require_root = False
if (
self.instance.is_deleting_account
or request_user == self.instance
or (self.instance.is_misago_admin and not request_user.is_misago_root)
):
self.fields["is_active"].disabled = True
self.fields["is_active_staff_message"].disabled = True
profilefields.add_fields_to_admin_form(self.request, self.instance, self)
def get_profile_fields_groups(self):
profile_fields_groups = []
for group in self._profile_fields_groups:
fields_group = {"name": group["name"], "fields": []}
for fieldname in group["fields"]:
fields_group["fields"].append(self[fieldname])
profile_fields_groups.append(fields_group)
return profile_fields_groups
def clean_group(self):
group = super().clean_group()
if self.request.user.is_misago_root:
return group
if group.id != self.instance.group.id:
if self.instance.group.id == DefaultGroupId.ADMINS:
raise forms.ValidationError(
pgettext(
"admin user form",
"You must be a root administrator to change this user's main group from the %(group)s.",
)
% {"group": self.instance.group}
)
if group.id == DefaultGroupId.ADMINS:
raise forms.ValidationError(
pgettext(
"admin user form",
"You must be a root administrator to change this user's main group to the %(group)s.",
)
% {"group": group}
)
return group
def clean_secondary_groups(self):
secondary_groups = super().clean_secondary_groups()
if self.request.user.is_misago_root:
return secondary_groups
admins_id = DefaultGroupId.ADMINS.value
initial_secondary_groups_ids = [
group_id
for group_id in self.instance.groups_ids
if group_id != self.instance.group_id
]
updated_secondary_groups_ids = [group.id for group in secondary_groups]
if (
admins_id in initial_secondary_groups_ids
and admins_id not in updated_secondary_groups_ids
):
raise forms.ValidationError(
pgettext(
"admin user form",
"You must be a root administrator to remove this user from the %(group)s group.",
)
% {"group": self.groups_dict[admins_id]}
)
if (
admins_id not in initial_secondary_groups_ids
and admins_id in updated_secondary_groups_ids
):
raise forms.ValidationError(
pgettext(
"admin user form",
"You must be a root administrator to add this user to the %(group)s group.",
)
% {"group": self.groups_dict[admins_id]}
)
return secondary_groups
def clean_signature(self):
data = self.cleaned_data["signature"]
length_limit = self.settings.signature_length_max
if len(data) > length_limit:
message = npgettext(
"signature length validator",
"Signature can't be longer than %(limit)s character.",
"Signature can't be longer than %(limit)s characters.",
length_limit,
)
raise forms.ValidationError(message % {"limit": length_limit})
return data
def clean(self):
data = super().clean()
return profilefields.clean_form(self.request, self.instance, self, data)
def user_form_factory(base_form_type: Type[BaseUserForm], instance: User):
groups = list(Group.objects.all())
groups_data = {group.id: group for group in groups}
groups_choices = []
for group in groups:
if group.id == DefaultGroupId.ADMINS:
groups_choices.append((group.id, f"{group}*"))
else:
groups_choices.append((group.id, str(group)))
if instance.group_id:
instance.group = groups_data[instance.group_id]
secondary_groups_initial = instance.groups_ids[:]
if instance.group_id in secondary_groups_initial:
secondary_groups_initial.remove(instance.group_id)
form_attrs = {
"groups_dict": groups_data,
"group": forms.TypedChoiceField(
label=pgettext_lazy("admin user form", "Main group"),
help_text=pgettext_lazy(
"admin user form",
"An asterisk (*) after the group's name signifies the administrators group.",
),
coerce=int,
choices=groups_choices,
initial=instance.group_id,
),
"secondary_groups": forms.TypedMultipleChoiceField(
label=pgettext_lazy("admin user form", "Secondary groups"),
help_text=pgettext_lazy(
"admin user form",
"Optional, other groups this user should be a member of. An asterisk (*) after the group's name signifies the administrators group.",
),
coerce=int,
choices=groups_choices,
initial=secondary_groups_initial,
widget=forms.CheckboxSelectMultiple,
required=False,
),
"rank": forms.ModelChoiceField(
label=pgettext_lazy("admin user form", "Rank"),
help_text=pgettext_lazy(
"admin user form",
"Ranks are used to group and distinguish users. They are also used to add permissions to groups of users.",
),
queryset=Rank.objects.order_by("name"),
initial=instance.rank,
),
}
roles = Role.objects.order_by("name")
form_attrs["roles"] = forms.ModelMultipleChoiceField(
label=pgettext_lazy("admin user form", "Roles"),
help_text=pgettext_lazy(
"admin user form",
'Individual roles of this user. All users must have a "Member" role.',
),
queryset=roles,
initial=instance.roles.all() if instance.pk else None,
widget=forms.CheckboxSelectMultiple,
)
return type("UserForm", (base_form_type,), form_attrs)
class BaseFilterUsersForm(forms.Form):
username = forms.CharField(
label=pgettext_lazy("admin users filter form", "Username"),
required=False,
)
email = forms.CharField(
label=pgettext_lazy("admin users filter form", "E-mail"),
required=False,
)
profilefields = forms.CharField(
label=pgettext_lazy("admin users filter form", "Profile fields contain"),
required=False,
)
is_inactive = forms.BooleanField(
label=pgettext_lazy("admin users filter form", "Requires activation")
)
is_deactivated = forms.BooleanField(
label=pgettext_lazy("admin users filter form", "Account deactivated")
)
is_admin = forms.BooleanField(
label=pgettext_lazy("admin users filter form", "Administrator")
)
is_deleting_account = forms.BooleanField(
label=pgettext_lazy("admin users filter form", "Deletes their account")
)
def filter_queryset(self, criteria, queryset):
if criteria.get("username"):
queryset = filter_queryset(
queryset, "slug", slugify_username(criteria["username"])
)
if criteria.get("email"):
queryset = filter_queryset(
queryset, "email", criteria["email"], case_sensitive=False
)
if criteria.get("main_group"):
queryset = queryset.filter(group_id=criteria["main_group"])
if criteria.get("group"):
queryset = queryset.filter(groups_ids__contains=[criteria["group"]])
if criteria.get("rank"):
queryset = queryset.filter(rank_id=criteria["rank"])
if criteria.get("role"):
queryset = queryset.filter(roles__id=criteria["role"])
if criteria.get("is_inactive"):
queryset = queryset.filter(requires_activation__gt=0)
if criteria.get("is_deactivated"):
queryset = queryset.filter(is_active=False)
if criteria.get("is_admin"):
queryset = queryset.filter(
Q(is_misago_root=True) | Q(groups_ids__contains=[DefaultGroupId.ADMINS])
)
if criteria.get("is_deleting_account"):
queryset = queryset.filter(is_deleting_account=True)
if criteria.get("profilefields", "").strip():
queryset = profilefields.search_users(
criteria.get("profilefields").strip(), queryset
)
return queryset
def create_filter_users_form():
"""
Factory that uses cache for ranks and roles,
and makes those ranks and roles typed choice fields that play nice
with passing values via GET
"""
groups_choices = [
("", pgettext_lazy("admin users group filter choice", "All groups"))
]
for group in Group.objects.order_by("name").iterator(chunk_size=50):
groups_choices.append((group.pk, str(group)))
ranks_choices = [("", pgettext_lazy("admin users rank filter choice", "All ranks"))]
for rank in Rank.objects.order_by("name").iterator(chunk_size=50):
ranks_choices.append((rank.pk, str(rank)))
roles_choices = [("", pgettext_lazy("admin users role filter choice", "All roles"))]
for role in Role.objects.order_by("name").iterator(chunk_size=50):
roles_choices.append((role.pk, str(role)))
extra_fields = {
"main_group": forms.TypedChoiceField(
label=pgettext_lazy("admin users filter form", "Main group"),
coerce=int,
required=False,
choices=groups_choices,
),
"group": forms.TypedChoiceField(
label=pgettext_lazy("admin users filter form", "Has group"),
coerce=int,
required=False,
choices=groups_choices,
),
"rank": forms.TypedChoiceField(
label=pgettext_lazy("admin users filter form", "Has rank"),
coerce=int,
required=False,
choices=ranks_choices,
),
"role": forms.TypedChoiceField(
label=pgettext_lazy("admin users filter form", "Has role"),
coerce=int,
required=False,
choices=roles_choices,
),
}
return type("FilterUsersForm", (BaseFilterUsersForm,), extra_fields)
class BanUsersForm(forms.Form):
ban_type = forms.MultipleChoiceField(
label=pgettext_lazy("admin ban users form", "Values to ban"),
widget=forms.CheckboxSelectMultiple,
choices=[],
)
user_message = forms.CharField(
label=pgettext_lazy("admin ban users form", "User message"),
required=False,
max_length=1000,
help_text=pgettext_lazy(
"admin ban users form",
"Optional message displayed to users instead of default one.",
),
widget=forms.Textarea(attrs={"rows": 3}),
error_messages={
"max_length": pgettext_lazy(
"admin ban users form", "Message can't be longer than 1000 characters."
)
},
)
staff_message = forms.CharField(
label=pgettext_lazy("admin ban users form", "Team message"),
required=False,
max_length=1000,
help_text=pgettext_lazy(
"admin ban users form",
"Optional ban message for moderators and administrators.",
),
widget=forms.Textarea(attrs={"rows": 3}),
error_messages={
"max_length": pgettext_lazy(
"admin ban users form", "Message can't be longer than 1000 characters."
)
},
)
expires_on = IsoDateTimeField(
label=pgettext_lazy("admin ban users form", "Expiration date"), required=False
)
def __init__(self, *args, **kwargs):
users = kwargs.pop("users")
super().__init__(*args, **kwargs)
self.fields["ban_type"].choices = [
("usernames", pgettext_lazy("admin ban users form", "Usernames")),
("emails", pgettext_lazy("admin ban users form", "E-mails")),
("domains", pgettext_lazy("admin ban users form", "E-mail domains")),
]
enable_ip_bans = list(filter(None, [u.joined_from_ip for u in users]))
if enable_ip_bans:
self.fields["ban_type"].choices += [
("ip", pgettext_lazy("admin ban users form", "IP addresses")),
(
"ip_first",
pgettext_lazy(
"admin ban users form", "First segment of IP addresses"
),
),
(
"ip_two",
pgettext_lazy(
"admin ban users form", "First two segments of IP addresses"
),
),
]
| 24,591
|
Python
|
.py
| 598
| 30.884615
| 176
| 0.602168
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,534
|
bans.py
|
rafalp_Misago/misago/users/admin/forms/bans.py
|
from django import forms
from django.contrib.auth import get_user_model
from django.utils.translation import pgettext, pgettext_lazy
from ....admin.forms import IsoDateTimeField, YesNoSwitch
from ...models import Ban
User = get_user_model()
class BanForm(forms.ModelForm):
check_type = forms.TypedChoiceField(
label=pgettext_lazy("admin ban form", "Check type"),
coerce=int,
choices=Ban.CHOICES,
)
registration_only = YesNoSwitch(
label=pgettext_lazy("admin ban form", "Restrict this ban to registrations"),
help_text=pgettext_lazy(
"admin ban form",
"Changing this to yes will make this ban check be only performed on registration step. This is good if you want to block certain registrations like ones from recently compromised e-mail providers, without harming existing users.",
),
)
banned_value = forms.CharField(
label=pgettext_lazy("admin ban form", "Banned value"),
max_length=250,
help_text=pgettext_lazy(
"admin ban form",
'This value is case-insensitive and accepts asterisk (*) for partial matches. For example, making IP ban for value "83.*" will ban all IP addresses beginning with "83.".',
),
error_messages={
"max_length": pgettext_lazy(
"admin ban form", "Banned value can't be longer than 250 characters."
)
},
)
user_message = forms.CharField(
label=pgettext_lazy("admin ban form", "User message"),
required=False,
max_length=1000,
help_text=pgettext_lazy(
"admin ban form",
"Optional message displayed to user instead of default one.",
),
widget=forms.Textarea(attrs={"rows": 3}),
error_messages={
"max_length": pgettext_lazy(
"admin ban form", "Message can't be longer than 1000 characters."
)
},
)
staff_message = forms.CharField(
label=pgettext_lazy("admin ban form", "Team message"),
required=False,
max_length=1000,
help_text=pgettext_lazy(
"admin ban form", "Optional ban message for moderators and administrators."
),
widget=forms.Textarea(attrs={"rows": 3}),
error_messages={
"max_length": pgettext_lazy(
"admin ban form", "Message can't be longer than 1000 characters."
)
},
)
expires_on = IsoDateTimeField(
label=pgettext_lazy("admin ban form", "Expiration date"),
required=False,
)
class Meta:
model = Ban
fields = [
"check_type",
"registration_only",
"banned_value",
"user_message",
"staff_message",
"expires_on",
]
def clean_banned_value(self):
data = self.cleaned_data["banned_value"]
while "**" in data:
data = data.replace("**", "*")
if data == "*":
raise forms.ValidationError(
pgettext("admin ban form", "Banned value is too vague.")
)
return data
class FilterBansForm(forms.Form):
check_type = forms.ChoiceField(
label=pgettext_lazy("admin bans filter form", "Type"),
required=False,
choices=[
("", pgettext_lazy("admin bans type filter choice", "All bans")),
("names", pgettext_lazy("admin bans type filter choice", "Usernames")),
("emails", pgettext_lazy("admin bans filter form", "E-mails")),
("ips", pgettext_lazy("admin bans type filter choice", "IPs")),
],
)
value = forms.CharField(
label=pgettext_lazy("admin bans filter form", "Banned value begins with"),
required=False,
)
registration_only = forms.ChoiceField(
label=pgettext_lazy("admin bans filter form", "Registration only"),
required=False,
choices=[
("", pgettext_lazy("admin bans registration filter choice", "Any")),
("only", pgettext_lazy("admin bans registration filter choice", "Yes")),
("exclude", pgettext_lazy("admin bans registration filter choice", "No")),
],
)
state = forms.ChoiceField(
label=pgettext_lazy("admin bans filter form", "State"),
required=False,
choices=[
("", pgettext_lazy("admin bans state filter choice", "Any")),
("used", pgettext_lazy("admin bans state filter choice", "Active")),
("unused", pgettext_lazy("admin bans state filter choice", "Expired")),
],
)
def filter_queryset(self, criteria, queryset):
if criteria.get("check_type") == "names":
queryset = queryset.filter(check_type=0)
if criteria.get("check_type") == "emails":
queryset = queryset.filter(check_type=1)
if criteria.get("check_type") == "ips":
queryset = queryset.filter(check_type=2)
if criteria.get("value"):
queryset = queryset.filter(
banned_value__startswith=criteria.get("value").lower()
)
if criteria.get("state") == "used":
queryset = queryset.filter(is_checked=True)
if criteria.get("state") == "unused":
queryset = queryset.filter(is_checked=False)
if criteria.get("registration_only") == "only":
queryset = queryset.filter(registration_only=True)
if criteria.get("registration_only") == "exclude":
queryset = queryset.filter(registration_only=False)
return queryset
| 5,644
|
Python
|
.py
| 137
| 31.708029
| 242
| 0.598943
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,535
|
ranks.py
|
rafalp_Misago/misago/users/admin/forms/ranks.py
|
from django import forms
from django.contrib.auth import get_user_model
from django.utils.translation import pgettext, pgettext_lazy
from ....acl.models import Role
from ....admin.forms import YesNoSwitch
from ....core.validators import validate_sluggable
from ...models import Rank
User = get_user_model()
class RankForm(forms.ModelForm):
name = forms.CharField(
label=pgettext_lazy("admin rank form", "Name"),
validators=[validate_sluggable()],
help_text=pgettext_lazy(
"admin rank form",
'Short and descriptive name of all users with this rank. "The Team" or "Game Masters" are good examples.',
),
)
title = forms.CharField(
label=pgettext_lazy("admin rank form", "User title"),
required=False,
help_text=pgettext_lazy(
"admin rank form",
'Optional, singular version of rank name displayed by user names. For example "GM" or "Dev".',
),
)
description = forms.CharField(
label=pgettext_lazy("admin rank form", "Description"),
max_length=2048,
required=False,
widget=forms.Textarea(attrs={"rows": 3}),
help_text=pgettext_lazy(
"admin rank form",
"Optional description explaining function or status of members distincted with this rank.",
),
)
roles = forms.ModelMultipleChoiceField(
label=pgettext_lazy("admin rank form", "User roles"),
widget=forms.CheckboxSelectMultiple,
queryset=Role.objects.order_by("name"),
required=False,
help_text=pgettext_lazy(
"admin rank form", "Rank can give additional roles to users with it."
),
)
css_class = forms.CharField(
label=pgettext_lazy("admin rank form", "CSS class"),
required=False,
help_text=pgettext_lazy(
"admin rank form",
"Optional css class added to content belonging to this rank owner.",
),
)
is_tab = YesNoSwitch(
label=pgettext_lazy("admin rank form", "Give rank dedicated tab on users list"),
required=False,
help_text=pgettext_lazy(
"admin rank form",
"Selecting this option will make users with this rank easily discoverable by others through dedicated page on forum users list.",
),
)
class Meta:
model = Rank
fields = ["name", "description", "css_class", "title", "roles", "is_tab"]
def clean_name(self):
data = self.cleaned_data["name"]
self.instance.set_name(data)
unique_qs = Rank.objects.filter(slug=self.instance.slug)
if self.instance.pk:
unique_qs = unique_qs.exclude(pk=self.instance.pk)
if unique_qs.exists():
raise forms.ValidationError(
pgettext(
"admin rank form",
"There's already an other rank with this name.",
)
)
return data
| 2,996
|
Python
|
.py
| 77
| 30.207792
| 141
| 0.621306
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,536
|
datadownloads.py
|
rafalp_Misago/misago/users/admin/forms/datadownloads.py
|
from django import forms
from django.contrib.auth import get_user_model
from django.db.models import Q
from django.utils.translation import pgettext, pgettext_lazy
from ...models import DataDownload
from ...utils import hash_email
User = get_user_model()
class RequestDataDownloadsForm(forms.Form):
user_identifiers = forms.CharField(
label=pgettext_lazy("admin data download request form", "Usernames or emails"),
help_text=pgettext_lazy(
"admin data download request form",
"Enter every item in new line. Duplicates will be ignored. This field is case insensitive. Depending on site configuration and amount of data to archive it may take up to few days for requests to complete. E-mail will notification will be sent to every user once their download is ready.",
),
widget=forms.Textarea,
)
def clean_user_identifiers(self):
user_identifiers = self.cleaned_data["user_identifiers"].lower().splitlines()
user_identifiers = list(filter(bool, user_identifiers))
user_identifiers = list(set(user_identifiers))
if len(user_identifiers) > 20:
raise forms.ValidationError(
pgettext(
"admin data download request form",
"You may not enter more than 20 items at a single time (You have entered %(show_value)s).",
)
% {"show_value": len(user_identifiers)}
)
return user_identifiers
def clean(self):
data = super().clean()
if data.get("user_identifiers"):
username_match = Q(slug__in=data["user_identifiers"])
email_match = Q(email_hash__in=map(hash_email, data["user_identifiers"]))
data["users"] = list(User.objects.filter(username_match | email_match))
if len(data["users"]) != len(data["user_identifiers"]):
raise forms.ValidationError(
pgettext(
"admin data download request form",
"One or more specified users could not be found.",
)
)
return data
class FilterDataDownloadsForm(forms.Form):
status = forms.ChoiceField(
label=pgettext_lazy("admin data download requests filter form", "Status"),
required=False,
choices=DataDownload.STATUS_CHOICES,
)
user = forms.CharField(
label=pgettext_lazy("admin data download requests filter form", "User"),
required=False,
)
requested_by = forms.CharField(
label=pgettext_lazy("admin data download requests filter form", "Requested by"),
required=False,
)
def filter_queryset(self, criteria, queryset):
if criteria.get("status") is not None:
queryset = queryset.filter(status=criteria["status"])
if criteria.get("user"):
queryset = queryset.filter(user__slug__istartswith=criteria["user"])
if criteria.get("requested_by"):
queryset = queryset.filter(
requester__slug__istartswith=criteria["requested_by"]
)
return queryset
| 3,174
|
Python
|
.py
| 67
| 37.208955
| 301
| 0.636776
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,537
|
conftest.py
|
rafalp_Misago/misago/users/admin/tests/conftest.py
|
import pytest
from django.urls import reverse
@pytest.fixture
def users_admin_link(admin_client):
response = admin_client.get(reverse("misago:admin:users:index"))
return response["location"]
| 201
|
Python
|
.py
| 6
| 30.833333
| 68
| 0.787565
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,538
|
test_searching_users.py
|
rafalp_Misago/misago/users/admin/tests/test_searching_users.py
|
import pytest
from ....acl.models import Role
from ....test import assert_contains, assert_not_contains
from ...models import Rank
from ...test import create_test_user
@pytest.fixture
def user_a(db):
return create_test_user("Tyrael", "test123@test.org")
@pytest.fixture
def user_b(db):
return create_test_user("Tyrion", "test321@gmail.com")
@pytest.fixture
def user_c(db):
return create_test_user("Karen", "other432@gmail.com")
def test_search_finds_user_by_username(admin_client, users_admin_link, user_a):
response = admin_client.get(f"{users_admin_link}&username=Tyrael")
assert_contains(response, user_a.username)
def test_search_finds_user_by_username_with_underscore(
admin_client, users_admin_link, other_user
):
response = admin_client.get(f"{users_admin_link}&username=other_user")
assert_contains(response, other_user.username)
def test_search_excludes_users_with_different_username(
admin_client, users_admin_link, user_b, user_c
):
response = admin_client.get(f"{users_admin_link}&username=Tyrael")
assert_not_contains(response, user_b.username)
assert_not_contains(response, user_c.username)
def test_search_finds_users_by_username_start(
admin_client, users_admin_link, user_a, user_b
):
response = admin_client.get(f"{users_admin_link}&username=Tyr*")
assert_contains(response, user_a.username)
assert_contains(response, user_b.username)
def test_search_finds_user_username_with_underscore_by_username_start(
admin_client, users_admin_link, other_user
):
response = admin_client.get(f"{users_admin_link}&username=other_*")
assert_contains(response, other_user.username)
def test_search_by_username_start_excludes_users_with_different_username(
admin_client, users_admin_link, user_c
):
response = admin_client.get(f"{users_admin_link}&username=Tyr*")
assert_not_contains(response, user_c.username)
def test_search_finds_user_by_username_end(admin_client, users_admin_link, user_a):
response = admin_client.get(f"{users_admin_link}&username=*ael")
assert_contains(response, user_a.username)
def test_search_by_username_end_excludes_users_with_different_username(
admin_client, users_admin_link, user_b, user_c
):
response = admin_client.get(f"{users_admin_link}&username=*ael")
assert_not_contains(response, user_b.username)
assert_not_contains(response, user_c.username)
def test_search_finds_users_by_username_content(
admin_client, users_admin_link, user_a, user_b
):
response = admin_client.get(f"{users_admin_link}&username=*yr*")
assert_contains(response, user_a.username)
assert_contains(response, user_b.username)
def test_search_by_username_content_excludes_users_with_different_username(
admin_client, users_admin_link, user_c
):
response = admin_client.get(f"{users_admin_link}&username=*yr*")
assert_not_contains(response, user_c.username)
def test_search_finds_user_by_email(admin_client, users_admin_link, user_a):
response = admin_client.get(f"{users_admin_link}&email=test123@test.org")
assert_contains(response, user_a.email)
def test_search_excludes_users_with_different_email(
admin_client, users_admin_link, user_b, user_c
):
response = admin_client.get(f"{users_admin_link}&email=test123@test.org")
assert_not_contains(response, user_b.email)
assert_not_contains(response, user_c.email)
def test_search_finds_users_by_email_start(
admin_client, users_admin_link, user_a, user_b
):
response = admin_client.get(f"{users_admin_link}&email=test*")
assert_contains(response, user_a.email)
assert_contains(response, user_b.email)
def test_search_by_email_start_excludes_users_with_different_email(
admin_client, users_admin_link, user_c
):
response = admin_client.get(f"{users_admin_link}&email=test*")
assert_not_contains(response, user_c.email)
def test_search_finds_user_by_email_end(admin_client, users_admin_link, user_a):
response = admin_client.get(f"{users_admin_link}&email=*org")
assert_contains(response, user_a.email)
def test_search_by_email_end_excludes_users_with_different_email(
admin_client, users_admin_link, user_b, user_c
):
response = admin_client.get(f"{users_admin_link}&email=*org")
assert_not_contains(response, user_b.email)
assert_not_contains(response, user_c.email)
def test_search_finds_users_by_email_content(
admin_client, users_admin_link, user_b, user_c
):
response = admin_client.get(f"{users_admin_link}&email=*@gmail*")
assert_contains(response, user_b.email)
assert_contains(response, user_c.email)
def test_search_by_email_content_excludes_users_with_different_email(
admin_client, users_admin_link, user_a
):
response = admin_client.get(f"{users_admin_link}&email=*@gmail*")
assert_not_contains(response, user_a.email)
def test_search_finds_user_with_main_group(
admin_client, users_admin_link, other_user, members_group
):
response = admin_client.get(f"{users_admin_link}&main_group={members_group.id}")
assert_contains(response, other_user.username)
def test_staff_users_search_excludes_user_without_main_group(
admin_client, users_admin_link, other_user, moderators_group
):
response = admin_client.get(f"{users_admin_link}&main_group={moderators_group.id}")
assert_not_contains(response, other_user.username)
def test_search_finds_user_with_group(
admin_client, users_admin_link, other_user, moderators_group, members_group
):
other_user.set_groups(members_group, [moderators_group])
other_user.save()
response = admin_client.get(f"{users_admin_link}&group={moderators_group.id}")
assert_contains(response, other_user.username)
def test_staff_users_search_excludes_user_without_group(
admin_client, users_admin_link, other_user, moderators_group
):
response = admin_client.get(f"{users_admin_link}&group={moderators_group.id}")
assert_not_contains(response, other_user.username)
@pytest.fixture
def rank(db):
return Rank.objects.create(name="Test Rank")
def test_search_finds_user_with_rank(admin_client, users_admin_link, rank):
user = create_test_user("UserWithRank", "rank@example.org", rank=rank)
response = admin_client.get(f"{users_admin_link}&rank={rank.pk}")
assert_contains(response, user.username)
def test_staff_users_search_excludes_user_without_rank(
admin_client, users_admin_link, rank
):
user = create_test_user("RegularUser", "regular@example.org")
response = admin_client.get(f"{users_admin_link}&rank={rank.pk}")
assert_not_contains(response, user.username)
@pytest.fixture
def role(db):
return Role.objects.create(name="Test Role")
def test_search_finds_user_with_role(admin_client, users_admin_link, role):
user = create_test_user("UserWithRole", "role@example.org")
user.roles.add(role)
response = admin_client.get(f"{users_admin_link}&role={role.pk}")
assert_contains(response, user.username)
def test_staff_users_search_excludes_user_without_role(
admin_client, users_admin_link, role
):
user = create_test_user("RegularUser", "regular@example.org")
response = admin_client.get(f"{users_admin_link}&role={role.pk}")
assert_not_contains(response, user.username)
def test_search_finds_inactive_user(admin_client, users_admin_link):
user = create_test_user(
"InactiveUser", "inactive@example.org", requires_activation=1
)
response = admin_client.get(f"{users_admin_link}&is_inactive=1")
assert_contains(response, user.username)
def test_inactive_users_search_excludes_activated_users(admin_client, users_admin_link):
user = create_test_user(
"ActivatedUser", "activated@example.org", requires_activation=0
)
response = admin_client.get(f"{users_admin_link}&is_inactive=1")
assert_not_contains(response, user.username)
def test_search_finds_deactivated_user(admin_client, users_admin_link):
user = create_test_user("DisabledUser", "disabled@example.org", is_active=False)
response = admin_client.get(f"{users_admin_link}&is_deactivated=1")
assert_contains(response, user.username)
def test_deactivated_users_search_excludes_active_users(admin_client, users_admin_link):
user = create_test_user("ActiveUser", "active@example.org", is_active=True)
response = admin_client.get(f"{users_admin_link}&is_deactivated=1")
assert_not_contains(response, user.username)
def test_search_finds_root_admin_user(admin_client, users_admin_link, root_admin):
response = admin_client.get(f"{users_admin_link}&is_admin=1")
assert_contains(response, root_admin.username)
def test_search_finds_admin_user(admin_client, users_admin_link, other_admin):
response = admin_client.get(f"{users_admin_link}&is_admin=1")
assert_contains(response, other_admin.username)
def test_search_finds_secondary_admin_user(
admin_client, users_admin_link, secondary_admin
):
response = admin_client.get(f"{users_admin_link}&is_admin=1")
assert_contains(response, secondary_admin.username)
def test_admin_users_search_excludes_non_admin_users(
admin_client, users_admin_link, other_user
):
response = admin_client.get(f"{users_admin_link}&is_admin=1")
assert_not_contains(response, other_user.username)
def test_search_finds_user_deleting_account(admin_client, users_admin_link):
user = create_test_user(
"DeletingUser", "deleting@example.org", is_deleting_account=True
)
response = admin_client.get(f"{users_admin_link}&is_deleting_account=1")
assert_contains(response, user.username)
def test_staff_users_search_excludes_non_deleting_users(admin_client, users_admin_link):
user = create_test_user(
"RegularUser", "regular@example.org", is_deleting_account=False
)
response = admin_client.get(f"{users_admin_link}&is_deleting_account=1")
assert_not_contains(response, user.username)
| 9,950
|
Python
|
.py
| 201
| 45.452736
| 88
| 0.745861
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,539
|
test_bans.py
|
rafalp_Misago/misago/users/admin/tests/test_bans.py
|
from datetime import timedelta
import pytest
from django.urls import reverse
from django.utils import timezone
from ....cache.test import assert_invalidates_cache
from ....test import assert_contains
from ... import BANS_CACHE
from ...models import Ban
@pytest.fixture
def admin_link(admin_client):
response = admin_client.get(reverse("misago:admin:users:bans:index"))
return response["location"]
@pytest.fixture
def ban(db):
return Ban.objects.create(banned_value="banned_username")
def test_link_is_registered_in_admin_nav(admin_client):
response = admin_client.get(reverse("misago:admin:users:index"))
response = admin_client.get(response["location"])
assert_contains(response, reverse("misago:admin:users:bans:index"))
def test_list_renders_empty(admin_client, admin_link):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_list_renders_with_item(admin_client, admin_link, ban):
response = admin_client.get(admin_link)
assert_contains(response, ban.banned_value)
def test_bans_can_be_mass_deleted(admin_client, admin_link):
bans_ids = [Ban.objects.create(banned_value="ban_%s" % i).id for i in range(10)]
admin_client.post(admin_link, data={"action": "delete", "selected_items": bans_ids})
assert Ban.objects.count() == 0
def test_mass_deleting_bans_invalidates_bans_cache(admin_client, admin_link, ban):
with assert_invalidates_cache(BANS_CACHE):
admin_client.post(
admin_link, data={"action": "delete", "selected_items": [ban.id]}
)
def test_ban_can_be_deleted(admin_client, ban):
admin_client.post(reverse("misago:admin:users:bans:delete", kwargs={"pk": ban.pk}))
with pytest.raises(Ban.DoesNotExist):
ban.refresh_from_db()
def test_deleting_ban_invalidates_bans_cache(admin_client, ban):
with assert_invalidates_cache(BANS_CACHE):
admin_client.post(
reverse("misago:admin:users:bans:delete", kwargs={"pk": ban.pk})
)
def test_new_ban_form_renders(admin_client):
response = admin_client.get(reverse("misago:admin:users:bans:new"))
assert response.status_code == 200
def test_new_ban_can_be_created(admin_client):
test_date = timezone.now() + timedelta(days=180)
response = admin_client.post(
reverse("misago:admin:users:bans:new"),
data={
"check_type": Ban.EMAIL,
"banned_value": "test@test.com",
"user_message": "Lorem ipsum dolor met",
"staff_message": "Sit amet elit",
"expires_on": test_date.isoformat(),
},
)
ban = Ban.objects.get()
assert ban.check_type == Ban.EMAIL
assert ban.banned_value == "test@test.com"
assert ban.user_message == "Lorem ipsum dolor met"
assert ban.staff_message == "Sit amet elit"
assert ban.expires_on.isoformat() == test_date.isoformat()
def test_new_ban_creation_invalidates_bans_cache(admin_client):
with assert_invalidates_cache(BANS_CACHE):
admin_client.post(
reverse("misago:admin:users:bans:new"),
data={"check_type": Ban.EMAIL, "banned_value": "test@test.com"},
)
def test_edit_ban_form_renders(admin_client, ban):
response = admin_client.get(
reverse("misago:admin:users:bans:edit", kwargs={"pk": ban.pk})
)
assert response.status_code == 200
def test_ban_can_be_edited(admin_client, ban):
test_date = timezone.now() + timedelta(days=180)
response = admin_client.post(
reverse("misago:admin:users:bans:edit", kwargs={"pk": ban.pk}),
data={
"check_type": Ban.EMAIL,
"banned_value": "test@test.com",
"user_message": "Lorem ipsum dolor met",
"staff_message": "Sit amet elit",
"expires_on": test_date.isoformat(),
},
)
ban.refresh_from_db()
assert ban.check_type == Ban.EMAIL
assert ban.banned_value == "test@test.com"
assert ban.user_message == "Lorem ipsum dolor met"
assert ban.staff_message == "Sit amet elit"
assert ban.expires_on.isoformat() == test_date.isoformat()
def test_ban_edition_invalidates_bans_cache(admin_client, ban):
with assert_invalidates_cache(BANS_CACHE):
admin_client.post(
reverse("misago:admin:users:bans:edit", kwargs={"pk": ban.pk}),
data={"check_type": Ban.EMAIL, "banned_value": "test@test.com"},
)
| 4,434
|
Python
|
.py
| 99
| 38.464646
| 88
| 0.67621
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,540
|
test_deleting_user_with_content.py
|
rafalp_Misago/misago/users/admin/tests/test_deleting_user_with_content.py
|
import pytest
from django.contrib.auth import get_user_model
from ...models import DeletedUser
from ..tasks import delete_user_with_content
User = get_user_model()
def test_task_does_nothing_for_nonexisting_user_id(db):
delete_user_with_content(1)
def test_task_does_nothing_for_staff_id(staffuser):
delete_user_with_content(staffuser.id)
staffuser.refresh_from_db()
def test_task_does_nothing_for_admin_id(admin):
delete_user_with_content(admin.id)
admin.refresh_from_db()
def test_task_deletes_user(user):
delete_user_with_content(user.id)
with pytest.raises(User.DoesNotExist):
user.refresh_from_db()
def test_task_records_user_deletion(user):
delete_user_with_content(user.id)
DeletedUser.objects.get(deleted_by=DeletedUser.DELETED_BY_STAFF)
| 802
|
Python
|
.py
| 20
| 36.3
| 68
| 0.768831
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,541
|
test_data_downloads.py
|
rafalp_Misago/misago/users/admin/tests/test_data_downloads.py
|
import os
from django.core.files import File
from django.urls import reverse
from ....admin.test import AdminTestCase
from ...datadownloads import request_user_data_download
from ...models import DataDownload
from ...test import create_test_user
APP_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
TESTFILES_DIR = os.path.join(APP_DIR, "tests", "testfiles")
TEST_FILE_PATH = os.path.join(TESTFILES_DIR, "avatar.png")
class DataDownloadAdminTests(AdminTestCase):
def test_link_registered(self):
"""admin nav contains data downloads link"""
response = self.client.get(reverse("misago:admin:users:index"))
response = self.client.get(response["location"])
self.assertContains(
response, reverse("misago:admin:users:data-downloads:index")
)
def test_list_view(self):
"""data downloads list view returns 200"""
response = self.client.get(reverse("misago:admin:users:data-downloads:index"))
self.assertEqual(response.status_code, 302)
view_url = response["location"]
response = self.client.get(view_url)
self.assertEqual(response.status_code, 200)
request_user_data_download(self.user)
response = self.client.get(view_url)
self.assertEqual(response.status_code, 200)
def test_expire_action(self):
"""expire action marks data download as expired and deletes its file"""
data_download = request_user_data_download(self.user)
with open(TEST_FILE_PATH, "rb") as upload:
data_download.file = File(upload)
data_download.save()
self.assertIsNotNone(data_download.file)
self.assertTrue(os.path.isfile(data_download.file.path))
response = self.client.post(
reverse("misago:admin:users:data-downloads:index"),
data={"action": "expire", "selected_items": [data_download.pk]},
)
self.assertEqual(response.status_code, 302)
updated_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_download.status, DataDownload.STATUS_EXPIRED)
self.assertFalse(updated_download.file)
self.assertFalse(os.path.isfile(data_download.file.path))
def test_delete_action(self):
"""dele action deletes data download together with its file"""
data_download = request_user_data_download(self.user)
with open(TEST_FILE_PATH, "rb") as upload:
data_download.file = File(upload)
data_download.save()
self.assertIsNotNone(data_download.file)
self.assertTrue(os.path.isfile(data_download.file.path))
response = self.client.post(
reverse("misago:admin:users:data-downloads:index"),
data={"action": "delete", "selected_items": [data_download.pk]},
)
self.assertEqual(response.status_code, 302)
self.assertEqual(DataDownload.objects.count(), 0)
self.assertFalse(os.path.isfile(data_download.file.path))
def test_request_view(self):
"""request data downloads view initializes new downloads"""
response = self.client.get(reverse("misago:admin:users:data-downloads:request"))
self.assertEqual(response.status_code, 200)
other_user = create_test_user("Other_User", "otheruser@example.com")
response = self.client.post(
reverse("misago:admin:users:data-downloads:request"),
data={
"user_identifiers": "\n".join([self.user.username, other_user.email])
},
)
self.assertEqual(response.status_code, 302)
self.assertEqual(DataDownload.objects.count(), 2)
def test_request_view_empty_data(self):
"""request data downloads view handles empty data"""
response = self.client.get(reverse("misago:admin:users:data-downloads:request"))
self.assertEqual(response.status_code, 200)
response = self.client.post(
reverse("misago:admin:users:data-downloads:request"),
data={"user_identifiers": ""},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(DataDownload.objects.count(), 0)
def test_request_view_user_not_found(self):
"""request data downloads view handles empty data"""
response = self.client.get(reverse("misago:admin:users:data-downloads:request"))
self.assertEqual(response.status_code, 200)
response = self.client.post(
reverse("misago:admin:users:data-downloads:request"),
data={"user_identifiers": "not@found.com"},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(DataDownload.objects.count(), 0)
| 4,762
|
Python
|
.py
| 93
| 42.344086
| 88
| 0.673566
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,542
|
test_ranks.py
|
rafalp_Misago/misago/users/admin/tests/test_ranks.py
|
from django.urls import reverse
from ....acl import ACL_CACHE
from ....acl.models import Role
from ....admin.test import AdminTestCase
from ....cache.test import assert_invalidates_cache
from ...models import Rank
class RankAdminTests(AdminTestCase):
def test_link_registered(self):
"""admin nav contains ranks link"""
response = self.client.get(reverse("misago:admin:users:index"))
response = self.client.get(response["location"])
self.assertContains(response, reverse("misago:admin:ranks:index"))
def test_list_view(self):
"""ranks list view returns 200"""
response = self.client.get(reverse("misago:admin:ranks:index"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Team")
def test_new_view(self):
"""new rank view has no showstoppers"""
test_role_a = Role.objects.create(name="Test Role A")
test_role_b = Role.objects.create(name="Test Role B")
test_role_c = Role.objects.create(name="Test Role C")
response = self.client.get(reverse("misago:admin:ranks:new"))
self.assertEqual(response.status_code, 200)
response = self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test Rank",
"description": "Lorem ipsum dolor met",
"title": "Test Title",
"style": "test",
"is_tab": "1",
"roles": [test_role_a.pk, test_role_c.pk],
},
)
self.assertEqual(response.status_code, 302)
response = self.client.get(reverse("misago:admin:ranks:index"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Test Rank")
self.assertContains(response, "Test Title")
test_rank = Rank.objects.get(slug="test-rank")
self.assertIn(test_role_a, test_rank.roles.all())
self.assertIn(test_role_c, test_rank.roles.all())
self.assertTrue(test_role_b not in test_rank.roles.all())
def test_edit_view(self):
"""edit rank view has no showstoppers"""
test_role_a = Role.objects.create(name="Test Role A")
test_role_b = Role.objects.create(name="Test Role B")
test_role_c = Role.objects.create(name="Test Role C")
self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test Rank",
"description": "Lorem ipsum dolor met",
"title": "Test Title",
"style": "test",
"is_tab": "1",
"roles": [test_role_a.pk, test_role_c.pk],
},
)
test_rank = Rank.objects.get(slug="test-rank")
response = self.client.get(
reverse("misago:admin:ranks:edit", kwargs={"pk": test_rank.pk})
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, test_rank.name)
self.assertContains(response, test_rank.title)
response = self.client.post(
reverse("misago:admin:ranks:edit", kwargs={"pk": test_rank.pk}),
data={"name": "Top Lel", "roles": [test_role_b.pk]},
)
self.assertEqual(response.status_code, 302)
test_rank = Rank.objects.get(slug="top-lel")
response = self.client.get(reverse("misago:admin:ranks:index"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, test_rank.name)
self.assertTrue("Test Rank" not in test_rank.roles.all())
self.assertTrue("Test Title" not in test_rank.roles.all())
self.assertIn(test_role_b, test_rank.roles.all())
self.assertTrue(test_role_a not in test_rank.roles.all())
self.assertTrue(test_role_c not in test_rank.roles.all())
def test_editing_rank_invalidates_acl_cache(self):
self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test Rank",
"description": "Lorem ipsum dolor met",
"title": "Test Title",
"style": "test",
"is_tab": "1",
},
)
test_rank = Rank.objects.get(slug="test-rank")
test_role_b = Role.objects.create(name="Test Role B")
with assert_invalidates_cache(ACL_CACHE):
self.client.post(
reverse("misago:admin:ranks:edit", kwargs={"pk": test_rank.pk}),
data={"name": "Top Lel", "roles": [test_role_b.pk]},
)
def test_default_view(self):
"""default rank view has no showstoppers"""
self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test Rank",
"description": "Lorem ipsum dolor met",
"title": "Test Title",
"style": "test",
"is_tab": "1",
},
)
test_rank = Rank.objects.get(slug="test-rank")
response = self.client.post(
reverse("misago:admin:ranks:default", kwargs={"pk": test_rank.pk})
)
self.assertEqual(response.status_code, 302)
test_rank = Rank.objects.get(slug="test-rank")
self.assertTrue(test_rank.is_default)
def test_move_up_view(self):
"""move rank up view has no showstoppers"""
self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test Rank",
"description": "Lorem ipsum dolor met",
"title": "Test Title",
"style": "test",
"is_tab": "1",
},
)
test_rank = Rank.objects.get(slug="test-rank")
response = self.client.post(
reverse("misago:admin:ranks:up", kwargs={"pk": test_rank.pk})
)
self.assertEqual(response.status_code, 302)
changed_rank = Rank.objects.get(slug="test-rank")
self.assertEqual(changed_rank.order + 1, test_rank.order)
def test_move_down_view(self):
"""move rank down view has no showstoppers"""
self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test Rank",
"description": "Lorem ipsum dolor met",
"title": "Test Title",
"style": "test",
"is_tab": "1",
},
)
test_rank = Rank.objects.get(slug="test-rank")
# Move rank up
response = self.client.post(
reverse("misago:admin:ranks:up", kwargs={"pk": test_rank.pk})
)
response = self.client.post(
reverse("misago:admin:ranks:down", kwargs={"pk": test_rank.pk})
)
self.assertEqual(response.status_code, 302)
# Test move down
changed_rank = Rank.objects.get(slug="test-rank")
self.assertEqual(changed_rank.order, test_rank.order)
def test_users_view(self):
"""users with this rank view has no showstoppers"""
self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test Rank",
"description": "Lorem ipsum dolor met",
"title": "Test Title",
"style": "test",
"is_tab": "1",
},
)
test_rank = Rank.objects.get(slug="test-rank")
response = self.client.get(
reverse("misago:admin:ranks:users", kwargs={"pk": test_rank.pk})
)
self.assertEqual(response.status_code, 302)
def test_delete_view(self):
"""delete rank view has no showstoppers"""
self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test Rank",
"description": "Lorem ipsum dolor met",
"title": "Test Title",
"style": "test",
"is_tab": "1",
},
)
test_rank = Rank.objects.get(slug="test-rank")
response = self.client.post(
reverse("misago:admin:ranks:delete", kwargs={"pk": test_rank.pk})
)
self.assertEqual(response.status_code, 302)
self.client.get(reverse("misago:admin:ranks:index"))
response = self.client.get(reverse("misago:admin:ranks:index"))
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, test_rank.name)
self.assertNotContains(response, test_rank.title)
def test_deleting_rank_invalidates_acl_cache(self):
self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test Rank",
"description": "Lorem ipsum dolor met",
"title": "Test Title",
"style": "test",
"is_tab": "1",
},
)
test_rank = Rank.objects.get(slug="test-rank")
with assert_invalidates_cache(ACL_CACHE):
self.client.post(
reverse("misago:admin:ranks:delete", kwargs={"pk": test_rank.pk})
)
def test_uniquess(self):
"""rank slug uniqueness is enforced by admin forms"""
test_role_a = Role.objects.create(name="Test Role A")
response = self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Members",
"description": "Colliding rank",
"title": "Test Title",
"style": "test",
"is_tab": "1",
"roles": [test_role_a.pk],
},
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "already an other rank with this name.")
self.client.post(
reverse("misago:admin:ranks:new"),
data={
"name": "Test rank",
"description": "Colliding rank",
"title": "Test Title",
"style": "test",
"is_tab": "1",
"roles": [test_role_a.pk],
},
)
test_rank = Rank.objects.get(slug="test-rank")
response = self.client.post(
reverse("misago:admin:ranks:edit", kwargs={"pk": test_rank.pk}),
data={"name": "Members", "roles": [test_role_a.pk]},
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "already an other rank with this name.")
| 10,542
|
Python
|
.py
| 250
| 30.628
| 81
| 0.55268
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,543
|
test_users_mass_actions.py
|
rafalp_Misago/misago/users/admin/tests/test_users_mass_actions.py
|
from unittest.mock import call
import pytest
from django.contrib.auth import get_user_model
from django.core import mail
from ... import BANS_CACHE
from ....cache.test import assert_invalidates_cache
from ....test import assert_contains, assert_has_error_message, assert_not_contains
from ...datadownloads import request_user_data_download
from ...enums import DefaultGroupId
from ...models import Ban, DataDownload, DeletedUser
from ...test import create_test_user
User = get_user_model()
def create_multiple_users(**kwargs):
return [
create_test_user("User%s" % i, "user%s@gmail.com" % i, **kwargs)
for i in range(5)
]
def get_multiple_users_ids(**kwargs):
users = create_multiple_users(**kwargs)
return [u.id for u in users]
@pytest.fixture
def users_ids(db):
return get_multiple_users_ids()
def test_multiple_users_can_be_activated_with_mass_action(
admin_client, users_admin_link
):
users = create_multiple_users(requires_activation=1)
admin_client.post(
users_admin_link,
data={"action": "activate", "selected_items": [u.id for u in users]},
)
for user in users:
user.refresh_from_db()
assert not user.requires_activation
def test_activating_multiple_users_sends_email_notifications_to_them(
admin_client, users_admin_link
):
users_ids = get_multiple_users_ids(requires_activation=1)
admin_client.post(
users_admin_link, data={"action": "activate", "selected_items": users_ids}
)
assert len(mail.outbox) == len(users_ids)
assert "has been activated" in mail.outbox[0].subject
def test_ban_multiple_users_form_is_rendered(admin_client, users_admin_link):
users_ids = get_multiple_users_ids()
response = admin_client.post(
users_admin_link, data={"action": "ban", "selected_items": users_ids}
)
assert response.status_code == 200
def test_multiple_users_can_be_banned_with_mass_action(admin_client, users_admin_link):
users = create_multiple_users()
admin_client.post(
users_admin_link,
data={
"action": "ban",
"selected_items": [u.id for u in users],
"ban_type": ["usernames", "emails", "domains"],
"finalize": "",
},
)
for user in users:
Ban.objects.get(banned_value=user.username.lower())
Ban.objects.get(banned_value=user.email)
Ban.objects.get(banned_value="*%s" % user.email[-10:])
def test_option_to_ban_multiple_users_ips_is_disabled_if_user_ips_are_not_available(
admin_client, users_admin_link, users_ids
):
response = admin_client.post(
users_admin_link, data={"action": "ban", "selected_items": users_ids}
)
assert_not_contains(response, 'value="ip"')
assert_not_contains(response, 'value="ip_first"')
assert_not_contains(response, 'value="ip_two"')
def test_option_to_ban_multiple_users_ips_is_enabled_if_user_ips_are_available(
admin_client, users_admin_link
):
users_ids = get_multiple_users_ids(joined_from_ip="1.2.3.4")
response = admin_client.post(
users_admin_link, data={"action": "ban", "selected_items": users_ids}
)
assert_contains(response, 'value="ip"')
assert_contains(response, 'value="ip_first"')
assert_contains(response, 'value="ip_two"')
def test_multiple_users_ips_can_be_banned_with_mass_action(
admin_client, users_admin_link
):
users_ids = get_multiple_users_ids(joined_from_ip="1.2.3.4")
admin_client.post(
users_admin_link,
data={
"action": "ban",
"selected_items": users_ids,
"ban_type": ["ip", "ip_first", "ip_two"],
"finalize": "",
},
)
Ban.objects.get(banned_value="1.2.3.4")
Ban.objects.get(banned_value="1.*")
Ban.objects.get(banned_value="1.2.*")
def test_banning_multiple_users_with_mass_action_invalidates_bans_cache(
admin_client, users_admin_link, users_ids
):
with assert_invalidates_cache(BANS_CACHE):
admin_client.post(
users_admin_link,
data={
"action": "ban",
"selected_items": users_ids,
"ban_type": ["usernames", "emails", "domains"],
"finalize": "",
},
)
def test_data_downloads_can_be_requested_for_multiple_users_with_mass_action(
admin_client, users_admin_link
):
users = create_multiple_users()
admin_client.post(
users_admin_link,
data={
"action": "request_data_download",
"selected_items": [u.id for u in users],
},
)
for user in users:
DataDownload.objects.get(user=user)
def test_mass_action_is_not_requesting_data_downloads_for_users_with_existing_requests(
admin_client, users_admin_link
):
users = create_multiple_users()
downloads_ids = [request_user_data_download(u).id for u in users]
admin_client.post(
users_admin_link,
data={
"action": "request_data_download",
"selected_items": [u.id for u in users],
},
)
assert not DataDownload.objects.exclude(id__in=downloads_ids).exists()
def test_multiple_users_can_be_deleted_with_mass_action(admin_client, users_admin_link):
users = create_multiple_users()
admin_client.post(
users_admin_link,
data={"action": "delete_accounts", "selected_items": [u.id for u in users]},
)
for user in users:
with pytest.raises(User.DoesNotExist):
user.refresh_from_db()
def test_mass_action_records_users_deletion_by_admin(admin_client, users_admin_link):
users = create_multiple_users()
admin_client.post(
users_admin_link,
data={"action": "delete_accounts", "selected_items": [u.id for u in users]},
)
deleted_count = DeletedUser.objects.filter(
deleted_by=DeletedUser.DELETED_BY_STAFF
).count()
assert deleted_count == len(users)
def test_delete_users_mass_action_fails_if_user_tries_to_delete_themselves(
admin_client, users_admin_link, admin
):
response = admin_client.post(
users_admin_link,
data={"action": "delete_accounts", "selected_items": [admin.id]},
)
assert_has_error_message(response)
admin.refresh_from_db()
def test_delete_users_mass_action_fails_if_user_tries_to_delete_staff_members(
admin_client, users_admin_link
):
users = create_multiple_users(is_staff=True)
response = admin_client.post(
users_admin_link,
data={"action": "delete_accounts", "selected_items": [u.id for u in users]},
)
assert_has_error_message(response)
for user in users:
user.refresh_from_db()
def test_delete_users_mass_action_fails_if_user_tries_to_delete_admins(
admin_client, users_admin_link, admins_group
):
users = create_multiple_users()
for user in users:
user.set_groups(admins_group)
user.save()
response = admin_client.post(
users_admin_link,
data={"action": "delete_accounts", "selected_items": [u.id for u in users]},
)
assert_has_error_message(response)
for user in users:
user.refresh_from_db()
def test_delete_users_mass_action_fails_if_user_tries_to_delete_root_admins(
admin_client, users_admin_link
):
users = create_multiple_users(is_misago_root=True)
response = admin_client.post(
users_admin_link,
data={"action": "delete_accounts", "selected_items": [u.id for u in users]},
)
assert_has_error_message(response)
for user in users:
user.refresh_from_db()
@pytest.fixture
def mock_delete_user_with_content(mocker):
delay = mocker.Mock()
mocker.patch(
"misago.users.admin.views.users.delete_user_with_content",
mocker.Mock(delay=delay),
)
return delay
def test_multiple_users_can_be_deleted_together_with_content_by_mass_action(
admin_client, users_admin_link, users_ids, mock_delete_user_with_content
):
admin_client.post(
users_admin_link, data={"action": "delete_all", "selected_items": users_ids}
)
calls = [call(u) for u in users_ids]
mock_delete_user_with_content.assert_has_calls(calls, any_order=True)
def test_deleting_multiple_users_with_content_disables_their_accounts(
admin_client, users_admin_link, mock_delete_user_with_content
):
users = create_multiple_users()
admin_client.post(
users_admin_link,
data={"action": "delete_all", "selected_items": [u.id for u in users]},
)
for user in users:
user.refresh_from_db()
assert not user.is_active
def test_delete_users_with_content_mass_action_fails_if_user_tries_to_delete_themselves(
admin_client, users_admin_link, admin, mock_delete_user_with_content
):
response = admin_client.post(
users_admin_link,
data={"action": "delete_all", "selected_items": [admin.id]},
)
assert_has_error_message(response)
mock_delete_user_with_content.assert_not_called()
admin.refresh_from_db()
assert admin.is_active
def test_delete_users_with_content_mass_action_fails_if_user_tries_to_delete_admin(
admin_client, users_admin_link, mock_delete_user_with_content
):
users = create_multiple_users(group_id=DefaultGroupId.ADMINS)
response = admin_client.post(
users_admin_link,
data={"action": "delete_all", "selected_items": [u.id for u in users]},
)
assert_has_error_message(response)
mock_delete_user_with_content.assert_not_called()
for user in users:
user.refresh_from_db()
assert user.is_active
def test_delete_users_with_content_mass_action_fails_if_user_tries_to_delete_root_admin(
admin_client, users_admin_link, mock_delete_user_with_content
):
users = create_multiple_users(is_misago_root=True)
response = admin_client.post(
users_admin_link,
data={"action": "delete_all", "selected_items": [u.id for u in users]},
)
assert_has_error_message(response)
mock_delete_user_with_content.assert_not_called()
for user in users:
user.refresh_from_db()
assert user.is_active
def test_delete_users_with_content_mass_action_fails_if_user_tries_to_delete_staff(
admin_client, users_admin_link, mock_delete_user_with_content
):
users = create_multiple_users(is_staff=True)
response = admin_client.post(
users_admin_link,
data={"action": "delete_all", "selected_items": [u.id for u in users]},
)
assert_has_error_message(response)
mock_delete_user_with_content.assert_not_called()
for user in users:
user.refresh_from_db()
assert user.is_active
| 10,710
|
Python
|
.py
| 279
| 32.333333
| 88
| 0.6714
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,544
|
test_django_admin_auth.py
|
rafalp_Misago/misago/users/admin/tests/test_django_admin_auth.py
|
from django.test import override_settings
from django.urls import reverse
from ....admin.test import AdminTestCase
@override_settings(ROOT_URLCONF="misago.core.testproject.urls")
class DjangoAdminAuthTests(AdminTestCase):
"""assertions for Django admin auth interop with Misago User Model"""
def test_login(self):
"""its possible to sign in to django admin"""
self.logout_user()
# form renders
response = self.client.get(reverse("admin:index"))
self.assertEqual(response.status_code, 200)
# form handles login
response = self.client.post(
reverse("admin:index"),
data={"username": self.user.email, "password": self.USER_PASSWORD},
)
self.assertEqual(response.status_code, 302)
response = self.client.get(reverse("admin:index"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.user.username)
def test_logout(self):
"""its possible to sign out from django admin"""
response = self.client.post(reverse("admin:index"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.user.username)
# assert there's no showstopper on signout page
response = self.client.post(reverse("admin:logout"))
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, self.user.username)
# user was signed out
response = self.client.post(reverse("admin:index"))
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, self.user.username)
| 1,647
|
Python
|
.py
| 34
| 40.441176
| 79
| 0.689956
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,545
|
test_users.py
|
rafalp_Misago/misago/users/admin/tests/test_users.py
|
import pytest
from django.contrib.auth import get_user_model
from django.urls import reverse
from ....acl.models import Role
from ....legal.models import Agreement
from ....legal.utils import save_user_agreement_acceptance
from ....permissions.permissionsid import get_permissions_id
from ....test import assert_contains
from ...models import Rank
from ...utils import hash_email
User = get_user_model()
def test_link_is_registered_in_admin_nav(admin_client):
response = admin_client.get(reverse("misago:admin:index"))
assert_contains(response, reverse("misago:admin:users:index"))
def test_list_renders_with_item(admin_client, users_admin_link, other_user):
response = admin_client.get(users_admin_link)
assert_contains(response, other_user.username)
def test_new_user_form_renders(admin_client):
response = admin_client.get(reverse("misago:admin:users:new"))
assert response.status_code == 200
def test_new_user_can_be_created(admin_client, members_group):
default_rank = Rank.objects.get_default()
authenticated_role = Role.objects.get(special_role="authenticated")
admin_client.post(
reverse("misago:admin:users:new"),
data={
"username": "User",
"group": str(members_group.id),
"rank": str(default_rank.pk),
"roles": str(authenticated_role.pk),
"email": "user@example.com",
"new_password": "pass123",
},
)
user = User.objects.get_by_email("user@example.com")
assert user.username == "User"
assert user.group == members_group
assert user.groups_ids == [members_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
assert user.rank == default_rank
assert authenticated_role in user.roles.all()
assert user.check_password("pass123")
assert not user.is_misago_root
def test_new_user_can_be_created_with_whitespace_around_password(
admin_client, members_group
):
default_rank = Rank.objects.get_default()
authenticated_role = Role.objects.get(special_role="authenticated")
admin_client.post(
reverse("misago:admin:users:new"),
data={
"username": "User",
"group": str(members_group.id),
"rank": str(default_rank.pk),
"roles": str(authenticated_role.pk),
"email": "user@example.com",
"new_password": " pass123 ",
},
)
user = User.objects.get_by_email("user@example.com")
assert user.check_password(" pass123 ")
def test_new_user_can_be_created_with_secondary_groups(
admin_client, moderators_group, members_group, guests_group
):
default_rank = Rank.objects.get_default()
authenticated_role = Role.objects.get(special_role="authenticated")
admin_client.post(
reverse("misago:admin:users:new"),
data={
"username": "User",
"group": str(members_group.id),
"secondary_groups": [str(moderators_group.id), str(guests_group.id)],
"rank": str(default_rank.pk),
"roles": str(authenticated_role.pk),
"email": "user@example.com",
"new_password": "pass123",
},
)
user = User.objects.get_by_email("user@example.com")
assert user.username == "User"
assert user.group == members_group
assert user.groups_ids == [moderators_group.id, members_group.id, guests_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
assert user.rank == default_rank
assert authenticated_role in user.roles.all()
assert user.check_password("pass123")
assert not user.is_misago_root
def test_root_admin_can_create_user_with_admin_main_group(
root_admin_client, admins_group
):
default_rank = Rank.objects.get_default()
authenticated_role = Role.objects.get(special_role="authenticated")
root_admin_client.post(
reverse("misago:admin:users:new"),
data={
"username": "User",
"group": str(admins_group.id),
"rank": str(default_rank.pk),
"roles": str(authenticated_role.pk),
"email": "user@example.com",
"new_password": "pass123",
},
)
user = User.objects.get_by_email("user@example.com")
assert user.username == "User"
assert user.group == admins_group
assert user.groups_ids == [admins_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
assert user.rank == default_rank
assert authenticated_role in user.roles.all()
assert user.check_password("pass123")
assert not user.is_misago_root
def test_root_admin_can_create_user_with_admin_secondary_group(
root_admin_client, admins_group, members_group
):
default_rank = Rank.objects.get_default()
authenticated_role = Role.objects.get(special_role="authenticated")
root_admin_client.post(
reverse("misago:admin:users:new"),
data={
"username": "User",
"group": str(members_group.id),
"secondary_groups": [str(admins_group.id)],
"rank": str(default_rank.pk),
"roles": str(authenticated_role.pk),
"email": "user@example.com",
"new_password": "pass123",
},
)
user = User.objects.get_by_email("user@example.com")
assert user.username == "User"
assert user.group == members_group
assert user.groups_ids == [admins_group.id, members_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
assert user.rank == default_rank
assert authenticated_role in user.roles.all()
assert user.check_password("pass123")
assert not user.is_misago_root
def test_new_user_creation_fails_because_user_was_not_given_group(
admin_client,
):
default_rank = Rank.objects.get_default()
authenticated_role = Role.objects.get(special_role="authenticated")
admin_client.post(
reverse("misago:admin:users:new"),
data={
"username": "User",
"rank": str(default_rank.pk),
"roles": str(authenticated_role.pk),
"email": "user@example.com",
"new_password": "pass123",
},
)
with pytest.raises(User.DoesNotExist):
User.objects.get_by_email("user@example.com")
def test_new_user_creation_fails_because_admin_user_cant_set_admin_group(
admin_client, admins_group
):
default_rank = Rank.objects.get_default()
authenticated_role = Role.objects.get(special_role="authenticated")
response = admin_client.post(
reverse("misago:admin:users:new"),
data={
"username": "User",
"group": str(admins_group.id),
"rank": str(default_rank.pk),
"roles": str(authenticated_role.pk),
"email": "user@example.com",
"new_password": "pass123",
},
)
assert_contains(
response,
(
"You must be a root administrator to set this user's "
"main group to the Administrators."
),
)
with pytest.raises(User.DoesNotExist):
User.objects.get_by_email("user@example.com")
def test_new_user_creation_fails_because_admin_user_cant_set_secondary_admin_group(
admin_client, admins_group, members_group
):
default_rank = Rank.objects.get_default()
authenticated_role = Role.objects.get(special_role="authenticated")
response = admin_client.post(
reverse("misago:admin:users:new"),
data={
"username": "User",
"group": str(members_group.id),
"secondary_groups": [str(admins_group.id)],
"rank": str(default_rank.pk),
"roles": str(authenticated_role.pk),
"email": "user@example.com",
"new_password": "pass123",
},
)
assert_contains(
response,
(
"You must be a root administrator to add this user "
"to the Administrators group."
),
)
with pytest.raises(User.DoesNotExist):
User.objects.get_by_email("user@example.com")
def test_new_user_creation_fails_because_user_was_not_given_authenticated_role(
admin_client, members_group
):
default_rank = Rank.objects.get_default()
guest_role = Role.objects.get(special_role="anonymous")
admin_client.post(
reverse("misago:admin:users:new"),
data={
"username": "User",
"group": str(members_group.id),
"rank": str(default_rank.pk),
"roles": str(guest_role.pk),
"email": "user@example.com",
"new_password": "pass123",
},
)
with pytest.raises(User.DoesNotExist):
User.objects.get_by_email("user@example.com")
def test_edit_user_form_renders(admin_client, user):
response = admin_client.get(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk})
)
assert response.status_code == 200
def test_edit_user_form_renders_for_root_admin(root_admin_client, user):
response = root_admin_client.get(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk})
)
assert response.status_code == 200
def test_edit_admin_form_renders_for_admin_user(admin_client, other_admin):
response = admin_client.get(
reverse("misago:admin:users:edit", kwargs={"pk": other_admin.pk})
)
assert response.status_code == 200
def test_edit_admin_form_renders_for_root_admin(root_admin_client, other_admin):
response = root_admin_client.get(
reverse("misago:admin:users:edit", kwargs={"pk": other_admin.pk})
)
assert response.status_code == 200
def test_edit_root_admin_form_renders_for_admin_user(admin_client, root_admin):
response = admin_client.get(
reverse("misago:admin:users:edit", kwargs={"pk": root_admin.pk})
)
assert response.status_code == 200
def test_edit_root_admin_form_renders_for_root_admin(
root_admin_client, other_root_admin
):
response = root_admin_client.get(
reverse("misago:admin:users:edit", kwargs={"pk": other_root_admin.pk})
)
assert response.status_code == 200
def get_default_edit_form_data(user):
data = {
"username": user.username,
"group": str(user.group_id),
"secondary_groups": [
str(group_id) for group_id in user.groups_ids if group_id != user.group_id
],
"rank": str(user.rank_id),
"roles": str(user.roles.all()[0].id),
"email": user.email,
"new_password": "",
"signature": user.signature or "",
"is_signature_locked": str(user.is_signature_locked),
"is_hiding_presence": str(user.is_hiding_presence),
"limits_private_thread_invites_to": str(user.limits_private_thread_invites_to),
"signature_lock_staff_message": str(user.signature_lock_staff_message or ""),
"signature_lock_user_message": str(user.signature_lock_user_message or ""),
"subscribe_to_started_threads": str(user.subscribe_to_started_threads),
"subscribe_to_replied_threads": str(user.subscribe_to_replied_threads),
"watch_started_threads": str(user.watch_started_threads),
"watch_replied_threads": str(user.watch_replied_threads),
"watch_new_private_threads_by_followed": str(
user.watch_new_private_threads_by_followed
),
"watch_new_private_threads_by_other_users": str(
user.watch_new_private_threads_by_other_users
),
"notify_new_private_threads_by_followed": str(
user.notify_new_private_threads_by_followed
),
"notify_new_private_threads_by_other_users": str(
user.notify_new_private_threads_by_other_users
),
"is_active": "1",
}
if user.is_misago_root:
data["is_misago_root"] = "1"
return data
def test_edit_form_changes_user_username(admin_client, user):
form_data = get_default_edit_form_data(user)
form_data["username"] = "NewUsername"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert user.username == "NewUsername"
assert user.slug == "newusername"
def test_editing_user_username_creates_entry_in_username_history(admin_client, user):
form_data = get_default_edit_form_data(user)
form_data["username"] = "NewUsername"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
assert user.namechanges.exists()
def test_not_editing_user_username_doesnt_create_entry_in_username_history(
admin_client, user
):
form_data = get_default_edit_form_data(user)
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
assert not user.namechanges.exists()
def test_edit_form_changes_user_email(admin_client, user):
form_data = get_default_edit_form_data(user)
form_data["email"] = "edited@example.com"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert user.email == "edited@example.com"
assert user.email_hash == hash_email("edited@example.com")
def test_admin_can_change_own_email(admin_client, admin):
form_data = get_default_edit_form_data(admin)
form_data["email"] = "edited@example.com"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": admin.pk}), data=form_data
)
admin.refresh_from_db()
assert admin.email == "edited@example.com"
assert admin.email_hash == hash_email("edited@example.com")
def test_admin_cant_change_other_admin_email(admin_client, other_admin):
form_data = get_default_edit_form_data(other_admin)
form_data["email"] = "edited@example.com"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_admin.pk}),
data=form_data,
)
other_admin.refresh_from_db()
assert other_admin.email == "otheradmin@example.com"
assert other_admin.email_hash == hash_email("otheradmin@example.com")
def test_admin_cant_change_root_admin_email(admin_client, root_admin):
form_data = get_default_edit_form_data(root_admin)
form_data["email"] = "edited@example.com"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": root_admin.pk}), data=form_data
)
root_admin.refresh_from_db()
assert root_admin.email == "rootadmin@example.com"
assert root_admin.email_hash == hash_email("rootadmin@example.com")
def test_root_admin_can_change_admin_email(root_admin_client, admin):
form_data = get_default_edit_form_data(admin)
form_data["email"] = "edited@example.com"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": admin.pk}), data=form_data
)
admin.refresh_from_db()
assert admin.email == "edited@example.com"
assert admin.email_hash == hash_email("edited@example.com")
def test_root_admin_can_change_other_root_admin_email(
root_admin_client, other_root_admin
):
form_data = get_default_edit_form_data(other_root_admin)
form_data["email"] = "edited@example.com"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_root_admin.pk}),
data=form_data,
)
other_root_admin.refresh_from_db()
assert other_root_admin.email == "edited@example.com"
assert other_root_admin.email_hash == hash_email("edited@example.com")
def test_edit_form_doesnt_remove_current_user_password_if_new_password_is_omitted(
admin_client, user, user_password
):
form_data = get_default_edit_form_data(user)
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert user.check_password(user_password)
def test_edit_form_displays_message_for_user_with_unusable_password(
admin_client, user, user_password
):
user.set_password(None)
user.save()
response = admin_client.get(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk})
)
assert_contains(response, "alert-has-unusable-password")
def test_edit_form_doesnt_set_password_for_user_with_unusable_password_if_none_is_given(
admin_client, user, user_password
):
user.set_password(None)
user.save()
form_data = get_default_edit_form_data(user)
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert not user.has_usable_password()
def test_edit_form_sets_password_for_user_with_unusable_password(
admin_client, user, user_password
):
user.set_password(None)
user.save()
form_data = get_default_edit_form_data(user)
form_data["new_password"] = user_password
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert user.check_password(user_password)
def test_edit_form_changes_user_password(admin_client, user):
form_data = get_default_edit_form_data(user)
form_data["new_password"] = "newpassword123"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert user.check_password("newpassword123")
def test_edit_form_preserves_whitespace_in_new_user_password(admin_client, user):
form_data = get_default_edit_form_data(user)
form_data["new_password"] = " newpassword123 "
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert user.check_password(" newpassword123 ")
def test_root_admin_can_change_own_password(root_admin_client, root_admin):
form_data = get_default_edit_form_data(root_admin)
form_data["new_password"] = "newpassword123"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": root_admin.pk}), data=form_data
)
root_admin.refresh_from_db()
assert root_admin.check_password("newpassword123")
def test_root_admin_can_change_other_root_admin_password(
root_admin_client, other_root_admin
):
form_data = get_default_edit_form_data(other_root_admin)
form_data["new_password"] = "newpassword123"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_root_admin.pk}),
data=form_data,
)
other_root_admin.refresh_from_db()
assert other_root_admin.check_password("newpassword123")
def test_root_admin_can_change_admin_password(root_admin_client, admin):
form_data = get_default_edit_form_data(admin)
form_data["new_password"] = "newpassword123"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": admin.pk}), data=form_data
)
admin.refresh_from_db()
assert admin.check_password("newpassword123")
def test_admin_can_change_own_password(admin_client, admin):
form_data = get_default_edit_form_data(admin)
form_data["new_password"] = "newpassword123"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": admin.pk}), data=form_data
)
admin.refresh_from_db()
assert admin.check_password("newpassword123")
def test_admin_cant_change_root_admin_password(
admin_client, other_root_admin, user_password
):
form_data = get_default_edit_form_data(other_root_admin)
form_data["new_password"] = "newpassword123"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_root_admin.pk}),
data=form_data,
)
other_root_admin.refresh_from_db()
assert other_root_admin.check_password(user_password)
def test_admin_can_change_other_admin_password(
admin_client, other_admin, user_password
):
form_data = get_default_edit_form_data(other_admin)
form_data["new_password"] = "newpassword123"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_admin.pk}),
data=form_data,
)
other_admin.refresh_from_db()
assert other_admin.check_password(user_password)
def test_admin_editing_their_own_password_is_not_logged_out(admin_client, admin):
form_data = get_default_edit_form_data(admin)
form_data["new_password"] = "newpassword123"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": admin.pk}), data=form_data
)
user = admin_client.get("/api/auth/")
assert user.json()["id"] == admin.id
def test_root_admin_can_change_other_user_main_group_to_admin(
root_admin_client, user, admins_group
):
form_data = get_default_edit_form_data(user)
form_data["group"] = str(admins_group.id)
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert user.group_id == admins_group.id
assert user.groups_ids == [admins_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_root_admin_can_change_other_user_secondary_group_to_admin(
root_admin_client, user, admins_group, members_group
):
form_data = get_default_edit_form_data(user)
form_data["secondary_groups"] = [str(admins_group.id)]
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert user.group_id == members_group.id
assert user.groups_ids == [admins_group.id, members_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_admin_cant_change_other_user_main_group_to_admin(
admin_client, user, admins_group, members_group
):
form_data = get_default_edit_form_data(user)
form_data["group"] = str(admins_group.id)
response = admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
assert_contains(
response,
(
"You must be a root administrator "
"to change this user's main group to the Administrators"
),
)
user.refresh_from_db()
assert user.group_id == members_group.id
assert user.groups_ids == [members_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_admin_cant_change_other_user_secondary_group_to_admin(
admin_client, user, admins_group, members_group
):
form_data = get_default_edit_form_data(user)
form_data["secondary_groups"] = [str(admins_group.id)]
response = admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
assert_contains(
response,
(
"You must be a root administrator to add this user "
"to the Administrators group."
),
)
user.refresh_from_db()
assert user.group_id == members_group.id
assert user.groups_ids == [members_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_root_admin_can_change_other_user_main_group_from_admin(
root_admin_client, admin, members_group
):
form_data = get_default_edit_form_data(admin)
form_data["group"] = str(members_group.id)
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": admin.pk}), data=form_data
)
admin.refresh_from_db()
assert admin.group_id == members_group.id
assert admin.groups_ids == [members_group.id]
assert admin.permissions_id == get_permissions_id(admin.groups_ids)
def test_root_admin_can_change_other_user_secondary_group_from_admin(
root_admin_client, secondary_admin, members_group
):
form_data = get_default_edit_form_data(secondary_admin)
form_data.pop("secondary_groups")
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": secondary_admin.pk}),
data=form_data,
)
secondary_admin.refresh_from_db()
assert secondary_admin.group_id == members_group.id
assert secondary_admin.groups_ids == [members_group.id]
assert secondary_admin.permissions_id == get_permissions_id(
secondary_admin.groups_ids
)
def test_admin_cant_change_other_user_main_group_from_admin(
admin_client, other_admin, admins_group, members_group
):
form_data = get_default_edit_form_data(other_admin)
form_data["group"] = str(members_group.id)
response = admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_admin.pk}),
data=form_data,
)
assert_contains(
response,
(
"You must be a root administrator to change this user's "
"main group from the Administrators."
),
)
other_admin.refresh_from_db()
assert other_admin.group_id == admins_group.id
assert other_admin.groups_ids == [admins_group.id]
assert other_admin.permissions_id == get_permissions_id(other_admin.groups_ids)
def test_admin_cant_change_other_user_secondary_group_from_admin(
admin_client, secondary_admin, admins_group, members_group
):
form_data = get_default_edit_form_data(secondary_admin)
form_data.pop("secondary_groups")
response = admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": secondary_admin.pk}),
data=form_data,
)
assert_contains(
response,
(
"You must be a root administrator to remove this user "
"from the Administrators group."
),
)
secondary_admin.refresh_from_db()
assert secondary_admin.group_id == members_group.id
assert secondary_admin.groups_ids == [admins_group.id, members_group.id]
assert secondary_admin.permissions_id == get_permissions_id(
secondary_admin.groups_ids
)
def test_admin_can_change_other_admin_main_group(
admin_client, secondary_admin, admins_group, moderators_group
):
form_data = get_default_edit_form_data(secondary_admin)
form_data["group"] = str(moderators_group.id)
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": secondary_admin.pk}),
data=form_data,
)
secondary_admin.refresh_from_db()
assert secondary_admin.group_id == moderators_group.id
assert secondary_admin.groups_ids == [admins_group.id, moderators_group.id]
assert secondary_admin.permissions_id == get_permissions_id(
secondary_admin.groups_ids
)
def test_admin_can_add_other_admin_secondary_group(
admin_client, secondary_admin, admins_group, moderators_group, members_group
):
form_data = get_default_edit_form_data(secondary_admin)
form_data["secondary_groups"] = [str(admins_group.id), str(moderators_group.id)]
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": secondary_admin.pk}),
data=form_data,
)
secondary_admin.refresh_from_db()
assert secondary_admin.group_id == members_group.id
assert secondary_admin.groups_ids == [
admins_group.id,
moderators_group.id,
members_group.id,
]
assert secondary_admin.permissions_id == get_permissions_id(
secondary_admin.groups_ids
)
def test_admin_can_remove_other_admin_secondary_group(
admin_client, secondary_admin, admins_group, moderators_group, members_group
):
secondary_admin.set_groups(members_group, [admins_group, moderators_group])
secondary_admin.save()
form_data = get_default_edit_form_data(secondary_admin)
form_data["secondary_groups"] = [str(admins_group.id)]
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": secondary_admin.pk}),
data=form_data,
)
secondary_admin.refresh_from_db()
assert secondary_admin.group_id == members_group.id
assert secondary_admin.groups_ids == [admins_group.id, members_group.id]
assert secondary_admin.permissions_id == get_permissions_id(
secondary_admin.groups_ids
)
def test_root_admin_can_promote_other_user_to_root(root_admin_client, user):
form_data = get_default_edit_form_data(user)
form_data["is_misago_root"] = "1"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert user.is_misago_root
def test_root_admin_can_remove_other_user_root_status(
root_admin_client, other_root_admin
):
form_data = get_default_edit_form_data(other_root_admin)
form_data.pop("is_misago_root")
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_root_admin.pk}),
data=form_data,
)
other_root_admin.refresh_from_db()
assert not other_root_admin.is_misago_root
def test_root_admin_cannot_remove_their_own_root_status(root_admin_client, root_admin):
form_data = get_default_edit_form_data(root_admin)
form_data.pop("is_misago_root")
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": root_admin.pk}), data=form_data
)
root_admin.refresh_from_db()
assert root_admin.is_misago_root
def test_admin_cant_promote_other_user_to_root_status(admin_client, user):
form_data = get_default_edit_form_data(user)
form_data["is_misago_root"] = "1"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert not user.is_misago_root
def test_admin_cant_remove_other_user_root_status(admin_client, root_admin):
form_data = get_default_edit_form_data(root_admin)
form_data.pop("is_misago_root")
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": root_admin.pk}), data=form_data
)
root_admin.refresh_from_db()
assert root_admin.is_misago_root
def test_admin_can_activate_user_account(admin_client, inactive_user):
form_data = get_default_edit_form_data(inactive_user)
form_data["is_active"] = "1"
form_data["is_active_staff_message"] = "Message"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": inactive_user.pk}),
data=form_data,
)
inactive_user.refresh_from_db()
assert inactive_user.is_active
assert inactive_user.is_active_staff_message == "Message"
def test_root_admin_can_activate_admin_account(root_admin_client, admin):
admin.is_active = False
admin.is_active_staff_message = None
admin.save()
form_data = get_default_edit_form_data(admin)
form_data["is_active"] = "1"
form_data["is_active_staff_message"] = "Message"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": admin.pk}),
data=form_data,
)
admin.refresh_from_db()
assert admin.is_active
assert admin.is_active_staff_message == "Message"
def test_root_admin_can_activate_other_root_admin_account(
root_admin_client, other_root_admin
):
other_root_admin.is_active = False
other_root_admin.is_active_staff_message = None
other_root_admin.save()
form_data = get_default_edit_form_data(other_root_admin)
form_data["is_active"] = "1"
form_data["is_active_staff_message"] = "Message"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_root_admin.pk}),
data=form_data,
)
other_root_admin.refresh_from_db()
assert other_root_admin.is_active
assert other_root_admin.is_active_staff_message == "Message"
def test_admin_cant_activate_other_admin_account(admin_client, other_admin):
other_admin.is_active = False
other_admin.is_active_staff_message = None
other_admin.save()
form_data = get_default_edit_form_data(other_admin)
form_data["is_active"] = "1"
form_data["is_active_staff_message"] = "Message"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_admin.pk}),
data=form_data,
)
other_admin.refresh_from_db()
assert not other_admin.is_active
assert not other_admin.is_active_staff_message
def test_admin_cant_activate_root_admin_account(admin_client, root_admin):
root_admin.is_active = False
root_admin.is_active_staff_message = None
root_admin.save()
form_data = get_default_edit_form_data(root_admin)
form_data["is_active"] = "1"
form_data["is_active_staff_message"] = "Message"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": root_admin.pk}),
data=form_data,
)
root_admin.refresh_from_db()
assert not root_admin.is_active
assert not root_admin.is_active_staff_message
def test_admin_can_deactivate_user_account(admin_client, user):
form_data = get_default_edit_form_data(user)
form_data.pop("is_active")
form_data["is_active_staff_message"] = "Message"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}),
data=form_data,
)
user.refresh_from_db()
assert not user.is_active
assert user.is_active_staff_message == "Message"
def test_root_admin_can_deactivate_admin_account(root_admin_client, admin):
form_data = get_default_edit_form_data(admin)
form_data.pop("is_active")
form_data["is_active_staff_message"] = "Message"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": admin.pk}),
data=form_data,
)
admin.refresh_from_db()
assert not admin.is_active
assert admin.is_active_staff_message == "Message"
def test_root_admin_can_deactivate_other_root_admin_account(
root_admin_client, other_root_admin
):
form_data = get_default_edit_form_data(other_root_admin)
form_data.pop("is_active")
form_data["is_active_staff_message"] = "Message"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_root_admin.pk}),
data=form_data,
)
other_root_admin.refresh_from_db()
assert not other_root_admin.is_active
assert other_root_admin.is_active_staff_message == "Message"
def test_admin_cant_deactivate_other_admin_account(admin_client, other_admin):
form_data = get_default_edit_form_data(other_admin)
form_data.pop("is_active")
form_data["is_active_staff_message"] = "Message"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": other_admin.pk}),
data=form_data,
)
other_admin.refresh_from_db()
assert other_admin.is_active
assert not other_admin.is_active_staff_message
def test_admin_cant_deactivate_root_admin_account(admin_client, root_admin):
form_data = get_default_edit_form_data(root_admin)
form_data.pop("is_active")
form_data["is_active_staff_message"] = "Message"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": root_admin.pk}),
data=form_data,
)
root_admin.refresh_from_db()
assert root_admin.is_active
assert not root_admin.is_active_staff_message
def test_admin_cant_deactivate_own_account(admin_client, admin):
form_data = get_default_edit_form_data(admin)
form_data.pop("is_active")
form_data["is_active_staff_message"] = "Message"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": admin.pk}),
data=form_data,
)
admin.refresh_from_db()
assert admin.is_active
assert not admin.is_active_staff_message
def test_root_admin_cant_deactivate_own_account(root_admin_client, root_admin):
form_data = get_default_edit_form_data(root_admin)
form_data.pop("is_active")
form_data["is_active_staff_message"] = "Message"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": root_admin.pk}),
data=form_data,
)
root_admin.refresh_from_db()
assert root_admin.is_active
assert not root_admin.is_active_staff_message
def test_admin_cant_activate_user_deleting_their_account(admin_client, user):
user.mark_for_delete()
form_data = get_default_edit_form_data(user)
form_data["is_active"] = "1"
form_data["is_active_staff_message"] = "Message"
admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert not user.is_active
assert not user.is_active_staff_message
def test_root_admin_cant_activate_user_deleting_their_account(root_admin_client, user):
user.mark_for_delete()
form_data = get_default_edit_form_data(user)
form_data["is_active"] = "1"
form_data["is_active_staff_message"] = "Message"
root_admin_client.post(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk}), data=form_data
)
user.refresh_from_db()
assert not user.is_active
assert not user.is_active_staff_message
def test_user_agreements_are_displayed_on_edit_form(admin_client, user):
agreement = Agreement.objects.create(
type=Agreement.TYPE_TOS,
title="Test agreement!",
text="Lorem ipsum!",
is_active=True,
)
save_user_agreement_acceptance(user, agreement, commit=True)
response = admin_client.get(
reverse("misago:admin:users:edit", kwargs={"pk": user.pk})
)
assert_contains(response, agreement.title)
| 37,452
|
Python
|
.py
| 905
| 35.175691
| 88
| 0.678183
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,546
|
test_django_admin_user.py
|
rafalp_Misago/misago/users/admin/tests/test_django_admin_user.py
|
from django.contrib.auth.models import Permission
from django.test import override_settings
from django.urls import reverse
from django.utils import formats
from ....admin.test import AdminTestCase
from ...test import create_test_user
from ..djangoadmin import UserAdminModel
@override_settings(ROOT_URLCONF="misago.core.testproject.urls")
class TestDjangoAdminUserForm(AdminTestCase):
def setUp(self):
super().setUp()
self.test_user = create_test_user("Other_User", "otheruser@example.com")
self.edit_test_user_in_django_url = reverse(
"admin:misago_users_user_change", args=[self.test_user.pk]
)
self.edit_test_user_in_misago_url = reverse(
"misago:admin:users:edit", args=[self.test_user.pk]
)
def test_user_edit_view_content(self):
"""basic data about a user is present in Django admin"""
response = self.client.get(self.edit_test_user_in_django_url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.test_user.username)
self.assertContains(response, self.test_user.email)
self.assertContains(response, self.test_user.rank)
last_login_date = formats.date_format(self.test_user.last_login)
self.assertContains(response, last_login_date)
register_date = formats.date_format(self.test_user.joined_on)
self.assertContains(response, register_date)
user_permissions = Permission.objects.all()
for permission in user_permissions:
self.assertContains(response, permission)
def test_user_edit_view_post(self):
"""user permissions are editable through Django admin"""
perms_all = Permission.objects.all()
perms_all_pks = []
for perm in perms_all:
perms_all_pks.append(perm.pk)
response = self.client.post(
self.edit_test_user_in_django_url, data={"user_permissions": perms_all_pks}
)
self.assertEqual(response.status_code, 302)
user_perms = self.test_user.user_permissions.all()
for perm_pk in perms_all_pks:
is_user_has_perm = user_perms.filter(pk=perm_pk).exists()
self.assertTrue(is_user_has_perm)
def test_misago_admin_url_presence_in_user_edit_view(self):
"""the url to Misago admin is present in Django admin user edit view"""
response = self.client.get(self.edit_test_user_in_django_url)
self.assertContains(response, self.edit_test_user_in_misago_url)
edit_from_misago_short_desc = (
UserAdminModel.get_edit_from_misago_url.short_description
)
self.assertContains(response, edit_from_misago_short_desc)
def test_misago_admin_url_presence_in_user_list_view(self):
"""the url to Misago admin is present in Django admin user list view"""
response = self.client.get(reverse("admin:misago_users_user_changelist"))
self.assertContains(response, self.edit_test_user_in_misago_url)
| 3,023
|
Python
|
.py
| 58
| 43.913793
| 87
| 0.69163
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,547
|
rankusers.py
|
rafalp_Misago/misago/users/viewmodels/rankusers.py
|
from ...core.shortcuts import paginate, pagination_dict
from ..online.utils import make_users_status_aware
from ..serializers import UserCardSerializer
class RankUsers:
def __init__(self, request, rank, page=0):
queryset = rank.user_set.select_related(
"rank", "ban_cache", "online_tracker"
).order_by("slug")
if not request.user.is_misago_admin:
queryset = queryset.filter(is_active=True)
list_page = paginate(
queryset,
page,
request.settings.users_per_page,
request.settings.users_per_page_orphans,
)
make_users_status_aware(request, list_page.object_list)
self.users = list_page.object_list
self.paginator = pagination_dict(list_page)
def get_frontend_context(self):
context = {"results": UserCardSerializer(self.users, many=True).data}
context.update(self.paginator)
return context
def get_template_context(self):
return {"users": self.users, "paginator": self.paginator}
| 1,064
|
Python
|
.py
| 25
| 34.08
| 77
| 0.656008
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,548
|
followers.py
|
rafalp_Misago/misago/users/viewmodels/followers.py
|
from django.http import Http404
from ...core.shortcuts import paginate, pagination_dict
from ..online.utils import make_users_status_aware
from ..serializers import UserCardSerializer
class Followers:
def __init__(self, request, profile, page=0, search=None):
queryset = self.get_queryset(profile).select_related("rank").order_by("slug")
if not request.user.is_misago_admin:
queryset = queryset.filter(is_active=True)
if search:
name_starts_with = search.strip().lower()
if name_starts_with:
queryset = queryset.filter(slug__startswith=name_starts_with)
else:
raise Http404()
list_page = paginate(
queryset,
page,
request.settings.users_per_page,
request.settings.users_per_page_orphans,
)
make_users_status_aware(request, list_page.object_list)
self.users = list_page.object_list
self.paginator = pagination_dict(list_page)
def get_queryset(self, profile):
return profile.followed_by
def get_frontend_context(self):
context = {"results": UserCardSerializer(self.users, many=True).data}
context.update(self.paginator)
return context
def get_template_context(self):
return {"followers": self.users, "count": self.paginator["count"]}
| 1,390
|
Python
|
.py
| 32
| 34.375
| 85
| 0.652819
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,549
|
__init__.py
|
rafalp_Misago/misago/users/viewmodels/__init__.py
|
from .activeposters import ActivePosters
from .followers import Followers
from .follows import Follows
from .threads import UserThreads
from .posts import UserPosts
from .rankusers import RankUsers
| 198
|
Python
|
.py
| 6
| 32
| 40
| 0.875
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,550
|
posts.py
|
rafalp_Misago/misago/users/viewmodels/posts.py
|
from ...threads.models import Thread
from ...threads.permissions import exclude_invisible_threads
from .threads import UserThreads
class UserPosts(UserThreads):
def get_threads_queryset(self, request, threads_categories, profile):
return exclude_invisible_threads(
request.user_acl, threads_categories, Thread.objects
)
def get_posts_queryset(self, user, profile, threads_queryset):
return profile.post_set.select_related("thread", "poster").filter(
thread_id__in=threads_queryset.values("id")
)
| 563
|
Python
|
.py
| 12
| 40.333333
| 74
| 0.720803
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,551
|
follows.py
|
rafalp_Misago/misago/users/viewmodels/follows.py
|
from .followers import Followers
class Follows(Followers):
def get_queryset(self, profile):
return profile.follows
def get_template_context(self):
return {"follows": self.users, "count": self.paginator["count"]}
| 239
|
Python
|
.py
| 6
| 34.333333
| 72
| 0.713043
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,552
|
threads.py
|
rafalp_Misago/misago/users/viewmodels/threads.py
|
from django.core.paginator import EmptyPage, InvalidPage
from django.http import Http404
from ...acl.objectacl import add_acl_to_obj
from ...core.cursorpagination import get_page
from ...core.shortcuts import paginate, pagination_dict
from ...threads.permissions import exclude_invisible_threads
from ...threads.serializers import FeedSerializer
from ...threads.utils import add_categories_to_items
from ...threads.viewmodels import ThreadsRootCategory
class UserThreads:
def __init__(self, request, profile, start=0):
root_category = ThreadsRootCategory(request)
threads_categories = [root_category.unwrap()] + root_category.subcategories
threads_queryset = self.get_threads_queryset(
request, threads_categories, profile
)
posts_queryset = (
self.get_posts_queryset(request.user, profile, threads_queryset)
.filter(is_event=False, is_hidden=False, is_unapproved=False)
.order_by("-id")
)
try:
list_page = get_page(
posts_queryset, "-id", request.settings.posts_per_page, start
)
except (EmptyPage, InvalidPage):
raise Http404()
posts = list(list_page.object_list)
threads = []
for post in posts:
threads.append(post.thread)
add_categories_to_items(
root_category.unwrap(), threads_categories, posts + threads
)
add_acl_to_obj(request.user_acl, threads)
add_acl_to_obj(request.user_acl, posts)
self._user = request.user
self.posts = posts
self.list_page = list_page
def get_threads_queryset(self, request, threads_categories, profile):
return exclude_invisible_threads(
request.user_acl, threads_categories, profile.thread_set
)
def get_posts_queryset(self, user, profile, threads_queryset):
return profile.post_set.select_related("thread", "poster").filter(
id__in=threads_queryset.values("first_post_id")
)
def get_frontend_context(self):
return {
"results": UserFeedSerializer(
self.posts, many=True, context={"user": self._user}
).data,
"next": self.list_page.next,
}
def get_template_context(self):
return {"posts": self.posts, "next": self.list_page.next}
UserFeedSerializer = FeedSerializer.exclude_fields("poster")
| 2,462
|
Python
|
.py
| 57
| 34.508772
| 83
| 0.655216
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,553
|
activeposters.py
|
rafalp_Misago/misago/users/viewmodels/activeposters.py
|
from ..activepostersranking import get_active_posters_ranking
from ..online.utils import make_users_status_aware
from ..serializers import UserCardSerializer
class ActivePosters:
def __init__(self, request):
ranking = get_active_posters_ranking()
make_users_status_aware(request, ranking["users"], fetch_state=True)
self.count = ranking["users_count"]
self.tracked_period = request.settings.top_posters_ranking_length
self.users = ranking["users"]
def get_frontend_context(self):
return {
"tracked_period": self.tracked_period,
"results": ScoredUserSerializer(self.users, many=True).data,
"count": self.count,
}
def get_template_context(self):
return {
"tracked_period": self.tracked_period,
"users": self.users,
"users_count": self.count,
}
ScoredUserSerializer = UserCardSerializer.extend_fields("meta")
| 969
|
Python
|
.py
| 23
| 34.043478
| 76
| 0.665602
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,554
|
account.py
|
rafalp_Misago/misago/users/permissions/account.py
|
from django import forms
from django.utils.translation import pgettext_lazy
from ...acl import algebra
from ...acl.models import Role
from ...admin.forms import YesNoSwitch
class PermissionsForm(forms.Form):
legend = pgettext_lazy("users accounts permission", "Account settings")
name_changes_allowed = forms.IntegerField(
label=pgettext_lazy(
"users accounts permission", "Allowed username changes number"
),
min_value=0,
initial=1,
)
name_changes_expire = forms.IntegerField(
label=pgettext_lazy(
"users accounts permission", "Don't count username changes older than"
),
help_text=pgettext_lazy(
"users accounts permission",
"Number of days since name change that makes that change no longer count to limit. Enter zero to make all changes count.",
),
min_value=0,
initial=0,
)
can_have_signature = YesNoSwitch(
label=pgettext_lazy("users accounts permission", "Can have signature")
)
allow_signature_links = YesNoSwitch(
label=pgettext_lazy("users accounts permission", "Can put links in signature")
)
allow_signature_images = YesNoSwitch(
label=pgettext_lazy("users accounts permission", "Can put images in signature")
)
allow_signature_blocks = YesNoSwitch(
label=pgettext_lazy(
"users accounts permission", "Can use text blocks in signature"
),
help_text=pgettext_lazy(
"users accounts permission",
"Controls whether or not users can put quote, code, spoiler blocks and horizontal lines in signatures.",
),
)
def change_permissions_form(role):
if isinstance(role, Role) and role.special_role != "anonymous":
return PermissionsForm
def build_acl(acl, roles, key_name):
new_acl = {
"name_changes_allowed": 0,
"name_changes_expire": 0,
"can_have_signature": 0,
"allow_signature_links": 0,
"allow_signature_images": 0,
"allow_signature_blocks": 0,
}
new_acl.update(acl)
return algebra.sum_acls(
new_acl,
roles=roles,
key=key_name,
name_changes_allowed=algebra.greater,
name_changes_expire=algebra.lower_non_zero,
can_have_signature=algebra.greater,
allow_signature_links=algebra.greater,
allow_signature_images=algebra.greater,
allow_signature_blocks=algebra.greater,
)
| 2,504
|
Python
|
.py
| 67
| 29.910448
| 134
| 0.660626
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,555
|
delete.py
|
rafalp_Misago/misago/users/permissions/delete.py
|
from datetime import timedelta
from django import forms
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied
from django.utils import timezone
from django.utils.translation import npgettext, pgettext_lazy
from ...acl import algebra
from ...acl.decorators import return_boolean
from ...acl.models import Role
__all__ = [
"allow_delete_user",
"can_delete_user",
"allow_delete_own_account",
"can_delete_own_account",
]
class PermissionsForm(forms.Form):
legend = pgettext_lazy("users delete permission", "Deleting users")
can_delete_users_newer_than = forms.IntegerField(
label=pgettext_lazy(
"users delete permission", "Maximum age of deleted account (in days)"
),
help_text=pgettext_lazy(
"users delete permission", "Enter zero to disable this check."
),
min_value=0,
initial=0,
)
can_delete_users_with_less_posts_than = forms.IntegerField(
label=pgettext_lazy(
"users delete permission", "Maximum number of posts on deleted account"
),
help_text=pgettext_lazy(
"users delete permission", "Enter zero to disable this check."
),
min_value=0,
initial=0,
)
def change_permissions_form(role):
if isinstance(role, Role) and role.special_role != "anonymous":
return PermissionsForm
def build_acl(acl, roles, key_name):
new_acl = {
"can_delete_users_newer_than": 0,
"can_delete_users_with_less_posts_than": 0,
}
new_acl.update(acl)
return algebra.sum_acls(
new_acl,
roles=roles,
key=key_name,
can_delete_users_newer_than=algebra.greater,
can_delete_users_with_less_posts_than=algebra.greater,
)
def add_acl_to_user(user_acl, target):
target.acl["can_delete"] = can_delete_user(user_acl, target)
if target.acl["can_delete"]:
target.acl["can_moderate"] = True
def register_with(registry):
registry.acl_annotator(get_user_model(), add_acl_to_user)
def allow_delete_user(user_acl, target):
newer_than = user_acl["can_delete_users_newer_than"]
less_posts_than = user_acl["can_delete_users_with_less_posts_than"]
if not newer_than and not less_posts_than:
raise PermissionDenied(
pgettext_lazy("users delete permission", "You can't delete users.")
)
if user_acl["user_id"] == target.id:
raise PermissionDenied(
pgettext_lazy("users delete permission", "You can't delete your account.")
)
if target.is_misago_admin:
raise PermissionDenied(
pgettext_lazy("users delete permission", "Administrators can't be deleted.")
)
if target.is_staff:
raise PermissionDenied(
pgettext_lazy(
"users delete permission", "Django staff users can't be deleted."
)
)
if newer_than:
if target.joined_on < timezone.now() - timedelta(days=newer_than):
message = npgettext(
"users delete permission",
"You can't delete users that are members for more than %(days)s day.",
"You can't delete users that are members for more than %(days)s days.",
newer_than,
)
raise PermissionDenied(message % {"days": newer_than})
if less_posts_than:
if target.posts > less_posts_than:
message = npgettext(
"users delete permission",
"You can't delete users that made more than %(posts)s post.",
"You can't delete users that made more than %(posts)s posts.",
less_posts_than,
)
raise PermissionDenied(message % {"posts": less_posts_than})
can_delete_user = return_boolean(allow_delete_user)
def allow_delete_own_account(settings, user, target):
if user.id != target.id:
raise PermissionDenied(
pgettext_lazy(
"users delete permission", "You can't delete other users accounts."
)
)
if not settings.allow_delete_own_account and not user.is_deleting_account:
raise PermissionDenied(
pgettext_lazy("users delete permission", "You can't delete your account.")
)
if user.is_misago_admin:
raise PermissionDenied(
pgettext_lazy(
"users delete permission",
"You can't delete your account because you are an administrator.",
)
)
if user.is_staff:
raise PermissionDenied(
pgettext_lazy(
"users delete permission",
"You can't delete your account because you are a staff user.",
)
)
can_delete_own_account = return_boolean(allow_delete_own_account)
| 4,874
|
Python
|
.py
| 125
| 30.408
| 88
| 0.630375
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,556
|
__init__.py
|
rafalp_Misago/misago/users/permissions/__init__.py
|
from .decorators import *
from .delete import *
from .moderation import *
from .profiles import *
| 98
|
Python
|
.py
| 4
| 23.5
| 25
| 0.787234
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,557
|
profiles.py
|
rafalp_Misago/misago/users/permissions/profiles.py
|
from django import forms
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext_lazy
from ...acl import algebra
from ...acl.decorators import return_boolean
from ...acl.models import Role
from ...admin.forms import YesNoSwitch
from .decorators import authenticated_only
__all__ = [
"allow_browse_users_list",
"can_browse_users_list",
"allow_follow_user",
"can_follow_user",
"allow_block_user",
"can_block_user",
"allow_see_ban_details",
"can_see_ban_details",
]
CAN_BROWSE_USERS_LIST = YesNoSwitch(
label=pgettext_lazy("users profiles permission", "Can browse users list"), initial=1
)
CAN_SEARCH_USERS = YesNoSwitch(
label=pgettext_lazy("users profiles permission", "Can search user profiles"),
initial=1,
)
CAN_SEE_USER_NAME_HISTORY = YesNoSwitch(
label=pgettext_lazy(
"users profiles permission", "Can see other members name history"
)
)
CAN_SEE_DETAILS = YesNoSwitch(
label=pgettext_lazy("users profiles permission", "Can see members bans details"),
help_text=pgettext_lazy(
"users profiles permission",
"Allows users with this permission to see user and staff ban messages.",
),
)
class LimitedPermissionsForm(forms.Form):
legend = pgettext_lazy("users profiles permission", "User profiles")
can_browse_users_list = CAN_BROWSE_USERS_LIST
can_search_users = CAN_SEARCH_USERS
can_see_users_name_history = CAN_SEE_USER_NAME_HISTORY
can_see_ban_details = CAN_SEE_DETAILS
class PermissionsForm(LimitedPermissionsForm):
can_browse_users_list = CAN_BROWSE_USERS_LIST
can_search_users = CAN_SEARCH_USERS
can_follow_users = YesNoSwitch(
label=pgettext_lazy("users profiles permission", "Can follow other users"),
initial=1,
)
can_be_blocked = YesNoSwitch(
label=pgettext_lazy(
"users profiles permission", "Can be blocked by other users"
),
initial=0,
)
can_see_users_name_history = CAN_SEE_USER_NAME_HISTORY
can_see_ban_details = CAN_SEE_DETAILS
can_see_users_emails = YesNoSwitch(
label=pgettext_lazy("users profiles permission", "Can see members e-mails")
)
can_see_users_ips = YesNoSwitch(
label=pgettext_lazy("users profiles permission", "Can see members IPs")
)
can_see_hidden_users = YesNoSwitch(
label=pgettext_lazy(
"users profiles permission", "Can see members that hide their presence"
)
)
def change_permissions_form(role):
if isinstance(role, Role):
if role.special_role == "anonymous":
return LimitedPermissionsForm
return PermissionsForm
def build_acl(acl, roles, key_name):
new_acl = {
"can_browse_users_list": 0,
"can_search_users": 0,
"can_follow_users": 0,
"can_be_blocked": 1,
"can_see_users_name_history": 0,
"can_see_ban_details": 0,
"can_see_users_emails": 0,
"can_see_users_ips": 0,
"can_see_hidden_users": 0,
}
new_acl.update(acl)
return algebra.sum_acls(
new_acl,
roles=roles,
key=key_name,
can_browse_users_list=algebra.greater,
can_search_users=algebra.greater,
can_follow_users=algebra.greater,
can_be_blocked=algebra.lower,
can_see_users_name_history=algebra.greater,
can_see_ban_details=algebra.greater,
can_see_users_emails=algebra.greater,
can_see_users_ips=algebra.greater,
can_see_hidden_users=algebra.greater,
)
def add_acl_to_user(user_acl, target):
target.acl["can_have_attitude"] = False
target.acl["can_follow"] = can_follow_user(user_acl, target)
target.acl["can_block"] = can_block_user(user_acl, target)
mod_permissions = ("can_have_attitude", "can_follow", "can_block")
for permission in mod_permissions:
if target.acl[permission]:
target.acl["can_have_attitude"] = True
break
def register_with(registry):
registry.acl_annotator(get_user_model(), add_acl_to_user)
def allow_browse_users_list(user_acl):
if not user_acl["can_browse_users_list"]:
raise PermissionDenied(
pgettext_lazy("users profiles permission", "You can't browse users list.")
)
can_browse_users_list = return_boolean(allow_browse_users_list)
@authenticated_only
def allow_follow_user(user_acl, target):
if not user_acl["can_follow_users"]:
raise PermissionDenied(
pgettext_lazy("users profiles permission", "You can't follow other users.")
)
if user_acl["user_id"] == target.id:
raise PermissionDenied(
pgettext_lazy(
"users profiles permission", "You can't add yourself to followed."
)
)
can_follow_user = return_boolean(allow_follow_user)
@authenticated_only
def allow_block_user(user_acl, target):
if target.is_misago_admin or target.is_staff:
raise PermissionDenied(
pgettext_lazy(
"users profiles permission", "Administrators can't be blocked."
)
)
if user_acl["user_id"] == target.id:
raise PermissionDenied(
pgettext_lazy("users profiles permission", "You can't block yourself.")
)
# FIXME: check if user has "can be blocked" permission
can_block_user = return_boolean(allow_block_user)
@authenticated_only
def allow_see_ban_details(user_acl, target):
if not user_acl["can_see_ban_details"]:
raise PermissionDenied(
pgettext_lazy(
"users profiles permission", "You can't see users bans details."
)
)
can_see_ban_details = return_boolean(allow_see_ban_details)
| 5,816
|
Python
|
.py
| 155
| 31.032258
| 88
| 0.672414
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,558
|
moderation.py
|
rafalp_Misago/misago/users/permissions/moderation.py
|
from datetime import timedelta
from django import forms
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied
from django.template.defaultfilters import date as format_date
from django.utils import timezone
from django.utils.translation import pgettext_lazy
from ...acl import algebra
from ...acl.decorators import return_boolean
from ...acl.models import Role
from ...admin.forms import YesNoSwitch
from ..bans import get_user_ban
__all__ = [
"allow_rename_user",
"can_rename_user",
"allow_moderate_avatar",
"can_moderate_avatar",
"allow_moderate_signature",
"can_moderate_signature",
"allow_edit_profile_details",
"can_edit_profile_details",
"allow_ban_user",
"can_ban_user",
"allow_lift_ban",
"can_lift_ban",
]
class PermissionsForm(forms.Form):
legend = pgettext_lazy("users moderation permission", "Users moderation")
can_rename_users = YesNoSwitch(
label=pgettext_lazy("users moderation permission", "Can rename users")
)
can_moderate_avatars = YesNoSwitch(
label=pgettext_lazy("users moderation permission", "Can moderate avatars")
)
can_moderate_signatures = YesNoSwitch(
label=pgettext_lazy("users moderation permission", "Can moderate signatures")
)
can_moderate_profile_details = YesNoSwitch(
label=pgettext_lazy(
"users moderation permission", "Can moderate profile details"
)
)
can_ban_users = YesNoSwitch(
label=pgettext_lazy("users moderation permission", "Can ban users")
)
max_ban_length = forms.IntegerField(
label=pgettext_lazy(
"users moderation permission", "Max length, in days, of imposed ban"
),
help_text=pgettext_lazy(
"users moderation permission",
"Enter zero to let moderators impose permanent bans.",
),
min_value=0,
initial=0,
)
can_lift_bans = YesNoSwitch(
label=pgettext_lazy("users moderation permission", "Can lift bans")
)
max_lifted_ban_length = forms.IntegerField(
label=pgettext_lazy(
"users moderation permission", "Max length, in days, of lifted ban"
),
help_text=pgettext_lazy(
"users moderation permission",
"Enter zero to let moderators lift permanent bans.",
),
min_value=0,
initial=0,
)
def change_permissions_form(role):
if isinstance(role, Role) and role.special_role != "anonymous":
return PermissionsForm
def build_acl(acl, roles, key_name):
new_acl = {
"can_rename_users": 0,
"can_moderate_avatars": 0,
"can_moderate_signatures": 0,
"can_moderate_profile_details": 0,
"can_ban_users": 0,
"max_ban_length": 2,
"can_lift_bans": 0,
"max_lifted_ban_length": 2,
}
new_acl.update(acl)
return algebra.sum_acls(
new_acl,
roles=roles,
key=key_name,
can_rename_users=algebra.greater,
can_moderate_avatars=algebra.greater,
can_moderate_signatures=algebra.greater,
can_moderate_profile_details=algebra.greater,
can_ban_users=algebra.greater,
max_ban_length=algebra.greater_or_zero,
can_lift_bans=algebra.greater,
max_lifted_ban_length=algebra.greater_or_zero,
)
def add_acl_to_user(user_acl, target):
target.acl["can_rename"] = can_rename_user(user_acl, target)
target.acl["can_moderate_avatar"] = can_moderate_avatar(user_acl, target)
target.acl["can_moderate_signature"] = can_moderate_signature(user_acl, target)
target.acl["can_edit_profile_details"] = can_edit_profile_details(user_acl, target)
target.acl["can_ban"] = can_ban_user(user_acl, target)
target.acl["max_ban_length"] = user_acl["max_ban_length"]
target.acl["can_lift_ban"] = can_lift_ban(user_acl, target)
mod_permissions = ["can_rename", "can_moderate_avatar", "can_moderate_signature"]
for permission in mod_permissions:
if target.acl[permission]:
target.acl["can_moderate"] = True
break
def register_with(registry):
registry.acl_annotator(get_user_model(), add_acl_to_user)
def allow_rename_user(user_acl, target):
if not user_acl["can_rename_users"]:
raise PermissionDenied(
pgettext_lazy("users moderation permission", "You can't rename users.")
)
if not user_acl["is_root"] and target.is_misago_admin:
raise PermissionDenied(
pgettext_lazy(
"users moderation permission", "You can't rename administrators."
)
)
can_rename_user = return_boolean(allow_rename_user)
def allow_moderate_avatar(user_acl, target):
if not user_acl["can_moderate_avatars"]:
raise PermissionDenied(
pgettext_lazy("users moderation permission", "You can't moderate avatars.")
)
if not user_acl["is_root"] and (target.is_misago_admin):
raise PermissionDenied(
pgettext_lazy(
"users moderation permission",
"You can't moderate administrators avatars.",
)
)
can_moderate_avatar = return_boolean(allow_moderate_avatar)
def allow_moderate_signature(user_acl, target):
if not user_acl["can_moderate_signatures"]:
raise PermissionDenied(
pgettext_lazy(
"users moderation permission", "You can't moderate signatures."
)
)
if not user_acl["is_root"] and target.is_misago_admin:
message = pgettext_lazy(
"users moderation permission",
"You can't moderate administrators signatures.",
)
raise PermissionDenied(message)
can_moderate_signature = return_boolean(allow_moderate_signature)
def allow_edit_profile_details(user_acl, target):
if user_acl["is_anonymous"]:
raise PermissionDenied(
pgettext_lazy(
"users moderation permission",
"You have to sign in to edit profile details.",
)
)
if (
user_acl["user_id"] != target.id
and not user_acl["can_moderate_profile_details"]
):
raise PermissionDenied(
pgettext_lazy(
"users moderation permission", "You can't edit other users details."
)
)
if not user_acl["is_root"] and target.is_misago_admin:
message = pgettext_lazy(
"users moderation permission", "You can't edit administrators details."
)
raise PermissionDenied(message)
can_edit_profile_details = return_boolean(allow_edit_profile_details)
def allow_ban_user(user_acl, target):
if not user_acl["can_ban_users"]:
raise PermissionDenied(
pgettext_lazy("users moderation permission", "You can't ban users.")
)
if target.is_misago_admin:
raise PermissionDenied(
pgettext_lazy(
"users moderation permission", "Administrators can't be banned."
)
)
can_ban_user = return_boolean(allow_ban_user)
def allow_lift_ban(user_acl, target):
if not user_acl["can_lift_bans"]:
raise PermissionDenied(
pgettext_lazy("users moderation permission", "You can't lift bans.")
)
ban = get_user_ban(target, user_acl["cache_versions"])
if not ban:
raise PermissionDenied(
pgettext_lazy("users moderation permission", "This user is not banned.")
)
if user_acl["max_lifted_ban_length"]:
expiration_limit = timedelta(days=user_acl["max_lifted_ban_length"])
lift_cutoff = (timezone.now() + expiration_limit).date()
if not ban.valid_until:
raise PermissionDenied(
pgettext_lazy(
"users moderation permission", "You can't lift permanent bans."
)
)
elif ban.valid_until > lift_cutoff:
message = pgettext_lazy(
"users moderation permission",
"You can't lift bans that expire after %(expiration)s.",
)
raise PermissionDenied(message % {"expiration": format_date(lift_cutoff)})
can_lift_ban = return_boolean(allow_lift_ban)
| 8,308
|
Python
|
.py
| 213
| 30.976526
| 87
| 0.6444
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,559
|
decorators.py
|
rafalp_Misago/misago/users/permissions/decorators.py
|
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext_lazy
__all__ = ["authenticated_only", "anonymous_only"]
def authenticated_only(f):
def perm_decorator(user_acl, target):
if user_acl["is_anonymous"]:
raise PermissionDenied(
pgettext_lazy(
"view decorator", "You have to sign in to perform this action."
)
)
return f(user_acl, target)
return perm_decorator
def anonymous_only(f):
def perm_decorator(user_acl, target):
if user_acl["is_authenticated"]:
raise PermissionDenied(
pgettext_lazy("view decorator", "Only guests can perform this action.")
)
return f(user_acl, target)
return perm_decorator
| 816
|
Python
|
.py
| 21
| 29.714286
| 87
| 0.630711
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,560
|
create_group.py
|
rafalp_Misago/misago/users/hooks/create_group.py
|
from typing import Optional, Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
from ..models import Group
class CreateGroupHookAction(Protocol):
"""
A standard Misago function used for creating a new user group or the next filter
function from another plugin.
# Arguments
Accepts the same arguments as `Group.objects.create()`.
It is guaranteed to be called with at least the `name: str` argument.
# Additional arguments
In addition to the standard `kwargs` accepted by `Group.objects.create()`, optional
arguments may be present:
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
## `form: Optional[Form]`
Bound `Form` instance that was used to create this group.
## `plugin_data: dict`
A plugin data `dict` that will be saved on the `Group.plugin_data` attribute.
# Return value
A newly created `Group` instance.
"""
def __call__(self, **kwargs) -> Group: ...
class CreateGroupHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: CreateGroupHookAction`
A standard Misago function used for creating a new user group or the next filter
function from another plugin.
See the [action](#action) section for details.
# Additional arguments
In addition to the standard `kwargs` accepted by `Group.objects.create()`, optional
arguments may be present:
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
## `form: Optional[Form]`
Bound `Form` instance that was used to create this group.
## `plugin_data: dict`
A plugin data `dict` that will be saved on the `Group.plugin_data` attribute.
# Return value
A newly created `Group` instance.
"""
def __call__(self, action: CreateGroupHookAction, **kwargs) -> Group: ...
class CreateGroupHook(FilterHook[CreateGroupHookAction, CreateGroupHookFilter]):
"""
This hook wraps the standard function that Misago uses to create a new user group.
Misago group creation logic is a thin wrapper for `Group.objects.create()` that
updates the `kwargs` to include a valid `slug` generated from the `name` and next
valid `ordering` position.
If `kwargs` contains either `request` of `form` special keys, those are also removed
before the `create(**kwargs)` is called.
# Example
The code below implements a custom filter function that stores an ID of user who
created the group, if its available:
```python
from django.http import HttpRequest
from misago.postgres.delete import delete_all
from misago.users.models import Group
@create_group_hook.append_filter
def set_group_creator_id(action, **kwargs) -> Group:
# request and plugin_data keys are guaranteed to be set in `kwargs`
if kwargs["request"] and kwargs["request"].user.id:
kwargs["plugin_data"]["creator_id"] = kwargs["request"].user.id
# Call the next function in chain
return action(group, **kwargs)
```
"""
__slots__ = FilterHook.__slots__
def __call__(self, action: CreateGroupHookAction, **kwargs) -> Group:
return super().__call__(action, **kwargs)
create_group_hook = CreateGroupHook()
| 3,393
|
Python
|
.py
| 73
| 40.876712
| 88
| 0.707824
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,561
|
update_group.py
|
rafalp_Misago/misago/users/hooks/update_group.py
|
from typing import Protocol
from ...plugins.hooks import FilterHook
from ..models import Group
class UpdateGroupHookAction(Protocol):
"""
A standard Misago function used to update an existing user group or the next filter
function from another plugin.
# Arguments
## `group: Group`
A group instance to update.
## `**kwargs`
A `dict` with group's attributes to update.
# Additional arguments
Optional arguments in `kwargs` that are not used to update the group but are still
provided for use by plugins:
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
## `form: Optional[Form]`
Bound `Form` instance that was used to update this group.
# Return value
An updated `Group` instance.
"""
def __call__(self, group: Group, **kwargs) -> Group: ...
class UpdateGroupHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: UpdateGroupHookAction`
A standard Misago function used to update an existing user group or the next filter
function from another plugin.
See the [action](#action) section for details.
## `group: Group`
A group instance to update.
## `**kwargs`
A `dict` with group's attributes to update.
# Additional arguments
Optional arguments in `kwargs` that are not used to update the group but are still
provided for use by plugins:
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
## `form: Optional[Form]`
Bound `Form` instance that was used to update this group.
# Return value
An updated `Group` instance.
"""
def __call__(
self, action: UpdateGroupHookAction, group: Group, **kwargs
) -> Group: ...
class UpdateGroupHook(FilterHook[UpdateGroupHookAction, UpdateGroupHookFilter]):
"""
This hook wraps the standard function that Misago uses to update user group.
# Example
The code below implements a custom filter function that stores an ID of user who
last modified the group, if its available:
```python
from django.http import HttpRequest
from misago.users.models import Group
@update_group_hook.append_filter
def set_group_updated_by_id(action, **kwargs) -> Group:
# request key is guaranteed to be set in `kwargs`
if kwargs["request"] and kwargs["request"].user.id:
group.plugin_data["updated_by"] = kwargs["request"].user.id
# Call the next function in chain
return action(group, **kwargs)
```
"""
__slots__ = FilterHook.__slots__
def __call__(self, action: UpdateGroupHookAction, group: Group, **kwargs) -> Group:
return super().__call__(action, group, **kwargs)
update_group_hook = UpdateGroupHook()
| 2,893
|
Python
|
.py
| 70
| 35.6
| 87
| 0.693084
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,562
|
__init__.py
|
rafalp_Misago/misago/users/hooks/__init__.py
|
from .create_group import create_group_hook
from .delete_group import delete_group_hook
from .set_default_group import set_default_group_hook
from .update_group import update_group_hook
from .update_group_description import update_group_description_hook
__all__ = [
"create_group_hook",
"delete_group_hook",
"set_default_group_hook",
"update_group_hook",
"update_group_description_hook",
]
| 411
|
Python
|
.py
| 12
| 31.5
| 67
| 0.761307
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,563
|
set_default_group.py
|
rafalp_Misago/misago/users/hooks/set_default_group.py
|
from typing import Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
from ..models import Group
class SetDefaultGroupHookAction(Protocol):
"""
A standard Misago function used to set the default user group, or the next
filter function from another plugin.
# Arguments
## `group: Group`
A `Group` model instance to set as default in the database.
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
"""
def __call__(
self,
group: Group,
request: HttpRequest | None = None,
) -> None: ...
class SetDefaultGroupHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: SetDefaultGroupHookAction`
A standard Misago function used to set the default user group, or the next
filter function from another plugin.
See the [action](#action) section for details.
## `group: Group`
A `Group` model instance to set as default in the database.
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
"""
def __call__(
self,
action: SetDefaultGroupHookAction,
group: Group,
request: HttpRequest | None = None,
) -> None: ...
class SetDefaultGroupHook(
FilterHook[SetDefaultGroupHookAction, SetDefaultGroupHookFilter]
):
"""
This hook wraps the standard function that Misago uses to set a default user group.
The default user group is the group assigned to a user at account creation time.
# Example
The code below implements a custom filter function that logs the default group
change:
```python
from logging import getLogger
from django.http import HttpRequest
from misago.users.models import Group
logger = getLogger(__file__)
@set_default_group_hook.append_filter
def log_default_group_change(
action, group: Group, request: HttpRequest | None = None
) -> None:
if request:
logger.info(
"%s (#%s) changed default user group to %s (#%s)",
request.user, request.user.id, group.name, group.id
)
# Call the next function in chain
return action(group, request)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: SetDefaultGroupHookAction,
group: Group,
request: HttpRequest | None = None,
) -> None:
return super().__call__(action, group, request)
set_default_group_hook = SetDefaultGroupHook()
| 2,663
|
Python
|
.py
| 74
| 29.594595
| 87
| 0.668363
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,564
|
delete_group.py
|
rafalp_Misago/misago/users/hooks/delete_group.py
|
from typing import Optional, Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
from ..models import Group
class DeleteGroupHookAction(Protocol):
"""
A standard Misago function used for deleting the user group, or the next
filter function from another plugin.
# Arguments
## `group: Group`
A `Group` model instance to delete from the database.
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
"""
def __call__(
self,
group: Group,
request: HttpRequest | None = None,
) -> None: ...
class DeleteGroupHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: DeleteGroupHookAction`
A standard Misago function used for deleting the user group, or the next
filter function from another plugin.
See the [action](#action) section for details.
## `group: Group`
A `Group` model instance to delete from the database.
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
"""
def __call__(
self,
action: DeleteGroupHookAction,
group: Group,
request: HttpRequest | None = None,
) -> None: ...
class DeleteGroupHook(FilterHook[DeleteGroupHookAction, DeleteGroupHookFilter]):
"""
This hook wraps the standard function that Misago uses to delete a user group.
Misago executes delete queries for groups and their relations directly, skipping
the Django ORM which uses the Object Collector logic to simulate the delete cascade
behavior that databases implement and run the pre and post delete signals.
Because of this, plugins need to explicitly delete objects related to the deleted
group in custom filters before a group itself is deleted from the database.
# Example
The code below implements a custom filter function that deletes a custom model
implemented in a plugin before group itself is deleted:
```python
from django.http import HttpRequest
from misago.postgres.delete import delete_all
from misago.users.models import Group
from .models import GroupPromotionRule
@delete_group_hook.append_filter
def delete_group_promotion_rules(
action, group: Group, request: HttpRequest | None = None
) -> None:
# Delete promotion rules related with this group bypassing the Django ORM
delete_all(GroupPromotionRule, group_id=group.id)
# Call the next function in chain
return action(group, request)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: DeleteGroupHookAction,
group: Group,
request: HttpRequest | None = None,
) -> None:
return super().__call__(action, group, request)
delete_group_hook = DeleteGroupHook()
| 2,957
|
Python
|
.py
| 73
| 34.534247
| 87
| 0.70516
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,565
|
update_group_description.py
|
rafalp_Misago/misago/users/hooks/update_group_description.py
|
from typing import Protocol
from ...plugins.hooks import FilterHook
from ..models import Group
class UpdateGroupDescriptionHookAction(Protocol):
"""
A standard Misago function used to update an existing user group's description or
the next filter function from another plugin.
# Arguments
## `group: Group`
A group instance to update.
## `**kwargs`
A `dict` with group description's attributes to update.
# Additional arguments
Optional arguments in `kwargs` that are not used to update the group but are still
provided for use by plugins:
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
## `form: Optional[Form]`
Bound `Form` instance that was used to update this group's description.
# Return value
An updated `Group` instance.
"""
def __call__(self, group: Group, **kwargs) -> Group: ...
class UpdateGroupDescriptionHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: UpdateGroupDescriptionHookAction`
A standard Misago function used to update an existing user group's description or
the next filter function from another plugin.
See the [action](#action) section for details.
## `group: Group`
A group instance to update.
## `**kwargs`
A `dict` with group description's attributes to update.
# Additional arguments
Optional arguments in `kwargs` that are not used to update the group but are still
provided for use by plugins:
## `request: Optional[HttpRequest]`
The request object or `None` if it was not provided.
## `form: Optional[Form]`
Bound `Form` instance that was used to update this group's description.
# Return value
An updated `Group` instance.
"""
def __call__(
self, action: UpdateGroupDescriptionHookAction, group: Group, **kwargs
) -> Group: ...
class UpdateGroupDescriptionHook(
FilterHook[UpdateGroupDescriptionHookAction, UpdateGroupDescriptionHookFilter]
):
"""
This hook wraps the standard function that Misago uses to update
user group's description.
# Example
The code below implements a custom filter function that stores an ID of user who
last modified the group description, if its available:
```python
from django.http import HttpRequest
from misago.users.models import Group
@update_group_description_hook.append_filter
def set_group_description_updated_by_id(action, **kwargs) -> Group:
# request key is guaranteed to be set in `kwargs`
if kwargs["request"] and kwargs["request"].user.id:
group.description.plugin_data["updated_by"] = kwargs["request"].user.id
# Call the next function in chain
return action(group, **kwargs)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self, action: UpdateGroupDescriptionHookAction, group: Group, **kwargs
) -> Group:
return super().__call__(action, group, **kwargs)
update_group_description_hook = UpdateGroupDescriptionHook()
| 3,170
|
Python
|
.py
| 75
| 36.586667
| 86
| 0.708661
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,566
|
ban.py
|
rafalp_Misago/misago/users/serializers/ban.py
|
from django.utils.translation import pgettext
from rest_framework import serializers
from ...core.utils import format_plaintext_for_html
from ..models import Ban
__all__ = ["BanMessageSerializer", "BanDetailsSerializer"]
def serialize_message(message):
if message:
return {"plain": message, "html": format_plaintext_for_html(message)}
class BanMessageSerializer(serializers.ModelSerializer):
message = serializers.SerializerMethodField()
class Meta:
model = Ban
fields = ["message", "expires_on"]
def get_message(self, obj):
if obj.user_message:
message = obj.user_message
elif obj.check_type == Ban.IP:
message = pgettext("ban message", "Your IP address is banned.")
else:
message = pgettext("ban message", "You are banned.")
return serialize_message(message)
class BanDetailsSerializer(serializers.ModelSerializer):
user_message = serializers.SerializerMethodField()
staff_message = serializers.SerializerMethodField()
class Meta:
model = Ban
fields = ["user_message", "staff_message", "expires_on"]
def get_user_message(self, obj):
return serialize_message(obj.user_message)
def get_staff_message(self, obj):
return serialize_message(obj.staff_message)
| 1,330
|
Python
|
.py
| 31
| 36.290323
| 77
| 0.701167
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,567
|
user.py
|
rafalp_Misago/misago/users/serializers/user.py
|
from django.contrib.auth import get_user_model
from django.urls import reverse
from rest_framework import serializers
from . import RankSerializer
from ...core.serializers import MutableFields
User = get_user_model()
__all__ = ["StatusSerializer", "UserSerializer", "UserCardSerializer"]
class StatusSerializer(serializers.Serializer):
is_offline = serializers.BooleanField()
is_online = serializers.BooleanField()
is_hidden = serializers.BooleanField()
is_offline_hidden = serializers.BooleanField()
is_online_hidden = serializers.BooleanField()
last_click = serializers.DateTimeField()
is_banned = serializers.BooleanField()
banned_until = serializers.DateTimeField()
class UserSerializer(serializers.ModelSerializer, MutableFields):
email = serializers.SerializerMethodField()
rank = RankSerializer(many=False, read_only=True)
signature = serializers.SerializerMethodField()
acl = serializers.SerializerMethodField()
is_followed = serializers.SerializerMethodField()
is_blocked = serializers.SerializerMethodField()
meta = serializers.SerializerMethodField()
real_name = serializers.SerializerMethodField()
status = serializers.SerializerMethodField()
api = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = User
fields = [
"id",
"username",
"slug",
"email",
"joined_on",
"rank",
"title",
"avatars",
"is_avatar_locked",
"signature",
"is_signature_locked",
"followers",
"following",
"threads",
"posts",
"acl",
"is_followed",
"is_blocked",
"meta",
"real_name",
"status",
"api",
"url",
]
def get_acl(self, obj):
return obj.acl
def get_email(self, obj):
request = self.context["request"]
if obj == request.user or request.user_acl["can_see_users_emails"]:
return obj.email
def get_is_followed(self, obj):
request = self.context["request"]
if obj.acl["can_follow"]:
return request.user.is_following(obj)
return False
def get_is_blocked(self, obj):
request = self.context["request"]
if obj.acl["can_block"]:
return request.user.is_blocking(obj)
return False
def get_meta(self, obj):
return {"score": obj.score}
def get_real_name(self, obj):
return obj.get_real_name()
def get_signature(self, obj):
if obj.has_valid_signature:
return obj.signature_parsed
def get_status(self, obj):
try:
return StatusSerializer(obj.status).data
except AttributeError:
return None
def get_api(self, obj):
return {
"index": reverse("misago:api:user-detail", kwargs={"pk": obj.pk}),
"follow": reverse("misago:api:user-follow", kwargs={"pk": obj.pk}),
"ban": reverse("misago:api:user-ban", kwargs={"pk": obj.pk}),
"details": reverse("misago:api:user-details", kwargs={"pk": obj.pk}),
"edit_details": reverse(
"misago:api:user-edit-details", kwargs={"pk": obj.pk}
),
"moderate_avatar": reverse(
"misago:api:user-moderate-avatar", kwargs={"pk": obj.pk}
),
"moderate_username": reverse(
"misago:api:user-moderate-username", kwargs={"pk": obj.pk}
),
"delete": reverse("misago:api:user-delete", kwargs={"pk": obj.pk}),
"followers": reverse("misago:api:user-followers", kwargs={"pk": obj.pk}),
"follows": reverse("misago:api:user-follows", kwargs={"pk": obj.pk}),
"threads": reverse("misago:api:user-threads", kwargs={"pk": obj.pk}),
"posts": reverse("misago:api:user-posts", kwargs={"pk": obj.pk}),
}
def get_url(self, obj):
return obj.get_absolute_url()
UserCardSerializer = UserSerializer.subset_fields(
"id",
"username",
"joined_on",
"rank",
"title",
"avatars",
"followers",
"threads",
"posts",
"real_name",
"status",
"url",
)
| 4,375
|
Python
|
.py
| 120
| 27.733333
| 85
| 0.600662
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,568
|
usernamechange.py
|
rafalp_Misago/misago/users/serializers/usernamechange.py
|
from rest_framework import serializers
from ..models import UsernameChange
from .user import UserSerializer as BaseUserSerializer
__all__ = ["UsernameChangeSerializer"]
UserSerializer = BaseUserSerializer.subset_fields("id", "username", "avatars", "url")
class UsernameChangeSerializer(serializers.ModelSerializer):
user = UserSerializer(many=False, read_only=True)
changed_by = UserSerializer(many=False, read_only=True)
class Meta:
model = UsernameChange
fields = [
"id",
"user",
"changed_by",
"changed_by_username",
"changed_on",
"new_username",
"old_username",
]
| 693
|
Python
|
.py
| 19
| 28.842105
| 85
| 0.655689
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,569
|
rank.py
|
rafalp_Misago/misago/users/serializers/rank.py
|
from rest_framework import serializers
from ...core.utils import format_plaintext_for_html
from ..models import Rank
__all__ = ["RankSerializer"]
class RankSerializer(serializers.ModelSerializer):
description = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = Rank
fields = [
"id",
"name",
"slug",
"description",
"title",
"css_class",
"is_default",
"is_tab",
"url",
]
def get_name(self, obj):
return str(obj)
def get_description(self, obj):
if obj.description:
return format_plaintext_for_html(obj.description)
return ""
def get_url(self, obj):
return obj.get_absolute_url()
| 832
|
Python
|
.py
| 28
| 21.285714
| 61
| 0.585427
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,570
|
auth.py
|
rafalp_Misago/misago/users/serializers/auth.py
|
from django.contrib.auth import get_user_model
from django.urls import reverse
from rest_framework import serializers
from ...acl.useracl import serialize_user_acl
from .user import UserSerializer
User = get_user_model()
__all__ = ["AuthenticatedUserSerializer", "AnonymousUserSerializer"]
class AuthFlags:
def get_is_authenticated(self, obj):
return bool(obj.is_authenticated)
def get_is_anonymous(self, obj):
return bool(obj.is_anonymous)
class AuthenticatedUserSerializer(UserSerializer, AuthFlags):
email = serializers.SerializerMethodField()
is_authenticated = serializers.SerializerMethodField()
is_anonymous = serializers.SerializerMethodField()
class Meta:
model = User
fields = UserSerializer.Meta.fields + [
"has_usable_password",
"is_hiding_presence",
"limits_private_thread_invites_to",
"unread_private_threads",
"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",
"is_authenticated",
"is_anonymous",
]
def get_acl(self, obj):
acl = self.context.get("acl")
if acl:
return serialize_user_acl(acl)
return {}
def get_email(self, obj):
return obj.email
def get_api(self, obj):
return {
"avatar": reverse("misago:api:user-avatar", kwargs={"pk": obj.pk}),
"details": reverse("misago:api:user-details", kwargs={"pk": obj.pk}),
"edit_details": reverse(
"misago:api:user-edit-details", kwargs={"pk": obj.pk}
),
}
def to_representation(self, instance) -> dict:
data = super().to_representation(instance)
data["unreadNotifications"] = instance.get_unread_notifications_for_display()
return data
AuthenticatedUserSerializer = AuthenticatedUserSerializer.exclude_fields(
"is_avatar_locked",
"is_blocked",
"is_followed",
"is_signature_locked",
"meta",
"signature",
"status",
)
class AnonymousUserSerializer(serializers.Serializer, AuthFlags):
id = serializers.ReadOnlyField()
acl = serializers.SerializerMethodField()
is_authenticated = serializers.SerializerMethodField()
is_anonymous = serializers.SerializerMethodField()
def get_acl(self, obj):
acl = self.context.get("acl")
if acl:
return serialize_user_acl(acl)
return {}
| 2,669
|
Python
|
.py
| 70
| 30.357143
| 85
| 0.655172
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,571
|
__init__.py
|
rafalp_Misago/misago/users/serializers/__init__.py
|
from .ban import *
from .moderation import *
from .rank import *
from .user import *
from .auth import *
from .username import ChangeUsernameSerializer
from .usernamechange import *
| 182
|
Python
|
.py
| 7
| 25
| 46
| 0.805714
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,572
|
moderation.py
|
rafalp_Misago/misago/users/serializers/moderation.py
|
from django.contrib.auth import get_user_model
from django.utils.translation import npgettext
from rest_framework import serializers
User = get_user_model()
__all__ = ["ModerateAvatarSerializer"]
class ModerateAvatarSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = [
"is_avatar_locked",
"avatar_lock_user_message",
"avatar_lock_staff_message",
]
| 440
|
Python
|
.py
| 13
| 27.615385
| 60
| 0.692671
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,573
|
username.py
|
rafalp_Misago/misago/users/serializers/username.py
|
from django.contrib.auth import get_user_model
from django.utils.translation import pgettext
from rest_framework import serializers
from ..validators import validate_username
User = get_user_model()
class ChangeUsernameSerializer(serializers.Serializer):
username = serializers.CharField(max_length=200, required=False, allow_blank=True)
def validate(self, data):
username = data.get("username")
if not username:
raise serializers.ValidationError(
pgettext("change username serializer", "Enter new username.")
)
user = self.context["user"]
if username == user.username:
raise serializers.ValidationError(
pgettext(
"change username serializer", "New username is same as current one."
)
)
settings = self.context["settings"]
validate_username(settings, username)
return data
def change_username(self, changed_by):
user = self.context["user"]
user.set_username(self.validated_data["username"], changed_by=changed_by)
user.save(update_fields=["username", "slug"])
| 1,178
|
Python
|
.py
| 27
| 34.592593
| 88
| 0.662872
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,574
|
conftest.py
|
rafalp_Misago/misago/icons/conftest.py
|
import pytest
from .models import Icon
@pytest.fixture
def favicon(db):
return Icon.objects.create(
type=Icon.TYPE_FAVICON, image="static/favicon.png", size=1, width=48, height=48
)
@pytest.fixture
def favicon_32(db):
return Icon.objects.create(
type=Icon.TYPE_FAVICON_32,
image="static/favicon-32.png",
size=1,
width=32,
height=32,
)
@pytest.fixture
def favicon_16(db):
return Icon.objects.create(
type=Icon.TYPE_FAVICON_16,
image="static/favicon-16.png",
size=1,
width=16,
height=16,
)
@pytest.fixture
def apple_touch_icon(db):
return Icon.objects.create(
type=Icon.TYPE_APPLE_TOUCH_ICON,
image="static/test.png",
size=1,
width=180,
height=180,
)
| 818
|
Python
|
.py
| 34
| 18.088235
| 87
| 0.630968
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,575
|
models.py
|
rafalp_Misago/misago/icons/models.py
|
from django.db import models
class Icon(models.Model):
TYPE_FAVICON = "favicon"
TYPE_FAVICON_32 = "favicon_32"
TYPE_FAVICON_16 = "favicon_16"
TYPE_APPLE_TOUCH_ICON = "apple_touch_icon"
FAVICON_TYPES = (TYPE_FAVICON, TYPE_FAVICON_32, TYPE_FAVICON_16)
type = models.CharField(max_length=255)
image = models.ImageField(
upload_to="icon", height_field="height", width_field="width"
)
size = models.PositiveIntegerField(default=0)
width = models.PositiveIntegerField(default=0)
height = models.PositiveIntegerField(default=0)
def delete(self, *args, **kwargs):
if self.image:
self.image.delete(save=False)
return super().delete(*args, **kwargs)
| 730
|
Python
|
.py
| 18
| 34.555556
| 68
| 0.686969
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,576
|
apps.py
|
rafalp_Misago/misago/icons/apps.py
|
from django.apps import AppConfig
class MisagoIconsConfig(AppConfig):
name = "misago.icons"
label = "misago_icons"
verbose_name = "Misago Icons"
| 159
|
Python
|
.py
| 5
| 28
| 35
| 0.743421
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,577
|
context_processors.py
|
rafalp_Misago/misago/icons/context_processors.py
|
from .models import Icon
def icons(request):
return {"icons": {i.type: i.image.url for i in Icon.objects.all()}}
| 119
|
Python
|
.py
| 3
| 36.666667
| 71
| 0.701754
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,578
|
0001_initial.py
|
rafalp_Misago/misago/icons/migrations/0001_initial.py
|
# Generated by Django 2.2.1 on 2019-06-09 19:13
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name="Icon",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("type", models.CharField(max_length=255)),
(
"image",
models.ImageField(
height_field="height", upload_to="icon", width_field="width"
),
),
("size", models.PositiveIntegerField(default=0)),
("width", models.PositiveIntegerField(default=0)),
("height", models.PositiveIntegerField(default=0)),
],
)
]
| 1,069
|
Python
|
.py
| 31
| 19.258065
| 84
| 0.440465
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,579
|
test_icons_markup.py
|
rafalp_Misago/misago/icons/tests/test_icons_markup.py
|
from ...test import assert_contains
def test_favicon_html_is_present_in_html_if_set(client, favicon):
response = client.get("/")
assert_contains(response, favicon.image.url)
def test_favicon_32_html_is_present_in_html_if_set(client, favicon_32):
response = client.get("/")
assert_contains(response, favicon_32.image.url)
def test_favicon_16_html_is_present_in_html_if_set(client, favicon_16):
response = client.get("/")
assert_contains(response, favicon_16.image.url)
def test_apple_touch_icon_html_is_present_in_html_if_set(client, apple_touch_icon):
response = client.get("/")
assert_contains(response, apple_touch_icon.image.url)
| 673
|
Python
|
.py
| 13
| 47.692308
| 83
| 0.73773
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,580
|
test_icons_context_processor.py
|
rafalp_Misago/misago/icons/tests/test_icons_context_processor.py
|
from ..context_processors import icons
from ..models import Icon
def test_context_processor_adds_icons_key_to_context(db):
assert "icons" in icons(None)
def test_icons_context_defaults_to_empty_dict(db):
assert icons(None) == {"icons": {}}
def test_set_favicon_icon_is_present_in_context(favicon):
assert Icon.TYPE_FAVICON in icons(None)["icons"]
def test_set_favicon_32_icon_is_present_in_context(favicon_32):
assert Icon.TYPE_FAVICON_32 in icons(None)["icons"]
def test_set_favicon_16_icon_is_present_in_context(favicon_16):
assert Icon.TYPE_FAVICON_16 in icons(None)["icons"]
def test_set_apple_touch_icon_icon_is_present_in_context(apple_touch_icon):
assert Icon.TYPE_APPLE_TOUCH_ICON in icons(None)["icons"]
| 749
|
Python
|
.py
| 14
| 49.928571
| 75
| 0.753804
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,581
|
__init__.py
|
rafalp_Misago/misago/icons/admin/__init__.py
|
from django.urls import path
from django.utils.translation import pgettext_lazy
from .views import icons_admin
class MisagoAdminExtension:
def register_urlpatterns(self, urlpatterns):
# Icons
urlpatterns.namespace("icons/", "icons", "settings")
urlpatterns.patterns("settings:icons", path("", icons_admin, name="index"))
def register_navigation_nodes(self, site):
site.add_node(
name=pgettext_lazy("admin node", "Icons"),
description=pgettext_lazy(
"admin node", "Upload favicon and application icon for the site."
),
parent="settings",
namespace="icons",
)
| 686
|
Python
|
.py
| 17
| 31.823529
| 83
| 0.645113
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,582
|
forms.py
|
rafalp_Misago/misago/icons/admin/forms.py
|
from io import BytesIO
from PIL import Image
from django import forms
from django.core.files.base import ContentFile
from django.utils.translation import pgettext_lazy
from ...core.utils import get_file_hash
from ...core.validators import validate_image_square
from ..models import Icon
FAVICON_MIN_SIZE = 48
FAVICON_SIZES = ((16, 16), (32, 32), (48, 48))
APPLE_TOUCH_MIN_SIZE = 180
VALID_MIME = ("image/gif", "image/jpeg", "image/png")
class IconsForm(forms.Form):
favicon = forms.ImageField(
label=pgettext_lazy("admin icons form", "Upload image"),
help_text=pgettext_lazy(
"admin icons form",
"Uploaded image should be a square that is 48px wide and tall.",
),
required=False,
)
favicon_delete = forms.BooleanField(
label=pgettext_lazy("admin icons form", "Delete custom icon"), required=False
)
apple_touch_icon = forms.ImageField(
label=pgettext_lazy("admin icons form", "Upload image"),
help_text=pgettext_lazy(
"admin icons form",
"Uploaded image should be square at least 180px wide and tall.",
),
required=False,
)
apple_touch_icon_delete = forms.BooleanField(
label=pgettext_lazy("admin icons form", "Delete custom icon"), required=False
)
def clean_favicon(self):
upload = self.cleaned_data.get("favicon")
if not upload or upload == self.initial.get("favicon"):
return None
validate_image_square(upload.image)
validate_image_dimensions(upload.image, FAVICON_MIN_SIZE)
validate_image_mime_type(upload)
return upload
def clean_apple_touch_icon(self):
upload = self.cleaned_data.get("apple_touch_icon")
if not upload or upload == self.initial.get("apple_touch_icon"):
return None
validate_image_square(upload.image)
validate_image_dimensions(upload.image, APPLE_TOUCH_MIN_SIZE)
validate_image_mime_type(upload)
return upload
def save(self):
if self.cleaned_data.get("favicon"):
self.save_favicon(self.cleaned_data["favicon"])
elif self.cleaned_data.get("favicon_delete"):
self.delete_icons(Icon.FAVICON_TYPES)
if self.cleaned_data.get("apple_touch_icon"):
self.save_apple_touch_icon(self.cleaned_data["apple_touch_icon"])
elif self.cleaned_data.get("apple_touch_icon_delete"):
self.delete_icons([Icon.TYPE_APPLE_TOUCH_ICON])
def save_favicon(self, image):
self.delete_icons(Icon.FAVICON_TYPES)
save_favicon(image)
save_icon(image, (32, 32), Icon.TYPE_FAVICON_32)
save_icon(image, (16, 16), Icon.TYPE_FAVICON_16)
def save_apple_touch_icon(self, image):
self.delete_icons([Icon.TYPE_APPLE_TOUCH_ICON])
save_icon(image, (180, 180), Icon.TYPE_APPLE_TOUCH_ICON)
def delete_icons(self, icon_types):
for icon in Icon.objects.filter(type__in=icon_types):
icon.delete()
def save_favicon(image):
icon = Image.open(image)
buffer = BytesIO()
icon.save(buffer, "ICO", sizes=FAVICON_SIZES)
buffer.seek(0)
icon_file = ContentFile(buffer.read())
icon_file.name = "%s.%s.ico" % ("favicon", get_file_hash(icon_file))
Icon.objects.create(type=Icon.TYPE_FAVICON, image=icon_file, size=icon_file.size)
def save_icon(image, size, icon_type):
icon = Image.open(image)
icon.thumbnail(size)
buffer = BytesIO()
icon.save(buffer, "PNG")
buffer.seek(0)
icon_file = ContentFile(buffer.read())
icon_file.name = "%s.%s.png" % (
icon_type.replace("_", "-"),
get_file_hash(icon_file),
)
Icon.objects.create(type=icon_type, image=icon_file, size=icon_file.size)
def validate_image_dimensions(image, size):
if image.width < size:
raise forms.ValidationError(
pgettext_lazy(
"admin icons form",
"Uploaded image's edge should be at least %(size)s pixels long.",
)
% {"size": size}
)
def validate_image_mime_type(upload):
if upload.content_type not in VALID_MIME:
raise forms.ValidationError(
pgettext_lazy(
"admin icons form", "Uploaded image was not gif, jpeg or png."
)
)
| 4,357
|
Python
|
.py
| 107
| 33.065421
| 85
| 0.647463
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,583
|
views.py
|
rafalp_Misago/misago/icons/admin/views.py
|
from django.contrib import messages
from django.shortcuts import redirect
from django.utils.translation import pgettext
from ...admin.views import render
from ..models import Icon
from .forms import IconsForm
def icons_admin(request):
form = IconsForm()
if request.method == "POST":
form = IconsForm(request.POST, request.FILES)
if form.is_valid():
form.save()
messages.success(
request, pgettext("admin icons", "Icons have been updated.")
)
return redirect("misago:admin:settings:icons:index")
return render(
request, "misago/admin/icons.html", {"form": form, "icons": get_icons()}
)
def get_icons():
return {i.type: i for i in Icon.objects.all()}
| 764
|
Python
|
.py
| 21
| 29.904762
| 80
| 0.664402
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,584
|
conftest.py
|
rafalp_Misago/misago/icons/admin/tests/conftest.py
|
from io import BytesIO
import pytest
from PIL import Image
from django.urls import reverse
@pytest.fixture
def admin_link():
return reverse("misago:admin:settings:icons:index")
def get_image(width, height):
image = Image.new("RGBA", (width, height))
buffer = BytesIO()
image.save(buffer, "PNG")
buffer.seek(0)
return buffer.read()
@pytest.fixture
def image():
return get_image(185, 185)
@pytest.fixture
def image_alt():
return get_image(85, 85)
@pytest.fixture
def image_non_square():
return get_image(180, 200)
@pytest.fixture
def image_small():
return get_image(20, 20)
| 625
|
Python
|
.py
| 25
| 21.88
| 55
| 0.729131
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,585
|
test_favicon.py
|
rafalp_Misago/misago/icons/admin/tests/test_favicon.py
|
import os
import pytest
from django.core.files.uploadedfile import SimpleUploadedFile
from ...models import Icon
@pytest.fixture
def favicon(db, image_alt):
return Icon.objects.create(
type=Icon.TYPE_FAVICON,
image=SimpleUploadedFile("favicon.png", image_alt, "image/png"),
)
@pytest.fixture
def favicon_32(db, image_alt):
return Icon.objects.create(
type=Icon.TYPE_FAVICON_32,
image=SimpleUploadedFile("favicon-32.png", image_alt, "image/png"),
)
@pytest.fixture
def favicon_16(db, image_alt):
return Icon.objects.create(
type=Icon.TYPE_FAVICON_16,
image=SimpleUploadedFile("favicon-16.png", image_alt, "image/png"),
)
def test_uploading_favicon_sets_favicon_images(admin_client, admin_link, image):
admin_client.post(
admin_link, {"favicon": SimpleUploadedFile("image.png", image, "image/png")}
)
Icon.objects.get(type=Icon.TYPE_FAVICON)
Icon.objects.get(type=Icon.TYPE_FAVICON_32)
Icon.objects.get(type=Icon.TYPE_FAVICON_16)
def test_uploading_favicon_removes_existing_favicon_images(
admin_client, admin_link, image, favicon, favicon_32, favicon_16
):
admin_client.post(
admin_link, {"favicon": SimpleUploadedFile("image.png", image, "image/png")}
)
with pytest.raises(Icon.DoesNotExist):
favicon.refresh_from_db()
with pytest.raises(Icon.DoesNotExist):
favicon_32.refresh_from_db()
with pytest.raises(Icon.DoesNotExist):
favicon_16.refresh_from_db()
def test_uploading_new_favicon_removes_old_one_image_file(
admin_client, admin_link, image, favicon, favicon_32, favicon_16
):
admin_client.post(
admin_link, {"favicon": SimpleUploadedFile("image.png", image, "image/png")}
)
assert not os.path.exists(favicon.image.path)
assert not os.path.exists(favicon_32.image.path)
assert not os.path.exists(favicon_16.image.path)
def test_submitting_form_without_new_icon_does_not_delete_old_favicon_images(
admin_client, admin_link, favicon, favicon_32, favicon_16
):
admin_client.post(admin_link, {})
favicon.refresh_from_db()
favicon_32.refresh_from_db()
favicon_16.refresh_from_db()
def test_favicon_can_be_deleted_without_setting_new_one(
admin_client, admin_link, favicon, favicon_32, favicon_16
):
admin_client.post(admin_link, {"favicon_delete": "1"})
with pytest.raises(Icon.DoesNotExist):
favicon.refresh_from_db()
with pytest.raises(Icon.DoesNotExist):
favicon_32.refresh_from_db()
with pytest.raises(Icon.DoesNotExist):
favicon_16.refresh_from_db()
def test_deleting_icon_also_deletes_its_image_files(
admin_client, admin_link, favicon, favicon_32, favicon_16
):
admin_client.post(admin_link, {"favicon_delete": "1"})
assert not os.path.exists(favicon.image.path)
assert not os.path.exists(favicon_32.image.path)
assert not os.path.exists(favicon_16.image.path)
def test_uploading_invalid_icon_does_not_remove_current_icon(
admin_client, admin_link, favicon, favicon_32, favicon_16, image_small
):
admin_client.post(
admin_link,
{"favicon": SimpleUploadedFile("image.png", image_small, "image/png")},
)
favicon.refresh_from_db()
favicon_32.refresh_from_db()
favicon_16.refresh_from_db()
def test_icon_is_not_set_because_it_was_not_square(
admin_client, admin_link, image_non_square
):
admin_client.post(
admin_link,
{"favicon": SimpleUploadedFile("image.png", image_non_square, "image/png")},
)
assert not Icon.objects.exists()
def test_icon_is_not_set_because_it_was_too_small(
admin_client, admin_link, image_small
):
admin_client.post(
admin_link,
{"favicon": SimpleUploadedFile("image.png", image_small, "image/png")},
)
assert not Icon.objects.exists()
| 3,876
|
Python
|
.py
| 100
| 33.64
| 84
| 0.709091
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,586
|
test_apple_touch_icon.py
|
rafalp_Misago/misago/icons/admin/tests/test_apple_touch_icon.py
|
import os
import pytest
from django.core.files.uploadedfile import SimpleUploadedFile
from ...models import Icon
@pytest.fixture
def apple_touch_icon(db, image):
return Icon.objects.create(
type=Icon.TYPE_APPLE_TOUCH_ICON,
image=SimpleUploadedFile("image.png", image, "image/png"),
)
def test_new_touch_icon_can_be_set(admin_client, admin_link, image):
admin_client.post(
admin_link,
{"apple_touch_icon": SimpleUploadedFile("image.png", image, "image/png")},
)
Icon.objects.get(type=Icon.TYPE_APPLE_TOUCH_ICON)
def test_setting_new_touch_icon_removes_old_one(
admin_client, admin_link, image, apple_touch_icon
):
admin_client.post(
admin_link,
{"apple_touch_icon": SimpleUploadedFile("image.png", image, "image/png")},
)
with pytest.raises(Icon.DoesNotExist):
apple_touch_icon.refresh_from_db()
def test_setting_new_touch_icon_removes_old_one_image_file(
admin_client, admin_link, image, apple_touch_icon
):
admin_client.post(
admin_link,
{"apple_touch_icon": SimpleUploadedFile("image.png", image, "image/png")},
)
assert not os.path.exists(apple_touch_icon.image.path)
def test_submitting_form_without_new_icon_does_not_delete_old_one(
admin_client, admin_link, apple_touch_icon
):
admin_client.post(admin_link, {})
apple_touch_icon.refresh_from_db()
def test_icon_can_be_deleted_without_setting_new_one(
admin_client, admin_link, apple_touch_icon
):
admin_client.post(admin_link, {"apple_touch_icon_delete": "1"})
with pytest.raises(Icon.DoesNotExist):
apple_touch_icon.refresh_from_db()
def test_deleting_icon_also_deletes_its_image_file(
admin_client, admin_link, apple_touch_icon
):
admin_client.post(admin_link, {"apple_touch_icon_delete": "1"})
assert not os.path.exists(apple_touch_icon.image.path)
def test_uploading_invalid_icon_does_not_remove_current_icon(
admin_client, admin_link, apple_touch_icon, image_small
):
admin_client.post(
admin_link,
{"apple_touch_icon": SimpleUploadedFile("image.png", image_small, "image/png")},
)
apple_touch_icon.refresh_from_db()
def test_icon_is_not_set_because_it_was_not_square(
admin_client, admin_link, image_non_square
):
admin_client.post(
admin_link,
{
"apple_touch_icon": SimpleUploadedFile(
"image.png", image_non_square, "image/png"
)
},
)
assert not Icon.objects.exists()
def test_icon_is_not_set_because_it_was_too_small(
admin_client, admin_link, image_small
):
admin_client.post(
admin_link,
{"apple_touch_icon": SimpleUploadedFile("image.png", image_small, "image/png")},
)
assert not Icon.objects.exists()
| 2,811
|
Python
|
.py
| 77
| 31.090909
| 88
| 0.690318
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,587
|
test_icons_view.py
|
rafalp_Misago/misago/icons/admin/tests/test_icons_view.py
|
from ....test import assert_contains
def test_icons_admin_view_displays(admin_client, admin_link):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_set_favicon_displays(admin_client, admin_link, favicon):
response = admin_client.get(admin_link)
assert_contains(response, favicon.image.url)
def test_set_favicon_32_displays(admin_client, admin_link, favicon_32):
response = admin_client.get(admin_link)
assert_contains(response, favicon_32.image.url)
def test_set_favicon_16_displays(admin_client, admin_link, favicon_16):
response = admin_client.get(admin_link)
assert_contains(response, favicon_16.image.url)
def test_set_apple_touch_icon_displays(admin_client, admin_link, apple_touch_icon):
response = admin_client.get(admin_link)
assert_contains(response, apple_touch_icon.image.url)
| 873
|
Python
|
.py
| 16
| 50.4375
| 83
| 0.765053
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,588
|
plaintext.py
|
rafalp_Misago/misago/parser/plaintext.py
|
import re
from ..core.utils import slugify
from .context import ParserContext
from .enums import PlainTextFormat
from .exceptions import AstError
from .hooks import render_ast_node_to_plaintext_hook
from .urls import clean_href
def render_ast_to_plaintext(
context: ParserContext,
ast: list[dict],
metadata: dict,
text_format: str | None = None,
) -> str:
plain_text = []
for ast_node in ast:
node_text = render_ast_node_to_plaintext(
context,
ast_node,
metadata,
text_format,
).strip()
if node_text:
plain_text.append(node_text)
text = (" ".join(plain_text)).strip()
if text_format in (
PlainTextFormat.META_DESCRIPTION,
PlainTextFormat.SEARCH_DOCUMENT,
):
return re.sub("\s\s+", " ", text)
return text
def render_inline_ast_to_plaintext(
context: ParserContext,
ast: list[dict],
metadata: dict,
text_format: str | None = None,
) -> str:
plain_text = ""
for ast_node in ast:
plain_text += render_ast_node_to_plaintext(
context,
ast_node,
metadata,
text_format,
)
return plain_text
def render_ast_node_to_plaintext(
context: ParserContext,
ast_node: dict,
metadata: dict,
text_format: str | None,
) -> str:
return render_ast_node_to_plaintext_hook(
_render_ast_node_to_plaintext_action,
context,
ast_node,
metadata,
text_format,
)
AST_INLINE_NODES = (
"heading",
"heading-setex",
"paragraph",
"emphasis",
"emphasis-underscore",
"strong",
"strong-underscore",
"strikethrough",
"strikethrough-bbcode",
"bold-bbcode",
"italics-bbcode",
"underline-bbcode",
"superscript-bbcode",
"subscript-bbcode",
)
def _render_ast_node_to_plaintext_action(
context: ParserContext,
ast_node: dict,
metadata: dict,
text_format: str | None,
) -> str:
ast_type = ast_node["type"]
if ast_type in AST_INLINE_NODES:
return render_inline_ast_to_plaintext(
context, ast_node["children"], metadata, text_format
).strip()
if ast_type == "list":
items: list[str] = []
for i, ast_item in enumerate(ast_node["items"]):
if children := render_inline_ast_to_plaintext(
context, ast_item["children"], metadata, text_format
).strip():
item = ""
if ast_node["ordered"]:
item += f"{i + 1}."
else:
item += ast_node["sign"]
item += " " + children
if lists := render_ast_to_plaintext(
context, ast_item["lists"], metadata, text_format
):
item += " " + lists
items.append(item)
return " ".join(items)
if ast_type in ("code", "code-bbcode", "code-indented"):
code_lines = [
line.strip() for line in ast_node["code"].splitlines() if line.strip()
]
if syntax := ast_node["syntax"]:
return f"{syntax}: " + " ".join(code_lines)
return " ".join(code_lines)
if ast_type == "code-inline":
return ast_node["code"]
if ast_type in ("quote", "quote-bbcode"):
children = render_ast_to_plaintext(
context, ast_node["children"], metadata, text_format
)
if author := ast_node.get("author"):
return f"{author}: {children}"
return children
if ast_type == "spoiler-bbcode":
children = render_ast_to_plaintext(
context, ast_node["children"], metadata, text_format
)
if summary := ast_node["summary"]:
return f"{summary}: {children}"
return children
if ast_type in ("image", "image-bbcode"):
alt = ast_node["alt"] or ""
if text_format == PlainTextFormat.META_DESCRIPTION:
return alt
src = clean_href(ast_node["src"])
return f"{alt} {src}".strip()
if ast_type in ("url", "url-bbcode"):
href = clean_href(ast_node["href"])
if children := render_inline_ast_to_plaintext(
context, ast_node["children"], metadata, text_format
).strip():
if text_format == PlainTextFormat.META_DESCRIPTION:
return children
else:
return f"{children} {href}"
if text_format == PlainTextFormat.META_DESCRIPTION:
return ""
return href
if ast_type in ("auto-link", "auto-url"):
if text_format == PlainTextFormat.META_DESCRIPTION:
return ""
return clean_href(ast_node["href"])
if ast_type == "mention":
username = slugify(ast_node["username"])
if username not in metadata["users"]:
return "@" + ast_node["username"]
user = metadata["users"][username]
return "@" + user.username
if ast_type == "escape":
return ast_node["character"]
if ast_type in ("thematic-break", "thematic-break-bbcode", "line-break"):
return " "
if ast_type == "text":
return ast_node["text"]
raise AstError(f"Unknown AST node type: {ast_type}")
| 5,321
|
Python
|
.py
| 161
| 24.614907
| 82
| 0.570815
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,589
|
context.py
|
rafalp_Misago/misago/parser/context.py
|
from dataclasses import dataclass
from django.contrib.auth import get_user_model
from django.contrib.auth.models import AnonymousUser
from django.http import HttpRequest
from ..conf.dynamicsettings import DynamicSettings
from ..permissions.proxy import UserPermissionsProxy
from .forumaddress import ForumAddress
from .hooks import setup_parser_context_hook
User = get_user_model()
@dataclass(frozen=True)
class ParserContext:
content_type: str | None
forum_address: ForumAddress
request: HttpRequest | None
user: User | AnonymousUser
user_permissions: UserPermissionsProxy
cache_versions: dict
settings: DynamicSettings
plugin_data: dict
def create_parser_context(
request: HttpRequest | None = None,
*,
user_permissions: UserPermissionsProxy | None = None,
cache_versions: dict | None = None,
settings: DynamicSettings | None = None,
content_type: str | None = None,
) -> ParserContext:
data = {
"user_permissions": None,
"user": None,
"cache_versions": None,
"settings": None,
"plugin_data": {},
}
if user_permissions:
data["user"] = user_permissions.user
data["user_permissions"] = user_permissions
elif request:
data["user"] = request.user
data["user_permissions"] = request.user_permissions
else:
raise TypeError(
"'user_permissions' argument is required if 'request' is not set"
)
if cache_versions:
data["cache_versions"] = cache_versions
elif request:
data["cache_versions"] = request.cache_versions
else:
raise TypeError("'cache_versions' argument is required if 'request' is not set")
if settings:
data["settings"] = settings
elif request:
data["settings"] = request.settings
else:
raise TypeError("'settings' argument is required if 'request' is not set")
context = ParserContext(
content_type=content_type,
forum_address=ForumAddress(data["settings"]),
request=request,
**data,
)
if not setup_parser_context_hook:
return context
return setup_parser_context_hook(_context_lambda, context)
_context_lambda = lambda c: c
| 2,250
|
Python
|
.py
| 66
| 28.257576
| 88
| 0.689719
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,590
|
enums.py
|
rafalp_Misago/misago/parser/enums.py
|
from enum import StrEnum
class ContentType(StrEnum):
GROUP_DESCRIPTION = "group-description"
POST = "post"
SIGNATURE = "signature"
class PlainTextFormat(StrEnum):
META_DESCRIPTION = "meta_description"
SEARCH_DOCUMENT = "search_document"
| 261
|
Python
|
.py
| 8
| 28.625
| 43
| 0.751004
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,591
|
factory.py
|
rafalp_Misago/misago/parser/factory.py
|
from typing import Callable
from django.contrib.auth import get_user_model
from .context import ParserContext
from .hooks import create_parser_hook
from .parser import Parser, Pattern
from .patterns import block_patterns, inline_patterns
from .postprocessors import post_processors
User = get_user_model()
def create_parser(context: ParserContext) -> Parser:
return create_parser_hook(
_create_parser_action,
context,
block_patterns=block_patterns.copy(),
inline_patterns=inline_patterns.copy(),
post_processors=post_processors.copy(),
)
def _create_parser_action(
context: ParserContext,
*,
block_patterns: list[Pattern],
inline_patterns: list[Pattern],
post_processors: list[Callable[[Parser, list[dict]], list[dict]]],
) -> Parser:
return Parser(block_patterns, inline_patterns, post_processors)
| 878
|
Python
|
.py
| 24
| 32.291667
| 70
| 0.744982
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,592
|
forumaddress.py
|
rafalp_Misago/misago/parser/forumaddress.py
|
from django.conf import settings
from ..conf.dynamicsettings import DynamicSettings
class ForumAddress:
current_address: str | None
hostnames: list[str]
def __init__(self, settings_: DynamicSettings | None):
self.current_address = settings_.forum_address or None
self.hostnames = []
if settings_.forum_address:
self.hostnames.append(self.get_hostname(settings_.forum_address))
for historic_address in settings.MISAGO_FORUM_ADDRESS_HISTORY:
self.hostnames.append(self.get_hostname(historic_address))
def is_inbound_link(self, link: str) -> bool:
return self.get_hostname(link) in self.hostnames
def get_hostname(self, link: str) -> str:
if "://" in link:
link = link[link.index("://") + 3 :]
if "/" in link:
link = link[: link.index("/")]
return link.lower()
| 899
|
Python
|
.py
| 20
| 36.9
| 77
| 0.648276
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,593
|
urls.py
|
rafalp_Misago/misago/parser/urls.py
|
def clean_href(href: str) -> str:
if href.startswith("://"):
return "http" + href
if "://" not in href:
return "http://" + href
return href
| 168
|
Python
|
.py
| 6
| 22.333333
| 33
| 0.537037
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,594
|
apps.py
|
rafalp_Misago/misago/parser/apps.py
|
from django.apps import AppConfig
class MisagoParserConfig(AppConfig):
name = "misago.parser"
label = "misago_parser"
verbose_name = "Misago Parser"
| 163
|
Python
|
.py
| 5
| 28.8
| 36
| 0.75
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,595
|
metadata.py
|
rafalp_Misago/misago/parser/metadata.py
|
from typing import Iterable
from django.conf import settings
from django.contrib.auth import get_user_model
from ..core.utils import slugify
from .context import ParserContext
from .hooks import (
get_ast_metadata_users_queryset_hook,
update_ast_metadata_hook,
update_ast_metadata_from_node_hook,
update_ast_metadata_users_hook,
)
User = get_user_model()
def create_ast_metadata(
context: ParserContext,
ast: list[dict],
) -> dict:
metadata = {
"outbound-links": set(),
"usernames": set(),
"users": {},
"posts": {
"ids": set(),
"objs": {},
},
}
return update_ast_metadata_hook(_update_ast_metadata_action, context, ast, metadata)
def _update_ast_metadata_action(
context: ParserContext,
ast: list[dict],
metadata: dict,
) -> dict:
for ast_node in ast:
update_ast_metadata_from_node(context, ast_node, metadata)
update_ast_metadata_users(context, metadata)
return metadata
def update_ast_metadata_from_node(
context: ParserContext,
ast_node: dict,
metadata: dict,
) -> None:
update_ast_metadata_from_node_hook(
_update_ast_metadata_from_node_action, context, ast_node, metadata
)
def _update_ast_metadata_from_node_action(
context: ParserContext,
ast_node: dict,
metadata: dict,
) -> None:
if ast_node["type"] == "mention":
metadata["usernames"].add(slugify(ast_node["username"]))
elif ast_node["type"] == "quote-bbcode":
if ast_node["author"]:
metadata["usernames"].add(slugify(ast_node["author"]))
if ast_node["post"]:
metadata["posts"]["ids"].add(ast_node["post"])
elif ast_node["type"] in ("auto-link", "auto-url", "url", "url-bbcode"):
if not context.forum_address.is_inbound_link(ast_node["href"]):
metadata["outbound-links"].add(ast_node["href"])
if ast_node.get("children"):
for child_node in ast_node["children"]:
update_ast_metadata_from_node(context, child_node, metadata)
if ast_node.get("items"):
for child_node in ast_node["items"]:
update_ast_metadata_from_node(context, child_node, metadata)
if ast_node.get("lists"):
for child_node in ast_node["lists"]:
update_ast_metadata_from_node(context, child_node, metadata)
def update_ast_metadata_users(context: ParserContext, metadata: dict) -> None:
update_ast_metadata_users_hook(_update_ast_metadata_users_action, context, metadata)
def _update_ast_metadata_users_action(context: ParserContext, metadata: dict) -> None:
if not metadata["usernames"]:
return
usernames = sorted(metadata["usernames"])
if len(usernames) > settings.MISAGO_PARSER_MAX_USERS:
return
if usernames:
queryset = get_ast_metadata_users_queryset(context, usernames)
for user in queryset:
metadata["users"][user.slug] = user
def get_ast_metadata_users_queryset(
context: ParserContext, usernames: list[str]
) -> Iterable[User]:
return get_ast_metadata_users_queryset_hook(
_get_ast_metadata_users_queryset_action, context, usernames
)
def _get_ast_metadata_users_queryset_action(
context: ParserContext, usernames: list[str]
) -> Iterable[User]:
return User.objects.filter(slug__in=usernames)
| 3,370
|
Python
|
.py
| 89
| 31.865169
| 88
| 0.669742
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,596
|
html.py
|
rafalp_Misago/misago/parser/html.py
|
from html import escape
from django.utils.translation import pgettext
from ..core.utils import slugify
from .context import ParserContext
from .exceptions import AstError
from .hooks import complete_markup_html_hook, render_ast_node_to_html_hook
from .urls import clean_href
SPOILER_SUMMARY = "<spoiler-summary-message>"
def render_ast_to_html(context: ParserContext, ast: list[dict], metadata: dict) -> str:
html = ""
for ast_node in ast:
node_html = render_ast_node_to_html(context, ast_node, metadata)
if node_html:
html += node_html
return html
def render_ast_node_to_html(
context: ParserContext, ast_node: dict, metadata: dict
) -> str:
return render_ast_node_to_html_hook(
_render_ast_node_to_html_action, context, ast_node, metadata
)
def _render_ast_node_to_html_action(
context: ParserContext, ast_node: dict, metadata: dict
) -> str:
ast_type = ast_node["type"]
if ast_type in ("heading", "heading-setex"):
html_tag = f"h{ast_node['level']}"
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<{html_tag}>{children}</{html_tag}>"
if ast_type == "list":
html_tag = "ol" if ast_node["ordered"] else "ul"
children = render_ast_to_html(context, ast_node["items"], metadata)
return f"<{html_tag}>{children}</{html_tag}>"
if ast_type == "list-item":
text = render_ast_to_html(context, ast_node["children"], metadata)
children = render_ast_to_html(context, ast_node["lists"], metadata)
return f"<li>{text}{children}</li>"
if ast_type in ("code", "code-bbcode"):
if ast_node["syntax"]:
html_class = f" class=\"language-{ast_node['syntax']}\""
else:
html_class = ""
return f"<pre{html_class}><code>{escape(ast_node['code'])}</code></pre>"
if ast_type == "code-indented":
return f"<pre><code>{escape(ast_node['code'])}</code></pre>"
if ast_type == "code-inline":
return f"<code>{escape(ast_node['code'])}</code>"
if ast_type == "quote":
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<blockquote>{children}</blockquote>"
if ast_type == "quote-bbcode":
children = render_ast_to_html(context, ast_node["children"], metadata)
if not ast_node["author"]:
return f"<blockquote>{children}</blockquote>"
heading = escape(ast_node["author"])
return (
'<aside class="quote-block">'
f'<div class="quote-heading" data-noquote="1">{heading}</div>'
f'<blockquote class="quote-body">{children}</blockquote>'
"</aside>"
)
if ast_type == "spoiler-bbcode":
if ast_node["summary"]:
summary = escape(ast_node["summary"])
else:
summary = SPOILER_SUMMARY
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<details><summary>{summary}</summary>{children}</details>"
if ast_type == "paragraph":
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<p>{children}</p>"
if ast_type in ("emphasis", "emphasis-underscore"):
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<em>{children}</em>"
if ast_type in ("strong", "strong-underscore"):
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<strong>{children}</strong>"
if ast_type in ("strikethrough", "strikethrough-bbcode"):
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<del>{children}</del>"
if ast_type == "bold-bbcode":
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<b>{children}</b>"
if ast_type == "italics-bbcode":
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<i>{children}</i>"
if ast_type == "underline-bbcode":
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<u>{children}</u>"
if ast_type == "superscript-bbcode":
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<sup>{children}</sup>"
if ast_type == "subscript-bbcode":
children = render_ast_to_html(context, ast_node["children"], metadata)
return f"<sub>{children}</sub>"
if ast_type in ("thematic-break", "thematic-break-bbcode"):
return "<hr />"
if ast_type in ("image", "image-bbcode"):
src = escape(clean_href(ast_node["src"]))
alt = escape(ast_node["alt"]) if ast_node["alt"] else ""
return f'<img src="{src}" alt="{alt}" />'
if ast_type in ("url", "url-bbcode"):
children = render_ast_to_html(context, ast_node["children"], metadata)
href = escape(clean_href(ast_node["href"]))
rel = "external nofollow noopener"
return f'<a href="{href}" rel="{rel}" target="_blank">{children or href}</a>'
if ast_type in ("auto-link", "auto-url"):
href = escape(clean_href(ast_node["href"]))
rel = "external nofollow noopener"
if ast_node.get("image"):
return f'<img src="{href}" alt="" />'
else:
return f'<a href="{href}" rel="{rel}" target="_blank">{href}</a>'
if ast_type == "mention":
username = slugify(ast_node["username"])
if username not in metadata["users"]:
return escape("@" + ast_node["username"])
user = metadata["users"][username]
return f'<a href="{user.get_absolute_url()}">@{escape(user.username)}</a>'
if ast_type == "escape":
return escape(ast_node["character"])
if ast_type == "line-break":
return "<br />"
if ast_type == "text":
return escape(ast_node["text"])
raise AstError(f"Unknown AST node type: {ast_type}")
def complete_markup_html(html: str, **kwargs) -> str:
return complete_markup_html_hook(_complete_markup_html_action, html, **kwargs)
def _complete_markup_html_action(html: str, **kwargs) -> str:
html = complete_markup_html_spoiler_summary(html)
return html
def complete_markup_html_spoiler_summary(html: str) -> str:
if SPOILER_SUMMARY in html:
html = html.replace(
SPOILER_SUMMARY, pgettext("spoiler summary", "Reveal spoiler")
)
return html
| 6,514
|
Python
|
.py
| 137
| 39.89781
| 87
| 0.620063
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,597
|
parents.py
|
rafalp_Misago/misago/parser/parents.py
|
from typing import Iterable
def has_invalid_parent(
invalid_parents: set[str] | None, parents: Iterable[str]
) -> bool:
if invalid_parents and invalid_parents.intersection(parents):
return True
return False
| 230
|
Python
|
.py
| 7
| 28.571429
| 65
| 0.736364
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,598
|
parser.py
|
rafalp_Misago/misago/parser/parser.py
|
import re
from functools import cached_property
from typing import Callable
from django.utils.crypto import get_random_string
class Pattern:
pattern_type: str
pattern: str
def parse(
self, parser: "Parser", match: str, parents: list[str]
) -> dict | list[dict]:
raise NotImplementedError()
class LineBreak(Pattern):
pattern_type = "line-break"
pattern = r" *\n *"
def parse(self, parser: "Parser", match: str, parents: list[str]) -> dict:
return {"type": self.pattern_type}
class Parser:
block_patterns: list[Pattern]
inline_patterns: list[Pattern]
post_processors: list[Callable[["Parser", list[dict]], list[dict]]]
reserve_inline_code = re.compile(r"`*`(.|\n)+?``*")
_reserved_patterns: dict[str, str]
def __init__(
self,
block_patterns: list[Pattern] | None = None,
inline_patterns: list[Pattern] | None = None,
post_processors: (
list[Callable[["Parser", list[dict]], list[dict]]] | None
) = None,
):
self.block_patterns = block_patterns or []
self.inline_patterns = inline_patterns or []
self.post_processors = post_processors or []
self._reserved_patterns = {}
def __call__(self, markup: str) -> list[dict]:
markup = self.reserve_patterns(markup)
ast = self.parse_blocks(markup, [])
for post_processor in self.post_processors:
ast = post_processor(self, ast)
return ast
def reserve_patterns(self, markup: str) -> str:
if not "`" in markup:
return markup
def replace_pattern(match):
match_str = match.group(0)
if match_str.startswith("``") or match_str.endswith("``"):
return match_str
pattern_id = f"%%{get_random_string(12)}%%"
while pattern_id in markup or pattern_id in self._reserved_patterns:
pattern_id = f"%%{get_random_string(12)}%%"
self._reserved_patterns[pattern_id] = match_str
return pattern_id
return self.reserve_inline_code.sub(replace_pattern, markup)
def reverse_reservations(self, value: str) -> str:
if not self._reserved_patterns or "%%" not in value:
return value
for pattern, org in self._reserved_patterns.items():
value = value.replace(pattern, org)
return value
def parse_blocks(self, markup: str, parents: list[str]) -> list[dict]:
cursor = 0
result: list[dict] = []
for m in self._block_re.finditer(markup):
for key, pattern in self._final_block_patterns.items():
block_match = m.group(key)
if block_match is not None:
start = m.start()
if start > cursor:
result += self.parse_paragraphs(markup[cursor:start], parents)
block_ast = pattern.parse(self, block_match, parents)
if isinstance(block_ast, list):
result += block_ast
elif isinstance(block_ast, dict):
result.append(block_ast)
cursor = m.end()
break
if cursor < len(markup):
result += self.parse_paragraphs(markup[cursor:], parents)
return result
def parse_paragraphs(self, markup: str, parents: list[str]) -> list[dict]:
markup = markup.strip()
if not markup:
return []
parents = parents + ["paragraph"]
result: list[dict] = []
for m in self._paragraph_re.finditer(markup):
result.append(
{
"type": "paragraph",
"children": self.parse_inline(
m.group(0).strip(), parents, reverse_reservations=True
),
}
)
return result
def parse_inline(
self,
markup: str,
parents: list[str],
reverse_reservations: bool = False,
) -> list[dict]:
if reverse_reservations:
markup = self.reverse_reservations(markup)
cursor = 0
result: list[dict] = []
for m in self._inline_re.finditer(markup):
for key, pattern in self._final_inline_patterns.items():
block_match = m.group(key)
if block_match is not None:
start = m.start()
if start > cursor:
if result and result[-1]["type"] == "text":
result[-1]["text"] += markup[cursor:start]
else:
result.append(
{"type": "text", "text": markup[cursor:start]}
)
inline_ast = pattern.parse(self, block_match, parents)
if isinstance(inline_ast, list):
for child in inline_ast:
if (
result
and child["type"] == "text"
and result[-1]["type"] == "text"
):
result[-1]["text"] += child["text"]
else:
result.append(child)
elif isinstance(inline_ast, dict):
if (
result
and inline_ast["type"] == "text"
and result[-1]["type"] == "text"
):
result[-1]["text"] += inline_ast["text"]
else:
result.append(inline_ast)
cursor = m.end()
break
if cursor < len(markup):
if result and result[-1]["type"] == "text":
result[-1]["text"] += markup[cursor:]
else:
result.append({"type": "text", "text": markup[cursor:]})
return result
@cached_property
def _final_block_patterns(self) -> dict[str, Pattern]:
patterns: list[Pattern] = self.block_patterns.copy()
return {f"b_{i}": pattern for i, pattern in enumerate(patterns)}
@cached_property
def _block_re(self) -> re.Pattern:
return self._build_re_pattern(self._final_block_patterns)
@cached_property
def _paragraph_re(self) -> re.Pattern:
return re.compile(r".+(\n.+)*")
@cached_property
def _final_inline_patterns(self) -> dict[str, Pattern]:
patterns: list[Pattern] = self.inline_patterns.copy()
patterns += [LineBreak()]
return {f"i_{i}": pattern for i, pattern in enumerate(patterns)}
@cached_property
def _inline_re(self) -> re.Pattern:
return self._build_re_pattern(self._final_inline_patterns)
def _build_re_pattern(self, patterns: dict[str, Pattern]) -> re.Pattern:
return re.compile(
"|".join(
f"(?P<{key}>{pattern.pattern})" for key, pattern in patterns.items()
),
re.IGNORECASE,
)
| 7,258
|
Python
|
.py
| 170
| 29.176471
| 86
| 0.516752
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,599
|
misago_markup.py
|
rafalp_Misago/misago/parser/templatetags/misago_markup.py
|
from django import template
from django.utils.safestring import mark_safe
from ..html import complete_markup_html
register = template.Library()
@register.simple_tag
def completemarkup(html: str, **kwargs):
return mark_safe(complete_markup_html(html, **kwargs))
| 269
|
Python
|
.py
| 7
| 36.285714
| 58
| 0.802326
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|