django-spire 0.24.2__py3-none-any.whl → 0.25.0__py3-none-any.whl

django_spire/consts.py

@@ -1,4 +1,4 @@
-__VERSION__ = '0.24.2'
+__VERSION__ = '0.25.0'
 
 MAINTENANCE_MODE_SETTINGS_NAME = 'MAINTENANCE_MODE'
 

django_spire/contrib/admin/admin.py

@@ -0,0 +1,140 @@
+from typing import Type, Tuple
+
+from django.contrib import admin
+from django.contrib.contenttypes.fields import GenericRelation
+from django.db import models
+
+
+class SpireModelAdmin(admin.ModelAdmin):
+    model_class: Type[models.Model] = None
+
+    max_search_fields: int = 5
+    max_list_display: int = 10
+
+    trailing_fields = ('is_active', 'is_deleted')
+
+    auto_readonly_fields: Tuple[str] = (
+        'created_datetime', 'is_active', 'is_deleted',
+    )
+
+    filter_field_types = (
+        models.BooleanField,
+        models.DateField,
+        models.DateTimeField,
+        models.ForeignKey,
+        models.CharField,
+    )
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        cls.model_fields = cls.model_class._meta.get_fields()
+
+        if cls.model_class is None:
+            raise ValueError(f'{cls.__name__} must define model_class')
+
+        if cls.model_class is not None:
+            cls._configure_if_needed()
+
+    @classmethod
+    def _configure_if_needed(cls):
+        if not hasattr(cls, '_spire_configured'):
+            cls._configure_list_display()
+            cls._configure_list_filter()
+            cls._configure_search_fields()
+            cls._configure_readonly_fields()
+            cls._configure_ordering()
+            cls._configure_list_per_page()
+            cls._spire_configured = True
+
+    @classmethod
+    def _configure_list_display(cls):
+        if cls.list_display != ('__str__',):
+            return
+
+        fields = []
+
+        for field in cls.model_fields:
+            if not isinstance(
+                field,
+                (models.ManyToManyField, models.ManyToOneRel, GenericRelation),
+            ):
+                if hasattr(field, 'name') and not field.name.startswith('_'):
+                    if field.name not in cls.trailing_fields:
+                        fields.append(field.name)
+
+        for trailing_field in cls.trailing_fields:
+            if trailing_field in [field.name for field in cls.model_fields]:
+                fields.append(trailing_field)
+
+        cls.list_display = tuple(fields[:cls.max_list_display])
+
+    @classmethod
+    def _configure_list_filter(cls):
+        if hasattr(cls, 'list_filter') and cls.list_filter:
+            return
+
+        filters = []
+
+        for field in cls.model_fields:
+            if not isinstance(field, (models.ManyToManyField, models.ManyToOneRel)):
+                if isinstance(field, models.BooleanField):
+                    filters.append(field.name)
+
+                elif isinstance(field, (models.DateField, models.DateTimeField)):
+                    filters.append(field.name)
+
+                elif isinstance(field, models.ForeignKey):
+                    filters.append(field.name)
+
+                elif (
+                    isinstance(field, models.CharField)
+                    and hasattr(field, 'choices')
+                    and field.choices
+                ):
+                    filters.append(field.name)
+
+        cls.list_filter = tuple(filters)
+
+    @classmethod
+    def _configure_search_fields(cls):
+        if hasattr(cls, 'search_fields') and cls.search_fields:
+            return
+
+        search_fields = []
+
+        for field in cls.model_fields:
+            if isinstance(field, (models.CharField, models.TextField)):
+                if not field.name.startswith('_'):
+                    search_fields.append(field.name)
+
+                    if len(search_fields) >= cls.max_search_fields:
+                        break
+
+        cls.search_fields = tuple(search_fields)
+
+    @classmethod
+    def _configure_readonly_fields(cls):
+        if hasattr(cls, 'readonly_fields') and cls.readonly_fields:
+            return
+
+        readonly = []
+
+        for field in cls.model_fields:
+            if hasattr(field, 'name') and field.name in cls.auto_readonly_fields:
+                readonly.append(field.name)
+
+        cls.readonly_fields = tuple(readonly)
+
+    @classmethod
+    def _configure_ordering(cls):
+        if hasattr(cls, 'ordering') and cls.ordering:
+            return
+
+        cls.ordering = ('-id',)
+        return
+
+    @classmethod
+    def _configure_list_per_page(cls):
+        if not hasattr(cls, 'list_per_page') or cls.list_per_page == 100:
+            cls.list_per_page = 25

