django-ledger 0.7.10__py3-none-any.whl → 0.8.0__py3-none-any.whl

django_ledger/models/closing_entry.py

@@ -2,8 +2,8 @@
 Django Ledger created by Miguel Sanda <msanda@arrobalytics.com>.
 Copyright© EDMA Group Inc licensed under the GPLv3 Agreement.
 """
-
-from datetime import datetime, time
+import warnings
+from datetime import datetime, time, date
 from decimal import Decimal
 from itertools import groupby, chain
 from typing import Optional
@@ -12,58 +12,75 @@ from uuid import uuid4, UUID
 from django.core.exceptions import ValidationError
 from django.core.validators import MinValueValidator
 from django.db import models
-from django.db.models import Q, Count
+from django.db.models import Q, Manager, QuerySet, Count
 from django.db.models.signals import pre_save
 from django.urls import reverse
 from django.utils.timezone import make_aware
 from django.utils.translation import gettext_lazy as _
 
+from django_ledger.models import EntityModel, deprecated_entity_slug_behavior, lazy_loader
 from django_ledger.models.journal_entry import JournalEntryModel
 from django_ledger.models.ledger import LedgerModel
 from django_ledger.models.mixins import CreateUpdateMixIn, MarkdownNotesMixIn
 from django_ledger.models.transactions import TransactionModel
-from django_ledger.models.utils import lazy_loader
+from django_ledger.settings import DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR
 
 
 class ClosingEntryValidationError(ValidationError):
     pass
 
 
-class ClosingEntryModelQuerySet(models.QuerySet):
+class ClosingEntryModelQuerySet(QuerySet):
 
-    def posted(self):
+    def for_user(self, user_model):
+        if user_model.is_superuser:
+            return self
+        return self.filter(
+            Q(entity_model__admin=user_model) |
+            Q(entity_model__managers__in=[user_model])
+        )
+
+    def posted(self) -> 'ClosingEntryModelQuerySet':
         return self.filter(posted=True)
 
-    def not_posted(self):
+    def not_posted(self) -> 'ClosingEntryModelQuerySet':
         return self.filter(posted=False)
 
 
-class ClosingEntryModelManager(models.Manager):
+class ClosingEntryModelManager(Manager):
 
-    def get_queryset(self):
+    def get_queryset(self) -> ClosingEntryModelQuerySet:
         qs = ClosingEntryModelQuerySet(self.model, using=self._db)
         return qs.annotate(
             ce_txs_count=Count('closingentrytransactionmodel')
         )
 
-    def for_user(self, user_model):
+    @deprecated_entity_slug_behavior
+    def for_entity(self, entity_model: EntityModel | str | UUID = None, **kwargs) -> ClosingEntryModelQuerySet:
+
         qs = self.get_queryset()
-        if user_model.is_superuser:
-            return qs
-        return qs.filter(
-            Q(entity_model__admin=user_model) |
-            Q(entity_model__managers__in=[user_model])
-        )
 
-    def for_entity(self, entity_slug, user_model):
-        qs = self.for_user(user_model)
-        if isinstance(entity_slug, lazy_loader.get_entity_model()):
-            return qs.filter(
-                Q(entity_model=entity_slug)
+        if 'user_model' in kwargs:
+            warnings.warn(
+                'user_model parameter is deprecated and will be removed in a future release. '
+                'Use for_user(user_model).for_entity(entity_model) instead to keep current behavior.',
+                DeprecationWarning,
+                stacklevel=2
             )
-        return qs.filter(
-            Q(entity_model__slug__exact=entity_slug)
-        )
+            if DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR:
+                qs = qs.for_user(kwargs['user_model'])
+
+        if isinstance(entity_model, EntityModel):
+            qs = qs.filter(entity_model=entity_model)
+        elif isinstance(entity_model, str):
+            qs = qs.filter(entity_model__slug__exact=entity_model)
+        elif isinstance(entity_model, UUID):
+            qs = qs.filter(entity_model_id=entity_model)
+        else:
+            raise ClosingEntryValidationError(
+                message='Must pass EntityModel, slug or UUID'
+            )
+        return qs
 
 
 class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
@@ -247,7 +264,7 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
         self.posted = False
 
         TransactionModel.objects.for_entity(
-            entity_slug=self.entity_model_id
+            entity_model=self.entity_model_id
         ).for_ledger(ledger_model=self.ledger_model).delete()
 
         self.ledger_model.journal_entries.all().delete()
@@ -321,7 +338,7 @@ class ClosingEntryModelAbstract(CreateUpdateMixIn, MarkdownNotesMixIn):
         self.ledger_model.unpost(commit=True, raise_exception=True)
 
         TransactionModel.objects.for_entity(
-            entity_slug=self.entity_model_id
+            entity_model=self.entity_model_id
         ).for_ledger(ledger_model=self.ledger_model).delete()
 
         return self.ledger_model.delete()
@@ -361,19 +378,62 @@ class ClosingEntryModel(ClosingEntryModelAbstract):
         abstract = False
 
 
-class ClosingEntryTransactionModelQuerySet(models.QuerySet):
-    pass
+def closingentrymodel_presave(instance: ClosingEntryModel, **kwargs):
+    instance.create_entry_ledger(commit=False)
+
+
+pre_save.connect(closingentrymodel_presave, sender=ClosingEntryModel)
+
+
+class ClosingEntryTransactionModelQuerySet(QuerySet):
 
+    def for_user(self, user_model) -> 'ClosingEntryTransactionModelQuerySet':
+        if user_model.is_superuser:
+            return self
+        return self.filter(
+            Q(closing_entry_model__entity_model__admin=user_model) |
+            Q(closing_entry_model__entity_model__managers__in=[user_model])
+        )
 
-class ClosingEntryTransactionModelManager(models.Manager):
+    def for_closing_date(self, closing_date: date) -> 'ClosingEntryTransactionModelQuerySet':
+        return self.filter(
+            closing_entry_model__closing_date__exact=closing_date
+        )
+
+
+class ClosingEntryTransactionModelManager(Manager):
+
+    def get_queryset(self) -> ClosingEntryTransactionModelQuerySet:
+        return ClosingEntryTransactionModelQuerySet(self.model, using=self._db)
+
+    @deprecated_entity_slug_behavior
+    def for_entity(self, entity_model: EntityModel | str | UUID = None,
+                   **kwargs) -> ClosingEntryTransactionModelQuerySet:
+        EntityModel = lazy_loader.get_entity(entity_model)
 
-    def for_entity(self, entity_slug):
         qs = self.get_queryset()
-        if isinstance(entity_slug, lazy_loader.get_entity_model()):
-            return qs.filter(closing_entry_model__entity_model=entity_slug)
-        elif isinstance(entity_slug, UUID):
-            return qs.filter(closing_entry_model__entity_model__uuid__exact=entity_slug)
-        return qs.filter(closing_entry_model__entity_model__slug__exact=entity_slug)
+
+        if 'user_model' in kwargs:
+            warnings.warn(
+                'user_model parameter is deprecated and will be removed in a future release. '
+                'Use for_user(user_model).for_entity(entity_model) instead to keep current behavior.',
+                DeprecationWarning,
+                stacklevel=2
+            )
+            if DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR:
+                qs = qs.for_user(kwargs['user_model'])
+
+        if isinstance(entity_model, EntityModel):
+            qs = qs.filter(closing_entry_model__entity_model=entity_model)
+        elif isinstance(entity_model, UUID):
+            qs = qs.filter(closing_entry_model__entity_model_id=entity_model)
+        elif isinstance(entity_model, str):
+            qs = qs.filter(closing_entry_model__slug__exact=entity_model)
+        else:
+            raise ClosingEntryValidationError(
+                message=_('Must pass EntityModel or UUID or str')
+            )
+        return qs
 
 
 class ClosingEntryTransactionModelAbstract(CreateUpdateMixIn):
@@ -453,13 +513,11 @@ class ClosingEntryTransactionModelAbstract(CreateUpdateMixIn):
     def __str__(self):
         return f'{self.__class__.__name__}: {self.closing_entry_model.closing_date.strftime("%D")} | {self.balance}'
 
-    def is_debit(self) -> Optional[bool]:
-        if self.tx_type is not None:
-            return self.tx_type == TransactionModel.DEBIT
+    def is_debit(self) -> bool:
+        return self.tx_type == TransactionModel.DEBIT
 
-    def is_credit(self) -> Optional[bool]:
-        if self.tx_type is not None:
-            return self.tx_type == TransactionModel.CREDIT
+    def is_credit(self) -> bool:
+        return self.tx_type == TransactionModel.CREDIT
 
     def adjust_tx_type_for_negative_balance(self):
         if self.balance < Decimal('0.00'):
@@ -485,13 +543,6 @@ class ClosingEntryTransactionModel(ClosingEntryTransactionModelAbstract):
         abstract = False
 
 
-def closingentrymodel_presave(instance: ClosingEntryModel, **kwargs):
-    instance.create_entry_ledger(commit=False)
-
-
-pre_save.connect(closingentrymodel_presave, sender=ClosingEntryModel)
-
-
 def closingentrytransactionmodel_presave(instance: ClosingEntryTransactionModel, **kwargs):
     instance.adjust_tx_type_for_negative_balance()
 

django_ledger/models/customer.py

@@ -7,17 +7,23 @@ created before it can be assigned to the InvoiceModel. Only customers who are ac
 """
 
 import os
