wbaccounting 2.2.1__py2.py3-none-any.whl

wbaccounting/models/model_tasks.py

@@ -0,0 +1,71 @@
+from contextlib import suppress
+from datetime import date
+
+from celery import shared_task
+from django.db.models.signals import post_save
+from django.utils.module_loading import import_string
+from wbaccounting.generators.base import generate_booking_entries
+from wbcore.contrib.directory.models import Entry
+
+
+@shared_task
+def submit_invoices_as_task(ids: list[int]):
+    from wbaccounting.models import Invoice
+
+    invoices = Invoice.objects.filter(id__in=ids)
+    for invoice in invoices:
+        invoice.submit()
+        invoice.save()
+
+
+@shared_task
+def approve_invoices_as_task(ids: list[int]):
+    from wbaccounting.models import Invoice
+
+    invoices = Invoice.objects.filter(id__in=ids)
+    for invoice in invoices:
+        invoice.approve()
+        invoice.save()
+
+
+@shared_task
+def pay_invoices_as_task(ids: list[int]):
+    from wbaccounting.models import Invoice
+
+    invoices = Invoice.objects.filter(id__in=ids)
+    for invoice in invoices:
+        invoice.pay()
+        invoice.save()
+
+
+@shared_task
+def refresh_complete_invoice_as_task(invoice_id: int):
+    from wbaccounting.models import Invoice
+    from wbaccounting.models.booking_entry import BookingEntry, booking_entry_changed
+
+    # We temmporarily disconnect the post_save hook in order to not regenerate the invoice over and over again
+    post_save.disconnect(booking_entry_changed, sender=BookingEntry)
+
+    for booking_entry in BookingEntry.objects.filter(invoice_id=invoice_id):
+        booking_entry.save()
+
+    Invoice.objects.get(id=invoice_id).save()
+
+    # We reattach the post_save hook
+    post_save.connect(booking_entry_changed, sender=BookingEntry)
+
+
+@shared_task
+def refresh_invoice_document_as_task(invoice_id):
+    from wbaccounting.models import Invoice
+
+    invoice = Invoice.objects.get(id=invoice_id)
+    invoice.refresh_invoice_document()
+
+
+@shared_task
+def generate_booking_entries_as_task(func: str, from_date: date, to_date: date, counterparty_id: int):
+    with suppress(ImportError):
+        generator = import_string(func)
+        counterparty = Entry.objects.get(id=counterparty_id)
+        generate_booking_entries(generator, from_date, to_date, counterparty)

wbaccounting/models/transactions.py

