wbaccounting 2.2.1__py2.py3-none-any.whl

wbaccounting/tests/test_serializers/test_transactions.py

@@ -0,0 +1,72 @@
+import factory
+import pytest
+from rest_framework.reverse import reverse
+from wbaccounting.models import Transaction
+from wbaccounting.serializers import (
+    TransactionModelSerializer,
+    TransactionRepresentationSerializer,
+)
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.directory.serializers import BankingContactRepresentationSerializer
+
+
+@pytest.mark.django_db
+class TestTransactionModelSerializer:
+    def test_serialize(self, transaction: Transaction):
+        # We need to add the currency symbol, which is usually done through the queryset in the viewset
+        transaction.bank_account_currency_symbol = transaction.bank_account.currency.symbol  # type: ignore
+
+        serializer = TransactionModelSerializer(transaction)
+        assert transaction.currency is not None
+        assert transaction.fx_rate is not None
+        assert transaction.value_local_ccy is not None
+        assert transaction.value is not None
+        assert serializer.data == {
+            "id": transaction.pk,
+            "description": transaction.description,
+            "booking_date": transaction.booking_date.strftime("%Y-%m-%d"),
+            "value_date": transaction.value_date.strftime("%Y-%m-%d"),
+            "bank_account": transaction.bank_account.id,
+            "_bank_account": BankingContactRepresentationSerializer(transaction.bank_account).data,
+            "from_bank_account": transaction.bank_account.id,
+            "_from_bank_account": BankingContactRepresentationSerializer(transaction.bank_account).data,
+            "to_bank_account": transaction.bank_account.id,
+            "_to_bank_account": BankingContactRepresentationSerializer(transaction.bank_account).data,
+            "currency": transaction.currency.pk,
+            "_currency": CurrencyRepresentationSerializer(transaction.currency).data,
+            "fx_rate": str(round(transaction.fx_rate, 4)),
+            "value_local_ccy": str(round(transaction.value_local_ccy, 2)),
+            "value": str(round(transaction.value, 2)),
+            "bank_account_currency_symbol": transaction.bank_account.currency.symbol,
+        }
+
+    def test_deserialize(self, transaction_factory, banking_contact):
+        data = factory.build(
+            dict,
+            FACTORY_CLASS=transaction_factory,
+            bank_account=banking_contact,
+        )
+
+        data["bank_account"] = data["bank_account"].id
+        data["from_bank_account"] = data["from_bank_account"].id
+        data["to_bank_account"] = data["to_bank_account"].id
+        data["currency"] = data["currency"].id
+        data["value"] = round(data["value"], 2)
+
+        serializer = TransactionModelSerializer(data=data)
+        assert serializer.is_valid()
+
+
+@pytest.mark.django_db
+class TestTransactionRepresentationSerializer:
+    def test_serialize(self, transaction: Transaction):
+        serializer = TransactionRepresentationSerializer(transaction)
+        assert transaction.value is not None
+        assert serializer.data == {
+            "id": transaction.pk,
+            "booking_date": transaction.booking_date.strftime("%Y-%m-%d"),
+            "bank_account": transaction.bank_account.id,
+            "_bank_account": BankingContactRepresentationSerializer(transaction.bank_account).data,
+            "value": str(round(transaction.value, 2)),
+            "_detail": reverse("wbaccounting:transaction-detail", args=[transaction.pk]),
+        }

wbaccounting/urls.py