django_spire/contrib/choices/choices.py

@@ -0,0 +1,9 @@
+import json
+
+from django.db.models import TextChoices
+
+
+class SpireTextChoices(TextChoices):
+    @classmethod
+    def to_glue_choices(cls) -> str:
+        return json.dumps(cls.choices)

django_spire/contrib/choices/tests/test_choices.py

@@ -0,0 +1,62 @@
+import json
+
+from django_spire.contrib.choices.choices import SpireTextChoices
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class TestSpireTextChoices(BaseTestCase):
+    def setUp(self):
+        class StatusChoices(SpireTextChoices):
+            DRAFT = ('dra', 'Draft')
+            PUBLISHED = ('pub', 'Published')
+            ARCHIVED = ('arc', 'Archived')
+
+
+        self.StatusChoices = StatusChoices
+
+    def test_inherits_from_text_choices(self):
+        assert issubclass(self.StatusChoices, SpireTextChoices), self.StatusChoices.__class__
+
+    def test_choices_property_exists(self):
+        assert hasattr(self.StatusChoices, 'choices'), self.StatusChoices.dir()
+        assert self.StatusChoices.choices is not None, self.StatusChoices.choices
+
+    def test_to_glue_choices_returns_string(self):
+        result = self.StatusChoices.to_glue_choices()
+        assert isinstance(result, str), type(result)
+
+    def test_to_glue_choices_returns_valid_json(self):
+        result = self.StatusChoices.to_glue_choices()
+        try:
+            parsed = json.loads(result)
+        except json.JSONDecodeError:
+            assert 'to_glue_choices did not return valid JSON'
+
+    def test_to_glue_choices_correct_structure(self):
+        result = self.StatusChoices.to_glue_choices()
+        parsed = json.loads(result)
+
+        assert isinstance(parsed, list), type(parsed)
+        assert len(parsed) == 3
+
+        assert parsed[0] == ['dra', 'Draft']
+        assert parsed[1] == ['pub', 'Published']
+        assert parsed[2] == ['arc', 'Archived']
+
+    def test_empty_choices(self):
+        class EmptyChoices(SpireTextChoices):
+            pass
+
+
+        result = EmptyChoices.to_glue_choices()
+        parsed = json.loads(result)
+        assert parsed == []
+
+    def test_single_choice(self):
+        class SingleChoice(SpireTextChoices):
+            ONLY = 'only', 'Only Option'
+
+
+        result = SingleChoice.to_glue_choices()
+        parsed = json.loads(result)
+        assert parsed == [['only', 'Only Option']]

django_spire/core/static/django_spire/css/app-printing.css