-from uuid import uuid4
+import warnings
+from uuid import uuid4, UUID
 
-from django.core.exceptions import ObjectDoesNotExist
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db import models, transaction, IntegrityError
 from django.db.models import Q, F, QuerySet, Manager
 from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
 
+from django_ledger.models.deprecations import deprecated_entity_slug_behavior
 from django_ledger.models.mixins import ContactInfoMixIn, CreateUpdateMixIn, TaxCollectionMixIn
 from django_ledger.models.utils import lazy_loader
-from django_ledger.settings import DJANGO_LEDGER_DOCUMENT_NUMBER_PADDING, DJANGO_LEDGER_CUSTOMER_NUMBER_PREFIX
+from django_ledger.settings import (
+    DJANGO_LEDGER_DOCUMENT_NUMBER_PADDING,
+    DJANGO_LEDGER_CUSTOMER_NUMBER_PREFIX,
+    DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR
+)
 
 
 def customer_picture_upload_to(instance, filename):
@@ -32,6 +38,10 @@ def customer_picture_upload_to(instance, filename):
     return f'customer_pictures/{customer_number}/{safe_name}{ext.lower()}'
 
 
+class CustomerModelValidationError(ValidationError):
+    pass
+
+
 class CustomerModelQueryset(QuerySet):
     """
     A custom defined QuerySet for the CustomerModel. This implements multiple methods or queries needed to get a
@@ -40,6 +50,27 @@ class CustomerModelQueryset(QuerySet):
     reports.
     """
 