@@ -0,0 +1,68 @@
+from django.urls import include, path
+from wbaccounting.viewsets import (
+    BookingEntryModelViewSet,
+    BookingEntryRepresentationViewSet,
+    ConsolidatedInvoiceViewSet,
+    EntryAccountingInformationModelViewSet,
+    EntryAccountingInformationRepresentationViewSet,
+    FutureCashFlowPandasAPIViewSet,
+    FutureCashFlowTransactionsPandasAPIViewSet,
+    InvoiceModelViewSet,
+    InvoiceRepresentationViewSet,
+    InvoiceTypeModelViewSet,
+    InvoiceTypeRepresentationViewSet,
+    TransactionModelViewSet,
+    TransactionRepresentationViewSet,
+)
+from wbcore.routers import WBCoreRouter
+
+router = WBCoreRouter()
+router.register(r"bookingentry", BookingEntryModelViewSet, basename="bookingentry")
+router.register(
+    r"bookingentryrepresentation", BookingEntryRepresentationViewSet, basename="bookingentryrepresentation"
+)
+router.register(r"invoice", InvoiceModelViewSet, basename="invoice")
+router.register(r"invoicerepresentation", InvoiceRepresentationViewSet, basename="invoicerepresentation")
+router.register(r"transaction", TransactionModelViewSet, basename="transaction")
+router.register(r"transactionrepresentation", TransactionRepresentationViewSet, basename="transactionrepresentation")
+router.register(r"consolidated-invoice", ConsolidatedInvoiceViewSet, basename="consolidated-invoice")
+router.register(r"invoicetype", InvoiceTypeModelViewSet, basename="invoicetype")
+router.register(r"invoicetyperepresentation", InvoiceTypeRepresentationViewSet, basename="invoicetyperepresentation")
+router.register(
+    r"entryaccountinginformationrepresentation",
+    EntryAccountingInformationRepresentationViewSet,
+    basename="entryaccountinginformationrepresentation",
+)
+router.register(
+    r"entryaccountinginformation", EntryAccountingInformationModelViewSet, basename="entryaccountinginformation"
+)
+router.register(r"futurecashflow", FutureCashFlowPandasAPIViewSet, basename="futurecashflow")
+router.register(
+    r"futurecashflowtransaction", FutureCashFlowTransactionsPandasAPIViewSet, basename="futurecashflowtransaction"
+)
+
+entry_router = WBCoreRouter()
+
+invoice_router = WBCoreRouter()
+invoice_router.register(r"bookingentry", BookingEntryModelViewSet, basename="invoice-bookingentry")
+
+entry_accounting_information_router = WBCoreRouter()
+entry_accounting_information_router.register(
+    r"invoice", InvoiceModelViewSet, basename="entryaccountinginformation-invoice"
+)
+entry_accounting_information_router.register(
+    r"bookingentry", BookingEntryModelViewSet, basename="entryaccountinginformation-bookingentry"
+)
+
+booking_entry_router = WBCoreRouter()
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("entry/<int:entry_id>/", include(entry_router.urls)),
+    path("invoice/<int:invoice_id>/", include(invoice_router.urls)),
+    path("bookingentry/<int:booking_entry_id>/", include(booking_entry_router.urls)),
+    path(
+        "entryaccountinginformation/<int:entry_accounting_information_id>/",
+        include(entry_accounting_information_router.urls),
+    ),
+]

wbaccounting/viewsets/__init__.py

@@ -0,0 +1,12 @@
+from .booking_entry import (
+    BookingEntryModelViewSet,
+    BookingEntryRepresentationViewSet,
+)
+from .entry_accounting_information import (
+    EntryAccountingInformationModelViewSet,
+    EntryAccountingInformationRepresentationViewSet,
+)
+from .invoice_type import InvoiceTypeModelViewSet, InvoiceTypeRepresentationViewSet
+from .invoice import InvoiceModelViewSet, ConsolidatedInvoiceViewSet, InvoiceRepresentationViewSet
+from .transactions import TransactionModelViewSet, TransactionRepresentationViewSet
+from .cashflows import FutureCashFlowPandasAPIViewSet, FutureCashFlowTransactionsPandasAPIViewSet

wbaccounting/viewsets/booking_entry.py