@@ -1,4 +1,29 @@
+.fs-print-1 {
+    font-size: 1.0rem !important;
+}
+
+.fs-print-2 {
+    font-size: 0.90rem !important;
+}
+
+.fs-print-3 {
+    font-size: 0.70rem !important;
+}
+
 @media print {
+
+    .fs-print-1 {
+        font-size: .80rem !important;
+    }
+
+    .fs-print-2 {
+        font-size: .70rem !important;
+    }
+
+    .fs-print-3 {
+        font-size: .55rem !important;
+    }
+
     .hide-on-print {
         display: none !important;
     }

django_spire/core/templates/django_spire/dropdown/ellipsis_modal_dropdown.html

@@ -12,14 +12,26 @@
 
 {% block dropdown_content %}
     {% if view_url %}
-        {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=view_url link_text='View' %}
+        {% if redirect_view_url %}
+            {% include 'django_spire/dropdown/element/dropdown_link_element.html' with view_url=view_url link_text='View' %}
+        {% else %}
+            {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=view_url link_text='View' %}
+        {% endif %}
     {% endif %}
 
     {% if edit_url %}
-        {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=edit_url link_text='Edit' %}
+        {% if redirect_edit_url %}
+            {% include 'django_spire/dropdown/element/dropdown_link_element.html' with view_url=edit_url link_text='Edit' %}
+        {% else %}
+            {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=edit_url link_text='Edit' %}
+        {% endif %}
     {% endif %}
 
     {% if delete_url %}
-        {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=delete_url link_text='Delete' link_css='text-app-danger' %}
+        {% if redirect_delete_url %}
+            {% include 'django_spire/dropdown/element/dropdown_link_element.html' with view_url=delete_url link_text='Delete' link_css='text-app-danger' %}
+        {% else %}
+            {% include 'django_spire/dropdown/element/ellipsis_dropdown_modal_link_element.html' with view_url=delete_url link_text='Delete' link_css='text-app-danger' %}
+        {% endif %}
     {% endif %}
 {% endblock %}

django_spire/core/templates/django_spire/element/attribute_element.html

@@ -32,6 +32,13 @@
             <span x-text="{{ x_attribute_value_postfix }}"></span>
         {% endif %}
     {% endif %}
+
+    {% if show_copy_button %}
+        {% block copy_button %}
+            {% firstof attribute_value or x_attribute_value as value %}
+            {% include 'django_spire/element/copy_to_clipboard_element.html' with value=value copy_func=copy_func %}
+        {% endblock %}
+    {% endif %}
 {% endblock %}
 
 {% if attribute_href or x_attribute_href %}

django_spire/core/templates/django_spire/element/copy_to_clipboard_element.html

@@ -0,0 +1,31 @@
+<span
+    x-data="{
+        clicked: false,
+        copy_value_to_clipboard() {
+            let text = '{{ value }}';
+
+            {% if copy_func %}
+            text = {{ copy_func }}(text);
+            {% endif %}
+
+            navigator.clipboard.writeText(text);
+            this.clicked = true;
+            setTimeout(() => {
+                this.clicked = false;
+            }, 1000);
+        }
+    }"
+>
+    <i
+        @click="copy_value_to_clipboard()"
+        class="bi bi-copy text-app-primary cursor-pointer"
+    ></i>
+    <span
+        class="text-app-primary"
+        x-show="clicked"
+        x-transition:enter.duration.500ms
+        x-transition:leave.duration.500ms
+    >
+        Copied!
+    </span>
+</span>

django_spire/metric/report/__init__.py

@@ -0,0 +1,7 @@
+from django_spire.metric.report.report import BaseReport
+from django_spire.metric.report.registry import ReportRegistry
+
+__all__ = [
+    'BaseReport',
+    'ReportRegistry',
+]

django_spire/metric/report/helper.py