+    def for_user(self, user_model):
+        """
+        Fetches a QuerySet of BillModels that the UserModel as access to.
+        May include BillModels from multiple Entities.
+
+        The user has access to bills if:
+            1. Is listed as Manager of Entity.
+            2. Is the Admin of the Entity.
+
+        Parameters
+        __________
+        user_model
+            Logged in and authenticated django UserModel instance.
+        """
+        if user_model.is_superuser:
+            return self
+        return self.filter(
+            Q(entity_model__admin=user_model) |
+            Q(entity_model__managers__in=[user_model])
+        )
+
     def active(self) -> QuerySet:
         """
         Active customers can be assigned to new Invoices and show on dropdown menus and views.
@@ -93,59 +124,49 @@ class CustomerModelQueryset(QuerySet):
 
 class CustomerModelManager(Manager):
     """
-    A custom defined CustomerModelManager that will act as an interface to handling the DB queries to the
+    A custom-defined CustomerModelManager that will act as an interface to handling the DB queries to the
     CustomerModel.
     """
 
-    def for_user(self, user_model):
-        """
-        Fetches a QuerySet of BillModels that the UserModel as access to.
-        May include BillModels from multiple Entities.
-
-        The user has access to bills if:
-            1. Is listed as Manager of Entity.
-            2. Is the Admin of the Entity.
-
-        Parameters
-        __________
-        user_model
-            Logged in and authenticated django UserModel instance.
-        """
-        qs = self.get_queryset()
-        if user_model.is_superuser:
-            return qs
-        return qs.filter(
-            Q(entity_model__admin=user_model) |
-            Q(entity_model__managers__in=[user_model])
-        )
-
-    def for_entity(self, entity_slug, user_model) -> CustomerModelQueryset:
+    @deprecated_entity_slug_behavior
+    def for_entity(self, entity_model: 'EntityModel | str | UUID' = None, **kwargs) -> CustomerModelQueryset:
         """
         Fetches a QuerySet of CustomerModel associated with a specific EntityModel & UserModel.
         May pass an instance of EntityModel or a String representing the EntityModel slug.
 
         Parameters
         __________
