django-advanced-report-builder 0.8.4__tar.gz → 0.9.0__tar.gz

{django-advanced-report-builder-0.8.4/django_advanced_report_builder.egg-info → django-advanced-report-builder-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-advanced-report-builder
-Version: 0.8.4
+Version: 0.9.0
 Summary: Django app that allows you to build reports from modals
 Home-page: https://github.com/django-advance-utils/django-advanced-report-builder
 Author: Thomas Turner

django-advanced-report-builder-0.9.0/advanced_report_builder/admin.py

@@ -0,0 +1,172 @@
+from django.contrib import admin
+from advanced_report_builder.models import (
+    Report,
+    ReportType,
+    TableReport,
+    ReportQuery,
+    SingleValueReport,
+    Dashboard,
+    DashboardReport,
+    BarChartReport,
+    LineChartReport,
+    PieChartReport,
+    FunnelChartReport,
+    ReportTag,
+    KanbanReport,
+    KanbanReportLane,
+    Target,
+    CustomReport,
+    KanbanReportDescription,
+)
+
+
+@admin.register(ReportQuery)
+class ReportQueryAdmin(admin.ModelAdmin):
+    list_display = ('report', 'name', 'query')
+
+
+class ReportQueryInline(admin.TabularInline):
+    model = ReportQuery
+
+
+@admin.register(Report)
+class ReportAdmin(admin.ModelAdmin):
+    list_display = ('name', 'instance_type', 'slug', 'slug_alias', 'version')
+    exclude = ('slug',)
+
+    inlines = [ReportQueryInline]
+
+
+@admin.register(ReportType)
+class ReportTypeAdmin(admin.ModelAdmin):
+    list_display = ('name', 'content_type', 'report_builder_class_name')
+
+
+@admin.register(TableReport)
+class TableReportAdmin(admin.ModelAdmin):
+    list_display = (
+        'name',
+        'slug',
+    )
+    exclude = (
+        'instance_type',
+        'slug',
+    )
+    inlines = [ReportQueryInline]
+
+
+@admin.register(SingleValueReport)
+class SingleValueReportAdmin(admin.ModelAdmin):
+    list_display = (
+        'name',
+        'slug',
+    )
+    exclude = (
+        'instance_type',
+        'slug',
+    )
+    inlines = [ReportQueryInline]
+
+
+@admin.register(BarChartReport)
+class BarChartReportAdmin(admin.ModelAdmin):
+    list_display = (
+        'name',
+        'slug',
+    )
+    exclude = (
+        'instance_type',
+        'slug',
+    )
+    inlines = [ReportQueryInline]
+
+
+@admin.register(LineChartReport)
+class LineChartReportAdmin(admin.ModelAdmin):
+    list_display = (
+        'name',
+        'slug',
+    )
+    exclude = (
+        'instance_type',
+        'slug',
+    )
+    inlines = [ReportQueryInline]
+
+
+@admin.register(PieChartReport)
+class PieChartReportAdmin(admin.ModelAdmin):
+    list_display = (
+        'name',
+        'slug',
+    )
+    exclude = (
+        'instance_type',
+        'slug',
+    )
+    inlines = [ReportQueryInline]
+
+
+@admin.register(FunnelChartReport)
+class FunnelChartReportAdmin(admin.ModelAdmin):
+    list_display = (
+        'name',
+        'slug',
+    )
+    exclude = (
+        'instance_type',
+        'slug',
+    )
+    inlines = [ReportQueryInline]
+
+
+@admin.register(CustomReport)
+class CustomReportAdmin(admin.ModelAdmin):
+    list_display = ('name', 'slug', 'output_type', 'view_name', 'settings')
+    exclude = ('instance_type', 'slug', 'report_type')
+
+
+class KanbanReportDescriptionInline(admin.TabularInline):
+    model = KanbanReportDescription
+
+
+class KanbanReportLaneInline(admin.TabularInline):
+    model = KanbanReportLane
+
+
+@admin.register(KanbanReport)
+class KanbanReportAdmin(admin.ModelAdmin):
+    list_display = (
+        'name',
+        'slug',
+    )
+    exclude = ('instance_type', 'slug', 'report_type')
+    inlines = [KanbanReportLaneInline, KanbanReportDescriptionInline]
+
+
+class DashboardReportInline(admin.TabularInline):
+    model = DashboardReport
+
+
+@admin.register(Dashboard)
+class DashboardAdmin(admin.ModelAdmin):
+    list_display = (
+        'slug',
+        'name',
+    )
+
+    exclude = [
+        'slug',
+    ]
+
+    inlines = [DashboardReportInline]
+
+
+@admin.register(ReportTag)
+class ReportTagAdmin(admin.ModelAdmin):
+    list_display = ('name', 'order')
+
+
+@admin.register(Target)
+class TargetAdmin(admin.ModelAdmin):
+    list_display = ('pk', 'name', 'target_type', 'default_value')

django-advanced-report-builder-0.9.0/advanced_report_builder/column_types.py

@@ -0,0 +1,26 @@
+from django.db import models
+from django_datatables.columns import CurrencyColumn, CurrencyPenceColumn, ColumnLink
+
+from advanced_report_builder.columns import (
+    ColourColumn,
+    ReverseForeignKeyStrColumn,
+    ReverseForeignKeyBoolColumn,
+    ReverseForeignKeyChoiceColumn,
+    ReverseForeignKeyDateColumn,
+)
+
+NUMBER_FIELDS = (
+    models.IntegerField,
+    models.PositiveSmallIntegerField,
+    models.PositiveIntegerField,
+    models.FloatField,
+)
+DATE_FIELDS = (models.DateTimeField, models.DateField)
+BOOLEAN_FIELD = models.BooleanField
+CURRENCY_COLUMNS = (CurrencyColumn, CurrencyPenceColumn)
+LINK_COLUMNS = ColumnLink
+COLOUR_COLUMNS = ColourColumn
+REVERSE_FOREIGN_KEY_STR_COLUMNS = ReverseForeignKeyStrColumn
+REVERSE_FOREIGN_KEY_BOOL_COLUMNS = ReverseForeignKeyBoolColumn
+REVERSE_FOREIGN_KEY_CHOICE_COLUMNS = ReverseForeignKeyChoiceColumn
+REVERSE_FOREIGN_KEY_DATE_COLUMNS = ReverseForeignKeyDateColumn

django-advanced-report-builder-0.9.0/advanced_report_builder/columns.py

@@ -0,0 +1,274 @@
+from django.contrib.humanize.templatetags.humanize import intcomma
+from django.contrib.postgres.aggregates import StringAgg, BoolOr, BoolAnd, ArrayAgg
+from django.db.models import Count, BooleanField, Min, Max
+from django.db.models.functions import Cast
+from django_datatables.columns import (
+    ColumnBase,
+    CurrencyPenceColumn,
+    CurrencyColumn,
+    NoHeadingColumn,
+    ColumnLink,
+    ManyToManyColumn,
+)
+from django_datatables.helpers import get_url, DUMMY_ID, render_replace
+from django_datatables.model_def import DatatableModel
+
+from advanced_report_builder.globals import (
+    REVERSE_FOREIGN_KEY_DELIMITER_COMMA,
+    REVERSE_FOREIGN_KEY_DELIMITER_VALUES,
+    DATE_FORMAT_TYPE_DD_MM_YY_SLASH,
+    DATE_FORMAT_TYPES_DJANGO_FORMAT,
+    REVERSE_FOREIGN_KEY_ANNOTATION_DATE_ARRAY,
+    REVERSE_FOREIGN_KEY_ANNOTATION_DATE_MAX,
+    REVERSE_FOREIGN_KEY_ANNOTATION_DATE_MIN,
+)
+from advanced_report_builder.globals import (
+    REVERSE_FOREIGN_KEY_ANNOTATION_BOOLEAN_XOR,
+    REVERSE_FOREIGN_KEY_ANNOTATION_BOOLEAN_AND,
+    REVERSE_FOREIGN_KEY_ANNOTATION_BOOLEAN_ARRAY,
+)
+
+
+class ReportBuilderDateColumn(ColumnBase):
+    def __init__(self, *, date_format=None, **kwargs):
+        if not self.initialise(locals()):
+            return
+        super().__init__(**kwargs)
+        if date_format:
+            self.date_format = date_format
+        else:
+            self.date_format = '%d/%m/%Y'
+
+    def row_result(self, data, _page_data):
+        try:
+            date = data[self.field].strftime(self.date_format)
+            return date
+        except AttributeError:
+            return ''
+
+
+class ReportBuilderNumberColumn(ColumnBase):
+    def __init__(self, *, decimal_places=0, trim_zeros=True, **kwargs):
+        if not self.initialise(locals()):
+            return
+        super().__init__(**kwargs)
+        self.decimal_places = f'{{:.{decimal_places}f}}'
+        self.trim_zeros = trim_zeros
+
+    def row_result(self, data, _page_data):
+        number = data.get(self.field)
+        if number is None:
+            return ''
+        else:
+            number = self.decimal_places.format(number)
+        if self.trim_zeros and '.' in number:
+            return number.rstrip('0').rstrip('.')
+        else:
+            return number
+
+
+class ReportBuilderCurrencyPenceColumn(CurrencyPenceColumn):
+    def row_result(self, data, _page_data):
+        try:
+            return intcomma('{:.2f}'.format(data[self.field] / 100.0))
+        except (KeyError, TypeError):
+            return '0.00'
+
+
+class ReportBuilderCurrencyColumn(CurrencyColumn):
+    def row_result(self, data, _page_data):
+        try:
+            return intcomma('{:.2f}'.format(data[self.field]))
+        except (KeyError, TypeError):
+            return '0.00'
+
+
+class ArrowColumn(NoHeadingColumn):
+    def __init__(self, **kwargs):
+        if not self.initialise(locals()):
+            return
+        kwargs['render'] = [{'html': '<i class="fa fa-angle-right fa-2x"></i>', 'function': 'Html'}]
+        kwargs['width'] = '10px'
+        super().__init__(**kwargs)
+
+
+class ColourColumn(ColumnBase):
+    def __init__(self, **kwargs):
+        if not self.initialise(locals()):
+            return
+        kwargs['render'] = [
+            render_replace(
+                html='<span style="display: inline-block; width: 60px; height: 15px;'
+                ' background-color: #%1%; vertical-align: middle;"></span>',
+                column=kwargs['column_name'],
+            )
+        ]
+        super().__init__(**kwargs)
+
+
+class FilterForeignKeyColumn(ColumnBase):
+    def get_query_options(self):
+        values = self.model.objects.distinct(self.field).order_by(self.field).values_list(self.field, flat=True)
+        return {v: v for v in values if v}
+
+
+class ReverseForeignKeyStrColumn(ColumnBase):
+    def __init__(self, field_name, report_builder_class_name, **kwargs):
+        if not self.initialise(locals()):
+            return
+        super().__init__(**kwargs)
+        self.field_name = field_name
+        self.report_builder_class_name = report_builder_class_name
+
+    def setup_annotations(self, delimiter_type=None, sub_filter=None, field_name=None):
+        if field_name is None:
+            field_name = self.field_name
+        delimiter = REVERSE_FOREIGN_KEY_DELIMITER_VALUES[delimiter_type]
+
+        self.annotations = {
+            field_name: StringAgg(self.field_name, delimiter=delimiter, distinct=True, filter=sub_filter)
+        }
+
+
+class ReverseForeignKeyBoolColumn(ColumnBase):
+    def __init__(self, field_name, report_builder_class_name, **kwargs):
+        if not self.initialise(locals()):
+            return
+        super().__init__(**kwargs)
+        self.field_name = field_name
+        self.report_builder_class_name = report_builder_class_name
+
+    def setup_annotations(self, annotations_type, sub_filter=None, field_name=None):
+        if field_name is None:
+            field_name = self.field_name
+
+        if annotations_type == REVERSE_FOREIGN_KEY_ANNOTATION_BOOLEAN_XOR:
+            self.annotations = {field_name: BoolOr(Cast(self.field_name, BooleanField()), filter=sub_filter)}
+        elif annotations_type == REVERSE_FOREIGN_KEY_ANNOTATION_BOOLEAN_AND:
+            self.annotations = {field_name: BoolAnd(Cast(self.field_name, BooleanField()), filter=sub_filter)}
+        elif annotations_type == REVERSE_FOREIGN_KEY_ANNOTATION_BOOLEAN_ARRAY:
+            self.annotations = {field_name: ArrayAgg(self.field_name, distinct=True, filter=sub_filter)}
+
+
+class ReverseForeignKeyChoiceColumn(ColumnBase):
+    def __init__(self, field_name, report_builder_class_name, **kwargs):
+        if not self.initialise(locals()):
+            return
+        self.field_name = field_name
+        self.choices = None
+        self.report_builder_class_name = report_builder_class_name
+        self.delimiter_type = REVERSE_FOREIGN_KEY_DELIMITER_COMMA
+        super().__init__(**kwargs)
+
+    def setup_results(self, request, all_results):
+        _, django_field, _ = DatatableModel.get_setup_data(self.model, self.field_name)
+        self.choices = {c[0]: c[1] for c in django_field.choices}
+
+    def row_result(self, data, _page_data):
+        results = []
+        for x in data.get(self.field):
+            results.append(self.choices.get(x, ''))
+        delimiter = REVERSE_FOREIGN_KEY_DELIMITER_VALUES[self.delimiter_type]
+        return delimiter.join(results)
+
+    def setup_annotations(self, delimiter_type=None, sub_filter=None, field_name=None):
+        if field_name is None:
+            field_name = self.field_name
+        self.delimiter_type = delimiter_type
+        self.annotations = {field_name: ArrayAgg(self.field_name, distinct=True, filter=sub_filter)}
+
+
+class ReverseForeignKeyDateColumn(ColumnBase):
+    def __init__(self, field_name, report_builder_class_name, **kwargs):
+        if not self.initialise(locals()):
+            return
+        super().__init__(**kwargs)
+        self.field_name = field_name
+        self.report_builder_class_name = report_builder_class_name
+        self.delimiter_type = REVERSE_FOREIGN_KEY_DELIMITER_COMMA
+        self.date_format_type = DATE_FORMAT_TYPE_DD_MM_YY_SLASH
+        self.annotations_type = REVERSE_FOREIGN_KEY_ANNOTATION_DATE_ARRAY
+
+    def setup_annotations(
+        self,
+        delimiter_type=None,
+        date_format_type=None,
+        annotations_type=None,
+        sub_filter=None,
+        field_name=None,
+    ):
+        if field_name is None:
+            field_name = self.field_name
+        self.delimiter_type = delimiter_type
+        self.date_format_type = date_format_type
+        self.annotations_type = annotations_type
+
+        if annotations_type == REVERSE_FOREIGN_KEY_ANNOTATION_DATE_ARRAY:
+            self.annotations = {field_name: ArrayAgg(self.field_name, distinct=True, filter=sub_filter)}
+        elif annotations_type == REVERSE_FOREIGN_KEY_ANNOTATION_DATE_MIN:
+            self.annotations = {field_name: Min(self.field_name, sub_filter=sub_filter)}
+
+        elif annotations_type == REVERSE_FOREIGN_KEY_ANNOTATION_DATE_MAX:
+            self.annotations = {field_name: Max(self.field_name, sub_filter=sub_filter)}
+
+    def row_result(self, data, _page_data):
+        field = self.field
+        if isinstance(field, list):
+            field = field[-1]
+        try:
+            date_formate_type_str = DATE_FORMAT_TYPES_DJANGO_FORMAT[self.date_format_type]
+            results = []
+            date_values = data[field]
+            if date_values is None:
+                return ''
+            if isinstance(date_values, list):
+                for value in date_values:
+                    results.append(value.strftime(date_formate_type_str))
+                delimiter = REVERSE_FOREIGN_KEY_DELIMITER_VALUES[self.delimiter_type]
+                return delimiter.join(results)
+            else:
+                return date_values.strftime(date_formate_type_str)
+        except AttributeError:
+            return ''
+
+
+class ReportBuilderColumnLink(ColumnLink):
+    """Sometimes you may want to have a report where the links don't work.
+    This is used for when you have a wall board"""
+
+    @property
+    def url(self):
+        return self._url
+
+    @url.setter
+    def url(self, url_name):
+        if (
+            not self.table
+            or self.table.view is None
+            or self.table.view.kwargs.get('enable_links')
+            or getattr(self.table.view, 'enable_links', False)
+        ):
+            self._url = get_url(url_name)
+        else:
+            self._url = f'#?{DUMMY_ID}'
+
+
+class RecordCountColumn(ColumnBase):
+    def __init__(self, field=None, **kwargs):
+        if 'annotations' not in kwargs:
+            kwargs['annotations'] = {'record_count': Count(1)}
+        if 'column_name' not in kwargs:
+            kwargs['column_name'] = 'record_count'
+        super().__init__(field, **kwargs)
+
+
+class ReportBuilderManyToManyColumn(ManyToManyColumn):
+    def __init__(self, *arg, **kwargs):
+        if not self.initialise(locals()):
+            return
+        super().__init__(*arg, **kwargs)
+        if self.model_path is not None:
+            self.field = 'id'
+
+    def row_result(self, data_dict, page_results):
+        return page_results['m2m' + self.column_name].get(data_dict[self.model_path + 'id'], self.blank)

{django-advanced-report-builder-0.8.4 → django-advanced-report-builder-0.9.0}/advanced_report_builder/customise.py

@@ -1,3 +1,2 @@
 class CustomiseReportBuilder:
     pass
-

{django-advanced-report-builder-0.8.4 → django-advanced-report-builder-0.9.0}/advanced_report_builder/data_merge/utils.py

@@ -7,16 +7,24 @@ from advanced_report_builder.utils import get_report_builder_class
 
 
 class DataMergeUtils(ReportBuilderFieldUtils):
-    def get_menu_fields(self, base_model, report_builder_class,
-                        menus=None, codes=None, code_prefix='', next_code_prefix='__',
-                        previous_base_model=None, table=None):
-
+    def get_menu_fields(
+        self,
+        base_model,
+        report_builder_class,
+        menus=None,
+        codes=None,
+        code_prefix='',
+        next_code_prefix='__',
+        previous_base_model=None,
+        table=None,
+    ):
         for report_builder_field in report_builder_class.fields:
             django_field, col_type_override, columns, _ = self.get_field_details(
                 base_model=base_model,
                 field=report_builder_field,
                 report_builder_class=report_builder_class,
-                table=table)
+                table=table,
+            )
             for column in columns:
                 full_id = code_prefix + column.column_name
                 if menus is not None:
@@ -29,8 +37,9 @@ class DataMergeUtils(ReportBuilderFieldUtils):
 
             new_model = apps.get_model(app_label, model)
             if new_model != previous_base_model:
-                new_report_builder_class = get_report_builder_class(model=new_model,
-                                                                    class_name=report_builder_fields_str)
+                new_report_builder_class = get_report_builder_class(
+                    model=new_model, class_name=report_builder_fields_str
+                )
 
                 title = include.get('title')
                 if title is None or title == '':
@@ -39,14 +48,16 @@ class DataMergeUtils(ReportBuilderFieldUtils):
                     menu = []
                 else:
                     menu = None
-                self.get_menu_fields(base_model=new_model,
-                                     report_builder_class=new_report_builder_class,
-                                     menus=menu,
-                                     codes=codes,
-                                     code_prefix=f"{code_prefix}{include_field}{next_code_prefix}",
-                                     next_code_prefix=next_code_prefix,
-                                     previous_base_model=base_model,
-                                     table=table)
+                self.get_menu_fields(
+                    base_model=new_model,
+                    report_builder_class=new_report_builder_class,
+                    menus=menu,
+                    codes=codes,
+                    code_prefix=f'{code_prefix}{include_field}{next_code_prefix}',
+                    next_code_prefix=next_code_prefix,
+                    previous_base_model=base_model,
+                    table=table,
+                )
                 if menus is not None:
                     menus.append({'text': title, 'menu': menu})
 
