django-handyhelpers 0.3.20__py3-none-any.whl → 0.3.35__py3-none-any.whl

handyhelpers/views/htmx.py

@@ -1,10 +1,11 @@
 from django.conf import settings
 from django.http import HttpResponse
 from django.template import loader
-from django.shortcuts import render
+from django.shortcuts import render, reverse
 from django.utils import timezone
-from django.views.generic import View
-from handyhelpers.mixins.view_mixins import HtmxViewMixin
+from django.views.generic import DetailView, View
+from handyhelpers.mixins.view_mixins import FilterByQueryParamsMixin, HtmxViewMixin
+from handyhelpers.views.gui import HandyHelperIndexView
 
 
 class BuildBootstrapModalView(HtmxViewMixin, View):
@@ -103,7 +104,6 @@ class HtmxSidebarItems(HtmxViewMixin, View):
         return render(request, self.template_name, self.context)
 
 
-
 class BuildModelSidebarNav(HtmxViewMixin, View):
     """Dynamically build a sidebar navigation menu where items included are sourced from application models.
     This is intended handyhelpers_with_sidebar.htm or similar template.
@@ -149,3 +149,395 @@ class BuildModelSidebarNav(HtmxViewMixin, View):
             menu_item_list=self.menu_item_list,
         )
         return render(request, self.template_name, context)
+
+
+class ModelDetailBootstrapModalView(BuildBootstrapModalView):
+    modal_button_submit = None
+    modal_template = None
+    model = None
+
+    def get(self, request, *args, **kwargs):
+        context = {}
+        context["object"] = self.model.objects.get(pk=kwargs["pk"])
+        if self.modal_title == None:
+            self.modal_title = f"{self.model._meta.object_name} Details"
+        if self.modal_subtitle == None:
+            self.modal_subtitle = context["object"]
+        self.modal_body = loader.render_to_string(self.modal_template, context=context)
+        return super().get(request, *args, **kwargs)
+
+
+class HtmxPostForm(HtmxViewMixin, View):
+
+    form = None
+    template_name = "handyhelpers/htmx/bs5/form/form_wrapper.htm"
+
+    def post(self, request, *args, **kwargs):
+
+        if not self.is_htmx():
+            return HttpResponse("Invalid request", status=400)
+        context = {}
+        form = self.form(request.POST)
+        if form.is_valid():
+            form.save()
+            context["success"] = True
+            context["form"] = self.form()
+        else:
+            context["form"] = form
+        return render(request, self.template_name, context)
+
+
+class CreateModelModalView(BuildBootstrapModalView):
+    """ """
+
+    modal_button_submit = "Create"
+    modal_title = None
+    form = None
+    form_display = "bs5"
+
+    def get(self, request, *args, **kwargs):
+        if not self.is_htmx():
+            return HttpResponse("Invalid request", status=400)
+        if not self.form:
+            return HttpResponse("Invalid request", status=400)
+
+        form_errors = request.session.get(f"{self.form.__name__}__errors")
+        if self.form and form_errors:
+            data = request.session.get(f"{self.form.__name__}__data")
+            form = self.form()
+            form.data = data
+            for field, error_message in form_errors.items():
+                try:
+                    form.add_error(field, error_message)
+                except:
+                    pass
+        else:
+            form = self.form()
+
+        context = {
+            "modal_title": (
+                self.modal_title
+                if self.modal_title
+                else f"Create {self.form.Meta.model._meta.object_name}"
+            ),
+            "modal_subtitle": self.modal_subtitle,
+            "modal_body": self.modal_body,
+            "modal_size": self.modal_size,
+            "modal_button_close": self.modal_button_close,
+            "modal_button_submit": self.modal_button_submit,
+            "data": self.data,
+            "extra_data": self.extra_data,
+            "form": form,
+            "form_display": self.form_display,
+        }
+        return render(request, self.template_name, context)
+
+    def post(self, request, *args, **kwargs):
+        form = self.form(request.POST)
+        if form.is_valid():
+            obj = form.save()
+            response = HttpResponse(status=204)
+            response["X-Toast-Message"] = (
+                f"""{obj._meta.object_name} '{obj}' created!"""
+            )
+            del request.session[f"{self.form.__name__}__errors"]
+            del request.session[f"{self.form.__name__}__data"]
+            return response
+        else:
+            form_error_dict = {}
+            for k, v in form.errors.as_data().items():
+                form_error_dict[k] = str(v[0].messages[0])
+            request.session[f"{self.form.__name__}__errors"] = form_error_dict
+            request.session[f"{self.form.__name__}__data"] = form.data
+            response = HttpResponse(status=400)
+            response["X-Toast-Message"] = (
+                f"""<span class="text-danger">Failed to create new {self.form.Meta.model._meta.object_name}</span>"""
+            )
+            return response
+
+
+class HtmxOptionView(HtmxViewMixin, View):
+    template_name = None
+    htmx_template_name = None
+    context = {}
+
+    def get(self, request):
+        if self.is_htmx() and self.template_name:
+            template_name = self.htmx_template_name
+        else:
+            template_name = self.template_name
+        return render(request, template_name, self.context)
+
+
+class HtmxOptionDetailView(HtmxViewMixin, DetailView):
+    template_name = None
+    htmx_template_name = None
+    initialize_tables = None
+
+    def render_to_response(self, context, **response_kwargs):
+        response = super().render_to_response(context, **response_kwargs)
+        if self.initialize_tables:
+            response["X-Initialize-Tables"] = "initialize-tables"
+        return response
+
+    def get(self, request, *args, **kwargs):
+        if self.is_htmx() and self.htmx_template_name:
+            self.template_name = self.htmx_template_name
+        return super().get(request, *args, **kwargs)
+
+
+class HtmxOptionMultiView(HtmxViewMixin, View):
+    title = None
+    subtitle = None
+    model = None
+    template_name = None
+    htmx_template_name = None
+    htmx_card_template_name = None
+    htmx_custom_template_name = None
+    htmx_index_template_name = None
+    htmx_list_template_name = None
+    htmx_minimal_template_name = None
+    htmx_table_template_name = None
+    htmx_table_wrapper_template_name = "handyhelpers/htmx/bs5/table_wrapper.htm"
+    context = {}
+    queryset = None
+
+    def get(self, request, **kwargs):
+        template_name = None
+        if self.queryset is not None:
+            self.queryset._result_cache = None
+        if self.is_htmx():
+            display = kwargs.get("display", None)
+            if display:
+                if display == "card" and self.htmx_card_template_name:
+                    template_name = self.htmx_card_template_name
+                elif display == "custom" and self.htmx_custom_template_name:
+                    template_name = self.htmx_custom_template_name
+                elif display == "index" and self.htmx_index_template_name:
+                    template_name = self.htmx_index_template_name
+                elif display == "list" and self.htmx_list_template_name:
+                    template_name = self.htmx_list_template_name
+                elif display == "minimal" and self.htmx_minimal_template_name:
+                    template_name = self.htmx_minimal_template_name
+                elif display == "table" and self.htmx_table_wrapper_template_name:
+                    template_name = self.htmx_table_wrapper_template_name
+                    self.context["table"] = self.htmx_table_template_name
+                elif self.htmx_template_name:
+                    template_name = self.htmx_template_name
+            else:
+                return HttpResponse("", content_type="text/plain")
+        else:
+            template_name = self.template_name
+        if self.queryset:
+            self.context["queryset"] = self.queryset
+        elif self.model:
+            self.context["queryset"] = self.model.objects.all()
+
+        if self.title:
+            self.context["title"] = self.title
+        elif self.model:
+            self.context["title"] = self.model._meta.verbose_name_plural.title()
+
+        self.context["subtitle"] = self.subtitle
+        return render(request, template_name, self.context)
+
+
+class HtmxOptionMultiFilterView(FilterByQueryParamsMixin, HtmxViewMixin, View):
+    context = {}
+    default_display = "table"
+    filter_form = None
+    htmx_card_template_name = None
+    htmx_card_wrapper_template_name = (
+        "handyhelpers/htmx/bs5/htmx_option_multi_filter_view/wrapper_card.htm"
+    )
+    htmx_list_template_name = None
+    htmx_list_wrapper_template_name = (
+        "handyhelpers/htmx/bs5/htmx_option_multi_filter_view/wrapper_list.htm"
+    )
+    htmx_minimal_template_name = None
+    htmx_minimal_wrapper_template_name = (
+        "handyhelpers/htmx/bs5/htmx_option_multi_filter_view/wrapper_minimal.htm"
+    )
+    htmx_table_template_name = None
+    htmx_table_wrapper_template_name = (
+        "handyhelpers/htmx/bs5/htmx_option_multi_filter_view/wrapper_table.htm"
+    )
+    htmx_template_name = None
+    model = None
+    queryset = None
+    subtitle = None
+    template_name = "handyhelpers/htmx/bs5/htmx_option_multi_filter_view/full.html"
+    title = None
+
+    def get(self, request, post_data={}, *args, **kwargs):
+        page_description = request.GET.get("page_description", None)
+        control_list = []
+        display = kwargs.get("display", None)
+        if not display:
+            display = self.default_display
+        root_url = reverse(
+            f"{request.resolver_match.app_name}:{request.resolver_match.url_name}"
+        ).replace("//", "/")
+        query_params = request.GET
+        template_name = None
+
+        if post_data:
+            query_string = ""
+            url = f"""{root_url}?"""
+            for key, value in post_data.items():
+                if value:
+                    url += f"{key}={value}&"
+                    query_string += f"{key}={value}&"
+        elif query_params:
+            query_string = query_params.urlencode()
+            url = f"{root_url}{display}?{query_string}"
+        else:
+            query_string = ""
+            url = f"{root_url}{display}"
+
+        if self.queryset is not None:
+            self.queryset._result_cache = None
+        if self.is_htmx():
+            if display == "card" and self.htmx_card_wrapper_template_name:
+                template_name = self.htmx_card_wrapper_template_name
+                self.context["item_content"] = self.htmx_card_template_name
+            elif display == "list" and self.htmx_list_wrapper_template_name:
+                template_name = self.htmx_list_wrapper_template_name
+                self.context["item_content"] = self.htmx_list_template_name
+            elif display == "minimal" and self.htmx_minimal_template_name:
+                template_name = self.htmx_minimal_wrapper_template_name
+                self.context["item_content"] = self.htmx_minimal_template_name
+            elif display == "table" and self.htmx_table_wrapper_template_name:
+                template_name = self.htmx_table_wrapper_template_name
+                self.context["item_content"] = self.htmx_table_template_name
+            elif self.htmx_template_name:
+                template_name = self.htmx_template_name
+        else:
+            template_name = self.template_name
+
+        # add display controls
+        if self.htmx_card_template_name:
+            control_list.append(
+                {
+                    "name": "card",
+                    "icon": """<i class="fa-regular fa-square"></i>""",
+                    "url": (
+                        f"{root_url}card/?{query_string}"
+                        if query_string
+                        else f"{root_url}card/"
+                    ),
+                }
+            )
+        if self.htmx_list_template_name:
+            control_list.append(
+                {
+                    "name": "list",
+                    "icon": """<i class="fa-solid fa-list-ul"></i>""",
+                    "url": (
+                        f"{root_url}list/?{query_string}"
+                        if query_string
+                        else f"{root_url}list/"
+                    ),
+                }
+            )
+        if self.htmx_minimal_template_name:
+            control_list.append(
+                {
+                    "name": "minimal",
+                    "icon": """<i class="fa-solid fa-compress"></i>""",
+                    "url": (
+                        f"{root_url}minimal/?{query_string}"
+                        if query_string
+                        else f"{root_url}minimal/"
+                    ),
+                }
+            )
+        if self.htmx_table_template_name:
+            control_list.append(
+                {
+                    "name": "table",
+                    "icon": """<i class="fa-solid fa-table"></i>""",
+                    "url": (
+                        f"{root_url}table/?{query_string}"
+                        if query_string
+                        else f"{root_url}table/"
+                    ),
+                }
+            )
+
+        if self.queryset == None and self.model:
+            self.queryset = self.model.objects.all()
+        if post_data:
+            self.queryset = self.queryset.filter(**post_data)
+        elif query_params:
+            self.queryset = self.filter_by_query_params()
+        self.context["queryset"] = self.queryset
+        self.context["title"] = self.title
+        self.context["control_list"] = control_list
+        self.context["display"] = display
+        self.context["filter_form"] = self.filter_form
+        self.context["htmx_template_name"] = template_name
+        self.context["page_description"] = page_description
+        self.context["query_string"] = query_string
+        self.context["root_url"] = root_url
+        self.context["subtitle"] = self.subtitle
+        self.context["url"] = url
+
+        response = render(request, template_name, self.context)
+        if self.is_htmx():
+            response["X-Initialize-Tables"] = "initialize-tables"
+        return response
+
+    def post(self, request, *args, **kwargs):
+        """build filter string from form fields and call get method to update queryset"""
+        form = self.filter_form(request.POST)
+        if form.is_valid():
+            post_data = {
+                key: value for key, value in request.POST.dict().items() if value
+            }
+        return self.get(request, post_data, *args, **kwargs)
+
+
+class HtmxItemizedView(HtmxViewMixin, HandyHelperIndexView):
+    template_name = "handyhelpers/generic/bs5/generic_index.html"
+    htmx_template_name = "handyhelpers/htmx/bs5/index.htm"
+
+    def get(self, request, *args, **kwargs):
+        if self.is_htmx() and self.htmx_template_name:
+            self.template_name = self.htmx_template_name
+        return super().get(request, *args, **kwargs)
+
+
+class HtmxFilterModalView(BuildBootstrapModalView):
+    """Render a modal containing a filter form"""
+
+    form = None
+    form_display = "bs5"
+    modal_button_submit = "Filter"
+    modal_title = "Filter"
+    template_name = (
+        "handyhelpers/htmx/bs5/htmx_option_multi_filter_view/filter_form_modal_swap.htm"
+    )
+
+    def get(self, request, *args, **kwargs):
+        if not self.is_htmx():
+            return HttpResponse("Invalid request", status=400)
+        if not self.form:
+            return HttpResponse("Invalid request", status=400)
+
+        list_display = request.GET.get("display", None)
+
+        context = {
+            "data": self.data,
+            "display": list_display,
+            "extra_data": self.extra_data,
+            "form": self.form,
+            "form_display": self.form_display,
+            "modal_body": self.modal_body,
+            "modal_button_close": self.modal_button_close,
+            "modal_button_submit": self.modal_button_submit,
+            "modal_size": self.modal_size,
+            "modal_subtitle": self.modal_subtitle,
+            "modal_title": self.modal_title,
+        }
+        return render(request, self.template_name, context)

handyhelpers/views/report.py

@@ -5,6 +5,7 @@ from django.conf import settings
 import datetime
 import calendar
 from dateutil.rrule import rrule, MONTHLY
+from handyhelpers.mixins.view_mixins import HtmxViewMixin
 
 
 def get_color_list():
@@ -44,7 +45,7 @@ def get_annual_timestamps(start=None, end=None, reverse=False):
     if not end:
         end = timezone.now()
     if not start:
-        start = end - datetime.timedelta(365)
+        start = end - datetime.timedelta(366)
     if reverse:
         data = [d.replace(day=1) for d in rrule(MONTHLY, dtstart=start, until=end)]
     else:
@@ -234,7 +235,7 @@ def build_day_week_month_year_charts(dataset_list):
     return return_dataset_list
 
 
-class AnnualStatView(View):
+class AnnualStatView(HtmxViewMixin, View):
     """
     Description:
         Tallies the number of entries added over the past year. Included are counts of entries sectioned by