@@ -0,0 +1,92 @@
+import calendar
+from datetime import datetime, timedelta
+
+from django.utils.timezone import now
+
+
+class Helper:
+    @property
+    def thirty_days_ago(self) -> datetime:
+        return self.today - timedelta(days=30)
+
+    @property
+    def sixty_days_ago(self) -> datetime:
+        return self.today - timedelta(days=60)
+
+    @property
+    def ninety_days_ago(self) -> datetime:
+        return self.today - timedelta(days=90)
+
+    @property
+    def today(self) -> datetime:
+        return now()
+
+    @property
+    def tomorrow(self) -> datetime:
+        return self.today + timedelta(days=1)
+
+    @property
+    def yesterday(self) -> datetime:
+        return self.today - timedelta(days=1)
+
+    @property
+    def start_of_current_week(self) -> datetime:
+        return self.today - timedelta(days=self.today.weekday())
+
+    @property
+    def end_of_current_week(self) -> datetime:
+        return self.start_of_week + timedelta(days=6)
+
+    @property
+    def start_of_last_week(self) -> datetime:
+        return self.start_of_week - timedelta(days=6)
+
+    @property
+    def end_of_last_week(self) -> datetime:
+        return self.end_of_week - timedelta(days=6)
+
+    @property
+    def start_of_current_month(self) -> datetime:
+        return self.today.replace(day=1)
+
+    @property
+    def end_of_current_month(self) -> datetime:
+        _, last_day = calendar.monthrange(self.today.year, self.today.month)
+        return self.today.replace(day=last_day)
+
+    @property
+    def start_of_last_month(self) -> datetime:
+        return self._add_months(self.today, -1).replace(day=1)
+
+    @property
+    def end_of_last_month(self) -> datetime:
+        last_month = self._add_months(self.today, -1)
+        _, last_day = calendar.monthrange(last_month.year, last_month.month)
+
+        return last_month.replace(day=last_day)
+
+    @property
+    def start_of_current_year(self) -> datetime:
+        return self.today.replace(month=1, day=1)
+
+    @property
+    def end_of_current_year(self) -> datetime:
+        return self.today.replace(month=12, day=31)
+
+    @property
+    def start_of_last_year(self) -> datetime:
+        return self.today.replace(year=self.today.year - 1, month=1, day=1)
+
+    @property
+    def end_of_last_year(self) -> datetime:
+        return self.today.replace(year=self.today.year - 1, month=12, day=31)
+
+    @staticmethod
+    def _add_months(datetime_, months):
+        month = datetime_.month - 1 + months
+        year = datetime_.year + month // 12
+        month = month % 12 + 1
+
+        day = min(datetime_.day, calendar.monthrange(year, month)[1])
+
+        return datetime_.replace(year=year, month=month, day=day)

django_spire/metric/report/report.py

@@ -5,6 +5,7 @@ from dataclasses import field
 from typing import Literal, Callable, Any
 
 from django_spire.metric.report.enums import ColumnType
+from django_spire.metric.report.helper import Helper
 from django_spire.metric.report.tools import get_text_alignment_css_class
 
 ColumnLiteralType = Literal['text', 'choice', 'number', 'dollar', 'percent']
@@ -31,27 +32,28 @@ class ReportCell:
     def css_class(self) -> str:
         return get_text_alignment_css_class(self.type)
 
-    def cell_value_verbose(self, value):
-        if self.type == ColumnType.DOLLAR:
+    @staticmethod
+    def cell_value_verbose(value, cell_type):
+        if cell_type == ColumnType.DOLLAR:
             return f"${float(value):,.2f}"
-        elif self.type == ColumnType.NUMBER:
+        elif cell_type == ColumnType.NUMBER:
             return f"{float(value):,.0f}"
-        elif self.type == ColumnType.PERCENT:
+        elif cell_type == ColumnType.PERCENT:
             return f"{float(value):.1f}%"
-        elif self.type == ColumnType.DECIMAL_1:
+        elif cell_type == ColumnType.DECIMAL_1:
             return f"{float(value):.1f}"
-        elif self.type == ColumnType.DECIMAL_2:
+        elif cell_type == ColumnType.DECIMAL_2:
             return f"{float(value):.2f}"
-        elif self.type == ColumnType.DECIMAL_3:
+        elif cell_type == ColumnType.DECIMAL_3:
             return f"{float(value):.3f}"
 
         return str(value)
 
     def value_verbose(self):
-        return self.cell_value_verbose(self.value)
+        return self.cell_value_verbose(self.value, self.type)
 
     def sub_value_verbose(self):
-        return self.cell_value_verbose(self.sub_value)
+        return self.cell_value_verbose(self.sub_value, self.sub_type)
 
 
 @dataclass
@@ -61,6 +63,8 @@ class ReportRow:
     page_break: bool = False
     span_all_columns: bool = False
     table_break: bool = False
