django-ledger 0.5.6.2__py3-none-any.whl → 0.5.6.4__py3-none-any.whl

django_ledger/models/entity.py

@@ -795,6 +795,10 @@ class EntityModelAbstract(MP_Node,
     def __str__(self):
         return f'EntityModel {self.slug}: {self.name}'
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._CLOSING_ENTRY_DATES: Optional[List[date]] = None
+
     # ## Logging ###
     def get_logger_name(self):
         return f'EntityModel {self.uuid}'
@@ -986,6 +990,21 @@ class EntityModelAbstract(MP_Node,
                 raise EntityModelValidationError(f'EntityModel {self.slug} does not have a default CoA')
         return self.default_coa
 
+    def set_default_coa(self, coa_model: Optional[Union[ChartOfAccountModel, str]], commit: bool = False):
+
+        # if str, will look up CoA Model by slug...
+        if isinstance(coa_model, str):
+            coa_model = self.chartofaccountmodel_set.get(slug=coa_model)
+        else:
+            self.validate_chart_of_accounts_for_entity(coa_model)
+
+        self.default_coa = coa_model
+        if commit:
+            self.save(update_fields=[
+                'default_coa',
+                'updated'
+            ])
+
     def create_chart_of_accounts(self,
                                  assign_as_default: bool = False,
                                  coa_name: Optional[str] = None,
@@ -1071,10 +1090,10 @@ class EntityModelAbstract(MP_Node,
         coa_has_accounts = coa_accounts_qs.not_coa_root().exists()
 
         if not coa_has_accounts or force:
-            root_accounts = coa_accounts_qs.is_coa_root()
+            root_account_qs = coa_accounts_qs.is_coa_root()
 
             root_maps = {
-                root_accounts.get(role__exact=k): [
+                root_account_qs.get(role__exact=k): [
                     AccountModel(
                         code=a['code'],
                         name=a['name'],
@@ -1096,12 +1115,14 @@ class EntityModelAbstract(MP_Node,
                         pass
 
                     account_model.clean()
-                    coa_model.create_account(account_model)
+                    coa_model.allocate_account(account_model, root_account_qs=root_account_qs)
 
         else:
             if not ignore_if_default_coa:
-                raise EntityModelValidationError(f'Entity {self.name} already has existing accounts. '
-                                                 'Use force=True to bypass this check')
+                raise EntityModelValidationError(
+                    f'Entity {self.name} already has existing accounts. '
+                    'Use force=True to bypass this check'
+                )
 
     # Model Validators....
     def validate_chart_of_accounts_for_entity(self,
@@ -1250,19 +1271,12 @@ class EntityModelAbstract(MP_Node,
         """
 
         if not coa_model:
-            account_model_qs = self.default_coa.accountmodel_set.all().select_related('coa_model', 'coa_model__entity')
+            account_model_qs = self.default_coa.accountmodel_set.all().select_related(
+                'coa_model', 'coa_model__entity').not_coa_root()
         else:
-            account_model_qs = AccountModel.objects.filter(
-                coa_model__entity__uuid__exact=self.uuid
-            ).select_related('coa_model', 'coa_model__entity')
-
-            if isinstance(coa_model, ChartOfAccountModel):
-                self.validate_chart_of_accounts_for_entity(coa_model=coa_model, raise_exception=True)
-                account_model_qs = coa_model.accountmodel_set.all()
-            if isinstance(coa_model, str):
-                account_model_qs = account_model_qs.filter(coa_model__slug__exact=coa_model)
-            elif isinstance(coa_model, UUID):
-                account_model_qs = account_model_qs.filter(coa_model__uuid__exact=coa_model)
+            self.validate_chart_of_accounts_for_entity(coa_model=coa_model)
+            account_model_qs = coa_model.accountmodel_set.select_related(
+                'coa_model', 'coa_model__entity').not_coa_root()
 
         if active:
             account_model_qs = account_model_qs.active()
@@ -1363,7 +1377,7 @@ class EntityModelAbstract(MP_Node,
                        role: str,
                        name: str,
                        balance_type: str,
-                       active: bool,
+                       active: bool = False,
                        coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
                        raise_exception: bool = True) -> AccountModel:
         """
@@ -1405,17 +1419,14 @@ class EntityModelAbstract(MP_Node,
         else:
             coa_model = self.default_coa
 
-        account_model = AccountModel(
+        return coa_model.create_account(
             code=code,
-            name=name,
             role=role,
-            active=active,
-            balance_type=balance_type
+            name=name,
+            balance_type=balance_type,
+            active=active
         )
 
-        account_model.clean()
-        return coa_model.create_account(account_model=account_model)
-
     def create_account_by_kwargs(self,
                                  account_model_kwargs: Dict,
                                  coa_model: Optional[Union[ChartOfAccountModel, UUID, str]] = None,
@@ -1453,9 +1464,29 @@ class EntityModelAbstract(MP_Node,
         else:
             coa_model = self.default_coa
 
-        account_model = AccountModel(**account_model_kwargs)
-        account_model.clean()
-        return coa_model, coa_model.create_account(account_model=account_model)
+        # account_model = AccountModel(**account_model_kwargs)
+        # account_model.clean()
+        return coa_model, coa_model.create_account(**account_model_kwargs)
+
+    # ### LEDGER MANAGEMENT ####
+    def get_ledgers(self, posted: bool = True):
+        return self.ledgermodel_set.filter(posted=posted)
+
+    # ### JOURNAL ENTRY MANAGEMENT ####
+    def get_journal_entries(self, ledger_model: LedgerModel, posted: bool = True):
+
+        if ledger_model:
+            self.validate_ledger_model_for_entity(ledger_model)
+            qs = ledger_model.journal_entries.all()
+            if posted:
+                return qs.posted()
+            return qs
+
+        JournalEntryModel = lazy_loader.get_journal_entry_model()
+        qs = JournalEntryModel.objects.for_entity(entity_slug=self)
+        if posted:
+            return qs.posted()
+        return qs
 
     # ### VENDOR MANAGEMENT ####
     def get_vendors(self, active: bool = True) -> VendorModelQuerySet:
@@ -2658,11 +2689,12 @@ class EntityModelAbstract(MP_Node,
 
         self.meta[self.META_KEY_CLOSING_ENTRY_DATES] = [d.isoformat() for d in date_list]
         if commit:
-            self.save(update_fields=[
-                'last_closing_date',
-                'updated',
-                'meta'
-            ])
+            self.save(
+                update_fields=[
+                    'last_closing_date',
+                    'updated',
+                    'meta'
+                ])
         return date_list
 
     def fetch_closing_entry_dates_meta(self, as_date: bool = True) -> List[date]:
@@ -2670,25 +2702,43 @@ class EntityModelAbstract(MP_Node,
             return list()
         date_list = self.meta[self.META_KEY_CLOSING_ENTRY_DATES]
         if as_date:
-            return [date.fromisoformat(dt) for dt in date_list]
+            if self._CLOSING_ENTRY_DATES is None:
+                self._CLOSING_ENTRY_DATES = [date.fromisoformat(dt) for dt in date_list]
+            return self._CLOSING_ENTRY_DATES
         return date_list
 
-    def get_closing_entry_for_date(self, io_date: date, inclusive: bool = True) -> Optional[date]:
+    def get_closing_entry_for_date(self, io_date: Union[date, datetime], inclusive: bool = True) -> Optional[date]:
         if io_date is None:
             return
         ce_date_list = self.fetch_closing_entry_dates_meta()
+
+        if not ce_date_list:
+            return
+
+        if isinstance(io_date, datetime):
+            io_date = io_date.date()
+
         ce_lookup = io_date - timedelta(days=1) if not inclusive else io_date
         if ce_lookup in ce_date_list:
             return ce_lookup
 
-    def get_nearest_next_closing_entry(self, io_date: date) -> Optional[date]:
+    def get_nearest_next_closing_entry(self, io_date: Union[date, datetime]) -> Optional[date]:
         if io_date is None:
             return
+
         ce_date_list = self.fetch_closing_entry_dates_meta()
         if not len(ce_date_list):
             return
+
+        if all([
+            isinstance(io_date, date),
+            isinstance(io_date, datetime),
+        ]):
+            io_date = io_date.date()
+
         if io_date > ce_date_list[0]:
             return ce_date_list[0]
+
         for f, p in zip_longest(ce_date_list, ce_date_list[1:]):
             if p and p <= io_date < f:
                 return p
@@ -2697,7 +2747,7 @@ class EntityModelAbstract(MP_Node,
                            closing_date: Optional[date] = None,
                            closing_entry_model=None,
                            force_update: bool = False,
-                           commit: bool = True):
+                           post_closing_entry: bool = True):
 
         if closing_entry_model and closing_date:
             raise EntityModelValidationError(
@@ -2709,13 +2759,18 @@ class EntityModelAbstract(MP_Node,
             )
 
         closing_entry_exists = False
+
         if closing_entry_model:
             closing_date = closing_entry_model.closing_date
             self.validate_closing_entry_model(closing_entry_model, closing_date=closing_date)
             closing_entry_exists = True
         else:
             try:
-                closing_entry_model = self.closingentrymodel_set.defer('markdown_notes').get(
+                closing_entry_model = self.closingentrymodel_set.select_related(
+                    'ledger_model',
+                    'ledger_model__entity'
+                ).defer(
+                    'markdown_notes').get(
                     closing_date__exact=closing_date
                 )
 
@@ -2724,29 +2779,34 @@ class EntityModelAbstract(MP_Node,
                 pass
 
         if force_update or not closing_entry_exists or closing_entry_model:
-            ce_model, ce_txs = self.create_closing_entry_for_date(
+            closing_entry_model, ce_txs = self.create_closing_entry_for_date(
                 closing_date=closing_date,
                 closing_entry_model=closing_entry_model,
-                closing_entry_exists=closing_entry_exists
+                closing_entry_exists=closing_entry_exists,
             )
 
-            if commit:
-                self.save(update_fields=[
-                    'last_closing_date',
-                    'meta',
-                    'updated'
-                ])
-            return ce_model, ce_txs
+            if post_closing_entry:
+                closing_entry_model.mark_as_posted(commit=True)
+                self.save_closing_entry_dates_meta(commit=True)
+
+            return closing_entry_model, ce_txs
         raise EntityModelValidationError(message=f'Closing Entry for Period {closing_date} already exists.')
 
-    def close_books_for_month(self, year: int, month: int, force_update: bool = False, commit: bool = True):
+    def close_books_for_month(self, year: int, month: int, force_update: bool = False, post_closing_entry: bool = True):
         _, day = monthrange(year, month)
         closing_dt = date(year, month, day)
-        return self.close_entity_books(closing_date=closing_dt, force_update=force_update, commit=commit)
+        return self.close_entity_books(
+            closing_date=closing_dt,
+            force_update=force_update,
+            post_closing_entry=post_closing_entry,
+            closing_entry_model=None
+        )
 
-    def close_books_for_fiscal_year(self, fiscal_year: int, force_update: bool = False, commit: bool = True):
+    def close_books_for_fiscal_year(self, fiscal_year: int, force_update: bool = False,
+                                    post_closing_entry: bool = True):
         closing_dt = self.get_fy_end(year=fiscal_year)
-        return self.close_entity_books(closing_date=closing_dt, force_update=force_update, commit=commit)
+        return self.close_entity_books(closing_date=closing_dt, force_update=force_update,
+                                       post_closing_entry=post_closing_entry)
 
     # ### RANDOM DATA GENERATION ####
 
@@ -2909,6 +2969,14 @@ class EntityModelAbstract(MP_Node,
                            'entity_slug': self.slug
                        })
 
+    def get_coa_list_url(self) -> str:
+        return reverse(
+            viewname='django_ledger:coa-list',
+            kwargs={
+                'entity_slug': self.slug
+            }
+        )
+
     def get_accounts_url(self) -> str:
         """
         The EntityModel Code of Accounts llist import URL.

django_ledger/models/invoice.py

@@ -441,13 +441,14 @@ class InvoiceModelAbstract(
             ledger_model.clean_fields()
             self.ledger = ledger_model
 
+            if commit_ledger or commit:
+                self.ledger.save()
+
             if self.can_generate_invoice_number():
                 self.generate_invoice_number(commit=commit)
 
             self.clean()
 
-            if commit_ledger or commit:
-                self.ledger.save()
 
             if commit:
                 self.save()

django_ledger/models/journal_entry.py

@@ -440,7 +440,7 @@ class JournalEntryModelAbstract(CreateUpdateMixIn):
             not self.is_posted(),
         ])
 
-    def can_edit_timestamp(self) -> bool:
+    def can_edit(self) -> bool:
         return not self.is_locked()
 
     def is_posted(self):
@@ -1138,8 +1138,12 @@ class JournalEntryModelAbstract(CreateUpdateMixIn):
 
         if not self.timestamp:
             self.timestamp = get_localtime()
-        elif self.timestamp and self.timestamp > get_localtime():
-            raise JournalEntryValidationError(message='Cannot create JE Models with timestamp in the future.')
+        elif all([
+            self.timestamp,
+            self.timestamp > get_localtime(),
+            self.is_posted()
+        ]):
+            raise JournalEntryValidationError(message='Cannot Post JE Models with timestamp in the future.')
 
         self.generate_je_number(commit=True)
         if verify:
@@ -1148,7 +1152,7 @@ class JournalEntryModelAbstract(CreateUpdateMixIn):
         return TransactionModel.objects.none(), self.is_verified()
 
     def get_delete_message(self) -> str:
-        return _(f'Are you sure you want to delete JournalEntry Model {self.description} on Ledger {self.ledger.name}?')
+        return _(f'Are you sure you want to delete JournalEntry Model {self.je_number} on Ledger {self.ledger.name}?')
 
     def delete(self, **kwargs):
         if not self.can_delete():

django_ledger/models/ledger.py

@@ -106,7 +106,7 @@ class LedgerModelQuerySet(models.QuerySet):
 
     def current(self):
         return self.filter(
-            Q(earliest_timestamp__gt=F('entity__last_closing_date'))
+            Q(earliest_timestamp__date__gt=F('entity__last_closing_date'))
             | Q(earliest_timestamp__isnull=True)
         )
 
@@ -392,6 +392,28 @@ class LedgerModelAbstract(CreateUpdateMixIn, IOMixIn):
             self.is_posted()
         ])
 
+    def can_hide(self) -> bool:
+        """
+        Determines if the LedgerModel can be hidden.
+
+        Returns
+        -------
+        bool
+            True if can be hidden, else False.
+        """
+        return self.hidden is False
+
+    def can_unhide(self) -> bool:
+        """
+        Determines if the LedgerModel can be un-hidden.
+
+        Returns
+        -------
+        bool
+            True if can be un-hidden, else False.
+        """
+        return self.hidden is True
+
     def can_delete(self) -> bool:
         if all([
             not self.is_locked(),
@@ -448,7 +470,7 @@ class LedgerModelAbstract(CreateUpdateMixIn, IOMixIn):
         raise_exception:bool
             Raises LedgerModelValidationError if un-posting not allowed.
         """
-        if self.can_unpost():
+        if not self.can_unpost():
             if raise_exception:
                 raise LedgerModelValidationError(
                     message=_(f'Ledger {self.uuid} cannot be unposted.')
@@ -511,22 +533,52 @@ class LedgerModelAbstract(CreateUpdateMixIn, IOMixIn):
                     'updated'
                 ])
 
+    def hide(self, commit: bool = False, raise_exception: bool = True, **kwargs):
+        if not self.can_hide():
+            if raise_exception:
+                raise LedgerModelValidationError(
+                    message=_(f'Ledger {self.name} cannot be hidden. UUID: {self.uuid}')
+                )
+            return
+        self.hidden = True
+        if commit:
+            self.save(update_fields=[
+                'hidden',
+                'updated'
+            ])
+
+    def unhide(self, commit: bool = False, raise_exception: bool = True, **kwargs):
+        if not self.can_unhide():
+            if raise_exception:
+                raise LedgerModelValidationError(
+                    message=_(f'Ledger {self.name} cannot be un-hidden. UUID: {self.uuid}')
+                )
+            return
+        self.hidden = False
+        if commit:
+            self.save(update_fields=[
+                'hidden',
+                'updated'
+            ])
+
     def delete(self, **kwargs):
         if not self.can_delete():
             raise LedgerModelValidationError(
                 message=_(f'LedgerModel {self.name} cannot be deleted because posted is {self.is_posted()} '
                           f'and locked is {self.is_locked()}')
             )
-        earliest_je_timestamp = self.journal_entries.posted().order_by('-timestamp').values('timestamp').first()
-        if earliest_je_timestamp is not None:
-            earliest_date = earliest_je_timestamp['timestamp'].date()
-            if earliest_date <= self.entity.last_closing_date:
-                raise LedgerModelValidationError(
-                    message=_(
-                        f'Journal Entries with date {earliest_date} cannot be deleted because of lastest closing '
-                        f'entry on {self.get_entity_last_closing_date()}')
-                )
 
+        # checks if ledger model has journal entries in a closed period...
+        if self.entity.has_closing_entry():
+            earliest_je_timestamp = self.journal_entries.posted().order_by('-timestamp').values('timestamp').first()
+            if earliest_je_timestamp is not None:
+                earliest_date = earliest_je_timestamp['timestamp'].date()
+                if earliest_date <= self.entity.last_closing_date:
+                    raise LedgerModelValidationError(
+                        message=_(
+                            f'Journal Entries with date {earliest_date} cannot be deleted because of latest closing '
+                            f'entry on {self.get_entity_last_closing_date()}')
+                    )
         return super().delete(**kwargs)
 
     def get_entity_name(self) -> str:

django_ledger/models/mixins.py

@@ -26,7 +26,7 @@ from django.utils.encoding import force_str
 from django.utils.translation import gettext_lazy as _
 from markdown import markdown
 
-from django_ledger.io.io_core import validate_io_date, check_tx_balance, get_localtime, get_localdate
+from django_ledger.io.io_core import validate_io_timestamp, check_tx_balance, get_localtime, get_localdate
 from django_ledger.models.utils import lazy_loader
 
 logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
@@ -748,7 +748,7 @@ class AccrualMixIn(models.Model):
                 unit_uuids = list(set(k[1] for k in idx_keys))
 
                 if je_timestamp:
-                    je_timestamp = validate_io_date(dt=je_timestamp)
+                    je_timestamp = validate_io_timestamp(dt=je_timestamp)
 
                 now_timestamp = get_localtime() if not je_timestamp else je_timestamp
                 je_list = {

django_ledger/models/transactions.py

@@ -24,9 +24,10 @@ from django.core.exceptions import ValidationError
 from django.core.validators import MinValueValidator
 from django.db import models
 from django.db.models import Q, QuerySet
+from django.db.models.signals import pre_save
 from django.utils.translation import gettext_lazy as _
 
-from django_ledger.io.io_core import validate_io_date
+from django_ledger.io.io_core import validate_io_timestamp
 from django_ledger.models.accounts import AccountModel
 from django_ledger.models.bill import BillModel
 from django_ledger.models.entity import EntityModel
@@ -156,7 +157,7 @@ class TransactionModelQuerySet(QuerySet):
         """
 
         if isinstance(to_date, str):
-            to_date = validate_io_date(to_date)
+            to_date = validate_io_timestamp(to_date)
 
         if isinstance(to_date, date):
             return self.filter(journal_entry__timestamp__date__lte=to_date)
@@ -180,7 +181,7 @@ class TransactionModelQuerySet(QuerySet):
             Returns a TransactionModelQuerySet with applied filters.
         """
         if isinstance(from_date, str):
-            from_date = validate_io_date(from_date)
+            from_date = validate_io_timestamp(from_date)
 
         if isinstance(from_date, date):
             return self.filter(journal_entry__timestamp__date__gte=from_date)
@@ -219,7 +220,7 @@ class TransactionModelAdmin(models.Manager):
         TransactionModelQuerySet
             Returns a TransactionModelQuerySet with applied filters.
         """
-        qs = self.get_queryset()
+        qs = self.get_queryset().select_related('journal_entry')
         if user_model.is_superuser:
             return qs
         return qs.filter(
@@ -284,10 +285,9 @@ class TransactionModelAdmin(models.Manager):
             Returns a TransactionModelQuerySet with applied filters.
         """
         qs = self.for_entity(user_model=user_model, entity_slug=entity_slug)
-        if isinstance(ledger_model, LedgerModel):
-            return qs.filter(journal_entry__ledger=ledger_model)
-        elif isinstance(ledger_model, str) or isinstance(ledger_model, UUID):
+        if isinstance(ledger_model, UUID):
             return qs.filter(journal_entry__ledger__uuid__exact=ledger_model)
+        return qs.filter(journal_entry__ledger=ledger_model)
 
     def for_unit(self,
                  entity_slug: Union[EntityModel, str],
@@ -410,8 +410,8 @@ class TransactionModelAdmin(models.Manager):
 
 class TransactionModelAbstract(CreateUpdateMixIn):
     """
-    This is the main abstract class which the BillModel database will inherit from.
-    The BillModel inherits functionality from the following MixIns:
+    This is the main abstract class which the TransactionModel database will inherit from.
+    The TransactionModel inherits functionality from the following MixIns:
 
         1. :func:`CreateUpdateMixIn <django_ledger.models.mixins.CreateUpdateMixIn>`
 
@@ -479,7 +479,6 @@ class TransactionModelAbstract(CreateUpdateMixIn):
         ]
 
     def __str__(self):
-        # pylint: disable=no-member
         return '{x1}-{x2}/{x5}: {x3}/{x4}'.format(x1=self.account.code,
                                                   x2=self.account.name,
                                                   x3=self.amount,
@@ -487,7 +486,7 @@ class TransactionModelAbstract(CreateUpdateMixIn):
                                                   x5=self.account.balance_type)
 
     def clean(self):
-        if self.account.is_root_account():
+        if self.account_id and self.account.is_root_account():
             raise TransactionModelValidationError(
                 message=_('Cannot transact on root accounts')
             )
@@ -497,3 +496,13 @@ class TransactionModel(TransactionModelAbstract):
     """
     Base Transaction Model From Abstract.
     """
+
+
+def transactionmodel_presave(instance: TransactionModel, **kwargs):
+    if instance.journal_entry_id and instance.journal_entry.is_locked():
+        raise TransactionModelValidationError(
+            message=_('Cannot modify transactions on locked journal entries')
+        )
+
+
+pre_save.connect(transactionmodel_presave, sender=TransactionModel)

django_ledger/report/balance_sheet.py

@@ -233,7 +233,7 @@ class BalanceSheetReport(BaseReportSupport):
         if to_dt:
             to_dt = to_dt.strftime(dt_strfmt if dt_strfmt else self.IO_DIGEST.get_strftime_format())
         else:
-            to_dt = self.IO_DIGEST.get_to_date(fmt=dt_strfmt, as_str=True)
+            to_dt = self.IO_DIGEST.get_to_datetime(fmt=dt_strfmt, as_str=True)
         f_name = f'{self.get_report_title()}_BalanceSheetStatement_{to_dt}.pdf'
         return f_name
 

django_ledger/report/cash_flow_statement.py

@@ -54,7 +54,7 @@ class CashFlowStatementReport(BaseReportSupport):
     def print_starting_net_income(self):
         net_income = self.IO_DIGEST.IO_DATA['cash_flow_statement']['operating']['GROUP_CFS_NET_INCOME']['balance']
         self.print_section_title(
-            title=f'Net Income as of {self.IO_DIGEST.get_from_date(as_str=True)}',
+            title=f'Net Income as of {self.IO_DIGEST.get_from_datetime(as_str=True)}',
             style='B',
             w=170)
         self.print_amount(amt=net_income, zoom=2)
@@ -197,8 +197,8 @@ class CashFlowStatementReport(BaseReportSupport):
 
         self.set_x(50)
         self.print_section_title(
-            title=f'Net Cash Flow from {self.IO_DIGEST.get_from_date(as_str=True)} '
-                  f'through {self.IO_DIGEST.get_to_date(as_str=True)}',
+            title=f'Net Cash Flow from {self.IO_DIGEST.get_from_datetime(as_str=True)} '
+                  f'through {self.IO_DIGEST.get_to_datetime(as_str=True)}',
             style='',
             zoom=0,
             align='R',
@@ -216,12 +216,12 @@ class CashFlowStatementReport(BaseReportSupport):
         if from_dt:
             from_dt = from_dt.strftime(dt_strfmt if dt_strfmt else self.IO_DIGEST.get_strftime_format())
         else:
-            from_dt = self.IO_DIGEST.get_from_date(fmt=dt_strfmt, as_str=True)
+            from_dt = self.IO_DIGEST.get_from_datetime(fmt=dt_strfmt, as_str=True)
 
         if to_dt:
             to_dt = to_dt.strftime(dt_strfmt if dt_strfmt else self.IO_DIGEST.get_strftime_format())
         else:
-            to_dt = self.IO_DIGEST.get_to_date(fmt=dt_strfmt, as_str=True)
+            to_dt = self.IO_DIGEST.get_to_datetime(fmt=dt_strfmt, as_str=True)
         f_name = f'{self.get_report_title()}_CashFlowStatement_{from_dt}_{to_dt}.pdf'
         return f_name
 

django_ledger/report/core.py

@@ -105,8 +105,8 @@ class BaseReportSupport(*load_support()):
             style='I'
         )
 
-        from_date = self.IO_DIGEST.get_from_date(as_str=True)
-        to_date = self.IO_DIGEST.get_to_date(as_str=True)
+        from_date = self.IO_DIGEST.get_from_datetime(as_str=True)
+        to_date = self.IO_DIGEST.get_to_datetime(as_str=True)
 
         if from_date and to_date:
             period = f'From {from_date} through {to_date}'

django_ledger/report/income_statement.py

@@ -297,12 +297,12 @@ class IncomeStatementReport(BaseReportSupport):
         if from_dt:
             from_dt = from_dt.strftime(dt_strfmt if dt_strfmt else self.IO_DIGEST.get_strftime_format())
         else:
-            from_dt = self.IO_DIGEST.get_from_date(fmt=dt_strfmt, as_str=True)
+            from_dt = self.IO_DIGEST.get_from_datetime(fmt=dt_strfmt, as_str=True)
 
         if to_dt:
             to_dt = to_dt.strftime(dt_strfmt if dt_strfmt else self.IO_DIGEST.get_strftime_format())
         else:
-            to_dt = self.IO_DIGEST.get_to_date(fmt=dt_strfmt, as_str=True)
+            to_dt = self.IO_DIGEST.get_to_datetime(fmt=dt_strfmt, as_str=True)
 
         f_name = f'{self.get_report_title()}_IncomeStatement_{from_dt}_{to_dt}.pdf'
         return f_name