@@ -70,7 +81,12 @@ class DataMergeUtils(ReportBuilderFieldUtils):
             for field in variable[1].split(' '):
                 if field != '' and (field == 'as' or field[0] in ['=', '<', '>']):
                     break
-                if field not in ['', 'not', 'and' 'or'] and field[0] not in ['(', ')', '"', "'"]:
+                if field not in ['', 'not', 'andor'] and field[0] not in [
+                    '(',
+                    ')',
+                    '"',
+                    "'",
+                ]:
                     all_fields.add(field)
         return all_fields
 
@@ -79,10 +95,12 @@ class DataMergeUtils(ReportBuilderFieldUtils):
         columns = set()
         column_map = {}
         for field in all_fields:
-            django_field, col_type_override, _, _ = self.get_field_details(base_model=base_model,
-                                                                           field=field,
-                                                                           report_builder_class=report_builder_class,
-                                                                           table=table)
+            django_field, col_type_override, _, _ = self.get_field_details(
+                base_model=base_model,
+                field=field,
+                report_builder_class=report_builder_class,
+                table=table,
+            )
             if django_field is not None or isinstance(col_type_override.field, (list, tuple)):
                 if field not in columns and f'.{field}' not in columns:
                     columns.add('.' + field)

{django-advanced-report-builder-0.8.4 → django-advanced-report-builder-0.9.0}/advanced_report_builder/data_merge/widget.py