+    border_top: bool = False
+    border_bottom: bool = False
 
 
 class BaseReport(ABC):
@@ -68,6 +72,7 @@ class BaseReport(ABC):
     description: str | None = None
     is_financially_accurate: bool = False
     ColumnType: type[ColumnType] = ColumnType
+    helper: Helper = Helper()
 
     def __init__(self):
         if not self.title:
@@ -97,8 +102,15 @@ class BaseReport(ABC):
             choices_method = getattr(self, f'{name}_choices', None)
 
             if choices_method and isinstance(choices_method, Callable):
-                arguments[name]['choices'] = choices_method()
-                arguments[name]['annotation'] = 'select'
+                choices = tuple(choices_method())
+
+                self.validate_choices(tuple(choices))
+
+                arguments[name]['choices'] = choices
+                if param.annotation.__name__ == 'list':
+                    arguments[name]['annotation'] = 'multi_select'
+                else:
+                    arguments[name]['annotation'] = 'select'
             else:
                 arguments[name]['annotation'] = param.annotation.__name__
 
@@ -108,10 +120,21 @@ class BaseReport(ABC):
     def run(self, **kwargs: Any):
         raise NotImplementedError
 
-    def add_blank_row(self):
+    def add_blank_row(
+            self,
+            text: str = '',
+            page_break: bool = False,
+            border_top: bool = False,
+            border_bottom: bool = False
+    ):
         self.add_row(
-            cell_values=[' '],
+            cell_values=[
+                text
+            ],
             span_all_columns=True,
+            page_break=page_break,
+            border_top=border_top,
+            border_bottom=border_bottom,
         )
 
     def add_column(
@@ -129,24 +152,30 @@ class BaseReport(ABC):
     def add_divider_row(
             self,
             title: str,
+            description: str | None = None,
             page_break: bool = False,
+            border_bottom: bool = True,
     ):
         self.add_row(
             cell_values=[title],
+            cell_sub_values=[description] if description else None,
             bold=True,
             page_break=page_break,
             span_all_columns=True,
+            border_bottom=border_bottom,
         )
 
     def add_footer_row(
             self,
             cell_values: list[Any],
             cell_sub_values: list[Any] | None = None,
+            border_top: bool = True,
     ):
         self.add_row(
             cell_values=cell_values,
             cell_sub_values=cell_sub_values,
             bold=True,
+            border_top=border_top,
         )
 
     def add_row(
@@ -157,6 +186,8 @@ class BaseReport(ABC):
             page_break: bool = False,
             span_all_columns: bool = False,
             table_break: bool = False,
+            border_top: bool = False,
+            border_bottom: bool = False,
     ):
         if span_all_columns or table_break:
             if len(cell_values) > 1:
@@ -183,5 +214,40 @@ class BaseReport(ABC):
                 page_break=page_break,
                 span_all_columns=span_all_columns,
                 table_break=table_break,
+                border_top=border_top,
+                border_bottom=border_bottom,
             )
         )
+
+    @staticmethod
+    def validate_choices(choices: tuple):
+        if not isinstance(choices, tuple):
+            raise TypeError(f'choices must be a tuple not {type(choices)}')
+        if not all(isinstance(item, tuple) and len(item) == 2 for item in choices):
+            raise ValueError('choices must contain tuples of length 2')
+
+    def to_markdown(self) -> str:
+        markdown = ''
+
+        for column in self.columns:
+            markdown += f'| {column.title} '
+
+        markdown += '|\n'
+
+        for column in self.columns:
+            markdown += '| ' + '-' * len(column.title) + ' '
+
+        markdown += '|\n'
+
+        for row in self.rows:
+            if row.span_all_columns:
+                markdown += f'| {row.cells[0].value}' + '|' * len(self.columns) + '\n'
+                continue
+
+            else:
+                for cell in row.cells:
+                    markdown += f'| {cell.value_verbose()} '
+
+            markdown += '|\n'
+
+        return markdown