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

advanced_report_builder/views/targets/utils.py

@@ -0,0 +1,251 @@
+from calendar import monthrange
+from datetime import date, timedelta
+
+from django.utils.dates import MONTHS
+
+from advanced_report_builder.models import Target
+
+
+class TargetUtils:
+    @staticmethod
+    def is_exact_full_month(min_date: date, max_date: date) -> bool:
+        if min_date.year != max_date.year or min_date.month != max_date.month:
+            return False
+
+        if min_date.day != 1:
+            return False
+
+        last_day = monthrange(min_date.year, min_date.month)[1]
+        return max_date.day == last_day
+
+    def get_monthly_target_value_for_range(self, min_date, max_date, target):
+        """
+        Returns the monthly target value for an arbitrary date range.
+
+        Rules:
+        - Exact full calendar month → direct lookup
+        - Partial / multi-month range → prorated by days
+        """
+
+        # Safety fallback
+        if not min_date or not max_date:
+            return target.get_value()
+
+        override_data = target.get_override_data() or {}
+
+        # ---- 1. Exact full month → lookup only ----
+        if self.is_exact_full_month(min_date, max_date):
+            year_data = override_data.get(str(min_date.year))
+            if year_data:
+                month_str = MONTHS[min_date.month]
+                return year_data.get(month_str, target.get_value())
+            return target.get_value()
+
+        # ---- 2. Partial / multi-month → prorated ----
+        total = 0.0
+
+        current = date(min_date.year, min_date.month, 1)
+
+        while current <= max_date:
+            year = current.year
+            month = current.month
+
+            days_in_month = monthrange(year, month)[1]
+            month_start = date(year, month, 1)
+            month_end = date(year, month, days_in_month)
+
+            effective_start = max(min_date, month_start)
+            effective_end = min(max_date, month_end)
+
+            if effective_start <= effective_end:
+                days_in_range = (effective_end - effective_start).days + 1
+
+                year_data = override_data.get(str(year), {})
+                month_str = MONTHS[month]
+                month_value = year_data.get(month_str, target.get_value())
+
+                total += (days_in_range / days_in_month) * month_value
+
+            # advance month
+            current = date(year + 1, 1, 1) if month == 12 else date(year, month + 1, 1)
+
+        return total
+
+    @staticmethod
+    def start_of_week(d: date) -> date:
+        return d - timedelta(days=d.weekday())
+
+    def is_exact_full_week(self, min_date: date, max_date: date) -> bool:
+        week_start = self.start_of_week(min_date)
+        week_end = week_start + timedelta(days=6)
+
+        return min_date == week_start and max_date == week_end
+
+    def get_weekly_target_value_for_range(self, min_date, max_date, target):
+        """
+        Returns the weekly target value for an arbitrary date range.
+
+        Rules:
+        - Exact full week → direct lookup
+        - Partial / multi-week range → prorated by days
+        """
+
+        # Safety fallback
+        if not min_date or not max_date:
+            return target.get_value()
+
+        override_data = target.get_override_data() or {}
+
+        # ---- 1. Exact full week → lookup ----
+        if self.is_exact_full_week(min_date, max_date):
+            year, week_no, _ = min_date.isocalendar()
+            year_data = override_data.get(str(year))
+            if year_data:
+                week_key = f'W{week_no:02d}'
+                return year_data.get(week_key, target.get_value())
+            return target.get_value()
+
+        # ---- 2. Partial / multi-week → prorated ----
+        total = 0.0
+        current = self.start_of_week(min_date)
+
+        while current <= max_date:
+            week_start = current
+            week_end = week_start + timedelta(days=6)
+
+            effective_start = max(min_date, week_start)
+            effective_end = min(max_date, week_end)
+
+            if effective_start <= effective_end:
+                days_in_range = (effective_end - effective_start).days + 1
+
+                year, week_no, _ = week_start.isocalendar()
+                year_data = override_data.get(str(year), {})
+                week_key = f'W{week_no:02d}'
+
+                week_value = year_data.get(week_key, target.get_value())
+
+                total += (days_in_range / 7) * week_value
+
+            current += timedelta(days=7)
+
+        return total
+
+    @staticmethod
+    def get_daily_target_value_for_range(min_date, max_date, target):
+        """
+        Returns the daily target value for an arbitrary date range.
+
+        Rules:
+        - Each day contributes exactly one daily target value
+        - Overrides are applied per day if present
+        """
+
+        # Safety fallback
+        if not min_date or not max_date:
+            return target.get_value()
+
+        override_data = target.get_override_data() or {}
+        default_value = target.get_value()
+
+        total = 0.0
+        current = min_date
+
+        while current <= max_date:
+            year_data = override_data.get(str(current.year), {})
+
+            # Support either YYYY-MM-DD or day-of-year style keys
+            day_key = current.isoformat()  # "2025-03-12"
+            doy_key = f'D{current.timetuple().tm_yday:03d}'  # "D071"
+
+            day_value = year_data.get(day_key) or year_data.get(doy_key) or default_value
+
+            total += day_value
+            current += timedelta(days=1)
+
+        return total
+
+    @staticmethod
+    def get_quarterly_target_value_for_range(min_date, target):
+        """
+        Return the quarterly target value.
+        Quarter validity is assumed to be checked by the caller.
+        """
+
+        override_data = target.get_override_data() or {}
+
+        year = min_date.year
+        quarter = ((min_date.month - 1) // 3) + 1
+        quarter_key = f'Q{quarter}'
+
+        year_data = override_data.get(str(year))
+        if year_data and quarter_key in year_data:
+            return year_data[quarter_key]
+
+        return target.get_value()
+
+    @staticmethod
+    def get_yearly_target_value_for_range(min_date, target):
+        override_data = target.get_override_data() or {}
+
+        year_data = override_data.get(str(min_date.year))
+        if year_data and 'YEAR' in year_data:
+            return year_data['YEAR']
+
+        return target.get_value()
+
+    def get_target_value(self, period_data, target):
+        if target.period_type == Target.PeriodType.DAILY:
+            period = period_data.get_day_period()
+            if period is None:
+                return None
+            target_value = self.get_daily_target_value_for_range(
+                min_date=period[0],
+                max_date=period[1],
+                target=target,
+            )
+
+        elif target.period_type == Target.PeriodType.WEEKLY:
+            period = period_data.get_week_period()
+            if period is None:
+                return None
+            target_value = self.get_weekly_target_value_for_range(
+                min_date=period[0],
+                max_date=period[1],
+                target=target,
+            )
+
+        elif target.period_type == Target.PeriodType.MONTHLY:
+            period = period_data.get_month_period()
+            if period is None:
+                return None
+            target_value = self.get_monthly_target_value_for_range(
+                min_date=period[0],
+                max_date=period[1],
+                target=target,
+            )
+
+        elif target.period_type == Target.PeriodType.QUARTER:
+            period = period_data.get_quarter_period()
+            if period is None:
+                return None
+            target_value = self.get_quarterly_target_value_for_range(
+                min_date=period[0],
+                target=target,
+            )
+        elif target.period_type == Target.PeriodType.YEARLY:
+            period = period_data.get_year_period()
+            if period is None:
+                return None
+
+            target_value = self.get_yearly_target_value_for_range(
+                min_date=period[0],
+                target=target,
+            )
+        else:
+            return None
+
+        if target_value == 0:
+            return None
+
+        return target_value

advanced_report_builder/views/targets/views.py

@@ -0,0 +1,139 @@
+from crispy_forms.layout import HTML, Div
+from django.conf import settings
+from django.forms import CharField
+from django.urls import reverse
+from django_datatables.columns import MenuColumn
+from django_datatables.widgets import DataTableWidget
+from django_menus.menu import HtmlMenu, MenuItem
+from django_modals.modals import ModelFormModal
+from django_modals.processes import PERMISSION_OFF, PROCESS_EDIT_DELETE
+
+from advanced_report_builder.columns import ColourColumn
+from advanced_report_builder.form_utils import PercentageWidget, SmallInputWidget
+from advanced_report_builder.models import Target, TargetColour
+from advanced_report_builder.utils import get_query_js
+
+
+class TargetModal(ModelFormModal):
+    model = Target
+    form_fields = ['name', 'target_type', 'period_type', 'default_colour', 'default_value', 'default_percentage']
+
+    widgets = {'default_value': SmallInputWidget, 'default_percentage': PercentageWidget}
+    process = PROCESS_EDIT_DELETE
+    permission_delete = PERMISSION_OFF
+
+    def form_setup(self, form, *_args, **_kwargs):
+        fields = ['name', 'target_type', 'period_type', 'default_colour', 'default_value', 'default_percentage']
+
+        form.add_trigger(
+            'target_type',
+            'onchange',
+            [
+                {
+                    'selector': '#div_id_default_value',
+                    'values': {Target.TargetType.COUNT: 'show', Target.TargetType.MONEY: 'show'},
+                    'default': 'hide',
+                },
+                {
+                    'selector': '#div_id_default_percentage',
+                    'values': {Target.TargetType.PERCENTAGE: 'show'},
+                    'default': 'hide',
+                },
+            ],
+        )
+
+        if self.object.id:
+            self.add_target_colours(form=form, fields=fields)
+        return fields
+
+    def post_save(self, created, form):
+        if created:
+            url_name = getattr(settings, 'REPORT_BUILDER_TARGET_URL_NAME', '')
+            if url_name:
+                url = reverse(url_name, kwargs={'slug': self.object.slug})
+                self.add_command('redirect', url=url)
+
+    def add_target_colours(self, form, fields):
+        add_query_js = 'django_modal.process_commands_lock([{"function": "post_modal", "button": {"button": "add_target_colour"}}])'
+
+        description_add_menu_items = [
+            MenuItem(
+                add_query_js.replace('"', '"'),
+                menu_display='Add Colour Override',
+                css_classes='btn btn-primary',
+                font_awesome='fas fa-palette',
+                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'))
+        target_colour_menu = self.query_target_colour_menu()
+
+        form.fields['target_colours'] = CharField(
+            required=False,
+            label='Colour Overrides',
+            widget=DataTableWidget(
+                model=TargetColour,
+                fields=[
+                    '_.index',
+                    '.id',
+                    'percentage',
+                    ColourColumn(column_name='colour', field='colour'),
+                    MenuColumn(
+                        column_name='menu',
+                        field='id',
+                        column_defs={'orderable': False, 'className': 'dt-right'},
+                        menu=HtmlMenu(
+                            self.request,
+                            'advanced_report_builder/datatables/onclick_menu.html',
+                        ).add_items(*target_colour_menu),
+                    ),
+                ],
+                attrs={'filter': {'target__id': self.object.id}},
+            ),
+        )
+        fields.append('target_colours')
+
+    @staticmethod
+    def query_target_colour_menu():
+        edit_query_js = get_query_js('edit_target_colour', 'target_colour_id')
+
+        description_edit_menu_items = [
+            MenuItem(
+                edit_query_js.replace('"', '"'),
+                menu_display='Edit',
+                css_classes='btn btn-sm btn-outline-dark',
+                font_awesome='fas fa-pencil',
+                link_type=MenuItem.HREF,
+            ),
+        ]
+        return description_edit_menu_items
+
+    def button_add_target_colour(self, **_kwargs):
+        slug = f'target_id-{self.object.id}'
+        url = reverse(
+            'advanced_report_builder:target_colour_modal',
+            kwargs={'slug': slug},
+        )
+        return self.command_response('show_modal', modal=url)
+
+    def button_edit_target_colour(self, **_kwargs):
+        target_colour_id = _kwargs['target_colour_id'][1:]
+        slug = f'pk-{target_colour_id}'
+        url = reverse(
+            'advanced_report_builder:target_colour_modal',
+            kwargs={'slug': slug},
+        )
+        return self.command_response('show_modal', modal=url)
+
+
+class TargetColourModal(ModelFormModal):
+    model = TargetColour
+    form_fields = ['colour', 'percentage']
+    widgets = {'percentage': PercentageWidget}
+
+    process = PROCESS_EDIT_DELETE
+    permission_delete = PERMISSION_OFF

advanced_report_builder/views/value_base.py

@@ -0,0 +1,198 @@
+from django.db.models import Count, ExpressionWrapper, FloatField, Sum
+from django.db.models.functions import Coalesce, NullIf
+
+from advanced_report_builder.column_types import NUMBER_FIELDS
+from advanced_report_builder.exceptions import ReportError
+from advanced_report_builder.globals import (
+    ANNOTATION_CHOICE_SUM,
+)
+from advanced_report_builder.views.charts_base import ChartBaseView
+
+
+class ValueBaseView(ChartBaseView):
+    use_annotations = False
+
+    def _get_count(self, fields):
+        number_function_kwargs = {
+            'aggregations': {'count': Count(1)},
+            'field': 'count',
+            'column_name': 'count',
+            'options': {'calculated': True},
+            'model_path': '',
+        }
+
+        field = self.number_field(**number_function_kwargs)
+        fields.append(field)
+
+    def _process_aggregations(
+        self,
+        field,
+        base_model,
+        report_builder_class,
+        decimal_places,
+        fields,
+        aggregations_type=ANNOTATION_CHOICE_SUM,
+        divider=None,
+    ):
+        django_field, col_type_override, _, _ = self.get_field_details(
+            base_model=base_model,
+            field=field,
+            report_builder_class=report_builder_class,
+        )
+
+        if isinstance(django_field, NUMBER_FIELDS) or col_type_override is not None and col_type_override.annotations:
+            self.get_number_field(
+                annotations_type=aggregations_type,
+                append_annotation_query=False,
+                index=0,
+                data_attr={},
+                table_field={'field': field, 'title': field},
+                fields=fields,
+                col_type_override=col_type_override,
+                decimal_places=decimal_places,
+                convert_currency_fields=True,
+                divider=divider,
+            )
+        else:
+            raise ReportError('not a number field')
+
+    def get_percentage_field(
+        self,
+        fields,
+        numerator_field_name,
+        numerator_col_type_override,
+        denominator_field_name,
+        denominator_col_type_override,
+        numerator_filter,
+        decimal_places=0,
+    ):
+        if numerator_col_type_override:
+            actual_numerator_field_name = numerator_col_type_override.field
+        else:
+            actual_numerator_field_name = numerator_field_name
+
+        if denominator_col_type_override:
+            actual_denominator_field_name = denominator_col_type_override.field
+        else:
+            actual_denominator_field_name = denominator_field_name
+
+        number_function_kwargs = {}
+        if decimal_places:
+            number_function_kwargs = {'decimal_places': int(decimal_places)}
+
+        new_field_name = f'{actual_numerator_field_name}_{actual_denominator_field_name}'
+
+        if numerator_col_type_override is not None and numerator_col_type_override.annotations:
+            if not isinstance(numerator_col_type_override.annotations, dict):
+                raise ReportError('Unknown annotation type')
+
+            annotations = list(numerator_col_type_override.annotations.values())[0]
+            if numerator_filter and isinstance(annotations, Sum | Count):
+                annotations.filter = numerator_filter
+                numerator = Coalesce(annotations + 0.0, 0.0)
+            else:
+                numerator = Coalesce(annotations + 0.0, 0.0)
+        else:
+            if numerator_filter:
+                numerator = Coalesce(
+                    (Sum(actual_numerator_field_name, filter=numerator_filter) + 0.0),
+                    0.0,
+                )
+            else:
+                numerator = Coalesce((Sum(actual_numerator_field_name) + 0.0), 0.0)
+
+        if denominator_col_type_override is not None and denominator_col_type_override.annotations:
+            if not isinstance(denominator_col_type_override.annotations, dict):
+                raise ReportError('Unknown annotation type')
+
+            annotations = list(denominator_col_type_override.annotations.values())[0]
+
+            denominator = Coalesce(annotations + 0.0, 0.0)
+        else:
+            denominator = Coalesce(Sum(actual_denominator_field_name) + 0.0, 0.0)
+
+        number_function_kwargs['aggregations'] = {
+            new_field_name: ExpressionWrapper((numerator / NullIf(denominator, 0)) * 100.0, output_field=FloatField())
+        }
+        field_name = new_field_name
+
+        number_function_kwargs.update(
+            {
+                'field': field_name,
+                'column_name': field_name,
+                'options': {'calculated': True},
+                'model_path': '',
+            }
+        )
+
+        field = self.number_field(**number_function_kwargs)
+
+        fields.append(field)
+
+        return field_name
+
+    def _process_percentage(
+        self,
+        numerator_filter,
+        denominator_field,
+        numerator_field,
+        base_model,
+        report_builder_class,
+        decimal_places,
+        fields,
+    ):
+        if denominator_field is None:
+            raise ReportError('denominator field is None')
+        if numerator_field is None:
+            raise ReportError('numerator field is None')
+        deno_django_field, denominator_col_type_override, _, _ = self.get_field_details(
+            base_model=base_model,
+            field=denominator_field,
+            report_builder_class=report_builder_class,
+        )
+        if not isinstance(deno_django_field, NUMBER_FIELDS) and (
+            denominator_col_type_override is not None and not denominator_col_type_override.annotations
+        ):
+            raise ReportError('denominator is not a number field')
+
+        num_django_field, numerator_col_type_override, _, _ = self.get_field_details(
+            base_model=base_model,
+            field=numerator_field,
+            report_builder_class=report_builder_class,
+        )
+
+        if not isinstance(num_django_field, NUMBER_FIELDS) and (
+            numerator_col_type_override is not None and not numerator_col_type_override.annotations
+        ):
+            raise ReportError('numerator is not a number field')
+
+        self.get_percentage_field(
+            fields=fields,
+            numerator_field_name=numerator_field,
+            numerator_col_type_override=numerator_col_type_override,
+            denominator_field_name=denominator_field,
+            denominator_col_type_override=denominator_col_type_override,
+            numerator_filter=numerator_filter,
+            decimal_places=decimal_places,
+        )
+
+    def _process_percentage_from_count(self, numerator_filter, decimal_places, fields):
+        if numerator_filter:
+            numerator = Coalesce(Count(1, filter=numerator_filter) + 0.0, 0.0)
+        else:
+            numerator = Coalesce(Count(1) + 0.0, 0.0)
+        denominator = Coalesce(Count(1) + 0.0, 0.0)
+        a = (numerator / denominator) * 100.0
+
+        number_function_kwargs = {
+            'aggregations': {'count': a},
+            'field': 'count',
+            'column_name': 'count',
+            'options': {'calculated': True},
+            'model_path': '',
+        }
+        if decimal_places:
+            number_function_kwargs['decimal_places'] = int(decimal_places)
+
+        field = self.number_field(**number_function_kwargs)
+        fields.append(field)

advanced_report_builder/widgets.py

@@ -0,0 +1,5 @@
+from django.forms import TextInput
+
+
+class SmallNumberInputWidget(TextInput):
+    crispy_kwargs = {'field_class': 'col-2', 'input_size': 'input-group-sm'}

django_advanced_report_builder-1.2.9.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: django-advanced-report-builder
+Version: 1.2.9
+Summary: Django app that allows you to build reports from modals
+Author: Thomas Turner
+License: MIT
+Project-URL: Homepage, https://github.com/django-advance-utils/django-advanced-report-builder
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=3.2
+Requires-Dist: django-filtered-datatables>=0.0.21
+Requires-Dist: django-ajax-helpers>=0.0.20
+Requires-Dist: django-nested-modals>=0.0.21
+Requires-Dist: time-stamped-model>=0.2.3
+Requires-Dist: date-offset>=0.0.2
+Requires-Dist: expression-builder>=0.0.12
+Dynamic: license-file
+
+[![PyPI version](https://badge.fury.io/py/django-advanced-report-builder.svg)](https://badge.fury.io/py/django-advanced-report-builder)
+
+
+# Django advanced report builder
+
+A Django application that provides a fully featured, dynamic report-building interface. It allows users to create, customise, preview and export reports directly through a dedicated front-end UI, without writing queries or touching the Django admin.
+
+## Features
+
+- Build reports through a standalone report-builder interface (not the Django admin).
+- Choose a root model and dynamically select fields to display.
+- Add filters, conditions, ordering and grouping.
+- Preview results instantly within the UI.
+- Export to CSV, Excel and other supported formats.
+- Pluggable architecture for adding formats, custom filters, or integration hooks.
+- Designed to integrate easily into existing Django projects.