django-advanced-report-builder 1.2.9__py3-none-any.whl

advanced_report_builder/views/query_modal/modal.py

@@ -0,0 +1,274 @@
+import json
+
+from crispy_forms.layout import HTML, Div
+from django.forms import CharField, ModelChoiceField
+from django.urls import reverse
+from django_datatables.columns import ColumnBase, MenuColumn
+from django_datatables.widgets import DataTableReorderWidget
+from django_menus.menu import HtmlMenu, MenuItem
+from django_modals.fields import FieldEx
+from django_modals.form_helpers import HorizontalNoEnterHelper
+from django_modals.forms import ModelCrispyForm
+from django_modals.modals import ModelFormModal
+from django_modals.processes import PERMISSION_OFF, PROCESS_EDIT_DELETE
+from django_modals.widgets.select2 import Select2
+
+from advanced_report_builder.models import ReportQuery, ReportQueryOrder, ReportType, Target
+from advanced_report_builder.toggle import RBToggle
+from advanced_report_builder.utils import get_query_js
+from advanced_report_builder.views.helpers import QueryBuilderModelForm
+from advanced_report_builder.views.modals_base import QueryBuilderModalBaseMixin
+
+
+class QueryForm(QueryBuilderModelForm):
+    cancel_class = 'btn-secondary modal-cancel'
+
+    class Meta:
+        model = ReportQuery
+        fields = ['name', 'query']
+
+
+class QueryFormWithTarget(QueryBuilderModelForm):
+    cancel_class = 'btn-secondary modal-cancel'
+
+    class Meta:
+        model = ReportQuery
+        fields = ['name', 'query', 'target']
+
+
+class QueryModal(QueryBuilderModalBaseMixin, ModelFormModal):
+    model = ReportQuery
+    process = PROCESS_EDIT_DELETE
+    permission_delete = PERMISSION_OFF
+
+    @property
+    def form_class(self):
+        if self.slug.get('show_target') == '1':
+            return QueryFormWithTarget
+        else:
+            return QueryForm
+
+    helper_class = HorizontalNoEnterHelper
+    ajax_commands = ['datatable', 'button']
+
+    template_name = 'advanced_report_builder/query_modal.html'
+    no_header_x = True
+
+    def __init__(self, *args, **kwargs):
+        self._base_and_class = None
+        super().__init__(*args, **kwargs)
+
+    def post_save(self, created, form):
+        self.add_command({'function': 'save_query_builder_id_query'})
+        return self.command_response('close')
+
+    def form_setup(self, form, *_args, **_kwargs):
+        fields = [
+            'name',
+        ]
+        if self.slug.get('show_target') == '1':
+            form.fields['target'] = ModelChoiceField(queryset=Target.objects.all(), widget=Select2(), required=False)
+            fields.append('target')
+
+        fields.append(FieldEx('query', template='advanced_report_builder/query_builder.html'))
+
+        if self.object.id and self.slug.get('show_order_by') == '1':
+            self.add_query_orders(form=form, fields=fields)
+
+        return fields
+
+    def ajax_get_query_builder_fields(self, **kwargs):
+        field_auto_id = kwargs['field_auto_id']
+        report_type_id = self.slug['report_type']
+        query_builder_filters = self.get_query_builder_report_type_field(report_type_id=report_type_id)
+        return self.command_response(f'query_builder_{field_auto_id}', data=json.dumps(query_builder_filters))
+
+    def get_report_builder_base_and_class(self):
+        if self._base_and_class is None:
+            self._base_and_class = self.get_report_builder_class(report_type_id=self.slug['report_type'])
+        return self._base_and_class
+
+    def order_by_result(self, _column, data_dict, _page_results):
+        order_by_field = data_dict['order_by_field']
+        field_values = []
+        report_builder_class, base_model = self.get_report_builder_base_and_class()
+        self.get_field_display_value(
+            field_type='order',
+            fields_values=field_values,
+            base_model=base_model,
+            report_builder_class=report_builder_class,
+            selected_field_value=order_by_field,
+        )
+
+        if len(field_values) > 0:
+            return field_values[0]['label']
+
+        return order_by_field
+
+    def add_query_orders(self, form, fields):
+        add_query_js = (
+            'django_modal.process_commands_lock([{"function": "post_modal", "button": {"button": "add_query_order"}}])'
+        )
+
+        description_add_menu_items = [
+            MenuItem(
+                add_query_js.replace('"', '"'),
+                menu_display='Add Order by',
+                css_classes='btn btn-primary',
+                font_awesome='fas fa-pencil',
+                link_type=MenuItem.HREF,
+            )
+        ]
+
+        menu = HtmlMenu(self.request, 'advanced_report_builder/datatables/onclick_menu.html').add_items(
+            *description_add_menu_items
+        )
+
+        fields.append(Div(HTML(menu.render()), css_class='form-buttons'))
+        edit_query_js = get_query_js('edit_query_order', 'query_order_id')
+        duplicate_query_js = get_query_js('duplicate_query_order', 'query_order_id')
+        description_edit_menu_items = [
+            MenuItem(
+                duplicate_query_js.replace('"', '"'),
+                menu_display='Duplicate',
+                css_classes='btn btn-sm btn-outline-dark',
+                font_awesome='fas fa-clone',
+                link_type=MenuItem.HREF,
+            ),
+            MenuItem(
+                edit_query_js.replace('"', '"'),
+                menu_display='Edit',
+                css_classes='btn btn-sm btn-outline-dark btn-query-edit',
+                font_awesome='fas fa-pencil',
+                link_type=MenuItem.HREF,
+            ),
+        ]
+
+        template = 'advanced_report_builder/datatables/onclick_menu.html'
+        form.fields['orders'] = CharField(
+            required=False,
+            label='Query Order',
+            widget=DataTableReorderWidget(
+                model=ReportQueryOrder,
+                order_field='order',
+                fields=[
+                    '_.index',
+                    '.id',
+                    ColumnBase(
+                        column_name='order_by',
+                        field='order_by_field',
+                        row_result=self.order_by_result,
+                    ),
+                    'order_by_ascending',
+                    MenuColumn(
+                        column_name='menu',
+                        field='id',
+                        column_defs={'orderable': False, 'className': 'dt-right'},
+                        menu=HtmlMenu(self.request, template).add_items(*description_edit_menu_items),
+                    ),
+                ],
+                attrs={'filter': {'report_query__id': self.object.id}},
+            ),
+        )
+        fields.append('orders')
+
+    def get_report_type(self):
+        return self.slug['report_type']
+
+    def button_duplicate_query_order(self, **_kwargs):
+        query_id = _kwargs['query_order_id'][1:]
+        report_query_order = ReportQueryOrder.objects.get(pk=query_id)
+        report_query_order.slug = None
+        report_query_order.pk = None
+        report_query_order.order = None
+        report_query_order.save()
+
+        report_type = self.get_report_type()
+        url = reverse(
+            'advanced_report_builder:query_order_modal',
+            kwargs={'slug': f'pk-{report_query_order.id}-report_type-{report_type}'},
+        )
+        return self.command_response('show_modal', modal=url)
+
+    def button_add_query_order(self, **_kwargs):
+        report_type = self.get_report_type()
+        url = reverse(
+            'advanced_report_builder:query_order_modal',
+            kwargs={'slug': f'report_query_id-{self.object.id}-report_type-{report_type}'},
+        )
+        return self.command_response('show_modal', modal=url)
+
+    def button_edit_query_order(self, **_kwargs):
+        query_order_id = _kwargs['query_order_id'][1:]
+        report_type = self.get_report_type()
+        url = reverse(
+            'advanced_report_builder:query_order_modal',
+            kwargs={'slug': f'pk-{query_order_id}-report_type-{report_type}'},
+        )
+        return self.command_response('show_modal', modal=url)
+
+    def datatable_sort(self, **kwargs):
+        current_sort = dict(ReportQueryOrder.objects.filter(report_query=self.object.id).values_list('id', 'order'))
+        for s in kwargs['sort']:
+            if current_sort[s[1]] != s[0]:
+                o = ReportQueryOrder.objects.get(id=s[1])
+                o.order = s[0]
+                o.save()
+        return self.command_response('')
+
+    def form_valid(self, form):
+        org_id = self.object.pk if hasattr(self, 'object') else None
+        instance = form.save(commit=False)
+        instance._current_user = self.request.user
+        instance.save()
+        self.post_save(created=org_id is None, form=form)
+        if not self.response_commands:
+            self.add_command('reload')
+        return self.command_response()
+
+
+class OrderByFieldForm(ModelCrispyForm):
+    class Meta:
+        model = ReportQueryOrder
+        fields = ['order_by_field', 'order_by_ascending']
+
+    cancel_class = 'btn-secondary modal-cancel'
+
+    def cancel_button(self, css_class=cancel_class, **kwargs):
+        commands = [{'function': 'save_query_builder_id_query'}, {'function': 'close'}]
+        return self.button('Cancel', commands, css_class, **kwargs)
+
+
+class QueryOrderModal(QueryBuilderModalBaseMixin, ModelFormModal):
+    form_class = OrderByFieldForm
+    ajax_commands = ['datatable', 'button']
+    model = ReportQueryOrder
+    process = PROCESS_EDIT_DELETE
+    permission_delete = PERMISSION_OFF
+    helper_class = HorizontalNoEnterHelper
+    no_header_x = True
+
+    def form_setup(self, form, *_args, **_kwargs):
+        form.fields['order_by_ascending'].widget = RBToggle()
+
+        report_type = ReportType.objects.get(id=self.slug['report_type'])
+        order_by_field = _kwargs['data'].get('order_by_field') if 'data' in _kwargs else form.instance.order_by_field
+
+        self.setup_field(
+            field_type='order',
+            form=form,
+            field_name='order_by_field',
+            selected_field_id=order_by_field,
+            report_type=report_type,
+        )
+
+    def select2_order_by_field(self, **kwargs):
+        return self.get_fields_for_select2(
+            field_type='django_order',
+            report_type=self.slug['report_type'],
+            search_string=kwargs.get('search'),
+        )
+
+    def post_save(self, created, form):
+        self.add_command({'function': 'save_query_builder_id_query'})
+        return self.command_response('close')