@@ -0,0 +1,112 @@
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+from django.db import models
+from django.utils.translation import gettext as _
+from wbaccounting.io.handlers.transactions import TransactionImportHandler
+from wbcore.contrib.io.mixins import ImportMixin
+from wbcore.models import WBModel
+
+if TYPE_CHECKING:
+    from wbcore.contrib.authentication.models import User
+
+
+class TransactionQuerySet(models.QuerySet):
+    def filter_for_user(self, user: "User") -> models.QuerySet["Transaction"]:
+        if user.is_superuser:
+            return self
+
+        return self.filter(bank_account__access__user_account__in=[user])
+
+
+class Transaction(ImportMixin, WBModel):
+    """A transaction represents a bank transfer of some funds in some currency from one Bank Account to another one."""
+
+    import_export_handler_class = TransactionImportHandler
+
+    booking_date = models.DateField(verbose_name=_("Booking Date"))
+    value_date = models.DateField(verbose_name=_("Value Date"))
+
+    bank_account = models.ForeignKey(
+        to="directory.BankingContact",
+        related_name="wbaccounting_transactions",
+        on_delete=models.PROTECT,
+        verbose_name=_("Linked Bank Account"),
+    )
+    from_bank_account = models.ForeignKey(
+        to="directory.BankingContact",
+        related_name="+",
+        null=True,
+        blank=True,
+        on_delete=models.PROTECT,
+        verbose_name=_("Source Bank Account"),
+    )
+    to_bank_account = models.ForeignKey(
+        to="directory.BankingContact",
+        related_name="+",
+        null=True,
+        blank=True,
+        on_delete=models.PROTECT,
+        verbose_name=_("Target Bank Account"),
+    )
+    currency = models.ForeignKey(
+        to="currency.Currency",
+        related_name="+",
+        null=True,
+        blank=True,
+        on_delete=models.PROTECT,
+        verbose_name=_("Currency"),
+    )
+    fx_rate = models.DecimalField(default=Decimal(1), max_digits=10, decimal_places=4, verbose_name=_("FX Rate"))
+    value_local_ccy = models.DecimalField(
+        max_digits=19, decimal_places=2, null=True, blank=True, verbose_name=_("Value (Local Currency)")
+    )
+    value = models.DecimalField(max_digits=19, decimal_places=2, null=True, blank=True, verbose_name=_("Value"))
+    description = models.TextField(default="")
+    prenotification = models.BooleanField(
+        default=False,
+        verbose_name=_("Prenotification"),
+        help_text=_("This field indicates that this transaction will happen sometime in the future."),
+    )
+    _hash = models.CharField(max_length=64, null=True, blank=True)
+
+    objects = TransactionQuerySet.as_manager()
+
+    def save(self, *args, **kwargs):
+        # We make sure that the relationship between value and
+        # value_local_ccy stays consistant while prefering value
+        if self.value is not None:
+            self.value_local_ccy = self.value / self.fx_rate
+
+        elif self.value_local_ccy is not None:
+            self.value = self.value_local_ccy * self.fx_rate
+
+        # If value date is not set we set it to the booking date
+        if self.value_date is None:
+            self.value_date = self.booking_date
+
+        super().save(*args, **kwargs)
+
+    def __str__(self) -> str:
+        return f"{self.booking_date:%d.%m.%Y}: {self.value:.2f}"
+
+    class Meta:
+        default_related_name = "transactions"
+        verbose_name = _("Transaction")
+        verbose_name_plural = _("Transactions")
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbaccounting:transaction"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbaccounting:transactionrepresentation-list"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{booking_date}}: {{value}}"

wbaccounting/permissions.py

@@ -0,0 +1,6 @@
+from rest_framework.permissions import BasePermission
+
+
+class IsInvoiceAdmin(BasePermission):
+    def has_permission(self, request, view):
+        return request.user.has_perm("wbaccounting.administrate_invoice")

wbaccounting/processors/dummy_processor.py

@@ -0,0 +1,5 @@
+from wbaccounting.models import Invoice
+
+
+def processor(invoice: Invoice):
+    print(f"I am a dummy processor that processes the Invoice: {invoice}")  # noqa

wbaccounting/serializers/__init__.py

@@ -0,0 +1,12 @@
+from .invoice_type import InvoiceTypeModelSerializer, InvoiceTypeRepresentationSerializer
+from .entry_accounting_information import (
+    EntryAccountingInformationModelSerializer,
+    EntryAccountingInformationRepresentationSerializer,
+)
+from .invoice import InvoiceRepresentationSerializer, InvoiceModelSerializer
+from .booking_entry import (
+    BookingEntryModelSerializer,
+    BookingEntryRepresentationSerializer,
+)
+from .transactions import TransactionModelSerializer, TransactionRepresentationSerializer
+from .consolidated_invoice import ConsolidatedInvoiceSerializer

wbaccounting/serializers/booking_entry.py