-        entity_slug: str or EntityModel
+        entity_model: str or EntityModel
             The entity slug or EntityModel used for filtering the QuerySet.
-        user_model
-            Logged in and authenticated django UserModel instance.
-
 
         Returns
         -------
         CustomerModelQueryset
             A filtered CustomerModel QuerySet.
         """
-        qs = self.for_user(user_model)
-
-        if isinstance(entity_slug, lazy_loader.get_entity_model()):
-            return qs.filter(
-                Q(entity_model=entity_slug)
+        EntityModel = lazy_loader.get_entity_model()
+        qs = self.get_queryset()
+        if 'user_model' in kwargs:
+            warnings.warn(
+                'user_model parameter is deprecated and will be removed in a future release. '
+                'Use for_user(user_model).for_entity(entity_model) instead to keep current behavior.',
+                DeprecationWarning,
+                stacklevel=2
             )
-        return qs.filter(
-            Q(entity_model__slug__exact=entity_slug)
-        )
+            if DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR:
+                qs = qs.for_user(kwargs['user_model'])
+
+        if isinstance(entity_model, EntityModel):
+            qs = qs.filter(entity_model=entity_model)
+        elif isinstance(entity_model, str):
+            qs = qs.filter(entity_model__slug__exact=entity_model)
+        elif isinstance(entity_model, UUID):
+            qs = qs.filter(entity_model_id=entity_model)
+        else:
+            raise CustomerModelValidationError(
+                message='Must pass EntityModel, slug or EntityModel UUID',
+            )
+        return qs
 
 
 class CustomerModelAbstract(ContactInfoMixIn, TaxCollectionMixIn, CreateUpdateMixIn):

django_ledger/models/data_import.py

@@ -10,7 +10,7 @@ application. It introduces two primary models to facilitate the import and proce
 or further processing.
 
 """
-
+import warnings
 from decimal import Decimal
 from typing import Optional, Set, Dict, List, Union
 from uuid import uuid4, UUID
@@ -23,10 +23,11 @@ from django.db.models.signals import pre_save
 from django.utils.translation import gettext_lazy as _
 
 from django_ledger.io import ASSET_CA_CASH, CREDIT, DEBIT
-from django_ledger.models import JournalEntryModel
+from django_ledger.models import JournalEntryModel, deprecated_entity_slug_behavior
 from django_ledger.models.entity import EntityModel
 from django_ledger.models.mixins import CreateUpdateMixIn
 from django_ledger.models.utils import lazy_loader
+from django_ledger.settings import DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR
 
 
 class ImportJobModelValidationError(ValidationError):
@@ -34,7 +35,34 @@ class ImportJobModelValidationError(ValidationError):
 
 
 class ImportJobModelQuerySet(QuerySet):
-    pass
+
+    def for_user(self, user_model) -> 'ImportJobModelQuerySet':
+        """
+        Filters the queryset based on the user's permissions for accessing the data
+        related to bank accounts and entities they manage or administer.
+
+        This method first retrieves the default queryset. If the user is a superuser,
+        the query will return the full queryset without any filters. Otherwise, the
+        query will be limited to the entities that the user either administers or is
+        listed as a manager for.
+
+        Parameters
+        ----------
+        user_model : User
+            The user model instance whose permissions determine the filtering of the queryset.
+
+        Returns
+        -------
+        QuerySet
+            A filtered queryset based on the user's role and associated permissions.
+        """
+        if user_model.is_superuser:
+            return self
+        return self.filter(
+            Q(bank_account_model__entity_model__admin=user_model) |
+            Q(bank_account_model__entity_model__managers__in=[user_model])
+
+        )
 
 
 class ImportJobModelManager(Manager):
@@ -49,7 +77,7 @@ class ImportJobModelManager(Manager):
 
     """
 
-    def get_queryset(self):
+    def get_queryset(self) -> ImportJobModelQuerySet:
         """
         Generates a QuerySet with annotated data for ImportJobModel.
 
@@ -100,44 +128,30 @@ class ImportJobModelManager(Manager):
             'ledger_model'
         )
 