advanced_report_builder/views/report.py

@@ -0,0 +1,241 @@
+import base64
+from urllib.parse import quote, unquote
+
+from ajax_helpers.mixins import AjaxHelpers
+from django.core.exceptions import FieldError
+from django.db.models import Q
+from django.forms import ChoiceField
+from django.shortcuts import get_object_or_404
+from django.urls import reverse
+from django_menus.menu import MenuItem, MenuMixin
+from django_modals.forms import CrispyForm
+from django_modals.modals import FormModal
+from django_modals.widgets.select2 import Select2, select2_ajax_result
+
+from advanced_report_builder.models import ReportOption
+from advanced_report_builder.utils import get_report_builder_class, make_slug_str
+
+
+class ReportBase(AjaxHelpers, MenuMixin):
+    max_dropdown_option = 20
+
+    # noinspection PyUnusedLocal
+    @staticmethod
+    def duplicate_menu(request, report_id):
+        return [
+            MenuItem(
+                f'advanced_report_builder:duplicate_report_modal,pk-{report_id}',
+                css_classes=['btn-success'],
+            )
+        ]
+
+    def get_dashboard_class(self, report):
+        return None
+
+    def queries_option_menus(self, report, dashboard_report):
+        menus = []
+
+        self._queries_menus(report=report, dashboard_report=dashboard_report, menus=menus)
+        self._option_menus(report=report, dashboard_report=dashboard_report, menus=menus)
+
+        return menus
+
+    def _queries_menus(self, report, dashboard_report, menus):
+        query_slug = f'query{report.id}'
+        if dashboard_report is not None:
+            if not dashboard_report.show_versions:
+                return
+            query_slug += f'_{dashboard_report.id}'
+        report_queries = report.reportquery_set.all()
+        if len(report_queries) > 1:
+            dropdown = []
+            for report_query in report_queries:
+                slug_str = make_slug_str(self.slug, overrides={query_slug: report_query.id})
+                dropdown.append(
+                    (
+                        self.request.resolver_match.view_name,
+                        report_query.name,
+                        {'url_kwargs': {'slug': slug_str}},
+                    )
+                )
+            menus.append(
+                MenuItem(
+                    menu_display='Version',
+                    no_hover=True,
+                    css_classes='btn-secondary',
+                    dropdown=dropdown,
+                )
+            )
+
+    def _option_menus(self, report, dashboard_report, menus):
+        append_option_slug = ''
+        dashboard_report_id = 0
+        if dashboard_report is not None:
+            if not dashboard_report.show_options:
+                return
+            dashboard_report_id = dashboard_report.id
+            append_option_slug = f'_{dashboard_report.id}'
+        view_name = self.request.resolver_match.view_name
+        for report_option in report.reportoption_set.all():
+            option_slug = f'option{report_option.id}{append_option_slug}'
+            base_model = report_option.content_type.model_class()
+            report_cls = get_report_builder_class(model=base_model, class_name=report_option.report_builder_class_name)
+            qs = base_model.objects.filter(report_cls.options_filter)
+            # Fetch at most 21 rows
+            probe = list(qs[: self.max_dropdown_option + 1])
+            if len(probe) <= self.max_dropdown_option:
+                slug_str = make_slug_str(self.slug, overrides={option_slug: 0})
+                dropdown = [
+                    (
+                        view_name,
+                        'N/A',
+                        {'url_kwargs': {'slug': slug_str}},
+                    )
+                ]
+                for _obj in probe:
+                    slug_str = make_slug_str(self.slug, overrides={option_slug: _obj.id})
+                    method = getattr(_obj, report_cls.option_label, None)
+                    label = method() if callable(method) else _obj.__str__()
+                    dropdown.append(
+                        (
+                            view_name,
+                            label,
+                            {'url_kwargs': {'slug': slug_str}},
+                        )
+                    )
+                menus.append(
+                    MenuItem(
+                        menu_display=report_option.name,
+                        no_hover=True,
+                        css_classes='btn-secondary',
+                        dropdown=dropdown,
+                    )
+                )
+            else:
+                view_name_encoded = quote(base64.b64encode(view_name.encode()).decode(), safe='')
+                slug_str = make_slug_str(
+                    self.slug,
+                    overrides={
+                        'report_option': report_option.id,
+                        'view_name': view_name_encoded,
+                        'dashboard_report_id': dashboard_report_id,
+                    },
+                )
+                menus.append(
+                    MenuItem(
+                        menu_display=report_option.name,
+                        url='advanced_report_builder:select_option_modal',
+                        url_slug=slug_str,
+                        css_classes='btn-secondary',
+                    )
+                )
+
+
+class SelectOptionModal(FormModal):
+    form_class = CrispyForm
+    max_options = 50
+
+    @property
+    def modal_title(self):
+        report_option = self.get_report_option()
+        return f'Select {report_option.name} option'
+
+    def __init__(self, *args, **kwargs):
+        self._report_cls = None
+        self._report_option = None
+        self._base_model = None
+        self._option_slug = None
+        super().__init__(*args, **kwargs)
+
+    def get_report_option(self):
+        if self._report_option is None:
+            self._report_option = get_object_or_404(ReportOption, pk=self.slug['report_option'])
+        return self._report_option
+
+    def get_report_class_and_base_model(self):
+        if self._report_cls is None:
+            report_option = self.get_report_option()
+            self._base_model = report_option.content_type.model_class()
+            self._report_cls = get_report_builder_class(
+                model=self._base_model, class_name=report_option.report_builder_class_name
+            )
+        return self._report_cls, self._base_model
+
+    def get_option_label(self, obj, report_cls):
+        method = getattr(obj, report_cls.option_label, None)
+        return method() if callable(method) else obj.__str__()
+
+    def form_setup(self, form, *_args, **_kwargs):
+        report_cls, base_model = self.get_report_class_and_base_model()
+        option_slug = self.get_option_slug()
+        choices = []
+        initial = None
+        if option_slug in self.slug:
+            _obj = base_model.objects.filter(report_cls.options_filter).first()
+            if _obj is not None:
+                label = self.get_option_label(_obj, report_cls)
+                choices.append((_obj.id, label))
+                initial = _obj.id
+
+        class MyChoiceField(ChoiceField):
+            def validate(self, value):
+                return
+
+        form.fields['select_option'] = MyChoiceField(widget=Select2(attrs={'ajax': True}), choices=choices)
+        if initial is not None:
+            form.fields['select_option'].initial = initial
+
+    def get_option_slug(self):
+        if self._option_slug is None:
+            dashboard_report_id = int(self.slug['dashboard_report_id'])
+            append_option_slug = ''
+            if dashboard_report_id != 0:
+                append_option_slug = f'_{dashboard_report_id}'
+            report_option = self.get_report_option()
+            self._option_slug = f'option{report_option.id}{append_option_slug}'
+        return self._option_slug
+
+    def form_valid(self, form):
+        view_name = base64.b64decode(unquote(self.slug['view_name'])).decode()
+        option_slug = self.get_option_slug()
+        slug_str = make_slug_str(
+            self.slug,
+            overrides={option_slug: form.cleaned_data['select_option']},
+            excludes=['report_option', 'view_name', 'dashboard_report_id'],
+        )
+        url = reverse(view_name, kwargs={'slug': slug_str})
+        return self.command_response('redirect', url=url)
+
+    def select2_select_option(self, search=None, page=None, **_kwargs):
+        report_cls, base_model = self.get_report_class_and_base_model()
+
+        qs = base_model.objects.filter(report_cls.options_filter)
+
+        if search:
+            try:
+                fields = report_cls.option_ajax_search or []
+
+                if fields:
+                    query = Q()
+                    for field in fields:
+                        query |= Q(**{f'{field}__icontains': search})
+
+                    qs = qs.filter(query)
+
+            except FieldError:
+                # Invalid field name → fall back to unfiltered qs
+                pass
+
+        qs = qs[: self.max_options]
+
+        new_results = []
+
+        # Add synthetic option (not from DB)
+        if not search:
+            new_results.append((0, 'N/A'))
+
+        for _obj in qs:
+            label = self.get_option_label(_obj, report_cls)
+            new_results.append((_obj.id, label))
+
+        return select2_ajax_result(new_results)