diff --git a/dev b/dev index a9a47aaa8b..c7e25df319 100755 --- a/dev +++ b/dev @@ -103,7 +103,7 @@ intro() { echo " ${BOLD}run${NORMAL} runs \"docker compose run --rm misago\"." echo " ${BOLD}psql${NORMAL} runs psql connected to development database." echo " ${BOLD}pyfmt${NORMAL} runs isort + black on python code." - echo " ${BOLD}loaddevfixture${NORMAL} populates database with pre-made data for dev." + echo " ${BOLD}loaddevfixture${NORMAL} populates database with pre-made data for dev." echo " ${BOLD}fakedata${NORMAL} populates database with generated testing data." echo " ${BOLD}fakebigdata${NORMAL} populates database with LARGE amount of geerated testing data." echo " ${BOLD}pipcompile${NORMAL} run pip-compile to update requirements.txt" diff --git a/dev-docs/plugins/hooks/can-upload-private-threads-attachments-hook.md b/dev-docs/plugins/hooks/can-upload-private-threads-attachments-hook.md new file mode 100644 index 0000000000..c9050091f7 --- /dev/null +++ b/dev-docs/plugins/hooks/can-upload-private-threads-attachments-hook.md @@ -0,0 +1,86 @@ +# `can_upload_private_threads_attachments_hook` + +This hook wraps the standard Misago function that checks whether a user has permission to upload attachments in private threads. + + +## Location + +This hook can be imported from `misago.permissions.hooks`: + +```python +from misago.permissions.hooks import can_upload_private_threads_attachments_hook +``` + + +## Filter + +```python +def custom_can_upload_private_threads_attachments_filter( + action: CanUploadPrivateThreadsAttachmentsHookAction, + permissions: 'UserPermissionsProxy', +) -> bool: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: CanUploadPrivateThreadsAttachmentsHookAction` + +A standard Misago function that checks whether a user has permission to upload attachments in private threads. + +See the [action](#action) section for details. + + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +### Return value + +`True` if a user can upload attachments in a category, and `False` if they cannot. + + +## Action + +```python +def can_upload_private_threads_attachments_action(permissions: 'UserPermissionsProxy') -> bool: + ... +``` + +A standard Misago function that checks whether a user has permission to upload attachments in private threads. + + +### Arguments + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +### Return value + +`True` if a user can upload attachments in a category, and `False` if they cannot. + + +## Example + +The code below implements a custom filter function that prevents a user from uploading attachments in private threads if a custom flag is set on their account. + +```python +from misago.permissions.hooks import can_upload_threads_attachments_hook +from misago.permissions.proxy import UserPermissionsProxy + +@can_upload_private_threads_attachments_hook.append_filter +def user_can_upload_attachments_in_category( + action, + permissions: UserPermissionsProxy, +) -> bool: + if permissions.user.plugin_data.get("banned_private_threads_attachments"): + return False + + result action(permissions) +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/can-upload-threads-attachments-hook.md b/dev-docs/plugins/hooks/can-upload-threads-attachments-hook.md new file mode 100644 index 0000000000..78ff9a125f --- /dev/null +++ b/dev-docs/plugins/hooks/can-upload-threads-attachments-hook.md @@ -0,0 +1,101 @@ +# `can_upload_threads_attachments_hook` + +This hook wraps the standard Misago function that checks whether a user has permission to upload attachments in a category. + + +## Location + +This hook can be imported from `misago.permissions.hooks`: + +```python +from misago.permissions.hooks import can_upload_threads_attachments_hook +``` + + +## Filter + +```python +def custom_can_upload_threads_attachments_filter( + action: CanUploadThreadsAttachmentsHookAction, + permissions: 'UserPermissionsProxy', + category: Category, +) -> bool: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: CanUploadThreadsAttachmentsHookAction` + +A standard Misago function that checks if a user has permission to upload attachments in a category. + +See the [action](#action) section for details. + + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `category: Category` + +A category to check permissions for. + + +### Return value + +`True` if a user can upload attachments in a category, and `False` if they cannot. + + +## Action + +```python +def can_upload_threads_attachments_action( + permissions: 'UserPermissionsProxy', category: Category +) -> bool: + ... +``` + +A standard Misago function that checks if a user has permission to upload attachments in a category. + + +### Arguments + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `category: Category` + +A category to check permissions for. + + +### Return value + +`True` if a user can upload attachments in a category, and `False` if they cannot. + + +## Example + +The code below implements a custom filter function that prevents a user from uploading attachments in a specific category if a custom flag is set on their account. + +```python +from misago.categories.models import Category +from misago.permissions.hooks import can_upload_threads_attachments_hook +from misago.permissions.proxy import UserPermissionsProxy + +@can_upload_threads_attachments_hook.append_filter +def user_can_upload_attachments_in_category( + action, + permissions: UserPermissionsProxy, + category: Category, +) -> bool: + if category.id in permissions.user.plugin_data.get("banned_attachments", []): + return False + + result action(permissions, category) +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/check-download-attachment-permission-hook.md b/dev-docs/plugins/hooks/check-download-attachment-permission-hook.md new file mode 100644 index 0000000000..7686b438ad --- /dev/null +++ b/dev-docs/plugins/hooks/check-download-attachment-permission-hook.md @@ -0,0 +1,138 @@ +# `check_download_attachment_permission_hook` + +This hook wraps the standard function that Misago uses to check if the user has permission to download an attachment. It raises Django's `Http404` if the user cannot see the attachment or `PermissionDenied` if they are not allowed to download it. + + +## Location + +This hook can be imported from `misago.permissions.hooks`: + +```python +from misago.permissions.hooks import check_download_attachment_permission_hook +``` + + +## Filter + +```python +def custom_check_download_attachment_permission_filter( + action: CheckDownloadAttachmentPermissionHookAction, + permissions: 'UserPermissionsProxy', + category: Category | None, + thread: Thread | None, + post: Post | None, + attachment: Attachment, +) -> None: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: CheckDownloadAttachmentPermissionHookAction` + +A standard Misago function used to check if a user has permission to download an attachment. It raises Django's `Http404` if the user cannot see the attachment or `PermissionDenied` if they are not allowed to download it. + +See the [action](#action) section for details. + + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `category: Category | None` + +A category to check permissions for, or `None` if the attachment wasn't posted. + + +#### `thread: Thread | None` + +A thread to check permissions for, or `None` if the attachment wasn't posted. + + +#### `post: Post | None` + +A post to check permissions for, or `None` if the attachment wasn't posted. + + +#### `attachment: Attachment` + +An attachment to check permissions for. + + +## Action + +```python +def check_download_attachment_permission_action( + permissions: 'UserPermissionsProxy', + category: Category | None, + thread: Thread | None, + post: Post | None, + attachment: Attachment, +) -> None: + ... +``` + +A standard Misago function used to check if a user has permission to download an attachment. It raises Django's `Http404` if the user cannot see the attachment or `PermissionDenied` if they are not allowed to download it. + + +### Arguments + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `category: Category | None` + +A category to check permissions for, or `None` if the attachment wasn't posted. + + +#### `thread: Thread | None` + +A thread to check permissions for, or `None` if the attachment wasn't posted. + + +#### `post: Post | None` + +A post to check permissions for, or `None` if the attachment wasn't posted. + + +#### `attachment: Attachment` + +An attachment to check permissions for. + + +## Example + +The code below implements a custom filter function that prevents a user from downloading an attachment if its flagged by plugin. + +```python +from django.http import Http404 +from misago.attachments.models import Attachment +from misago.categories.models import Category +from misago.permissions.hooks import check_download_attachment_permission_hook +from misago.permissions.proxy import UserPermissionsProxy +from misago.threads.models import Post, Thread + +@check_download_attachment_permission_hook.append_filter +def check_user_can_download_attachment( + action, + permissions: UserPermissionsProxy, + category: Category | None, + thread: Thread | None, + post: Post | None, + attachment: Attachment, +) -> None: + action(permissions, category, thread, post, attachment) + + if not ( + attachment.plugin_data.get("hidden") + and permissions.user.is_authenticated + and permissions.user.is_misago_admin + ): + raise Http404() +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/check-edit-private-thread-post-permission-hook.md b/dev-docs/plugins/hooks/check-edit-private-thread-post-permission-hook.md index 0bd4195cce..ee9b265cb1 100644 --- a/dev-docs/plugins/hooks/check-edit-private-thread-post-permission-hook.md +++ b/dev-docs/plugins/hooks/check-edit-private-thread-post-permission-hook.md @@ -98,7 +98,7 @@ def check_user_can_edit_thread( thread: Thread, post: Post, ) -> None: - action(permissions, category, post, thread) + action(permissions, thread, post) if ( "[PROTECT]" in post.original diff --git a/dev-docs/plugins/hooks/check-edit-post-permission-hook.md b/dev-docs/plugins/hooks/check-edit-thread-post-permission-hook.md similarity index 69% rename from dev-docs/plugins/hooks/check-edit-post-permission-hook.md rename to dev-docs/plugins/hooks/check-edit-thread-post-permission-hook.md index 17eca5d4ba..68c3033ffa 100644 --- a/dev-docs/plugins/hooks/check-edit-post-permission-hook.md +++ b/dev-docs/plugins/hooks/check-edit-thread-post-permission-hook.md @@ -1,6 +1,6 @@ -# `check_edit_post_permission_hook` +# `check_edit_thread_post_permission_hook` -This hook wraps the standard function that Misago uses to check if the user has permission to edit a post. It raises Django's `PermissionDenied` with an error message if they can't. +This hook wraps the standard function that Misago uses to check if the user has permission to edit a post in a thread. It raises Django's `PermissionDenied` with an error message if they can't. ## Location @@ -8,15 +8,15 @@ This hook wraps the standard function that Misago uses to check if the user has This hook can be imported from `misago.permissions.hooks`: ```python -from misago.permissions.hooks import check_edit_post_permission_hook +from misago.permissions.hooks import check_edit_thread_post_permission_hook ``` ## Filter ```python -def custom_check_edit_post_permission_filter( - action: CheckEditPostPermissionHookAction, +def custom_check_edit_thread_post_permission_filter( + action: CheckEditThreadPostPermissionHookAction, permissions: 'UserPermissionsProxy', category: Category, thread: Thread, @@ -30,9 +30,9 @@ A function implemented by a plugin that can be registered in this hook. ### Arguments -#### `action: CheckEditPostPermissionHookAction` +#### `action: CheckEditThreadPostPermissionHookAction` -A standard Misago function used to check if the user has permission to edit a post. It raises Django's `PermissionDenied` with an error message if they can't. +A standard Misago function used to check if the user has permission to edit a post in a thread. It raises Django's `PermissionDenied` with an error message if they can't. See the [action](#action) section for details. @@ -60,7 +60,7 @@ A post to check permissions for. ## Action ```python -def check_edit_post_permission_action( +def check_edit_thread_post_permission_action( permissions: 'UserPermissionsProxy', category: Category, thread: Thread, @@ -69,7 +69,7 @@ def check_edit_post_permission_action( ... ``` -A standard Misago function used to check if the user has permission to edit a post. It raises Django's `PermissionDenied` with an error message if they can't. +A standard Misago function used to check if the user has permission to edit a post in a thread. It raises Django's `PermissionDenied` with an error message if they can't. ### Arguments @@ -101,19 +101,19 @@ The code below implements a custom filter function that prevents a user from edi ```python from django.core.exceptions import PermissionDenied from misago.categories.models import Category -from misago.permissions.hooks import check_edit_post_permission_hook +from misago.permissions.hooks import check_edit_thread_post_permission_hook from misago.permissions.proxy import UserPermissionsProxy from misago.threads.models import Post, Thread -@check_edit_post_permission_hook.append_filter -def check_user_can_edit_thread( +@check_edit_thread_post_permission_hook.append_filter +def check_user_can_edit_thread_post( action, permissions: UserPermissionsProxy, category: Category, thread: Thread, post: Post, ) -> None: - action(permissions, category, post, thread) + action(permissions, category, thread, post) if ( "[PROTECT]" in post.original diff --git a/dev-docs/plugins/hooks/check-see-post-permission-hook.md b/dev-docs/plugins/hooks/check-see-post-permission-hook.md new file mode 100644 index 0000000000..0fe452325f --- /dev/null +++ b/dev-docs/plugins/hooks/check-see-post-permission-hook.md @@ -0,0 +1,127 @@ +# `check_see_post_permission_hook` + +This hook wraps the standard Misago function used to check if the user has a permission to see a post. Raises Django's `Http404` if they can't see it or `PermissionDenied` with an error message if they can't see it's contents. + + +## Location + +This hook can be imported from `misago.permissions.hooks`: + +```python +from misago.permissions.hooks import check_see_post_permission_hook +``` + + +## Filter + +```python +def custom_check_see_post_permission_filter( + action: CheckSeePostPermissionHookAction, + permissions: 'UserPermissionsProxy', + category: Category, + thread: Thread, + post: Post, +) -> None: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: CheckSeePostPermissionHookAction` + +A standard Misago function used to check if the user has a permission to see a post. Raises Django's `Http404` if they can't see it or `PermissionDenied` with an error message if they can't see it's contents. + +See the [action](#action) section for details. + + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `category: Category` + +A category to check permissions for. + + +#### `thread: Thread` + +A thread to check permissions for. + + +#### `post: Post` + +A post to check permissions for. + + +## Action + +```python +def check_see_post_permission_action( + permissions: 'UserPermissionsProxy', + category: Category, + thread: Thread, + post: Post, +) -> None: + ... +``` + +A standard Misago function used to check if the user has a permission to see a post. Raises Django's `Http404` if they can't see it or `PermissionDenied` with an error message if they can't see it's contents. + + +### Arguments + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `category: Category` + +A category to check permissions for. + + +#### `thread: Thread` + +A thread to check permissions for. + + +#### `post: Post` + +A post to check permissions for. + + +## Example + +The code below implements a custom filter function that blocks a user from seeing a specified thread's post if there is a custom flag set on their account. + +```python +from django.core.exceptions import PermissionDenied +from django.utils.translation import pgettext +from misago.categories.models import Category +from misago.permissions.hooks import check_see_post_permission_hook +from misago.permissions.proxy import UserPermissionsProxy +from misago.threads.models import Post, Thread + +@check_see_post_permission_hook.append_filter +def check_user_can_see_thread_post( + action, + permissions: UserPermissionsProxy, + category: Category, + thread: Thread, + post: Post, +) -> None: + # Run standard permission checks + action(permissions, category, thread, post) + + if thread.id in permissions.user.plugin_data.get("hidden_post", []): + raise PermissionDenied( + pgettext( + "post permission error", + "Site admin has removed your access to this post." + ) + ) +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/check-see-private-thread-permission-hook.md b/dev-docs/plugins/hooks/check-see-private-thread-permission-hook.md index c16897a44c..b34fa09788 100644 --- a/dev-docs/plugins/hooks/check-see-private-thread-permission-hook.md +++ b/dev-docs/plugins/hooks/check-see-private-thread-permission-hook.md @@ -87,7 +87,7 @@ def check_user_can_see_thread( thread: Thread, ) -> None: # Run standard permission checks - action(permissions, category) + action(permissions, category, thread) if thread.id in permissions.user.plugin_data.get("banned_thread", []): raise PermissionDenied( diff --git a/dev-docs/plugins/hooks/check-see-private-thread-post-permission-hook.md b/dev-docs/plugins/hooks/check-see-private-thread-post-permission-hook.md new file mode 100644 index 0000000000..d835b03459 --- /dev/null +++ b/dev-docs/plugins/hooks/check-see-private-thread-post-permission-hook.md @@ -0,0 +1,111 @@ +# `check_see_private_thread_post_permission_hook` + +This hook wraps the standard Misago function used to check if the user has a permission to see a private thread post. Raises Django's `Http404` if they can't. + + +## Location + +This hook can be imported from `misago.permissions.hooks`: + +```python +from misago.permissions.hooks import check_see_private_thread_post_permission_hook +``` + + +## Filter + +```python +def custom_check_see_private_thread_post_permission_filter( + action: CheckSeePrivateThreadPostPermissionHookAction, + permissions: 'UserPermissionsProxy', + thread: Thread, + post: Post, +) -> None: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: CheckSeePrivateThreadPostPermissionHookAction` + +A standard Misago function used to check if the user has a permission to see a private thread. Raises Django's `Http404` if they can't. + +See the [action](#action) section for details. + + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `thread: Thread` + +A thread to check permissions for. + + +#### `post: Post` + +A post to check permissions for. + + +## Action + +```python +def check_see_private_thread_post_permission_action( + permissions: 'UserPermissionsProxy', thread: Thread, post: Post +) -> None: + ... +``` + +A standard Misago function used to check if the user has a permission to see a private thread post. Raises Django's `Http404` if they can't. + + +### Arguments + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `thread: Thread` + +A thread to check permissions for. + + +#### `post: Post` + +A post to check permissions for. + + +## Example + +The code below implements a custom filter function that blocks a user from seeing a specified post if there is a custom flag set on their account. + +```python +from django.core.exceptions import PermissionDenied +from django.utils.translation import pgettext +from misago.permissions.hooks import check_see_private_thread_post_permission_hook +from misago.permissions.proxy import UserPermissionsProxy +from misago.threads.models import Post, Thread + +@check_see_private_thread_post_permission_hook.append_filter +def check_user_can_see_thread( + action, + permissions: UserPermissionsProxy, + thread: Thread, + post: Post, +) -> None: + # Run standard permission checks + action(permissions, category, thread, post) + + if post.id in permissions.user.plugin_data.get("hidden_post", []): + raise PermissionDenied( + pgettext( + "post permission error", + "Site admin has removed your access to this post." + ) + ) +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/check-see-thread-permission-hook.md b/dev-docs/plugins/hooks/check-see-thread-permission-hook.md index 29cd467890..1f7bbce78e 100644 --- a/dev-docs/plugins/hooks/check-see-thread-permission-hook.md +++ b/dev-docs/plugins/hooks/check-see-thread-permission-hook.md @@ -102,7 +102,7 @@ def check_user_can_see_thread( thread: Thread, ) -> None: # Run standard permission checks - action(permissions, category) + action(permissions, category, thread) if thread.id in permissions.user.plugin_data.get("banned_thread", []): raise PermissionDenied( diff --git a/dev-docs/plugins/hooks/check-see-thread-post-permission-hook.md b/dev-docs/plugins/hooks/check-see-thread-post-permission-hook.md new file mode 100644 index 0000000000..0431403968 --- /dev/null +++ b/dev-docs/plugins/hooks/check-see-thread-post-permission-hook.md @@ -0,0 +1,127 @@ +# `check_see_thread_post_permission_hook` + +This hook wraps the standard Misago function used to check if the user has a permission to see a post in a thread. Raises Django's `Http404` if they can't see it or `PermissionDenied` with an error message if they can't see it's contents. + + +## Location + +This hook can be imported from `misago.permissions.hooks`: + +```python +from misago.permissions.hooks import check_see_thread_post_permission_hook +``` + + +## Filter + +```python +def custom_check_see_thread_post_permission_filter( + action: CheckSeeThreadPostPermissionHookAction, + permissions: 'UserPermissionsProxy', + category: Category, + thread: Thread, + post: Post, +) -> None: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: CheckSeeThreadPostPermissionHookAction` + +A standard Misago function used to check if the user has a permission to see a post in a thread. Raises Django's `Http404` if they can't see it or `PermissionDenied` with an error message if they can't see it's contents. + +See the [action](#action) section for details. + + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `category: Category` + +A category to check permissions for. + + +#### `thread: Thread` + +A thread to check permissions for. + + +#### `post: Post` + +A post to check permissions for. + + +## Action + +```python +def check_see_thread_post_permission_action( + permissions: 'UserPermissionsProxy', + category: Category, + thread: Thread, + post: Post, +) -> None: + ... +``` + +A standard Misago function used to check if the user has a permission to see a post in a thread. Raises Django's `Http404` if they can't see it or `PermissionDenied` with an error message if they can't see it's contents. + + +### Arguments + +#### `user_permissions: UserPermissionsProxy` + +A proxy object with the current user's permissions. + + +#### `category: Category` + +A category to check permissions for. + + +#### `thread: Thread` + +A thread to check permissions for. + + +#### `post: Post` + +A post to check permissions for. + + +## Example + +The code below implements a custom filter function that blocks a user from seeing a specified post if there is a custom flag set on their account. + +```python +from django.core.exceptions import PermissionDenied +from django.utils.translation import pgettext +from misago.categories.models import Category +from misago.permissions.hooks import check_see_thread_post_permission_hook +from misago.permissions.proxy import UserPermissionsProxy +from misago.threads.models import Post, Thread + +@check_see_thread_post_permission_hook.append_filter +def check_user_can_see_thread_post( + action, + permissions: UserPermissionsProxy, + category: Category, + thread: Thread, + post: Post, +) -> None: + # Run standard permission checks + action(permissions, category, thread, post) + + if post.id in permissions.user.plugin_data.get("hidden_post", []): + raise PermissionDenied( + pgettext( + "post permission error", + "Site admin has removed your access to this post." + ) + ) +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/complete-markup-html-hook.md b/dev-docs/plugins/hooks/complete-markup-html-hook.md deleted file mode 100644 index 7727c8dbc3..0000000000 --- a/dev-docs/plugins/hooks/complete-markup-html-hook.md +++ /dev/null @@ -1,104 +0,0 @@ -# `complete_markup_html_hook` - -This hook wraps the standard function that Misago uses to complete an HTML representation of parsed markup. - -Completion process includes: - -- Replacing of placeholder spoiler blocks summaries with messages in active language. - Replacing quotation blocks headers with final HTML. - - -## Location - -This hook can be imported from `misago.parser.hooks`: - -```python -from misago.parser.hooks import complete_markup_html_hook -``` - - -## Filter - -```python -def custom_complete_markup_html_filter( - action: CompleteMarkupHtmlHookAction, html: str, **kwargs -) -> str: - ... -``` - -A function implemented by a plugin that can be registered in this hook. - - -### Arguments - -#### `action: CompleteMarkupHtmlHookAction` - -A standard Misago function used to complete an HTML representation of parsed markup or the next filter function from another plugin. - -See the [action](#action) section for details. - - -#### `html: str` - -An HTML representation of parsed markup to complete. - - -#### `**kwargs` - -Additional data that can be used to complete the HTML. - - -### Return value - -A `str` with completed HTML representation of parsed markup. - - -## Action - -```python -def complete_markup_html_action(html: str, **kwargs) -> str: - ... -``` - -A standard Misago function used to complete an HTML representation of parsed markup or the next filter function from another plugin. - - -### Arguments - -#### `html: str` - -An HTML representation of parsed markup to complete. - - -#### `**kwargs` - -Additional data that can be used to complete the HTML. - - -### Return value - -A `str` with completed HTML representation of parsed markup. - - -## Example - -The code below implements a custom filter function that replaces default spoiler block summary with a custom message: - -```python -from misago.parser.context import ParserContext -from misago.parser.html import SPOILER_SUMMARY - - -@complete_markup_html_hook.append_filter -def complete_markup_html_with_custom_spoiler-summary( - action: CompleteMarkupHtmlHookAction, - html: str, - **kwargs, -) -> str: - if SPOILER_SUMMARY in html: - html = html.replace( - SPOILER_SUMMARY, "SPOILER! Click at your own discretion!" - ) - - # Call the next function in chain - return action(context, html, **kwargs) -``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/create-prefetch-posts-related-objects-hook.md b/dev-docs/plugins/hooks/create-prefetch-posts-related-objects-hook.md new file mode 100644 index 0000000000..87ad41e438 --- /dev/null +++ b/dev-docs/plugins/hooks/create-prefetch-posts-related-objects-hook.md @@ -0,0 +1,211 @@ +# `create_prefetch_posts_related_objects_hook` + +This hook wraps the standard function Misago uses to create a `PrefetchPostsRelatedObjects` object, which prefetches related objects for posts displayed on a thread replies page. + +`PrefetchPostsRelatedObjects` is initialized with settings, user permissions, a list of posts for which related objects need to be prefetched, and lists of other already available objects. + +The object itself does not implement prefetch logic but instead maintains a list of prefetch operations to be executed to fetch the objects required for displaying posts on a thread's page. + +Additional prefetch operations can be added using the add_operation method. + + +## Location + +This hook can be imported from `misago.threads.hooks`: + +```python +from misago.threads.hooks import create_prefetch_posts_related_objects_hook +``` + + +## Filter + +```python +def custom_create_prefetch_posts_related_objects_filter( + action: CreatePrefetchPostsRelatedObjectsHookAction, + settings: DynamicSettings, + permissions: UserPermissionsProxy, + posts: Iterable[Post], + *, + categories: Iterable[Category] | None=None, + threads: Iterable[Thread] | None=None, + attachments: Iterable[Attachment] | None=None, + users: Iterable['User'] | None=None, +) -> 'PrefetchPostsRelatedObjects': + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: CreatePrefetchPostsRelatedObjectsHookAction` + +A standard Misago function used to create a `PrefetchPostsRelatedObjects` object, which is used to prefetch related objects for posts displayed on a thread replies page. + +See the [action](#action) section for details. + + +#### `settings: DynamicSettings` + +The `DynamicSettings` object. + + +#### `permissions: UserPermissionsProxy` + +The `UserPermissionsProxy` object for current user. + + +#### `posts: Iterable[Post]` + +Iterable of `Post` instances to prefetch related objects for. + + +#### `categories: Iterable[Category] | None = None` + +Iterable of categories that were already loaded. Defaults to `None` if not provided. + + +#### `threads: Iterable[Thread] | None = None` + +Iterable of threads that were already loaded. Defaults to `None` if not provided. + + +#### `attachments: Iterable[Attachment] | None = None` + +Iterable of attachments that were already loaded. Defaults to `None` if not provided. + + +#### `users: Iterable["User"] | None = None` + +Iterable of users that were already loaded. Defaults to `None` if not provided. + + +### Return value + +A `PrefetchPostsRelatedObjects` object to use to fetch related objects. + + +## Action + +```python +def create_prefetch_posts_related_objects_action( + settings: DynamicSettings, + permissions: UserPermissionsProxy, + posts: Iterable[Post], + *, + categories: Iterable[Category] | None=None, + threads: Iterable[Thread] | None=None, + attachments: Iterable[Attachment] | None=None, + users: Iterable['User'] | None=None, +) -> 'PrefetchPostsRelatedObjects': + ... +``` + +A standard Misago function used to create a `PrefetchPostsRelatedObjects` object, which is used to prefetch related objects for posts displayed on a thread replies page. + + +### Arguments + +#### `settings: DynamicSettings` + +The `DynamicSettings` object. + + +#### `permissions: UserPermissionsProxy` + +The `UserPermissionsProxy` object for current user. + + +#### `posts: Iterable[Post]` + +Iterable of `Post` instances to prefetch related objects for. + + +#### `categories: Iterable[Category] | None = None` + +Iterable of categories that were already loaded. Defaults to `None` if not provided. + + +#### `threads: Iterable[Thread] | None = None` + +Iterable of threads that were already loaded. Defaults to `None` if not provided. + + +#### `attachments: Iterable[Attachment] | None = None` + +Iterable of attachments that were already loaded. Defaults to `None` if not provided. + + +#### `users: Iterable["User"] | None = None` + +Iterable of users that were already loaded. Defaults to `None` if not provided. + + +### Return value + +A `PrefetchPostsRelatedObjects` object to use to fetch related objects. + + +## Example + +The code below implements a custom filter function that includes a new prefetch operation: + +```python +from typing import Iterable + +from misago.attachments.models import Attachment +from misago.categories.models import Category +from misago.conf.dynamicsettings import DynamicSettings +from misago.permissions.proxy import UserPermissionsProxy +from misago.plugins.hooks import FilterHook +from misago.threads.models import Post, Thread +from misago.threads.prefetch import PrefetchPostsRelatedObjects +from misago.users.models import User + +from .plugin.models import PluginModel + + +def fetch_posts_plugin_data( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + data["plugin_models"] = {} + ids_to_fetch: set[int] = set() + + for post in data["posts"].values(): + ids_to_fetch.add(post.plugin_data["plugin_object_id"]) + + if ids_to_fetch: + queryset = PluginModel.objects.filter(id__in=ids_to_fetch) + data["plugin_models"] = {u.id: u for u in queryset} + + +@create_prefetch_posts_related_objects_hook.append_filter +def include_custom_filter( + action: CreatePrefetchPostsRelatedObjectsHookAction, + settings: DynamicSettings, + permissions: UserPermissionsProxy, + posts: Iterable[Post], + *, + categories: Iterable[Category] | None = None, + threads: Iterable[Thread] | None = None, + attachments: Iterable[Attachment] | None = None, + users: Iterable["User"] | None = None, +) -> PrefetchPostsRelatedObjects: + prefetch = action( + settings, + permissions, + posts, + categories=categories, + threads=threads, + attachments=attachments, + users=users, + ) + + prefetch.add_operation(fetch_posts_plugin_data) + + return prefetch +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/delete-attachments-hook.md b/dev-docs/plugins/hooks/delete-attachments-hook.md new file mode 100644 index 0000000000..12b4715ff5 --- /dev/null +++ b/dev-docs/plugins/hooks/delete-attachments-hook.md @@ -0,0 +1,121 @@ +# `delete_attachments_hook` + +This hook wraps the standard function that Misago uses to delete specified attachments. + + +## Location + +This hook can be imported from `misago.attachments.hooks`: + +```python +from misago.attachments.hooks import delete_attachments_hook +``` + + +## Filter + +```python +def custom_delete_attachments_filter( + action: DeleteAttachmentsHookAction, + attachments: Iterable[Union[Attachment, int]], + *, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: DeleteAttachmentsHookAction` + +A standard function used by Misago to delete specified attachments. + +See the [action](#action) section for details. + + +#### `attachments: Iterable[Union[Attachment, int]]` + +An iterable of attachments or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Action + +```python +def delete_attachments_action( + attachments: Iterable[Union[Attachment, int]], + *, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A standard function used by Misago to delete specified attachments. + + +### Arguments + +#### `attachments: Iterable[Union[Attachment, int]]` + +An iterable of attachments or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Example + +The code below implements a custom filter function that logs delete. + +```python +import logging +from typing import Iterable, Protocol, Union + +from django.http import HttpRequest +from misago.attachments.hooks import delete_attachments_hook +from misago.attachments.models import Attachment + +logger = logging.getLogger("attachments.delete") + + +@delete_attachments_hook.append_filter +def log_delete_attachments( + action, + attachments: Iterable[Union[Attachment, int]], + *, + request: HttpRequest | None = None, +) -> int: + deleted = action(attachments, request=request) + + if request and request.user.is_authenticated: + user = f"#{request.user.id}: {request.user.username}" + else: + user = None + + logger.info( + "Deleted attachments: %s", + str(deleted), + extra={"user": user}, + ) + + return deleted +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/delete-categories-attachments-hook.md b/dev-docs/plugins/hooks/delete-categories-attachments-hook.md new file mode 100644 index 0000000000..e08266670b --- /dev/null +++ b/dev-docs/plugins/hooks/delete-categories-attachments-hook.md @@ -0,0 +1,121 @@ +# `delete_categories_attachments_hook` + +This hook wraps the standard function that Misago uses to delete attachments associated with specified categories. + + +## Location + +This hook can be imported from `misago.attachments.hooks`: + +```python +from misago.attachments.hooks import delete_categories_attachments_hook +``` + + +## Filter + +```python +def custom_delete_categories_attachments_filter( + action: DeleteCategoriesAttachmentsHookAction, + categories: Iterable[Union[Category, int]], + *, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: DeleteCategoriesAttachmentsHookAction` + +A standard function used by Misago to delete attachments associated with specified categories. + +See the [action](#action) section for details. + + +#### `categories: Iterable[Union[Category, int]]` + +An iterable of categories or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Action + +```python +def delete_categories_attachments_action( + categories: Iterable[Union[Category, int]], + *, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A standard function used by Misago to delete attachments associated with specified categories. + + +### Arguments + +#### `categories: Iterable[Union[Category, int]]` + +An iterable of categories or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Example + +The code below implements a custom filter function that logs delete. + +```python +import logging +from typing import Iterable, Protocol, Union + +from django.http import HttpRequest +from misago.attachments.hooks import delete_categories_attachments_hook +from misago.categories.models import Category + +logger = logging.getLogger("attachments.delete") + + +@delete_categories_attachments_hook.append_filter +def log_delete_categories_attachments( + action, + categories: Iterable[Union[Category, int]], + *, + request: HttpRequest | None = None, +) -> int: + deleted = action(categories, request=request) + + if request and request.user.is_authenticated: + user = f"#{request.user.id}: {request.user.username}" + else: + user = None + + logger.info( + "Deleted categories attachments: %s", + str(deleted), + extra={"user": user}, + ) + + return deleted +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/delete-categories-hook.md b/dev-docs/plugins/hooks/delete-categories-hook.md new file mode 100644 index 0000000000..499f742ebe --- /dev/null +++ b/dev-docs/plugins/hooks/delete-categories-hook.md @@ -0,0 +1,138 @@ +# `delete_categories_hook` + +This hook wraps the standard function that Misago uses to delete category and its children. + + +## Location + +This hook can be imported from `misago.categories.hooks`: + +```python +from misago.categories.hooks import delete_categories_hook +``` + + +## Filter + +```python +def custom_delete_categories_filter( + action: DeleteCategoriesHookAction, + categories: list[Category], + *, + move_children_to: Category | bool | None=True, + move_contents_to: Category | None=None, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: DeleteCategoriesHookAction` + +A standard function used by Misago to delete category and its children. + + +#### `categories: list[Category]` + +A list of categories that will be deleted. If `move_children_to` is `None`, it will contain both the deleted category and all its descendants that will also be deleted. Otherwise, `categories` list will contain only single item. + + +#### `move_children_to: Category | bool | None = True` + +A category to move categories children to, `True` to make them root categories, or `None` to delete them too. + + +#### `move_contents_to: Category | None = None` + +A category to move categories content to, or `None` to delete contents too. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +## Action + +```python +def delete_categories_action( + categories: list[Category], + *, + move_children_to: Category | bool | None=True, + move_contents_to: Category | None=None, + request: HttpRequest | None=None, +): + ... +``` + +A standard function used by Misago to delete category and its children. + + +### Arguments + +#### `categories: list[Category]` + +A list of categories that will be deleted. If `move_children_to` is `None`, it will contain both the deleted category and all its descendants that will also be deleted. Otherwise, `categories` list will contain only single item. + + +#### `move_children_to: Category | bool | None = True` + +A category to move children categories to, `True` to make them root categories, or `None` to delete them too. + + +#### `move_contents_to: Category | None = None` + +A category to move categories content to, or `None` to delete contents too. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +## Example + +The code below implements a custom filter function that logs delete. + +```python +import logging +from typing import list, Protocol + +from django.http import HttpRequest +from misago.categories.hooks import delete_categories_hook +from misago.categories.models import Category + +logger = logging.getLogger("attachments.delete") + + +@delete_categories_hook.append_filter +def log_delete_categories( + action, + categories: list[Category], + *, + move_children_to: Category | bool | None = True, + move_contents_to: Category | None = None, + request: HttpRequest | None = None, +): + action( + categories, + move_children_to=move_children_to, + move_contents_to=move_contents_to, + request=request, + ) + + if request and request.user.is_authenticated: + user = f"#{request.user.id}: {request.user.username}" + else: + user = None + + logger.info( + "Deleted categories: %s", + ", ".join(f"#{c.id}: {c.name}" for c in categories), + extra={"user": user}, + ) +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/delete-posts-attachments-hook.md b/dev-docs/plugins/hooks/delete-posts-attachments-hook.md new file mode 100644 index 0000000000..8608db1d9e --- /dev/null +++ b/dev-docs/plugins/hooks/delete-posts-attachments-hook.md @@ -0,0 +1,119 @@ +# `delete_posts_attachments_hook` + +This hook wraps the standard function that Misago uses to delete attachments associated with specified posts. + + +## Location + +This hook can be imported from `misago.attachments.hooks`: + +```python +from misago.attachments.hooks import delete_posts_attachments_hook +``` + + +## Filter + +```python +def custom_delete_posts_attachments_filter( + action: DeletePostsAttachmentsHookAction, + posts: Iterable[Union[Post, int]], + *, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: DeletePostsAttachmentsHookAction` + +A standard function used by Misago to delete attachments associated with specified posts. + +See the [action](#action) section for details. + + +#### `posts: Iterable[Union[Post, int]]` + +An iterable of posts or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Action + +```python +def delete_posts_attachments_action( + posts: Iterable[Union[Post, int]], *, request: HttpRequest | None=None +) -> int: + ... +``` + +A standard function used by Misago to delete attachments associated with specified posts. + + +### Arguments + +#### `posts: Iterable[Union[Post, int]]` + +An iterable of posts or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Example + +The code below implements a custom filter function that logs delete. + +```python +import logging +from typing import Iterable, Protocol, Union + +from django.http import HttpRequest +from misago.attachments.hooks import delete_posts_attachments_hook +from misago.threads.models import Post + +logger = logging.getLogger("attachments.delete") + + +@delete_posts_attachments_hook.append_filter +def log_delete_posts_attachments( + action, + posts: Iterable[Union[Post, int]], + *, + request: HttpRequest | None = None, +) -> int: + deleted = action(posts, request=request) + + if request and request.user.is_authenticated: + user = f"#{request.user.id}: {request.user.username}" + else: + user = None + + logger.info( + "Deleted posts attachments: %s", + str(deleted), + extra={"user": user}, + ) + + return deleted +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/delete-threads-attachments-hook.md b/dev-docs/plugins/hooks/delete-threads-attachments-hook.md new file mode 100644 index 0000000000..200ceb7b4d --- /dev/null +++ b/dev-docs/plugins/hooks/delete-threads-attachments-hook.md @@ -0,0 +1,121 @@ +# `delete_threads_attachments_hook` + +This hook wraps the standard function that Misago uses to delete attachments associated with specified threads. + + +## Location + +This hook can be imported from `misago.attachments.hooks`: + +```python +from misago.attachments.hooks import delete_threads_attachments_hook +``` + + +## Filter + +```python +def custom_delete_threads_attachments_filter( + action: DeleteThreadsAttachmentsHookAction, + threads: Iterable[Union[Thread, int]], + *, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: DeleteThreadsAttachmentsHookAction` + +A standard function used by Misago to delete attachments associated with specified threads. + +See the [action](#action) section for details. + + +#### `threads: Iterable[Union[Thread, int]]` + +An iterable of threads or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Action + +```python +def delete_threads_attachments_action( + threads: Iterable[Union[Thread, int]], + *, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A standard function used by Misago to delete attachments associated with specified threads. + + +### Arguments + +#### `threads: Iterable[Union[Thread, int]]` + +An iterable of threads or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Example + +The code below implements a custom filter function that logs delete. + +```python +import logging +from typing import Iterable, Protocol, Union + +from django.http import HttpRequest +from misago.attachments.hooks import delete_threads_attachments_hook +from misago.threads.models import Thread + +logger = logging.getLogger("attachments.delete") + + +@delete_threads_attachments_hook.append_filter +def log_delete_threads_attachments( + action, + threads: Iterable[Union[Thread, int]], + *, + request: HttpRequest | None = None, +) -> int: + deleted = action(threads, request=request) + + if request and request.user.is_authenticated: + user = f"#{request.user.id}: {request.user.username}" + else: + user = None + + logger.info( + "Deleted threads attachments: %s", + str(deleted), + extra={"user": user}, + ) + + return deleted +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/delete-users-attachments-hook.md b/dev-docs/plugins/hooks/delete-users-attachments-hook.md new file mode 100644 index 0000000000..177c4fc9da --- /dev/null +++ b/dev-docs/plugins/hooks/delete-users-attachments-hook.md @@ -0,0 +1,121 @@ +# `delete_users_attachments_hook` + +This hook wraps the standard function that Misago uses to delete attachments associated with specified users. + + +## Location + +This hook can be imported from `misago.attachments.hooks`: + +```python +from misago.attachments.hooks import delete_users_attachments_hook +``` + + +## Filter + +```python +def custom_delete_users_attachments_filter( + action: DeleteUsersAttachmentsHookAction, + users: Iterable[Union['User', int]], + *, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: DeleteUsersAttachmentsHookAction` + +A standard function used by Misago to delete attachments associated with specified users. + +See the [action](#action) section for details. + + +#### `users: Iterable[Union[User, int]]` + +An iterable of users or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Action + +```python +def delete_users_attachments_action( + users: Iterable[Union['User', int]], + *, + request: HttpRequest | None=None, +) -> int: + ... +``` + +A standard function used by Misago to delete attachments associated with specified users. + + +### Arguments + +#### `users: Iterable[Union[User, int]]` + +An iterable of users or their IDs. + + +#### `request: HttpRequest | None` + +The request object or `None`. + + +### Return value + +An `int` with the number of attachments marked for deletion. + + +## Example + +The code below implements a custom filter function that logs delete. + +```python +import logging +from typing import Iterable, Protocol, Union + +from django.http import HttpRequest +from misago.attachments.hooks import delete_users_attachments_hook +from misago.users.models import User + +logger = logging.getLogger("attachments.delete") + + +@delete_users_attachments_hook.append_filter +def log_delete_users_attachments( + action, + users: Iterable[Union[User, int]], + *, + request: HttpRequest | None = None, +) -> int: + deleted = action(users, request=request) + + if request and request.user.is_authenticated: + user = f"#{request.user.id}: {request.user.username}" + else: + user = None + + logger.info( + "Deleted users attachments: %s", + str(deleted), + extra={"user": user}, + ) + + return deleted +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/get-attachment-details-page-context-data-hook.md b/dev-docs/plugins/hooks/get-attachment-details-page-context-data-hook.md new file mode 100644 index 0000000000..961ec12bbc --- /dev/null +++ b/dev-docs/plugins/hooks/get-attachment-details-page-context-data-hook.md @@ -0,0 +1,96 @@ +# `get_attachment_details_page_context_data_hook` + +This hook wraps the standard function that Misago uses to get the template context data for the attachment details page. + + +## Location + +This hook can be imported from `misago.attachments.hooks`: + +```python +from misago.attachments.hooks import get_attachment_details_page_context_data_hook +``` + + +## Filter + +```python +def custom_get_attachment_details_page_context_data_filter( + action: GetAttachmentDetailsPageContextDataHookAction, + request: HttpRequest, + attachment: Attachment, +) -> dict: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: GetAttachmentDetailsPageContextDataHookAction` + +A standard Misago function used to get the template context data for the attachment details page. + +See the [action](#action) section for details. + + +#### `request: HttpRequest` + +The request object. + + +#### `attachment: Attachment` + +The `Attachment` instance. + + +### Return value + +A Python `dict` with context data to use to `render` the attachment details page. + + +## Action + +```python +def get_attachment_details_page_context_data_action(request: HttpRequest, attachment: Attachment) -> dict: + ... +``` + +A standard Misago function used to get the template context data for the attachment details page. + + +### Arguments + +#### `request: HttpRequest` + +The request object. + + +#### `attachment: Attachment` + +The `Attachment` instance. + + +### Return value + +A Python `dict` with context data to use to `render` the attachment details page. + + +## Example + +The code below implements a custom filter function that adds custom context data to the attachment details page: + +```python +from django.http import HttpRequest +from misago.attachments.hooks import get_attachment_details_page_context_data_hook + + +@get_attachment_details_page_context_data_hook.append_filter +def include_custom_context(action, request: HttpRequest, attachment: Attachment) -> dict: + context = action(request, attachment) + + context["plugin_data"] = "..." + + return context +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/get-attachment-plugin-data-hook.md b/dev-docs/plugins/hooks/get-attachment-plugin-data-hook.md new file mode 100644 index 0000000000..d6767622d4 --- /dev/null +++ b/dev-docs/plugins/hooks/get-attachment-plugin-data-hook.md @@ -0,0 +1,121 @@ +# `get_attachment_plugin_data_hook` + +This hook wraps the standard function that Misago uses to create a `dict` to be saved in new attachment's `plugin_data` JSON field. + + +## Location + +This hook can be imported from `misago.attachments.hooks`: + +```python +from misago.attachments.hooks import get_attachment_plugin_data_hook +``` + + +## Filter + +```python +def custom_get_attachment_plugin_data_filter( + action: GetAttachmentPluginDataHookAction, + request: HttpRequest, + upload: UploadedFile, + image: Image | None=None, +) -> dict: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: GetAttachmentPluginDataHookAction` + +A standard function that Misago uses to create a `dict` to be saved in new attachment's `plugin_data` JSON field. + +See the [action](#action) section for details. + + +#### `request: HttpRequest` + +The request object. + + +#### `upload: UploadedFile` + +The `UploadedFile` instance. + + +#### `image: Image | None` + +The `PIL.Image.Image` instance if uploaded file was an image, or `None`. + + +### Return value + +A JSON-serializable `dict`. + + +## Action + +```python +def get_attachment_plugin_data_action( + request: HttpRequest, upload: UploadedFile, image: Image | None=None +) -> dict: + ... +``` + +A standard function that Misago uses to create a `dict` to be saved in new attachment's `plugin_data` JSON field. + + +### Arguments + +#### `request: HttpRequest` + +The request object. + + +#### `upload: UploadedFile` + +The `UploadedFile` instance. + + +#### `image: Image | None` + +The `PIL.Image.Image` instance if uploaded file was an image, or `None`. + + +### Return value + +A JSON-serializable `dict`. + + +## Example + +The code below implements a custom filter function that stores an image's EXIF data in the `Attachment.plugin_data` if the uploaded file is an image: + +```python +from PIL.Image import Image +from django.core.files.uploadedfile import UploadedFile +from django.http import HttpRequest +from misago.attachments.hooks import get_attachment_plugin_data_hook + + +@get_attachment_plugin_data_hook.append_filter +def store_attachment_exif_data( + action, + request: HttpRequest, + upload: UploadedFile, + image: Image | None = None, +) -> dict: + plugin_data = action(request, upload, image) + + if image: + exif = image.getexif() + plugin_data["exif"] = { + "make": exif.get(271, None), + "model": exif.get(272, None) + } + + return plugin_data +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/get-categories-page-component-hook.md b/dev-docs/plugins/hooks/get-categories-page-component-hook.md new file mode 100644 index 0000000000..488c8bb334 --- /dev/null +++ b/dev-docs/plugins/hooks/get-categories-page-component-hook.md @@ -0,0 +1,92 @@ +# `get_categories_page_component_hook` + +This hook wraps the standard function that Misago uses to build a `dict` with data for the categories list component, used to display the list of categories on the categories page. + + +## Location + +This hook can be imported from `misago.categories.hooks`: + +```python +from misago.categories.hooks import get_categories_page_component_hook +``` + + +## Filter + +```python +def custom_get_categories_page_component_filter( + action: GetCategoriesPageComponentHookAction, request: HttpRequest +) -> dict: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: GetCategoriesPageComponentHookAction` + +A standard Misago function used to build a `dict` with data for the categories list component, used to display the list of categories on the categories page. + +See the [action](#action) section for details. + + +#### `request: HttpRequest` + +The request object. + + +### Return value + +A Python `dict` with data for the categories list component. + + +## Action + +```python +def get_categories_page_component_action(request: HttpRequest) -> dict: + ... +``` + +A standard Misago function used to build a `dict` with data for the categories list component, used to display the list of categories on the categories page. + + +### Arguments + +#### `request: HttpRequest` + +The request object. + + +### Return value + +A Python `dict` with data for the categories list component. + +Must have at least two keys: `categories` and `template_name`: + +```python +{ + "categories": ..., + "template_name": "misago/categories/list.html" +} +``` + + +## Example + +The code below implements a custom filter function that replaces default categories component with a custom one. + +```python +from django.http import HttpRequest +from misago.categories.hooks import get_categories_component_hook + + +@get_categories_component_hook.append_filter +def custom_categories_list(action, request: HttpRequest) -> dict: + return { + "categories": [], + "template_name": "plugin/categories_list.html", + } +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/get-categories-page-metatags-hook.md b/dev-docs/plugins/hooks/get-categories-page-metatags-hook.md new file mode 100644 index 0000000000..d688a68a4c --- /dev/null +++ b/dev-docs/plugins/hooks/get-categories-page-metatags-hook.md @@ -0,0 +1,103 @@ +# `get_categories_page_metatags_hook` + +This hook wraps the standard function that Misago uses to get metatags for the categories page. + + +## Location + +This hook can be imported from `misago.categories.hooks`: + +```python +from misago.categories.hooks import get_categories_page_metatags_hook +``` + + +## Filter + +```python +def custom_get_categories_page_metatags_filter( + action: GetCategoriesPageMetatagsHookAction, + request: HttpRequest, + context: dict, +) -> dict[str, MetaTag]: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: GetCategoriesPageMetatagsHookAction` + +A standard Misago function used to get metatags for the categories page. + +See the [action](#action) section for details. + + +#### `request: HttpRequest` + +The request object. + + +#### `context: dict` + +The context to render the page with. + + +### Return value + +A Python `dict` with metatags to include in the response HTML. + + +## Action + +```python +def get_categories_page_metatags_action(request: HttpRequest, context: dict) -> dict[str, MetaTag]: + ... +``` + +A standard Misago function used to get metatags for the categories page. + + +### Arguments + +#### `request: HttpRequest` + +The request object. + + +#### `context: dict` + +The context to render the page with. + + +### Return value + +A Python `dict` with metatags to include in the response HTML. + + +## Example + +The code below implements a custom filter function that sets a custom metatag on the categories page, if its not used as the forum index page: + +```python +from django.http import HttpRequest +from misago.categories.hooks import get_categories_page_metatags_hook +from misago.metatags.metatag import MetaTag + + +@get_categories_page_metatags_hook.append_filter +def include_custom_metatag(action, request: HttpRequest, context) -> dict[str, MetaTag]: + metatags = action(request) + + if not context["is_index"]: + categories = len(context["categories_list"]) + metatags["description"] = MetaTag( + name="og:description", + property="twitter:description", + content=f"There are currently {categories} categories on our forums.", + ) + + return metatags +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/get-categories-query-values-hook.md b/dev-docs/plugins/hooks/get-categories-query-values-hook.md new file mode 100644 index 0000000000..9af5d51a6e --- /dev/null +++ b/dev-docs/plugins/hooks/get-categories-query-values-hook.md @@ -0,0 +1,58 @@ +# `get_categories_query_values_hook` + +This hook wraps the standard Misago function used to retrieve a set of arguments for the `values` call on the categories queryset. + + +## Location + +This hook can be imported from `misago.categories.hooks`: + +```python +from misago.categories.hooks import get_categories_query_values_hook +``` + + +## Filter + +```python +def custom_get_categories_query_values_filter(action: GetCategoriesQueryValuesHookAction) -> set[str]: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Return value + +A Python `set` with names of the `Category` model fields to include in the queryset. + + +## Action + +```python +def get_categories_query_values_action(self) -> set[str]: + ... +``` + +A standard Misago function used to retrieve a set of arguments for the `values` call on the categories queryset. + + +### Return value + +A Python `set` with names of the `Category` model fields to include in the queryset. + + +## Example + +The code below implements a custom filter function that includes the `plugin_data` field in the queryset. + +```python +from misago.categories.hooks import get_categories_query_values_hook + + +@get_categories_query_values_hook.append_filter +def include_plugin_data_in_query(action) -> set[str]: + fields = action(groups) + fields.add("plugin_data") + return fields +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/get-category-data-hook.md b/dev-docs/plugins/hooks/get-category-data-hook.md new file mode 100644 index 0000000000..bb06f7ee9d --- /dev/null +++ b/dev-docs/plugins/hooks/get-category-data-hook.md @@ -0,0 +1,75 @@ +# `get_category_data_hook` + +This hook wraps the standard function that Misago uses to build a `dict` with category data from queryset's result. + + +## Location + +This hook can be imported from `misago.categories.hooks`: + +```python +from misago.categories.hooks import get_category_data_hook +``` + + +## Filter + +```python +def custom_get_category_data_filter( + action: GetCategoryDataHookAction, result: dict[str, Any] +) -> dict[str, Any]: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +#### `result: dict[str, Any]` + +A `dict` with category data returned by the queryset. + + +### Return value + +A Python `dict` with category data to cache and use by Misago. + + +## Action + +```python +def get_category_data_action(result: dict[str, Any]) -> dict[str, Any]: + ... +``` + +A standard Misago function used to build a `dict` with category result from queryset's result. + + +### Arguments + +#### `result: dict[str, Any]` + +A `dict` with category data returned by the queryset. + + +### Return value + +A Python `dict` with category data to cache and use by Misago. + + +## Example + +The code below implements a custom filter function that includes a custom dict entry using `plugin_data`: + +```python +from typing import Any +from misago.categories.hooks import get_category_data_hook + + +@get_category_data_hook.append_filter +def include_plugin_permission_in_data(action, result: result[str, Any]) -> dict: + data = action(groups) + if result.get("plugin_data"): + data["plugin_flag"] = result["plugin_data"].get("plugin_flag") + + return data +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/get-posts-feed-item-user-ids-hook.md b/dev-docs/plugins/hooks/get-posts-feed-item-user-ids-hook.md deleted file mode 100644 index 92a6a6b664..0000000000 --- a/dev-docs/plugins/hooks/get-posts-feed-item-user-ids-hook.md +++ /dev/null @@ -1,57 +0,0 @@ -# `get_posts_feed_item_user_ids_hook` - -This hook enables plugins to include extra user IDs stored on posts in the query that Misago uses to retrieve `User`s to display on thread and private thread replies pages. - - -## Location - -This hook can be imported from `misago.threads.hooks`: - -```python -from misago.threads.hooks import get_posts_feed_item_user_ids_hook -``` - - -## Action - -```python -def custom_get_posts_feed_item_user_ids_filter( - request: HttpRequest, item: dict, user_ids: set[int] -): - ... -``` - -A function that finds user ids in the `item` and updates `user_ids` set with them. - - -### Arguments - -#### `item: dict` - -A `dict` with feed's item data. - - -#### `user_ids: set[int]` - -A `set` of `int`s being user ids to retrieve from the database that action should mutate calling its `add` or `update` methods. - - -## Example - -The code below implements a custom function that adds - -```python -from misago.threads.hooks import get_posts_feed_item_user_ids_hook - - -@get_posts_feed_item_user_ids_hook.append_action -def include_plugin_users( - item: dict, - user_ids: set[int], -): - if item["type"] != "post": - return - - if linked_user_ids := item["plugin_data"].get("linked_posts_users"): - user_ids.update(linked_user_ids) -``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/get-posts-feed-users-hook.md b/dev-docs/plugins/hooks/get-posts-feed-users-hook.md deleted file mode 100644 index 8a01238b9b..0000000000 --- a/dev-docs/plugins/hooks/get-posts-feed-users-hook.md +++ /dev/null @@ -1,105 +0,0 @@ -# `get_posts_feed_users_hook` - -This hook wraps the standard function that Misago uses to get a `dict` of `User` instances used to display thread posts feed. Users have their `group` field already populated. - - -## Location - -This hook can be imported from `misago.threads.hooks`: - -```python -from misago.threads.hooks import get_posts_feed_users_hook -``` - - -## Filter - -```python -def custom_get_posts_feed_users_filter( - action: GetThreadPostsFeedUsersHookAction, - request: HttpRequest, - user_ids: set[int], -) -> dict[int, 'User']: - ... -``` - -A function implemented by a plugin that can be registered in this hook. - - -### Arguments - -#### `action: GetThreadPostsFeedUsersHookAction` - -A standard Misago function used to get a `dict` of `User` instances used to display thread posts feed. Users have their `group` field populated. - -See the [action](#action) section for details. - - -#### `request: HttpRequest` - -The request object. - - -#### `user_ids: set[int]` - -A set of IDs of `User` objects to retrieve from the database - - -#### Return value - -A `dict` of `User` instances, indexed by their IDs. - - -## Action - -```python -def get_posts_feed_users_action(request: HttpRequest, user_ids: set[int]) -> dict[int, 'User']: - ... -``` - -A standard Misago function used to get a `dict` of `User` instances used to display thread posts feed. Users have their `group` field already populated. - - -### Arguments - -#### `request: HttpRequest` - -The request object. - - -#### `user_ids: set[int]` - -A set of IDs of `User` objects to retrieve from the database - - -#### Return value - -A `dict` of `User` instances, indexed by their IDs. - - -## Example - -The code below implements a custom filter function that removes some users from the dictionary, making them display on a posts feed as deleted users. - -```python -from typing import TYPE_CHECKING - -from django.http import HttpRequest -from misago.threads.hooks import get_posts_feed_users_hook - -if TYPE_CHECKING: - from misago.users.models import User - - -@get_posts_feed_users_hook.append_filter -def replace_post_poster( - action, request: HttpRequest, user_ids: set[int] -) -> dict[int, "User"]: - users = action(request, user_ids) - - for user_id, user in list(users.items()) - if user.plugin_data.get("is_hidden"): - del users[user_id] - - return users -``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/reference.md b/dev-docs/plugins/hooks/reference.md index 2fd8c872c3..e671639bd8 100644 --- a/dev-docs/plugins/hooks/reference.md +++ b/dev-docs/plugins/hooks/reference.md @@ -4,6 +4,7 @@ This document contains a list of all standard plugin hooks existing in Misago. Hooks instances are importable from the following Python modules: +- [`misago.attachments.hooks`](#misago-attachments-hooks) - [`misago.categories.hooks`](#misago-categories-hooks) - [`misago.oauth2.hooks`](#misago-oauth2-hooks) - [`misago.parser.hooks`](#misago-parser-hooks) @@ -13,10 +14,29 @@ Hooks instances are importable from the following Python modules: - [`misago.users.hooks`](#misago-users-hooks) +## `misago.attachments.hooks` + +`misago.attachments.hooks` defines the following hooks: + +- [`delete_attachments_hook`](./delete-attachments-hook.md) +- [`delete_categories_attachments_hook`](./delete-categories-attachments-hook.md) +- [`delete_posts_attachments_hook`](./delete-posts-attachments-hook.md) +- [`delete_threads_attachments_hook`](./delete-threads-attachments-hook.md) +- [`delete_users_attachments_hook`](./delete-users-attachments-hook.md) +- [`get_attachment_details_page_context_data_hook`](./get-attachment-details-page-context-data-hook.md) +- [`get_attachment_plugin_data_hook`](./get-attachment-plugin-data-hook.md) +- [`serialize_attachment_hook`](./serialize-attachment-hook.md) + + ## `misago.categories.hooks` `misago.categories.hooks` defines the following hooks: +- [`delete_categories_hook`](./delete-categories-hook.md) +- [`get_categories_page_component_hook`](./get-categories-page-component-hook.md) +- [`get_categories_page_metatags_hook`](./get-categories-page-metatags-hook.md) +- [`get_categories_query_values_hook`](./get-categories-query-values-hook.md) +- [`get_category_data_hook`](./get-category-data-hook.md) ## `misago.oauth2.hooks` @@ -31,11 +51,11 @@ Hooks instances are importable from the following Python modules: `misago.parser.hooks` defines the following hooks: -- [`complete_markup_html_hook`](./complete-markup-html-hook.md) - [`create_parser_hook`](./create-parser-hook.md) - [`get_ast_metadata_users_queryset_hook`](./get-ast-metadata-users-queryset-hook.md) - [`render_ast_node_to_html_hook`](./render-ast-node-to-html-hook.md) - [`render_ast_node_to_plaintext_hook`](./render-ast-node-to-plaintext-hook.md) +- [`replace_rich_text_tokens_hook`](./replace-rich-text-tokens-hook.md) - [`setup_parser_context_hook`](./setup-parser-context-hook.md) - [`update_ast_metadata_from_node_hook`](./update-ast-metadata-from-node-hook.md) - [`update_ast_metadata_hook`](./update-ast-metadata-hook.md) @@ -48,19 +68,25 @@ Hooks instances are importable from the following Python modules: - [`build_user_category_permissions_hook`](./build-user-category-permissions-hook.md) - [`build_user_permissions_hook`](./build-user-permissions-hook.md) +- [`can_upload_private_threads_attachments_hook`](./can-upload-private-threads-attachments-hook.md) +- [`can_upload_threads_attachments_hook`](./can-upload-threads-attachments-hook.md) - [`check_browse_category_permission_hook`](./check-browse-category-permission-hook.md) -- [`check_edit_post_permission_hook`](./check-edit-post-permission-hook.md) +- [`check_download_attachment_permission_hook`](./check-download-attachment-permission-hook.md) - [`check_edit_private_thread_permission_hook`](./check-edit-private-thread-permission-hook.md) - [`check_edit_private_thread_post_permission_hook`](./check-edit-private-thread-post-permission-hook.md) - [`check_edit_thread_permission_hook`](./check-edit-thread-permission-hook.md) +- [`check_edit_thread_post_permission_hook`](./check-edit-thread-post-permission-hook.md) - [`check_post_in_closed_category_permission_hook`](./check-post-in-closed-category-permission-hook.md) - [`check_post_in_closed_thread_permission_hook`](./check-post-in-closed-thread-permission-hook.md) - [`check_private_threads_permission_hook`](./check-private-threads-permission-hook.md) - [`check_reply_private_thread_permission_hook`](./check-reply-private-thread-permission-hook.md) - [`check_reply_thread_permission_hook`](./check-reply-thread-permission-hook.md) - [`check_see_category_permission_hook`](./check-see-category-permission-hook.md) +- [`check_see_post_permission_hook`](./check-see-post-permission-hook.md) - [`check_see_private_thread_permission_hook`](./check-see-private-thread-permission-hook.md) +- [`check_see_private_thread_post_permission_hook`](./check-see-private-thread-post-permission-hook.md) - [`check_see_thread_permission_hook`](./check-see-thread-permission-hook.md) +- [`check_see_thread_post_permission_hook`](./check-see-thread-post-permission-hook.md) - [`check_start_private_threads_permission_hook`](./check-start-private-threads-permission-hook.md) - [`check_start_thread_permission_hook`](./check-start-thread-permission-hook.md) - [`copy_category_permissions_hook`](./copy-category-permissions-hook.md) @@ -111,6 +137,7 @@ Hooks instances are importable from the following Python modules: `misago.threads.hooks` defines the following hooks: +- [`create_prefetch_posts_related_objects_hook`](./create-prefetch-posts-related-objects-hook.md) - [`get_category_threads_page_context_data_hook`](./get-category-threads-page-context-data-hook.md) - [`get_category_threads_page_filters_hook`](./get-category-threads-page-filters-hook.md) - [`get_category_threads_page_moderation_actions_hook`](./get-category-threads-page-moderation-actions-hook.md) @@ -121,8 +148,6 @@ Hooks instances are importable from the following Python modules: - [`get_edit_private_thread_post_page_context_data_hook`](./get-edit-private-thread-post-page-context-data-hook.md) - [`get_edit_thread_page_context_data_hook`](./get-edit-thread-page-context-data-hook.md) - [`get_edit_thread_post_page_context_data_hook`](./get-edit-thread-post-page-context-data-hook.md) -- [`get_posts_feed_item_user_ids_hook`](./get-posts-feed-item-user-ids-hook.md) -- [`get_posts_feed_users_hook`](./get-posts-feed-users-hook.md) - [`get_private_thread_replies_page_context_data_hook`](./get-private-thread-replies-page-context-data-hook.md) - [`get_private_thread_replies_page_posts_queryset_hook`](./get-private-thread-replies-page-posts-queryset-hook.md) - [`get_private_thread_replies_page_thread_queryset_hook`](./get-private-thread-replies-page-thread-queryset-hook.md) @@ -145,7 +170,7 @@ Hooks instances are importable from the following Python modules: - [`get_threads_page_queryset_hook`](./get-threads-page-queryset-hook.md) - [`get_threads_page_subcategories_hook`](./get-threads-page-subcategories-hook.md) - [`get_threads_page_threads_hook`](./get-threads-page-threads-hook.md) -- [`set_posts_feed_item_users_hook`](./set-posts-feed-item-users-hook.md) +- [`set_posts_feed_related_objects_hook`](./set-posts-feed-related-objects-hook.md) ## `misago.users.hooks` diff --git a/dev-docs/plugins/hooks/replace-rich-text-tokens-hook.md b/dev-docs/plugins/hooks/replace-rich-text-tokens-hook.md new file mode 100644 index 0000000000..54dbeae14b --- /dev/null +++ b/dev-docs/plugins/hooks/replace-rich-text-tokens-hook.md @@ -0,0 +1,102 @@ +# `replace_rich_text_tokens_hook` + +This hook wraps the standard function that Misago uses to replace rich-text tokens in pre-rendered HTML or the next filter from another plugin. + +Tokens are pseudo-HTML elements like `` that are replaced with real HTML markup instead. + + +## Location + +This hook can be imported from `misago.parser.hooks`: + +```python +from misago.parser.hooks import replace_rich_text_tokens_hook +``` + + +## Filter + +```python +def custom_replace_rich_text_tokens_filter( + action: ReplaceRichTextTokensHookAction, html: str, data: dict +) -> str: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: ReplaceRichTextTokensHookAction` + +A standard Misago function used to replace rich-text tokens in pre-rendered HTML or the next filter from another plugin. + +See the [action](#action) section for details. + + +#### `html: str` + +An HTML string in which tokens will be replaced. + + +#### `data: dict` + +Data that can be embedded in HTML. + + +### Return value + +A `str` with HTML that has its tokens replaced. + + +## Action + +```python +def replace_rich_text_tokens_action(html: str, data: dict) -> str: + ... +``` + +A standard Misago function used to replace rich-text tokens in pre-rendered HTML or the next filter from another plugin. + + +### Arguments + +#### `html: str` + +An HTML string in which tokens will be replaced. + + +#### `data: dict` + +Data that can be embedded in HTML. + + +### Return value + +A `str` with HTML that has its tokens replaced. + + +## Example + +The code below implements a custom filter function that replaces default spoiler block summary with a custom message: + +```python +from misago.parser.context import ParserContext +from misago.parser.html import SPOILER_SUMMARY + + +@replace_rich_text_tokens_hook.append_filter +def replace_rich_text_spoiler_hoom( + action: ReplaceRichTextTokensHookAction, + html: str, + data: dict, +) -> str: + if SPOILER_SUMMARY in html: + html = html.replace( + SPOILER_SUMMARY, "SPOILER! Click at your own discretion!" + ) + + # Call the next function in chain + return action(context, html, **kwargs) +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/serialize-attachment-hook.md b/dev-docs/plugins/hooks/serialize-attachment-hook.md new file mode 100644 index 0000000000..f665c594ec --- /dev/null +++ b/dev-docs/plugins/hooks/serialize-attachment-hook.md @@ -0,0 +1,84 @@ +# `serialize_attachment_hook` + +This hook wraps the standard function that Misago uses to create a JSON-serializable `dict` for an attachment. + + +## Location + +This hook can be imported from `misago.attachments.hooks`: + +```python +from misago.attachments.hooks import serialize_attachment_hook +``` + + +## Filter + +```python +def custom_serialize_attachment_filter( + action: SerializeAttachmentHookAction, attachment: Attachment +) -> dict: + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: SerializeAttachmentHookAction` + +A standard function that Misago uses to create a JSON-serializable `dict` for an attachment. + +See the [action](#action) section for details. + + +#### `attachment: Attachment` + +The `Attachment` instance to serialize. + + +### Return value + +A JSON-serializable `dict`. + + +## Action + +```python +def serialize_attachment_action(attachment: Attachment) -> dict: + ... +``` + +A standard function that Misago uses to create a JSON-serializable `dict` for an attachment. + + +### Arguments + +#### `attachment: Attachment` + +The `Attachment` instance to serialize. + + +### Return value + +A JSON-serializable `dict`. + + +## Example + +The code below implements a custom filter function that includes image's EXIF data in serialized payload + +```python +from misago.attachments.hooks import serialize_attachment_hook +from misago.attachments.models import Attachment + + +@serialize_attachment_hook.append_filter +def serialize_attachment_exif_data( + action, attachment: Attachment +) -> dict: + data = action(attachment) + data["exif"] = attachment.plugin_data.get("exif) + return data +``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/set-posts-feed-item-users-hook.md b/dev-docs/plugins/hooks/set-posts-feed-item-users-hook.md deleted file mode 100644 index 08581f3b45..0000000000 --- a/dev-docs/plugins/hooks/set-posts-feed-item-users-hook.md +++ /dev/null @@ -1,92 +0,0 @@ -# `set_posts_feed_item_users_hook` - -This hook wraps the standard function that Misago uses to set `User` instances on a `dict` with thread posts feed item's data. - - -## Location - -This hook can be imported from `misago.threads.hooks`: - -```python -from misago.threads.hooks import set_posts_feed_item_users_hook -``` - - -## Filter - -```python -def custom_set_posts_feed_item_users_filter( - action: SetPostFeedItemUsersHookAction, - users: dict[int, 'User'], - item: dict, -): - ... -``` - -A function implemented by a plugin that can be registered in this hook. - - -### Arguments - -#### `action: SetPostFeedItemUsersHookAction` - -A standard Misago function used to set `User` instances on a `dict` with thread posts feed item's data. - -See the [action](#action) section for details. - - -#### `users: dict[int, "User"]` - -A `dict` of `User` instances, indexed by their IDs. - - -#### `item: dict` - -A `dict` with posts feed item's data. Hook should update it using the `User` instances from the `users`. - - -## Action - -```python -def set_posts_feed_item_users_action(users: dict[int, 'User'], item: dict): - ... -``` - -A standard Misago function used to set `User` instances on a `dict` with thread posts feed item's data. - - -### Arguments - -#### `users: dict[int, "User"]` - -A `dict` of `User` instances, indexed by their IDs. - - -#### `item: dict` - -A `dict` with posts feed item's data. Hook should update it using the `User` instances from the `users`. - - -## Example - -The code below implements a custom filter function that replaces post's real author with other one: - -```python -from typing import TYPE_CHECKING - -from misago.threads.hooks import set_posts_feed_item_users_hook - -if TYPE_CHECKING: - from misago.users.models import User - - -@set_posts_feed_item_users_hook.append_filter -def replace_post_poster( - action, users: dict[int, "User"], item: dict -): - action(users, item) - - if item["type"] == "post": - if override_poster := item["post"].plugin_data.get("poster_id"): - item["poster"] = users[override_poster] -``` \ No newline at end of file diff --git a/dev-docs/plugins/hooks/set-posts-feed-related-objects-hook.md b/dev-docs/plugins/hooks/set-posts-feed-related-objects-hook.md new file mode 100644 index 0000000000..617f9b9868 --- /dev/null +++ b/dev-docs/plugins/hooks/set-posts-feed-related-objects-hook.md @@ -0,0 +1,90 @@ +# `set_posts_feed_related_objects_hook` + +This hook wraps the standard function that Misago uses to set related objects on dicts containing posts feed data. + + +## Location + +This hook can be imported from `misago.threads.hooks`: + +```python +from misago.threads.hooks import set_posts_feed_related_objects_hook +``` + + +## Filter + +```python +def custom_set_posts_feed_related_objects_filter( + action: SetPostsFeedRelatedObjectsHookAction, + feed: list[dict], + related_objects: dict, +): + ... +``` + +A function implemented by a plugin that can be registered in this hook. + + +### Arguments + +#### `action: SetPostsFeedRelatedObjectsHookAction` + +A standard Misago function used to set related objects on dicts containing posts feed data. + +See the [action](#action) section for details. + + +#### `feed: list[dict]` + +A list of `dict` objects with post feed items. This function updates these dicts with objects from the `related_objects` dictionary. + + +#### `related_objects: dict` + +A `dict` with objects related to the feed's items. + + +## Action + +```python +def set_posts_feed_related_objects_action(feed: list[dict], related_objects: dict): + ... +``` + +A standard Misago function used to set related objects on dicts containing posts feed data. + + +### Arguments + +#### `feed: list[dict]` + +A list of `dict` objects with post feed items. This function updates these dicts with objects from the `related_objects` dictionary. + + +#### `related_objects: dict` + +A `dict` with objects related to the feed's items. + + +## Example + +The code below implements a custom filter function that populates feed's items with plugin objects + +```python +from misago.threads.hooks import set_posts_feed_related_objects_hook + + +@set_posts_feed_related_objects_hook.append_filter +def replace_post_poster( + action, feed: list[dict], related_objects: dict +): + action(feed, related_objects) + + for item in feed: + if item["type"] == "post": + plugin_obj = related_objects["plugin_objects"].get( + item["post"].plugin_data["plugin_relation_id"] + ) + item["plugin_attr"] = plugin_obj +``` \ No newline at end of file diff --git a/dev-docs/plugins/template-outlets-reference.md b/dev-docs/plugins/template-outlets-reference.md index ab3f004bba..0b225ee3da 100644 --- a/dev-docs/plugins/template-outlets-reference.md +++ b/dev-docs/plugins/template-outlets-reference.md @@ -3,9 +3,9 @@ This document contains a list of all built-in template outlets in Misago. -## `ADMIN_DASHBOARD_AFTER_ANALYTICS` +## `ADMIN_DASHBOARD_START` -On the Admin dashboard page, below the Analytics card. +On the Admin dashboard page, above all other content. ## `ADMIN_DASHBOARD_AFTER_CHECKS` @@ -13,39 +13,44 @@ On the Admin dashboard page, below the Analytics card. On the Admin dashboard page, below the Checks card. +## `ADMIN_DASHBOARD_AFTER_ANALYTICS` + +On the Admin dashboard page, below the Analytics card. + + ## `ADMIN_DASHBOARD_END` On the Admin dashboard page, below all other content. -## `ADMIN_DASHBOARD_START` +## `ATTACHMENT_PAGE_START` -On the Admin dashboard page, above all other content. +On the attachment details page, above the preview. -## `CATEGORIES_LIST_END` +## `ATTACHMENT_PAGE_AFTER_PREVIEW` -On the Categories page, below the list. +On the attachment details page, under the preview. -## `CATEGORIES_LIST_START` +## `ATTACHMENT_PAGE_END` -On the Categories page, above the list. +On the attachment details page, under the details block. -## `CATEGORY_THREADS_LIST_END` +## `ATTACHMENT_DELETE_PAGE_START` -On the Category threads page, below the list. +On the attachment delete page, above the confirmation block. -## `CATEGORY_THREADS_LIST_MIDDLE` +## `ATTACHMENT_DELETE_PAGE_END` -On the Category threads page, between the subcategories and the list. +On the attachment delete page, below the confirmation block. -## `CATEGORY_THREADS_LIST_START` +## `LOGIN_PAGE_START` -On the Category threads page, above the list. +On the Sign in page, above the form. ## `LOGIN_PAGE_END` @@ -53,44 +58,44 @@ On the Category threads page, above the list. On the Sign in page, below the form. -## `LOGIN_PAGE_START` +## `CATEGORIES_LIST_START` -On the Sign in page, above the form. +On the Categories page, above the list. -## `MARKUP_EDITOR_TOOLBAR_BEFORE_LINK` +## `CATEGORIES_LIST_END` -On the the markup editor's toolbar, between insert horizontal ruler and insert link. +On the Categories page, below the list. -## `MARKUP_EDITOR_TOOLBAR_BEFORE_QUOTE` +## `THREADS_LIST_START` -On the the markup editor's toolbar, between insert photo and insert quote. +On the Threads page, above the list. -## `MARKUP_EDITOR_TOOLBAR_BEFORE_RULER` +## `THREADS_LIST_MIDDLE` -On the the markup editor's toolbar, between strikethrough and insert horizontal. +On the Threads page, between the subcategories and the list. -## `MARKUP_EDITOR_TOOLBAR_BEFORE_UPLOAD` +## `THREADS_LIST_END` -On the the markup editor's toolbar, between insert code block and upload. +On the Threads page, below the list. -## `MARKUP_EDITOR_TOOLBAR_END` +## `CATEGORY_THREADS_LIST_START` -At the end of the markup editor's toolbar. +On the Category threads page, above the list. -## `MARKUP_EDITOR_TOOLBAR_START` +## `CATEGORY_THREADS_LIST_MIDDLE` -At the start of the markup editor's toolbar. +On the Category threads page, between the subcategories and the list. -## `PRIVATE_THREADS_LIST_END` +## `CATEGORY_THREADS_LIST_END` -On the Private threads page, below the list. +On the Category threads page, below the list. ## `PRIVATE_THREADS_LIST_START` @@ -98,101 +103,116 @@ On the Private threads page, below the list. On the Private threads page, above the list. -## `PRIVATE_THREAD_REPLIES_PAGE_END` +## `PRIVATE_THREADS_LIST_END` -On the Private thread replies page, above the bottom breadcrumbs. +On the Private threads page, below the list. -## `PRIVATE_THREAD_REPLIES_PAGE_START` +## `THREADS_LIST_TOOLBAR_START` -On the Private thread replies page, below the page's header. +On threads lists pages, at the start of the toolbar. -## `PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_AFTER_SPACER` +## `THREADS_LIST_TOOLBAR_BEFORE_SPACER` -On the Private thread replies page, after the toolbar's spacer. +On threads lists pages, before the toolbar's spacer. -## `PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_BEFORE_SPACER` +## `THREADS_LIST_TOOLBAR_AFTER_SPACER` -On the Private thread replies page, before the toolbar's spacer. +On threads lists pages, after the toolbar's spacer. -## `PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_END` +## `THREADS_LIST_TOOLBAR_END` -On the Private thread replies page, at the end of the toolbar. +On threads lists pages, at the end of the toolbar. -## `PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_START` +## `THREAD_REPLIES_PAGE_START` -On the Private thread replies page, at the start of the toolbar. +On the Thread replies page, below the page's header. -## `TEST` +## `THREAD_REPLIES_PAGE_END` -Used in some tests. +On the Thread replies page, above the bottom breadcrumbs. -## `THREADS_LIST_END` +## `THREAD_REPLIES_PAGE_TOOLBAR_START` -On the Threads page, below the list. +On the Thread replies page, at the start of the toolbar. -## `THREADS_LIST_MIDDLE` +## `THREAD_REPLIES_PAGE_TOOLBAR_BEFORE_SPACER` -On the Threads page, between the subcategories and the list. +On the Thread replies page, before the toolbar's spacer. -## `THREADS_LIST_START` +## `THREAD_REPLIES_PAGE_TOOLBAR_AFTER_SPACER` -On the Threads page, above the list. +On the Thread replies page, after the toolbar's spacer. -## `THREADS_LIST_TOOLBAR_AFTER_SPACER` +## `THREAD_REPLIES_PAGE_TOOLBAR_END` -On threads lists pages, after the toolbar's spacer. +On the Thread replies page, at the end of the toolbar. -## `THREADS_LIST_TOOLBAR_BEFORE_SPACER` +## `PRIVATE_THREAD_REPLIES_PAGE_START` -On threads lists pages, before the toolbar's spacer. +On the Private thread replies page, below the page's header. -## `THREADS_LIST_TOOLBAR_END` +## `PRIVATE_THREAD_REPLIES_PAGE_END` -On threads lists pages, at the end of the toolbar. +On the Private thread replies page, above the bottom breadcrumbs. -## `THREADS_LIST_TOOLBAR_START` +## `PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_START` -On threads lists pages, at the start of the toolbar. +On the Private thread replies page, at the start of the toolbar. -## `THREAD_REPLIES_PAGE_END` +## `PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_BEFORE_SPACER` -On the Thread replies page, above the bottom breadcrumbs. +On the Private thread replies page, before the toolbar's spacer. -## `THREAD_REPLIES_PAGE_START` +## `PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_AFTER_SPACER` -On the Thread replies page, below the page's header. +On the Private thread replies page, after the toolbar's spacer. -## `THREAD_REPLIES_PAGE_TOOLBAR_AFTER_SPACER` +## `PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_END` -On the Thread replies page, after the toolbar's spacer. +On the Private thread replies page, at the end of the toolbar. -## `THREAD_REPLIES_PAGE_TOOLBAR_BEFORE_SPACER` +## `MARKUP_EDITOR_TOOLBAR_START` -On the Thread replies page, before the toolbar's spacer. +At the start of the markup editor's toolbar. -## `THREAD_REPLIES_PAGE_TOOLBAR_END` +## `MARKUP_EDITOR_TOOLBAR_BEFORE_RULER` -On the Thread replies page, at the end of the toolbar. +On the the markup editor's toolbar, between strikethrough and insert horizontal. -## `THREAD_REPLIES_PAGE_TOOLBAR_START` +## `MARKUP_EDITOR_TOOLBAR_BEFORE_LINK` + +On the the markup editor's toolbar, between insert horizontal ruler and insert link. + + +## `MARKUP_EDITOR_TOOLBAR_BEFORE_QUOTE` + +On the the markup editor's toolbar, between insert photo and insert quote. + + +## `MARKUP_EDITOR_TOOLBAR_END` + +At the end of the markup editor's toolbar. + + +## `TEST` -On the Thread replies page, at the start of the toolbar. \ No newline at end of file +Used in some tests. \ No newline at end of file diff --git a/devproject/settings.py b/devproject/settings.py index a049b76f54..b0c04fe2e8 100644 --- a/devproject/settings.py +++ b/devproject/settings.py @@ -279,6 +279,11 @@ # Misago specific settings # https://misago.readthedocs.io/en/latest/developers/settings.html +# Use Django's FileResponse to serve attachments in dev server + +MISAGO_ATTACHMENTS_SERVER = "misago.attachments.servers.django_file_response" + + # On dev instance, generate only three sizes of avatars instead of default 6 sizes. MISAGO_AVATARS_SIZES = [400, 200, 100] diff --git a/devproject/test_settings.py b/devproject/test_settings.py index a605a4ba4e..d4117e2d14 100644 --- a/devproject/test_settings.py +++ b/devproject/test_settings.py @@ -32,6 +32,9 @@ {"NAME": "django.contrib.auth.password_validation.NumericPasswordValidator"}, ] +# Use Django's redirects for serving attachments +MISAGO_ATTACHMENTS_SERVER = "misago.attachments.servers.django_redirect_response" + # Use english search config MISAGO_SEARCH_CONFIG = "english" diff --git a/frontend/src/animations.js b/frontend/src/animations.js new file mode 100644 index 0000000000..12155a080b --- /dev/null +++ b/frontend/src/animations.js @@ -0,0 +1,21 @@ +export function deleteElement(element, callback) { + element.classList.remove("animation-fade-in") + + element + .querySelectorAll("button, input, select, textarea") + .forEach((child) => { + child.setAttribute("disabled", "") + }) + + element.addEventListener("animationend", ({ animationName }) => { + if (animationName === "deleteElementAnimation") { + element.remove() + + if (callback) { + callback() + } + } + }) + + element.classList.add("animation-delete") +} diff --git a/frontend/src/csrf.js b/frontend/src/csrf.js new file mode 100644 index 0000000000..dce07d9a8a --- /dev/null +++ b/frontend/src/csrf.js @@ -0,0 +1,17 @@ +export const CSRF_FIELD_NAME = "csrfmiddlewaretoken" + +export function getCSRFToken() { + const element = document.querySelector( + 'input[name="' + CSRF_FIELD_NAME + '"]' + ) + + if (element) { + return element.value + } + + return null +} + +export function appendCSRFTokenToForm(form) { + form.append(CSRF_FIELD_NAME, getCSRFToken()) +} diff --git a/frontend/src/editor/editor.js b/frontend/src/editor/editor.js index d325b7b88d..5d27a80b58 100644 --- a/frontend/src/editor/editor.js +++ b/frontend/src/editor/editor.js @@ -1,4 +1,6 @@ import htmx from "htmx.org" +import * as animations from "../animations" +import MarkupEditorUploader from "./uploader" import { MarkupEditorCodeModal, MarkupEditorImageModal, @@ -118,7 +120,7 @@ class MarkupEditor { const toolbar = element.querySelector(".markup-editor-toolbar-left") let btnWidth = 0 - element.querySelectorAll("button").forEach((child) => { + toolbar.querySelectorAll("button").forEach((child) => { let childWidth = child.clientWidth const childStyle = window.getComputedStyle(child) childWidth += parseInt(parseFloat(childStyle.borderLeftWidth)) @@ -148,6 +150,8 @@ class MarkupEditor { this._setEditorActive(element) this._setEditorFocus(element) this._setEditorActions(element) + this._setEditorPasteUpload(element) + this._setEditorDropUpload(element) this._resizeEditor(element) } } @@ -157,35 +161,51 @@ class MarkupEditor { } _setEditorFocus(element) { - element.addEventListener("focusin", () => { - element.classList.add("markup-editor-focused") + const focusEvents = ["focusin", "click"] + const className = "markup-editor-focused" + + focusEvents.forEach((event) => { + element.addEventListener(event, () => { + element.classList.add(className) + }) }) - element.addEventListener("focusout", () => { - element.classList.remove("markup-editor-focused") + focusEvents.forEach((event) => { + document.addEventListener(event, (event) => { + if (!element.contains(event.target)) { + element.classList.remove(className) + } + }) }) } _setEditorActions(element) { - const input = element.querySelector("textarea") + const textarea = this.getTextarea(element) - element.querySelectorAll("[misago-editor-action]").forEach((control) => { - const actionName = control.getAttribute("misago-editor-action") - control.addEventListener("click", (event) => { - event.preventDefault() + element.addEventListener("click", (event) => { + const target = event.target.closest("[misago-editor-action]") + if (!target) { + return null + } - const action = this.actions[actionName] - if (action) { - action({ - input, - target: event.target, - editor: this, - selection: new MarkupEditorSelection(input), - }) - } else { - console.warn("Undefined editor action: " + actionName) - } - }) + const actionName = target.getAttribute("misago-editor-action") + if (!actionName) { + return null + } + + event.preventDefault() + + const action = this.actions[actionName] + if (action) { + action({ + textarea, + target, + editor: this, + selection: new MarkupEditorSelection(textarea), + }) + } else { + console.warn("Undefined editor action: " + actionName) + } }) element @@ -202,6 +222,80 @@ class MarkupEditor { }) } + _setEditorPasteUpload = (element) => { + element.addEventListener("paste", (event) => { + const uploader = new MarkupEditorUploader(this, element) + if (!uploader.canUpload) { + uploader.showPermissionDeniedError() + } else if (event.clipboardData.files) { + event.preventDefault() + const textarea = event.target.closest("textarea") + uploader.uploadFiles(event.clipboardData.files, textarea) + } + }) + } + + _setEditorDropUpload = (element) => { + const className = "markup-editor-drag-drop" + const elements = [element.querySelector("textarea")] + + const attachments = element.querySelector("[misago-editor-attachments]") + if (attachments) { + elements.push(attachments) + } + + elements.forEach((child) => { + child.addEventListener("drop", (event) => { + const uploader = new MarkupEditorUploader(this, element) + if (event.dataTransfer.files) { + event.preventDefault() + if (!uploader.canUpload) { + uploader.showPermissionDeniedError() + } else if (event.dataTransfer.files) { + const textarea = event.target.closest("textarea") + uploader.uploadFiles(event.dataTransfer.files, textarea) + } + } + + child.classList.remove(className) + }) + + child.addEventListener("dragenter", (event) => { + event.preventDefault() + }) + + child.addEventListener("dragleave", () => { + child.classList.remove(className) + }) + + child.addEventListener("dragover", (event) => { + child.classList.add(className) + event.preventDefault() + }) + }) + } + + getTextarea(element) { + return element.querySelector("textarea") + } + + getSelection(textarea) { + return new MarkupEditorSelection(textarea) + } + + showFilePrompt(element, options) { + const uploader = new MarkupEditorUploader( + this, + element.closest("[misago-editor-active]") + ) + + if (!uploader.canUpload) { + uploader.showPermissionDeniedError() + } else { + uploader.prompt(options) + } + } + showCodeModal(selection) { this.codeModal.show(selection) } @@ -217,11 +311,26 @@ class MarkupEditor { showQuoteModal(selection) { this.quoteModal.show(selection) } + + getAttachmentByKey(key) { + return document.querySelector('[misago-editor-upload-key="' + key + '"]') + } + + removeAttachmentElement(element) { + const list = element.closest("ul") + + animations.deleteElement(element, function () { + if (!list.querySelector("li")) { + const container = list.closest(".markup-editor-attachments-list") + container.classList.add("d-none") + } + }) + } } class MarkupEditorSelection { - constructor(input) { - this.input = input + constructor(textarea) { + this.textarea = textarea this._range = this._getRange() } @@ -254,7 +363,7 @@ class MarkupEditorSelection { value += prefix + this._range.text + suffix value += this._range.suffix - this.input.value = value + this.textarea.value = value this._range.start += prefix.length this._range.end += prefix.length @@ -265,7 +374,7 @@ class MarkupEditorSelection { replace(text, options) { const value = this._range.prefix + text + this._range.suffix - this.input.value = value + this.textarea.value = value if (options && options.start) { this._range.start += options.start @@ -287,35 +396,92 @@ class MarkupEditorSelection { this.refocus() } + insert(text, options) { + const whitespace = (options && options.whitespace) || "" + + const prefix = whitespace + ? this._range.prefix.trimEnd() + : this._range.prefix + const suffix = whitespace ? this._range.suffix.trim() : this._range.suffix + + let whitespaces = 1 + let value = prefix + + if (prefix.length && whitespace) { + value += whitespace + whitespaces += 1 + } + + value += text + whitespace + suffix + this.textarea.value = value + + const caret = prefix.length + text.length + whitespace.length * whitespaces + this._range.end = this._range.start = caret + this._range.length = 0 + + this.refocus() + } + + replaceAttachments(callback) { + this.textarea.value = this.textarea.value.replace( + //gi, + function (match, p1) { + if (p1.match(/:/g).length !== 1) { + return match + } + + let value = p1.trim() + while (value.substring(0, 1) === '"') { + value = value.substring(1) + } + while (value.substring(value.length - 1) === '"') { + value = value.substring(0, value.length - 1) + } + + const name = value.substring(0, value.indexOf(":")).trim() + const id = value.substring(value.indexOf(":") + 1).trim() + + if ((name, id)) { + const result = callback({ match, name, id }) + if (typeof result === "string" || result instanceof String) { + return result + } + } + + return match + } + ) + } + refocus() { window.setTimeout(() => { - const scroll = this.input.scrollTop - this.input.focus() - this.input.scrollTop = scroll + const scroll = this.textarea.scrollTop + this.textarea.focus() + this.textarea.scrollTop = scroll const caret = this._range.start - this.input.setSelectionRange(caret, caret + this._range.length) + this.textarea.setSelectionRange(caret, caret + this._range.length) }, 250) } _getRange() { if (document.selection) { - this.input.focus() + this.textarea.focus() const range = document.selection.createRange() const length = range.text.length - range.moveStart("character", -this.input.value.length) + range.moveStart("character", -this.textarea.value.length) return this._createRange( - this.input, + this.textarea, range.text.length - length, range.text.length ) } - if (this.input.selectionStart || this.input.selectionStart == "0") { + if (this.textarea.selectionStart || this.textarea.selectionStart == "0") { return this._createRange( - this.input, - this.input.selectionStart, - this.input.selectionEnd + this.textarea, + this.textarea.selectionStart, + this.textarea.selectionEnd ) } } @@ -370,7 +536,7 @@ editor.setAction("strikethrough", function ({ selection }) { }) editor.setAction("horizontal-ruler", function ({ selection }) { - selection.replace("\n\n- - -\n\n", { start: 9 }) + selection.insert("- - -", { whitespace: "\n\n" }) }) editor.setAction("link", function ({ editor, selection }) { @@ -405,6 +571,74 @@ editor.setAction("code", function ({ editor, selection }) { editor.showCodeModal(selection) }) +editor.setAction("attachment", function ({ target, selection }) { + const attachment = target.getAttribute("misago-editor-attachment") + if (attachment) { + selection.insert("", { whitespace: "\n\n" }) + } +}) + +editor.setAction("image-upload", function ({ editor, target }) { + editor.showFilePrompt(target, { accept: "image", insert: true }) +}) + +editor.setAction("attachment-upload", function ({ editor, target }) { + editor.showFilePrompt(target) +}) + +editor.setAction("attachment-delete", function ({ editor, target, selection }) { + const attachment = target.getAttribute("misago-editor-attachment") + const name = target + .closest("[misago-editor-deleted-attachments-name]") + .getAttribute("misago-editor-deleted-attachments-name") + + selection.replaceAttachments(function ({ id }) { + if (id === attachment) { + return "" + } + + return false + }) + + const element = target.closest("li") + editor.removeAttachmentElement(element) + + const input = document.createElement("input") + input.setAttribute("type", "hidden") + input.setAttribute("name", name) + input.setAttribute("value", attachment) + + const attachments = target.closest("[misago-editor-attachments]") + attachments.appendChild(input) +}) + +editor.setAction( + "attachment-error-dismiss", + function ({ editor, target, selection }) { + const key = target.getAttribute("misago-editor-attachment-key") + + selection.replaceAttachments(function (attachment) { + if (attachment.id === key) { + return "" + } + + return false + }) + + const message = document.querySelector( + '[misago-editor-attachment-error="' + key + '"]' + ) + if (message) { + animations.deleteElement(message) + } + + const attachment = editor.getAttachmentByKey(key) + if (attachment) { + editor.removeAttachmentElement(attachment) + } + } +) + editor.setAction("formatting-help", function ({ target }) { const modal = document.getElementById("markup-editor-formatting-help") const element = target.closest("a") diff --git a/frontend/src/editor/modals.js b/frontend/src/editor/modals.js index 1934dbf207..39ca6ff259 100644 --- a/frontend/src/editor/modals.js +++ b/frontend/src/editor/modals.js @@ -6,8 +6,10 @@ class MarkupEditorModal { document.addEventListener("DOMContentLoaded", () => { this.element = this.getElement() - this.form = this.element.querySelector("form") - this.initForm(this.form) + if (this.element) { + this.form = this.element.querySelector("form") + this.initForm(this.form) + } }) } diff --git a/frontend/src/editor/uploader.js b/frontend/src/editor/uploader.js new file mode 100644 index 0000000000..547eb4e796 --- /dev/null +++ b/frontend/src/editor/uploader.js @@ -0,0 +1,427 @@ +import { appendCSRFTokenToForm } from "../csrf" +import getRandomString from "../getRandomString" +import renderTemplate from "../renderTemplate" +import * as snackbar from "../snackbars" + +export default class MarkupEditorUploader { + constructor(editor, element) { + this.editor = editor + + this.element = element + this.textarea = editor.getTextarea(element) + + this.lists = { + media: element.querySelector('[misago-editor-attachments="media"]'), + other: element.querySelector('[misago-editor-attachments="other"]'), + } + + this.templates = { + error: document.getElementById("attachment-upload-error-template"), + media: document.getElementById("attachment-media-template"), + mediaFooter: document.getElementById("attachment-media-footer-template"), + mediaFailedFooter: document.getElementById( + "attachment-media-failed-footer-template" + ), + other: document.getElementById("attachment-other-template"), + otherFailed: document.getElementById("attachment-other-failed-template"), + otherUploaded: document.getElementById( + "attachment-other-uploaded-template" + ), + } + + const attachmentsElement = element.querySelector( + "[misago-editor-attachments]" + ) + this.field = { + name: element.getAttribute("misago-editor-attachments-name"), + element: attachmentsElement, + } + + this.accept = { + all: this._getAcceptedExtensions( + attachmentsElement.getAttribute("misago-editor-accept-attachments") + ), + image: this._getAcceptedExtensions( + attachmentsElement.getAttribute("misago-editor-accept-image") + ), + video: this._getAcceptedExtensions( + attachmentsElement.getAttribute("misago-editor-accept-video") + ), + } + + this.uploadUrl = this._getUploadUrl(element) + this.canUpload = !!this.uploadUrl && !!this.accept.all + } + + _getUploadUrl(element) { + return element.getAttribute("misago-editor-attachments-url") || null + } + + _getAcceptedExtensions(extensions) { + return extensions.split(",").map((item) => item.trim()) + } + + showPermissionDeniedError() { + snackbar.error( + pgettext("markup editor upload", "You can't upload attachments") + ) + } + + prompt(options) { + const accept = options ? options.accept : "all" + const insert = options ? options.insert : false + + const input = document.createElement("input") + input.setAttribute("type", "file") + input.setAttribute( + "accept", + (this.accept[accept] || this.accept.all).join(",") + ) + input.setAttribute("multiple", true) + input.classList.add("d-none") + + input.addEventListener("change", (event) => { + const files = event.target.files + if (files.length) { + this.uploadFiles(files, insert) + } + input.remove() + }) + + this.element.appendChild(input) + input.click() + } + + _getAcceptAttributeStr(accept) { + return (this.accept[accept] || this.accept.all).join(",") + } + + uploadFiles(files, insert) { + const allowedFiles = [] + + for (let i = 0; i < files.length; i++) { + const file = files[i] + if (this._isFileTypeAccepted(file)) { + allowedFiles.push(file) + } else { + snackbar.error( + pgettext( + "markup editor upload", + "%(name)s: uploaded file type is not allowed." + ).replace("%(name)s", file.name) + ) + } + } + + if (!allowedFiles) { + return { keys: [], files: [] } + } + + const keys = [] + const elements = {} + + const data = new FormData() + appendCSRFTokenToForm(data) + + allowedFiles.forEach((file) => { + const key = getRandomString(16) + keys.push(key) + data.append("keys", key) + data.append("upload", file) + + elements[key] = this._createUploadUI(file, key) + }) + + if (insert) { + this._insertAttachmentsInTextarea(keys, allowedFiles) + } + + const request = new XMLHttpRequest() + + this._addOnLoadedEventListener(request, keys, elements) + this._addOnProgressEventListener(request, keys, elements) + + request.open("POST", this.uploadUrl) + request.send(data) + + return { keys, files: allowedFiles } + } + + _isFileTypeAccepted(file) { + return this._isFileTypeInList(file, this.accept.all) + } + + _isFileTypeImage(file) { + return this._isFileTypeInList(file, this.accept.image) + } + + _isFileTypeVideo(file) { + return this._isFileTypeInList(file, this.accept.video) + } + + _isFileTypeInList(file, list) { + const name = file.name.toLowerCase() + for (const extension of list) { + if (name.substring(name.length - extension.length) === extension) { + return true + } + } + return false + } + + _insertAttachmentsInTextarea(keys, files) { + const markup = [] + + for (let i = 0; i < keys.length; i++) { + const key = keys[i] + const file = files[i] + markup.push("") + } + + if (markup) { + const selection = this.editor.getSelection(this.textarea) + selection.insert(markup.join("\n"), { whitespace: "\n\n" }) + } + } + + _addOnLoadedEventListener(request, keys, elements) { + request.addEventListener("loadend", () => { + if (request.readyState === XMLHttpRequest.DONE) { + if (request.status === 200) { + this._handleUploadSuccess(request, keys, elements) + } else { + this._handleUploadError(request, keys) + } + + keys.forEach((key) => (elements[key] = null)) + } + }) + } + + _handleUploadSuccess(request, keys, elements) { + try { + const { attachments, errors } = JSON.parse(request.response) + + this._replaceTextareaPlaceholders(this.textarea, keys, attachments) + + if (errors) { + const helpText = this.element.querySelector( + "[misago-editor-attachments-help]" + ) + keys.forEach((key) => { + const error = errors[key] + if (error) { + this._updateUploadUIWithError(key, helpText, error) + } + }) + } + + if (attachments) { + attachments.forEach((attachment) => { + try { + this._updateUploadUI(attachment, elements[attachment.key]) + this._createAttachmentIDField(attachment) + } catch (error) { + console.error(error) + } + }) + } + + } catch (error) { + snackbar.error( + pgettext("markup editor upload", "Unexpected upload API response") + ) + console.error(error) + } + } + + _handleUploadError(request, keys) { + if (request.status === 0) { + snackbar.error( + pgettext("markup editor upload", "Site could not be reached") + ) + } else if (request.status >= 400 && request.status < 500) { + try { + snackbar.error(JSON.parse(request.response).error) + } catch (error) { + snackbar.error( + pgettext( + "markup editor upload", + "Unexpected upload API error response" + ) + ) + console.error(error) + } + } else { + snackbar.error( + pgettext("markup editor upload", "Unexpected error during upload") + ) + } + + keys.forEach(key => { + this._updateUploadUIWithError(key) + }) + } + + _addOnProgressEventListener(request, keys, elements) { + request.upload.addEventListener("progress", (event) => { + if (event.lengthComputable) { + const progress = Math.ceil((event.loaded * 100) / event.total) + for (const key of keys) { + const progressBar = elements[key].querySelector(".progress-bar") + progressBar.setAttribute("aria-valuenow", progress) + progressBar.style.width = progress + "%" + } + } + }) + } + + _replaceTextareaPlaceholders(textarea, keys, attachments) { + const results = {} + keys.forEach((key) => (results[key] = null)) + if (attachments) { + attachments.forEach( + (attachment) => (results[attachment.key] = attachment) + ) + } + + const selection = this.editor.getSelection(textarea) + selection.replaceAttachments(function ({ id: key }) { + const attachment = results[key] + if (attachment) { + return "" + } else if (attachment === null) { + return "" + } + }) + } + + _createUploadUI(file, key) { + const data = { + key, + file, + name: file.name, + isImage: false, + isVideo: false, + } + + if (this._isFileTypeImage(file)) { + data.isImage = true + this._createMediaUploadUI(data) + } else if (this._isFileTypeVideo(file)) { + data.isVideo = true + this._createMediaUploadUI(data) + } else { + this._createOtherUploadUI(data) + } + + return this.editor.getAttachmentByKey(key) + } + + _createMediaUploadUI(data) { + const element = renderTemplate(this.templates.media, data) + + if (data.isImage) { + const image = element.querySelector("[misago-tpl-image]") + const buffer = new FileReader() + buffer.onload = () => { + image.style.backgroundImage = "url('" + buffer.result + "')" + } + buffer.readAsDataURL(data.file) + } else if (data.isVideo) { + const video = element.querySelector("video") + const buffer = new FileReader() + buffer.onload = () => { + const source = document.createElement("source") + source.setAttribute("src", buffer.result) + source.setAttribute("type", data.file.type) + + video.append(source) + } + buffer.readAsDataURL(data.file) + } + + this._addUIToAttachmentsList(this.lists.media, element) + } + + _createOtherUploadUI(data) { + const element = renderTemplate(this.templates.other, data) + this._addUIToAttachmentsList(this.lists.other, element) + } + + _addUIToAttachmentsList(list, element) { + list.querySelector("ul").prepend(element) + list.classList.remove("d-none") + } + + _createAttachmentIDField(attachment) { + const input = document.createElement("input") + input.setAttribute("type", "hidden") + input.setAttribute("name", this.field.name) + input.setAttribute("value", attachment.id) + this.field.element.appendChild(input) + } + + _updateUploadUI(attachment, element) { + if (attachment.filetype["is_media"]) { + this._updateMediaUploadUI(attachment, element) + } else { + this._updateOtherUploadUI(attachment, element) + } + } + + _updateMediaUploadUI(attachment, element) { + const footer = renderTemplate(this.templates.mediaFooter, attachment) + + footer + .querySelector("[misago-editor-attachment]") + .setAttribute( + "misago-editor-attachment", + attachment.name + ":" + attachment.id + ) + + element.querySelector("[misago-tpl-footer]").replaceWith(footer) + } + + _updateOtherUploadUI(attachment, element) { + const item = renderTemplate(this.templates.otherUploaded, attachment) + + item + .querySelector("[misago-editor-attachment]") + .setAttribute( + "misago-editor-attachment", + attachment.name + ":" + attachment.id + ) + + element.replaceWith(item) + } + + _updateUploadUIWithError(key, helpText, error) { + if (error) { + this._createErrorMessage(key, error, helpText) + } + + const attachment = this.editor.getAttachmentByKey(key) + const footer = attachment.querySelector("[misago-tpl-footer]") + if (footer) { + // Media attachment + const template = renderTemplate(this.templates.mediaFailedFooter, { key }) + footer.replaceWith(template) + } else { + // Other attachment + const upload = attachment.querySelector("[misago-tpl-upload]") + const button = upload.closest("li").querySelector("button") + + button.setAttribute("misago-editor-action", "attachment-error-dismiss") + button.setAttribute("misago-editor-attachment-key", key) + button.removeAttribute("disabled") + + upload.replaceWith(renderTemplate(this.templates.otherFailed)) + } + } + + _createErrorMessage(key, error, insertAfter) { + const errorTemplate = renderTemplate(this.templates.error, { key, error }) + insertAfter.after(errorTemplate) + } +} diff --git a/frontend/src/getRandomString.js b/frontend/src/getRandomString.js new file mode 100644 index 0000000000..2661a8eeb2 --- /dev/null +++ b/frontend/src/getRandomString.js @@ -0,0 +1,11 @@ +const ALPHABET = + "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" +const ALPHABET_LENGTH = ALPHABET.length + +export default function getRandomString(length) { + let string = "" + for (let i = 0; i < length; i++) { + string += ALPHABET[Math.floor(Math.random() * ALPHABET_LENGTH)] + } + return string +} diff --git a/frontend/src/htmxErrors.js b/frontend/src/htmxErrors.js index 237360221e..71cf75c96c 100644 --- a/frontend/src/htmxErrors.js +++ b/frontend/src/htmxErrors.js @@ -28,10 +28,7 @@ function getResponseErrorMessage(xhr) { function handleSendError(event) { if (isEventVisible(event)) { - const message = pgettext( - "htmx response error", - "Site could not be reached." - ) + const message = pgettext("htmx response error", "Site could not be reached") error(message) } } diff --git a/frontend/src/index.js b/frontend/src/index.js index 462b84a83b..cff58ac131 100644 --- a/frontend/src/index.js +++ b/frontend/src/index.js @@ -131,3 +131,11 @@ document.addEventListener("htmx:load", activateEditors) document.addEventListener("misago:afterModeration", () => { $("#threads-moderation-modal").modal("hide") }) + +// Custom misago-confirm attribute +document.addEventListener("submit", function (event) { + const element = event.target.closest("form[misago-confirm]") + if (!!element && !window.confirm(element.getAttribute("misago-confirm"))) { + event.preventDefault() + } +}) diff --git a/frontend/src/renderTemplate.js b/frontend/src/renderTemplate.js new file mode 100644 index 0000000000..c0e49c74e5 --- /dev/null +++ b/frontend/src/renderTemplate.js @@ -0,0 +1,59 @@ +export default function renderTemplate(template, data) { + const node = template.content.cloneNode(true) + + node.querySelectorAll("[misago-tpl-if]").forEach((element) => { + const variable = element.getAttribute("misago-tpl-if") + if (getVariableValue(data, variable)) { + element.removeAttribute("misago-tpl-if") + } else { + element.remove() + } + }) + + node.querySelectorAll("[misago-tpl-ifnot]").forEach((element) => { + const variable = element.getAttribute("misago-tpl-ifnot") + if (getVariableValue(data, variable)) { + element.remove() + } else { + element.removeAttribute("misago-tpl-ifnot") + } + }) + + node.querySelectorAll("[misago-tpl-var]").forEach((element) => { + const variable = element.getAttribute("misago-tpl-var") + element.innerText = getVariableValue(data, variable) || "" + element.removeAttribute("misago-tpl-var") + }) + + node.querySelectorAll("[misago-tpl-attr]").forEach((element) => { + const attr = element.getAttribute("misago-tpl-attr") + if (attr.indexOf(":") !== ":") { + const name = attr.substring(0, attr.indexOf(":")).trim() + const variable = attr.substring(attr.indexOf(":") + 1).trim() + const value = variable ? getVariableValue(data, variable) : undefined + + if (name && value) { + element.setAttribute(name, value) + } + } + element.removeAttribute("misago-tpl-attr") + }) + + return node +} + +function getVariableValue(data, variable) { + if (variable.indexOf(".") === -1) { + return data[variable] + } else { + let value = data + for (const part of variable.split(".")) { + if (part && typeof value[part] !== "undefined") { + value = value[part] + } else { + return undefined + } + } + return value + } +} diff --git a/frontend/src/style/flavor/typo.less b/frontend/src/style/flavor/typo.less index 44ed97bf21..ca4e0d5409 100644 --- a/frontend/src/style/flavor/typo.less +++ b/frontend/src/style/flavor/typo.less @@ -6,3 +6,18 @@ abbr { outline: none; text-decoration: none; } + +.text-danger { + color: @state-danger-text !important; +} + +.text-help-block { + color: @gray-light !important; + + a, + a:link, + a:visited { + color: darken(@gray-light, 5); + text-decoration: underline; + } +} diff --git a/frontend/src/style/img-bg.png b/frontend/src/style/img-bg.png new file mode 100644 index 0000000000..9462e513b3 Binary files /dev/null and b/frontend/src/style/img-bg.png differ diff --git a/frontend/src/style/index.less b/frontend/src/style/index.less index 3ece480e50..acb1cf092f 100644 --- a/frontend/src/style/index.less +++ b/frontend/src/style/index.less @@ -62,6 +62,7 @@ // -------------------------------------------------- // Core CSS +@import "misago/animations.less"; @import "misago/scaffolding.less"; @import "misago/flex-row.less"; @import "misago/display.less"; @@ -96,6 +97,7 @@ @import "misago/page-header.less"; @import "misago/page-container.less"; @import "misago/panels.less"; +@import "misago/rich-text.less"; @import "misago/footer.less"; @import "misago/moderation.less"; @import "misago/ui-preview.less"; @@ -106,7 +108,6 @@ @import "misago/user-card.less"; @import "misago/toolbar.less"; @import "misago/type.less"; -@import "misago/markup.less"; @import "misago/formatting-help.less"; @import "misago/scroll-target.less"; @@ -133,6 +134,8 @@ @import "misago/auth-pages.less"; @import "misago/message-pages.less"; @import "misago/threads-lists.less"; +@import "misago/attachment-list.less"; +@import "misago/attachment-details.less"; @import "misago/notifications-list.less"; @import "misago/notifications-dropdown.less"; @import "misago/notifications-overlay.less"; diff --git a/frontend/src/style/misago/account-settings.less b/frontend/src/style/misago/account-settings.less index 38114a01cf..27faf6d538 100644 --- a/frontend/src/style/misago/account-settings.less +++ b/frontend/src/style/misago/account-settings.less @@ -47,3 +47,74 @@ .table-watching-option .material-icon { font-size: 18px; } + +.panel-attachments-usage { + h4 { + margin: 0; + } + + .progress { + margin: @line-height-computed 0; + } + + .progress-bar-locked { + background-color: #434343; + } +} + +.attachment-usage-legend { + margin: -5px -5px floor(@line-height-computed / 2) -5px; + padding: 0; + + list-style: none; + + li { + display: inline-block; + margin: 5px; + } +} + +.attachment-usage-legend-item { + display: inline-block; + + width: 10px; + height: 10px; + + background-color: @gray-lighter; + border-radius: 100%; + vertical-align: baseline; +} + +.attachment-usage-exceeded { + background-color: @brand-danger; +} + +.attachment-usage-posted { + background-color: @brand-primary; +} + +.attachment-usage-unused { + background-color: @brand-warning; +} + +.attachment-usage-help-text { + position: relative; + + padding-left: 15px; + + color: @gray; + + &:last-child { + margin: 0; + } + + .attachment-usage-legend-item { + position: absolute; + left: 0; + top: 5px; + } + + strong { + color: @text-color; + } +} diff --git a/frontend/src/style/misago/animations.less b/frontend/src/style/misago/animations.less new file mode 100644 index 0000000000..ab6e835edf --- /dev/null +++ b/frontend/src/style/misago/animations.less @@ -0,0 +1,30 @@ +@keyframes deleteElementAnimation { + from { + opacity: 1; + } + to { + opacity: 0; + } +} + +.animation-delete { + animation-name: deleteElementAnimation; + animation-duration: 0.3s; + animation-iteration-count: 1; + opacity: 0; +} + +@keyframes fadeInElementAnimation { + from { + opacity: 0; + } + to { + opacity: 1; + } +} + +.animation-fade-in { + animation-name: fadeInElementAnimation; + animation-duration: 0.3s; + animation-iteration-count: 1; +} diff --git a/frontend/src/style/misago/attachment-details.less b/frontend/src/style/misago/attachment-details.less new file mode 100644 index 0000000000..57b421f924 --- /dev/null +++ b/frontend/src/style/misago/attachment-details.less @@ -0,0 +1,140 @@ +.attachment-details-video, +.attachment-details-image { + background-color: #1f1f1f; + + img, + video { + display: block; + max-width: 100%; + height: auto; + + margin: 0 auto; + padding: 0; + } +} + +@media screen and (max-width: @screen-xs-max) { + .attachment-video-container { + padding: 0; + } +} + +.attachment-details-image, +.attachment-details-image-sm { + img { + background-image: url("../img-bg.png"); + background-repeat: repeat; + } +} + +.attachment-details-image-sm { + display: flex; + justify-content: center; + + a { + display: block; + + margin: @line-height-computed auto; + padding: 4px; + + background-color: #fff; + border: 1px solid #ccc; + } +} + +.attachment-details-file { + margin: @line-height-computed * 2 0; + + .btn { + display: flex; + flex-direction: column; + width: 180px; + height: 180px; + justify-content: center; + + margin: 0 auto; + padding: @padding-xs-horizontal; + + background-color: @body-bg; + border: 1px solid @gray-lighter; + border-radius: @border-radius-base; + color: @text-color; + text-wrap-mode: wrap; + + span, + strong, + small { + display: block; + } + + .material-icon { + width: 64px; + height: 64px; + + margin: 0 auto; + margin-bottom: floor(@line-height-computed / 2); + + color: @gray-light; + font-size: 64px; + line-height: 64px; + } + + strong { + word-break: break-all; + } + + small { + margin-top: floor(@line-height-computed / 4); + } + } +} + +.panel-attachment-details { + .panel-title { + color: @text-color; + } + + .panel-body { + padding-top: 0; + padding-bottom: 0; + } + + .col-xs-12 { + padding: @panel-body-padding; + + border-bottom: 1px solid @gray-lighter; + } + + .item-link { + &, + &:link, + &:visited { + color: @gray-dark; + text-decoration: none; + } + + &:hover, + &:focus, + &:active { + color: @text-color; + text-decoration: underline; + } + } +} + +@media screen and (min-width: @screen-md-min) { + .panel-attachment-details { + .panel-body { + padding: 0; + } + + .row { + margin: 0; + } + + .col-xs-12 { + padding-left: 0; + padding-right: 0; + } + } +} diff --git a/frontend/src/style/misago/attachment-list.less b/frontend/src/style/misago/attachment-list.less new file mode 100644 index 0000000000..930ba17cf4 --- /dev/null +++ b/frontend/src/style/misago/attachment-list.less @@ -0,0 +1,162 @@ +.attachment-list-item { + display: flex; + align-items: start; +} + +.attachment-list-item-download-btn { + display: block; + flex: 1; + + padding: 2px; + + border: 1px solid @gray-lighter; + border-radius: 4px; + + &, + &:link, + &:hover, + &:focus, + &:active, + &:visited { + color: darken(@gray-lighter, 25); + font-size: 32px; + line-height: 32px; + text-decoration: none; + } + + &:hover, + &:focus, + &:active { + border-color: darken(@gray-lighter, 15); + } +} + +.attachment-list-item-icon, +.attachment-list-item-icon-broken { + display: flex; + align-items: center; + justify-content: center; + + width: 40px; + height: 40px; + + background-color: @gray-lighter; + border-radius: 2px; +} + +.attachment-list-item-icon-broken { + color: #ee6e6c; + background-color: #fae3e2; +} + +.attachment-list-item-image { + width: 40px; + height: 40px; + + background-size: cover; + background-repeat: no-repeat; + background-position: center; + border-radius: 2px; +} + +.attachment-list-item-body { + width: 100%; + + margin-left: 15px; +} + +.attachment-list-item-name { + word-break: break-word; + + s { + color: @gray; + font-weight: bold; + } + + a, + a:link, + a:hover, + a:focus, + a:active, + a:visited { + color: @text-color; + font-weight: bold; + } +} + +.attachment-list-item-details { + display: block; + + margin: 2px -4px -2px -4px; + padding: 0; + + color: @gray-light; + list-style-image: none; + + li { + display: inline-block; + + margin: 2px 4px; + } +} + +.attachment-list-item-thread { + word-break: break-word; + + &, + &:link, + &:hover, + &:focus, + &:active, + &:visited { + color: @gray-darker; + } +} + +.attachment-list-item-delete-btn { + .btn { + display: flex; + align-items: center; + justify-content: center; + + position: relative; + left: 7px; + + width: 28px; + height: 28px; + padding: 0; + + color: darken(@gray-lighter, 35); + } +} + +@media screen and (min-width: @screen-sm-min) { + .attachment-list-item { + align-items: center; + } + + .attachment-list-item-icon, + .attachment-list-item-icon-broken, + .attachment-list-item-image { + width: 64px; + height: 64px; + } + + .attachment-list-item-delete-btn { + margin-left: 15px; + + .btn { + position: static; + + width: 32px; + height: 32px; + } + } +} + +.attachment-list-blankslate { + padding: 30px 15px; + + font-size: @font-size-large; + text-align: center; +} diff --git a/frontend/src/style/misago/inputs.less b/frontend/src/style/misago/inputs.less index c5f40bb40e..138363ab11 100644 --- a/frontend/src/style/misago/inputs.less +++ b/frontend/src/style/misago/inputs.less @@ -76,27 +76,16 @@ input.hidden-file-upload { .form-control-post { resize: none; min-height: 200px; - - &.form-control-post-lg { - min-height: 300px; - } } -@media screen and (min-height: 600px) { - .form-control-post { - field-sizing: content; - resize: vertical; - - &.form-control-post-lg { - min-height: 340px; - } +@media screen and (min-height: 800px) { + .form-control-post.form-control-post-lg { + min-height: 300px; } } -@media screen and (min-height: 760px) { - .form-control-post { - &.form-control-post-lg { - min-height: 500px; - } +@media screen and (min-height: 1000px) { + .form-control-post.form-control-post-lg { + min-height: 400px; } } diff --git a/frontend/src/style/misago/markup-editor.less b/frontend/src/style/misago/markup-editor.less index 02ab9b9d2d..8d898fa2a1 100644 --- a/frontend/src/style/misago/markup-editor.less +++ b/frontend/src/style/misago/markup-editor.less @@ -87,23 +87,13 @@ margin-right: @line-height-computed / 2; } -// Footer -.markup-editor-footer { - display: flex; - padding: @markup-editor-padding; - - background: @markup-editor-footer-bg; - border-top: 1px solid @markup-editor-footer-border-color; -} - // Spacer that pushes items away from each other .markup-editor-spacer { flex: 1; } -// Toolbar and footer items layout -.markup-editor-toolbar, -.markup-editor-footer { +// Toolbar items layout +.markup-editor-toolbar { // Add spacing between buttons .btn + .btn, .btn + .dropdown, @@ -114,9 +104,10 @@ // Textarea .markup-editor-textarea.form-control { - height: @markup-editor-height; + min-height: @markup-editor-height; padding: @markup-editor-padding; resize: none; + field-sizing: content; border: 0; border-radius: 0; @@ -129,163 +120,355 @@ } } -// Preview area -// Relative/absolute positioning is a fix for preview area changing height -// when it's contents are too long. -.markup-editor-preview { - position: relative; - height: @markup-editor-height; - overflow-y: auto; +// Attachments +.markup-editor-attachments { + background: @markup-editor-attachments-bg; + border-top: 1px solid @markup-editor-attachments-border-color; + + .form-group { + margin: 0; + padding: @markup-editor-padding; + + .help-block:last-child { + margin-bottom: 0; + } + } } -.markup-editor-preview-contents { - position: absolute; - padding: @markup-editor-padding; +.markup-editor-attachments-noscript-row input { + margin-bottom: floor(@line-height-computed / 2); +} + +@media screen and (min-width: 400px) { + .markup-editor-attachments-noscript-row { + display: flex; + + input { + margin-right: floor(@grid-gutter-width / 2); + margin-bottom: 0; + } + + button { + width: auto; + } + } } -.markup-editor-preview-loading { +.markup-editor-attachments-script-row { + font-weight: bold; + + button { + padding: 0; + + background: transparent; + border: 0; + text-decoration: underline; + } +} + +.markup-editor-attachments-header { + margin: 0; + padding: 0 @markup-editor-padding-horizontal; + + font-size: @font-size-base; + font-weight: bold; +} + +.markup-editor-attachments-error-dismiss-button { + margin-left: 4px; + padding: 0; + + background-color: transparent; + border: 0; + + &:hover { + text-decoration: underline; + } +} + +.markup-editor-attachments-media-list, +.markup-editor-attachments-other-list { + display: grid; + grid-template-columns: minmax(0, 1fr); + gap: floor(@grid-gutter-width / 2); + + margin: 0; padding: @markup-editor-padding; + + list-style: none; + + li { + margin: 0; + + border: 1px solid @gray-lighter; + border-radius: @border-radius-base; + } } -// Attachments -.markup-editor-attachments { - max-height: @markup-editor-attachments-max-height; - overflow-y: auto; +.markup-editor-attachments-media-list-item { + display: block; + padding: 2px; } -.markup-editor-attachments-container { - padding: floor(@markup-editor-padding / 2); - overflow: auto; +.markup-editor-attachments-media-list-item-preview-video { + position: relative; + + background-color: #1e1e1e; + + .markup-editor-attachments-media-list-item-preview-video-container { + position: absolute; + display: flex; + align-items: center; + justify-content: center; + width: 100%; + height: 100%; + } + + video { + max-width: 100%; + max-height: 100%; + } } -.markup-editor-attachments-item { - padding: floor(@markup-editor-padding / 2); +.markup-editor-attachments-media-list-item-preview-image { + background-position: center; + background-repeat: no-repeat; + background-size: cover; } -.markup-editor-attachment { - display: flex; - align-items: center; - padding: floor(@markup-editor-padding / 2); +.markup-editor-attachments-media-list-item-preview-video, +.markup-editor-attachments-media-list-item-preview-image { + margin-bottom: floor(@grid-gutter-width / 4); + + padding-bottom: 100%; - border: 1px solid @markup-editor-attachment-border-color; border-radius: @border-radius-small; + overflow: hidden; } -.markup-editor-attachment-details { - flex: 1; - white-space: nowrap; +.markup-editor-attachments-media-list-item-preview { + margin-bottom: floor(@grid-gutter-width / 4); + padding-bottom: 100%; + + background-position: center; + background-repeat: no-repeat; + background-size: cover; + border-radius: @border-radius-small; +} + +.markup-editor-attachments-media-list-item-body { + padding: @padding-small-vertical @padding-small-horizontal; + + font-size: @font-size-small; +} + +.markup-editor-attachments-media-list-item-name { overflow: hidden; + padding: 6px 4px; + + font-size: @font-size-small; + font-weight: bold; + white-space: nowrap; text-overflow: ellipsis; +} - strong { - display: block; - } +.markup-editor-attachments-media-list-item-footer { + display: flex; + padding: 4px; +} - .list-unstyled { - margin-bottom: 0; - } +.markup-editor-attachments-media-list-item-footer-spacer { + width: 100%; } -.btn-markup-editor-attachment { - margin-left: floor(@markup-editor-padding / 2); +.markup-editor-attachments-media-list-item-button { + padding: 0 12px; + + background-color: @gray-lighter; + border: none; + border-radius: @border-radius-small; + + &:disabled { + opacity: 0.3; + } } -// Make attachments responsive -@media screen and (min-width: @screen-sm-min) { - .markup-editor-attachments-item { - width: 50%; - float: left; +.markup-editor-attachments-media-list-item-delete-button { + display: flex; + flex-shrink: 0; + align-items: center; + justify-content: center; + + width: 28px; + height: 28px; + padding: 0; + + .material-icon { + font-size: 16px; + line-height: 16px; } } -@media screen and (min-width: @screen-md-min) { - .markup-editor-attachments-item { - width: 25%; +.markup-editor-attachments-media-list-item-upload-progress { + display: flex; + align-items: center; + + height: 36px; + padding: 0 4px; + + .progress { + width: 100%; + margin: 0; } } -// Center attachment's image in modal -.markup-editor-attachment-modal-preview { - margin: @line-height-computed 0 @line-height-computed * 2 0; +.markup-editor-attachments-media-list-item-failed-message { + display: flex; + align-items: center; + width: 100%; - text-align: center; + color: darken(@brand-danger, 30); + font-size: @font-size-small; - a { - display: inline-block; - padding: @padding-base-horizontal; + .material-icon { + margin-right: 4px; - background: #fff; - border: 1px solid @gray-lighter; + font-size: 18px; } +} - img { - max-width: 100%; - max-height: 50vh; +.markup-editor-attachments-other-list-item { + display: flex; + align-items: center; + justify-content: space-between; + + width: 100%; + min-width: 0; + height: 100%; + + padding-right: 6px; +} + +.markup-editor-attachments-other-list-item-body { + width: calc(100% - 36px); + padding: 2px 6px; + + background: transparent; + border: 0; + text-align: left; + + cursor: default; + + &:disabled { + cursor: default !important; } } -.markup-editor-attachment-modal-filename { - font-size: @font-size-base * 2; +.markup-editor-attachments-other-list-item-name { + overflow: hidden; + font-weight: bold; - margin-bottom: @line-height-computed; + font-size: @font-size-small; + text-overflow: ellipsis; + white-space: nowrap; +} + +.markup-editor-attachments-other-list-item-description { + color: @gray-light; + font-size: @font-size-small; + text-overflow: ellipsis; + white-space: nowrap; } -.markup-editor-attachment-modal-details { - margin-bottom: @line-height-computed; +.markup-editor-attachments-other-list-item-cta { + margin-left: 8px; } -// Make editor take full height on full-screen mode -.posting-fullscreen .markup-editor { +.markup-editor-attachments-other-list-item-delete-button { display: flex; - flex-direction: column; - height: 100%; + flex-shrink: 0; + align-items: center; + justify-content: center; + + width: 28px; + height: 28px; + padding: 0; - .markup-editor-textarea, - .markup-editor-preview { - flex: 1; - height: auto; + background-color: @gray-lighter; + border: none; + border-radius: @border-radius-small; + + &:disabled { + opacity: 0.3; + } + + .material-icon { + font-size: 16px; + line-height: 16px; } } -// Make editor take full height on mobile devices -@media screen and (max-width: @screen-sm-max) { - body.posting-default .markup-editor { - display: flex; - flex-direction: column; - height: 100%; +.markup-editor-attachments-other-list-item-upload-progress { + display: flex; + align-items: center; - .markup-editor-textarea, - .markup-editor-preview { - flex: 1; - height: 100%; - } + height: 17px; + + .progress { + width: 100%; + margin: 0; } } -// Some overrides for x-small mobile devices -@media screen and (max-width: @screen-xs-max) { - // Limit editor attachments list height on small mobile devices - .markup-editor-attachments { - max-height: @markup-editor-attachments-max-height-xs; - } +.markup-editor-attachments-other-list-item-upload-failed { + display: flex; + align-items: center; - // Make buttons in footer take whole width - .markup-editor-footer .btn-auto { - flex: 1; + height: 17px; + + color: darken(@brand-danger, 30); + font-size: @font-size-small; +} + +.misago-javascript .markup-editor-attachments-other-list-item-body { + cursor: pointer; + + &:hover, + &:active { + .markup-editor-attachments-other-list-item-cta { + color: @gray-dark; + text-decoration: underline; + } } +} - .markup-editor-footer .btn-icon { - margin-right: @line-height-computed / 2; +@media screen and (min-width: @screen-sm-min) { + .markup-editor-attachments-media-list { + grid-template-columns: repeat(3, minmax(0, 1fr)); } - .markup-editor-spacer { - display: none; + .markup-editor-attachments-other-list { + grid-template-columns: repeat(2, minmax(0, 1fr)); } } -// Hide controls dropdown on larger displays @media screen and (min-width: @screen-md-min) { - .markup-editor-controls-dropdown { - display: none; + .markup-editor-attachments-media-list { + grid-template-columns: repeat(5, minmax(0, 1fr)); + } + + .markup-editor-attachments-other-list { + grid-template-columns: repeat(3, minmax(0, 1fr)); } } + +// Drag and drop focus +.markup-editor-textarea.form-control, +.markup-editor-attachments { + transition: background-color 0.5s; +} + +.markup-editor-textarea.form-control.markup-editor-drag-drop, +.markup-editor-attachments.markup-editor-drag-drop { + background-color: @markup-editor-drag-drop-bg; +} diff --git a/frontend/src/style/misago/markup.less b/frontend/src/style/misago/markup.less deleted file mode 100644 index 9e620087ac..0000000000 --- a/frontend/src/style/misago/markup.less +++ /dev/null @@ -1,171 +0,0 @@ -// -// Markup styles -// -------------------------------------------------- - -// Set font-size -.misago-markup, -.misago-markup blockquote { - font-size: @misago-markup-font-size; -} - -// Force word wrap for user text -.misago-markup { - h1, - h2, - h3, - h4, - h5, - h6, - p { - overflow-wrap: anywhere; - } -} - -// Add upper margins for headers -.misago-markup { - h1, - h2, - h3, - h4, - h5, - h6 { - margin-top: @line-height-computed * 2; - } -} - -// Even out blocks -.misago-markup > *, -.misago-markup blockquote > * { - margin: @line-height-computed 0px; - - &:first-child { - margin-top: 0px; - } - - &:last-child { - margin-bottom: 0px; - } -} - -// Downscale images so they don't expand area -.misago-markup img { - max-width: 100%; - max-height: 500px; -} - -// Make quotes stand out a little -.misago-markup .quote-block, -.misago-markup blockquote { - background-color: #f0f9ff; - border-left: 3px solid #0ea5e9; - border-radius: @border-radius-small; - overflow: hidden; - - color: #0c4a6e; -} - -.misago-markup .quote-heading { - padding: @padding-large-vertical @padding-large-horizontal; - - font-size: @font-size-base; - font-weight: bold; -} - -.misago-markup .quote-body { - border: none; - border-radius: 0; -} - -.misago-markup blockquote { - padding: @padding-large-vertical @padding-large-horizontal; - - &:last-child { - margin-bottom: 0; - } -} - -// Add extra styles to nested quotes -.misago-markup .quote-body > blockquote, -.misago-markup .quote-body > .quote-block, -.misago-markup blockquote > blockquote, -.misago-markup blockquote > .quote-block { - border: 1px solid #0ea5e9; - border-left: 3px solid #0ea5e9; -} - -// Style spoilers -.misago-markup .spoiler-block { - position: relative; - - background: repeating-linear-gradient( - 45deg, - fadeout(@gray-lighter, 50%), - fadeout(@gray-lighter, 50%) 10px, - @post-bg 10px, - @post-bg 20px - ); - border: 3px solid @gray-lighter; - border-radius: @border-radius-base; - font-size: @font-size-base; -} - -.misago-markup .spoiler-body { - background: @body-bg; - border-width: 0; - margin: 0px; - padding: @line-height-computed; -} - -.misago-markup .spoiler-overlay { - position: absolute; - top: 0; - left: 0; - width: 100%; - height: 100%; - display: flex; - align-items: center; - justify-content: center; - background: @body-bg; -} - -.misago-markup .spoiler-block.revealed .spoiler-overlay { - display: none; -} - -// Add bullets to lists -.misago-markup ul { - list-style-type: square; - - li { - list-style-type: square; - } -} - -.misago-markup ol { - list-style-type: decimal; - - li { - list-style-type: decimal; - } -} - -// Expand code blocks a little -.misago-markup pre { - background: #eee; - border: none; - padding: @padding-large-vertical; - overflow: hidden; - - color: #000; - - code.hljs { - margin: @padding-large-vertical * -1; - padding: ((@line-height-computed - 1) / 2); - } -} - -// Align markup horizontally -.misago-markup-example { - display: flex; - align-items: center; -} diff --git a/frontend/src/style/misago/panels.less b/frontend/src/style/misago/panels.less index 680d749476..994646bdf3 100644 --- a/frontend/src/style/misago/panels.less +++ b/frontend/src/style/misago/panels.less @@ -62,3 +62,26 @@ max-width: 500px; margin: @line-height-computed auto; } + +// Responsive panel +.panel-responsive { + margin-left: floor(@grid-gutter-width / -2); + margin-right: floor(@grid-gutter-width / -2); + margin-bottom: @line-height-computed; + + .panel-heading { + border-bottom: 1px solid @panel-default-border; + } +} + +@media screen and (min-width: @screen-md-min) { + .panel-responsive { + margin-left: 0; + margin-right: 0; + + .panel-heading { + padding-left: 0; + padding-right: 0; + } + } +} diff --git a/frontend/src/style/misago/posts-feed.less b/frontend/src/style/misago/posts-feed.less index 343c41cec1..d65222c30e 100644 --- a/frontend/src/style/misago/posts-feed.less +++ b/frontend/src/style/misago/posts-feed.less @@ -169,6 +169,119 @@ padding: floor(@line-height-computed / 2) 0; } +.posts-feed-item-attachments { + margin-top: @line-height-computed; +} + +.posts-feed-item-attachments-header { + margin: 0 0 floor(@line-height-computed / 2) 0; + + color: @gray-dark; + font-size: @font-size-base; + font-weight: bold; +} + +.posts-feed-item-attachments-list { + display: grid; + grid-template-columns: minmax(0, 1fr); + gap: 8px; + + margin: 0; + padding: 0; + + list-style: none; +} + +@media screen and (min-width: 600px) { + .posts-feed-item-attachments-list { + grid-template-columns: repeat(2, minmax(0, 1fr)); + } +} + +@media screen and (min-width: 900px) { + .posts-feed-item-attachments-list { + grid-template-columns: repeat(3, minmax(0, 1fr)); + } +} + +.posts-feed-item-attachments-list-item { + display: flex; + align-items: center; + + min-width: 0; + + padding: 2px; + + border: 1px solid @gray-lighter; + border-radius: @border-radius-small; +} + +.posts-feed-item-attachments-list-item-image, +.posts-feed-item-attachments-list-item-icon { + flex-shrink: 0; + + width: 38px; + height: 38px; + margin-right: floor(@grid-gutter-width / 4); + + border-radius: @border-radius-small; +} + +.posts-feed-item-attachments-list-item-image { + background-size: cover; +} + +.posts-feed-item-attachments-list-item-icon { + display: flex; + align-items: center; + justify-content: center; + + font-size: 24px; + line-height: 24px; + + &, + &:link, + &:visited { + color: darken(@gray-lighter, 10); + } + + &:hover, + &:focus { + color: @gray; + background-color: @gray-lighter; + text-decoration: none; + } + + &:active { + color: darken(@gray, 10); + background-color: darken(@gray-lighter, 10); + text-decoration: none; + } +} + +.posts-feed-item-attachments-list-item-body { + width: 100%; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; +} + +.posts-feed-item-attachments-list-item-name { + font-size: @font-size-small; + font-weight: bold; + + &, + &:link, + &:visited { + color: @text-color; + } +} + +.posts-feed-item-attachments-list-item-details { + color: @gray; + font-size: @font-size-small; +} + .posts-feed-item-post-body-footer { display: flex; align-items: center; diff --git a/frontend/src/style/misago/rich-text.less b/frontend/src/style/misago/rich-text.less new file mode 100644 index 0000000000..06fd4f818a --- /dev/null +++ b/frontend/src/style/misago/rich-text.less @@ -0,0 +1,281 @@ +.rich-text { + font-size: 16px; + + h1 { + font-size: 36px; + } + h2 { + font-size: 32px; + } + h3 { + font-size: 28px; + } + h4 { + font-size: 24px; + } + h5 { + font-size: 20px; + } + h6 { + font-size: 16px; + } + + h1, + h2, + h3, + h4, + h5, + h6 { + margin-top: @line-height-computed * 2; + + &:first-child { + margin-top: 0; + } + } + + h1, + h2, + h3, + h4, + h5, + h6, + hr, + p, + ul, + ol { + margin-bottom: @line-height-computed; + + &:last-child { + margin-bottom: 0; + } + } + + img { + max-width: 100%; + } +} + +.rich-text-image { + display: inline-block; + position: relative; + overflow: hidden; + max-width: 100%; + + border-radius: @border-radius-base; + + .rich-text-image-link { + display: inline-block; + } +} + +.rich-text-image-responsive img { + width: 100%; + height: auto; +} + +.rich-text-video { + position: relative; + + display: block; + overflow: hidden; + + height: 0; + padding: 0 0 56.25% 0; + + background-color: #1e1e1e; + border-radius: @border-radius-base; + + video { + position: absolute; + top: 0; + bottom: 0; + left: 0; + + width: 100%; + height: 100%; + + border: 0; + } +} + +.rich-text-info-hover-btn { + display: flex; + align-items: center; + justify-content: center; + + position: absolute; + top: 10px; + right: 10px; + + width: 32px; + height: 32px; + + border-radius: @border-radius-base; + + &, + &:link, + &:visited { + background-color: fadeout(#000, 50); + color: #eee; + } + + &:hover, + &:focus, + &:active { + background-color: fadeout(#333, 10); + color: #fff; + text-decoration: none; + } + + .material-icon { + font-size: 24px; + line-height: 24px; + } +} + +.rich-text-file { + display: inline-block; +} + +.rich-text-file-body { + display: inline-block; + position: relative; + + .rich-text-info-hover-btn { + top: 3px; + right: 4px; + + width: 32px; + height: 32px; + + &, + &:link, + &:visited { + background-color: transparent; + color: @gray; + } + + &:hover, + &:focus, + &:active { + background-color: darken(@gray-lighter, 10); + color: @gray-dark; + text-decoration: none; + } + } +} + +.rich-text-file-link { + display: inline-block; + position: relative; + + padding: 8px 48px 8px 42px; + + border-radius: @border-radius-base; + + &:link, + &:visited { + background: @gray-lighter; + color: @text-color; + text-decoration: none; + } + + &:hover, + &:focus, + &:active { + background: darken(@gray-lighter, 5); + color: @text-color; + text-decoration: none; + } + + .material-icon { + position: absolute; + top: 8px; + left: 10px; + + font-size: 24px; + line-height: 24px; + } + + .rich-text-file-name { + margin-right: 8px; + + word-break: break-all; + + &:last-child { + margin: 0; + } + } + + .rich-text-file-size { + color: @gray; + } +} + +.rich-text-attachment-error { + display: inline-block; + + &:last-child { + margin-bottom: 0; + } + + .rich-text-attachment-error-body { + display: inline-block; + position: relative; + + display: inline-block; + padding: 8px 12px 8px 42px; + + background: lighten(@gray-lighter, 5); + border-radius: @border-radius-base; + color: @gray-light; + } + + .material-icon { + position: absolute; + top: 7px; + left: 10px; + + color: @gray-light; + font-size: 24px; + line-height: 24px; + } + + .rich-text-attachment-error-name { + word-break: break-all; + } +} + +.rich-text-image + .rich-text-file, +.rich-text-image + .rich-text-attachment-error, +.rich-text-file + .rich-text-image, +.rich-text-attachment-error + .rich-text-image { + clear: left; +} + +.rich-text-attachment-group { + overflow: auto; + + margin: 0 -6px; + + .rich-text-image, + .rich-text-file, + .rich-text-attachment-error { + float: left; + } + + .rich-text-video { + clear: both; + } + + .rich-text-image, + .rich-text-video, + .rich-text-file, + .rich-text-attachment-error { + margin: 0 6px @line-height-computed 6px; + } + + &:last-child { + margin-bottom: @line-height-computed * -1; + } +} diff --git a/frontend/src/style/misago/toolbar.less b/frontend/src/style/misago/toolbar.less index 2bf57bc10f..71de7222e7 100644 --- a/frontend/src/style/misago/toolbar.less +++ b/frontend/src/style/misago/toolbar.less @@ -16,13 +16,14 @@ } .toolbar-section { - justify-items: center; display: flex; + justify-items: center; flex: 1; margin-bottom: @line-height-computed; } .toolbar-item { + display: block; flex: 1; padding: 0 floor(@grid-gutter-width * 0.25); diff --git a/frontend/src/style/misago/variables.less b/frontend/src/style/misago/variables.less index 9820db582b..9cf7cd2e2d 100644 --- a/frontend/src/style/misago/variables.less +++ b/frontend/src/style/misago/variables.less @@ -402,6 +402,7 @@ @markup-editor-height: 200px; @markup-editor-padding: floor(@grid-gutter-width / 2); +@markup-editor-padding-horizontal: floor(@grid-gutter-width / 2); @markup-editor-bg: @input-bg; @markup-editor-border-color: @input-border; @@ -427,12 +428,12 @@ @markup-editor-btn-active-border: @gray-lighter; @markup-editor-btn-active-color: @text-color; -@markup-editor-attachments-max-height: 170px; -@markup-editor-attachments-max-height-xs: 120px; +@markup-editor-drag-drop-bg: #e0ecff; + @markup-editor-attachment-border-color: @gray-lighter; -@markup-editor-footer-bg: #fff; -@markup-editor-footer-border-color: @gray-lighter; +@markup-editor-attachments-bg: #fff; +@markup-editor-attachments-border-color: @gray-lighter; // Dropdown height offset used in calc() @dropdown-height-offset: @navbar-height + @line-height-computed; diff --git a/generate_dev_docs.py b/generate_dev_docs.py index def161ff85..1fdcf339ca 100644 --- a/generate_dev_docs.py +++ b/generate_dev_docs.py @@ -8,6 +8,7 @@ from textwrap import dedent, indent HOOKS_MODULES = ( + "misago.attachments.hooks", "misago.categories.hooks", "misago.oauth2.hooks", "misago.parser.hooks", @@ -328,11 +329,11 @@ def generate_outlets_reference(): fp.write( "This document contains a list of all built-in template outlets in Misago." ) - for outlet_name in sorted(outlets_dict): + for outlet_name, outlet_contents in outlets_dict.items(): fp.write("\n\n\n") fp.write(f"## `{outlet_name}`") fp.write("\n\n") - fp.write(outlets_dict[outlet_name]) + fp.write(outlet_contents) def get_callable_class_signature(class_def: ast.ClassDef) -> tuple[str, str | None]: diff --git a/misago-admin/src/style/admin-dashboard.scss b/misago-admin/src/style/admin-dashboard.scss index 85b37a9b9a..b8280d701f 100644 --- a/misago-admin/src/style/admin-dashboard.scss +++ b/misago-admin/src/style/admin-dashboard.scss @@ -17,13 +17,6 @@ padding: $table-cell-padding; } -// Make stat larger -.card-admin-stat { - @extend .text-center; - - font-size: $font-size-lg; -} - // Make text sizes in admin checks smaller .media-admin-check { font-size: $font-size-sm; diff --git a/misago-admin/src/style/admin-table.scss b/misago-admin/src/style/admin-table.scss index a41058d5b7..f8336106f2 100644 --- a/misago-admin/src/style/admin-table.scss +++ b/misago-admin/src/style/admin-table.scss @@ -88,6 +88,21 @@ background-size: cover; } +.card-admin-table .btn-thumbnail-broken { + display: flex; + align-items: center; + justify-content: center; + + width: $font-size-base * 2; + height: $font-size-base * 2; + + padding: 0; + + background-color: lighten($red, 30%); + color: $red; + cursor: default !important; +} + // Util for making item link stand out .card-admin-table .item-name { @extend .font-weight-bold; @@ -107,6 +122,13 @@ } } +.card-admin-table .item-deleted-name { + @extend .font-weight-bold; + + color: $gray-600; + text-decoration: line-through; +} + // Depth indicator .card-admin-table .item-level { margin-right: $btn-padding-x-sm; diff --git a/misago-admin/src/style/controls.scss b/misago-admin/src/style/controls.scss index a5019a8173..50c9d78c45 100644 --- a/misago-admin/src/style/controls.scss +++ b/misago-admin/src/style/controls.scss @@ -62,6 +62,24 @@ } } +// Image dimensions +.control-dimensions { + display: flex; + align-items: center; + + max-width: 280px; + + .form-control { + width: 50%; + } +} + +.control-dimensions-separator { + margin: 0 .5rem; + + color: $gray-700; +} + // Image upload/preview .control-image-preview { @extend .d-inline-block; diff --git a/misago-admin/src/tooltips.js b/misago-admin/src/tooltips.js index bcdd16837b..f084d1d3ad 100644 --- a/misago-admin/src/tooltips.js +++ b/misago-admin/src/tooltips.js @@ -3,6 +3,7 @@ import $ from "jquery" const initTooltips = () => { $('[data-tooltip="top"]').tooltip({ placement: "top" }) $('[data-tooltip="bottom"]').tooltip({ placement: "bottom" }) + $('[data-tooltip="left"]').tooltip({ placement: "left" }) } export default initTooltips diff --git a/misago/account/menus.py b/misago/account/menus.py index d6ef2bc7b7..2ca5b99a86 100644 --- a/misago/account/menus.py +++ b/misago/account/menus.py @@ -59,6 +59,14 @@ def auth_is_not_delegated(request: HttpRequest) -> bool: ) +account_settings_menu.add_item( + key="password", + url_name="misago:account-attachments", + label=pgettext_lazy("account settings page", "Attachments"), + icon="file_download", +) + + def show_download_data(request: HttpRequest) -> bool: return request.settings.allow_data_downloads diff --git a/misago/account/tests/test_account_attachments.py b/misago/account/tests/test_account_attachments.py new file mode 100644 index 0000000000..5f8dd58a77 --- /dev/null +++ b/misago/account/tests/test_account_attachments.py @@ -0,0 +1,452 @@ +from unittest.mock import patch + +from django.urls import reverse + +from ...conf.test import override_dynamic_settings +from ...pagination.cursor import EmptyPageError +from ...test import assert_contains, assert_not_contains + + +def test_account_attachments_displays_login_page_for_guests(db, client): + response = client.get(reverse("misago:account-attachments")) + assert_contains(response, "Sign in to change your settings") + + +def test_account_attachments_shows_storage_for_user_without_attachments(user_client): + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_with_used_attachment( + user, user_client, attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_with_unused_attachment( + user, user_client, attachment +): + attachment.uploader = user + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_with_used_and_unused_attachments( + user, user_client, attachment, user_attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +@override_dynamic_settings(unused_attachments_storage_limit=0) +def test_account_attachments_shows_storage_for_user_without_attachments_and_no_limits( + members_group, user_client +): + members_group.attachment_storage_limit = 0 + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +@override_dynamic_settings(unused_attachments_storage_limit=0) +def test_account_attachments_shows_storage_for_user_with_used_attachment_and_no_limits( + user, members_group, user_client, attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + members_group.attachment_storage_limit = 0 + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +@override_dynamic_settings(unused_attachments_storage_limit=0) +def test_account_attachments_shows_storage_for_user_with_unused_attachment_and_no_limits( + user, members_group, user_client, attachment +): + attachment.uploader = user + attachment.save() + + members_group.attachment_storage_limit = 0 + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +@override_dynamic_settings(unused_attachments_storage_limit=0) +def test_account_attachments_shows_storage_for_user_with_used_and_unused_attachments_and_no_limits( + user, members_group, user_client, attachment, user_attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + members_group.attachment_storage_limit = 0 + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_without_attachments_and_no_group_limits( + members_group, user_client +): + members_group.attachment_storage_limit = 0 + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_with_used_attachment_and_no_group_limits( + user, members_group, user_client, attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + members_group.attachment_storage_limit = 0 + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_with_unused_attachment_and_no_group_limits( + user, members_group, user_client, attachment +): + attachment.uploader = user + attachment.save() + + members_group.attachment_storage_limit = 0 + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_with_used_and_unused_attachments_and_no_group_limits( + user, members_group, user_client, attachment, user_attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + members_group.attachment_storage_limit = 0 + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +@override_dynamic_settings(unused_attachments_storage_limit=0) +def test_account_attachments_shows_storage_for_user_without_attachments_and_no_unused_limits( + members_group, user_client +): + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +@override_dynamic_settings(unused_attachments_storage_limit=0) +def test_account_attachments_shows_storage_for_user_with_used_attachment_and_no_unused_limits( + user, members_group, user_client, attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +@override_dynamic_settings(unused_attachments_storage_limit=0) +def test_account_attachments_shows_storage_for_user_with_unused_attachment_and_no_unused_limits( + user, members_group, user_client, attachment +): + attachment.uploader = user + attachment.save() + + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +@override_dynamic_settings(unused_attachments_storage_limit=0) +def test_account_attachments_shows_storage_for_user_with_used_and_unused_attachments_and_no_unused_limits( + user, members_group, user_client, attachment, user_attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + members_group.unused_attachments_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_without_attachments_and_no_storage_limit( + members_group, user_client +): + members_group.attachment_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_with_used_attachment_and_no_storage_limit( + user, members_group, user_client, attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + members_group.attachment_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_with_unused_attachment_and_no_storage_limit( + user, members_group, user_client, attachment +): + attachment.uploader = user + attachment.save() + + members_group.attachment_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +def test_account_attachments_shows_storage_for_user_with_used_and_unused_attachments_and_no_storage_limit( + user, members_group, user_client, attachment, user_attachment, post +): + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + members_group.attachment_storage_limit = 0 + members_group.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert response.status_code == 200 + + +@override_dynamic_settings(unused_attachments_lifetime=12) +def test_account_attachments_shows_unused_attachments_expire_in_12_hours( + user, user_client, attachment +): + attachment.uploader = user + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_contains(response, "12 hours") + + +@override_dynamic_settings(unused_attachments_lifetime=48) +def test_account_attachments_shows_unused_attachments_expire_in_two_days( + user, user_client, attachment +): + attachment.uploader = user + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + print(response.content.decode()) + assert_contains(response, "2 days") + + +def test_account_attachments_list_shows_blankslate_for_user_without_attachments( + user_client, +): + response = user_client.get(reverse("misago:account-attachments")) + assert_contains( + response, "You haven’t uploaded any attachments, or they have been deleted." + ) + + +def test_account_attachments_list_shows_broken_attachment( + user, attachment, user_client +): + attachment.uploader = user + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_contains(response, attachment.name) + assert_contains(response, attachment.get_absolute_url()) + + +def test_account_attachments_list_shows_image_attachment(user, attachment, user_client): + attachment.uploader = user + attachment.upload = "test.png" + attachment.filetype_id = "png" + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_contains(response, attachment.name) + assert_contains(response, attachment.get_absolute_url()) + + +def test_account_attachments_list_shows_image_attachment_with_thumbnail( + user, attachment, user_client +): + attachment.uploader = user + attachment.upload = "test.png" + attachment.thumbnail = "thumbnail.png" + attachment.filetype_id = "png" + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_contains(response, attachment.name) + assert_contains(response, attachment.get_thumbnail_url()) + assert_contains(response, attachment.get_absolute_url()) + + +def test_account_attachments_list_shows_video_attachment(user, attachment, user_client): + attachment.uploader = user + attachment.upload = "video.mp4" + attachment.filetype_id = "mp4" + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_contains(response, attachment.name) + assert_contains(response, attachment.get_absolute_url()) + + +def test_account_attachments_list_shows_file_attachment(user, attachment, user_client): + attachment.uploader = user + attachment.upload = "document.pdf" + attachment.filetype_id = "pdf" + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_contains(response, attachment.name) + assert_contains(response, attachment.get_absolute_url()) + + +def test_account_attachments_list_shows_attachment_delete_option_if_user_has_permission( + user, attachment, user_client +): + attachment.uploader = user + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_contains(response, attachment.name) + assert_contains(response, attachment.get_delete_url()) + + +def test_account_attachments_list_hides_attachment_delete_option_if_user_has_no_permission( + user, members_group, attachment, user_client, post +): + members_group.can_always_delete_own_attachments = False + members_group.save() + + attachment.uploader = user + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_contains(response, attachment.name) + assert_not_contains(response, attachment.get_delete_url()) + + +def test_account_attachments_list_excludes_anonymous_attachments( + attachment, user_client +): + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_not_contains(response, attachment.name) + + +def test_account_attachments_list_excludes_other_users_attachments( + other_user, attachment, user_client +): + attachment.uploader = other_user + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_not_contains(response, attachment.name) + + +def test_account_attachments_list_excludes_user_deleted_attachments( + user, attachment, user_client +): + attachment.uploader = user + attachment.is_deleted = True + attachment.save() + + response = user_client.get(reverse("misago:account-attachments")) + assert_not_contains(response, attachment.name) + + +@patch( + "misago.account.views.settings.paginate_queryset", side_effect=EmptyPageError(10) +) +def test_account_attachments_list_redirects_to_last_page_for_invalid_cursor( + mock_pagination, user_client +): + response = user_client.get(reverse("misago:account-attachments")) + + assert response.status_code == 302 + assert response["location"] == reverse("misago:account-attachments") + "?cursor=10" + + mock_pagination.assert_called_once() diff --git a/misago/account/tests/test_account_username.py b/misago/account/tests/test_account_username.py index 4b9cae2209..118330a6c0 100644 --- a/misago/account/tests/test_account_username.py +++ b/misago/account/tests/test_account_username.py @@ -165,7 +165,7 @@ def test_account_username_renders_history_item(user_client, user): "misago.account.views.settings.paginate_queryset", side_effect=EmptyPageError(10) ) def test_account_username_redirects_to_last_page_for_invalid_cursor( - mock_pagination, user_client, user + mock_pagination, user_client ): response = user_client.get(reverse("misago:account-username")) diff --git a/misago/account/urls.py b/misago/account/urls.py index 78cd9fc2d3..890c3b117b 100644 --- a/misago/account/urls.py +++ b/misago/account/urls.py @@ -40,6 +40,11 @@ settings.account_email_confirm_change, name="account-email-confirm-change", ), + path( + "attachments/", + settings.AccountAttachmentsView.as_view(), + name="account-attachments", + ), path( "download-data/", settings.AccountDownloadDataView.as_view(), diff --git a/misago/account/views/settings.py b/misago/account/views/settings.py index 029c2b240b..fc29e920c5 100644 --- a/misago/account/views/settings.py +++ b/misago/account/views/settings.py @@ -1,3 +1,4 @@ +from math import ceil from typing import Any from django.conf import settings @@ -12,10 +13,19 @@ from django.views import View from django.views.decorators.debug import sensitive_post_parameters +from ...attachments.models import Attachment +from ...attachments.storage import ( + get_user_attachment_storage_usage, + get_user_unused_attachments_size, +) from ...auth.decorators import login_required from ...core.mail import build_mail from ...pagination.cursor import EmptyPageError, paginate_queryset from ...pagination.redirect import redirect_to_last_page +from ...permissions.attachments import check_delete_attachment_permission +from ...permissions.checkutils import check_permissions +from ...permissions.posts import check_see_post_permission +from ...threads.privatethreads import prefetch_private_thread_member_ids from ...users.datadownloads import ( request_user_data_download, user_has_data_download_request, @@ -417,6 +427,170 @@ def account_email_confirm_change(request, user_id, token): ) +class AccountAttachmentsView(AccountSettingsFormView): + template_name = "misago/account/settings/attachments.html" + template_name_htmx = "misago/account/settings/attachments_list.html" + + def get(self, request: HttpRequest) -> HttpResponse: + if request.is_htmx: + template_name = self.template_name_htmx + else: + template_name = self.template_name + + return self.render(request, template_name) + + def get_context_data( + self, + request: HttpRequest, + context: dict[str, Any], + ) -> dict[str, Any]: + context["storage_usage"] = self.get_storage_usage(request) + context["attachments"] = self.get_attachments(request) + + return context + + def get_storage_usage(self, request: HttpRequest) -> dict: + unused_attachments_lifetime_days = 0 + unused_attachments_lifetime = request.settings.unused_attachments_lifetime + + if unused_attachments_lifetime >= 24 and unused_attachments_lifetime % 24 == 0: + unused_attachments_lifetime_days = int(unused_attachments_lifetime / 24) + + total_storage = request.user_permissions.attachment_storage_limit + total_unused_storage = ( + request.settings.unused_attachments_storage_limit * 1024 * 1024 + ) + unused_storage = request.user_permissions.unused_attachments_storage_limit + + unused_storage_limit = 0 + if total_unused_storage and unused_storage: + unused_storage_limit = min(total_unused_storage, unused_storage) + else: + unused_storage_limit = total_unused_storage or unused_storage + + all_attachments = get_user_attachment_storage_usage(request.user) + unused_attachments = get_user_unused_attachments_size(request.user) + posted_attachments = max(all_attachments - unused_attachments, 0) + + free_storage = 0 + exceeded_storage = 0 + posted_pc = 0 + unused_pc = 0 + exceeded_pc = 0 + + if total_storage: + free_pc = 100 + free_storage = max(total_storage - all_attachments, 0) + + if all_attachments > total_storage: + exceeded_storage = all_attachments - total_storage + max_storage = all_attachments + exceeded_storage + else: + max_storage = total_storage + + if exceeded_storage: + exceeded_pc = ceil(float(exceeded_storage) * 100 / float(max_storage)) + free_pc -= exceeded_pc + + if unused_attachments: + unused_pc = ceil(float(unused_attachments) * 100 / float(max_storage)) + free_pc -= unused_pc + + if posted_attachments: + posted_pc = ceil(float(posted_attachments) * 100 / float(max_storage)) + posted_pc = min(posted_pc, free_pc) + + elif unused_storage_limit and unused_attachments < unused_storage_limit: + free_storage = unused_storage_limit - unused_attachments + + storage_max = posted_attachments + unused_storage_limit + if unused_attachments: + unused_pc = ceil(float(unused_attachments) * 100 / float(storage_max)) + if posted_attachments: + posted_pc = ceil(float(posted_attachments) * 100 / float(storage_max)) + + elif posted_attachments or unused_attachments: + unused_pc = ceil(float(unused_attachments) * 100 / float(all_attachments)) + posted_pc = 100 - unused_pc + + return { + "total": all_attachments, + "posted": posted_attachments, + "unused": unused_attachments, + "exceeded": exceeded_storage, + "free": free_storage, + "total_limit": total_storage, + "unused_limit": unused_storage_limit, + "posted_pc": posted_pc, + "unused_pc": unused_pc, + "exceeded_pc": exceeded_pc, + "unused_lifetime_hours": unused_attachments_lifetime, + "unused_lifetime_days": unused_attachments_lifetime_days, + } + + def get_attachments(self, request: HttpRequest) -> dict: + queryset = Attachment.objects.filter( + uploader=request.user, is_deleted=False + ).prefetch_related("category", "thread", "post") + + result = paginate_queryset(request, queryset, 20, "-id") + prefetch_private_thread_member_ids( + [attachment.thread for attachment in result.items if attachment.thread] + ) + + show_post_column = False + show_delete_column = False + + items: list[dict] = [] + for attachment in result.items: + attachment.uploader = request.user + + if attachment.post: + with check_permissions() as can_see_post: + check_see_post_permission( + request.user_permissions, + attachment.category, + attachment.thread, + attachment.post, + ) + else: + can_see_post = False + + with check_permissions() as can_delete: + check_delete_attachment_permission( + request.user_permissions, + attachment.category, + attachment.thread, + attachment.post, + attachment, + ) + + if can_see_post: + show_post_column = True + if can_delete: + show_delete_column = True + + items.append( + { + "attachment": attachment, + "show_post": can_see_post, + "show_delete": can_delete, + } + ) + + referer = "?referer=settings" + if request.GET.get("cursor"): + referer += "&cursor=" + request.GET["cursor"] + + return { + "referer": referer, + "paginator": result, + "items": items, + "show_post_column": show_post_column, + "show_delete_column": show_delete_column, + } + + class AccountDownloadDataView(AccountSettingsView): template_name = "misago/account/settings/download_data.html" template_name_htmx = "misago/account/settings/download_data_form.html" diff --git a/misago/admin/admin.py b/misago/admin/admin.py index 90b1c38514..14acb0b5f5 100644 --- a/misago/admin/admin.py +++ b/misago/admin/admin.py @@ -1,6 +1,7 @@ from django.urls import path from django.utils.translation import pgettext_lazy +from .attachments import views as attachments from .categories import views as categories from .groups import views as groups from .moderators import views as moderators @@ -27,6 +28,17 @@ def register_navigation_nodes(self, site): after="categories:index", namespace="moderators", ) + site.add_node( + name=pgettext_lazy("admin node", "Attachments"), + icon="fas fa-paperclip", + after="permissions:index", + namespace="attachments", + ) + site.add_node( + name=pgettext_lazy("admin node", "File types"), + parent="attachments", + namespace="filetypes", + ) def register_urlpatterns(self, urlpatterns): urlpatterns.namespace("groups/", "groups") @@ -84,3 +96,21 @@ def register_urlpatterns(self, urlpatterns): path("edit//", moderators.EditView.as_view(), name="edit"), path("delete//", moderators.DeleteView.as_view(), name="delete"), ) + + urlpatterns.namespace("attachments/", "attachments") + urlpatterns.patterns( + "attachments", + path("", attachments.AttachmentsList.as_view(), name="index"), + path("/", attachments.AttachmentsList.as_view(), name="index"), + path( + "delete//", + attachments.DeleteAttachment.as_view(), + name="delete", + ), + ) + urlpatterns.single_pattern( + "filetypes/", + "filetypes", + "attachments", + attachments.AttachmentsFiletypesList.as_view(), + ) diff --git a/misago/threads/admin/tests/__init__.py b/misago/admin/attachments/__init__.py similarity index 100% rename from misago/threads/admin/tests/__init__.py rename to misago/admin/attachments/__init__.py diff --git a/misago/admin/attachments/forms.py b/misago/admin/attachments/forms.py new file mode 100644 index 0000000000..ee268acf25 --- /dev/null +++ b/misago/admin/attachments/forms.py @@ -0,0 +1,86 @@ +from django import forms +from django.utils.translation import pgettext_lazy + +from ...attachments.filetypes import filetypes + + +def get_searchable_filetypes(): + choices = [("", pgettext_lazy("admin attachments type filter choice", "All types"))] + choices.extend(filetypes.as_django_choices()) + return choices + + +class FilterAttachmentsForm(forms.Form): + uploader = forms.CharField( + label=pgettext_lazy("admin attachments filter form", "Uploader name contains"), + required=False, + ) + name = forms.CharField( + label=pgettext_lazy("admin attachments filter form", "Name contains"), + required=False, + ) + filetype = forms.ChoiceField( + label=pgettext_lazy("admin attachments filter form", "File type"), + choices=get_searchable_filetypes, + required=False, + ) + status = forms.ChoiceField( + label=pgettext_lazy("admin attachments filter form", "Status"), + required=False, + choices=[ + ( + "", + pgettext_lazy( + "admin attachments status filter choice", + "All", + ), + ), + ( + "posted", + pgettext_lazy( + "admin attachments status filter choice", + "Posted", + ), + ), + ( + "unused", + pgettext_lazy( + "admin attachments status filter choice", + "Unused", + ), + ), + ( + "deleted", + pgettext_lazy( + "admin attachments status filter choice", + "Deleted", + ), + ), + ( + "broken", + pgettext_lazy( + "admin attachments status filter choice", + "Broken", + ), + ), + ], + ) + + def filter_queryset(self, criteria, queryset): + if criteria.get("uploader"): + queryset = queryset.filter( + uploader_slug__contains=criteria["uploader"].lower() + ) + if criteria.get("name"): + queryset = queryset.filter(name__icontains=criteria["name"]) + if criteria.get("filetype"): + queryset = queryset.filter(filetype_id=criteria["filetype"]) + if criteria.get("status") == "posted": + queryset = queryset.filter(post__isnull=False) + elif criteria.get("status") == "unused": + queryset = queryset.filter(post__isnull=True, is_deleted=False) + elif criteria.get("status") == "deleted": + queryset = queryset.filter(is_deleted=True) + elif criteria.get("status") == "broken": + queryset = queryset.filter(upload="") + return queryset diff --git a/misago/threads/admin/views/attachments.py b/misago/admin/attachments/views.py similarity index 82% rename from misago/threads/admin/views/attachments.py rename to misago/admin/attachments/views.py index 6f2e7b310e..f7ca866c99 100644 --- a/misago/threads/admin/views/attachments.py +++ b/misago/admin/attachments/views.py @@ -2,9 +2,11 @@ from django.db import transaction from django.utils.translation import pgettext, pgettext_lazy -from ....admin.views import generic -from ...models import Attachment, Post -from ..forms import FilterAttachmentsForm +from ...attachments.filetypes import filetypes +from ...attachments.models import Attachment +from ...threads.models import Post +from ..views import generic +from .forms import FilterAttachmentsForm class AttachmentAdmin(generic.AdminBaseMixin): @@ -17,9 +19,7 @@ class AttachmentAdmin(generic.AdminBaseMixin): def get_queryset(self): qs = super().get_queryset() - return qs.select_related( - "filetype", "uploader", "post", "post__thread", "post__category" - ) + return qs.select_related("uploader", "post", "post__thread", "post__category") class AttachmentsList(AttachmentAdmin, generic.ListView): @@ -88,9 +88,9 @@ def button_action(self, request, target): self.delete_from_cache(target) target.delete() message = pgettext( - "admin attachments", 'Attachment "%(filename)s" has been deleted.' + "admin attachments", 'Attachment "%(name)s" has been deleted.' ) - messages.success(request, message % {"filename": target.filename}) + messages.success(request, message % {"name": target.name}) def delete_from_cache(self, attachment): if not attachment.post.attachments_cache: @@ -103,3 +103,12 @@ def delete_from_cache(self, attachment): attachment.post.attachments_cache = clean_cache or None attachment.post.save(update_fields=["attachments_cache"]) + + +class AttachmentsFiletypesList(generic.AdminView): + root_link = "misago:admin:attachments:filetypes:index" + templates_dir = "misago/admin/attachments_filetypes" + template_name = "list.html" + + def get(self, request): + return self.render(request, {"items": filetypes.get_all_filetypes()}) diff --git a/misago/admin/categories/forms.py b/misago/admin/categories/forms.py index 8e5ba60b84..32b7980abd 100644 --- a/misago/admin/categories/forms.py +++ b/misago/admin/categories/forms.py @@ -326,15 +326,6 @@ def __init__(self, *args, **kwargs): self.setup_fields() def setup_fields(self): - content_queryset = Category.objects.all_categories().order_by("lft") - self.fields["move_threads_to"] = AdminCategoryChoiceField( - label=pgettext_lazy("admin category form", "Move category threads to"), - queryset=content_queryset, - initial=self.instance.parent, - empty_label=pgettext_lazy("admin category form", "Delete with category"), - required=False, - ) - not_siblings = models.Q(lft__lt=self.instance.lft) not_siblings = not_siblings | models.Q(rght__gt=self.instance.rght) children_queryset = Category.objects.all_categories(True) @@ -350,22 +341,31 @@ def setup_fields(self): required=False, ) + content_queryset = Category.objects.all_categories().order_by("lft") + self.fields["move_contents_to"] = AdminCategoryChoiceField( + label=pgettext_lazy("admin category form", "Move contents to"), + queryset=content_queryset, + initial=self.instance.parent, + empty_label=pgettext_lazy("admin category form", "Delete with category"), + required=False, + ) + def clean(self): data = super().clean() - if data.get("move_threads_to"): - if data["move_threads_to"].pk == self.instance.pk: + if data.get("move_contents_to"): + if data["move_contents_to"].pk == self.instance.pk: message = pgettext_lazy( "admin category form", "You are trying to move this category threads to itself.", ) raise forms.ValidationError(message) - moving_to_child = self.instance.has_child(data["move_threads_to"]) + moving_to_child = self.instance.has_child(data["move_contents_to"]) if moving_to_child and not data.get("move_children_to"): message = pgettext_lazy( "admin category form", - "You are trying to move this category's threads to a child category that will also be deleted.", + "You are trying to move this category's contents to a child category that will also be deleted.", ) raise forms.ValidationError(message) diff --git a/misago/admin/categories/views.py b/misago/admin/categories/views.py index 37bbe59cad..61ef15e9b2 100644 --- a/misago/admin/categories/views.py +++ b/misago/admin/categories/views.py @@ -6,6 +6,7 @@ from ...admin.views import generic from ...cache.enums import CacheName from ...cache.versions import invalidate_cache +from ...categories.delete import delete_category from ...categories.enums import CategoryTree from ...categories.models import Category, RoleCategoryACL from ...permissions.admin import get_admin_category_permissions @@ -167,32 +168,17 @@ class DeleteCategory(CategoryAdmin, generic.ModelFormView): def handle_form(self, form, request, target): move_children_to = form.cleaned_data.get("move_children_to") - move_threads_to = form.cleaned_data.get("move_threads_to") + move_contents_to = form.cleaned_data.get("move_contents_to") - if move_children_to: - for child in target.get_children(): - # refresh child and new parent - move_children_to = Category.objects.get(pk=move_children_to.pk) - child = Category.objects.get(pk=child.pk) + if move_children_to and not move_children_to.level: + move_children_to = True - child.move_to(move_children_to, "last-child") - if move_threads_to and child.pk == move_threads_to.pk: - move_threads_to = child - else: - for child in target.get_descendants().order_by("-lft"): - child.delete_content() - child.delete() - - if move_threads_to: - target.move_content(move_threads_to) - move_threads_to.synchronize() - move_threads_to.save() - else: - target.delete_content() - - # refresh instance - instance = Category.objects.get(pk=form.instance.pk) - instance.delete() + delete_category( + target, + move_children_to=move_children_to, + move_contents_to=move_contents_to, + request=request, + ) invalidate_cache( CacheName.CATEGORIES, diff --git a/misago/admin/groups/forms.py b/misago/admin/groups/forms.py index 993e69ddc2..1a1ddb8c6d 100644 --- a/misago/admin/groups/forms.py +++ b/misago/admin/groups/forms.py @@ -1,6 +1,6 @@ from django import forms from django.core.validators import validate_slug -from django.utils.translation import pgettext_lazy +from django.utils.translation import pgettext, pgettext_lazy from ...core.validators import validate_color_hex, validate_css_name, validate_sluggable from ...parser.context import create_parser_context @@ -9,6 +9,7 @@ from ...parser.html import render_ast_to_html from ...parser.metadata import create_ast_metadata from ...parser.plaintext import PlainTextFormat, render_ast_to_plaintext +from ...permissions.enums import CanUploadAttachments from ...users.models import Group, GroupDescription from ..forms import YesNoSwitch @@ -169,6 +170,52 @@ class EditGroupForm(forms.ModelForm): min_value=1, ) + can_upload_attachments = forms.TypedChoiceField( + label=pgettext_lazy("admin group permissions form", "Can upload attachments"), + choices=CanUploadAttachments.get_choices(), + widget=forms.RadioSelect(), + coerce=int, + ) + attachment_storage_limit = forms.IntegerField( + label=pgettext_lazy( + "admin group permissions form", "Total attachment storage limit" + ), + help_text=pgettext_lazy( + "admin group permissions form", + "Maximum total storage space, in megabytes, that each member of this group can to use for their attachments. Enter zero to remove this limit.", + ), + min_value=0, + ) + unused_attachments_storage_limit = forms.IntegerField( + label=pgettext_lazy( + "admin group permissions form", "Unused attachments storage limit" + ), + help_text=pgettext_lazy( + "admin group permissions form", + "Maximum total storage space, in megabytes, for member's attachments that have been uploaded but are not associated with any posts. Enter zero to remove this limit.", + ), + min_value=0, + ) + attachment_size_limit = forms.IntegerField( + label=pgettext_lazy( + "admin group permissions form", "Attachment file size limit" + ), + help_text=pgettext_lazy( + "admin group permissions form", + "Maximum file size of an attachment in kilobytes. Enter zero to remove this limit. Note: Server and Django request body size limits will still apply.", + ), + min_value=0, + ) + can_always_delete_own_attachments = YesNoSwitch( + label=pgettext_lazy( + "admin group permissions form", "Can always delete own attachments" + ), + help_text=pgettext_lazy( + "admin group permissions form", + "This permission allows users to delete their own attachments, even if they no longer have permission to edit or view the post they are associated with.", + ), + ) + can_change_username = YesNoSwitch( label=pgettext_lazy("admin group permissions form", "Can change username"), ) @@ -226,6 +273,11 @@ class Meta: "can_use_private_threads", "can_start_private_threads", "private_thread_users_limit", + "can_upload_attachments", + "attachment_storage_limit", + "unused_attachments_storage_limit", + "attachment_size_limit", + "can_always_delete_own_attachments", "can_change_username", "username_changes_limit", "username_changes_expire", @@ -240,6 +292,28 @@ def __init__(self, *args, **kwargs): id=kwargs["instance"].id ) + def clean(self): + data = super().clean() + + attachment_storage_limit = data.get("attachment_storage_limit") + unused_attachments_storage_limit = data.get("unused_attachments_storage_limit") + if ( + attachment_storage_limit + and unused_attachments_storage_limit + and unused_attachments_storage_limit > attachment_storage_limit + ): + self.add_error( + "unused_attachments_storage_limit", + forms.ValidationError( + message=pgettext( + "admin group form", + "Unused attachments limit cannot exceed total attachments limit.", + ), + ), + ) + + return data + class EditGroupDescriptionForm(forms.ModelForm): markdown = forms.CharField( diff --git a/misago/admin/templates/misago/admin/attachments/list.html b/misago/admin/templates/misago/admin/attachments/list.html new file mode 100644 index 0000000000..bfdedd190c --- /dev/null +++ b/misago/admin/templates/misago/admin/attachments/list.html @@ -0,0 +1,143 @@ +{% extends "misago/admin/generic/list.html" %} +{% load i18n misago_admin_form misago_capture %} + + +{% block table-header %} +  +{% translate "Attachment" context "admin attachments list" %} +{% translate "Size" context "admin attachments list" %} +{% translate "Type" context "admin attachments list" %} +{% translate "Uploader" context "admin attachments list" %} +{% translate "Uploaded at" context "admin attachments list" %} +{% translate "Thread" context "admin attachments list" %} +  +{% endblock table-header %} + + +{% block table-row %} +{% if item.upload %} + {% if item.filetype.is_image %} + + {% if item.thumbnail %} + + {% else %} + + {% endif %} + + {% else %} + + + + + + {% endif %} +{% else %} + +
+ +
+ +{% endif %} + + {% if item.upload %} + + {{ item.name }} + + {% else %} + + {{ item.name }} + + {% endif %} + + + {{ item.size|filesizeformat }} + + + {{ item.filetype_name }} + + + {% if item.uploader %} + {{ item.uploader }} + {% else %} + {{ item.uploader_name }} + {% endif %} + + + + {{ item.uploaded_at }} + + + + {% if item.post %} + + {{ item.post.thread }} + + {% elif item.is_deleted %} + + {% translate "Marked for deletion" context "admin attachment status" %} + + {% else %} + + {% translate "Unused" context "admin attachment status" %} + + {% endif %} + + +
+ {% csrf_token %} + +
+ +{% endblock table-row %} + + +{% block blankslate %} + + {% if active_filters %} + {% translate "No attachments matching criteria exist." context "admin attachments" %} + {% else %} + {% translate "No attachments exist." context "admin attachments" %} + {% endif %} + +{% endblock blankslate %} + + +{% block filters-modal-body %} +
+
+ {% form_row filter_form.uploader %} +
+
+
+
+ {% form_row filter_form.name %} +
+
+
+
+ {% form_row filter_form.filetype %} +
+
+
+
+ {% form_row filter_form.status %} +
+
+{% endblock filters-modal-body %} + + +{% block javascripts %} +{{ block.super }} + +{% endblock %} diff --git a/misago/admin/templates/misago/admin/attachments_filetypes/list.html b/misago/admin/templates/misago/admin/attachments_filetypes/list.html new file mode 100644 index 0000000000..06416409c2 --- /dev/null +++ b/misago/admin/templates/misago/admin/attachments_filetypes/list.html @@ -0,0 +1,61 @@ +{% extends "misago/admin/generic/base.html" %} +{% load i18n %} + + +{% block title %} +{{ active_link.name }} | {{ block.super }} +{% endblock title %} + + +{% block view %} +
+ + + + + + + + + + + + {% for item in items %} + + + + + + + + {% empty %} + + + + {% endfor %} + +
{% translate "ID" context "admin attachment filetypes list" %}{% translate "Name" context "admin attachment filetypes list" %}{% translate "Extensions" context "admin attachment filetypes list" %}{% translate "Content types" context "admin attachment filetypes list" %} 
{{ item.id }}{{ item.name }} + {% for extension in item.extensions %} + .{{ extension }}{% if not forloop.last %},{% endif %} + {% endfor %} + + {% for content_type in item.content_types %} + {{ content_type }}{% if not forloop.last %},{% endif %} + {% endfor %} + + + + +
+ {% translate "No attachments file types exist." context "admin attachments filetypes" %} +
+
+{% endblock view %} \ No newline at end of file diff --git a/misago/templates/misago/admin/attachmenttypes/form.html b/misago/admin/templates/misago/admin/attachmenttypes/form.html similarity index 100% rename from misago/templates/misago/admin/attachmenttypes/form.html rename to misago/admin/templates/misago/admin/attachmenttypes/form.html diff --git a/misago/templates/misago/admin/attachmenttypes/list.html b/misago/admin/templates/misago/admin/attachmenttypes/list.html similarity index 100% rename from misago/templates/misago/admin/attachmenttypes/list.html rename to misago/admin/templates/misago/admin/attachmenttypes/list.html diff --git a/misago/templates/misago/admin/base.html b/misago/admin/templates/misago/admin/base.html similarity index 100% rename from misago/templates/misago/admin/base.html rename to misago/admin/templates/misago/admin/base.html diff --git a/misago/admin/templates/misago/admin/categories/delete.html b/misago/admin/templates/misago/admin/categories/delete.html index 087f66edbc..a99859b60c 100644 --- a/misago/admin/templates/misago/admin/categories/delete.html +++ b/misago/admin/templates/misago/admin/categories/delete.html @@ -3,9 +3,9 @@ {% block title %} -{% blocktrans trimmed with category=target.name context "admin category form" %} +{% blocktranslate trimmed with category=target.name context "admin category form" %} Delete category: {{ category }} -{% endblocktrans %} | {{ active_link.name }} | {{ block.super }} +{% endblocktranslate %} | {{ active_link.name }} | {{ block.super }} {% endblock title %} @@ -18,23 +18,23 @@ {% block form-header %} -{% trans "Delete category" context "admin category form" %} +{% translate "Delete category" context "admin category form" %} {% endblock %} {% block form-body %}
- {% trans "Category contents" context "admin category form" %} + {% translate "Category contents" context "admin category form" %} {% if not form.instance.is_leaf_node %} {% form_row form.move_children_to %} {% endif %} - {% form_row form.move_threads_to %} + {% form_row form.move_contents_to %}
{% endblock form-body %} {% block form-footer %} - + {% endblock %} diff --git a/misago/admin/templates/misago/admin/categories/form.html b/misago/admin/templates/misago/admin/categories/form.html index 7ecaba0979..d7f23f60bd 100644 --- a/misago/admin/templates/misago/admin/categories/form.html +++ b/misago/admin/templates/misago/admin/categories/form.html @@ -6,7 +6,7 @@ {% if target.pk %} {{ target }} {% else %} - {% trans "New category" context "admin category form" %} + {% translate "New category" context "admin category form" %} {% endif %} | {{ active_link.name }} | {{ block.super }} {% endblock title %} @@ -26,13 +26,13 @@
- {% trans "Change permissions" context "admin categories" %} + {% translate "Change permissions" context "admin categories" %}
- {% trans "View on site" context "admin categories" %} + {% translate "View on site" context "admin categories" %}
{% endif %} @@ -41,9 +41,9 @@ {% block form-header %} {% if target.pk %} - {% trans "Edit category" context "admin category form" %} + {% translate "Edit category" context "admin category form" %} {% else %} - {% trans "New category" context "admin category form" %} + {% translate "New category" context "admin category form" %} {% endif %} {% endblock %} @@ -51,7 +51,7 @@ {% block form-body %}
- {% trans "Display and position" context "admin category form" %} + {% translate "Display and position" context "admin category form" %} {% form_row form.new_parent %} {% form_row form.name %} @@ -64,7 +64,7 @@
- {% trans "Behavior" context "admin category form" %} + {% translate "Behavior" context "admin category form" %} {% form_row form.copy_permissions %} {% form_row form.allow_polls %} @@ -79,7 +79,7 @@
- {% trans "Content approval" context "admin category form" %} + {% translate "Content approval" context "admin category form" %} {% form_row form.require_threads_approval %} {% form_row form.require_replies_approval %} @@ -89,7 +89,7 @@
- {% trans "Prune threads" context "admin category form" %} + {% translate "Prune threads" context "admin category form" %} {% form_row form.prune_started_after %} {% form_row form.prune_replied_after %} diff --git a/misago/admin/templates/misago/admin/categories/list.html b/misago/admin/templates/misago/admin/categories/list.html index 8682190d47..cca07f96d7 100644 --- a/misago/admin/templates/misago/admin/categories/list.html +++ b/misago/admin/templates/misago/admin/categories/list.html @@ -6,18 +6,18 @@
- {% trans "New category" context "admin categories" %} + {% translate "New category" context "admin categories" %}
{% endblock %} {% block table-header %} -{% trans "Category" context "admin categories list" %} -{% trans "Label" context "admin categories list" %} -{% trans "CSS class" context "admin categories list" %} -{% trans "Threads" context "admin categories list" %} -{% trans "Posts" context "admin categories list" %} +{% translate "Category" context "admin categories list" %} +{% translate "Label" context "admin categories list" %} +{% translate "CSS class" context "admin categories list" %} +{% translate "Threads" context "admin categories list" %} +{% translate "Posts" context "admin categories list" %}       @@ -46,7 +46,7 @@ {% if item.css_class %} 
{{ item.css_class }}
{% else %} - {% trans "Not set" context "admin category css class" %} + {% translate "Not set" context "admin category css class" %} {% endif %} @@ -56,7 +56,7 @@ {{ item.posts }} - + @@ -64,7 +64,7 @@ {% if not item.first %}
{% csrf_token %} -
@@ -78,7 +78,7 @@ {% if not item.last %}
{% csrf_token %} -
@@ -89,7 +89,7 @@ {% endif %} - + @@ -100,7 +100,7 @@
- {% trans "Change permissions" context "admin categories" %} + {% translate "Change permissions" context "admin categories" %} {% for action in extra_actions %} @@ -108,10 +108,10 @@ {% endfor %} - {% trans "Edit category" context "admin categories" %} + {% translate "Edit category" context "admin categories" %} - {% trans "Delete category" context "admin categories" %} + {% translate "Delete category" context "admin categories" %}
@@ -121,6 +121,6 @@ {% block blankslate %} - {% trans "No categories are set." context "admin categories" %} + {% translate "No categories are set." context "admin categories" %} {% endblock blankslate %} diff --git a/misago/admin/templates/misago/admin/categories/permissions.html b/misago/admin/templates/misago/admin/categories/permissions.html index 14cf3a0f59..a7b2f8bf40 100644 --- a/misago/admin/templates/misago/admin/categories/permissions.html +++ b/misago/admin/templates/misago/admin/categories/permissions.html @@ -3,7 +3,7 @@ {% block title %} -{% trans "Category permissions" context "admin category form" %} | {{ target }} | {{ active_link.name }} | {{ block.super }} +{% translate "Category permissions" context "admin category form" %} | {{ target }} | {{ active_link.name }} | {{ block.super }} {% endblock title %} @@ -19,23 +19,23 @@
- {% trans "Edit category" context "admin categories" %} + {% translate "Edit category" context "admin categories" %}
- {% trans "View on site" context "admin categories" %} + {% translate "View on site" context "admin categories" %}
{% endblock %} {% block form-header %} -{% trans "Category permissions" context "admin category form" %} +{% translate "Category permissions" context "admin category form" %} {% endblock %} {% block item-header %} -{% trans "Category" context "admin category form" %} +{% translate "Category" context "admin category form" %} {% endblock item-header %} \ No newline at end of file diff --git a/misago/templates/misago/admin/dashboard/analytics.html b/misago/admin/templates/misago/admin/dashboard/analytics.html similarity index 100% rename from misago/templates/misago/admin/dashboard/analytics.html rename to misago/admin/templates/misago/admin/dashboard/analytics.html diff --git a/misago/templates/misago/admin/dashboard/checks.html b/misago/admin/templates/misago/admin/dashboard/checks.html similarity index 78% rename from misago/templates/misago/admin/dashboard/checks.html rename to misago/admin/templates/misago/admin/dashboard/checks.html index 2d25bd0ffe..c22d688129 100644 --- a/misago/templates/misago/admin/dashboard/checks.html +++ b/misago/admin/templates/misago/admin/dashboard/checks.html @@ -29,8 +29,8 @@
{% translate "Checking Misago version used by the site..." context "admin ve
{% translate "The site is running in DEBUG mode." context "admin debug check" %}
{% blocktranslate trimmed context "admin debug check" %} - Error pages displayed in DEBUG mode will expose site configuration details like secrets and tokens to all visitors. - This is MAJOR security risk. + Error pages displayed in the DEBUG mode will expose site configuration details like secrets and tokens to all visitors. + This is a MAJOR security risk. {% endblocktranslate %}
@@ -85,7 +85,7 @@
{% translate "Configured forum address appears to be incorrect." context "ad
- +
@@ -143,6 +143,43 @@
{% endif %} + {% if not checks.attachments_storage.is_ok %} +
+
+
+
+ {% if checks.attachments_storage.usage > 85 %} +
+ +
+ {% else %} +
+ +
+ {% endif %} +
+
+ {% blocktranslate trimmed with usage=checks.attachments_storage.usage context "admin attachments storage check" %} + Unused attachments storage is {{ usage }}% full. + {% endblocktranslate %} +
+ {% blocktranslate trimmed context "admin attachments storage check" %} + Users without unlimited unused attachments storage will not be able to upload files if it is 100% full. + {% endblocktranslate %} + {% blocktranslate trimmed with space_left=checks.attachments_storage.space_left|filesizeformat limit=checks.attachments_storage.limit|filesizeformat context "admin attachments storage check" %} + {{ space_left }} of {{ limit }} is available for new attachments. + {% endblocktranslate %} +
+
+
+
+ + + +
+
+
+ {% endif %} {% if not checks.inactive_users.is_ok %}
diff --git a/misago/templates/misago/admin/dashboard/index.html b/misago/admin/templates/misago/admin/dashboard/index.html similarity index 100% rename from misago/templates/misago/admin/dashboard/index.html rename to misago/admin/templates/misago/admin/dashboard/index.html diff --git a/misago/admin/templates/misago/admin/dashboard/totals.html b/misago/admin/templates/misago/admin/dashboard/totals.html new file mode 100644 index 0000000000..00b9accb1a --- /dev/null +++ b/misago/admin/templates/misago/admin/dashboard/totals.html @@ -0,0 +1,36 @@ +{% load i18n %} +
+
+

+ {% translate "Totals" context "admin dashboard totals" %} +

+
+ + + + + + + + + +
+ {% translate "Users:" context "admin dashboard totals" %} + {{ totals.users }} + + {% translate "Threads:" context "admin dashboard totals" %} + {{ totals.threads }} + + {% translate "Posts:" context "admin dashboard totals" %} + {{ totals.posts }} + + {% translate "Attachments:" context "admin dashboard totals" %} + {{ totals.attachments }} + + {% translate "Attachments size:" context "admin dashboard totals" %} + {{ totals.attachments_total_size|filesizeformat }} + + {% translate "Unused attachments:" context "admin dashboard totals" %} + {{ totals.attachments_unused_size|filesizeformat }} +
+
\ No newline at end of file diff --git a/misago/templates/misago/admin/errorpages/403.html b/misago/admin/templates/misago/admin/errorpages/403.html similarity index 100% rename from misago/templates/misago/admin/errorpages/403.html rename to misago/admin/templates/misago/admin/errorpages/403.html diff --git a/misago/templates/misago/admin/errorpages/404.html b/misago/admin/templates/misago/admin/errorpages/404.html similarity index 100% rename from misago/templates/misago/admin/errorpages/404.html rename to misago/admin/templates/misago/admin/errorpages/404.html diff --git a/misago/templates/misago/admin/errorpages/csrf_failure.html b/misago/admin/templates/misago/admin/errorpages/csrf_failure.html similarity index 100% rename from misago/templates/misago/admin/errorpages/csrf_failure.html rename to misago/admin/templates/misago/admin/errorpages/csrf_failure.html diff --git a/misago/templates/misago/admin/errorpages/csrf_failure_authenticated.html b/misago/admin/templates/misago/admin/errorpages/csrf_failure_authenticated.html similarity index 100% rename from misago/templates/misago/admin/errorpages/csrf_failure_authenticated.html rename to misago/admin/templates/misago/admin/errorpages/csrf_failure_authenticated.html diff --git a/misago/templates/misago/admin/errorpages/csrf_failure_message.html b/misago/admin/templates/misago/admin/errorpages/csrf_failure_message.html similarity index 100% rename from misago/templates/misago/admin/errorpages/csrf_failure_message.html rename to misago/admin/templates/misago/admin/errorpages/csrf_failure_message.html diff --git a/misago/templates/misago/admin/form/checkbox_row.html b/misago/admin/templates/misago/admin/form/checkbox_row.html similarity index 100% rename from misago/templates/misago/admin/form/checkbox_row.html rename to misago/admin/templates/misago/admin/form/checkbox_row.html diff --git a/misago/admin/templates/misago/admin/form/dimensions_row.html b/misago/admin/templates/misago/admin/form/dimensions_row.html new file mode 100644 index 0000000000..26866cb41d --- /dev/null +++ b/misago/admin/templates/misago/admin/form/dimensions_row.html @@ -0,0 +1,26 @@ +{% load i18n misago_admin_form %} +
+ +
+
+ {% form_input field_width %} + + {% form_input field_height %} +
+ {% for error in field_width.errors %} + + {% translate "Width:" context "admin dimension field" %} {{ error }} + + {% endfor %} + {% for error in field_height.errors %} + + {% translate "Height:" context "admin dimension field" %} {{ error }} + + {% endfor %} + {% if field_width.help_text %} + {{ field_width.help_text }} + {% endif %} +
+
\ No newline at end of file diff --git a/misago/templates/misago/admin/form/image_row.html b/misago/admin/templates/misago/admin/form/image_row.html similarity index 100% rename from misago/templates/misago/admin/form/image_row.html rename to misago/admin/templates/misago/admin/form/image_row.html diff --git a/misago/templates/misago/admin/form/input.html b/misago/admin/templates/misago/admin/form/input.html similarity index 100% rename from misago/templates/misago/admin/form/input.html rename to misago/admin/templates/misago/admin/form/input.html diff --git a/misago/templates/misago/admin/form/multiple_choice.html b/misago/admin/templates/misago/admin/form/multiple_choice.html similarity index 100% rename from misago/templates/misago/admin/form/multiple_choice.html rename to misago/admin/templates/misago/admin/form/multiple_choice.html diff --git a/misago/templates/misago/admin/form/radio_select.html b/misago/admin/templates/misago/admin/form/radio_select.html similarity index 100% rename from misago/templates/misago/admin/form/radio_select.html rename to misago/admin/templates/misago/admin/form/radio_select.html diff --git a/misago/templates/misago/admin/form/row.html b/misago/admin/templates/misago/admin/form/row.html similarity index 95% rename from misago/templates/misago/admin/form/row.html rename to misago/admin/templates/misago/admin/form/row.html index 04a548980e..d28542bc4e 100644 --- a/misago/templates/misago/admin/form/row.html +++ b/misago/admin/templates/misago/admin/form/row.html @@ -1,5 +1,5 @@ {% load i18n misago_admin_form %} -
+
diff --git a/misago/templates/misago/admin/form/select.html b/misago/admin/templates/misago/admin/form/select.html similarity index 100% rename from misago/templates/misago/admin/form/select.html rename to misago/admin/templates/misago/admin/form/select.html diff --git a/misago/admin/templates/misago/admin/generic/filter_form.html b/misago/admin/templates/misago/admin/generic/filter_form.html index 30a6ea1c58..1f413423ba 100644 --- a/misago/admin/templates/misago/admin/generic/filter_form.html +++ b/misago/admin/templates/misago/admin/generic/filter_form.html @@ -4,7 +4,7 @@ {% endif %} diff --git a/misago/admin/templates/misago/admin/generic/form.html b/misago/admin/templates/misago/admin/generic/form.html index 615097f199..8f3ddaaa6e 100644 --- a/misago/admin/templates/misago/admin/generic/form.html +++ b/misago/admin/templates/misago/admin/generic/form.html @@ -22,7 +22,7 @@
{% empty %} {% endfor %} {% endif %} @@ -33,7 +33,7 @@
{% block form-footer-cancel %} - {% trans "Cancel" context "admin form" %} + {% translate "Cancel" context "admin form" %} {% endblock %} {% block form-footer %} diff --git a/misago/admin/templates/misago/admin/generic/form_footer.html b/misago/admin/templates/misago/admin/generic/form_footer.html index 93c0df9597..249bd462d1 100644 --- a/misago/admin/templates/misago/admin/generic/form_footer.html +++ b/misago/admin/templates/misago/admin/generic/form_footer.html @@ -1,16 +1,16 @@ {% load i18n %} {% if target and target.pk %} {% else %} {% endif %} \ No newline at end of file diff --git a/misago/admin/templates/misago/admin/generic/list.html b/misago/admin/templates/misago/admin/generic/list.html index b613397a6e..0848729178 100644 --- a/misago/admin/templates/misago/admin/generic/list.html +++ b/misago/admin/templates/misago/admin/generic/list.html @@ -84,10 +84,10 @@
-
@@ -102,10 +102,10 @@
{% endif %} -{% endblock content%} +{% endblock content %} {% block javascripts %} diff --git a/misago/admin/templates/misago/admin/generic/mass_actions.html b/misago/admin/templates/misago/admin/generic/mass_actions.html index f466ca3a34..017204549c 100644 --- a/misago/admin/templates/misago/admin/generic/mass_actions.html +++ b/misago/admin/templates/misago/admin/generic/mass_actions.html @@ -7,7 +7,7 @@ {{ empty_selection_label }}
-
{% trans "With selected:" context "admin list" %}
+
{% translate "With selected:" context "admin list" %}
{% for action in mass_actions %}
- {% trans "Change sorting to:" context "admin list ordering" %} + {% translate "Change sorting to:" context "admin list ordering" %}
{% for ordering in order_by %}
diff --git a/misago/admin/templates/misago/admin/generic/paginator.html b/misago/admin/templates/misago/admin/generic/paginator.html index 3e9f2ac086..6e4e4b59ed 100644 --- a/misago/admin/templates/misago/admin/generic/paginator.html +++ b/misago/admin/templates/misago/admin/generic/paginator.html @@ -1,16 +1,16 @@ {% load i18n %}
{% if page.has_previous %} - - {% trans "First" context "admin paginator" %} + + {% translate "First" context "admin paginator" %} {% else %} {% endif %} {% if page.number > 1 %} - + {% else %} @@ -19,23 +19,23 @@ {% endif %} {% if page.has_next %} - + - - {% trans "Last" context "admin paginator" %} + + {% translate "Last" context "admin paginator" %} {% else %} {% endif %}
- {% blocktrans trimmed with page=page.number pages=paginator.num_pages context "admin paginator" %} + {% blocktranslate trimmed with page=page.number pages=paginator.num_pages context "admin paginator" %} Page {{ page }} of {{ pages }} - {% endblocktrans %} + {% endblocktranslate %}
diff --git a/misago/admin/templates/misago/admin/generic/permissions_form.html b/misago/admin/templates/misago/admin/generic/permissions_form.html index ef652ee7c2..1484a78fc3 100644 --- a/misago/admin/templates/misago/admin/generic/permissions_form.html +++ b/misago/admin/templates/misago/admin/generic/permissions_form.html @@ -13,8 +13,8 @@
{% block form-header %}{% endblock form-header %} - {% trans "Hint:" context "admin permissions table" %} - {% trans "Click on permission or item name to quickly toggle selection." context "admin permissions table" %} + {% translate "Hint:" context "admin permissions table" %} + {% translate "Click on permission or item name to quickly toggle selection." context "admin permissions table" %}
@@ -53,7 +53,7 @@
{% block form-footer-cancel %} - {% trans "Cancel" context "admin form" %} + {% translate "Cancel" context "admin form" %} {% endblock %} {% block form-footer %} diff --git a/misago/admin/templates/misago/admin/groups/categories.html b/misago/admin/templates/misago/admin/groups/categories.html index 92dd6dde13..cae45bb40b 100644 --- a/misago/admin/templates/misago/admin/groups/categories.html +++ b/misago/admin/templates/misago/admin/groups/categories.html @@ -3,7 +3,7 @@ {% block title %} -{% trans "Category permissions" context "admin group form" %} | {{ target }} | {{ active_link.name }} | {{ block.super }} +{% translate "Category permissions" context "admin group form" %} | {{ target }} | {{ active_link.name }} | {{ block.super }} {% endblock title %} @@ -19,17 +19,17 @@
- {% trans "Edit group" context "admin groups" %} + {% translate "Edit group" context "admin groups" %}
{% endblock %} {% block form-header %} -{% trans "Category permissions" context "admin group form" %} +{% translate "Category permissions" context "admin group form" %} {% endblock %} {% block item-header %} -{% trans "Category" context "admin group form" %} +{% translate "Category" context "admin group form" %} {% endblock item-header %} \ No newline at end of file diff --git a/misago/admin/templates/misago/admin/groups/edit.html b/misago/admin/templates/misago/admin/groups/edit.html index f08d4252eb..a607d151ce 100644 --- a/misago/admin/templates/misago/admin/groups/edit.html +++ b/misago/admin/templates/misago/admin/groups/edit.html @@ -19,21 +19,21 @@
- {% trans "Category permissions" context "admin groups" %} + {% translate "Category permissions" context "admin groups" %}
{% endblock %} {% block form-header %} -{% trans "Edit group" context "admin group form" %} +{% translate "Edit group" context "admin group form" %} {% endblock %} {% block form-body %}
- {% trans "Basic settings" context "admin group form" %} + {% translate "Basic settings" context "admin group form" %} {% form_row form.group.name %} {% form_row form.group.slug %} @@ -42,7 +42,7 @@
- {% trans "Description" context "admin group form" %} + {% translate "Description" context "admin group form" %} {% form_row form.description.markdown %} {% form_row form.description.meta %} @@ -51,7 +51,7 @@
- {% trans "Display and appearance" context "admin group form" %} + {% translate "Display and appearance" context "admin group form" %} {% form_row form.group.user_title %} {% form_row form.group.color %} @@ -64,7 +64,7 @@
- {% trans "Permissions" context "admin group form" %} + {% translate "Permissions" context "admin group form" %} {% form_row form.group.copy_permissions %} @@ -72,7 +72,7 @@
- {% trans "Posting" context "admin group permissions form" %} + {% translate "Posting" context "admin group permissions form" %} {% form_row form.group.can_edit_own_threads %} {% form_row form.group.own_threads_edit_time_limit %} @@ -84,7 +84,7 @@
- {% trans "Private threads" context "admin group permissions form" %} + {% translate "Private threads" context "admin group permissions form" %} {% form_row form.group.can_use_private_threads %} {% form_row form.group.can_start_private_threads %} @@ -94,7 +94,19 @@
- {% trans "Usernames" context "admin group permissions form" %} + {% translate "Attachments" context "admin group permissions form" %} + + {% form_row form.group.can_upload_attachments %} + {% form_row form.group.attachment_storage_limit %} + {% form_row form.group.unused_attachments_storage_limit %} + {% form_row form.group.attachment_size_limit %} + {% form_row form.group.can_always_delete_own_attachments %} + +
+
+
+
+ {% translate "Usernames" context "admin group permissions form" %} {% form_row form.group.can_change_username %} {% form_row form.group.username_changes_limit %} @@ -105,7 +117,7 @@
- {% trans "User profiles" context "admin group permissions form" %} + {% translate "User profiles" context "admin group permissions form" %} {% form_row form.group.can_see_user_profiles %} diff --git a/misago/admin/templates/misago/admin/groups/list.html b/misago/admin/templates/misago/admin/groups/list.html index 4b4fcb18f6..13a7791a85 100644 --- a/misago/admin/templates/misago/admin/groups/list.html +++ b/misago/admin/templates/misago/admin/groups/list.html @@ -6,7 +6,7 @@
- {% trans "New group" context "admin groups" %} + {% translate "New group" context "admin groups" %}
{% endblock %} @@ -14,12 +14,12 @@ {% block table-header %}
- + - - - - + + + + @@ -39,28 +39,28 @@ @@ -89,12 +89,12 @@ {{ item.members_count|default:0 }} @@ -104,35 +104,35 @@
-
{% trans "Show members" context "admin groups" %}
+
{% translate "Show members" context "admin groups" %}
- {% trans "All members" context "admin groups" %} + {% translate "All members" context "admin groups" %} - {% trans "Main group" context "admin groups" %} + {% translate "Main group" context "admin groups" %}
-
{% trans "Admin group" context "admin groups" %}
+
{% translate "Admin group" context "admin groups" %}
{% if not item.is_default and item.id not in invalid_default_group_ids %} {% csrf_token %} {% endif %} - {% trans "Edit group" context "admin groups" %} + {% translate "Edit group" context "admin groups" %} - {% trans "Category permissions" context "admin groups" %} + {% translate "Category permissions" context "admin groups" %} {% if not item.is_protected %}
{% csrf_token %} {% endif %} @@ -146,7 +146,7 @@
{% trans "Admin group" context "admin groups" %}
window.misago.initConfirmation( "[data-delete-confirmation]", - "{% trans 'Are you sure you want to delete this group?' context 'admin groups' %}" + "{% translate 'Are you sure you want to delete this group?' context 'admin groups' %}" ) window.misago.initItemsOrdering("{% url 'misago:admin:groups:ordering' %}") diff --git a/misago/admin/templates/misago/admin/groups/new.html b/misago/admin/templates/misago/admin/groups/new.html index 78d35aad91..fbedae23ea 100644 --- a/misago/admin/templates/misago/admin/groups/new.html +++ b/misago/admin/templates/misago/admin/groups/new.html @@ -3,12 +3,12 @@ {% block title %} -{% trans "New group" context "admin group form" %} | {{ active_link.name }} | {{ block.super }} +{% translate "New group" context "admin group form" %} | {{ active_link.name }} | {{ block.super }} {% endblock title %} {% block form-header %} -{% trans "New group" context "admin group form" %} +{% translate "New group" context "admin group form" %} {% endblock %} @@ -23,5 +23,5 @@ {% block form-footer %} - + {% endblock form-footer %} diff --git a/misago/templates/misago/admin/icons.html b/misago/admin/templates/misago/admin/icons.html similarity index 100% rename from misago/templates/misago/admin/icons.html rename to misago/admin/templates/misago/admin/icons.html diff --git a/misago/templates/misago/admin/layout.html b/misago/admin/templates/misago/admin/layout.html similarity index 100% rename from misago/templates/misago/admin/layout.html rename to misago/admin/templates/misago/admin/layout.html diff --git a/misago/templates/misago/admin/login.html b/misago/admin/templates/misago/admin/login.html similarity index 100% rename from misago/templates/misago/admin/login.html rename to misago/admin/templates/misago/admin/login.html diff --git a/misago/templates/misago/admin/messages.html b/misago/admin/templates/misago/admin/messages.html similarity index 100% rename from misago/templates/misago/admin/messages.html rename to misago/admin/templates/misago/admin/messages.html diff --git a/misago/admin/templates/misago/admin/moderators/form.html b/misago/admin/templates/misago/admin/moderators/form.html index b4b88ad178..2d4547fd95 100644 --- a/misago/admin/templates/misago/admin/moderators/form.html +++ b/misago/admin/templates/misago/admin/moderators/form.html @@ -6,7 +6,7 @@ {% if target.pk %} {{ target }} {% else %} - {% trans "New moderator" context "admin moderator form" %} + {% translate "New moderator" context "admin moderator form" %} {% endif %} | {{ active_link.name }} | {{ block.super }} {% endblock title %} @@ -21,9 +21,9 @@ {% block form-header %} {% if target.pk %} - {% trans "Edit moderator" context "admin moderator form" %} + {% translate "Edit moderator" context "admin moderator form" %} {% else %} - {% trans "New moderator" context "admin moderator form" %} + {% translate "New moderator" context "admin moderator form" %} {% endif %} {% endblock %} @@ -31,7 +31,7 @@ {% block form-body %}
- {% trans "Basic settings" context "admin moderator form" %} + {% translate "Basic settings" context "admin moderator form" %} {% form_row form.is_global %} @@ -39,7 +39,7 @@
- {% trans "Categories" context "admin moderator form" %} + {% translate "Categories" context "admin moderator form" %} {% form_row form.categories %} @@ -47,12 +47,12 @@
- {% trans "Private threads" context "admin moderator form" %} + {% translate "Private threads" context "admin moderator form" %}
- {% blocktrans trimmed context "admin moderator form" %} + {% blocktranslate trimmed context "admin moderator form" %} Moderators can only access private threads they've been invited to or those that contain reported content. - {% endblocktrans %} + {% endblocktranslate %}
{% form_row form.private_threads %} @@ -67,7 +67,7 @@ {% include "misago/admin/generic/form_footer.html" %} {% else %} {% endif %} {% endblock %} diff --git a/misago/admin/templates/misago/admin/moderators/list.html b/misago/admin/templates/misago/admin/moderators/list.html index 8bb4836859..27f876b8d2 100644 --- a/misago/admin/templates/misago/admin/moderators/list.html +++ b/misago/admin/templates/misago/admin/moderators/list.html @@ -6,7 +6,7 @@
{% endblock %} @@ -14,7 +14,7 @@ {% block table-header %}
- + @@ -24,12 +24,12 @@ {% block table-row %} @@ -44,13 +44,13 @@ @@ -60,7 +60,7 @@ {% else %} - + {% endif %} @@ -73,7 +73,7 @@ {% else %} {% csrf_token %} - @@ -89,8 +89,8 @@
- -
@@ -106,7 +106,7 @@
@@ -120,7 +120,7 @@
+
+
+ {% translate "Attachments" context "admin threads settings form" %} + + {% form_row form.allowed_attachment_types %} + + {% with field=form.restrict_attachments_extensions select=form.restrict_attachments_extensions_type %} +
+ +
+
+ {% form_input select %} +
+ {% form_input field %} + {% for error in field.errors %} + {{ error }} + {% endfor %} + {% for error in select.errors %} + {{ error }} + {% endfor %} + {% if field.help_text %} + {{ field.help_text }} + {% endif %} +
+
+ {% endwith%} + + {% form_row form.allow_private_threads_attachments %} + {% form_row form.post_attachments_limit %} + {% form_row form.additional_embedded_attachments_limit %} + {% form_row form.unused_attachments_storage_limit %} + {% form_row form.unused_attachments_lifetime %} + {% form_dimensions_row form.attachment_image_max_width form.attachment_image_max_height %} + {% form_dimensions_row form.attachment_thumbnail_width form.attachment_thumbnail_height %} + +
+
{% translate "Threads lists" context "admin threads settings form" %} @@ -57,17 +93,4 @@
-
-
- {% translate "Attachment error images" context "admin threads settings form" %} - - {% with delete_field=form.attachment_403_image_delete setting=form_settings.attachment_403_image %} - {% form_image_row form.attachment_403_image delete_field=delete_field size=setting.image_size dimensions=setting.image_dimensions %} - {% endwith %} - {% with delete_field=form.attachment_404_image_delete setting=form_settings.attachment_404_image %} - {% form_image_row form.attachment_404_image delete_field=delete_field size=setting.image_size dimensions=setting.image_dimensions %} - {% endwith %} - -
-
{% endblock form-body %} \ No newline at end of file diff --git a/misago/templates/misago/admin/themes/assets/list.html b/misago/templates/misago/admin/themes/assets/list.html index 776e57bcc8..a10ca97f14 100644 --- a/misago/templates/misago/admin/themes/assets/list.html +++ b/misago/templates/misago/admin/themes/assets/list.html @@ -36,7 +36,7 @@ {% include "misago/admin/themes/assets/upload-css.html" %} {% include "misago/admin/themes/assets/upload-media.html" %} -{% endblock content%} +{% endblock content %} {% block javascripts %} {{ block.super }} diff --git a/misago/templates/misago/attachment_delete/index.html b/misago/templates/misago/attachment_delete/index.html new file mode 100644 index 0000000000..6232e648b7 --- /dev/null +++ b/misago/templates/misago/attachment_delete/index.html @@ -0,0 +1,40 @@ +{% extends "misago/base.html" %} +{% load i18n misago_plugins %} + + +{% block title %} + {{ attachment.name }} | {% translate "Delete attachment" context "attachment delete page" %} | {{ settings.forum_name }} +{% endblock title %} + + +{% block content %} +
+
+ {% pluginoutlet ATTACHMENT_DELETE_PAGE_START %} +
+ {% csrf_token %} +
+
+

+ {{ attachment.name }} +

+
+
+

+ {% translate "Are you sure you want to delete this attachment? This action cannot be undone." context "attachment delete confirmation" %} +

+
+
+ + + {% translate "Cancel" context "attachment delete page btn" %} + +
+
+ + {% pluginoutlet ATTACHMENT_DELETE_PAGE_END %} +
+
+{% endblock content %} diff --git a/misago/templates/misago/attachment_details/details.html b/misago/templates/misago/attachment_details/details.html new file mode 100644 index 0000000000..3dbfd0a082 --- /dev/null +++ b/misago/templates/misago/attachment_details/details.html @@ -0,0 +1,51 @@ +{% load i18n misago_formats %} +
+
+

+ {{ attachment.name }} +

+
+
+
+
+ {% translate "Type:" context "attachment details page" %} + {{ attachment.filetype.name }} +
+
+ {% translate "Size:" context "attachment details page" %} + {{ attachment.size|filesizeformat }} +
+
+ {% translate "Uploader:" context "attachment details page" %} + {% if attachment.uploader %} + + {{ attachment.uploader.username }} + + {% else %} + + {{ attachment.uploader_name }} + + {% endif %} +
+
+ {% translate "Uploaded:" context "attachment details page" %} + + {{ attachment.uploaded_at|date_relative }} + +
+
+ {% if can_see_post and attachment.post %} +
+
+ {% translate "Thread:" context "attachment details page" %} + + {{ attachment.thread.title }} + +
+
+ {% endif %} +
+
\ No newline at end of file diff --git a/misago/templates/misago/attachment_details/file.html b/misago/templates/misago/attachment_details/file.html new file mode 100644 index 0000000000..1765277825 --- /dev/null +++ b/misago/templates/misago/attachment_details/file.html @@ -0,0 +1,8 @@ +{% load i18n %} +
+ + file_download + {{ attachment.name }} + {% translate "(Click to download)" context "attachment details page" %} + +
\ No newline at end of file diff --git a/misago/templates/misago/attachment_details/image_large.html b/misago/templates/misago/attachment_details/image_large.html new file mode 100644 index 0000000000..3951ec2b86 --- /dev/null +++ b/misago/templates/misago/attachment_details/image_large.html @@ -0,0 +1,7 @@ +
+
+ + + +
+
\ No newline at end of file diff --git a/misago/templates/misago/attachment_details/image_small.html b/misago/templates/misago/attachment_details/image_small.html new file mode 100644 index 0000000000..396ba9e3b1 --- /dev/null +++ b/misago/templates/misago/attachment_details/image_small.html @@ -0,0 +1,5 @@ +
+ + + +
\ No newline at end of file diff --git a/misago/templates/misago/attachment_details/index.html b/misago/templates/misago/attachment_details/index.html new file mode 100644 index 0000000000..1d82cb3f3c --- /dev/null +++ b/misago/templates/misago/attachment_details/index.html @@ -0,0 +1,21 @@ +{% extends "misago/base.html" %} +{% load i18n misago_plugins %} + + +{% block title %} + {{ attachment.name }} | {% translate "Attachment" context "attachment page" %} | {{ settings.forum_name }} +{% endblock title %} + + +{% block content %} +
+ {% pluginoutlet ATTACHMENT_PAGE_START %} + {% include "misago/attachment_details/preview.html" %} + {% pluginoutlet ATTACHMENT_PAGE_AFTER_PREVIEW %} +
+ {% include "misago/attachment_details/details.html" %} + {% include "misago/attachment_details/toolbar.html" %} + {% pluginoutlet ATTACHMENT_PAGE_END %} +
+
+{% endblock content %} diff --git a/misago/templates/misago/attachment_details/preview.html b/misago/templates/misago/attachment_details/preview.html new file mode 100644 index 0000000000..ca5e429e84 --- /dev/null +++ b/misago/templates/misago/attachment_details/preview.html @@ -0,0 +1,11 @@ +{% if attachment.filetype.is_video %} + {% include "misago/attachment_details/video.html" %} +{% elif attachment.filetype.is_image %} + {% if attachment.dimensions and attachment.width < 300 and attachment.height < 300 %} + {% include "misago/attachment_details/image_small.html" %} + {% else %} + {% include "misago/attachment_details/image_large.html" %} + {% endif %} +{% else %} + {% include "misago/attachment_details/file.html" %} +{% endif %} \ No newline at end of file diff --git a/misago/templates/misago/attachment_details/toolbar.html b/misago/templates/misago/attachment_details/toolbar.html new file mode 100644 index 0000000000..a004dcc366 --- /dev/null +++ b/misago/templates/misago/attachment_details/toolbar.html @@ -0,0 +1,25 @@ +{% load i18n %} +{% if can_delete_attachment %} +
+
+
+ +
+
+ {% csrf_token %} + + +
+
+
+{% endif %} \ No newline at end of file diff --git a/misago/templates/misago/attachment_details/video.html b/misago/templates/misago/attachment_details/video.html new file mode 100644 index 0000000000..d88caf0286 --- /dev/null +++ b/misago/templates/misago/attachment_details/video.html @@ -0,0 +1,9 @@ +{% load i18n %} +
+
+ +
+
\ No newline at end of file diff --git a/misago/templates/misago/edit_private_thread/form.html b/misago/templates/misago/edit_private_thread/form.html index d96b19b450..91056b91e3 100644 --- a/misago/templates/misago/edit_private_thread/form.html +++ b/misago/templates/misago/edit_private_thread/form.html @@ -12,6 +12,7 @@ +

+ + +

+ + + + + + + + + + + + + diff --git a/misago/templates/misago/posting/attachments_form.html b/misago/templates/misago/posting/attachments_form.html new file mode 100644 index 0000000000..466902f8ea --- /dev/null +++ b/misago/templates/misago/posting/attachments_form.html @@ -0,0 +1,188 @@ +{% load i18n misago_capture %} +
+ {% if form.show_attachments_upload %} + {% with upload_field=form.upload %} +
+ +

+ {% capture trimmed as upload_button %} + + {% endcapture %} + {% blocktranslate trimmed with upload=upload_button|safe context "posting form" %} + To attach files to your message, {{ upload }}, paste them into the text field above, or drag them over the message editor. + {% endblocktranslate %} +

+

+ {% blocktranslate trimmed count limit=form.attachments_limit context "posting form" %} + You can attach {{ limit }} file to a post. + {% plural %} + You can attach up to {{ limit }} files to a post. + {% endblocktranslate %} + {% if form.attachment_size_limit %} + {% blocktranslate trimmed with limit=form.attachment_size_limit|filesizeformat context "posting form" %} + Uploaded file can't be larger than {{ limit }}. + {% endblocktranslate %} + {% endif %} + {% capture trimmed as account_attachments %} + {% translate "account settings" context "posting form" %} + {% endcapture %} + {% blocktranslate trimmed with settings=account_attachments|safe context "posting form" %} + Visit your {{ settings }} to view all your attachments and manage your available storage. + {% endblocktranslate %} +

+ {% for error in upload_field.errors %} +

{{ error }}

+ {% endfor %} +
+ {% endwith %} + {% endif %} + {% with attachments=form.attachments_media %} +
+

{% translate "Uploaded media" context "posting form" %}

+
    + {% for attachment in attachments %} +
  • + {% if attachment.upload %} + {% if attachment.filetype.is_video %} +
    +
    + +
    +
    + {% else %} +
    + {% endif %} + {% else %} +
    + broken_image +
    + {% endif %} +
    + {{ attachment.name }} +
    +
    + +
    + + +
    +
    • + {% endfor %} +
+
+ {% endwith %} + {% with attachments=form.attachments_other %} +
+

{% translate "Uploaded files" context "posting form" %}

+
    + {% for attachment in attachments %} +
  • + + + +
    • + {% endfor %} +
+
+ {% endwith %} + {% for attachment in form.attachments %} + + {% endfor %} + {% for attachment in form.deleted_attachments %} + + {% endfor %} +
\ No newline at end of file diff --git a/misago/templates/misago/posting/editor_toolbar.html b/misago/templates/misago/posting/editor_toolbar.html index 99c7ef8f13..c358fb4fc9 100644 --- a/misago/templates/misago/posting/editor_toolbar.html +++ b/misago/templates/misago/posting/editor_toolbar.html @@ -47,30 +47,42 @@ > insert_link -
+{% if form.show_attachments_upload %} +
+ +
    +
  • + +
    • +
  • + +
    • +
+
+{% else %} -
    -
  • - -
    • -
  • - -
    • -
-
+{% endif %} -{% pluginoutlet MARKUP_EDITOR_TOOLBAR_BEFORE_UPLOAD %} - {% pluginoutlet MARKUP_EDITOR_TOOLBAR_END %} \ No newline at end of file diff --git a/misago/templates/misago/posting/post_form.html b/misago/templates/misago/posting/post_form.html index cfaf678fc9..e37736d322 100644 --- a/misago/templates/misago/posting/post_form.html +++ b/misago/templates/misago/posting/post_form.html @@ -1,8 +1,13 @@ {% load i18n misago_forms %} {% with field=form.post %} -
-
+
+
{% include "misago/posting/editor_toolbar.html" %} @@ -34,13 +39,16 @@ id="{{ field.id_for_label }}" name="{{ field.html_name }}" class="markup-editor-textarea form-control form-control-post{% if post_control_large %} form-control-post-lg{% endif %}" - maxlength="{{ field.field.max_length }}" + maxlength="{{ field.field.max_length|default:'' }}" aria-label="{% translate 'Post message' context 'posting form' %}" {{ field|requiredhtml }} >{{ field.value|default:"" }} + {% if form.show_attachments %} + {% include "misago/posting/attachments_form.html" %} + {% endif %}
{% for error in field.errors %} -

{{ error }}

+

{{ error }}

{% endfor %}
{% endwith %} \ No newline at end of file diff --git a/misago/templates/misago/posting/preview.html b/misago/templates/misago/posting/preview.html index 8e5a896ce9..69ee8c8821 100644 --- a/misago/templates/misago/posting/preview.html +++ b/misago/templates/misago/posting/preview.html @@ -1,4 +1,4 @@ -{% load i18n %} +{% load i18n misago_rich_text %}
@@ -7,8 +7,8 @@

-
- {{ preview|safe }} +
+ {% rich_text preview preview_rich_text_data %}
\ No newline at end of file diff --git a/misago/templates/misago/posts_feed/post.html b/misago/templates/misago/posts_feed/post.html index fda53d10c6..e988f3a334 100644 --- a/misago/templates/misago/posts_feed/post.html +++ b/misago/templates/misago/posts_feed/post.html @@ -1,4 +1,4 @@ -{% load i18n misago_avatars misago_formats %} +{% load i18n misago_avatars misago_formats misago_rich_text %}
-
- {{ post.parsed|safe }} +
+ {% rich_text post.parsed rich_text_data %}
+ {% if attachments %} + {% include "misago/posts_feed/post_attachments.html" %} + {% endif %}
diff --git a/misago/templates/misago/posts_feed/post_attachments.html b/misago/templates/misago/posts_feed/post_attachments.html new file mode 100644 index 0000000000..fb94529304 --- /dev/null +++ b/misago/templates/misago/posts_feed/post_attachments.html @@ -0,0 +1,39 @@ +{% load i18n %} +
+

+ {% translate "Attachments" context "posts feed attachments title" %} +

+ +
\ No newline at end of file diff --git a/misago/templates/misago/private_thread/index.html b/misago/templates/misago/private_thread/index.html index 56d79aef78..3131ceef6c 100644 --- a/misago/templates/misago/private_thread/index.html +++ b/misago/templates/misago/private_thread/index.html @@ -27,5 +27,6 @@ {% block modals %} {% if user.is_authenticated %} {% include "misago/posting/markup_editor_modals.html" %} + {% include "misago/posting/attachment_templates.html" %} {% endif %} {% endblock modals %} diff --git a/misago/templates/misago/quick_reply/form.html b/misago/templates/misago/quick_reply/form.html index e380d76191..8cbe4f9e99 100644 --- a/misago/templates/misago/quick_reply/form.html +++ b/misago/templates/misago/quick_reply/form.html @@ -3,6 +3,7 @@ {% endblock content %} + + +{% block modals %} +{% include "misago/posting/markup_editor_modals.html" %} +{% include "misago/posting/attachment_templates.html" %} +{% endblock modals %} \ No newline at end of file diff --git a/misago/templates/misago/reply_thread/form.html b/misago/templates/misago/reply_thread/form.html index 518b7da68f..b26af91db9 100644 --- a/misago/templates/misago/reply_thread/form.html +++ b/misago/templates/misago/reply_thread/form.html @@ -12,6 +12,7 @@ {% endblock content %} + + +{% block modals %} +{% include "misago/posting/markup_editor_modals.html" %} +{% include "misago/posting/attachment_templates.html" %} +{% endblock modals %} \ No newline at end of file diff --git a/misago/templates/misago/rich_text/attachment_broken.html b/misago/templates/misago/rich_text/attachment_broken.html new file mode 100644 index 0000000000..4ef7a5f82d --- /dev/null +++ b/misago/templates/misago/rich_text/attachment_broken.html @@ -0,0 +1,10 @@ +{% load i18n %} +
+
+ broken_image + {{ attachment.name }} +
+
\ No newline at end of file diff --git a/misago/templates/misago/rich_text/attachment_file.html b/misago/templates/misago/rich_text/attachment_file.html new file mode 100644 index 0000000000..0483712769 --- /dev/null +++ b/misago/templates/misago/rich_text/attachment_file.html @@ -0,0 +1,18 @@ +{% load i18n %} +
+
+ + file_download + {{ attachment.name }} + {{ attachment.size|filesizeformat }} + + + info + +
+
\ No newline at end of file diff --git a/misago/templates/misago/rich_text/attachment_image.html b/misago/templates/misago/rich_text/attachment_image.html new file mode 100644 index 0000000000..e2f150b642 --- /dev/null +++ b/misago/templates/misago/rich_text/attachment_image.html @@ -0,0 +1,18 @@ +{% load i18n %} +
+ + {% if attachment.thumbnail %} + {{ attachment.name }} + {% else %} + {{ attachment.name }} + {% endif %} + + + info + +
\ No newline at end of file diff --git a/misago/templates/misago/rich_text/attachment_link.html b/misago/templates/misago/rich_text/attachment_link.html new file mode 100644 index 0000000000..fea9d22a1e --- /dev/null +++ b/misago/templates/misago/rich_text/attachment_link.html @@ -0,0 +1,17 @@ +{% load i18n %} +
+
+ + open_in_new + {{ name }} + + + info + +
+
\ No newline at end of file diff --git a/misago/templates/misago/rich_text/attachment_permission_denied.html b/misago/templates/misago/rich_text/attachment_permission_denied.html new file mode 100644 index 0000000000..e6c780f409 --- /dev/null +++ b/misago/templates/misago/rich_text/attachment_permission_denied.html @@ -0,0 +1,7 @@ +{% load i18n %} +
+ + lock_outline + {{ name }} + +
\ No newline at end of file diff --git a/misago/templates/misago/rich_text/attachment_video.html b/misago/templates/misago/rich_text/attachment_video.html new file mode 100644 index 0000000000..1a669b46b6 --- /dev/null +++ b/misago/templates/misago/rich_text/attachment_video.html @@ -0,0 +1,15 @@ +{% load i18n %} +
+ + + info + +
\ No newline at end of file diff --git a/misago/templates/misago/start_private_thread/index.html b/misago/templates/misago/start_private_thread/index.html index b1c89ff5d4..a44877d8f9 100644 --- a/misago/templates/misago/start_private_thread/index.html +++ b/misago/templates/misago/start_private_thread/index.html @@ -18,6 +18,7 @@ {% csrf_token %}
@@ -49,4 +50,5 @@

{% block modals %} {% include "misago/posting/markup_editor_modals.html" %} +{% include "misago/posting/attachment_templates.html" %} {% endblock modals %} diff --git a/misago/templates/misago/start_thread/index.html b/misago/templates/misago/start_thread/index.html index 69366b4234..e8b9459f52 100644 --- a/misago/templates/misago/start_thread/index.html +++ b/misago/templates/misago/start_thread/index.html @@ -18,6 +18,7 @@ {% csrf_token %}
@@ -49,4 +50,5 @@

{% block modals %} {% include "misago/posting/markup_editor_modals.html" %} +{% include "misago/posting/attachment_templates.html" %} {% endblock modals %} diff --git a/misago/templates/misago/thread/index.html b/misago/templates/misago/thread/index.html index 0d728829c6..f09dc38a0d 100644 --- a/misago/templates/misago/thread/index.html +++ b/misago/templates/misago/thread/index.html @@ -32,5 +32,6 @@ {% block modals %} {% if user.is_authenticated %} {% include "misago/posting/markup_editor_modals.html" %} + {% include "misago/posting/attachment_templates.html" %} {% endif %} {% endblock modals %} diff --git a/misago/templates/misago/thread_flags.html b/misago/templates/misago/thread_flags.html index 075a39b9ee..c3581623f3 100644 --- a/misago/templates/misago/thread_flags.html +++ b/misago/templates/misago/thread_flags.html @@ -24,7 +24,7 @@ bookmark_outline {% endif %} - {% if thread.best_answer %} + {% if thread.best_answer_id %}
  • bool: f"Expected message was not set during the request: {message}\n" f"Found messages:\n\n{messages}" ) - - -class MisagoClient(Client): - def post(self, *args, **kwargs): - if "json" in kwargs: - return super().post( - *args, - data=kwargs.pop("json"), - content_type="application/json", - **kwargs, - ) - - return super().post(*args, **kwargs) - - def put(self, *args, **kwargs): - if "json" in kwargs: - return super().put( - *args, - data=kwargs.pop("json"), - content_type="application/json", - **kwargs, - ) - - return super().put(*args, **kwargs) diff --git a/misago/test/attachments.py b/misago/test/attachments.py new file mode 100644 index 0000000000..c919550447 --- /dev/null +++ b/misago/test/attachments.py @@ -0,0 +1,16 @@ +import pytest + +from ..attachments.models import Attachment + + +@pytest.fixture() +def teardown_attachments(db): + existing_attachments: list[int] = list( + Attachment.objects.values_list("id", flat=True) + ) + + try: + yield + finally: + for attachment in Attachment.objects.exclude(id__in=existing_attachments): + attachment.delete() diff --git a/misago/test/categories.py b/misago/test/categories.py new file mode 100644 index 0000000000..cba236155e --- /dev/null +++ b/misago/test/categories.py @@ -0,0 +1,346 @@ +import pytest + +from ..acl.models import Role +from ..attachments.models import Attachment +from ..categories.models import Category, CategoryRole, RoleCategoryACL +from ..notifications.models import Notification, WatchedThread +from ..permissions.models import CategoryGroupPermission +from ..readtracker.models import ReadCategory, ReadThread +from ..threads.models import ( + Attachment as LegacyAttachment, + AttachmentType, + Poll, + PollVote, + Post, + PostEdit, + PostLike, + Subscription, + Thread, +) +from ..threads.test import post_poll, post_thread, reply_thread +from ..users.models import User, Group + +__all__ = ["CategoryRelationsFactory"] + + +class CategoryRelationsFactory: + category: Category + + user: User + other_user: User + group: Group + + attachment: Attachment + category_group_permission: CategoryGroupPermission + legacy_attachment: LegacyAttachment + notification: Notification + poll: Poll + poll_vote: PollVote + post_edit: PostEdit + post_like: PostLike + read_category: ReadCategory + read_thread: ReadThread + role_category_acl: RoleCategoryACL + thread: Thread + thread_first_post: Post + thread_reply: Post + thread_subscription: Subscription + watched_thread: WatchedThread + + def __init__( + self, + *, + category: Category, + user: User, + other_user: User, + group: Group, + ): + self.category = category + + self.user = user + self.other_user = other_user + self.group = group + + self.create_relations() + + def create_relations(self): + self.thread = self.create_thread() + self.thread_first_post = self.thread.first_post + self.thread_reply = self.create_thread_reply() + + self.attachment = self.create_attachment() + self.category_group_permission = self.create_category_group_permission() + self.legacy_attachment = self.create_legacy_attachment() + self.notification = self.create_notification() + self.poll = self.create_poll() + self.poll_vote = self.create_poll_vote() + self.post_edit = self.create_post_edit() + self.post_like = self.create_post_like() + self.read_category = self.create_read_category() + self.read_thread = self.create_read_thread() + self.role_category_acl = self.create_role_category_acl() + self.subscription = self.create_subscription() + self.watched_thread = self.create_watched_thread() + + self.category.set_last_thread(self.thread) + self.category.save() + + def create_attachment(self): + return Attachment.objects.create( + category=self.category, + thread=self.thread, + post=self.thread_reply, + uploader_name="Anonymous", + uploader_slug="anonymous", + name="filename.txt", + slug="filename-txt", + ) + + def create_category_group_permission(self) -> CategoryGroupPermission: + return CategoryGroupPermission.objects.create( + category=self.category, + group=self.group, + permission="TEST", + ) + + def create_legacy_attachment(self) -> LegacyAttachment: + return LegacyAttachment.objects.create( + secret="secret", + filetype=AttachmentType.objects.order_by("id").first(), + post=self.thread_reply, + uploader=self.user, + uploader_name=self.user.username, + uploader_slug=self.user.slug, + filename="filename.txt", + ) + + def create_notification(self) -> Notification: + return Notification.objects.create( + user=self.user, + verb="TEST", + actor=self.other_user, + actor_name=self.other_user.username, + category=self.category, + thread=self.thread, + thread_title=self.thread.title, + post=self.thread_reply, + ) + + def create_poll(self) -> Poll: + return post_poll(self.thread, self.user) + + def create_poll_vote(self) -> PollVote: + return self.poll.pollvote_set.order_by("id").first() + + def create_post_edit(self) -> PostEdit: + return PostEdit.objects.create( + category=self.category, + thread=self.thread, + post=self.thread_reply, + editor=self.user, + editor_name=self.user.username, + editor_slug=self.user.slug, + edited_from="", + edited_to="", + ) + + def create_post_like(self) -> PostLike: + return PostLike.objects.create( + category=self.category, + thread=self.thread, + post=self.thread_first_post, + liker=self.other_user, + liker_name=self.other_user.username, + liker_slug=self.other_user.slug, + ) + + def create_read_category(self) -> ReadCategory: + return ReadCategory.objects.create( + user=self.user, + category=self.category, + ) + + def create_read_thread(self) -> ReadThread: + return ReadThread.objects.create( + user=self.user, + category=self.category, + thread=self.thread, + ) + + def create_role_category_acl(self) -> RoleCategoryACL: + return RoleCategoryACL.objects.create( + role=Role.objects.order_by("id").first(), + category=self.category, + category_role=CategoryRole.objects.order_by("id").first(), + ) + + def create_subscription(self) -> Subscription: + return Subscription.objects.create( + user=self.user, + thread=self.thread, + category=self.category, + ) + + def create_thread(self) -> Thread: + return post_thread(self.category, poster=self.user) + + def create_thread_reply(self) -> Post: + return reply_thread(self.thread, poster=self.other_user) + + def create_watched_thread(self) -> WatchedThread: + return WatchedThread.objects.create( + user=self.user, + category=self.category, + thread=self.thread, + ) + + def assert_relations_are_deleted(self): + self.attachment.refresh_from_db() + assert self.attachment.is_deleted, "Attachment should be marked for deletion" + assert ( + not self.attachment.category + ), "Attachment category relation should be removed" + assert ( + not self.attachment.thread + ), "Attachment thread relation should be removed" + assert not self.attachment.post, "Attachment post relation should be removed" + + with pytest.raises(CategoryGroupPermission.DoesNotExist): + """CategoryGroupPermission should be deleted when category is deleted""" + self.category_group_permission.refresh_from_db() + + self.legacy_attachment.refresh_from_db() + assert ( + self.legacy_attachment.post is None + ), "LegacyAttachment should marked for deletion" + + with pytest.raises(Notification.DoesNotExist): + """Notification should be deleted when category is deleted""" + self.notification.refresh_from_db() + + with pytest.raises(Poll.DoesNotExist): + """Poll should be deleted when category is deleted""" + self.poll.refresh_from_db() + + with pytest.raises(PollVote.DoesNotExist): + """PollVote should be deleted when category is deleted""" + self.poll_vote.refresh_from_db() + + with pytest.raises(PostEdit.DoesNotExist): + """PostEdit should be deleted when category is deleted""" + self.post_edit.refresh_from_db() + + with pytest.raises(PostLike.DoesNotExist): + """Notification PostLike be deleted when category is deleted""" + self.post_like.refresh_from_db() + + with pytest.raises(ReadCategory.DoesNotExist): + """ReadCategory should be deleted when category is deleted""" + self.read_category.refresh_from_db() + + with pytest.raises(ReadThread.DoesNotExist): + """ReadThread should be deleted when category is deleted""" + self.read_thread.refresh_from_db() + + with pytest.raises(RoleCategoryACL.DoesNotExist): + """RoleCategoryACL should be deleted when category is deleted""" + self.role_category_acl.refresh_from_db() + + with pytest.raises(Subscription.DoesNotExist): + """Subscription should be deleted when category is deleted""" + self.subscription.refresh_from_db() + + with pytest.raises(Thread.DoesNotExist): + """Thread should be deleted when category is deleted""" + self.thread.refresh_from_db() + + with pytest.raises(Post.DoesNotExist): + """Thread's first post should be deleted when category is deleted""" + self.thread_first_post.refresh_from_db() + + with pytest.raises(Post.DoesNotExist): + """Thread reply should be deleted when category is deleted""" + self.thread_reply.refresh_from_db() + + with pytest.raises(WatchedThread.DoesNotExist): + """WatchedThread should be deleted when category is deleted""" + self.watched_thread.refresh_from_db() + + def assert_relations_are_moved(self, new_category: Category): + self.attachment.refresh_from_db() + assert not self.attachment.is_deleted, "Attachment was NOT marked for deletion" + assert ( + self.attachment.category_id == new_category.id + ), "Attachment category relation was not updated" + + with pytest.raises(CategoryGroupPermission.DoesNotExist): + """CategoryGroupPermission should be deleted when category is deleted""" + self.category_group_permission.refresh_from_db() + + self.legacy_attachment.refresh_from_db() + assert ( + self.legacy_attachment.post_id == self.thread_reply.id + ), "LegacyAttachment post was updated" + + self.notification.refresh_from_db() + assert ( + self.notification.category_id == new_category.id + ), "Notification category relation was not updated" + + self.poll.refresh_from_db() + assert ( + self.poll.category_id == new_category.id + ), "Poll category relation was not updated" + + self.poll_vote.refresh_from_db() + assert ( + self.poll_vote.category_id == new_category.id + ), "PollVote category relation was not updated" + + self.post_edit.refresh_from_db() + assert ( + self.post_edit.category_id == new_category.id + ), "PostEdit category relation was not updated" + + self.post_like.refresh_from_db() + assert ( + self.post_like.category_id == new_category.id + ), "PostLike category relation was not updated" + + with pytest.raises(ReadCategory.DoesNotExist): + """ReadCategory should be deleted when category is deleted""" + self.read_category.refresh_from_db() + + self.read_thread.refresh_from_db() + assert ( + self.read_thread.category_id == new_category.id + ), "ReadThread category relation was not updated" + + with pytest.raises(RoleCategoryACL.DoesNotExist): + """RoleCategoryACL should be deleted when category is deleted""" + self.role_category_acl.refresh_from_db() + + self.subscription.refresh_from_db() + assert ( + self.subscription.category_id == new_category.id + ), "Subscription category relation was not updated" + + self.thread.refresh_from_db() + assert ( + self.thread.category_id == new_category.id + ), "Thread category relation was not updated" + + self.thread_first_post.refresh_from_db() + assert ( + self.thread_first_post.category_id == new_category.id + ), "Thread's first post's category relation was not updated" + + self.thread_reply.refresh_from_db() + assert ( + self.thread_reply.category_id == new_category.id + ), "Thread reply's category relation was not updated" + + self.watched_thread.refresh_from_db() + assert ( + self.watched_thread.category_id == new_category.id + ), "WatchedThread category relation was not updated" diff --git a/misago/test/client.py b/misago/test/client.py new file mode 100644 index 0000000000..d99f7dd123 --- /dev/null +++ b/misago/test/client.py @@ -0,0 +1,25 @@ +from django.test import Client + + +class MisagoClient(Client): + def post(self, *args, **kwargs): + if "json" in kwargs: + return super().post( + *args, + data=kwargs.pop("json"), + content_type="application/json", + **kwargs, + ) + + return super().post(*args, **kwargs) + + def put(self, *args, **kwargs): + if "json" in kwargs: + return super().put( + *args, + data=kwargs.pop("json"), + content_type="application/json", + **kwargs, + ) + + return super().put(*args, **kwargs) diff --git a/misago/test/files.py b/misago/test/files.py new file mode 100644 index 0000000000..f47d92f4a8 --- /dev/null +++ b/misago/test/files.py @@ -0,0 +1,8 @@ +import os + +FILES_DIR = os.path.join(os.path.dirname(__file__), "files") + +IMAGE_INVALID = os.path.join(FILES_DIR, "image_invalid.png") +IMAGE_LARGE = os.path.join(FILES_DIR, "image_large.png") +IMAGE_SMALL = os.path.join(FILES_DIR, "image_small.png") +TEXT_FILE = os.path.join(FILES_DIR, "textfile.txt") diff --git a/misago/test/files/image_invalid.png b/misago/test/files/image_invalid.png new file mode 100644 index 0000000000..1c26dc8d62 --- /dev/null +++ b/misago/test/files/image_invalid.png @@ -0,0 +1 @@ +Lorem ipsum dolor met sit amet elit. \ No newline at end of file diff --git a/misago/test/files/image_large.png b/misago/test/files/image_large.png new file mode 100644 index 0000000000..4b9257e23f Binary files /dev/null and b/misago/test/files/image_large.png differ diff --git a/misago/test/files/image_small.png b/misago/test/files/image_small.png new file mode 100644 index 0000000000..774cfa04a4 Binary files /dev/null and b/misago/test/files/image_small.png differ diff --git a/misago/test/files/textfile.txt b/misago/test/files/textfile.txt new file mode 100644 index 0000000000..1c26dc8d62 --- /dev/null +++ b/misago/test/files/textfile.txt @@ -0,0 +1 @@ +Lorem ipsum dolor met sit amet elit. \ No newline at end of file diff --git a/misago/test/parser.py b/misago/test/parser.py new file mode 100644 index 0000000000..813570317e --- /dev/null +++ b/misago/test/parser.py @@ -0,0 +1,5 @@ +from django.test import override_settings + + +def disable_parser_clean_ast(f): + return override_settings(MISAGO_PARSER_CLEAN_AST=False)(f) diff --git a/misago/threads/admin/__init__.py b/misago/threads/admin/__init__.py deleted file mode 100644 index 3291b782e3..0000000000 --- a/misago/threads/admin/__init__.py +++ /dev/null @@ -1,50 +0,0 @@ -from django.urls import path -from django.utils.translation import pgettext_lazy - -from .views.attachments import AttachmentsList, DeleteAttachment -from .views.attachmenttypes import ( - AttachmentTypesList, - DeleteAttachmentType, - EditAttachmentType, - NewAttachmentType, -) - - -class MisagoAdminExtension: - def register_urlpatterns(self, urlpatterns): - # Attachment - urlpatterns.namespace("attachments/", "attachments") - urlpatterns.patterns( - "attachments", - path("", AttachmentsList.as_view(), name="index"), - path("/", AttachmentsList.as_view(), name="index"), - path("delete//", DeleteAttachment.as_view(), name="delete"), - ) - - # AttachmentType - urlpatterns.namespace("attachment-types/", "attachment-types", "settings") - urlpatterns.patterns( - "settings:attachment-types", - path("", AttachmentTypesList.as_view(), name="index"), - path("new/", NewAttachmentType.as_view(), name="new"), - path("edit//", EditAttachmentType.as_view(), name="edit"), - path("delete//", DeleteAttachmentType.as_view(), name="delete"), - ) - - def register_navigation_nodes(self, site): - site.add_node( - name=pgettext_lazy("admin node", "Attachments"), - icon="fas fa-paperclip", - after="permissions:index", - namespace="attachments", - ) - - site.add_node( - name=pgettext_lazy("admin node", "Attachment types"), - description=pgettext_lazy( - "admin node", - "Specify what files may be uploaded as part of user posts.", - ), - parent="settings", - namespace="attachment-types", - ) diff --git a/misago/threads/admin/forms.py b/misago/threads/admin/forms.py deleted file mode 100644 index 636b54045c..0000000000 --- a/misago/threads/admin/forms.py +++ /dev/null @@ -1,148 +0,0 @@ -from django import forms -from django.utils.translation import pgettext, pgettext_lazy - -from ..models import AttachmentType - - -def get_searchable_filetypes(): - choices = [(0, pgettext_lazy("admin attachments type filter choice", "All types"))] - choices += [(a.id, a.name) for a in AttachmentType.objects.order_by("name")] - return choices - - -class FilterAttachmentsForm(forms.Form): - uploader = forms.CharField( - label=pgettext_lazy("admin attachments filter form", "Uploader name contains"), - required=False, - ) - filename = forms.CharField( - label=pgettext_lazy("admin attachments filter form", "Filename contains"), - required=False, - ) - filetype = forms.TypedChoiceField( - label=pgettext_lazy("admin attachments filter form", "File type"), - coerce=int, - choices=get_searchable_filetypes, - empty_value=0, - required=False, - ) - is_orphan = forms.ChoiceField( - label=pgettext_lazy("admin attachments filter form", "State"), - required=False, - choices=[ - ( - "", - pgettext_lazy( - "admin attachments orphan filter choice", - "All", - ), - ), - ( - "yes", - pgettext_lazy( - "admin attachments orphan filter choice", - "Only orphaned", - ), - ), - ( - "no", - pgettext_lazy( - "admin attachments orphan filter choice", - "Not orphaned", - ), - ), - ], - ) - - def filter_queryset(self, criteria, queryset): - if criteria.get("uploader"): - queryset = queryset.filter( - uploader_slug__contains=criteria["uploader"].lower() - ) - if criteria.get("filename"): - queryset = queryset.filter(filename__icontains=criteria["filename"]) - if criteria.get("filetype"): - queryset = queryset.filter(filetype_id=criteria["filetype"]) - if criteria.get("is_orphan") == "yes": - queryset = queryset.filter(post__isnull=True) - elif criteria.get("is_orphan") == "no": - queryset = queryset.filter(post__isnull=False) - return queryset - - -class AttachmentTypeForm(forms.ModelForm): - class Meta: - model = AttachmentType - fields = [ - "name", - "extensions", - "mimetypes", - "size_limit", - "status", - "limit_uploads_to", - "limit_downloads_to", - ] - labels = { - "name": pgettext_lazy("admin attachment type form", "Type name"), - "extensions": pgettext_lazy( - "admin attachment type form", "File extensions" - ), - "mimetypes": pgettext_lazy("admin attachment type form", "Mimetypes"), - "size_limit": pgettext_lazy( - "admin attachment type form", "Maximum allowed uploaded file size" - ), - "status": pgettext_lazy("admin attachment type form", "Status"), - "limit_uploads_to": pgettext_lazy( - "admin attachment type form", "Limit uploads to" - ), - "limit_downloads_to": pgettext_lazy( - "admin attachment type form", "Limit downloads to" - ), - } - help_texts = { - "extensions": pgettext_lazy( - "admin attachment type form", - "List of comma separated file extensions associated with this attachment type.", - ), - "mimetypes": pgettext_lazy( - "admin attachment type form", - "Optional list of comma separated mime types associated with this attachment type.", - ), - "size_limit": pgettext_lazy( - "admin attachment type form", - "Maximum allowed uploaded file size for this type, in kb. This setting is deprecated and has no effect. It will be deleted in Misago 1.0.", - ), - "status": pgettext_lazy( - "admin attachment type form", - "Controls this attachment type availability on your site.", - ), - "limit_uploads_to": pgettext_lazy( - "admin attachment type form", - "If you wish to limit option to upload files of this type to users with specific roles, select them on this list. Otherwise don't select any roles to allow all users with permission to upload attachments to be able to upload attachments of this type.", - ), - "limit_downloads_to": pgettext_lazy( - "admin attachment type form", - "If you wish to limit option to download files of this type to users with specific roles, select them on this list. Otherwise don't select any roles to allow all users with permission to download attachments to be able to download attachments of this type.", - ), - } - widgets = { - "limit_uploads_to": forms.CheckboxSelectMultiple, - "limit_downloads_to": forms.CheckboxSelectMultiple, - } - - def clean_extensions(self): - data = self.clean_list(self.cleaned_data["extensions"]) - if not data: - raise forms.ValidationError( - pgettext("admin attachment type form", "This field is required.") - ) - return data - - def clean_mimetypes(self): - data = self.cleaned_data["mimetypes"] - if data: - return self.clean_list(data) - - def clean_list(self, value): - items = [v.lstrip(".") for v in value.lower().replace(" ", "").split(",")] - return ",".join(set(filter(bool, items))) diff --git a/misago/threads/admin/tests/test_attachment_types_views.py b/misago/threads/admin/tests/test_attachment_types_views.py deleted file mode 100644 index fcf8038928..0000000000 --- a/misago/threads/admin/tests/test_attachment_types_views.py +++ /dev/null @@ -1,220 +0,0 @@ -from django.urls import reverse - -from ....acl.models import Role -from ....admin.test import AdminTestCase -from ...models import AttachmentType - - -class AttachmentTypeAdminViewsTests(AdminTestCase): - def setUp(self): - super().setUp() - self.admin_link = reverse("misago:admin:settings:attachment-types:index") - - def test_link_registered(self): - """admin nav contains attachment types link""" - response = self.client.get(reverse("misago:admin:settings:index")) - self.assertContains(response, self.admin_link) - - def test_list_view(self): - """attachment types list returns 200 and renders all attachment types""" - response = self.client.get(self.admin_link) - self.assertEqual(response.status_code, 200) - - for attachment_type in AttachmentType.objects.all(): - self.assertContains(response, attachment_type.name) - for file_extension in attachment_type.extensions_list: - self.assertContains(response, file_extension) - for mimename in attachment_type.mimetypes_list: - self.assertContains(response, mimename) - - def test_new_view(self): - """new attachment type view has no showstoppers""" - form_link = reverse("misago:admin:settings:attachment-types:new") - - response = self.client.get(form_link) - self.assertEqual(response.status_code, 200) - - response = self.client.post(form_link, data={}) - self.assertEqual(response.status_code, 200) - - response = self.client.post( - form_link, - data={ - "name": "Test type", - "extensions": ".test", - "size_limit": 0, - "status": AttachmentType.ENABLED, - }, - ) - self.assertEqual(response.status_code, 302) - - # clean alert about new item created - self.client.get(self.admin_link) - - response = self.client.get(self.admin_link) - self.assertEqual(response.status_code, 200) - self.assertContains(response, "Test type") - self.assertContains(response, "test") - - def test_edit_view(self): - """edit attachment type view has no showstoppers""" - self.client.post( - reverse("misago:admin:settings:attachment-types:new"), - data={ - "name": "Test type", - "extensions": ".test", - "size_limit": 0, - "status": AttachmentType.ENABLED, - }, - ) - - test_type = AttachmentType.objects.order_by("id").last() - self.assertEqual(test_type.name, "Test type") - - form_link = reverse( - "misago:admin:settings:attachment-types:edit", kwargs={"pk": test_type.pk} - ) - - response = self.client.get(form_link) - self.assertEqual(response.status_code, 200) - - response = self.client.post(form_link, data={}) - self.assertEqual(response.status_code, 200) - - response = self.client.post( - form_link, - data={ - "name": "Test type edited", - "extensions": ".test.extension", - "mimetypes": "test/edited-mime", - "size_limit": 512, - "status": AttachmentType.DISABLED, - "limit_uploads_to": [r.pk for r in Role.objects.all()], - "limit_downloads_to": [r.pk for r in Role.objects.all()], - }, - ) - self.assertEqual(response.status_code, 302) - - test_type = AttachmentType.objects.order_by("id").last() - self.assertEqual(test_type.name, "Test type edited") - - # clean alert about new item created - self.client.get(self.admin_link) - - response = self.client.get(self.admin_link) - self.assertEqual(response.status_code, 200) - self.assertContains(response, test_type.name) - self.assertContains(response, test_type.extensions) - self.assertContains(response, test_type.mimetypes) - - self.assertEqual(test_type.limit_uploads_to.count(), Role.objects.count()) - self.assertEqual(test_type.limit_downloads_to.count(), Role.objects.count()) - - # remove limits from type - response = self.client.post( - form_link, - data={ - "name": "Test type edited", - "extensions": ".test.extension", - "mimetypes": "test/edited-mime", - "size_limit": 512, - "status": AttachmentType.DISABLED, - "limit_uploads_to": [], - "limit_downloads_to": [], - }, - ) - self.assertEqual(response.status_code, 302) - - self.assertEqual(test_type.limit_uploads_to.count(), 0) - self.assertEqual(test_type.limit_downloads_to.count(), 0) - - def test_clean_params_view(self): - """admin form nicely cleans lists of extensions/mimetypes""" - TEST_CASES = [ - ("test", ["test"]), - (".test", ["test"]), - (".tar.gz", ["tar.gz"]), - (". test", ["test"]), - ("test, test", ["test"]), - ("test, tEst", ["test"]), - ("test, other, tEst", ["test", "other"]), - ("test, other, tEst,OTher", ["test", "other"]), - ] - - for raw, final in TEST_CASES: - response = self.client.post( - reverse("misago:admin:settings:attachment-types:new"), - data={ - "name": "Test type", - "extensions": raw, - "size_limit": 0, - "status": AttachmentType.ENABLED, - }, - ) - self.assertEqual(response.status_code, 302) - - test_type = AttachmentType.objects.order_by("id").last() - self.assertEqual(set(test_type.extensions_list), set(final)) - - def test_delete_view(self): - """delete attachment type view has no showstoppers""" - self.client.post( - reverse("misago:admin:settings:attachment-types:new"), - data={ - "name": "Test type", - "extensions": ".test", - "size_limit": 0, - "status": AttachmentType.ENABLED, - }, - ) - - test_type = AttachmentType.objects.order_by("id").last() - self.assertEqual(test_type.name, "Test type") - - action_link = reverse( - "misago:admin:settings:attachment-types:delete", kwargs={"pk": test_type.pk} - ) - - response = self.client.post(action_link) - self.assertEqual(response.status_code, 302) - - # clean alert about item deleted - self.client.get(self.admin_link) - - response = self.client.get(self.admin_link) - self.assertEqual(response.status_code, 200) - self.assertNotContains(response, test_type.name) - - def test_cant_delete_type_with_attachments_view(self): - """delete attachment type is not allowed if it has attachments associated""" - self.client.post( - reverse("misago:admin:settings:attachment-types:new"), - data={ - "name": "Test type", - "extensions": ".test", - "size_limit": 0, - "status": AttachmentType.ENABLED, - }, - ) - - test_type = AttachmentType.objects.order_by("id").last() - self.assertEqual(test_type.name, "Test type") - - test_type.attachment_set.create( - secret="loremipsum", - filetype=test_type, - uploader_name="User", - uploader_slug="user", - filename="test.zip", - file="sad76asd678as687sa.zip", - ) - - action_link = reverse( - "misago:admin:settings:attachment-types:delete", kwargs={"pk": test_type.pk} - ) - - response = self.client.post(action_link) - self.assertEqual(response.status_code, 302) - - # get alert form database - AttachmentType.objects.get(pk=test_type.pk) diff --git a/misago/threads/admin/tests/test_attachments_views.py b/misago/threads/admin/tests/test_attachments_views.py deleted file mode 100644 index c7403a1ce5..0000000000 --- a/misago/threads/admin/tests/test_attachments_views.py +++ /dev/null @@ -1,128 +0,0 @@ -from django.urls import reverse - -from ... import test -from ....admin.test import AdminTestCase -from ....categories.models import Category -from ...models import Attachment, AttachmentType - - -class AttachmentAdminViewsTests(AdminTestCase): - def setUp(self): - super().setUp() - - self.category = Category.objects.get(slug="first-category") - self.post = test.post_thread(category=self.category).first_post - - self.filetype = AttachmentType.objects.order_by("id").first() - - self.admin_link = reverse("misago:admin:attachments:index") - - def mock_attachment(self, post=None, file=None, image=None, thumbnail=None): - return Attachment.objects.create( - secret=Attachment.generate_new_secret(), - filetype=self.filetype, - post=post, - size=1000, - uploader=self.user, - uploader_name=self.user.username, - uploader_slug=self.user.slug, - filename="testfile_%s.zip" % (Attachment.objects.count() + 1), - file=None, - image=None, - thumbnail=None, - ) - - def test_link_registered(self): - """admin nav contains attachments link""" - response = self.client.get(reverse("misago:admin:settings:index")) - self.assertContains(response, self.admin_link) - - def test_list_view(self): - """attachments list returns 200 and renders all attachments""" - final_link = self.client.get(self.admin_link)["location"] - - response = self.client.get(final_link) - self.assertEqual(response.status_code, 200) - - attachments = [ - self.mock_attachment(self.post, file="somefile.pdf"), - self.mock_attachment(image="someimage.jpg"), - self.mock_attachment( - self.post, image="somelargeimage.png", thumbnail="somethumb.png" - ), - ] - - response = self.client.get(final_link) - self.assertEqual(response.status_code, 200) - - for attachment in attachments: - delete_link = reverse( - "misago:admin:attachments:delete", kwargs={"pk": attachment.pk} - ) - self.assertContains(response, attachment.filename) - self.assertContains(response, delete_link) - self.assertContains(response, attachment.get_absolute_url()) - self.assertContains(response, attachment.uploader.username) - self.assertContains(response, attachment.uploader.get_absolute_url()) - - if attachment.thumbnail: - self.assertContains(response, attachment.get_thumbnail_url()) - - def test_delete_multiple(self): - """mass delete tool on list works""" - attachments = [ - self.mock_attachment(self.post, file="somefile.pdf"), - self.mock_attachment(image="someimage.jpg"), - self.mock_attachment( - self.post, image="somelargeimage.png", thumbnail="somethumb.png" - ), - ] - - self.post.attachments_cache = [{"id": attachments[-1].pk}] - self.post.save() - - response = self.client.post( - self.admin_link, - data={"action": "delete", "selected_items": [a.pk for a in attachments]}, - ) - self.assertEqual(response.status_code, 302) - - self.assertEqual(Attachment.objects.count(), 0) - - # assert attachments were removed from post's cache - attachments_cache = self.category.post_set.get( - pk=self.post.pk - ).attachments_cache - self.assertIsNone(attachments_cache) - - def test_delete_view(self): - """delete attachment view has no showstoppers""" - attachment = self.mock_attachment(self.post) - self.post.attachments_cache = [ - {"id": attachment.pk + 1}, - {"id": attachment.pk}, - {"id": attachment.pk + 2}, - ] - self.post.save() - - action_link = reverse( - "misago:admin:attachments:delete", kwargs={"pk": attachment.pk} - ) - - response = self.client.post(action_link) - self.assertEqual(response.status_code, 302) - - # clean alert about item, grab final list url - final_link = self.client.get(self.admin_link)["location"] - - response = self.client.get(final_link) - self.assertEqual(response.status_code, 200) - self.assertNotContains(response, action_link) - - # assert it was removed from post's attachments cache - attachments_cache = self.category.post_set.get( - pk=self.post.pk - ).attachments_cache - self.assertEqual( - attachments_cache, [{"id": attachment.pk + 1}, {"id": attachment.pk + 2}] - ) diff --git a/misago/threads/admin/views/attachmenttypes.py b/misago/threads/admin/views/attachmenttypes.py deleted file mode 100644 index bb36258e0a..0000000000 --- a/misago/threads/admin/views/attachmenttypes.py +++ /dev/null @@ -1,63 +0,0 @@ -from django.contrib import messages -from django.db.models import Count -from django.utils.translation import pgettext, pgettext_lazy - -from ....admin.views import generic -from ...models import AttachmentType -from ..forms import AttachmentTypeForm - - -class AttachmentTypeAdmin(generic.AdminBaseMixin): - root_link = "misago:admin:settings:attachment-types:index" - model = AttachmentType - form_class = AttachmentTypeForm - templates_dir = "misago/admin/attachmenttypes" - message_404 = pgettext_lazy( - "admin attachments types", "Requested attachment type does not exist." - ) - - def update_roles(self, target, roles): - target.roles.clear() - if roles: - target.roles.add(*roles) - - def handle_form(self, form, request, target): - super().handle_form(form, request, target) - form.save() - - -class AttachmentTypesList(AttachmentTypeAdmin, generic.ListView): - ordering = (("name", None),) - - def get_queryset(self): - queryset = super().get_queryset() - return queryset.annotate(num_files=Count("attachment")) - - -class NewAttachmentType(AttachmentTypeAdmin, generic.ModelFormView): - message_submit = pgettext_lazy( - "admin attachments types", 'New type "%(name)s" has been saved.' - ) - - -class EditAttachmentType(AttachmentTypeAdmin, generic.ModelFormView): - message_submit = pgettext_lazy( - "admin attachments types", 'Attachment type "%(name)s" has been edited.' - ) - - -class DeleteAttachmentType(AttachmentTypeAdmin, generic.ButtonView): - def check_permissions(self, request, target): - if target.attachment_set.exists(): - message = pgettext( - "admin attachments types", - 'Attachment type "%(name)s" has associated attachments and can\'t be deleted.', - ) - return message % {"name": target.name} - - def button_action(self, request, target): - target.delete() - message = pgettext( - "admin attachments types", 'Attachment type "%(name)s" has been deleted.' - ) - messages.success(request, message % {"name": target.name}) diff --git a/misago/threads/api/attachments.py b/misago/threads/api/attachments.py deleted file mode 100644 index f6f956c5a8..0000000000 --- a/misago/threads/api/attachments.py +++ /dev/null @@ -1,122 +0,0 @@ -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 diff --git a/misago/threads/api/postingendpoint/attachments.py b/misago/threads/api/postingendpoint/attachments.py deleted file mode 100644 index 770c1b9a8b..0000000000 --- a/misago/threads/api/postingendpoint/attachments.py +++ /dev/null @@ -1,142 +0,0 @@ -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, - } - ) diff --git a/misago/threads/context_processors.py b/misago/threads/context_processors.py index f45ff02e0b..b405668010 100644 --- a/misago/threads/context_processors.py +++ b/misago/threads/context_processors.py @@ -4,7 +4,6 @@ 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"), diff --git a/misago/threads/hooks/__init__.py b/misago/threads/hooks/__init__.py index 7c958823b9..3935547018 100644 --- a/misago/threads/hooks/__init__.py +++ b/misago/threads/hooks/__init__.py @@ -1,3 +1,6 @@ +from .create_prefetch_posts_related_objects import ( + create_prefetch_posts_related_objects_hook, +) from .get_category_threads_page_context_data import ( get_category_threads_page_context_data_hook, ) @@ -22,8 +25,6 @@ from .get_edit_thread_post_page_context_data import ( get_edit_thread_post_page_context_data_hook, ) -from .get_posts_feed_item_user_ids import get_posts_feed_item_user_ids_hook -from .get_posts_feed_users import get_posts_feed_users_hook from .get_private_thread_replies_page_context_data import ( get_private_thread_replies_page_context_data_hook, ) @@ -66,9 +67,10 @@ from .get_threads_page_queryset import get_threads_page_queryset_hook from .get_threads_page_subcategories import get_threads_page_subcategories_hook from .get_threads_page_threads import get_threads_page_threads_hook -from .set_posts_feed_item_users import set_posts_feed_item_users_hook +from .set_posts_feed_related_objects import set_posts_feed_related_objects_hook __all__ = [ + "create_prefetch_posts_related_objects_hook", "get_category_threads_page_context_data_hook", "get_category_threads_page_filters_hook", "get_category_threads_page_moderation_actions_hook", @@ -91,8 +93,6 @@ "get_reply_thread_page_context_data_hook", "get_start_private_thread_page_context_data_hook", "get_start_thread_page_context_data_hook", - "get_posts_feed_item_user_ids_hook", - "get_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", @@ -103,5 +103,5 @@ "get_threads_page_queryset_hook", "get_threads_page_subcategories_hook", "get_threads_page_threads_hook", - "set_posts_feed_item_users_hook", + "set_posts_feed_related_objects_hook", ] diff --git a/misago/threads/hooks/create_prefetch_posts_related_objects.py b/misago/threads/hooks/create_prefetch_posts_related_objects.py new file mode 100644 index 0000000000..7cc23d34b5 --- /dev/null +++ b/misago/threads/hooks/create_prefetch_posts_related_objects.py @@ -0,0 +1,247 @@ +from typing import TYPE_CHECKING, Iterable, Protocol + +from ...attachments.models import Attachment +from ...categories.models import Category +from ...conf.dynamicsettings import DynamicSettings +from ...permissions.proxy import UserPermissionsProxy +from ...plugins.hooks import FilterHook +from ..models import Post, Thread + +if TYPE_CHECKING: + from ...users.models import User + from ..prefetch import PrefetchPostsRelatedObjects + + +class CreatePrefetchPostsRelatedObjectsHookAction(Protocol): + """ + A standard Misago function used to create a `PrefetchPostsRelatedObjects` + object, which is used to prefetch related objects for posts displayed on + a thread replies page. + + # Arguments + + ## `settings: DynamicSettings` + + The `DynamicSettings` object. + + ## `permissions: UserPermissionsProxy` + + The `UserPermissionsProxy` object for current user. + + ## `posts: Iterable[Post]` + + Iterable of `Post` instances to prefetch related objects for. + + ## `categories: Iterable[Category] | None = None` + + Iterable of categories that were already loaded. Defaults to `None` if not + provided. + + ## `threads: Iterable[Thread] | None = None` + + Iterable of threads that were already loaded. Defaults to `None` if not provided. + + ## `attachments: Iterable[Attachment] | None = None` + + Iterable of attachments that were already loaded. Defaults to `None` if not + provided. + + ## `users: Iterable["User"] | None = None` + + Iterable of users that were already loaded. Defaults to `None` if not provided. + + # Return value + + A `PrefetchPostsRelatedObjects` object to use to fetch related objects. + """ + + def __call__( + self, + settings: DynamicSettings, + permissions: UserPermissionsProxy, + posts: Iterable[Post], + *, + categories: Iterable[Category] | None = None, + threads: Iterable[Thread] | None = None, + attachments: Iterable[Attachment] | None = None, + users: Iterable["User"] | None = None, + ) -> "PrefetchPostsRelatedObjects": ... + + +class CreatePrefetchPostsRelatedObjectsHookFilter(Protocol): + """ + A function implemented by a plugin that can be registered in this hook. + + # Arguments + + ## `action: CreatePrefetchPostsRelatedObjectsHookAction` + + A standard Misago function used to create a `PrefetchPostsRelatedObjects` + object, which is used to prefetch related objects for posts displayed on + a thread replies page. + + See the [action](#action) section for details. + + ## `settings: DynamicSettings` + + The `DynamicSettings` object. + + ## `permissions: UserPermissionsProxy` + + The `UserPermissionsProxy` object for current user. + + ## `posts: Iterable[Post]` + + Iterable of `Post` instances to prefetch related objects for. + + ## `categories: Iterable[Category] | None = None` + + Iterable of categories that were already loaded. Defaults to `None` if not + provided. + + ## `threads: Iterable[Thread] | None = None` + + Iterable of threads that were already loaded. Defaults to `None` if not provided. + + ## `attachments: Iterable[Attachment] | None = None` + + Iterable of attachments that were already loaded. Defaults to `None` if not + provided. + + ## `users: Iterable["User"] | None = None` + + Iterable of users that were already loaded. Defaults to `None` if not provided. + + # Return value + + A `PrefetchPostsRelatedObjects` object to use to fetch related objects. + """ + + def __call__( + self, + action: CreatePrefetchPostsRelatedObjectsHookAction, + settings: DynamicSettings, + permissions: UserPermissionsProxy, + posts: Iterable[Post], + *, + categories: Iterable[Category] | None = None, + threads: Iterable[Thread] | None = None, + attachments: Iterable[Attachment] | None = None, + users: Iterable["User"] | None = None, + ) -> "PrefetchPostsRelatedObjects": ... + + +class CreatePrefetchPostsRelatedObjectsHook( + FilterHook[ + CreatePrefetchPostsRelatedObjectsHookAction, + CreatePrefetchPostsRelatedObjectsHookFilter, + ] +): + """ + This hook wraps the standard function Misago uses to create a + `PrefetchPostsRelatedObjects` object, which prefetches related objects for + posts displayed on a thread replies page. + + `PrefetchPostsRelatedObjects` is initialized with settings, user permissions, + a list of posts for which related objects need to be prefetched, and lists + of other already available objects. + + The object itself does not implement prefetch logic but instead maintains + a list of prefetch operations to be executed to fetch the objects required + for displaying posts on a thread's page. + + Additional prefetch operations can be added using the add_operation method. + + # Example + + The code below implements a custom filter function that includes a new + prefetch operation: + + ```python + from typing import Iterable + + from misago.attachments.models import Attachment + from misago.categories.models import Category + from misago.conf.dynamicsettings import DynamicSettings + from misago.permissions.proxy import UserPermissionsProxy + from misago.plugins.hooks import FilterHook + from misago.threads.models import Post, Thread + from misago.threads.prefetch import PrefetchPostsRelatedObjects + from misago.users.models import User + + from .plugin.models import PluginModel + + + def fetch_posts_plugin_data( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, + ): + data["plugin_models"] = {} + ids_to_fetch: set[int] = set() + + for post in data["posts"].values(): + ids_to_fetch.add(post.plugin_data["plugin_object_id"]) + + if ids_to_fetch: + queryset = PluginModel.objects.filter(id__in=ids_to_fetch) + data["plugin_models"] = {u.id: u for u in queryset} + + + @create_prefetch_posts_related_objects_hook.append_filter + def include_custom_filter( + action: CreatePrefetchPostsRelatedObjectsHookAction, + settings: DynamicSettings, + permissions: UserPermissionsProxy, + posts: Iterable[Post], + *, + categories: Iterable[Category] | None = None, + threads: Iterable[Thread] | None = None, + attachments: Iterable[Attachment] | None = None, + users: Iterable["User"] | None = None, + ) -> PrefetchPostsRelatedObjects: + prefetch = action( + settings, + permissions, + posts, + categories=categories, + threads=threads, + attachments=attachments, + users=users, + ) + + prefetch.add_operation(fetch_posts_plugin_data) + + return prefetch + ``` + """ + + __slots__ = FilterHook.__slots__ + + def __call__( + self, + action: CreatePrefetchPostsRelatedObjectsHookAction, + settings: DynamicSettings, + permissions: UserPermissionsProxy, + posts: Iterable[Post], + *, + categories: Iterable[Category] | None = None, + threads: Iterable[Thread] | None = None, + attachments: Iterable[Attachment] | None = None, + users: Iterable["User"] | None = None, + ) -> "PrefetchPostsRelatedObjects": + return super().__call__( + action, + settings, + permissions, + posts, + categories=categories, + threads=threads, + attachments=attachments, + users=users, + ) + + +create_prefetch_posts_related_objects_hook = CreatePrefetchPostsRelatedObjectsHook( + cache=False +) diff --git a/misago/threads/hooks/get_posts_feed_item_user_ids.py b/misago/threads/hooks/get_posts_feed_item_user_ids.py deleted file mode 100644 index 5315687590..0000000000 --- a/misago/threads/hooks/get_posts_feed_item_user_ids.py +++ /dev/null @@ -1,70 +0,0 @@ -from typing import Protocol - -from django.http import HttpRequest - -from ...plugins.hooks import ActionHook - - -class GetPostsFeedItemUserIDsHookAction(Protocol): - """ - A function that finds user ids in the `item` and updates `user_ids` set with - them. - - # Arguments - - ## `item: dict` - - A `dict` with feed's item data. - - ## `user_ids: set[int]` - - A `set` of `int`s being user ids to retrieve from the database that action - should mutate calling its `add` or `update` methods. - """ - - def __call__( - self, - request: HttpRequest, - item: dict, - user_ids: set[int], - ): ... - - -class GetPostsFeedItemUserIDsHook(ActionHook[GetPostsFeedItemUserIDsHookAction]): - """ - This hook enables plugins to include extra user IDs stored on posts in the - query that Misago uses to retrieve `User`s to display on thread and private - thread replies pages. - - # Example - - The code below implements a custom function that adds - - ```python - from misago.threads.hooks import get_posts_feed_item_user_ids_hook - - - @get_posts_feed_item_user_ids_hook.append_action - def include_plugin_users( - item: dict, - user_ids: set[int], - ): - if item["type"] != "post": - return - - if linked_user_ids := item["plugin_data"].get("linked_posts_users"): - user_ids.update(linked_user_ids) - ``` - """ - - __slots__ = ActionHook.__slots__ - - def __call__( - self, - item: dict, - user_ids: set[int], - ): - super().__call__(item, user_ids) - - -get_posts_feed_item_user_ids_hook = GetPostsFeedItemUserIDsHook() diff --git a/misago/threads/hooks/get_posts_feed_users.py b/misago/threads/hooks/get_posts_feed_users.py deleted file mode 100644 index fae68df179..0000000000 --- a/misago/threads/hooks/get_posts_feed_users.py +++ /dev/null @@ -1,120 +0,0 @@ -from typing import TYPE_CHECKING, Protocol - -from django.http import HttpRequest - -from ...plugins.hooks import FilterHook - -if TYPE_CHECKING: - from ...users.models import User - - -class GetThreadPostsFeedUsersHookAction(Protocol): - """ - A standard Misago function used to get a `dict` of `User` instances used - to display thread posts feed. Users have their `group` field already populated. - - # Arguments - - ## `request: HttpRequest` - - The request object. - - ## `user_ids: set[int]` - - A set of IDs of `User` objects to retrieve from the database - - ## Return value - - A `dict` of `User` instances, indexed by their IDs. - """ - - def __call__( - self, - request: HttpRequest, - user_ids: set[int], - ) -> dict[int, "User"]: ... - - -class GetPostsFeedUsersHookFilter(Protocol): - """ - A function implemented by a plugin that can be registered in this hook. - - # Arguments - - ## `action: GetThreadPostsFeedUsersHookAction` - - A standard Misago function used to get a `dict` of `User` instances used - to display thread posts feed. Users have their `group` field populated. - - See the [action](#action) section for details. - - ## `request: HttpRequest` - - The request object. - - ## `user_ids: set[int]` - - A set of IDs of `User` objects to retrieve from the database - - ## Return value - - A `dict` of `User` instances, indexed by their IDs. - """ - - def __call__( - self, - action: GetThreadPostsFeedUsersHookAction, - request: HttpRequest, - user_ids: set[int], - ) -> dict[int, "User"]: ... - - -class GetPostsFeedUsersHook( - FilterHook[GetThreadPostsFeedUsersHookAction, GetPostsFeedUsersHookFilter] -): - """ - This hook wraps the standard function that Misago uses to get a `dict` of - `User` instances used to display thread posts feed. Users have their `group` - field already populated. - - # Example - - The code below implements a custom filter function that removes some users - from the dictionary, making them display on a posts feed as deleted users. - - ```python - from typing import TYPE_CHECKING - - from django.http import HttpRequest - from misago.threads.hooks import get_posts_feed_users_hook - - if TYPE_CHECKING: - from misago.users.models import User - - - @get_posts_feed_users_hook.append_filter - def replace_post_poster( - action, request: HttpRequest, user_ids: set[int] - ) -> dict[int, "User"]: - users = action(request, user_ids) - - for user_id, user in list(users.items()) - if user.plugin_data.get("is_hidden"): - del users[user_id] - - return users - ``` - """ - - __slots__ = FilterHook.__slots__ - - def __call__( - self, - action: GetThreadPostsFeedUsersHookAction, - request: HttpRequest, - user_ids: set[int], - ) -> dict[int, "User"]: - return super().__call__(action, request, user_ids) - - -get_posts_feed_users_hook = GetPostsFeedUsersHook(cache=False) diff --git a/misago/threads/hooks/set_posts_feed_item_users.py b/misago/threads/hooks/set_posts_feed_item_users.py deleted file mode 100644 index d988fdcc98..0000000000 --- a/misago/threads/hooks/set_posts_feed_item_users.py +++ /dev/null @@ -1,104 +0,0 @@ -from typing import TYPE_CHECKING, Protocol - -from ...plugins.hooks import FilterHook - -if TYPE_CHECKING: - from ...users.models import User - - -class SetPostFeedItemUsersHookAction(Protocol): - """ - A standard Misago function used to set `User` instances on a `dict` with - thread posts feed item's data. - - # Arguments - - ## `users: dict[int, "User"]` - - A `dict` of `User` instances, indexed by their IDs. - - ## `item: dict` - - A `dict` with posts feed item's data. Hook should update it using the `User` - instances from the `users`. - """ - - def __call__(self, users: dict[int, "User"], item: dict): ... - - -class SetPostFeedItemUsersHookFilter(Protocol): - """ - A function implemented by a plugin that can be registered in this hook. - - # Arguments - - ## `action: SetPostFeedItemUsersHookAction` - - A standard Misago function used to set `User` instances on a `dict` with - thread posts feed item's data. - - See the [action](#action) section for details. - - ## `users: dict[int, "User"]` - - A `dict` of `User` instances, indexed by their IDs. - - ## `item: dict` - - A `dict` with posts feed item's data. Hook should update it using the `User` - instances from the `users`. - """ - - def __call__( - self, - action: SetPostFeedItemUsersHookAction, - users: dict[int, "User"], - item: dict, - ): ... - - -class SetPostFeedItemUsersHook( - FilterHook[SetPostFeedItemUsersHookAction, SetPostFeedItemUsersHookFilter] -): - """ - This hook wraps the standard function that Misago uses to set `User` instances - on a `dict` with thread posts feed item's data. - - # Example - - The code below implements a custom filter function that replaces post's real - author with other one: - - ```python - from typing import TYPE_CHECKING - - from misago.threads.hooks import set_posts_feed_item_users_hook - - if TYPE_CHECKING: - from misago.users.models import User - - - @set_posts_feed_item_users_hook.append_filter - def replace_post_poster( - action, users: dict[int, "User"], item: dict - ): - action(users, item) - - if item["type"] == "post": - if override_poster := item["post"].plugin_data.get("poster_id"): - item["poster"] = users[override_poster] - ``` - """ - - __slots__ = FilterHook.__slots__ - - def __call__( - self, - action: SetPostFeedItemUsersHookAction, - users: dict[int, "User"], - item: dict, - ): - return super().__call__(action, users, item) - - -set_posts_feed_item_users_hook = SetPostFeedItemUsersHook(cache=False) diff --git a/misago/threads/hooks/set_posts_feed_related_objects.py b/misago/threads/hooks/set_posts_feed_related_objects.py new file mode 100644 index 0000000000..b76c3bf62f --- /dev/null +++ b/misago/threads/hooks/set_posts_feed_related_objects.py @@ -0,0 +1,104 @@ +from typing import TYPE_CHECKING, Protocol + +from ...plugins.hooks import FilterHook + +if TYPE_CHECKING: + from ...users.models import User + + +class SetPostsFeedRelatedObjectsHookAction(Protocol): + """ + A standard Misago function used to set related objects on dicts containing + posts feed data. + + # Arguments + + ## `feed: list[dict]` + + A list of `dict` objects with post feed items. This function updates these + dicts with objects from the `related_objects` dictionary. + + ## `related_objects: dict` + + A `dict` with objects related to the feed's items. + """ + + def __call__(self, feed: list[dict], related_objects: dict): ... + + +class SetPostsFeedRelatedObjectsHookFilter(Protocol): + """ + A function implemented by a plugin that can be registered in this hook. + + # Arguments + + ## `action: SetPostsFeedRelatedObjectsHookAction` + + A standard Misago function used to set related objects on dicts containing + posts feed data. + + See the [action](#action) section for details. + + ## `feed: list[dict]` + + A list of `dict` objects with post feed items. This function updates these + dicts with objects from the `related_objects` dictionary. + + ## `related_objects: dict` + + A `dict` with objects related to the feed's items. + """ + + def __call__( + self, + action: SetPostsFeedRelatedObjectsHookAction, + feed: list[dict], + related_objects: dict, + ): ... + + +class SetPostsFeedRelatedObjectsHook( + FilterHook[ + SetPostsFeedRelatedObjectsHookAction, SetPostsFeedRelatedObjectsHookFilter + ] +): + """ + This hook wraps the standard function that Misago uses to set related objects + on dicts containing posts feed data. + + # Example + + The code below implements a custom filter function that populates feed's items + with plugin objects + + ```python + from misago.threads.hooks import set_posts_feed_related_objects_hook + + + @set_posts_feed_related_objects_hook.append_filter + def replace_post_poster( + action, feed: list[dict], related_objects: dict + ): + action(feed, related_objects) + + for item in feed: + if item["type"] == "post": + plugin_obj = related_objects["plugin_objects"].get( + item["post"].plugin_data["plugin_relation_id"] + ) + item["plugin_attr"] = plugin_obj + ``` + """ + + __slots__ = FilterHook.__slots__ + + def __call__( + self, + action: SetPostsFeedRelatedObjectsHookAction, + feed: list[dict], + related_objects: dict, + ): + return super().__call__(action, feed, related_objects) + + +set_posts_feed_related_objects_hook = SetPostsFeedRelatedObjectsHook(cache=False) diff --git a/misago/threads/management/commands/clearattachments.py b/misago/threads/management/commands/clearattachments.py deleted file mode 100644 index 8009229e23..0000000000 --- a/misago/threads/management/commands/clearattachments.py +++ /dev/null @@ -1,41 +0,0 @@ -import time -from datetime import timedelta - -from django.core.management.base import BaseCommand -from django.utils import timezone - -from ....conf.shortcuts import get_dynamic_settings -from ....core.management.progressbar import show_progress -from ...models import Attachment - - -class Command(BaseCommand): - help = "Deletes attachments not associated with any posts" - - def handle(self, *args, **options): - settings = get_dynamic_settings() - - cutoff = timezone.now() - timedelta(hours=settings.unused_attachments_lifetime) - queryset = Attachment.objects.filter(post__isnull=True, uploaded_on__lt=cutoff) - - attachments_to_sync = queryset.count() - - if not attachments_to_sync: - self.stdout.write("\n\nNo unused attachments were cleared") - else: - self.sync_attachments(queryset, attachments_to_sync) - - def sync_attachments(self, queryset, attachments_to_sync): - self.stdout.write("Clearing %s attachments...\n" % attachments_to_sync) - - cleared_count = 0 - show_progress(self, cleared_count, attachments_to_sync) - start_time = time.time() - - for attachment in queryset.iterator(chunk_size=50): - attachment.delete() - - cleared_count += 1 - show_progress(self, cleared_count, attachments_to_sync, start_time) - - self.stdout.write("\n\nCleared %s attachments" % cleared_count) diff --git a/misago/threads/migrations/0015_post_metadata.py b/misago/threads/migrations/0015_post_metadata.py new file mode 100644 index 0000000000..e2aac96107 --- /dev/null +++ b/misago/threads/migrations/0015_post_metadata.py @@ -0,0 +1,18 @@ +# Generated by Django 4.2.10 on 2025-01-25 23:04 + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ("misago_threads", "0014_plugin_data"), + ] + + operations = [ + migrations.AddField( + model_name="post", + name="metadata", + field=models.JSONField(default=dict), + ), + ] diff --git a/misago/threads/migrations/0016_update_attachments_markup.py b/misago/threads/migrations/0016_update_attachments_markup.py new file mode 100644 index 0000000000..ad76de776a --- /dev/null +++ b/misago/threads/migrations/0016_update_attachments_markup.py @@ -0,0 +1,205 @@ +# Generated by Django 4.2.10 on 2025-01-17 21:58 +import re +from functools import partial + +from django.conf import settings +from django.db import migrations +from django.db.models import Q +from django.urls import reverse + + +# TODO: move this to separate file, write tests for it +RE_IMG_LINK = re.compile( + r"\[!\[.+?\]\(/a/(?P[A-Za-z0-9]+)/(?P[1-9][0-9]*)/(\?shva=1)?\)\]\(/a/[A-Za-z0-9]+/[1-9][0-9]*/(\?shva=1)?\)" +) +RE_IMG_LINK_WITH_THUMB = re.compile( + r"\[!\[.+?\]\(/a/thumb/(?P[A-Za-z0-9]+)/(?P[1-9][0-9]*)/(\?shva=1)?\)\]\(/a/[A-Za-z0-9]+/[1-9][0-9]*/(\?shva=1)?\)" +) +RE_IMG = re.compile( + r"!\[.+?\]\(/a/(thumb/)?(?P[A-Za-z0-9]+)/(?P[1-9][0-9]*)/(\?shva=1)?\)" +) +RE_ATTACHMENT_URL = re.compile( + r"/a/(?Pthumb/)?(?P[A-Za-z0-9]+)/(?P[1-9][0-9]*)/(\?shva=1)?" +) +RE_MEDIA_URL = re.compile( + re.escape(settings.MEDIA_URL) + + r"attachments/[A-Za-z0-9]{2}/[A-Za-z0-9]{2}/[A-Za-z0-9]+/.+(\.[A-Za-z]+)?\.([A-Za-z]+)" +) + + +def update_attachments_markup(apps, _): + Attachment = apps.get_model("misago_attachments", "Attachment") + Post = apps.get_model("misago_threads", "Post") + + update_img_with_thumb_markdown_syntax_partial = partial( + update_img_with_thumb_markdown_syntax, Attachment + ) + update_attachment_url_partial = partial(update_attachment_url, Attachment) + update_media_url_partial = partial(update_media_url, Attachment) + + # Replace attachments urls with markdown + queryset = Post.objects.filter(original__contains="/a/").order_by("-id") + for post in queryset.iterator(chunk_size=20): + new_original = RE_IMG_LINK_WITH_THUMB.sub( + update_img_with_thumb_markdown_syntax_partial, post.original + ) + new_original = RE_IMG_LINK.sub( + update_img_with_thumb_markdown_syntax_partial, new_original + ) + new_original = RE_IMG.sub( + update_img_with_thumb_markdown_syntax_partial, new_original + ) + new_original = RE_ATTACHMENT_URL.sub( + update_attachment_url_partial, new_original + ) + + if new_original != post.original: + post.original = new_original + post.save(update_fields=["original"]) + + # Replace links pointing directly to MEDIA_URL with ones to attachment view + queryset = Post.objects.filter( + original__contains=settings.MEDIA_URL + "attachments/" + ).order_by("-id") + + for post in queryset.iterator(chunk_size=20): + new_original = RE_MEDIA_URL.sub(update_media_url_partial, post.original) + + if new_original != post.original: + post.original = new_original + post.save(update_fields=["original"]) + + +def update_img_with_thumb_markdown_syntax(attachment_type, matchobj): + full_match = matchobj.group(0) + + try: + id = int(matchobj.group("id")) + except (TypeError, ValueError): + return full_match + + secret = matchobj.group("secret") + if not id or not secret: + return full_match + + attachment = attachment_type.objects.filter(id=id, secret=secret).first() + if not attachment: + return full_match + + return f"" + + +def update_attachment_url(attachment_type, matchobj): + full_match = matchobj.group(0) + + try: + id = int(matchobj.group("id")) + except (TypeError, ValueError): + return full_match + + secret = matchobj.group("secret") + if not id or not secret: + return full_match + + attachment = attachment_type.objects.filter(id=id, secret=secret).first() + if not attachment: + return full_match + + if full_match.startswith("/a/thumb/") and attachment.thumbnail: + return reverse( + "misago:attachment-thumbnail", + kwargs={"id": attachment.id, "slug": attachment.slug}, + ) + + return reverse( + "misago:attachment-download", + kwargs={"id": attachment.id, "slug": attachment.slug}, + ) + + +def update_media_url(attachment_type, matchobj): + full_match = matchobj.group(0) + file_path = full_match[len(settings.MEDIA_URL) :] + + attachment = attachment_type.objects.filter( + Q(upload=file_path) | Q(thumbnail=file_path) + ).first() + + if not attachment: + return full_match + + if attachment.thumbnail and attachment.thumbnail.name == full_match: + return reverse( + "misago:attachment-thumbnail", + kwargs={"id": attachment.id, "slug": attachment.slug}, + ) + + return reverse( + "misago:attachment-download", + kwargs={"id": attachment.id, "slug": attachment.slug}, + ) + + +def downgrade_attachments_markup(apps, _): + Attachment = apps.get_model("misago_attachments", "Attachment") + Post = apps.get_model("misago_threads", "Post") + + reverse_attachment_url = partial(update_media_url, Attachment) + + # Replace attachments urls with markdown + queryset = Post.objects.filter(original__contains="/a/").order_by("-id") + for post in queryset.iterator(chunk_size=20): + new_original = RE_IMG_LINK_WITH_THUMB.sub( + update_img_with_thumb_markdown_syntax_partial, post.original + ) + new_original = RE_IMG_LINK.sub( + update_img_with_thumb_markdown_syntax_partial, new_original + ) + new_original = RE_IMG.sub( + update_img_with_thumb_markdown_syntax_partial, new_original + ) + new_original = RE_ATTACHMENT_URL.sub( + update_attachment_url_partial, new_original + ) + + if new_original != post.original: + post.original = new_original + post.save(update_fields=["original"]) + + +def reverse_attachment_url(attachment_type, matchobj): + full_match = matchobj.group(0) + file_path = full_match[len(settings.MEDIA_URL) :] + + attachment = attachment_type.objects.filter( + Q(upload=file_path) | Q(thumbnail=file_path) + ).first() + + if not attachment: + return full_match + + if attachment.thumbnail and attachment.thumbnail.name == full_match: + return reverse( + "misago:attachment-thumbnail", + kwargs={"id": attachment.id, "slug": attachment.slug}, + ) + + return reverse( + "misago:attachment-download", + kwargs={"id": attachment.id, "slug": attachment.slug}, + ) + + +class Migration(migrations.Migration): + + dependencies = [ + ("misago_attachments", "0005_attachment_clean_names_populate_slugs"), + ("misago_threads", "0015_post_metadata"), + ] + + operations = [ + # migrations.RunPython( + # update_attachments_markup, + # downgrade_attachments_markup, + # ), + ] diff --git a/misago/threads/models/post.py b/misago/threads/models/post.py index fbf6635a57..00dce14ec1 100644 --- a/misago/threads/models/post.py +++ b/misago/threads/models/post.py @@ -25,6 +25,7 @@ class Post(PluginDataModel): original = models.TextField() parsed = models.TextField() checksum = models.CharField(max_length=64, default="-") + metadata = models.JSONField(default=dict) mentions = models.ManyToManyField( settings.AUTH_USER_MODEL, related_name="mention_set" ) diff --git a/misago/threads/models/thread.py b/misago/threads/models/thread.py index 3541a4707d..b31e6656a1 100644 --- a/misago/threads/models/thread.py +++ b/misago/threads/models/thread.py @@ -229,7 +229,7 @@ def replies_in_ks(self): return "%sK" % round(self.replies / 1000, 0) @cached_property - def participants_ids(self) -> list[int]: + def private_thread_member_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. @@ -240,6 +240,12 @@ def participants_ids(self) -> list[int]: ) ) + @property + def private_thread_owner_id(self) -> int | None: + if members_ids := self.private_thread_member_ids: + return members_ids[0] + return None + @property def thread_type(self): return self.category.thread_type diff --git a/misago/threads/participants.py b/misago/threads/participants.py index 058ad5994c..e1ad256544 100644 --- a/misago/threads/participants.py +++ b/misago/threads/participants.py @@ -128,12 +128,14 @@ def add_participants(user: User, thread: Thread, participants: list[User]): users=participants, participants=thread_participants, exclude_user=user ) - participants_ids = [ + private_thread_member_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) + if private_thread_member_ids: + notify_on_new_private_thread.delay( + user.id, thread.id, private_thread_member_ids + ) def remove_participant(request, thread, user): diff --git a/misago/threads/postsfeed.py b/misago/threads/postsfeed.py index 4ba6acbdcd..63509defc3 100644 --- a/misago/threads/postsfeed.py +++ b/misago/threads/postsfeed.py @@ -1,28 +1,20 @@ -from typing import TYPE_CHECKING, Iterable +from typing import Iterable -from django.core.exceptions import PermissionDenied -from django.contrib.auth import get_user_model -from django.db.models import prefetch_related_objects -from django.http import Http404, HttpRequest +from django.http import HttpRequest from django.urls import reverse +from ..permissions.checkutils import check_permissions from ..permissions.privatethreads import ( check_edit_private_thread_post_permission, ) from ..permissions.threads import ( - check_edit_post_permission, + check_edit_thread_post_permission, ) from .hooks import ( - get_posts_feed_item_user_ids_hook, - get_posts_feed_users_hook, - set_posts_feed_item_users_hook, + set_posts_feed_related_objects_hook, ) from .models import Post, Thread - -if TYPE_CHECKING: - from ..users.models import User -else: - User = get_user_model() +from .prefetch import prefetch_posts_related_objects class PostsFeed: @@ -82,7 +74,16 @@ def get_feed_data(self) -> list[dict]: for i, post in enumerate(self.posts): feed.append(self.get_post_data(post, i + self.counter_start + 1)) - self.populate_feed_users(feed) + related_objects = prefetch_posts_related_objects( + self.request.settings, + self.request.user_permissions, + self.posts, + categories=[self.thread.category], + threads=[self.thread], + ) + set_posts_feed_related_objects_hook( + self.set_feed_related_objects, feed, related_objects + ) return feed @@ -106,6 +107,8 @@ def get_post_data(self, post: Post, counter: int = 1) -> dict: "unread": post.id in self.unread, "edit_url": edit_url, "moderation": False, + "attachments": [], + "rich_text_data": None, } def allow_edit_post(self, post: Post) -> bool: @@ -117,40 +120,27 @@ def get_edit_thread_post_url(self) -> str | None: def get_edit_post_url(self, post: Post) -> str | None: return None - def populate_feed_users(self, feed: list[dict]) -> None: - user_ids: set[int] = set() - for item in feed: - self.get_feed_item_users_ids(item, user_ids) - get_posts_feed_item_user_ids_hook(item, user_ids) - - if not user_ids: - return - - users = get_posts_feed_users_hook(self.get_feed_users, self.request, user_ids) - + def set_feed_related_objects(self, feed: list[dict], related_objects: dict) -> None: for item in feed: - set_posts_feed_item_users_hook(self.set_feed_item_users, users, item) - - def get_feed_item_users_ids(self, item: dict, user_ids: set[int]): - if item["type"] == "post": - user_ids.add(item["post"].poster_id) - - def get_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 + if item["type"] == "post": + self.set_post_related_objects(item, item["post"], related_objects) + + def set_post_related_objects( + self, item: dict, post: Post, related_objects: dict + ) -> None: + item["poster"] = related_objects["users"].get(post.poster_id) + item["rich_text_data"] = related_objects + + embedded_attachments = post.metadata.get("attachments", []) + for attachment in related_objects["attachments"].values(): + if ( + attachment.post_id == post.id + and attachment.id not in embedded_attachments ): - users[user.id] = user - - prefetch_related_objects(list(users.values()), "group") - return users + item["attachments"].append(attachment) - def set_feed_item_users(self, users: dict[int, "User"], item: dict): - if item["type"] == "post": - item["poster"] = users.get(item["post"].poster_id) + if item["attachments"]: + item["attachments"].sort(reverse=True, key=lambda a: a.id) class ThreadPostsFeed(PostsFeed): @@ -158,13 +148,12 @@ def allow_edit_post(self, post: Post) -> bool: if self.request.user.is_anonymous: return False - try: - check_edit_post_permission( + with check_permissions() as can_edit_post: + check_edit_thread_post_permission( self.request.user_permissions, self.thread.category, self.thread, post ) - return True - except (Http404, PermissionDenied): - return False + + return can_edit_post def get_edit_thread_post_url(self) -> str | None: return reverse( @@ -181,13 +170,12 @@ def get_edit_post_url(self, post: Post) -> str | None: class PrivateThreadPostsFeed(PostsFeed): def allow_edit_post(self, post: Post) -> bool: - try: + with check_permissions() as can_edit_post: check_edit_private_thread_post_permission( self.request.user_permissions, self.thread, post ) - return True - except (Http404, PermissionDenied): - return False + + return can_edit_post def get_edit_thread_post_url(self) -> str | None: return reverse( diff --git a/misago/threads/prefetch.py b/misago/threads/prefetch.py new file mode 100644 index 0000000000..8c3e412f58 --- /dev/null +++ b/misago/threads/prefetch.py @@ -0,0 +1,400 @@ +from typing import TYPE_CHECKING, Iterable, Protocol + +from django.contrib.auth import get_user_model + +from ..attachments.models import Attachment +from ..categories.enums import CategoryTree +from ..categories.models import Category +from ..conf.dynamicsettings import DynamicSettings +from ..permissions.attachments import check_download_attachment_permission +from ..permissions.posts import check_see_post_permission +from ..permissions.proxy import UserPermissionsProxy +from ..permissions.checkutils import check_permissions +from ..users.models import Group +from .hooks import create_prefetch_posts_related_objects_hook +from .models import Post, Thread +from .privatethreads import prefetch_private_thread_member_ids + +if TYPE_CHECKING: + from ..users.models import User +else: + User = get_user_model() + +__all__ = [ + "PrefetchPostsRelatedObjects", + "PrefetchPostsRelationsOperation", + "prefetch_posts_related_objects", +] + + +def prefetch_posts_related_objects( + settings: DynamicSettings, + permissions: UserPermissionsProxy, + posts: Iterable[Post], + *, + categories: Iterable[Category] | None = None, + threads: Iterable[Thread] | None = None, + attachments: Iterable[Attachment] | None = None, + users: Iterable["User"] | None = None, +) -> dict: + prefetch = create_prefetch_posts_related_objects_hook( + _create_prefetch_posts_related_objects_action, + settings, + permissions, + posts, + categories=categories, + threads=threads, + attachments=attachments, + users=users, + ) + return prefetch() + + +def _create_prefetch_posts_related_objects_action( + settings: DynamicSettings, + permissions: UserPermissionsProxy, + posts: Iterable[Post], + *, + categories: Iterable[Category] | None = None, + threads: Iterable[Thread] | None = None, + attachments: Iterable[Attachment] | None = None, + users: Iterable["User"] | None = None, +) -> "PrefetchPostsRelatedObjects": + prefetch = PrefetchPostsRelatedObjects( + settings, + permissions, + posts=posts, + categories=categories, + threads=threads, + attachments=attachments, + users=users, + ) + + prefetch.add_operation(find_attachment_ids) + prefetch.add_operation(fetch_attachments) + prefetch.add_operation(find_post_ids) + prefetch.add_operation(fetch_posts) + prefetch.add_operation(find_thread_ids) + prefetch.add_operation(fetch_threads) + prefetch.add_operation(find_category_ids) + prefetch.add_operation(fetch_categories) + prefetch.add_operation(fetch_private_threads_members) + prefetch.add_operation(find_users_ids) + prefetch.add_operation(fetch_users) + prefetch.add_operation(fetch_users_groups) + prefetch.add_operation(check_attachments_permissions) + + return prefetch + + +class PrefetchPostsRelationsOperation(Protocol): + def __call__( + self, + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, + ) -> None: + pass + + +class PrefetchPostsRelatedObjects: + ops: list[PrefetchPostsRelationsOperation] + + settings: DynamicSettings + permissions: User + + categories: list[Category] + threads: list[Thread] + posts: list[Post] + attachments: list[Attachment] + users: list[User] + extra_kwargs: dict + + def __init__( + self, + settings: DynamicSettings, + permissions: UserPermissionsProxy, + *, + posts: Iterable[Post], + categories: Iterable[Category] | None = None, + threads: Iterable[Thread] | None = None, + attachments: Iterable[Attachment] | None = None, + users: Iterable["User"] | None = None, + **kwargs, + ): + self.ops = [] + + self.settings = settings + self.permissions = permissions + + self.categories = categories or [] + self.threads = threads or [] + self.posts = list(posts) + self.attachments = attachments or [] + self.users = users or [] + + if permissions.user.is_authenticated and permissions.user not in self.users: + self.users.append(permissions.user) + + self.extra_kwargs = kwargs + + def __call__(self) -> dict: + data = { + "category_ids": set(), + "thread_ids": set(), + "post_ids": set(), + "attachment_ids": set(), + "user_ids": set(), + "categories": {c.id: c for c in self.categories if c.id}, + "threads": {t.id: t for t in self.threads if t.id}, + "posts": {p.id: p for p in self.posts if p.id}, + "attachments": {a.id: a for a in self.attachments}, + "attachment_errors": {}, + "users": {u.id: u for u in self.users}, + "extra_kwargs": self.extra_kwargs, + } + + for op in self.ops: + op(data, self.settings, self.permissions) + + return data + + def add_operation( + self, + op: PrefetchPostsRelationsOperation, + *, + after: PrefetchPostsRelationsOperation | None = None, + before: PrefetchPostsRelationsOperation | None = None, + ): + if after and before: + raise ValueError("'after' and 'before' option's can't be used together") + + if after: + inserted = False + new_ops: list[PrefetchPostsRelationsOperation] = [] + + for existing_step in self.ops: + new_ops.append(existing_step) + if existing_step == after: + new_ops.append(op) + inserted = True + self.ops = new_ops + + if not inserted: + raise ValueError( + f"Operation '{after}' doesn't exist in this loader instance" + ) + + elif before: + prepended = False + new_ops: list[PrefetchPostsRelationsOperation] = [] + + for existing_step in self.ops: + if existing_step == before: + new_ops.append(op) + prepended = True + new_ops.append(existing_step) + self.ops = new_ops + + if not prepended: + raise ValueError( + f"Operation '{after}' doesn't exist in this loader instance" + ) + + else: + self.ops.append(op) + + +def find_category_ids( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + for post in data["posts"].values(): + if post.category_id: + data["category_ids"].add(post.category_id) + + for thread in data["threads"].values(): + if thread.category_id: + data["category_ids"].add(thread.category_id) + + for attachment in data["attachments"].values(): + if attachment.category_id: + data["category_ids"].add(attachment.category_id) + + +def fetch_categories( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + if ids_to_fetch := data["category_ids"].difference(data["categories"]): + queryset = Category.objects.filter(id__in=ids_to_fetch) + data["categories"].update({c.id: c for c in queryset}) + + +def find_thread_ids( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + for post in data["posts"].values(): + if post.thread_id: + data["thread_ids"].add(post.thread_id) + + for attachment in data["attachments"].values(): + if attachment.thread_id: + data["thread_ids"].add(attachment.thread_id) + + +def fetch_threads( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + if ids_to_fetch := data["thread_ids"].difference(data["threads"]): + queryset = Thread.objects.filter(id__in=ids_to_fetch) + data["threads"].update({t.id: t for t in queryset}) + + +def fetch_private_threads_members( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + private_threads: list[Thread] = [] + for thread in data["threads"].values(): + category = data["categories"][thread.category_id] + if category.tree_id == CategoryTree.PRIVATE_THREADS: + private_threads.append(thread) + + if private_threads: + prefetch_private_thread_member_ids(private_threads) + + +def find_post_ids( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + for attachment in data["attachments"].values(): + if attachment.post_id: + data["post_ids"].add(attachment.post_id) + + +def fetch_posts( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + if ids_to_fetch := data["post_ids"].difference(data["posts"]): + queryset = Post.objects.filter(id__in=ids_to_fetch) + data["posts"].update({p.id: p for p in queryset}) + + +def find_attachment_ids( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + for post in data["posts"].values(): + data["attachment_ids"].update(post.metadata.get("attachments", [])) + + +def fetch_attachments( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + visible_posts: list[int] = [] + for post in data["posts"].values(): + with check_permissions() as can_see: + check_see_post_permission( + permissions, + post.category, + post.thread, + post, + ) + + if can_see: + visible_posts.append(post.id) + + queryset = Attachment.objects.filter(post_id__in=visible_posts) + + if ids_to_fetch := data["attachment_ids"].difference(data["attachments"]): + if settings.additional_embedded_attachments_limit: + queryset = queryset.union( + Attachment.objects.filter(id__in=ids_to_fetch, post__isnull=False) + .exclude(post_id__in=visible_posts) + .order_by("-id")[: settings.additional_embedded_attachments_limit] + ) + + data["attachments"].update({a.id: a for a in queryset}) + + +def check_attachments_permissions( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + attachments_list = sorted( + data["attachments"].values(), reverse=True, key=lambda a: a.id + ) + + accessible_attachments: dict[int, Attachment] = {} + for attachment in attachments_list: + if attachment.category_id: + attachment.category = data["categories"][attachment.category_id] + if attachment.thread_id: + attachment.thread = data["threads"][attachment.thread_id] + if attachment.post_id: + attachment.post = data["posts"][attachment.post_id] + + with check_permissions() as can_download: + check_download_attachment_permission( + permissions, + attachment.category, + attachment.thread, + attachment.post, + attachment, + ) + + if can_download: + accessible_attachments[attachment.id] = attachment + else: + data["attachment_errors"][attachment.id] = can_download + + data["attachments"] = accessible_attachments + + +def find_users_ids( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + for post in data["posts"].values(): + data["user_ids"].add(post.poster_id) + + +def fetch_users( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + if ids_to_fetch := data["user_ids"].difference(data["users"]): + queryset = User.objects.filter(id__in=ids_to_fetch, is_active=True) + data["users"].update({u.id: u for u in queryset}) + + +def fetch_users_groups( + data: dict, + settings: DynamicSettings, + permissions: UserPermissionsProxy, +): + users = data["users"].values() + + ids_to_fetch: set[int] = set(u.group_id for u in users) + if ids_to_fetch: + groups = {g.id: g for g in Group.objects.filter(id__in=ids_to_fetch)} + for user in users: + user.group = groups[user.group_id] diff --git a/misago/threads/privatethreads.py b/misago/threads/privatethreads.py new file mode 100644 index 0000000000..e99b25d29a --- /dev/null +++ b/misago/threads/privatethreads.py @@ -0,0 +1,18 @@ +from typing import Iterable + +from .models import Thread, ThreadParticipant + + +def prefetch_private_thread_member_ids(threads: Iterable[Thread]): + threads_members: dict[int : list[int]] = {t.id: [] for t in threads} + + queryset = ( + ThreadParticipant.objects.filter(thread__in=threads) + .order_by("-is_owner") + .values_list("thread_id", "user_id") + ) + for thread_id, user_id in queryset: + threads_members[thread_id].append(user_id) + + for thread in threads: + thread.private_thread_member_ids = threads_members[thread.id] diff --git a/misago/threads/signals.py b/misago/threads/signals.py index 324976537c..51ccfe303c 100644 --- a/misago/threads/signals.py +++ b/misago/threads/signals.py @@ -5,8 +5,9 @@ from django.dispatch import Signal, receiver from django.utils.translation import pgettext +from ..attachments.delete import delete_users_attachments +from ..attachments.models import Attachment from ..categories.models import Category -from ..categories.signals import delete_category_content, move_category_content from ..notifications.models import Notification, WatchedThread from ..users.signals import ( anonymize_user_data, @@ -15,7 +16,15 @@ username_changed, ) from .anonymize import ANONYMIZABLE_EVENTS, anonymize_event, anonymize_post_last_likes -from .models import Attachment, Poll, PollVote, Post, PostEdit, PostLike, Thread +from .models import ( + Attachment as LegacyAttachment, + Poll, + PollVote, + Post, + PostEdit, + PostLike, + Thread, +) delete_post = Signal() delete_thread = Signal() @@ -86,36 +95,10 @@ def change_thread_title(sender, **kwargs): sender.notification_set.update(thread_title=sender.title) -@receiver(delete_category_content) -def delete_category_threads(sender, **kwargs): - sender.notification_set.all().delete() - sender.watchedthread_set.all().delete() - sender.subscription_set.all().delete() - sender.pollvote_set.all().delete() - sender.poll_set.all().delete() - sender.postlike_set.all().delete() - sender.thread_set.all().delete() - sender.postedit_set.all().delete() - sender.post_set.all().delete() - - -@receiver(move_category_content) -def move_category_threads(sender, **kwargs): - new_category = kwargs["new_category"] - - sender.thread_set.update(category=new_category) - sender.post_set.filter(category=sender).update(category=new_category) - sender.postedit_set.filter(category=sender).update(category=new_category) - sender.postlike_set.filter(category=sender).update(category=new_category) - sender.poll_set.filter(category=sender).update(category=new_category) - sender.pollvote_set.update(category=new_category) - sender.subscription_set.update(category=new_category) - sender.notification_set.update(category=new_category) - sender.watchedthread_set.update(category=new_category) - - @receiver(delete_user_content) def delete_user_threads(sender, **kwargs): + delete_users_attachments([sender]) + recount_categories = set() recount_threads = set() @@ -156,13 +139,18 @@ def delete_user_threads(sender, **kwargs): @receiver(archive_user_data) def archive_user_attachments(sender, archive=None, **kwargs): - queryset = sender.attachment_set.order_by("id") + queryset = Attachment.objects.filter(uploader=sender).order_by("id") for attachment in queryset.iterator(chunk_size=50): archive.add_model_file( attachment.file, prefix=attachment.uploaded_on.strftime("%H%M%S-file"), date=attachment.uploaded_on, ) + archive.add_model_file( + attachment.video, + prefix=attachment.uploaded_on.strftime("%H%M%S-video"), + date=attachment.uploaded_on, + ) archive.add_model_file( attachment.image, prefix=attachment.uploaded_on.strftime("%H%M%S-image"), @@ -175,6 +163,27 @@ def archive_user_attachments(sender, archive=None, **kwargs): ) +@receiver(archive_user_data) +def archive_user_legacy_attachments(sender, archive=None, **kwargs): + queryset = sender.attachment_set.order_by("id") + for attachment in queryset.iterator(chunk_size=50): + archive.add_model_file( + attachment.file, + prefix=attachment.uploaded_on.strftime("%H%M%S-legacy-file"), + date=attachment.uploaded_on, + ) + archive.add_model_file( + attachment.image, + prefix=attachment.uploaded_on.strftime("%H%M%S-legacy-image"), + date=attachment.uploaded_on, + ) + archive.add_model_file( + attachment.thumbnail, + prefix=attachment.uploaded_on.strftime("%H%M%S-legacy-thumbnail"), + date=attachment.uploaded_on, + ) + + @receiver(archive_user_data) def archive_user_posts(sender, archive=None, **kwargs): for post in sender.post_set.order_by("id").iterator(chunk_size=50): @@ -260,6 +269,9 @@ def update_usernames(sender, **kwargs): Attachment.objects.filter(uploader=sender).update( uploader_name=sender.username, uploader_slug=sender.slug ) + LegacyAttachment.objects.filter(uploader=sender).update( + uploader_name=sender.username, uploader_slug=sender.slug + ) Poll.objects.filter(poster=sender).update( poster_name=sender.username, poster_slug=sender.slug diff --git a/misago/threads/tests/conftest.py b/misago/threads/tests/conftest.py index d97e85d9fb..a42d0ce1d3 100644 --- a/misago/threads/tests/conftest.py +++ b/misago/threads/tests/conftest.py @@ -3,7 +3,6 @@ from ...categories.models import Category from ...permissions.enums import CategoryPermission -from ...posting.forms.title import PREFIX as THREAD_TITLE_FORM from ...posting.hooks import validate_posted_contents_hook from ...testutils import grant_category_group_permissions @@ -52,7 +51,7 @@ def posted_contents_validator(): def validate_spam_contents(formset, state): # Check if posting form included thread title - if THREAD_TITLE_FORM in formset and "spam" in state.thread.title.lower(): + if formset.title and "spam" in state.thread.title.lower(): raise ValidationError("Your message contains spam!") if "spam" in state.post.original.lower(): diff --git a/misago/threads/tests/test_attachments_api.py b/misago/threads/tests/test_attachments_api.py deleted file mode 100644 index df695778e5..0000000000 --- a/misago/threads/tests/test_attachments_api.py +++ /dev/null @@ -1,308 +0,0 @@ -import os - -from django.urls import reverse -from PIL import Image - -from ...acl.models import Role -from ...acl.test import patch_user_acl -from ...conf import settings -from ...users.test import AuthenticatedUserTestCase -from ..models import Attachment, AttachmentType - -TESTFILES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "testfiles") -TEST_DOCUMENT_PATH = os.path.join(TESTFILES_DIR, "document.pdf") -TEST_LARGEPNG_PATH = os.path.join(TESTFILES_DIR, "large.png") -TEST_SMALLJPG_PATH = os.path.join(TESTFILES_DIR, "small.jpg") -TEST_ANIMATEDGIF_PATH = os.path.join(TESTFILES_DIR, "animated.gif") -TEST_CORRUPTEDIMG_PATH = os.path.join(TESTFILES_DIR, "corrupted.gif") - - -class AttachmentsApiTestCase(AuthenticatedUserTestCase): - def setUp(self): - super().setUp() - - AttachmentType.objects.all().delete() - - self.api_link = reverse("misago:api:attachment-list") - - def test_anonymous(self): - """user has to be authenticated to be able to upload files""" - self.logout_user() - - response = self.client.post(self.api_link) - self.assertEqual(response.status_code, 403) - - @patch_user_acl({"max_attachment_size": 0}) - def test_no_permission(self): - """user needs permission to upload files""" - response = self.client.post(self.api_link) - self.assertEqual(response.status_code, 403) - self.assertEqual( - response.json(), - {"detail": "You don't have permission to upload new files."}, - ) - - def test_no_file_uploaded(self): - """no file uploaded scenario is handled""" - response = self.client.post(self.api_link) - self.assertEqual(response.status_code, 400) - self.assertEqual(response.json(), {"detail": "No file has been uploaded."}) - - def test_invalid_extension(self): - """uploaded file's extension is rejected as invalid""" - AttachmentType.objects.create( - name="Test extension", extensions="jpg,jpeg", mimetypes=None - ) - - with open(TEST_DOCUMENT_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 400) - self.assertEqual( - response.json(), {"detail": "You can't upload files of this type."} - ) - - def test_invalid_mime(self): - """uploaded file's mimetype is rejected as invalid""" - AttachmentType.objects.create( - name="Test extension", extensions="png", mimetypes="loremipsum" - ) - - with open(TEST_DOCUMENT_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 400) - self.assertEqual( - response.json(), {"detail": "You can't upload files of this type."} - ) - - def test_no_perm_to_type(self): - """user needs permission to upload files of this type""" - attachment_type = AttachmentType.objects.create( - name="Test extension", extensions="png", mimetypes="application/pdf" - ) - - user_roles = (r.pk for r in self.user.get_roles()) - attachment_type.limit_uploads_to.set(Role.objects.exclude(id__in=user_roles)) - - with open(TEST_DOCUMENT_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 400) - self.assertEqual( - response.json(), {"detail": "You can't upload files of this type."} - ) - - def test_type_is_locked(self): - """new uploads for this filetype are locked""" - AttachmentType.objects.create( - name="Test extension", - extensions="png", - mimetypes="application/pdf", - status=AttachmentType.LOCKED, - ) - - with open(TEST_DOCUMENT_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 400) - self.assertEqual( - response.json(), {"detail": "You can't upload files of this type."} - ) - - def test_type_is_disabled(self): - """new uploads for this filetype are disabled""" - AttachmentType.objects.create( - name="Test extension", - extensions="png", - mimetypes="application/pdf", - status=AttachmentType.DISABLED, - ) - - with open(TEST_DOCUMENT_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 400) - self.assertEqual( - response.json(), {"detail": "You can't upload files of this type."} - ) - - @patch_user_acl({"max_attachment_size": 100}) - def test_upload_too_big_for_user(self): - """too big uploads are rejected""" - AttachmentType.objects.create( - name="Test extension", extensions="png", mimetypes="image/png" - ) - - with open(TEST_LARGEPNG_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 400) - self.assertEqual( - response.json(), - { - "detail": ( - "You can't upload files larger than 100.0\xa0KB " - "(your file has 253.9\xa0KB)." - ) - }, - ) - - def test_corrupted_image_upload(self): - """corrupted image upload is handled""" - AttachmentType.objects.create(name="Test extension", extensions="gif") - - with open(TEST_CORRUPTEDIMG_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 400) - self.assertEqual( - response.json(), {"detail": "Uploaded image is unsupported or invalid."} - ) - - def test_document_upload(self): - """successful upload creates orphan attachment""" - AttachmentType.objects.create( - name="Test extension", extensions="pdf", mimetypes="application/pdf" - ) - - with open(TEST_DOCUMENT_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 200) - - response_json = response.json() - attachment = Attachment.objects.get(id=response_json["id"]) - - self.assertEqual(attachment.filename, "document.pdf") - self.assertTrue(attachment.is_file) - self.assertFalse(attachment.is_image) - - self.assertIsNotNone(attachment.file) - self.assertTrue(not attachment.image) - self.assertTrue(not attachment.thumbnail) - - self.assertTrue(str(attachment.file).endswith("document.pdf")) - - self.assertIsNone(response_json["post"]) - self.assertEqual(response_json["uploader_name"], self.user.username) - self.assertEqual(response_json["url"]["index"], attachment.get_absolute_url()) - self.assertIsNone(response_json["url"]["thumb"]) - self.assertEqual(response_json["url"]["uploader"], self.user.get_absolute_url()) - - self.assertEqual(self.user.audittrail_set.count(), 1) - - # files associated with attachment are deleted on its deletion - file_path = attachment.file.path - self.assertTrue(os.path.exists(file_path)) - attachment.delete() - self.assertFalse(os.path.exists(file_path)) - - def test_small_image_upload(self): - """successful small image upload creates orphan attachment without thumbnail""" - AttachmentType.objects.create( - name="Test extension", extensions="jpeg,jpg", mimetypes="image/jpeg" - ) - - with open(TEST_SMALLJPG_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 200) - - response_json = response.json() - attachment = Attachment.objects.get(id=response_json["id"]) - - self.assertEqual(attachment.filename, "small.jpg") - self.assertFalse(attachment.is_file) - self.assertTrue(attachment.is_image) - - self.assertTrue(not attachment.file) - self.assertIsNotNone(attachment.image) - self.assertTrue(not attachment.thumbnail) - - self.assertTrue(str(attachment.image).endswith("small.jpg")) - - self.assertIsNone(response_json["post"]) - self.assertEqual(response_json["uploader_name"], self.user.username) - self.assertEqual(response_json["url"]["index"], attachment.get_absolute_url()) - self.assertIsNone(response_json["url"]["thumb"]) - self.assertEqual(response_json["url"]["uploader"], self.user.get_absolute_url()) - - self.assertEqual(self.user.audittrail_set.count(), 1) - - @patch_user_acl({"max_attachment_size": 10 * 1024}) - def test_large_image_upload(self): - """successful large image upload creates orphan attachment with thumbnail""" - AttachmentType.objects.create( - name="Test extension", extensions="png", mimetypes="image/png" - ) - - with open(TEST_LARGEPNG_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 200) - - response_json = response.json() - attachment = Attachment.objects.get(id=response_json["id"]) - - self.assertEqual(attachment.filename, "large.png") - self.assertFalse(attachment.is_file) - self.assertTrue(attachment.is_image) - - self.assertTrue(not attachment.file) - self.assertIsNotNone(attachment.image) - self.assertIsNotNone(attachment.thumbnail) - - self.assertTrue(str(attachment.image).endswith("large.png")) - self.assertTrue(str(attachment.thumbnail).endswith("large.png")) - - self.assertIsNone(response_json["post"]) - self.assertEqual(response_json["uploader_name"], self.user.username) - self.assertEqual(response_json["url"]["index"], attachment.get_absolute_url()) - self.assertEqual(response_json["url"]["thumb"], attachment.get_thumbnail_url()) - self.assertEqual(response_json["url"]["uploader"], self.user.get_absolute_url()) - - self.assertEqual(self.user.audittrail_set.count(), 1) - - # thumbnail was scaled down - thumbnail = Image.open(attachment.thumbnail.path) - self.assertEqual( - thumbnail.size[0], settings.MISAGO_ATTACHMENT_IMAGE_SIZE_LIMIT[0] - ) - self.assertLess( - thumbnail.size[1], settings.MISAGO_ATTACHMENT_IMAGE_SIZE_LIMIT[1] - ) - - # files associated with attachment are deleted on its deletion - image_path = attachment.image.path - thumbnail_path = attachment.thumbnail.path - - self.assertTrue(os.path.exists(image_path)) - self.assertTrue(os.path.exists(thumbnail_path)) - - attachment.delete() - - self.assertFalse(os.path.exists(image_path)) - self.assertFalse(os.path.exists(thumbnail_path)) - - def test_animated_image_upload(self): - """successful gif upload creates orphan attachment with thumbnail""" - AttachmentType.objects.create( - name="Test extension", extensions="gif", mimetypes="image/gif" - ) - - with open(TEST_ANIMATEDGIF_PATH, "rb") as upload: - response = self.client.post(self.api_link, data={"upload": upload}) - self.assertEqual(response.status_code, 200) - - response_json = response.json() - attachment = Attachment.objects.get(id=response_json["id"]) - - self.assertEqual(attachment.filename, "animated.gif") - self.assertFalse(attachment.is_file) - self.assertTrue(attachment.is_image) - - self.assertTrue(not attachment.file) - self.assertIsNotNone(attachment.image) - self.assertIsNotNone(attachment.thumbnail) - - self.assertTrue(str(attachment.image).endswith("animated.gif")) - self.assertTrue(str(attachment.thumbnail).endswith("animated.gif")) - - self.assertIsNone(response_json["post"]) - self.assertEqual(response_json["uploader_name"], self.user.username) - self.assertEqual(response_json["url"]["index"], attachment.get_absolute_url()) - self.assertEqual(response_json["url"]["thumb"], attachment.get_thumbnail_url()) - self.assertEqual(response_json["url"]["uploader"], self.user.get_absolute_url()) - - self.assertEqual(self.user.audittrail_set.count(), 1) diff --git a/misago/threads/tests/test_attachments_middleware.py b/misago/threads/tests/test_attachments_middleware.py deleted file mode 100644 index 1f5e012c76..0000000000 --- a/misago/threads/tests/test_attachments_middleware.py +++ /dev/null @@ -1,302 +0,0 @@ -from unittest.mock import Mock - -import pytest -from rest_framework import serializers - -from .. import test -from ...conf.test import override_dynamic_settings -from ..api.postingendpoint import PostingEndpoint -from ..api.postingendpoint.attachments import ( - AttachmentsMiddleware, - validate_attachments_count, -) -from ..models import Attachment, AttachmentType - - -@pytest.fixture -def context(default_category, dynamic_settings, user, user_acl): - thread = test.post_thread(category=default_category) - post = thread.first_post - post.update_fields = [] - - return { - "category": default_category, - "thread": thread, - "post": post, - "settings": dynamic_settings, - "user": user, - "user_acl": user_acl, - } - - -def create_attachment(*, post=None, user=None): - return Attachment.objects.create( - secret=Attachment.generate_new_secret(), - filetype=AttachmentType.objects.order_by("id").last(), - post=post, - size=1000, - uploader=user if user else None, - uploader_name=user.username if user else "testuser", - uploader_slug=user.slug if user else "testuser", - filename="testfile_%s.zip" % (Attachment.objects.count() + 1), - ) - - -def test_middleware_is_used_if_user_has_permission_to_upload_attachments(context): - context["user_acl"]["max_attachment_size"] = 1024 - middleware = AttachmentsMiddleware(**context) - assert middleware.use_this_middleware() - - -def test_middleware_is_not_used_if_user_has_no_permission_to_upload_attachments( - context, -): - context["user_acl"]["max_attachment_size"] = 0 - middleware = AttachmentsMiddleware(**context) - assert not middleware.use_this_middleware() - - -def test_middleware_handles_no_data(context): - middleware = AttachmentsMiddleware( - request=Mock(data={}), mode=PostingEndpoint.START, **context - ) - - serializer = middleware.get_serializer() - assert serializer.is_valid() - - -def test_middleware_handles_empty_data(context): - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": []}), mode=PostingEndpoint.START, **context - ) - - serializer = middleware.get_serializer() - assert serializer.is_valid() - - -def test_data_validation_fails_if_attachments_data_is_not_iterable(context): - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": "none"}), - mode=PostingEndpoint.START, - **context - ) - - serializer = middleware.get_serializer() - assert not serializer.is_valid() - - -def test_data_validation_fails_if_attachments_data_has_non_int_values(context): - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": [1, "b"]}), - mode=PostingEndpoint.START, - **context - ) - - serializer = middleware.get_serializer() - assert not serializer.is_valid() - - -@override_dynamic_settings(post_attachments_limit=2) -def test_data_validation_fails_if_attachments_data_is_longer_than_allowed(context): - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": range(5)}), - mode=PostingEndpoint.START, - **context - ) - - serializer = middleware.get_serializer() - assert not serializer.is_valid() - - -def test_middleware_adds_attachment_to_new_post(context): - new_attachment = create_attachment(user=context["user"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": [new_attachment.id]}), - mode=PostingEndpoint.START, - **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - new_attachment.refresh_from_db() - assert new_attachment.post == context["post"] - - -def test_middleware_adds_attachment_to_attachments_cache(context): - new_attachment = create_attachment(user=context["user"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": [new_attachment.id]}), - mode=PostingEndpoint.START, - **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - attachments_cache = context["post"].attachments_cache - assert len(attachments_cache) == 1 - assert attachments_cache[0]["id"] == new_attachment.id - - -def test_middleware_adds_attachment_to_existing_post(context): - new_attachment = create_attachment(user=context["user"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": [new_attachment.id]}), - mode=PostingEndpoint.EDIT, - **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - new_attachment.refresh_from_db() - assert new_attachment.post == context["post"] - - -def test_middleware_adds_attachment_to_post_with_existing_attachment(context): - old_attachment = create_attachment(post=context["post"]) - new_attachment = create_attachment(user=context["user"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": [old_attachment.id, new_attachment.id]}), - mode=PostingEndpoint.EDIT, - **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - new_attachment.refresh_from_db() - assert new_attachment.post == context["post"] - - old_attachment.refresh_from_db() - assert old_attachment.post == context["post"] - - -def test_middleware_adds_attachment_to_existing_attachments_cache(context): - old_attachment = create_attachment(post=context["post"]) - new_attachment = create_attachment(user=context["user"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": [old_attachment.id, new_attachment.id]}), - mode=PostingEndpoint.EDIT, - **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - attachments_cache = context["post"].attachments_cache - assert len(attachments_cache) == 2 - assert attachments_cache[0]["id"] == new_attachment.id - assert attachments_cache[1]["id"] == old_attachment.id - - -def test_other_user_attachment_cant_be_added_to_post(context): - attachment = create_attachment() - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": [attachment.id]}), - mode=PostingEndpoint.EDIT, - **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - attachment.refresh_from_db() - assert not attachment.post - - -def test_other_post_attachment_cant_be_added_to_new_post(context, default_category): - post = test.post_thread(category=default_category).first_post - attachment = create_attachment(post=post, user=context["user"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": [attachment.id]}), - mode=PostingEndpoint.EDIT, - **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - attachment.refresh_from_db() - assert attachment.post == post - - -def test_middleware_removes_attachment_from_post(context): - attachment = create_attachment(post=context["post"], user=context["user"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": []}), mode=PostingEndpoint.EDIT, **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - context["post"].refresh_from_db() - assert not context["post"].attachment_set.exists() - - -def test_middleware_removes_attachment_from_attachments_cache(context): - attachment = create_attachment(post=context["post"], user=context["user"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": []}), mode=PostingEndpoint.EDIT, **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - assert not context["post"].attachments_cache - - -def test_middleware_deletes_attachment_removed_from_post(context): - attachment = create_attachment(post=context["post"], user=context["user"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": []}), mode=PostingEndpoint.EDIT, **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - with pytest.raises(Attachment.DoesNotExist): - attachment.refresh_from_db() - - -def test_middleware_blocks_user_from_removing_other_user_attachment_without_permission( - context, -): - attachment = create_attachment(post=context["post"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": []}), mode=PostingEndpoint.EDIT, **context - ) - serializer = middleware.get_serializer() - assert not serializer.is_valid() - middleware.save(serializer) - - attachment.refresh_from_db() - assert attachment.post == context["post"] - - -def test_middleware_allows_user_with_permission_to_remove_other_user_attachment( - context, -): - context["user_acl"]["can_delete_other_users_attachments"] = True - attachment = create_attachment(post=context["post"]) - middleware = AttachmentsMiddleware( - request=Mock(data={"attachments": []}), mode=PostingEndpoint.EDIT, **context - ) - serializer = middleware.get_serializer() - serializer.is_valid() - middleware.save(serializer) - - context["post"].refresh_from_db() - assert not context["post"].attachment_set.exists() - - -def test_attachments_count_validator_allows_attachments_within_limit(): - settings = Mock(post_attachments_limit=5) - validate_attachments_count(range(5), settings) - - -def test_attachments_count_validator_raises_validation_error_on_too_many_attachmes(): - settings = Mock(post_attachments_limit=2) - with pytest.raises(serializers.ValidationError): - validate_attachments_count(range(5), settings) diff --git a/misago/threads/tests/test_attachments_proxy.py b/misago/threads/tests/test_attachments_proxy.py deleted file mode 100644 index 3b3e639d0c..0000000000 --- a/misago/threads/tests/test_attachments_proxy.py +++ /dev/null @@ -1,272 +0,0 @@ -import pytest -from django.urls import reverse - -from ...acl.models import Role -from ...acl.test import patch_user_acl -from ...conf import settings -from ...conf.test import override_dynamic_settings -from ..models import Attachment, AttachmentType - - -@pytest.fixture -def attachment_type(db): - return AttachmentType.objects.order_by("id").first() - - -@pytest.fixture -def attachment(attachment_type, post, user): - return Attachment.objects.create( - secret="secret", - filetype=attachment_type, - post=post, - uploader=user, - uploader_name=user.username, - uploader_slug=user.slug, - filename="test.txt", - file="test.txt", - size=1000, - ) - - -@pytest.fixture -def image(post, user): - return Attachment.objects.create( - secret="secret", - filetype=AttachmentType.objects.get(mimetypes="image/png"), - post=post, - uploader=user, - uploader_name=user.username, - uploader_slug=user.slug, - filename="test.png", - image="test.png", - size=1000, - ) - - -@pytest.fixture -def image_with_thumbnail(post, user): - return Attachment.objects.create( - secret="secret", - filetype=AttachmentType.objects.get(mimetypes="image/png"), - post=post, - uploader=user, - uploader_name=user.username, - uploader_slug=user.slug, - filename="test.png", - image="test.png", - thumbnail="test-thumbnail.png", - size=1000, - ) - - -@pytest.fixture -def other_users_attachment(attachment, other_user): - attachment.uploader = other_user - attachment.save() - return attachment - - -@pytest.fixture -def orphaned_attachment(attachment): - attachment.post = None - attachment.save() - return attachment - - -@pytest.fixture -def other_users_orphaned_attachment(other_users_attachment): - other_users_attachment.post = None - other_users_attachment.save() - return other_users_attachment - - -def assert_403(response): - assert response.status_code == 302 - assert response["location"].endswith(settings.MISAGO_ATTACHMENT_403_IMAGE) - - -def assert_404(response): - assert response.status_code == 302 - assert response["location"].endswith(settings.MISAGO_ATTACHMENT_404_IMAGE) - - -def test_proxy_redirects_client_to_attachment_file(client, attachment): - response = client.get(attachment.get_absolute_url()) - assert response.status_code == 302 - assert response["location"].endswith("test.txt") - - -def test_proxy_redirects_client_to_attachment_image(client, image): - response = client.get(image.get_absolute_url()) - assert response.status_code == 302 - assert response["location"].endswith("test.png") - - -def test_proxy_redirects_client_to_attachment_thumbnail(client, image_with_thumbnail): - response = client.get(image_with_thumbnail.get_thumbnail_url()) - assert response.status_code == 302 - assert response["location"].endswith("test-thumbnail.png") - - -def test_proxy_redirects_to_404_image_for_nonexistant_attachment(db, client): - response = client.get( - reverse("misago:attachment", kwargs={"pk": 1, "secret": "secret"}) - ) - assert_404(response) - - -def test_proxy_redirects_to_404_image_for_url_with_invalid_attachment_secret( - client, attachment -): - response = client.get( - reverse("misago:attachment", kwargs={"pk": attachment.id, "secret": "invalid"}) - ) - assert_404(response) - - -@patch_user_acl({"can_download_other_users_attachments": False}) -def test_proxy_redirects_to_403_image_for_user_without_permission_to_see_attachment( - user_client, other_users_attachment -): - response = user_client.get(other_users_attachment.get_absolute_url()) - assert_403(response) - - -def test_thumbnail_proxy_redirects_to_404_for_non_image_attachment(client, attachment): - response = client.get( - reverse( - "misago:attachment-thumbnail", - kwargs={"pk": attachment.pk, "secret": attachment.secret}, - ) - ) - assert_404(response) - - -def test_thumbnail_proxy_redirects_to_regular_image_for_image_without_thumbnail( - client, image -): - response = client.get( - reverse( - "misago:attachment-thumbnail", - kwargs={"pk": image.pk, "secret": image.secret}, - ) - ) - assert response.status_code == 302 - assert response["location"].endswith("test.png") - - -def test_thumbnail_proxy_redirects_to_thumbnail_image(client, image_with_thumbnail): - response = client.get( - reverse( - "misago:attachment-thumbnail", - kwargs={ - "pk": image_with_thumbnail.pk, - "secret": image_with_thumbnail.secret, - }, - ) - ) - assert response.status_code == 302 - assert response["location"].endswith("test-thumbnail.png") - - -def test_proxy_blocks_user_from_their_orphaned_attachment( - user_client, orphaned_attachment -): - response = user_client.get(orphaned_attachment.get_absolute_url()) - assert_404(response) - - -def test_proxy_redirects_user_to_their_orphaned_attachment_if_link_has_shva_key( - user_client, orphaned_attachment -): - response = user_client.get("%s?shva=1" % orphaned_attachment.get_absolute_url()) - assert response.status_code == 302 - assert response["location"].endswith("test.txt") - - -def test_proxy_blocks_user_from_other_users_orphaned_attachment( - user_client, other_users_orphaned_attachment -): - response = user_client.get(other_users_orphaned_attachment.get_absolute_url()) - assert_404(response) - - -def test_proxy_blocks_user_from_other_users_orphaned_attachment_if_link_has_shva_key( - user_client, other_users_orphaned_attachment -): - response = user_client.get( - "%s?shva=1" % other_users_orphaned_attachment.get_absolute_url() - ) - assert_404(response) - - -def test_proxy_redirects_admin_to_other_users_orphaned_attachment( - admin_client, orphaned_attachment -): - response = admin_client.get("%s?shva=1" % orphaned_attachment.get_absolute_url()) - assert response.status_code == 302 - assert response["location"].endswith("test.txt") - - -def test_proxy_blocks_user_from_attachment_with_disabled_type( - user_client, attachment, attachment_type -): - attachment_type.status = AttachmentType.DISABLED - attachment_type.save() - - response = user_client.get(attachment.get_absolute_url()) - assert_403(response) - - -@pytest.fixture -def role(db): - return Role.objects.create(name="Test") - - -@pytest.fixture -def limited_attachment_type(attachment_type, role): - attachment_type.limit_downloads_to.add(role) - return attachment_type - - -def test_proxy_blocks_user_without_role_from_attachment_with_limited_type( - user_client, attachment, limited_attachment_type -): - response = user_client.get(attachment.get_absolute_url()) - assert_403(response) - - -def test_proxy_allows_user_with_role_to_download_attachment_with_limited_type( - user, user_client, role, attachment, limited_attachment_type -): - user.roles.add(role) - response = user_client.get(attachment.get_absolute_url()) - assert response.status_code == 302 - assert response["location"].endswith("test.txt") - - -def test_proxy_allows_admin_without_role_to_download_attachment_with_limited_type( - admin_client, attachment, limited_attachment_type -): - response = admin_client.get(attachment.get_absolute_url()) - assert response.status_code == 302 - assert response["location"].endswith("test.txt") - - -@override_dynamic_settings(attachment_403_image="custom-403-image.png") -@patch_user_acl({"can_download_other_users_attachments": False}) -def test_proxy_uses_custom_permission_denied_image_if_one_is_set( - user_client, other_users_attachment -): - response = user_client.get(other_users_attachment.get_absolute_url()) - assert response.status_code == 302 - assert response["location"].endswith("custom-403-image.png") - - -@override_dynamic_settings(attachment_404_image="custom-404-image.png") -def test_proxy_uses_custom_not_found_image_if_one_is_set(db, client): - response = client.get( - reverse("misago:attachment", kwargs={"pk": 1, "secret": "secret"}) - ) - assert response.status_code == 302 - assert response["location"].endswith("custom-404-image.png") diff --git a/misago/threads/tests/test_clearattachments.py b/misago/threads/tests/test_clearattachments.py deleted file mode 100644 index cf8e7a2204..0000000000 --- a/misago/threads/tests/test_clearattachments.py +++ /dev/null @@ -1,67 +0,0 @@ -from datetime import timedelta -from io import StringIO - -import pytest -from django.core import management -from django.utils import timezone - -from ...conf.test import override_dynamic_settings -from ..management.commands import clearattachments -from ..models import Attachment, AttachmentType - - -@pytest.fixture -def attachment_type(db): - return AttachmentType.objects.order_by("id").last() - - -def create_attachment(attachment_type, uploaded_on, post=None): - return Attachment.objects.create( - secret=Attachment.generate_new_secret(), - post=post, - filetype=attachment_type, - size=1000, - uploaded_on=uploaded_on, - uploader_name="User", - uploader_slug="user", - filename="testfile_%s.zip" % (Attachment.objects.count() + 1), - ) - - -def call_command(): - command = clearattachments.Command() - - out = StringIO() - management.call_command(command, stdout=out) - return out.getvalue().strip().splitlines()[-1].strip() - - -def test_command_works_if_there_are_no_attachments(db): - command_output = call_command() - assert command_output == "No unused attachments were cleared" - - -@override_dynamic_settings(unused_attachments_lifetime=2) -def test_recent_attachment_is_not_cleared(attachment_type): - attachment = create_attachment(attachment_type, timezone.now()) - command_output = call_command() - assert command_output == "No unused attachments were cleared" - - -@override_dynamic_settings(unused_attachments_lifetime=2) -def test_old_used_attachment_is_not_cleared(attachment_type, post): - uploaded_on = timezone.now() - timedelta(hours=3) - attachment = create_attachment(attachment_type, uploaded_on, post) - command_output = call_command() - assert command_output == "No unused attachments were cleared" - - -@override_dynamic_settings(unused_attachments_lifetime=2) -def test_old_unused_attachment_is_cleared(attachment_type): - uploaded_on = timezone.now() - timedelta(hours=3) - attachment = create_attachment(attachment_type, uploaded_on) - command_output = call_command() - assert command_output == "Cleared 1 attachments" - - with pytest.raises(Attachment.DoesNotExist): - attachment.refresh_from_db() diff --git a/misago/threads/tests/test_edit_private_thread_post_view.py b/misago/threads/tests/test_edit_private_thread_post_view.py index 5ce9216337..2d852ed43b 100644 --- a/misago/threads/tests/test_edit_private_thread_post_view.py +++ b/misago/threads/tests/test_edit_private_thread_post_view.py @@ -1,5 +1,10 @@ +from django.core.files.uploadedfile import SimpleUploadedFile from django.urls import reverse +from ...attachments.enums import AllowedAttachments +from ...attachments.models import Attachment +from ...conf.test import override_dynamic_settings +from ...permissions.enums import CanUploadAttachments from ...test import assert_contains, assert_not_contains from ..test import reply_thread @@ -281,6 +286,17 @@ def test_edit_private_thread_post_view_cancels_thread_post_edits_inline_in_htmx( post_original = user_private_thread.first_post.original assert_contains(response, post_original) + assert_contains( + response, + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + "post": user_private_thread.first_post_id, + }, + ), + ) post = user_private_thread.first_post post.refresh_from_db() @@ -430,3 +446,90 @@ def test_edit_private_thread_post_view_shows_error_if_thread_post_is_accessed( assert_not_contains(response, "Edit post", status_code=404) assert_not_contains(response, thread.title, status_code=404) + + +def test_edit_private_thread_post_view_displays_attachments_form( + user_client, user_private_thread +): + response = user_client.get( + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + "post": user_private_thread.first_post_id, + }, + ), + ) + assert_contains(response, "Edit post") + assert_contains(response, "misago-editor-attachments=") + + +@override_dynamic_settings(allowed_attachment_types=AllowedAttachments.NONE.value) +def test_edit_private_thread_post_view_hides_attachments_form_if_uploads_are_disabled( + user_client, user_private_thread +): + response = user_client.get( + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + "post": user_private_thread.first_post_id, + }, + ), + ) + assert_contains(response, "Edit post") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_edit_private_thread_post_view_hides_attachments_form_if_user_has_no_group_permission( + members_group, user_client, user_private_thread +): + members_group.can_upload_attachments = CanUploadAttachments.THREADS + members_group.save() + + response = user_client.get( + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + "post": user_private_thread.first_post_id, + }, + ), + ) + assert_contains(response, "Edit post") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_edit_private_thread_post_view_uploads_attachment_on_submit( + user, user_client, user_private_thread, teardown_attachments +): + assert not Attachment.objects.exists() + + response = user_client.post( + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + "post": user_private_thread.first_post_id, + }, + ), + { + "posting-post-post": "Edited post", + "posting-post-upload": [ + SimpleUploadedFile("test.txt", b"Hello world!", "text/plain"), + ], + }, + ) + assert response.status_code == 302 + + attachment = Attachment.objects.get(uploader=user) + assert attachment.category_id == user_private_thread.category_id + assert attachment.thread_id == user_private_thread.id + assert attachment.post_id == user_private_thread.first_post_id + assert attachment.uploader_id == user.id + assert not attachment.is_deleted + assert attachment.name == "test.txt" diff --git a/misago/threads/tests/test_edit_private_thread_view.py b/misago/threads/tests/test_edit_private_thread_view.py index 232ef21851..4b0e96cb72 100644 --- a/misago/threads/tests/test_edit_private_thread_view.py +++ b/misago/threads/tests/test_edit_private_thread_view.py @@ -1,5 +1,10 @@ +from django.core.files.uploadedfile import SimpleUploadedFile from django.urls import reverse +from ...attachments.enums import AllowedAttachments +from ...attachments.models import Attachment +from ...conf.test import override_dynamic_settings +from ...permissions.enums import CanUploadAttachments from ...test import assert_contains, assert_not_contains @@ -298,6 +303,27 @@ def test_edit_private_thread_view_cancels_thread_and_post_edits_inline_in_htmx( post_original = user_private_thread.first_post.original assert_contains(response, post_original) + assert_contains( + response, + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + }, + ), + ) + assert_not_contains( + response, + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + "post": user_private_thread.first_post_id, + }, + ), + ) user_private_thread.refresh_from_db() assert user_private_thread.title == "User Private Thread" @@ -466,3 +492,87 @@ def test_edit_private_thread_view_shows_error_if_thread_post_is_accessed( assert_not_contains(response, "Edit thread", status_code=404) assert_not_contains(response, thread.title, status_code=404) + + +def test_edit_private_thread_view_displays_attachments_form( + user_client, user_private_thread +): + response = user_client.get( + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + }, + ), + ) + assert_contains(response, "Edit thread") + assert_contains(response, "misago-editor-attachments=") + + +@override_dynamic_settings(allowed_attachment_types=AllowedAttachments.NONE.value) +def test_edit_private_thread_view_hides_attachments_form_if_uploads_are_disabled( + user_client, user_private_thread +): + response = user_client.get( + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + }, + ), + ) + assert_contains(response, "Edit thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_edit_private_thread_view_hides_attachments_form_if_user_has_no_group_permission( + members_group, user_client, user_private_thread +): + members_group.can_upload_attachments = CanUploadAttachments.THREADS + members_group.save() + + response = user_client.get( + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + }, + ), + ) + assert_contains(response, "Edit thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_edit_private_thread_view_uploads_attachment_on_submit( + user, user_client, user_private_thread, teardown_attachments +): + assert not Attachment.objects.exists() + + response = user_client.post( + reverse( + "misago:edit-private-thread", + kwargs={ + "id": user_private_thread.id, + "slug": user_private_thread.slug, + }, + ), + { + "posting-title-title": "Edited title", + "posting-post-post": "Edited post", + "posting-post-upload": [ + SimpleUploadedFile("test.txt", b"Hello world!", "text/plain"), + ], + }, + ) + assert response.status_code == 302 + + attachment = Attachment.objects.get(uploader=user) + assert attachment.category_id == user_private_thread.category_id + assert attachment.thread_id == user_private_thread.id + assert attachment.post_id == user_private_thread.first_post_id + assert attachment.uploader_id == user.id + assert not attachment.is_deleted + assert attachment.name == "test.txt" diff --git a/misago/threads/tests/test_edit_thread_post_view.py b/misago/threads/tests/test_edit_thread_post_view.py index 8219c1a1ec..21f05f36bc 100644 --- a/misago/threads/tests/test_edit_thread_post_view.py +++ b/misago/threads/tests/test_edit_thread_post_view.py @@ -1,6 +1,10 @@ +from django.core.files.uploadedfile import SimpleUploadedFile from django.urls import reverse -from ...permissions.enums import CategoryPermission +from ...attachments.enums import AllowedAttachments +from ...attachments.models import Attachment +from ...conf.test import override_dynamic_settings +from ...permissions.enums import CanUploadAttachments, CategoryPermission from ...permissions.models import CategoryGroupPermission from ...test import assert_contains, assert_not_contains from ..test import reply_thread @@ -419,6 +423,17 @@ def test_edit_thread_post_view_cancels_thread_post_edits_inline_in_htmx( post_original = user_thread.first_post.original assert_contains(response, post_original) + assert_contains( + response, + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + "post": user_thread.first_post_id, + }, + ), + ) post = user_thread.first_post post.refresh_from_db() @@ -570,3 +585,88 @@ def test_edit_thread_post_view_shows_error_if_private_thread_post_is_accessed( assert_not_contains(response, "Edit post", status_code=404) assert_not_contains(response, user_private_thread.title, status_code=404) + + +def test_edit_thread_post_view_displays_attachments_form(user_client, user_thread): + response = user_client.get( + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + "post": user_thread.first_post_id, + }, + ), + ) + assert_contains(response, "Edit post") + assert_contains(response, "misago-editor-attachments=") + + +@override_dynamic_settings(allowed_attachment_types=AllowedAttachments.NONE.value) +def test_edit_thread_post_view_hides_attachments_form_if_uploads_are_disabled( + user_client, user_thread +): + response = user_client.get( + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + "post": user_thread.first_post_id, + }, + ), + ) + assert_contains(response, "Edit post") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_edit_thread_post_view_hides_attachments_form_if_user_has_no_group_permission( + members_group, user_client, user_thread +): + members_group.can_upload_attachments = CanUploadAttachments.NEVER + members_group.save() + + response = user_client.get( + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + "post": user_thread.first_post_id, + }, + ), + ) + assert_contains(response, "Edit post") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_edit_thread_post_view_uploads_attachment_on_submit( + user, user_client, user_thread, teardown_attachments +): + assert not Attachment.objects.exists() + + response = user_client.post( + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + "post": user_thread.first_post_id, + }, + ), + { + "posting-post-post": "Edited post", + "posting-post-upload": [ + SimpleUploadedFile("test.txt", b"Hello world!", "text/plain"), + ], + }, + ) + assert response.status_code == 302 + + attachment = Attachment.objects.get(uploader=user) + assert attachment.category_id == user_thread.category_id + assert attachment.thread_id == user_thread.id + assert attachment.post_id == user_thread.first_post_id + assert attachment.uploader_id == user.id + assert not attachment.is_deleted + assert attachment.name == "test.txt" diff --git a/misago/threads/tests/test_edit_thread_view.py b/misago/threads/tests/test_edit_thread_view.py index fef35b3bc9..19ab05a55c 100644 --- a/misago/threads/tests/test_edit_thread_view.py +++ b/misago/threads/tests/test_edit_thread_view.py @@ -1,6 +1,10 @@ +from django.core.files.uploadedfile import SimpleUploadedFile from django.urls import reverse -from ...permissions.enums import CategoryPermission +from ...attachments.enums import AllowedAttachments +from ...attachments.models import Attachment +from ...conf.test import override_dynamic_settings +from ...permissions.enums import CanUploadAttachments, CategoryPermission from ...permissions.models import CategoryGroupPermission from ...test import assert_contains, assert_not_contains @@ -378,6 +382,27 @@ def test_edit_thread_view_cancels_thread_and_post_edits_inline_in_htmx( post_original = user_thread.first_post.original assert_contains(response, post_original) + assert_contains( + response, + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + }, + ), + ) + assert_not_contains( + response, + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + "post": user_thread.first_post_id, + }, + ), + ) user_thread.refresh_from_db() assert user_thread.title == "Test thread" @@ -520,3 +545,85 @@ def test_edit_thread_view_shows_error_if_private_thread_post_is_accessed( assert_not_contains(response, "Edit thread", status_code=404) assert_not_contains(response, user_private_thread.title, status_code=404) + + +def test_edit_thread_view_displays_attachments_form(user_client, user_thread): + response = user_client.get( + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + }, + ), + ) + assert_contains(response, "Edit thread") + assert_contains(response, "misago-editor-attachments=") + + +@override_dynamic_settings(allowed_attachment_types=AllowedAttachments.NONE.value) +def test_edit_thread_view_hides_attachments_form_if_uploads_are_disabled( + user_client, user_thread +): + response = user_client.get( + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + }, + ), + ) + assert_contains(response, "Edit thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_edit_thread_view_hides_attachments_form_if_user_has_no_group_permission( + members_group, user_client, user_thread +): + members_group.can_upload_attachments = CanUploadAttachments.NEVER + members_group.save() + + response = user_client.get( + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + }, + ), + ) + assert_contains(response, "Edit thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_edit_thread_view_uploads_attachment_on_submit( + user, user_client, user_thread, teardown_attachments +): + assert not Attachment.objects.exists() + + response = user_client.post( + reverse( + "misago:edit-thread", + kwargs={ + "id": user_thread.id, + "slug": user_thread.slug, + }, + ), + { + "posting-title-title": "Edited title", + "posting-post-post": "Edited post", + "posting-post-upload": [ + SimpleUploadedFile("test.txt", b"Hello world!", "text/plain"), + ], + }, + ) + assert response.status_code == 302 + + attachment = Attachment.objects.get(uploader=user) + assert attachment.category_id == user_thread.category_id + assert attachment.thread_id == user_thread.id + assert attachment.post_id == user_thread.first_post_id + assert attachment.uploader_id == user.id + assert not attachment.is_deleted + assert attachment.name == "test.txt" diff --git a/misago/threads/tests/test_posts_feed.py b/misago/threads/tests/test_posts_feed.py index 8e63abd5cb..a0a48c8dd7 100644 --- a/misago/threads/tests/test_posts_feed.py +++ b/misago/threads/tests/test_posts_feed.py @@ -7,9 +7,10 @@ @pytest.fixture -def request_factory(rf, cache_versions): +def request_factory(rf, dynamic_settings, cache_versions): def factory(user): request = rf.get("/") + request.settings = dynamic_settings request.user = user request.user_permissions = UserPermissionsProxy(user, cache_versions) return request @@ -28,7 +29,7 @@ def test_posts_feed_returns_post_data(request_factory, user, thread, post): assert feed_data["items"][0]["post"] == post -def test_posts_feed_embeds_poster_data_in_post( +def test_posts_feed_sets_posters_in_post_data( request_factory, user, other_user, thread, other_user_reply ): request = request_factory(user) @@ -42,6 +43,27 @@ def test_posts_feed_embeds_poster_data_in_post( assert post_data["poster_name"] == other_user.username +def test_posts_feed_sets_rich_text_data_in_post_data( + request_factory, user, thread, other_user_reply, attachment +): + attachment.category = other_user_reply.category + attachment.thread = other_user_reply.thread + attachment.post = other_user_reply + attachment.save() + + other_user_reply.metadata = {"attachments": [attachment.id]} + other_user_reply.save() + + request = request_factory(user) + + posts_feed = PostsFeed(request, thread, [other_user_reply]) + feed_data = posts_feed.get_context_data() + + post_data = feed_data["items"][0] + assert post_data["rich_text_data"]["attachment_errors"] == {} + assert post_data["rich_text_data"]["attachments"] == {attachment.id: attachment} + + def test_posts_feed_marks_post_as_animated(request_factory, user, thread, post, reply): request = request_factory(user) diff --git a/misago/threads/tests/test_prefetch_posts_related_objects.py b/misago/threads/tests/test_prefetch_posts_related_objects.py new file mode 100644 index 0000000000..eb4578184e --- /dev/null +++ b/misago/threads/tests/test_prefetch_posts_related_objects.py @@ -0,0 +1,598 @@ +from ...conf.test import override_dynamic_settings +from ...permissions.proxy import UserPermissionsProxy +from ..prefetch import prefetch_posts_related_objects + + +def test_prefetch_posts_related_objects_preloads_categories( + dynamic_settings, + cache_versions, + anonymous_user, + default_category, + sibling_category, +): + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, + permissions, + [], + categories=[default_category, sibling_category], + ) + assert data["categories"] == { + default_category.id: default_category, + sibling_category.id: sibling_category, + } + + +def test_prefetch_posts_related_objects_prefetches_threads_categories( + dynamic_settings, + cache_versions, + anonymous_user, + default_category, + thread, + user_thread, +): + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [], threads=[thread, user_thread] + ) + assert data["categories"] == {default_category.id: default_category} + + +def test_prefetch_posts_related_objects_prefetches_posts_categories( + dynamic_settings, + cache_versions, + anonymous_user, + default_category, + post, + user_reply, + other_user_reply, +): + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [post, user_reply, other_user_reply] + ) + assert data["categories"] == {default_category.id: default_category} + + +def test_prefetch_posts_related_objects_prefetches_attachments_categories( + dynamic_settings, + cache_versions, + anonymous_user, + default_category, + attachment, + user_attachment, + post, +): + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + user_attachment.category = post.category + user_attachment.thread = post.thread + user_attachment.post = post + user_attachment.save() + + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [], attachments=[attachment, user_attachment] + ) + assert data["categories"] == {default_category.id: default_category} + + +def test_prefetch_posts_related_objects_preloads_threads( + dynamic_settings, + cache_versions, + anonymous_user, + thread, + user_thread, +): + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [], threads=[thread, user_thread] + ) + assert data["threads"] == { + thread.id: thread, + user_thread.id: user_thread, + } + + +def test_prefetch_posts_related_objects_prefetches_posts_threads( + dynamic_settings, + cache_versions, + anonymous_user, + thread, + post, + user_reply, + other_user_reply, +): + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [post, user_reply, other_user_reply] + ) + assert data["threads"] == {thread.id: thread} + + +def test_prefetch_posts_related_objects_prefetches_attachments_threads( + dynamic_settings, cache_versions, anonymous_user, thread, post, attachment +): + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [], attachments=[attachment] + ) + assert data["threads"] == {thread.id: thread} + + +def test_prefetch_posts_related_objects_prefetches_private_threads_members( + dynamic_settings, + cache_versions, + anonymous_user, + user_private_thread, + django_assert_num_queries, +): + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + prefetch_posts_related_objects( + dynamic_settings, permissions, [], threads=[user_private_thread] + ) + + with django_assert_num_queries(0): + user_private_thread.private_thread_member_ids + + +def test_prefetch_posts_related_objects_preloads_posts( + dynamic_settings, + cache_versions, + anonymous_user, + post, + user_reply, +): + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [post, user_reply] + ) + assert data["posts"] == { + post.id: post, + user_reply.id: user_reply, + } + + +def test_prefetch_posts_related_objects_prefetches_attachments_posts( + dynamic_settings, + cache_versions, + anonymous_user, + post, + user_reply, + attachment, + user_attachment, +): + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + user_attachment.category = user_reply.category + user_attachment.thread = user_reply.thread + user_attachment.post = user_reply + user_attachment.save() + + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [], attachments=[attachment, user_attachment] + ) + assert data["posts"] == { + post.id: post, + user_reply.id: user_reply, + } + + +def test_prefetch_posts_related_objects_preloads_attachments( + dynamic_settings, + cache_versions, + anonymous_user, + attachment, + user_attachment, + post, +): + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + user_attachment.category = post.category + user_attachment.thread = post.thread + user_attachment.post = post + user_attachment.save() + + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [], attachments=[attachment, user_attachment] + ) + assert data["attachments"] == { + attachment.id: attachment, + user_attachment.id: user_attachment, + } + + +def test_prefetch_posts_related_objects_removes_preloaded_attachments_without_permission( + dynamic_settings, + cache_versions, + user, + attachment, + user_attachment, +): + permissions = UserPermissionsProxy(user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [], attachments=[attachment, user_attachment] + ) + assert data["attachments"] == { + user_attachment.id: user_attachment, + } + + +def test_prefetch_posts_related_objects_fetches_posts_attachments( + dynamic_settings, + cache_versions, + anonymous_user, + attachment, + user_attachment, + post, + user_reply, +): + attachment.category = post.category + attachment.thread = post.thread + attachment.post = post + attachment.save() + + user_attachment.category = user_reply.category + user_attachment.thread = user_reply.thread + user_attachment.post = user_reply + user_attachment.save() + + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [post, user_reply] + ) + assert data["attachments"] == { + attachment.id: attachment, + user_attachment.id: user_attachment, + } + + +def test_prefetch_posts_related_objects_fetches_posts_metadata_attachments( + dynamic_settings, + cache_versions, + anonymous_user, + attachment, + user_attachment, + post, + user_reply, + other_user_reply, +): + attachment.category = other_user_reply.category + attachment.thread = other_user_reply.thread + attachment.post = other_user_reply + attachment.save() + + user_attachment.category = other_user_reply.category + user_attachment.thread = other_user_reply.thread + user_attachment.post = other_user_reply + user_attachment.save() + + post.metadata["attachments"] = [attachment.id] + post.save() + + user_reply.metadata["attachments"] = [user_attachment.id] + user_reply.save() + + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [post, user_reply] + ) + assert data["attachments"] == { + attachment.id: attachment, + user_attachment.id: user_attachment, + } + + +@override_dynamic_settings(additional_embedded_attachments_limit=0) +def test_prefetch_posts_related_objects_doesnt_fetch_posts_metadata_attachments_if_its_disabled( + dynamic_settings, + cache_versions, + anonymous_user, + attachment, + user_attachment, + post, + user_reply, + other_user_reply, +): + attachment.category = other_user_reply.category + attachment.thread = other_user_reply.thread + attachment.post = other_user_reply + attachment.save() + + user_attachment.category = other_user_reply.category + user_attachment.thread = other_user_reply.thread + user_attachment.post = other_user_reply + user_attachment.save() + + post.metadata["attachments"] = [attachment.id] + post.save() + + user_reply.metadata["attachments"] = [user_attachment.id] + user_reply.save() + + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [post, user_reply] + ) + assert data["attachments"] == {} + + +@override_dynamic_settings(additional_embedded_attachments_limit=1) +def test_prefetch_posts_related_objects_fetch_posts_metadata_attachments_is_limited( + dynamic_settings, + cache_versions, + anonymous_user, + attachment, + user_attachment, + post, + user_reply, + other_user_reply, +): + attachment.category = other_user_reply.category + attachment.thread = other_user_reply.thread + attachment.post = other_user_reply + attachment.save() + + user_attachment.category = other_user_reply.category + user_attachment.thread = other_user_reply.thread + user_attachment.post = other_user_reply + user_attachment.save() + + post.metadata["attachments"] = [attachment.id] + post.save() + + user_reply.metadata["attachments"] = [user_attachment.id] + user_reply.save() + + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [post, user_reply] + ) + assert data["attachments"] == {user_attachment.id: user_attachment} + + +def test_prefetch_posts_related_objects_fetch_posts_metadata_attachments_excludes_unused_attachments( + dynamic_settings, + cache_versions, + user, + attachment, + user_attachment, + post, + user_reply, + other_user_reply, +): + attachment.category = other_user_reply.category + attachment.thread = other_user_reply.thread + attachment.post = other_user_reply + attachment.save() + + post.metadata["attachments"] = [attachment.id] + post.save() + + user_reply.metadata["attachments"] = [user_attachment.id] + user_reply.save() + + permissions = UserPermissionsProxy(user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [post, user_reply] + ) + assert data["attachments"] == { + attachment.id: attachment, + } + + +def test_prefetch_posts_related_objects_fetch_posts_metadata_attachments_excludes_inaccessible_attachments( + dynamic_settings, + cache_versions, + anonymous_user, + attachment, + user_attachment, + post, + user_reply, + other_user_reply, + private_thread, +): + attachment.category = other_user_reply.category + attachment.thread = other_user_reply.thread + attachment.post = other_user_reply + attachment.save() + + user_attachment.category = private_thread.category + user_attachment.thread = private_thread + user_attachment.post = private_thread.first_post + user_attachment.save() + + post.metadata["attachments"] = [attachment.id] + post.save() + + user_reply.metadata["attachments"] = [user_attachment.id] + user_reply.save() + + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [post, user_reply] + ) + assert data["attachments"] == { + attachment.id: attachment, + } + assert data["attachment_errors"][user_attachment.id].not_found + + +def test_prefetch_posts_related_objects_preloads_users( + dynamic_settings, + cache_versions, + anonymous_user, + user, + other_user, +): + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [], users=[user, other_user] + ) + assert data["users"] == { + user.id: user, + other_user.id: other_user, + } + + +def test_prefetch_posts_related_objects_preloads_user_from_permissions( + dynamic_settings, + cache_versions, + user, + django_assert_num_queries, +): + permissions = UserPermissionsProxy(user, cache_versions) + + data = prefetch_posts_related_objects(dynamic_settings, permissions, []) + assert data["users"] == {user.id: user} + + with django_assert_num_queries(0): + assert data["users"][user.id].group + + +def test_prefetch_posts_related_objects_doesnt_preload_anonymous_user_from_permissions( + dynamic_settings, + cache_versions, + anonymous_user, + post, +): + permissions = UserPermissionsProxy(anonymous_user, cache_versions) + + data = prefetch_posts_related_objects(dynamic_settings, permissions, [post]) + assert data["users"] == {} + + +def test_prefetch_posts_related_objects_prefetches_posts_users( + dynamic_settings, + cache_versions, + user, + other_user, + user_reply, + other_user_reply, + django_assert_num_queries, +): + permissions = UserPermissionsProxy(user, cache_versions) + + data = prefetch_posts_related_objects( + dynamic_settings, permissions, [user_reply, other_user_reply] + ) + assert data["users"] == {user.id: user, other_user.id: other_user} + + with django_assert_num_queries(0): + assert data["users"][user.id].group + assert data["users"][other_user.id].group + + +def test_prefetch_posts_related_objects_doesnt_prefetch_anonymous_posts_users( + dynamic_settings, + cache_versions, + user, + post, + django_assert_num_queries, +): + permissions = UserPermissionsProxy(user, cache_versions) + + data = prefetch_posts_related_objects(dynamic_settings, permissions, [post]) + assert data["users"] == {user.id: user} + + with django_assert_num_queries(0): + assert data["users"][user.id].group + + +def test_prefetch_posts_related_objects_prefetches_objects_in_cascade( + dynamic_settings, + cache_versions, + user, + other_user, + default_category, + private_threads_category, + thread, + post, + user_reply, + other_user_reply, + user_private_thread, + attachment, + user_attachment, + other_user_attachment, + django_assert_num_queries, +): + permissions = UserPermissionsProxy(user, cache_versions) + permissions.permissions + permissions.is_global_moderator + + attachment.category = default_category + attachment.thread = thread + attachment.post = post + attachment.save() + + other_user_attachment.category = private_threads_category + other_user_attachment.thread = user_private_thread + other_user_attachment.post = user_private_thread.first_post + other_user_attachment.save() + + user_reply.metadata["attachments"] = [user_attachment.id, other_user_attachment.id] + user_reply.save() + + with django_assert_num_queries(8): + data = prefetch_posts_related_objects( + dynamic_settings, + permissions, + [post, user_reply, other_user_reply], + ) + + assert default_category.id in data["categories"] + assert private_threads_category.id in data["categories"] + + assert thread.id in data["threads"] + assert user_private_thread.id in data["threads"] + + assert data["threads"][user_private_thread.id].private_thread_member_ids + + assert post.id in data["posts"] + assert user_reply.id in data["posts"] + assert other_user_reply.id in data["posts"] + assert user_private_thread.first_post_id in data["posts"] + + assert user.id in data["users"] + assert other_user.id in data["users"] + + assert data["users"][user.id].group + assert data["users"][other_user.id].group + + assert attachment.id in data["attachments"] + assert other_user_attachment.id in data["attachments"] diff --git a/misago/threads/tests/test_prefetch_private_thread_member_ids.py b/misago/threads/tests/test_prefetch_private_thread_member_ids.py new file mode 100644 index 0000000000..bb4cf52b0f --- /dev/null +++ b/misago/threads/tests/test_prefetch_private_thread_member_ids.py @@ -0,0 +1,19 @@ +from ..models import ThreadParticipant +from ..privatethreads import prefetch_private_thread_member_ids + + +def test_prefetch_private_thread_member_ids_sets_thread_member_ids_property( + thread, user_thread, user, other_user, django_assert_num_queries +): + ThreadParticipant.objects.create(thread=thread, user=user, is_owner=False) + ThreadParticipant.objects.create(thread=thread, user=other_user, is_owner=True) + ThreadParticipant.objects.create(thread=user_thread, user=user, is_owner=True) + ThreadParticipant.objects.create( + thread=user_thread, user=other_user, is_owner=False + ) + + with django_assert_num_queries(1): + prefetch_private_thread_member_ids([thread, user_thread]) + + assert thread.private_thread_member_ids == [other_user.id, user.id] + assert user_thread.private_thread_member_ids == [user.id, other_user.id] diff --git a/misago/threads/tests/test_reply_private_thread_view.py b/misago/threads/tests/test_reply_private_thread_view.py index 08fbab10fd..c02530fdb7 100644 --- a/misago/threads/tests/test_reply_private_thread_view.py +++ b/misago/threads/tests/test_reply_private_thread_view.py @@ -1,9 +1,13 @@ from datetime import timedelta +from django.core.files.uploadedfile import SimpleUploadedFile from django.urls import reverse from django.utils import timezone +from ...attachments.enums import AllowedAttachments +from ...attachments.models import Attachment from ...conf.test import override_dynamic_settings +from ...permissions.enums import CanUploadAttachments from ...readtracker.models import ReadCategory from ...readtracker.tracker import mark_thread_read from ...test import assert_contains, assert_not_contains @@ -677,3 +681,88 @@ def test_reply_private_thread_view_shows_error_if_thread_is_accessed( assert_not_contains(response, "Reply to thread", status_code=404) assert_not_contains(response, thread.title, status_code=404) + + +def test_reply_private_thread_view_displays_attachments_form( + user_client, other_user_private_thread +): + response = user_client.get( + reverse( + "misago:reply-private-thread", + kwargs={ + "id": other_user_private_thread.id, + "slug": other_user_private_thread.slug, + }, + ), + ) + assert_contains(response, "Reply to thread") + assert_contains(response, "misago-editor-attachments=") + + +@override_dynamic_settings(allowed_attachment_types=AllowedAttachments.NONE.value) +def test_reply_private_thread_view_hides_attachments_form_if_uploads_are_disabled( + user_client, other_user_private_thread +): + response = user_client.get( + reverse( + "misago:reply-private-thread", + kwargs={ + "id": other_user_private_thread.id, + "slug": other_user_private_thread.slug, + }, + ), + ) + assert_contains(response, "Reply to thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_reply_private_thread_view_hides_attachments_form_if_user_has_no_group_permission( + members_group, user_client, other_user_private_thread +): + members_group.can_upload_attachments = CanUploadAttachments.THREADS + members_group.save() + + response = user_client.get( + reverse( + "misago:reply-private-thread", + kwargs={ + "id": other_user_private_thread.id, + "slug": other_user_private_thread.slug, + }, + ), + ) + assert_contains(response, "Reply to thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_reply_private_thread_view_uploads_attachment_on_submit( + user, user_client, other_user_private_thread, teardown_attachments +): + assert not Attachment.objects.exists() + + response = user_client.post( + reverse( + "misago:reply-private-thread", + kwargs={ + "id": other_user_private_thread.id, + "slug": other_user_private_thread.slug, + }, + ), + { + "posting-post-post": "How's going?", + "posting-post-upload": [ + SimpleUploadedFile("test.txt", b"Hello world!", "text/plain"), + ], + }, + ) + assert response.status_code == 302 + + other_user_private_thread.refresh_from_db() + + attachment = Attachment.objects.get(uploader=user) + assert attachment.category_id == other_user_private_thread.category_id + assert attachment.thread_id == other_user_private_thread.id + assert attachment.post_id == other_user_private_thread.last_post_id + assert attachment.uploader_id == user.id + assert not attachment.is_deleted + assert attachment.name == "test.txt" diff --git a/misago/threads/tests/test_reply_thread_view.py b/misago/threads/tests/test_reply_thread_view.py index 405eb03d8c..3a6937d874 100644 --- a/misago/threads/tests/test_reply_thread_view.py +++ b/misago/threads/tests/test_reply_thread_view.py @@ -1,10 +1,13 @@ from datetime import timedelta +from django.core.files.uploadedfile import SimpleUploadedFile from django.urls import reverse from django.utils import timezone +from ...attachments.enums import AllowedAttachments +from ...attachments.models import Attachment from ...conf.test import override_dynamic_settings -from ...permissions.enums import CategoryPermission +from ...permissions.enums import CanUploadAttachments, CategoryPermission from ...permissions.models import CategoryGroupPermission from ...readtracker.models import ReadCategory from ...readtracker.tracker import mark_thread_read @@ -671,3 +674,83 @@ def test_reply_thread_view_shows_error_if_private_thread_is_accessed( assert_not_contains(response, "Reply to thread", status_code=404) assert_not_contains(response, user_private_thread.title, status_code=404) + + +def test_reply_thread_view_displays_attachments_form(user_client, thread): + response = user_client.get( + reverse( + "misago:reply-thread", + kwargs={ + "id": thread.id, + "slug": thread.slug, + }, + ), + ) + assert_contains(response, "Reply to thread") + assert_contains(response, "misago-editor-attachments=") + + +@override_dynamic_settings(allowed_attachment_types=AllowedAttachments.NONE.value) +def test_reply_thread_view_hides_attachments_form_if_uploads_are_disabled( + user_client, thread +): + response = user_client.get( + reverse( + "misago:reply-thread", + kwargs={ + "id": thread.id, + "slug": thread.slug, + }, + ), + ) + assert_contains(response, "Reply to thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_reply_thread_view_hides_attachments_form_if_user_has_no_group_permission( + members_group, user_client, thread +): + members_group.can_upload_attachments = CanUploadAttachments.NEVER + members_group.save() + + response = user_client.get( + reverse( + "misago:reply-thread", + kwargs={ + "id": thread.id, + "slug": thread.slug, + }, + ), + ) + assert_contains(response, "Reply to thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_reply_thread_view_uploads_attachment_on_submit( + user, user_client, thread, teardown_attachments +): + assert not Attachment.objects.exists() + + response = user_client.post( + reverse( + "misago:reply-thread", + kwargs={"id": thread.id, "slug": thread.slug}, + ), + { + "posting-post-post": "How's going?", + "posting-post-upload": [ + SimpleUploadedFile("test.txt", b"Hello world!", "text/plain"), + ], + }, + ) + assert response.status_code == 302 + + thread.refresh_from_db() + + attachment = Attachment.objects.get(uploader=user) + assert attachment.category_id == thread.category_id + assert attachment.thread_id == thread.id + assert attachment.post_id == thread.last_post_id + assert attachment.uploader_id == user.id + assert not attachment.is_deleted + assert attachment.name == "test.txt" diff --git a/misago/threads/tests/test_start_private_thread_view.py b/misago/threads/tests/test_start_private_thread_view.py index c8e2ad4e3b..958cc15623 100644 --- a/misago/threads/tests/test_start_private_thread_view.py +++ b/misago/threads/tests/test_start_private_thread_view.py @@ -1,6 +1,11 @@ +from django.core.files.uploadedfile import SimpleUploadedFile from django.urls import reverse -from ...test import assert_contains +from ...attachments.enums import AllowedAttachments +from ...attachments.models import Attachment +from ...conf.test import override_dynamic_settings +from ...permissions.enums import CanUploadAttachments +from ...test import assert_contains, assert_not_contains from ..models import Thread @@ -130,3 +135,61 @@ def test_start_private_thread_view_runs_flood_control( assert_contains( response, "You can't post a new message so soon after the previous one." ) + + +def test_start_private_thread_view_displays_attachments_form(user_client): + response = user_client.get(reverse("misago:start-private-thread")) + assert_contains(response, "Start new private thread") + assert_contains(response, "misago-editor-attachments=") + + +@override_dynamic_settings(allowed_attachment_types=AllowedAttachments.NONE.value) +def test_start_private_thread_view_hides_attachments_form_if_uploads_are_disabled( + user_client, default_category +): + response = user_client.get(reverse("misago:start-private-thread")) + assert_contains(response, "Start new private thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_start_private_thread_view_hides_attachments_form_if_user_has_no_group_permission( + members_group, user_client +): + members_group.can_upload_attachments = CanUploadAttachments.THREADS + members_group.save() + + response = user_client.get(reverse("misago:start-private-thread")) + assert_contains(response, "Start new private thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_start_private_thread_view_uploads_attachment_on_submit( + user, other_user, user_client, teardown_attachments +): + assert not Attachment.objects.exists() + + response = user_client.post( + reverse("misago:start-private-thread"), + { + "posting-invite-users-users": other_user.username, + "posting-title-title": "Hello world", + "posting-post-post": "How's going?", + "posting-post-upload": [ + SimpleUploadedFile("test.txt", b"Hello world!", "text/plain"), + ], + }, + ) + assert response.status_code == 302 + + thread = Thread.objects.get(slug="hello-world") + assert response["location"] == reverse( + "misago:private-thread", kwargs={"id": thread.pk, "slug": thread.slug} + ) + + attachment = Attachment.objects.get(uploader=user) + assert attachment.category_id == thread.category_id + assert attachment.thread_id == thread.id + assert attachment.post_id == thread.first_post_id + assert attachment.uploader_id == user.id + assert not attachment.is_deleted + assert attachment.name == "test.txt" diff --git a/misago/threads/tests/test_start_thread_view.py b/misago/threads/tests/test_start_thread_view.py index 576b2afad3..c333dabb32 100644 --- a/misago/threads/tests/test_start_thread_view.py +++ b/misago/threads/tests/test_start_thread_view.py @@ -1,8 +1,12 @@ +from django.core.files.uploadedfile import SimpleUploadedFile from django.urls import reverse -from ...permissions.enums import CategoryPermission +from ...attachments.enums import AllowedAttachments +from ...attachments.models import Attachment +from ...conf.test import override_dynamic_settings +from ...permissions.enums import CanUploadAttachments, CategoryPermission from ...permissions.models import CategoryGroupPermission -from ...test import assert_contains +from ...test import assert_contains, assert_not_contains from ..models import Thread @@ -223,3 +227,97 @@ def test_start_thread_view_runs_flood_control( assert_contains( response, "You can't post a new message so soon after the previous one." ) + + +def test_start_thread_view_displays_attachments_form(user_client, default_category): + response = user_client.get( + reverse( + "misago:start-thread", + kwargs={"id": default_category.id, "slug": default_category.slug}, + ), + ) + assert_contains(response, "Start new thread") + assert_contains(response, "misago-editor-attachments=") + + +def test_start_thread_view_hides_attachments_form_if_user_has_no_category_permission( + members_group, user_client, default_category +): + CategoryGroupPermission.objects.filter( + category=default_category, + group=members_group, + permission=CategoryPermission.ATTACHMENTS, + ).delete() + + response = user_client.get( + reverse( + "misago:start-thread", + kwargs={"id": default_category.id, "slug": default_category.slug}, + ), + ) + assert_contains(response, "Start new thread") + assert_not_contains(response, "misago-editor-attachments=") + + +@override_dynamic_settings(allowed_attachment_types=AllowedAttachments.NONE.value) +def test_start_thread_view_hides_attachments_form_if_uploads_are_disabled( + user_client, default_category +): + response = user_client.get( + reverse( + "misago:start-thread", + kwargs={"id": default_category.id, "slug": default_category.slug}, + ), + ) + assert_contains(response, "Start new thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_start_thread_view_hides_attachments_form_if_user_has_no_group_permission( + members_group, user_client, default_category +): + members_group.can_upload_attachments = CanUploadAttachments.NEVER + members_group.save() + + response = user_client.get( + reverse( + "misago:start-thread", + kwargs={"id": default_category.id, "slug": default_category.slug}, + ), + ) + assert_contains(response, "Start new thread") + assert_not_contains(response, "misago-editor-attachments=") + + +def test_start_thread_view_uploads_attachment_on_submit( + user, user_client, default_category, teardown_attachments +): + assert not Attachment.objects.exists() + + response = user_client.post( + reverse( + "misago:start-thread", + kwargs={"id": default_category.id, "slug": default_category.slug}, + ), + { + "posting-title-title": "Hello world", + "posting-post-post": "How's going?", + "posting-post-upload": [ + SimpleUploadedFile("test.txt", b"Hello world!", "text/plain"), + ], + }, + ) + assert response.status_code == 302 + + thread = Thread.objects.get(slug="hello-world") + assert response["location"] == reverse( + "misago:thread", kwargs={"id": thread.pk, "slug": thread.slug} + ) + + attachment = Attachment.objects.get(uploader=user) + assert attachment.category_id == thread.category_id + assert attachment.thread_id == thread.id + assert attachment.post_id == thread.first_post_id + assert attachment.uploader_id == user.id + assert not attachment.is_deleted + assert attachment.name == "test.txt" diff --git a/misago/threads/tests/test_thread_model.py b/misago/threads/tests/test_thread_model.py index dacea62519..c76689b257 100644 --- a/misago/threads/tests/test_thread_model.py +++ b/misago/threads/tests/test_thread_model.py @@ -409,11 +409,26 @@ def test_delete_private_thread(self): Thread.objects.get(id=self.thread.id) -def test_thread_participants_ids_property_returns_list_of_participants_users_ids( +def test_thread_private_thread_member_ids_property_returns_list_of_private_thread_member_ids( thread, user, other_user ): ThreadParticipant.objects.create(thread=thread, user=user, is_owner=False) ThreadParticipant.objects.create(thread=thread, user=other_user, is_owner=True) - participants_ids = list(thread.participants_ids) - assert participants_ids == [other_user.id, user.id] + private_thread_member_ids = list(thread.private_thread_member_ids) + assert private_thread_member_ids == [other_user.id, user.id] + + +def test_thread_private_thread_owner_id_property_returns_id_of_private_thread_owner( + thread, user, other_user +): + ThreadParticipant.objects.create(thread=thread, user=user, is_owner=False) + ThreadParticipant.objects.create(thread=thread, user=other_user, is_owner=True) + + assert thread.private_thread_owner_id == other_user.id + + +def test_thread_private_thread_owner_id_property_returns_none_if_thread_has_no_members( + thread, +): + assert thread.private_thread_owner_id is None diff --git a/misago/threads/tests/test_threads_editor_api.py b/misago/threads/tests/test_threads_editor_api.py index 7299d2acb0..83765c39e9 100644 --- a/misago/threads/tests/test_threads_editor_api.py +++ b/misago/threads/tests/test_threads_editor_api.py @@ -541,27 +541,7 @@ def test_edit_first_post_hidden(self): @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( @@ -573,13 +553,6 @@ def test_edit(self): "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, - ], + "attachments": [], }, ) diff --git a/misago/threads/urls/__init__.py b/misago/threads/urls/__init__.py index 170862e2f8..694765874f 100644 --- a/misago/threads/urls/__init__.py +++ b/misago/threads/urls/__init__.py @@ -2,7 +2,6 @@ from ...conf import settings -from ..views.attachment import attachment_server from ..views.edit import ( edit_private_thread, edit_private_thread_post, @@ -178,17 +177,3 @@ path("c///subscribed/", redirect_subscribed_to_watched), path("private-threads/subscribed/", redirect_subscribed_to_watched), ] - -urlpatterns += [ - path( - "a///", - attachment_server, - name="attachment", - ), - path( - "a/thumb///", - attachment_server, - name="attachment-thumbnail", - kwargs={"thumbnail": True}, - ), -] diff --git a/misago/threads/urls/api.py b/misago/threads/urls/api.py index d54cab474f..be69d87a79 100644 --- a/misago/threads/urls/api.py +++ b/misago/threads/urls/api.py @@ -1,13 +1,10 @@ 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[^/.]+)/posts", ThreadPostsViewSet, basename="thread-post" diff --git a/misago/threads/views/attachment.py b/misago/threads/views/attachment.py deleted file mode 100644 index 20b3317916..0000000000 --- a/misago/threads/views/attachment.py +++ /dev/null @@ -1,64 +0,0 @@ -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() diff --git a/misago/threads/views/edit.py b/misago/threads/views/edit.py index f68d441c61..d15623a9fe 100644 --- a/misago/threads/views/edit.py +++ b/misago/threads/views/edit.py @@ -13,7 +13,7 @@ check_edit_private_thread_permission, ) from ...permissions.threads import ( - check_edit_post_permission, + check_edit_thread_post_permission, check_edit_thread_permission, ) from ...posting.formsets import ( @@ -38,6 +38,7 @@ get_edit_thread_post_page_context_data_hook, ) from ..models import Post, Thread +from ..prefetch import prefetch_posts_related_objects from .redirect import private_thread_post_redirect, thread_post_redirect from .generic import PrivateThreadView, ThreadView @@ -47,7 +48,8 @@ class EditView(View): template_name_htmx: str template_name_inline: str = "misago/inline_edit/index.html" template_name_inline_form: str = "misago/inline_edit/form.html" - post_select_related: Iterable[str] = ("thread", "category", "poster") + post_select_related: Iterable[str] = ("poster",) + allow_edit_thread: bool = False def get( self, request: HttpRequest, id: int, slug: str, post: int | None = None @@ -71,8 +73,13 @@ def post( formset = self.get_formset(request, post_obj) formset.update_state(state) - if request.POST.get("preview"): - return self.render(request, post_obj, formset, state.post.parsed) + if formset.is_request_preview(request): + formset.clear_errors_in_preview() + return self.render(request, post_obj, formset, state) + + if formset.is_request_upload(request): + formset.clear_errors_in_upload() + return self.render(request, post_obj, formset) if not self.is_valid(formset, state): return self.render(request, post_obj, formset) @@ -104,15 +111,19 @@ def post_inline_edit( ) -> HttpResponse: feed = self.get_posts_feed(request, state.thread, [state.post]) + if self.allow_edit_thread: + feed.set_allow_edit_thread(True) + if animate: feed.set_animated_posts([state.post.id]) - counter_start = ( - self.get_thread_posts_queryset(request, state.thread) - .filter(id__lt=state.post.id) - .count() - ) - feed.set_counter_start(counter_start) + if state.post.id != state.thread.first_post_id: + counter_start = ( + self.get_thread_posts_queryset(request, state.thread) + .filter(id__lt=state.post.id) + .count() + ) + feed.set_counter_start(counter_start) post_context = feed.get_feed_data()[0] return render(request, self.template_name_inline, context=post_context) @@ -131,10 +142,23 @@ def render( request: HttpRequest, post: Post, formset: PostingFormset, - preview: str | None = None, + preview: PostingState | None = None, ): context = self.get_context_data(request, post, formset) - context["preview"] = preview + + if preview: + related_objects = prefetch_posts_related_objects( + request.settings, + request.user_permissions, + [preview.post], + categories=[post.category], + threads=[post.thread], + users=[post.poster], + attachments=preview.attachments, + ) + + context["preview"] = preview.post.parsed + context["preview_rich_text_data"] = related_objects if self.is_inline(request): template_name = self.template_name_inline_form @@ -175,7 +199,7 @@ def get_thread_post( self, request: HttpRequest, thread: Thread, post_id: int ) -> Post: post = super().get_thread_post(request, thread, post_id) - check_edit_post_permission( + check_edit_thread_post_permission( request.user_permissions, post.category, post.thread, post ) return post @@ -234,6 +258,7 @@ def get_redirect_url(self, request: HttpRequest, thread: Thread, post: Post) -> class EditThreadView(EditThreadPostView): template_name: str = "misago/edit_thread/index.html" template_name_htmx: str = "misago/edit_thread/form.html" + allow_edit_thread: bool = True def get_thread(self, request: HttpRequest, thread_id: int) -> Thread: thread = super().get_thread(request, thread_id) @@ -254,6 +279,7 @@ def get_context_data( class EditPrivateThreadView(EditPrivateThreadPostView): template_name: str = "misago/edit_private_thread/index.html" template_name_htmx: str = "misago/edit_private_thread/form.html" + allow_edit_thread: bool = True def get_thread(self, request: HttpRequest, thread_id: int) -> Thread: thread = super().get_thread(request, thread_id) diff --git a/misago/threads/views/generic.py b/misago/threads/views/generic.py index 119b17a39b..87731b4eef 100644 --- a/misago/threads/views/generic.py +++ b/misago/threads/views/generic.py @@ -26,6 +26,7 @@ class GenericView(View): thread_select_related: Iterable[str] | True | None = None thread_annotate_read_time: bool = False thread_url_name: str + post_select_related: Iterable[str] | True | None = None def get_thread(self, request: HttpRequest, thread_id: int) -> Thread: queryset = self.get_thread_queryset(request) @@ -50,6 +51,11 @@ def get_thread_post( self, request: HttpRequest, thread: Thread, post_id: int ) -> Post: queryset = self.get_thread_posts_queryset(request, thread) + if self.post_select_related is True: + queryset = queryset.select_related() + elif self.post_select_related: + queryset = queryset.select_related(*self.post_select_related) + post = get_object_or_404(queryset, id=post_id) if self.thread_select_related and ( diff --git a/misago/threads/views/list.py b/misago/threads/views/list.py index f6fbffdd81..b62221b082 100644 --- a/misago/threads/views/list.py +++ b/misago/threads/views/list.py @@ -4,7 +4,7 @@ from django.contrib import messages from django.contrib.auth import get_user_model -from django.core.exceptions import PermissionDenied, ValidationError +from django.core.exceptions import ValidationError from django.db import transaction from django.http import Http404, HttpRequest from django.http.response import HttpResponse @@ -41,6 +41,7 @@ ) from ...pagination.redirect import redirect_to_last_page from ...permissions.categories import check_browse_category_permission +from ...permissions.checkutils import check_permissions from ...permissions.enums import CategoryPermission from ...permissions.privatethreads import ( check_private_threads_permission, @@ -1455,13 +1456,14 @@ def get_pagination_url(self, kwargs: dict) -> str: return reverse("misago:private-threads") def get_start_thread_url(self, request: HttpRequest) -> str | None: - try: + with check_permissions() as can_start_thread: check_start_private_threads_permission(request.user_permissions) - except (Http404, PermissionDenied): - return None - else: + + if can_start_thread: return reverse("misago:start-private-thread") + return None + def poll_new_threads(self, request: HttpRequest, kwargs: dict) -> HttpResponse: category = self.get_category(request, kwargs) diff --git a/misago/threads/views/replies.py b/misago/threads/views/replies.py index a0340ef366..8512490827 100644 --- a/misago/threads/views/replies.py +++ b/misago/threads/views/replies.py @@ -3,8 +3,8 @@ from django.core.exceptions import PermissionDenied from django.contrib.auth import get_user_model -from django.db.models import QuerySet, prefetch_related_objects -from django.http import Http404, HttpRequest, HttpResponse +from django.db.models import QuerySet +from django.http import HttpRequest, HttpResponse from django.shortcuts import redirect, render from django.urls import reverse from django.views import View @@ -12,6 +12,7 @@ from ...categories.models import Category from ...core.exceptions import OutdatedSlug from ...notifications.threads import update_watched_thread_read_time +from ...permissions.checkutils import check_permissions from ...permissions.privatethreads import ( check_edit_private_thread_permission, check_reply_private_thread_permission, @@ -257,13 +258,12 @@ def allow_edit_thread(self, request: HttpRequest, thread: Thread) -> bool: if request.user.is_anonymous: return False - try: + with check_permissions() as can_edit_thread: check_edit_thread_permission( request.user_permissions, thread.category, thread ) - return True - except (Http404, PermissionDenied): - return False + + return can_edit_thread def is_category_read( self, @@ -327,11 +327,10 @@ def allow_edit_thread(self, request: HttpRequest, thread: Thread) -> bool: if request.user.is_anonymous: return False - try: + with check_permissions() as can_edit_thread: check_edit_private_thread_permission(request.user_permissions, thread) - return True - except (Http404, PermissionDenied): - return False + + return can_edit_thread def update_thread_read_time( self, diff --git a/misago/threads/views/reply.py b/misago/threads/views/reply.py index 152b8c12c0..de2fc08fd9 100644 --- a/misago/threads/views/reply.py +++ b/misago/threads/views/reply.py @@ -1,8 +1,7 @@ from datetime import datetime, timedelta from django.contrib import messages -from django.core.exceptions import PermissionDenied -from django.http import Http404, HttpRequest, HttpResponse +from django.http import HttpRequest, HttpResponse from django.shortcuts import render from django.urls import reverse from django.utils import timezone @@ -12,12 +11,13 @@ from ...auth.decorators import login_required from ...categories.models import Category from ...htmx.response import htmx_redirect +from ...permissions.checkutils import check_permissions from ...permissions.privatethreads import ( check_edit_private_thread_post_permission, check_reply_private_thread_permission, ) from ...permissions.threads import ( - check_edit_post_permission, + check_edit_thread_post_permission, check_reply_thread_permission, ) from ...posting.formsets import ( @@ -47,6 +47,7 @@ get_reply_thread_page_context_data_hook, ) from ..models import Post, Thread +from ..prefetch import prefetch_posts_related_objects from .redirect import private_thread_post_redirect, thread_post_redirect from .generic import PrivateThreadView, ThreadView @@ -65,18 +66,23 @@ def get(self, request: HttpRequest, id: int, slug: str) -> HttpResponse: def post(self, request: HttpRequest, id: int, slug: str) -> HttpResponse: thread = self.get_thread(request, id) + formset = self.get_formset(request, thread) - if not request.POST.get("preview"): + if not formset.is_request_preview(request): last_post = self.get_last_post(request, thread) else: last_post = None state = self.get_state(request, thread, last_post) - formset = self.get_formset(request, thread) formset.update_state(state) - if request.POST.get("preview"): - return self.render(request, thread, formset, state.post.parsed) + if formset.is_request_preview(request): + formset.clear_errors_in_preview() + return self.render(request, thread, formset, state) + + if formset.is_request_upload(request): + formset.clear_errors_in_upload() + return self.render(request, thread, formset) if not self.is_valid(formset, state): return self.render(request, thread, formset) @@ -200,15 +206,27 @@ def render( request: HttpRequest, thread: Thread, formset: PostingFormset, - preview: str | None = None, + preview: PostingState | None = None, feed: list[dict] | None = None, htmx_swap: bool = False, ): context = self.get_context_data(request, thread, formset) - context["preview"] = preview context["new_feed"] = feed context["htmx_swap"] = htmx_swap + if preview: + related_objects = prefetch_posts_related_objects( + request.settings, + request.user_permissions, + [preview.post], + categories=[thread.category], + threads=[thread], + attachments=preview.attachments, + ) + + context["preview"] = preview.post.parsed + context["preview_rich_text_data"] = related_objects + if self.is_quick_reply(request): template_name = self.template_name_quick_reply elif request.is_htmx: @@ -260,15 +278,16 @@ def get_thread(self, request: HttpRequest, thread_id: int) -> Thread: return thread def get_last_post(self, request: HttpRequest, thread: Thread) -> Post | None: - try: - last_post = super().get_last_post(request, thread) - if last_post: - check_edit_post_permission( + if last_post := super().get_last_post(request, thread): + with check_permissions() as can_edit_post: + check_edit_thread_post_permission( request.user_permissions, thread.category, thread, last_post ) - return last_post - except (Http404, PermissionDenied): - return None + + if can_edit_post: + return last_post + + return None def get_state( self, request: HttpRequest, thread: Thread, post: Post | None @@ -313,15 +332,16 @@ def get_thread(self, request: HttpRequest, thread_id: int) -> Thread: return thread def get_last_post(self, request: HttpRequest, thread: Thread) -> Post | None: - try: - last_post = super().get_last_post(request, thread) - if last_post: + if last_post := super().get_last_post(request, thread): + with check_permissions() as can_edit_post: check_edit_private_thread_post_permission( request.user_permissions, thread.category, last_post ) - return last_post - except (Http404, PermissionDenied): - return None + + if can_edit_post: + return last_post + + return None def get_state( self, request: HttpRequest, thread: Thread, post: Post | None diff --git a/misago/threads/views/selectcategory.py b/misago/threads/views/selectcategory.py index 3849d70dad..4f2ac39301 100644 --- a/misago/threads/views/selectcategory.py +++ b/misago/threads/views/selectcategory.py @@ -1,11 +1,12 @@ from django.core.exceptions import PermissionDenied -from django.http import Http404, HttpRequest, HttpResponse +from django.http import HttpRequest, HttpResponse from django.views import View from django.shortcuts import render from django.urls import reverse from django.utils.translation import pgettext from ...categories.models import Category +from ...permissions.checkutils import check_permissions from ...permissions.threads import check_start_thread_permission @@ -38,12 +39,8 @@ def get_category_choices(self, request: HttpRequest) -> list[dict]: choices: list[dict] = [] for category in queryset: - try: + with check_permissions() as has_permission: check_start_thread_permission(request.user_permissions, category) - except (Http404, PermissionDenied): - has_permission = False - else: - has_permission = True choice = { "id": category.id, diff --git a/misago/threads/views/start.py b/misago/threads/views/start.py index b2e0e45900..ce8ec4ad6e 100644 --- a/misago/threads/views/start.py +++ b/misago/threads/views/start.py @@ -33,6 +33,7 @@ get_start_thread_page_context_data_hook, ) from ..models import Thread +from ..prefetch import prefetch_posts_related_objects class StartThreadView(View): @@ -57,10 +58,13 @@ def post(self, request: HttpRequest, **kwargs) -> HttpResponse: formset = self.get_formset(request, category) formset.update_state(state) - if request.POST.get("preview"): - context = self.get_context_data(request, category, formset) - context["preview"] = state.post.parsed + if formset.is_request_preview(request): + formset.clear_errors_in_preview() + return self.preview(request, category, formset, state) + if formset.is_request_upload(request): + context = self.get_context_data(request, category, formset) + formset.clear_errors_in_upload() return render(request, self.template_name, context) if not self.is_valid(formset, state): @@ -77,6 +81,30 @@ def post(self, request: HttpRequest, **kwargs) -> HttpResponse: thread_url = self.get_thread_url(request, state.thread) return redirect(thread_url) + def preview( + self, + request: HttpRequest, + category: Category, + formset: StartThreadFormset, + state: StartThreadState, + ) -> HttpResponse: + formset.clear_errors_in_preview() + + context = self.get_context_data(request, category, formset) + + related_objects = prefetch_posts_related_objects( + request.settings, + request.user_permissions, + [state.post], + categories=[category], + attachments=state.attachments, + ) + + context["preview"] = state.post.parsed + context["preview_rich_text_data"] = related_objects + + return render(request, self.template_name, context) + def get_category(self, request: HttpRequest, kwargs: dict) -> Category: try: category = Category.objects.get( diff --git a/misago/urls.py b/misago/urls.py index 36bc84ce79..62d9ac12dc 100644 --- a/misago/urls.py +++ b/misago/urls.py @@ -15,6 +15,7 @@ path("", include("misago.legal.urls")), path("", include("misago.users.urls")), path("account/", include("misago.account.urls")), + path("", include("misago.attachments.urls")), path("", include("misago.categories.urls")), path("", include("misago.threads.urls")), path("", include("misago.notifications.urls")), diff --git a/misago/users/migrations/0027_new_permissions.py b/misago/users/migrations/0027_new_permissions.py index 94a37dcf67..66454dd3ab 100644 --- a/misago/users/migrations/0027_new_permissions.py +++ b/misago/users/migrations/0027_new_permissions.py @@ -42,6 +42,17 @@ class Migration(migrations.Migration): ("can_use_private_threads", models.BooleanField(default=False)), ("can_start_private_threads", models.BooleanField(default=False)), ("private_thread_users_limit", models.PositiveIntegerField(default=1)), + ("can_upload_attachments", models.PositiveIntegerField(default=0)), + ("attachment_storage_limit", models.PositiveIntegerField(default=512)), + ( + "unused_attachments_storage_limit", + models.PositiveIntegerField(default=64), + ), + ("attachment_size_limit", models.PositiveIntegerField(default=1000)), + ( + "can_always_delete_own_attachments", + models.BooleanField(default=False), + ), ("can_change_username", models.BooleanField(default=False)), ("username_changes_limit", models.PositiveIntegerField(default=0)), ("username_changes_expire", models.PositiveIntegerField(default=0)), diff --git a/misago/users/migrations/0028_default_groups.py b/misago/users/migrations/0028_default_groups.py index 7af3a81dcd..9a07f9ba98 100644 --- a/misago/users/migrations/0028_default_groups.py +++ b/misago/users/migrations/0028_default_groups.py @@ -2,6 +2,7 @@ from django.db import migrations +from ...permissions.enums import CanUploadAttachments from ...permissions.permissionsid import get_permissions_id from ..enums import CUSTOM_GROUP_ID_START, DefaultGroupId @@ -33,6 +34,11 @@ def create_default_groups(apps, schema_editor): can_use_private_threads=True, can_start_private_threads=True, private_thread_users_limit=20, + can_upload_attachments=CanUploadAttachments.EVERYWHERE, + attachment_size_limit=0, + attachment_storage_limit=3 * 1024, + unused_attachments_storage_limit=128, + can_always_delete_own_attachments=True, can_change_username=True, can_see_user_profiles=True, ), @@ -55,6 +61,11 @@ def create_default_groups(apps, schema_editor): can_use_private_threads=True, can_start_private_threads=True, private_thread_users_limit=20, + can_upload_attachments=CanUploadAttachments.EVERYWHERE, + attachment_size_limit=0, + attachment_storage_limit=3 * 1024, + unused_attachments_storage_limit=64, + can_always_delete_own_attachments=True, can_change_username=True, can_see_user_profiles=True, ), @@ -73,6 +84,11 @@ def create_default_groups(apps, schema_editor): can_use_private_threads=True, can_start_private_threads=True, private_thread_users_limit=5, + can_upload_attachments=CanUploadAttachments.EVERYWHERE, + attachment_size_limit=5 * 1024, + attachment_storage_limit=3 * 1024, + unused_attachments_storage_limit=40, + can_always_delete_own_attachments=True, can_change_username=True, username_changes_limit=5, username_changes_expire=4, diff --git a/misago/users/models/group.py b/misago/users/models/group.py index 138735807c..dff964a60f 100644 --- a/misago/users/models/group.py +++ b/misago/users/models/group.py @@ -22,16 +22,20 @@ class Group(PluginDataModel): can_edit_own_threads = models.BooleanField(default=False) own_threads_edit_time_limit = models.PositiveIntegerField(default=0) - can_edit_own_posts = models.BooleanField(default=False) own_posts_edit_time_limit = models.PositiveIntegerField(default=0) - exempt_from_flood_control = models.BooleanField(default=False) can_use_private_threads = models.BooleanField(default=False) can_start_private_threads = models.BooleanField(default=False) private_thread_users_limit = models.PositiveIntegerField(default=1) + can_upload_attachments = models.PositiveIntegerField(default=0) + attachment_storage_limit = models.PositiveIntegerField(default=512) + unused_attachments_storage_limit = models.PositiveIntegerField(default=64) + attachment_size_limit = models.PositiveIntegerField(default=1000) + can_always_delete_own_attachments = models.BooleanField(default=False) + can_change_username = models.BooleanField(default=False) username_changes_limit = models.PositiveIntegerField(default=0) username_changes_expire = models.PositiveIntegerField(default=0)

    •  {% trans "Group" context "admin groups list" %}{% translate "Group" context "admin groups list" %}  {% trans "User title" context "admin groups list" %}{% trans "Icon" context "admin groups list" %}{% trans "CSS suffix" context "admin groups list" %}{% trans "Members" context "admin groups list" %}{% translate "User title" context "admin groups list" %}{% translate "Icon" context "admin groups list" %}{% translate "CSS suffix" context "admin groups list" %}{% translate "Members" context "admin groups list" %}       {% if item.is_admin %} - - {% trans "Admin" context "admin rank is admin status" %} + + {% translate "Admin" context "admin rank is admin status" %} {% endif %} {% if item.is_default %} - - {% trans "Default" context "admin rank is default status" %} + + {% translate "Default" context "admin rank is default status" %} {% endif %} {% if item.is_page %} - - {% trans "Page" context "admin rank is default status" %} + + {% translate "Page" context "admin rank is default status" %} {% endif %} {% if item.is_hidden %} - - {% trans "Hidden" context "admin rank is default status" %} + + {% translate "Hidden" context "admin rank is default status" %} {% endif %} {% if item.is_protected %} - - {% trans "Protected" context "admin rank is default status" %} + + {% translate "Protected" context "admin rank is default status" %} {% endif %} - + - +  {% trans "Moderator" context "admin moderators list" %}{% translate "Moderator" context "admin moderators list" %}       {% if item.group %} - + {% else %} - {% trans 'Avatar' context 'admin user avatar' %} + {% translate 'Avatar' context 'admin user avatar' %} {% endif %} {% if item.is_global %} - - {% trans "Global" context "admin moderators admin global status" %} + + {% translate "Global" context "admin moderators admin global status" %} {% endif %} {% if item.is_protected %} - - {% trans "Protected" context "admin moderators admin protected status" %} + + {% translate "Protected" context "admin moderators admin protected status" %} {% endif %}