Can't seem to figure out of the link Transactions and Account correctly

[nicoferreira90]

Hey everybody. I guess there isn't any other better place to post this, so here it goes:

I'm working on a project where I'm trying to integrate pretty much every Django Ledger model:

• Entity, Ledgers, Journal Entries and Transactions to keep track of an individual customer's activity;
• Entity, Chart of Accounts, Accounts and Transactions to keep some global Accounts of the project's results.

I am getting an error though, when a Journal Entry is Posted and I try to access the Balance Sheet:

NoReverseMatch at /ledger/financial-statement/ledger/my-p2p-business-260-entity-ti1eo8c9/96d64465-1089-413d-b47e-326dacc10b6b/balance-sheet/year/2025/

Reverse for 'account-detail' with keyword arguments '{'entity_slug': 'my-p2p-business-260-entity-ti1eo8c9', 'account_pk': UUID('50dd8417-9c0f-4ff0-81e1-09c494fff480')}' not found. 1 pattern(s) tried: ['ledger/account/(?P<entity_slug>[-a-zA-Z0-9_]+)/(?P<coa_slug>[-a-zA-Z0-9_]+)/detail/(?P<account_pk>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/\Z']

This anchor is the culprit:

<a href="{% url 'django_ledger:account-detail' entity_slug=tx_digest.entity_slug account_pk=acc.account_uuid %}"
class="dropdown-item has-text-success">{% trans 'Detail' %}</a>

If no Journal Entry is posted, it correctly takes me to an empty Ledger balance sheet.

I'm pretty sure I'm doing something wrong with regards to the connection between Transactions and Accounts. So far I can get the Transactions in the customer's (Taker) Ledger to correctly feed into the Global CoA's Account, but something seems broken at the Ledger level.

Any help would be very appreciated. Here is much of the code I'm working with:

(It's probably clear I don't entirely know what I'm doing. There's some logic for creating the Entity's Global CoA and the Accounts involved elsewhere, but I don't think that's where the problem lays)

from decimal import Decimal
from django.db import transaction
from django.utils import timezone
from django_ledger.models.journal_entry import JournalEntryModel
from django_ledger.models.transactions import TransactionModel
from django_ledger.models.accounts import AccountModel
from django_ledger.io import roles
from apps.orders.models import Order


class OrderLedgerService:
    """Service class to manage ledger transactions for orders."""

    @staticmethod
    def _get_or_create_account(coa_model, code, name, role, balance_type):
        """Helper method to get or create accounts consistently."""
        try:
            return AccountModel.objects.get(coa_model=coa_model, code=code)
        except AccountModel.DoesNotExist:
            entity = coa_model.entity
            return entity.create_account(
                code=code,
                name=name,
                role=role,
                balance_type=balance_type,
                active=True,
                coa_model=coa_model,
            )

    @staticmethod
    def confirm_payment(order: Order, paid_amount: Decimal, bank_reference: str = None):
        """
        Confirm that payment has been received from taker.
        This will create appropriate journal entries to record the payment.
        """
        if order.payment_status not in ["PENDING", "PARTIAL"]:
            raise ValueError(
                f"Order {order.order_number} is not in pending or partial payment status"
            )

        if not order.taker or not order.taker.ledger:
            raise ValueError("Order must have an associated taker with a ledger")

        # Calculate expected amount and validate payment
        expected_amount = order.expected_amount or order.total_price
        total_paid = (order.paid_amount or Decimal("0")) + paid_amount

        if paid_amount <= 0:
            raise ValueError("Paid amount must be greater than 0")

        if total_paid > expected_amount:
            raise ValueError(
                f"Total paid amount ({total_paid}) exceeds expected amount ({expected_amount})"
            )

        with transaction.atomic():
            # Update order payment information
            order.paid_amount = total_paid
            order.bank_reference = bank_reference

            # Determine payment status based on amount
            if total_paid >= expected_amount:
                order.payment_status = "PAID"
                order.payment_confirmed_at = timezone.now()
            else:
                order.payment_status = "PARTIAL"

            order.save()

            # Create journal entry for payment received
            journal_entry = JournalEntryModel.objects.create(
                ledger=order.taker.ledger,
                description=f"Payment: {paid_amount} {order.fiat_unit} - Ref: {bank_reference[:10] if bank_reference else 'N/A'}",
                posted=False,
            )

            # Get COA model
            entity = order.business.entity
            coa_model = entity.default_coa or entity.chartofaccountmodel_set.first()
            if not coa_model:
                raise ValueError(f"No Chart of Accounts found for entity {entity}")

            # Get the specific business accounts
            cash_account = OrderLedgerService._get_or_create_account(
                coa_model,
                "1000",
                "Banco BCI - Cuenta Corriente",
                roles.ASSET_CA_CASH,
                "debit",
            )

            pending_clients_account = OrderLedgerService._get_or_create_account(
                coa_model,
                "1500",
                "Saldos Pendientes de Clientes",
                roles.ASSET_CA_RECEIVABLES,
                "debit",
            )

            # Create transactions: Add to cash (1000), subtract from pending clients (1500)
            TransactionModel.objects.create(
                journal_entry=journal_entry,
                account=cash_account,
                amount=paid_amount,
                tx_type=TransactionModel.DEBIT,
            )

            TransactionModel.objects.create(
                journal_entry=journal_entry,
                account=pending_clients_account,
                amount=paid_amount,
                tx_type=TransactionModel.CREDIT,
            )

            # Post the journal entry (this validates and marks as posted)
            journal_entry.posted = True
            journal_entry.save()
            return order

[nicoferreira90]

or could it be a bug on Django Ledger's frontend...?

edit: it seems it was a frontend bug on Django Ledger's end, I fixed it by switching to a newer version

[elarroba]

Hello @nicoferreira90 . The error you are getting is because you are missing the coa_slug key-word argument when resolving the account-detail url. Here's the url pattern from the url/accounts.py file:

    path('<slug:entity_slug>/<slug:coa_slug>/detail/<uuid:account_pk>/',
         views.AccountModelDetailView.as_view(),
         name='account-detail'),

Change the url reverse match to the following and if the issue is resolved:

<a href="{% url 'django_ledger:account-detail' entity_slug=tx_digest.entity_slug coa_slug=acc.coa_model.slug account_pk=acc.account_uuid %}"
class="dropdown-item has-text-success">{% trans 'Detail' %}</a>

Alternatively you can use the get_absolute_url method on the AccountModel:

<a href="acc.get_absolute_url" class="dropdown-item has-text-success">{% trans 'Detail' %}</a>