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

django_ledger/tests/test_closing_entry.py

@@ -17,17 +17,25 @@ class ClosingEntryModelTests(DjangoLedgerBaseTest):
             p.name: set(p.pattern.converters.keys()) for p in closing_entry_urls
         }
 
-        for entity_model in self.ENTITY_MODEL_QUERYSET:
-            for y in [self.START_DATE.year, self.START_DATE.year + 1]:
-                for m in range(1, 13):
-                    ce_model, ce_txs_list = entity_model.close_books_for_month(
-                        year=y,
-                        month=m,
-                        force_update=True)
+        self.MONTHS = list(range(1, 13))
+        self.YEARS = [self.START_DATE.year, self.START_DATE.year + 1]
+
+    def test_closing_entry_create(self):
+        entity_model = self.get_random_entity_model()
+        for y in self.YEARS:
+            for m in self.MONTHS:
+                entity_model.close_books_for_month(
+                    year=y,
+                    month=m,
+                    post_closing_entry=True
+                )
 
     def test_protected_views(self):
         self.logout_client()
         entity_model = self.get_random_entity_model()
+        entity_model.close_entity_books(
+            closing_date=self.get_random_date()
+        )
         closing_entry_model = choice(entity_model.get_closing_entries())
 
         for path, kwargs in self.URL_PATTERNS.items():
@@ -53,16 +61,5 @@ class ClosingEntryModelTests(DjangoLedgerBaseTest):
         self.login_client()
         entity_model = self.get_random_entity_model()
         url = reverse('django_ledger:closing-entry-list', kwargs={'entity_slug': entity_model.slug})
-        with self.assertNumQueries(5):
+        with self.assertNumQueries(4):
             response = self.CLIENT.get(path=url)
-
-    def test_closing_entry_create(self):
-        entity_model = self.get_random_entity_model()
-
-        with self.assertNumQueries(1):
-
-            # closing entry does not exist...
-            entity_model.close_books_for_month(
-                year=self.START_DATE.year + 2,
-                month=self.START_DATE.month
-            )

django_ledger/tests/test_entity.py

@@ -226,7 +226,7 @@ class EntityModelTests(DjangoLedgerBaseTest):
                                         })
             response = self.CLIENT.get(entity_detail_url)
 
-        with self.assertNumQueries(7):  # previously 10
+        with self.assertNumQueries(8):  # previously 10
             local_dt = get_localdate()
             entity_month_detail_url = reverse('django_ledger:entity-dashboard-month',
                                               kwargs={
@@ -236,7 +236,7 @@ class EntityModelTests(DjangoLedgerBaseTest):
                                               })
             self.assertRedirects(response, entity_month_detail_url)
 
-        with self.assertNumQueries(7):
+        with self.assertNumQueries(8):
             # same as before, but this time the session must not be update because user has not suited entities...
             response = self.CLIENT.get(entity_month_detail_url)
             self.assertContains(response, text=entity_model.name)
@@ -249,7 +249,7 @@ class EntityModelTests(DjangoLedgerBaseTest):
         # entity_models = self.create_entity_models(n=1)
         entity_model = choice(self.ENTITY_MODEL_QUERYSET)
         # ENTITY-DELETE VIEW...