@@ -0,0 +1,61 @@
+from django.db.models import QuerySet
+from wbaccounting.models import BookingEntry
+from wbaccounting.serializers import (
+    BookingEntryModelSerializer,
+    BookingEntryRepresentationSerializer,
+)
+from wbaccounting.viewsets.buttons import BookingEntryButtonConfig
+from wbaccounting.viewsets.display import BookingEntryDisplayConfig
+from wbaccounting.viewsets.titles import BookingEntryTitleConfig
+from wbcore import viewsets
+
+
+class BookingEntryRepresentationViewSet(viewsets.RepresentationViewSet):
+    search_fields = ["counterparty__computed_str", "title", "currency__key"]
+    ordering_fields = ["title"]
+    ordering = ["title"]
+    serializer_class = BookingEntryRepresentationSerializer
+    queryset = BookingEntry.objects.all()
+
+    def get_queryset(self):
+        return BookingEntry.objects.filter_for_user(self.request.user)
+
+
+class BookingEntryModelViewSet(viewsets.ModelViewSet):
+    filterset_fields = {
+        "counterparty": ["exact"],
+        "booking_date": ["gte", "exact", "lte"],
+        "reference_date": ["gte", "exact", "lte"],
+    }
+    search_fields = ["counterparty__computed_str", "title", "currency__key"]
+    ordering_fields = (
+        "counterparty__computed_str",
+        "booking_date",
+        "gross_value",
+        "net_value",
+        "reference_date",
+    )
+    ordering = ["-booking_date"]
+
+    serializer_class = BookingEntryModelSerializer
+    queryset = BookingEntry.objects.all()
+
+    button_config_class = BookingEntryButtonConfig
+    display_config_class = BookingEntryDisplayConfig
+    title_config_class = BookingEntryTitleConfig
+
+    def get_queryset(self) -> QuerySet[BookingEntry]:
+        booking_entries = BookingEntry.objects.filter_for_user(self.request.user)
+
+        if eai_id := self.kwargs.get("entry_accounting_information_id", None):
+            booking_entries = booking_entries.filter(counterparty__entry_accounting_information__id=eai_id)
+
+        if invoice_id := self.kwargs.get("invoice_id", None):
+            booking_entries = booking_entries.filter(invoice_id=invoice_id)
+
+        return booking_entries.select_related(
+            "counterparty",
+            "invoice",
+            "currency",
+            "invoice__invoice_currency",
+        )

wbaccounting/viewsets/buttons/__init__.py

@@ -0,0 +1,3 @@
+from .entry_accounting_information import EntryAccountingInformationButtonConfig
+from .booking_entry import BookingEntryButtonConfig
+from .invoice import InvoiceButtonConfig, ConsolidatedInvoiceButtonConfig

wbaccounting/viewsets/buttons/booking_entry.py

@@ -0,0 +1,15 @@
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+
+class BookingEntryButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        return {
+            buttons.WidgetButton(
+                key="appended_booking_entries", label="Appended Booking Entries", icon=WBIcon.NOTEBOOK.icon
+            )
+        }
+
+    def get_custom_list_instance_buttons(self):
+        return self.get_custom_instance_buttons()

wbaccounting/viewsets/buttons/entry_accounting_information.py

@@ -0,0 +1,100 @@
+from django.dispatch import receiver
+from rest_framework.reverse import reverse
+from wbcore import serializers
+from wbcore.contrib.directory.serializers import EntryRepresentationSerializer
+from wbcore.contrib.directory.viewsets import (
+    CompanyModelViewSet,
+    EntryModelViewSet,
+    PersonModelViewSet,
+)
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbcore.signals.instance_buttons import add_instance_button
+from wbcore.utils.date import current_quarter_date_end, current_quarter_date_start
+
+
+class StartEndParametersSerializer(serializers.Serializer):
+    start = serializers.DateField(default=current_quarter_date_start(), label="Start")
+    end = serializers.DateField(default=current_quarter_date_end(), label="End")
+
+
+class CounterpartiesSerializer(serializers.Serializer):
+    counterparties = serializers.PrimaryKeyRelatedField(many=True)
+    _counterparties = EntryRepresentationSerializer(many=True, source="counterparties")
+
+
+class StartEndParametersWithCounterpartiesSerializer(CounterpartiesSerializer, StartEndParametersSerializer):
+    ...
+
+
+class EntryAccountingInformationButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self) -> set:
+        if not self.instance:
+            return {
+                buttons.ActionButton(
+                    method=RequestType.POST,
+                    identifiers=("wbaccounting:bookingentry",),
+                    endpoint=reverse(
+                        "wbaccounting:entryaccountinginformation-generate-booking-entries-for-counterparties",
+                        request=self.request,
+                    ),
+                    label="Generate Booking Entries",
+                    description_fields="""<p>Generate Booking Entries between {{start}} and {{end}}?</p>""",
+                    action_label="Generate Booking Entries",
+                    title="Generate Booking Entries",
+                    serializer=StartEndParametersWithCounterpartiesSerializer,
+                    instance_display=create_simple_display([["start"], ["end"], ["counterparties"]]),
+                ),
+                buttons.ActionButton(
+                    method=RequestType.POST,
+                    identifiers=("wbaccounting:invoice",),
+                    endpoint=reverse(
+                        "wbaccounting:entryaccountinginformation-generate-invoices-for-counterparties",
+                        request=self.request,
+                    ),
+                    label="Invoice outstanding Bookings",
+                    description_fields="""<p>Invoice outstanding bookings? If you don't supply counterparties, all counterparties will be considered</p>""",
+                    action_label="Invoice outstanding Bookings",
+                    title="Invoice outstanding Bookings",
+                    serializer=CounterpartiesSerializer,
+                    instance_display=create_simple_display([["counterparties"]]),
+                ),
+            }
+        return set()
+
+    def get_custom_instance_buttons(self) -> set:
+        return {
+            buttons.ActionButton(
+                method=RequestType.POST,
+                identifiers=("wbaccounting:bookingentry",),
+                key="generate_booking_entries",
+                label="Generate Booking Entries",
+                description_fields="""<p>Generate Booking Entries between {{start}} and {{end}}?</p>""",
+                action_label="Generate Booking Entries",
+                title="Generate Booking Entries",
+                serializer=StartEndParametersSerializer,
+                instance_display=create_simple_display([["start"], ["end"]]),
+            ),
+            buttons.ActionButton(
+                method=RequestType.POST,
+                identifiers=("wbaccounting:invoice",),
+                key="invoice_booking_entries",
+                label="Invoice Booking Entries",
+                description_fields="<p>Do you want to invoice all outstanding booking entries?</p>",
+                action_label="Invoice Booking Entries",
+                title="Invoice Booking Entries",
+            ),
+        }
+
+
+@receiver(add_instance_button, sender=PersonModelViewSet)
+@receiver(add_instance_button, sender=EntryModelViewSet)
+@receiver(add_instance_button, sender=CompanyModelViewSet)
+def entry_adding_instance_buttons(sender, many, *args, **kwargs):
+    if not many:
+        return buttons.WidgetButton(key="accounting-information", label="Accounting", icon=WBIcon.MAIL_OPEN.icon)