@@ -258,10 +259,12 @@ class AnnualStatView(View):
     base_template = getattr(settings, 'BASE_TEMPLATE', 'handyhelpers/handyhelpers_base.htm')
     title = 'Annual Statistics Report'
     sub_title = None
-    template_name = 'handyhelpers/report/chartjs/annual_stats.html'
+    template_name = 'handyhelpers/report/annual_stats.html'
     dataset_list = list()
 
     def get(self, request):
+        if self.is_htmx():
+            self.template_name = 'handyhelpers/report/annual_stats_content.htm'
         context = dict()
         context['base_template'] = self.base_template
         context['title'] = self.title
@@ -293,7 +296,7 @@ class AnnualStatView(View):
         return render(request, self.template_name, context)
 
 
-class AnnualTrendView(View):
+class AnnualTrendView(HtmxViewMixin, View):
     """
     Description:
         Tallies the number of elements processed over the past year. Included are counts of elements processed in the
@@ -320,6 +323,8 @@ class AnnualTrendView(View):
     dataset_list = list()
 
     def get(self, request):
+        if self.is_htmx():
+            self.template_name = 'handyhelpers/report/chartjs/annual_trends_content.htm'
         context = dict()
         context['base_template'] = self.base_template
         context['title'] = self.title
@@ -334,7 +339,7 @@ class AnnualTrendView(View):
         return render(request, self.template_name, context)
 
 
-class AnnualProgressView(View):
+class AnnualProgressView(HtmxViewMixin, View):
     """
     Description:
         Show the current number of elements per dataset and chart showing counts of data added per month over the