-        with self.assertNumQueries(3):
+        with self.assertNumQueries(4):
             entity_delete_url = reverse('django_ledger:entity-delete',
                                         kwargs={
                                             'entity_slug': entity_model.slug

django_ledger/tests/test_io.py

@@ -1,7 +1,197 @@
+from datetime import timedelta, datetime
+from random import randint
+from zoneinfo import ZoneInfo
+
+from django.conf import settings
+
+from django_ledger.io.io_core import IOValidationError
+from django_ledger.models import EntityModel
 from django_ledger.tests.base import DjangoLedgerBaseTest
 
 
 class IOTest(DjangoLedgerBaseTest):
 
-    def test_this_runs(self):
-        self.assertEqual(True, True)
+    def test_digest_dttm__dttm(self):
+        self.assertTrue(settings.USE_TZ, msg='Timezone not enabled.')
+
+        entity_model = self.get_random_entity_model()
+        from_datetime = self.START_DATE
+        to_datetime = self.START_DATE + timedelta(days=randint(10, 60))
+
+        io_digest = entity_model.digest(from_date=from_datetime, to_date=to_datetime)
+        self.assertTrue(isinstance(io_digest.get_to_datetime(), datetime))
+        self.assertTrue(isinstance(io_digest.get_from_datetime(), datetime))
+        self.assertEqual(io_digest.get_from_datetime(), from_datetime)
+        self.assertEqual(io_digest.get_to_datetime(), to_datetime)
+
+    def test_digest_dt__dttm(self):
+        self.assertTrue(settings.USE_TZ, msg='Timezone not enabled.')
+
+        entity_model = self.get_random_entity_model()
+        from_datetime = self.START_DATE
+        to_datetime = self.START_DATE + timedelta(days=randint(10, 60))
+
+        io_digest = entity_model.digest(from_date=from_datetime.date(), to_date=to_datetime)
+        self.assertTrue(isinstance(io_digest.get_to_datetime(), datetime))
+        self.assertTrue(isinstance(io_digest.get_from_datetime(), datetime))
+
+        self.assertEqual(
+            # the assumed datetime given a date...
+            io_digest.get_from_datetime(),
+
+            # equals the localized datetime @ 0:00
+            datetime.combine(
+                from_datetime.date(),
+                datetime.min.time(),
+                tzinfo=ZoneInfo(settings.TIME_ZONE)
+            )
+        )
+
+        self.assertEqual(io_digest.get_to_datetime(), to_datetime)
+
+    def test_digest_dttm__dt(self):
+        self.assertTrue(settings.USE_TZ, msg='Timezone not enabled.')
+
+        entity_model = self.get_random_entity_model()
+        from_datetime = self.START_DATE
+        to_datetime = self.START_DATE + timedelta(days=randint(10, 60))
+
+        io_digest = entity_model.digest(from_date=from_datetime, to_date=to_datetime.date())
+
+        self.assertTrue(isinstance(io_digest.get_to_datetime(), datetime))
+        self.assertTrue(isinstance(io_digest.get_from_datetime(), datetime))
+
+        self.assertEqual(io_digest.get_from_datetime(), from_datetime)
+
+        self.assertEqual(
+            # the assumed datetime given a date...
+            io_digest.get_to_datetime(),
+
+            # equals the localized datetime @ 0:00
+            datetime.combine(
+                to_datetime.date(),
+                datetime.min.time(),
+                tzinfo=ZoneInfo(settings.TIME_ZONE)
+            )
+        )
+
+    def test_digest_dt__dt(self):
+        self.assertTrue(settings.USE_TZ, msg='Timezone not enabled.')
+
+        entity_model = self.get_random_entity_model()
+        from_datetime = self.START_DATE
+        to_datetime = self.START_DATE + timedelta(days=randint(10, 60))
+
+        io_digest = entity_model.digest(from_date=from_datetime.date(), to_date=to_datetime.date())
+
+        self.assertTrue(isinstance(io_digest.get_to_datetime(), datetime))
+        self.assertTrue(isinstance(io_digest.get_from_datetime(), datetime))
+
+        self.assertEqual(
+            # the assumed datetime given a date...
+            io_digest.get_from_datetime(),
+
+            # equals the localized datetime @ 0:00
+            datetime.combine(
+                from_datetime.date(),
+                datetime.min.time(),
+                tzinfo=ZoneInfo(settings.TIME_ZONE)
+            )
+        )
+
+        self.assertEqual(
+            # the assumed datetime given a date...
+            io_digest.get_to_datetime(),
+
+            # equals the localized datetime @ 0:00
+            datetime.combine(
+                to_datetime.date(),
+                datetime.min.time(),
+                tzinfo=ZoneInfo(settings.TIME_ZONE)
+            )
+        )
+
+    def test_digest_none__dttm(self):
+        self.assertTrue(settings.USE_TZ, msg='Timezone not enabled.')
+
+        entity_model = self.get_random_entity_model()
+        to_datetime = self.START_DATE + timedelta(days=randint(10, 60))
+
+        io_digest = entity_model.digest(to_date=to_datetime)
+
+        self.assertTrue(io_digest.get_from_datetime() is None)
+        self.assertTrue(isinstance(io_digest.get_to_datetime(), datetime))
+
+        self.assertEqual(
+            # the assumed datetime given a date...
+            io_digest.get_from_datetime(),
+
+            # equals the localized datetime @ 0:00
+            None
+        )
+
+        self.assertEqual(io_digest.get_to_datetime(), to_datetime)
+
+    def test_digest_none__dt(self):
+        self.assertTrue(settings.USE_TZ, msg='Timezone not enabled.')
+
+        entity_model = self.get_random_entity_model()
+        to_datetime = self.START_DATE + timedelta(days=randint(10, 60))
+
+        io_digest = entity_model.digest(to_date=to_datetime.date())
+
+        self.assertTrue(io_digest.get_from_datetime() is None)
+        self.assertTrue(isinstance(io_digest.get_to_datetime(), datetime))
+
+        self.assertEqual(
+            # the assumed datetime given a date...
+            io_digest.get_from_datetime(),
+
+            # equals the localized datetime @ 0:00
+            None
+        )
+
+        self.assertEqual(
+            # the assumed datetime given a date...
+            io_digest.get_to_datetime(),
+
+            # equals the localized datetime @ 0:00
+            datetime.combine(
+                to_datetime.date(),
+                datetime.min.time(),
+                tzinfo=ZoneInfo(settings.TIME_ZONE)
+            )
+        )
+
+    def test_digest_entity(self):
+        entity_model = self.get_random_entity_model()
+        from_datetime = self.START_DATE
+        to_datetime = self.START_DATE + timedelta(days=randint(10, 60))
+
+        with self.assertRaises(IOValidationError):
+            entity_model.digest(
+                entity_slug='1234',
+                from_date=from_datetime,
+                to_date=to_datetime
+            )
+
+        io_digest = entity_model.digest(
+            entity_slug=entity_model.slug,
+            from_date=from_datetime,
+            to_date=to_datetime
+        )
+
+        self.assertTrue(isinstance(io_digest.IO_MODEL, EntityModel))
+        self.assertTrue(io_digest.get_io_data(), io_digest.IO_DATA)
+        self.assertTrue(io_digest.IO_DATA['entity_slug'], entity_model.slug)
+        self.assertFalse(io_digest.IO_DATA['by_activity'])
+        self.assertFalse(io_digest.IO_DATA['by_unit'])
+        self.assertFalse(io_digest.IO_DATA['by_tx_type'])
+
+        # io_digest = entity_model.digest(
+        #     unit_slug='3212',
+        #     from_date=from_datetime,
+        #     to_date=to_datetime
+        # )
+        #
+        # self.assertEqual(io_digest.get_io_txs_queryset().count(), 0)

django_ledger/tests/test_transactions.py

@@ -0,0 +1,290 @@
+from decimal import Decimal
+from random import choice, randint
+
+from django.contrib.auth import get_user_model
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.db.models import Count
+from django.db.utils import IntegrityError
+
+from django_ledger.forms.transactions import (
+    get_transactionmodel_formset_class,
+    TransactionModelForm,
+    TransactionModelFormSet
+)
+from django_ledger.io.io_core import get_localdate
+from django_ledger.models import (
+    TransactionModel, EntityModel, AccountModel, LedgerModel, JournalEntryModel,
+    TransactionModelValidationError, JournalEntryValidationError
+)
+from django_ledger.tests.base import DjangoLedgerBaseTest
+
+UserModel = get_user_model()
+
+
+class TransactionModelTest(DjangoLedgerBaseTest):
+
+    def test_invalid_balance(self):
+        entity_model = self.get_random_entity_model()
+        txs_model = self.get_random_transaction(entity_model=entity_model)
+
+        # transaction model does not allow for negative balances
+        txs_model.amount = Decimal('-100.00')
+
+        with self.assertRaises(ValidationError):
+            txs_model.full_clean()
+
+
+class TransactionModelFormTest(DjangoLedgerBaseTest):
+
+    def test_valid_data(self):
+        entity_model: EntityModel = self.get_random_entity_model()
+
+        account_model = str(self.get_random_account(entity_model=entity_model, balance_type='credit').uuid),
+        random_tx_type = choice([tx_type[0] for tx_type in TransactionModel.TX_TYPE])
+
+        form_data = {
+            'account': account_model[0],
+            'tx_type': random_tx_type,
+            'amount': Decimal(randint(10000, 99999)),
+            'description': 'Bought Something ...'
+        }
+
+        form = TransactionModelForm(form_data)
+
+        self.assertTrue(form.is_valid(), msg=f'Form is invalid with error: {form.errors}')
+        with self.assertRaises(IntegrityError):
+            form.save()
+
+    def test_invalid_tx_type(self):
+        account_model = choice(AccountModel.objects.filter(balance_type='credit'))
+        form = TransactionModelForm({
+            'account': account_model,
+            'tx_type': 'crebit patty',
+        })
+        self.assertFalse(form.is_valid(), msg='tx_type other than credit / debit shouldn\'t be valid')
+
+    def test_blank_data(self):
+        form = TransactionModelForm()
+        self.assertFalse(form.is_valid(), msg='Form without data is supposed to be invalid')
+
+    def test_invalid_account(self):
+        with self.assertRaises(ObjectDoesNotExist):
+            form = TransactionModelForm({
+                'account': 'Asset',
+            })
+            form.is_valid()
+
+
+class TransactionModelFormSetTest(DjangoLedgerBaseTest):
+
+    def get_random_txs_formsets(self,
+                                entity_model: EntityModel,
+                                ledger_model: LedgerModel = None,
+                                je_model: JournalEntryModel = None) -> TransactionModelFormSet:
+        """
+        Returns a TransactionModelFormSet with prefilled form data.
+        """
+
+        if ledger_model:
+            # if ledger model provided, get a je_model from provided ledger model...
+            je_model: JournalEntryModel = self.get_random_je(
+                entity_model=entity_model,
+                ledger_model=ledger_model
+            ) if not je_model else je_model
+
+        else:
+
+            # get a journal entry that has transactions...
+            je_model = JournalEntryModel.objects.for_entity(
+                entity_slug=entity_model,
+                user_model=self.user_model
+            ).annotate(
+                txs_count=Count('transactionmodel')).filter(
+                txs_count__gt=0).order_by('-timestamp').first()
+
+        TransactionModelFormSet = get_transactionmodel_formset_class(journal_entry_model=je_model)
+
+        txs_formset = TransactionModelFormSet(
+            entity_slug=entity_model.slug,
+            user_model=self.user_model,
+            je_model=je_model,
+            ledger_pk=je_model.ledger_id,
+        )
+        return txs_formset
+
+    def test_valid_formset(self):
+        """
+        Saved Transaction instances should have identical detail with initial formset.
+        """
+        entity_model: EntityModel = self.get_random_entity_model()
+        ledger_model: LedgerModel = self.get_random_ledger(entity_model=entity_model)
+        je_model: JournalEntryModel = self.get_random_je(entity_model=entity_model, ledger_model=ledger_model)
+        credit_account: AccountModel = self.get_random_account(entity_model=entity_model, balance_type='credit')
+        debit_account: AccountModel = self.get_random_account(entity_model=entity_model, balance_type='debit')
+        transaction_amount = Decimal.from_float(randint(10000, 99999))
+
+        txs_formset = self.get_random_txs_formsets(
+            entity_model=entity_model,
+            je_model=je_model,
+            ledger_model=ledger_model
+        )
+
+        self.assertTrue(
+            txs_formset.is_valid(),
+            msg=f"Formset is not valid, error: {txs_formset.errors}")
+
+        txs_instances = txs_formset.save(commit=False)
+        for txs in txs_instances:
+            if not txs.journal_entry_id:
+                txs.journal_entry_id = je_model.uuid
+
+        txs_instances = txs_formset.save()
+        for txs in txs_instances:
+            if txs.tx_type == 'credit':
+                self.assertEqual(
+                    txs.account, credit_account,
+                    msg=f'Saved Transaction record has mismatched Credit Account from the submitted formset. Saved:{txs.account} | form:{credit_account}')
+
+            elif txs.tx_type == 'debit':
+                self.assertEqual(
+                    txs.account, debit_account,
+                    msg=f'Saved Transaction record has mismatched Debit Account from the submitted formset. Saved:{txs.account} | form:{debit_account}')
+
+            self.assertEqual(
+                txs.amount, Decimal(transaction_amount),
+                msg=f'Saved Transaction record has mismatched total amount from the submitted formset. Saved:{txs.amount} | form:{transaction_amount}')
+
+    def test_imbalance_transactions(self):
+        """
+        Imbalanced Transactions should be invalid.
+        """
+        entity_model: EntityModel = self.get_random_entity_model()
+
+        txs_formset = self.get_random_txs_formsets(entity_model=entity_model)
+
+        self.assertFalse(
+            txs_formset.is_valid(),
+            msg=f"Formset is supposed to be invalid because of imbalance transaction"
+        )
+
+    def test_je_locked(self):
+        """
+        Transaction on locked a locked Journal Entry should fail.
+        """
+        entity_model: EntityModel = self.get_random_entity_model()
+        ledger_model: LedgerModel = self.get_random_ledger(
+            entity_model=entity_model
+        )
+
+        je_model: JournalEntryModel = self.get_random_je(
+            entity_model=entity_model,
+            ledger_model=ledger_model
+        )
+        je_model.mark_as_locked(commit=True, raise_exception=False)
+
+        self.assertTrue(je_model.is_locked())
+        txs_model = je_model.transactionmodel_set.all().first()
+        txs_model.amount += Decimal.from_float(1.00)
+
+        with self.assertRaises(TransactionModelValidationError):
+            txs_model.save()
+
+        with self.assertRaises(
+                TransactionModelValidationError,
+                msg=f'Cannot create transaction on locked Journal Entry'
+        ):
+            je_model.transactionmodel_set.create(
+                amount=Decimal.from_float(100.00),
+                account=self.get_random_account(entity_model=entity_model, balance_type='debit')
+            )
+
+    def test_ledger_lock(self):
+        """
+        Transaction on locked a locked Ledger should fail.
+        """
+        entity_model: EntityModel = self.get_random_entity_model()
+        ledger_model = self.get_random_ledger(entity_model=entity_model)
+        ledger_model.post(commit=True, raise_exception=False)
+        self.assertTrue(ledger_model.is_posted())
+        ledger_model.lock(commit=True, raise_exception=False)
+        self.assertTrue(ledger_model.is_locked())
+
+        with self.assertRaises(
+                JournalEntryValidationError,
+                msg='Cannot create Journal Entries on locked ledgers.'
+        ):
+            ledger_model.journal_entries.create(
+                timestamp=get_localdate(),
+                description='Test Journal Entry'
+            )
+
+        je_model = ledger_model.journal_entries.first()
+
+        with self.assertRaises(
+                JournalEntryValidationError,
+                msg='Cannot unpost journal entry on locked ledgers'
+        ):
+            je_model.mark_as_unposted(commit=True, raise_exception=True)
+
+
+class GetTransactionModelFormSetClassTest(DjangoLedgerBaseTest):
+
+    def test_unlocked_journal_entry_formset(self):
+        """
+        The Formset will contain 6 extra forms & delete fields if Journal Entry is unlocked.
+        """
+        entity_model: EntityModel = self.get_random_entity_model()
+        ledger_model: LedgerModel = self.get_random_ledger(entity_model=entity_model)
+        je_model: JournalEntryModel = self.get_random_je(entity_model=entity_model, ledger_model=ledger_model)
+        je_model.mark_as_unlocked(commit=True)
+
+        transaction_model_form_set = get_transactionmodel_formset_class(journal_entry_model=je_model)
+        txs_formset = transaction_model_form_set(
+            user_model=self.user_model,
+            je_model=je_model,
+            ledger_pk=ledger_model,
+            entity_slug=entity_model.slug,
+        )
+
+        self.assertTrue(not je_model.is_locked(),
+                        msg="At this point in this test case, Journal Entry should be unlocked.")
+
+        delete_field = '<input type="checkbox" name="form-0-DELETE" id="id_form-0-DELETE">'
+        self.assertInHTML(
+            delete_field,
+            txs_formset.as_table(),
+            msg_prefix='Transactions Formset with unlocked Journal Entry should have `can_delete` enabled'
+        )
+
+        self.assertEqual(len(txs_formset), 6,
+                         msg='Transactions Formset with unlocked Journal Entry should have 6 extras')
+
+    def test_locked_journal_entry_formset(self):
+        """
+        The Formset will contain no extra forms & only forms with Transaction if Journal Entry is locked.
+        """
+        entity_model: EntityModel = self.get_random_entity_model()
+        ledger_model: LedgerModel = self.get_random_ledger(entity_model=entity_model)
+        je_model: JournalEntryModel = self.get_random_je(entity_model=entity_model, ledger_model=ledger_model)
+        # transaction_pairs = randint(1, 12)
+        # self.get_random_transactions(entity_model=entity_model, je_model=je_model,
+        #                              pairs=transaction_pairs)  # Fill Journal Entry with Transactions
+
+        je_model.mark_as_locked(commit=True)
+        self.assertTrue(
+            je_model.is_locked(),
+            msg="Journal Entry should be locked in this test case")
+
+        transaction_model_form_set = get_transactionmodel_formset_class(journal_entry_model=je_model)
+
+        txs_formset = transaction_model_form_set(
+            user_model=self.user_model,
+            je_model=je_model,
+            ledger_pk=ledger_model,
+            entity_slug=entity_model.slug,
+            queryset=je_model.transactionmodel_set.all().order_by('account__code')
+        )
+
+        self.assertEqual(
+            len(txs_formset), (je_model.transactionmodel_set.count()),  # Convert pairs to total count
+            msg="Transactions Formset with unlocked Journal Entry did not match the expected count")

django_ledger/urls/account.py

@@ -3,15 +3,30 @@ from django.urls import path
 from django_ledger import views
 
 urlpatterns = [
+
+    # NO COA SLUG USES DEFAULT COA....
+    path('<slug:entity_slug>/create/',
+         views.AccountModelCreateView.as_view(),
+         name='account-create'),
     path('<slug:entity_slug>/list/',
          views.AccountModelListView.as_view(),
          name='account-list'),
     path('<slug:entity_slug>/list/active/',
          views.AccountModelListView.as_view(active_only=True),
          name='account-list-active'),
-    path('<slug:entity_slug>/create/',
+
+    # EXPLICIT COA...
+    path('<slug:entity_slug>/<slug:coa_slug>/create/',
          views.AccountModelCreateView.as_view(),
-         name='account-create'),
+         name='account-create-coa'),
+    path('<slug:entity_slug>/<slug:coa_slug>/list/',
+         views.AccountModelListView.as_view(),
+         name='account-list-coa'),
+    path('<slug:entity_slug>/<slug:coa_slug>/list/active/',
+         views.AccountModelListView.as_view(active_only=True),
+         name='account-list-active-coa'),
+
+    # Account Transaction Detail....
     path('<slug:entity_slug>/update/<uuid:account_pk>/',
          views.AccountModelUpdateView.as_view(),
          name='account-update'),
@@ -31,7 +46,7 @@ urlpatterns = [
          views.AccountModelDateDetailView.as_view(),
          name='account-detail-date'),
 
-    # Actions...
+    # Account Actions...
     path('<slug:entity_slug>/action/<uuid:account_pk>/activate/',
          views.AccountModelModelActionView.as_view(action_name='activate'),
          name='account-action-activate'),

django_ledger/urls/chart_of_accounts.py

@@ -3,5 +3,25 @@ from django.urls import path
 from django_ledger import views
 
 urlpatterns = [
-    path('<slug:entity_slug>/<slug:coa_slug>/update/', views.ChartOfAccountsUpdateView.as_view(), name='coa-update'),
+    path('<slug:entity_slug>/list/',
+         views.ChartOfAccountsListView.as_view(),
+         name='coa-list'),
+    path('<slug:entity_slug>/detail/<slug:coa_slug>/',
+         views.ChartOfAccountsListView.as_view(),
+         name='coa-detail'),
+    path('<slug:entity_slug>/update/<slug:coa_slug>/',
+         views.ChartOfAccountsUpdateView.as_view(),
+         name='coa-update'),
+
+    # ACTIONS....
+    path('<slug:entity_slug>/action/<slug:coa_slug>/mark-as-default/',
+         views.CharOfAccountModelActionView.as_view(action_name='mark_as_default'),
+         name='coa-action-mark-as-default'),
+    path('<slug:entity_slug>/action/<slug:coa_slug>/mark-as-active/',
+         views.CharOfAccountModelActionView.as_view(action_name='mark_as_active'),
+         name='coa-action-mark-as-active'),
+    path('<slug:entity_slug>/action/<slug:coa_slug>/mark-as-inactive/',
+         views.CharOfAccountModelActionView.as_view(action_name='mark_as_inactive'),
+         name='coa-action-mark-as-inactive'),
+
 ]

django_ledger/urls/ledger.py

@@ -50,4 +50,11 @@ urlpatterns = [
          views.LedgerModelModelActionView.as_view(action_name='unlock'),
          name='ledger-action-unlock'),
 
+    path('<slug:entity_slug>/action/<uuid:ledger_pk>/hide/',
+         views.LedgerModelModelActionView.as_view(action_name='hide'),
+         name='ledger-action-hide'),
+    path('<slug:entity_slug>/action/<uuid:ledger_pk>/unhide/',
+         views.LedgerModelModelActionView.as_view(action_name='unhide'),
+         name='ledger-action-unhide'),
+
 ]