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

django_ledger/models/closing_entry.py

@@ -95,14 +95,24 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
         return make_aware(datetime.combine(self.closing_date, time.max))
 
     def migrate(self):
-        ce_txs = self.closingentrytransactionmodel_set.all().order_by(
+        ce_txs = self.closingentrytransactionmodel_set.all().select_related(
+            'account_model',
+            'unit_model'
+        ).order_by(
             'tx_type',
             'account_model',
             'unit_model',
         )
+
+        # evaluate the QS...
+        ce_txs = list(ce_txs)
+
+        # grouping by DEBIT/CREDIT
         ce_txs_gb = groupby(ce_txs, key=lambda k: k.tx_type)
-        ce_txs_gb = {k: list(l) for k, l in ce_txs_gb}
-        ce_txs_sum = {k: sum(v.balance for v in l) for k, l in ce_txs_gb.items()}
+
+        # adding DEBITS and CREDITS...
+        # ce_txs_gb = {k: list(l) for k, l in ce_txs_gb}
+        ce_txs_sum = {k: sum(v.balance for v in l) for k, l in ce_txs_gb}
 
         if len(ce_txs_sum) and ce_txs_sum[TransactionModel.DEBIT] != ce_txs_sum[TransactionModel.CREDIT]:
             raise ClosingEntryValidationError(
@@ -110,20 +120,17 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
                         f'do not equal Debits {ce_txs_sum[TransactionModel.DEBIT]}'
             )
 
-        ce_txs = list(ce_txs)
-        key_func = lambda i: (
-            str(i.unit_model_id) if i.unit_model_id else '',
-            i.activity if i.activity else ''
-        )
+
+
+        key_func = lambda i: (str(i.unit_model_id) if i.unit_model_id else '', i.activity if i.activity else '')
+
         ce_txs.sort(key=key_func)
         ce_txs_gb = groupby(ce_txs, key=key_func)
-        ce_txs_gb = {
-            unit_model_id: list(je_txs) for unit_model_id, je_txs in ce_txs_gb
-        }
+        ce_txs_gb = {unit_model_id: list(je_txs) for unit_model_id, je_txs in ce_txs_gb}
 
         ce_txs_journal_entries = {
             (unit_model_id, activity): JournalEntryModel(
-                ledger=self.ledger_model,
+                ledger_id=self.ledger_model_id,
                 timestamp=self.get_closing_date_as_timestamp(),
                 activity=activity if activity else None,
                 entity_unit_id=unit_model_id if unit_model_id else None,
@@ -177,7 +184,7 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
     def can_post(self) -> bool:
         return not self.is_posted()
 
-    def mark_as_posted(self, commit: bool = False, **kwargs):
+    def mark_as_posted(self, commit: bool = False, update_entity_meta: bool = False, **kwargs):
         if not self.can_post():
             raise ClosingEntryValidationError(
                 message=_(f'Closing Entry {self.closing_date} is already posted.')
@@ -186,12 +193,14 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
         self.migrate()
         self.posted = True
         if commit:
-            self.save(update_fields=[
-                'posted',
-                'ledger_model',
-                'updated'
-            ])
-            self.entity_model.save_closing_entry_dates_meta(commit=True)
+            self.save(
+                update_fields=[
+                    'posted',
+                    'ledger_model',
+                    'updated'
+                ])
+            if update_entity_meta:
+                self.entity_model.save_closing_entry_dates_meta(commit=True)
 
     def get_mark_as_posted_html_id(self) -> str:
         return f'closing_entry_post_{self.uuid}'
@@ -212,7 +221,7 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
     def can_unpost(self) -> bool:
         return self.is_posted()
 
-    def mark_as_unposted(self, commit: bool = False, **kwargs):
+    def mark_as_unposted(self, commit: bool = False, update_entity_meta: bool = False, **kwargs):
         if not self.can_unpost():
             raise ClosingEntryValidationError(
                 message=_(f'Closing Entry {self.closing_date} is not posted.')
@@ -224,12 +233,14 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
         ).delete()
         self.ledger_model.journal_entries.all().delete()
         if commit:
-            self.save(update_fields=[
-                'posted',
-                'ledger_model',
-                'updated'
-            ])
-            self.entity_model.save_closing_entry_dates_meta(commit=True)
+            self.save(
+                update_fields=[
+                    'posted',
+                    'ledger_model',
+                    'updated'
+                ])
+            if update_entity_meta:
+                self.entity_model.save_closing_entry_dates_meta(commit=True)
 
     def get_mark_as_unposted_html_id(self) -> str:
         return f'closing_entry_unpost_{self.uuid}'
@@ -250,7 +261,7 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
     def can_update_txs(self) -> bool:
         return not self.is_posted()
 
-    def update_transactions(self, force_update: bool = False, commit: bool = True, **kwargs):
+    def update_transactions(self, force_update: bool = False, post_closing_entry: bool = True, **kwargs):
         if not self.can_update_txs():
             raise ClosingEntryValidationError(
                 message=_('Cannot update transactions of a posted Closing Entry.')
@@ -259,7 +270,7 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
         entity_model.close_entity_books(
             closing_entry_model=self,
             force_update=force_update,
-            commit=commit
+            post_closing_entry=post_closing_entry
         )
 
     def get_update_transactions_html_id(self) -> str:

django_ledger/models/coa.py

@@ -31,7 +31,7 @@ from django.contrib.auth import get_user_model
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.db.models import Q
-from django.db.models.signals import pre_save, post_save
+from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 from django_ledger.io import (ROOT_COA, ROOT_GROUP_LEVEL_2, ROOT_GROUP_META, ROOT_ASSETS,
@@ -40,7 +40,6 @@ from django_ledger.io import (ROOT_COA, ROOT_GROUP_LEVEL_2, ROOT_GROUP_META, ROO
 from django_ledger.models import lazy_loader
 from django_ledger.models.accounts import AccountModel, AccountModelQuerySet
 from django_ledger.models.mixins import CreateUpdateMixIn, SlugNameMixIn
-from django_ledger.settings import logger
 
 UserModel = get_user_model()
 
@@ -150,10 +149,10 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
     entity: EntityModel
         The EntityModel associated with this Chart of Accounts.
 
-    locked: bool
+    active: bool
         This determines whether any changes can be done to the Chart of Accounts.
-        Before making any update to the ChartOf Account, the account needs to be unlocked.
-        Default value is set to False (unlocked).
+        Inactive Chart of Accounts will not be able to be used in new Transactions.
+        Default value is set to False (inactive).
 
     description: str
         A user generated description for this Chart of Accounts.
@@ -164,7 +163,7 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
                                editable=False,
                                verbose_name=_('Entity'),
                                on_delete=models.CASCADE)
-    locked = models.BooleanField(default=False, verbose_name=_('Locked'))
+    active = models.BooleanField(default=True, verbose_name=_('Is Active'))
     description = models.TextField(verbose_name=_('CoA Description'), null=True, blank=True)
     objects = ChartOfAccountModelManager.from_queryset(queryset_class=ChartOfAccountModelQuerySet)()
 
@@ -194,7 +193,7 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
                         root_account_qs: Optional[AccountModelQuerySet] = None,
                         as_queryset: bool = False) -> Union[AccountModelQuerySet, AccountModel]:
 
-        if not account_model.is_coa_root():
+        if not account_model.is_root_account():
 
             if not root_account_qs:
                 root_account_qs = self.get_coa_root_accounts_qs()
@@ -262,8 +261,9 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
                 locked=True,
                 balance_type=role_meta['balance_type']
             )
-            coa_root_account_model = AccountModel.add_root(instance=root_account)
+            AccountModel.add_root(instance=root_account)
 
+            # must retrieve root model after added pero django-treebeard documentation...
             coa_root_account_model = AccountModel.objects.get(uuid__exact=account_pk)
 
             for root_role in ROOT_GROUP_LEVEL_2:
@@ -284,10 +284,11 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
                         ))
 
     def is_default(self) -> bool:
-        if self.entity_id is None:
-            return False
         return self.entity.default_coa_id == self.uuid
 
+    def is_active(self) -> bool:
+        return self.active is True
+
     def validate_account_model_qs(self, account_model_qs: AccountModelQuerySet):
         if not isinstance(account_model_qs, AccountModelQuerySet):
             raise ChartOfAccountsModelValidationError(
@@ -299,23 +300,72 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
                     message=f'Invalid root queryset for CoA {self.name}'
                 )
 
-    def create_account(self, account_model: AccountModel, root_account_qs: Optional[AccountModelQuerySet] = None):
-        if not account_model.coa_model_id:
+    def allocate_account(self,
+                         account_model: AccountModel,
+                         root_account_qs: Optional[AccountModelQuerySet] = None):
+        """
+        Allocates a given account model to the appropriate root account depending on the Account Model Role.
 
-            if not root_account_qs:
-                root_account_qs = self.get_coa_root_accounts_qs()
-            else:
-                self.validate_account_model_qs(root_account_qs)
+        Parameters
+        ----------
+        account_model: AccountModel
+            The Account Model to Allocate
+        root_account_qs:
+            The Root Account QuerySet of the Chart Of Accounts to use.
+            Will be validated against current CoA Model.
 
-            l2_root_node: AccountModel = self.get_coa_l2_root(account_model, root_account_qs=root_account_qs)
+        Returns
+        -------
+        AccountModel
+            The saved and allocated AccountModel.
+        """
 
-            account_model.coa_model = self
-            account_model = l2_root_node.add_child(instance=account_model)
+        if account_model.coa_model_id:
+            if account_model.coa_model_id != self.uuid:
+                raise ChartOfAccountsModelValidationError(
+                    message=f'Invalid Account Model {account_model} for CoA {self}'
+                )
+
+        if not root_account_qs:
+            root_account_qs = self.get_coa_root_accounts_qs()
+        else:
+            self.validate_account_model_qs(root_account_qs)
+
+        l2_root_node: AccountModel = self.get_coa_l2_root(
+            account_model=account_model,
+            root_account_qs=root_account_qs
+        )
+
+        account_model.coa_model = self
+        l2_root_node.add_child(instance=account_model)
+        coa_accounts_qs = self.get_non_root_coa_accounts_qs()
+        return coa_accounts_qs.get(uuid__exact=account_model.uuid)
+
+    def create_account(self,
+                       code: str,
+                       role: str,
+                       name: str,
+                       balance_type: str,
+                       active: bool,
+                       root_account_qs: Optional[AccountModelQuerySet] = None):
+
+        account_model = AccountModel(
+            code=code,
+            name=name,
+            role=role,
+            active=active,
+            balance_type=balance_type
+        )
+        account_model.clean()
+
+        account_model = self.allocate_account(
+            account_model=account_model,
+            root_account_qs=root_account_qs
+        )
         return account_model
 
     # ACTIONS -----
-
-    # todo: use these methods once multi CoA fetures are enabled...
+    # todo: use these methods once multi CoA features are enabled...
     def lock_all_accounts(self) -> AccountModelQuerySet:
         non_root_accounts_qs = self.get_non_root_coa_accounts_qs()
         non_root_accounts_qs.update(locked=True)
@@ -326,25 +376,184 @@ class ChartOfAccountModelAbstract(SlugNameMixIn, CreateUpdateMixIn):
         non_root_accounts_qs.update(locked=False)
         return non_root_accounts_qs
 
-    def clean(self):
-        self.generate_slug()
+    def mark_as_default(self, commit: bool = False, raise_exception: bool = False, **kwargs):
+        """
+        Marks the current Chart of Accounts instances as default for the EntityModel.
+
+        Parameters
+        ----------
+        commit: bool
+            Commit the action into the Database. Default is False.
+        raise_exception: bool
+            Raises exception if Chart of Account model instance is already marked as default.
+        """
+        if self.is_default():
+            if raise_exception:
+                raise ChartOfAccountsModelValidationError(
+                    message=_(f'The Chart of Accounts {self.slug} is already default')
+                )
+            return
+        self.entity.default_coa_id = self.uuid
+        self.clean()
+        if commit:
+            self.entity.save(
+                update_fields=[
+                    'default_coa_id',
+                    'updated'
+                ]
+            )
 
+    def mark_as_default_url(self) -> str:
+        """
+        Returns the URL to mark the current Chart of Accounts instances as Default for the EntityModel.
 
-class ChartOfAccountModel(ChartOfAccountModelAbstract):
-    """
-    Base ChartOfAccounts Model
-    """
+        Returns
+        -------
+        str
+            The URL as a String.
+        """
+        return reverse(
+            viewname='django_ledger:coa-action-mark-as-default',
+            kwargs={
+                'entity_slug': self.entity.slug,
+                'coa_slug': self.slug
+            }
+        )
+
+    def can_activate(self) -> bool:
+        return self.active is False
+
+    def can_deactivate(self) -> bool:
+        return all([
+            self.is_active(),
+            not self.is_default()
+        ])
+
+    def mark_as_active(self, commit: bool = False, raise_exception: bool = False, **kwargs):
+        """
+        Marks the current Chart of Accounts as Active.
+
+        Parameters
+        ----------
+        commit: bool
+            Commit the action into the Database. Default is False.
+        raise_exception: bool
+            Raises exception if Chart of Account model instance is already active. Default is False.
+        """
+        if self.is_active():
+            if raise_exception:
+                raise ChartOfAccountsModelValidationError(
+                    message=_('The Chart of Accounts is currently active.')
+                )
+            return
+
+        self.active = True
+        self.clean()
+        if commit:
+            self.save(
+                update_fields=[
+                    'active',
+                    'updated'
+                ])
+
+    def mark_as_active_url(self) -> str:
+        """
+        Returns the URL to mark the current Chart of Accounts instances as active.
+
+        Returns
+        -------
+        str
+            The URL as a String.
+        """
+        return reverse(
+            viewname='django_ledger:coa-action-mark-as-active',
+            kwargs={
+                'entity_slug': self.entity.slug,
+                'coa_slug': self.slug
+            }
+        )
+
+    def mark_as_inactive(self, commit: bool = False, raise_exception: bool = False, **kwargs):
+        """
+        Marks the current Chart of Accounts as Active.
+
+        Parameters
+        ----------
+        commit: bool
+            Commit the action into the Database. Default is False.
+        raise_exception: bool
+            Raises exception if Chart of Account model instance is already active. Default is False.
+        """
+        if not self.is_active():
+            if raise_exception:
+                raise ChartOfAccountsModelValidationError(
+                    message=_('The Chart of Accounts is currently not active.')
+                )
+            return
 
+        self.active = False
+        self.clean()
+        if commit:
+            self.save(
+                update_fields=[
+                    'active',
+                    'updated'
+                ])
 
-# def chartofaccountmodel_presave(instance: ChartOfAccountModel, **kwargs):
-#     if instance._state.adding:
-#         instance.configure(raise_exception=True)
+    def mark_as_inactive_url(self) -> str:
+        """
+        Returns the URL to mark the current Chart of Accounts instances as inactive.
 
+        Returns
+        -------
+        str
+            The URL as a String.
+        """
+        return reverse(
+            viewname='django_ledger:coa-action-mark-as-inactive',
+            kwargs={
+                'entity_slug': self.entity.slug,
+                'coa_slug': self.slug
+            }
+        )
+
+    def get_absolute_url(self) -> str:
+        return reverse(
+            viewname='django_ledger:coa-detail',
+            kwargs={
+                'coa_slug': self.slug,
+                'entity_slug': self.entity.slug
+            }
+        )
+
+    def get_account_list_url(self):
+        return reverse(
+            viewname='django_ledger:account-list-coa',
+            kwargs={
+                'entity_slug': self.entity.slug,
+                'coa_slug': self.slug
+            }
+        )
+
+    def get_create_coa_account_url(self):
+        return reverse(
+            viewname='django_ledger:account-create-coa',
+            kwargs={
+                'coa_slug': self.slug,
+                'entity_slug': self.entity.slug
+            }
+        )
 
-def chartofaccountmodel_postsave(instance: ChartOfAccountModel, **kwargs):
-    if instance._state.adding:
-        instance.configure(raise_exception=True)
+    def clean(self):
+        self.generate_slug()
+
+        if self.is_default() and not self.active:
+            raise ChartOfAccountsModelValidationError(
+                _('Default Chart of Accounts cannot be deactivated.')
+            )
 
 
-# pre_save.connect(receiver=chartofaccountmodel_presave, sender=ChartOfAccountModel)
-post_save.connect(receiver=chartofaccountmodel_postsave, sender=ChartOfAccountModel)
+class ChartOfAccountModel(ChartOfAccountModelAbstract):
+    """
+    Base ChartOfAccounts Model
+    """