@@ -0,0 +1,78 @@
+from django.utils.http import urlencode
+from rest_framework.reverse import reverse
+from wbaccounting.models import BookingEntry
+from wbaccounting.serializers import InvoiceRepresentationSerializer
+from wbcore import serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.directory.serializers import EntryRepresentationSerializer
+from wbcore.metadata.configs.buttons import WidgetButton
+
+
+class BookingEntryRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="wbaccounting:bookingentry-detail")
+
+    class Meta:
+        model = BookingEntry
+        fields = (
+            "id",
+            "title",
+            "_detail",
+        )
+
+
+class BookingEntryModelSerializer(serializers.ModelSerializer):
+    _currency = CurrencyRepresentationSerializer(source="currency")
+    _counterparty = EntryRepresentationSerializer(source="counterparty")
+    _invoice = InvoiceRepresentationSerializer(source="invoice")
+
+    invoice_currency = serializers.StringRelatedField(
+        source="invoice.invoice_currency", read_only=True, label="Inv. Currency"
+    )
+
+    @serializers.register_dynamic_button()
+    def dynamic_buttons(self, instance, request, user):
+        buttons = []
+
+        if backlinks := instance.backlinks:
+            for _, backlink in backlinks.items():
+                buttons.append(
+                    WidgetButton(
+                        label=backlink["title"],
+                        endpoint=f'{reverse(backlink["reverse"], request=request)}?{urlencode(backlink["parameters"])}',
+                    )
+                )
+
+        return buttons
+
+    class Meta:
+        model = BookingEntry
+        decorators = {
+            "gross_value": serializers.decorator(decorator_type="text", position="left", value="{{_currency.symbol}}"),
+            "net_value": serializers.decorator(decorator_type="text", position="left", value="{{_currency.symbol}}"),
+        }
+        percent_fields = ["vat"]
+        read_only_fields = ["invoice_net_value", "invoice_gross_value", "invoice_fx_rate"]
+
+        fields = (
+            "id",
+            "title",
+            "booking_date",
+            "due_date",
+            "payment_date",
+            "reference_date",
+            "net_value",
+            "gross_value",
+            "vat",
+            "invoice_net_value",
+            "invoice_gross_value",
+            "invoice_fx_rate",
+            "currency",
+            "_currency",
+            "counterparty",
+            "_counterparty",
+            "invoice",
+            "_invoice",
+            "invoice_currency",
+            "_additional_resources",
+            "_buttons",
+        )

wbaccounting/serializers/consolidated_invoice.py