wbaccounting/viewsets/buttons/invoice.py

@@ -0,0 +1,65 @@
+from rest_framework.reverse import reverse
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+
+class InvoiceBaseButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        return {bt.HyperlinkButton(key="invoice_file", label="Invoice", icon=WBIcon.DOCUMENT.icon)}
+
+    def get_custom_list_instance_buttons(self):
+        return self.get_custom_instance_buttons()
+
+
+class InvoiceButtonConfig(InvoiceBaseButtonConfig):
+    def get_custom_buttons(self) -> set:
+        buttons = super().get_custom_buttons()
+        if not (self.view.kwargs.get("pk") or self.new_mode):
+            buttons.add(
+                bt.WidgetButton(
+                    label="Consolidated Invoices",
+                    endpoint=reverse("wbaccounting:consolidated-invoice-list", args=[], request=self.request),
+                )
+            )
+        return buttons
+
+
+class ConsolidatedInvoiceButtonConfig(InvoiceBaseButtonConfig):
+    def get_custom_list_instance_buttons(self) -> set:
+        return {
+            bt.ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbaccounting:invoice",),
+                label="Approve ({{num_submitted}})",
+                description_fields="""
+                        <p>Do you want to approve all {{num_submitted}} submitted invoices?</p>
+                        """,
+                action_label="Approving",
+                title="Approve",
+                key="approve",
+            ),
+            bt.ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbaccounting:invoice",),
+                label="Submit ({{num_draft}})",
+                description_fields="""
+                        <p>Do you want to submit {{num_draft}} invoices?</p>
+                        """,
+                action_label="Submitting",
+                title="Submit",
+                key="submit",
+            ),
+            bt.ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbaccounting:invoice",),
+                label="Pay ({{num_sent}})",
+                description_fields="""
+                        <p>Do you want to pay all {{num_sent}} invoices?</p>
+                        """,
+                action_label="Payment",
+                title="Pay",
+                key="pay",
+            ),
+        }

wbaccounting/viewsets/cashflows.py