@@ -359,6 +364,8 @@ class AnnualProgressView(View):
     dataset_list = list()
 
     def get(self, request):
+        if self.is_htmx():
+            self.template_name = 'handyhelpers/report/chartjs/annual_progress_content.htm'
         context = dict()
         context['base_template'] = self.base_template
         context['title'] = self.title

handyhelpers/management/commands/generate_admin.py

@@ -1,110 +0,0 @@
-from django.core.management.base import BaseCommand, CommandError
-from django.apps import apps
-from django.conf import settings
-from jinja2 import Template
-import os
-
-__version__ = '0.0.2'
-
-
-class Command(BaseCommand):
-    help = "Generate admin.py file, based on a jinja2 template, for a given app"
-
-    def __init__(self):
-        self.opts = None
-        self.app = None
-        self.model_list = None
-        super(Command, self).__init__()
-
-    def add_arguments(self, parser):
-        """ define command arguments """
-        parser.add_argument('app', type=str, help='name of the django app')
-        parser.add_argument('--template', type=str, help='path to Jinja template used to create admin.py file')
-        parser.add_argument('--output_file', type=str, help='path of output file to create')
-
-    def handle(self, *args, **options):
-        """ command entry point """
-        if options['app'] not in settings.INSTALLED_APPS:
-            raise CommandError(f"'{options['app']}' is not an available application in this project")
-
-        self.opts = options
-        self.app = options['app']
-        self.get_model_list()
-        self.get_admin_template()
-        self.get_output_file()
-        self.build_admin()
-        self.stdout.write(self.style.SUCCESS(f"{self.opts['output_file']} generated!"))
-
-    def get_output_file(self):
-        """ return the full path of the generated file """
-        if not self.opts['output_file']:
-            self.opts['output_file'] = f'{os.getcwd()}/{self.app}/admin.py'
-
-    def get_admin_template(self):
-        """ return the full path of the jinja template to use in creating the admin.py file """
-        if not self.opts['template']:
-            self.opts['template'] = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                                 'admin_templates', 'admin.jinja')
-
-    def get_model_list(self):
-        """ return a list of all models in application """
-        app = apps.get_app_config(self.app)
-        self.model_list = list(app.get_models())
-
-    @staticmethod
-    def get_model_field_names(model, exclude_list=()):
-        """ return a list of field names for a given model """
-        return [i.name for i in model._meta.fields if type(i).__name__ not in exclude_list]
-
-    def build_admin(self):
-        """ build the admin.py file """
-        model_fields = {}
-        for model in self.model_list:
-            model_fields[model.__name__] = self.get_model_field_names(model)
-
-        data = {'model_list': self.model_list,
-                'app_name': self.app,
-                'models_file': 'models',
-                'model_data': self.get_models_and_fields(),
-                }
-
-        with open(self.opts['template']) as f:
-            template = Template(f.read())
-        file_text = template.render(data)
-
-        with open(self.opts['output_file'], 'w') as f:
-            f.write(file_text)
-
-    @staticmethod
-    def get_display_fields(model, exclude_field_list=()):
-        """ build and return a list of 'list_display' to be used in admin.py for a given model """
-        return [i.name for i in model._meta.fields if i.get_internal_type() not in exclude_field_list]
-
-    @staticmethod
-    def get_search_fields(model, exclude_field_list=('AutoField', 'BooleanField', 'DateTimeField', 'ForeignKey')):
-        """ build and return a list of 'search_fields' to be used in admin.py for a given model """
-        return [i.name for i in model._meta.fields if i.get_internal_type() not in exclude_field_list]
-
-    @staticmethod
-    def get_filter_fields(model, include_field_list=('BooleanField', 'ForeignKey', 'CharField')):
-        """ build and return a list of 'filter_fields' to be used in admin.py for a given model """
-        return_list = []
-        for i in model._meta.fields:
-            field_type = i.get_internal_type()
-            if field_type in include_field_list:
-                if field_type == 'CharField' and not i.choices:
-                    continue
-                elif field_type == 'CharField' and i.choices:
-                    return_list.append(i.name)
-                else:
-                    return_list.append(i.name)
-        return return_list
-
-    def get_models_and_fields(self):
-        return_data = {}
-        for model in self.model_list:
-            return_data[model.__name__] = {'display_fields': self.get_display_fields(model),
-                                           'search_fields': self.get_search_fields(model),
-                                           'filter_fields': self.get_filter_fields(model),
-                                           }
-        return return_data

handyhelpers/static/node_modules/@popperjs/core/dist/esm/utils/format.js

@@ -1,9 +0,0 @@
-export default function format(str) {
-  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    args[_key - 1] = arguments[_key];
-  }
-
-  return [].concat(args).reduce(function (p, c) {
-    return p.replace(/%s/, c);
-  }, str);
-}