@@ -0,0 +1,109 @@
+from django.utils.http import urlencode
+from rest_framework.reverse import reverse
+from wbaccounting.models import BookingEntry, Invoice
+from wbaccounting.serializers import (
+    BookingEntryRepresentationSerializer,
+    InvoiceRepresentationSerializer,
+    InvoiceTypeRepresentationSerializer,
+)
+from wbcore import serializers
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.directory.serializers import EntryRepresentationSerializer
+
+
+class ConsolidatedInvoiceSerializer(serializers.Serializer):
+    id = serializers.PrimaryKeyCharField()
+    reference_date = serializers.DateField()
+    invoice = serializers.PrimaryKeyRelatedField(allow_null=True)
+    _invoice = InvoiceRepresentationSerializer(source="invoice")
+    invoice_currency = serializers.PrimaryKeyRelatedField(allow_null=True)
+    _invoice_currency = CurrencyRepresentationSerializer(source="invoice_currency")
+    counterparty = serializers.PrimaryKeyRelatedField(allow_null=True)
+    _counterparty = EntryRepresentationSerializer(source="counterparty")
+    _group_key = serializers.CharField()
+    type = serializers.PrimaryKeyRelatedField(allow_null=True)
+    _type = InvoiceTypeRepresentationSerializer(source="type")
+    booking_entries = serializers.PrimaryKeyRelatedField(allow_null=True)
+    _booking_entries = BookingEntryRepresentationSerializer(source="booking_entries")
+    group = serializers.CharField()
+    currency_symbol = serializers.CharField()
+    value = serializers.DecimalField(
+        max_digits=15,
+        decimal_places=2,
+        decorators=[serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}")],
+    )
+    casted_endpoint = serializers.SerializerMethodField()
+    depth = serializers.IntegerField()
+    num_draft = serializers.IntegerField()
+    num_submitted = serializers.IntegerField()
+    num_sent = serializers.IntegerField()
+    num_paid = serializers.IntegerField()
+
+    @serializers.register_resource()
+    def register_buttons(self, instance: dict, request, user: User) -> dict[str, str]:
+        button_dict = {}
+
+        if instance["depth"] == 5:
+            return button_dict
+
+        if instance.get("num_draft", 0) > 0:
+            button_dict["submit"] = reverse(
+                "wbaccounting:consolidated-invoice-submit", args=[instance["id"]], request=request
+            )
+
+        if instance.get("num_submitted", 0) > 0 and user.has_perm("wbaccounting.administrate_invoice"):
+            button_dict["approve"] = reverse(
+                "wbaccounting:consolidated-invoice-approve", args=[instance["id"]], request=request
+            )
+
+        if instance.get("num_sent", 0) > 0 and user.has_perm("wbaccounting.administrate_invoice"):
+            button_dict["pay"] = reverse(
+                "wbaccounting:consolidated-invoice-pay", args=[instance["id"]], request=request
+            )
+
+        for key in button_dict.keys():
+            button_dict[key] = button_dict[key] + "?" + urlencode(dict(request.GET.items()))
+        return button_dict
+
+    def get_casted_endpoint(self, obj: dict) -> str | None:
+        if obj.get("depth", 0) == 4:
+            return reverse(
+                f"{Invoice.get_endpoint_basename()}-detail",
+                args=[obj["id"]],
+                request=self.context.get("request", None),
+            )
+        elif obj.get("depth", 0) == 5:
+            return reverse(
+                f"{BookingEntry.get_endpoint_basename()}-detail",
+                args=[obj["id"]],
+                request=self.context.get("request", None),
+            )
+
+    class Meta:
+        fields = read_only_fields = (
+            "id",
+            "reference_date",
+            "invoice",
+            "_invoice",
+            "invoice_currency",
+            "_invoice_currency",
+            "counterparty",
+            "_counterparty",
+            "booking_entries",
+            "_booking_entries",
+            "group",
+            "value",
+            "_additional_resources",
+            "type",
+            "_type",
+            "casted_endpoint",
+            "currency_symbol",
+            "_buttons",
+            "_group_key",
+            "depth",
+            "num_draft",
+            "num_submitted",
+            "num_sent",
+            "num_paid",
+        )

wbaccounting/serializers/entry_accounting_information.py

