id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
18,200
|
get_thread_posts_feed_item_user_ids.py
|
rafalp_Misago/misago/threads/hooks/get_thread_posts_feed_item_user_ids.py
|
from typing import Protocol
from django.http import HttpRequest
from ...plugins.hooks import ActionHook
class GetThreadPostsFeedItemUserIDsHookAction(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 GetThreadPostsFeedItemUserIDsHook(
ActionHook[GetThreadPostsFeedItemUserIDsHookAction]
):
"""
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_thread_posts_feed_item_user_ids_hook
@get_thread_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_thread_posts_feed_item_user_ids_hook = GetThreadPostsFeedItemUserIDsHook()
| 1,685
|
Python
|
.py
| 50
| 27.54
| 80
| 0.66026
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,201
|
get_thread_replies_page_thread_queryset.py
|
rafalp_Misago/misago/threads/hooks/get_thread_replies_page_thread_queryset.py
|
from typing import Protocol
from django.db.models import QuerySet
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
class GetThreadRepliesPageThreadQuerysetHookAction(Protocol):
"""
A standard Misago function used to get a queryset used to get a thread for
the thread replies page.
# Arguments
## `request: HttpRequest`
The request object.
# Return value
A `QuerySet` instance to use in the `get_object_or_404` call.
"""
def __call__(self, request: HttpRequest) -> QuerySet: ...
class GetThreadRepliesPageThreadQuerysetHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetThreadRepliesPageThreadQuerysetHookAction`
A standard Misago function used to get a queryset used to get a thread for
the thread replies page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
# Return value
A `QuerySet` instance to use in the `get_object_or_404` call.
"""
def __call__(
self,
action: GetThreadRepliesPageThreadQuerysetHookAction,
request: HttpRequest,
) -> QuerySet: ...
class GetThreadRepliesPageThreadQuerysetHook(
FilterHook[
GetThreadRepliesPageThreadQuerysetHookAction,
GetThreadRepliesPageThreadQuerysetHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get a queryset
used to get a thread for the thread replies page.
# Example
The code below implements a custom filter function that joins plugin's table
with `select_related`:
```python
from django.http import HttpRequest
from misago.threads.hooks import get_thread_replies_page_thread_queryset_hook
@get_thread_replies_page_thread_queryset_hook.append_filter
def select_related_plugin_data(action, request: HttpRequest):
queryset = action(request)
return queryset.select_related("plugin")
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetThreadRepliesPageThreadQuerysetHookAction,
request: HttpRequest,
) -> dict:
return super().__call__(action, request)
get_thread_replies_page_thread_queryset_hook = GetThreadRepliesPageThreadQuerysetHook()
| 2,373
|
Python
|
.py
| 62
| 32.629032
| 87
| 0.724002
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,202
|
get_category_threads_page_context_data.py
|
rafalp_Misago/misago/threads/hooks/get_category_threads_page_context_data.py
|
from typing import Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
class GetCategoryThreadsPageContextDataHookAction(Protocol):
"""
A standard Misago function used to get the template context data
for the category threads page.
# Arguments
## `request: HttpRequest`
The request object.
## `kwargs: dict`
A Python `dict` with view's keyword arguments.
# Return value
A Python `dict` with context data to use to `render` the category threads page.
"""
def __call__(self, request: HttpRequest, kwargs: dict) -> dict: ...
class GetCategoryThreadsPageContextDataHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetCategoryThreadsPageContextDataHookAction`
A standard Misago function used to get the template context data
for the category threads page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
## `kwargs: dict`
A Python `dict` with view's keyword arguments.
# Return value
A Python `dict` with context data to use to `render` the category threads page.
"""
def __call__(
self,
action: GetCategoryThreadsPageContextDataHookAction,
request: HttpRequest,
kwargs: dict,
) -> dict: ...
class GetCategoryThreadsPageContextDataHook(
FilterHook[
GetCategoryThreadsPageContextDataHookAction,
GetCategoryThreadsPageContextDataHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get
the template context data for the category threads page.
# Example
The code below implements a custom filter function that adds custom context
data to the category threads page:
```python
from django.http import HttpRequest
from misago.threads.hooks import get_category_threads_page_context_data_hook
@get_category_threads_page_context_data_hook.append_filter
def include_custom_context(action, request: HttpRequest, kwargs: dict) -> dict:
context = action(request, kwargs)
context["plugin_data"] = "..."
return context
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetCategoryThreadsPageContextDataHookAction,
request: HttpRequest,
kwargs: dict,
) -> dict:
return super().__call__(action, request, kwargs)
get_category_threads_page_context_data_hook = GetCategoryThreadsPageContextDataHook()
| 2,606
|
Python
|
.py
| 68
| 32.411765
| 85
| 0.7116
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,203
|
__init__.py
|
rafalp_Misago/misago/threads/hooks/__init__.py
|
from .get_category_threads_page_context_data import (
get_category_threads_page_context_data_hook,
)
from .get_category_threads_page_filters import get_category_threads_page_filters_hook
from .get_category_threads_page_moderation_actions import (
get_category_threads_page_moderation_actions_hook,
)
from .get_category_threads_page_queryset import get_category_threads_page_queryset_hook
from .get_category_threads_page_subcategories import (
get_category_threads_page_subcategories_hook,
)
from .get_category_threads_page_threads import get_category_threads_page_threads_hook
from .get_private_thread_replies_page_context_data import (
get_private_thread_replies_page_context_data_hook,
)
from .get_private_thread_replies_page_posts_queryset import (
get_private_thread_replies_page_posts_queryset_hook,
)
from .get_private_thread_replies_page_thread_queryset import (
get_private_thread_replies_page_thread_queryset_hook,
)
from .get_private_threads_page_context_data import (
get_private_threads_page_context_data_hook,
)
from .get_private_threads_page_filters import get_private_threads_page_filters_hook
from .get_private_threads_page_queryset import get_private_threads_page_queryset_hook
from .get_private_threads_page_threads import get_private_threads_page_threads_hook
from .get_redirect_to_post_response import get_redirect_to_post_response_hook
from .get_thread_posts_feed_item_user_ids import (
get_thread_posts_feed_item_user_ids_hook,
)
from .get_thread_posts_feed_users import (
get_thread_posts_feed_users_hook,
)
from .get_thread_replies_page_context_data import (
get_thread_replies_page_context_data_hook,
)
from .get_thread_replies_page_posts_queryset import (
get_thread_replies_page_posts_queryset_hook,
)
from .get_thread_replies_page_thread_queryset import (
get_thread_replies_page_thread_queryset_hook,
)
from .get_thread_url import get_thread_url_hook
from .get_threads_page_context_data import get_threads_page_context_data_hook
from .get_threads_page_filters import get_threads_page_filters_hook
from .get_threads_page_moderation_actions import (
get_threads_page_moderation_actions_hook,
)
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_thread_posts_feed_item_users import set_thread_posts_feed_item_users_hook
__all__ = [
"get_category_threads_page_context_data_hook",
"get_category_threads_page_filters_hook",
"get_category_threads_page_moderation_actions_hook",
"get_category_threads_page_queryset_hook",
"get_category_threads_page_subcategories_hook",
"get_category_threads_page_threads_hook",
"get_private_thread_replies_page_context_data_hook",
"get_private_thread_replies_page_posts_queryset_hook",
"get_private_thread_replies_page_thread_queryset_hook",
"get_private_threads_page_context_data_hook",
"get_private_threads_page_filters_hook",
"get_private_threads_page_queryset_hook",
"get_private_threads_page_threads_hook",
"get_redirect_to_post_response_hook",
"get_thread_posts_feed_item_user_ids_hook",
"get_thread_posts_feed_users_hook",
"get_thread_replies_page_context_data_hook",
"get_thread_replies_page_posts_queryset_hook",
"get_thread_replies_page_thread_queryset_hook",
"get_thread_url_hook",
"get_threads_page_context_data_hook",
"get_threads_page_filters_hook",
"get_threads_page_moderation_actions_hook",
"get_threads_page_queryset_hook",
"get_threads_page_subcategories_hook",
"get_threads_page_threads_hook",
"set_thread_posts_feed_item_users_hook",
]
| 3,750
|
Python
|
.py
| 82
| 42.768293
| 87
| 0.781293
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,204
|
get_private_threads_page_threads.py
|
rafalp_Misago/misago/threads/hooks/get_private_threads_page_threads.py
|
from typing import Protocol
from django.http import HttpRequest
from ...categories.models import Category
from ...plugins.hooks import FilterHook
class GetPrivateThreadsPageThreadsHookAction(Protocol):
"""
A standard Misago function used to get the complete threads data for
the private threads page. Returns a `dict` that is included in the template
context under the `threads` key.
# Arguments
## `request: HttpRequest`
The request object.
## `category: Category`
The private threads category instance.
## `kwargs: dict`
A `dict` with `kwargs` this view was called with.
# Return value
A `dict` with the template context.
"""
def __call__(
self,
request: HttpRequest,
category: Category,
kwargs: dict,
) -> dict: ...
class GetPrivateThreadsPageThreadsHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetPrivateThreadsPageThreadsHookAction`
A standard Misago function used to get the complete threads data for
the private threads page. Returns a `dict` that is included in the template
context under the `threads` key.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
## `category: Category`
The private threads category instance.
## `kwargs: dict`
A `dict` with `kwargs` this view was called with.
# Return value
A `dict` with the template context.
"""
def __call__(
self,
action: GetPrivateThreadsPageThreadsHookAction,
request: HttpRequest,
category: Category,
kwargs: dict,
) -> dict: ...
class GetPrivateThreadsPageThreadsHook(
FilterHook[
GetPrivateThreadsPageThreadsHookAction,
GetPrivateThreadsPageThreadsHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get
complete threads data for the private threads page.
# Example
The code below implements a custom filter function makes view use a different
threads list template instead of the default one.
```python
from django.http import HttpRequest
from misago.categories.models import Category
from misago.threads.hooks import get_private_threads_page_threads_hook
@get_private_threads_page_threads_hook.append_filter
def replace_threads_list_template(
action, request: HttpRequest, category: Category, kwargs: dict
) -> dict:
data = action(request, kwargs)
data["template_name"] = "plugin/threads_list.html"
return data
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetPrivateThreadsPageThreadsHookAction,
request: HttpRequest,
category: Category,
kwargs: dict,
) -> dict:
return super().__call__(action, request, category, kwargs)
get_private_threads_page_threads_hook = GetPrivateThreadsPageThreadsHook()
| 3,061
|
Python
|
.py
| 85
| 29.976471
| 81
| 0.698569
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,205
|
get_private_threads_page_filters.py
|
rafalp_Misago/misago/threads/hooks/get_private_threads_page_filters.py
|
from typing import Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
from ..filters import ThreadsFilter
class GetPrivateThreadsPageFiltersHookAction(Protocol):
"""
A standard Misago function used to get available filters for
the private threads list.
# Arguments
## `request: HttpRequest`
The request object.
# Return value
A Python `list` with `ThreadsFilter` instances.
"""
def __call__(self, request: HttpRequest) -> list[ThreadsFilter]: ...
class GetPrivateThreadsPageFiltersHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetPrivateThreadsPageFiltersHookAction`
A standard Misago function used to get available filters for
the private threads list.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
# Return value
A Python `list` with `ThreadsFilter` instances.
"""
def __call__(
self,
action: GetPrivateThreadsPageFiltersHookAction,
request: HttpRequest,
) -> list[ThreadsFilter]: ...
class GetPrivateThreadsPageFiltersHook(
FilterHook[
GetPrivateThreadsPageFiltersHookAction,
GetPrivateThreadsPageFiltersHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get available
filters for the private threads list.
# Example
The code below implements a custom filter function that includes a new filter:
```python
from django.http import HttpRequest
from misago.threads.filters import ThreadsFilter
from misago.threads.hooks import get_private_threads_page_filters_hook
class CustomFilter(ThreadsFilter):
name: str = "Custom filter"
slug: str = "custom"
def __callable__(self, queryset):
if not self.request.user.is_authenticated:
return queryset
return queryset.filter(plugin_data__custom=True)
@get_private_threads_page_filters_hook.append_filter
def include_custom_filter(action, request: HttpRequest) -> list[ThreadsFilter]:
filters = action(request)
filters.append(CustomFilter(request))
return filters
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetPrivateThreadsPageFiltersHookAction,
request: HttpRequest,
) -> list[ThreadsFilter]:
return super().__call__(action, request)
get_private_threads_page_filters_hook = GetPrivateThreadsPageFiltersHook()
| 2,629
|
Python
|
.py
| 70
| 31.3
| 83
| 0.710266
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,206
|
get_threads_page_queryset.py
|
rafalp_Misago/misago/threads/hooks/get_threads_page_queryset.py
|
from typing import Protocol
from django.http import HttpRequest
from django.db.models import QuerySet
from ...plugins.hooks import FilterHook
class GetThreadsPageQuerysetHookAction(Protocol):
"""
A standard Misago function used to get the base threads queryset
for the threads page.
# Arguments
## `request: HttpRequest`
The request object.
# Return value
A `QuerySet` instance that will return `Threads`.
"""
def __call__(self, request: HttpRequest) -> QuerySet: ...
class GetThreadsPageQuerysetHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetThreadsPageQuerysetHookAction`
A standard Misago function used to get the base threads queryset
for the threads page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
# Return value
A `QuerySet` instance that will return `Threads`.
"""
def __call__(
self,
action: GetThreadsPageQuerysetHookAction,
request: HttpRequest,
) -> QuerySet: ...
class GetThreadsPageQuerysetHook(
FilterHook[
GetThreadsPageQuerysetHookAction,
GetThreadsPageQuerysetHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get
base threads queryset for the threads page.
# Example
The code below implements a custom filter function that joins first post to
every returned thread.
```python
from django.db.models import QuerySet
from django.http import HttpRequest
from misago.threads.hooks import get_threads_page_queryset_hook
@get_threads_page_queryset_hook.append_filter
def select_first_post(action, request: HttpRequest) -> QuerySet:
queryset = action(request)
return queryset.select_related("first_post")
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetThreadsPageQuerysetHookAction,
request: HttpRequest,
) -> QuerySet:
return super().__call__(action, request)
get_threads_page_queryset_hook = GetThreadsPageQuerysetHook()
| 2,208
|
Python
|
.py
| 63
| 29.412698
| 79
| 0.710838
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,207
|
get_private_thread_replies_page_posts_queryset.py
|
rafalp_Misago/misago/threads/hooks/get_private_thread_replies_page_posts_queryset.py
|
from typing import Protocol
from django.db.models import QuerySet
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
from ..models import Thread
class GetPrivateThreadRepliesPagePostsQuerysetHookAction(Protocol):
"""
A standard Misago function used to get a queryset used to get posts displayed
on the private thread replies page.
# Arguments
## `request: HttpRequest`
The request object.
## `thread: Thread`
A `Thread` instance.
# Return value
An unfiltered `QuerySet` instance to use to get posts displayed on
the private thread replies page.
"""
def __call__(self, request: HttpRequest, thread: Thread) -> QuerySet: ...
class GetPrivateThreadRepliesPagePostsQuerysetHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetPrivateThreadRepliesPagePostsQuerysetHookAction`
A standard Misago function used to get a queryset used to get posts displayed
on the ptivate thread replies page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
# Return value
An unfiltered `QuerySet` instance to use to get posts displayed on
the private thread replies page.
"""
def __call__(
self,
action: GetPrivateThreadRepliesPagePostsQuerysetHookAction,
request: HttpRequest,
thread: Thread,
) -> QuerySet: ...
class GetPrivateThreadRepliesPagePostsQuerysetHook(
FilterHook[
GetPrivateThreadRepliesPagePostsQuerysetHookAction,
GetPrivateThreadRepliesPagePostsQuerysetHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get a queryset
with posts to display on the private thread replies page.
This hook should be used only to add new joins with `select_related`. To filter
posts, use the `filter_private_thread_posts_queryset` hook instead.
# Example
The code below implements a custom filter function that joins plugin's table
with `select_related`:
```python
from django.http import HttpRequest
from misago.threads.hooks import get_private_thread_replies_page_posts_queryset_hook
from misago.threads.models import Thread
@get_private_thread_replies_page_posts_queryset_hook.append_filter
def select_related_plugin_data(
action, request: HttpRequest, thread: Thread
):
queryset = action(request, thread)
return queryset.select_related("plugin")
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetPrivateThreadRepliesPagePostsQuerysetHookAction,
request: HttpRequest,
thread: Thread,
) -> dict:
return super().__call__(action, request, thread)
get_private_thread_replies_page_posts_queryset_hook = (
GetPrivateThreadRepliesPagePostsQuerysetHook()
)
| 2,967
|
Python
|
.py
| 76
| 33.421053
| 88
| 0.731092
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,208
|
get_category_threads_page_subcategories.py
|
rafalp_Misago/misago/threads/hooks/get_category_threads_page_subcategories.py
|
from typing import Protocol
from django.http import HttpRequest
from ...categories.models import Category
from ...plugins.hooks import FilterHook
class GetCategoryThreadsPageSubcategoriesHookAction(Protocol):
"""
A standard Misago function used to build a `dict` with data for
the categories list component, used to display the list of subcategories on
the category threads page.
# Arguments
## `request: HttpRequest`
The request object.
## `category: Category`
A category instance.
# 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/category/subcategories.html"
}
```
To suppress categories lists on a page, return `None`.
"""
def __call__(self, request: HttpRequest, category: Category) -> dict | None: ...
class GetCategoryThreadsPageSubcategoriesHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetCategoryThreadsPageSubcategoriesHookAction`
A standard Misago function used to build a `dict` with data for
the categories list component, used to display the list of subcategories on
the category threads page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
## `category: Category`
A category instance.
# 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/category/subcategories.html"
}
```
To suppress categories lists on a page, return `None`.
"""
def __call__(
self,
action: GetCategoryThreadsPageSubcategoriesHookAction,
request: HttpRequest,
category: Category,
) -> dict | None: ...
class GetCategoryThreadsPageSubcategoriesHook(
FilterHook[
GetCategoryThreadsPageSubcategoriesHookAction,
GetCategoryThreadsPageSubcategoriesHookFilter,
]
):
"""
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
subcategories on the category threads page.
# Example
The code below implements a custom filter function that replaces full
subcategories component's template with a custom one
```python
from django.http import HttpRequest
from misago.categories.models import Category
from misago.threads.hooks import get_category_threads_page_subcategories_hook
@get_category_threads_page_subcategories_hook.append_filter
def customize_subcategories_template(
action, request: HttpRequest, category: Category
) -> dict | None:
data = action(request, category)
data["template_name"] = "plugin/subcategories.html"
return data
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetCategoryThreadsPageSubcategoriesHookAction,
request: HttpRequest,
category: Category,
) -> dict | None:
return super().__call__(action, request, category)
get_category_threads_page_subcategories_hook = GetCategoryThreadsPageSubcategoriesHook()
| 3,475
|
Python
|
.py
| 91
| 32.285714
| 88
| 0.709455
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,209
|
get_private_threads_page_context_data.py
|
rafalp_Misago/misago/threads/hooks/get_private_threads_page_context_data.py
|
from typing import Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
class GetPrivateThreadsPageContextDataHookAction(Protocol):
"""
A standard Misago function used to get the template context data
for the private threads page.
# Arguments
## `request: HttpRequest`
The request object.
## `kwargs: dict`
A Python `dict` with view's keyword arguments.
# Return value
A Python `dict` with context data to use to `render` the private threads page.
"""
def __call__(self, request: HttpRequest, kwargs: dict) -> dict: ...
class GetPrivateThreadsPageContextDataHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetPrivateThreadsPageContextDataHookAction`
A standard Misago function used to get the template context data
for the private threads page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
## `kwargs: dict`
A Python `dict` with view's keyword arguments.
# Return value
A Python `dict` with context data to use to `render` the private threads page.
"""
def __call__(
self,
action: GetPrivateThreadsPageContextDataHookAction,
request: HttpRequest,
kwargs: dict,
) -> dict: ...
class GetPrivateThreadsPageContextDataHook(
FilterHook[
GetPrivateThreadsPageContextDataHookAction,
GetPrivateThreadsPageContextDataHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get
the template context data for the private threads page.
# Example
The code below implements a custom filter function that adds custom context
data to the private threads page:
```python
from django.http import HttpRequest
from misago.threads.hooks import get_private_threads_page_context_data_hook
@get_private_threads_page_context_data_hook.append_filter
def include_custom_context(action, request: HttpRequest, : dict) -> dict:
context = action(request, kwargs)
context["plugin_data"] = "..."
return context
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetPrivateThreadsPageContextDataHookAction,
request: HttpRequest,
kwargs: dict,
) -> dict:
return super().__call__(action, request, kwargs)
get_private_threads_page_context_data_hook = GetPrivateThreadsPageContextDataHook()
| 2,582
|
Python
|
.py
| 68
| 32.058824
| 83
| 0.708805
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,210
|
get_category_threads_page_moderation_actions.py
|
rafalp_Misago/misago/threads/hooks/get_category_threads_page_moderation_actions.py
|
from typing import Protocol, Type
from django.http import HttpRequest
from ...categories.models import Category
from ...moderation.threads import ThreadsBulkModerationAction
from ...plugins.hooks import FilterHook
class GetCategoryThreadsPageModerationActionsHookAction(Protocol):
"""
A standard Misago function used to get available moderation actions for
a category's threads list.
# Arguments
## `request: HttpRequest`
The request object.
## `category: Category`
A category instance.
# Return value
A Python `list` with `ThreadsBulkModerationAction` types.
"""
def __call__(
self,
request: HttpRequest,
category: Category,
) -> list[Type[ThreadsBulkModerationAction]]: ...
class GetCategoryThreadsPageModerationActionsHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetCategoryThreadsPageModerationActionsHookAction`
A standard Misago function used to get available filters for
a category's threads list.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
## `category: Category`
A category instance.
# Return value
A Python `list` with `ThreadsBulkModerationAction` types.
"""
def __call__(
self,
action: GetCategoryThreadsPageModerationActionsHookAction,
request: HttpRequest,
category: Category,
) -> list[Type[ThreadsBulkModerationAction]]: ...
class GetCategoryThreadsPageModerationActionsHook(
FilterHook[
GetCategoryThreadsPageModerationActionsHookAction,
GetCategoryThreadsPageModerationActionsHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get available
moderation actions for a category's threads list.
# Example
The code below implements a custom filter function that includes a new moderation
action for users with a special permission only:
```python
from django.http import HttpRequest
from misago.categories.models import Category
from misago.moderation.threads import ModerationResult, ThreadsBulkModerationAction
from misago.threads.hooks import get_category_threads_page_moderation_actions_hook
from misago.threads.models import Thread
class CustomModerationAction(ThreadsBulkModerationAction):
id: str = "custom"
name: str = "Custom"
def __call__(
self, request: HttpRequest, threads: list[Thread]
) -> ModerationResult | None:
...
@get_category_threads_page_moderation_actions_hook.append_filter
def include_custom_moderation_action(
action, request: HttpRequest, category: Category
) -> list[Type[ThreadsBulkModerationAction]]:
moderation_actions = action(request)
if request.user_permissions.is_global_moderator:
moderation_actions.append(ThreadsBulkModerationAction)
return moderation_actions
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetCategoryThreadsPageModerationActionsHookAction,
request: HttpRequest,
category: Category,
) -> list[Type[ThreadsBulkModerationAction]]:
return super().__call__(action, request, category)
get_category_threads_page_moderation_actions_hook = (
GetCategoryThreadsPageModerationActionsHook()
)
| 3,491
|
Python
|
.py
| 89
| 33.022472
| 87
| 0.727624
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,211
|
set_thread_posts_feed_item_users.py
|
rafalp_Misago/misago/threads/hooks/set_thread_posts_feed_item_users.py
|
from typing import TYPE_CHECKING, Protocol
from ...plugins.hooks import FilterHook
if TYPE_CHECKING:
from ...users.models import User
class SetThreadPostFeedItemUsersHookAction(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 SetThreadPostFeedItemUsersHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: SetThreadPostFeedItemUsersHookAction`
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: SetThreadPostFeedItemUsersHookAction,
users: dict[int, "User"],
item: dict,
): ...
class SetThreadPostFeedItemUsersHook(
FilterHook[
SetThreadPostFeedItemUsersHookAction, SetThreadPostFeedItemUsersHookFilter
]
):
"""
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_thread_posts_feed_item_users_hook
if TYPE_CHECKING:
from misago.users.models import User
@set_thread_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: SetThreadPostFeedItemUsersHookAction,
users: dict[int, "User"],
item: dict,
):
return super().__call__(action, users, item)
set_thread_posts_feed_item_users_hook = SetThreadPostFeedItemUsersHook()
| 2,685
|
Python
|
.py
| 71
| 31.704225
| 82
| 0.672741
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,212
|
get_redirect_to_post_response.py
|
rafalp_Misago/misago/threads/hooks/get_redirect_to_post_response.py
|
from typing import Protocol
from django.http import HttpRequest, HttpResponse
from ...plugins.hooks import FilterHook
from ..models import Post
class GetRedirectToPostResponseHookAction(Protocol):
"""
A standard Misago function used to get a HTTP redirect response to a post.
# Arguments
## `request: HttpRequest`
The request object.
## `post: Post`
A post to redirect to. It's `category` attribute is already populated.
# Return value
Django's `HttpResponse` with redirect to a post.
"""
def __call__(
self,
request: HttpRequest,
post: Post,
) -> HttpResponse: ...
class GetRedirectToPostResponseHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetRedirectToPostResponseHookAction`
A standard Misago function used to get a HTTP redirect response to a post.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
## `post: Post`
A post to redirect to. It's `category` attribute is already populated.
# Return value
Django's `HttpResponse` with redirect to a post.
"""
def __call__(
self,
action: GetRedirectToPostResponseHookAction,
request: HttpRequest,
post: Post,
) -> HttpResponse: ...
class GetRedirectToPostResponseHook(
FilterHook[
GetRedirectToPostResponseHookAction,
GetRedirectToPostResponseHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get a HTTP
redirect response to a post.
# Example
The code below implements a custom filter function that creates custom redirect
response for posts in non-standard category type:
```python
from django.http import HttpRequest
from django.shortcuts import redirect
from django.urls import reverse
from misago.threads.hooks import get_redirect_to_post_response_hook
from misago.threads.models import Post
BLOG_CATEGORY_TREE = 500
@get_redirect_to_post_response_hook.append_filter
def redirect_to_blog_comment(
action, request: HttpRequest, post: Post
) -> HttpResponse:
if post.category.tree_id == BLOG_CATEGORY_TREE:
return redirect(
reverse(
"blog:story",
kwargs={"id": post.thread_id},
) + f"#comment-{post.id}"
)
return action(request, post)
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetRedirectToPostResponseHookAction,
request: HttpRequest,
post: Post,
) -> HttpResponse:
return super().__call__(action, request, post)
get_redirect_to_post_response_hook = GetRedirectToPostResponseHook()
| 2,880
|
Python
|
.py
| 82
| 28.390244
| 83
| 0.675725
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,213
|
get_threads_page_threads.py
|
rafalp_Misago/misago/threads/hooks/get_threads_page_threads.py
|
from typing import Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
class GetThreadsPageThreadsHookAction(Protocol):
"""
A standard Misago function used to get the complete threads data for the threads page.
Returns a `dict` that is included in the template context under the `threads` key.
# Arguments
## `request: HttpRequest`
The request object.
## `kwargs: dict`
A `dict` with `kwargs` this view was called with.
# Return value
A `dict` with the template context.
"""
def __call__(self, request: HttpRequest, kwargs: dict) -> dict: ...
class GetThreadsPageThreadsHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetThreadsPageThreadsHookAction`
A standard Misago function used to get the complete threads data for the threads page.
Returns a `dict` that is included in the template context under the `threads` key.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
## `kwargs: dict`
A `dict` with `kwargs` this view was called with.
# Return value
A `dict` with the template context.
"""
def __call__(
self,
action: GetThreadsPageThreadsHookAction,
request: HttpRequest,
kwargs: dict,
) -> dict: ...
class GetThreadsPageThreadsHook(
FilterHook[
GetThreadsPageThreadsHookAction,
GetThreadsPageThreadsHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get
complete threads data for the threads page.
# Example
The code below implements a custom filter function makes view use a different
threads list template instead of the default one.
```python
from django.http import HttpRequest
from misago.threads.hooks import get_threads_page_threads_hook
@get_threads_page_threads_hook.append_filter
def replace_threads_list_template(
action, request: HttpRequest, kwargs: dict
) -> dict:
data = action(request, kwargs)
data["template_name"] = "plugin/threads_list.html"
return data
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetThreadsPageThreadsHookAction,
request: HttpRequest,
kwargs: dict,
) -> dict:
return super().__call__(action, request, kwargs)
get_threads_page_threads_hook = GetThreadsPageThreadsHook()
| 2,559
|
Python
|
.py
| 70
| 30.642857
| 90
| 0.693844
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,214
|
get_private_threads_page_queryset.py
|
rafalp_Misago/misago/threads/hooks/get_private_threads_page_queryset.py
|
from typing import Protocol
from django.http import HttpRequest
from django.db.models import QuerySet
from ...categories.models import Category
from ...plugins.hooks import FilterHook
class GetPrivateThreadsPageQuerysetHookAction(Protocol):
"""
A standard Misago function used to get the base threads queryset
for the private threads page.
# Arguments
## `request: HttpRequest`
The request object.
## `category: Category`
The private threads category instance.
# Return value
A `QuerySet` instance that will return `Threads`.
"""
def __call__(self, request: HttpRequest, category: Category) -> QuerySet: ...
class GetPrivateThreadsPageQuerysetHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetPrivateThreadsPageQuerysetHookAction`
A standard Misago function used to get the base threads queryset
for the private threads page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
## `category: Category`
The private threads category instance.
# Return value
A `QuerySet` instance that will return `Threads`.
"""
def __call__(
self,
action: GetPrivateThreadsPageQuerysetHookAction,
request: HttpRequest,
category: Category,
) -> QuerySet: ...
class GetPrivateThreadsPageQuerysetHook(
FilterHook[
GetPrivateThreadsPageQuerysetHookAction,
GetPrivateThreadsPageQuerysetHookFilter,
]
):
"""
This hook wraps the standard function that Misago uses to get
base threads queryset for the private threads page.
# Example
The code below implements a custom filter function that joins first post to
every returned thread.
```python
from django.db.models import QuerySet
from django.http import HttpRequest
from misago.categories.models import Category
from misago.threads.hooks import get_private_threads_page_queryset_hook
@get_private_threads_page_queryset_hook.append_filter
def select_first_post(action, request: HttpRequest) -> QuerySet:
queryset = action(request)
return queryset.select_related("first_post")
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetPrivateThreadsPageQuerysetHookAction,
request: HttpRequest,
category: Category,
) -> QuerySet:
return super().__call__(action, request, category)
get_private_threads_page_queryset_hook = GetPrivateThreadsPageQuerysetHook()
| 2,643
|
Python
|
.py
| 71
| 31.549296
| 81
| 0.72358
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,215
|
postlike.py
|
rafalp_Misago/misago/threads/serializers/postlike.py
|
from django.urls import reverse
from rest_framework import serializers
from ..models import PostLike
__all__ = ["PostLikeSerializer"]
class PostLikeSerializer(serializers.ModelSerializer):
avatars = serializers.SerializerMethodField()
liker_id = serializers.SerializerMethodField()
username = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = PostLike
fields = ["id", "avatars", "liked_on", "liker_id", "username", "url"]
def get_liker_id(self, obj):
return obj["liker_id"]
def get_username(self, obj):
return obj["liker_name"]
def get_avatars(self, obj):
return obj.get("liker__avatars")
def get_url(self, obj):
if obj["liker_id"]:
return reverse(
"misago:user", kwargs={"slug": obj["liker_slug"], "pk": obj["liker_id"]}
)
| 906
|
Python
|
.py
| 23
| 32.565217
| 88
| 0.657503
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,216
|
pollvote.py
|
rafalp_Misago/misago/threads/serializers/pollvote.py
|
from django.urls import reverse
from django.utils.translation import npgettext, pgettext
from rest_framework import serializers
__all__ = ["NewVoteSerializer", "PollVoteSerializer"]
class NewVoteSerializer(serializers.Serializer):
choices = serializers.ListField(child=serializers.CharField())
def validate_choices(self, data):
if len(data) > self.context["allowed_choices"]:
message = npgettext(
"new vote serializer",
"This poll disallows voting for more than %(choices)s choice.",
"This poll disallows voting for more than %(choices)s choices.",
self.context["allowed_choices"],
)
raise serializers.ValidationError(
message % {"choices": self.context["allowed_choices"]}
)
valid_choices = [c["hash"] for c in self.context["choices"]]
clean_choices = []
for choice in data:
if choice in valid_choices and choice not in clean_choices:
clean_choices.append(choice)
if len(clean_choices) != len(data):
raise serializers.ValidationError(
pgettext(
"new vote serializer", "One or more of poll choices were invalid."
)
)
if not clean_choices:
raise serializers.ValidationError(
pgettext("new vote serializer", "You have to make a choice.")
)
return clean_choices
class PollVoteSerializer(serializers.Serializer):
voted_on = serializers.DateTimeField()
username = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
fields = ["voted_on", "username", "url"]
def get_username(self, obj):
return obj["voter_name"]
def get_url(self, obj):
if obj["voter_id"]:
return reverse(
"misago:user", kwargs={"pk": obj["voter_id"], "slug": obj["voter_slug"]}
)
| 2,018
|
Python
|
.py
| 46
| 33.326087
| 88
| 0.612672
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,217
|
post.py
|
rafalp_Misago/misago/threads/serializers/post.py
|
from django.urls import reverse
from rest_framework import serializers
from ...core.serializers import MutableFields
from ...users.serializers import UserSerializer as BaseUserSerializer
from ..models import Post
__all__ = ["PostSerializer"]
UserSerializer = BaseUserSerializer.subset_fields(
"id",
"username",
"real_name",
"rank",
"avatars",
"signature",
"title",
"status",
"posts",
"url",
)
class PostSerializer(serializers.ModelSerializer, MutableFields):
poster = UserSerializer(many=False, read_only=True)
content = serializers.SerializerMethodField()
attachments = serializers.SerializerMethodField()
last_editor = serializers.PrimaryKeyRelatedField(read_only=True)
hidden_by = serializers.PrimaryKeyRelatedField(read_only=True)
acl = serializers.SerializerMethodField()
is_read = serializers.SerializerMethodField()
is_new = serializers.SerializerMethodField()
is_liked = serializers.SerializerMethodField()
is_protected = serializers.SerializerMethodField()
last_likes = serializers.SerializerMethodField()
likes = serializers.SerializerMethodField()
api = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = Post
fields = [
"id",
"poster",
"poster_name",
"content",
"attachments",
"posted_on",
"updated_on",
"hidden_on",
"edits",
"last_editor",
"last_editor_name",
"last_editor_slug",
"hidden_by",
"hidden_by_name",
"hidden_by_slug",
"is_unapproved",
"is_hidden",
"is_protected",
"is_event",
"event_type",
"event_context",
"acl",
"is_liked",
"is_new",
"is_read",
"last_likes",
"likes",
"api",
"url",
]
def get_content(self, obj):
if (
obj.is_valid
and not obj.is_event
and (not obj.is_hidden or obj.acl["can_see_hidden"])
):
return obj.content
def get_attachments(self, obj):
return obj.attachments_cache
def get_acl(self, obj):
try:
return obj.acl
except AttributeError:
return None
def get_is_liked(self, obj):
try:
return obj.is_liked
except AttributeError:
return None
def get_is_new(self, obj):
try:
return obj.is_new
except AttributeError:
return None
def get_is_read(self, obj):
try:
return obj.is_read
except AttributeError:
return None
def get_is_protected(self, obj):
if obj.is_event:
return None
try:
if obj.acl["can_see_protected"]:
return obj.is_protected
except AttributeError:
pass
return None
def get_last_likes(self, obj):
if obj.is_event:
return None
try:
if obj.acl["can_see_likes"]:
return obj.last_likes
except AttributeError:
return None
def get_likes(self, obj):
if obj.is_event:
return None
try:
if obj.acl["can_see_likes"]:
return obj.likes
except AttributeError:
return None
def get_api(self, obj):
api_links = {
"index": obj.get_api_url(),
"likes": obj.get_likes_api_url(),
"editor": obj.get_editor_api_url(),
"edits": obj.get_edits_api_url(),
}
if obj.is_event:
del api_links["likes"]
return api_links
def get_url(self, obj):
return {
"index": obj.get_absolute_url(),
"last_editor": self.get_last_editor_url(obj),
"hidden_by": self.get_hidden_by_url(obj),
}
def get_last_editor_url(self, obj):
if obj.last_editor_id:
return reverse(
"misago:user",
kwargs={"pk": obj.last_editor_id, "slug": obj.last_editor_slug},
)
def get_hidden_by_url(self, obj):
if obj.hidden_by_id:
return reverse(
"misago:user",
kwargs={"pk": obj.hidden_by_id, "slug": obj.hidden_by_slug},
)
| 4,538
|
Python
|
.py
| 148
| 20.939189
| 80
| 0.55306
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,218
|
feed.py
|
rafalp_Misago/misago/threads/serializers/feed.py
|
from rest_framework import serializers
from ...categories.serializers import CategorySerializer
from ...core.serializers import MutableFields
from ...users.serializers import UserSerializer
from ..models import Post
from .post import PostSerializer
__all__ = ["FeedSerializer"]
FeedUserSerializer = UserSerializer.subset_fields(
"id", "username", "avatars", "url", "title", "rank"
)
FeedCategorySerializer = CategorySerializer.subset_fields("name", "css_class", "url")
class FeedSerializer(PostSerializer, MutableFields):
poster = FeedUserSerializer(many=False, read_only=True)
category = FeedCategorySerializer(many=False, read_only=True)
thread = serializers.SerializerMethodField()
class Meta:
model = Post
fields = PostSerializer.Meta.fields + ["category", "thread"]
def get_thread(self, obj):
return {"title": obj.thread.title, "url": obj.thread.get_absolute_url()}
def to_representation(self, obj):
data = super().to_representation(obj)
data["headline"] = getattr(obj, "headline", None)
return data
FeedSerializer = FeedSerializer.exclude_fields("is_liked", "is_new", "is_read")
| 1,173
|
Python
|
.py
| 25
| 42.4
| 85
| 0.735035
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,219
|
thread.py
|
rafalp_Misago/misago/threads/serializers/thread.py
|
from math import ceil
from django.urls import reverse
from rest_framework import serializers
from ...categories.serializers import CategorySerializer
from ...core.serializers import MutableFields
from ...notifications.threads import ThreadNotifications
from ..models import Thread
from .poll import PollSerializer
from .threadparticipant import ThreadParticipantSerializer
__all__ = ["ThreadSerializer", "PrivateThreadSerializer", "ThreadsListSerializer"]
BasicCategorySerializer = CategorySerializer.subset_fields(
"id",
"parent",
"name",
"short_name",
"color",
"description",
"is_closed",
"css_class",
"level",
"lft",
"rght",
"is_read",
"url",
)
class ThreadSerializer(serializers.ModelSerializer, MutableFields):
category = BasicCategorySerializer(many=False, read_only=True)
acl = serializers.SerializerMethodField()
has_unapproved_posts = serializers.SerializerMethodField()
is_new = serializers.SerializerMethodField()
is_read = serializers.SerializerMethodField()
path = BasicCategorySerializer(many=True, read_only=True)
poll = PollSerializer(many=False, read_only=True)
pages = serializers.SerializerMethodField()
best_answer = serializers.PrimaryKeyRelatedField(read_only=True)
best_answer_marked_by = serializers.PrimaryKeyRelatedField(read_only=True)
notifications = serializers.SerializerMethodField()
starter = serializers.SerializerMethodField()
last_poster = serializers.SerializerMethodField()
api = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = Thread
fields = [
"id",
"category",
"title",
"replies",
"has_unapproved_posts",
"started_on",
"starter_name",
"last_post_on",
"last_post_is_event",
"last_post",
"last_poster_name",
"is_unapproved",
"is_hidden",
"is_closed",
"weight",
"best_answer",
"best_answer_is_protected",
"best_answer_marked_on",
"best_answer_marked_by",
"best_answer_marked_by_name",
"best_answer_marked_by_slug",
"acl",
"is_new",
"is_read",
"path",
"poll",
"notifications",
"starter",
"last_poster",
"pages",
"api",
"url",
]
def get_acl(self, obj):
try:
return obj.acl
except AttributeError:
return {}
def get_has_unapproved_posts(self, obj):
try:
acl = obj.acl
except AttributeError:
return False
return acl.get("can_approve") and obj.has_unapproved_posts
def get_is_new(self, obj):
try:
return obj.is_new
except AttributeError:
return None
def get_is_read(self, obj):
try:
return obj.is_read
except AttributeError:
return None
def get_participants(self, obj):
return ThreadParticipantSerializer(obj.participants_list, many=True).data
def get_notifications(self, obj):
if self.context:
watched_thread = self.context.get("watched_thread")
if watched_thread:
if watched_thread.send_emails:
return ThreadNotifications.SITE_AND_EMAIL
return ThreadNotifications.SITE_ONLY
watched_threads = self.context.get("watched_threads")
if watched_threads:
return watched_threads.get(obj.id)
return None
def get_starter(self, obj):
if obj.starter_id:
return {
"id": obj.starter_id,
"username": obj.starter.username,
"real_name": obj.starter.get_real_name(),
"avatars": obj.starter.avatars,
}
def get_last_poster(self, obj):
if obj.last_poster_id:
return {
"id": obj.last_poster_id,
"username": obj.last_poster.username,
"real_name": obj.last_poster.get_real_name(),
"avatars": obj.last_poster.avatars,
}
def get_pages(self, obj):
settings = self.context["settings"]
posts_per_page = settings.posts_per_page - 1
posts_per_page_orphans = settings.posts_per_page_orphans
if posts_per_page_orphans:
posts_per_page_orphans += 1
total_posts = obj.replies + 1
if total_posts <= posts_per_page + posts_per_page_orphans:
return 1
hits = total_posts - posts_per_page_orphans
return ceil(hits / posts_per_page)
def get_api(self, obj):
return {
"index": obj.get_api_url(),
"editor": obj.get_editor_api_url(),
"merge": obj.get_merge_api_url(),
"poll": obj.get_poll_api_url(),
"watch": obj.get_watch_api_url(),
"posts": {
"index": obj.get_posts_api_url(),
"merge": obj.get_post_merge_api_url(),
"move": obj.get_post_move_api_url(),
"split": obj.get_post_split_api_url(),
},
}
def get_url(self, obj):
return {
"index": obj.get_absolute_url(),
"new_post": obj.get_new_post_url(),
"last_post": obj.get_last_post_url(),
"best_answer": obj.get_best_answer_url(),
"unapproved_post": obj.get_unapproved_post_url(),
"starter": self.get_starter_url(obj),
"last_poster": self.get_last_poster_url(obj),
}
def get_starter_url(self, obj):
if obj.starter_id:
return reverse(
"misago:user", kwargs={"slug": obj.starter_slug, "pk": obj.starter_id}
)
def get_last_poster_url(self, obj):
if obj.last_poster_id:
return reverse(
"misago:user",
kwargs={"slug": obj.last_poster_slug, "pk": obj.last_poster_id},
)
class PrivateThreadSerializer(ThreadSerializer):
participants = serializers.SerializerMethodField()
class Meta:
model = Thread
fields = ThreadSerializer.Meta.fields + ["participants"]
class ThreadsListSerializer(ThreadSerializer):
category = serializers.PrimaryKeyRelatedField(read_only=True)
last_post = serializers.PrimaryKeyRelatedField(read_only=True)
class Meta:
model = Thread
fields = ThreadSerializer.Meta.fields + ["has_poll"]
ThreadsListSerializer = ThreadsListSerializer.exclude_fields("path", "poll")
| 6,792
|
Python
|
.py
| 185
| 26.913514
| 86
| 0.593365
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,220
|
poll.py
|
rafalp_Misago/misago/threads/serializers/poll.py
|
from django.urls import reverse
from django.utils.crypto import get_random_string
from django.utils.translation import npgettext, pgettext
from rest_framework import serializers
from ..models import Poll
__all__ = [
"PollSerializer",
"EditPollSerializer",
"NewPollSerializer",
"PollChoiceSerializer",
]
MAX_POLL_OPTIONS = 16
class PollSerializer(serializers.ModelSerializer):
acl = serializers.SerializerMethodField()
choices = serializers.SerializerMethodField()
api = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = Poll
fields = [
"id",
"poster_name",
"posted_on",
"length",
"question",
"allowed_choices",
"allow_revotes",
"votes",
"is_public",
"acl",
"choices",
"api",
"url",
]
def get_api(self, obj):
return {"index": obj.get_api_url(), "votes": obj.get_votes_api_url()}
def get_url(self, obj):
return {"poster": self.get_poster_url(obj)}
def get_poster_url(self, obj):
if obj.poster_id:
return reverse(
"misago:user", kwargs={"slug": obj.poster_slug, "pk": obj.poster_id}
)
def get_acl(self, obj):
try:
return obj.acl
except AttributeError:
return None
def get_choices(self, obj):
return obj.choices
class EditPollSerializer(serializers.ModelSerializer):
length = serializers.IntegerField(required=True, min_value=0, max_value=180)
question = serializers.CharField(required=True, max_length=255)
allowed_choices = serializers.IntegerField(required=True, min_value=1)
choices = serializers.ListField(allow_empty=False, child=serializers.DictField())
class Meta:
model = Poll
fields = ["length", "question", "allowed_choices", "allow_revotes", "choices"]
def validate_choices(self, choices):
clean_choices = list(map(self.clean_choice, choices))
# generate hashes for added choices
choices_map = {}
for choice in self.instance.choices:
choices_map[choice["hash"]] = choice
final_choices = []
for choice in clean_choices:
if choice["hash"] in choices_map:
choices_map[choice["hash"]].update({"label": choice["label"]})
final_choices.append(choices_map[choice["hash"]])
else:
choice.update({"hash": get_random_string(12), "votes": 0})
final_choices.append(choice)
self.validate_choices_num(final_choices)
return final_choices
def clean_choice(self, choice):
clean_choice = {
"hash": choice.get("hash", get_random_string(12)),
"label": choice.get("label", ""),
}
serializer = PollChoiceSerializer(data=clean_choice)
if not serializer.is_valid():
raise serializers.ValidationError(
pgettext(
"edit poll serializer", "One or more poll choices are invalid."
)
)
return serializer.data
def validate_choices_num(self, choices):
total_choices = len(choices)
if total_choices < 2:
raise serializers.ValidationError(
pgettext(
"edit poll serializer",
"You need to add at least two choices to a poll.",
)
)
if total_choices > MAX_POLL_OPTIONS:
# pylint: disable=line-too-long
message = npgettext(
"edit poll serializer",
"You can't add more than %(limit_value)s option to a single poll (added %(show_value)s).",
"You can't add more than %(limit_value)s options to a single poll (added %(show_value)s).",
MAX_POLL_OPTIONS,
)
raise serializers.ValidationError(
message % {"limit_value": MAX_POLL_OPTIONS, "show_value": total_choices}
)
def validate(self, data):
if data["allowed_choices"] > len(data["choices"]):
raise serializers.ValidationError(
pgettext(
"edit poll serializer",
"Number of allowed choices can't be greater than number of all choices.",
)
)
return data
def update(self, instance, validated_data):
if instance.choices:
self.update_choices(instance, validated_data["choices"])
return super().update(instance, validated_data)
def update_choices(self, instance, cleaned_choices):
removed_hashes = []
final_hashes = [c["hash"] for c in cleaned_choices]
for choice in instance.choices:
if choice["hash"] not in final_hashes:
instance.votes -= choice["votes"]
removed_hashes.append(choice["hash"])
if removed_hashes:
instance.pollvote_set.filter(choice_hash__in=removed_hashes).delete()
class NewPollSerializer(EditPollSerializer):
class Meta:
model = Poll
fields = [
"length",
"question",
"allowed_choices",
"allow_revotes",
"is_public",
"choices",
]
def validate_choices(self, choices):
clean_choices = list(map(self.clean_choice, choices))
self.validate_choices_num(clean_choices)
for choice in clean_choices:
choice.update({"hash": get_random_string(12), "votes": 0})
return clean_choices
class PollChoiceSerializer(serializers.Serializer):
hash = serializers.CharField(required=True, min_length=12, max_length=12)
label = serializers.CharField(required=True, max_length=255)
| 5,928
|
Python
|
.py
| 149
| 29.416107
| 107
| 0.594529
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,221
|
__init__.py
|
rafalp_Misago/misago/threads/serializers/__init__.py
|
from .moderation import *
from .threadparticipant import *
from .thread import *
from .post import *
from .feed import *
from .postedit import *
from .postlike import *
from .attachment import *
from .poll import *
from .pollvote import *
| 239
|
Python
|
.py
| 10
| 22.9
| 32
| 0.781659
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,222
|
attachment.py
|
rafalp_Misago/misago/threads/serializers/attachment.py
|
from django.urls import reverse
from rest_framework import serializers
from ..models import Attachment
__all__ = ["AttachmentSerializer"]
class AttachmentSerializer(serializers.ModelSerializer):
post = serializers.PrimaryKeyRelatedField(read_only=True)
acl = serializers.SerializerMethodField()
is_image = serializers.SerializerMethodField()
filetype = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = Attachment
fields = [
"id",
"filetype",
"post",
"uploaded_on",
"uploader_name",
"filename",
"size",
"acl",
"is_image",
"url",
]
def get_acl(self, obj):
try:
return obj.acl
except AttributeError:
return None
def get_is_image(self, obj):
return obj.is_image
def get_filetype(self, obj):
return obj.filetype.name
def get_url(self, obj):
return {
"index": obj.get_absolute_url(),
"thumb": obj.get_thumbnail_url(),
"uploader": self.get_uploader_url(obj),
}
def get_uploader_url(self, obj):
if obj.uploader_id:
return reverse(
"misago:user", kwargs={"slug": obj.uploader_slug, "pk": obj.uploader_id}
)
| 1,403
|
Python
|
.py
| 44
| 22.795455
| 88
| 0.584261
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,223
|
postedit.py
|
rafalp_Misago/misago/threads/serializers/postedit.py
|
from django.urls import reverse
from rest_framework import serializers
from ..models import PostEdit
__all__ = ["PostEditSerializer"]
class PostEditSerializer(serializers.ModelSerializer):
diff = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = PostEdit
fields = ["id", "edited_on", "editor_name", "editor_slug", "diff", "url"]
def get_diff(self, obj):
return obj.get_diff()
def get_url(self, obj):
return {"editor": self.get_editor_url(obj)}
def get_editor_url(self, obj):
if obj.editor_id:
return reverse(
"misago:user", kwargs={"slug": obj.editor_slug, "pk": obj.editor_id}
)
| 741
|
Python
|
.py
| 19
| 32.052632
| 84
| 0.652174
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,224
|
moderation.py
|
rafalp_Misago/misago/threads/serializers/moderation.py
|
from django.core.exceptions import PermissionDenied, ValidationError
from django.http import Http404
from django.utils.translation import npgettext, pgettext, pgettext_lazy
from rest_framework import serializers
from ...acl.objectacl import add_acl_to_obj
from ...categories import THREADS_ROOT_NAME
from ...conf import settings
from ..mergeconflict import MergeConflict
from ..models import Thread
from ..permissions import (
allow_delete_best_answer,
allow_delete_event,
allow_delete_post,
allow_delete_thread,
allow_merge_post,
allow_merge_thread,
allow_move_post,
allow_split_post,
can_reply_thread,
can_see_thread,
can_start_thread,
exclude_invisible_posts,
)
from ..threadtypes import trees_map
from ..utils import get_thread_id_from_url
from ..validators import validate_category, validate_thread_title
__all__ = [
"DeletePostsSerializer",
"DeleteThreadsSerializer",
"MergePostsSerializer",
"MergeThreadSerializer",
"MergeThreadsSerializer",
"MovePostsSerializer",
"NewThreadSerializer",
"SplitPostsSerializer",
]
def get_posts_limit(settings):
return settings.posts_per_page + settings.posts_per_page_orphans
class DeletePostsSerializer(serializers.Serializer):
error_empty_or_required = pgettext_lazy(
"delete posts serializer", "You have to specify at least one post to delete."
)
posts = serializers.ListField(
allow_empty=False,
child=serializers.IntegerField(
error_messages={
"invalid": pgettext_lazy(
"invalid posts ids",
"One or more post ids received were invalid.",
)
}
),
error_messages={
"required": error_empty_or_required,
"null": error_empty_or_required,
"empty": error_empty_or_required,
},
)
def validate_posts(self, data):
limit = get_posts_limit(self.context["settings"])
if len(data) > limit:
message = npgettext(
"delete posts serializer",
"No more than %(limit)s post can be deleted at a single time.",
"No more than %(limit)s posts can be deleted at a single time.",
limit,
)
raise ValidationError(message % {"limit": limit})
user_acl = self.context["user_acl"]
thread = self.context["thread"]
posts_queryset = exclude_invisible_posts(
user_acl, thread.category, thread.post_set
)
posts_queryset = posts_queryset.filter(id__in=data).order_by("id")
posts = []
for post in posts_queryset:
post.category = thread.category
post.thread = thread
if post.is_event:
allow_delete_event(user_acl, post)
else:
allow_delete_best_answer(user_acl, post)
allow_delete_post(user_acl, post)
posts.append(post)
if len(posts) != len(data):
raise PermissionDenied(
pgettext(
"delete posts serializer",
"One or more posts to delete could not be found.",
)
)
return posts
class MergePostsSerializer(serializers.Serializer):
error_empty_or_required = pgettext_lazy(
"merge posts serializer", "You have to select at least two posts to merge."
)
posts = serializers.ListField(
child=serializers.IntegerField(
error_messages={
"invalid": pgettext_lazy(
"invalid posts ids",
"One or more post ids received were invalid.",
)
}
),
error_messages={
"null": error_empty_or_required,
"required": error_empty_or_required,
},
)
def validate_posts(self, data):
limit = get_posts_limit(self.context["settings"])
data = list(set(data))
if len(data) < 2:
raise serializers.ValidationError(self.error_empty_or_required)
if len(data) > limit:
message = npgettext(
"merge posts serializer",
"No more than %(limit)s post can be merged at a single time.",
"No more than %(limit)s posts can be merged at a single time.",
limit,
)
raise serializers.ValidationError(message % {"limit": limit})
user_acl = self.context["user_acl"]
thread = self.context["thread"]
posts_queryset = exclude_invisible_posts(
user_acl, thread.category, thread.post_set
)
posts_queryset = posts_queryset.filter(id__in=data).order_by("id")
posts = []
for post in posts_queryset:
post.category = thread.category
post.thread = thread
try:
allow_merge_post(user_acl, post)
except PermissionDenied as e:
raise serializers.ValidationError(e)
if not posts:
posts.append(post)
continue
authorship_error = pgettext(
"merge posts serializer",
"Posts made by different users can't be merged.",
)
if post.poster_id != posts[0].poster_id:
raise serializers.ValidationError(authorship_error)
elif (
post.poster_id is None
and posts[0].poster_id is None
and post.poster_name != posts[0].poster_name
):
raise serializers.ValidationError(authorship_error)
if posts[0].is_first_post and post.is_best_answer:
raise serializers.ValidationError(
pgettext(
"merge posts serializer",
"Post marked as best answer can't be merged with thread's first post.",
)
)
if not posts[0].is_first_post:
if (
posts[0].is_hidden != post.is_hidden
or posts[0].is_unapproved != post.is_unapproved
):
raise serializers.ValidationError(
pgettext(
"merge posts serializer",
"Posts with different visibility can't be merged.",
)
)
posts.append(post)
if len(posts) != len(data):
raise serializers.ValidationError(
pgettext(
"merge posts serializer",
"One or more posts to merge could not be found.",
)
)
return posts
class MovePostsSerializer(serializers.Serializer):
error_empty_or_required = pgettext_lazy(
"move posts serializer", "You have to specify at least one post to move."
)
new_thread = serializers.CharField(
error_messages={
"required": pgettext_lazy(
"move posts serializer", "Enter link to new thread."
)
}
)
posts = serializers.ListField(
allow_empty=False,
child=serializers.IntegerField(
error_messages={
"invalid": pgettext_lazy(
"invalid posts ids",
"One or more post ids received were invalid.",
)
}
),
error_messages={
"empty": error_empty_or_required,
"null": error_empty_or_required,
"required": error_empty_or_required,
},
)
def validate_new_thread(self, data):
request = self.context["request"]
thread = self.context["thread"]
viewmodel = self.context["viewmodel"]
new_thread_id = get_thread_id_from_url(request, data)
if not new_thread_id:
raise serializers.ValidationError(
pgettext("invalid thread url", "This is not a valid thread link.")
)
if new_thread_id == thread.pk:
raise serializers.ValidationError(
pgettext(
"move posts serializer",
"Thread to move posts to is same as current one.",
)
)
try:
new_thread = viewmodel(request, new_thread_id).unwrap()
except Http404:
raise serializers.ValidationError(
pgettext(
"move posts serializer",
"The thread you have entered link to doesn't exist or you don't have permission to see it.",
)
)
if not new_thread.acl["can_reply"]:
raise serializers.ValidationError(
pgettext(
"move posts serializer",
"You can't move posts to threads you can't reply.",
)
)
return new_thread
def validate_posts(self, data):
limit = get_posts_limit(self.context["settings"])
data = list(set(data))
if len(data) > limit:
message = npgettext(
"move posts serializer",
"No more than %(limit)s post can be moved at a single time.",
"No more than %(limit)s posts can be moved at a single time.",
limit,
)
raise serializers.ValidationError(message % {"limit": limit})
request = self.context["request"]
thread = self.context["thread"]
posts_queryset = exclude_invisible_posts(
request.user_acl, thread.category, thread.post_set
)
posts_queryset = posts_queryset.filter(id__in=data).order_by("id")
posts = []
for post in posts_queryset:
post.category = thread.category
post.thread = thread
try:
allow_move_post(request.user_acl, post)
posts.append(post)
except PermissionDenied as e:
raise serializers.ValidationError(e)
if len(posts) != len(data):
raise serializers.ValidationError(
pgettext(
"move posts serializer",
"One or more posts to move could not be found.",
)
)
return posts
class NewThreadSerializer(serializers.Serializer):
title = serializers.CharField()
category = serializers.IntegerField()
weight = serializers.IntegerField(
required=False,
allow_null=True,
max_value=Thread.WEIGHT_GLOBAL,
min_value=Thread.WEIGHT_DEFAULT,
)
is_hidden = serializers.BooleanField(required=False, allow_null=True)
is_closed = serializers.BooleanField(required=False, allow_null=True)
def validate_title(self, title):
settings = self.context["settings"]
validate_thread_title(settings, title)
return title
def validate_category(self, category_id):
user_acl = self.context["user_acl"]
self.category = validate_category(user_acl, category_id)
if not can_start_thread(user_acl, self.category):
raise ValidationError(
pgettext(
"new thread serializer",
"You can't create new threads in selected category.",
)
)
return self.category
def validate_weight(self, weight):
try:
add_acl_to_obj(self.context["user_acl"], self.category)
except AttributeError:
return weight # don't validate weight further if category failed
if weight > self.category.acl.get("can_pin_threads", 0):
if weight == 2:
raise ValidationError(
pgettext(
"new thread serializer",
"You don't have permission to pin threads globally in this category.",
)
)
else:
raise ValidationError(
pgettext(
"new thread serializer",
"You don't have permission to pin threads in this category.",
)
)
return weight
def validate_is_hidden(self, is_hidden):
try:
add_acl_to_obj(self.context["user_acl"], self.category)
except AttributeError:
return is_hidden # don't validate hidden further if category failed
if is_hidden and not self.category.acl.get("can_hide_threads"):
raise ValidationError(
pgettext(
"new thread serializer",
"You don't have permission to hide threads in this category.",
)
)
return is_hidden
def validate_is_closed(self, is_closed):
try:
add_acl_to_obj(self.context["user_acl"], self.category)
except AttributeError:
return is_closed # don't validate closed further if category failed
if is_closed and not self.category.acl.get("can_close_threads"):
raise ValidationError(
pgettext(
"new thread serializer",
"You don't have permission to close threads in this category.",
)
)
return is_closed
class SplitPostsSerializer(NewThreadSerializer):
error_empty_or_required = pgettext_lazy(
"split posts serializer", "You have to specify at least one post to split."
)
posts = serializers.ListField(
allow_empty=False,
child=serializers.IntegerField(
error_messages={
"invalid": pgettext_lazy(
"invalid posts ids",
"One or more post ids received were invalid.",
)
}
),
error_messages={
"empty": error_empty_or_required,
"null": error_empty_or_required,
"required": error_empty_or_required,
},
)
def validate_posts(self, data):
limit = get_posts_limit(self.context["settings"])
if len(data) > limit:
message = npgettext(
"split posts serializer",
"No more than %(limit)s post can be split at a single time.",
"No more than %(limit)s posts can be split at a single time.",
limit,
)
raise ValidationError(message % {"limit": limit})
thread = self.context["thread"]
user_acl = self.context["user_acl"]
posts_queryset = exclude_invisible_posts(
user_acl, thread.category, thread.post_set
)
posts_queryset = posts_queryset.filter(id__in=data).order_by("id")
posts = []
for post in posts_queryset:
post.category = thread.category
post.thread = thread
try:
allow_split_post(user_acl, post)
except PermissionDenied as e:
raise ValidationError(str(e))
posts.append(post)
if len(posts) != len(data):
raise ValidationError(
pgettext(
"split posts serializer",
"One or more posts to split could not be found.",
)
)
return posts
class DeleteThreadsSerializer(serializers.Serializer):
error_empty_or_required = pgettext_lazy(
"delete threads serializer",
"You have to specify at least one thread to delete.",
)
threads = serializers.ListField(
allow_empty=False,
child=serializers.IntegerField(
error_messages={
"invalid": pgettext_lazy(
"invalid threads ids",
"One or more thread ids received were invalid.",
)
}
),
error_messages={
"required": error_empty_or_required,
"null": error_empty_or_required,
"empty": error_empty_or_required,
},
)
def validate_threads(self, data):
limit = self.context["settings"].threads_per_page
if len(data) > limit:
message = npgettext(
"delete threads serializer",
"No more than %(limit)s thread can be deleted at a single time.",
"No more than %(limit)s threads can be deleted at a single time.",
limit,
)
raise ValidationError(message % {"limit": limit})
request = self.context["request"]
viewmodel = self.context["viewmodel"]
threads = []
errors = []
for thread_id in data:
try:
thread = viewmodel(request, thread_id).unwrap()
allow_delete_thread(request.user_acl, thread)
threads.append(thread)
except PermissionDenied as e:
errors.append(
{
"thread": {"id": thread.id, "title": thread.title},
"error": str(e),
}
)
except Http404 as e:
pass # skip invisible threads
if errors:
raise serializers.ValidationError({"details": errors})
if len(threads) != len(data):
raise ValidationError(
pgettext(
"delete threads serializer",
"One or more threads to delete could not be found.",
)
)
return threads
class MergeThreadSerializer(serializers.Serializer):
other_thread = serializers.CharField(
error_messages={
"required": pgettext_lazy(
"merge thread serializer", "Enter link to new thread."
)
}
)
best_answer = serializers.IntegerField(
required=False,
error_messages={
"invalid": pgettext_lazy("merge threads serializer", "Invalid choice.")
},
)
poll = serializers.IntegerField(
required=False,
error_messages={
"invalid": pgettext_lazy("merge threads serializer", "Invalid choice.")
},
)
def validate_other_thread(self, data):
request = self.context["request"]
thread = self.context["thread"]
viewmodel = self.context["viewmodel"]
other_thread_id = get_thread_id_from_url(request, data)
if not other_thread_id:
raise ValidationError(
pgettext("invalid thread url", "This is not a valid thread link.")
)
if other_thread_id == thread.pk:
raise ValidationError(
pgettext(
"merge thread serializer", "You can't merge thread with itself."
)
)
try:
other_thread = viewmodel(request, other_thread_id).unwrap()
allow_merge_thread(request.user_acl, other_thread, otherthread=True)
except PermissionDenied as e:
raise serializers.ValidationError(e)
except Http404:
raise ValidationError(
pgettext(
"merge thread serializer",
"The thread you have entered link to doesn't exist or you don't have permission to see it.",
)
)
if not can_reply_thread(request.user_acl, other_thread):
raise ValidationError(
pgettext(
"merge thread serializer",
"You can't merge this thread into thread you can't reply.",
)
)
return other_thread
def validate(self, data):
thread = self.context["thread"]
other_thread = data["other_thread"]
merge_conflict = MergeConflict(data, [thread, other_thread])
merge_conflict.is_valid(raise_exception=True)
data.update(merge_conflict.get_resolution())
self.merge_conflict = merge_conflict.get_conflicting_fields()
return data
class MergeThreadsSerializer(NewThreadSerializer):
error_empty_or_required = pgettext_lazy(
"merge threads serializer", "You have to select at least two threads to merge."
)
threads = serializers.ListField(
allow_empty=False,
min_length=2,
child=serializers.IntegerField(
error_messages={
"invalid": pgettext_lazy(
"invalid threads ids",
"One or more thread ids received were invalid.",
)
}
),
error_messages={
"empty": error_empty_or_required,
"null": error_empty_or_required,
"required": error_empty_or_required,
"min_length": error_empty_or_required,
},
)
best_answer = serializers.IntegerField(
required=False,
error_messages={
"invalid": pgettext_lazy("merge threads serializer", "Invalid choice.")
},
)
poll = serializers.IntegerField(
required=False,
error_messages={
"invalid": pgettext_lazy("merge threads serializer", "Invalid choice.")
},
)
def validate_threads(self, data):
limit = self.context["settings"].threads_per_page
if len(data) > limit:
message = npgettext(
"merge threads serializer",
"No more than %(limit)s thread can be merged at a single time.",
"No more than %(limit)s threads can be merged at a single time.",
limit,
)
raise ValidationError(message % {"limit": limit})
threads_tree_id = trees_map.get_tree_id_for_root(THREADS_ROOT_NAME)
threads_queryset = (
Thread.objects.filter(id__in=data, category__tree_id=threads_tree_id)
.select_related("category")
.order_by("-id")
)
user_acl = self.context["user_acl"]
threads = []
for thread in threads_queryset:
add_acl_to_obj(user_acl, thread)
if can_see_thread(user_acl, thread):
threads.append(thread)
if len(threads) != len(data):
raise ValidationError(
pgettext(
"merge threads serializer",
"One or more threads to merge could not be found.",
)
)
return threads
| 22,631
|
Python
|
.py
| 585
| 26.557265
| 112
| 0.555723
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,225
|
threadparticipant.py
|
rafalp_Misago/misago/threads/serializers/threadparticipant.py
|
from rest_framework import serializers
from ..models import ThreadParticipant
__all__ = ["ThreadParticipantSerializer"]
class ThreadParticipantSerializer(serializers.ModelSerializer):
id = serializers.SerializerMethodField()
username = serializers.SerializerMethodField()
avatars = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = ThreadParticipant
fields = ["id", "username", "avatars", "url", "is_owner"]
def get_id(self, obj):
return obj.user.id
def get_username(self, obj):
return obj.user.username
def get_avatars(self, obj):
return obj.user.avatars
def get_url(self, obj):
return obj.user.get_absolute_url()
| 757
|
Python
|
.py
| 19
| 33.894737
| 65
| 0.717033
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,226
|
profilefields.py
|
rafalp_Misago/misago/profile/profilefields.py
|
from dataclasses import dataclass
from functools import cached_property
from typing import TYPE_CHECKING, Any, TypedDict, Sequence
from django.conf import settings
from django.forms import Field
from django.http import HttpRequest
from django.utils.module_loading import import_string
from ..users.profilefields.basefields import ProfileField
if TYPE_CHECKING:
from ..users.models import User
class ProfileFieldsetSetting(TypedDict):
name: str
fields: Sequence[str]
class FormDataFieldset(TypedDict):
name: str
fields: list[str]
@dataclass(frozen=True)
class FormData:
fieldsets: list[FormDataFieldset]
fields: dict[str, Field]
profile_fields: dict[str, ProfileField]
def clean_data(
self, field: str, data: Any, request: HttpRequest, user: "User"
) -> Any:
return self.profile_fields[field].clean(request, user, data)
class ProfileFieldsLoader:
fieldsets: Sequence[ProfileFieldsetSetting]
def __init__(self, fieldsets: Sequence[ProfileFieldsetSetting]):
self.fieldsets = fieldsets
@cached_property
def profile_fields(self) -> dict[str, ProfileField]:
fields: dict[str, ProfileField] = {}
for fieldset in self.fieldsets:
for field_path in fieldset["fields"]:
if field_path not in fields:
fields[field_path] = import_string(field_path)()
return fields
@cached_property
def fields_dict(self) -> dict[str, ProfileField]:
fields: dict[str, ProfileField] = {}
for field in self.profile_fields.values():
fields[field.fieldname] = field
return fields
def get_form_data(self, request: HttpRequest, user: "User") -> FormData | None:
profile_fields = dict(self.profile_fields)
fieldsets: list[FormDataFieldset] = []
fields: dict[str, Field] = {}
form_data_profile_fields: dict[str, ProfileField] = {}
for fieldset in self.fieldsets:
fieldset_fields: dict[str, Field] = {}
for field_path in fieldset["fields"]:
profile_field = profile_fields[field_path]
if profile_field.readonly:
continue
form_field = profile_field.get_form_field(request, user)
if not form_field:
continue
fieldset_fields[profile_field.fieldname] = form_field
form_data_profile_fields[profile_field.fieldname] = profile_field
if fieldset_fields:
fieldsets.append(
FormDataFieldset(
name=fieldset["name"],
fields=list(fieldset_fields),
)
)
fields.update(fieldset_fields)
if fieldsets and fields:
return FormData(
fieldsets=fieldsets,
fields=fields,
profile_fields=form_data_profile_fields,
)
return None
profile_fields = ProfileFieldsLoader(settings.MISAGO_PROFILE_FIELDS)
| 3,094
|
Python
|
.py
| 75
| 31.4
| 83
| 0.637579
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,227
|
apps.py
|
rafalp_Misago/misago/profile/apps.py
|
from django.apps import AppConfig
class MisagoProfileConfig(AppConfig):
name = "misago.profile"
label = "misago_profile"
verbose_name = "Misago Profile"
| 167
|
Python
|
.py
| 5
| 29.6
| 37
| 0.75625
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,228
|
misago_profile_fields.py
|
rafalp_Misago/misago/profile/templatetags/misago_profile_fields.py
|
from django import forms, template
from django.forms.boundfield import BoundField
register = template.Library()
TEXT_WIDGETS = (
forms.TextInput,
forms.EmailInput,
forms.PasswordInput,
forms.URLInput,
)
@register.filter
def profilefieldwidget(field: BoundField) -> dict:
if isinstance(field.field.widget, TEXT_WIDGETS):
return get_textinput_data(field)
if isinstance(field.field.widget, forms.Textarea):
return get_textarea_data(field)
if isinstance(field.field.widget, forms.RadioSelect):
return get_choice_data(field)
return {}
def get_textinput_data(field: BoundField) -> dict:
data = {
"input": "text",
"type": "text",
}
if isinstance(field.field.widget, forms.EmailInput):
data["type"] = "email"
elif isinstance(field.field.widget, forms.PasswordInput):
data["type"] = "password"
elif isinstance(field.field.widget, forms.URLInput):
data["type"] = "url"
return data
def get_textarea_data(field: BoundField) -> dict:
return {
"input": "textarea",
"rows": field.field.widget.attrs.get("rows"),
"cols": field.field.widget.attrs.get("cols"),
}
def get_choice_data(field: BoundField) -> dict:
return {
"input": "radiochoice",
"rows": field.field.widget.attrs.get("rows"),
"cols": field.field.widget.attrs.get("cols"),
}
| 1,421
|
Python
|
.py
| 42
| 28.047619
| 61
| 0.667401
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,229
|
test_profilefieldsloader.py
|
rafalp_Misago/misago/profile/tests/test_profilefieldsloader.py
|
from unittest.mock import ANY
from ...users.profilefields.default import GenderField, RealNameField
from ..profilefields import ProfileFieldsLoader
PROFILE_FIELDS_CONFIG = [
{
"name": "Fieldset",
"fields": [
"misago.users.profilefields.default.RealNameField",
"misago.users.profilefields.default.GenderField",
],
}
]
def test_profile_fields_loader_profile_fields_attr_returns_fields_objects():
loader = ProfileFieldsLoader(PROFILE_FIELDS_CONFIG)
assert len(loader.profile_fields) == 2
assert isinstance(
loader.profile_fields["misago.users.profilefields.default.RealNameField"],
RealNameField,
)
assert isinstance(
loader.profile_fields["misago.users.profilefields.default.GenderField"],
GenderField,
)
def test_profile_fields_loader_fields_dict_attr_returns_fields_objects():
loader = ProfileFieldsLoader(PROFILE_FIELDS_CONFIG)
assert len(loader.fields_dict) == 2
assert isinstance(loader.fields_dict[RealNameField.fieldname], RealNameField)
assert isinstance(loader.fields_dict[GenderField.fieldname], GenderField)
def test_profile_fields_loader_get_form_data_attr_returns_form_data_helper(user):
loader = ProfileFieldsLoader(PROFILE_FIELDS_CONFIG)
form_data = loader.get_form_data(None, user)
assert form_data.fieldsets == [
{
"name": "Fieldset",
"fields": [
ANY,
ANY,
],
}
]
assert form_data.fields == {
RealNameField.fieldname: ANY,
GenderField.fieldname: ANY,
}
| 1,631
|
Python
|
.py
| 44
| 30.090909
| 82
| 0.687183
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,230
|
urlpatterns.py
|
rafalp_Misago/misago/admin/urlpatterns.py
|
from django.urls import include, path
class URLPatterns:
def __init__(self):
self.namespace_patterns = None
self._namespaces = []
self._patterns = []
self._urlpatterns = None
def namespace(self, url_path, namespace, parent=None):
self._namespaces.append(
{"path": url_path, "parent": parent, "namespace": namespace}
)
def patterns(self, namespace, *new_patterns):
self._patterns.append({"namespace": namespace, "urlpatterns": new_patterns})
def single_pattern(self, url_path, namespace, parent, view):
self.namespace(url_path, namespace, parent)
self.patterns(":".join((parent, namespace)), path("", view, name="index"))
def get_child_patterns(self, parent):
prefix = "%s:" % parent if parent else ""
namespace_urlpatterns = self.namespace_patterns.get(parent, [])
for namespace in self._namespaces:
if namespace["parent"] == parent:
prefixed_namespace = prefix + namespace["namespace"]
child_patterns = self.get_child_patterns(prefixed_namespace)
included_patterns = include(
(child_patterns, namespace["namespace"]),
namespace=namespace["namespace"],
)
namespace_urlpatterns.append(path(namespace["path"], included_patterns))
return namespace_urlpatterns
def sum_registered_patters(self):
all_patterns = {}
for urls in self._patterns:
namespace = urls["namespace"]
added_patterns = urls["urlpatterns"]
all_patterns.setdefault(namespace, []).extend(added_patterns)
self.namespace_patterns = all_patterns
def build_root_urlpatterns(self):
root_urlpatterns = []
for namespace in self._namespaces:
if not namespace["parent"]:
child_patterns = self.get_child_patterns(namespace["namespace"])
included_patterns = include(
(child_patterns, namespace["namespace"]),
namespace=namespace["namespace"],
)
root_urlpatterns.append(path(namespace["path"], included_patterns))
return root_urlpatterns
def build_urlpatterns(self):
self.sum_registered_patters()
return self.build_root_urlpatterns()
def __call__(self):
if self._urlpatterns:
return self._urlpatterns
self._urlpatterns = self.build_urlpatterns()
self._namespaces = []
self._patterns = []
return self._urlpatterns
urlpatterns = URLPatterns()
| 2,659
|
Python
|
.py
| 58
| 35.051724
| 88
| 0.611992
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,231
|
discoverer.py
|
rafalp_Misago/misago/admin/discoverer.py
|
from importlib import import_module
from django.apps import apps
from .site import site
from .urlpatterns import urlpatterns
def discover_misago_admin():
for app in apps.get_app_configs():
module = import_module(app.name)
if not hasattr(module, "admin"):
continue
admin_module = import_module("%s.admin" % app.name)
if hasattr(admin_module, "MisagoAdminExtension"):
extension = getattr(admin_module, "MisagoAdminExtension")()
if hasattr(extension, "register_navigation_nodes"):
extension.register_navigation_nodes(site)
if hasattr(extension, "register_urlpatterns"):
extension.register_urlpatterns(urlpatterns)
| 732
|
Python
|
.py
| 16
| 37.1875
| 71
| 0.680731
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,232
|
test.py
|
rafalp_Misago/misago/admin/test.py
|
from django.urls import reverse
from ..users.test import SuperUserTestCase
class AdminTestCase(SuperUserTestCase):
def setUp(self):
super().setUp()
self.login_admin(self.user)
def login_admin(self, user):
self.client.post(
reverse("misago:admin:index"),
data={"username": user.email, "password": self.USER_PASSWORD},
)
self.client.get(reverse("misago:admin:index"))
| 442
|
Python
|
.py
| 12
| 29.5
| 74
| 0.659624
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,233
|
urls.py
|
rafalp_Misago/misago/admin/urls.py
|
from django.urls import path
from .. import admin
from .views import auth, index, select
urlpatterns = [
# "misago:admin:index" link symbolises "root" of Misago admin links space
# any request with path that falls below this one is assumed to be directed
# at Misago Admin and will be checked by Misago Admin Middleware
path("", index.admin_index, name="index"),
path("select/user/", select.select_user, name="select-user"),
path("logout/", auth.logout, name="logout"),
]
# Discover admin and register patterns
admin.discover_misago_admin()
urlpatterns += admin.urlpatterns()
| 603
|
Python
|
.py
| 14
| 40.142857
| 79
| 0.740614
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,234
|
apps.py
|
rafalp_Misago/misago/admin/apps.py
|
from django.apps import AppConfig
class MisagoAdminConfig(AppConfig):
name = "misago.admin"
label = "misago_admin"
verbose_name = "Misago Admin"
| 159
|
Python
|
.py
| 5
| 28
| 35
| 0.743421
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,235
|
auth.py
|
rafalp_Misago/misago/admin/auth.py
|
from hashlib import md5
from time import time
from django.contrib import auth as dj_auth
from django.contrib import messages
from django.utils.translation import pgettext
from ..conf import settings
TOKEN_KEY = "misago_admin_session_token"
UPDATED_KEY = "misago_admin_session_updated"
# Admin session state controls
def is_admin_authorized(request):
if request.user.is_anonymous:
return False
if not request.user.is_misago_admin:
return False
admin_token = request.session.get(TOKEN_KEY)
if not admin_token == make_user_admin_token(request.user):
return False
updated = request.session.get(UPDATED_KEY, 0)
if updated < time() - (settings.MISAGO_ADMIN_SESSION_EXPIRATION * 60):
if updated:
request.session.pop(UPDATED_KEY, None)
messages.info(
request, pgettext("admin auth", "Your admin session has expired.")
)
return False
return True
def authorize_admin(request):
request.session[TOKEN_KEY] = make_user_admin_token(request.user)
request.session[UPDATED_KEY] = int(time())
def update_admin_authorization(request):
request.session[UPDATED_KEY] = int(time())
def remove_admin_authorization(request):
request.session.pop(TOKEN_KEY, None)
request.session.pop(UPDATED_KEY, None)
def make_user_admin_token(user):
formula = (str(user.pk), user.email, user.password, settings.SECRET_KEY)
return md5(":".join(formula).encode()).hexdigest()
# Re-export login/logout from Django Admin
login = dj_auth.login
logout = dj_auth.logout
# Register signal for logout to make sure eventual admin session is closed
def django_login_handler(sender, **kwargs):
request, user = kwargs["request"], kwargs["user"]
try:
admin_namespace = request.admin_namespace
except AttributeError:
admin_namespace = False
if admin_namespace and user.is_misago_admin:
authorize_admin(request)
dj_auth.signals.user_logged_in.connect(django_login_handler)
def django_logout_handler(sender, **kwargs):
remove_admin_authorization(kwargs["request"])
dj_auth.signals.user_logged_out.connect(django_logout_handler)
| 2,189
|
Python
|
.py
| 53
| 36.169811
| 82
| 0.730204
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,236
|
__init__.py
|
rafalp_Misago/misago/admin/__init__.py
|
from .site import site
from .urlpatterns import urlpatterns
from .discoverer import discover_misago_admin
| 106
|
Python
|
.py
| 3
| 34.333333
| 45
| 0.864078
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,237
|
site.py
|
rafalp_Misago/misago/admin/site.py
|
from django.urls import reverse
class Node:
def __init__(self, *, name=None, description=None, icon=None, link=None):
self.parent = None
self.name = name
self.description = description
self.icon = icon
self.link = link
self._children = []
self._children_dict = {}
self._resolved_namespace = None
@property
def namespace(self):
if self._resolved_namespace:
return self._resolved_namespace
bits = self.link.split(":")
self._resolved_namespace = ":".join(bits[:-1])
return self._resolved_namespace
def children(self):
return self._children
def children_as_dicts(self):
childrens = []
for children in self._children:
childrens.append(
{
"name": children.name,
"description": children.description,
"icon": children.icon,
"link": reverse(children.link),
"namespace": children.namespace,
}
)
return childrens
def add_node(self, node, after=None, before=None):
if after:
return self.add_node_after(node, after)
if before:
return self.add_node_before(node, before)
node.parent = self
self._children.append(node)
self._children_dict[node.link] = node
return True
def add_node_after(self, node, after):
success = False
new_children_list = []
for children in self._children:
new_children_list.append(children)
if children.link == after:
new_children_list.append(node)
success = True
if success:
node.parent = self
self._children_dict[node.link] = node
self._children = new_children_list
return success
def add_node_before(self, node, before):
success = False
new_children_list = []
for children in self._children:
if children.link == before:
new_children_list.append(node)
success = True
new_children_list.append(children)
if success:
node.parent = self
self._children_dict[node.link] = node
self._children = new_children_list
return success
def child(self, namespace):
try:
return self._children_dict[namespace]
except KeyError:
raise ValueError(
"Node %s is not a child of node %s" % (namespace, self.name)
)
def is_root(self):
return False
class AdminSiteInvalidNodeError(Exception):
pass
class AdminSite:
def __init__(self):
self.nodes_record = []
self.nodes_dict = {}
def build_nodes_dict(self):
self.validate_nodes()
nodes_dict = {"misago:admin": Node(link="misago:admin:index")}
iterations = 0
while self.nodes_record:
iterations += 1
if iterations > 1024:
message = (
"Misago Admin hierarchy is invalid or too complex to resolve. "
"Nodes left: %s"
)
raise AdminSiteInvalidNodeError(message % self.nodes_record)
for index, node in enumerate(self.nodes_record):
if node["parent"] in nodes_dict:
node_obj = Node(
name=node["name"],
description=node["description"],
icon=node["icon"],
link=node["link"],
)
parent = nodes_dict[node["parent"]]
if node["after"]:
node_added = parent.add_node(node_obj, after=node["after"])
elif node["before"]:
node_added = parent.add_node(node_obj, before=node["before"])
else:
node_added = parent.add_node(node_obj)
if node_added:
namespace = node.get("namespace") or node_obj.namespace
if namespace not in nodes_dict:
nodes_dict[namespace] = node_obj
del self.nodes_record[index]
break
return nodes_dict
def add_node(
self,
*,
name=None,
description=None,
icon=None,
parent=None,
after=None,
before=None,
namespace=None,
link="index",
):
if self.nodes_dict:
raise RuntimeError(
"Misago admin site has already been initialized. "
"You can't add new nodes to it."
)
if after and before:
raise ValueError("after and before arguments are exclusive")
self.nodes_record.append(
{
"name": name,
"description": description,
"icon": icon,
"parent": join_namespace(parent),
"after": join_namespace(parent, after) if after else None,
"before": join_namespace(parent, before) if before else None,
"namespace": join_namespace(parent, namespace),
"link": join_namespace(parent, namespace, link),
}
)
def visible_branches(self, request):
if not self.nodes_dict:
self.nodes_dict = self.build_nodes_dict()
branches = []
try:
namespace = request.resolver_match.namespace
except AttributeError:
namespace = "misago:admin"
if namespace in self.nodes_dict:
node = self.nodes_dict[namespace]
while node:
children = node.children_as_dicts()
if children:
branches.append(children)
node = node.parent
try:
namespaces = request.resolver_match.namespaces
except AttributeError:
namespaces = ["misago", "admin"]
branches.reverse()
for depth, branch in enumerate(branches):
depth_namespace = namespaces[2 : 3 + depth]
for node in branch:
node_namespace = node["namespace"].split(":")[2 : 3 + depth]
if request.resolver_match:
node["is_active"] = depth_namespace == node_namespace
else:
node["is_active"] = False
return branches
def validate_nodes(self):
self.validate_nodes_parents()
self.validate_nodes_after()
self.validate_nodes_before()
def validate_nodes_parents(self):
parents: set[str] = {"misago:admin"}
for node in self.nodes_record:
parents.add(node["namespace"])
for node in self.nodes_record:
if node["parent"] not in parents:
raise AdminSiteInvalidNodeError(
f"Misago Admin node '{node['link']}' has an invalid parent "
f"'{node["parent"]}'."
)
def validate_nodes_after(self):
self.validate_nodes_ordering("after")
def validate_nodes_before(self):
self.validate_nodes_ordering("before")
def validate_nodes_ordering(self, node_attr: str):
for node in self.nodes_record:
self.validate_node_ordering(node, node_attr)
def validate_node_ordering(self, node: dict, node_attr: str):
if node[node_attr] is None:
return
node_siblings: set[str] = set()
for other_node in self.nodes_record:
if other_node == node:
continue
if other_node["parent"] == node["parent"]:
node_siblings.add(other_node["link"])
if node[node_attr] not in node_siblings:
raise AdminSiteInvalidNodeError(
f"Misago Admin node '{node['link']}' has an invalid {node_attr} "
f"node '{node[node_attr]}'."
)
def join_namespace(*args):
parts = list(filter(None, args))
parts.insert(0, "misago:admin")
return ":".join(parts)
site = AdminSite()
| 8,310
|
Python
|
.py
| 217
| 25.764977
| 85
| 0.53651
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,238
|
admin.py
|
rafalp_Misago/misago/admin/admin.py
|
from django.urls import path
from django.utils.translation import pgettext_lazy
from .categories import views as categories
from .groups import views as groups
from .moderators import views as moderators
class MisagoAdminExtension:
def register_navigation_nodes(self, site):
site.add_node(name=pgettext_lazy("admin node", "Dashboard"), icon="fa fa-home")
site.add_node(
name=pgettext_lazy("admin node", "Groups"),
icon="fas fa-adjust",
after="users:index",
namespace="groups",
)
site.add_node(
name=pgettext_lazy("admin node", "Categories"),
icon="fas fa-sitemap",
after="ranks:index",
namespace="categories",
)
site.add_node(
name=pgettext_lazy("admin node", "Moderators"),
icon="fas fa-shield-alt",
after="categories:index",
namespace="moderators",
)
def register_urlpatterns(self, urlpatterns):
urlpatterns.namespace("groups/", "groups")
urlpatterns.patterns(
"groups",
path("", groups.ListView.as_view(), name="index"),
path("ordering/", groups.OrderingView.as_view(), name="ordering"),
path("new/", groups.NewView.as_view(), name="new"),
path("edit/<int:pk>/", groups.EditView.as_view(), name="edit"),
path(
"categories/<int:pk>/",
groups.CategoryPermissionsView.as_view(),
name="categories",
),
path("default/<int:pk>/", groups.MakeDefaultView.as_view(), name="default"),
path("members/<int:pk>/", groups.MembersView.as_view(), name="members"),
path(
"members-main/<int:pk>/",
groups.MembersMainView.as_view(),
name="members-main",
),
path("delete/<int:pk>/", groups.DeleteView.as_view(), name="delete"),
)
urlpatterns.namespace("categories/", "categories")
urlpatterns.patterns(
"categories",
path("", categories.CategoriesList.as_view(), name="index"),
path("new/", categories.NewCategory.as_view(), name="new"),
path("edit/<int:pk>/", categories.EditCategory.as_view(), name="edit"),
path(
"permissions/<int:pk>/",
categories.CategoryPermissionsView.as_view(),
name="permissions",
),
path(
"move/down/<int:pk>/",
categories.MoveDownCategory.as_view(),
name="down",
),
path("move/up/<int:pk>/", categories.MoveUpCategory.as_view(), name="up"),
path(
"delete/<int:pk>/", categories.DeleteCategory.as_view(), name="delete"
),
)
urlpatterns.namespace("moderators/", "moderators")
urlpatterns.patterns(
"moderators",
path("", moderators.ListView.as_view(), name="index"),
path(
"new/group/<int:group>/", moderators.NewView.as_view(), name="new-group"
),
path("new/user/<int:user>/", moderators.NewView.as_view(), name="new-user"),
path("edit/<int:pk>/", moderators.EditView.as_view(), name="edit"),
path("delete/<int:pk>/", moderators.DeleteView.as_view(), name="delete"),
)
| 3,449
|
Python
|
.py
| 80
| 31.2375
| 88
| 0.550401
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,239
|
middleware.py
|
rafalp_Misago/misago/admin/middleware.py
|
from django.shortcuts import redirect
from django.utils.deprecation import MiddlewareMixin
from .auth import (
is_admin_authorized,
remove_admin_authorization,
update_admin_authorization,
)
from .views import get_protected_namespace
from .views.auth import login
class AdminAuthMiddleware(MiddlewareMixin):
def process_view(self, request, view_func, view_args, view_kwargs):
request.admin_namespace = get_protected_namespace(request)
if request.admin_namespace:
return self.check_admin_authorization(request)
def check_admin_authorization(self, request):
if not is_admin_authorized(request):
remove_admin_authorization(request)
if request.resolver_match.url_name == "index":
return login(request)
return redirect("%s:index" % request.admin_namespace)
update_admin_authorization(request)
| 908
|
Python
|
.py
| 21
| 36.47619
| 71
| 0.727891
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,240
|
momentjs.py
|
rafalp_Misago/misago/admin/momentjs.py
|
import os
from glob import glob
from pathlib import Path
MISAGO_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
MOMENT_LOCALES_DIR = os.path.join(MISAGO_DIR, "static", "misago", "admin", "momentjs")
def get_admin_locales():
locales = []
for locale_path in glob(os.path.join(MOMENT_LOCALES_DIR, "*.js")):
locales.append(Path(locale_path).stem)
return locales
MISAGO_ADMIN_MOMENT_LOCALES = get_admin_locales()
| 451
|
Python
|
.py
| 11
| 37.727273
| 86
| 0.721839
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,241
|
forms.py
|
rafalp_Misago/misago/admin/forms.py
|
import re
from typing import Any, Iterable, Type
from django.db.models import AutoField, CharField, Model
from django.forms import (
CharField,
DateTimeField,
RadioSelect,
TypedChoiceField,
TypedMultipleChoiceField,
ValidationError,
)
from django.core.validators import RegexValidator
from django.utils.translation import pgettext_lazy
from ..core.utils import parse_iso8601_string
def ColorField(**kwargs):
return CharField(
validators=[
RegexValidator(
r"^#[0-9a-f]{6}$",
flags=re.IGNORECASE,
message=pgettext_lazy(
"admin color field",
'Value must be a 7-character string specifying an RGB color in a hexadecimal format (eg.: "#F5A9B8").',
),
)
],
**kwargs
)
class IsoDateTimeField(DateTimeField):
input_formats = ["iso8601"]
def prepare_value(self, value):
try:
return value.isoformat()
except AttributeError:
return value
def to_python(self, value):
"""
Validates that the input can be converted to a datetime. Returns a
Python datetime.datetime object.
"""
if value in self.empty_values:
return None
try:
return parse_iso8601_string(value)
except ValueError:
raise ValidationError(self.error_messages["invalid"], code="invalid")
class YesNoSwitchBase(TypedChoiceField):
def prepare_value(self, value):
"""normalize bools to binary 1/0 so field works on them too"""
if value in (True, "True", "true", 1, "1"):
return 1
return 0
def clean(self, value):
return self.prepare_value(value)
def YesNoSwitch(**kwargs):
yes_label = kwargs.pop("yes_label", pgettext_lazy("admin yesno switch", "Yes"))
no_label = kwargs.pop("no_label", pgettext_lazy("admin yesno switch", "No"))
return YesNoSwitchBase(
coerce=int,
choices=[(1, yes_label), (0, no_label)],
widget=RadioSelect(attrs={"class": "yesno-switch"}),
**kwargs
)
| 2,158
|
Python
|
.py
| 63
| 26.222222
| 123
| 0.625
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,242
|
misago_admin_form.py
|
rafalp_Misago/misago/admin/templatetags/misago_admin_form.py
|
from django import forms, template
from django.utils.html import format_html_join
from ..forms import YesNoSwitchBase
register = template.Library()
@register.inclusion_tag("misago/admin/form/row.html")
def form_row(field, label_class=None, field_class=None):
return {"field": field, "label_class": label_class, "field_class": field_class}
@register.inclusion_tag("misago/admin/form/image_row.html")
def form_image_row(
field,
label_class=None,
field_class=None,
image_class=None,
delete_field=None,
size=None,
dimensions=None,
):
return {
"field": field,
"field_image": field.initial,
"size": size,
"dimensions": get_field_image_dimensions(dimensions),
"delete_field": delete_field,
"label_class": label_class,
"field_class": field_class,
"image_class": image_class,
}
def get_field_image_dimensions(dimensions):
if dimensions:
return {"width": dimensions[0], "height": dimensions[1]}
return None
@register.inclusion_tag("misago/admin/form/checkbox_row.html")
def form_checkbox_row(field, label_class=None, field_class=None):
return {"field": field, "label_class": label_class, "field_class": field_class}
@register.inclusion_tag("misago/admin/form/input.html")
def form_input(field):
attrs = {"id": field.auto_id}
if field.field.disabled:
attrs["disabled"] = True
elif field.field.required:
attrs["required"] = True
context = field.field.widget.get_context(field.html_name, field.value(), attrs)
context["field"] = field
return context
@register.simple_tag
def render_attrs(attrs, class_name=None):
rendered_attrs = []
for attr, value in attrs.items():
if value not in (True, False, None):
rendered_attrs.append((attr, value))
if not attrs.get("class") and class_name:
rendered_attrs.append(("class", class_name))
return format_html_join(" ", '{}="{}"', rendered_attrs)
BOOL_ATTRS = ("selected", "checked", "disabled", "required", "readonly")
@register.simple_tag
def render_bool_attrs(attrs):
attrs_html = []
for attr, value in attrs.items():
if attr in BOOL_ATTRS and value is True:
attrs_html.append(attr)
return " ".join(attrs_html)
@register.filter
def is_yesno_switch_field(field):
return isinstance(field.field, YesNoSwitchBase)
@register.filter
def is_radio_select_field(field):
return isinstance(field.field.widget, forms.RadioSelect)
@register.filter
def is_select_field(field):
return isinstance(field.field.widget, forms.Select)
MULTIPLE_CHOICE_WIDGETS = (forms.CheckboxSelectMultiple, forms.SelectMultiple)
@register.filter
def is_multiple_choice_field(field):
return isinstance(field.field.widget, MULTIPLE_CHOICE_WIDGETS)
@register.filter
def is_textarea_field(field):
return isinstance(field.field.widget, forms.Textarea)
@register.filter
def get_options(widget):
"""Filter that extracts field choices into an easily iterable list"""
options = []
for _, optgroup, _ in widget["optgroups"]:
options += optgroup
return options
| 3,159
|
Python
|
.py
| 84
| 32.833333
| 83
| 0.705457
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,243
|
forms.py
|
rafalp_Misago/misago/admin/categories/forms.py
|
from django import forms
from django.db import models
from django.utils.html import conditional_escape, mark_safe
from django.utils.translation import pgettext, pgettext_lazy
from mptt.forms import TreeNodeChoiceField, TreeNodeMultipleChoiceField
from ...admin.forms import YesNoSwitch
from ...categories.enums import CategoryTree, CategoryChildrenComponent
from ...categories.models import Category
from ...core.validators import validate_color_hex, validate_sluggable
class AdminCategoryFieldMixin:
def __init__(self, *args, **kwargs):
self.base_level = kwargs.pop("base_level", 1)
kwargs["level_indicator"] = kwargs.get("level_indicator", "- - ")
queryset = Category.objects.filter(tree_id=CategoryTree.THREADS)
if not kwargs.pop("include_root", False):
queryset = queryset.exclude(special_role="root_category")
kwargs.setdefault("queryset", queryset)
super().__init__(*args, **kwargs)
def _get_level_indicator(self, obj):
level = getattr(obj, obj._mptt_meta.level_attr) - self.base_level
if level > 0:
return mark_safe(conditional_escape(self.level_indicator) * level)
return ""
class AdminCategoryChoiceField(AdminCategoryFieldMixin, TreeNodeChoiceField):
pass
class AdminCategoryMultipleChoiceField(
AdminCategoryFieldMixin, TreeNodeMultipleChoiceField
):
pass
class CategoryForm(forms.ModelForm):
name = forms.CharField(
label=pgettext_lazy("admin category form", "Name"),
validators=[validate_sluggable()],
)
short_name = forms.CharField(
label=pgettext_lazy("admin category form", "Short name"),
required=False,
help_text=pgettext_lazy(
"admin category form",
"Optional, alternative or abbreviated name (eg. abbreviation) used on threads list.",
),
validators=[validate_sluggable()],
)
color = forms.CharField(
label=pgettext_lazy("admin category form", "Color"),
required=False,
help_text=pgettext_lazy(
"admin category form",
"Optional but recommended, should be in hex format, eg. #F5A9B8.",
),
validators=[validate_color_hex],
)
description = forms.CharField(
label=pgettext_lazy("admin category form", "Description"),
max_length=2048,
required=False,
widget=forms.Textarea(attrs={"rows": 3}),
help_text=pgettext_lazy(
"admin category form",
"Optional description explaining category intented purpose.",
),
)
css_class = forms.CharField(
label=pgettext_lazy("admin category form", "CSS class"),
required=False,
help_text=pgettext_lazy(
"admin category form",
"Optional CSS class used to customize this category's appearance from themes.",
),
)
allow_polls = YesNoSwitch(
label=pgettext_lazy("admin category form", "Allow polls"),
required=False,
help_text=pgettext_lazy(
"admin category form",
"Controls if users can start new polls in this category.",
),
)
delay_browse_check = YesNoSwitch(
label=pgettext_lazy(
"admin category form",
'Allow users without the "browse contents" permission to access category\'s threads list',
),
required=False,
help_text=pgettext_lazy(
"admin category form",
'Enabling this option will allow users with permission to "see" this category to access it\'s threads list page. They will receive an error if they try to see threads replies.',
),
)
show_started_only = YesNoSwitch(
label=pgettext_lazy(
"admin category form", "Show users only threads that they started"
),
required=False,
help_text=pgettext_lazy(
"admin category form",
"Enabling this option will limit users access to threads in this category to only the threads they have started. Moderators will still have access to all threads.",
),
)
is_closed = YesNoSwitch(
label=pgettext_lazy("admin category form", "Close category"),
required=False,
help_text=pgettext_lazy(
"admin category form",
"Only members with valid permissions can post in closed categories.",
),
)
is_vanilla = YesNoSwitch(
label=pgettext_lazy("admin category form", "Make category vanilla"),
required=False,
help_text=pgettext_lazy(
"admin category form",
'Vanilla categories behave like categories in "vanilla" forum software: users can\'t post threads directly in them. They are also displayed differently in the UI. Vanilla categories must have at least one visible subcategory to be shown to users.',
),
)
list_children_threads = YesNoSwitch(
label=pgettext_lazy(
"admin category form",
"Include threads from child categories on threads list",
),
required=False,
help_text=pgettext_lazy(
"admin category form",
"Enabling this option will make this category's threads list also include threads from child categories. For vanilla categories disabling this option will remove threads list from category page.",
),
)
children_categories_component = forms.CharField(
label=pgettext_lazy("admin category form", "Children categories UI component"),
help_text=pgettext_lazy(
"admin category form",
"Select UI component to use for displaying category's subcategories on its page.",
),
widget=forms.RadioSelect(
choices=CategoryChildrenComponent.get_category_choices(),
),
)
require_threads_approval = YesNoSwitch(
label=pgettext_lazy("admin category form", "Threads"),
required=False,
help_text=pgettext_lazy(
"admin category form",
"All threads started in this category will require moderator approval.",
),
)
require_replies_approval = YesNoSwitch(
label=pgettext_lazy("admin category form", "Replies"),
required=False,
help_text=pgettext_lazy(
"admin category form",
"All replies posted in this category will require moderator approval.",
),
)
require_edits_approval = YesNoSwitch(
label=pgettext_lazy("admin category form", "Edits"),
required=False,
help_text=pgettext_lazy(
"admin category form",
"Will make all edited replies return to unapproved state for moderator to review.",
),
)
prune_started_after = forms.IntegerField(
label=pgettext_lazy("admin category form", "Thread age"),
min_value=0,
help_text=pgettext_lazy(
"admin category form",
"Prune thread if number of days since its creation is greater than specified. Enter 0 to disable this pruning criteria.",
),
)
prune_replied_after = forms.IntegerField(
label=pgettext_lazy("admin category form", "Last reply"),
min_value=0,
help_text=pgettext_lazy(
"admin category form",
"Prune thread if number of days since last reply is greater than specified. Enter 0 to disable this pruning criteria.",
),
)
class Meta:
model = Category
fields = [
"name",
"short_name",
"color",
"description",
"css_class",
"allow_polls",
"delay_browse_check",
"show_started_only",
"is_closed",
"is_vanilla",
"list_children_threads",
"children_categories_component",
"require_threads_approval",
"require_replies_approval",
"require_edits_approval",
"prune_started_after",
"prune_replied_after",
"archive_pruned_in",
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setup_new_parent_field()
self.setup_copy_permissions_field()
self.setup_archive_pruned_in_field()
def setup_new_parent_field(self):
parent_queryset = Category.objects.all_categories(True).order_by("lft")
if self.instance.pk:
not_siblings = models.Q(lft__lt=self.instance.lft)
not_siblings = not_siblings | models.Q(rght__gt=self.instance.rght)
parent_queryset = parent_queryset.filter(not_siblings)
self.fields["new_parent"] = AdminCategoryChoiceField(
label=pgettext_lazy("admin category form", "Parent category"),
queryset=parent_queryset,
initial=self.instance.parent,
empty_label=None,
)
def setup_copy_permissions_field(self):
self.fields["copy_permissions"] = AdminCategoryChoiceField(
label=pgettext_lazy("admin category form", "Copy permissions"),
help_text=pgettext_lazy(
"admin category form",
"You can replace this category permissions with permissions copied from the category selected here.",
),
queryset=Category.objects.all_categories(),
empty_label=pgettext_lazy("admin category form", "Don't copy permissions"),
required=False,
)
def setup_archive_pruned_in_field(self):
self.fields["archive_pruned_in"] = AdminCategoryChoiceField(
label=pgettext_lazy("admin category form", "Archive"),
help_text=pgettext_lazy(
"admin category form",
"Instead of being deleted, pruned threads can be moved to designated category.",
),
queryset=Category.objects.all_categories(),
empty_label=pgettext_lazy(
"admin category form", "Don't archive pruned threads"
),
required=False,
)
def clean_copy_permissions(self):
data = self.cleaned_data["copy_permissions"]
if data and data.pk == self.instance.pk:
message = pgettext(
"admin category form",
"Permissions cannot be copied from category into itself.",
)
raise forms.ValidationError(message)
return data
def clean_archive_pruned_in(self):
data = self.cleaned_data["archive_pruned_in"]
if data and data.pk == self.instance.pk:
message = pgettext(
"admin category form", "Category cannot act as archive for itself."
)
raise forms.ValidationError(message)
return data
def clean(self):
data = super().clean()
self.instance.set_name(data.get("name"))
if not self.errors and data["is_vanilla"]:
self.validate_vanilla_invalid_values(data)
return data
def validate_vanilla_invalid_values(self, data: dict):
new_parent = data.get("new_parent")
if new_parent and new_parent.level != 0:
self.add_error(
"is_vanilla",
forms.ValidationError(
pgettext(
"admin category form",
"Only top-level categories can be set as vanilla.",
)
),
)
elif (
not data["list_children_threads"]
and data["children_categories_component"]
== CategoryChildrenComponent.DROPDOWN
):
self.add_error(
"children_categories_component",
forms.ValidationError(
pgettext(
"admin category form",
"This choice is not available for vanilla categories with disabled listing of child category threads.",
)
),
)
class DeleteCategoryForm(forms.ModelForm):
class Meta:
model = Category
fields = []
def __init__(self, *args, **kwargs):
super().__init__(*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)
children_queryset = children_queryset.filter(not_siblings).order_by("lft")
if children_queryset.exists():
self.fields["move_children_to"] = AdminCategoryChoiceField(
label=pgettext_lazy("admin category form", "Move child categories to"),
queryset=children_queryset,
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:
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"])
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.",
)
raise forms.ValidationError(message)
return data
| 14,254
|
Python
|
.py
| 334
| 32.209581
| 260
| 0.613456
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,244
|
views.py
|
rafalp_Misago/misago/admin/categories/views.py
|
from django.contrib import messages
from django.shortcuts import redirect
from django.utils.translation import pgettext_lazy
from ...acl.cache import clear_acl_cache
from ...admin.views import generic
from ...cache.enums import CacheName
from ...cache.versions import invalidate_cache
from ...categories.enums import CategoryTree
from ...categories.models import Category, RoleCategoryACL
from ...permissions.admin import get_admin_category_permissions
from ...permissions.copy import copy_category_permissions
from ...permissions.models import CategoryGroupPermission
from ...users.models import Group
from .forms import CategoryForm, DeleteCategoryForm
class CategoryAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:categories:index"
model = Category
templates_dir = "misago/admin/categories"
message_404 = pgettext_lazy(
"admin categories", "Requested category does not exist."
)
def get_target(self, request, kwargs):
target = super().get_target(request, kwargs)
target_is_special = bool(target.special_role)
target_not_in_categories_tree = target.tree_id != CategoryTree.THREADS
if target.pk and (target_is_special or target_not_in_categories_tree):
raise Category.DoesNotExist()
else:
return target
class CategoriesList(CategoryAdmin, generic.ListView):
def get_queryset(self):
return Category.objects.all_categories()
def process_context(self, request, context):
context["items"] = [f for f in context["items"]]
children_lists = {}
for item in context["items"]:
item.level_range = range(item.level - 1)
item.first = False
item.last = False
children_lists.setdefault(item.parent_id, []).append(item)
for level_items in children_lists.values():
level_items[0].first = True
level_items[-1].last = True
return context
class CategoryFormMixin:
form_class = CategoryForm
def handle_form(self, form, request, target):
if form.instance.pk:
if form.instance.parent_id != form.cleaned_data["new_parent"].pk:
form.instance.move_to(
form.cleaned_data["new_parent"], position="last-child"
)
form.instance.save()
else:
form.instance.insert_at(
form.cleaned_data["new_parent"], position="last-child", save=True
)
if form.cleaned_data.get("copy_permissions"):
form.instance.category_role_set.all().delete()
copy_from = form.cleaned_data["copy_permissions"]
copied_acls = []
for acl in copy_from.category_role_set.all():
copied_acls.append(
RoleCategoryACL(
role_id=acl.role_id,
category=form.instance,
category_role_id=acl.category_role_id,
)
)
if copied_acls:
RoleCategoryACL.objects.bulk_create(copied_acls)
copy_category_permissions(
form.cleaned_data["copy_permissions"], form.instance, request
)
clear_acl_cache()
invalidate_cache(
CacheName.CATEGORIES,
CacheName.MODERATORS,
CacheName.PERMISSIONS,
)
messages.success(request, self.message_submit % {"name": target.name})
class NewCategory(CategoryFormMixin, CategoryAdmin, generic.ModelFormView):
message_submit = pgettext_lazy(
"admin categories", 'New category "%(name)s" has been saved.'
)
class EditCategory(CategoryFormMixin, CategoryAdmin, generic.ModelFormView):
message_submit = pgettext_lazy(
"admin categories", 'Category "%(name)s" has been edited.'
)
class CategoryPermissionsView(CategoryAdmin, generic.PermissionsFormView):
template_name = "permissions.html"
message_submit = pgettext_lazy(
"admin categories", 'The "%(name)s" category permissions have been updated.'
)
def get_permissions(self, request, target):
return get_admin_category_permissions(self)
def get_items(self, request, target):
for group in Group.objects.values("id", "name"):
yield self.create_item(
id=group["id"],
name=group["name"],
)
def get_initial_data(self, request, target):
return CategoryGroupPermission.objects.filter(category=target).values_list(
"group_id", "permission"
)
def handle_form(self, data, request, target):
CategoryGroupPermission.objects.filter(category=target).delete()
new_permissions = []
for group_id, permissions in data.items():
for permission in permissions:
new_permissions.append(
CategoryGroupPermission(
category=target,
group_id=group_id,
permission=permission,
)
)
if new_permissions:
CategoryGroupPermission.objects.bulk_create(new_permissions)
invalidate_cache(CacheName.PERMISSIONS)
messages.success(request, self.message_submit % {"name": target.name})
class DeleteCategory(CategoryAdmin, generic.ModelFormView):
form_class = DeleteCategoryForm
message_submit = pgettext_lazy(
"admin categories", 'Category "%(name)s" has been deleted.'
)
template_name = "delete.html"
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")
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)
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()
invalidate_cache(
CacheName.CATEGORIES,
CacheName.MODERATORS,
CacheName.PERMISSIONS,
)
messages.success(request, self.message_submit % {"name": target.name})
return redirect(self.root_link)
class MoveDownCategory(CategoryAdmin, generic.ButtonView):
def button_action(self, request, target):
try:
other_target = target.get_next_sibling()
except Category.DoesNotExist:
other_target = None
if other_target:
Category.objects.move_node(target, other_target, "right")
invalidate_cache(CacheName.CATEGORIES)
message = pgettext_lazy(
"admin categories",
'Category "%(name)s" has been moved below "%(other)s".',
)
targets_names = {"name": target.name, "other": other_target.name}
messages.success(request, message % targets_names)
class MoveUpCategory(CategoryAdmin, generic.ButtonView):
def button_action(self, request, target):
try:
other_target = target.get_previous_sibling()
except Category.DoesNotExist:
other_target = None
if other_target:
Category.objects.move_node(target, other_target, "left")
invalidate_cache(CacheName.CATEGORIES)
message = pgettext_lazy(
"admin categories",
'Category "%(name)s" has been moved above "%(other)s".',
)
targets_names = {"name": target.name, "other": other_target.name}
messages.success(request, message % targets_names)
| 8,341
|
Python
|
.py
| 189
| 33.497354
| 84
| 0.625262
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,245
|
select.py
|
rafalp_Misago/misago/admin/views/select.py
|
from django.contrib.auth import get_user_model
from django.shortcuts import render
from ...users.utils import slugify_username
User = get_user_model()
MAX_RESULTS = 10
def select_user(request):
search = request.GET.get("search", "").strip()
if search:
username = slugify_username(search)
choices = User.objects.filter(slug=username).union(
User.objects.filter(slug__startswith=username)[:MAX_RESULTS]
)
else:
choices = User.objects.none()
return render(
request, "misago/admin/select/user.html", {"search": search, "choices": choices}
)
| 616
|
Python
|
.py
| 17
| 30.588235
| 88
| 0.685811
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,246
|
auth.py
|
rafalp_Misago/misago/admin/views/auth.py
|
from django.contrib import messages
from django.shortcuts import redirect, render
from django.utils.translation import pgettext
from django.views.decorators.cache import never_cache
from django.views.decorators.csrf import csrf_protect
from django.views.decorators.debug import sensitive_post_parameters
from .. import auth
from ...users.forms.auth import AdminAuthenticationForm
@sensitive_post_parameters()
@csrf_protect
@never_cache
def login(request):
if request.admin_namespace == "misago:admin":
target = "misago"
elif request.admin_namespace == "admin":
target = "django"
else:
target = "unknown"
form = AdminAuthenticationForm(request=request)
if request.method == "POST":
form = AdminAuthenticationForm(request.POST, request=request)
if form.is_valid():
auth.login(request, form.user_cache)
return redirect("%s:index" % request.admin_namespace)
return render(request, "misago/admin/login.html", {"form": form, "target": target})
@csrf_protect
@never_cache
def logout(request):
if request.method == "POST":
auth.remove_admin_authorization(request)
messages.info(
request, pgettext("admin auth", "Your admin session has been closed.")
)
return redirect("misago:admin:index")
| 1,322
|
Python
|
.py
| 34
| 33.764706
| 87
| 0.723438
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,247
|
__init__.py
|
rafalp_Misago/misago/admin/views/__init__.py
|
from typing import Any, Dict, Optional
from django.http import HttpRequest
from django.urls import reverse, NoReverseMatch
from django.utils.translation import get_language
from django.shortcuts import render as dj_render
from ...conf import settings
from ...core.momentjs import get_locale_url
from .. import site
from ..auth import is_admin_authorized, update_admin_authorization
from ..momentjs import MISAGO_ADMIN_MOMENT_LOCALES
from .auth import login
def get_protected_namespace(request):
for namespace in settings.MISAGO_ADMIN_NAMESPACES:
try:
admin_path = reverse("%s:index" % namespace)
if request.path.startswith(admin_path):
return namespace
except NoReverseMatch:
pass
def render(
request: HttpRequest,
template: str,
context: Optional[Dict[str, Any]] = None,
error_page: bool = False,
):
context = context or {}
navigation = site.visible_branches(request)
sections = navigation[0]
try:
actions = navigation[1]
except IndexError:
actions = []
context.update({"sections": sections, "actions": actions})
if error_page:
# admittedly haxy solution for displaying navs on error pages
context["actions"] = []
context["pages"] = []
for item in sections:
item["is_active"] = False
else:
context["active_section"] = None
for item in sections:
if item["is_active"]:
context["active_section"] = item
break
context["active_link"] = None
for nav in navigation:
for item in nav:
if item["is_active"]:
context["active_link"] = item
break
context["ADMIN_MOMENTJS_LOCALE_URL"] = get_admin_moment_locale_url()
return dj_render(request, template, context)
def get_admin_moment_locale_url():
return get_locale_url(
get_language(),
static_path_template="misago/admin/momentjs/%s.js",
locales=MISAGO_ADMIN_MOMENT_LOCALES,
)
# Decorator for views
def protected_admin_view(f):
def decorator(request, *args, **kwargs):
protected_view = get_protected_namespace(request)
if protected_view:
if is_admin_authorized(request):
update_admin_authorization(request)
return f(request, *args, **kwargs)
request.admin_namespace = protected_view
return login(request)
return f(request, *args, **kwargs)
return decorator
| 2,576
|
Python
|
.py
| 71
| 28.492958
| 72
| 0.645758
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,248
|
index.py
|
rafalp_Misago/misago/admin/views/index.py
|
from datetime import timedelta
from django.conf import settings
from django.contrib.auth import get_user_model
from django.core.cache import cache
from django.utils import timezone
from . import render
from ...threads.models import Post, Thread, Attachment
from ...users.models import DataDownload
VERSION_CHECK_CACHE_KEY = "misago_version_check"
User = get_user_model()
def admin_index(request):
totals = count_db_items()
checks = {
"address": check_forum_address(request),
"cache": check_cache(),
"data_downloads": check_data_downloads(),
"debug": check_debug_status(),
"https": check_https(request),
"inactive_users": check_inactive_users(),
}
return render(
request,
"misago/admin/dashboard/index.html",
{"totals": totals, "checks": checks},
)
def check_cache():
cache.set("misago_cache_test", "ok")
return {"is_ok": cache.get("misago_cache_test") == "ok"}
def check_debug_status():
return {"is_ok": not settings.DEBUG}
def check_https(request):
return {"is_ok": request.is_secure()}
def check_forum_address(request):
set_address = request.settings.forum_address
correct_address = request.build_absolute_uri("/").rstrip("/")
return {
"is_ok": set_address == correct_address,
"set_address": set_address,
"correct_address": correct_address,
}
def check_data_downloads():
cutoff = timezone.now() - timedelta(days=3)
unprocessed_count = DataDownload.objects.filter(
status__lte=DataDownload.STATUS_PROCESSING, requested_on__lte=cutoff
).count()
return {"is_ok": unprocessed_count == 0, "count": unprocessed_count}
def check_inactive_users():
count = User.objects.exclude(requires_activation=User.ACTIVATION_NONE).count()
return {"is_ok": count <= 10, "count": count}
def count_db_items():
return {
"attachments": Attachment.objects.count(),
"threads": Thread.objects.count(),
"posts": Post.objects.count(),
"users": User.objects.count(),
}
| 2,083
|
Python
|
.py
| 56
| 31.857143
| 82
| 0.675649
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,249
|
errorpages.py
|
rafalp_Misago/misago/admin/views/errorpages.py
|
from django.shortcuts import redirect, render as dj_render
from . import get_protected_namespace, protected_admin_view, render
from ...core.utils import get_exception_message
from ..auth import is_admin_authorized, update_admin_authorization
# Magic error page used by admin
@protected_admin_view
def _error_page(request, code, exception=None, default_message=None):
if not is_admin_authorized(request):
return redirect("misago:admin:index")
template_pattern = "misago/admin/errorpages/%s.html" % code
response = render(
request,
template_pattern,
{"message": get_exception_message(exception, default_message)},
error_page=True,
)
response.status_code = code
return response
def admin_error_page(f):
def decorator(request, *args, **kwargs):
if get_protected_namespace(request):
update_admin_authorization(request)
return _error_page(request, *args, **kwargs)
return f(request, *args, **kwargs)
return decorator
# Magic CSRF fail page for Admin
def _csrf_failure(request, reason=""):
if is_admin_authorized(request):
update_admin_authorization(request)
response = render(
request,
"misago/admin/errorpages/csrf_failure_authenticated.html",
error_page=True,
)
else:
response = dj_render(request, "misago/admin/errorpages/csrf_failure.html")
response.status_code = 403
return response
def admin_csrf_failure(f):
def decorator(request, *args, **kwargs):
if get_protected_namespace(request):
return _csrf_failure(request, *args, **kwargs)
return f(request, *args, **kwargs)
return decorator
| 1,732
|
Python
|
.py
| 44
| 32.772727
| 82
| 0.688769
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,250
|
ordering.py
|
rafalp_Misago/misago/admin/views/generic/ordering.py
|
from django.core.exceptions import ValidationError
from django.db.models import Model
from django.http import HttpRequest, HttpResponse
from django.utils.translation import pgettext
from .base import AdminView
class OrderingView(AdminView):
def post(self, request: HttpRequest):
items = {item.pk: item for item in self.get_queryset()}
try:
ordered_items = self.get_ordered_items(request, items)
self.order_items(request, ordered_items)
return HttpResponse(status=204)
except ValidationError as error:
return HttpResponse(error.message, status=400)
def get_queryset(self):
return self.get_model().objects.all()
def get_ordered_items(
self, request: HttpRequest, items: dict[int, Model]
) -> list[Model]:
items_ordering = request.POST.getlist("item")
if not items_ordering:
raise ValidationError(pgettext("admin reorder", "No items sent."))
ordered_items: dict[int, Model] = {}
for item_id_str in items_ordering:
try:
item_id = int(item_id_str)
except (TypeError, ValueError):
raise ValidationError(
pgettext("admin reorder", "Invalid item type: %(item)s")
% {"item": item_id_str}
)
if item_id in ordered_items:
raise ValidationError(
pgettext("admin reorder", "The item is not unique: %(item)s")
% {"item": item_id}
)
try:
ordered_items[item_id] = items[item_id]
except KeyError:
raise ValidationError(
pgettext("admin reorder", "The item does not exist: %(item)s")
% {"item": item_id}
)
return list(ordered_items.values())
def order_items(self, request: HttpRequest, items: list[Model]):
pass
| 1,979
|
Python
|
.py
| 46
| 31.456522
| 82
| 0.587103
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,251
|
mixin.py
|
rafalp_Misago/misago/admin/views/generic/mixin.py
|
class AdminBaseMixin:
"""
Admin mixin abstraciton used for configuring admin CRUD views.
Takes following attributes:
model - Model instance
root_link - name of link leading to root action (eg. list of all items
templates_dir - directory with templates
message_404 - string used in "requested item not found" messages
"""
model = None
root_link = None
templates_dir = None
message_404 = None
def get_model(self):
"""basic method for retrieving Model, used in cases such as User model."""
return self.model
| 577
|
Python
|
.py
| 16
| 30.5625
| 82
| 0.696589
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,252
|
formsbuttons.py
|
rafalp_Misago/misago/admin/views/generic/formsbuttons.py
|
from django.contrib import messages
from django.db import transaction
from django.shortcuts import redirect
from django.utils.translation import pgettext_lazy
from ....users.models import Group
from .base import AdminView
SAFE_HTTP_METHODS = ("GET", "HEAD", "OPTIONS", "TRACE")
class TargetedView(AdminView):
is_atomic = True
def dispatch(self, request, *args, **kwargs):
if self.is_atomic and request.method not in SAFE_HTTP_METHODS:
with transaction.atomic():
return self.wrapped_dispatch(request, *args, **kwargs)
return self.wrapped_dispatch(request, *args, **kwargs)
def wrapped_dispatch(self, request, *args, **kwargs):
target = self.get_target_or_none(request, kwargs)
if not target:
messages.error(request, self.message_404)
return redirect(self.root_link)
error = self.check_permissions( # pylint: disable=assignment-from-no-return
request, target
)
if error:
messages.error(request, error)
return redirect(self.root_link)
return self.real_dispatch(request, target)
def get_target_or_none(self, request, kwargs):
try:
return self.get_target(request, kwargs)
except self.get_model().DoesNotExist:
return None
def get_target(self, request, kwargs):
if len(kwargs) > 1:
raise ValueError("TargetedView.get_target() received more than one kwarg")
if len(kwargs) != 1:
return self.get_model()()
queryset = self.get_model().objects
if self.is_atomic and request.method not in SAFE_HTTP_METHODS:
queryset = queryset.select_for_update()
(pk,) = kwargs.values()
return queryset.get(pk=pk)
def check_permissions(self, request, target):
pass
def real_dispatch(self, request, target):
pass
class FormView(TargetedView):
form_class = None
template_name = "form.html"
def get_form_class(self, request):
return self.form_class
def get_form(self, form_class, request):
if request.method == "POST":
return form_class(request.POST, request.FILES)
return form_class()
def handle_form(self, form, request):
raise NotImplementedError(
"You have to define your own handle_form method to handle form submissions."
)
def real_dispatch(self, request, target):
FormType = self.get_form_class(request)
form = self.get_form(FormType, request)
if request.method == "POST" and form.is_valid():
response = self.handle_form(form, request)
if response:
return response
if "stay" in request.POST:
return redirect(request.path)
return redirect(self.root_link)
return self.render(request, {"form": form})
class ModelFormView(FormView):
message_submit = None
def get_form_class(self, request, target):
return self.form_class
def get_form(self, form_class, request, target):
if request.method == "POST":
return form_class(request.POST, request.FILES, instance=target)
return form_class(instance=target)
def handle_form(self, form, request, target):
form.instance.save()
if self.message_submit:
messages.success(request, self.message_submit % {"name": target.name})
def real_dispatch(self, request, target):
form_class = self.get_form_class(request, target)
form = self.get_form(form_class, request, target)
if request.method == "POST" and form.is_valid():
response = self.handle_form( # pylint: disable=assignment-from-no-return
form, request, target
)
if response:
return response
if "stay" in request.POST:
return redirect(request.path)
return redirect(self.root_link)
template_name = self.get_template_name(request, target)
return self.render(request, {"form": form, "target": target}, template_name)
def get_template_name(self, request, target):
return "%s/%s" % (self.templates_dir, self.template_name)
class PermissionsFormView(TargetedView):
message_empty = pgettext_lazy(
"admin permissions table", "No items exist to set permissions for."
)
def get_permissions(self, request, target):
return []
@staticmethod
def create_permission(
*,
id: str,
name: str,
help_text: str | None = None,
color: str | None = None,
) -> dict:
return {
"id": id,
"name": str(name),
"help_text": str(help_text) if help_text else None,
"color": color or "#fff",
}
def get_items(self, request, target):
return []
@staticmethod
def create_item(*, id: str, name: str, level: int = 0) -> dict:
return {"id": id, "name": str(name), "level": level * "-", "permissions": []}
def get_initial_data(self, request, target) -> list[tuple[int, str]]:
return []
def handle_form(self, request, target, data):
pass
def real_dispatch(self, request, target):
permissions = list(self.get_permissions(request, target))
items = list(self.get_items(request, target))
if not items:
messages.info(request, self.message_empty)
return redirect(self.root_link)
if request.method == "POST":
data = {}
for item in items:
data[item["id"]] = []
row_permissions = request.POST.getlist(f"permissions[{item['id']}]")
for permission in permissions:
if permission["id"] in row_permissions:
data[item["id"]].append(permission["id"])
response = self.handle_form(data, request, target)
if response:
return response
if "stay" in request.POST:
return redirect(request.path)
return redirect(self.root_link)
initial_data = {}
for item_id, permission in self.get_initial_data(request, target):
initial_data.setdefault(item_id, []).append(permission)
for item in items:
item["permissions"] = initial_data.get(item["id"], [])
template_name = self.get_template_name(request, target)
return self.render(
request,
{
"target": target,
"table_permissions": permissions,
"table_items": items,
},
template_name,
)
def get_template_name(self, request, target):
return "%s/%s" % (self.templates_dir, self.template_name)
class ButtonView(TargetedView):
def real_dispatch(self, request, target):
if request.method == "POST":
new_response = self.button_action(request, target)
if new_response:
return new_response
return redirect(self.root_link)
def button_action(self, request, target):
raise NotImplementedError("You have to define custom button_action.")
| 7,275
|
Python
|
.py
| 172
| 32.47093
| 88
| 0.610237
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,253
|
__init__.py
|
rafalp_Misago/misago/admin/views/generic/__init__.py
|
from .mixin import AdminBaseMixin
from .base import AdminView
from .list import ListView, MassActionError
from .ordering import OrderingView
from .formsbuttons import (
ButtonView,
FormView,
ModelFormView,
PermissionsFormView,
TargetedView,
)
__all__ = [
"AdminBaseMixin",
"AdminView",
"ButtonView",
"FormView",
"ListView",
"MassActionError",
"ModelFormView",
"OrderingView",
"PermissionsFormView",
"TargetedView",
]
| 478
|
Python
|
.py
| 23
| 17.130435
| 43
| 0.718062
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,254
|
base.py
|
rafalp_Misago/misago/admin/views/generic/base.py
|
from django.views import View
from .. import render
class AdminView(View):
def get_template_name(self, request):
return "%s/%s" % (self.templates_dir, self.template_name)
def current_link(self, request):
matched_url = request.resolver_match.url_name
return "%s:%s" % (request.resolver_match.namespace, matched_url)
def process_context(self, request, context):
"""simple hook for extending and manipulating template context."""
return context
def render(self, request, context=None, template_name=None):
context = context or {}
context["root_link"] = self.root_link
context["current_link"] = self.current_link(request)
context = self.process_context(request, context)
template_name = template_name or self.get_template_name(request)
return render(request, template_name, context)
| 892
|
Python
|
.py
| 18
| 42.277778
| 74
| 0.689017
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,255
|
list.py
|
rafalp_Misago/misago/admin/views/generic/list.py
|
from urllib.parse import urlencode
from django.contrib import messages
from django.core.paginator import EmptyPage, Paginator
from django.db import transaction
from django.shortcuts import redirect
from django.urls import reverse
from django.utils.translation import pgettext_lazy
from ....core.exceptions import ExplicitFirstPage
from .base import AdminView
class MassActionError(Exception):
pass
class ListView(AdminView):
"""
Admin items list view
Uses following attributes:
template = template name used to render items list
items_per_page = number of items displayed on single page
(enter 0 or don't define for no pagination)
ordering = tuple of tuples defining allowed orderings
typles should follow this format: (name, order_by)
"""
template_name = "list.html"
items_per_page = 0
ordering = None
extra_actions = None
mass_actions = None
selection_label = pgettext_lazy("admin lists", "Selected: 0")
empty_selection_label = pgettext_lazy("admin lists", "Select items")
@classmethod
def add_mass_action(cls, action, name, confirmation=None):
if not cls.mass_actions:
cls.mass_actions = []
cls.extra_actions.append(
{"action": action, "name": name, "confirmation": confirmation}
)
@classmethod
def add_item_action(cls, name, link):
if not cls.extra_actions:
cls.extra_actions = []
cls.extra_actions.append({"name": name, "link": link})
def get_queryset(self):
return self.get_model().objects.all()
def dispatch(
self, request, *args, **kwargs
): # pylint: disable=too-many-branches, too-many-locals
mass_actions_list = self.mass_actions or []
extra_actions_list = self.extra_actions or []
refresh_querystring = False
context = {
"items": self.get_queryset(),
"paginator": None,
"page": None,
"order_by": [],
"order": None,
"filter_form": None,
"active_filters": {},
"querystring": "",
"query_order": {},
"query_filters": {},
"selected_items": [],
"selection_label": self.selection_label,
"empty_selection_label": self.empty_selection_label,
"mass_actions": mass_actions_list,
"extra_actions": extra_actions_list,
"extra_actions_len": len(extra_actions_list),
}
if request.method == "POST" and mass_actions_list:
try:
response = self.handle_mass_action(request, context)
if response:
return response
return redirect(request.path)
except MassActionError as e:
messages.error(request, e.args[0])
if self.ordering:
ordering_methods = self.get_ordering_methods(request)
used_method = self.get_ordering_method_to_use(ordering_methods)
self.set_ordering_in_context(context, used_method)
if (
ordering_methods["GET"]
and ordering_methods["GET"] != ordering_methods["session"]
):
# Store GET ordering in session for future requests
session_key = self.ordering_session_key
request.session[session_key] = ordering_methods["GET"]
if context["order_by"] and not ordering_methods["GET"]:
# Make view redirect to itself with querystring,
# So address ball contains copy-friendly link
refresh_querystring = True
filter_form = self.get_filter_form(request)
if filter_form:
filtering_methods = self.get_filtering_methods(request, filter_form)
active_filters = self.get_filtering_method_to_use(filtering_methods)
if request.GET.get("clear_filters"):
# Clear filters from querystring
request.session.pop(self.filters_session_key, None)
active_filters = {}
self.apply_filtering_on_context(context, active_filters, filter_form)
if (
filtering_methods["GET"]
and filtering_methods["GET"] != filtering_methods["session"]
):
# Store GET filters in session for future requests
session_key = self.filters_session_key
request.session[session_key] = filtering_methods["GET"]
if request.GET.get("set_filters"):
# Force store filters in session
session_key = self.filters_session_key
request.session[session_key] = context["active_filters"]
refresh_querystring = True
if context["active_filters"] and not filtering_methods["GET"]:
# Make view redirect to itself with querystring,
# so address bar contains copy-friendly link
refresh_querystring = True
self.make_querystring(context)
if self.items_per_page:
try:
self.paginate_items(context, kwargs.get("page", 0))
except EmptyPage:
return redirect(
"%s%s" % (reverse(self.root_link), context["querystring"])
)
if refresh_querystring and "redirected" not in request.GET:
return redirect("%s%s" % (request.path, context["querystring"]))
return self.render(request, context)
def paginate_items(self, context, page):
try:
page = int(page)
if page == 1:
raise ExplicitFirstPage()
elif page == 0:
page = 1
except ValueError:
page = 1
context["paginator"] = Paginator(
context["items"], self.items_per_page, allow_empty_first_page=True
)
context["page"] = context["paginator"].page(page)
context["items"] = context["page"].object_list
# Filter list items
filter_form = None
def get_filter_form(self, request):
return self.filter_form
@property
def filters_session_key(self):
return "misago_admin_%s_filters" % self.root_link
def get_filtering_methods(self, request, filter_form):
methods = {
"GET": self.get_filters_from_GET(request, filter_form),
"session": self.get_filters_from_session(request, filter_form),
}
if request.GET.get("set_filters"):
methods["session"] = {}
return methods
def get_filters_from_GET(self, request, filter_form):
form = filter_form(request.GET)
form.is_valid()
return self.clean_filtering_data(form.cleaned_data)
def get_filters_from_session(self, request, filter_form):
session_filters = request.session.get(self.filters_session_key, {})
form = filter_form(session_filters)
form.is_valid()
return self.clean_filtering_data(form.cleaned_data)
def clean_filtering_data(self, data):
for key, value in list(data.items()):
if not value:
del data[key]
return data
def get_filtering_method_to_use(self, methods):
for method in ("GET", "session"):
if methods.get(method):
return methods.get(method)
return {}
def apply_filtering_on_context(self, context, active_filters, filter_form):
context["active_filters"] = active_filters
context["filter_form"] = filter_form(initial=context["active_filters"])
if context["active_filters"]:
context["items"] = context["filter_form"].filter_queryset(
active_filters, context["items"]
)
# Order list items
def get_ordering_methods(self, request):
return {
"GET": self.get_ordering_from_GET(request),
"session": self.get_ordering_from_session(request),
"default": self.clean_ordering(self.ordering[0][0]),
}
def get_ordering_from_GET(self, request):
sort = request.GET.get("sort")
if request.GET.get("direction") == "desc":
new_ordering = "-%s" % sort
elif request.GET.get("direction") == "asc":
new_ordering = sort
else:
new_ordering = "?nope"
return self.clean_ordering(new_ordering)
@property
def ordering_session_key(self):
return "misago_admin_%s_order_by" % self.root_link
def get_ordering_from_session(self, request):
new_ordering = request.session.get(self.ordering_session_key)
return self.clean_ordering(new_ordering)
def get_ordering_method_to_use(self, methods):
for method in ("GET", "session", "default"):
if methods.get(method):
return methods.get(method)
def clean_ordering(self, new_ordering):
for order_by, _ in self.ordering: # pylint: disable=not-an-iterable
if order_by == new_ordering:
return order_by
def set_ordering_in_context(self, context, method):
for order_by, name in self.ordering: # pylint: disable=not-an-iterable
order_as_dict = {
"type": "desc" if order_by[0] == "-" else "asc",
"order_by": order_by,
"name": name,
}
if order_by == method:
context["order"] = order_as_dict
context["items"] = context["items"].order_by(order_as_dict["order_by"])
elif order_as_dict["name"]:
if order_as_dict["type"] == "desc":
order_as_dict["order_by"] = order_as_dict["order_by"][1:]
context["order_by"].append(order_as_dict)
# Mass actions
def handle_mass_action(self, request, context):
limit = self.items_per_page or 64
action = self.select_mass_action(request.POST.get("action"))
items = [x for x in request.POST.getlist("selected_items")[:limit]]
context["selected_items"] = items
if not context["selected_items"]:
raise MassActionError(
pgettext_lazy("admin lists", "You have to select one or more items.")
)
action_queryset = context["items"].filter(pk__in=items)
if not action_queryset.exists():
raise MassActionError(
pgettext_lazy("admin lists", "You have to select one or more items.")
)
action_callable = getattr(self, "action_%s" % action["action"])
if action.get("is_atomic", True):
with transaction.atomic():
return action_callable(request, action_queryset)
else:
return action_callable(request, action_queryset)
def select_mass_action(self, action):
for definition in self.mass_actions: # pylint: disable=not-an-iterable
if definition["action"] == action:
return definition
raise MassActionError(pgettext_lazy("admin lists", "Action is not allowed."))
# Querystring builder
def make_querystring(self, context):
values = {}
filter_values = {}
order_values = {}
if context["active_filters"]:
filter_values = context["active_filters"]
values.update(filter_values)
if context["order_by"]:
order_values = {
"sort": context["order"]["order_by"],
"direction": context["order"]["type"],
}
if order_values["sort"][0] == "-":
# We don't start sorting criteria with minus in querystring
order_values["sort"] = order_values["sort"][1:]
values.update(order_values)
if values:
values["redirected"] = 1
context["querystring"] = "?%s" % urlencode(values, "utf-8")
if order_values:
context["query_order"] = order_values
if filter_values:
context["query_filters"] = filter_values
| 12,141
|
Python
|
.py
| 274
| 33.211679
| 87
| 0.591271
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,256
|
test_category_edit.py
|
rafalp_Misago/misago/admin/tests/test_category_edit.py
|
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...categories.models import Category
from ...permissions.models import CategoryGroupPermission
from ...test import assert_contains, assert_has_error_message
from .categories_tree import assert_valid_categories_tree
category_new = reverse("misago:admin:categories:new")
def test_edit_category_form_renders(admin_client, default_category):
response = admin_client.get(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk})
)
assert_contains(response, "Edit category")
assert_contains(response, default_category.name)
def test_edit_category_form_shows_error_if_category_doesnt_exist(
default_category, admin_client
):
response = admin_client.get(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk + 1}),
)
assert response.status_code == 302
assert_has_error_message(response, "Requested category does not exist.")
def test_edit_category_form_shows_error_if_category_is_root(
root_category, admin_client
):
response = admin_client.get(
reverse("misago:admin:categories:edit", kwargs={"pk": root_category.pk}),
)
assert response.status_code == 302
assert_has_error_message(response, "Requested category does not exist.")
def form_data(category: Category, new_data: dict | None = None) -> dict:
data = {
"new_parent": str(category.parent_id),
"name": category.name or "",
"short_name": category.short_name or "",
"color": category.color or "",
"description": category.description or "",
"css_class": category.css_class or "",
"copy_permissions": "",
"allow_polls": category.allow_polls,
"delay_browse_check": category.delay_browse_check,
"show_started_only": category.show_started_only,
"is_closed": category.is_closed,
"is_vanilla": category.is_vanilla,
"list_children_threads": category.list_children_threads,
"children_categories_component": category.children_categories_component,
"require_threads_approval": category.require_threads_approval,
"require_replies_approval": category.require_replies_approval,
"require_edits_approval": category.require_edits_approval,
"prune_started_after": str(category.prune_started_after),
"prune_replied_after": str(category.prune_replied_after),
"archive_pruned_in": str(category.archive_pruned_in or ""),
}
if new_data:
data.update(new_data)
return data
def test_edit_category_form_moves_category_under_other_category(
root_category, default_category, admin_client
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk}),
form_data(default_category, {"new_parent": str(sibling_category.id)}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(sibling_category, 1, 2, 5),
(default_category, 2, 3, 4),
]
)
def test_edit_category_form_moves_child_category_to_top_level(
root_category, default_category, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": child_category.pk}),
form_data(child_category, {"new_parent": str(root_category.id)}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(child_category, 1, 4, 5),
]
)
def test_edit_category_form_invalidates_categories_cache(
default_category, admin_client
):
with assert_invalidates_cache(CacheName.CATEGORIES):
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk}),
form_data(default_category),
)
assert response.status_code == 302
def test_edit_category_form_invalidates_moderators_cache(
default_category, admin_client
):
with assert_invalidates_cache(CacheName.MODERATORS):
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk}),
form_data(default_category),
)
assert response.status_code == 302
def test_edit_category_form_invalidates_permissions_cache(
default_category, admin_client
):
with assert_invalidates_cache(CacheName.PERMISSIONS):
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk}),
form_data(default_category),
)
assert response.status_code == 302
def test_edit_category_form_shows_error_if_category_is_moved_to_self(
root_category, default_category, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk}),
form_data(default_category, {"new_parent": str(default_category.id)}),
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_edit_category_form_shows_error_if_category_is_moved_to_own_child_category(
root_category, default_category, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk}),
form_data(default_category, {"new_parent": str(child_category.id)}),
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 5),
(child_category, 2, 3, 4),
]
)
def test_edit_category_form_shows_error_if_category_is_moved_to_invalid_category(
root_category, default_category, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk}),
form_data(default_category, {"new_parent": str(default_category.id + 1)}),
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_edit_category_form_changes_top_category_to_vanilla(
root_category, default_category, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk}),
form_data(default_category, {"is_vanilla": True}),
)
assert response.status_code == 302
default_category.refresh_from_db()
assert default_category.is_vanilla
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_edit_category_form_shows_error_if_child_category_is_changed_to_vanilla(
root_category, default_category, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": child_category.pk}),
form_data(child_category, {"is_vanilla": True}),
)
assert_contains(response, "Only top-level categories can be set as vanilla.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 5),
(child_category, 2, 3, 4),
]
)
def test_edit_category_form_fails_if_vanilla_category_without_threads_and_categories_dropdown(
admin_client, root_category, default_category
):
response = admin_client.post(
reverse("misago:admin:categories:edit", kwargs={"pk": default_category.pk}),
form_data(
default_category,
{
"new_parent": str(root_category.id),
"is_vanilla": True,
"list_children_threads": False,
"children_categories_component": "dropdown",
},
),
)
assert_contains(
response,
"This choice is not available for vanilla categories with disabled listing",
)
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
| 9,167
|
Python
|
.py
| 220
| 34.6
| 94
| 0.664157
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,257
|
test_admin_index_view.py
|
rafalp_Misago/misago/admin/tests/test_admin_index_view.py
|
from django.urls import reverse
def test_view_has_no_showstoppers(admin_client):
response = admin_client.get(reverse("misago:admin:index"))
assert response.status_code == 200
| 185
|
Python
|
.py
| 4
| 42.75
| 62
| 0.77095
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,258
|
test_admin_site.py
|
rafalp_Misago/misago/admin/tests/test_admin_site.py
|
import pytest
from ..site import AdminSite, AdminSiteInvalidNodeError, Node
def test_admin_site_validate_nodes_raises_error_if_node_has_invalid_parent():
site = AdminSite()
site.add_node(
name="Test",
icon="test",
namespace="test",
parent="invalid",
)
with pytest.raises(AdminSiteInvalidNodeError) as exc_info:
site.validate_nodes()
assert str(exc_info.value) == (
"Misago Admin node 'misago:admin:invalid:test:index' has "
"an invalid parent 'misago:admin:invalid'."
)
def test_admin_site_validate_nodes_raises_error_if_node_has_invalid_after():
site = AdminSite()
site.add_node(
name="Test",
icon="test",
namespace="parent",
)
site.add_node(
name="Test",
icon="test",
parent="parent",
namespace="second",
after="invalid",
)
site.add_node(
name="Test",
icon="test",
parent="parent",
namespace="first",
)
with pytest.raises(AdminSiteInvalidNodeError) as exc_info:
site.validate_nodes()
assert str(exc_info.value) == (
"Misago Admin node 'misago:admin:parent:second:index' has "
"an invalid after node 'misago:admin:parent:invalid'."
)
def test_admin_site_validate_nodes_raises_error_if_node_has_invalid_before():
site = AdminSite()
site.add_node(
name="Test",
icon="test",
namespace="parent",
)
site.add_node(
name="Test",
icon="test",
parent="parent",
namespace="second",
before="invalid",
)
site.add_node(
name="Test",
icon="test",
parent="parent",
namespace="first",
)
with pytest.raises(AdminSiteInvalidNodeError) as exc_info:
site.validate_nodes()
assert str(exc_info.value) == (
"Misago Admin node 'misago:admin:parent:second:index' has "
"an invalid before node 'misago:admin:parent:invalid'."
)
def test_node_is_added_at_end_of_parent_children():
parent = Node(name="Apples", link="misago:index")
child = Node(name="Oranges", link="misago:index")
parent.add_node(child)
assert parent.children()[-1].name == child.name
def test_add_node_after():
"""add_node added node after specific node"""
parent = Node(name="Apples", link="misago:index")
child = Node(name="Oranges", link="misago:index")
parent.add_node(child)
test = Node(name="Potatoes", link="misago:index")
parent.add_node(test, after="misago:index")
all_nodes = parent.children()
for i, node in enumerate(all_nodes):
if node.name == test.name:
assert all_nodes[i - 1].name == child.name
def test_add_node_before():
"""add_node added node before specific node"""
parent = Node(name="Apples", link="misago:index")
child = Node(name="Oranges", link="misago:index")
parent.add_node(child)
test = Node(name="Potatoes", link="misago:index")
parent.add_node(test, before="misago:index")
all_nodes = parent.children()
for i, node in enumerate(all_nodes):
if node.name == test.name:
assert all_nodes[i + 1].name == child.name
| 3,233
|
Python
|
.py
| 95
| 27.252632
| 77
| 0.62882
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,259
|
test_generic_admin_list_view.py
|
rafalp_Misago/misago/admin/tests/test_generic_admin_list_view.py
|
from urllib.parse import urlencode
from django.urls import reverse
list_link = reverse("misago:admin:users:index")
def test_view_redirects_if_redirected_flag_is_not_present_in_querystring(admin_client):
response = admin_client.get(list_link)
assert response.status_code == 302
def test_view_sets_redirect_flag_in_redirect_url(admin_client):
response = admin_client.get(list_link)
assert response.status_code == 302
assert "redirected=1" in response["location"]
def test_view_checks_only_redirect_flag_presence_and_not_value(admin_client):
response = admin_client.get(list_link + "?redirected")
assert response.status_code == 200
def test_view_preserves_rest_of_querystring_in_redirect_url(admin_client):
response = admin_client.get(list_link + "?username=test")
assert response.status_code == 302
assert "redirected=1" in response["location"]
assert "username=test" in response["location"]
def test_unicode_is_preserved_in_redirect_querystring(admin_client):
response = admin_client.get(list_link + "?username=łóć")
assert response.status_code == 302
assert urlencode({"username": "łóć"}) in response["location"]
def test_view_is_not_redirecting_if_flag_is_set_in_querystring(admin_client):
response = admin_client.get("%s?redirected=1" % list_link)
assert response.status_code == 200
def test_restoring_filters_from_session_handles_filters_entry_being_none(admin_client):
"""Regression test for https://github.com/rafalp/Misago/pull/1177"""
response = admin_client.get("%s?set_filters=1&rank=1" % list_link)
assert response.status_code == 302
response = admin_client.get("%s?set_filters=0" % list_link)
assert response.status_code == 302
response = admin_client.get("%s?redirected=1" % list_link)
assert response.status_code == 200
| 1,847
|
Python
|
.py
| 33
| 51.515152
| 87
| 0.743304
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,260
|
test_category_permissions.py
|
rafalp_Misago/misago/admin/tests/test_category_permissions.py
|
import pytest
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...permissions.enums import CategoryPermission
from ...permissions.models import CategoryGroupPermission
from ...test import assert_contains, assert_has_error_message
def test_category_permissions_form_is_rendered(
admin_client, custom_group, sibling_category
):
response = admin_client.get(
reverse(
"misago:admin:categories:permissions", kwargs={"pk": sibling_category.id}
)
)
assert_contains(response, sibling_category.name)
assert_contains(response, custom_group.name)
def test_category_permissions_form_replaces_old_category_permissions_with_new(
admin_client, custom_group, sibling_category
):
see_permission = CategoryGroupPermission.objects.create(
group=custom_group,
category=sibling_category,
permission=CategoryPermission.SEE,
)
response = admin_client.post(
reverse(
"misago:admin:categories:permissions", kwargs={"pk": sibling_category.id}
),
{f"permissions[{custom_group.id}]": [CategoryPermission.BROWSE]},
)
assert response.status_code == 302
with pytest.raises(CategoryGroupPermission.DoesNotExist):
see_permission.refresh_from_db()
CategoryGroupPermission.objects.get(
group=custom_group,
category=sibling_category,
permission=CategoryPermission.BROWSE,
)
def test_category_permissions_form_invalidates_permissions_cache(
admin_client, custom_group, sibling_category
):
with assert_invalidates_cache(CacheName.PERMISSIONS):
admin_client.post(
reverse(
"misago:admin:categories:permissions",
kwargs={"pk": sibling_category.id},
),
{f"permissions[{custom_group.id}]": [CategoryPermission.BROWSE]},
)
def test_category_permissions_form_handles_not_existing_category_id(
admin_client, sibling_category
):
response = admin_client.get(
reverse(
"misago:admin:categories:permissions",
kwargs={"pk": sibling_category.id + 1000},
)
)
assert response.status_code == 302
assert_has_error_message(response, "Requested category does not exist.")
| 2,331
|
Python
|
.py
| 61
| 31.639344
| 85
| 0.70372
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,261
|
test_moderators.py
|
rafalp_Misago/misago/admin/tests/test_moderators.py
|
from django.urls import reverse
from ...permissions.models import Moderator
from ...test import assert_contains
moderators_list = reverse("misago:admin:moderators:index")
def test_moderators_link_is_registered_in_admin_nav(admin_client):
response = admin_client.get(reverse("misago:admin:index"))
assert_contains(response, moderators_list)
def test_moderators_list_renders_with_default_groups_moderators(
admin_client, admins_group, moderators_group
):
response = admin_client.get(moderators_list)
assert_contains(response, admins_group.name)
assert_contains(response, moderators_group.name)
def test_moderators_list_renders_with_custom_group_moderator(
admin_client, custom_group
):
Moderator.objects.create(group=custom_group)
response = admin_client.get(moderators_list)
assert_contains(response, custom_group.name)
def test_moderators_list_renders_with_custom_user_moderator(admin_client, other_user):
Moderator.objects.create(user=other_user)
response = admin_client.get(moderators_list)
assert_contains(response, other_user.username)
| 1,102
|
Python
|
.py
| 23
| 44.217391
| 86
| 0.790458
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,262
|
test_categories.py
|
rafalp_Misago/misago/admin/tests/test_categories.py
|
from django.urls import reverse
from ...categories.models import Category
from ...test import assert_contains
categories_list = reverse("misago:admin:categories:index")
def test_categories_link_is_registered_in_admin_nav(admin_client):
response = admin_client.get(categories_list)
assert_contains(response, categories_list)
def test_categories_list_renders_empty(admin_client, root_category):
for child in root_category.get_descendants():
child.delete()
response = admin_client.get(categories_list)
assert_contains(response, "No categories are set.")
def test_categories_list_renders_category(admin_client, default_category):
response = admin_client.get(categories_list)
assert_contains(response, default_category.name)
def test_categories_list_renders_child_category(admin_client, default_category):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
response = admin_client.get(categories_list)
assert_contains(response, child_category.name)
| 1,106
|
Python
|
.py
| 20
| 51.1
| 80
| 0.780261
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,263
|
test_group_edit.py
|
rafalp_Misago/misago/admin/tests/test_group_edit.py
|
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...permissions.models import CategoryGroupPermission
from ...test import assert_contains
from ...users.models import Group
def get_form_data(group: Group) -> dict:
return {
"group-name": group.name,
"group-slug": group.slug,
"group-color": group.color or "",
"group-icon": group.icon or "",
"group-css_suffix": group.css_suffix or "",
"group-user_title": group.user_title or "",
"group-is_page": "1" if group.is_page else "",
"group-is_hidden": "1" if group.is_hidden else "",
"group-can_use_private_threads": "1" if group.can_use_private_threads else "",
"group-can_change_username": "1" if group.can_change_username else "",
"group-username_changes_limit": str(group.username_changes_limit),
"group-username_changes_expire": str(group.username_changes_expire),
"group-username_changes_span": str(group.username_changes_span),
"group-can_see_user_profiles": "1" if group.can_see_user_profiles else "",
}
def test_edit_group_form_is_rendered(admin_client, custom_group):
response = admin_client.get(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id})
)
assert response.status_code == 200
def test_edit_group_form_updates_name(admin_client, custom_group):
form_data = get_form_data(custom_group)
form_data["group-name"] = "New Name"
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert response.status_code == 302
custom_group.refresh_from_db()
assert custom_group.name == "New Name"
def test_edit_group_form_sets_custom_slug(admin_client, custom_group):
form_data = get_form_data(custom_group)
form_data["group-slug"] = "customized"
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert response.status_code == 302
custom_group.refresh_from_db()
assert custom_group.slug == "customized"
def test_edit_group_form_validates_slug(admin_client, custom_group):
form_data = get_form_data(custom_group)
form_data["group-slug"] = "invalid!"
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert_contains(
response,
"Enter a valid “slug” consisting of letters, numbers, underscores or hyphens.",
)
custom_group.refresh_from_db()
assert custom_group.slug == "custom-group"
def test_edit_group_form_sets_slug_from_name_if_its_empty(admin_client, custom_group):
form_data = get_form_data(custom_group)
form_data["group-name"] = "New Name"
form_data["group-slug"] = ""
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert response.status_code == 302
custom_group.refresh_from_db()
assert custom_group.slug == "new-name"
def test_edit_group_form_validates_color(admin_client, custom_group):
form_data = get_form_data(custom_group)
form_data["group-color"] = "invalid"
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert_contains(response, "Entered value is not a valid color")
custom_group.refresh_from_db()
assert custom_group.css_suffix is None
def test_edit_group_form_validates_css_suffix(admin_client, custom_group):
form_data = get_form_data(custom_group)
form_data["group-css_suffix"] = "invalid!"
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert_contains(response, "Enter a valid CSS class name")
custom_group.refresh_from_db()
assert custom_group.css_suffix is None
def test_edit_group_form_updates_appearance_settings(admin_client, custom_group):
form_data = get_form_data(custom_group)
form_data["group-icon"] = "fas fa-shield"
form_data["group-css_suffix"] = "lorem-ipsum"
form_data["group-user_title"] = "Customer"
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert response.status_code == 302
custom_group.refresh_from_db()
assert custom_group.icon == "fas fa-shield"
assert custom_group.css_suffix == "lorem-ipsum"
assert custom_group.user_title == "Customer"
def test_edit_group_form_copies_group_permissions(
admin_client, custom_group, members_group, other_category
):
form_data = get_form_data(custom_group)
form_data["group-copy_permissions"] = str(members_group.id)
CategoryGroupPermission.objects.create(
group=members_group,
category=other_category,
permission="copied",
)
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert response.status_code == 302
CategoryGroupPermission.objects.get(
group=custom_group,
category=other_category,
permission="copied",
)
def test_edit_group_form_sets_group_description_and_meta_description(
admin_client, custom_group
):
form_data = get_form_data(custom_group)
form_data["description-markdown"] = "Hello **world**!"
form_data["description-meta"] = "Hello meta description!"
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert response.status_code == 302
custom_group.description.refresh_from_db()
assert custom_group.description.markdown == "Hello **world**!"
assert custom_group.description.html == "<p>Hello <strong>world</strong>!</p>"
assert custom_group.description.meta == "Hello meta description!"
def test_edit_group_form_sets_group_description_and_automatic_meta_description(
admin_client, custom_group
):
form_data = get_form_data(custom_group)
form_data["description-markdown"] = "Hello **world**!"
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert response.status_code == 302
custom_group.description.refresh_from_db()
assert custom_group.description.markdown == "Hello **world**!"
assert custom_group.description.html == "<p>Hello <strong>world</strong>!</p>"
assert custom_group.description.meta == "Hello world!"
def test_edit_group_form_clears_group_description_and_meta_description(
admin_client, custom_group
):
custom_group.description.markdown = "Hello **world**!"
custom_group.description.html = "<p>Hello <strong>world</strong>!</p>"
custom_group.description.meta = "Hello meta description!"
custom_group.description.save()
form_data = get_form_data(custom_group)
form_data["description-markdown"] = ""
form_data["description-meta"] = ""
response = admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
form_data,
)
assert response.status_code == 302
custom_group.description.refresh_from_db()
assert custom_group.description.markdown is None
assert custom_group.description.html is None
assert custom_group.description.meta is None
def test_edit_group_form_invalidates_groups_cache(admin_client, custom_group):
with assert_invalidates_cache(CacheName.GROUPS):
admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
get_form_data(custom_group),
)
def test_edit_group_form_invalidates_permissions_cache(admin_client, custom_group):
with assert_invalidates_cache(CacheName.PERMISSIONS):
admin_client.post(
reverse("misago:admin:groups:edit", kwargs={"pk": custom_group.id}),
get_form_data(custom_group),
)
| 8,182
|
Python
|
.py
| 186
| 37.983871
| 87
| 0.685398
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,264
|
test_login_to_admin.py
|
rafalp_Misago/misago/admin/tests/test_login_to_admin.py
|
from django.urls import reverse
from ...test import assert_contains
from ..auth import is_admin_authorized
admin_link = reverse("misago:admin:index")
def test_login_form_is_displayed(db, client):
response = client.get(admin_link)
assert response.status_code == 200
assert_contains(response, "Administration")
assert_contains(response, "Sign in")
assert_contains(response, "Username or email")
assert_contains(response, "Password")
def test_attempt_to_login_using_invalid_credentials_fails(db, client):
response = client.post(admin_link, {"username": "no", "password": "no"})
assert_contains(response, "Login or password is incorrect.")
def test_attempt_to_login_using_invalid_password_fails(client, admin):
response = client.post(admin_link, {"username": admin.username, "password": "no"})
assert_contains(response, "Login or password is incorrect.")
def test_attempt_to_login_without_admin_status_fails(client, user, user_password):
response = client.post(
admin_link, {"username": user.username, "password": user_password}
)
assert_contains(response, "Your account does not have admin privileges.")
def test_attempt_to_login_as_django_staff_user_fails(client, user, user_password):
user.is_staff = True
user.save()
response = client.post(
admin_link, {"username": user.username, "password": user_password}
)
assert_contains(response, "Your account does not have admin privileges.")
def test_attempt_to_login_as_django_superuser_user_fails(
client, superuser, user_password
):
response = client.post(
admin_link, {"username": superuser.username, "password": user_password}
)
assert_contains(response, "Your account does not have admin privileges.")
def test_attempt_to_login_as_django_non_staff_superuser_user_fails(
client, superuser, user_password
):
superuser.is_staff = False
superuser.save()
response = client.post(
admin_link, {"username": superuser.username, "password": user_password}
)
assert_contains(response, "Your account does not have admin privileges.")
def test_user_with_admin_status_is_logged_to_admin(client, admin, user_password):
response = client.post(
admin_link, {"username": admin.username, "password": user_password}
)
assert is_admin_authorized(response.wsgi_request)
assert response.wsgi_request.user == admin
def test_user_with_root_admin_status_is_logged_to_admin(
client, root_admin, user_password
):
response = client.post(
admin_link, {"username": root_admin.username, "password": user_password}
)
assert is_admin_authorized(response.wsgi_request)
assert response.wsgi_request.user == root_admin
def test_login_form_redirects_user_to_admin_index_after_successful_login(
client, admin, user_password
):
response = client.post(
admin_link, {"username": admin.username, "password": user_password}
)
assert response["location"] == admin_link
| 3,016
|
Python
|
.py
| 66
| 41
| 86
| 0.726247
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,265
|
test_color_field.py
|
rafalp_Misago/misago/admin/tests/test_color_field.py
|
from django import forms
from ..forms import ColorField
class ColorForm(forms.Form):
test_field = ColorField(label="Hello!")
def test_input_returns_str_with_color_hex():
form = ColorForm({"test_field": "#e9e9e9"})
form.full_clean()
assert form.cleaned_data["test_field"] == "#e9e9e9"
def test_input_rejects_short_color():
form = ColorForm({"test_field": "#eee"})
form.full_clean()
assert "test_field" not in form.cleaned_data
def test_input_rejects_invalid_color():
form = ColorForm({"test_field": "#ggg"})
form.full_clean()
assert "test_field" not in form.cleaned_data
def test_input_returns_none_for_empty_value():
form = ColorForm({"test_field": ""})
form.full_clean()
assert "test_field" not in form.cleaned_data
| 780
|
Python
|
.py
| 20
| 34.85
| 55
| 0.695594
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,266
|
test_moderator_delete.py
|
rafalp_Misago/misago/admin/tests/test_moderator_delete.py
|
import pytest
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...permissions.models import Moderator
from ...test import assert_has_error_message
def test_group_moderator_is_deleted(admin_client, custom_group):
moderator = Moderator.objects.create(group=custom_group)
response = admin_client.post(
reverse("misago:admin:moderators:delete", kwargs={"pk": moderator.id})
)
assert response.status_code == 302
with pytest.raises(Moderator.DoesNotExist):
moderator.refresh_from_db()
def test_user_moderator_is_deleted(admin_client, other_user):
moderator = Moderator.objects.create(user=other_user)
response = admin_client.post(
reverse("misago:admin:moderators:delete", kwargs={"pk": moderator.id})
)
assert response.status_code == 302
with pytest.raises(Moderator.DoesNotExist):
moderator.refresh_from_db()
def test_deleting_moderator_invalidates_moderators_cache(admin_client, custom_group):
moderator = Moderator.objects.create(group=custom_group)
with assert_invalidates_cache(CacheName.MODERATORS):
admin_client.post(
reverse("misago:admin:moderators:delete", kwargs={"pk": moderator.id})
)
def test_protected_moderator_cant_be_deleted(admin_client, admins_group):
moderator = Moderator.objects.get(group=admins_group)
response = admin_client.post(
reverse("misago:admin:moderators:delete", kwargs={"pk": moderator.id})
)
assert_has_error_message(
response,
'Can\'t remove "Administrators" moderator permissions because they are protected.',
)
def test_non_existing_moderator_cant_be_deleted(admin_client):
response = admin_client.post(
reverse("misago:admin:moderators:delete", kwargs={"pk": 404})
)
assert_has_error_message(response, "Requested moderator does not exist.")
| 1,942
|
Python
|
.py
| 42
| 40.738095
| 91
| 0.733935
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,267
|
test_category_move.py
|
rafalp_Misago/misago/admin/tests/test_category_move.py
|
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...categories.models import Category
from ...permissions.models import CategoryGroupPermission
from ...test import assert_contains, assert_has_error_message
from .categories_tree import assert_valid_categories_tree
def test_category_move_up_shows_error_if_category_doesnt_exist(
default_category, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:up", kwargs={"pk": default_category.pk + 1}),
)
assert response.status_code == 302
assert_has_error_message(response, "Requested category does not exist.")
def test_category_move_down_shows_error_if_category_doesnt_exist(
default_category, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:down", kwargs={"pk": default_category.pk + 1}),
)
assert response.status_code == 302
assert_has_error_message(response, "Requested category does not exist.")
def test_category_move_up_shows_error_if_category_is_root(root_category, admin_client):
response = admin_client.post(
reverse("misago:admin:categories:up", kwargs={"pk": root_category.pk}),
)
assert response.status_code == 302
assert_has_error_message(response, "Requested category does not exist.")
def test_category_move_down_shows_error_if_category_is_root(
root_category, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:down", kwargs={"pk": root_category.pk}),
)
assert response.status_code == 302
assert_has_error_message(response, "Requested category does not exist.")
def test_only_category_move_up_does_nothing(
root_category, default_category, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:up", kwargs={"pk": default_category.pk}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_only_category_move_down_does_nothing(
root_category, default_category, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:down", kwargs={"pk": default_category.pk}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_top_category_move_up_updates_tree(
root_category, default_category, admin_client
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:up", kwargs={"pk": sibling_category.pk}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(sibling_category, 1, 2, 3),
(default_category, 1, 4, 5),
]
)
def test_top_category_move_down_updates_tree(
root_category, default_category, admin_client
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="first-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:down", kwargs={"pk": sibling_category.pk}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(sibling_category, 1, 4, 5),
]
)
def test_middle_category_move_up_updates_tree(
root_category, default_category, admin_client
):
middle_category = Category(name="Middle Category", slug="middle-category")
middle_category.insert_at(root_category, position="last-child", save=True)
bottom_category = Category(name="Bottom Category", slug="bottom-category")
bottom_category.insert_at(root_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:up", kwargs={"pk": middle_category.pk}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 8),
(middle_category, 1, 2, 3),
(default_category, 1, 4, 5),
(bottom_category, 1, 6, 7),
]
)
def test_middle_category_move_down_updates_tree(
root_category, default_category, admin_client
):
middle_category = Category(name="Middle Category", slug="middle-category")
middle_category.insert_at(root_category, position="last-child", save=True)
bottom_category = Category(name="Bottom Category", slug="bottom-category")
bottom_category.insert_at(root_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:down", kwargs={"pk": middle_category.pk}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 8),
(default_category, 1, 2, 3),
(bottom_category, 1, 4, 5),
(middle_category, 1, 6, 7),
]
)
def test_ategory_move_up_invalidates_categories_cache(
root_category, default_category, admin_client
):
other_category = Category(name="Other Category", slug="other-category")
other_category.insert_at(root_category, position="first-child", save=True)
with assert_invalidates_cache(CacheName.CATEGORIES):
response = admin_client.post(
reverse("misago:admin:categories:up", kwargs={"pk": default_category.pk}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(other_category, 1, 4, 5),
]
)
def test_category_move_down_invalidates_categories_cache(
root_category, default_category, admin_client
):
other_category = Category(name="Other Category", slug="other-category")
other_category.insert_at(root_category, position="last-child", save=True)
with assert_invalidates_cache(CacheName.CATEGORIES):
response = admin_client.post(
reverse("misago:admin:categories:down", kwargs={"pk": default_category.pk}),
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(other_category, 1, 2, 3),
(default_category, 1, 4, 5),
]
)
| 6,694
|
Python
|
.py
| 167
| 33.54491
| 88
| 0.667283
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,268
|
categories_tree.py
|
rafalp_Misago/misago/admin/tests/categories_tree.py
|
from ...categories.models import Category
def assert_valid_categories_tree(expected_tree: list[tuple]):
root = Category.objects.root_category()
queryset = Category.objects.filter(tree_id=root.tree_id).order_by("lft")
current_tree = []
for category in queryset:
current_tree.append(
(
category,
category.level,
category.lft - root.lft + 1,
category.rght - root.lft + 1,
)
)
c_len, e_len = len(current_tree), len(expected_tree)
assert c_len == e_len, (
"categories trees lengths don't match: " f"found {c_len}, expected {e_len}"
)
for i, current in enumerate(current_tree):
expected = expected_tree[i]
assert current[0] == expected[0], (
f"category #{i} is wrong: " f"'{current[0].name}' != '{expected[0].name}'"
)
c_level, e_level = current[1], expected[1]
assert (
c_level == e_level
), f"category #{i} level is invalid: {c_level} != {e_level}"
c_lft, e_lft = current[2], expected[2]
assert c_lft == e_lft, f"category #{i} left edge is invalid: {c_lft} != {e_lft}"
c_rght, e_rght = current[3], expected[3]
assert (
c_rght == e_rght
), f"category #{i} right edge is invalid: {c_rght} != {e_rght}"
| 1,373
|
Python
|
.py
| 33
| 32.212121
| 88
| 0.555973
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,269
|
test_admin_system_checks.py
|
rafalp_Misago/misago/admin/tests/test_admin_system_checks.py
|
from datetime import timedelta
from unittest.mock import Mock
import pytest
from django.contrib.auth import get_user_model
from django.test import override_settings
from django.urls import reverse
from django.utils import timezone
from ...conf.test import override_dynamic_settings
from ...test import assert_contains
from ...users.datadownloads import request_user_data_download
from ...users.models import DataDownload
from ...users.test import create_test_user
from ..views.index import (
check_cache,
check_data_downloads,
check_debug_status,
check_forum_address,
check_https,
check_inactive_users,
)
User = get_user_model()
admin_link = reverse("misago:admin:index")
def test_cache_check_passess_if_cache_can_be_read_after_setting(mocker):
mocker.patch("misago.admin.views.index.cache.set")
mocker.patch("misago.admin.views.index.cache.get", return_value="ok")
assert check_cache() == {"is_ok": True}
def test_cache_check_passess_if_cache_cant_be_read_after_setting(mocker):
mocker.patch("misago.admin.views.index.cache.set")
mocker.patch("misago.admin.views.index.cache.get", return_value=None)
assert check_cache() == {"is_ok": False}
def test_warning_about_disabled_cache_is_displayed_on_checks_list(mocker, admin_client):
mocker.patch("misago.admin.views.index.check_cache", return_value={"is_ok": False})
response = admin_client.get(admin_link)
assert_contains(response, "Cache is disabled")
def test_data_downloads_processing_check_passes_if_there_are_no_data_downloads(db):
assert check_data_downloads() == {"is_ok": True, "count": 0}
def test_ready_data_downloads_are_excluded_by_check(user):
data_download = request_user_data_download(user)
data_download.status = DataDownload.STATUS_READY
data_download.save()
assert check_data_downloads() == {"is_ok": True, "count": 0}
def test_expired_data_downloads_are_excluded_by_check(user):
data_download = request_user_data_download(user)
data_download.status = DataDownload.STATUS_EXPIRED
data_download.save()
assert check_data_downloads() == {"is_ok": True, "count": 0}
def test_recent_pending_data_downloads_are_excluded_by_check(user):
data_download = request_user_data_download(user)
data_download.status = DataDownload.STATUS_PENDING
data_download.save()
assert check_data_downloads() == {"is_ok": True, "count": 0}
def test_recent_processing_data_downloads_are_excluded_by_check(user):
data_download = request_user_data_download(user)
data_download.status = DataDownload.STATUS_PROCESSING
data_download.save()
assert check_data_downloads() == {"is_ok": True, "count": 0}
def test_check_fails_if_there_are_old_processing_data_downloads(user):
data_download = request_user_data_download(user)
data_download.status = DataDownload.STATUS_PROCESSING
data_download.requested_on = timezone.now() - timedelta(days=5)
data_download.save()
assert check_data_downloads() == {"is_ok": False, "count": 1}
def test_check_fails_if_there_are_old_pending_data_downloads(user):
data_download = request_user_data_download(user)
data_download.status = DataDownload.STATUS_PENDING
data_download.requested_on = timezone.now() - timedelta(days=5)
data_download.save()
assert check_data_downloads() == {"is_ok": False, "count": 1}
def test_warning_about_unprocessed_data_downloads_is_displayed_on_checks_list(
admin_client, user
):
data_download = request_user_data_download(user)
data_download.status = DataDownload.STATUS_PENDING
data_download.requested_on = timezone.now() - timedelta(days=5)
data_download.save()
response = admin_client.get(admin_link)
assert_contains(response, "There is 1 unprocessed data download request")
class RequestMock:
absolute_uri = "https://misago-project.org"
def __init__(self, settings):
self.settings = settings
def build_absolute_uri(self, location):
assert location == "/"
return self.absolute_uri
@pytest.fixture
def request_mock(dynamic_settings):
return RequestMock(dynamic_settings)
incorrect_address = "http://somewhere.com"
correct_address = RequestMock.absolute_uri
@override_dynamic_settings(forum_address=None)
def test_forum_address_check_handles_setting_not_configured(request_mock):
result = check_forum_address(request_mock)
assert result == {
"is_ok": False,
"set_address": None,
"correct_address": request_mock.absolute_uri,
}
@override_dynamic_settings(forum_address=incorrect_address)
def test_forum_address_check_detects_invalid_address_configuration(request_mock):
result = check_forum_address(request_mock)
assert result == {
"is_ok": False,
"set_address": incorrect_address,
"correct_address": request_mock.absolute_uri,
}
@override_dynamic_settings(forum_address=correct_address)
def test_forum_address_check_detects_valid_address_configuration(request_mock):
result = check_forum_address(request_mock)
assert result == {
"is_ok": True,
"set_address": correct_address,
"correct_address": request_mock.absolute_uri,
}
@override_dynamic_settings(forum_address=None)
def test_warning_about_unset_forum_address_is_displayed_on_checks_list(admin_client):
response = admin_client.get(admin_link)
assert_contains(response, "address")
@override_dynamic_settings(forum_address=incorrect_address)
def test_warning_about_incorrect_forum_address_is_displayed_on_checks_list(
admin_client,
):
response = admin_client.get(admin_link)
assert_contains(response, "address")
@override_settings(DEBUG=False)
def test_debug_check_passess_if_debug_is_disabled():
assert check_debug_status() == {"is_ok": True}
@override_settings(DEBUG=True)
def test_debug_check_fails_if_debug_is_enabled():
assert check_debug_status() == {"is_ok": False}
@override_settings(DEBUG=True)
def test_warning_about_enabled_debug_is_displayed_on_checks_list(admin_client):
response = admin_client.get(admin_link)
assert_contains(response, "site is running in DEBUG mode")
def test_https_check_passes_if_site_is_accessed_over_https():
request = Mock(is_secure=Mock(return_value=True))
assert check_https(request) == {"is_ok": True}
def test_https_check_fails_if_site_is_accessed_without_https(mocker):
request = Mock(is_secure=Mock(return_value=False))
assert check_https(request) == {"is_ok": False}
def test_warning_about_accessing_site_without_https_is_displayed_on_checks_list(
admin_client,
):
response = admin_client.get(admin_link)
assert_contains(response, "site is not running over HTTPS")
def test_inactive_users_check_passess_if_there_are_no_inactive_users(db):
assert check_inactive_users() == {"is_ok": True, "count": 0}
def test_inactive_users_check_passess_if_there_are_less_than_eleven_inactive_users(db):
for i in range(10):
create_test_user(
"User%s" % i,
"user%s@example.com" % i,
requires_activation=User.ACTIVATION_USER,
)
assert check_inactive_users() == {"is_ok": True, "count": 10}
def test_inactive_users_check_fails_if_there_are_more_than_ten_inactive_users(db):
for i in range(11):
create_test_user(
"User%s" % i,
"user%s@example.com" % i,
requires_activation=User.ACTIVATION_USER,
)
assert check_inactive_users() == {"is_ok": False, "count": 11}
def test_warning_about_inactive_users_is_displayed_on_checks_list(admin_client):
for i in range(11):
create_test_user(
"User%s" % i,
"user%s@example.com" % i,
requires_activation=User.ACTIVATION_USER,
)
response = admin_client.get(admin_link)
assert_contains(response, "There are 11 inactive users accounts")
| 7,907
|
Python
|
.py
| 171
| 41.333333
| 88
| 0.724817
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,270
|
test_admin_views_are_protected.py
|
rafalp_Misago/misago/admin/tests/test_admin_views_are_protected.py
|
from django.urls import reverse
from ...test import assert_contains, assert_not_contains
from ..auth import is_admin_authorized
admin_link = reverse("misago:admin:index")
def assert_requires_admin_login(response):
assert response.status_code == 200
assert_contains(response, "Administration")
assert_contains(response, "Sign in")
def test_anonymous_user_is_asked_to_login_to_access_admin_view(db, client):
response = client.get(admin_link)
assert_requires_admin_login(response)
def test_authenticated_user_is_asked_to_login_to_access_admin_view(client, user):
client.force_login(user)
response = client.get(admin_link)
assert_requires_admin_login(response)
def test_unauthorized_admin_is_asked_to_login_to_access_admin_view(client, admin):
client.force_login(admin)
response = client.get(admin_link)
assert_requires_admin_login(response)
def test_authorized_admin_is_allowed_to_access_admin_view(admin_client):
response = admin_client.get(admin_link)
assert is_admin_authorized(response.wsgi_request)
assert_not_contains(response, "Sign in")
def test_admin_authorization_is_checked_on_admin_view_access(mocker, client, user):
admin_authorization = mocker.patch(
"misago.admin.middleware.is_admin_authorized", return_value=False
)
response = client.get(admin_link)
admin_authorization.assert_called_once_with(response.wsgi_request)
| 1,425
|
Python
|
.py
| 29
| 44.896552
| 83
| 0.768452
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,271
|
test_select_user.py
|
rafalp_Misago/misago/admin/tests/test_select_user.py
|
from django.urls import reverse
from ...test import assert_contains, assert_not_contains
def test_select_user_view_returns_empty_message_if_query_is_not_set(admin_client):
response = admin_client.get(reverse("misago:admin:select-user"))
assert_contains(response, "Enter a user name to search.")
def test_select_user_view_returns_empty_message_if_query_has_no_results(admin_client):
response = admin_client.get(reverse("misago:admin:select-user") + "?search=blank")
assert_contains(response, "No matching users have been found.")
def test_select_user_view_returns_exact_results(admin_client, admin):
response = admin_client.get(reverse("misago:admin:select-user") + "?search=admin")
assert_contains(response, admin.username)
def test_select_user_view_returns_results_matching_prefix(admin_client, admin):
response = admin_client.get(reverse("misago:admin:select-user") + "?search=ad")
assert_contains(response, admin.username)
def test_select_user_view_returns_excludes_users_not_matching_query(
admin_client, admin, other_user
):
response = admin_client.get(reverse("misago:admin:select-user") + "?search=other")
assert_contains(response, other_user.username)
assert_not_contains(response, admin.username)
def test_select_user_view_requires_admin_auth(user_client):
response = user_client.get(reverse("misago:admin:select-user"))
assert response.status_code == 302
| 1,434
|
Python
|
.py
| 23
| 58.347826
| 86
| 0.763233
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,272
|
test_moderator_new.py
|
rafalp_Misago/misago/admin/tests/test_moderator_new.py
|
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...permissions.models import Moderator
from ...test import assert_contains, assert_has_error_message
def test_moderator_new_group_form_is_rendered(admin_client, custom_group):
response = admin_client.get(
reverse(
"misago:admin:moderators:new-group",
kwargs={"group": custom_group.pk},
)
)
assert_contains(response, custom_group.name)
def test_moderator_new_user_form_is_rendered(admin_client, other_user):
response = admin_client.get(
reverse(
"misago:admin:moderators:new-user",
kwargs={"user": other_user.pk},
)
)
assert_contains(response, other_user.username)
def test_moderator_new_group_form_creates_moderator(admin_client, custom_group):
response = admin_client.post(
reverse(
"misago:admin:moderators:new-group",
kwargs={"group": custom_group.pk},
),
{"is_global": True},
)
assert response.status_code == 302
Moderator.objects.get(group=custom_group, is_global=True)
def test_moderator_new_user_form_creates_moderator(admin_client, other_user):
response = admin_client.post(
reverse(
"misago:admin:moderators:new-user",
kwargs={"user": other_user.pk},
),
{"is_global": True},
)
assert response.status_code == 302
Moderator.objects.get(user=other_user, is_global=True)
def test_moderator_new_user_form_invalidates_moderator_cache(admin_client, other_user):
with assert_invalidates_cache(CacheName.MODERATORS):
admin_client.post(
reverse(
"misago:admin:moderators:new-user",
kwargs={"user": other_user.pk},
),
{"is_global": True},
)
def test_moderator_new_group_form_handles_non_existing_group(admin_client):
response = admin_client.get(
reverse(
"misago:admin:moderators:new-group",
kwargs={"group": 404},
)
)
assert_has_error_message(response, "Requested user or group does not exist.")
def test_moderator_new_user_form_handles_non_existing_user(admin_client, admin):
response = admin_client.get(
reverse(
"misago:admin:moderators:new-user",
kwargs={"user": admin.id + 404},
)
)
assert_has_error_message(response, "Requested user or group does not exist.")
def test_moderator_new_group_form_redirects_to_existing_moderator(
admin_client, custom_group
):
moderator = Moderator.objects.create(group=custom_group)
response = admin_client.get(
reverse(
"misago:admin:moderators:new-group",
kwargs={"group": custom_group.pk},
)
)
assert response.status_code == 302
assert response.headers["location"].endswith(
reverse("misago:admin:moderators:edit", kwargs={"pk": moderator.id})
)
def test_moderator_new_user_form_redirects_to_existing_moderator(
admin_client, other_user
):
moderator = Moderator.objects.create(user=other_user)
response = admin_client.get(
reverse(
"misago:admin:moderators:new-user",
kwargs={"user": other_user.pk},
)
)
assert response.status_code == 302
assert response.headers["location"].endswith(
reverse("misago:admin:moderators:edit", kwargs={"pk": moderator.id})
)
def test_moderator_new_group_form_displays_error_if_group_is_default(
admin_client, custom_group
):
custom_group.is_default = True
custom_group.save()
response = admin_client.get(
reverse(
"misago:admin:moderators:new-group",
kwargs={"group": custom_group.pk},
)
)
assert_has_error_message(
response,
"Can't grant \"Custom Group\" moderator permissions because it's the default group.",
)
def test_moderator_new_group_form_displays_error_if_group_is_protected(
admin_client, guests_group
):
response = admin_client.get(
reverse(
"misago:admin:moderators:new-group",
kwargs={"group": guests_group.pk},
)
)
assert_has_error_message(
response,
"Can't grant \"Guests\" moderator permissions because it's protected group.",
)
| 4,405
|
Python
|
.py
| 122
| 28.844262
| 93
| 0.651469
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,273
|
test_group_make_default.py
|
rafalp_Misago/misago/admin/tests/test_group_make_default.py
|
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...permissions.models import Moderator
from ...test import assert_has_error_message
def test_make_default_group_changes_default_group(
admin_client, members_group, custom_group
):
assert members_group.is_default
assert not custom_group.is_default
response = admin_client.post(
reverse("misago:admin:groups:default", kwargs={"pk": custom_group.pk})
)
assert response.status_code == 302
custom_group.refresh_from_db()
assert custom_group.is_default
members_group.refresh_from_db()
assert not members_group.is_default
def test_make_default_group_invalidates_groups_cache(
admin_client, members_group, custom_group
):
with assert_invalidates_cache(CacheName.GROUPS):
admin_client.post(
reverse("misago:admin:groups:default", kwargs={"pk": custom_group.pk})
)
def test_make_default_group_handles_nonexisting_group(admin_client):
response = admin_client.post(
reverse("misago:admin:groups:default", kwargs={"pk": 404})
)
assert response.status_code == 302
assert_has_error_message(response, "Requested group does not exist.")
def test_make_default_group_handles_already_default_group(admin_client, members_group):
response = admin_client.post(
reverse("misago:admin:groups:default", kwargs={"pk": members_group.id})
)
assert response.status_code == 302
assert_has_error_message(response, '"Members" group is already the default.')
def test_make_default_group_rejects_admins_group(admin_client, admins_group):
response = admin_client.post(
reverse("misago:admin:groups:default", kwargs={"pk": admins_group.id})
)
assert response.status_code == 302
assert_has_error_message(
response, '"Administrators" group can\'t be set as default.'
)
def test_make_default_group_rejects_moderators_group(admin_client, moderators_group):
response = admin_client.post(
reverse("misago:admin:groups:default", kwargs={"pk": moderators_group.id})
)
assert response.status_code == 302
assert_has_error_message(response, '"Moderators" group can\'t be set as default.')
def test_make_default_group_rejects_guests_group(admin_client, guests_group):
response = admin_client.post(
reverse("misago:admin:groups:default", kwargs={"pk": guests_group.id})
)
assert response.status_code == 302
assert_has_error_message(response, '"Guests" group can\'t be set as default.')
def test_make_default_group_rejects_custom_moderators_group(admin_client, custom_group):
Moderator.objects.create(group=custom_group, is_global=True)
response = admin_client.post(
reverse("misago:admin:groups:default", kwargs={"pk": custom_group.id})
)
assert response.status_code == 302
assert_has_error_message(
response,
'Can\'t set "Custom Group" group as default because it has moderator permissions.',
)
| 3,056
|
Python
|
.py
| 67
| 40.358209
| 91
| 0.722372
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,274
|
test_group_new.py
|
rafalp_Misago/misago/admin/tests/test_group_new.py
|
import pytest
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...permissions.models import CategoryGroupPermission
from ...users.models import Group
def test_new_group_form_is_rendered(admin_client):
response = admin_client.get(reverse("misago:admin:groups:new"))
assert response.status_code == 200
def test_new_group_form_creates_new_group(admin_client):
response = admin_client.post(
reverse("misago:admin:groups:new"),
{"name": "New Group"},
)
assert response.status_code == 302
Group.objects.get(slug="new-group")
def test_new_group_form_copies_group_permissions(
admin_client, members_group, other_category
):
CategoryGroupPermission.objects.create(
group=members_group,
category=other_category,
permission="copied",
)
response = admin_client.post(
reverse("misago:admin:groups:new"),
{"name": "New Group", "copy_permissions": str(members_group.id)},
)
assert response.status_code == 302
new_group = Group.objects.get(slug="new-group")
CategoryGroupPermission.objects.get(
group=new_group,
category=other_category,
permission="copied",
)
def test_new_group_form_invalidates_groups_cache(admin_client):
with assert_invalidates_cache(CacheName.GROUPS):
admin_client.post(
reverse("misago:admin:groups:new"),
{"name": "New Group"},
)
def test_new_group_form_invalidates_permissions_cache(admin_client):
with assert_invalidates_cache(CacheName.PERMISSIONS):
admin_client.post(
reverse("misago:admin:groups:new"),
{"name": "New Group"},
)
| 1,758
|
Python
|
.py
| 47
| 31.255319
| 73
| 0.690631
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,275
|
test_group_members.py
|
rafalp_Misago/misago/admin/tests/test_group_members.py
|
from django.urls import reverse
from ...test import assert_has_error_message
def test_group_members_shortcut_handles_non_existing_group(admin_client):
response = admin_client.get(
reverse("misago:admin:groups:members", kwargs={"pk": 404})
)
assert response.status_code == 302
assert_has_error_message(response, "Requested group does not exist.")
def test_group_members_shortcut_redirects_to_users(admin_client, admins_group):
response = admin_client.get(
reverse("misago:admin:groups:members", kwargs={"pk": admins_group.pk})
)
assert response.status_code == 302
users_list = reverse("misago:admin:users:index")
assert response["location"] == f"{users_list}?group={admins_group.id}"
def test_group_main_members_shortcut_handles_non_existing_group(admin_client):
response = admin_client.get(
reverse("misago:admin:groups:members-main", kwargs={"pk": 404})
)
assert response.status_code == 302
assert_has_error_message(response, "Requested group does not exist.")
def test_group_main_members_shortcut_redirects_to_users(admin_client, admins_group):
response = admin_client.get(
reverse("misago:admin:groups:members-main", kwargs={"pk": admins_group.pk})
)
assert response.status_code == 302
users_list = reverse("misago:admin:users:index")
assert response["location"] == f"{users_list}?main_group={admins_group.id}"
| 1,429
|
Python
|
.py
| 28
| 45.928571
| 84
| 0.720863
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,276
|
test_404_view.py
|
rafalp_Misago/misago/admin/tests/test_404_view.py
|
from django.urls import reverse
from ...test import assert_contains
def test_admin_displays_own_error_page_on_404_error(admin_client):
response = admin_client.get(reverse("misago:admin:index") + "404-not-found/")
assert_contains(response, "Administration", 404)
assert_contains(response, "Requested page could not be found", 404)
| 345
|
Python
|
.py
| 6
| 54
| 81
| 0.761905
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,277
|
test_admin_form_templatetags.py
|
rafalp_Misago/misago/admin/tests/test_admin_form_templatetags.py
|
import pytest
from django import forms
from django.template import Context, Template, TemplateSyntaxError
from ..forms import YesNoSwitch
from ..templatetags.misago_admin_form import (
get_field_image_dimensions,
is_multiple_choice_field,
is_radio_select_field,
is_select_field,
is_textarea_field,
is_yesno_switch_field,
render_attrs,
render_bool_attrs,
)
class Form(forms.Form):
text_field = forms.CharField(
label="Hello", max_length=255, help_text="I am a help text."
)
textarea_field = forms.CharField(
label="Message", max_length=255, widget=forms.Textarea()
)
select_field = forms.ChoiceField(
label="Choice", choices=(("y", "Yes"), ("n", "No"))
)
ratio_select_field = forms.ChoiceField(
label="Choice",
choices=(("y", "Yes"), ("n", "No")),
widget=forms.RadioSelect,
)
checkbox_select_field = forms.MultipleChoiceField(
label="Color",
choices=(("r", "Red"), ("g", "Green"), ("b", "Blue")),
widget=forms.CheckboxSelectMultiple,
)
multiple_select_field = forms.MultipleChoiceField(
label="Rank", choices=(("r", "Red"), ("g", "Green"), ("b", "Blue"))
)
yesno_field = YesNoSwitch(label="Switch")
image_field = forms.ImageField(label="Image!", help_text="I am a help text.")
@pytest.fixture
def form():
return Form()
def render(template_str, form=None):
base_template = "{%% load misago_admin_form %%} %s"
context = Context({"form": form or Form()})
template = Template(base_template % template_str)
return template.render(context).strip()
def test_row_with_input_field_is_rendered(snapshot):
html = render("{% form_row form.text_field %}")
assert snapshot == html
def test_row_with_disabled_input_field_is_rendered(snapshot):
form = Form()
form.fields["text_field"].disabled = True
html = render("{% form_row form.text_field %}", form)
assert snapshot == html
def test_row_with_input_field_with_value_is_rendered(snapshot):
form = Form({"text_field": "Hello world!"})
html = render("{% form_row form.text_field %}", form)
assert snapshot == html
def test_row_with_field_input_and_label_css_class_is_rendered():
html = render('{% form_row form.text_field label_class="col-md-3" %}')
assert "id_text_field" in html
assert "col-md-3" in html
def test_row_with_field_input_and_field_css_class_is_rendered():
html = render('{% form_row form.text_field field_class="col-md-9" %}')
assert "id_text_field" in html
assert "col-md-9" in html
def test_row_with_field_input_and_label_and_field_css_classes_is_rendered():
html = render('{% form_row form.text_field "col-md-3" "col-md-9" %}')
assert "id_text_field" in html
assert "col-md-3" in html
assert "col-md-9" in html
def test_field_label_is_rendered():
html = render("{% form_row form.text_field %}")
assert "Hello" in html
def test_field_help_text_is_rendered():
html = render("{% form_row form.text_field %}")
assert "I am a help text." in html
def test_tag_without_field_raises_exception():
with pytest.raises(TemplateSyntaxError):
render("{% form_row %}")
def test_image_row_with_field_input_is_rendered():
html = render("{% form_image_row form.image_field %}")
assert "id_image_field" in html
def test_image_row_with_field_input_and_label_css_class_is_rendered():
html = render('{% form_image_row form.image_field label_class="col-md-3" %}')
assert "id_image_field" in html
assert "col-md-3" in html
def test_image_row_with_field_input_and_field_css_class_is_rendered():
html = render('{% form_image_row form.image_field field_class="col-md-9" %}')
assert "id_image_field" in html
assert "col-md-9" in html
def test_image_row_with_field_input_and_label_and_field_css_classes_is_rendered():
html = render('{% form_image_row form.image_field "col-md-3" "col-md-9" %}')
assert "id_image_field" in html
assert "col-md-3" in html
assert "col-md-9" in html
def test_image_field_label_is_rendered():
html = render("{% form_image_row form.image_field %}")
assert "Image!" in html
def test_image_field_help_text_is_rendered():
html = render("{% form_image_row form.image_field %}")
assert "I am a help text." in html
class TestImage:
url = "test-image.png"
def __str__(self):
return self.url
def render_image(template_str):
base_template = "{%% load misago_admin_form %%} %s"
context = Context({"form": Form(initial={"image_field": TestImage()})})
template = Template(base_template % template_str)
return template.render(context).strip()
def test_image_row_with_value_renders_label(snapshot):
html = render_image("{% form_image_row form.image_field %}")
assert snapshot == html
def test_image_row_with_value_renders_help_text(snapshot):
html = render_image("{% form_image_row form.image_field %}")
assert snapshot == html
def test_image_row_with_value_renders_image_preview(snapshot):
html = render_image("{% form_image_row form.image_field %}")
assert ('src="%s"' % TestImage.url) in html
assert snapshot == html
def test_image_row_with_value_renders_input(snapshot):
html = render_image("{% form_image_row form.image_field %}")
assert "id_image_field" in html
assert snapshot == html
def test_image_row_with_value_renders_input_and_label_css_class(snapshot):
html = render_image('{% form_image_row form.image_field label_class="col-md-3" %}')
assert "id_image_field" in html
assert "col-md-3" in html
assert snapshot == html
def test_image_row_with_value_renders_input_and_field_css_class(snapshot):
html = render_image('{% form_image_row form.image_field field_class="col-md-9" %}')
assert "id_image_field" in html
assert "col-md-9" in html
assert snapshot == html
def test_image_row_with_value_renders_input_and_label_and_field_css_classes(snapshot):
html = render_image('{% form_image_row form.image_field "col-md-3" "col-md-9" %}')
assert "id_image_field" in html
assert "col-md-3" in html
assert "col-md-9" in html
assert snapshot == html
def test_image_tag_without_field_raises_exception():
with pytest.raises(TemplateSyntaxError):
render("{% form_image_row %}")
def test_for_field_with_radio_select_widget_filter_returns_true(form):
assert is_radio_select_field(form["ratio_select_field"])
def test_for_field_without_radio_select_widget_filter_returns_false(form):
assert not is_radio_select_field(form["text_field"])
def test_row_with_radio_select_field_is_rendered(snapshot):
html = render("{% form_row form.ratio_select_field %}")
assert snapshot == html
def test_row_with_disabled_radio_select_field_is_rendered(snapshot):
form = Form()
form.fields["ratio_select_field"].disabled = True
html = render("{% form_row form.ratio_select_field %}", form)
assert snapshot == html
def test_row_with_radio_select_field_with_value_is_rendered(snapshot):
form = Form({"ratio_select_field": "y"})
html = render("{% form_row form.ratio_select_field %}", form)
assert snapshot == html
def test_for_field_with_select_widget_filter_returns_true(form):
assert is_select_field(form["select_field"])
def teste_for_field_without_select_widget_filter_returns_false(form):
assert not is_select_field(form["text_field"])
def test_row_with_select_field_is_rendered(snapshot):
html = render("{% form_row form.select_field %}")
assert snapshot == html
def test_row_with_disabled_select_field_is_rendered(snapshot):
form = Form()
form.fields["select_field"].disabled = True
html = render("{% form_row form.select_field %}", form)
assert snapshot == html
def test_row_with_select_field_with_value_is_rendered(snapshot):
form = Form({"select_field": "y"})
html = render("{% form_row form.select_field %}", form)
assert snapshot == html
def test_for_field_with_checkbox_select_widget_filter_returns_true(form):
assert is_multiple_choice_field(form["checkbox_select_field"])
def test_for_field_without_checkbox_select_widget_filter_returns_false(form):
assert not is_multiple_choice_field(form["text_field"])
def test_row_with_checkbox_select_field_is_rendered(snapshot):
html = render("{% form_row form.checkbox_select_field %}")
assert snapshot == html
def test_for_field_with_multiple_select_widget_filter_returns_true(form):
assert is_multiple_choice_field(form["multiple_select_field"])
def test_for_field_without_multiple_select_widget_filter_returns_false(form):
assert not is_multiple_choice_field(form["text_field"])
def test_row_with_select_multiple_field_is_rendered(snapshot):
html = render("{% form_row form.multiple_select_field %}")
assert snapshot == html
def test_row_with_disabled_select_multiple_field_is_rendered(snapshot):
form = Form()
form.fields["multiple_select_field"].disabled = True
html = render("{% form_row form.multiple_select_field %}", form)
assert snapshot == html
def test_row_with_select_multiple_field_with_value_is_rendered(snapshot):
form = Form({"multiple_select_field": ["r", "b"]})
html = render("{% form_row form.multiple_select_field %}", form)
assert snapshot == html
def test_for_field_with_textarea_widget_filter_returns_true(form):
assert is_textarea_field(form["textarea_field"])
def test_for_field_without_textarea_widget_filter_returns_false(form):
assert not is_textarea_field(form["text_field"])
def test_row_with_textarea_field_is_rendered(snapshot):
html = render("{% form_row form.textarea_field %}")
assert snapshot == html
def test_row_with_disabled_textarea_field_is_rendered(snapshot):
form = Form()
form.fields["textarea_field"].disabled = True
html = render("{% form_row form.textarea_field %}", form)
assert snapshot == html
def test_row_with_textarea_field_with_value_is_rendered(snapshot):
form = Form({"textarea_field": "Hello world!"})
html = render("{% form_row form.textarea_field %}", form)
assert snapshot == html
def test_for_yes_no_field_filter_returns_true(form):
assert is_yesno_switch_field(form["yesno_field"])
def test_for_non_yes_no_field_filter_returns_false(form):
assert not is_yesno_switch_field(form["text_field"])
def test_row_with_yes_no_field_is_rendered(snapshot):
html = render("{% form_row form.yesno_field %}")
assert snapshot == html
def test_row_with_disabled_yes_no_field_is_rendered(snapshot):
form = Form()
form.fields["yesno_field"].disabled = True
html = render("{% form_row form.yesno_field %}", form)
assert snapshot == html
def test_row_with_yes_no_field_with_value_is_rendered(snapshot):
form = Form({"yesno_field": True})
html = render("{% form_row form.yesno_field %}", form)
assert snapshot == html
def test_specified_class_name_is_rendered():
result = render_attrs({}, class_name="form-control")
assert result == 'class="form-control"'
def test_specified_class_name_overrided_by_class_attr():
result = render_attrs({"class": "custom"}, class_name="form-control")
assert result == 'class="custom"'
def test_attr_with_string_value_is_rendered():
result = render_attrs({"name": "lorem"})
assert result == 'name="lorem"'
def test_attr_with_int_value_is_rendered():
result = render_attrs({"cols": 5})
assert result == 'cols="5"'
def test_attr_with_boolean_true_value_is_not_rendered():
result = render_attrs({"selected": True})
assert result == ""
def test_attr_with_boolean_false_value_is_not_rendered():
result = render_attrs({"selected": False})
assert result == ""
def test_attr_with_none_value_is_not_rendered():
result = render_attrs({"selected": None})
assert result == ""
def test_attr_name_is_escaped():
result = render_attrs({'"': "test"})
assert result == '"="test"'
def test_attr_value_is_escaped():
result = render_attrs({"name": '"'})
assert result == 'name="""'
def test_multiple_valid_attrs_are_rendered():
result = render_attrs({"name": "lorem", "cols": 5})
assert result == 'name="lorem" cols="5"'
def test_empty_attr_dict_is_not_rendered():
result = render_attrs({})
assert result == ""
def test_attr_with_boolean_true_value_is_rendered():
result = render_bool_attrs({"selected": True})
assert result == "selected"
def test_bool_attr_with_string_value_is_not_rendered():
result = render_bool_attrs({"name": "hello"})
assert result == ""
def test_bool_attr_with_int_value_is_not_rendered():
result = render_bool_attrs({"col": 13})
assert result == ""
def test_bool_attr_with_boolean_false_value_is_not_rendered():
result = render_bool_attrs({"selected": False})
assert result == ""
def test_bool_attr_with_none_value_is_not_rendered():
result = render_bool_attrs({"selected": None})
assert result == ""
def test_bool_attr_with_false_int_value_is_not_rendered():
result = render_bool_attrs({"selected": 0})
assert result == ""
def test_multiple_bool_attrs_with_boolean_true_value_are_rendered():
result = render_bool_attrs({"selected": True, "required": True})
assert result == "selected required"
def test_only_bool_attrs_with_boolean_true_value_are_rendered():
result = render_bool_attrs({"selected": True, "string": "hello", "int": 123})
assert result == "selected"
def test_util_turns_dimensions_tuple_into_dict():
assert get_field_image_dimensions((20, 40)) == {"width": 20, "height": 40}
def test_util_returs_none_if_dimensions_are_empty():
assert get_field_image_dimensions(None) is None
| 13,793
|
Python
|
.py
| 293
| 42.511945
| 87
| 0.692671
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,278
|
test_group_category_permissions.py
|
rafalp_Misago/misago/admin/tests/test_group_category_permissions.py
|
import pytest
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...categories.models import Category
from ...permissions.enums import CategoryPermission
from ...permissions.models import CategoryGroupPermission
from ...test import assert_contains, assert_has_error_message, assert_has_info_message
def test_group_category_permissions_form_is_rendered(
admin_client, custom_group, sibling_category
):
response = admin_client.get(
reverse("misago:admin:groups:categories", kwargs={"pk": custom_group.id})
)
assert_contains(response, custom_group.name)
assert_contains(response, sibling_category.name)
def test_group_category_permissions_form_replaces_old_category_permissions_with_new(
admin_client, custom_group, sibling_category
):
see_permission = CategoryGroupPermission.objects.create(
group=custom_group,
category=sibling_category,
permission=CategoryPermission.SEE,
)
response = admin_client.post(
reverse("misago:admin:groups:categories", kwargs={"pk": custom_group.id}),
{f"permissions[{sibling_category.id}]": [CategoryPermission.BROWSE]},
)
assert response.status_code == 302
with pytest.raises(CategoryGroupPermission.DoesNotExist):
see_permission.refresh_from_db()
CategoryGroupPermission.objects.get(
group=custom_group,
category=sibling_category,
permission=CategoryPermission.BROWSE,
)
def test_group_category_permissions_form_invalidates_permissions_cache(
admin_client, custom_group, sibling_category
):
with assert_invalidates_cache(CacheName.PERMISSIONS):
admin_client.post(
reverse("misago:admin:groups:categories", kwargs={"pk": custom_group.id}),
{f"permissions[{sibling_category.id}]": [CategoryPermission.BROWSE]},
)
def test_group_category_permissions_form_redirects_to_groups_list_if_no_categories_exist(
admin_client, custom_group
):
Category.objects.filter(level__gt=0).delete()
response = admin_client.get(
reverse("misago:admin:groups:categories", kwargs={"pk": custom_group.id})
)
assert response.status_code == 302
assert_has_info_message(
response, "No categories exist to set group permissions for."
)
def test_group_category_permissions_form_handles_not_existing_group_id(
admin_client, custom_group
):
response = admin_client.get(
reverse(
"misago:admin:groups:categories",
kwargs={"pk": custom_group.id + 1000},
)
)
assert response.status_code == 302
assert_has_error_message(response, "Requested group does not exist.")
| 2,735
|
Python
|
.py
| 66
| 35.848485
| 89
| 0.727204
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,279
|
test_authorization.py
|
rafalp_Misago/misago/admin/tests/test_authorization.py
|
from time import time
from unittest.mock import Mock
import pytest
from django.test import override_settings
from ..auth import (
TOKEN_KEY,
UPDATED_KEY,
authorize_admin,
is_admin_authorized,
remove_admin_authorization,
update_admin_authorization,
)
def test_authorizing_admin_updates_request_session(user):
request = Mock(session={}, user=user)
authorize_admin(request)
assert request.session
def test_admin_user_can_be_authorized(admin):
request = Mock(session={}, user=admin)
authorize_admin(request)
assert is_admin_authorized(request)
def test_root_admin_user_can_be_authorized(root_admin):
request = Mock(session={}, user=root_admin)
authorize_admin(request)
assert is_admin_authorized(request)
def test_non_admin_user_admin_authorization_is_never_valid(user):
request = Mock(session={}, user=user)
authorize_admin(request)
assert not is_admin_authorized(request)
def test_anonymous_user_admin_authorization_is_never_valid(user, anonymous_user):
request = Mock(session={}, user=user)
authorize_admin(request)
request.user = anonymous_user
assert not is_admin_authorized(request)
def test_django_staff_admin_authorization_is_never_valid(staffuser):
request = Mock(session={}, user=staffuser)
authorize_admin(request)
assert not is_admin_authorized(request)
def test_django_superuser_admin_authorization_is_never_valid(superuser):
request = Mock(session={}, user=superuser)
authorize_admin(request)
assert not is_admin_authorized(request)
def test_django_non_staff_superuser_admin_authorization_is_never_valid(superuser):
superuser.is_staff = False
superuser.save()
request = Mock(session={}, user=superuser)
authorize_admin(request)
assert not is_admin_authorized(request)
@pytest.fixture
def admin_request(admin):
request = Mock(session={}, user=admin)
authorize_admin(request)
return request
def test_admin_authorization_is_invalidated_by_user_pk_change(admin_request, admin):
admin_request.user.pk = admin.pk + 1
assert not is_admin_authorized(admin_request)
def test_admin_authorization_is_invalidated_by_user_email_change(admin_request):
admin_request.user.email = "changed@example.com"
assert not is_admin_authorized(admin_request)
def test_admin_authorization_is_invalidated_by_user_password_change(admin_request):
admin_request.user.set_password("changed-password")
assert not is_admin_authorized(admin_request)
def test_admin_authorization_is_invalidated_by_secret_key_change(admin_request):
with override_settings(SECRET_KEY="changed-secret-key"):
assert not is_admin_authorized(admin_request)
def test_admin_authorization_is_invalidated_by_token_change(admin_request):
admin_request.session[TOKEN_KEY] = "authorization-token-changed"
assert not is_admin_authorized(admin_request)
@override_settings(MISAGO_ADMIN_SESSION_EXPIRATION=5)
def test_admin_authorization_is_invalidated_by_token_expiration(admin_request):
admin_request.session[UPDATED_KEY] = time() - 5 * 60 - 1
assert not is_admin_authorized(admin_request)
def test_updating_authorization_extends_authorization_expiration_time(admin_request):
admin_request.session[UPDATED_KEY] = 0
update_admin_authorization(admin_request)
assert admin_request.session[UPDATED_KEY]
def test_updating_authorization_validates_authorization(admin_request):
admin_request.session[UPDATED_KEY] = 0
update_admin_authorization(admin_request)
assert is_admin_authorized(admin_request)
def test_removing_authorization_removes_autorization_from_request_session(
admin_request,
):
admin_request.session[UPDATED_KEY] = 0
remove_admin_authorization(admin_request)
assert not admin_request.session
def test_removing_authorization_invalidates_autorization(admin_request):
admin_request.session[UPDATED_KEY] = 0
remove_admin_authorization(admin_request)
assert not is_admin_authorized(admin_request)
| 4,033
|
Python
|
.py
| 89
| 41.067416
| 85
| 0.774789
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,280
|
test_yesno_switch.py
|
rafalp_Misago/misago/admin/tests/test_yesno_switch.py
|
from django import forms
from ..forms import YesNoSwitch
class YesNoForm(forms.Form):
test_field = YesNoSwitch(label="Hello!")
def test_input_returns_int_true_for_valid_true_input():
for value in ("1", "True", "true", 1, True):
form = YesNoForm({"test_field": value})
form.full_clean()
assert form.cleaned_data["test_field"] == 1
def test_input_returns_int_false_for_false_input():
for value in ("0", "False", "false", False, 0, None, ""):
form = YesNoForm({"test_field": value})
form.full_clean()
assert form.cleaned_data["test_field"] == 0
def test_input_returns_int_false_for_invalid_input():
form = YesNoForm({"test_field": "invalid"})
form.full_clean()
assert form.cleaned_data["test_field"] == 0
| 783
|
Python
|
.py
| 18
| 38
| 61
| 0.654762
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,281
|
test_admin_momentjs_locales.py
|
rafalp_Misago/misago/admin/tests/test_admin_momentjs_locales.py
|
from django.urls import reverse
from django.utils import translation
from ...test import assert_contains, assert_not_contains
from ..momentjs import MISAGO_ADMIN_MOMENT_LOCALES, get_admin_locales
def test_admin_loads_locales_list():
assert get_admin_locales()
def test_admin_locales_list_include_some_valid_locales():
assert "pl" in MISAGO_ADMIN_MOMENT_LOCALES
assert "en-gb" in MISAGO_ADMIN_MOMENT_LOCALES
def test_moment_locale_is_not_included_for_english(admin_client):
with translation.override("en"):
response = admin_client.get(reverse("misago:admin:index"))
assert_not_contains(response, "misago/admin/momentjs/")
def test_moment_locale_is_included_for_british_english(admin_client):
with translation.override("en_GB"):
response = admin_client.get(reverse("misago:admin:index"))
assert_contains(response, "misago/admin/momentjs/en-gb.js")
| 907
|
Python
|
.py
| 17
| 48.764706
| 69
| 0.759364
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,282
|
test_category_new.py
|
rafalp_Misago/misago/admin/tests/test_category_new.py
|
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...categories.models import Category
from ...permissions.models import CategoryGroupPermission
from ...test import assert_contains
from .categories_tree import assert_valid_categories_tree
category_new = reverse("misago:admin:categories:new")
def test_new_category_form_renders(admin_client):
response = admin_client.get(category_new)
assert_contains(response, "New category")
def form_data(new_data: dict) -> dict:
data = {
"name": "New Category",
"short_name": "",
"color": "",
"description": "",
"css_class": "",
"copy_permissions": "",
"allow_polls": True,
"delay_browse_check": False,
"show_started_only": False,
"is_closed": False,
"is_vanilla": False,
"list_children_threads": True,
"children_categories_component": "full",
"require_threads_approval": False,
"require_replies_approval": False,
"require_edits_approval": False,
"prune_started_after": "0",
"prune_replied_after": "0",
"archive_pruned_in": "",
}
data.update(new_data)
return data
def test_new_category_form_creates_new_top_category(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(root_category.id),
}
),
)
assert response.status_code == 302
new_category = Category.objects.get(slug="new-category")
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(new_category, 1, 4, 5),
]
)
def test_new_category_form_creates_new_child_category(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(default_category.id),
}
),
)
assert response.status_code == 302
new_category = Category.objects.get(slug="new-category")
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 5),
(new_category, 2, 3, 4),
]
)
def test_new_category_form_copies_category_permissions(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(root_category.id),
"copy_permissions": str(default_category.id),
}
),
)
assert response.status_code == 302
new_category = Category.objects.get(slug="new-category")
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(new_category, 1, 4, 5),
]
)
assert CategoryGroupPermission.objects.filter(category=new_category).exists()
def test_new_category_form_creates_category_with_archive(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(root_category.id),
"archive_pruned_in": str(default_category.id),
}
),
)
assert response.status_code == 302
new_category = Category.objects.get(slug="new-category")
assert new_category.archive_pruned_in == default_category
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(new_category, 1, 4, 5),
]
)
def test_new_category_form_invalidates_categories_cache(
admin_client, root_category, default_category
):
with assert_invalidates_cache(CacheName.CATEGORIES):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(root_category.id),
}
),
)
assert response.status_code == 302
new_category = Category.objects.get(slug="new-category")
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(new_category, 1, 4, 5),
]
)
def test_new_category_form_invalidates_moderators_cache(
admin_client, root_category, default_category
):
with assert_invalidates_cache(CacheName.MODERATORS):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(root_category.id),
}
),
)
assert response.status_code == 302
new_category = Category.objects.get(slug="new-category")
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(new_category, 1, 4, 5),
]
)
def test_new_category_form_invalidates_permissions_cache(
admin_client, root_category, default_category
):
with assert_invalidates_cache(CacheName.PERMISSIONS):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(root_category.id),
}
),
)
assert response.status_code == 302
new_category = Category.objects.get(slug="new-category")
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(new_category, 1, 4, 5),
]
)
def test_new_category_form_fails_if_parent_doesnt_exist(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(default_category.id + 1),
}
),
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_new_category_form_creates_vanilla_category(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data({"new_parent": str(root_category.id), "is_vanilla": True}),
)
assert response.status_code == 302
new_category = Category.objects.get(slug="new-category")
assert new_category.is_vanilla
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 3),
(new_category, 1, 4, 5),
]
)
def test_new_category_form_fails_if_vanilla_category_with_parent(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data({"new_parent": str(default_category.id), "is_vanilla": True}),
)
assert_contains(response, "Only top-level categories can be set as vanilla.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_new_category_form_fails_if_vanilla_category_without_threads_and_categories_dropdown(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(root_category.id),
"is_vanilla": True,
"list_children_threads": False,
"children_categories_component": "dropdown",
}
),
)
assert_contains(
response,
"This choice is not available for vanilla categories with disabled listing",
)
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_new_category_form_fails_if_copy_permissions_doesnt_exist(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(default_category.id),
"copy_permissions": str(default_category.id + 1),
}
),
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_new_category_form_fails_if_copy_permissions_is_root(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(default_category.id),
"copy_permissions": str(root_category.id),
}
),
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_new_category_form_fails_if_archive_doesnt_exist(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(default_category.id),
"archive_pruned_in": str(default_category.id + 1),
}
),
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
def test_new_category_form_fails_if_archive_is_root(
admin_client, root_category, default_category
):
response = admin_client.post(
category_new,
form_data(
{
"new_parent": str(default_category.id),
"archive_pruned_in": str(root_category.id),
}
),
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
| 10,343
|
Python
|
.py
| 331
| 22.761329
| 93
| 0.575417
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,283
|
test_moderator_edit.py
|
rafalp_Misago/misago/admin/tests/test_moderator_edit.py
|
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...permissions.models import Moderator
from ...test import assert_contains, assert_has_error_message
def test_moderator_edit_group_form_renders(admin_client, custom_group):
moderator = Moderator.objects.create(group=custom_group)
response = admin_client.get(
reverse("misago:admin:moderators:edit", kwargs={"pk": moderator.pk}),
)
assert_contains(response, custom_group.name)
def test_moderator_edit_user_form_renders(admin_client, other_user):
moderator = Moderator.objects.create(user=other_user)
response = admin_client.get(
reverse("misago:admin:moderators:edit", kwargs={"pk": moderator.pk}),
)
assert_contains(response, other_user.username)
def test_moderator_edit_group_form_updates_moderator(admin_client, custom_group):
moderator = Moderator.objects.create(group=custom_group, is_global=True)
response = admin_client.post(
reverse("misago:admin:moderators:edit", kwargs={"pk": moderator.pk}),
{"is_global": "0"},
)
assert response.status_code == 302
moderator.refresh_from_db()
assert not moderator.is_global
def test_moderator_edit_user_form_updates_moderator(admin_client, other_user):
moderator = Moderator.objects.create(user=other_user, is_global=True)
assert moderator.is_global
response = admin_client.post(
reverse("misago:admin:moderators:edit", kwargs={"pk": moderator.pk}),
{"is_global": "0"},
)
assert response.status_code == 302
moderator.refresh_from_db()
assert not moderator.is_global
def test_moderator_edit_group_form_invalidates_moderators_cache(
admin_client, custom_group
):
moderator = Moderator.objects.create(group=custom_group)
with assert_invalidates_cache(CacheName.MODERATORS):
admin_client.post(
reverse("misago:admin:moderators:edit", kwargs={"pk": moderator.pk}),
{"is_global": "0"},
)
def test_moderator_edit_user_form_invalidates_moderators_cache(
admin_client, other_user
):
moderator = Moderator.objects.create(user=other_user)
with assert_invalidates_cache(CacheName.MODERATORS):
admin_client.post(
reverse("misago:admin:moderators:edit", kwargs={"pk": moderator.pk}),
{"is_global": "0"},
)
def test_moderator_edit_handles_non_existing_moderator(admin_client):
response = admin_client.get(
reverse("misago:admin:moderators:edit", kwargs={"pk": 404}),
)
assert_has_error_message(response, "Requested moderator does not exist.")
def test_moderator_edit_handles_non_protected_moderator(admin_client, admins_group):
moderator = Moderator.objects.get(group=admins_group)
response = admin_client.get(
reverse("misago:admin:moderators:edit", kwargs={"pk": moderator.id}),
)
assert_has_error_message(
response,
'Can\'t change "Administrators" moderator permissions because they are protected.',
)
| 3,085
|
Python
|
.py
| 68
| 39.573529
| 91
| 0.71548
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,284
|
test_protected_urls_detection.py
|
rafalp_Misago/misago/admin/tests/test_protected_urls_detection.py
|
from unittest.mock import Mock
from django.urls import reverse
from ..views import get_protected_namespace
django_admin_url = reverse("admin:index")
misago_admin_url = reverse("misago:admin:index")
site_url = reverse("misago:index")
def test_request_to_misago_admin_root_url_is_protected():
request = Mock(path=misago_admin_url)
assert get_protected_namespace(request) == "misago:admin"
def test_request_to_misago_admin_subpath_url_is_protected():
request = Mock(path=misago_admin_url + "users/")
assert get_protected_namespace(request) == "misago:admin"
def test_request_to_django_admin_root_url_is_protected():
request = Mock(path=django_admin_url)
assert get_protected_namespace(request) == "admin"
def test_request_to_django_admin_subpath_url_is_protected():
request = Mock(path=django_admin_url + "users/")
assert get_protected_namespace(request) == "admin"
def test_request_to_site_root_url_is_not_protected():
request = Mock(path=site_url)
assert get_protected_namespace(request) is None
def test_request_to_site_subpath_url_is_not_protected():
request = Mock(path=site_url + "t/some-thread-123/")
assert get_protected_namespace(request) is None
def test_request_to_site_non_reversable_url_is_not_protected():
request = Mock(path=site_url + "somewhere-custom/")
assert get_protected_namespace(request) is None
| 1,390
|
Python
|
.py
| 27
| 47.777778
| 63
| 0.751857
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,285
|
test_category_delete.py
|
rafalp_Misago/misago/admin/tests/test_category_delete.py
|
import pytest
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...categories.models import Category
from ...test import assert_contains, assert_has_error_message
from ...threads.models import Thread
from .categories_tree import assert_valid_categories_tree
def test_category_delete_form_renders(default_category, admin_client):
response = admin_client.get(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
)
assert_contains(response, "Delete category")
def test_category_delete_form_shows_error_if_category_doesnt_exist(
default_category, admin_client
):
response = admin_client.get(
reverse(
"misago:admin:categories:delete", kwargs={"pk": default_category.pk + 1}
),
)
assert response.status_code == 302
assert_has_error_message(response, "Requested category does not exist.")
def test_category_delete_form_shows_error_if_category_is_root(
root_category, admin_client
):
response = admin_client.get(
reverse("misago:admin:categories:delete", kwargs={"pk": root_category.pk}),
)
assert response.status_code == 302
assert_has_error_message(response, "Requested category does not exist.")
def test_only_leaf_category_is_deleted(root_category, default_category, admin_client):
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": ""},
)
assert response.status_code == 302
assert_valid_categories_tree([(root_category, 0, 1, 2)])
def test_category_with_child_is_deleted_together_with_child(
root_category, default_category, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": ""},
)
assert response.status_code == 302
assert_valid_categories_tree([(root_category, 0, 1, 2)])
def test_category_with_child_is_deleted_and_child_is_made_top_category(
root_category, default_category, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": str(root_category.id), "move_threads_to": ""},
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(child_category, 1, 2, 3),
]
)
def test_category_with_child_is_deleted_and_child_is_moved_to_sibling(
root_category, default_category, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": str(sibling_category.id), "move_threads_to": ""},
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(sibling_category, 1, 2, 5),
(child_category, 2, 3, 4),
]
)
def test_category_with_child_cant_be_deleted_because_move_children_to_is_invalid(
root_category, default_category, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": str(child_category.id + 1), "move_threads_to": ""},
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 5),
(child_category, 2, 3, 4),
]
)
def test_category_with_children_cant_be_deleted_because_move_children_to_is_deleted(
root_category, default_category, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
deep_category = Category(name="Child Category", slug="child-category")
deep_category.insert_at(child_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": str(child_category.id), "move_threads_to": ""},
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 8),
(default_category, 1, 2, 7),
(child_category, 2, 3, 6),
(deep_category, 3, 4, 5),
]
)
def test_category_with_children_cant_be_deleted_because_deep_move_children_to_is_deleted(
root_category, default_category, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
deep_category = Category(name="Deep Category", slug="deep-category")
deep_category.insert_at(child_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": str(deep_category.id), "move_threads_to": ""},
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 8),
(default_category, 1, 2, 7),
(child_category, 2, 3, 6),
(deep_category, 3, 4, 5),
]
)
def test_category_is_deleted_and_sibling_edges_are_updated(
root_category, default_category, admin_client
):
sibling_category = Category(name="Sibling Category", slug="sibling-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": ""},
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(sibling_category, 1, 2, 3),
]
)
def test_category_is_deleted_and_both_siblings_edges_are_updated(
root_category, default_category, admin_client
):
first_category = Category(name="F Category", slug="f-category")
first_category.insert_at(root_category, position="first-child", save=True)
last_category = Category(name="l Category", slug="l-category")
last_category.insert_at(root_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": ""},
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(first_category, 1, 2, 3),
(last_category, 1, 4, 5),
]
)
def test_category_thread_is_deleted_with_category(
root_category, default_category, thread, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": ""},
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 2),
]
)
with pytest.raises(Thread.DoesNotExist):
thread.refresh_from_db()
def test_category_thread_is_moved_to_other_category_on_delete(
root_category, default_category, thread, admin_client
):
sibling_category = Category(name="Child Category", slug="child-category")
sibling_category.insert_at(root_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": str(sibling_category.id)},
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(sibling_category, 1, 2, 3),
]
)
sibling_category.refresh_from_db()
assert sibling_category.last_thread == thread
thread.refresh_from_db()
assert thread.category == sibling_category
def test_category_thread_is_moved_to_kept_child_category_on_delete(
root_category, default_category, thread, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={
"move_children_to": str(root_category.id),
"move_threads_to": str(child_category.id),
},
)
assert response.status_code == 302
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(child_category, 1, 2, 3),
]
)
child_category.refresh_from_db()
assert child_category.last_thread == thread
thread.refresh_from_db()
assert thread.category == child_category
def test_category_threads_cant_be_moved_to_deleted_child_category(
root_category, default_category, thread, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": str(child_category.id)},
)
assert_contains(
response,
"You are trying to move this category's threads to a child category that will also be deleted.",
)
assert_valid_categories_tree(
[
(root_category, 0, 1, 6),
(default_category, 1, 2, 5),
(child_category, 2, 3, 4),
]
)
thread.refresh_from_db()
assert thread.category == default_category
def test_category_threads_cant_be_moved_to_deleted_deep_category(
root_category, default_category, thread, admin_client
):
child_category = Category(name="Child Category", slug="child-category")
child_category.insert_at(default_category, position="last-child", save=True)
deep_category = Category(name="Deep Category", slug="deep-category")
deep_category.insert_at(child_category, position="last-child", save=True)
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": str(deep_category.id)},
)
assert_contains(
response,
"You are trying to move this category's threads to a child category that will also be deleted.",
)
assert_valid_categories_tree(
[
(root_category, 0, 1, 8),
(default_category, 1, 2, 7),
(child_category, 2, 3, 6),
(deep_category, 3, 4, 5),
]
)
thread.refresh_from_db()
assert thread.category == default_category
def test_category_threads_cant_be_moved_to_root_category(
root_category, default_category, thread, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": str(root_category.id)},
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
thread.refresh_from_db()
assert thread.category == default_category
def test_category_threads_cant_be_moved_to_nonexisting_category(
root_category, default_category, thread, admin_client
):
response = admin_client.post(
reverse("misago:admin:categories:delete", kwargs={"pk": default_category.pk}),
data={"move_children_to": "", "move_threads_to": str(default_category.id + 1)},
)
assert_contains(response, "That choice is not one of the available choices.")
assert_valid_categories_tree(
[
(root_category, 0, 1, 4),
(default_category, 1, 2, 3),
]
)
thread.refresh_from_db()
assert thread.category == default_category
def test_deleting_category_invalidates_categories_cache(default_category, admin_client):
with assert_invalidates_cache(CacheName.CATEGORIES):
admin_client.post(
reverse(
"misago:admin:categories:delete", kwargs={"pk": default_category.pk}
),
data={"move_children_to": "", "move_threads_to": ""},
)
def test_deleting_category_invalidates_permissions_cache(
default_category, admin_client
):
with assert_invalidates_cache(CacheName.PERMISSIONS):
admin_client.post(
reverse(
"misago:admin:categories:delete", kwargs={"pk": default_category.pk}
),
data={"move_children_to": "", "move_threads_to": ""},
)
def test_deleting_category_invalidates_moderators_cache(default_category, admin_client):
with assert_invalidates_cache(CacheName.MODERATORS):
admin_client.post(
reverse(
"misago:admin:categories:delete", kwargs={"pk": default_category.pk}
),
data={"move_children_to": "", "move_threads_to": ""},
)
| 14,591
|
Python
|
.py
| 339
| 36.19174
| 109
| 0.66156
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,286
|
test_generic_admin_ordering_view.py
|
rafalp_Misago/misago/admin/tests/test_generic_admin_ordering_view.py
|
from urllib.parse import urlencode
from django.urls import reverse
from ...test import assert_contains
ordering_link = reverse("misago:admin:groups:ordering")
def test_ordering_view_returns_error_405_if_request_is_not_post(admin_client):
response = admin_client.get(ordering_link)
assert response.status_code == 405
def test_ordering_view_returns_error_if_post_request_was_empty(admin_client):
response = admin_client.post(ordering_link)
assert_contains(response, "No items sent.", status_code=400)
def test_ordering_view_returns_error_if_posted_item_type_is_invalid(admin_client):
response = admin_client.post(ordering_link, {"item": ["invalid"]})
assert_contains(response, "Invalid item type: invalid", status_code=400)
def test_ordering_view_returns_error_if_posted_item_is_not_unique(
admin_client, admins_group, members_group
):
response = admin_client.post(
ordering_link,
{"item": [str(admins_group.id), str(members_group.id), str(members_group.id)]},
)
assert_contains(
response,
f"The item is not unique: {members_group.id}",
status_code=400,
)
def test_ordering_view_returns_error_if_posted_item_doesnt_exist(
admin_client, admins_group, members_group
):
response = admin_client.post(
ordering_link,
{
"item": [
str(admins_group.id),
str(members_group.id),
str(members_group.id + 100),
]
},
)
assert_contains(
response,
f"The item does not exist: {members_group.id + 100}",
status_code=400,
)
def test_ordering_view_returns_204_response_on_success(
admin_client, admins_group, moderators_group, members_group
):
response = admin_client.post(
ordering_link,
{
"item": [
str(admins_group.id),
str(moderators_group.id),
str(members_group.id),
]
},
)
assert response.status_code == 204
| 2,043
|
Python
|
.py
| 57
| 28.684211
| 87
| 0.648402
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,287
|
test_group_delete.py
|
rafalp_Misago/misago/admin/tests/test_group_delete.py
|
from unittest.mock import patch
import pytest
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...test import assert_has_error_message
from ...users.models import Group
@patch("misago.users.groups.remove_group_from_users_groups_ids")
def test_custom_group_is_deleted(
mock_remove_group_from_users_groups_ids, admin_client, custom_group
):
response = admin_client.post(
reverse("misago:admin:groups:delete", kwargs={"pk": custom_group.id})
)
assert response.status_code == 302
with pytest.raises(Group.DoesNotExist):
custom_group.refresh_from_db()
@patch("misago.users.groups.remove_group_from_users_groups_ids")
def test_deleting_group_invalidates_groups_cache(
mock_remove_group_from_users_groups_ids, admin_client, custom_group
):
with assert_invalidates_cache(CacheName.GROUPS):
admin_client.post(
reverse("misago:admin:groups:delete", kwargs={"pk": custom_group.id})
)
@patch("misago.users.groups.remove_group_from_users_groups_ids")
def test_deleting_group_invalidates_permissions_cache(
mock_remove_group_from_users_groups_ids, admin_client, custom_group
):
with assert_invalidates_cache(CacheName.PERMISSIONS):
admin_client.post(
reverse("misago:admin:groups:delete", kwargs={"pk": custom_group.id})
)
@patch("misago.users.groups.remove_group_from_users_groups_ids")
def test_deleting_group_calls_users_groups_ids_update_task(
mock_remove_group_from_users_groups_ids, admin_client, custom_group
):
admin_client.post(
reverse("misago:admin:groups:delete", kwargs={"pk": custom_group.id})
)
mock_remove_group_from_users_groups_ids.delay.assert_called_once_with(
custom_group.id
)
def test_protected_group_cant_be_deleted(admin_client, members_group, user):
response = admin_client.post(
reverse("misago:admin:groups:delete", kwargs={"pk": members_group.id})
)
assert_has_error_message(response, 'Can\'t delete a protected group "Members".')
def test_default_group_cant_be_deleted(admin_client, custom_group):
custom_group.is_default = True
custom_group.save()
response = admin_client.post(
reverse("misago:admin:groups:delete", kwargs={"pk": custom_group.id})
)
assert_has_error_message(
response, 'Can\'t delete the default group "Custom Group".'
)
def test_main_group_cant_be_deleted(admin_client, custom_group, user):
user.set_groups(custom_group)
user.save()
response = admin_client.post(
reverse("misago:admin:groups:delete", kwargs={"pk": custom_group.id})
)
assert_has_error_message(
response,
"Can't delete \"Custom Group\" group because it's a main group for some users.",
)
def test_non_existing_group_cant_be_deleted(admin_client):
response = admin_client.post(
reverse("misago:admin:groups:delete", kwargs={"pk": 404})
)
assert_has_error_message(response, "Requested group does not exist.")
| 3,078
|
Python
|
.py
| 72
| 37.666667
| 88
| 0.718164
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,288
|
test_logout_from_admin.py
|
rafalp_Misago/misago/admin/tests/test_logout_from_admin.py
|
from django.urls import reverse
from ...test import assert_has_info_message
from ..auth import is_admin_authorized
admin_logout_link = reverse("misago:admin:logout")
admin_link = reverse("misago:admin:index")
site_logout_link = reverse("misago:logout")
def test_admin_can_logout_from_admin_site_but_stay_logged(admin_client, admin):
response = admin_client.post(admin_logout_link)
assert response.wsgi_request.user == admin
assert not is_admin_authorized(response.wsgi_request)
def test_admin_is_redirected_to_login_form_on_logout(admin_client):
response = admin_client.post(admin_logout_link)
assert response.status_code == 302
assert response["location"] == admin_link
def test_admin_is_displayed_message_after_logout(admin_client):
response = admin_client.post(admin_logout_link)
assert_has_info_message(response, "Your admin session has been closed.")
def test_admin_can_logout_from_entire_site(admin_client):
response = admin_client.post(site_logout_link)
assert response.wsgi_request.user.is_anonymous
assert not is_admin_authorized(response.wsgi_request)
| 1,116
|
Python
|
.py
| 21
| 49.571429
| 79
| 0.775115
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,289
|
test_groups.py
|
rafalp_Misago/misago/admin/tests/test_groups.py
|
from django.urls import reverse
from ...cache.enums import CacheName
from ...cache.test import assert_invalidates_cache
from ...test import assert_contains
groups_list = reverse("misago:admin:groups:index")
def test_groups_link_is_registered_in_admin_nav(admin_client):
response = admin_client.get(reverse("misago:admin:index"))
assert_contains(response, groups_list)
def test_groups_list_renders(
admin_client, admins_group, moderators_group, members_group, guests_group
):
response = admin_client.get(groups_list)
assert_contains(response, admins_group.name)
assert_contains(response, moderators_group.name)
assert_contains(response, members_group.name)
assert_contains(response, guests_group.name)
def test_groups_can_be_reordered(
admin_client, admins_group, moderators_group, members_group, guests_group
):
response = admin_client.post(
reverse("misago:admin:groups:ordering"),
{
"item": [
str(members_group.id),
str(guests_group.id),
str(admins_group.id),
str(moderators_group.id),
],
},
)
assert response.status_code == 204
admins_group.refresh_from_db()
assert admins_group.ordering == 2
moderators_group.refresh_from_db()
assert moderators_group.ordering == 3
members_group.refresh_from_db()
assert members_group.ordering == 0
guests_group.refresh_from_db()
assert guests_group.ordering == 1
def test_reordering_groups_invalidates_groups_cache(
admin_client, admins_group, moderators_group, members_group, guests_group
):
with assert_invalidates_cache(CacheName.GROUPS):
admin_client.post(
reverse("misago:admin:groups:ordering"),
{
"item": [
str(members_group.id),
str(guests_group.id),
str(admins_group.id),
str(moderators_group.id),
],
},
)
| 2,031
|
Python
|
.py
| 54
| 29.611111
| 77
| 0.651044
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,290
|
forms.py
|
rafalp_Misago/misago/admin/moderators/forms.py
|
from django import forms
from django.utils.translation import pgettext_lazy
from ...categories.enums import CategoryTree
from ...categories.models import Category
from ...permissions.models import Moderator
from ...users.models import Group
from ..forms import YesNoSwitch
class NewModeratorModalForm(forms.Form):
moderator_type = forms.ChoiceField(
label=pgettext_lazy("admin moderators form", "Moderator type"),
choices=[
("group", pgettext_lazy("admin moderators form type choice", "User group")),
(
"user",
pgettext_lazy("admin moderators form type choice", "Individual user"),
),
],
)
group = forms.TypedChoiceField(
label=pgettext_lazy("admin moderators form", "Group"),
choices=[],
coerce=int,
required=False,
)
user = forms.CharField(
label=pgettext_lazy("admin moderators form", "User"),
required=False,
)
def __init__(self, *args, **kwarg):
super().__init__(*args, **kwarg)
self.fields["group"].choices = []
for group in Group.objects.all():
self.fields["group"].choices.append((group.id, str(group)))
class ModeratorForm(forms.ModelForm):
is_global = YesNoSwitch(
label=pgettext_lazy("admin moderators form", "Is global moderator"),
help_text=pgettext_lazy(
"admin moderators form",
"Global moderators can moderate all content they have access to. Other options have no effect if this setting is enabled.",
),
)
categories = forms.TypedMultipleChoiceField(
label=pgettext_lazy("admin moderators form", "Moderated categories"),
coerce=int,
required=False,
)
private_threads = YesNoSwitch(
label=pgettext_lazy("admin moderators form", "Is private threads moderator"),
)
class Meta:
model = Moderator
fields = ["is_global", "categories", "private_threads"]
def __init__(self, *args, **kwarg):
super().__init__(*args, **kwarg)
self.fields["categories"].choices = get_categories_choices()
def get_categories_choices():
categories_queryset = Category.objects.filter(
level__gt=0, tree_id=CategoryTree.THREADS
).values_list("id", "name", "level")
categories_choices = []
for category_id, category_name, category_level in categories_queryset:
prefix = ""
if category_level > 1:
prefix = " → " * (category_level - 1)
categories_choices.append((category_id, f"{prefix}{category_name}"))
return categories_choices
| 2,643
|
Python
|
.py
| 66
| 32.575758
| 135
| 0.644809
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,291
|
views.py
|
rafalp_Misago/misago/admin/moderators/views.py
|
from django.contrib import messages
from django.contrib.auth import get_user_model
from django.shortcuts import redirect
from django.urls import reverse
from django.utils.translation import pgettext, pgettext_lazy
from ...cache.enums import CacheName
from ...cache.versions import invalidate_cache
from ...permissions.models import Moderator
from ...users.models import Group
from ..views import generic
from .forms import ModeratorForm, NewModeratorModalForm
User = get_user_model()
class ModeratorAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:moderators:index"
templates_dir = "misago/admin/moderators"
model = Moderator
message_404 = pgettext_lazy(
"admin moderators", "Requested moderator does not exist."
)
class ListView(ModeratorAdmin, generic.ListView):
def get_queryset(self):
return self.get_model().objects.prefetch_related("group", "user")
def process_context(self, request, context):
context["items"] = sort_moderators(context["items"])
context["new_moderator_form"] = NewModeratorModalForm(
auto_id="new_moderator_form_%s",
)
return context
def sort_moderators(items):
groups = []
users = []
for item in items:
if item.group_id:
groups.append(item)
else:
users.append(item)
groups = sorted(groups, key=lambda i: i.group.id)
users = sorted(users, key=lambda i: i.user.username)
return groups + users
class NewView(ModeratorAdmin, generic.ModelFormView):
template_name = "form.html"
form_class = ModeratorForm
message_404 = pgettext_lazy(
"admin moderators", "Requested user or group does not exist."
)
def get_target(self, request, kwargs):
if kwargs.get("group"):
group = Group.objects.get(id=kwargs["group"])
return Moderator(group=group)
else:
user = User.objects.get(id=kwargs["user"])
return Moderator(user=user)
def get_target_or_none(self, request, kwargs):
try:
return self.get_target(request, kwargs)
except (Group.DoesNotExist, User.DoesNotExist):
return None
def real_dispatch(self, request, target):
# If moderator already exists for given group or user, redirect to it
if target.group_id:
instance = Moderator.objects.filter(group=target.group).first()
else:
instance = Moderator.objects.filter(user=target.user).first()
if instance:
return redirect(
reverse("misago:admin:moderators:edit", kwargs={"pk": instance.id})
)
return super().real_dispatch(request, target)
def check_permissions(self, request, target):
if target.group and target.group.is_default:
return pgettext_lazy(
"admin moderators",
"Can't grant \"%(name)s\" moderator permissions because it's the default group.",
) % {"name": target.name}
if target.group and target.group.is_protected:
return pgettext_lazy(
"admin moderators",
"Can't grant \"%(name)s\" moderator permissions because it's protected group.",
) % {"name": target.name}
def handle_form(self, data, request, target):
super().handle_form(data, request, target)
invalidate_cache(CacheName.MODERATORS)
class EditView(ModeratorAdmin, generic.ModelFormView):
template_name = "form.html"
form_class = ModeratorForm
success_message = pgettext_lazy(
"admin moderators", '"%(name)s" moderator has been updated.'
)
def check_permissions(self, request, target):
if target.is_protected:
return pgettext(
"admin moderators",
'Can\'t change "%(name)s" moderator permissions because they are protected.',
) % {"name": target.group}
def handle_form(self, data, request, target):
super().handle_form(data, request, target)
invalidate_cache(CacheName.MODERATORS)
class DeleteView(ModeratorAdmin, generic.ButtonView):
def check_permissions(self, request, target):
if target.is_protected:
return pgettext(
"admin moderators",
'Can\'t remove "%(name)s" moderator permissions because they are protected.',
) % {"name": target.group}
def button_action(self, request, target):
target.delete()
invalidate_cache(CacheName.MODERATORS)
message = pgettext("admin moderators", '"%(name)s" moderator has been deleted.')
messages.success(request, message % {"name": target.name})
| 4,710
|
Python
|
.py
| 109
| 34.93578
| 97
| 0.657262
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,292
|
forms.py
|
rafalp_Misago/misago/admin/groups/forms.py
|
from django import forms
from django.core.validators import validate_slug
from django.utils.translation import pgettext_lazy
from ...core.validators import validate_color_hex, validate_css_name, validate_sluggable
from ...parser.context import create_parser_context
from ...parser.enums import ContentType
from ...parser.factory import create_parser
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 ...users.models import Group, GroupDescription
from ..forms import YesNoSwitch
class NewGroupForm(forms.ModelForm):
name = forms.CharField(
label=pgettext_lazy("admin group form", "Name"),
validators=[validate_sluggable()],
)
copy_permissions = forms.ModelChoiceField(
label=pgettext_lazy("admin group form", "Copy permissions from"),
help_text=pgettext_lazy(
"admin group form",
"You can speed up a new group setup process by copying its permissions from another group. Aadministrator and moderator permissions are not copied.",
),
queryset=Group.objects,
required=False,
empty_label=pgettext_lazy("admin group form", "(Don't copy permissions)"),
)
class Meta:
model = Group
fields = ["name"]
class EditGroupForm(forms.ModelForm):
name = forms.CharField(
label=pgettext_lazy("admin group form", "Name"),
validators=[validate_sluggable()],
)
slug = forms.CharField(
label=pgettext_lazy("admin group form", "Slug"),
help_text=pgettext_lazy(
"admin group form",
"Leave this field empty to set a default slug from the group's name.",
),
validators=[validate_slug],
required=False,
)
user_title = forms.CharField(
label=pgettext_lazy("admin group form", "User title"),
help_text=pgettext_lazy(
"admin group form",
"Optional user title displayed instead of the group's name next to group members in the interface.",
),
required=False,
)
color = forms.CharField(
label=pgettext_lazy("admin group form", "Color"),
help_text=pgettext_lazy(
"admin group form",
"Optional. Should be in hex format, eg. #F5A9B8.",
),
required=False,
validators=[validate_color_hex],
)
icon = forms.CharField(
label=pgettext_lazy("admin group form", "Icon"),
help_text=pgettext_lazy(
"admin group form",
"Optional icon displayed next to the group's name (or member titles) in the interface.",
),
required=False,
)
css_suffix = forms.CharField(
label=pgettext_lazy("admin group form", "CSS suffix"),
help_text=pgettext_lazy(
"admin group form",
"Optional CSS suffix added to various interface elements, enabling customization of how content from group members is displayed.",
),
validators=[validate_css_name],
required=False,
)
is_page = YesNoSwitch(
label=pgettext_lazy(
"admin group form", "Give this group a dedicated section on the Users page"
),
help_text=pgettext_lazy(
"admin group form",
"Enabling this option will allow users to view all members of this group on a dedicated section of the Users page.",
),
)
is_hidden = YesNoSwitch(
label=pgettext_lazy("admin group form", "Hide this group on user details"),
help_text=pgettext_lazy(
"admin group form",
"Enabling this option will prevent this group from appearing on members' cards, profiles, and postbits.",
),
)
copy_permissions = forms.ModelChoiceField(
label=pgettext_lazy("admin group form", "Copy permissions from"),
help_text=pgettext_lazy(
"admin group form",
"You can replace this group's permissions with those copied from another group. Administrator and moderator permissions are not copied.",
),
queryset=Group.objects,
required=False,
empty_label=pgettext_lazy("admin group form", "(Don't copy permissions)"),
)
# Permissions
can_use_private_threads = YesNoSwitch(
label=pgettext_lazy("admin group permissions form", "Can use private threads"),
)
can_change_username = YesNoSwitch(
label=pgettext_lazy("admin group permissions form", "Can change username"),
)
username_changes_limit = forms.IntegerField(
label=pgettext_lazy("admin group permissions form", "Limit username changes"),
help_text=pgettext_lazy(
"admin group permissions form",
"Enter zero to don't limit username changes.",
),
min_value=0,
)
username_changes_expire = forms.IntegerField(
label=pgettext_lazy(
"admin group permissions form", "Expire old username changes after"
),
help_text=pgettext_lazy(
"admin group permissions form",
"Enter the number of hours since the change after which it no longer counts towards the limit, or enter zero for old username changes to always count.",
),
min_value=0,
)
username_changes_span = forms.IntegerField(
label=pgettext_lazy(
"admin group permissions form", "Minimum time between changes"
),
help_text=pgettext_lazy(
"admin group permissions form",
"Enter the minimum time between changes in hours, or enter zero to not limit the time between changes.",
),
min_value=0,
)
can_see_user_profiles = YesNoSwitch(
label=pgettext_lazy(
"admin group permissions form", "Can see other users profiles"
),
)
class Meta:
model = Group
fields = [
"name",
"slug",
"user_title",
"color",
"icon",
"css_suffix",
"is_page",
"is_hidden",
"can_use_private_threads",
"can_change_username",
"username_changes_limit",
"username_changes_expire",
"username_changes_span",
"can_see_user_profiles",
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["copy_permissions"].queryset = Group.objects.exclude(
id=kwargs["instance"].id
)
class EditGroupDescriptionForm(forms.ModelForm):
markdown = forms.CharField(
label=pgettext_lazy("admin group form", "Description"),
help_text=pgettext_lazy(
"admin group form",
"Optional. Group's description in Markdown that will be parsed into HTML displayed on the group's page.",
),
required=False,
widget=forms.Textarea(attrs={"rows": 4}),
)
meta = forms.CharField(
label=pgettext_lazy("admin group form", "Meta description"),
help_text=pgettext_lazy(
"admin group form",
"Optional. Will be used verbatim for the group page's meta description. Leave empty to generate one from the group's description.",
),
required=False,
widget=forms.Textarea(attrs={"rows": 2}),
)
class Meta:
model = GroupDescription
fields = [
"markdown",
"meta",
]
def __init__(self, *args, request, **kwargs):
self.request = request
self.context = None
self.ast = None
self.metadata = None
super().__init__(*args, **kwargs)
def clean(self):
data = super().clean()
if data.get("markdown"):
context = create_parser_context(
self.request,
content_type=ContentType.GROUP_DESCRIPTION,
)
parse = create_parser(context)
ast = parse(data["markdown"])
metadata = create_ast_metadata(context, ast)
data["html"] = render_ast_to_html(context, ast, metadata)
if not data.get("meta"):
data["meta"] = render_ast_to_plaintext(
context, ast, metadata, PlainTextFormat.META_DESCRIPTION
)
self.context = context
self.ast = ast
self.metadata = metadata
else:
data.update({"markdown": None, "html": None})
if not data.get("meta"):
data["meta"] = None
return data
| 8,625
|
Python
|
.py
| 221
| 29.954751
| 164
| 0.615688
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,293
|
views.py
|
rafalp_Misago/misago/admin/groups/views.py
|
from django.contrib import messages
from django.shortcuts import redirect
from django.urls import reverse
from django.utils.translation import pgettext, pgettext_lazy
from ...cache.enums import CacheName
from ...cache.versions import invalidate_cache
from ...categories.enums import CategoryTree
from ...categories.models import Category
from ...forms.formset import Formset
from ...permissions.admin import get_admin_category_permissions
from ...permissions.copy import copy_group_permissions
from ...permissions.models import CategoryGroupPermission, Moderator
from ...users.enums import DefaultGroupId
from ...users.groups import (
count_groups_members,
create_group,
delete_group,
set_default_group,
update_group,
update_group_description,
)
from ...users.models import Group
from ..views import generic
from .forms import EditGroupDescriptionForm, EditGroupForm, NewGroupForm
INVALID_DEFAULT_GROUP_IDS = (
DefaultGroupId.ADMINS,
DefaultGroupId.MODERATORS,
DefaultGroupId.GUESTS,
)
class GroupAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:groups:index"
templates_dir = "misago/admin/groups"
model = Group
message_404 = pgettext_lazy("admin groups", "Requested group does not exist.")
class ListView(GroupAdmin, generic.ListView):
def process_context(self, request, context):
items = list(context["items"])
items_dict = {item.id: item for item in items}
for group_id, members_count in count_groups_members():
items_dict[group_id].members_count = members_count
context["items"] = items
context["invalid_default_group_ids"] = INVALID_DEFAULT_GROUP_IDS
return context
class OrderingView(GroupAdmin, generic.OrderingView):
def order_items(self, request, items: list[Group]):
items_update = []
for ordering, item in enumerate(items):
item.ordering = ordering
items_update.append(item)
Group.objects.bulk_update(items_update, ["ordering"])
invalidate_cache(CacheName.GROUPS)
class MembersView(GroupAdmin, generic.TargetedView):
def real_dispatch(self, request, target):
redirect_url = reverse("misago:admin:users:index")
return redirect(f"{redirect_url}?group={target.pk}")
class MembersMainView(GroupAdmin, generic.TargetedView):
def real_dispatch(self, request, target):
redirect_url = reverse("misago:admin:users:index")
return redirect(f"{redirect_url}?main_group={target.pk}")
class NewView(GroupAdmin, generic.ModelFormView):
template_name = "new.html"
form_class = NewGroupForm
message_submit = pgettext_lazy("admin groups", '"%(name)s" group has been created.')
def handle_form(self, form, request, target):
group = create_group(
name=form.cleaned_data["name"],
request=request,
form=form,
)
if form.cleaned_data["copy_permissions"]:
copy_group_permissions(
form.cleaned_data["copy_permissions"], group, request
)
invalidate_cache(CacheName.GROUPS, CacheName.PERMISSIONS)
messages.success(request, self.message_submit % {"name": group.name})
return redirect("misago:admin:groups:edit", pk=group.pk)
class EditView(GroupAdmin, generic.ModelFormView):
template_name = "edit.html"
message_submit = pgettext_lazy("admin groups", '"%(name)s" group has been updated.')
def get_form(self, form_class, request, target):
formset = Formset()
if request.method == "POST":
group_form = EditGroupForm(
request.POST,
request.FILES,
instance=target,
prefix="group",
)
description_form = EditGroupDescriptionForm(
request.POST,
request.FILES,
instance=target.description,
prefix="description",
request=request,
)
else:
group_form = EditGroupForm(instance=target, prefix="group")
description_form = EditGroupDescriptionForm(
instance=target.description,
prefix="description",
request=request,
)
formset.add_form(group_form)
formset.add_form(description_form)
return formset
def handle_form(self, formset, request, target):
group_form = formset["group"]
description_form = formset["description"]
copy_permissions = group_form.cleaned_data.pop("copy_permissions", None)
target = update_group(
target,
request=request,
form=group_form,
**group_form.cleaned_data,
)
if copy_permissions:
copy_group_permissions(copy_permissions, target, request)
update_group_description(
target,
request=request,
form=description_form,
**description_form.cleaned_data,
)
invalidate_cache(CacheName.GROUPS, CacheName.PERMISSIONS)
messages.success(request, self.message_submit % {"name": target.name})
class CategoryPermissionsView(GroupAdmin, generic.PermissionsFormView):
template_name = "categories.html"
message_empty = pgettext_lazy(
"admin groups", "No categories exist to set group permissions for."
)
message_submit = pgettext_lazy(
"admin groups", '"%(name)s" category permissions have been updated.'
)
def get_permissions(self, request, target):
return get_admin_category_permissions(self)
def get_items(self, request, target):
queryset = Category.objects.filter(
tree_id=CategoryTree.THREADS, level__gt=0
).values("id", "name", "level")
for category in queryset:
yield self.create_item(
id=category["id"],
name=category["name"],
level=category["level"] - 1,
)
def get_initial_data(self, request, target):
return CategoryGroupPermission.objects.filter(group=target).values_list(
"category_id", "permission"
)
def handle_form(self, data, request, target):
CategoryGroupPermission.objects.filter(group=target).delete()
new_permissions = []
for category_id, permissions in data.items():
for permission in permissions:
new_permissions.append(
CategoryGroupPermission(
group=target,
category_id=category_id,
permission=permission,
)
)
if new_permissions:
CategoryGroupPermission.objects.bulk_create(new_permissions)
invalidate_cache(CacheName.PERMISSIONS)
messages.success(request, self.message_submit % {"name": target.name})
class DeleteView(GroupAdmin, generic.ButtonView):
def check_permissions(self, request, target):
message_format = {"name": target.name}
if target.is_protected:
return (
pgettext(
"admin groups",
'Can\'t delete a protected group "%(name)s".',
)
% message_format
)
if target.is_default:
return (
pgettext(
"admin groups",
'Can\'t delete the default group "%(name)s".',
)
% message_format
)
if target.user_set.exists():
return (
pgettext(
"admin groups",
"Can't delete \"%(name)s\" group because it's a main group for some users.",
)
% message_format
)
def button_action(self, request, target):
delete_group(target, request)
invalidate_cache(CacheName.GROUPS, CacheName.PERMISSIONS)
message = pgettext("admin groups", '"%(name)s" group has been deleted.')
messages.success(request, message % {"name": target.name})
class MakeDefaultView(GroupAdmin, generic.ButtonView):
def check_permissions(self, request, target):
message_format = {"name": target.name}
if target.is_default:
return (
pgettext("admin groups", '"%(name)s" group is already the default.')
% message_format
)
if target.id in INVALID_DEFAULT_GROUP_IDS:
return (
pgettext("admin groups", '"%(name)s" group can\'t be set as default.')
% message_format
)
if Moderator.objects.filter(group=target).exists():
return (
pgettext(
"admin groups",
'Can\'t set "%(name)s" group as default because it has moderator permissions.',
)
% message_format
)
def button_action(self, request, target):
set_default_group(target, request)
invalidate_cache(CacheName.GROUPS)
message = pgettext("admin groups", '"%(name)s" group has been made a default.')
messages.success(request, message % {"name": target.name})
| 9,318
|
Python
|
.py
| 223
| 31.55157
| 99
| 0.619965
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,294
|
models.py
|
rafalp_Misago/misago/cache/models.py
|
from django.db import models
from .utils import generate_version_string
class CacheVersion(models.Model):
cache = models.CharField(max_length=128, primary_key=True)
version = models.CharField(max_length=8, default=generate_version_string)
| 250
|
Python
|
.py
| 5
| 46.8
| 77
| 0.801653
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,295
|
enums.py
|
rafalp_Misago/misago/cache/enums.py
|
from enum import StrEnum
class CacheName(StrEnum):
BANS = "bans"
CATEGORIES = "categories"
GROUPS = "groups"
MODERATORS = "moderators"
PERMISSIONS = "permissions"
SETTINGS = "settings"
| 211
|
Python
|
.py
| 8
| 22.125
| 31
| 0.696517
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,296
|
test.py
|
rafalp_Misago/misago/cache/test.py
|
from enum import StrEnum
from .versions import get_cache_versions
class assert_invalidates_cache:
def __init__(self, cache: str | StrEnum):
self.cache = cache
def __enter__(self):
self.versions = get_cache_versions()
return self
def __exit__(self, exc_type, *_):
if exc_type:
return False
new_versions = get_cache_versions()
for cache, version in new_versions.items():
if cache == self.cache:
message = "cache %s was not invalidated" % cache
assert self.versions[cache] != version, message
| 612
|
Python
|
.py
| 16
| 29.625
| 64
| 0.60678
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,297
|
versions.py
|
rafalp_Misago/misago/cache/versions.py
|
from .models import CacheVersion
from .utils import generate_version_string
def get_cache_versions() -> dict[str, str]:
queryset = CacheVersion.objects.all()
return {i.cache: i.version for i in queryset}
def invalidate_cache(*cache_name: str) -> None:
CacheVersion.objects.filter(cache__in=cache_name).update(
version=generate_version_string()
)
def invalidate_all_caches() -> None:
for cache_name in get_cache_versions().keys():
CacheVersion.objects.filter(cache=cache_name).update(
version=generate_version_string()
)
| 582
|
Python
|
.py
| 14
| 36.142857
| 61
| 0.709964
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,298
|
apps.py
|
rafalp_Misago/misago/cache/apps.py
|
from django.apps import AppConfig
class MisagoCacheConfig(AppConfig):
name = "misago.cache"
label = "misago_cache"
verbose_name = "Misago Cache"
| 159
|
Python
|
.py
| 5
| 28
| 35
| 0.743421
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,299
|
middleware.py
|
rafalp_Misago/misago/cache/middleware.py
|
from .versions import get_cache_versions
def cache_versions_middleware(get_response):
"""Sets request.cache_versions attribute with dict of cache versions."""
def middleware(request):
request.cache_versions = get_cache_versions()
return get_response(request)
return middleware
| 309
|
Python
|
.py
| 7
| 38.571429
| 76
| 0.748322
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|