@@ -0,0 +1,124 @@
+from datetime import date, datetime
+from typing import TYPE_CHECKING, Any
+
+import pandas as pd
+from django.db.models import DateField, F, Sum, Value
+from wbaccounting.models import Transaction
+from wbaccounting.viewsets.display import FutureCashFlowDisplayConfig
+from wbcore.pandas import fields as pf
+from wbcore.pandas.views import PandasAPIViewSet
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+    from django.db.models.query import ValuesQuerySet
+    from rest_framework.request import Request
+
+
+class FutureCashFlowPandasAPIViewSetMixin(PandasAPIViewSet):
+    DATE_COL_START = 0
+    BOLD = False
+
+    queryset = Transaction.objects.none()
+    display_config_class = FutureCashFlowDisplayConfig
+
+    def get_pandas_fields(self, request) -> pf.PandasFields:
+        fields = self.get_dataframe(request, self.get_queryset()).columns[self.DATE_COL_START :]
+        return pf.PandasFields(
+            fields=[
+                pf.PKField(key="bank_account__id", label="ID"),
+                pf.CharField(key="_group_key", label="GROUPKEY"),
+                pf.CharField(key="bank_account__iban", label="IBAN"),
+                pf.CharField(key="bank_account__currency__symbol", label="Currency"),
+                *[
+                    pf.FloatField(
+                        key=field,
+                        label=datetime.strptime(field, "%Y-%m-%d").strftime("%d.%m.%Y"),
+                        display_mode=pf.DisplayMode.SHORTENED,
+                    )
+                    for field in fields
+                ],
+            ]
+        )
+
+
+class FutureCashFlowPandasAPIViewSet(FutureCashFlowPandasAPIViewSetMixin):
+    DATE_COL_START = 4
+    BOLD = True
+
+    def get_queryset(self) -> "ValuesQuerySet[Transaction, Any]":
+        base_queryset = Transaction.objects.filter_for_user(self.request.user)
+        if banking_contact_ids := self.request.GET.get("banking_contact"):
+            base_queryset = base_queryset.filter(bank_account__id__in=banking_contact_ids.split(","))
+
+        past_transactions = (
+            base_queryset.filter(prenotification=False)
+            .values("bank_account__id")
+            .annotate(
+                value_date=Value(date.today(), output_field=DateField()),
+                balance=Sum("value"),
+                _group_key=F("bank_account__id"),
+            )
+            .values(
+                "bank_account__id",
+                "bank_account__iban",
+                "bank_account__currency__symbol",
+                "value_date",
+                "balance",
+                "_group_key",
+            )
+        )
+
+        future_transactions = (
+            base_queryset.filter(prenotification=True, value_date__gt=date.today())
+            .values("bank_account__id", "value_date")
+            .annotate(balance=Sum("value"), _group_key=F("bank_account__id"))
+            .values(
+                "bank_account__id",
+                "bank_account__iban",
+                "bank_account__currency__symbol",
+                "value_date",
+                "balance",
+                "_group_key",
+            )
+        )
+
+        return past_transactions.union(future_transactions)
+
+    def get_dataframe(
+        self, request: "Request", queryset: "ValuesQuerySet[Transaction, Any]", **kwargs
+    ) -> pd.DataFrame:
+        if not queryset.exists():
+            return pd.DataFrame()
+        df = (
+            pd.DataFrame(queryset)
+            .pivot_table(
+                index=["bank_account__id", "bank_account__iban", "bank_account__currency__symbol", "_group_key"],
+                columns=["value_date"],
+                values="balance",
+            )
+            .astype(float)
+            .fillna(0)
+            .cumsum(axis=1)
+        )
+        df.columns = df.columns.astype(str)
+        return df.reset_index()
+
+
+class FutureCashFlowTransactionsPandasAPIViewSet(FutureCashFlowPandasAPIViewSetMixin):
+    DATE_COL_START = 2
+
+    def get_queryset(self):
+        queryset = Transaction.objects.filter(prenotification=True, value_date__gt=date.today())
+        if bank_account := self.request.GET.get("bank_account", None):
+            return queryset.filter(bank_account_id=bank_account)
+        return queryset
+
+    def get_dataframe(self, request: "Request", queryset: "QuerySet[Transaction]", **kwargs) -> pd.DataFrame:
+        df = pd.DataFrame(
+            queryset.values_list("description", "value", "value_date"), columns=["description", "value", "value_date"]
+        ).pivot_table(index=["description"], columns=["value_date"], values="value")
+        df.columns = df.columns.astype(str)
+        df = df.reset_index()
+        df = df.rename(columns={"description": "bank_account__iban"})
+        df.insert(0, "bank_account__id", df["bank_account__iban"])
+        return df

wbaccounting/viewsets/display/__init__.py