@@ -0,0 +1,149 @@
+from decimal import Decimal
+
+from django.db.models import Q
+from django.dispatch import receiver
+from rest_framework.exceptions import ValidationError
+from rest_framework.reverse import reverse
+from wbaccounting.generators.base import get_all_booking_entry_choices
+from wbaccounting.models import EntryAccountingInformation
+from wbaccounting.serializers import InvoiceTypeRepresentationSerializer
+from wbcore import serializers
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.authentication.serializers import UserRepresentationSerializer
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.directory.serializers import (
+    CompanyModelSerializer,
+    EmailContactRepresentationSerializer,
+    EntryModelSerializer,
+    EntryRepresentationSerializer,
+    PersonModelSerializer,
+)
+from wbcore.signals import add_instance_additional_resource
+
+
+class EntryAccountingInformationRepresentationSerializer(serializers.RepresentationSerializer):
+    entry_repr = serializers.CharField(source="entry.computed_str", read_only=True)
+
+    class Meta:
+        model = EntryAccountingInformation
+        fields = (
+            "id",
+            "entry_repr",
+        )
+
+
+class EntryAccountingInformationModelSerializer(serializers.ModelSerializer):
+    _entry = EntryRepresentationSerializer(source="entry")
+    _default_currency = CurrencyRepresentationSerializer(source="default_currency")
+    _default_invoice_type = InvoiceTypeRepresentationSerializer(source="default_invoice_type")
+    vat = serializers.DecimalField(percent=True, required=False, max_digits=6, decimal_places=4, default=Decimal(0))
+    _exempt_users = UserRepresentationSerializer(source="exempt_users", many=True)
+
+    _email_to = EmailContactRepresentationSerializer(source="email_to", many=True, ignore_filter=True)
+    _email_cc = EmailContactRepresentationSerializer(source="email_cc", many=True, ignore_filter=True)
+    _email_bcc = EmailContactRepresentationSerializer(source="email_bcc", many=True, ignore_filter=True)
+    booking_entry_generator = serializers.ChoiceField(
+        choices=list(get_all_booking_entry_choices()), required=False, allow_null=True
+    )
+
+    _external_invoice_users = UserRepresentationSerializer(source="external_invoice_users", many=True)
+
+    @serializers.register_only_instance_resource()
+    def generate(self, instance, request, user, **kwargs):
+        generators = {}
+
+        if instance.booking_entry_generator and (
+            user.is_superuser or user.has_perm("wbaccounting.can_generate_booking_entries")
+        ):
+            generators["generate_booking_entries"] = reverse(
+                "wbaccounting:entryaccountinginformation-generate-booking-entries",
+                args=[instance.id],
+                request=request,
+            )
+
+        if user.is_superuser or user.has_perm("wbaccounting.can_generate_invoice"):
+            if instance.entry.booking_entries.filter(Q(invoice__isnull=True) & Q(payment_date__isnull=True)).exists():
+                generators["invoice_booking_entries"] = reverse(
+                    "wbaccounting:entryaccountinginformation-invoice-booking-entries",
+                    args=[instance.id],
+                    request=request,
+                )
+
+        return generators
+
+    @serializers.register_only_instance_resource()
+    def inline_lists(self, instance, request, user, **kwargs):
+        return {
+            "invoices": reverse(
+                "wbaccounting:entryaccountinginformation-invoice-list",
+                args=[instance.id],
+                request=request,
+            ),
+            "bookingentries": reverse(
+                "wbaccounting:entryaccountinginformation-bookingentry-list",
+                args=[instance.id],
+                request=request,
+            ),
+        }
+
+    class Meta:
+        model = EntryAccountingInformation
+
+        percent_fields = ["vat"]
+        fields = (
+            "id",
+            "entry",
+            "_entry",
+            "tax_id",
+            "vat",
+            "default_currency",
+            "_default_currency",
+            "default_invoice_type",
+            "_default_invoice_type",
+            "email_to",
+            "email_cc",
+            "email_bcc",
+            "_email_to",
+            "_email_cc",
+            "_email_bcc",
+            "email_subject",
+            "email_body",
+            "send_mail",
+            "counterparty_is_private",
+            "exempt_users",
+            "_exempt_users",
+            "booking_entry_generator",
+            "external_invoice_users",
+            "_external_invoice_users",
+            "_additional_resources",
+        )
+
+    def validate(self, data: dict) -> dict:
+        counterparty_is_private: bool | None = data.get(
+            "counterparty_is_private", self.instance.counterparty_is_private if self.instance else None
+        )
+        exempt_users: list[User] | None = data.get(
+            "exempt_users", list(self.instance.exempt_users.all()) if self.instance else None
+        )
+
+        if exempt_users and not counterparty_is_private:
+            raise ValidationError({"exempt_users": "You can only select exempt users for private counterparties."})
+
+        return super().validate(data)
+
+
+@receiver(add_instance_additional_resource, sender=CompanyModelSerializer)
+@receiver(add_instance_additional_resource, sender=PersonModelSerializer)
+@receiver(add_instance_additional_resource, sender=EntryModelSerializer)
+def entry_adding_additional_resource(sender, serializer, instance, request, user, **kwargs):
+    if hasattr(instance, "entry_accounting_information"):
+        entry_accounting_information = instance.entry_accounting_information
+        if entry_accounting_information:
+            return {
+                "accounting-information": reverse(
+                    "wbaccounting:entryaccountinginformation-detail",
+                    args=[entry_accounting_information.id],
+                    request=request,
+                )
+            }
+    return {}