@@ -4,7 +4,10 @@ from django.forms.widgets import Input
 class DataMergeWidget(Input):
     template_name = 'advanced_report_builder/data_merge/data_merge.html'
     input_type = 'textarea'
-    crispy_kwargs = {'label_class': 'col-3 col-form-label-sm', 'field_class': 'col-12 input-group-sm'}
+    crispy_kwargs = {
+        'label_class': 'col-3 col-form-label-sm',
+        'field_class': 'col-12 input-group-sm',
+    }
 
     def __init__(self, data_merge_data=None, height=150):
         self.height = height

{django-advanced-report-builder-0.8.4 → django-advanced-report-builder-0.9.0}/advanced_report_builder/duplicate.py

@@ -1,22 +1,30 @@
 from copy import deepcopy
 
-from advanced_report_builder.models import TableReport, SingleValueReport, BarChartReport, PieChartReport, \
-    FunnelChartReport, KanbanReport, LineChartReport, CustomReport
+from advanced_report_builder.models import (
+    TableReport,
+    SingleValueReport,
+    BarChartReport,
+    PieChartReport,
+    FunnelChartReport,
+    KanbanReport,
+    LineChartReport,
+    CustomReport,
+)
 from django.shortcuts import get_object_or_404
 
 
 class DuplicateReport:
-
     def duplicate(self, report):
-        duplicate_methods = {'tablereport': self._duplicate_table_report,
-                             'singlevaluereport': self._duplicate_single_value_report,
-                             'barchartreport': self._duplicate_bar_chart_report,
-                             'linechartreport': self._duplicate_line_chart_report,
-                             'piechartreport': self._duplicate_pie_chart_report,
-                             'funnelchartreport': self._duplicate_funnel_chart_report,
-                             'kanbanreport': self._duplicate_kanban_report,
-                             'customreport': self._duplicate_custom_report,
-                             }
+        duplicate_methods = {
+            'tablereport': self._duplicate_table_report,
+            'singlevaluereport': self._duplicate_single_value_report,
+            'barchartreport': self._duplicate_bar_chart_report,
+            'linechartreport': self._duplicate_line_chart_report,
+            'piechartreport': self._duplicate_pie_chart_report,
+            'funnelchartreport': self._duplicate_funnel_chart_report,
+            'kanbanreport': self._duplicate_kanban_report,
+            'customreport': self._duplicate_custom_report,
+        }
         new_report = duplicate_methods[report.instance_type](report_id=report.id)
         return new_report