-    def for_user(self, user_model):
-        """
-        Filters the queryset based on the user's permissions for accessing the data
-        related to bank accounts and entities they manage or administer.
-
-        This method first retrieves the default queryset. If the user is a superuser,
-        the query will return the full queryset without any filters. Otherwise, the
-        query will be limited to the entities that the user either administers or is
-        listed as a manager for.
-
-        Parameters
-        ----------
-        user_model : User
-            The user model instance whose permissions determine the filtering of the queryset.
-
-        Returns
-        -------
-        QuerySet
-            A filtered queryset based on the user's role and associated permissions.
-        """
+    @deprecated_entity_slug_behavior
+    def for_entity(self, entity_model: Union[EntityModel, str, UUID] = None, **kwargs) -> ImportJobModelQuerySet:
         qs = self.get_queryset()
-        if user_model.is_superuser:
-            return qs
-        return qs.filter(
-            Q(bank_account_model__entity_model__admin=user_model) |
-            Q(bank_account_model__entity_model__managers__in=[user_model])
-
-        )
-
-    def for_entity(self, entity_slug: Union[EntityModel, str], user_model):
-        qs = self.for_user(user_model)
-        if isinstance(entity_slug, EntityModel):
-            return qs.filter(
-            Q(bank_account_model__entity_model=entity_slug)
-        )
-        return qs.filter(
-            Q(bank_account_model__entity_model__slug__exact=entity_slug)
-        )
+        if 'user_model' in kwargs:
+            warnings.warn(
+                'user_model parameter is deprecated and will be removed in a future release. '
+                'Use for_user(user_model).for_entity(entity_model) instead to keep current behavior.',
+                DeprecationWarning,
+                stacklevel=2
+            )
+            if DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR:
+                qs = qs.for_user(kwargs['user_model'])
+
+        if isinstance(entity_model, EntityModel):
+            qs = qs.filter(bank_account_model__entity_model=entity_model)
+        elif isinstance(entity_model, UUID):
+            qs = qs.filter(bank_account_model__entity_model_id=entity_model)
+        elif isinstance(entity_model, str):
+            qs = qs.filter(bank_account_model__slug__exact=entity_model)
+        else:
+            raise ImportJobModelValidationError(
+                message=_('Must pass EntityModel, slug or UUID'),
+            )
+        return qs
 
 
 class ImportJobModelAbstract(CreateUpdateMixIn):

django_ledger/models/deprecations.py

@@ -0,0 +1,61 @@
+import warnings
+from functools import wraps
+
+from django_ledger.settings import DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR
+
+if DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR:
+    warnings.warn(
+        message=(
+            'You are using the deprecated behavior of django_ledger. '
+            'Set DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR = False to transition to new API.'
+        )
+    )
+
+
+def deprecated_entity_slug_behavior(func=None, *, message=None):
+    """
+    Decorator for for_entity(...) methods to warn about the deprecated `entity_slug` argument
+    and optionally map it to `entity_model` for backward compatibility.
+
+    Usage:
+      @deprecated_for_entity_behavior
+      def for_entity(self, entity_model=None, **kwargs):
+          ...
+
+      or with custom message:
+      @deprecated_for_entity_behavior(message="custom deprecation message")
+      def for_entity(...):
+          ...
+    """
+    default_message = (
+        'entity_slug parameter is deprecated and will be removed in a future release. '
+        'Use entity_model instead (accepts EntityModel instance, UUID, or slug string).'
+    )
+
+    if func is None:
+        # Called as @deprecated_for_entity_behavior(...)
+        return lambda f: deprecated_entity_slug_behavior(f, message=message)
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if 'entity_slug' in kwargs and kwargs.get('entity_slug') is not None:
+            warnings.warn(message or default_message, DeprecationWarning, stacklevel=2)
+
+            # If both are provided, fail fast to avoid ambiguity
+            if kwargs.get('entity_model') is not None:
+                raise ValueError(
+                    'Cannot specify both `entity_model` and `entity_slug`. '
+                    'entity_slug is deprecated; pass only entity_model.'
+                )
+
+            # Maintain legacy behavior when enabled by settings toggle
+            if DJANGO_LEDGER_USE_DEPRECATED_BEHAVIOR:
+                kwargs['entity_model'] = kwargs.pop('entity_slug')
+            else:
+                # If deprecated behavior is disabled, drop the deprecated param
+                # and rely on the method's own validation (likely to fail fast).
+                kwargs.pop('entity_slug', None)
+
+        return func(*args, **kwargs)
+
+    return wrapper

django_ledger/models/entity.py

@@ -24,7 +24,7 @@ from decimal import Decimal
 from itertools import zip_longest
 from random import choices
 from string import ascii_lowercase, digits