wbaccounting/serializers/invoice.py

@@ -0,0 +1,95 @@
+from django.contrib.contenttypes.models import ContentType
+from django.utils.http import urlencode
+from rest_framework.reverse import reverse
+from wbaccounting.models import Invoice, InvoiceType
+from wbaccounting.serializers import InvoiceTypeRepresentationSerializer
+from wbcore import serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.directory.serializers import EntryRepresentationSerializer
+from wbcore.metadata.configs.buttons import WidgetButton
+
+
+class InvoiceRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="wbaccounting:invoice-detail")
+
+    class Meta:
+        model = Invoice
+        fields = (
+            "id",
+            "title",
+            "invoice_date",
+            "_detail",
+        )
+
+
+class InvoiceModelSerializer(serializers.ModelSerializer):
+    _counterparty = EntryRepresentationSerializer(source="counterparty")
+    _invoice_currency = CurrencyRepresentationSerializer(source="invoice_currency")
+    _invoice_type = InvoiceTypeRepresentationSerializer(source="invoice_type")
+    invoice_type = serializers.PrimaryKeyRelatedField(label="Type", required=True, queryset=InvoiceType.objects.all())
+
+    net_value = serializers.DecimalField(max_digits=16, decimal_places=2, label="Net Value", read_only=True)
+    gross_value = serializers.DecimalField(max_digits=16, decimal_places=2, label="Gross Value", read_only=True)
+
+    @serializers.register_resource()
+    def bookingentries(self, instance, request, user):
+        # Do some something (checks, etc.)
+        return {
+            "bookingentries": reverse("wbaccounting:invoice-bookingentry-list", args=[instance.id], request=request)
+        }
+
+    @serializers.register_resource()
+    def invoice_file(self, instance, request, user):
+        return {
+            "invoice_file": f'{reverse("wbcore:documents:document-urlredirect", args=[], request=request)}?content_type={ContentType.objects.get_for_model(Invoice).id}&object_id={instance.id}'
+        }
+
+    @serializers.register_dynamic_button()
+    def dynamic_buttons(self, instance, request, user):
+        buttons = []
+
+        if backlinks := instance.backlinks:
+            for _, backlink in backlinks.items():
+                buttons.append(
+                    WidgetButton(
+                        label=backlink["title"],
+                        endpoint=f'{reverse(backlink["reverse"], request=request)}?{urlencode(backlink["parameters"])}',
+                    )
+                )
+
+        return buttons
+
+    class Meta:
+        model = Invoice
+        decorators = {
+            "net_value": serializers.decorator(
+                decorator_type="text", position="left", value="{{_invoice_currency.symbol}}"
+            ),
+            "gross_value": serializers.decorator(
+                decorator_type="text", position="left", value="{{_invoice_currency.symbol}}"
+            ),
+        }
+        fields = (
+            "id",
+            "status",
+            "reference_date",
+            "resolved",
+            "title",
+            "invoice_date",
+            "invoice_currency",
+            "_invoice_currency",
+            "counterparty",
+            "_counterparty",
+            "text_above",
+            "text_below",
+            "_additional_resources",
+            "gross_value",
+            "net_value",
+            "invoice_type",
+            "_invoice_type",
+            "_buttons",
+        )
+        read_only_fields = (
+            "gross_value",
+            "net_value",
+        )

wbaccounting/serializers/invoice_type.py

@@ -0,0 +1,16 @@
+from wbaccounting.models import InvoiceType
+from wbcore import serializers
+
+
+class InvoiceTypeModelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = InvoiceType
+        fields = ("id", "name", "processor")
+
+
+class InvoiceTypeRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="wbaccounting:invoicetype-detail")
+
+    class Meta:
+        model = InvoiceType
+        fields = ("id", "name", "_detail")