mirror of
https://github.com/ae-utbm/sith.git
synced 2025-04-04 19:00:27 +00:00
225 lines
8.2 KiB
Python
225 lines
8.2 KiB
Python
import copy
|
|
import inspect
|
|
from typing import Any, LiteralString, Protocol, Unpack
|
|
|
|
from django.conf import settings
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
from django.http import HttpRequest, HttpResponse
|
|
from django.template.loader import render_to_string
|
|
from django.utils.safestring import SafeString
|
|
from django.views import View
|
|
from django.views.generic.base import ContextMixin, TemplateResponseMixin
|
|
|
|
|
|
class TabedViewMixin(View):
|
|
"""Basic functions for displaying tabs in the template."""
|
|
|
|
def get_tabs_title(self):
|
|
if hasattr(self, "tabs_title"):
|
|
return self.tabs_title
|
|
raise ImproperlyConfigured("tabs_title is required")
|
|
|
|
def get_current_tab(self):
|
|
if hasattr(self, "current_tab"):
|
|
return self.current_tab
|
|
raise ImproperlyConfigured("current_tab is required")
|
|
|
|
def get_list_of_tabs(self):
|
|
if hasattr(self, "list_of_tabs"):
|
|
return self.list_of_tabs
|
|
raise ImproperlyConfigured("list_of_tabs is required")
|
|
|
|
def get_context_data(self, **kwargs):
|
|
kwargs = super().get_context_data(**kwargs)
|
|
kwargs["tabs_title"] = self.get_tabs_title()
|
|
kwargs["current_tab"] = self.get_current_tab()
|
|
kwargs["list_of_tabs"] = self.get_list_of_tabs()
|
|
return kwargs
|
|
|
|
|
|
class QuickNotifMixin:
|
|
quick_notif_list = []
|
|
|
|
def dispatch(self, request, *arg, **kwargs):
|
|
# In some cases, the class can stay instanciated, so we need to reset the list
|
|
self.quick_notif_list = []
|
|
return super().dispatch(request, *arg, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
ret = super().get_success_url()
|
|
if hasattr(self, "quick_notif_url_arg"):
|
|
if "?" in ret:
|
|
ret += "&" + self.quick_notif_url_arg
|
|
else:
|
|
ret += "?" + self.quick_notif_url_arg
|
|
return ret
|
|
|
|
def get_context_data(self, **kwargs):
|
|
"""Add quick notifications to context."""
|
|
kwargs = super().get_context_data(**kwargs)
|
|
kwargs["quick_notifs"] = []
|
|
for n in self.quick_notif_list:
|
|
kwargs["quick_notifs"].append(settings.SITH_QUICK_NOTIF[n])
|
|
for key, val in settings.SITH_QUICK_NOTIF.items():
|
|
for gk in self.request.GET:
|
|
if key == gk:
|
|
kwargs["quick_notifs"].append(val)
|
|
return kwargs
|
|
|
|
|
|
class AllowFragment:
|
|
"""Add `is_fragment` to templates. It's only True if the request is emitted by htmx"""
|
|
|
|
def get_context_data(self, **kwargs):
|
|
kwargs["is_fragment"] = self.request.headers.get("HX-Request", False)
|
|
return super().get_context_data(**kwargs)
|
|
|
|
|
|
class FragmentRenderer(Protocol):
|
|
def __call__(
|
|
self, request: HttpRequest, **kwargs: Unpack[dict[str, Any]]
|
|
) -> SafeString: ...
|
|
|
|
|
|
class FragmentMixin(TemplateResponseMixin, ContextMixin):
|
|
"""Make a view buildable as a fragment that can be embedded in a template.
|
|
|
|
Most fragments are used in two different ways :
|
|
- in the request/response cycle, like any regular view
|
|
- in templates, where the rendering is done in another view
|
|
|
|
This mixin aims to simplify the initial fragment rendering.
|
|
The rendered fragment will then be able to re-render itself
|
|
through the request/response cycle if it uses HTMX.
|
|
|
|
!!!Example
|
|
```python
|
|
class MyFragment(FragmentMixin, FormView):
|
|
template_name = "app/fragment.jinja"
|
|
form_class = MyForm
|
|
success_url = reverse_lazy("foo:bar")
|
|
|
|
# in another view :
|
|
def some_view(request):
|
|
fragment = MyFragment.as_fragment()
|
|
return render(
|
|
request,
|
|
"app/template.jinja",
|
|
context={"fragment": fragment(request)
|
|
}
|
|
|
|
# in urls.py
|
|
urlpatterns = [
|
|
path("foo/view", some_view),
|
|
path("foo/fragment", MyFragment.as_view()),
|
|
]
|
|
```
|
|
"""
|
|
|
|
reload_on_redirect: bool = False
|
|
"""If True, this fragment will trigger a full page reload on redirect."""
|
|
|
|
@classmethod
|
|
def as_fragment(cls, **initkwargs) -> FragmentRenderer:
|
|
# the following code is heavily inspired from the base View.as_view method
|
|
for key in initkwargs:
|
|
if not hasattr(cls, key):
|
|
raise TypeError(
|
|
"%s() received an invalid keyword %r. as_view "
|
|
"only accepts arguments that are already "
|
|
"attributes of the class." % (cls.__name__, key)
|
|
)
|
|
|
|
def fragment(request: HttpRequest, **kwargs) -> SafeString:
|
|
self = cls(**initkwargs)
|
|
# any POST action on the fragment will be dealt by the fragment itself.
|
|
# So, if the view that is rendering this fragment is in a POST context,
|
|
# let's pretend anyway it's a GET, in order to be sure the fragment
|
|
# won't try to do any POST action (like form validation) on initial render.
|
|
self.request = copy.copy(request)
|
|
self.request.method = "GET"
|
|
self.kwargs = kwargs
|
|
return self.render_fragment(request, **kwargs)
|
|
|
|
fragment.__doc__ = cls.__doc__
|
|
fragment.__module__ = cls.__module__
|
|
return fragment
|
|
|
|
def render_fragment(self, request, **kwargs) -> SafeString:
|
|
return render_to_string(
|
|
self.get_template_names(),
|
|
context=self.get_context_data(**kwargs),
|
|
request=request,
|
|
)
|
|
|
|
def dispatch(self, *args, **kwargs):
|
|
res: HttpResponse = super().dispatch(*args, **kwargs)
|
|
if 300 <= res.status_code < 400 and self.reload_on_redirect:
|
|
# HTMX doesn't care about redirection codes (because why not),
|
|
# so we must transform the redirection code into a 200.
|
|
res.status_code = 200
|
|
res.headers["HX-Redirect"] = res["Location"]
|
|
return res
|
|
|
|
|
|
class UseFragmentsMixin(ContextMixin):
|
|
"""Mark a view as using fragments.
|
|
|
|
This mixin is not mandatory
|
|
(you may as well render manually your fragments in the `get_context_data` method).
|
|
However, the interface of this class bring some distinction
|
|
between fragments and other context data, which may
|
|
reduce boilerplate.
|
|
|
|
!!!Example
|
|
```python
|
|
class FooFragment(FragmentMixin, FormView): ...
|
|
|
|
class BarFragment(FragmentMixin, FormView): ...
|
|
|
|
class AdminFragment(FragmentMixin, FormView): ...
|
|
|
|
class MyView(UseFragmentsMixin, TemplateView)
|
|
template_name = "app/view.jinja"
|
|
fragments = {
|
|
"foo": FooFragment
|
|
"bar": BarFragment(template_name="some_template.jinja")
|
|
}
|
|
fragments_data = {
|
|
"foo": {"some": "data"} # this will be passed to the FooFragment renderer
|
|
}
|
|
|
|
def get_fragments(self):
|
|
res = super().get_fragments()
|
|
if self.request.user.is_superuser:
|
|
res["admin_fragment"] = AdminFragment
|
|
return res
|
|
```
|
|
"""
|
|
|
|
fragments: dict[LiteralString, type[FragmentMixin] | FragmentRenderer] | None = None
|
|
fragment_data: dict[LiteralString, dict[LiteralString, Any]] | None = None
|
|
|
|
def get_fragments(self) -> dict[str, type[FragmentMixin] | FragmentRenderer]:
|
|
return self.fragments if self.fragments is not None else {}
|
|
|
|
def get_fragment_data(self) -> dict[str, dict[str, Any]]:
|
|
"""Return eventual data used to initialize the fragments."""
|
|
return self.fragment_data if self.fragment_data is not None else {}
|
|
|
|
def get_fragment_context_data(self) -> dict[str, SafeString]:
|
|
"""Return the rendered fragments as context data."""
|
|
res = {}
|
|
data = self.get_fragment_data()
|
|
for name, fragment in self.get_fragments().items():
|
|
is_cls = inspect.isclass(fragment) and issubclass(fragment, FragmentMixin)
|
|
_fragment = fragment.as_fragment() if is_cls else fragment
|
|
fragment_data = data.get(name, {})
|
|
res[name] = _fragment(self.request, **fragment_data)
|
|
return res
|
|
|
|
def get_context_data(self, **kwargs):
|
|
kwargs = super().get_context_data(**kwargs)
|
|
kwargs.update(self.get_fragment_context_data())
|
|
return kwargs
|