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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
18,000
|
search.py
|
rafalp_Misago/misago/threads/search.py
|
from django.contrib.postgres.search import (
SearchHeadline,
SearchQuery,
SearchRank,
SearchVector,
)
from django.utils.translation import pgettext_lazy
from ..conf import settings
from ..core.shortcuts import paginate, pagination_dict
from ..search import SearchProvider
from .filtersearch import filter_search
from .models import Post, Thread
from .permissions import exclude_invisible_threads
from .serializers import FeedSerializer
from .utils import add_categories_to_items
from .viewmodels import ThreadsRootCategory
class SearchThreads(SearchProvider):
name = pgettext_lazy("search provider", "Threads")
icon = "forum"
url = "threads"
def search(self, query, page=1):
root_category = ThreadsRootCategory(self.request)
threads_categories = [root_category.unwrap()] + root_category.subcategories
if len(query) > 1:
visible_threads = exclude_invisible_threads(
self.request.user_acl, threads_categories, Thread.objects
)
results = search_threads(self.request, query, visible_threads)
else:
results = []
list_page = paginate(
results,
page,
self.request.settings.posts_per_page,
self.request.settings.posts_per_page_orphans,
allow_explicit_first_page=True,
)
paginator = pagination_dict(list_page)
posts = []
threads = []
if paginator["count"]:
posts = list(
list_page.object_list.select_related("thread", "poster", "poster__rank")
)
threads = []
for post in posts:
threads.append(post.thread)
add_categories_to_items(
root_category.unwrap(), threads_categories, posts + threads
)
results = {
"results": FeedSerializer(
posts,
many=True,
context={
"settings": self.request.settings,
"user": self.request.user,
},
).data
}
results.update(paginator)
return results
def search_threads(request, query, visible_threads):
max_hits = request.settings.posts_per_page * 5
clean_query = filter_search(query)
if not clean_query:
# Short-circuit search due to empty cleaned query
return Post.objects.none()
search_query = SearchQuery(clean_query, config=settings.MISAGO_SEARCH_CONFIG)
search_vector = SearchVector(
"search_document", config=settings.MISAGO_SEARCH_CONFIG
)
queryset = Post.objects.filter(
is_event=False,
is_hidden=False,
is_unapproved=False,
thread_id__in=visible_threads.values("id"),
search_vector=search_query,
)
if queryset[: max_hits + 1].count() > max_hits:
queryset = queryset.order_by("-id")[:max_hits]
return (
Post.objects.filter(id__in=queryset.values("id"))
.annotate(
headline=SearchHeadline(
"search_document",
query,
max_words=20,
min_words=10,
max_fragments=5,
),
rank=SearchRank(search_vector, search_query),
)
.order_by("-rank", "-id")
)
| 3,362
|
Python
|
.py
| 95
| 25.989474
| 88
| 0.605725
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,001
|
apps.py
|
rafalp_Misago/misago/threads/apps.py
|
from django.apps import AppConfig
class MisagoThreadsConfig(AppConfig):
name = "misago.threads"
label = "misago_threads"
verbose_name = "Misago Threads"
def ready(self):
from . import signals as _
| 224
|
Python
|
.py
| 7
| 27.142857
| 37
| 0.71028
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,002
|
context_processors.py
|
rafalp_Misago/misago/threads/context_processors.py
|
from django.urls import reverse
def preload_threads_urls(request):
request.frontend_context.update(
{
"ATTACHMENTS_API": reverse("misago:api:attachment-list"),
"THREAD_EDITOR_API": reverse("misago:api:thread-editor"),
"THREADS_API": reverse("misago:api:thread-list"),
"PRIVATE_THREADS_API": reverse("misago:api:private-thread-list"),
"PRIVATE_THREADS_URL": reverse("misago:private-threads"),
}
)
return {}
| 497
|
Python
|
.py
| 12
| 32.833333
| 77
| 0.634855
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,003
|
mergeconflict.py
|
rafalp_Misago/misago/threads/mergeconflict.py
|
from django.utils.translation import pgettext
from rest_framework.exceptions import ValidationError
from .models import Poll
class MergeConflictHandler:
def __init__(self, threads):
self.items = []
self.choices = {0: None}
self._is_valid = False
self._resolution = None
self.threads = threads
self.populate_from_threads(threads)
if len(self.items) == 1:
self._is_valid = True
self._resolution = self.items[0]
def populate_from_threads(self, threads):
raise NotImplementedError("merge handler must define populate_from_threads")
def is_merge_conflict(self):
return len(self.items) > 1
def set_resolution(self, resolution):
try:
resolution_clean = int(resolution)
except (TypeError, ValueError):
return
if resolution_clean in self.choices:
self._resolution = self.choices[resolution_clean]
self._is_valid = True
def is_valid(self):
return self._is_valid
def get_resolution(self):
return self._resolution or None
class BestAnswerMergeHandler(MergeConflictHandler):
data_name = "best_answer"
def populate_from_threads(self, threads):
for thread in threads:
if thread.has_best_answer:
self.items.append(thread)
self.choices[thread.pk] = thread
self.items.sort(key=lambda thread: (thread.title, thread.id))
def get_available_resolutions(self):
resolutions = [
[0, pgettext("merge conflict best answer", "Unmark all best answers")]
]
for thread in self.items:
resolutions.append([thread.pk, thread.title])
return resolutions
class PollMergeHandler(MergeConflictHandler):
data_name = "poll"
def populate_from_threads(self, threads):
for thread in threads:
try:
self.items.append(thread.poll)
self.choices[thread.poll.id] = thread.poll
except Poll.DoesNotExist:
pass
self.items.sort(key=lambda poll: poll.question)
def get_available_resolutions(self):
resolutions = [[0, pgettext("merge conflict poll", "Delete all polls")]]
for poll in self.items:
resolutions.append(
[poll.id, "%s (%s)" % (poll.question, poll.thread.title)]
)
return resolutions
class MergeConflict:
"""
Utility class single point of entry for detecting merge conflicts on different
properties and validating user resolutions.
"""
HANDLERS = (BestAnswerMergeHandler, PollMergeHandler)
def __init__(self, data=None, threads=None):
self.data = data or {}
self._handlers = [Handler(threads) for Handler in self.HANDLERS]
self._conflicts = [i for i in self._handlers if i.is_merge_conflict()]
self.set_resolution(data)
def is_merge_conflict(self):
return bool(self._conflicts)
def get_conflicting_fields(self):
return [i.data_name for i in self._conflicts]
def set_resolution(self, data):
for handler in self._conflicts:
data = self.data.get(handler.data_name)
handler.set_resolution(data)
def is_valid(self, raise_exception=False):
if raise_exception:
self.raise_exception()
return all([i.is_valid() for i in self._handlers])
def raise_exception(self):
# if any choice was made by user, we are in validation stage of resolution
for conflict in self._conflicts:
if self.data.get(conflict.data_name) is not None:
self.raise_validation_exception()
break
else:
self.raise_resolutions_exception()
def raise_validation_exception(self):
errors = {}
for conflict in self._conflicts:
if not conflict.is_valid() or self.data.get(conflict.data_name) is None:
errors[conflict.data_name] = [
pgettext("merge conflict invalid resolution", "Invalid choice.")
]
if errors:
raise ValidationError(errors)
def raise_resolutions_exception(self):
resolutions = {}
for conflict in self._conflicts:
key = "%ss" % conflict.data_name
resolutions[key] = conflict.get_available_resolutions()
if resolutions:
raise ValidationError(resolutions)
def get_resolution(self):
resolved_handlers = [i for i in self._handlers if i.is_valid()]
return {i.data_name: i.get_resolution() for i in resolved_handlers}
| 4,683
|
Python
|
.py
| 112
| 32.3125
| 84
| 0.632738
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,004
|
utils.py
|
rafalp_Misago/misago/threads/utils.py
|
from urllib.parse import urlparse
from django.urls import Resolver404, resolve
from .models import PostLike
def add_categories_to_items(root_category, categories, items):
categories_dict = {}
for category in categories:
categories_dict[category.pk] = category
if category.parent_id:
category.parent = categories_dict[category.parent_id]
for item in items:
item.category = categories_dict[item.category_id]
def add_likes_to_posts(user, posts):
if user.is_anonymous:
return
posts_map = {}
for post in posts:
posts_map[post.id] = post
post.is_liked = False
queryset = PostLike.objects.filter(liker=user, post_id__in=posts_map.keys())
for like in queryset.values("post_id"):
posts_map[like["post_id"]].is_liked = True
SUPPORTED_THREAD_ROUTES = {
"misago:thread": "id",
"misago:thread-post": "pk",
"misago:thread-last": "pk",
"misago:thread-new": "pk",
"misago:thread-unapproved": "pk",
}
def get_thread_id_from_url(request, url): # pylint: disable=too-many-return-statements
clean_url = str(url).strip()
url_bits = urlparse(clean_url)
if url_bits.netloc and url_bits.netloc != request.get_host():
return None
if url_bits.path.startswith(request.get_host()):
clean_path = url_bits.path.lstrip(request.get_host())
else:
clean_path = url_bits.path
wsgi_alias = request.path[: len(request.path_info) * -1]
if wsgi_alias and not clean_path.startswith(wsgi_alias):
return None
try:
resolution = resolve(clean_path[len(wsgi_alias) :])
except Resolver404:
return None
if not resolution.namespaces:
return None
url_name = "%s:%s" % (":".join(resolution.namespaces), resolution.url_name)
kwargname = SUPPORTED_THREAD_ROUTES.get(url_name)
if not kwargname:
return None
try:
return int(resolution.kwargs.get(kwargname))
except (TypeError, ValueError):
return None
| 2,031
|
Python
|
.py
| 54
| 31.388889
| 87
| 0.670588
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,005
|
events.py
|
rafalp_Misago/misago/threads/events.py
|
from django.utils import timezone
from .models import Post
def record_event(request, thread, event_type, context=None, commit=True):
time_now = timezone.now()
event = Post.objects.create(
category=thread.category,
thread=thread,
poster=request.user,
poster_name=request.user.username,
original="-",
parsed="-",
posted_on=time_now,
updated_on=time_now,
is_event=True,
event_type=event_type,
event_context=context,
)
thread.has_events = True
thread.set_last_post(event)
if commit:
thread.save()
if not (thread.is_hidden and thread.is_unapproved):
thread.category.set_last_thread(thread)
if commit:
thread.category.save()
return event
| 795
|
Python
|
.py
| 26
| 23.307692
| 73
| 0.64042
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,006
|
validators.py
|
rafalp_Misago/misago/threads/validators.py
|
from django.core.exceptions import ValidationError
from django.utils.module_loading import import_string
from django.utils.translation import npgettext, pgettext
from .. import hooks
from ..categories import THREADS_ROOT_NAME
from ..categories.models import Category
from ..categories.permissions import can_browse_category, can_see_category
from ..conf import settings
from ..core.validators import validate_sluggable
from .threadtypes import trees_map
def validate_category(user_acl, category_id, allow_root=False):
try:
threads_tree_id = trees_map.get_tree_id_for_root(THREADS_ROOT_NAME)
category = Category.objects.get(tree_id=threads_tree_id, id=category_id)
except Category.DoesNotExist:
category = None
# Skip ACL validation for root category?
if allow_root and category and not category.level:
return category
if not category or not can_see_category(user_acl, category):
raise ValidationError(
pgettext(
"thread category validator", "Requested category could not be found."
)
)
if not can_browse_category(user_acl, category):
raise ValidationError(
pgettext(
"thread category validator",
"You don't have permission to access this category.",
)
)
return category
def validate_thread_title(settings, title):
validate_thread_title_length(settings, title)
error_not_sluggable = pgettext(
"thread title validator",
"Thread title should contain alpha-numeric characters.",
)
error_slug_too_long = pgettext(
"thread title validator", "Thread title is too long."
)
validate_sluggable(error_not_sluggable, error_slug_too_long)(title)
def validate_thread_title_length(settings, value):
value_len = len(value)
if not value_len:
raise ValidationError(
pgettext(
"thread title length validator", "You have to enter an thread title."
)
)
if value_len < settings.thread_title_length_min:
# pylint: disable=line-too-long
message = npgettext(
"thread title length validator",
"Thread title should be at least %(limit_value)s character long (it has %(show_value)s).",
"Thread title should be at least %(limit_value)s characters long (it has %(show_value)s).",
settings.thread_title_length_min,
)
raise ValidationError(
message
% {"limit_value": settings.thread_title_length_min, "show_value": value_len}
)
if value_len > settings.thread_title_length_max:
# pylint: disable=line-too-long
message = npgettext(
"thread title length validator",
"Thread title cannot be longer than %(limit_value)s character (it has %(show_value)s).",
"Thread title cannot be longer than %(limit_value)s characters (it has %(show_value)s).",
settings.thread_title_length_max,
)
raise ValidationError(
message
% {"limit_value": settings.thread_title_length_max, "show_value": value_len}
)
def validate_post_length(settings, value):
value_len = len(value)
if not value_len:
raise ValidationError(
pgettext("post length validator", "You have to enter a message.")
)
if value_len < settings.post_length_min:
# pylint: disable=line-too-long
message = npgettext(
"post length validator",
"Posted message should be at least %(limit_value)s character long (it has %(show_value)s).",
"Posted message should be at least %(limit_value)s characters long (it has %(show_value)s).",
settings.post_length_min,
)
raise ValidationError(
message % {"limit_value": settings.post_length_min, "show_value": value_len}
)
if settings.post_length_max and value_len > settings.post_length_max:
# pylint: disable=line-too-long
message = npgettext(
"post length validator",
"Posted message cannot be longer than %(limit_value)s character (it has %(show_value)s).",
"Posted message cannot be longer than %(limit_value)s characters (it has %(show_value)s).",
settings.post_length_max,
)
raise ValidationError(
message % {"limit_value": settings.post_length_max, "show_value": value_len}
)
# Post validation framework
validators_list = settings.MISAGO_POST_VALIDATORS
POST_VALIDATORS = list(map(import_string, validators_list))
def validate_post(context, data, validators=None):
validators = validators or POST_VALIDATORS
for validator in validators:
data = validator(context, data) or data
for validator in hooks.post_validators:
data = validator(context, data) or data
return data
| 4,954
|
Python
|
.py
| 113
| 35.469027
| 105
| 0.65843
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,007
|
checksums.py
|
rafalp_Misago/misago/threads/checksums.py
|
from ..markup import checksums
def is_post_valid(post):
valid_checksum = make_post_checksum(post)
return post.checksum == valid_checksum
def make_post_checksum(post):
post_seeds = [str(v) for v in (post.id, str(post.posted_on.date()))]
return checksums.make_checksum(post.parsed, post_seeds)
def update_post_checksum(post):
post.checksum = make_post_checksum(post)
return post.checksum
| 416
|
Python
|
.py
| 10
| 37.6
| 72
| 0.7375
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,008
|
threadurl.py
|
rafalp_Misago/misago/threads/threadurl.py
|
from django.urls import reverse
from ..categories.enums import CategoryTree
from ..categories.models import Category
from .models import Thread
def get_thread_url(thread: Thread, category: Category | None = None) -> str:
return _get_thread_url_action(thread, category)
def _get_thread_url_action(thread: Thread, category: Category | None = None) -> str:
tree_id = (category or thread.category).tree_id
if tree_id == CategoryTree.THREADS:
return reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug})
if tree_id == CategoryTree.PRIVATE_THREADS:
return reverse(
"misago:private-thread", kwargs={"id": thread.id, "slug": thread.slug}
)
raise ValueError(
f"Don't know how to build a thread URL for category tree ID: {tree_id}"
)
| 818
|
Python
|
.py
| 17
| 42.647059
| 86
| 0.697352
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,009
|
participants.py
|
rafalp_Misago/misago/threads/participants.py
|
from django.contrib.auth import get_user_model
from ..notifications.tasks import notify_on_new_private_thread
from .events import record_event
from .models import Thread, ThreadParticipant
User = get_user_model()
def has_participants(thread):
return thread.threadparticipant_set.exists()
def make_participants_aware(user, target):
if hasattr(target, "__iter__"):
make_threads_participants_aware(user, target)
else:
make_thread_participants_aware(user, target)
def make_threads_participants_aware(user, threads):
threads_dict = {}
for thread in threads:
thread.participant = None
threads_dict[thread.pk] = thread
participants_qs = ThreadParticipant.objects.filter(
user=user, thread_id__in=threads_dict.keys()
)
for participant in participants_qs:
participant.user = user
threads_dict[participant.thread_id].participant = participant
def make_thread_participants_aware(user, thread):
thread.participants_list = []
thread.participant = None
participants_qs = ThreadParticipant.objects.filter(thread=thread)
participants_qs = participants_qs.select_related("user")
for participant in participants_qs.order_by("-is_owner", "user__slug"):
participant.thread = thread
thread.participants_list.append(participant)
if participant.user == user:
thread.participant = participant
return thread.participants_list
def set_users_unread_private_threads_sync(
users=None, participants=None, exclude_user=None
):
users_ids = []
if users:
users_ids += [u.pk for u in users]
if participants:
users_ids += [p.user_id for p in participants]
if exclude_user:
users_ids = filter(lambda u: u != exclude_user.pk, users_ids)
if not users_ids:
return
User.objects.filter(id__in=set(users_ids)).update(sync_unread_private_threads=True)
def set_owner(thread, user):
ThreadParticipant.objects.set_owner(thread, user)
def change_owner(request, thread, new_owner):
ThreadParticipant.objects.set_owner(thread, new_owner)
set_users_unread_private_threads_sync(
participants=thread.participants_list, exclude_user=request.user
)
if thread.participant and thread.participant.is_owner:
record_event(
request,
thread,
"changed_owner",
{
"user": {
"id": new_owner.id,
"username": new_owner.username,
"url": new_owner.get_absolute_url(),
}
},
)
else:
record_event(request, thread, "tookover")
def add_participant(request, thread, new_participant):
"""adds single participant to thread, registers this on the event"""
add_participants(request.user, thread, [new_participant])
if request.user == new_participant:
record_event(request, thread, "entered_thread")
else:
record_event(
request,
thread,
"added_participant",
{
"user": {
"id": new_participant.id,
"username": new_participant.username,
"url": new_participant.get_absolute_url(),
}
},
)
def add_participants(user: User, thread: Thread, participants: list[User]):
"""
Add multiple participants to thread, set "recount private threads" flag on them
notify them about being added to thread.
"""
ThreadParticipant.objects.add_participants(thread, participants)
try:
thread_participants = thread.participants_list
except AttributeError:
thread_participants = []
set_users_unread_private_threads_sync(
users=participants, participants=thread_participants, exclude_user=user
)
participants_ids = [
participant.id for participant in participants if participant.id != user.id
]
if participants_ids:
notify_on_new_private_thread.delay(user.id, thread.id, participants_ids)
def remove_participant(request, thread, user):
"""remove thread participant, set "recound private threads" flag on user"""
removed_owner = False
remaining_participants = []
for participant in thread.participants_list:
if participant.user == user:
removed_owner = participant.is_owner
else:
remaining_participants.append(participant.user)
set_users_unread_private_threads_sync(participants=thread.participants_list)
if not remaining_participants:
thread.delete()
else:
thread.threadparticipant_set.filter(user=user).delete()
thread.subscription_set.filter(user=user).delete()
if removed_owner:
thread.is_closed = True # flag thread to close
if request.user == user:
event_type = "owner_left"
else:
event_type = "removed_owner"
else:
if request.user == user:
event_type = "participant_left"
else:
event_type = "removed_participant"
record_event(
request,
thread,
event_type,
{
"user": {
"id": user.id,
"username": user.username,
"url": user.get_absolute_url(),
}
},
)
| 5,481
|
Python
|
.py
| 143
| 29.391608
| 87
| 0.633704
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,010
|
postlike.py
|
rafalp_Misago/misago/threads/models/postlike.py
|
from django.conf import settings
from django.db import models
from django.utils import timezone
class PostLike(models.Model):
category = models.ForeignKey("misago_categories.Category", on_delete=models.CASCADE)
thread = models.ForeignKey("misago_threads.Thread", on_delete=models.CASCADE)
post = models.ForeignKey("misago_threads.Post", on_delete=models.CASCADE)
liker = models.ForeignKey(
settings.AUTH_USER_MODEL, blank=True, null=True, on_delete=models.SET_NULL
)
liker_name = models.CharField(max_length=255, db_index=True)
liker_slug = models.CharField(max_length=255)
liked_on = models.DateTimeField(default=timezone.now)
class Meta:
ordering = ["-id"]
| 716
|
Python
|
.py
| 15
| 42.933333
| 88
| 0.747126
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,011
|
pollvote.py
|
rafalp_Misago/misago/threads/models/pollvote.py
|
from django.conf import settings
from django.db import models
from django.utils import timezone
class PollVote(models.Model):
category = models.ForeignKey("misago_categories.Category", on_delete=models.CASCADE)
thread = models.ForeignKey("misago_threads.Thread", on_delete=models.CASCADE)
poll = models.ForeignKey("misago_threads.Poll", on_delete=models.CASCADE)
voter = models.ForeignKey(
settings.AUTH_USER_MODEL, blank=True, null=True, on_delete=models.SET_NULL
)
voter_name = models.CharField(max_length=255)
voter_slug = models.CharField(max_length=255)
voted_on = models.DateTimeField(default=timezone.now)
choice_hash = models.CharField(max_length=12, db_index=True)
class Meta:
indexes = [
models.Index(fields=["poll", "voter_name"]),
]
| 824
|
Python
|
.py
| 18
| 40.388889
| 88
| 0.726027
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,012
|
post.py
|
rafalp_Misago/misago/threads/models/post.py
|
import copy
from django.contrib.postgres.indexes import GinIndex
from django.contrib.postgres.search import SearchVector, SearchVectorField
from django.db import models
from django.db.models import Q
from django.urls import reverse
from django.utils import timezone
from ...conf import settings
from ...core.utils import parse_iso8601_string
from ...markup import finalize_markup
from ...plugins.models import PluginDataModel
from ..checksums import is_post_valid, update_post_checksum
from ..filtersearch import filter_search
class Post(PluginDataModel):
category = models.ForeignKey("misago_categories.Category", on_delete=models.CASCADE)
thread = models.ForeignKey("misago_threads.Thread", on_delete=models.CASCADE)
poster = models.ForeignKey(
settings.AUTH_USER_MODEL, blank=True, null=True, on_delete=models.SET_NULL
)
poster_name = models.CharField(max_length=255)
original = models.TextField()
parsed = models.TextField()
checksum = models.CharField(max_length=64, default="-")
mentions = models.ManyToManyField(
settings.AUTH_USER_MODEL, related_name="mention_set"
)
attachments_cache = models.JSONField(null=True, blank=True)
posted_on = models.DateTimeField(db_index=True)
updated_on = models.DateTimeField()
hidden_on = models.DateTimeField(default=timezone.now)
edits = models.PositiveIntegerField(default=0)
last_editor = models.ForeignKey(
settings.AUTH_USER_MODEL,
blank=True,
null=True,
on_delete=models.SET_NULL,
related_name="+",
)
last_editor_name = models.CharField(max_length=255, null=True, blank=True)
last_editor_slug = models.SlugField(max_length=255, null=True, blank=True)
hidden_by = models.ForeignKey(
settings.AUTH_USER_MODEL,
blank=True,
null=True,
on_delete=models.SET_NULL,
related_name="+",
)
hidden_by_name = models.CharField(max_length=255, null=True, blank=True)
hidden_by_slug = models.SlugField(max_length=255, null=True, blank=True)
has_reports = models.BooleanField(default=False)
has_open_reports = models.BooleanField(default=False)
is_unapproved = models.BooleanField(default=False, db_index=True)
is_hidden = models.BooleanField(default=False)
is_protected = models.BooleanField(default=False)
is_event = models.BooleanField(default=False, db_index=True)
event_type = models.CharField(max_length=255, null=True, blank=True)
event_context = models.JSONField(null=True, blank=True)
likes = models.PositiveIntegerField(default=0)
last_likes = models.JSONField(null=True, blank=True)
liked_by = models.ManyToManyField(
settings.AUTH_USER_MODEL,
related_name="liked_post_set",
through="misago_threads.PostLike",
)
search_document = models.TextField(null=True, blank=True)
search_vector = SearchVectorField()
class Meta:
indexes = [
*PluginDataModel.Meta.indexes,
models.Index(
name="misago_post_has_open_repo_part",
fields=["has_open_reports"],
condition=Q(has_open_reports=True),
),
models.Index(
name="misago_post_is_hidden_part",
fields=["is_hidden"],
condition=Q(is_hidden=False),
),
models.Index(
name="misago_post_is_event_part",
fields=["is_event", "event_type"],
condition=Q(is_event=True),
),
GinIndex(fields=["search_vector"]),
# Speed up threadview for team members
models.Index(fields=["thread", "id"]),
models.Index(fields=["is_event", "is_hidden"]),
models.Index(fields=["poster", "posted_on"]),
]
def __str__(self):
return "%s..." % self.original[10:].strip()
def delete(self, *args, **kwargs):
from ..signals import delete_post
delete_post.send(sender=self)
super().delete(*args, **kwargs)
def merge(self, other_post):
if self.poster_id != other_post.poster_id:
raise ValueError("post can't be merged with other user's post")
elif (
self.poster_id is None
and other_post.poster_id is None
and self.poster_name != other_post.poster_name
):
raise ValueError("post can't be merged with other user's post")
if self.thread_id != other_post.thread_id:
raise ValueError("only posts belonging to same thread can be merged")
if self.is_event or other_post.is_event:
raise ValueError("can't merge events")
if self.pk == other_post.pk:
raise ValueError("post can't be merged with itself")
other_post.original = str("\n\n").join((other_post.original, self.original))
other_post.parsed = str("\n").join((other_post.parsed, self.parsed))
update_post_checksum(other_post)
if self.is_protected:
other_post.is_protected = True
if self.is_best_answer:
self.thread.best_answer = other_post
if other_post.is_best_answer:
self.thread.best_answer_is_protected = other_post.is_protected
from ..signals import merge_post
merge_post.send(sender=self, other_post=other_post)
def move(self, new_thread):
from ..signals import move_post
if self.is_best_answer:
self.thread.clear_best_answer()
self.category = new_thread.category
self.thread = new_thread
move_post.send(sender=self)
@property
def attachments(self):
# pylint: disable=access-member-before-definition
if hasattr(self, "_hydrated_attachments_cache"):
return self._hydrated_attachments_cache
self._hydrated_attachments_cache = []
if self.attachments_cache:
for attachment in copy.deepcopy(self.attachments_cache):
attachment["uploaded_on"] = parse_iso8601_string(
attachment["uploaded_on"]
)
self._hydrated_attachments_cache.append(attachment)
return self._hydrated_attachments_cache
@property
def content(self):
if not hasattr(self, "_finalised_parsed"):
self._finalised_parsed = finalize_markup(self.parsed)
return self._finalised_parsed
@property
def thread_type(self):
return self.category.thread_type
def get_absolute_url(self):
return reverse("misago:post", kwargs={"id": self.id})
def get_api_url(self):
return self.thread_type.get_post_api_url(self)
def get_likes_api_url(self):
return self.thread_type.get_post_likes_api_url(self)
def get_editor_api_url(self):
return self.thread_type.get_post_editor_api_url(self)
def get_edits_api_url(self):
return self.thread_type.get_post_edits_api_url(self)
def set_search_document(self, thread_title=None):
if thread_title:
self.search_document = filter_search(
"\n\n".join([thread_title, self.original])
)
else:
self.search_document = filter_search(self.original)
def update_search_vector(self):
self.search_vector = SearchVector(
"search_document", config=settings.MISAGO_SEARCH_CONFIG
)
@property
def short(self):
if self.is_valid:
if len(self.original) > 150:
return str("%s...") % self.original[:150].strip()
return self.original
return ""
@property
def is_valid(self):
return is_post_valid(self)
@property
def is_first_post(self):
return self.id == self.thread.first_post_id
@property
def is_best_answer(self):
return self.id == self.thread.best_answer_id
| 7,934
|
Python
|
.py
| 187
| 33.764706
| 88
| 0.647624
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,013
|
thread.py
|
rafalp_Misago/misago/threads/models/thread.py
|
from functools import cached_property
from django.core.exceptions import ObjectDoesNotExist
from django.db import models
from django.db.models import Q
from django.utils import timezone
from django.utils.translation import pgettext_lazy
from ...conf import settings
from ...core.utils import slugify
from ...plugins.models import PluginDataModel
class Thread(PluginDataModel):
WEIGHT_DEFAULT = 0
WEIGHT_PINNED = 1
WEIGHT_GLOBAL = 2
WEIGHT_CHOICES = [
(
WEIGHT_DEFAULT,
pgettext_lazy("thread weight choice", "Not pinned"),
),
(
WEIGHT_PINNED,
pgettext_lazy("thread weight choice", "Pinned in category"),
),
(
WEIGHT_GLOBAL,
pgettext_lazy("thread weight choice", "Pinned globally"),
),
]
category = models.ForeignKey("misago_categories.Category", on_delete=models.CASCADE)
title = models.CharField(max_length=255)
slug = models.CharField(max_length=255)
replies = models.PositiveIntegerField(default=0, db_index=True)
has_events = models.BooleanField(default=False)
has_poll = models.BooleanField(default=False)
has_reported_posts = models.BooleanField(default=False)
has_open_reports = models.BooleanField(default=False)
has_unapproved_posts = models.BooleanField(default=False)
has_hidden_posts = models.BooleanField(default=False)
started_on = models.DateTimeField(db_index=True)
last_post_on = models.DateTimeField(db_index=True)
first_post = models.ForeignKey(
"misago_threads.Post",
related_name="+",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
starter = models.ForeignKey(
settings.AUTH_USER_MODEL, null=True, blank=True, on_delete=models.SET_NULL
)
starter_name = models.CharField(max_length=255)
starter_slug = models.CharField(max_length=255)
last_post = models.ForeignKey(
"misago_threads.Post",
related_name="+",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
last_post_is_event = models.BooleanField(default=False)
last_poster = models.ForeignKey(
settings.AUTH_USER_MODEL,
related_name="last_poster_set",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
last_poster_name = models.CharField(max_length=255, null=True, blank=True)
last_poster_slug = models.CharField(max_length=255, null=True, blank=True)
weight = models.PositiveIntegerField(default=WEIGHT_DEFAULT)
is_unapproved = models.BooleanField(default=False, db_index=True)
is_hidden = models.BooleanField(default=False)
is_closed = models.BooleanField(default=False)
best_answer = models.ForeignKey(
"misago_threads.Post",
related_name="+",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
best_answer_is_protected = models.BooleanField(default=False)
best_answer_marked_on = models.DateTimeField(null=True, blank=True)
best_answer_marked_by = models.ForeignKey(
settings.AUTH_USER_MODEL,
related_name="marked_best_answer_set",
null=True,
blank=True,
on_delete=models.SET_NULL,
)
best_answer_marked_by_name = models.CharField(max_length=255, null=True, blank=True)
best_answer_marked_by_slug = models.CharField(max_length=255, null=True, blank=True)
participants = models.ManyToManyField(
settings.AUTH_USER_MODEL,
related_name="privatethread_set",
through="ThreadParticipant",
through_fields=("thread", "user"),
)
class Meta:
indexes = [
*PluginDataModel.Meta.indexes,
models.Index(
name="misago_thread_pinned_glob_part",
fields=["weight"],
condition=Q(weight=2),
),
models.Index(
name="misago_thread_pinned_loca_part",
fields=["weight"],
condition=Q(weight=1),
),
models.Index(
name="misago_thread_not_pinned_part",
fields=["weight"],
condition=Q(weight=0),
),
models.Index(
name="misago_thread_not_global_part",
fields=["weight"],
condition=Q(weight__lt=2),
),
models.Index(
name="misago_thread_has_reporte_part",
fields=["has_reported_posts"],
condition=Q(has_reported_posts=True),
),
models.Index(
name="misago_thread_has_unappro_part",
fields=["has_unapproved_posts"],
condition=Q(has_unapproved_posts=True),
),
models.Index(
name="misago_thread_is_visible_part",
fields=["is_hidden"],
condition=Q(is_hidden=False),
),
models.Index(fields=["category", "id"]),
models.Index(fields=["category", "last_post_on"]),
models.Index(fields=["category", "replies"]),
]
def __str__(self):
return self.title
def delete(self, *args, **kwargs):
from ..signals import delete_thread
delete_thread.send(sender=self)
super().delete(*args, **kwargs)
def merge(self, other_thread):
if self.pk == other_thread.pk:
raise ValueError("thread can't be merged with itself")
from ..signals import merge_thread
merge_thread.send(sender=self, other_thread=other_thread)
def move(self, new_category):
from ..signals import move_thread
self.category = new_category
move_thread.send(sender=self)
def synchronize(self):
try:
self.has_poll = bool(self.poll)
except ObjectDoesNotExist:
self.has_poll = False
self.replies = self.post_set.filter(is_event=False, is_unapproved=False).count()
if self.replies > 0:
self.replies -= 1
reported_post_qs = self.post_set.filter(has_reports=True)
self.has_reported_posts = reported_post_qs.exists()
if self.has_reported_posts:
open_reports_qs = self.post_set.filter(has_open_reports=True)
self.has_open_reports = open_reports_qs.exists()
else:
self.has_open_reports = False
unapproved_post_qs = self.post_set.filter(is_unapproved=True)
self.has_unapproved_posts = unapproved_post_qs.exists()
hidden_post_qs = self.post_set.filter(is_hidden=True)[:1]
self.has_hidden_posts = hidden_post_qs.exists()
posts = self.post_set.order_by("id")
first_post = posts.first()
self.set_first_post(first_post)
last_post = posts.filter(is_unapproved=False).last()
if last_post:
self.set_last_post(last_post)
else:
self.set_last_post(first_post)
self.has_events = False
if last_post:
if last_post.is_event:
self.has_events = True
else:
self.has_events = self.post_set.filter(is_event=True).exists()
@property
def has_best_answer(self):
return bool(self.best_answer_id)
@property
def replies_in_ks(self):
return "%sK" % round(self.replies / 1000, 0)
@cached_property
def participants_ids(self) -> list[int]:
"""Returns lists of private thread participating users ids.
Cached property. Thread owner is guaranteed to be first item of the list.
"""
return self.participants.through.objects.order_by(
"-is_owner", "id"
).values_list("user_id", flat=True)
@property
def thread_type(self):
return self.category.thread_type
def get_api_url(self):
return self.thread_type.get_thread_api_url(self)
def get_editor_api_url(self):
return self.thread_type.get_thread_editor_api_url(self)
def get_merge_api_url(self):
return self.thread_type.get_thread_merge_api_url(self)
def get_posts_api_url(self):
return self.thread_type.get_thread_posts_api_url(self)
def get_post_merge_api_url(self):
return self.thread_type.get_post_merge_api_url(self)
def get_post_move_api_url(self):
return self.thread_type.get_post_move_api_url(self)
def get_post_split_api_url(self):
return self.thread_type.get_post_split_api_url(self)
def get_poll_api_url(self):
return self.thread_type.get_thread_poll_api_url(self)
def get_watch_api_url(self):
return self.thread_type.get_thread_watch_api_url(self)
def get_absolute_url(self, page=1):
return self.thread_type.get_thread_absolute_url(self, page)
def get_new_post_url(self):
return self.thread_type.get_thread_new_post_url(self)
def get_last_post_url(self):
return self.thread_type.get_thread_last_post_url(self)
def get_best_answer_url(self):
return self.thread_type.get_thread_best_answer_url(self)
def get_unapproved_post_url(self):
return self.thread_type.get_thread_unapproved_post_url(self)
def set_title(self, title):
self.title = title
self.slug = slugify(title)
if self.id:
from ..signals import update_thread_title
update_thread_title.send(sender=self)
def set_first_post(self, post):
self.started_on = post.posted_on
self.first_post = post
self.starter = post.poster
self.starter_name = post.poster_name
if post.poster:
self.starter_slug = post.poster.slug
else:
self.starter_slug = slugify(post.poster_name)
self.is_unapproved = post.is_unapproved
self.is_hidden = post.is_hidden
def set_last_post(self, post):
self.last_post_on = post.posted_on
self.last_post_is_event = post.is_event
self.last_post = post
self.last_poster = post.poster
self.last_poster_name = post.poster_name
if post.poster:
self.last_poster_slug = post.poster.slug
else:
self.last_poster_slug = slugify(post.poster_name)
def set_best_answer(self, user, post):
if post.thread_id != self.id:
raise ValueError("post to set as best answer must be in same thread")
if post.is_first_post:
raise ValueError("post to set as best answer can't be first post")
if post.is_hidden:
raise ValueError("post to set as best answer can't be hidden")
if post.is_unapproved:
raise ValueError("post to set as best answer can't be unapproved")
self.best_answer = post
self.best_answer_is_protected = post.is_protected
self.best_answer_marked_on = timezone.now()
self.best_answer_marked_by = user
self.best_answer_marked_by_name = user.username
self.best_answer_marked_by_slug = user.slug
def clear_best_answer(self):
self.best_answer = None
self.best_answer_is_protected = False
self.best_answer_marked_on = None
self.best_answer_marked_by = None
self.best_answer_marked_by_name = None
self.best_answer_marked_by_slug = None
| 11,367
|
Python
|
.py
| 280
| 31.442857
| 88
| 0.629445
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,014
|
poll.py
|
rafalp_Misago/misago/threads/models/poll.py
|
from datetime import timedelta
from math import ceil
from django.conf import settings
from django.db import models
from django.utils import timezone
from ...plugins.models import PluginDataModel
class Poll(PluginDataModel):
category = models.ForeignKey("misago_categories.Category", on_delete=models.CASCADE)
thread = models.OneToOneField("misago_threads.Thread", on_delete=models.CASCADE)
poster = models.ForeignKey(
settings.AUTH_USER_MODEL, blank=True, null=True, on_delete=models.SET_NULL
)
poster_name = models.CharField(max_length=255)
poster_slug = models.CharField(max_length=255)
posted_on = models.DateTimeField(default=timezone.now)
length = models.PositiveIntegerField(default=0)
question = models.CharField(max_length=255)
choices = models.JSONField()
allowed_choices = models.PositiveIntegerField(default=1)
allow_revotes = models.BooleanField(default=False)
votes = models.PositiveIntegerField(default=0)
is_public = models.BooleanField(default=False)
def move(self, thread):
if self.thread_id != thread.id:
self.thread = thread
self.category_id = thread.category_id
self.save()
self.pollvote_set.update(thread=self.thread, category_id=self.category_id)
@property
def ends_on(self):
if self.length:
return self.posted_on + timedelta(days=self.length)
@property
def is_over(self):
if self.length:
return timezone.now() > self.ends_on
return False
@property
def thread_type(self):
return self.category.thread_type
def get_api_url(self):
return self.thread_type.get_poll_api_url(self)
def get_votes_api_url(self):
return self.thread_type.get_poll_votes_api_url(self)
def make_choices_votes_aware(self, user):
if user.is_anonymous:
for choice in self.choices:
choice["selected"] = False
return
queryset = self.pollvote_set.filter(voter=user).values("choice_hash")
user_votes = [v["choice_hash"] for v in queryset]
for choice in self.choices:
choice["selected"] = choice["hash"] in user_votes
@property
def has_selected_choices(self):
for choice in self.choices:
if choice.get("selected"):
return True
return False
@property
def view_choices(self):
view_choices = []
for choice in self.choices:
if choice["votes"] and self.votes:
proc = int(ceil(choice["votes"] * 100 / self.votes))
else:
proc = 0
view_choices.append(
{
"label": choice["label"],
"votes": choice["votes"],
"selected": choice["selected"],
"proc": proc,
}
)
return view_choices
| 2,965
|
Python
|
.py
| 76
| 29.960526
| 88
| 0.631928
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,015
|
__init__.py
|
rafalp_Misago/misago/threads/models/__init__.py
|
from .post import Post
from .postedit import PostEdit
from .postlike import PostLike
from .thread import Thread
from .threadparticipant import ThreadParticipant
from .subscription import Subscription
from .attachmenttype import AttachmentType
from .attachment import Attachment
from .poll import Poll
from .pollvote import PollVote
| 332
|
Python
|
.py
| 10
| 32.2
| 48
| 0.875776
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,016
|
attachment.py
|
rafalp_Misago/misago/threads/models/attachment.py
|
import os
from hashlib import md5
from io import BytesIO
from django.core.files import File
from django.core.files.base import ContentFile
from django.db import models
from django.urls import reverse
from django.utils import timezone
from django.utils.crypto import get_random_string
from PIL import Image
from ...conf import settings
from ...core.utils import slugify
from ...plugins.models import PluginDataModel
def upload_to(instance, filename):
# pylint: disable=undefined-loop-variable
spread_path = md5(str(instance.secret[:16]).encode()).hexdigest()
secret = Attachment.generate_new_secret()
filename_lowered = filename.lower().strip()
for extension in instance.filetype.extensions_list:
if filename_lowered.endswith(extension):
break
filename_clean = ".".join(
(slugify(filename[: (len(extension) + 1) * -1])[:16], extension)
)
return os.path.join(
"attachments", spread_path[:2], spread_path[2:4], secret, filename_clean
)
class Attachment(PluginDataModel):
secret = models.CharField(max_length=64)
filetype = models.ForeignKey("AttachmentType", on_delete=models.CASCADE)
post = models.ForeignKey("Post", blank=True, null=True, on_delete=models.SET_NULL)
uploaded_on = models.DateTimeField(default=timezone.now, db_index=True)
uploader = models.ForeignKey(
settings.AUTH_USER_MODEL, blank=True, null=True, on_delete=models.SET_NULL
)
uploader_name = models.CharField(max_length=255)
uploader_slug = models.CharField(max_length=255, db_index=True)
filename = models.CharField(max_length=255, db_index=True)
size = models.PositiveIntegerField(default=0, db_index=True)
thumbnail = models.ImageField(
max_length=255, blank=True, null=True, upload_to=upload_to
)
image = models.ImageField(
max_length=255, blank=True, null=True, upload_to=upload_to
)
file = models.FileField(max_length=255, blank=True, null=True, upload_to=upload_to)
def __str__(self):
return self.filename
def delete(self, *args, **kwargs):
self.delete_files()
return super().delete(*args, **kwargs)
def delete_files(self):
if self.thumbnail:
self.thumbnail.delete(save=False)
if self.image:
self.image.delete(save=False)
if self.file:
self.file.delete(save=False)
@classmethod
def generate_new_secret(cls):
return get_random_string(settings.MISAGO_ATTACHMENT_SECRET_LENGTH)
@property
def is_image(self):
return bool(self.image)
@property
def is_file(self):
return not self.is_image
def get_absolute_url(self):
return reverse(
"misago:attachment", kwargs={"pk": self.pk, "secret": self.secret}
)
def get_thumbnail_url(self):
if self.thumbnail:
return reverse(
"misago:attachment-thumbnail",
kwargs={"pk": self.pk, "secret": self.secret},
)
def set_file(self, upload):
self.file = File(upload, upload.name)
def set_image(self, upload):
fileformat = self.filetype.extensions_list[0]
self.image = File(upload, upload.name)
thumbnail = Image.open(upload)
downscale_image = (
thumbnail.size[0] > settings.MISAGO_ATTACHMENT_IMAGE_SIZE_LIMIT[0]
or thumbnail.size[1] > settings.MISAGO_ATTACHMENT_IMAGE_SIZE_LIMIT[1]
)
strip_animation = fileformat == "gif"
thumb_stream = BytesIO()
if downscale_image:
thumbnail.thumbnail(settings.MISAGO_ATTACHMENT_IMAGE_SIZE_LIMIT)
if fileformat == "jpg":
# normalize jpg to jpeg for Pillow
thumbnail.save(thumb_stream, "jpeg")
else:
thumbnail.save(thumb_stream, "png")
elif strip_animation:
thumbnail.save(thumb_stream, "png")
if downscale_image or strip_animation:
self.thumbnail = ContentFile(thumb_stream.getvalue(), upload.name)
| 4,090
|
Python
|
.py
| 100
| 33.35
| 87
| 0.666667
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,017
|
subscription.py
|
rafalp_Misago/misago/threads/models/subscription.py
|
from django.db import models
from django.utils import timezone
from ...conf import settings
class Subscription(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
thread = models.ForeignKey("Thread", on_delete=models.CASCADE)
category = models.ForeignKey("misago_categories.Category", on_delete=models.CASCADE)
last_read_on = models.DateTimeField(default=timezone.now)
send_email = models.BooleanField(default=False)
class Meta:
indexes = [
models.Index(fields=["send_email", "last_read_on"]),
]
| 593
|
Python
|
.py
| 13
| 40.230769
| 88
| 0.732174
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,018
|
postedit.py
|
rafalp_Misago/misago/threads/models/postedit.py
|
import difflib
from django.conf import settings
from django.db import models
from django.utils import timezone
class PostEdit(models.Model):
category = models.ForeignKey("misago_categories.Category", on_delete=models.CASCADE)
thread = models.ForeignKey("misago_threads.Thread", on_delete=models.CASCADE)
post = models.ForeignKey(
"misago_threads.Post", related_name="edits_record", on_delete=models.CASCADE
)
edited_on = models.DateTimeField(default=timezone.now)
editor = models.ForeignKey(
settings.AUTH_USER_MODEL, blank=True, null=True, on_delete=models.SET_NULL
)
editor_name = models.CharField(max_length=255)
editor_slug = models.CharField(max_length=255)
edited_from = models.TextField()
edited_to = models.TextField()
class Meta:
ordering = ["-id"]
def get_diff(self):
return difflib.ndiff(self.edited_from.splitlines(), self.edited_to.splitlines())
| 951
|
Python
|
.py
| 22
| 38.045455
| 88
| 0.731813
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,019
|
attachmenttype.py
|
rafalp_Misago/misago/threads/models/attachmenttype.py
|
from django.db import models
from django.utils.translation import pgettext_lazy
from ...plugins.models import PluginDataModel
class AttachmentType(PluginDataModel):
ENABLED = 0
LOCKED = 1
DISABLED = 2
name = models.CharField(max_length=255)
extensions = models.CharField(max_length=255)
mimetypes = models.CharField(null=True, blank=True, max_length=255)
size_limit = models.PositiveIntegerField(default=1024)
status = models.PositiveIntegerField(
default=ENABLED,
choices=[
(
ENABLED,
pgettext_lazy(
"attachment availability choice",
"Allow uploads and downloads",
),
),
(
LOCKED,
pgettext_lazy(
"attachment availability choice",
"Allow downloads only",
),
),
(
DISABLED,
pgettext_lazy(
"attachment availability choice",
"Disallow both uploading and downloading",
),
),
],
)
limit_uploads_to = models.ManyToManyField(
"misago_acl.Role", related_name="+", blank=True
)
limit_downloads_to = models.ManyToManyField(
"misago_acl.Role", related_name="+", blank=True
)
def __str__(self):
return self.name
@property
def is_enabled(self):
return self.status == AttachmentType.ENABLED
@property
def is_locked(self):
return self.status == AttachmentType.LOCKED
@property
def extensions_list(self):
if self.extensions:
return self.extensions.split(",")
return []
@property
def mimetypes_list(self):
if self.mimetypes:
return self.mimetypes.split(",")
return []
| 1,905
|
Python
|
.py
| 61
| 21.147541
| 71
| 0.56325
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,020
|
threadparticipant.py
|
rafalp_Misago/misago/threads/models/threadparticipant.py
|
from django.db import models
from ...conf import settings
class ThreadParticipantManager(models.Manager):
def set_owner(self, thread, user):
ThreadParticipant.objects.filter(thread=thread, is_owner=True).update(
is_owner=False
)
self.remove_participant(thread, user)
ThreadParticipant.objects.create(thread=thread, user=user, is_owner=True)
def add_participants(self, thread, users):
bulk = []
for user in users:
bulk.append(ThreadParticipant(thread=thread, user=user, is_owner=False))
ThreadParticipant.objects.bulk_create(bulk)
def remove_participant(self, thread, user):
ThreadParticipant.objects.filter(thread=thread, user=user).delete()
class ThreadParticipant(models.Model):
thread = models.ForeignKey("misago_threads.Thread", on_delete=models.CASCADE)
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
is_owner = models.BooleanField(default=False)
objects = ThreadParticipantManager()
| 1,046
|
Python
|
.py
| 21
| 42.761905
| 84
| 0.728797
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,021
|
misago_poststags.py
|
rafalp_Misago/misago/threads/templatetags/misago_poststags.py
|
from django import template
from django.utils.translation import npgettext, pgettext
register = template.Library()
@register.simple_tag
def likes_label(post):
last_likes = post.last_likes or []
usernames = []
for like in last_likes[:3]:
usernames.append(like["username"])
if len(usernames) == 1:
return pgettext("post likes message", "%(user)s likes this.") % {
"user": usernames[0]
}
hidden_likes = post.likes - len(usernames)
if len(last_likes) < 4:
usernames_string = humanize_usernames_list(usernames)
else:
usernames_string = ", ".join(usernames)
if not hidden_likes:
return pgettext("post likes message", "%(users)s like this.") % {
"users": usernames_string
}
label = npgettext(
"post likes message",
"%(users)s and %(likes)s other user like this.",
"%(users)s and %(likes)s other users like this.",
hidden_likes,
)
formats = {"users": usernames_string, "likes": hidden_likes}
return label % formats
def humanize_usernames_list(usernames):
formats = {"users": ", ".join(usernames[:-1]), "last_user": usernames[-1]}
return pgettext("post likes message", "%(users)s and %(last_user)s") % formats
| 1,281
|
Python
|
.py
| 33
| 32.363636
| 82
| 0.635113
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,022
|
0012_set_dj_partial_indexes.py
|
rafalp_Misago/misago/threads/migrations/0012_set_dj_partial_indexes.py
|
# Generated by Django 2.2.1 on 2019-05-18 16:59
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0011_remove_custom_partial_indexes")]
operations = [
migrations.AddIndex(
model_name="post",
index=models.Index(
condition=models.Q(has_open_reports=True),
fields=["has_open_reports"],
name="misago_post_has_open_repo_part",
),
),
migrations.AddIndex(
model_name="post",
index=models.Index(
condition=models.Q(is_hidden=False),
fields=["is_hidden"],
name="misago_post_is_hidden_part",
),
),
migrations.AddIndex(
model_name="post",
index=models.Index(
condition=models.Q(is_event=True),
fields=["is_event", "event_type"],
name="misago_post_is_event_part",
),
),
migrations.AddIndex(
model_name="thread",
index=models.Index(
condition=models.Q(weight=2),
fields=["weight"],
name="misago_thread_pinned_glob_part",
),
),
migrations.AddIndex(
model_name="thread",
index=models.Index(
condition=models.Q(weight=1),
fields=["weight"],
name="misago_thread_pinned_loca_part",
),
),
migrations.AddIndex(
model_name="thread",
index=models.Index(
condition=models.Q(weight=0),
fields=["weight"],
name="misago_thread_not_pinned_part",
),
),
migrations.AddIndex(
model_name="thread",
index=models.Index(
condition=models.Q(weight__lt=2),
fields=["weight"],
name="misago_thread_not_global_part",
),
),
migrations.AddIndex(
model_name="thread",
index=models.Index(
condition=models.Q(has_reported_posts=True),
fields=["has_reported_posts"],
name="misago_thread_has_reporte_part",
),
),
migrations.AddIndex(
model_name="thread",
index=models.Index(
condition=models.Q(has_unapproved_posts=True),
fields=["has_unapproved_posts"],
name="misago_thread_has_unappro_part",
),
),
migrations.AddIndex(
model_name="thread",
index=models.Index(
condition=models.Q(is_hidden=False),
fields=["is_hidden"],
name="misago_thread_is_visible_part",
),
),
]
| 2,903
|
Python
|
.py
| 86
| 20.94186
| 77
| 0.493423
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,023
|
0002_threads_settings.py
|
rafalp_Misago/misago/threads/migrations/0002_threads_settings.py
|
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0001_initial"), ("misago_conf", "0001_initial")]
operations = []
| 184
|
Python
|
.py
| 4
| 42.25
| 88
| 0.723164
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,024
|
0007_auto_20171008_0131.py
|
rafalp_Misago/misago/threads/migrations/0007_auto_20171008_0131.py
|
# Generated by Django 1.11.5 on 2017-10-08 01:31
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0006_redo_partial_indexes")]
operations = [
migrations.AlterField(
model_name="post",
name="posted_on",
field=models.DateTimeField(db_index=True),
)
]
| 383
|
Python
|
.py
| 11
| 27.727273
| 68
| 0.647696
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,025
|
0010_auto_20180609_1523.py
|
rafalp_Misago/misago/threads/migrations/0010_auto_20180609_1523.py
|
# Generated by Django 1.11.13 on 2018-06-09 15:23
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0009_auto_20180326_0010")]
operations = [
migrations.RemoveField(model_name="attachment", name="uploader_ip"),
migrations.RemoveField(model_name="poll", name="poster_ip"),
migrations.RemoveField(model_name="pollvote", name="voter_ip"),
migrations.RemoveField(model_name="post", name="poster_ip"),
migrations.RemoveField(model_name="postedit", name="editor_ip"),
migrations.RemoveField(model_name="postlike", name="liker_ip"),
]
| 649
|
Python
|
.py
| 12
| 47.833333
| 76
| 0.70347
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,026
|
0006_redo_partial_indexes.py
|
rafalp_Misago/misago/threads/migrations/0006_redo_partial_indexes.py
|
# Generated by Django 1.11.1 on 2017-05-21 17:52
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0005_index_search_document")]
operations = []
| 214
|
Python
|
.py
| 5
| 39.6
| 69
| 0.747573
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,027
|
0005_index_search_document.py
|
rafalp_Misago/misago/threads/migrations/0005_index_search_document.py
|
# Generated by Django 1.11.1 on 2017-05-21 17:52
import django.contrib.postgres.indexes
from django.contrib.postgres.operations import BtreeGinExtension
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0004_update_settings")]
operations = [
BtreeGinExtension(),
migrations.AddIndex(
model_name="post",
index=django.contrib.postgres.indexes.GinIndex(
fields=["search_vector"], name="misago_thre_search__b472a2_gin"
),
),
]
| 572
|
Python
|
.py
| 15
| 31.066667
| 79
| 0.680505
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,028
|
0001_initial.py
|
rafalp_Misago/misago/threads/migrations/0001_initial.py
|
import django.db.models.deletion
import django.utils.timezone
from django.conf import settings
from django.contrib.postgres.search import SearchVectorField
from django.db import migrations, models
import misago.threads.models.attachment
class Migration(migrations.Migration):
initial = True
dependencies = [
("misago_categories", "0001_initial"),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name="Post",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("poster_name", models.CharField(max_length=255)),
("poster_ip", models.GenericIPAddressField()),
("original", models.TextField()),
("parsed", models.TextField()),
("checksum", models.CharField(max_length=64, default="-")),
("attachments_cache", models.JSONField(null=True, blank=True)),
("posted_on", models.DateTimeField()),
("updated_on", models.DateTimeField()),
("edits", models.PositiveIntegerField(default=0)),
(
"last_editor_name",
models.CharField(max_length=255, null=True, blank=True),
),
(
"last_editor_slug",
models.SlugField(max_length=255, null=True, blank=True),
),
(
"hidden_by",
models.ForeignKey(
related_name="+",
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to=settings.AUTH_USER_MODEL,
null=True,
),
),
(
"hidden_by_name",
models.CharField(max_length=255, null=True, blank=True),
),
(
"hidden_by_slug",
models.SlugField(max_length=255, null=True, blank=True),
),
("hidden_on", models.DateTimeField(default=django.utils.timezone.now)),
("has_reports", models.BooleanField(default=False)),
("has_open_reports", models.BooleanField(default=False)),
("is_unapproved", models.BooleanField(default=False, db_index=True)),
("is_hidden", models.BooleanField(default=False)),
("is_protected", models.BooleanField(default=False)),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
(
"last_editor",
models.ForeignKey(
related_name="+",
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to=settings.AUTH_USER_MODEL,
null=True,
),
),
(
"mentions",
models.ManyToManyField(
related_name="mention_set", to=settings.AUTH_USER_MODEL
),
),
(
"poster",
models.ForeignKey(
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to=settings.AUTH_USER_MODEL,
null=True,
),
),
("is_event", models.BooleanField(default=False, db_index=True)),
("event_type", models.CharField(max_length=255, null=True, blank=True)),
("event_context", models.JSONField(null=True, blank=True)),
("likes", models.PositiveIntegerField(default=0)),
("last_likes", models.JSONField(blank=True, null=True)),
("search_document", models.TextField(blank=True, null=True)),
("search_vector", SearchVectorField()),
],
options={},
bases=(models.Model,),
),
migrations.CreateModel(
name="Thread",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("title", models.CharField(max_length=255)),
("slug", models.CharField(max_length=255)),
("replies", models.PositiveIntegerField(default=0, db_index=True)),
("has_events", models.BooleanField(default=False)),
("has_poll", models.BooleanField(default=False)),
("has_reported_posts", models.BooleanField(default=False)),
("has_open_reports", models.BooleanField(default=False)),
("has_unapproved_posts", models.BooleanField(default=False)),
("has_hidden_posts", models.BooleanField(default=False)),
("started_on", models.DateTimeField(db_index=True)),
("starter_name", models.CharField(max_length=255)),
("starter_slug", models.CharField(max_length=255)),
("last_post_is_event", models.BooleanField(default=False)),
("last_post_on", models.DateTimeField(db_index=True)),
(
"last_poster_name",
models.CharField(max_length=255, null=True, blank=True),
),
(
"last_poster_slug",
models.CharField(max_length=255, null=True, blank=True),
),
("weight", models.PositiveIntegerField(default=0)),
("is_unapproved", models.BooleanField(default=False, db_index=True)),
("is_hidden", models.BooleanField(default=False)),
("is_closed", models.BooleanField(default=False)),
],
options={},
bases=(models.Model,),
),
migrations.CreateModel(
name="ThreadParticipant",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"thread",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.Thread",
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
("is_owner", models.BooleanField(default=False)),
],
options={},
bases=(models.Model,),
),
migrations.AddField(
model_name="thread",
name="participants",
field=models.ManyToManyField(
related_name="privatethread_set",
through="misago_threads.ThreadParticipant",
to=settings.AUTH_USER_MODEL,
),
preserve_default=True,
),
migrations.AddField(
model_name="post",
name="thread",
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE, to="misago_threads.Thread"
),
preserve_default=True,
),
migrations.AddField(
model_name="thread",
name="first_post",
field=models.ForeignKey(
related_name="+",
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to="misago_threads.Post",
null=True,
),
preserve_default=True,
),
migrations.AddField(
model_name="thread",
name="category",
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
preserve_default=True,
),
migrations.AddField(
model_name="thread",
name="last_post",
field=models.ForeignKey(
related_name="+",
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to="misago_threads.Post",
null=True,
),
preserve_default=True,
),
migrations.AddField(
model_name="thread",
name="last_poster",
field=models.ForeignKey(
related_name="last_poster_set",
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to=settings.AUTH_USER_MODEL,
null=True,
),
preserve_default=True,
),
migrations.AddField(
model_name="thread",
name="starter",
field=models.ForeignKey(
on_delete=django.db.models.deletion.SET_NULL,
blank=True,
to=settings.AUTH_USER_MODEL,
null=True,
),
preserve_default=True,
),
migrations.AlterIndexTogether(
name="thread",
index_together=set(
[
("category", "id"),
("category", "last_post_on"),
("category", "replies"),
]
),
),
migrations.AlterIndexTogether(
name="post",
index_together=set(
[("thread", "id"), ("is_event", "is_hidden"), ("poster", "posted_on")]
),
),
migrations.CreateModel(
name="Subscription",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"last_read_on",
models.DateTimeField(default=django.utils.timezone.now),
),
("send_email", models.BooleanField(default=False)),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
(
"thread",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.Thread",
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
],
options={},
bases=(models.Model,),
),
migrations.AlterIndexTogether(
name="subscription", index_together=set([("send_email", "last_read_on")])
),
migrations.CreateModel(
name="PostEdit",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("edited_on", models.DateTimeField(default=django.utils.timezone.now)),
("editor_name", models.CharField(max_length=255)),
("editor_slug", models.CharField(max_length=255)),
("editor_ip", models.GenericIPAddressField()),
("edited_from", models.TextField()),
("edited_to", models.TextField()),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
(
"editor",
models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
to=settings.AUTH_USER_MODEL,
),
),
(
"post",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
related_name="edits_record",
to="misago_threads.Post",
),
),
(
"thread",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.Thread",
),
),
],
options={"ordering": ["-id"]},
),
migrations.CreateModel(
name="Attachment",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("secret", models.CharField(max_length=64)),
(
"uploaded_on",
models.DateTimeField(
default=django.utils.timezone.now, db_index=True
),
),
("uploader_name", models.CharField(max_length=255)),
("uploader_slug", models.CharField(max_length=255, db_index=True)),
("uploader_ip", models.GenericIPAddressField()),
("filename", models.CharField(max_length=255, db_index=True)),
("size", models.PositiveIntegerField(default=0, db_index=True)),
(
"thumbnail",
models.ImageField(
max_length=255,
blank=True,
null=True,
upload_to=misago.threads.models.attachment.upload_to,
),
),
(
"image",
models.ImageField(
max_length=255,
blank=True,
null=True,
upload_to=misago.threads.models.attachment.upload_to,
),
),
(
"file",
models.FileField(
max_length=255,
blank=True,
null=True,
upload_to=misago.threads.models.attachment.upload_to,
),
),
(
"post",
models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
to="misago_threads.Post",
),
),
],
),
migrations.CreateModel(
name="AttachmentType",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("name", models.CharField(max_length=255)),
("extensions", models.CharField(max_length=255)),
("mimetypes", models.CharField(blank=True, max_length=255, null=True)),
("size_limit", models.PositiveIntegerField(default=1024)),
(
"status",
models.PositiveIntegerField(
choices=[
(0, "Allow uploads and downloads"),
(1, "Allow downloads only"),
(2, "Disallow both uploading and downloading"),
],
default=0,
),
),
(
"limit_downloads_to",
models.ManyToManyField(
blank=True,
related_name="_attachmenttype_limit_downloads_to_+",
to="misago_acl.Role",
),
),
(
"limit_uploads_to",
models.ManyToManyField(
blank=True,
related_name="_attachmenttype_limit_uploads_to_+",
to="misago_acl.Role",
),
),
],
),
migrations.AddField(
model_name="attachment",
name="filetype",
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.AttachmentType",
),
),
migrations.AddField(
model_name="attachment",
name="uploader",
field=models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
to=settings.AUTH_USER_MODEL,
),
),
migrations.CreateModel(
name="Poll",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("poster_name", models.CharField(max_length=255)),
("poster_slug", models.CharField(max_length=255)),
("poster_ip", models.GenericIPAddressField()),
("posted_on", models.DateTimeField(default=django.utils.timezone.now)),
("length", models.PositiveIntegerField(default=0)),
("question", models.CharField(max_length=255)),
("choices", models.JSONField()),
("allowed_choices", models.PositiveIntegerField(default=1)),
("allow_revotes", models.BooleanField(default=False)),
("votes", models.PositiveIntegerField(default=0)),
("is_public", models.BooleanField(default=False)),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
(
"poster",
models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
to=settings.AUTH_USER_MODEL,
),
),
(
"thread",
models.OneToOneField(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.Thread",
),
),
],
),
migrations.CreateModel(
name="PollVote",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("voter_name", models.CharField(max_length=255)),
("voter_slug", models.CharField(max_length=255)),
("voter_ip", models.GenericIPAddressField()),
("voted_on", models.DateTimeField(default=django.utils.timezone.now)),
("choice_hash", models.CharField(db_index=True, max_length=12)),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
(
"poll",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.Poll",
),
),
(
"thread",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.Thread",
),
),
(
"voter",
models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
to=settings.AUTH_USER_MODEL,
),
),
],
),
migrations.AlterIndexTogether(
name="pollvote", index_together=set([("poll", "voter_name")])
),
migrations.CreateModel(
name="PostLike",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("liker_name", models.CharField(max_length=255, db_index=True)),
("liker_slug", models.CharField(max_length=255)),
("liker_ip", models.GenericIPAddressField()),
("liked_on", models.DateTimeField(default=django.utils.timezone.now)),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
],
options={"ordering": ["-id"]},
),
migrations.AddField(
model_name="postlike",
name="post",
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE, to="misago_threads.Post"
),
),
migrations.AddField(
model_name="postlike",
name="thread",
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE, to="misago_threads.Thread"
),
),
migrations.AddField(
model_name="postlike",
name="liker",
field=models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
to=settings.AUTH_USER_MODEL,
),
),
migrations.AddField(
model_name="post",
name="liked_by",
field=models.ManyToManyField(
related_name="liked_post_set",
through="misago_threads.PostLike",
to=settings.AUTH_USER_MODEL,
),
),
]
| 24,849
|
Python
|
.py
| 654
| 20.180428
| 88
| 0.420298
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,029
|
0009_auto_20180326_0010.py
|
rafalp_Misago/misago/threads/migrations/0009_auto_20180326_0010.py
|
# Generated by Django 1.11.9 on 2018-03-26 00:10
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0008_auto_20180310_2234")]
operations = []
| 211
|
Python
|
.py
| 5
| 39
| 66
| 0.743842
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,030
|
0003_attachment_types.py
|
rafalp_Misago/misago/threads/migrations/0003_attachment_types.py
|
# Generated by Django 1.9.7 on 2016-10-04 21:41
from django.db import migrations
ATTACHMENTS = [
{
"name": "GIF",
"extensions": ("gif",),
"mimetypes": ("image/gif",),
"size_limit": 5 * 1024,
},
{
"name": "JPG",
"extensions": ("jpg", "jpeg"),
"mimetypes": ("image/jpeg",),
"size_limit": 3 * 1024,
},
{
"name": "PNG",
"extensions": ("png",),
"mimetypes": ("image/png",),
"size_limit": 3 * 1024,
},
{
"name": "WEBP",
"extensions": ("webp",),
"mimetypes": ("image/webp",),
"size_limit": 3 * 1024,
},
{
"name": "PDF",
"extensions": ("pdf",),
"mimetypes": (
"application/pdf",
"application/x-pdf",
"application/x-bzpdf",
"application/x-gzpdf",
),
"size_limit": 4 * 1024,
},
{
"name": "Text",
"extensions": ("txt",),
"mimetypes": ("text/plain",),
"size_limit": 4 * 1024,
},
{
"name": "Markdown",
"extensions": ("md",),
"mimetypes": ("text/markdown",),
"size_limit": 4 * 1024,
},
{
"name": "reStructuredText",
"extensions": ("rst",),
"mimetypes": ("text/x-rst",),
"size_limit": 4 * 1024,
},
{
"name": "7Z",
"extensions": ("7z",),
"mimetypes": ("application/x-7z-compressed",),
"size_limit": 4 * 1024,
},
{
"name": "RAR",
"extensions": ("rar",),
"mimetypes": ("application/vnd.rar",),
"size_limit": 4 * 1024,
},
{
"name": "TAR",
"extensions": ("tar",),
"mimetypes": ("application/x-tar",),
"size_limit": 4 * 1024,
},
{
"name": "GZ",
"extensions": ("gz",),
"mimetypes": ("application/gzip",),
"size_limit": 4 * 1024,
},
{
"name": "ZIP",
"extensions": ("zip", "zipx"),
"mimetypes": ("application/zip",),
"size_limit": 4 * 1024,
},
]
def create_attachment_types(apps, schema_editor):
AttachmentType = apps.get_model("misago_threads", "AttachmentType")
for attachment in ATTACHMENTS:
kwargs = attachment
kwargs["extensions"] = ",".join(kwargs["extensions"])
kwargs["mimetypes"] = ",".join(kwargs["mimetypes"])
AttachmentType.objects.create(**kwargs)
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0002_threads_settings")]
operations = [migrations.RunPython(create_attachment_types)]
| 2,628
|
Python
|
.py
| 97
| 19.597938
| 71
| 0.487921
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,031
|
0008_auto_20180310_2234.py
|
rafalp_Misago/misago/threads/migrations/0008_auto_20180310_2234.py
|
# Generated by Django 1.11.9 on 2018-03-10 22:34
import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
("misago_threads", "0007_auto_20171008_0131"),
]
operations = [
migrations.AddField(
model_name="thread",
name="best_answer",
field=models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
related_name="+",
to="misago_threads.Post",
),
),
migrations.AddField(
model_name="thread",
name="best_answer_is_protected",
field=models.BooleanField(default=False),
),
migrations.AddField(
model_name="thread",
name="best_answer_marked_by",
field=models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
related_name="marked_best_answer_set",
to=settings.AUTH_USER_MODEL,
),
),
migrations.AddField(
model_name="thread",
name="best_answer_marked_by_name",
field=models.CharField(blank=True, max_length=255, null=True),
),
migrations.AddField(
model_name="thread",
name="best_answer_marked_by_slug",
field=models.CharField(blank=True, max_length=255, null=True),
),
migrations.AddField(
model_name="thread",
name="best_answer_marked_on",
field=models.DateTimeField(blank=True, null=True),
),
]
| 1,846
|
Python
|
.py
| 53
| 23.811321
| 74
| 0.560335
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,032
|
0011_remove_custom_partial_indexes.py
|
rafalp_Misago/misago/threads/migrations/0011_remove_custom_partial_indexes.py
|
# Generated by Django 2.2.1 on 2019-05-18 16:31
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0010_auto_20180609_1523")]
operations = [
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_has_ope_479906_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_is_hidd_85db69_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_is_even_42bda7_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_weight_955884_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_weight_9e8f9c_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_weight_c7ef29_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_weight__4af9ee_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_has_rep_84acfa_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_has_una_b0dbf5_part"),
migrations.RunSQL("DROP INDEX IF EXISTS misago_thre_is_hidd_d2b96c_part"),
]
| 1,043
|
Python
|
.py
| 16
| 58.1875
| 82
| 0.723363
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,033
|
0004_update_settings.py
|
rafalp_Misago/misago/threads/migrations/0004_update_settings.py
|
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_threads", "0003_attachment_types")]
operations = []
| 160
|
Python
|
.py
| 4
| 36.25
| 64
| 0.751634
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,034
|
0013_rename_pollvote_poll_voter_name_misago_thre_poll_id_c3e8fe_idx_and_more.py
|
rafalp_Misago/misago/threads/migrations/0013_rename_pollvote_poll_voter_name_misago_thre_poll_id_c3e8fe_idx_and_more.py
|
# Generated by Django 4.2.7 on 2023-11-13 19:08
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("misago_acl", "0004_cache_version"),
("misago_threads", "0012_set_dj_partial_indexes"),
]
operations = [
migrations.RenameIndex(
model_name="pollvote",
new_name="misago_thre_poll_id_c3e8fe_idx",
old_fields=("poll", "voter_name"),
),
migrations.RenameIndex(
model_name="post",
new_name="misago_thre_thread__4e5114_idx",
old_fields=("thread", "id"),
),
migrations.RenameIndex(
model_name="post",
new_name="misago_thre_poster__eefeb2_idx",
old_fields=("poster", "posted_on"),
),
migrations.RenameIndex(
model_name="post",
new_name="misago_thre_is_even_d29c90_idx",
old_fields=("is_event", "is_hidden"),
),
migrations.RenameIndex(
model_name="subscription",
new_name="misago_thre_send_em_da8b99_idx",
old_fields=("send_email", "last_read_on"),
),
migrations.RenameIndex(
model_name="thread",
new_name="misago_thre_categor_6cb52c_idx",
old_fields=("category", "id"),
),
migrations.RenameIndex(
model_name="thread",
new_name="misago_thre_categor_7ec8b0_idx",
old_fields=("category", "last_post_on"),
),
migrations.RenameIndex(
model_name="thread",
new_name="misago_thre_categor_c5eaf1_idx",
old_fields=("category", "replies"),
),
migrations.AlterField(
model_name="attachmenttype",
name="limit_downloads_to",
field=models.ManyToManyField(
blank=True, related_name="+", to="misago_acl.role"
),
),
migrations.AlterField(
model_name="attachmenttype",
name="limit_uploads_to",
field=models.ManyToManyField(
blank=True, related_name="+", to="misago_acl.role"
),
),
]
| 2,214
|
Python
|
.py
| 63
| 24.428571
| 66
| 0.541686
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,035
|
0014_plugin_data.py
|
rafalp_Misago/misago/threads/migrations/0014_plugin_data.py
|
# Generated by Django 4.2.7 on 2023-12-05 19:22
import django.contrib.postgres.indexes
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
(
"misago_threads",
"0013_rename_pollvote_poll_voter_name_misago_thre_poll_id_c3e8fe_idx_and_more",
),
]
operations = [
migrations.AddField(
model_name="attachment",
name="plugin_data",
field=models.JSONField(default=dict),
),
migrations.AddField(
model_name="attachmenttype",
name="plugin_data",
field=models.JSONField(default=dict),
),
migrations.AddField(
model_name="poll",
name="plugin_data",
field=models.JSONField(default=dict),
),
migrations.AddField(
model_name="post",
name="plugin_data",
field=models.JSONField(default=dict),
),
migrations.AddField(
model_name="thread",
name="plugin_data",
field=models.JSONField(default=dict),
),
migrations.AddIndex(
model_name="attachment",
index=django.contrib.postgres.indexes.GinIndex(
fields=["plugin_data"], name="misago_thre_plugin__46d25a_gin"
),
),
migrations.AddIndex(
model_name="attachmenttype",
index=django.contrib.postgres.indexes.GinIndex(
fields=["plugin_data"], name="misago_thre_plugin__236db5_gin"
),
),
migrations.AddIndex(
model_name="poll",
index=django.contrib.postgres.indexes.GinIndex(
fields=["plugin_data"], name="misago_thre_plugin__5e1be7_gin"
),
),
migrations.AddIndex(
model_name="post",
index=django.contrib.postgres.indexes.GinIndex(
fields=["plugin_data"], name="misago_thre_plugin__91da06_gin"
),
),
migrations.AddIndex(
model_name="thread",
index=django.contrib.postgres.indexes.GinIndex(
fields=["plugin_data"], name="misago_thre_plugin__e6e836_gin"
),
),
]
| 2,287
|
Python
|
.py
| 67
| 23.283582
| 91
| 0.556859
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,036
|
thread.py
|
rafalp_Misago/misago/threads/views/thread.py
|
from django.shortcuts import render
from django.urls import reverse
from django.views import View
from ..viewmodels import ForumThread, PrivateThread, ThreadPosts
class ThreadBase(View):
thread = None
posts = ThreadPosts
template_name = None
def get(self, request, pk, slug, page=0):
thread = self.get_thread(request, pk, slug)
posts = self.get_posts(request, thread, page)
frontend_context = self.get_frontend_context(request, thread, posts)
request.frontend_context.update(frontend_context)
template_context = self.get_template_context(request, thread, posts)
return render(request, self.template_name, template_context)
def get_thread(self, request, pk, slug):
return self.thread( # pylint: disable=not-callable
request,
pk,
slug,
path_aware=True,
read_aware=True,
watch_aware=True,
poll_votes_aware=True,
)
def get_posts(self, request, thread, page):
return self.posts(request, thread, page)
def get_default_frontend_context(self):
return {}
def get_frontend_context(self, request, thread, posts):
context = self.get_default_frontend_context()
context.update(
{
"THREAD": thread.get_frontend_context(),
"POSTS": posts.get_frontend_context(),
}
)
return context
def get_template_context(self, request, thread, posts):
context = {
"url_name": ":".join(
request.resolver_match.namespaces + [request.resolver_match.url_name]
)
}
context.update(thread.get_template_context())
context.update(posts.get_template_context())
return context
class ThreadView(ThreadBase):
thread = ForumThread
template_name = "misago/thread/thread.html"
def get_default_frontend_context(self):
return {"THREADS_API": reverse("misago:api:thread-list")}
class PrivateThreadView(ThreadBase):
thread = PrivateThread
template_name = "misago/thread/private_thread.html"
| 2,158
|
Python
|
.py
| 55
| 30.654545
| 85
| 0.646974
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,037
|
redirect.py
|
rafalp_Misago/misago/threads/views/redirect.py
|
from django.core.exceptions import PermissionDenied
from django.http import Http404, HttpRequest, HttpResponse
from django.db.models import QuerySet
from django.shortcuts import get_object_or_404, redirect
from django.utils.translation import pgettext
from django.views import View
from ...categories.enums import CategoryTree
from ...readtracker.readtime import get_default_read_time
from ..hooks import get_redirect_to_post_response_hook
from ..models import Post, Thread
from .generic import PrivateThreadView, ThreadView
class RedirectView(View):
def get(self, request: HttpRequest, id: int, slug: str, **kwargs) -> HttpResponse:
thread = self.get_thread(request, id)
queryset = self.get_thread_posts_queryset(request, thread)
post = self.get_post(request, thread, queryset, kwargs)
paginator = self.get_thread_posts_paginator(request, queryset)
if post:
post_id = post.id
offset = queryset.filter(id__lt=post_id).count()
page = paginator.get_item_page(offset)
else:
post_id = queryset.last().id
page = paginator.num_pages
thread_url = self.get_thread_url(thread, page) + f"#post-{post_id}"
return redirect(thread_url)
def get_post(
self, request: HttpRequest, thread: Thread, queryset: QuerySet, kwargs: dict
) -> Post | None:
raise NotImplementedError()
class LastPostRedirectView(RedirectView):
def get_post(self, *args) -> None:
return None # Redirect to last post is default
class ThreadLastPostRedirectView(LastPostRedirectView, ThreadView):
pass
class PrivateThreadLastPostRedirectView(LastPostRedirectView, PrivateThreadView):
pass
class UnreadPostRedirectView(RedirectView):
thread_annotate_read_time = True
def get_post(
self, request: HttpRequest, thread: Thread, queryset: QuerySet, kwargs: dict
) -> Post | None:
if request.user.is_anonymous:
return None
read_times = [get_default_read_time(request.settings, request.user)]
if thread.read_time:
read_times.append(thread.read_time)
if thread.category_read_time:
read_times.append(thread.category_read_time)
read_time = max(read_times)
return queryset.filter(posted_on__gt=read_time).first()
class ThreadUnreadPostRedirectView(UnreadPostRedirectView, ThreadView):
pass
class PrivateThreadUnreadPostRedirectView(UnreadPostRedirectView, PrivateThreadView):
pass
class SolutionRedirectView(RedirectView):
thread_annotate_read_time = True
def get_post(
self, request: HttpRequest, thread: Thread, queryset: QuerySet, kwargs: dict
) -> Post | None:
if not thread.best_answer_id:
return None
return queryset.filter(id=thread.best_answer_id).first()
class ThreadSolutionRedirectView(SolutionRedirectView, ThreadView):
pass
class UnapprovedPostRedirectView(RedirectView):
def raise_permission_denied_error(self):
raise PermissionDenied(
pgettext(
"unaproved post redirect",
"You must be a moderator to view unapproved posts.",
)
)
class ThreadUnapprovedPostRedirectView(UnapprovedPostRedirectView, ThreadView):
def get_post(
self, request: HttpRequest, thread: Thread, queryset: QuerySet, kwargs: dict
) -> Post | None:
if not (
request.user_permissions.is_global_moderator
or thread.category in request.user_permissions.categories_moderator
):
self.raise_permission_denied_error()
return queryset.filter(is_unapproved=True).first()
class PrivateThreadUnapprovedPostRedirectView(
UnapprovedPostRedirectView, PrivateThreadView
):
def get_post(
self, request: HttpRequest, thread: Thread, queryset: QuerySet, kwargs: dict
) -> Post | None:
if not request.user_permissions.private_threads_moderator:
self.raise_permission_denied_error()
return queryset.filter(is_unapproved=True).first()
class PostRedirectView(View):
def get(self, request: HttpRequest, id: int) -> HttpResponse:
queryset = Post.objects.select_related("category")
post = get_object_or_404(queryset, id=id)
return get_redirect_to_post_response(request, post)
def get_redirect_to_post_response(request: HttpRequest, post: Post) -> HttpResponse:
try:
return get_redirect_to_post_response_hook(
_get_redirect_to_post_response_action, request, post
)
except PermissionDenied:
raise Http404()
def _get_redirect_to_post_response_action(
request: HttpRequest, post: Post
) -> HttpResponse:
if post.category.tree_id == CategoryTree.THREADS:
return thread_post_redirect(request, post.thread_id, "", post=post.id)
if post.category.tree_id == CategoryTree.PRIVATE_THREADS:
return private_thread_post_redirect(request, post.thread_id, "", post=post.id)
raise Http404()
class GetPostRedirectView(RedirectView):
def get_post(
self, request: HttpRequest, thread: Thread, queryset: QuerySet, kwargs: dict
) -> Post | None:
return get_object_or_404(queryset, id=kwargs["post"])
class ThreadPostRedirectView(GetPostRedirectView, ThreadView):
pass
class PrivateThreadPostRedirectView(GetPostRedirectView, PrivateThreadView):
pass
thread_post_redirect = ThreadPostRedirectView.as_view()
private_thread_post_redirect = PrivateThreadPostRedirectView.as_view()
| 5,582
|
Python
|
.py
| 123
| 38.504065
| 86
| 0.716346
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,038
|
generic.py
|
rafalp_Misago/misago/threads/views/generic.py
|
from typing import Iterable
from django.core.paginator import Paginator
from django.db.models import QuerySet
from django.http import HttpRequest
from django.http.response import HttpResponse as HttpResponse
from django.shortcuts import get_object_or_404
from django.urls import reverse
from django.views import View
from ...permissions.privatethreads import (
check_see_private_thread_permission,
filter_private_thread_posts_queryset,
)
from ...permissions.threads import (
check_see_thread_permission,
filter_thread_posts_queryset,
)
from ...readtracker.tracker import annotate_threads_read_time
from ..models import Post, Thread
from ..paginator import ThreadRepliesPaginator
class GenericView(View):
thread_select_related: Iterable[str] | True | None = None
thread_annotate_read_time: bool = False
post_select_related: Iterable[str] | None = None
thread_url_name: str
def get_thread(self, request: HttpRequest, thread_id: int) -> Thread:
queryset = self.get_thread_queryset(request)
return get_object_or_404(queryset, id=thread_id)
def get_thread_queryset(self, request: HttpRequest) -> Thread:
queryset = Thread.objects
if self.thread_annotate_read_time:
queryset = annotate_threads_read_time(request.user, queryset)
if self.thread_select_related is True:
return queryset.select_related()
elif self.thread_select_related:
return queryset.select_related(*self.thread_select_related)
return queryset
def get_thread_posts_queryset(
self, request: HttpRequest, thread: Thread
) -> QuerySet:
return thread.post_set.order_by("id")
def get_thread_post(
self, request: HttpRequest, thread: Thread, post_id: int
) -> Post:
queryset = self.get_thread_posts_queryset(request, thread)
return queryset.get(id=post_id)
def get_thread_posts_paginator(
self,
request: HttpRequest,
queryset: QuerySet,
) -> Paginator:
return ThreadRepliesPaginator(
queryset.order_by("id"),
request.settings.posts_per_page,
request.settings.posts_per_page_orphans,
)
def get_thread_url(self, thread: Thread, page: int | None = None) -> str:
if page and page > 1:
return reverse(
self.thread_url_name,
kwargs={"id": thread.id, "slug": thread.slug, "page": page},
)
return reverse(
self.thread_url_name,
kwargs={"id": thread.id, "slug": thread.slug},
)
class ThreadView(GenericView):
thread_select_related: Iterable[str] | True | None = ("category",)
thread_url_name: str = "misago:thread"
def get_thread(self, request: HttpRequest, thread_id: int) -> Thread:
thread = super().get_thread(request, thread_id)
check_see_thread_permission(request.user_permissions, thread.category, thread)
return thread
def get_thread_posts_queryset(
self, request: HttpRequest, thread: Thread
) -> QuerySet:
queryset = super().get_thread_posts_queryset(request, thread)
return filter_thread_posts_queryset(request.user_permissions, thread, queryset)
class PrivateThreadView(GenericView):
thread_url_name: str = "misago:private-thread"
def get_thread(self, request: HttpRequest, thread_id: int) -> Thread:
thread = super().get_thread(request, thread_id)
check_see_private_thread_permission(request.user_permissions, thread)
return thread
def get_thread_posts_queryset(
self, request: HttpRequest, thread: Thread
) -> QuerySet:
queryset = super().get_thread_posts_queryset(request, thread)
return filter_private_thread_posts_queryset(
request.user_permissions, thread, queryset
)
| 3,880
|
Python
|
.py
| 90
| 35.988889
| 87
| 0.686555
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,039
|
attachment.py
|
rafalp_Misago/misago/threads/views/attachment.py
|
from django.templatetags.static import static
from django.core.exceptions import PermissionDenied
from django.http import Http404
from django.shortcuts import get_object_or_404, redirect
from ...conf import settings
from ..models import Attachment, AttachmentType
def attachment_server(request, pk, secret, thumbnail=False):
try:
url = serve_file(request, pk, secret, thumbnail)
return redirect(url)
except PermissionDenied:
error_image = request.settings.attachment_403_image
if not error_image:
error_image = static(settings.MISAGO_ATTACHMENT_403_IMAGE)
return redirect(error_image)
except Http404:
error_image = request.settings.attachment_404_image
if not error_image:
error_image = static(settings.MISAGO_ATTACHMENT_404_IMAGE)
return redirect(error_image)
def serve_file(request, pk, secret, thumbnail):
queryset = Attachment.objects.select_related("filetype")
attachment = get_object_or_404(queryset, pk=pk, secret=secret)
if not attachment.post_id and request.GET.get("shva") != "1":
# if attachment is orphaned, don't run acl test unless explicitly told so
# this saves user suprise of deleted attachment still showing in posts/quotes
raise Http404()
if not request.user.is_misago_admin:
allow_file_download(request, attachment)
if attachment.is_image:
if thumbnail and attachment.thumbnail:
return attachment.thumbnail.url
return attachment.image.url
if thumbnail:
raise Http404()
return attachment.file.url
def allow_file_download(request, attachment):
is_authenticated = request.user.is_authenticated
if not is_authenticated or request.user.id != attachment.uploader_id:
if not attachment.post_id:
raise Http404()
if not request.user_acl["can_download_other_users_attachments"]:
raise PermissionDenied()
allowed_roles = set(r.pk for r in attachment.filetype.limit_downloads_to.all())
if allowed_roles:
user_roles = set(r.pk for r in request.user.get_roles())
if not user_roles & allowed_roles:
raise PermissionDenied()
if attachment.filetype.status == AttachmentType.DISABLED:
raise PermissionDenied()
| 2,319
|
Python
|
.py
| 50
| 39.26
| 85
| 0.713525
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,040
|
replies.py
|
rafalp_Misago/misago/threads/views/replies.py
|
from datetime import datetime
from typing import TYPE_CHECKING, Any
from django.contrib.auth import get_user_model
from django.db.models import QuerySet, prefetch_related_objects
from django.http import HttpRequest, HttpResponse
from django.shortcuts import redirect, render
from django.views import View
from ...categories.models import Category
from ...core.exceptions import OutdatedSlug
from ...notifications.threads import update_watched_thread_read_time
from ...readtracker.tracker import (
get_unread_posts,
mark_category_read,
mark_thread_read,
)
from ...readtracker.privatethreads import unread_private_threads_exist
from ...readtracker.threads import is_category_read
from ..hooks import (
get_private_thread_replies_page_context_data_hook,
get_private_thread_replies_page_posts_queryset_hook,
get_private_thread_replies_page_thread_queryset_hook,
get_thread_posts_feed_item_user_ids_hook,
get_thread_posts_feed_users_hook,
get_thread_replies_page_context_data_hook,
get_thread_replies_page_posts_queryset_hook,
get_thread_replies_page_thread_queryset_hook,
set_thread_posts_feed_item_users_hook,
)
from ..models import Post, Thread
from .generic import PrivateThreadView, ThreadView
if TYPE_CHECKING:
from ...users.models import User
else:
User = get_user_model()
class PageOutOfRangeError(Exception):
redirect_to: str
def __init__(self, redirect_to: str):
self.redirect_to = redirect_to
class RepliesView(View):
thread_annotate_read_time: bool = True
template_name: str
template_partial_name: str
feed_template_name: str = "misago/posts_feed/index.html"
feed_post_template_name: str = "misago/posts_feed/post.html"
def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
try:
return super().dispatch(request, *args, **kwargs)
except PageOutOfRangeError as exc:
return redirect(exc.redirect_to)
def get(
self, request: HttpRequest, id: int, slug: str, page: int | None = None
) -> HttpResponse:
thread = self.get_thread(request, id)
if not request.is_htmx and thread.slug != slug:
raise OutdatedSlug(thread)
context = self.get_context_data(request, thread, page)
if request.is_htmx:
template_name = self.template_partial_name
else:
template_name = self.template_name
return render(request, template_name, context)
def get_context_data(
self, request: HttpRequest, thread: Thread, page: int | None = None
) -> dict:
return self.get_context_data_action(request, thread, page)
def get_context_data_action(
self, request: HttpRequest, thread: Thread, page: int | None = None
) -> dict:
return {
"thread": thread,
"thread_url": self.get_thread_url(thread),
"feed": self.get_posts_feed_data(request, thread, page),
}
def get_posts_feed_data(
self, request: HttpRequest, thread: Thread, page: int | None = None
) -> dict:
queryset = self.get_thread_posts_queryset(request, thread)
paginator = self.get_thread_posts_paginator(request, queryset)
if page and page > paginator.num_pages:
if not request.is_htmx:
raise PageOutOfRangeError(
self.get_thread_url(thread, paginator.num_pages)
)
page = paginator.num_pages
page_obj = paginator.get_page(page)
posts = list(page_obj.object_list)
unread = get_unread_posts(request, thread, posts)
items: list[dict] = []
for post in posts:
items.append(
{
"template_name": self.feed_post_template_name,
"type": "post",
"post": post,
"poster": None,
"poster_name": post.poster_name,
"unread": post.id in unread,
}
)
self.set_posts_feed_users(request, items)
if unread:
self.update_thread_read_time(request, thread, posts[-1].posted_on)
if request.user.is_authenticated and request.user.unread_notifications:
self.read_user_notifications(request.user, posts)
return {
"template_name": self.feed_template_name,
"items": items,
"paginator": page_obj,
}
def set_posts_feed_users(self, request: HttpRequest, feed: list[dict]) -> None:
user_ids: set[int] = set()
for item in feed:
self.get_posts_feed_item_user_ids(item, user_ids)
get_thread_posts_feed_item_user_ids_hook(item, user_ids)
if not user_ids:
return
users = get_thread_posts_feed_users_hook(
self.get_posts_feed_users, request, user_ids
)
for item in feed:
set_thread_posts_feed_item_users_hook(
self.set_post_feed_item_users, users, item
)
def get_posts_feed_item_user_ids(self, item: dict, user_ids: set[int]):
if item["type"] == "post":
user_ids.add(item["post"].poster_id)
def get_posts_feed_users(
self, request: HttpRequest, user_ids: set[int]
) -> dict[int, "User"]:
users: dict[int, "User"] = {}
for user in User.objects.filter(id__in=user_ids):
if user.is_active or (
request.user.is_authenticated and request.user.is_misago_admin
):
users[user.id] = user
prefetch_related_objects(list(users.values()), "group")
return users
def set_post_feed_item_users(self, users: dict[int, "User"], item: dict):
if item["type"] == "post":
item["poster"] = users.get(item["post"].poster_id)
def update_thread_read_time(
self,
request: HttpRequest,
thread: Thread,
read_time: datetime,
):
mark_thread_read(request.user, thread, read_time)
update_watched_thread_read_time(request.user, thread, read_time)
if self.is_category_read(request, thread.category, thread.category_read_time):
self.mark_category_read(
request.user,
thread.category,
force_update=bool(thread.category_read_time),
)
def is_category_read(
self,
request: HttpRequest,
category: Category,
category_read_time: datetime | None,
) -> bool:
raise NotImplementedError()
def mark_category_read(
self,
user: "User",
category: Category,
*,
force_update: bool,
):
mark_category_read(user, category, force_update=force_update)
def read_user_notifications(self, user: "User", posts: list[Post]):
updated_notifications = user.notification_set.filter(
post__in=posts, is_read=False
).update(is_read=True)
if updated_notifications:
new_unread_notifications = max(
[0, user.unread_notifications - updated_notifications]
)
if user.unread_notifications != new_unread_notifications:
user.unread_notifications = new_unread_notifications
user.save(update_fields=["unread_notifications"])
class ThreadRepliesView(RepliesView, ThreadView):
template_name: str = "misago/thread/index.html"
template_partial_name: str = "misago/thread/partial.html"
def get_thread_queryset(self, request: HttpRequest) -> Thread:
return get_thread_replies_page_thread_queryset_hook(
super().get_thread_queryset, request
)
def get_context_data(
self, request: HttpRequest, thread: Thread, page: int | None = None
) -> dict:
return get_thread_replies_page_context_data_hook(
self.get_context_data_action, request, thread, page
)
def get_context_data_action(
self, request: HttpRequest, thread: Thread, page: int | None = None
) -> dict:
context = super().get_context_data_action(request, thread, page)
context.update(
{
"category": thread.category,
}
)
return context
def get_thread_posts_queryset(
self, request: HttpRequest, thread: Thread
) -> QuerySet:
return get_thread_replies_page_posts_queryset_hook(
super().get_thread_posts_queryset, request, thread
)
def is_category_read(
self,
request: HttpRequest,
category: Category,
category_read_time: datetime | None,
) -> bool:
return is_category_read(request, category, category_read_time)
class PrivateThreadRepliesView(RepliesView, PrivateThreadView):
template_name: str = "misago/private_thread/index.html"
template_partial_name: str = "misago/private_thread/partial.html"
def get_thread_queryset(self, request: HttpRequest) -> Thread:
return get_private_thread_replies_page_thread_queryset_hook(
super().get_thread_queryset, request
)
def get_context_data(
self, request: HttpRequest, thread: Thread, page: int | None = None
) -> dict:
return get_private_thread_replies_page_context_data_hook(
self.get_context_data_action, request, thread, page
)
def get_context_data_action(
self, request: HttpRequest, thread: Thread, page: int | None = None
) -> dict:
context = super().get_context_data_action(request, thread, page)
context.update(
{
"participants": None,
}
)
return context
def get_thread_posts_queryset(
self, request: HttpRequest, thread: Thread
) -> QuerySet:
return get_private_thread_replies_page_posts_queryset_hook(
super().get_thread_posts_queryset, request, thread
)
def update_thread_read_time(
self,
request: HttpRequest,
thread: Thread,
read_time: datetime,
):
unread_private_threads = request.user.unread_private_threads
if read_time >= thread.last_post_on and request.user.unread_private_threads:
request.user.unread_private_threads -= 1
super().update_thread_read_time(request, thread, read_time)
if request.user.unread_private_threads != unread_private_threads:
request.user.save(update_fields=["unread_private_threads"])
def is_category_read(
self,
request: HttpRequest,
category: Category,
category_read_time: datetime | None,
) -> bool:
return not unread_private_threads_exist(request, category, category_read_time)
def mark_category_read(
self,
user: "User",
category: Category,
*,
force_update: bool,
):
super().mark_category_read(user, category, force_update=force_update)
user.clear_unread_private_threads()
thread_replies = ThreadRepliesView.as_view()
private_thread_replies = PrivateThreadRepliesView.as_view()
| 11,210
|
Python
|
.py
| 275
| 31.872727
| 88
| 0.633361
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,041
|
subscribed.py
|
rafalp_Misago/misago/threads/views/subscribed.py
|
from django.http import HttpRequest
from django.shortcuts import redirect
def redirect_subscribed_to_watched(request: HttpRequest, **kwargs):
return redirect(
request.path.replace("/subscribed/", "/watched/"),
permanent=True,
)
| 254
|
Python
|
.py
| 7
| 31.571429
| 67
| 0.734694
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,042
|
list.py
|
rafalp_Misago/misago/threads/views/list.py
|
import re
from math import ceil
from typing import Any, TYPE_CHECKING, Type
from django.contrib import messages
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied, ValidationError
from django.db import transaction
from django.http import Http404, HttpRequest
from django.http.response import HttpResponse
from django.shortcuts import redirect, render
from django.urls import reverse
from django.utils import timezone
from django.utils.translation import pgettext
from django.views import View
from ...categories.enums import CategoryChildrenComponent, CategoryTree
from ...categories.components import get_categories_data, get_subcategories_data
from ...categories.models import Category
from ...core.exceptions import OutdatedSlug
from ...metatags.metatag import MetaTag
from ...metatags.metatags import (
get_default_metatags,
get_forum_index_metatags,
)
from ...moderation.results import (
ModerationBulkResult,
ModerationResult,
ModerationTemplateResult,
)
from ...moderation.threads import (
CloseThreadsBulkModerationAction,
MoveThreadsBulkModerationAction,
OpenThreadsBulkModerationAction,
ThreadsBulkModerationAction,
)
from ...pagination.cursor import (
CursorPaginationResult,
EmptyPageError,
paginate_queryset,
)
from ...pagination.redirect import redirect_to_last_page
from ...permissions.categories import check_browse_category_permission
from ...permissions.enums import CategoryPermission
from ...permissions.privatethreads import (
check_private_threads_permission,
check_start_private_threads_permission,
filter_private_threads_queryset,
)
from ...permissions.threads import (
CategoryThreadsQuerysetFilter,
ThreadsQuerysetFilter,
check_start_thread_in_category_permission,
)
from ...readtracker.privatethreads import unread_private_threads_exist
from ...readtracker.threads import is_category_read
from ...readtracker.tracker import (
annotate_categories_read_time,
annotate_threads_read_time,
get_unread_threads,
mark_category_read,
)
from ...readtracker.models import ReadCategory, ReadThread
from ..enums import (
ThreadsListsPolling,
ThreadWeight,
)
from ..filters import (
MyThreadsFilter,
ThreadsFilter,
ThreadsFilterChoice,
UnapprovedThreadsFilter,
UnreadThreadsFilter,
)
from ..hooks import (
get_category_threads_page_context_data_hook,
get_category_threads_page_filters_hook,
get_category_threads_page_moderation_actions_hook,
get_category_threads_page_queryset_hook,
get_category_threads_page_subcategories_hook,
get_category_threads_page_threads_hook,
get_private_threads_page_context_data_hook,
get_private_threads_page_filters_hook,
get_private_threads_page_queryset_hook,
get_private_threads_page_threads_hook,
get_threads_page_context_data_hook,
get_threads_page_filters_hook,
get_threads_page_moderation_actions_hook,
get_threads_page_queryset_hook,
get_threads_page_subcategories_hook,
get_threads_page_threads_hook,
)
from ..models import Thread
if TYPE_CHECKING:
from ...users.models import User
else:
User = get_user_model()
POLL_NEW_THREADS = "poll_new"
ANIMATE_NEW_THREADS = "animate_new"
class ListView(View):
template_name: str
template_name_htmx: str
moderation_page_template_name: str
moderation_modal_template_name: str
threads_component_template_name = "misago/threads_list/index.html"
new_threads_template_name = "misago/threads/poll_new.html"
def dispatch(
self,
request: HttpRequest,
*args: Any,
**kwargs: Any,
) -> HttpResponse:
try:
return super().dispatch(request, *args, **kwargs)
except EmptyPageError as exc:
return redirect_to_last_page(request, exc)
def get(self, request: HttpRequest, **kwargs):
if (
request.is_htmx
and self.is_threads_polling_enabled(request)
and POLL_NEW_THREADS in request.GET
):
return self.poll_new_threads(request, kwargs)
context = self.get_context_data(request, kwargs)
if request.is_htmx:
template_name = self.template_name_htmx
else:
template_name = self.template_name
return render(request, template_name, context)
def get_context_data(self, request: HttpRequest, kwargs: dict) -> dict:
return {}
def show_thread_flags(
self,
for_moderator: bool,
thread: Thread,
category: Category | None = None,
) -> bool:
if (
thread.weight == ThreadWeight.PINNED_GLOBALLY
or thread.is_closed
or thread.has_best_answer
or thread.has_poll
):
return True
if thread.weight == ThreadWeight.PINNED_IN_CATEGORY and (
(category and category.id == thread.category_id) or for_moderator
):
return True
if for_moderator and thread.has_unapproved_posts:
return True
return False
def get_threads_users(self, request: HttpRequest, threads: list[Thread]) -> dict:
user_ids: set[int] = set()
for thread in threads:
user_ids.add(thread.starter_id)
user_ids.add(thread.last_poster_id)
if not user_ids:
return {}
return {user.id: user for user in User.objects.filter(id__in=user_ids)}
def get_threads_to_animate(
self, request: HttpRequest, kwargs: dict, threads: list[Thread]
) -> dict[int, bool]:
if "animate" in kwargs:
return {thread.id: thread.id in kwargs["animate"] for thread in threads}
if not request.is_htmx or ANIMATE_NEW_THREADS not in request.GET:
return {}
try:
animate_threads = int(request.GET.get(ANIMATE_NEW_THREADS))
if animate_threads < 0:
raise Http404()
except (ValueError, TypeError):
raise Http404()
return {thread.id: thread.last_post_id > animate_threads for thread in threads}
def get_thread_urls(self, thread: Thread) -> dict[str, str]:
kwargs = {"id": thread.id, "slug": thread.slug}
return {
"absolute_url": reverse("misago:thread", kwargs=kwargs),
"last_post_url": reverse("misago:thread-last-post", kwargs=kwargs),
"unapproved_post_url": reverse(
"misago:thread-unapproved-post", kwargs=kwargs
),
"unread_post_url": reverse("misago:thread-unread-post", kwargs=kwargs),
"solution_post_url": reverse("misago:thread-solution-post", kwargs=kwargs),
}
def post_mark_as_read(self, request: HttpRequest, kwargs: dict) -> HttpResponse:
current_url = request.get_full_path_info()
if request.user.is_authenticated:
if response := self.mark_as_read(request, kwargs):
return response
if request.is_htmx:
return self.get(request, **kwargs)
return redirect(current_url)
def mark_as_read(self, request: HttpRequest, kwargs: dict) -> HttpResponse | None:
raise NotImplementedError()
@transaction.atomic
def read_categories(self, user: "User", categories_ids: list[str]):
if not categories_ids:
return
read_time = timezone.now()
# Clear read tracker for categories
ReadThread.objects.filter(user=user, category_id__in=categories_ids).delete()
ReadCategory.objects.filter(user=user, category_id__in=categories_ids).delete()
ReadCategory.objects.bulk_create(
ReadCategory(user=user, read_time=read_time, category_id=category_id)
for category_id in categories_ids
)
def post_moderation(self, request: HttpRequest, kwargs: dict) -> HttpResponse:
try:
current_url = request.get_full_path_info()
result = self.moderate_threads(request, kwargs)
if isinstance(result, ModerationTemplateResult):
result.update_context(
{
"template_name": result.template_name,
"cancel_url": current_url,
}
)
if request.is_htmx:
template_name = self.moderation_modal_template_name
else:
template_name = self.moderation_page_template_name
return render(request, template_name, result.context)
if request.is_htmx:
if isinstance(result, ModerationBulkResult) and result.updated:
kwargs.update({"animate": result.updated})
response = self.get(request, **kwargs)
self.set_moderation_response_headers(request, response)
return response
return redirect(current_url)
except ValidationError as e:
messages.error(request, e.message)
return self.get(request, **kwargs)
def set_moderation_response_headers(
self, request: HttpRequest, response: HttpResponse
):
response.headers["hx-trigger"] = "misago:afterModeration"
if request.POST.get("success-hx-target"):
response.headers["hx-retarget"] = request.POST["success-hx-target"]
if request.POST.get("success-hx-swap"):
response.headers["hx-reswap"] = request.POST["success-hx-swap"]
def moderate_threads(self, request: HttpRequest, kwargs) -> dict | None:
raise NotImplementedError()
def get_moderation_action(
self, request: HttpRequest, threads: dict
) -> ThreadsBulkModerationAction | None:
action_id = request.POST["moderation"]
for action in threads["moderation_actions"]:
if action.id == action_id:
return action()
raise ValidationError(
pgettext("threads moderation error", "Invalid moderation action."),
)
def get_selected_threads(self, request: HttpRequest, threads: dict) -> list[Thread]:
threads_ids = self.get_selected_threads_ids(request)
selection: list[Thread] = []
for thread_data in threads["items"]:
thread = thread_data["thread"]
if thread.id in threads_ids:
if not thread_data["moderation"]:
raise ValidationError(
pgettext(
"threads moderation error",
'Can\'t moderate the "%(thread)s" thread.',
)
% {"thread": thread.title},
)
selection.append(thread)
if not selection:
raise ValidationError(
pgettext("threads moderation error", "No valid threads selected."),
)
return selection
def get_selected_threads_ids(self, request: HttpRequest) -> set[int]:
threads_ids: set[int] = set()
for thread_id in request.POST.getlist("threads"):
try:
threads_ids.add(int(thread_id))
except (TypeError, ValueError):
pass
return threads_ids
def get_threads_latest_post_id(self, threads: list[Thread]) -> int:
if threads:
return max(t.last_post_id for t in threads)
return 0
def is_threads_polling_enabled(self, request: HttpRequest) -> bool:
polling = request.settings.threads_lists_polling
if polling == ThreadsListsPolling.DISABLED:
return False
if (
polling == ThreadsListsPolling.ENABLED_FOR_USERS
and request.user.is_anonymous
):
return False
return True
def poll_new_threads(self, request: HttpRequest, kwargs: dict):
raise NotImplementedError()
def get_poll_new_threads_cursor(self, request: HttpRequest):
try:
latest_post = int(request.GET.get(POLL_NEW_THREADS, 0))
if latest_post < 0:
raise Http404()
return latest_post
except (ValueError, TypeError):
raise Http404()
def get_thread_pages_count(self, request: HttpRequest, thread: Thread) -> int:
posts = max(1, thread.replies + 1 - request.settings.posts_per_page_orphans)
return ceil(posts / request.settings.posts_per_page)
def allow_thread_moderation(self, request: HttpRequest, thread: Thread) -> bool:
return (
request.user_permissions.is_global_moderator
or thread.category_id in request.user_permissions.categories_moderator
)
def get_metatags(self, request: HttpRequest, context: dict) -> dict:
return get_default_metatags(request)
def get_canonical_link(self, request: HttpRequest, context: dict) -> list:
link = context["pagination_url"]
if "cursor" in request.GET:
link += "?cursor" + request.GET["cursor"]
return link
class ThreadsListView(ListView):
template_name = "misago/threads/index.html"
template_name_htmx = "misago/threads/partial.html"
mark_as_read_template_name = "misago/threads/mark_as_read_page.html"
moderation_page_template_name = "misago/threads/moderation_page.html"
moderation_modal_template_name = "misago/threads/moderation_modal.html"
def dispatch(
self,
request: HttpRequest,
*args: Any,
is_index: bool | None = None,
**kwargs: Any,
) -> HttpResponse:
if (
not is_index
and not kwargs.get("filter")
and request.settings.index_view == "threads"
):
return redirect(reverse("misago:index"))
return super().dispatch(request, *args, is_index=is_index, **kwargs)
def post(self, request: HttpRequest, **kwargs) -> HttpResponse:
if "mark_as_read" in request.POST:
return self.post_mark_as_read(request, kwargs)
if "moderation" in request.POST:
return self.post_moderation(request, kwargs)
return self.get(request, **kwargs)
def mark_as_read(self, request: HttpRequest, kwargs: dict) -> HttpResponse | None:
if not request.POST.get("confirm"):
return render(request, self.mark_as_read_template_name)
categories_ids = list(request.categories.categories)
self.read_categories(request.user, categories_ids)
messages.success(
request, pgettext("mark threads as read", "Threads marked as read")
)
def moderate_threads(self, request: HttpRequest, kwargs) -> ModerationResult | None:
threads = self.get_threads(request, kwargs)
action = self.get_moderation_action(request, threads)
selection = self.get_selected_threads(request, threads)
result = action(request, selection)
if isinstance(result, ModerationTemplateResult):
result.update_context(
{
"is_index": kwargs.get("is_index", False),
"moderation_action": action.get_context_data(),
"threads": threads,
"selection": selection,
}
)
return result
def get_context_data(self, request: HttpRequest, kwargs: dict):
return get_threads_page_context_data_hook(
self.get_context_data_action, request, kwargs
)
def get_context_data_action(self, request: HttpRequest, kwargs: dict):
subcategories = self.get_subcategories(request)
threads = self.get_threads(request, kwargs)
context = {
"template_name_htmx": self.template_name_htmx,
"is_index": kwargs.get("is_index", False),
"subcategories": subcategories,
"threads": threads,
"pagination_url": self.get_pagination_url(kwargs),
"start_thread_modal": True,
"start_thread_url": self.get_start_thread_url(request),
}
context["metatags"] = self.get_metatags(request, context)
context["canonical_link"] = self.get_canonical_link(request, context)
return context
def get_subcategories(self, request: HttpRequest) -> dict | None:
return get_threads_page_subcategories_hook(
self.get_subcategories_action, request
)
def get_subcategories_action(self, request: HttpRequest) -> dict | None:
component = request.settings.threads_list_categories_component
if component == CategoryChildrenComponent.FULL:
if request.is_htmx:
return None
return {
"categories": get_categories_data(request),
"template_name": "misago/threads/subcategories_full.html",
}
if component == CategoryChildrenComponent.DROPDOWN:
return {
"categories": [
c for c in request.categories.categories_list if c["level"] < 2
],
"template_name": None,
}
return None
def get_threads(self, request: HttpRequest, kwargs: dict):
return get_threads_page_threads_hook(self.get_threads_action, request, kwargs)
def get_threads_action(self, request: HttpRequest, kwargs: dict):
filters_base_url = self.get_filters_base_url()
active_filter, filters = self.get_threads_filters(
request, filters_base_url, kwargs.get("filter")
)
permissions_filter = self.get_threads_permissions_queryset_filter(request)
queryset = self.get_threads_queryset(request)
if not active_filter or active_filter.url != "unread":
queryset = annotate_threads_read_time(request.user, queryset)
if active_filter:
threads_queryset = active_filter.filter(queryset)
else:
threads_queryset = queryset
paginator = self.get_threads_paginator(
request, permissions_filter, threads_queryset
)
threads_list: list[Thread] = []
if not paginator.has_previous:
threads_list = self.get_pinned_threads(
request, permissions_filter, queryset
)
threads_list += paginator.items
users = self.get_threads_users(request, threads_list)
animate = self.get_threads_to_animate(request, kwargs, threads_list)
selected = self.get_selected_threads_ids(request)
if active_filter and active_filter.url == "unread":
unread = set(thread.id for thread in threads_list)
else:
unread = get_unread_threads(request, threads_list)
items: list[dict] = []
for thread in threads_list:
categories = request.categories.get_thread_categories(thread.category_id)
moderation = self.allow_thread_moderation(request, thread)
thread_data = {
"thread": thread,
"unread": thread.id in unread,
"starter": users.get(thread.starter_id),
"last_poster": users.get(thread.last_poster_id),
"pages": self.get_thread_pages_count(request, thread),
"categories": categories,
"moderation": moderation,
"animate": animate.get(thread.id, False),
"selected": thread.id in selected,
"show_flags": self.show_thread_flags(moderation, thread),
}
thread_data.update(self.get_thread_urls(thread))
items.append(thread_data)
return {
"template_name": self.threads_component_template_name,
"latest_post": self.get_threads_latest_post_id(threads_list),
"active_filter": active_filter,
"filters": filters,
"filters_clear_url": self.get_filters_clear_url(request),
"moderation_actions": self.get_moderation_actions(request),
"items": items,
"paginator": paginator,
"categories_component": (
request.settings.threads_list_item_categories_component
),
"enable_polling": self.is_threads_polling_enabled(request),
}
def get_filters_base_url(self) -> str:
return reverse("misago:threads")
def get_filters_clear_url(self, request: HttpRequest) -> str:
if request.settings.index_view == "threads":
return reverse("misago:index")
return self.get_filters_base_url()
def get_threads_filters(
self, request: HttpRequest, base_url: str, filter: str | None
) -> tuple[ThreadsFilterChoice | None, list[ThreadsFilterChoice]]:
active: ThreadsFilterChoice | None = None
choices: list[ThreadsFilterChoice] = []
filters = get_threads_page_filters_hook(
self.get_threads_filters_action, request
)
for obj in filters:
choice = obj.as_choice(base_url, obj.url == filter)
if choice.active:
active = choice
choices.append(choice)
if filter and not active:
raise Http404()
return active, choices
def get_threads_filters_action(self, request: HttpRequest) -> list[ThreadsFilter]:
if request.user.is_anonymous:
return []
filters = [
UnreadThreadsFilter(request),
MyThreadsFilter(request),
]
if (
request.user_permissions.is_global_moderator
or request.user_permissions.categories_moderator
):
filters.append(UnapprovedThreadsFilter(request))
return filters
def get_threads_queryset(self, request: HttpRequest):
return get_threads_page_queryset_hook(self.get_threads_queryset_action, request)
def get_threads_queryset_action(self, request: HttpRequest):
return Thread.objects
def get_threads_permissions_queryset_filter(
self, request: HttpRequest
) -> ThreadsQuerysetFilter:
return ThreadsQuerysetFilter(
request.user_permissions, request.categories.categories_list
)
def get_threads_paginator(
self,
request: HttpRequest,
permissions_filter: ThreadsQuerysetFilter,
queryset,
) -> CursorPaginationResult:
return paginate_queryset(
request,
permissions_filter.filter(queryset),
request.settings.threads_per_page,
order_by="-last_post_id",
)
def get_pinned_threads(
self,
request: HttpRequest,
permissions_filter: ThreadsQuerysetFilter,
queryset,
) -> list[Thread]:
return list(
permissions_filter.filter_pinned(queryset).order_by(
"-weight", "-last_post_id"
)
)
def get_pagination_url(self, kwargs: dict) -> str:
if kwargs["is_index"]:
return reverse("misago:index")
if kwargs.get("filter"):
return reverse("misago:threads", kwargs={"filter": kwargs["filter"]})
return reverse("misago:threads")
def get_start_thread_url(self, request: HttpRequest) -> str | None:
if request.user_permissions.categories[CategoryPermission.START]:
return reverse("misago:start-thread")
def get_moderation_actions(
self, request: HttpRequest
) -> list[Type[ThreadsBulkModerationAction]]:
return get_threads_page_moderation_actions_hook(
self.get_moderation_actions_action, request
)
def get_moderation_actions_action(
self, request: HttpRequest
) -> list[Type[ThreadsBulkModerationAction]]:
actions: list = []
if not (
request.user_permissions.is_global_moderator
or request.user_permissions.categories_moderator
):
return actions
actions += [
OpenThreadsBulkModerationAction,
CloseThreadsBulkModerationAction,
MoveThreadsBulkModerationAction,
]
return actions
def poll_new_threads(self, request: HttpRequest, kwargs: dict) -> HttpResponse:
filters_base_url = self.get_filters_base_url()
active_filter, _ = self.get_threads_filters(
request, filters_base_url, kwargs.get("filter")
)
cursor = self.get_poll_new_threads_cursor(request)
new_threads = self.count_new_threads(request, active_filter, cursor)
return render(
request,
self.new_threads_template_name,
{
"latest_post": cursor,
"new_threads": new_threads,
"pagination_url": self.get_pagination_url(kwargs),
},
)
def count_new_threads(
self,
request: HttpRequest,
active_filter: ThreadsFilterChoice | None,
after: int,
) -> int:
permissions_filter = self.get_threads_permissions_queryset_filter(request)
queryset = self.get_threads_queryset(request).filter(last_post_id__gt=after)
if active_filter:
threads_queryset = active_filter.filter(queryset)
else:
threads_queryset = queryset
new_threads = permissions_filter.filter(threads_queryset).count()
new_threads += permissions_filter.filter_pinned(queryset).count()
return new_threads
def get_metatags(self, request: HttpRequest, context: dict) -> dict:
if context["is_index"]:
return get_forum_index_metatags(request)
return super().get_metatags(request, context)
class CategoryThreadsListView(ListView):
template_name = "misago/category/index.html"
template_name_htmx = "misago/category/partial.html"
mark_as_read_template_name = "misago/category/mark_as_read_page.html"
moderation_page_template_name = "misago/category/moderation_page.html"
moderation_modal_template_name = "misago/threads/moderation_modal.html"
def post(self, request: HttpRequest, **kwargs) -> HttpResponse:
if "mark_as_read" in request.POST:
return self.post_mark_as_read(request, kwargs)
if "moderation" in request.POST:
return self.post_moderation(request, kwargs)
return self.get(request, **kwargs)
def mark_as_read(self, request: HttpRequest, kwargs: dict) -> HttpResponse | None:
category = self.get_category(request, kwargs)
if not request.POST.get("confirm"):
return render(
request,
self.mark_as_read_template_name,
{
"category": category,
"breadcrumbs": request.categories.get_category_path(
category.id, include_self=False
),
},
)
if category.list_children_threads:
categories_ids = [
c["id"]
for c in request.categories.get_category_descendants(category.id)
]
else:
categories_ids = [category.id]
self.read_categories(request.user, categories_ids)
messages.success(
request, pgettext("mark threads as read", "Category marked as read")
)
def moderate_threads(self, request: HttpRequest, kwargs) -> ModerationResult | None:
category = self.get_category(request, kwargs)
threads = self.get_threads(request, category, kwargs)
action = self.get_moderation_action(request, threads)
selection = self.get_selected_threads(request, threads)
result = action(request, selection)
if isinstance(result, ModerationTemplateResult):
result.update_context(
{
"category": category,
"moderation_action": action.get_context_data(),
"threads": threads,
"selection": selection,
"breadcrumbs": request.categories.get_category_path(
category.id, include_self=False
),
}
)
return result
def get_context_data(self, request: HttpRequest, kwargs: dict):
return get_category_threads_page_context_data_hook(
self.get_context_data_action, request, kwargs
)
def get_context_data_action(self, request: HttpRequest, kwargs: dict):
category = self.get_category(request, kwargs)
if not category.is_vanilla or category.list_children_threads:
threads = self.get_threads(request, category, kwargs)
else:
threads = None
path = request.categories.get_category_path(category.id, include_self=False)
context = {
"template_name_htmx": self.template_name_htmx,
"category": category,
"subcategories": self.get_subcategories(request, category),
"threads": threads,
"breadcrumbs": path,
"pagination_url": self.get_pagination_url(category, kwargs),
"start_thread_url": self.get_start_thread_url(request, category),
}
self.raise_404_for_vanilla_category(category, context)
if kwargs.get("filter"):
context["pagination_url"] = reverse(
"misago:category",
kwargs={
"id": category.id,
"slug": category.slug,
"filter": kwargs["filter"],
},
)
else:
context["pagination_url"] = category.get_absolute_url()
context["metatags"] = self.get_metatags(request, context)
context["canonical_link"] = self.get_canonical_link(request, context)
return context
def get_category(self, request: HttpRequest, kwargs: dict):
try:
queryset = annotate_categories_read_time(request.user, Category.objects)
category = queryset.get(
id=kwargs["id"],
tree_id=CategoryTree.THREADS,
level__gt=0,
)
except Category.DoesNotExist:
raise Http404()
check_browse_category_permission(
request.user_permissions, category, can_delay=True
)
if category.slug != kwargs["slug"]:
raise OutdatedSlug(category)
return category
def get_subcategories(
self, request: HttpRequest, category: Category
) -> dict | None:
if category.is_leaf_node():
return None
return get_category_threads_page_subcategories_hook(
self.get_subcategories_action, request, category
)
def get_subcategories_action(
self, request: HttpRequest, category: Category
) -> dict | None:
component = category.children_categories_component
if component == CategoryChildrenComponent.FULL:
if request.is_htmx:
return None
categories = get_subcategories_data(request, category)
if not categories:
return None
return {
"categories": categories,
"template_name": "misago/category/subcategories_full.html",
}
if component == CategoryChildrenComponent.DROPDOWN:
categories = list(self.get_subcategories_dropdown_items(request, category))
if not categories:
return None
return {
"categories": categories,
"template_name": None,
}
return None
def get_subcategories_dropdown_items(
self, request: HttpRequest, category: Category
):
for c in request.categories.categories_list:
if (
c["lft"] > category.lft
and c["rght"] < category.rght
and c["level"] - category.level < 3
):
category_data = c.copy()
category_data["level"] -= category.level
yield category_data
def get_threads(self, request: HttpRequest, category: Category, kwargs: dict):
return get_category_threads_page_threads_hook(
self.get_threads_action, request, category, kwargs
)
def get_threads_action(
self, request: HttpRequest, category: Category, kwargs: dict
):
filters_base_url = self.get_filters_base_url(category)
active_filter, filters = self.get_threads_filters(
request, category, filters_base_url, kwargs.get("filter")
)
permissions_filter = self.get_threads_permissions_queryset_filter(
request, category
)
queryset = self.get_threads_queryset(request)
if not active_filter or active_filter.url != "unread":
queryset = annotate_threads_read_time(request.user, queryset)
if active_filter:
threads_queryset = active_filter.filter(queryset)
else:
threads_queryset = queryset
paginator = self.get_threads_paginator(
request, permissions_filter, threads_queryset
)
threads_list: list[Thread] = []
if not paginator.has_previous:
threads_list = self.get_pinned_threads(
request, permissions_filter, queryset
)
threads_list += paginator.items
users = self.get_threads_users(request, threads_list)
animate = self.get_threads_to_animate(request, kwargs, threads_list)
selected = self.get_selected_threads_ids(request)
if active_filter and active_filter.url == "unread":
unread = set(thread.id for thread in threads_list)
else:
unread = get_unread_threads(request, threads_list)
mark_read = bool(threads_list)
items: list[dict] = []
for thread in threads_list:
categories = request.categories.get_thread_categories(
thread.category_id, category.id
)
moderation = self.allow_thread_moderation(request, thread)
if thread.category_id == category and thread.id in unread:
mark_read = False
thread_data = {
"thread": thread,
"unread": thread.id in unread,
"starter": users.get(thread.starter_id),
"last_poster": users.get(thread.last_poster_id),
"pages": self.get_thread_pages_count(request, thread),
"categories": categories,
"moderation": moderation,
"animate": animate.get(thread.id, False),
"selected": thread.id in selected,
"show_flags": self.show_thread_flags(moderation, thread),
}
thread_data.update(self.get_thread_urls(thread))
items.append(thread_data)
if (
mark_read
and self.is_category_unread(request.user, category)
and is_category_read(request, category, category.read_time)
):
mark_category_read(request.user, category)
return {
"template_name": self.threads_component_template_name,
"latest_post": self.get_threads_latest_post_id(threads_list),
"active_filter": active_filter,
"filters": filters,
"filters_clear_url": filters_base_url,
"moderation_actions": self.get_moderation_actions(request, category),
"items": items,
"paginator": paginator,
"categories_component": (
request.settings.threads_list_item_categories_component
),
"enable_polling": self.is_threads_polling_enabled(request),
}
def get_filters_base_url(self, category: Category) -> str:
return category.get_absolute_url()
def get_threads_filters(
self,
request: HttpRequest,
category: Category,
base_url: str,
filter: str | None,
) -> tuple[ThreadsFilterChoice | None, list[ThreadsFilterChoice]]:
active: ThreadsFilterChoice | None = None
choices: list[ThreadsFilterChoice] = []
filters = get_category_threads_page_filters_hook(
self.get_threads_filters_action, request, category
)
for obj in filters:
choice = obj.as_choice(base_url, obj.url == filter)
if choice.active:
active = choice
choices.append(choice)
if filter and not active:
raise Http404()
return active, choices
def get_threads_filters_action(
self, request: HttpRequest, category: Category
) -> list[ThreadsFilter]:
if request.user.is_anonymous:
return []
filters = [
UnreadThreadsFilter(request),
MyThreadsFilter(request),
]
if (
request.user_permissions.is_global_moderator
or category.id in request.user_permissions.categories_moderator
):
filters.append(UnapprovedThreadsFilter(request))
return filters
def get_threads_queryset(self, request: HttpRequest):
return get_category_threads_page_queryset_hook(
self.get_threads_queryset_action, request
)
def get_threads_queryset_action(self, request: HttpRequest):
return Thread.objects
def get_threads_permissions_queryset_filter(
self, request: HttpRequest, category: Category
) -> CategoryThreadsQuerysetFilter:
categories = request.categories.get_category_descendants(category.id)
return CategoryThreadsQuerysetFilter(
request.user_permissions,
request.categories.categories_list,
current_category=categories[0],
child_categories=categories[1:],
include_children=category.list_children_threads,
)
def get_threads_paginator(
self,
request: HttpRequest,
permissions_filter: CategoryThreadsQuerysetFilter,
queryset,
) -> CursorPaginationResult:
return paginate_queryset(
request,
permissions_filter.filter(queryset),
request.settings.threads_per_page,
order_by="-last_post_id",
)
def get_pinned_threads(
self,
request: HttpRequest,
permissions_filter: CategoryThreadsQuerysetFilter,
queryset,
) -> list[Thread]:
return list(
permissions_filter.filter_pinned(queryset).order_by(
"-weight", "-last_post_id"
)
)
def get_pagination_url(self, category: Category, kwargs: dict) -> str:
return category.get_absolute_url()
def get_start_thread_url(
self, request: HttpRequest, category: Category
) -> str | None:
try:
check_start_thread_in_category_permission(
request.user_permissions, category
)
except:
return None
else:
return reverse(
"misago:start-thread",
kwargs={"id": category.id, "slug": category.slug},
)
def is_category_unread(self, user: "User", category: Category) -> bool:
if user.is_anonymous:
return False
if not category.last_post_on:
return False
if not category.read_time:
return True
return category.last_post_on > category.read_time
def get_moderation_actions(
self, request: HttpRequest, category: Category
) -> list[Type[ThreadsBulkModerationAction]]:
return get_category_threads_page_moderation_actions_hook(
self.get_moderation_actions_action, request, category
)
def get_moderation_actions_action(
self, request: HttpRequest, category: Category
) -> list[Type[ThreadsBulkModerationAction]]:
actions: list = []
if not self.show_moderation_actions_in_category(request, category):
return actions
actions += [
OpenThreadsBulkModerationAction,
CloseThreadsBulkModerationAction,
MoveThreadsBulkModerationAction,
]
return actions
def show_moderation_actions_in_category(
self, request: HttpRequest, category: Category
) -> bool:
if request.user_permissions.is_global_moderator:
return True
categories_ids = set(
c["id"] for c in request.categories.get_category_descendants(category.id)
)
return bool(
request.user_permissions.categories_moderator.intersection(categories_ids)
)
def raise_404_for_vanilla_category(self, category: Category, context: dict):
"""Raise 404 for empty top-level vanilla category
Ignore nested vanilla categories because using them is mistake on admin part.
Ignore categories that display either subcategories or threads from subcategories.
"""
if (
category.is_vanilla
and category.level == 1
and not context["threads"]
and not context["subcategories"]
):
raise Http404()
def poll_new_threads(self, request: HttpRequest, kwargs: dict) -> HttpResponse:
category = self.get_category(request, kwargs)
filters_base_url = self.get_filters_base_url(category)
active_filter, _ = self.get_threads_filters(
request, category, filters_base_url, kwargs.get("filter")
)
cursor = self.get_poll_new_threads_cursor(request)
new_threads = self.count_new_threads(request, category, active_filter, cursor)
return render(
request,
self.new_threads_template_name,
{
"latest_post": cursor,
"new_threads": new_threads,
"pagination_url": self.get_pagination_url(category, kwargs),
},
)
def count_new_threads(
self,
request: HttpRequest,
category: Category,
active_filter: ThreadsFilterChoice | None,
after: int,
) -> int:
permissions_filter = self.get_threads_permissions_queryset_filter(
request, category
)
queryset = self.get_threads_queryset(request).filter(last_post_id__gt=after)
if active_filter:
threads_queryset = active_filter.filter(queryset)
else:
threads_queryset = queryset
new_threads = permissions_filter.filter(threads_queryset).count()
new_threads += permissions_filter.filter_pinned(queryset).count()
return new_threads
def get_metatags(self, request: HttpRequest, context: dict) -> dict:
metatags = super().get_metatags(request, context)
category = context["category"]
metatags.update(
{
"title": MetaTag(
property="og:title",
name="twitter:title",
content=category.name,
),
"url": MetaTag(
property="og:url",
name="twitter:url",
content=category.get_absolute_url(),
),
}
)
if category.description:
metatags["description"] = MetaTag(
property="og:description",
name="twitter:description",
content=re.sub(
"\n+",
" ",
category.description,
),
)
return metatags
class PrivateThreadsListView(ListView):
template_name = "misago/private_threads/index.html"
template_name_htmx = "misago/private_threads/partial.html"
mark_as_read_template_name = "misago/private_threads/mark_as_read_page.html"
def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
check_private_threads_permission(request.user_permissions)
return super().dispatch(request, *args, **kwargs)
def post(self, request: HttpRequest, **kwargs) -> HttpResponse:
if "mark_as_read" in request.POST:
return self.post_mark_as_read(request, kwargs)
return self.get(request, **kwargs)
def mark_as_read(self, request: HttpRequest, kwargs: dict) -> HttpResponse | None:
if not request.POST.get("confirm"):
return render(
request,
self.mark_as_read_template_name,
{},
)
category = self.get_category(request, kwargs)
self.read_categories(request.user, [category.id])
request.user.clear_unread_private_threads()
messages.success(
request, pgettext("mark threads as read", "Private threads marked as read")
)
def get_context_data(self, request: HttpRequest, kwargs: dict):
return get_private_threads_page_context_data_hook(
self.get_context_data_action, request, kwargs
)
def get_context_data_action(self, request: HttpRequest, kwargs: dict):
category = self.get_category(request, kwargs)
context = {
"template_name_htmx": self.template_name_htmx,
"threads": self.get_threads(request, category, kwargs),
"pagination_url": self.get_pagination_url(kwargs),
"start_thread_url": self.get_start_thread_url(request),
}
context["metatags"] = self.get_metatags(request, {})
return context
def get_category(self, request: HttpRequest, kwargs: dict):
queryset = annotate_categories_read_time(
request.user, Category.objects.filter(tree_id=CategoryTree.PRIVATE_THREADS)
)
return queryset.first()
def get_threads(self, request: HttpRequest, category: Category, kwargs: dict):
return get_private_threads_page_threads_hook(
self.get_threads_action, request, category, kwargs
)
def get_threads_action(
self, request: HttpRequest, category: Category, kwargs: dict
):
filters_base_url = self.get_filters_base_url()
active_filter, filters = self.get_threads_filters(
request, filters_base_url, kwargs.get("filter")
)
queryset = self.get_threads_queryset(request, category)
if not active_filter or active_filter.url != "unread":
queryset = annotate_threads_read_time(request.user, queryset)
if active_filter:
queryset = active_filter.filter(queryset)
paginator = self.get_threads_paginator(request, queryset)
threads_list: list[Thread] = paginator.items
users = self.get_threads_users(request, threads_list)
animate = self.get_threads_to_animate(request, kwargs, threads_list)
if active_filter and active_filter.url == "unread":
unread = set(thread.id for thread in threads_list)
else:
unread = get_unread_threads(request, threads_list)
mark_read = bool(threads_list)
moderator = request.user_permissions.private_threads_moderator
items: list[dict] = []
for thread in threads_list:
if thread.category_id == category and thread.id in unread:
mark_read = False
thread_data = {
"thread": thread,
"unread": thread.id in unread,
"starter": users.get(thread.starter_id),
"last_poster": users.get(thread.last_poster_id),
"pages": self.get_thread_pages_count(request, thread),
"categories": None,
"animate": animate.get(thread.id, False),
"show_flags": self.show_thread_flags(moderator, thread),
}
thread_data.update(self.get_thread_urls(thread))
items.append(thread_data)
if mark_read and not unread_private_threads_exist(
request, category, category.read_time
):
mark_category_read(request.user, category)
request.user.clear_unread_private_threads()
return {
"template_name": self.threads_component_template_name,
"latest_post": self.get_threads_latest_post_id(threads_list),
"active_filter": active_filter,
"filters": filters,
"filters_clear_url": filters_base_url,
"items": items,
"paginator": paginator,
"enable_polling": self.is_threads_polling_enabled(request),
}
def get_filters_base_url(self) -> str:
return reverse("misago:private-threads")
def get_threads_filters(
self, request: HttpRequest, base_url: str, filter: str | None
) -> tuple[ThreadsFilterChoice | None, list[ThreadsFilterChoice]]:
active: ThreadsFilterChoice | None = None
choices: list[ThreadsFilterChoice] = []
filters = get_private_threads_page_filters_hook(
self.get_threads_filters_action, request
)
for obj in filters:
choice = obj.as_choice(base_url, obj.url == filter)
if choice.active:
active = choice
choices.append(choice)
if filter and not active:
raise Http404()
return active, choices
def get_threads_filters_action(self, request: HttpRequest) -> list[ThreadsFilter]:
if request.user.is_anonymous:
return []
return [
UnreadThreadsFilter(request),
MyThreadsFilter(request),
]
def get_threads_queryset(self, request: HttpRequest, category: Category):
return get_private_threads_page_queryset_hook(
self.get_threads_queryset_action, request, category
)
def get_threads_queryset_action(self, request: HttpRequest, category: Category):
return Thread.objects.filter(category=category)
def get_threads_paginator(self, request: HttpRequest, queryset):
threads_queryset = filter_private_threads_queryset(
request.user_permissions, queryset
)
return paginate_queryset(
request,
threads_queryset,
request.settings.threads_per_page,
order_by="-last_post_id",
)
def get_thread_urls(self, thread: Thread) -> dict[str, str]:
kwargs = {"id": thread.id, "slug": thread.slug}
return {
"absolute_url": reverse("misago:private-thread", kwargs=kwargs),
"last_post_url": reverse("misago:private-thread-last-post", kwargs=kwargs),
"unapproved_post_url": reverse(
"misago:private-thread-unapproved-post", kwargs=kwargs
),
"unread_post_url": reverse(
"misago:private-thread-unread-post", kwargs=kwargs
),
}
def get_pagination_url(self, kwargs: dict) -> str:
if kwargs.get("filter"):
return reverse(
"misago:private-threads",
kwargs={"filter": kwargs["filter"]},
)
return reverse("misago:private-threads")
def get_start_thread_url(self, request: HttpRequest) -> str | None:
try:
check_start_private_threads_permission(request.user_permissions)
except (Http404, PermissionDenied):
return None
else:
return reverse("misago:start-private-thread")
def poll_new_threads(self, request: HttpRequest, kwargs: dict) -> HttpResponse:
category = self.get_category(request, kwargs)
filters_base_url = self.get_filters_base_url()
active_filter, _ = self.get_threads_filters(
request, filters_base_url, kwargs.get("filter")
)
cursor = self.get_poll_new_threads_cursor(request)
new_threads = self.count_new_threads(request, category, active_filter, cursor)
return render(
request,
self.new_threads_template_name,
{
"latest_post": cursor,
"new_threads": new_threads,
"pagination_url": self.get_pagination_url(kwargs),
},
)
def count_new_threads(
self,
request: HttpRequest,
category: Category,
active_filter: ThreadsFilterChoice | None,
after: int,
) -> int:
queryset = self.get_threads_queryset(request, category).filter(
last_post_id__gt=after
)
queryset = filter_private_threads_queryset(request.user_permissions, queryset)
if active_filter:
queryset = active_filter.filter(queryset)
return queryset.count()
threads = ThreadsListView.as_view()
category_threads = CategoryThreadsListView.as_view()
private_threads = PrivateThreadsListView.as_view()
| 53,026
|
Python
|
.py
| 1,237
| 32.28941
| 90
| 0.619326
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,043
|
__init__.py
|
rafalp_Misago/misago/threads/moderation/__init__.py
|
from .exceptions import ModerationError
from .threads import *
from .posts import *
| 84
|
Python
|
.py
| 3
| 27
| 39
| 0.82716
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,044
|
posts.py
|
rafalp_Misago/misago/threads/moderation/posts.py
|
from django.db import transaction
from django.utils import timezone
from django.utils.translation import pgettext
from .exceptions import ModerationError
__all__ = [
"approve_post",
"protect_post",
"unprotect_post",
"unhide_post",
"hide_post",
"delete_post",
]
def approve_post(user, post):
if not post.is_unapproved:
return False
post.is_unapproved = False
post.save(update_fields=["is_unapproved"])
return True
def protect_post(user, post):
if post.is_protected:
return False
post.is_protected = True
post.save(update_fields=["is_protected"])
if post.is_best_answer:
post.thread.best_answer_is_protected = True
post.thread.save(update_fields=["best_answer_is_protected"])
return True
def unprotect_post(user, post):
if not post.is_protected:
return False
post.is_protected = False
post.save(update_fields=["is_protected"])
if post.is_best_answer:
post.thread.best_answer_is_protected = False
post.thread.save(update_fields=["best_answer_is_protected"])
return True
def unhide_post(user, post):
if post.is_first_post:
raise ModerationError(
pgettext(
"post unhide",
"You can't make original post visible without revealing the thread.",
)
)
if not post.is_hidden:
return False
post.is_hidden = False
post.save(update_fields=["is_hidden"])
return True
def hide_post(user, post):
if post.is_first_post:
raise ModerationError(
pgettext("post hide", "You can't hide original post without hiding thread.")
)
if post.is_hidden:
return False
post.is_hidden = True
post.hidden_by = user
post.hidden_by_name = user.username
post.hidden_by_slug = user.slug
post.hidden_on = timezone.now()
post.save(
update_fields=[
"is_hidden",
"hidden_by",
"hidden_by_name",
"hidden_by_slug",
"hidden_on",
]
)
return True
@transaction.atomic
def delete_post(user, post):
if post.is_first_post:
raise ModerationError(
pgettext(
"post delete", "You can't delete original post without deleting thread."
)
)
post.delete()
return True
| 2,383
|
Python
|
.py
| 81
| 22.518519
| 88
| 0.631579
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,045
|
threads.py
|
rafalp_Misago/misago/threads/moderation/threads.py
|
from django.db import transaction
from django.utils import timezone
from ...notifications.tasks import delete_duplicate_watched_threads
from ..events import record_event
__all__ = [
"change_thread_title",
"pin_thread_globally",
"pin_thread_locally",
"unpin_thread",
"move_thread",
"merge_thread",
"approve_thread",
"open_thread",
"close_thread",
"unhide_thread",
"hide_thread",
"delete_thread",
]
@transaction.atomic
def change_thread_title(request, thread, new_title):
if thread.title == new_title:
return False
old_title = thread.title
thread.set_title(new_title)
thread.save(update_fields=["title", "slug"])
thread.first_post.set_search_document(thread.title)
thread.first_post.save(update_fields=["search_document"])
thread.first_post.update_search_vector()
thread.first_post.save(update_fields=["search_vector"])
record_event(request, thread, "changed_title", {"old_title": old_title})
return True
@transaction.atomic
def pin_thread_globally(request, thread):
if thread.weight == 2:
return False
thread.weight = 2
record_event(request, thread, "pinned_globally")
return True
@transaction.atomic
def pin_thread_locally(request, thread):
if thread.weight == 1:
return False
thread.weight = 1
record_event(request, thread, "pinned_locally")
return True
@transaction.atomic
def unpin_thread(request, thread):
if thread.weight == 0:
return False
thread.weight = 0
record_event(request, thread, "unpinned")
return True
@transaction.atomic
def move_thread(request, thread, new_category):
if thread.category_id == new_category.pk:
return False
from_category = thread.category
thread.move(new_category)
record_event(
request,
thread,
"moved",
{
"from_category": {
"name": from_category.name,
"url": from_category.get_absolute_url(),
}
},
)
return True
@transaction.atomic
def merge_thread(request, thread, other_thread):
thread.merge(other_thread)
other_thread.delete()
delete_duplicate_watched_threads.delay(thread.id)
record_event(request, thread, "merged", {"merged_thread": other_thread.title})
return True
@transaction.atomic
def approve_thread(request, thread):
if not thread.is_unapproved:
return False
thread.first_post.is_unapproved = False
thread.first_post.save(update_fields=["is_unapproved"])
thread.is_unapproved = False
unapproved_post_qs = thread.post_set.filter(is_unapproved=True)
thread.has_unapproved_posts = unapproved_post_qs.exists()
record_event(request, thread, "approved")
return True
@transaction.atomic
def open_thread(request, thread):
if not thread.is_closed:
return False
thread.is_closed = False
record_event(request, thread, "opened")
return True
@transaction.atomic
def close_thread(request, thread):
if thread.is_closed:
return False
thread.is_closed = True
record_event(request, thread, "closed")
return True
@transaction.atomic
def unhide_thread(request, thread):
if not thread.is_hidden:
return False
thread.first_post.is_hidden = False
thread.first_post.save(update_fields=["is_hidden"])
thread.is_hidden = False
record_event(request, thread, "unhid")
if thread.pk == thread.category.last_thread_id:
thread.category.synchronize()
thread.category.save()
return True
@transaction.atomic
def hide_thread(request, thread):
if thread.is_hidden:
return False
thread.first_post.is_hidden = True
thread.first_post.hidden_by = request.user
thread.first_post.hidden_by_name = request.user.username
thread.first_post.hidden_by_slug = request.user.slug
thread.first_post.hidden_on = timezone.now()
thread.first_post.save(
update_fields=[
"is_hidden",
"hidden_by",
"hidden_by_name",
"hidden_by_slug",
"hidden_on",
]
)
thread.is_hidden = True
record_event(request, thread, "hid")
if thread.pk == thread.category.last_thread_id:
thread.category.synchronize()
thread.category.save()
return True
@transaction.atomic
def delete_thread(request, thread):
thread.delete()
thread.category.synchronize()
thread.category.save()
return True
| 4,524
|
Python
|
.py
| 144
| 25.743056
| 82
| 0.684077
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,046
|
exceptions.py
|
rafalp_Misago/misago/threads/moderation/exceptions.py
|
# pylint: disable=super-init-not-called
class ModerationError(Exception):
def __init__(self, message):
self.message = message
def __str__(self):
return self.message
| 190
|
Python
|
.py
| 6
| 26.5
| 39
| 0.672131
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,047
|
api.py
|
rafalp_Misago/misago/threads/urls/api.py
|
from ...core.apirouter import MisagoApiRouter
from ..api.attachments import AttachmentViewSet
from ..api.threadpoll import ThreadPollViewSet
from ..api.threadposts import PrivateThreadPostsViewSet, ThreadPostsViewSet
from ..api.threads import PrivateThreadViewSet, ThreadViewSet
router = MisagoApiRouter()
router.register(r"attachments", AttachmentViewSet, basename="attachment")
router.register(r"threads", ThreadViewSet, basename="thread")
router.register(
r"threads/(?P<thread_pk>[^/.]+)/posts", ThreadPostsViewSet, basename="thread-post"
)
router.register(
r"threads/(?P<thread_pk>[^/.]+)/poll", ThreadPollViewSet, basename="thread-poll"
)
router.register(r"private-threads", PrivateThreadViewSet, basename="private-thread")
router.register(
r"private-threads/(?P<thread_pk>[^/.]+)/posts",
PrivateThreadPostsViewSet,
basename="private-thread-post",
)
urlpatterns = router.urls
| 906
|
Python
|
.py
| 21
| 40.952381
| 86
| 0.790909
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,048
|
__init__.py
|
rafalp_Misago/misago/threads/urls/__init__.py
|
from django.urls import path
from ...conf import settings
from ..views.attachment import attachment_server
from ..views.list import category_threads, private_threads, threads
from ..views.redirect import (
PostRedirectView,
PrivateThreadLastPostRedirectView,
PrivateThreadUnapprovedPostRedirectView,
PrivateThreadUnreadPostRedirectView,
ThreadLastPostRedirectView,
ThreadSolutionRedirectView,
ThreadUnapprovedPostRedirectView,
ThreadUnreadPostRedirectView,
)
from ..views.replies import private_thread_replies, thread_replies
from ..views.subscribed import redirect_subscribed_to_watched
urlpatterns = [
path(
"threads/",
threads,
name="threads",
kwargs={"is_index": False},
),
path(
"threads/<slug:filter>/",
threads,
name="threads",
),
path(
"c/<slug:slug>/<int:id>/",
category_threads,
name="category",
),
path(
"c/<slug:slug>/<int:id>/<slug:filter>/",
category_threads,
name="category",
),
path(
"private/",
private_threads,
name="private-threads",
),
path(
"private/<slug:filter>/",
private_threads,
name="private-threads",
),
path(
"t/<slug:slug>/<int:id>/",
thread_replies,
name="thread",
),
path(
"t/<slug:slug>/<int:id>/<int:page>/",
thread_replies,
name="thread",
),
path(
"p/<slug:slug>/<int:id>/",
private_thread_replies,
name="private-thread",
),
path(
"p/<slug:slug>/<int:id>/<int:page>/",
private_thread_replies,
name="private-thread",
),
path(
"t/<slug:slug>/<int:id>/last/",
ThreadLastPostRedirectView.as_view(),
name="thread-last-post",
),
path(
"t/<slug:slug>/<int:id>/unread/",
ThreadUnreadPostRedirectView.as_view(),
name="thread-unread-post",
),
path(
"t/<slug:slug>/<int:id>/unapproved/",
ThreadUnapprovedPostRedirectView.as_view(),
name="thread-unapproved-post",
),
path(
"t/<slug:slug>/<int:id>/solution/",
ThreadSolutionRedirectView.as_view(),
name="thread-solution-post",
),
path(
"p/<slug:slug>/<int:id>/last/",
PrivateThreadLastPostRedirectView.as_view(),
name="private-thread-last-post",
),
path(
"p/<slug:slug>/<int:id>/unread/",
PrivateThreadUnreadPostRedirectView.as_view(),
name="private-thread-unread-post",
),
path(
"p/<slug:slug>/<int:id>/unapproved/",
PrivateThreadUnapprovedPostRedirectView.as_view(),
name="private-thread-unapproved-post",
),
path(
"post/<int:id>/",
PostRedirectView.as_view(),
name="post",
),
]
# Redirect from subscribed to watched
if settings.MISAGO_THREADS_ON_INDEX:
root_subscribed_path = "subscribed/"
else:
root_subscribed_path = "threads/subscribed/"
urlpatterns += [
path(root_subscribed_path, redirect_subscribed_to_watched),
path("c/<slug:slug>/<int:pk>/subscribed/", redirect_subscribed_to_watched),
path("private-threads/subscribed/", redirect_subscribed_to_watched),
]
urlpatterns += [
path(
"a/<slug:secret>/<int:pk>/",
attachment_server,
name="attachment",
),
path(
"a/thumb/<slug:secret>/<int:pk>/",
attachment_server,
name="attachment-thumbnail",
kwargs={"thumbnail": True},
),
]
| 3,571
|
Python
|
.py
| 132
| 20.628788
| 79
| 0.610026
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,049
|
threadposts.py
|
rafalp_Misago/misago/threads/api/threadposts.py
|
from django.core.exceptions import PermissionDenied
from django.db import transaction
from django.utils.translation import pgettext
from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from ...acl.objectacl import add_acl_to_obj
from ...categories import PRIVATE_THREADS_ROOT_NAME, THREADS_ROOT_NAME
from ...core.shortcuts import get_int_or_404
from ...users.online.utils import make_users_status_aware
from ..models import Post
from ..permissions import allow_edit_post, allow_reply_thread
from ..serializers import AttachmentSerializer, PostSerializer
from ..viewmodels import ForumThread, PrivateThread, ThreadPost, ThreadPosts
from .postendpoints.delete import delete_bulk, delete_post
from .postendpoints.edits import get_edit_endpoint, revert_post_endpoint
from .postendpoints.likes import likes_list_endpoint
from .postendpoints.merge import posts_merge_endpoint
from .postendpoints.move import posts_move_endpoint
from .postendpoints.patch_event import event_patch_endpoint
from .postendpoints.patch_post import bulk_patch_endpoint, post_patch_endpoint
from .postendpoints.split import posts_split_endpoint
from .postingendpoint import PostingEndpoint
class ViewSet(viewsets.ViewSet):
thread = None
posts = ThreadPosts
post_ = ThreadPost
def get_thread(
self, request, pk, path_aware=False, read_aware=False, watch_aware=False
):
return self.thread( # pylint: disable=not-callable
request,
get_int_or_404(pk),
path_aware=path_aware,
read_aware=read_aware,
watch_aware=watch_aware,
)
def get_posts(self, request, thread, page):
return self.posts(request, thread, page)
def get_post(self, request, thread, pk):
return self.post_(request, thread, get_int_or_404(pk))
def list(self, request, thread_pk):
page = get_int_or_404(request.query_params.get("page", 0))
if page == 1:
page = 0 # api allows explicit first page
thread = self.get_thread(
request,
thread_pk,
path_aware=True,
read_aware=True,
watch_aware=True,
)
posts = self.get_posts(request, thread, page)
data = thread.get_frontend_context()
data["post_set"] = posts.get_frontend_context()
return Response(data)
@action(detail=False, methods=["post"])
@transaction.atomic
def merge(self, request, thread_pk):
thread = self.get_thread(request, thread_pk).unwrap()
return posts_merge_endpoint(request, thread)
@action(detail=False, methods=["post"])
@transaction.atomic
def move(self, request, thread_pk):
thread = self.get_thread(request, thread_pk).unwrap()
return posts_move_endpoint(request, thread, self.thread)
@action(detail=False, methods=["post"])
@transaction.atomic
def split(self, request, thread_pk):
thread = self.get_thread(request, thread_pk).unwrap()
return posts_split_endpoint(request, thread)
@transaction.atomic
def create(self, request, thread_pk):
thread = self.get_thread(request, thread_pk).unwrap()
allow_reply_thread(request.user_acl, thread)
post = Post(thread=thread, category=thread.category)
# Put them through posting pipeline
posting = PostingEndpoint(
request,
PostingEndpoint.REPLY,
tree_name=self.tree_name,
thread=thread,
post=post,
)
if not posting.is_valid():
return Response(posting.errors, status=400)
user_posts = request.user.posts
posting.save()
# setup extra data for serialization
post.is_read = False
post.is_new = True
post.poster.posts = user_posts + 1
make_users_status_aware(request, [post.poster])
return Response(PostSerializer(post, context={"user": request.user}).data)
@transaction.atomic
def update(self, request, thread_pk, pk=None):
thread = self.get_thread(request, thread_pk).unwrap()
post = self.get_post(request, thread, pk).unwrap()
allow_edit_post(request.user_acl, post)
posting = PostingEndpoint(
request,
PostingEndpoint.EDIT,
tree_name=self.tree_name,
thread=thread,
post=post,
)
if not posting.is_valid():
return Response(posting.errors, status=400)
post_edits = post.edits
posting.save()
post.is_read = True
post.is_new = False
post.edits = post_edits + 1
if post.poster:
make_users_status_aware(request, [post.poster])
return Response(PostSerializer(post, context={"user": request.user}).data)
def patch(self, request, thread_pk):
thread = self.get_thread(request, thread_pk)
return bulk_patch_endpoint(request, thread.unwrap())
@transaction.atomic
def partial_update(self, request, thread_pk, pk):
thread = self.get_thread(request, thread_pk)
post = self.get_post(request, thread, pk).unwrap()
if post.is_event:
return event_patch_endpoint(request, post)
return post_patch_endpoint(request, post)
@transaction.atomic
def delete(self, request, thread_pk, pk=None):
thread = self.get_thread(request, thread_pk)
if pk:
post = self.get_post(request, thread, pk).unwrap()
return delete_post(request, thread.unwrap(), post)
return delete_bulk(request, thread.unwrap())
@action(detail=True, methods=["get"], url_name="editor")
def post_editor(self, request, thread_pk, pk=None):
thread = self.get_thread(request, thread_pk)
post = self.get_post(request, thread, pk).unwrap()
allow_edit_post(request.user_acl, post)
attachments = []
for attachment in post.attachment_set.order_by("-id"):
add_acl_to_obj(request.user_acl, attachment)
attachments.append(attachment)
attachments_json = AttachmentSerializer(
attachments, many=True, context={"user": request.user}
).data
return Response(
{
"id": post.pk,
"api": post.get_api_url(),
"post": post.original,
"attachments": attachments_json,
"can_protect": bool(thread.category.acl["can_protect_posts"]),
"is_protected": post.is_protected,
"poster": post.poster_name,
}
)
@action(detail=False, methods=["get"], url_name="editor")
def reply_editor(self, request, thread_pk):
thread = self.get_thread(request, thread_pk).unwrap()
allow_reply_thread(request.user_acl, thread)
if "reply" not in request.query_params:
return Response({})
reply_to = self.get_post(
request, thread, request.query_params["reply"]
).unwrap()
if reply_to.is_event:
raise PermissionDenied(pgettext("posts api", "Events can't be replied to."))
if reply_to.is_hidden and not reply_to.acl["can_see_hidden"]:
raise PermissionDenied(
pgettext("posts api", "You can't reply to hidden posts.")
)
return Response(
{
"id": reply_to.pk,
"post": reply_to.original,
"poster": reply_to.poster_name,
}
)
@action(detail=True, methods=["get", "post"])
def edits(self, request, thread_pk, pk=None):
if request.method == "GET":
thread = self.get_thread(request, thread_pk)
post = self.get_post(request, thread, pk).unwrap()
return get_edit_endpoint(request, post)
if request.method == "POST":
with transaction.atomic():
thread = self.get_thread(request, thread_pk)
post = self.get_post(request, thread, pk).unwrap()
allow_edit_post(request.user_acl, post)
return revert_post_endpoint(request, post)
@action(detail=True, methods=["get"])
def likes(self, request, thread_pk, pk=None):
thread = self.get_thread(request, thread_pk)
post = self.get_post(request, thread, pk).unwrap()
if post.acl["can_see_likes"] < 2:
raise PermissionDenied(
pgettext("posts api", "You can't see who liked this post.")
)
return likes_list_endpoint(request, post)
class ThreadPostsViewSet(ViewSet):
tree_name = THREADS_ROOT_NAME
thread = ForumThread
class PrivateThreadPostsViewSet(ViewSet):
tree_name = PRIVATE_THREADS_ROOT_NAME
thread = PrivateThread
| 8,875
|
Python
|
.py
| 205
| 34.263415
| 88
| 0.640153
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,050
|
pollvotecreateendpoint.py
|
rafalp_Misago/misago/threads/api/pollvotecreateendpoint.py
|
from copy import deepcopy
from rest_framework.response import Response
from ...acl.objectacl import add_acl_to_obj
from ..permissions import allow_vote_poll
from ..serializers import NewVoteSerializer, PollSerializer
def poll_vote_create(request, thread, poll):
poll.make_choices_votes_aware(request.user)
allow_vote_poll(request.user_acl, poll)
serializer = NewVoteSerializer(
data={"choices": request.data},
context={"allowed_choices": poll.allowed_choices, "choices": poll.choices},
)
if not serializer.is_valid():
return Response({"detail": serializer.errors["choices"][0]}, status=400)
remove_user_votes(request.user, poll, serializer.data["choices"])
set_new_votes(request, poll, serializer.data["choices"])
add_acl_to_obj(request.user_acl, poll)
serialized_poll = PollSerializer(poll).data
poll.choices = list(map(presave_clean_choice, deepcopy(poll.choices)))
poll.save()
return Response(serialized_poll)
def presave_clean_choice(choice):
del choice["selected"]
return choice
def remove_user_votes(user, poll, final_votes):
removed_votes = []
for choice in poll.choices:
if choice["selected"] and choice["hash"] not in final_votes:
poll.votes -= 1
choice["votes"] -= 1
choice["selected"] = False
removed_votes.append(choice["hash"])
if removed_votes:
poll.pollvote_set.filter(voter=user, choice_hash__in=removed_votes).delete()
def set_new_votes(request, poll, final_votes):
for choice in poll.choices:
if not choice["selected"] and choice["hash"] in final_votes:
poll.votes += 1
choice["votes"] += 1
choice["selected"] = True
poll.pollvote_set.create(
category=poll.category,
thread=poll.thread,
voter=request.user,
voter_name=request.user.username,
voter_slug=request.user.slug,
choice_hash=choice["hash"],
)
| 2,063
|
Python
|
.py
| 48
| 34.8125
| 84
| 0.657143
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,051
|
threadpoll.py
|
rafalp_Misago/misago/threads/api/threadpoll.py
|
from django.core.exceptions import PermissionDenied
from django.db import transaction
from django.http import Http404
from django.utils.translation import pgettext
from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from ...acl.objectacl import add_acl_to_obj
from ...core.shortcuts import get_int_or_404
from ...users.audittrail import create_audit_trail
from ..models import Poll
from ..permissions import (
allow_delete_poll,
allow_edit_poll,
allow_see_poll_votes,
allow_start_poll,
can_start_poll,
)
from ..serializers import (
EditPollSerializer,
NewPollSerializer,
PollSerializer,
PollVoteSerializer,
)
from ..viewmodels import ForumThread
from .pollvotecreateendpoint import poll_vote_create
class ViewSet(viewsets.ViewSet):
thread = None
def get_thread(self, request, thread_pk):
return self.thread( # pylint: disable=not-callable
request, get_int_or_404(thread_pk)
).unwrap()
def get_poll(self, thread, pk):
try:
poll_id = get_int_or_404(pk)
if thread.poll.pk != poll_id:
raise Http404()
poll = Poll.objects.get(pk=thread.poll.pk)
poll.thread = thread
poll.category = thread.category
return poll
except Poll.DoesNotExist:
raise Http404()
@transaction.atomic
def create(self, request, thread_pk):
thread = self.get_thread(request, thread_pk)
allow_start_poll(request.user_acl, thread)
try:
if thread.poll and thread.poll.pk:
raise PermissionDenied(
pgettext("polls api", "There's already a poll in this thread.")
)
except Poll.DoesNotExist:
pass
instance = Poll(
thread=thread,
category=thread.category,
poster=request.user,
poster_name=request.user.username,
poster_slug=request.user.slug,
)
serializer = NewPollSerializer(instance, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
add_acl_to_obj(request.user_acl, instance)
for choice in instance.choices:
choice["selected"] = False
thread.has_poll = True
thread.save()
create_audit_trail(request, instance)
return Response(PollSerializer(instance).data)
@transaction.atomic
def update(self, request, thread_pk, pk=None):
thread = self.get_thread(request, thread_pk)
instance = self.get_poll(thread, pk)
allow_edit_poll(request.user_acl, instance)
serializer = EditPollSerializer(instance, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
add_acl_to_obj(request.user_acl, instance)
instance.make_choices_votes_aware(request.user)
create_audit_trail(request, instance)
return Response(PollSerializer(instance).data)
@transaction.atomic
def delete(self, request, thread_pk, pk=None):
thread = self.get_thread(request, thread_pk)
instance = self.get_poll(thread, pk)
allow_delete_poll(request.user_acl, instance)
thread.poll.delete()
thread.has_poll = False
thread.save()
return Response({"can_start_poll": can_start_poll(request.user_acl, thread)})
@action(detail=True, methods=["get", "post"])
def votes(self, request, thread_pk, pk=None):
if request.method == "POST":
return self.post_votes(request, thread_pk, pk)
return self.get_votes(request, thread_pk, pk)
@transaction.atomic
def post_votes(self, request, thread_pk, pk=None):
thread = self.get_thread(request, thread_pk)
instance = self.get_poll(thread, pk)
return poll_vote_create(request, thread, instance)
def get_votes(self, request, thread_pk, pk=None):
poll_pk = get_int_or_404(pk)
try:
thread = self.get_thread(request, thread_pk)
if thread.poll.pk != poll_pk:
raise Http404()
except Poll.DoesNotExist:
raise Http404()
allow_see_poll_votes(request.user_acl, thread.poll)
choices = []
voters = {}
for choice in thread.poll.choices:
choice["voters"] = []
voters[choice["hash"]] = choice["voters"]
choices.append(choice)
queryset = thread.poll.pollvote_set.values(
"voter_id", "voter_name", "voter_slug", "voted_on", "choice_hash"
)
for voter in queryset.order_by("voter_name").iterator(chunk_size=50):
voters[voter["choice_hash"]].append(PollVoteSerializer(voter).data)
return Response(choices)
class ThreadPollViewSet(ViewSet):
thread = ForumThread
| 4,945
|
Python
|
.py
| 125
| 31.048
| 85
| 0.648734
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,052
|
threads.py
|
rafalp_Misago/misago/threads/api/threads.py
|
from django.core.exceptions import PermissionDenied
from django.db import transaction
from django.utils.translation import pgettext
from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.response import Response
from ...categories import PRIVATE_THREADS_ROOT_NAME, THREADS_ROOT_NAME
from ...core.shortcuts import get_int_or_404
from ..models import Post, Thread
from ..permissions import allow_use_private_threads
from ..viewmodels import (
ForumThread,
PrivateThread,
PrivateThreadsCategory,
ThreadsRootCategory,
)
from .postingendpoint import PostingEndpoint
from .threadendpoints.delete import delete_bulk, delete_thread
from .threadendpoints.editor import thread_start_editor
from .threadendpoints.list import private_threads_list_endpoint, threads_list_endpoint
from .threadendpoints.merge import thread_merge_endpoint, threads_merge_endpoint
from .threadendpoints.patch import bulk_patch_endpoint, thread_patch_endpoint
class ViewSet(viewsets.ViewSet):
thread = None
def get_thread(
self, request, pk, path_aware=False, read_aware=False, watch_aware=False
):
return self.thread( # pylint: disable=not-callable
request,
get_int_or_404(pk),
path_aware=path_aware,
read_aware=read_aware,
watch_aware=watch_aware,
)
def retrieve(self, request, pk):
thread = self.get_thread(
request, pk, path_aware=True, read_aware=True, watch_aware=True
)
return Response(thread.get_frontend_context())
@transaction.atomic
def partial_update(self, request, pk=None):
thread = self.get_thread(request, pk).unwrap()
return thread_patch_endpoint(request, thread)
def patch(self, request):
return bulk_patch_endpoint(request, self.thread)
def delete(self, request, pk=None):
if pk:
thread = self.get_thread(request, pk).unwrap()
return delete_thread(request, thread)
return delete_bulk(request, self.thread)
class ThreadViewSet(ViewSet):
category = ThreadsRootCategory
thread = ForumThread
def list(self, request):
return threads_list_endpoint(request)
@transaction.atomic
def create(self, request):
# Initialize empty instances for new thread
thread = Thread()
post = Post(thread=thread)
# Put them through posting pipeline
posting = PostingEndpoint(
request,
PostingEndpoint.START,
tree_name=THREADS_ROOT_NAME,
thread=thread,
post=post,
)
if not posting.is_valid():
return Response(posting.errors, status=400)
posting.save()
return Response(
{"id": thread.pk, "title": thread.title, "url": thread.get_absolute_url()}
)
@action(detail=True, methods=["post"], url_path="merge", url_name="merge")
@transaction.atomic
def thread_merge(self, request, pk=None):
thread = self.get_thread(request, pk).unwrap()
return thread_merge_endpoint(request, thread, self.thread)
@action(detail=False, methods=["post"], url_path="merge", url_name="merge")
@transaction.atomic
def threads_merge(self, request):
return threads_merge_endpoint(request)
@action(detail=False, methods=["get"])
def editor(self, request):
return thread_start_editor(request)
class PrivateThreadViewSet(ViewSet):
category = PrivateThreadsCategory
thread = PrivateThread
def list(self, request):
return private_threads_list_endpoint(request)
@transaction.atomic
def create(self, request):
allow_use_private_threads(request.user_acl)
if not request.user_acl["can_start_private_threads"]:
raise PermissionDenied(
pgettext("private threads api", "You can't start private threads.")
)
request.user.lock()
# Initialize empty instances for new thread
thread = Thread()
post = Post(thread=thread)
# Put them through posting pipeline
posting = PostingEndpoint(
request,
PostingEndpoint.START,
tree_name=PRIVATE_THREADS_ROOT_NAME,
thread=thread,
post=post,
)
if not posting.is_valid():
return Response(posting.errors, status=400)
posting.save()
return Response(
{"id": thread.pk, "title": thread.title, "url": thread.get_absolute_url()}
)
| 4,592
|
Python
|
.py
| 116
| 31.913793
| 86
| 0.675439
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,053
|
attachments.py
|
rafalp_Misago/misago/threads/api/attachments.py
|
from django.core.exceptions import PermissionDenied, ValidationError
from django.template.defaultfilters import filesizeformat
from django.utils.translation import pgettext
from rest_framework import viewsets
from rest_framework.response import Response
from ...acl.objectacl import add_acl_to_obj
from ...users.audittrail import create_audit_trail
from ..models import Attachment, AttachmentType
from ..serializers import AttachmentSerializer
IMAGE_EXTENSIONS = ("jpg", "jpeg", "png", "gif", "webp")
class AttachmentViewSet(viewsets.ViewSet):
def create(self, request):
if not request.user_acl["max_attachment_size"]:
raise PermissionDenied(
pgettext(
"attachments api", "You don't have permission to upload new files."
)
)
try:
return self.create_attachment(request)
except ValidationError as e:
return Response({"detail": e.args[0]}, status=400)
def create_attachment(self, request):
upload = request.FILES.get("upload")
if not upload:
raise ValidationError(
pgettext("attachments api", "No file has been uploaded.")
)
user_roles = set(r.pk for r in request.user.get_roles())
filetype = validate_filetype(upload, user_roles)
validate_filesize(upload, request.user_acl["max_attachment_size"])
attachment = Attachment(
secret=Attachment.generate_new_secret(),
filetype=filetype,
size=upload.size,
uploader=request.user,
uploader_name=request.user.username,
uploader_slug=request.user.slug,
filename=upload.name,
)
if is_upload_image(upload):
try:
attachment.set_image(upload)
except IOError:
raise ValidationError(
pgettext(
"attachments api", "Uploaded image is unsupported or invalid."
)
)
else:
attachment.set_file(upload)
attachment.save()
add_acl_to_obj(request.user_acl, attachment)
create_audit_trail(request, attachment)
return Response(
AttachmentSerializer(attachment, context={"user": request.user}).data
)
def validate_filetype(upload, user_roles):
filename = upload.name.strip().lower()
queryset = AttachmentType.objects.filter(status=AttachmentType.ENABLED)
for filetype in queryset.prefetch_related("limit_uploads_to"):
for extension in filetype.extensions_list:
if filename.endswith(".%s" % extension):
break
else:
continue
if (
filetype.mimetypes_list
and upload.content_type not in filetype.mimetypes_list
):
continue
if filetype.limit_uploads_to.exists():
allowed_roles = set(r.pk for r in filetype.limit_uploads_to.all())
if not user_roles & allowed_roles:
continue
return filetype
raise ValidationError(
pgettext("attachments api", "You can't upload files of this type.")
)
def validate_filesize(upload, upload_limit):
if upload.size > upload_limit * 1024:
message = pgettext(
"attachments api",
"You can't upload files larger than %(limit)s (your file has %(upload)s).",
)
raise ValidationError(
message
% {
"upload": filesizeformat(upload.size).rstrip(".0"),
"limit": filesizeformat(upload_limit * 1024).rstrip(".0"),
}
)
def is_upload_image(upload):
filename = upload.name.strip().lower()
for extension in IMAGE_EXTENSIONS:
if filename.endswith(".%s" % extension):
return True
return False
| 3,919
|
Python
|
.py
| 98
| 29.765306
| 87
| 0.616803
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,054
|
category.py
|
rafalp_Misago/misago/threads/api/postingendpoint/category.py
|
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext, pgettext_lazy
from rest_framework import serializers
from . import PostingEndpoint, PostingMiddleware
from ....acl.objectacl import add_acl_to_obj
from ....categories import THREADS_ROOT_NAME
from ....categories.models import Category
from ....categories.permissions import can_browse_category, can_see_category
from ...permissions import allow_start_thread
from ...threadtypes import trees_map
class CategoryMiddleware(PostingMiddleware):
"""
middleware that validates category id and sets category on thread and post instances
"""
def use_this_middleware(self):
if self.mode == PostingEndpoint.START:
return self.tree_name == THREADS_ROOT_NAME
return False
def get_serializer(self):
return CategorySerializer(self.user_acl, data=self.request.data)
def pre_save(self, serializer):
category = serializer.category_cache
add_acl_to_obj(self.user_acl, category)
# set flags for savechanges middleware
category.update_all = False
category.update_fields = []
# assign category to thread and post
self.thread.category = category
self.post.category = category
class CategorySerializer(serializers.Serializer):
category = serializers.IntegerField(
error_messages={
"required": pgettext_lazy(
"posting api", "You have to select category to post thread in."
),
"invalid": pgettext_lazy("posting api", "Selected category is invalid."),
}
)
def __init__(self, user_acl, *args, **kwargs):
self.user_acl = user_acl
self.category_cache = None
super().__init__(*args, **kwargs)
def validate_category(self, value):
try:
self.category_cache = Category.objects.get(
pk=value, tree_id=trees_map.get_tree_id_for_root(THREADS_ROOT_NAME)
)
can_see = can_see_category(self.user_acl, self.category_cache)
can_browse = can_browse_category(self.user_acl, self.category_cache)
if not (self.category_cache.level and can_see and can_browse):
raise PermissionDenied(
pgettext("posting api", "Selected category is invalid.")
)
allow_start_thread(self.user_acl, self.category_cache)
except Category.DoesNotExist:
raise serializers.ValidationError(
pgettext(
"posting api",
"Selected category doesn't exist or you don't have permission to browse it.",
)
)
except PermissionDenied as e:
raise serializers.ValidationError(e.args[0])
| 2,816
|
Python
|
.py
| 63
| 35.444444
| 97
| 0.655462
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,055
|
protect.py
|
rafalp_Misago/misago/threads/api/postingendpoint/protect.py
|
from rest_framework import serializers
from . import PostingEndpoint, PostingMiddleware
class ProtectMiddleware(PostingMiddleware):
def use_this_middleware(self):
return self.mode == PostingEndpoint.EDIT
def get_serializer(self):
return ProtectSerializer(data=self.request.data)
def post_save(self, serializer):
if self.thread.category.acl["can_protect_posts"]:
try:
self.post.is_protected = serializer.validated_data.get("protect", False)
self.post.update_fields.append("is_protected")
except (TypeError, ValueError):
pass
class ProtectSerializer(serializers.Serializer):
protect = serializers.BooleanField(required=False, default=False)
| 758
|
Python
|
.py
| 16
| 38.9375
| 88
| 0.708844
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,056
|
recordedit.py
|
rafalp_Misago/misago/threads/api/postingendpoint/recordedit.py
|
from django.db.models import F
from . import PostingEndpoint, PostingMiddleware
class RecordEditMiddleware(PostingMiddleware):
def use_this_middleware(self):
self.original_post = self.post.original
return self.mode == PostingEndpoint.EDIT
def save(self, serializer):
is_post_changed = self.original_post != self.post.original
if not is_post_changed:
return
self.post.updated_on = self.datetime
self.post.edits = F("edits") + 1
self.post.last_editor = self.user
self.post.last_editor_name = self.user.username
self.post.last_editor_slug = self.user.slug
self.post.update_fields.extend(
(
"updated_on",
"edits",
"last_editor",
"last_editor_name",
"last_editor_slug",
)
)
self.post.edits_record.create(
category=self.post.category,
thread=self.thread,
edited_on=self.datetime,
editor=self.user,
editor_name=self.user.username,
editor_slug=self.user.slug,
edited_from=self.original_post,
edited_to=self.post.original,
)
| 1,249
|
Python
|
.py
| 34
| 25.941176
| 66
| 0.588723
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,057
|
moderationqueue.py
|
rafalp_Misago/misago/threads/api/postingendpoint/moderationqueue.py
|
from . import PostingEndpoint, PostingMiddleware
from ....categories import PRIVATE_THREADS_ROOT_NAME
class ModerationQueueMiddleware(PostingMiddleware):
def use_this_middleware(self):
try:
tree_name = self.tree_name
except AttributeError:
tree_name = self.thread.category.thread_type.root_name
return tree_name != PRIVATE_THREADS_ROOT_NAME
def save(self, serializer):
if self.mode == PostingEndpoint.START:
self.post.is_unapproved = self.thread.category.acl[
"require_threads_approval"
]
if self.mode == PostingEndpoint.REPLY:
self.post.is_unapproved = self.thread.category.acl[
"require_replies_approval"
]
if self.mode == PostingEndpoint.EDIT:
self.post.is_unapproved = self.thread.category.acl["require_edits_approval"]
if self.post.is_unapproved:
self.post.update_fields.append("is_unapproved")
| 999
|
Python
|
.py
| 22
| 35.363636
| 88
| 0.654639
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,058
|
floodprotection.py
|
rafalp_Misago/misago/threads/api/postingendpoint/floodprotection.py
|
from datetime import timedelta
from django.utils import timezone
from django.utils.translation import pgettext
from . import PostingEndpoint, PostingInterrupt, PostingMiddleware
MIN_POSTING_INTERVAL = 3
class FloodProtectionMiddleware(PostingMiddleware):
def use_this_middleware(self):
return (
not self.user_acl["can_omit_flood_protection"]
and self.mode != PostingEndpoint.EDIT
)
def interrupt_posting(self, serializer):
now = timezone.now()
if self.user.last_posted_on:
previous_post = now - self.user.last_posted_on
if previous_post.total_seconds() < MIN_POSTING_INTERVAL:
raise PostingInterrupt(
pgettext(
"posting api",
"You can't post message so quickly after previous one.",
)
)
self.user.last_posted_on = timezone.now()
self.user.update_fields.append("last_posted_on")
if self.settings.hourly_post_limit:
cutoff = now - timedelta(hours=1)
if self.is_limit_exceeded(cutoff, self.settings.hourly_post_limit):
raise PostingInterrupt(
pgettext(
"posting api", "Your account has exceed an hourly post limit."
)
)
if self.settings.daily_post_limit:
cutoff = now - timedelta(hours=24)
if self.is_limit_exceeded(cutoff, self.settings.daily_post_limit):
raise PostingInterrupt(
pgettext(
"posting api", "Your account has exceed a daily post limit."
)
)
def is_limit_exceeded(self, cutoff, limit):
return self.user.post_set.filter(posted_on__gte=cutoff).count() >= limit
| 1,873
|
Python
|
.py
| 42
| 31.619048
| 86
| 0.585165
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,059
|
close.py
|
rafalp_Misago/misago/threads/api/postingendpoint/close.py
|
from rest_framework import serializers
from . import PostingEndpoint, PostingMiddleware
from ... import moderation
class CloseMiddleware(PostingMiddleware):
def use_this_middleware(self):
return self.mode == PostingEndpoint.START
def get_serializer(self):
return CloseSerializer(data=self.request.data)
def post_save(self, serializer):
if self.thread.category.acl["can_close_threads"]:
if serializer.validated_data.get("close"):
moderation.close_thread(self.request, self.thread)
class CloseSerializer(serializers.Serializer):
close = serializers.BooleanField(required=False, default=False)
| 666
|
Python
|
.py
| 14
| 41.214286
| 67
| 0.748837
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,060
|
updatestats.py
|
rafalp_Misago/misago/threads/api/postingendpoint/updatestats.py
|
from django.db.models import F
from . import PostingEndpoint, PostingMiddleware
from ....categories import THREADS_ROOT_NAME
class UpdateStatsMiddleware(PostingMiddleware):
def save(self, serializer):
self.update_user(self.user, self.post)
self.update_thread(self.thread, self.post)
self.update_category(self.thread.category, self.thread, self.post)
def update_category(self, category, thread, post):
if post.is_unapproved:
return # don't update category on moderated post
if self.mode == PostingEndpoint.START:
category.threads = F("threads") + 1
if self.mode != PostingEndpoint.EDIT:
category.set_last_thread(thread)
category.posts = F("posts") + 1
category.update_all = True
def update_thread(self, thread, post):
if post.is_unapproved:
thread.has_unapproved_posts = True
if self.post.id == self.thread.first_post_id:
thread.is_unapproved = True
else:
if self.mode != PostingEndpoint.EDIT:
thread.set_last_post(post)
if self.mode == PostingEndpoint.REPLY:
thread.replies = F("replies") + 1
thread.update_all = True
def update_user(self, user, post):
if post.is_unapproved:
return # don't update user on moderated post
if self.thread.thread_type.root_name == THREADS_ROOT_NAME:
if self.mode == PostingEndpoint.START:
user.threads = F("threads") + 1
user.update_fields.append("threads")
if self.mode != PostingEndpoint.EDIT:
user.posts = F("posts") + 1
user.update_fields.append("posts")
| 1,763
|
Python
|
.py
| 38
| 35.605263
| 74
| 0.618797
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,061
|
__init__.py
|
rafalp_Misago/misago/threads/api/postingendpoint/__init__.py
|
from rest_framework import serializers
from django.core.exceptions import PermissionDenied
from django.http import QueryDict
from django.utils import timezone
from django.utils.module_loading import import_string
from ....conf import settings
class PostingInterrupt(Exception):
def __init__(self, message): # pylint: disable=super-init-not-called
if not message:
raise ValueError("You have to provide PostingInterrupt message.")
self.message = message
class PostingEndpoint:
START = 0
REPLY = 1
EDIT = 2
def __init__(self, request, mode, **kwargs):
# we are using lock on user model to protect us from flood
request.user.lock()
# build kwargs dict for passing to middlewares
self.kwargs = kwargs
self.kwargs.update(
{
"mode": mode,
"request": request,
"settings": request.settings,
"user": request.user,
"user_acl": request.user_acl,
}
)
self.__dict__.update(kwargs)
# some middlewares (eg. emailnotification) may call render()
# which will crash if this isn't set to false
request.include_frontend_context = False
self.datetime = timezone.now()
self.errors = {}
self._is_validated = False
self.middlewares = self._load_middlewares()
self._serializers = self._initialize_serializers()
@property
def is_start_endpoint(self):
return self.mode == self.START
@property
def is_reply_endpoint(self):
return self.mode == self.REPLY
@property
def is_edit_endpoint(self):
return self.mode == self.EDIT
def _load_middlewares(self):
kwargs = self.kwargs.copy()
kwargs.update({"datetime": self.datetime, "parsing_result": {}})
middlewares = []
for middleware in settings.MISAGO_POSTING_MIDDLEWARES:
middleware_class = import_string(middleware)
try:
middleware_obj = middleware_class(prefix=middleware, **kwargs)
if middleware_obj.use_this_middleware():
middlewares.append((middleware, middleware_obj))
except PostingInterrupt:
raise ValueError(
"Posting process can only be interrupted during pre_save phase"
)
return middlewares
def get_serializers(self):
"""return list of serializers belonging to serializerset"""
return self._serializers
def _initialize_serializers(self):
try:
serializers = {}
for middleware, obj in self.middlewares:
serializer = obj.get_serializer()
if serializer:
serializers[middleware] = serializer
return serializers
except PostingInterrupt:
raise ValueError(
"Posting process can only be interrupted during pre_save phase"
)
def is_valid(self):
"""validate data against all serializers"""
for serializer in self._serializers.values():
if not serializer.is_valid():
self.errors.update(serializer.errors)
self._is_validated = True
return not self.errors
def save(self):
"""save new state to backend"""
if not self._is_validated or self.errors:
raise RuntimeError(
"You need to validate posting data successfully before calling save"
)
try:
for middleware, obj in self.middlewares:
obj.pre_save(self._serializers.get(middleware))
except PostingInterrupt as e:
raise ValueError(
"Posting process can only be interrupted "
"from within interrupt_posting method"
)
try:
for middleware, obj in self.middlewares:
obj.interrupt_posting(self._serializers.get(middleware))
except PostingInterrupt as e:
raise PermissionDenied(e.message)
try:
for middleware, obj in self.middlewares:
obj.save(self._serializers.get(middleware))
for middleware, obj in self.middlewares:
obj.post_save(self._serializers.get(middleware))
except PostingInterrupt as e:
raise ValueError(
"Posting process can only be interrupted "
"from within interrupt_posting method"
)
class PostingMiddleware:
"""abstract middleware class"""
def __init__(self, **kwargs):
self.kwargs = kwargs
self.__dict__.update(kwargs)
def use_this_middleware(self):
return True
def get_serializer(self):
pass
def pre_save(self, serializer):
pass
def interrupt_posting(self, serializer):
pass
def save(self, serializer):
pass
def post_save(self, serializer):
pass
| 5,033
|
Python
|
.py
| 130
| 28.392308
| 84
| 0.610232
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,062
|
privatethread.py
|
rafalp_Misago/misago/threads/api/postingendpoint/privatethread.py
|
from . import PostingEndpoint, PostingMiddleware
from ....acl.objectacl import add_acl_to_obj
from ....categories import PRIVATE_THREADS_ROOT_NAME
from ....categories.models import Category
class PrivateThreadMiddleware(PostingMiddleware):
"""middleware that sets private threads category for thread and post"""
def use_this_middleware(self):
if self.mode == PostingEndpoint.START:
return self.tree_name == PRIVATE_THREADS_ROOT_NAME
return False
def pre_save(self, serializer):
category = Category.objects.private_threads()
add_acl_to_obj(self.user_acl, category)
# set flags for savechanges middleware
category.update_all = False
category.update_fields = []
# assign category to thread and post
self.thread.category = category
self.post.category = category
| 869
|
Python
|
.py
| 19
| 38.894737
| 75
| 0.71293
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,063
|
mentions.py
|
rafalp_Misago/misago/threads/api/postingendpoint/mentions.py
|
from . import PostingEndpoint, PostingMiddleware
class MentionsMiddleware(PostingMiddleware):
def post_save(self, serializer):
existing_mentions = []
if self.mode == PostingEndpoint.EDIT:
existing_mentions = self.get_existing_mentions()
new_mentions = []
for user_pk in self.post.parsing_result["mentions"]:
if user_pk not in existing_mentions:
new_mentions.append(user_pk)
if new_mentions:
self.post.mentions.add(*new_mentions)
def get_existing_mentions(self):
return [
u["id"] for u in self.post.mentions.values("id").iterator(chunk_size=50)
]
| 679
|
Python
|
.py
| 16
| 33.125
| 84
| 0.639818
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,064
|
savechanges.py
|
rafalp_Misago/misago/threads/api/postingendpoint/savechanges.py
|
from collections import OrderedDict
from . import PostingMiddleware
from ....categories.models import Category
class SaveChangesMiddleware(PostingMiddleware):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.reset_state()
def reset_state(self):
self.user.update_all = False
self.thread.update_all = False
self.post.update_all = False
self.user.update_fields = []
self.thread.update_fields = []
self.post.update_fields = []
try:
self.thread.category.update_all = False
self.thread.category.update_fields = []
except Category.DoesNotExist:
# Exception for cases when thread has no category associated
# If this is the case, its Category's middleware job to set those flags
pass
def save_models(self):
self.save_model(self.user)
self.save_model(self.thread.category)
self.save_model(self.thread)
self.save_model(self.post)
self.reset_state()
def save_model(self, model):
if model.update_all:
model.save()
elif model.update_fields:
update_fields = list(OrderedDict.fromkeys(model.update_fields))
model.save(update_fields=update_fields)
def save(self, serializer):
self.save_models()
def post_save(self, serializer):
self.save_models()
| 1,426
|
Python
|
.py
| 37
| 29.918919
| 83
| 0.639594
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,065
|
reply.py
|
rafalp_Misago/misago/threads/api/postingendpoint/reply.py
|
from django.utils.translation import pgettext_lazy
from rest_framework import serializers
from . import PostingEndpoint, PostingMiddleware
from ....markup import common_flavour
from ....users.audittrail import create_audit_trail
from ...checksums import update_post_checksum
from ...validators import validate_post, validate_post_length, validate_thread_title
class ReplyMiddleware(PostingMiddleware):
def get_serializer(self):
if self.mode == PostingEndpoint.START:
serializer = ThreadSerializer
else:
serializer = ReplySerializer
return serializer(data=self.request.data, context=self.kwargs)
def save(self, serializer):
if self.mode == PostingEndpoint.START:
self.new_thread(serializer.validated_data)
parsing_result = serializer.validated_data["parsing_result"]
if self.mode == PostingEndpoint.EDIT:
self.edit_post(serializer.validated_data, parsing_result)
else:
self.new_post(serializer.validated_data, parsing_result)
if self.mode == PostingEndpoint.START:
self.post.set_search_document(self.thread.title)
else:
self.post.set_search_document()
self.post.updated_on = self.datetime
self.post.save()
self.post.update_search_vector()
update_post_checksum(self.post)
self.post.update_fields += ["checksum", "search_vector"]
if self.mode == PostingEndpoint.START:
self.thread.set_first_post(self.post)
self.thread.set_last_post(self.post)
if self.mode in (PostingEndpoint.START, PostingEndpoint.REPLY):
save_read(self.user, self.post)
self.thread.save()
create_audit_trail(self.request, self.post)
# annotate post for future middlewares
self.post.parsing_result = parsing_result
def new_thread(self, validated_data):
self.thread.set_title(validated_data["title"])
self.thread.starter_name = self.user.username
self.thread.starter_slug = self.user.slug
self.thread.last_poster_name = self.user.username
self.thread.last_poster_slug = self.user.slug
self.thread.started_on = self.datetime
self.thread.last_post_on = self.datetime
self.thread.save()
def edit_post(self, validated_data, parsing_result):
self.post.original = parsing_result["original_text"]
self.post.parsed = parsing_result["parsed_text"]
def new_post(self, validated_data, parsing_result):
self.post.thread = self.thread
self.post.poster = self.user
self.post.poster_name = self.user.username
self.post.posted_on = self.datetime
self.post.original = parsing_result["original_text"]
self.post.parsed = parsing_result["parsed_text"]
class ReplySerializer(serializers.Serializer):
post = serializers.CharField(
error_messages={
"required": pgettext_lazy("posting api", "You have to enter a message.")
}
)
def validate_post(self, data):
validate_post_length(self.context["settings"], data)
return data
def validate(self, data):
if data.get("post"):
data["parsing_result"] = self.parse_post(data["post"])
data = validate_post(self.context, data)
return data
def parse_post(self, post):
if self.context["mode"] == PostingEndpoint.START:
return common_flavour(self.context["request"], self.context["user"], post)
return common_flavour(
self.context["request"], self.context["post"].poster, post
)
class ThreadSerializer(ReplySerializer):
title = serializers.CharField(
error_messages={
"required": pgettext_lazy(
"posting api", "You have to enter a thread title."
)
}
)
def validate_title(self, data):
validate_thread_title(self.context["settings"], data)
return data
| 4,021
|
Python
|
.py
| 90
| 35.966667
| 86
| 0.665214
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,066
|
participants.py
|
rafalp_Misago/misago/threads/api/postingendpoint/participants.py
|
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied
from django.utils.translation import npgettext, pgettext
from rest_framework import serializers
from . import PostingEndpoint, PostingMiddleware
from ....acl import useracl
from ....categories import PRIVATE_THREADS_ROOT_NAME
from ....users.utils import slugify_username
from ...participants import add_participants, set_owner
from ...permissions import allow_message_user
User = get_user_model()
class ParticipantsMiddleware(PostingMiddleware):
def use_this_middleware(self):
if self.mode == PostingEndpoint.START:
return self.tree_name == PRIVATE_THREADS_ROOT_NAME
return False
def get_serializer(self):
return ParticipantsSerializer(
data=self.request.data,
context={
"request": self.request,
"user": self.user,
"user_acl": self.user_acl,
},
)
def post_save(self, serializer):
set_owner(self.thread, self.user)
add_participants(self.request.user, self.thread, serializer.users_cache)
class ParticipantsSerializer(serializers.Serializer):
to = serializers.ListField(child=serializers.CharField(), required=True)
def validate_to(self, usernames):
clean_usernames = self.clean_usernames(usernames)
self.users_cache = self.get_users(clean_usernames)
def clean_usernames(self, usernames):
clean_usernames = []
for name in usernames:
clean_name = slugify_username(name)
if clean_name == self.context["user"].slug:
raise serializers.ValidationError(
pgettext(
"posting api",
"You can't include yourself on the list of users to invite to new thread.",
)
)
if clean_name and clean_name not in clean_usernames:
clean_usernames.append(clean_name)
if not clean_usernames:
raise serializers.ValidationError(
pgettext("posting api", "You have to enter user names.")
)
max_participants = self.context["user_acl"]["max_private_thread_participants"]
if max_participants and len(clean_usernames) > max_participants:
# pylint: disable=line-too-long
message = npgettext(
"posting api",
"You can't add more than %(users)s user to private thread (you've added %(added)s).",
"You can't add more than %(users)s users to private thread (you've added %(added)s).",
max_participants,
)
raise serializers.ValidationError(
message % {"users": max_participants, "added": len(clean_usernames)}
)
return list(set(clean_usernames))
def get_users(self, usernames):
users = []
for user in User.objects.filter(slug__in=usernames):
try:
user_acl = useracl.get_user_acl(
user, self.context["request"].cache_versions
)
allow_message_user(self.context["user_acl"], user, user_acl)
except PermissionDenied as e:
raise serializers.ValidationError(str(e))
users.append(user)
if len(usernames) != len(users):
invalid_usernames = set(usernames) - {u.slug for u in users}
sorted_usernames = sorted(invalid_usernames)
message = pgettext(
"posting api", "One or more users could not be found: %(usernames)s"
)
raise serializers.ValidationError(
message % {"usernames": ", ".join(sorted_usernames)}
)
return users
| 3,830
|
Python
|
.py
| 84
| 34.321429
| 102
| 0.614167
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,067
|
syncprivatethreads.py
|
rafalp_Misago/misago/threads/api/postingendpoint/syncprivatethreads.py
|
from . import PostingEndpoint, PostingMiddleware
from ....categories import PRIVATE_THREADS_ROOT_NAME
from ...participants import set_users_unread_private_threads_sync
class SyncPrivateThreadsMiddleware(PostingMiddleware):
"""middleware that sets private thread participants to sync unread threads"""
def use_this_middleware(self):
if self.mode == PostingEndpoint.REPLY:
return self.thread.thread_type.root_name == PRIVATE_THREADS_ROOT_NAME
return False
def post_save(self, serializer):
set_users_unread_private_threads_sync(
participants=self.thread.participants_list,
exclude_user=self.user,
)
| 680
|
Python
|
.py
| 14
| 41.571429
| 81
| 0.732628
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,068
|
attachments.py
|
rafalp_Misago/misago/threads/api/postingendpoint/attachments.py
|
from django.utils.translation import npgettext, pgettext
from rest_framework import serializers
from rest_framework.fields import empty
from . import PostingEndpoint, PostingMiddleware
from ....acl.objectacl import add_acl_to_obj
from ...serializers import AttachmentSerializer
class AttachmentsMiddleware(PostingMiddleware):
def use_this_middleware(self):
return bool(self.user_acl["max_attachment_size"])
def get_serializer(self):
return AttachmentsSerializer(
data=self.request.data,
context={
"mode": self.mode,
"user": self.user,
"user_acl": self.user_acl,
"post": self.post,
"settings": self.settings,
},
)
def save(self, serializer):
serializer.save()
class AttachmentsSerializer(serializers.Serializer):
attachments = serializers.ListField(
child=serializers.IntegerField(), required=False
)
def __init__(self, *args, **kwargs):
self.update_attachments = False
self.removed_attachments = []
self.final_attachments = []
super().__init__(*args, **kwargs)
def validate_attachments(self, ids):
ids = list(set(ids))
validate_attachments_count(ids, self.context["settings"])
attachments = self.get_initial_attachments()
new_attachments = self.get_new_attachments(ids)
if not attachments and not new_attachments:
return [] # no attachments
# clean existing attachments
for attachment in attachments:
if attachment.pk in ids:
self.final_attachments.append(attachment)
else:
if attachment.acl["can_delete"]:
self.update_attachments = True
self.removed_attachments.append(attachment)
else:
message = pgettext(
"posting api",
'You don\'t have permission to remove "%(attachment)s" attachment.',
)
raise serializers.ValidationError(
message % {"attachment": attachment.filename}
)
if new_attachments:
self.update_attachments = True
self.final_attachments += new_attachments
self.final_attachments.sort(key=lambda a: a.pk, reverse=True)
def get_initial_attachments(self):
attachments = []
if self.context["mode"] == PostingEndpoint.EDIT:
queryset = self.context["post"].attachment_set.select_related("filetype")
attachments = list(queryset)
add_acl_to_obj(self.context["user_acl"], attachments)
return attachments
def get_new_attachments(self, ids):
if not ids:
return []
queryset = (
self.context["user"]
.attachment_set.select_related("filetype")
.filter(post__isnull=True, id__in=ids)
)
return list(queryset)
def save(self):
if not self.update_attachments:
return
if self.removed_attachments:
for attachment in self.removed_attachments:
attachment.delete_files()
self.context["post"].attachment_set.filter(
id__in=[a.id for a in self.removed_attachments]
).delete()
if self.final_attachments:
# sort final attachments by id, descending
self.final_attachments.sort(key=lambda a: a.pk, reverse=True)
self.context["user"].attachment_set.filter(
id__in=[a.id for a in self.final_attachments]
).update(post=self.context["post"])
self.sync_attachments_cache(self.context["post"], self.final_attachments)
def sync_attachments_cache(self, post, attachments):
if attachments:
post.attachments_cache = AttachmentSerializer(attachments, many=True).data
for attachment in post.attachments_cache:
del attachment["acl"]
del attachment["post"]
else:
post.attachments_cache = None
post.update_fields.append("attachments_cache")
def validate_attachments_count(data, settings):
total_attachments = len(data)
if total_attachments > settings.post_attachments_limit:
# pylint: disable=line-too-long
message = npgettext(
"posting api",
"You can't attach more than %(limit_value)s file to single post (added %(show_value)s).",
"You can't attach more than %(limit_value)s flies to single post (added %(show_value)s).",
settings.post_attachments_limit,
)
raise serializers.ValidationError(
message
% {
"limit_value": settings.post_attachments_limit,
"show_value": total_attachments,
}
)
| 4,967
|
Python
|
.py
| 116
| 31.422414
| 102
| 0.601865
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,069
|
notifications.py
|
rafalp_Misago/misago/threads/api/postingendpoint/notifications.py
|
from ....notifications.tasks import notify_on_new_thread_reply
from ....notifications.threads import (
watch_replied_thread,
watch_started_thread,
)
from . import PostingEndpoint, PostingMiddleware
class NotificationsMiddleware(PostingMiddleware):
def use_this_middleware(self):
return self.mode != PostingEndpoint.EDIT
def post_save(self, serializer):
if self.mode == PostingEndpoint.START:
watch_started_thread(self.user, self.thread)
elif self.mode == PostingEndpoint.REPLY:
watch_replied_thread(self.user, self.thread)
if self.mode == PostingEndpoint.REPLY:
notify_on_new_thread_reply.delay(self.post.id)
| 697
|
Python
|
.py
| 16
| 37.0625
| 62
| 0.717873
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,070
|
hide.py
|
rafalp_Misago/misago/threads/api/postingendpoint/hide.py
|
from rest_framework import serializers
from . import PostingEndpoint, PostingMiddleware
from ... import moderation
class HideMiddleware(PostingMiddleware):
def use_this_middleware(self):
return self.mode == PostingEndpoint.START
def get_serializer(self):
return HideSerializer(data=self.request.data)
def post_save(self, serializer):
if self.thread.category.acl["can_hide_threads"]:
if serializer.validated_data.get("hide"):
moderation.hide_thread(self.request, self.thread)
self.thread.update_all = True
self.thread.save(update_fields=["is_hidden"])
self.thread.category.synchronize()
self.thread.category.update_all = True
class HideSerializer(serializers.Serializer):
hide = serializers.BooleanField(required=False, default=False)
| 874
|
Python
|
.py
| 18
| 39.777778
| 66
| 0.699292
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,071
|
pin.py
|
rafalp_Misago/misago/threads/api/postingendpoint/pin.py
|
from rest_framework import serializers
from . import PostingEndpoint, PostingMiddleware
from ... import moderation
from ...models import Thread
class PinMiddleware(PostingMiddleware):
def use_this_middleware(self):
return self.mode == PostingEndpoint.START
def get_serializer(self):
return PinSerializer(data=self.request.data)
def post_save(self, serializer):
allowed_pin = self.thread.category.acl["can_pin_threads"]
if allowed_pin > 0:
pin = serializer.validated_data["pin"]
if pin <= allowed_pin:
if pin == Thread.WEIGHT_GLOBAL:
moderation.pin_thread_globally(self.request, self.thread)
elif pin == Thread.WEIGHT_PINNED:
moderation.pin_thread_locally(self.request, self.thread)
class PinSerializer(serializers.Serializer):
pin = serializers.IntegerField(required=False, default=0)
| 937
|
Python
|
.py
| 20
| 38.25
| 77
| 0.686469
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,072
|
merge.py
|
rafalp_Misago/misago/threads/api/threadendpoints/merge.py
|
from django.core.exceptions import PermissionDenied
from rest_framework.response import Response
from ....acl.objectacl import add_acl_to_obj
from ....notifications.tasks import delete_duplicate_watched_threads
from ...events import record_event
from ...mergeconflict import MergeConflict
from ...models import Thread
from ...moderation import threads as moderation
from ...permissions import allow_merge_thread
from ...serializers import (
MergeThreadSerializer,
MergeThreadsSerializer,
ThreadsListSerializer,
)
def thread_merge_endpoint(
request, thread, viewmodel
): # pylint: disable=too-many-branches
allow_merge_thread(request.user_acl, thread)
serializer = MergeThreadSerializer(
data=request.data,
context={
"request": request,
"settings": request.settings,
"thread": thread,
"viewmodel": viewmodel,
},
)
if not serializer.is_valid():
if "other_thread" in serializer.errors:
errors = serializer.errors["other_thread"]
elif "best_answer" in serializer.errors:
errors = serializer.errors["best_answer"]
elif "best_answers" in serializer.errors:
return Response(
{"best_answers": serializer.errors["best_answers"]}, status=400
)
elif "poll" in serializer.errors:
errors = serializer.errors["poll"]
elif "polls" in serializer.errors:
return Response({"polls": serializer.errors["polls"]}, status=400)
else:
errors = list(serializer.errors.values())[0]
return Response({"detail": errors[0]}, status=400)
# merge conflict
other_thread = serializer.validated_data["other_thread"]
best_answer = serializer.validated_data.get("best_answer")
if "best_answer" in serializer.merge_conflict and not best_answer:
other_thread.clear_best_answer()
if best_answer and best_answer != other_thread:
other_thread.best_answer_id = thread.best_answer_id
other_thread.best_answer_is_protected = thread.best_answer_is_protected
other_thread.best_answer_marked_on = thread.best_answer_marked_on
other_thread.best_answer_marked_by_id = thread.best_answer_marked_by_id
other_thread.best_answer_marked_by_name = thread.best_answer_marked_by_name
other_thread.best_answer_marked_by_slug = thread.best_answer_marked_by_slug
poll = serializer.validated_data.get("poll")
if "poll" in serializer.merge_conflict:
if poll and poll.thread_id != other_thread.id:
other_thread.poll.delete()
poll.move(other_thread)
elif not poll:
other_thread.poll.delete()
elif poll:
poll.move(other_thread)
# merge thread contents
moderation.merge_thread(request, other_thread, thread)
other_thread.synchronize()
other_thread.save()
other_thread.category.synchronize()
other_thread.category.save()
if thread.category != other_thread.category:
thread.category.synchronize()
thread.category.save()
return Response(
{
"id": other_thread.pk,
"title": other_thread.title,
"url": other_thread.get_absolute_url(),
}
)
def threads_merge_endpoint(request):
serializer = MergeThreadsSerializer(
data=request.data,
context={
"settings": request.settings,
"user_acl": request.user_acl,
},
)
if not serializer.is_valid():
if "threads" in serializer.errors:
errors = {"detail": serializer.errors["threads"][0]}
return Response(errors, status=403)
if "non_field_errors" in serializer.errors:
errors = {"detail": serializer.errors["non_field_errors"][0]}
return Response(errors, status=403)
return Response(serializer.errors, status=400)
threads = serializer.validated_data["threads"]
invalid_threads = []
for thread in threads:
try:
allow_merge_thread(request.user_acl, thread)
except PermissionDenied as e:
invalid_threads.append(
{"id": thread.pk, "title": thread.title, "errors": [str(e)]}
)
if invalid_threads:
return Response(invalid_threads, status=403)
# handle merge conflict
merge_conflict = MergeConflict(serializer.validated_data, threads)
merge_conflict.is_valid(raise_exception=True)
new_thread = merge_threads(
request, serializer.validated_data, threads, merge_conflict
)
return Response(
ThreadsListSerializer(
new_thread,
context={"settings": request.settings},
).data
)
def merge_threads(request, validated_data, threads, merge_conflict):
new_thread = Thread(
category=validated_data["category"],
started_on=threads[0].started_on,
last_post_on=threads[0].last_post_on,
)
new_thread.set_title(validated_data["title"])
new_thread.save()
resolution = merge_conflict.get_resolution()
best_answer = resolution.get("best_answer")
if best_answer:
new_thread.best_answer_id = best_answer.best_answer_id
new_thread.best_answer_is_protected = best_answer.best_answer_is_protected
new_thread.best_answer_marked_on = best_answer.best_answer_marked_on
new_thread.best_answer_marked_by_id = best_answer.best_answer_marked_by_id
new_thread.best_answer_marked_by_name = best_answer.best_answer_marked_by_name
new_thread.best_answer_marked_by_slug = best_answer.best_answer_marked_by_slug
poll = resolution.get("poll")
if poll:
poll.move(new_thread)
categories = []
for thread in threads:
categories.append(thread.category)
new_thread.merge(thread)
thread.delete()
record_event(
request, new_thread, "merged", {"merged_thread": thread.title}, commit=False
)
new_thread.synchronize()
new_thread.save()
if validated_data.get("weight") == Thread.WEIGHT_GLOBAL:
moderation.pin_thread_globally(request, new_thread)
elif validated_data.get("weight"):
moderation.pin_thread_locally(request, new_thread)
if validated_data.get("is_hidden", False):
moderation.hide_thread(request, new_thread)
if validated_data.get("is_closed", False):
moderation.close_thread(request, new_thread)
if new_thread.category not in categories:
categories.append(new_thread.category)
for category in categories:
category.synchronize()
category.save()
# set extra attrs on thread for UI
new_thread.is_read = False
new_thread.subscription = None
# Deduplicate watched threads
delete_duplicate_watched_threads.delay(new_thread.id)
add_acl_to_obj(request.user_acl, new_thread)
return new_thread
| 6,942
|
Python
|
.py
| 169
| 33.325444
| 88
| 0.668498
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,073
|
delete.py
|
rafalp_Misago/misago/threads/api/threadendpoints/delete.py
|
from django.db import transaction
from rest_framework.response import Response
from ...moderation import threads as moderation
from ...permissions import allow_delete_thread
from ...serializers import DeleteThreadsSerializer
@transaction.atomic
def delete_thread(request, thread):
allow_delete_thread(request.user_acl, thread)
moderation.delete_thread(request, thread)
return Response({})
def delete_bulk(request, viewmodel):
serializer = DeleteThreadsSerializer(
data={"threads": request.data},
context={
"request": request,
"settings": request.settings,
"viewmodel": viewmodel,
},
)
if not serializer.is_valid():
if "threads" in serializer.errors:
errors = serializer.errors["threads"]
if "details" in errors:
return Response(hydrate_error_details(errors["details"]), status=400)
# Fix for KeyError - errors[0]
try:
return Response({"detail": errors[0]}, status=403)
except KeyError:
return Response({"detail": list(errors.values())[0][0]}, status=403)
errors = list(serializer.errors)[0][0]
return Response({"detail": errors}, status=400)
for thread in serializer.validated_data["threads"]:
with transaction.atomic():
delete_thread(request, thread)
return Response([])
def hydrate_error_details(errors):
for error in errors:
error["thread"]["id"] = int(error["thread"]["id"])
return errors
| 1,564
|
Python
|
.py
| 39
| 32.153846
| 85
| 0.651255
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,074
|
editor.py
|
rafalp_Misago/misago/threads/api/threadendpoints/editor.py
|
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext
from rest_framework.response import Response
from ....acl.objectacl import add_acl_to_obj
from ....categories.enums import CategoryTree
from ....categories.models import Category
from ...permissions import can_start_thread
def thread_start_editor(request):
if request.user.is_anonymous:
raise PermissionDenied(
pgettext("posting api", "You need to be signed in to start threads.")
)
# list of categories that allow or contain subcategories that allow new threads
available = []
categories = []
queryset = Category.objects.filter(
pk__in=request.user_acl["browseable_categories"],
tree_id=CategoryTree.THREADS,
).order_by("-lft")
for category in queryset:
add_acl_to_obj(request.user_acl, category)
post = False
if can_start_thread(request.user_acl, category):
post = {
"close": bool(category.acl["can_close_threads"]),
"hide": bool(category.acl["can_hide_threads"]),
"pin": category.acl["can_pin_threads"],
}
available.append(category.pk)
available.append(category.parent_id)
elif category.pk in available:
available.append(category.parent_id)
categories.append(
{
"id": category.pk,
"name": category.name,
"level": category.level - 1,
"post": post,
}
)
# list only categories that allow new threads,
# or contains subcategory that allows one
cleaned_categories = []
for category in reversed(categories):
if category["id"] in available:
cleaned_categories.append(category)
if not cleaned_categories:
raise PermissionDenied(
pgettext(
"posting api",
"No categories that allow new threads are available to you at the moment.",
)
)
return Response(cleaned_categories)
| 2,107
|
Python
|
.py
| 54
| 29.796296
| 91
| 0.627634
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,075
|
patch.py
|
rafalp_Misago/misago/threads/api/threadendpoints/patch.py
|
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied, ValidationError
from django.http import Http404
from django.shortcuts import get_object_or_404
from django.utils.translation import npgettext, pgettext
from rest_framework import serializers
from rest_framework.response import Response
from ....acl import useracl
from ....acl.objectacl import add_acl_to_obj
from ....categories.models import Category
from ....categories.permissions import allow_browse_category, allow_see_category
from ....categories.serializers import CategorySerializer
from ....conf import settings
from ....core.apipatch import ApiPatch
from ....core.shortcuts import get_int_or_404
from ....users.utils import slugify_username
from ...moderation import threads as moderation
from ...participants import (
add_participant,
change_owner,
make_participants_aware,
remove_participant,
)
from ...permissions import (
allow_add_participant,
allow_add_participants,
allow_approve_thread,
allow_change_best_answer,
allow_change_owner,
allow_edit_thread,
allow_hide_thread,
allow_mark_as_best_answer,
allow_mark_best_answer,
allow_move_thread,
allow_pin_thread,
allow_remove_participant,
allow_see_post,
allow_start_thread,
allow_unhide_thread,
allow_unmark_best_answer,
)
from ...serializers import ThreadParticipantSerializer
from ...validators import validate_thread_title
User = get_user_model()
thread_patch_dispatcher = ApiPatch()
def patch_acl(request, thread, value):
"""useful little op that updates thread acl to current state"""
if value:
add_acl_to_obj(request.user_acl, thread)
return {"acl": thread.acl}
return {"acl": None}
thread_patch_dispatcher.add("acl", patch_acl)
def patch_title(request, thread, value):
try:
value_cleaned = str(value).strip()
except (TypeError, ValueError):
raise PermissionDenied(pgettext("threads api", "Not a valid string."))
try:
validate_thread_title(request.settings, value_cleaned)
except ValidationError as e:
raise PermissionDenied(e.args[0])
allow_edit_thread(request.user_acl, thread)
moderation.change_thread_title(request, thread, value_cleaned)
return {"title": thread.title}
thread_patch_dispatcher.replace("title", patch_title)
def patch_weight(request, thread, value):
allow_pin_thread(request.user_acl, thread)
if not thread.acl.get("can_pin_globally") and thread.weight == 2:
raise PermissionDenied(
pgettext(
"threads api",
"You can't change globally pinned threads weights in this category.",
)
)
if value == 2:
if thread.acl.get("can_pin_globally"):
moderation.pin_thread_globally(request, thread)
else:
raise PermissionDenied(
pgettext(
"threads api", "You can't pin threads globally in this category."
)
)
elif value == 1:
moderation.pin_thread_locally(request, thread)
elif value == 0:
moderation.unpin_thread(request, thread)
return {"weight": thread.weight}
thread_patch_dispatcher.replace("weight", patch_weight)
def patch_move(request, thread, value):
allow_move_thread(request.user_acl, thread)
category_pk = get_int_or_404(value)
new_category = get_object_or_404(
Category.objects.all_categories().select_related("parent"), pk=category_pk
)
add_acl_to_obj(request.user_acl, new_category)
allow_see_category(request.user_acl, new_category)
allow_browse_category(request.user_acl, new_category)
allow_start_thread(request.user_acl, new_category)
if new_category == thread.category:
raise PermissionDenied(
pgettext(
"threads api", "You can't move thread to the category it's already in."
)
)
moderation.move_thread(request, thread, new_category)
return {
"category": CategorySerializer(
new_category,
context={
"settings": request.settings,
},
).data,
}
thread_patch_dispatcher.replace("category", patch_move)
def patch_flatten_categories(request, thread, value):
try:
return {"category": thread.category_id}
except AttributeError:
return {"category": thread.category_id}
thread_patch_dispatcher.replace("flatten-categories", patch_flatten_categories)
def patch_is_unapproved(request, thread, value):
allow_approve_thread(request.user_acl, thread)
if value:
raise PermissionDenied(
pgettext("threads api", "Content approval can't be reversed.")
)
moderation.approve_thread(request, thread)
return {
"is_unapproved": thread.is_unapproved,
"has_unapproved_posts": thread.has_unapproved_posts,
}
thread_patch_dispatcher.replace("is-unapproved", patch_is_unapproved)
def patch_is_closed(request, thread, value):
if thread.acl.get("can_close"):
if value:
moderation.close_thread(request, thread)
else:
moderation.open_thread(request, thread)
return {"is_closed": thread.is_closed}
else:
if value:
raise PermissionDenied(
pgettext(
"threads api", "You don't have permission to close this thread."
)
)
else:
raise PermissionDenied(
pgettext(
"threads api", "You don't have permission to open this thread."
)
)
thread_patch_dispatcher.replace("is-closed", patch_is_closed)
def patch_is_hidden(request, thread, value):
if value:
allow_hide_thread(request.user_acl, thread)
moderation.hide_thread(request, thread)
else:
allow_unhide_thread(request.user_acl, thread)
moderation.unhide_thread(request, thread)
return {"is_hidden": thread.is_hidden}
thread_patch_dispatcher.replace("is-hidden", patch_is_hidden)
def patch_best_answer(request, thread, value):
try:
post_id = int(value)
except (TypeError, ValueError):
raise PermissionDenied(pgettext("threads api", "A valid integer is required."))
allow_mark_best_answer(request.user_acl, thread)
post = get_object_or_404(thread.post_set, id=post_id)
post.category = thread.category
post.thread = thread
allow_see_post(request.user_acl, post)
allow_mark_as_best_answer(request.user_acl, post)
if post.is_best_answer:
raise PermissionDenied(
pgettext(
"threads api", "This post is already marked as thread's best answer."
)
)
if thread.has_best_answer:
allow_change_best_answer(request.user_acl, thread)
thread.set_best_answer(request.user, post)
thread.save()
return {
"best_answer": thread.best_answer_id,
"best_answer_is_protected": thread.best_answer_is_protected,
"best_answer_marked_on": thread.best_answer_marked_on,
"best_answer_marked_by": thread.best_answer_marked_by_id,
"best_answer_marked_by_name": thread.best_answer_marked_by_name,
"best_answer_marked_by_slug": thread.best_answer_marked_by_slug,
}
thread_patch_dispatcher.replace("best-answer", patch_best_answer)
def patch_unmark_best_answer(request, thread, value):
try:
post_id = int(value)
except (TypeError, ValueError):
raise PermissionDenied(pgettext("threads api", "A valid integer is required."))
post = get_object_or_404(thread.post_set, id=post_id)
post.category = thread.category
post.thread = thread
if not post.is_best_answer:
raise PermissionDenied(
pgettext(
"threads api",
"This post can't be unmarked because it's not currently marked as best answer.",
)
)
allow_unmark_best_answer(request.user_acl, thread)
thread.clear_best_answer()
thread.save()
return {
"best_answer": None,
"best_answer_is_protected": False,
"best_answer_marked_on": None,
"best_answer_marked_by": None,
"best_answer_marked_by_name": None,
"best_answer_marked_by_slug": None,
}
thread_patch_dispatcher.remove("best-answer", patch_unmark_best_answer)
def patch_add_participant(request, thread, value: str):
allow_add_participants(request.user_acl, thread)
try:
user_slug = slugify_username(value)
if not user_slug:
raise PermissionDenied(
pgettext("threads api", "You have to enter new participant's username.")
)
participant = User.objects.get(slug=user_slug)
except User.DoesNotExist:
raise PermissionDenied(
pgettext("threads api", "No user with this name exists.")
)
if participant in [p.user for p in thread.participants_list]:
raise PermissionDenied(
pgettext("threads api", "This user is already thread participant.")
)
participant_acl = useracl.get_user_acl(participant, request.cache_versions)
allow_add_participant(request.user_acl, participant, participant_acl)
add_participant(request, thread, participant)
make_participants_aware(request.user, thread)
participants = ThreadParticipantSerializer(thread.participants_list, many=True)
return {"participants": participants.data}
thread_patch_dispatcher.add("participants", patch_add_participant)
def patch_remove_participant(request, thread, value):
# pylint: disable=undefined-loop-variable
try:
user_id = int(value)
except (ValueError, TypeError):
raise PermissionDenied(pgettext("threads api", "A valid integer is required."))
for participant in thread.participants_list:
if participant.user_id == user_id:
break
else:
raise PermissionDenied(pgettext("threads api", "Participant doesn't exist."))
allow_remove_participant(request.user_acl, thread, participant.user)
remove_participant(request, thread, participant.user)
if len(thread.participants_list) == 1:
return {"deleted": True}
make_participants_aware(request.user, thread)
participants = ThreadParticipantSerializer(thread.participants_list, many=True)
return {"deleted": False, "participants": participants.data}
thread_patch_dispatcher.remove("participants", patch_remove_participant)
def patch_replace_owner(request, thread, value):
# pylint: disable=undefined-loop-variable
try:
user_id = int(value)
except (ValueError, TypeError):
raise PermissionDenied(pgettext("threads api", "A valid integer is required."))
for participant in thread.participants_list:
if participant.user_id == user_id:
if participant.is_owner:
raise PermissionDenied(
pgettext("threads api", "This user already is thread owner.")
)
else:
break
else:
raise PermissionDenied(pgettext("threads api", "Participant doesn't exist."))
allow_change_owner(request.user_acl, thread)
change_owner(request, thread, participant.user)
make_participants_aware(request.user, thread)
participants = ThreadParticipantSerializer(thread.participants_list, many=True)
return {"participants": participants.data}
thread_patch_dispatcher.replace("owner", patch_replace_owner)
def thread_patch_endpoint(request, thread):
old_title = thread.title
old_is_hidden = thread.is_hidden
old_is_unapproved = thread.is_unapproved
old_category = thread.category
response = thread_patch_dispatcher.dispatch(request, thread)
# diff thread's state against pre-patch and resync category if necessary
hidden_changed = old_is_hidden != thread.is_hidden
unapproved_changed = old_is_unapproved != thread.is_unapproved
category_changed = old_category != thread.category
title_changed = old_title != thread.title
if thread.category.last_thread_id != thread.pk:
title_changed = False # don't trigger resync on simple title change
if hidden_changed or unapproved_changed or category_changed:
thread.category.synchronize()
thread.category.save()
if category_changed:
old_category.synchronize()
old_category.save()
elif title_changed:
thread.category.last_thread_title = thread.title
thread.category.last_thread_slug = thread.slug
thread.category.save(update_fields=["last_thread_title", "last_thread_slug"])
return response
def bulk_patch_endpoint(
request, viewmodel
): # pylint: disable=too-many-branches, too-many-locals
serializer = BulkPatchSerializer(
data=request.data, context={"settings": request.settings}
)
if not serializer.is_valid():
return Response(serializer.errors, status=400)
threads = clean_threads_for_patch(request, viewmodel, serializer.data["ids"])
old_titles = [t.title for t in threads]
old_is_hidden = [t.is_hidden for t in threads]
old_is_unapproved = [t.is_unapproved for t in threads]
old_category = [t.category_id for t in threads]
response = thread_patch_dispatcher.dispatch_bulk(request, threads)
new_titles = [t.title for t in threads]
new_is_hidden = [t.is_hidden for t in threads]
new_is_unapproved = [t.is_unapproved for t in threads]
new_category = [t.category_id for t in threads]
# sync titles
if new_titles != old_titles:
for i, t in enumerate(threads):
if t.title != old_titles[i] and t.category.last_thread_id == t.pk:
t.category.last_thread_title = t.title
t.category.last_thread_slug = t.slug
t.category.save(update_fields=["last_thread_title", "last_thread_slug"])
# sync categories
sync_categories = []
if new_is_hidden != old_is_hidden:
for i, t in enumerate(threads):
if t.is_hidden != old_is_hidden[i] and t.category_id not in sync_categories:
sync_categories.append(t.category_id)
if new_is_unapproved != old_is_unapproved:
for i, t in enumerate(threads):
if (
t.is_unapproved != old_is_unapproved[i]
and t.category_id not in sync_categories
):
sync_categories.append(t.category_id)
if new_category != old_category:
for i, t in enumerate(threads):
if t.category_id != old_category[i]:
if t.category_id not in sync_categories:
sync_categories.append(t.category_id)
if old_category[i] not in sync_categories:
sync_categories.append(old_category[i])
if sync_categories:
for category in Category.objects.filter(id__in=sync_categories):
category.synchronize()
category.save()
return response
def clean_threads_for_patch(request, viewmodel, threads_ids):
threads = []
for thread_id in sorted(set(threads_ids), reverse=True):
try:
threads.append(viewmodel(request, thread_id).unwrap())
except (Http404, PermissionDenied):
raise PermissionDenied(
pgettext(
"threads api", "One or more threads to update could not be found."
)
)
return threads
class BulkPatchSerializer(serializers.Serializer):
ids = serializers.ListField(
child=serializers.IntegerField(min_value=1), min_length=1
)
ops = serializers.ListField(
child=serializers.DictField(), min_length=1, max_length=10
)
def validate_ids(self, data):
limit = self.context["settings"].threads_per_page
if len(data) > limit:
message = npgettext(
"threads api",
"No more than %(limit)s thread can be updated at a single time.",
"No more than %(limit)s threads can be updated at a single time.",
limit,
)
raise ValidationError(message % {"limit": limit})
return data
| 16,334
|
Python
|
.py
| 389
| 34.169666
| 96
| 0.669363
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,076
|
list.py
|
rafalp_Misago/misago/threads/api/threadendpoints/list.py
|
from rest_framework.response import Response
from ....core.shortcuts import get_int_or_404
from ...viewmodels import (
ForumThreads,
PrivateThreads,
PrivateThreadsCategory,
ThreadsCategory,
ThreadsRootCategory,
)
class ThreadsList:
threads = None
def __call__(self, request, **kwargs):
start = get_int_or_404(request.query_params.get("start", 0))
list_type = request.query_params.get("list", "all")
category = self.get_category(request, pk=request.query_params.get("category"))
threads = self.get_threads(request, category, list_type, start)
return Response(self.get_response_json(request, category, threads)["THREADS"])
def get_category(self, request, pk=None):
raise NotImplementedError(
"Threads list has to implement get_category(request, pk=None)"
)
def get_threads(self, request, category, list_type, start):
return self.threads( # pylint: disable=not-callable
request, category, list_type, start
)
def get_response_json(self, request, category, threads):
return threads.get_frontend_context()
class ForumThreadsList(ThreadsList):
threads = ForumThreads
def get_category(self, request, pk=None):
if pk:
return ThreadsCategory(request, pk=pk)
return ThreadsRootCategory(request)
class PrivateThreadsList(ThreadsList):
threads = PrivateThreads
def get_category(self, request, pk=None):
return PrivateThreadsCategory(request)
threads_list_endpoint = ForumThreadsList()
private_threads_list_endpoint = PrivateThreadsList()
| 1,638
|
Python
|
.py
| 39
| 35.564103
| 86
| 0.707517
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,077
|
likes.py
|
rafalp_Misago/misago/threads/api/postendpoints/likes.py
|
from rest_framework.response import Response
from ...serializers import PostLikeSerializer
def likes_list_endpoint(request, post):
queryset = (
post.postlike_set.order_by("-id")
.select_related("liker")
.values(
"id", "liker_id", "liker_name", "liker_slug", "liked_on", "liker__avatars"
)
)
likes = []
for like in queryset.iterator(chunk_size=50):
likes.append(PostLikeSerializer(like).data)
return Response(likes)
| 492
|
Python
|
.py
| 14
| 28.642857
| 86
| 0.651163
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,078
|
split.py
|
rafalp_Misago/misago/threads/api/postendpoints/split.py
|
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext
from rest_framework.response import Response
from ...models import Thread
from ...moderation import threads as moderation
from ...serializers import SplitPostsSerializer
def posts_split_endpoint(request, thread):
if not thread.acl["can_move_posts"]:
raise PermissionDenied(
pgettext("posts api", "You can't split posts from this thread.")
)
serializer = SplitPostsSerializer(
data=request.data,
context={
"settings": request.settings,
"thread": thread,
"user_acl": request.user_acl,
},
)
if not serializer.is_valid():
if "posts" in serializer.errors:
# Fix for KeyError - errors[0]
errors = serializer.errors["posts"]
try:
errors = {"detail": errors[0]}
except KeyError:
if isinstance(errors, dict):
errors = {"detail": list(errors.values())[0][0]}
else:
errors = serializer.errors
return Response(errors, status=400)
split_posts_to_new_thread(request, thread, serializer.validated_data)
return Response({})
def split_posts_to_new_thread(request, thread, validated_data):
new_thread = Thread(
category=validated_data["category"],
started_on=thread.started_on,
last_post_on=thread.last_post_on,
)
new_thread.set_title(validated_data["title"])
new_thread.save()
for post in validated_data["posts"]:
post.move(new_thread)
post.save()
thread.synchronize()
thread.save()
new_thread.synchronize()
new_thread.save()
if validated_data.get("weight") == Thread.WEIGHT_GLOBAL:
moderation.pin_thread_globally(request, new_thread)
elif validated_data.get("weight"):
moderation.pin_thread_locally(request, new_thread)
if validated_data.get("is_hidden", False):
moderation.hide_thread(request, new_thread)
if validated_data.get("is_closed", False):
moderation.close_thread(request, new_thread)
thread.category.synchronize()
thread.category.save()
if new_thread.category != thread.category:
new_thread.category.synchronize()
new_thread.category.save()
| 2,351
|
Python
|
.py
| 61
| 30.704918
| 76
| 0.655081
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,079
|
merge.py
|
rafalp_Misago/misago/threads/api/postendpoints/merge.py
|
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext
from rest_framework.response import Response
from ....acl.objectacl import add_acl_to_obj
from ...serializers import MergePostsSerializer, PostSerializer
def posts_merge_endpoint(request, thread):
if not thread.acl["can_merge_posts"]:
raise PermissionDenied(
pgettext("posts api", "You can't merge posts in this thread.")
)
serializer = MergePostsSerializer(
data=request.data,
context={
"settings": request.settings,
"thread": thread,
"user_acl": request.user_acl,
},
)
if not serializer.is_valid():
# Fix for KeyError - errors[0]
errors = list(serializer.errors.values())[0]
try:
return Response({"detail": errors[0]}, status=400)
except KeyError:
return Response({"detail": list(errors.values())[0][0]}, status=400)
posts = serializer.validated_data["posts"]
first_post, merged_posts = posts[0], posts[1:]
for post in merged_posts:
post.merge(first_post)
post.delete()
if first_post.pk == thread.first_post_id:
first_post.set_search_document(thread.title)
else:
first_post.set_search_document()
first_post.save()
first_post.update_search_vector()
first_post.save(update_fields=["search_vector"])
thread.synchronize()
thread.save()
thread.category.synchronize()
thread.category.save()
first_post.thread = thread
first_post.category = thread.category
add_acl_to_obj(request.user_acl, first_post)
return Response(PostSerializer(first_post, context={"user": request.user}).data)
| 1,747
|
Python
|
.py
| 45
| 31.8
| 84
| 0.669828
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,080
|
delete.py
|
rafalp_Misago/misago/threads/api/postendpoints/delete.py
|
from rest_framework.response import Response
from ...moderation import posts as moderation
from ...permissions import (
allow_delete_best_answer,
allow_delete_event,
allow_delete_post,
)
from ...serializers import DeletePostsSerializer
def delete_post(request, thread, post):
if post.is_event:
allow_delete_event(request.user_acl, post)
else:
allow_delete_best_answer(request.user_acl, post)
allow_delete_post(request.user_acl, post)
moderation.delete_post(request.user, post)
sync_related(thread)
return Response({})
def delete_bulk(request, thread):
serializer = DeletePostsSerializer(
data={"posts": request.data},
context={
"settings": request.settings,
"thread": thread,
"user_acl": request.user_acl,
},
)
if not serializer.is_valid():
if "posts" in serializer.errors:
errors = serializer.errors["posts"]
else:
errors = list(serializer.errors.values())[0]
# Fix for KeyError - errors[0]
try:
errors = errors[0]
except KeyError:
if errors and isinstance(errors, dict):
errors = list(errors.values())[0][0]
return Response({"detail": errors}, status=400)
for post in serializer.validated_data["posts"]:
post.delete()
sync_related(thread)
return Response({})
def sync_related(thread):
thread.synchronize()
thread.save()
thread.category.synchronize()
thread.category.save()
| 1,565
|
Python
|
.py
| 47
| 26.12766
| 56
| 0.644947
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,081
|
move.py
|
rafalp_Misago/misago/threads/api/postendpoints/move.py
|
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext
from rest_framework.response import Response
from ...serializers import MovePostsSerializer
def posts_move_endpoint(request, thread, viewmodel):
if not thread.acl["can_move_posts"]:
raise PermissionDenied(
pgettext("posts api", "You can't move posts from this thread.")
)
serializer = MovePostsSerializer(
data=request.data,
context={
"request": request,
"settings": request.settings,
"thread": thread,
"viewmodel": viewmodel,
},
)
if not serializer.is_valid():
if "new_thread" in serializer.errors:
errors = serializer.errors["new_thread"]
else:
errors = list(serializer.errors.values())[0]
# Fix for KeyError - errors[0]
try:
return Response({"detail": errors[0]}, status=400)
except KeyError:
return Response({"detail": list(errors.values())[0][0]}, status=400)
new_thread = serializer.validated_data["new_thread"]
for post in serializer.validated_data["posts"]:
post.move(new_thread)
post.save()
thread.synchronize()
thread.save()
new_thread.synchronize()
new_thread.save()
thread.category.synchronize()
thread.category.save()
if thread.category != new_thread.category:
new_thread.category.synchronize()
new_thread.category.save()
return Response({})
| 1,541
|
Python
|
.py
| 42
| 28.833333
| 80
| 0.645595
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,082
|
patch_post.py
|
rafalp_Misago/misago/threads/api/postendpoints/patch_post.py
|
from django.core.exceptions import PermissionDenied
from django.utils.translation import npgettext, pgettext
from rest_framework import serializers
from rest_framework.response import Response
from ....acl.objectacl import add_acl_to_obj
from ....conf import settings
from ....core.apipatch import ApiPatch
from ...models import PostLike
from ...moderation import posts as moderation
from ...permissions import (
allow_approve_post,
allow_hide_best_answer,
allow_hide_post,
allow_protect_post,
allow_unhide_post,
exclude_invisible_posts,
)
post_patch_dispatcher = ApiPatch()
def patch_acl(request, post, value):
"""useful little op that updates post acl to current state"""
if value:
add_acl_to_obj(request.user_acl, post)
return {"acl": post.acl}
return {"acl": None}
post_patch_dispatcher.add("acl", patch_acl)
def patch_is_liked(request, post, value):
if not post.acl["can_like"]:
raise PermissionDenied(
pgettext("posts api", "You can't like posts in this category.")
)
# lock user to protect us from likes flood
request.user.lock()
# grab like state for this post and user
try:
user_like = post.postlike_set.get(liker=request.user)
except PostLike.DoesNotExist:
user_like = None
# no change
if (value and user_like) or (not value and not user_like):
return {
"likes": post.likes,
"last_likes": post.last_likes or [],
"is_liked": value,
}
# like
if value:
post.postlike_set.create(
category=post.category,
thread=post.thread,
liker=request.user,
liker_name=request.user.username,
liker_slug=request.user.slug,
)
post.likes += 1
# unlike
if not value:
user_like.delete()
post.likes -= 1
post.last_likes = []
for like in post.postlike_set.all()[:4]:
post.last_likes.append({"id": like.liker_id, "username": like.liker_name})
post.save(update_fields=["likes", "last_likes"])
return {"likes": post.likes, "last_likes": post.last_likes or [], "is_liked": value}
post_patch_dispatcher.replace("is-liked", patch_is_liked)
def patch_is_protected(request, post, value):
allow_protect_post(request.user_acl, post)
if value:
moderation.protect_post(request.user, post)
else:
moderation.unprotect_post(request.user, post)
return {"is_protected": post.is_protected}
post_patch_dispatcher.replace("is-protected", patch_is_protected)
def patch_is_unapproved(request, post, value):
allow_approve_post(request.user_acl, post)
if value:
raise PermissionDenied(
pgettext("posts api", "Content approval can't be reversed.")
)
moderation.approve_post(request.user, post)
return {"is_unapproved": post.is_unapproved}
post_patch_dispatcher.replace("is-unapproved", patch_is_unapproved)
def patch_is_hidden(request, post, value):
if value is True:
allow_hide_post(request.user_acl, post)
allow_hide_best_answer(request.user_acl, post)
moderation.hide_post(request.user, post)
elif value is False:
allow_unhide_post(request.user_acl, post)
moderation.unhide_post(request.user, post)
return {"is_hidden": post.is_hidden}
post_patch_dispatcher.replace("is-hidden", patch_is_hidden)
def post_patch_endpoint(request, post):
old_is_unapproved = post.is_unapproved
response = post_patch_dispatcher.dispatch(request, post)
# diff posts's state against pre-patch and resync thread/category if necessarys
if old_is_unapproved != post.is_unapproved:
post.thread.synchronize()
post.thread.save()
post.category.synchronize()
post.category.save()
return response
def bulk_patch_endpoint(request, thread):
serializer = BulkPatchSerializer(
data=request.data, context={"settings": request.settings}
)
if not serializer.is_valid():
return Response(serializer.errors, status=400)
posts = clean_posts_for_patch(request, thread, serializer.data["ids"])
old_unapproved_posts = [p.is_unapproved for p in posts].count(True)
response = post_patch_dispatcher.dispatch_bulk(request, posts)
new_unapproved_posts = [p.is_unapproved for p in posts].count(True)
if old_unapproved_posts != new_unapproved_posts:
thread.synchronize()
thread.save()
thread.category.synchronize()
thread.category.save()
return response
def clean_posts_for_patch(request, thread, posts_ids):
posts_queryset = exclude_invisible_posts(
request.user_acl, thread.category, thread.post_set
)
posts_queryset = posts_queryset.filter(id__in=posts_ids, is_event=False).order_by(
"id"
)
posts = []
for post in posts_queryset:
post.category = thread.category
post.thread = thread
posts.append(post)
if len(posts) != len(posts_ids):
raise PermissionDenied(
pgettext("posts api", "One or more posts to update could not be found.")
)
return posts
class BulkPatchSerializer(serializers.Serializer):
ids = serializers.ListField(
child=serializers.IntegerField(min_value=1), min_length=1
)
ops = serializers.ListField(
child=serializers.DictField(), min_length=1, max_length=10
)
def validate_ids(self, data):
settings = self.context["settings"]
limit = settings.posts_per_page + settings.posts_per_page_orphans
if len(data) > limit:
message = npgettext(
"posts api",
"No more than %(limit)s post can be updated at a single time.",
"No more than %(limit)s posts can be updated at a single time.",
limit,
)
raise serializers.ValidationError(message % {"limit": limit})
return data
| 6,000
|
Python
|
.py
| 153
| 32.27451
| 88
| 0.670466
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,083
|
patch_event.py
|
rafalp_Misago/misago/threads/api/postendpoints/patch_event.py
|
from ....acl.objectacl import add_acl_to_obj
from ....core.apipatch import ApiPatch
from ...moderation import posts as moderation
from ...permissions import allow_hide_event, allow_unhide_event
event_patch_dispatcher = ApiPatch()
def patch_acl(request, event, value):
"""useful little op that updates event acl to current state"""
if value:
add_acl_to_obj(request.user_acl, event)
return {"acl": event.acl}
return {"acl": None}
event_patch_dispatcher.add("acl", patch_acl)
def patch_is_hidden(request, event, value):
if value:
allow_hide_event(request.user_acl, event)
moderation.hide_post(request.user, event)
else:
allow_unhide_event(request.user_acl, event)
moderation.unhide_post(request.user, event)
return {"is_hidden": event.is_hidden}
event_patch_dispatcher.replace("is-hidden", patch_is_hidden)
def event_patch_endpoint(request, event):
old_is_hidden = event.is_hidden
response = event_patch_dispatcher.dispatch(request, event)
if old_is_hidden != event.is_hidden:
event.thread.synchronize()
event.thread.save()
event.category.synchronize()
event.category.save()
return response
| 1,224
|
Python
|
.py
| 30
| 35.266667
| 66
| 0.708829
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,084
|
edits.py
|
rafalp_Misago/misago/threads/api/postendpoints/edits.py
|
from django.core.exceptions import PermissionDenied
from django.db.models import F
from django.shortcuts import get_object_or_404
from django.utils import timezone
from django.utils.translation import pgettext
from rest_framework.response import Response
from ....acl.objectacl import add_acl_to_obj
from ....core.shortcuts import get_int_or_404
from ....markup import common_flavour
from ....users.online.utils import make_users_status_aware
from ...checksums import update_post_checksum
from ...serializers import PostEditSerializer, PostSerializer
def get_edit_endpoint(request, post):
edit = get_edit(post, request.GET.get("edit"))
data = PostEditSerializer(edit).data
try:
queryset = post.edits_record.filter(id__gt=edit.id).order_by("id")
data["next"] = queryset[:1][0].id
except IndexError:
data["next"] = None
try:
queryset = post.edits_record.filter(id__lt=edit.id).order_by("-id")
data["previous"] = queryset[:1][0].id
except IndexError:
data["previous"] = None
return Response(data)
def revert_post_endpoint(request, post):
edit = get_edit_by_pk(post, request.GET.get("edit"))
datetime = timezone.now()
post_edits = post.edits
post.edits_record.create(
category=post.category,
thread=post.thread,
edited_on=datetime,
editor=request.user,
editor_name=request.user.username,
editor_slug=request.user.slug,
edited_from=post.original,
edited_to=edit.edited_from,
)
parsing_result = common_flavour(request, post.poster, edit.edited_from)
post.original = parsing_result["original_text"]
post.parsed = parsing_result["parsed_text"]
update_post_checksum(post)
post.updated_on = datetime
post.edits = F("edits") + 1
post.last_editor = request.user
post.last_editor_name = request.user.username
post.last_editor_slug = request.user.slug
post.save()
post.is_read = True
post.is_new = False
post.edits = post_edits + 1
add_acl_to_obj(request.user_acl, post)
if post.poster:
make_users_status_aware(request, [post.poster])
return Response(PostSerializer(post, context={"user": request.user}).data)
def get_edit(post, pk=None):
if pk is not None:
return get_edit_by_pk(post, pk)
edit = post.edits_record.first()
if not edit:
raise PermissionDenied(
pgettext("posts api", "This post has no changes history.")
)
return edit
def get_edit_by_pk(post, pk):
return get_object_or_404(post.edits_record, pk=get_int_or_404(pk))
| 2,630
|
Python
|
.py
| 68
| 33.058824
| 78
| 0.695189
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,085
|
treesmap.py
|
rafalp_Misago/misago/threads/threadtypes/treesmap.py
|
from django.utils.module_loading import import_string
from ...conf import settings
class TreesMap:
"""Object that maps trees to strategies"""
def __init__(self, types_modules):
self.is_loaded = False
self.types_modules = types_modules
def load(self):
self.types = self.load_types(self.types_modules)
self.trees = self.load_trees(self.types)
self.roots = self.get_roots(self.trees)
self.is_loaded = True
def load_types(self, types_modules):
loaded_types = {}
for path in types_modules:
type_cls = import_string(path)
loaded_types[type_cls.root_name] = type_cls()
return loaded_types
def load_trees(self, types):
from ...categories.models import Category
trees = {}
for category in Category.objects.filter(level=0, special_role__in=types.keys()):
trees[category.tree_id] = types[category.special_role]
return trees
def get_roots(self, trees):
roots = {}
for tree_id in trees:
roots[trees[tree_id].root_name] = tree_id
return roots
def get_type_for_tree_id(self, tree_id):
if not self.is_loaded:
self.load()
try:
return self.trees[tree_id]
except KeyError:
raise KeyError("'%s' tree id has no type defined" % tree_id)
def get_tree_id_for_root(self, root_name):
if not self.is_loaded:
self.load()
try:
return self.roots[root_name]
except KeyError:
raise KeyError('"%s" root has no tree defined' % root_name)
trees_map = TreesMap(settings.MISAGO_THREAD_TYPES)
| 1,698
|
Python
|
.py
| 44
| 29.795455
| 88
| 0.616229
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,086
|
thread.py
|
rafalp_Misago/misago/threads/threadtypes/thread.py
|
from django.urls import reverse
from django.utils.translation import pgettext_lazy
from . import ThreadType
from ...categories import THREADS_ROOT_NAME
class Thread(ThreadType):
root_name = THREADS_ROOT_NAME
def get_category_name(self, category):
if category.level:
return category.name
return pgettext_lazy(
"threads root category name", "None (will become top level category)"
)
def get_category_absolute_url(self, category):
if category.level:
return reverse(
"misago:category", kwargs={"id": category.id, "slug": category.slug}
)
return reverse("misago:threads")
def get_category_last_thread_url(self, category):
return reverse(
"misago:thread",
kwargs={"slug": category.last_thread_slug, "id": category.last_thread_id},
)
def get_category_last_thread_new_url(self, category):
return reverse(
"misago:thread-unread-post",
kwargs={"slug": category.last_thread_slug, "id": category.last_thread_id},
)
def get_category_last_post_url(self, category):
return reverse(
"misago:thread-last-post",
kwargs={"slug": category.last_thread_slug, "id": category.last_thread_id},
)
def get_thread_absolute_url(self, thread, page=1):
if page > 1:
return reverse(
"misago:thread",
kwargs={"slug": thread.slug, "id": thread.id, "page": page},
)
return reverse("misago:thread", kwargs={"slug": thread.slug, "id": thread.id})
def get_thread_last_post_url(self, thread):
return reverse(
"misago:thread-last-post", kwargs={"slug": thread.slug, "id": thread.pk}
)
def get_thread_new_post_url(self, thread):
return reverse(
"misago:thread-unread-post", kwargs={"slug": thread.slug, "id": thread.pk}
)
def get_thread_best_answer_url(self, thread):
return reverse(
"misago:thread-solution-post", kwargs={"slug": thread.slug, "id": thread.pk}
)
def get_thread_unapproved_post_url(self, thread):
return reverse(
"misago:thread-unapproved-post",
kwargs={"slug": thread.slug, "id": thread.pk},
)
def get_thread_api_url(self, thread):
return reverse("misago:api:thread-detail", kwargs={"pk": thread.pk})
def get_thread_editor_api_url(self, thread):
return reverse("misago:api:thread-post-editor", kwargs={"thread_pk": thread.pk})
def get_thread_merge_api_url(self, thread):
return reverse("misago:api:thread-merge", kwargs={"pk": thread.pk})
def get_thread_poll_api_url(self, thread):
return reverse("misago:api:thread-poll-list", kwargs={"thread_pk": thread.pk})
def get_thread_watch_api_url(self, thread):
return reverse("misago:apiv2:thread-watch", kwargs={"thread_id": thread.id})
def get_thread_posts_api_url(self, thread):
return reverse("misago:api:thread-post-list", kwargs={"thread_pk": thread.pk})
def get_poll_api_url(self, poll):
return reverse(
"misago:api:thread-poll-detail",
kwargs={"thread_pk": poll.thread_id, "pk": poll.pk},
)
def get_poll_votes_api_url(self, poll):
return reverse(
"misago:api:thread-poll-votes",
kwargs={"thread_pk": poll.thread_id, "pk": poll.pk},
)
def get_post_merge_api_url(self, thread):
return reverse("misago:api:thread-post-merge", kwargs={"thread_pk": thread.pk})
def get_post_move_api_url(self, thread):
return reverse("misago:api:thread-post-move", kwargs={"thread_pk": thread.pk})
def get_post_split_api_url(self, thread):
return reverse("misago:api:thread-post-split", kwargs={"thread_pk": thread.pk})
def get_post_absolute_url(self, post):
return reverse(
"misago:thread-post",
kwargs={"slug": post.thread.slug, "pk": post.thread.pk, "post": post.pk},
)
def get_post_api_url(self, post):
return reverse(
"misago:api:thread-post-detail",
kwargs={"thread_pk": post.thread_id, "pk": post.pk},
)
def get_post_likes_api_url(self, post):
return reverse(
"misago:api:thread-post-likes",
kwargs={"thread_pk": post.thread_id, "pk": post.pk},
)
def get_post_editor_api_url(self, post):
return reverse(
"misago:api:thread-post-editor",
kwargs={"thread_pk": post.thread_id, "pk": post.pk},
)
def get_post_edits_api_url(self, post):
return reverse(
"misago:api:thread-post-edits",
kwargs={"thread_pk": post.thread_id, "pk": post.pk},
)
| 4,859
|
Python
|
.py
| 110
| 34.890909
| 88
| 0.609368
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,087
|
__init__.py
|
rafalp_Misago/misago/threads/threadtypes/__init__.py
|
from .treesmap import trees_map
class ThreadType:
"""Abstract class for thread type strategy"""
root_name = "undefined"
def get_forum_name(self, category):
return category.name
def get_category_absolute_url(self, category):
return None
def get_category_last_thread_url(self, category):
return None
def get_category_last_post_url(self, category):
return None
def get_thread_absolute_url(self, thread, page=1):
return None
def get_thread_last_post_url(self, thread):
return None
def get_thread_new_post_url(self, thread):
return None
def get_thread_best_answer_url(self, thread):
return None
def get_thread_unapproved_post_url(self, thread):
return None
def get_thread_api_url(self, thread):
return None
def get_thread_editor_api_url(self, thread):
return None
def get_thread_merge_api_url(self, thread):
return None
def get_thread_poll_api_url(self, thread):
return None
def get_thread_watch_api_url(self, thread):
return None
def get_thread_posts_api_url(self, thread):
return None
def get_poll_api_url(self, poll):
return None
def get_poll_votes_api_url(self, poll):
return None
def get_post_merge_api_url(self, thread):
return None
def get_post_move_api_url(self, thread):
return None
def get_post_split_api_url(self, thread):
return None
def get_post_absolute_url(self, post):
return None
def get_post_api_url(self, post):
return None
def get_post_likes_api_url(self, post):
return None
def get_post_editor_api_url(self, post):
return None
def get_post_edits_api_url(self, post):
return None
| 1,831
|
Python
|
.py
| 54
| 26.685185
| 54
| 0.655232
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,088
|
privatethread.py
|
rafalp_Misago/misago/threads/threadtypes/privatethread.py
|
from django.urls import reverse
from django.utils.translation import pgettext_lazy
from . import ThreadType
from ...categories import PRIVATE_THREADS_ROOT_NAME
class PrivateThread(ThreadType):
root_name = PRIVATE_THREADS_ROOT_NAME
def get_category_name(self, category):
return pgettext_lazy("private threads category name", "Private threads")
def get_category_absolute_url(self, category):
return reverse("misago:private-threads")
def get_category_last_thread_url(self, category):
return reverse(
"misago:private-thread",
kwargs={"slug": category.last_thread_slug, "id": category.last_thread_id},
)
def get_category_last_thread_new_url(self, category):
return reverse(
"misago:private-thread-unread-post",
kwargs={"slug": category.last_thread_slug, "id": category.last_thread_id},
)
def get_category_last_post_url(self, category):
return reverse(
"misago:private-thread-last-post",
kwargs={"slug": category.last_thread_slug, "id": category.last_thread_id},
)
def get_thread_absolute_url(self, thread, page=1):
if page > 1:
return reverse(
"misago:private-thread",
kwargs={"slug": thread.slug, "id": thread.id, "page": page},
)
return reverse(
"misago:private-thread", kwargs={"slug": thread.slug, "id": thread.id}
)
def get_thread_last_post_url(self, thread):
return reverse(
"misago:private-thread-last-post",
kwargs={"slug": thread.slug, "id": thread.pk},
)
def get_thread_new_post_url(self, thread):
return reverse(
"misago:private-thread-unread-post",
kwargs={"slug": thread.slug, "id": thread.pk},
)
def get_thread_api_url(self, thread):
return reverse("misago:api:private-thread-detail", kwargs={"pk": thread.pk})
def get_thread_editor_api_url(self, thread):
return reverse(
"misago:api:private-thread-post-editor", kwargs={"thread_pk": thread.pk}
)
def get_thread_posts_api_url(self, thread):
return reverse(
"misago:api:private-thread-post-list", kwargs={"thread_pk": thread.pk}
)
def get_post_merge_api_url(self, thread):
return reverse(
"misago:api:private-thread-post-merge", kwargs={"thread_pk": thread.pk}
)
def get_post_absolute_url(self, post):
return reverse(
"misago:private-thread-post",
kwargs={"slug": post.thread.slug, "pk": post.thread.pk, "post": post.pk},
)
def get_post_api_url(self, post):
return reverse(
"misago:api:private-thread-post-detail",
kwargs={"thread_pk": post.thread_id, "pk": post.pk},
)
def get_post_likes_api_url(self, post):
return reverse(
"misago:api:private-thread-post-likes",
kwargs={"thread_pk": post.thread_id, "pk": post.pk},
)
def get_post_editor_api_url(self, post):
return reverse(
"misago:api:private-thread-post-editor",
kwargs={"thread_pk": post.thread_id, "pk": post.pk},
)
def get_post_edits_api_url(self, post):
return reverse(
"misago:api:private-thread-post-edits",
kwargs={"thread_pk": post.thread_id, "pk": post.pk},
)
def get_thread_watch_api_url(self, thread):
return reverse(
"misago:apiv2:private-thread-watch", kwargs={"thread_id": thread.id}
)
| 3,640
|
Python
|
.py
| 87
| 32.494253
| 86
| 0.607193
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,089
|
test_delete_user_likes.py
|
rafalp_Misago/misago/threads/tests/test_delete_user_likes.py
|
from django.test import RequestFactory
from .. import test
from ...categories.models import Category
from ...users.test import AuthenticatedUserTestCase, create_test_user
from ..api.postendpoints.patch_post import patch_is_liked
from ..models import Post
class DeleteUserLikesTests(AuthenticatedUserTestCase):
def setUp(self):
super().setUp()
self.factory = RequestFactory()
def get_request(self, user=None):
request = self.factory.get("/customer/details")
request.user = user or self.user
request.user_ip = "127.0.0.1"
return request
def test_anonymize_user_likes(self):
"""post's last like is anonymized by user.anonymize_data"""
category = Category.objects.get(slug="first-category")
thread = test.post_thread(category)
post = test.reply_thread(thread)
post.acl = {"can_like": True}
user = create_test_user("Other_User", "otheruser@example.com")
patch_is_liked(self.get_request(self.user), post, 1)
patch_is_liked(self.get_request(user), post, 1)
user.delete_content()
last_likes = Post.objects.get(pk=post.pk).last_likes
self.assertEqual(
last_likes, [{"id": self.user.id, "username": self.user.username}]
)
| 1,290
|
Python
|
.py
| 29
| 37.344828
| 78
| 0.676259
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,090
|
conftest.py
|
rafalp_Misago/misago/threads/tests/conftest.py
|
import pytest
from ...categories.models import Category
from ...permissions.enums import CategoryPermission
from ...testutils import grant_category_group_permissions
@pytest.fixture
def notify_on_new_private_thread_mock(mocker):
return mocker.patch("misago.threads.participants.notify_on_new_private_thread")
@pytest.fixture
def notify_on_new_thread_reply_mock(mocker):
return mocker.patch(
"misago.threads.api.postingendpoint.notifications.notify_on_new_thread_reply"
)
@pytest.fixture
def child_category(default_category, guests_group, members_group, moderators_group):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
for group in (guests_group, members_group, moderators_group):
grant_category_group_permissions(
child_category,
group,
CategoryPermission.SEE,
CategoryPermission.BROWSE,
)
return child_category
@pytest.fixture
def hidden_category(root_category):
hidden_category = Category(name="Hidden Category", slug="hidden-category")
hidden_category.insert_at(root_category, position="last-child", save=True)
return hidden_category
| 1,263
|
Python
|
.py
| 29
| 38.310345
| 85
| 0.753066
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,091
|
test_post_mentions.py
|
rafalp_Misago/misago/threads/tests/test_post_mentions.py
|
from unittest.mock import patch
from django.test.client import BOUNDARY, MULTIPART_CONTENT, encode_multipart
from django.urls import reverse
from .. import test
from ...categories.models import Category
from ...markup.mentions import MENTIONS_LIMIT
from ...users.test import AuthenticatedUserTestCase, create_test_user
class PostMentionsTests(AuthenticatedUserTestCase):
def setUp(self):
super().setUp()
self.category = Category.objects.get(slug="first-category")
self.thread = test.post_thread(category=self.category)
self.post_link = reverse(
"misago:api:thread-post-list", kwargs={"thread_pk": self.thread.pk}
)
def put(self, url, data=None):
content = encode_multipart(BOUNDARY, data or {})
return self.client.put(url, content, content_type=MULTIPART_CONTENT)
@patch(
"misago.threads.api.postingendpoint.notifications.notify_on_new_thread_reply"
)
def test_mention_noone(self, notify_on_new_thread_reply_mock):
"""endpoint handles no mentions in post"""
response = self.client.post(
self.post_link, data={"post": "This is test response!"}
)
self.assertEqual(response.status_code, 200)
post = self.user.post_set.order_by("id").last()
self.assertEqual(post.mentions.count(), 0)
@patch(
"misago.threads.api.postingendpoint.notifications.notify_on_new_thread_reply"
)
def test_mention_nonexistant(self, notify_on_new_thread_reply_mock):
"""endpoint handles nonexistant mention"""
response = self.client.post(
self.post_link, data={"post": "This is test response, @InvalidUser!"}
)
self.assertEqual(response.status_code, 200)
post = self.user.post_set.order_by("id").last()
self.assertEqual(post.mentions.count(), 0)
@patch(
"misago.threads.api.postingendpoint.notifications.notify_on_new_thread_reply"
)
def test_mention_self(self, notify_on_new_thread_reply_mock):
"""endpoint mentions author"""
response = self.client.post(
self.post_link, data={"post": "This is test response, @%s!" % self.user}
)
self.assertEqual(response.status_code, 200)
post = self.user.post_set.order_by("id").last()
self.assertEqual(post.mentions.count(), 1)
self.assertEqual(post.mentions.all()[0], self.user)
@patch(
"misago.threads.api.postingendpoint.notifications.notify_on_new_thread_reply"
)
def test_mention_limit(self, notify_on_new_thread_reply_mock):
"""endpoint mentions over limit results in no mentions set"""
users = []
for i in range(MENTIONS_LIMIT + 5):
users.append(create_test_user("User%s" % i, "user%s@example.com" % i))
mentions = ["@%s" % u for u in users]
response = self.client.post(
self.post_link,
data={"post": "This is test response, %s!" % (", ".join(mentions))},
)
self.assertEqual(response.status_code, 200)
post = self.user.post_set.order_by("id").last()
self.assertEqual(post.mentions.count(), 0)
@patch(
"misago.threads.api.postingendpoint.notifications.notify_on_new_thread_reply"
)
def test_mention_update(self, notify_on_new_thread_reply_mock):
"""edit post endpoint updates mentions"""
user = create_test_user("User", "user@example.com")
other_user = create_test_user("Other_User", "otheruser@example.com")
response = self.client.post(
self.post_link, data={"post": "This is test response, @%s!" % user}
)
self.assertEqual(response.status_code, 200)
post = self.user.post_set.order_by("id").last()
self.assertEqual(post.mentions.count(), 1)
self.assertEqual(post.mentions.order_by("id")[0], user)
# add mention to post
edit_link = reverse(
"misago:api:thread-post-detail",
kwargs={"thread_pk": self.thread.pk, "pk": post.pk},
)
response = self.put(
edit_link,
data={"post": "This is test response, @%s and @%s!" % (user, other_user)},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(post.mentions.count(), 2)
self.assertEqual(list(post.mentions.order_by("id")), [user, other_user])
# remove first mention from post - should preserve mentions
response = self.put(
edit_link, data={"post": "This is test response, @%s!" % other_user}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(post.mentions.count(), 2)
self.assertEqual(list(post.mentions.order_by("id")), [user, other_user])
# remove mentions from post - should preserve mentions
response = self.put(edit_link, data={"post": "This is test response!"})
self.assertEqual(response.status_code, 200)
self.assertEqual(post.mentions.count(), 2)
self.assertEqual(list(post.mentions.order_by("id")), [user, other_user])
@patch(
"misago.threads.api.postingendpoint.notifications.notify_on_new_thread_reply"
)
def test_mentions_merge(self, notify_on_new_thread_reply_mock):
"""posts merge sums mentions"""
user = create_test_user("User1", "user1@example.com")
other_user = create_test_user("User2", "user2@example.com")
response = self.client.post(
self.post_link, data={"post": "This is test response, @%s!" % user}
)
self.assertEqual(response.status_code, 200)
post_a = self.user.post_set.order_by("id").last()
self.assertEqual(post_a.mentions.count(), 1)
self.assertEqual(list(post_a.mentions.all()), [user])
# post second reply
self.user.last_post_on = None
self.user.save()
response = self.client.post(
self.post_link,
data={"post": "This is test response, @%s and @%s!" % (user, other_user)},
)
self.assertEqual(response.status_code, 200)
post_b = self.user.post_set.order_by("id").last()
# merge posts and validate that post A has all mentions
post_b.merge(post_a)
self.assertEqual(post_a.mentions.count(), 2)
self.assertEqual(list(post_a.mentions.order_by("id")), [user, other_user])
| 6,405
|
Python
|
.py
| 133
| 39.466165
| 86
| 0.638216
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,092
|
test_events.py
|
rafalp_Misago/misago/threads/tests/test_events.py
|
from unittest.mock import Mock
from django.test import TestCase
from django.utils import timezone
from ...acl import useracl
from ...acl.objectacl import add_acl_to_obj
from ...categories.models import Category
from ...conftest import get_cache_versions
from ...users.test import create_test_user
from ..events import record_event
from ..models import Thread
cache_versions = get_cache_versions()
class EventsApiTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com")
datetime = timezone.now()
self.category = Category.objects.all_categories()[:1][0]
self.thread = Thread(
category=self.category,
started_on=datetime,
starter_name="Tester",
starter_slug="tester",
last_post_on=datetime,
last_poster_name="Tester",
last_poster_slug="tester",
)
self.thread.set_title("Test thread")
self.thread.save()
user_acl = useracl.get_user_acl(self.user, cache_versions)
add_acl_to_obj(user_acl, self.category)
add_acl_to_obj(user_acl, self.thread)
def test_record_event_with_context(self):
"""record_event registers event with context in thread"""
request = Mock(user=self.user, user_ip="123.14.15.222")
context = {"user": "Lorem ipsum"}
event = record_event(request, self.thread, "announcement", context)
event_post = self.thread.post_set.order_by("-id")[:1][0]
self.assertEqual(self.thread.last_post, event_post)
self.assertTrue(self.thread.has_events)
self.assertTrue(self.thread.last_post_is_event)
self.assertEqual(event.pk, event_post.pk)
self.assertTrue(event_post.is_event)
self.assertEqual(event_post.event_type, "announcement")
self.assertEqual(event_post.event_context, context)
self.assertEqual(event_post.poster_id, request.user.pk)
| 1,957
|
Python
|
.py
| 44
| 36.931818
| 75
| 0.673856
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,093
|
test_threads_editor_api.py
|
rafalp_Misago/misago/threads/tests/test_threads_editor_api.py
|
import os
from django.urls import reverse
from .. import test
from ...acl import useracl
from ...acl.objectacl import add_acl_to_obj
from ...categories.models import Category
from ...conftest import get_cache_versions
from ...users.test import AuthenticatedUserTestCase
from ..models import Attachment
from ..serializers import AttachmentSerializer
from ..test import patch_category_acl
TESTFILES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "testfiles")
TEST_DOCUMENT_PATH = os.path.join(TESTFILES_DIR, "document.pdf")
cache_versions = get_cache_versions()
class EditorApiTestCase(AuthenticatedUserTestCase):
def setUp(self):
super().setUp()
self.category = Category.objects.get(slug="first-category")
class ThreadPostEditorApiTests(EditorApiTestCase):
def setUp(self):
super().setUp()
self.api_link = reverse("misago:api:thread-editor")
def test_anonymous_user_request(self):
"""endpoint validates if user is authenticated"""
self.logout_user()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You need to be signed in to start threads."}
)
@patch_category_acl({"can_browse": False})
def test_category_visibility_validation(self):
"""endpoint omits non-browseable categories"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{
"detail": (
"No categories that allow new threads are available "
"to you at the moment."
)
},
)
@patch_category_acl({"can_start_threads": False})
def test_category_disallowing_new_threads(self):
"""endpoint omits category disallowing starting threads"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{
"detail": (
"No categories that allow new threads are available "
"to you at the moment."
)
},
)
@patch_category_acl({"can_close_threads": False, "can_start_threads": True})
def test_category_closed_disallowing_new_threads(self):
"""endpoint omits closed category"""
self.category.is_closed = True
self.category.save()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{
"detail": (
"No categories that allow new threads are available "
"to you at the moment."
)
},
)
@patch_category_acl({"can_close_threads": True, "can_start_threads": True})
def test_category_closed_allowing_new_threads(self):
"""endpoint adds closed category that allows new threads"""
self.category.is_closed = True
self.category.save()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(
response_json[0],
{
"id": self.category.pk,
"name": self.category.name,
"level": 0,
"post": {"close": True, "hide": False, "pin": 0},
},
)
@patch_category_acl({"can_start_threads": True})
def test_category_allowing_new_threads(self):
"""endpoint adds category that allows new threads"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(
response_json[0],
{
"id": self.category.pk,
"name": self.category.name,
"level": 0,
"post": {"close": False, "hide": False, "pin": 0},
},
)
@patch_category_acl({"can_close_threads": True, "can_start_threads": True})
def test_category_allowing_closing_threads(self):
"""endpoint adds category that allows new closed threads"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(
response_json[0],
{
"id": self.category.pk,
"name": self.category.name,
"level": 0,
"post": {"close": True, "hide": False, "pin": 0},
},
)
@patch_category_acl({"can_start_threads": True, "can_pin_threads": 1})
def test_category_allowing_locally_pinned_threads(self):
"""endpoint adds category that allows locally pinned threads"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(
response_json[0],
{
"id": self.category.pk,
"name": self.category.name,
"level": 0,
"post": {"close": False, "hide": False, "pin": 1},
},
)
@patch_category_acl({"can_start_threads": True, "can_pin_threads": 2})
def test_category_allowing_globally_pinned_threads(self):
"""endpoint adds category that allows globally pinned threads"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(
response_json[0],
{
"id": self.category.pk,
"name": self.category.name,
"level": 0,
"post": {"close": False, "hide": False, "pin": 2},
},
)
@patch_category_acl({"can_start_threads": True, "can_hide_threads": 1})
def test_category_allowing_hidding_threads(self):
"""endpoint adds category that allows hiding threads"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(
response_json[0],
{
"id": self.category.pk,
"name": self.category.name,
"level": 0,
"post": {"close": 0, "hide": 1, "pin": 0},
},
)
@patch_category_acl({"can_start_threads": True, "can_hide_threads": 2})
def test_category_allowing_hidding_and_deleting_threads(self):
"""endpoint adds category that allows hiding and deleting threads"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(
response_json[0],
{
"id": self.category.pk,
"name": self.category.name,
"level": 0,
"post": {"close": False, "hide": 1, "pin": 0},
},
)
class ThreadReplyEditorApiTests(EditorApiTestCase):
def setUp(self):
super().setUp()
self.thread = test.post_thread(category=self.category)
self.api_link = reverse(
"misago:api:thread-post-editor", kwargs={"thread_pk": self.thread.pk}
)
def test_anonymous_user_request(self):
"""endpoint validates if user is authenticated"""
self.logout_user()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You have to sign in to reply threads."}
)
def test_thread_visibility(self):
"""thread's visibility is validated"""
with patch_category_acl({"can_see": False}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 404)
with patch_category_acl({"can_browse": False}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 404)
with patch_category_acl({"can_see_all_threads": False}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 404)
@patch_category_acl({"can_reply_threads": False})
def test_no_reply_permission(self):
"""permssion to reply is validated"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You can't reply to threads in this category."}
)
def test_closed_category(self):
"""permssion to reply in closed category is validated"""
self.category.is_closed = True
self.category.save()
with patch_category_acl(
{"can_reply_threads": True, "can_close_threads": False}
):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{
"detail": (
"This category is closed. You can't reply to threads in it."
)
},
)
# allow to post in closed category
with patch_category_acl({"can_reply_threads": True, "can_close_threads": True}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
def test_closed_thread(self):
"""permssion to reply in closed thread is validated"""
self.thread.is_closed = True
self.thread.save()
with patch_category_acl(
{"can_reply_threads": True, "can_close_threads": False}
):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "You can't reply to closed threads in this category."},
)
# allow to post in closed thread
with patch_category_acl({"can_reply_threads": True, "can_close_threads": True}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
@patch_category_acl({"can_reply_threads": True})
def test_allow_reply_thread(self):
"""api returns 200 code if thread reply is allowed"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
def test_reply_to_visibility(self):
"""api validates replied post visibility"""
# unapproved reply can't be replied to
unapproved_reply = test.reply_thread(self.thread, is_unapproved=True)
with patch_category_acl({"can_reply_threads": True}):
response = self.client.get(
"%s?reply=%s" % (self.api_link, unapproved_reply.pk)
)
self.assertEqual(response.status_code, 404)
# hidden reply can't be replied to
hidden_reply = test.reply_thread(self.thread, is_hidden=True)
with patch_category_acl({"can_reply_threads": True}):
response = self.client.get("%s?reply=%s" % (self.api_link, hidden_reply.pk))
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You can't reply to hidden posts."}
)
def test_reply_to_other_thread_post(self):
"""api validates is replied post belongs to same thread"""
other_thread = test.post_thread(category=self.category)
reply_to = test.reply_thread(other_thread)
response = self.client.get("%s?reply=%s" % (self.api_link, reply_to.pk))
self.assertEqual(response.status_code, 404)
@patch_category_acl({"can_reply_threads": True})
def test_reply_to_event(self):
"""events can't be replied to"""
reply_to = test.reply_thread(self.thread, is_event=True)
response = self.client.get("%s?reply=%s" % (self.api_link, reply_to.pk))
self.assertEqual(response.status_code, 403)
self.assertEqual(response.json(), {"detail": "Events can't be replied to."})
@patch_category_acl({"can_reply_threads": True})
def test_reply_to(self):
"""api includes replied to post details in response"""
reply_to = test.reply_thread(self.thread)
response = self.client.get("%s?reply=%s" % (self.api_link, reply_to.pk))
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"id": reply_to.pk,
"post": reply_to.original,
"poster": reply_to.poster_name,
},
)
class EditReplyEditorApiTests(EditorApiTestCase):
def setUp(self):
super().setUp()
self.thread = test.post_thread(category=self.category)
self.post = test.reply_thread(self.thread, poster=self.user)
self.api_link = reverse(
"misago:api:thread-post-editor",
kwargs={"thread_pk": self.thread.pk, "pk": self.post.pk},
)
def test_anonymous_user_request(self):
"""endpoint validates if user is authenticated"""
self.logout_user()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You have to sign in to edit posts."}
)
def test_thread_visibility(self):
"""thread's visibility is validated"""
with patch_category_acl({"can_see": False}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 404)
with patch_category_acl({"can_browse": False}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 404)
with patch_category_acl({"can_see_all_threads": False}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 404)
@patch_category_acl({"can_edit_posts": 0})
def test_no_edit_permission(self):
"""permssion to edit is validated"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You can't edit posts in this category."}
)
def test_closed_category(self):
"""permssion to edit in closed category is validated"""
self.category.is_closed = True
self.category.save()
with patch_category_acl({"can_edit_posts": 1, "can_close_threads": False}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "This category is closed. You can't edit posts in it."},
)
# allow to edit in closed category
with patch_category_acl({"can_edit_posts": 1, "can_close_threads": True}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
def test_closed_thread(self):
"""permssion to edit in closed thread is validated"""
self.thread.is_closed = True
self.thread.save()
with patch_category_acl({"can_edit_posts": 1, "can_close_threads": False}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "This thread is closed. You can't edit posts in it."},
)
# allow to edit in closed thread
with patch_category_acl({"can_edit_posts": 1, "can_close_threads": True}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
def test_protected_post(self):
"""permssion to edit protected post is validated"""
self.post.is_protected = True
self.post.save()
with patch_category_acl({"can_edit_posts": 1, "can_protect_posts": False}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "This post is protected. You can't edit it."},
)
# allow to post in closed thread
with patch_category_acl({"can_edit_posts": 1, "can_protect_posts": True}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
def test_post_visibility(self):
"""edited posts visibility is validated"""
self.post.is_hidden = True
self.post.save()
with patch_category_acl({"can_edit_posts": 1}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "This post is hidden, you can't edit it."}
)
# allow hidden edition
with patch_category_acl({"can_edit_posts": 1, "can_hide_posts": 1}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
# test unapproved post
self.post.is_unapproved = True
self.post.is_hidden = False
self.post.poster = None
self.post.save()
with patch_category_acl({"can_edit_posts": 2, "can_approve_content": 0}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 404)
# allow unapproved edition
with patch_category_acl({"can_edit_posts": 2, "can_approve_content": 1}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
@patch_category_acl({"can_edit_posts": 2})
def test_post_is_event(self):
"""events can't be edited"""
self.post.is_event = True
self.post.save()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(response.json(), {"detail": "Events can't be edited."})
def test_other_user_post(self):
"""api validates if other user's post can be edited"""
self.post.poster = None
self.post.save()
with patch_category_acl({"can_edit_posts": 1}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "You can't edit other users posts in this category."},
)
# allow other users post edition
with patch_category_acl({"can_edit_posts": 2}):
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
@patch_category_acl({"can_hide_threads": 1, "can_edit_posts": 2})
def test_edit_first_post_hidden(self):
"""
endpoint returns valid configuration for editor of hidden thread's first post
"""
self.thread.is_hidden = True
self.thread.save()
self.thread.first_post.is_hidden = True
self.thread.first_post.save()
api_link = reverse(
"misago:api:thread-post-editor",
kwargs={"thread_pk": self.thread.pk, "pk": self.thread.first_post.pk},
)
response = self.client.get(api_link)
self.assertEqual(response.status_code, 200)
@patch_category_acl({"can_edit_posts": 1})
def test_edit(self):
"""endpoint returns valid configuration for editor"""
with patch_category_acl({"max_attachment_size": 1000}):
for _ in range(3):
with open(TEST_DOCUMENT_PATH, "rb") as upload:
response = self.client.post(
reverse("misago:api:attachment-list"), data={"upload": upload}
)
self.assertEqual(response.status_code, 200)
attachments = list(Attachment.objects.order_by("id"))
attachments[0].uploader = None
attachments[0].save()
for attachment in attachments[:2]:
attachment.post = self.post
attachment.save()
response = self.client.get(self.api_link)
user_acl = useracl.get_user_acl(self.user, cache_versions)
for attachment in attachments:
add_acl_to_obj(user_acl, attachment)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"id": self.post.pk,
"api": self.post.get_api_url(),
"post": self.post.original,
"can_protect": False,
"is_protected": self.post.is_protected,
"poster": self.post.poster_name,
"attachments": [
AttachmentSerializer(
attachments[1], context={"user": self.user}
).data,
AttachmentSerializer(
attachments[0], context={"user": self.user}
).data,
],
},
)
| 21,657
|
Python
|
.py
| 487
| 33.535934
| 88
| 0.58955
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,094
|
test_threads_lists_polling.py
|
rafalp_Misago/misago/threads/tests/test_threads_lists_polling.py
|
from django.urls import reverse
from ...categories.models import Category
from ...conf.test import override_dynamic_settings
from ...test import assert_contains, assert_not_contains
from ..enums import ThreadsListsPolling
from ..models import ThreadParticipant
from ..test import post_thread
@override_dynamic_settings(index_view="categories")
def test_threads_list_includes_polling_if_its_not_empty(client, default_category):
thread = post_thread(default_category)
response = client.get(reverse("misago:threads"))
assert_contains(
response, reverse("misago:threads") + f"?poll_new={thread.last_post_id}"
)
@override_dynamic_settings(
index_view="categories", threads_lists_polling=ThreadsListsPolling.DISABLED
)
def test_threads_list_excludes_polling_for_guests_if_its_disabled(
client, default_category
):
post_thread(default_category)
response = client.get(reverse("misago:threads"))
assert_not_contains(response, reverse("misago:threads") + "?poll_new=")
@override_dynamic_settings(
index_view="categories", threads_lists_polling=ThreadsListsPolling.DISABLED
)
def test_threads_list_excludes_polling_for_authenticated_if_its_disabled(
user_client, default_category
):
post_thread(default_category)
response = user_client.get(reverse("misago:threads"))
assert_not_contains(response, reverse("misago:threads") + "?poll_new=")
@override_dynamic_settings(
index_view="categories", threads_lists_polling=ThreadsListsPolling.ENABLED_FOR_USERS
)
def test_threads_list_excludes_polling_for_guest_if_its_enabled_for_users(
client, default_category
):
post_thread(default_category)
response = client.get(reverse("misago:threads"))
assert_not_contains(response, reverse("misago:threads") + "?poll_new=")
@override_dynamic_settings(
index_view="categories", threads_lists_polling=ThreadsListsPolling.ENABLED_FOR_USERS
)
def test_threads_list_includes_polling_for_user_if_its_enabled_for_users(
user_client, default_category
):
thread = post_thread(default_category)
response = user_client.get(reverse("misago:threads"))
assert_contains(
response, reverse("misago:threads") + f"?poll_new={thread.last_post_id}"
)
@override_dynamic_settings(index_view="categories")
def test_threads_list_poll_returns_update_button_for_hx_request_if_there_are_new_threads(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(
reverse("misago:threads") + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 2 new or updated threads")
@override_dynamic_settings(index_view="categories")
def test_threads_list_poll_returns_update_button_for_hx_request_if_there_are_new_threads_after_thread(
client, default_category
):
thread = post_thread(default_category)
post_thread(default_category)
post_thread(default_category)
response = client.get(
reverse("misago:threads") + f"?poll_new={thread.last_post_id}",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 2 new or updated threads")
@override_dynamic_settings(index_view="categories")
def test_threads_list_poll_doesnt_return_update_button_for_hx_request_if_there_are_no_new_threads(
client, default_category
):
response = client.get(
reverse("misago:threads") + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(index_view="categories")
def test_threads_list_poll_doesnt_return_update_button_for_hx_request_if_there_are_no_new_threads_after_thread(
client, default_category
):
thread = post_thread(default_category)
response = client.get(
reverse("misago:threads") + f"?poll_new={thread.last_post_id}",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(
index_view="categories", threads_lists_polling=ThreadsListsPolling.DISABLED
)
def test_threads_list_poll_doesnt_return_update_button_for_guest_hx_request_if_polling_is_disabled(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(
reverse("misago:threads") + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(
index_view="categories", threads_lists_polling=ThreadsListsPolling.DISABLED
)
def test_threads_list_poll_doesnt_return_update_button_for_user_hx_request_if_polling_is_disabled(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(
reverse("misago:threads") + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(
index_view="categories", threads_lists_polling=ThreadsListsPolling.ENABLED_FOR_USERS
)
def test_threads_list_poll_doesnt_return_update_button_for_guest_hx_request_if_polling_is_disabled_for_anonymous(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(
reverse("misago:threads") + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(
index_view="categories", threads_lists_polling=ThreadsListsPolling.ENABLED_FOR_USERS
)
def test_threads_list_poll_returns_update_button_for_user_hx_request_if_polling_is_disabled_for_anonymous(
user_client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = user_client.get(
reverse("misago:threads") + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 2 new or updated threads")
@override_dynamic_settings(index_view="categories")
def test_threads_list_poll_doesnt_return_button_if_request_is_not_htmx(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(reverse("misago:threads") + "?poll_new=0")
assert_not_contains(response, "Show 2 new or updated threads")
@override_dynamic_settings(index_view="categories")
def test_threads_list_poll_uses_category_permissions(
client, default_category, hidden_category
):
post_thread(hidden_category)
post_thread(default_category)
response = client.get(
reverse("misago:threads") + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 1 new or updated thread")
@override_dynamic_settings(index_view="categories")
def test_threads_list_poll_raises_404_error_if_filter_is_invalid(
default_category, user, user_client
):
post_thread(default_category, title="User Thread", poster=user)
response = user_client.get(
reverse("misago:threads", kwargs={"filter": "invalid"}) + "?poll_new=0",
headers={"hx-request": "true"},
)
assert response.status_code == 404
@override_dynamic_settings(index_view="categories")
def test_threads_list_poll_filters_threads(default_category, user, user_client):
post_thread(default_category, title="User Thread", poster=user)
post_thread(default_category, title="Updated Thread")
response = user_client.get(
reverse("misago:threads", kwargs={"filter": "my"}) + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 1 new or updated thread")
def test_category_threads_list_includes_polling_if_its_not_empty(
client, default_category
):
thread = post_thread(default_category)
response = client.get(default_category.get_absolute_url())
assert_contains(
response,
default_category.get_absolute_url() + f"?poll_new={thread.last_post_id}",
)
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.DISABLED)
def test_category_threads_list_excludes_polling_for_guests_if_its_disabled(
client, default_category
):
post_thread(default_category)
response = client.get(default_category.get_absolute_url())
assert_not_contains(response, default_category.get_absolute_url() + "?poll_new=")
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.DISABLED)
def test_category_threads_list_excludes_polling_for_authenticated_if_its_disabled(
user_client, default_category
):
post_thread(default_category)
response = user_client.get(default_category.get_absolute_url())
assert_not_contains(response, default_category.get_absolute_url() + "?poll_new=")
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.ENABLED_FOR_USERS)
def test_category_threads_list_excludes_polling_for_guest_if_its_enabled_for_users(
client, default_category
):
post_thread(default_category)
response = client.get(default_category.get_absolute_url())
assert_not_contains(response, default_category.get_absolute_url() + "?poll_new=")
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.ENABLED_FOR_USERS)
def test_category_threads_list_includes_polling_for_user_if_its_enabled_for_users(
user_client, default_category
):
thread = post_thread(default_category)
response = user_client.get(default_category.get_absolute_url())
assert_contains(
response,
default_category.get_absolute_url() + f"?poll_new={thread.last_post_id}",
)
def test_category_threads_list_poll_returns_update_button_for_hx_request_if_there_are_new_threads(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(
default_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 2 new or updated threads")
def test_category_threads_list_poll_returns_update_button_for_hx_request_if_there_are_new_threads_after_thread(
client, default_category
):
thread = post_thread(default_category)
post_thread(default_category)
post_thread(default_category)
response = client.get(
default_category.get_absolute_url() + f"?poll_new={thread.last_post_id}",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 2 new or updated threads")
def test_category_threads_list_poll_doesnt_return_update_button_for_hx_request_if_there_are_no_new_threads(
client, default_category
):
response = client.get(
default_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
def test_category_threads_list_poll_doesnt_return_update_button_for_hx_request_if_there_are_no_new_threads_after_thread(
client, default_category
):
thread = post_thread(default_category)
response = client.get(
default_category.get_absolute_url() + f"?poll_new={thread.last_post_id}",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.DISABLED)
def test_category_threads_list_poll_doesnt_return_update_button_for_guest_hx_request_if_polling_is_disabled(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(
default_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.DISABLED)
def test_category_threads_list_poll_doesnt_return_update_button_for_user_hx_request_if_polling_is_disabled(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(
default_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.ENABLED_FOR_USERS)
def test_category_threads_list_poll_doesnt_return_update_button_for_guest_hx_request_if_polling_is_disabled_for_anonymous(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(
default_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.ENABLED_FOR_USERS)
def test_category_threads_list_poll_returns_update_button_for_user_hx_request_if_polling_is_disabled_for_anonymous(
user_client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = user_client.get(
default_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 2 new or updated threads")
def test_category_threads_list_poll_doesnt_return_button_if_request_is_not_htmx(
client, default_category
):
post_thread(default_category)
post_thread(default_category)
response = client.get(default_category.get_absolute_url() + "?poll_new=0")
assert_not_contains(response, "Show 2 new or updated threads")
def test_category_threads_list_poll_uses_category_permissions(client, default_category):
post_thread(default_category)
category = Category(name="Hidden Child", slug="hidden-child")
category.insert_at(default_category, position="last-child", save=True)
response = client.get(
default_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 1 new or updated thread")
def test_category_threads_list_poll_raises_404_error_if_filter_is_invalid(
default_category, user, user_client
):
post_thread(default_category, title="User Thread", poster=user)
response = user_client.get(
reverse(
"misago:category",
kwargs={
"id": default_category.id,
"slug": default_category.slug,
"filter": "invalid",
},
)
+ "?poll_new=0",
headers={"hx-request": "true"},
)
assert response.status_code == 404
def test_category_threads_list_poll_filters_threads(
default_category, user, user_client
):
post_thread(default_category, title="User Thread", poster=user)
post_thread(default_category, title="Other Thread")
response = user_client.get(
reverse(
"misago:category",
kwargs={
"id": default_category.id,
"slug": default_category.slug,
"filter": "my",
},
)
+ "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 1 new or updated thread")
def test_private_threads_list_includes_polling_if_its_not_empty(
user, user_client, private_threads_category
):
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(thread=thread, user=user)
response = user_client.get(private_threads_category.get_absolute_url())
assert_contains(
response,
private_threads_category.get_absolute_url()
+ f"?poll_new={thread.last_post_id}",
)
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.DISABLED)
def test_private_threads_list_excludes_polling_if_its_disabled(
user, user_client, private_threads_category
):
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(thread=thread, user=user)
response = user_client.get(private_threads_category.get_absolute_url())
assert_not_contains(
response, private_threads_category.get_absolute_url() + "?poll_new="
)
def test_private_threads_list_poll_returns_update_button_for_hx_request_if_there_are_new_threads(
user, user_client, private_threads_category
):
thread_1 = post_thread(private_threads_category)
ThreadParticipant.objects.create(thread=thread_1, user=user)
thread_2 = post_thread(private_threads_category)
ThreadParticipant.objects.create(thread=thread_2, user=user)
response = user_client.get(
private_threads_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 2 new or updated threads")
def test_private_threads_list_poll_returns_update_button_for_hx_request_if_there_are_new_threads_after_thread(
user, user_client, private_threads_category
):
threads = [
post_thread(private_threads_category),
post_thread(private_threads_category),
post_thread(private_threads_category),
]
for thread in threads:
ThreadParticipant.objects.create(thread=thread, user=user)
response = user_client.get(
private_threads_category.get_absolute_url()
+ f"?poll_new={threads[0].last_post_id}",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 2 new or updated threads")
def test_private_threads_list_poll_doesnt_return_update_button_for_hx_request_if_there_are_no_new_threads(
user_client, private_threads_category
):
response = user_client.get(
private_threads_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
def test_private_threads_list_poll_doesnt_return_update_button_for_hx_request_if_there_are_no_new_threads_after_thread(
user, user_client, private_threads_category
):
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(thread=thread, user=user)
response = user_client.get(
private_threads_category.get_absolute_url()
+ f"?poll_new={thread.last_post_id}",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
@override_dynamic_settings(threads_lists_polling=ThreadsListsPolling.DISABLED)
def test_private_threads_list_poll_doesnt_return_update_button_if_polling_is_disabled(
user, user_client, private_threads_category
):
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(thread=thread, user=user)
response = user_client.get(
private_threads_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
def test_private_threads_list_poll_doesnt_return_button_if_request_is_not_htmx(
user, user_client, private_threads_category
):
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(thread=thread, user=user)
response = user_client.get(
private_threads_category.get_absolute_url() + "?poll_new=0"
)
assert_not_contains(response, "new or updated thread")
def test_private_threads_list_poll_shows_error_to_users_without_permission(
user_client, private_threads_category, members_group
):
members_group.can_use_private_threads = False
members_group.save()
response = user_client.get(
private_threads_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "You can't use private threads.", status_code=403)
def test_private_threads_list_poll_doesnt_return_button_if_new_threads_are_not_visible(
user_client, private_threads_category, other_user
):
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(thread=thread, user=other_user)
response = user_client.get(
private_threads_category.get_absolute_url() + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_not_contains(response, "new or updated thread")
def test_private_threads_list_poll_raises_404_error_if_filter_is_invalid(
private_threads_category, user, user_client
):
thread = post_thread(private_threads_category, title="User Thread", poster=user)
ThreadParticipant.objects.create(thread=thread, user=user)
response = user_client.get(
reverse("misago:private-threads", kwargs={"filter": "invalid"}) + "?poll_new=0",
headers={"hx-request": "true"},
)
assert response.status_code == 404
def test_private_threads_list_poll_filters_threads(
private_threads_category, user, user_client
):
visible_thread = post_thread(
private_threads_category, title="User Thread", poster=user
)
hidden_thread = post_thread(private_threads_category, title="Other Thread")
ThreadParticipant.objects.create(thread=visible_thread, user=user)
ThreadParticipant.objects.create(thread=hidden_thread, user=user)
response = user_client.get(
reverse("misago:private-threads", kwargs={"filter": "my"}) + "?poll_new=0",
headers={"hx-request": "true"},
)
assert_contains(response, "Show 1 new or updated thread")
| 21,307
|
Python
|
.py
| 489
| 38.433538
| 122
| 0.722077
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,095
|
test_thread_pollvotes_api.py
|
rafalp_Misago/misago/threads/tests/test_thread_pollvotes_api.py
|
from datetime import timedelta
from django.contrib.auth import get_user_model
from django.urls import reverse
from django.utils import timezone
from ...acl.test import patch_user_acl
from ..models import Poll
from ..test import patch_category_acl
from .test_thread_poll_api import ThreadPollApiTestCase
User = get_user_model()
class ThreadGetVotesTests(ThreadPollApiTestCase):
def setUp(self):
super().setUp()
self.mock_poll()
self.poll.is_public = True
self.poll.save()
self.api_link = reverse(
"misago:api:thread-poll-votes",
kwargs={"thread_pk": self.thread.pk, "pk": self.poll.pk},
)
def test_anonymous(self):
"""api allows guests to get poll votes"""
self.logout_user()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
def test_invalid_thread_id(self):
"""api validates that thread id is integer"""
api_link = reverse(
"misago:api:thread-poll-votes",
kwargs={"thread_pk": "kjha6dsa687sa", "pk": self.poll.pk},
)
response = self.client.get(api_link)
self.assertEqual(response.status_code, 404)
def test_nonexistant_thread_id(self):
"""api validates that thread exists"""
api_link = reverse(
"misago:api:thread-poll-votes",
kwargs={"thread_pk": self.thread.pk + 1, "pk": self.poll.pk},
)
response = self.client.get(api_link)
self.assertEqual(response.status_code, 404)
def test_invalid_poll_id(self):
"""api validates that poll id is integer"""
api_link = reverse(
"misago:api:thread-poll-votes",
kwargs={"thread_pk": self.thread.pk, "pk": "sad98as7d97sa98"},
)
response = self.client.get(api_link)
self.assertEqual(response.status_code, 404)
def test_nonexistant_poll_id(self):
"""api validates that poll exists"""
api_link = reverse(
"misago:api:thread-poll-votes",
kwargs={"thread_pk": self.thread.pk, "pk": self.poll.pk + 123},
)
response = self.client.get(api_link)
self.assertEqual(response.status_code, 404)
@patch_user_acl({"can_always_see_poll_voters": False})
def test_no_permission(self):
"""api chcecks permission to see poll voters"""
self.poll.is_public = False
self.poll.save()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
def test_nonpublic_poll(self):
"""api validates that poll is public"""
self.logout_user()
self.poll.is_public = False
self.poll.save()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 403)
def test_get_votes(self):
"""api returns list of voters"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(len(response_json), 4)
self.assertEqual(
[c["label"] for c in response_json], ["Alpha", "Beta", "Gamma", "Delta"]
)
self.assertEqual([c["votes"] for c in response_json], [1, 0, 2, 1])
self.assertEqual([len(c["voters"]) for c in response_json], [1, 0, 2, 1])
self.assertEqual(
[[v["username"] for v in c["voters"]] for c in response_json][0][0], "User"
)
user = User.objects.get(slug="user")
self.assertEqual(
[[v["url"] for v in c["voters"]] for c in response_json][0][0],
user.get_absolute_url(),
)
@patch_user_acl({"can_always_see_poll_voters": True})
def test_get_votes_private_poll(self):
"""api returns list of voters on private poll for user with permission"""
self.poll.is_public = False
self.poll.save()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(len(response_json), 4)
self.assertEqual(
[c["label"] for c in response_json], ["Alpha", "Beta", "Gamma", "Delta"]
)
self.assertEqual([c["votes"] for c in response_json], [1, 0, 2, 1])
self.assertEqual([len(c["voters"]) for c in response_json], [1, 0, 2, 1])
self.assertEqual(
[[v["username"] for v in c["voters"]] for c in response_json][0][0], "User"
)
user = User.objects.get(slug="user")
self.assertEqual(
[[v["url"] for v in c["voters"]] for c in response_json][0][0],
user.get_absolute_url(),
)
class ThreadPostVotesTests(ThreadPollApiTestCase):
def setUp(self):
super().setUp()
self.mock_poll()
self.api_link = reverse(
"misago:api:thread-poll-votes",
kwargs={"thread_pk": self.thread.pk, "pk": self.poll.pk},
)
def delete_user_votes(self):
self.poll.choices[2]["votes"] = 1
self.poll.choices[3]["votes"] = 0
self.poll.votes = 2
self.poll.save()
self.poll.pollvote_set.filter(voter=self.user).delete()
def test_anonymous(self):
"""api requires you to sign in to vote in poll"""
self.logout_user()
response = self.post(self.api_link)
self.assertEqual(response.status_code, 403)
def test_empty_vote_json(self):
"""api validates if vote that user has made was empty"""
self.delete_user_votes()
response = self.client.post(
self.api_link, "[]", content_type="application/json"
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "You have to make a choice."})
def test_empty_vote_form(self):
"""api validates if vote that user has made was empty"""
self.delete_user_votes()
response = self.client.post(self.api_link)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "You have to make a choice."})
def test_malformed_vote(self):
"""api validates if vote that user has made was correctly structured"""
self.delete_user_votes()
response = self.post(self.api_link)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": 'Expected a list of items but got type "dict".'}
)
response = self.post(self.api_link, data={})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": 'Expected a list of items but got type "dict".'}
)
response = self.post(self.api_link, data="hello")
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": 'Expected a list of items but got type "str".'}
)
response = self.post(self.api_link, data=123)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": 'Expected a list of items but got type "int".'}
)
def test_invalid_choices(self):
"""api validates if vote that user has made overlaps with allowed votes"""
self.delete_user_votes()
response = self.post(self.api_link, data=["lorem", "ipsum"])
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": "One or more of poll choices were invalid."}
)
def test_too_many_choices(self):
"""api validates if vote that user has made overlaps with allowed votes"""
self.poll.allowed_choices = 1
self.poll.allow_revotes = True
self.poll.save()
response = self.post(self.api_link, data=["aaaaaaaaaaaa", "bbbbbbbbbbbb"])
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"detail": "This poll disallows voting for more than 1 choice."},
)
def test_revote(self):
"""
api validates if user is trying to change vote in poll that disallows revoting
"""
response = self.post(self.api_link, data=["lorem", "ipsum"])
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You have already voted in this poll."}
)
self.delete_user_votes()
response = self.post(self.api_link)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": 'Expected a list of items but got type "dict".'}
)
@patch_category_acl({"can_close_threads": False})
def test_vote_in_closed_thread_no_permission(self):
"""api validates is user has permission to vote poll in closed thread"""
self.thread.is_closed = True
self.thread.save()
self.delete_user_votes()
response = self.post(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "This thread is closed. You can't vote in it."}
)
@patch_category_acl({"can_close_threads": True})
def test_vote_in_closed_thread(self):
"""api validates is user has permission to vote poll in closed thread"""
self.thread.is_closed = True
self.thread.save()
self.delete_user_votes()
response = self.post(self.api_link)
self.assertEqual(response.status_code, 400)
@patch_category_acl({"can_close_threads": False})
def test_vote_in_closed_category_no_permission(self):
"""api validates is user has permission to vote poll in closed category"""
self.category.is_closed = True
self.category.save()
self.delete_user_votes()
response = self.post(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "This category is closed. You can't vote in it."},
)
@patch_category_acl({"can_close_threads": True})
def test_vote_in_closed_category(self):
"""api validates is user has permission to vote poll in closed category"""
self.category.is_closed = True
self.category.save()
self.delete_user_votes()
response = self.post(self.api_link)
self.assertEqual(response.status_code, 400)
def test_vote_in_finished_poll(self):
"""api valdiates if poll has finished before letting user to vote in it"""
self.poll.posted_on = timezone.now() - timedelta(days=15)
self.poll.length = 5
self.poll.save()
self.delete_user_votes()
response = self.post(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "This poll is over. You can't vote in it."}
)
self.poll.length = 50
self.poll.save()
response = self.post(self.api_link)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": 'Expected a list of items but got type "dict".'}
)
def test_fresh_vote(self):
"""api handles first vote in poll"""
self.delete_user_votes()
response = self.post(self.api_link, data=["aaaaaaaaaaaa", "bbbbbbbbbbbb"])
self.assertEqual(response.status_code, 200)
# validate state change
poll = Poll.objects.get(pk=self.poll.pk)
self.assertEqual(poll.votes, 4)
self.assertEqual([c["votes"] for c in poll.choices], [2, 1, 1, 0])
for choice in poll.choices:
self.assertNotIn("selected", choice)
self.assertEqual(poll.pollvote_set.count(), 4)
# validate response json
response_json = response.json()
self.assertEqual(response_json["votes"], 4)
self.assertEqual([c["votes"] for c in response_json["choices"]], [2, 1, 1, 0])
self.assertEqual(
[c["selected"] for c in response_json["choices"]],
[True, True, False, False],
)
self.assertFalse(response_json["acl"]["can_vote"])
def test_vote_change(self):
"""api handles vote change"""
self.poll.allow_revotes = True
self.poll.save()
response = self.post(self.api_link, data=["aaaaaaaaaaaa", "bbbbbbbbbbbb"])
self.assertEqual(response.status_code, 200)
# validate state change
poll = Poll.objects.get(pk=self.poll.pk)
self.assertEqual(poll.votes, 4)
self.assertEqual([c["votes"] for c in poll.choices], [2, 1, 1, 0])
for choice in poll.choices:
self.assertNotIn("selected", choice)
self.assertEqual(poll.pollvote_set.count(), 4)
# validate response json
response_json = response.json()
self.assertEqual(response_json["votes"], 4)
self.assertEqual([c["votes"] for c in response_json["choices"]], [2, 1, 1, 0])
self.assertEqual(
[c["selected"] for c in response_json["choices"]],
[True, True, False, False],
)
self.assertTrue(response_json["acl"]["can_vote"])
| 13,375
|
Python
|
.py
| 301
| 35.305648
| 88
| 0.615651
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,096
|
test_thread_replies_paginator.py
|
rafalp_Misago/misago/threads/tests/test_thread_replies_paginator.py
|
from ..paginator import ThreadRepliesPaginator
from ..test import reply_thread
def test_thread_replies_paginator_counts_pages_without_orphans(thread):
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 1
assert paginator.num_pages == 1
# Fill in first page
for i in range(4):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 2 + i
assert paginator.num_pages == 1
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 5
assert paginator.num_pages == 1
# Fill in second page
for i in range(5):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 6 + i
assert paginator.num_pages == 2
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 10
assert paginator.num_pages == 2
# Fill in third page
for i in range(5):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 11 + i
assert paginator.num_pages == 3
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 15
assert paginator.num_pages == 3
def test_thread_replies_paginator_counts_pages_with_orphans(thread):
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 1
assert paginator.num_pages == 1
# Fill in first page
for i in range(4):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 2 + i
assert paginator.num_pages == 1
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 5
assert paginator.num_pages == 1
# Add orphans
for i in range(2):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 6 + i
assert paginator.num_pages == 1
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 7
assert paginator.num_pages == 1
# Orphans + 1 produces new page
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 8
assert paginator.num_pages == 2
# Fill in second page
for i in range(2):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 9 + i
assert paginator.num_pages == 2
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 10
assert paginator.num_pages == 2
# Add orphans
for i in range(2):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 11 + i
assert paginator.num_pages == 2
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 12
assert paginator.num_pages == 2
# Orphans + 1 produces new page
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 13
assert paginator.num_pages == 3
def test_thread_replies_paginator_without_orphans_calculates_item_page(thread):
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
# First item page
assert paginator.get_item_page(0) == 1
# First page items
for i in range(4):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.get_item_page(i) == 1
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 5
assert paginator.num_pages == 1
# Second page items
for i in range(5):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.get_item_page(5 + i) == 2
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 10
assert paginator.num_pages == 2
# Third page items
for i in range(5):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.get_item_page(10 + i) == 3
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 15
assert paginator.num_pages == 3
def test_thread_replies_paginator_with_orphans_calculates_item_page(thread):
paginator = ThreadRepliesPaginator(thread.post_set, 5, 3)
# First item page
assert paginator.get_item_page(0) == 1
# First page items
for i in range(4):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.get_item_page(i) == 1
paginator = ThreadRepliesPaginator(thread.post_set, 5, 0)
assert paginator.count == 5
assert paginator.num_pages == 1
# Add orphans
for i in range(2):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.get_item_page(i) == 1
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 7
assert paginator.num_pages == 1
# Orphans + 1 produces second page
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 8
assert paginator.num_pages == 2
# Item offsets changed when orphans were moved to second page
for i in range(8):
if i < 5:
assert paginator.get_item_page(i) == 1
else:
assert paginator.get_item_page(i) == 2
# Fill in second page items
for i in range(2):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.get_item_page(9 + i) == 2
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 10
assert paginator.num_pages == 2
# Add orphans to second page
for i in range(2):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.get_item_page(11 + i) == 2
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 12
assert paginator.num_pages == 2
# Orphans + 1 produces third page
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 13
assert paginator.num_pages == 3
for i in range(13):
if i < 5:
assert paginator.get_item_page(i) == 1
elif i < 10:
assert paginator.get_item_page(i) == 2
else:
assert paginator.get_item_page(i) == 3
# Fill in third page
for i in range(2):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.get_item_page(14 + i) == 3
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 15
assert paginator.num_pages == 3
# Add orphans to third page
for i in range(2):
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.get_item_page(16 + i) == 3
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 17
assert paginator.num_pages == 3
for i in range(17):
if i < 5:
assert paginator.get_item_page(i) == 1
elif i < 10:
assert paginator.get_item_page(i) == 2
else:
assert paginator.get_item_page(i) == 3
# Orphans + 1 produces four page
reply_thread(thread)
paginator = ThreadRepliesPaginator(thread.post_set, 5, 2)
assert paginator.count == 18
assert paginator.num_pages == 4
for i in range(18):
if i < 5:
assert paginator.get_item_page(i) == 1
elif i < 10:
assert paginator.get_item_page(i) == 2
elif i < 15:
assert paginator.get_item_page(i) == 3
else:
assert paginator.get_item_page(i) == 4
| 8,278
|
Python
|
.py
| 207
| 33.101449
| 79
| 0.66409
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,097
|
test_thread_replies_view.py
|
rafalp_Misago/misago/threads/tests/test_thread_replies_view.py
|
from django.urls import reverse
from ...permissions.models import Moderator, CategoryGroupPermission
from ...test import assert_contains, assert_not_contains
def test_thread_replies_view_shows_error_on_missing_permission(
guests_group, client, thread, post
):
CategoryGroupPermission.objects.filter(group=guests_group).delete()
response = client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug})
)
assert_not_contains(response, thread.title, status_code=404)
def test_thread_replies_view_filters_posts_using_user_permissions(
client, thread, post, unapproved_reply
):
response = client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug})
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
assert_not_contains(response, unapproved_reply.parsed)
def test_thread_replies_view_redirects_if_slug_is_invalid(moderator_client, thread):
response = moderator_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": "invalid"}),
)
assert response.status_code == 301
assert response["location"] == reverse(
"misago:thread", kwargs={"id": thread.id, "slug": thread.slug}
)
def test_thread_replies_view_ignores_invalid_slug_in_htmx(
moderator_client, thread, post
):
response = moderator_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": "invalid"}),
headers={"hx-request": "true"},
)
assert_contains(response, post.parsed)
def test_thread_replies_view_redirects_to_last_page_if_page_number_is_too_large(
moderator_client, thread
):
response = moderator_client.get(
reverse(
"misago:thread", kwargs={"id": thread.id, "slug": thread.slug, "page": 1000}
),
)
assert response.status_code == 302
assert response["location"] == reverse(
"misago:thread", kwargs={"id": thread.id, "slug": thread.slug}
)
def test_thread_replies_view_shows_last_page_if_page_number_is_too_large_in_htmx(
moderator_client, thread, post
):
response = moderator_client.get(
reverse(
"misago:thread", kwargs={"id": thread.id, "slug": thread.slug, "page": 1000}
),
headers={"hx-request": "true"},
)
assert_contains(response, post.parsed)
def test_thread_replies_view_shows_to_anonymous_user(client, thread, post):
response = client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug})
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
def test_thread_replies_view_shows_to_user(user_client, thread, post):
response = user_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug})
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
def test_thread_replies_view_shows_to_category_moderator(
default_category, user, user_client, thread, post
):
Moderator.objects.create(
categories=[default_category.id],
user=user,
is_global=False,
)
response = user_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug})
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
def test_thread_replies_view_shows_to_global_moderator(moderator_client, thread, post):
response = moderator_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug})
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
def test_thread_replies_view_shows_to_anonymous_user_in_htmx(client, thread, post):
response = client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug}),
headers={"hx-request": "true"},
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
def test_thread_replies_view_shows_to_user_in_htmx(user_client, thread, post):
response = user_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug}),
headers={"hx-request": "true"},
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
def test_thread_replies_view_shows_to_category_moderator_in_htmx(
default_category, user, user_client, thread, post
):
Moderator.objects.create(
categories=[default_category.id],
user=user,
is_global=False,
)
response = user_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug}),
headers={"hx-request": "true"},
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
def test_thread_replies_view_shows_to_global_moderator_in_htmx(
moderator_client, thread, post
):
response = moderator_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug}),
headers={"hx-request": "true"},
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
def test_thread_replies_view_shows_anonymous_unapproved_reply_to_category_moderator(
default_category, user, user_client, thread, post, unapproved_reply
):
Moderator.objects.create(
categories=[default_category.id],
user=user,
is_global=False,
)
response = user_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug}),
headers={"hx-request": "true"},
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
assert_contains(response, unapproved_reply.parsed)
def test_thread_replies_view_shows_anonymous_unapproved_reply_to_global_moderator(
moderator_client, thread, post, unapproved_reply
):
response = moderator_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug}),
headers={"hx-request": "true"},
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
assert_contains(response, unapproved_reply.parsed)
def test_thread_replies_view_shows_other_users_unapproved_reply_to_category_moderator(
default_category, user, user_client, thread, post, other_user_unapproved_reply
):
Moderator.objects.create(
categories=[default_category.id],
user=user,
is_global=False,
)
response = user_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug}),
headers={"hx-request": "true"},
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
assert_contains(response, other_user_unapproved_reply.parsed)
def test_thread_replies_view_shows_other_users_unapproved_reply_to_global_moderator(
moderator_client, thread, post, other_user_unapproved_reply
):
response = moderator_client.get(
reverse("misago:thread", kwargs={"id": thread.id, "slug": thread.slug}),
headers={"hx-request": "true"},
)
assert_contains(response, thread.title)
assert_contains(response, post.parsed)
assert_contains(response, other_user_unapproved_reply.parsed)
def test_thread_replies_view_shows_error_if_private_thread_is_accessed(
user_client, user_private_thread
):
response = user_client.get(
reverse(
"misago:thread",
kwargs={"id": user_private_thread.id, "slug": user_private_thread.slug},
),
)
assert_not_contains(response, user_private_thread.title, status_code=404)
assert_not_contains(
response,
user_private_thread.first_post.parsed,
status_code=404,
)
| 7,776
|
Python
|
.py
| 191
| 35.020942
| 88
| 0.690625
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,098
|
test_thread_patch_api.py
|
rafalp_Misago/misago/threads/tests/test_thread_patch_api.py
|
import json
from datetime import timedelta
from django.utils import timezone
from .. import test
from ...categories.models import Category
from ..models import Thread
from ..test import patch_category_acl, patch_other_category_acl
from .test_threads_api import ThreadsApiTestCase
class ThreadPatchApiTestCase(ThreadsApiTestCase):
def patch(self, api_link, ops):
return self.client.patch(
api_link, json.dumps(ops), content_type="application/json"
)
class ThreadAddAclApiTests(ThreadPatchApiTestCase):
def test_add_acl_true(self):
"""api adds current thread's acl to response"""
response = self.patch(
self.api_link, [{"op": "add", "path": "acl", "value": True}]
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertTrue(response_json["acl"])
def test_add_acl_false(self):
"""
if value is false, api won't add acl to the response, but will set empty key
"""
response = self.patch(
self.api_link, [{"op": "add", "path": "acl", "value": False}]
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertIsNone(response_json["acl"])
class ThreadChangeTitleApiTests(ThreadPatchApiTestCase):
@patch_category_acl({"can_edit_threads": 2})
def test_change_thread_title(self):
"""api makes it possible to change thread title"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "title", "value": "Lorem ipsum change!"}],
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(response_json["title"], "Lorem ipsum change!")
thread_json = self.get_thread_json()
self.assertEqual(thread_json["title"], "Lorem ipsum change!")
@patch_category_acl({"can_edit_threads": 0})
def test_change_thread_title_no_permission(self):
"""api validates permission to change title"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "title", "value": "Lorem ipsum change!"}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "You can't edit threads in this category."
)
@patch_category_acl({"can_edit_threads": 2, "can_close_threads": 0})
def test_change_thread_title_closed_category_no_permission(self):
"""api test permission to edit thread title in closed category"""
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "title", "value": "Lorem ipsum change!"}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"This category is closed. You can't edit threads in it.",
)
@patch_category_acl({"can_edit_threads": 2, "can_close_threads": 0})
def test_change_thread_title_closed_thread_no_permission(self):
"""api test permission to edit closed thread title"""
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "title", "value": "Lorem ipsum change!"}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "This thread is closed. You can't edit it."
)
@patch_category_acl({"can_edit_threads": 1, "thread_edit_time": 1})
def test_change_thread_title_after_edit_time(self):
"""api cleans, validates and rejects too short title"""
self.thread.started_on = timezone.now() - timedelta(minutes=10)
self.thread.starter = self.user
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "title", "value": "Lorem ipsum change!"}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You can't edit threads that are older than 1 minute.",
)
@patch_category_acl({"can_edit_threads": 2})
def test_change_thread_title_invalid(self):
"""api cleans, validates and rejects too short title"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "title", "value": 12}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"Thread title should be at least 5 characters long (it has 2).",
)
class ThreadPinGloballyApiTests(ThreadPatchApiTestCase):
@patch_category_acl({"can_pin_threads": 2})
def test_pin_thread(self):
"""api makes it possible to pin globally thread"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 2}]
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(response_json["weight"], 2)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 2)
@patch_category_acl({"can_pin_threads": 2, "can_close_threads": 0})
def test_pin_thread_closed_category_no_permission(self):
"""api checks if category is closed"""
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 2}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"This category is closed. You can't change threads weights in it.",
)
@patch_category_acl({"can_pin_threads": 2, "can_close_threads": 0})
def test_pin_thread_closed_no_permission(self):
"""api checks if thread is closed"""
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 2}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"This thread is closed. You can't change its weight.",
)
@patch_category_acl({"can_pin_threads": 2})
def test_unpin_thread(self):
"""api makes it possible to unpin thread"""
self.thread.weight = 2
self.thread.save()
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 2)
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 0}]
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(response_json["weight"], 0)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 0)
@patch_category_acl({"can_pin_threads": 1})
def test_pin_thread_no_permission(self):
"""api pin thread globally with no permission fails"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 2}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You can't pin threads globally in this category.",
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 0)
@patch_category_acl({"can_pin_threads": 1})
def test_unpin_thread_no_permission(self):
"""api unpin thread with no permission fails"""
self.thread.weight = 2
self.thread.save()
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 2)
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 1}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You can't change globally pinned threads weights in this category.",
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 2)
class ThreadPinLocallyApiTests(ThreadPatchApiTestCase):
@patch_category_acl({"can_pin_threads": 1})
def test_pin_thread(self):
"""api makes it possible to pin locally thread"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 1}]
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(response_json["weight"], 1)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 1)
@patch_category_acl({"can_pin_threads": 1})
def test_unpin_thread(self):
"""api makes it possible to unpin thread"""
self.thread.weight = 1
self.thread.save()
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 1)
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 0}]
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(response_json["weight"], 0)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 0)
@patch_category_acl({"can_pin_threads": 0})
def test_pin_thread_no_permission(self):
"""api pin thread locally with no permission fails"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 1}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You can't change threads weights in this category.",
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 0)
@patch_category_acl({"can_pin_threads": 0})
def test_unpin_thread_no_permission(self):
"""api unpin thread with no permission fails"""
self.thread.weight = 1
self.thread.save()
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 1)
response = self.patch(
self.api_link, [{"op": "replace", "path": "weight", "value": 0}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You can't change threads weights in this category.",
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["weight"], 1)
class ThreadMoveApiTests(ThreadPatchApiTestCase):
def setUp(self):
super().setUp()
Category(name="Other category", slug="other-category").insert_at(
self.category, position="last-child", save=True
)
self.dst_category = Category.objects.get(slug="other-category")
@patch_other_category_acl({"can_start_threads": 2})
@patch_category_acl({"can_move_threads": True})
def test_move_thread_no_top(self):
"""api moves thread to other category, sets no top category"""
response = self.patch(
self.api_link,
[
{"op": "replace", "path": "category", "value": self.dst_category.pk},
{"op": "add", "path": "top-category", "value": self.dst_category.pk},
{"op": "replace", "path": "flatten-categories", "value": None},
],
)
self.assertEqual(response.status_code, 200)
reponse_json = response.json()
self.assertEqual(reponse_json["category"], self.dst_category.pk)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["category"]["id"], self.dst_category.pk)
@patch_other_category_acl({"can_start_threads": 2})
@patch_category_acl({"can_move_threads": True})
def test_move_thread_with_top(self):
"""api moves thread to other category, sets top"""
response = self.patch(
self.api_link,
[
{"op": "replace", "path": "category", "value": self.dst_category.pk},
{
"op": "add",
"path": "top-category",
"value": Category.objects.root_category().pk,
},
{"op": "replace", "path": "flatten-categories", "value": None},
],
)
self.assertEqual(response.status_code, 200)
reponse_json = response.json()
self.assertEqual(reponse_json["category"], self.dst_category.pk)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["category"]["id"], self.dst_category.pk)
@patch_other_category_acl({"can_start_threads": 2})
@patch_category_acl({"can_move_threads": True})
def test_move_thread_reads(self):
"""api moves thread reads together with thread"""
poststracker.save_read(self.user, self.thread.first_post)
self.assertEqual(self.user.postread_set.count(), 1)
self.user.postread_set.get(category=self.category)
response = self.patch(
self.api_link,
[
{"op": "replace", "path": "category", "value": self.dst_category.pk},
{"op": "add", "path": "top-category", "value": self.dst_category.pk},
{"op": "replace", "path": "flatten-categories", "value": None},
],
)
self.assertEqual(response.status_code, 200)
# thread read was moved to new category
postreads = self.user.postread_set.filter(post__is_event=False).order_by("id")
self.assertEqual(postreads.count(), 1)
postreads.get(category=self.dst_category)
@patch_other_category_acl({"can_start_threads": 2})
@patch_category_acl({"can_move_threads": True})
def test_move_thread_subscriptions(self):
"""api moves thread subscriptions together with thread"""
self.user.subscription_set.create(
thread=self.thread,
category=self.thread.category,
last_read_on=self.thread.last_post_on,
send_email=False,
)
self.assertEqual(self.user.subscription_set.count(), 1)
self.user.subscription_set.get(category=self.category)
response = self.patch(
self.api_link,
[
{"op": "replace", "path": "category", "value": self.dst_category.pk},
{"op": "add", "path": "top-category", "value": self.dst_category.pk},
{"op": "replace", "path": "flatten-categories", "value": None},
],
)
self.assertEqual(response.status_code, 200)
# thread read was moved to new category
self.assertEqual(self.user.subscription_set.count(), 1)
self.user.subscription_set.get(category=self.dst_category)
@patch_category_acl({"can_move_threads": False})
def test_move_thread_no_permission(self):
"""api move thread to other category with no permission fails"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "category", "value": self.dst_category.pk}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "You can't move threads in this category."
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["category"]["id"], self.category.pk)
@patch_other_category_acl({"can_close_threads": False})
@patch_category_acl({"can_move_threads": True})
def test_move_thread_closed_category_no_permission(self):
"""api move thread from closed category with no permission fails"""
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "category", "value": self.dst_category.pk}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"This category is closed. You can't move it's threads.",
)
@patch_other_category_acl({"can_close_threads": False})
@patch_category_acl({"can_move_threads": True})
def test_move_closed_thread_no_permission(self):
"""api move closed thread with no permission fails"""
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "category", "value": self.dst_category.pk}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "This thread is closed. You can't move it."
)
@patch_other_category_acl({"can_see": False})
@patch_category_acl({"can_move_threads": True})
def test_move_thread_no_category_access(self):
"""api move thread to category with no access fails"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "category", "value": self.dst_category.pk}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(response_json["detail"][0], "NOT FOUND")
thread_json = self.get_thread_json()
self.assertEqual(thread_json["category"]["id"], self.category.pk)
@patch_other_category_acl({"can_browse": False})
@patch_category_acl({"can_move_threads": True})
def test_move_thread_no_category_browse(self):
"""api move thread to category with no browsing access fails"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "category", "value": self.dst_category.pk}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
'You don\'t have permission to browse "Other category" contents.',
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["category"]["id"], self.category.pk)
@patch_other_category_acl({"can_start_threads": False})
@patch_category_acl({"can_move_threads": True})
def test_move_thread_no_category_start_threads(self):
"""api move thread to category with no posting access fails"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "category", "value": self.dst_category.pk}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You don't have permission to start new threads in this category.",
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["category"]["id"], self.category.pk)
@patch_other_category_acl({"can_start_threads": 2})
@patch_category_acl({"can_move_threads": True})
def test_move_thread_same_category(self):
"""api move thread to category it's already in fails"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "category", "value": self.thread.category_id}],
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You can't move thread to the category it's already in.",
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["category"]["id"], self.category.pk)
def test_thread_flatten_categories(self):
"""api flatten thread categories"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "flatten-categories", "value": None}],
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(response_json["category"], self.category.pk)
class ThreadCloseApiTests(ThreadPatchApiTestCase):
@patch_category_acl({"can_close_threads": True})
def test_close_thread(self):
"""api makes it possible to close thread"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-closed", "value": True}]
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertTrue(response_json["is_closed"])
thread_json = self.get_thread_json()
self.assertTrue(thread_json["is_closed"])
@patch_category_acl({"can_close_threads": True})
def test_open_thread(self):
"""api makes it possible to open thread"""
self.thread.is_closed = True
self.thread.save()
thread_json = self.get_thread_json()
self.assertTrue(thread_json["is_closed"])
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-closed", "value": False}]
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertFalse(response_json["is_closed"])
thread_json = self.get_thread_json()
self.assertFalse(thread_json["is_closed"])
@patch_category_acl({"can_close_threads": False})
def test_close_thread_no_permission(self):
"""api close thread with no permission fails"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-closed", "value": True}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You don't have permission to close this thread.",
)
thread_json = self.get_thread_json()
self.assertFalse(thread_json["is_closed"])
@patch_category_acl({"can_close_threads": False})
def test_open_thread_no_permission(self):
"""api open thread with no permission fails"""
self.thread.is_closed = True
self.thread.save()
thread_json = self.get_thread_json()
self.assertTrue(thread_json["is_closed"])
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-closed", "value": False}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "You don't have permission to open this thread."
)
thread_json = self.get_thread_json()
self.assertTrue(thread_json["is_closed"])
class ThreadApproveApiTests(ThreadPatchApiTestCase):
@patch_category_acl({"can_approve_content": True})
def test_approve_thread(self):
"""api makes it possible to approve thread"""
self.thread.first_post.is_unapproved = True
self.thread.first_post.save()
self.thread.synchronize()
self.thread.save()
self.assertTrue(self.thread.is_unapproved)
self.assertTrue(self.thread.has_unapproved_posts)
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-unapproved", "value": False}]
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertFalse(response_json["is_unapproved"])
self.assertFalse(response_json["has_unapproved_posts"])
thread_json = self.get_thread_json()
self.assertFalse(thread_json["is_unapproved"])
self.assertFalse(thread_json["has_unapproved_posts"])
thread = Thread.objects.get(pk=self.thread.pk)
self.assertFalse(thread.is_unapproved)
self.assertFalse(thread.has_unapproved_posts)
@patch_category_acl({"can_approve_content": True, "can_close_threads": False})
def test_approve_thread_category_closed_no_permission(self):
"""api checks permission for approving threads in closed categories"""
self.thread.first_post.is_unapproved = True
self.thread.first_post.save()
self.thread.synchronize()
self.thread.save()
self.assertTrue(self.thread.is_unapproved)
self.assertTrue(self.thread.has_unapproved_posts)
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-unapproved", "value": False}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"This category is closed. You can't approve threads in it.",
)
@patch_category_acl({"can_approve_content": True, "can_close_threads": False})
def test_approve_thread_closed_no_permission(self):
"""api checks permission for approving posts in closed categories"""
self.thread.first_post.is_unapproved = True
self.thread.first_post.save()
self.thread.synchronize()
self.thread.save()
self.assertTrue(self.thread.is_unapproved)
self.assertTrue(self.thread.has_unapproved_posts)
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-unapproved", "value": False}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "This thread is closed. You can't approve it."
)
@patch_category_acl({"can_approve_content": True})
def test_unapprove_thread(self):
"""api returns permission error on approval removal"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-unapproved", "value": True}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "Content approval can't be reversed."
)
class ThreadHideApiTests(ThreadPatchApiTestCase):
@patch_category_acl({"can_hide_threads": True})
def test_hide_thread(self):
"""api makes it possible to hide thread"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": True}]
)
self.assertEqual(response.status_code, 200)
reponse_json = response.json()
self.assertTrue(reponse_json["is_hidden"])
thread_json = self.get_thread_json()
self.assertTrue(thread_json["is_hidden"])
@patch_category_acl({"can_hide_threads": False})
def test_hide_thread_no_permission(self):
"""api hide thread with no permission fails"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": True}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "You can't hide threads in this category."
)
thread_json = self.get_thread_json()
self.assertFalse(thread_json["is_hidden"])
@patch_category_acl({"can_hide_threads": False, "can_hide_own_threads": True})
def test_hide_non_owned_thread(self):
"""api forbids non-moderator from hiding other users threads"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": True}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You can't hide other users theads in this category.",
)
@patch_category_acl(
{"can_hide_threads": False, "can_hide_own_threads": True, "thread_edit_time": 1}
)
def test_hide_owned_thread_no_time(self):
"""api forbids non-moderator from hiding other users threads"""
self.thread.started_on = timezone.now() - timedelta(minutes=5)
self.thread.starter = self.user
self.thread.save()
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": True}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"You can't hide threads that are older than 1 minute.",
)
@patch_category_acl({"can_hide_threads": True, "can_close_threads": False})
def test_hide_closed_category_no_permission(self):
"""api test permission to hide thread in closed category"""
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": True}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"This category is closed. You can't hide threads in it.",
)
@patch_category_acl({"can_hide_threads": True, "can_close_threads": False})
def test_hide_closed_thread_no_permission(self):
"""api test permission to hide closed thread"""
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": True}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "This thread is closed. You can't hide it."
)
class ThreadUnhideApiTests(ThreadPatchApiTestCase):
def setUp(self):
super().setUp()
self.thread.is_hidden = True
self.thread.save()
@patch_category_acl({"can_hide_threads": True})
def test_unhide_thread(self):
"""api makes it possible to unhide thread"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": False}]
)
self.assertEqual(response.status_code, 200)
reponse_json = response.json()
self.assertFalse(reponse_json["is_hidden"])
thread_json = self.get_thread_json()
self.assertFalse(thread_json["is_hidden"])
@patch_category_acl({"can_hide_threads": False})
def test_unhide_thread_no_permission(self):
"""api unhide thread with no permission fails as thread is invisible"""
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": True}]
)
self.assertEqual(response.status_code, 404)
@patch_category_acl({"can_hide_threads": True, "can_close_threads": False})
def test_unhide_closed_category_no_permission(self):
"""api test permission to unhide thread in closed category"""
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": False}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0],
"This category is closed. You can't reveal threads in it.",
)
@patch_category_acl({"can_hide_threads": True, "can_close_threads": False})
def test_unhide_closed_thread_no_permission(self):
"""api test permission to unhide closed thread"""
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link, [{"op": "replace", "path": "is-hidden", "value": False}]
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(
response_json["detail"][0], "This thread is closed. You can't reveal it."
)
class ThreadMarkBestAnswerApiTests(ThreadPatchApiTestCase):
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer(self):
"""api makes it possible to mark best answer"""
best_answer = test.reply_thread(self.thread)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": ["ok"],
"best_answer": best_answer.id,
"best_answer_is_protected": False,
"best_answer_marked_on": response.json()["best_answer_marked_on"],
"best_answer_marked_by": self.user.id,
"best_answer_marked_by_name": self.user.username,
"best_answer_marked_by_slug": self.user.slug,
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], best_answer.id)
self.assertEqual(thread_json["best_answer_is_protected"], False)
self.assertEqual(
thread_json["best_answer_marked_on"],
response.json()["best_answer_marked_on"],
)
self.assertEqual(thread_json["best_answer_marked_by"], self.user.id)
self.assertEqual(thread_json["best_answer_marked_by_name"], self.user.username)
self.assertEqual(thread_json["best_answer_marked_by_slug"], self.user.slug)
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer_anonymous(self):
"""api validates that user is authenticated before marking best answer"""
self.logout_user()
best_answer = test.reply_thread(self.thread)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "This action is not available to guests."}
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 0})
def test_mark_best_answer_no_permission(self):
"""api validates permission to mark best answers"""
best_answer = test.reply_thread(self.thread)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to mark best answers "
'in the "First category" category.'
],
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 1})
def test_mark_best_answer_not_thread_starter(self):
"""api validates permission to mark best answers in owned thread"""
best_answer = test.reply_thread(self.thread)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to mark best answer in this thread "
"because you didn't start it."
],
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
# passing scenario is possible
self.thread.starter = self.user
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl({"can_mark_best_answers": 2, "can_close_threads": False})
def test_mark_best_answer_category_closed_no_permission(self):
"""api validates permission to mark best answers in closed category"""
best_answer = test.reply_thread(self.thread)
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to mark best answer in this thread "
'because its category "First category" is closed.'
],
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2, "can_close_threads": True})
def test_mark_best_answer_category_closed(self):
"""api validates permission to mark best answers in closed category"""
best_answer = test.reply_thread(self.thread)
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl({"can_mark_best_answers": 2, "can_close_threads": False})
def test_mark_best_answer_thread_closed_no_permission(self):
"""api validates permission to mark best answers in closed thread"""
best_answer = test.reply_thread(self.thread)
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You can't mark best answer in this thread because it's closed and "
"you don't have permission to open it."
],
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2, "can_close_threads": True})
def test_mark_best_answer_thread_closed(self):
"""api validates permission to mark best answers in closed thread"""
best_answer = test.reply_thread(self.thread)
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer_invalid_post_id(self):
"""api validates that post id is int"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": "d7sd89a7d98sa"}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"id": self.thread.id, "detail": ["A valid integer is required."]},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer_post_not_found(self):
"""api validates that post exists"""
response = self.patch(
self.api_link,
[
{
"op": "replace",
"path": "best-answer",
"value": self.thread.last_post_id + 1,
}
],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"id": self.thread.id, "detail": ["NOT FOUND"]}
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer_post_invisible(self):
"""api validates post visibility to action author"""
unapproved_post = test.reply_thread(self.thread, is_unapproved=True)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": unapproved_post.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"id": self.thread.id, "detail": ["NOT FOUND"]}
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer_post_other_thread(self):
"""api validates post belongs to same thread"""
other_thread = test.post_thread(self.category)
response = self.patch(
self.api_link,
[
{
"op": "replace",
"path": "best-answer",
"value": other_thread.first_post_id,
}
],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"id": self.thread.id, "detail": ["NOT FOUND"]}
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer_event_id(self):
"""api validates that post is not an event"""
best_answer = test.reply_thread(self.thread)
best_answer.is_event = True
best_answer.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": ["Events can't be marked as best answers."],
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer_first_post(self):
"""api validates that post is not a first post in thread"""
response = self.patch(
self.api_link,
[
{
"op": "replace",
"path": "best-answer",
"value": self.thread.first_post_id,
}
],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": ["First post in a thread can't be marked as best answer."],
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer_hidden_post(self):
"""api validates that post is not hidden"""
best_answer = test.reply_thread(self.thread, is_hidden=True)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": ["Hidden posts can't be marked as best answers."],
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2})
def test_mark_best_answer_unapproved_post(self):
"""api validates that post is not unapproved"""
best_answer = test.reply_thread(
self.thread, poster=self.user, is_unapproved=True
)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": ["Unapproved posts can't be marked as best answers."],
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2, "can_protect_posts": False})
def test_mark_best_answer_protected_post_no_permission(self):
"""api respects post protection"""
best_answer = test.reply_thread(self.thread, is_protected=True)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to mark this post as best answer "
"because a moderator has protected it."
],
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
@patch_category_acl({"can_mark_best_answers": 2, "can_protect_posts": True})
def test_mark_best_answer_protected_post(self):
"""api respects post protection"""
best_answer = test.reply_thread(self.thread, is_protected=True)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 200)
class ThreadChangeBestAnswerApiTests(ThreadPatchApiTestCase):
def setUp(self):
super().setUp()
self.best_answer = test.reply_thread(self.thread)
self.thread.set_best_answer(self.user, self.best_answer)
self.thread.save()
@patch_category_acl({"can_mark_best_answers": 2, "can_change_marked_answers": 2})
def test_change_best_answer(self):
"""api makes it possible to change best answer"""
best_answer = test.reply_thread(self.thread)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": ["ok"],
"best_answer": best_answer.id,
"best_answer_is_protected": False,
"best_answer_marked_on": response.json()["best_answer_marked_on"],
"best_answer_marked_by": self.user.id,
"best_answer_marked_by_name": self.user.username,
"best_answer_marked_by_slug": self.user.slug,
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], best_answer.id)
self.assertEqual(thread_json["best_answer_is_protected"], False)
self.assertEqual(
thread_json["best_answer_marked_on"],
response.json()["best_answer_marked_on"],
)
self.assertEqual(thread_json["best_answer_marked_by"], self.user.id)
self.assertEqual(thread_json["best_answer_marked_by_name"], self.user.username)
self.assertEqual(thread_json["best_answer_marked_by_slug"], self.user.slug)
@patch_category_acl({"can_mark_best_answers": 2, "can_change_marked_answers": 2})
def test_change_best_answer_same_post(self):
"""api validates if new best answer is same as current one"""
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": ["This post is already marked as thread's best answer."],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl({"can_mark_best_answers": 0, "can_change_marked_answers": 2})
def test_change_best_answer_no_permission_to_mark(self):
"""
api validates permission to mark best answers before allowing answer change
"""
best_answer = test.reply_thread(self.thread)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to mark best answers in the "
'"First category" category.'
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl({"can_mark_best_answers": 2, "can_change_marked_answers": 0})
def test_change_best_answer_no_permission(self):
"""api validates permission to change best answers"""
best_answer = test.reply_thread(self.thread)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to change this thread's marked answer "
'because it\'s in the "First category" category.'
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl({"can_mark_best_answers": 2, "can_change_marked_answers": 1})
def test_change_best_answer_not_starter(self):
"""api validates permission to change best answers"""
best_answer = test.reply_thread(self.thread)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to change this thread's marked answer "
"because you are not a thread starter."
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
# passing scenario is possible
self.thread.starter = self.user
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl(
{
"can_mark_best_answers": 2,
"can_change_marked_answers": 1,
"best_answer_change_time": 5,
}
)
def test_change_best_answer_timelimit_out_of_time(self):
"""
api validates permission for starter to change best answers within timelimit
"""
best_answer = test.reply_thread(self.thread)
self.thread.best_answer_marked_on = timezone.now() - timedelta(minutes=6)
self.thread.starter = self.user
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to change best answer that was marked "
"for more than 5 minutes."
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl(
{
"can_mark_best_answers": 2,
"can_change_marked_answers": 1,
"best_answer_change_time": 5,
}
)
def test_change_best_answer_timelimit(self):
"""
api validates permission for starter to change best answers within timelimit
"""
best_answer = test.reply_thread(self.thread)
self.thread.best_answer_marked_on = timezone.now() - timedelta(minutes=1)
self.thread.starter = self.user
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl(
{
"can_mark_best_answers": 2,
"can_change_marked_answers": 2,
"can_protect_posts": False,
}
)
def test_change_best_answer_protected_no_permission(self):
"""api validates permission to change protected best answers"""
best_answer = test.reply_thread(self.thread)
self.thread.best_answer_is_protected = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to change this thread's best answer "
"because a moderator has protected it."
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl(
{
"can_mark_best_answers": 2,
"can_change_marked_answers": 2,
"can_protect_posts": True,
}
)
def test_change_best_answer_protected(self):
"""api validates permission to change protected best answers"""
best_answer = test.reply_thread(self.thread)
self.thread.best_answer_is_protected = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl({"can_mark_best_answers": 2, "can_change_marked_answers": 2})
def test_change_best_answer_post_validation(self):
"""api validates new post'"""
best_answer = test.reply_thread(self.thread, is_hidden=True)
response = self.patch(
self.api_link,
[{"op": "replace", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
class ThreadUnmarkBestAnswerApiTests(ThreadPatchApiTestCase):
def setUp(self):
super().setUp()
self.best_answer = test.reply_thread(self.thread)
self.thread.set_best_answer(self.user, self.best_answer)
self.thread.save()
@patch_category_acl({"can_mark_best_answers": 0, "can_change_marked_answers": 2})
def test_unmark_best_answer(self):
"""api makes it possible to unmark best answer"""
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": ["ok"],
"best_answer": None,
"best_answer_is_protected": False,
"best_answer_marked_on": None,
"best_answer_marked_by": None,
"best_answer_marked_by_name": None,
"best_answer_marked_by_slug": None,
},
)
thread_json = self.get_thread_json()
self.assertIsNone(thread_json["best_answer"])
self.assertFalse(thread_json["best_answer_is_protected"])
self.assertIsNone(thread_json["best_answer_marked_on"])
self.assertIsNone(thread_json["best_answer_marked_by"])
self.assertIsNone(thread_json["best_answer_marked_by_name"])
self.assertIsNone(thread_json["best_answer_marked_by_slug"])
@patch_category_acl({"can_mark_best_answers": 0, "can_change_marked_answers": 2})
def test_unmark_best_answer_invalid_post_id(self):
"""api validates that post id is int"""
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": "d7sd89a7d98sa"}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"id": self.thread.id, "detail": ["A valid integer is required."]},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl({"can_mark_best_answers": 0, "can_change_marked_answers": 2})
def test_unmark_best_answer_post_not_found(self):
"""api validates that post to unmark exists"""
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id + 1}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"id": self.thread.id, "detail": ["NOT FOUND"]}
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl({"can_mark_best_answers": 0, "can_change_marked_answers": 2})
def test_unmark_best_answer_wrong_post(self):
"""api validates if post given to unmark is best answer"""
best_answer = test.reply_thread(self.thread)
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"This post can't be unmarked because it's not currently marked "
"as best answer."
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl({"can_mark_best_answers": 0, "can_change_marked_answers": 0})
def test_unmark_best_answer_no_permission(self):
"""api validates if user has permission to unmark best answers"""
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to unmark threads answers in "
'the "First category" category.'
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl({"can_mark_best_answers": 0, "can_change_marked_answers": 1})
def test_unmark_best_answer_not_starter(self):
"""api validates if starter has permission to unmark best answers"""
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to unmark this best answer because "
"you are not a thread starter."
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
# passing scenario is possible
self.thread.starter = self.user
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl(
{
"can_mark_best_answers": 0,
"can_change_marked_answers": 1,
"best_answer_change_time": 5,
}
)
def test_unmark_best_answer_timelimit(self):
"""
api validates if starter has permission to unmark best answer within time limit
"""
self.thread.best_answer_marked_on = timezone.now() - timedelta(minutes=6)
self.thread.starter = self.user
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to unmark best answer that was marked "
"for more than 5 minutes."
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
# passing scenario is possible
self.thread.best_answer_marked_on = timezone.now() - timedelta(minutes=2)
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl(
{
"can_mark_best_answers": 0,
"can_change_marked_answers": 2,
"can_close_threads": False,
}
)
def test_unmark_best_answer_closed_category_no_permission(self):
"""
api validates if user has permission to unmark best answer in closed category
"""
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to unmark this best answer because "
'its category "First category" is closed.'
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl(
{
"can_mark_best_answers": 0,
"can_change_marked_answers": 2,
"can_close_threads": True,
}
)
def test_unmark_best_answer_closed_category(self):
"""
api validates if user has permission to unmark best answer in closed category
"""
self.category.is_closed = True
self.category.save()
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl(
{
"can_mark_best_answers": 0,
"can_change_marked_answers": 2,
"can_close_threads": False,
}
)
def test_unmark_best_answer_closed_thread_no_permission(self):
"""
api validates if user has permission to unmark best answer in closed thread
"""
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You can't unmark this thread's best answer because it's closed "
"and you don't have permission to open it."
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl(
{
"can_mark_best_answers": 0,
"can_change_marked_answers": 2,
"can_close_threads": True,
}
)
def test_unmark_best_answer_closed_thread(self):
"""
api validates if user has permission to unmark best answer in closed thread
"""
self.thread.is_closed = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 200)
@patch_category_acl(
{
"can_mark_best_answers": 0,
"can_change_marked_answers": 2,
"can_protect_posts": 0,
}
)
def test_unmark_best_answer_protected_no_permission(self):
"""api validates permission to unmark protected best answers"""
self.thread.best_answer_is_protected = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"id": self.thread.id,
"detail": [
"You don't have permission to unmark this thread's best answer "
"because a moderator has protected it."
],
},
)
thread_json = self.get_thread_json()
self.assertEqual(thread_json["best_answer"], self.best_answer.id)
@patch_category_acl(
{
"can_mark_best_answers": 0,
"can_change_marked_answers": 2,
"can_protect_posts": 1,
}
)
def test_unmark_best_answer_protected(self):
"""api validates permission to unmark protected best answers"""
self.thread.best_answer_is_protected = True
self.thread.save()
response = self.patch(
self.api_link,
[{"op": "remove", "path": "best-answer", "value": self.best_answer.id}],
)
self.assertEqual(response.status_code, 200)
| 69,373
|
Python
|
.py
| 1,616
| 32.649752
| 88
| 0.58338
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,099
|
test_thread_bulkpatch_api.py
|
rafalp_Misago/misago/threads/tests/test_thread_bulkpatch_api.py
|
import json
from django.urls import reverse
from .. import test
from ...categories.models import Category
from ...conf.test import override_dynamic_settings
from ..models import Thread
from ..test import patch_category_acl, patch_other_category_acl
from .test_threads_api import ThreadsApiTestCase
class ThreadsBulkPatchApiTestCase(ThreadsApiTestCase):
def setUp(self):
super().setUp()
self.threads = list(
reversed(
[
test.post_thread(category=self.category),
test.post_thread(category=self.category),
test.post_thread(category=self.category),
]
)
)
self.ids = list(reversed([t.id for t in self.threads]))
self.api_link = reverse("misago:api:thread-list")
def patch(self, api_link, ops):
return self.client.patch(
api_link, json.dumps(ops), content_type="application/json"
)
class BulkPatchSerializerTests(ThreadsBulkPatchApiTestCase):
def test_invalid_input_type(self):
"""api rejects invalid input type"""
response = self.patch(self.api_link, [1, 2, 3])
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"non_field_errors": [
"Invalid data. Expected a dictionary, but got list."
]
},
)
def test_missing_input_keys(self):
"""api rejects input with missing keys"""
response = self.patch(self.api_link, {})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"ids": ["This field is required."], "ops": ["This field is required."]},
)
def test_empty_input_keys(self):
"""api rejects input with empty keys"""
response = self.patch(self.api_link, {"ids": [], "ops": []})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"ids": ["Ensure this field has at least 1 elements."],
"ops": ["Ensure this field has at least 1 elements."],
},
)
def test_invalid_input_keys(self):
"""api rejects input with invalid keys"""
response = self.patch(self.api_link, {"ids": ["a"], "ops": [1]})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"ids": {"0": ["A valid integer is required."]},
"ops": {"0": ['Expected a dictionary of items but got type "int".']},
},
)
def test_too_small_id(self):
"""api rejects input with implausiple id"""
response = self.patch(self.api_link, {"ids": [0], "ops": [{}]})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"ids": {"0": ["Ensure this value is greater than or equal to 1."]}},
)
@override_dynamic_settings(threads_per_page=5)
def test_too_large_input(self):
"""api rejects too large input"""
response = self.patch(
self.api_link,
{"ids": [i + 1 for i in range(6)], "ops": [{} for i in range(200)]},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"ids": ["No more than 5 threads can be updated at a single time."],
"ops": ["Ensure this field has no more than 10 elements."],
},
)
def test_threads_not_found(self):
"""api fails to find threads"""
threads = [
test.post_thread(category=self.category, is_hidden=True),
test.post_thread(category=self.category, is_unapproved=True),
]
response = self.patch(
self.api_link, {"ids": [t.id for t in threads], "ops": [{}]}
)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "One or more threads to update could not be found."},
)
def test_ops_invalid(self):
"""api validates descriptions"""
response = self.patch(self.api_link, {"ids": self.ids[:1], "ops": [{}]})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), [{"id": self.ids[0], "detail": ["undefined op"]}]
)
def test_anonymous_user(self):
"""anonymous users can't use bulk actions"""
self.logout_user()
response = self.patch(self.api_link, {"ids": self.ids[:1], "ops": [{}]})
self.assertEqual(response.status_code, 403)
class ThreadAddAclApiTests(ThreadsBulkPatchApiTestCase):
def test_add_acl_true(self):
"""api adds current threads acl to response"""
response = self.patch(
self.api_link,
{"ids": self.ids, "ops": [{"op": "add", "path": "acl", "value": True}]},
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
for i, thread in enumerate(self.threads):
self.assertEqual(response_json[i]["id"], thread.id)
self.assertTrue(response_json[i]["acl"])
class BulkThreadChangeTitleApiTests(ThreadsBulkPatchApiTestCase):
@patch_category_acl({"can_edit_threads": 2})
def test_change_thread_title(self):
"""api changes thread title and resyncs the category"""
response = self.patch(
self.api_link,
{
"ids": self.ids,
"ops": [
{"op": "replace", "path": "title", "value": "Changed the title!"}
],
},
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
for i, thread in enumerate(self.threads):
self.assertEqual(response_json[i]["id"], thread.id)
self.assertEqual(response_json[i]["title"], "Changed the title!")
for thread in Thread.objects.filter(id__in=self.ids):
self.assertEqual(thread.title, "Changed the title!")
category = Category.objects.get(pk=self.category.id)
self.assertEqual(category.last_thread_title, "Changed the title!")
@patch_category_acl({"can_edit_threads": 0})
def test_change_thread_title_no_permission(self):
"""api validates permission to change title, returns errors"""
response = self.patch(
self.api_link,
{
"ids": self.ids,
"ops": [
{"op": "replace", "path": "title", "value": "Changed the title!"}
],
},
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
for i, thread in enumerate(self.threads):
self.assertEqual(response_json[i]["id"], thread.id)
self.assertEqual(
response_json[i]["detail"], ["You can't edit threads in this category."]
)
class BulkThreadMoveApiTests(ThreadsBulkPatchApiTestCase):
def setUp(self):
super().setUp()
Category(name="Other Category", slug="other-category").insert_at(
self.category, position="last-child", save=True
)
self.other_category = Category.objects.get(slug="other-category")
@patch_category_acl({"can_move_threads": True})
@patch_other_category_acl({"can_start_threads": 2})
def test_move_thread(self):
"""api moves threads to other category and syncs both categories"""
response = self.patch(
self.api_link,
{
"ids": self.ids,
"ops": [
{
"op": "replace",
"path": "category",
"value": self.other_category.id,
},
{"op": "replace", "path": "flatten-categories", "value": None},
],
},
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
for i, thread in enumerate(self.threads):
self.assertEqual(response_json[i]["id"], thread.id)
self.assertEqual(response_json[i]["category"], self.other_category.id)
for thread in Thread.objects.filter(id__in=self.ids):
self.assertEqual(thread.category_id, self.other_category.id)
category = Category.objects.get(pk=self.category.id)
self.assertEqual(category.threads, self.category.threads - 3)
new_category = Category.objects.get(pk=self.other_category.id)
self.assertEqual(new_category.threads, 3)
class BulkThreadsHideApiTests(ThreadsBulkPatchApiTestCase):
@patch_category_acl({"can_hide_threads": 1})
def test_hide_thread(self):
"""api makes it possible to hide thread"""
response = self.patch(
self.api_link,
{
"ids": self.ids,
"ops": [{"op": "replace", "path": "is-hidden", "value": True}],
},
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
for i, thread in enumerate(self.threads):
self.assertEqual(response_json[i]["id"], thread.id)
self.assertTrue(response_json[i]["is_hidden"])
for thread in Thread.objects.filter(id__in=self.ids):
self.assertTrue(thread.is_hidden)
category = Category.objects.get(pk=self.category.id)
self.assertNotIn(category.last_thread_id, self.ids)
class BulkThreadsApproveApiTests(ThreadsBulkPatchApiTestCase):
@patch_category_acl({"can_approve_content": True})
def test_approve_thread(self):
"""api approvse threads and syncs category"""
for thread in self.threads:
thread.first_post.is_unapproved = True
thread.first_post.save()
thread.synchronize()
thread.save()
self.assertTrue(thread.is_unapproved)
self.assertTrue(thread.has_unapproved_posts)
self.category.synchronize()
self.category.save()
response = self.patch(
self.api_link,
{
"ids": self.ids,
"ops": [{"op": "replace", "path": "is-unapproved", "value": False}],
},
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
for i, thread in enumerate(self.threads):
self.assertEqual(response_json[i]["id"], thread.id)
self.assertFalse(response_json[i]["is_unapproved"])
self.assertFalse(response_json[i]["has_unapproved_posts"])
for thread in Thread.objects.filter(id__in=self.ids):
self.assertFalse(thread.is_unapproved)
self.assertFalse(thread.has_unapproved_posts)
category = Category.objects.get(pk=self.category.id)
self.assertIn(category.last_thread_id, self.ids)
| 11,132
|
Python
|
.py
| 258
| 32.333333
| 88
| 0.578139
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|