@@ -0,0 +1,8 @@
+from .booking_entry import BookingEntryDisplayConfig
+from .invoice import InvoiceDisplayConfig, ConsolidatedInvoiceDisplayConfig
+from .invoice_type import InvoiceTypeDisplayConfig
+from .entry_accounting_information import (
+    EntryAccountingInformationDisplayConfig,
+)
+from .transactions import TransactionDisplayConfig
+from .cashflows import FutureCashFlowDisplayConfig

wbaccounting/viewsets/display/booking_entry.py

@@ -0,0 +1,58 @@
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class BookingEntryDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> dp.ListDisplay:
+        _counterparty_fields = [dp.Field(key="counterparty", label="Counterparty")]
+        _common_fields = [
+            dp.Field(key="booking_date", label="Book. Date", width=100),
+            dp.Field(key="reference_date", label="Ref. Date", width=100),
+            dp.Field(key="payment_date", label="Payment. Date", width=100),
+            dp.Field(key="title", label="Title", width=325),
+            dp.Field(key="vat", label="VAT", width=100),
+            dp.Field(key="gross_value", label="Gross", width=100),
+            dp.Field(key="net_value", label="Net", width=100),
+        ]
+        _invoice_fields = [dp.Field(key="invoice", label="Invoice", width=325)]
+
+        if "invoice_id" in self.view.kwargs:
+            return dp.ListDisplay(fields=_common_fields)
+
+        if "entry_accounting_information_id" in self.view.kwargs:
+            return dp.ListDisplay(fields=[*_common_fields, *_invoice_fields])
+
+        return dp.ListDisplay(fields=[*_counterparty_fields, *_common_fields, *_invoice_fields])
+
+    def get_instance_display(self) -> dp.Display:
+        return dp.Display(
+            pages=[
+                dp.Page(
+                    layouts={
+                        dp.default(): dp.Layout(
+                            grid_template_areas=[
+                                ["title", "title", "title", "counterparty", ".", "booking_date"],
+                                ["currency", "vat", "gross_value", "net_value", ".", "reference_date"],
+                                [
+                                    "invoice_currency",
+                                    "invoice_fx_rate",
+                                    "invoice_gross_value",
+                                    "invoice_net_value",
+                                    ".",
+                                    "due_date",
+                                ],
+                                ["invoice", "invoice", "invoice", "invoice", ".", "payment_date"],
+                            ],
+                            grid_template_columns=[
+                                "100px",
+                                "100px",
+                                "200px",
+                                "200px",
+                                "25px",
+                                "150px",
+                            ],
+                        )
+                    }
+                )
+            ]
+        )

wbaccounting/viewsets/display/cashflows.py

@@ -0,0 +1,58 @@
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+from wbcore.utils.models import WBColor
+
+if TYPE_CHECKING:
+    from wbaccounting.viewsets.cashflows import FutureCashFlowPandasAPIViewSetMixin
+
+
+class FutureCashFlowDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> dp.ListDisplay:
+        view: "FutureCashFlowPandasAPIViewSetMixin" = self.view  # type: ignore
+        fields = view.get_dataframe(self.request, view.get_queryset()).columns[view.DATE_COL_START :]
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="bank_account__currency__symbol", label="Currency"),
+                *[
+                    dp.Field(
+                        key=field,
+                        label=datetime.strptime(field, "%Y-%m-%d").strftime("%d.%m.%Y"),
+                        formatting_rules=[
+                            dp.FormattingRule(
+                                style={"color": WBColor.GREEN_DARK.value},
+                                condition=(">=", 0),
+                            ),
+                            dp.FormattingRule(
+                                style={"color": WBColor.RED_DARK.value},
+                                condition=("<", 0),
+                            ),
+                            *[
+                                dp.FormattingRule(style={"fontWeight": "bold"})
+                                if view.BOLD
+                                else dp.FormattingRule(style={"fontWeight": "normal"})
+                            ],
+                        ],
+                    )
+                    for field in fields
+                ],
+            ],
+            tree=True,
+            tree_group_field="bank_account__iban",
+            tree_group_label="IBAN",
+            tree_group_level_options=[
+                dp.TreeGroupLevelOption(
+                    filter_depth=1,
+                    lookup="bank_account__id",
+                    filter_key="bank_account",
+                    list_endpoint=reverse(
+                        "wbaccounting:futurecashflowtransaction-list",
+                        args=[],
+                        request=self.request,
+                    ),
+                )
+            ],
+        )