-from typing import Tuple, Union, Optional, List, Dict, Set
+from typing import Tuple, Union, Optional, List, Dict, Set, Self
 from uuid import uuid4, UUID
 
 from django.contrib.auth import get_user_model
@@ -71,7 +71,7 @@ class EntityModelQuerySet(MP_NodeQuerySet):
     Inherits from the Materialized Path Node QuerySet Class from Django Treebeard.
     """
 
-    def hidden(self):
+    def hidden(self) -> 'EntityModelQuerySet':
         """
         A QuerySet of all hidden EntityModel.
 
@@ -82,7 +82,7 @@ class EntityModelQuerySet(MP_NodeQuerySet):
         """
         return self.filter(hidden=True)
 
-    def visible(self):
+    def visible(self) -> 'EntityModelQuerySet':
         """
         A Queryset of all visible EntityModel.
 
@@ -108,7 +108,7 @@ class EntityModelManager(MP_NodeManager):
 
     """
 
-    def get_queryset(self):
+    def get_queryset(self) -> EntityModelQuerySet:
         """Sets the custom queryset as the default."""
         qs = EntityModelQuerySet(
             self.model,
@@ -441,12 +441,13 @@ class EntityModelClosingEntryMixIn:
             )
 
     # ---> Closing Entry IO Digest <---
-    def get_closing_entry_digest(self,
-                                 to_date: date,
-                                 from_date: Optional[date] = None,
-                                 user_model: Optional[UserModel] = None,
-                                 closing_entry_model=None,
-                                 **kwargs: Dict) -> Tuple:
+    def get_closing_entry_digest(
+            self,
+            to_date: date,
+            from_date: Optional[date] = None,
+            user_model: Optional[UserModel] = None,
+            closing_entry_model=None,
+            **kwargs: Dict) -> Tuple:
         ClosingEntryModel = lazy_loader.get_closing_entry_model()
         ClosingEntryTransactionModel = lazy_loader.get_closing_entry_transaction_model()
 
@@ -512,8 +513,8 @@ class EntityModelClosingEntryMixIn:
     def get_closing_entry_queryset_for_date(self, closing_date: date):
         ClosingEntryTransactionModel = lazy_loader.get_closing_entry_transaction_model()
         return ClosingEntryTransactionModel.objects.for_entity(
-            entity_slug=self,
-        ).filter(closing_entry_model__closing_date__exact=closing_date)
+            entity_model=self,
+        ).for_closing_date(closing_date)
 
     def get_closing_entry_queryset_for_month(self, year: int, month: int):
         _, end_day = monthrange(year, month)
@@ -538,7 +539,7 @@ class EntityModelClosingEntryMixIn:
                 message=_(f'Cannot create closing entry with a future date {closing_date}.')
             )
 
-        if closing_entry_model is None or closing_entry_exists:
+        if closing_entry_model is None:
             self.closingentrymodel_set.filter(closing_date__exact=closing_date).delete()
         else:
             closing_entry_model.closingentrytransactionmodel_set.all().delete()
@@ -787,7 +788,6 @@ class EntityModelAbstract(MP_Node,
     meta = models.JSONField(default=dict, null=True, blank=True)
     objects = EntityModelManager.from_queryset(queryset_class=EntityModelQuerySet)()
 
-
     class Meta:
         abstract = True
         ordering = ['-created']
@@ -1547,7 +1547,7 @@ class EntityModelAbstract(MP_Node,
             return qs
 
         JournalEntryModel = lazy_loader.get_journal_entry_model()
-        qs = JournalEntryModel.objects.for_entity(entity_slug=self)
+        qs = JournalEntryModel.objects.for_entity(entity_model=self)
         if posted:
             return qs.posted()
         return qs
@@ -2603,7 +2603,9 @@ class EntityModelAbstract(MP_Node,
         ItemTransactionModel = lazy_loader.get_item_transaction_model()
         ItemModel = lazy_loader.get_item_model()
 
-        counted_qs: ItemTransactionModelQuerySet = ItemTransactionModel.objects.inventory_count(entity_slug=self.slug)
+        counted_qs: ItemTransactionModelQuerySet = ItemTransactionModel.objects.inventory_count(
+            entity_model=self.slug
+        )
         recorded_qs: ItemModelQuerySet = self.recorded_inventory(as_values=False)
         recorded_qs_values = self.recorded_inventory(item_qs=recorded_qs, as_values=True)