wbaccounting 2.2.1__py2.py3-none-any.whl

wbaccounting/files/utils.py

@@ -0,0 +1,331 @@
+from django.template import Context, Template
+from reportlab.lib import colors, utils
+from reportlab.lib.enums import TA_CENTER, TA_RIGHT
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+from reportlab.lib.units import cm
+from reportlab.platypus import Image, Paragraph, Table, TableStyle
+from wbaccounting.dynamic_preferences_registry import format_invoice_number
+
+
+def get_styles():
+    styles = getSampleStyleSheet()
+    styles.add(ParagraphStyle(name="Headline", fontName="Helvetica", fontSize=24, leading=34))
+    styles.add(ParagraphStyle(name="Default", fontName="Helvetica", fontSize=10, leading=12))
+    styles.add(ParagraphStyle(name="Default-Table-Header", fontName="Helvetica", fontSize=14, leading=16))
+    styles.add(
+        ParagraphStyle(
+            name="Default-Table-Header-Right", fontName="Helvetica", fontSize=14, leading=16, alignment=TA_RIGHT
+        )
+    )
+    styles.add(ParagraphStyle(name="Default-Right", fontName="Helvetica", fontSize=10, leading=12, alignment=TA_RIGHT))
+    styles.add(
+        ParagraphStyle(
+            name="Default-Right-Linebreak",
+            fontName="Helvetica",
+            fontSize=10,
+            leading=12,
+            alignment=TA_RIGHT,
+            spaceAfter=12,
+        )
+    )
+    styles.add(
+        ParagraphStyle(name="Default-Center", fontName="Helvetica", fontSize=10, leading=12, alignment=TA_CENTER)
+    )
+    styles.add(ParagraphStyle(name="Default-Linebreak", fontName="Helvetica", fontSize=10, leading=12, spaceAfter=12))
+    styles.add(
+        ParagraphStyle(name="Default-Linebreak-Before", fontName="Helvetica", fontSize=10, leading=12, spaceBefore=12)
+    )
+    styles.add(
+        ParagraphStyle(name="Default-Double-Linebreak", fontName="Helvetica", fontSize=10, leading=12, spaceAfter=24)
+    )
+    styles.add(
+        ParagraphStyle(
+            name="Default-Double-Linebreak-With-Before",
+            fontName="Helvetica",
+            fontSize=10,
+            leading=12,
+            spaceAfter=24,
+            spaceBefore=24,
+        )
+    )
+    styles.add(ParagraphStyle(name="Normal-Right", alignment=TA_RIGHT)),
+    styles.add(ParagraphStyle(name="Annotation", fontName="Helvetica", fontSize=8, leading=10)),
+    styles.add(
+        ParagraphStyle(name="Annotation-Right", fontName="Helvetica", fontSize=8, leading=10, alignment=TA_RIGHT)
+    ),
+    return styles
+
+
+# TODO to be removed
+# def get_taxes(invoice, party, counterparty):
+#     vat = 0
+#     social_charges = 0
+#     if invoice.favour == 'COUNTERPARTY':
+#         vat = counterparty.accounting_information.vat if counterparty.accounting_information.vat else 0
+#         social_charges = counterparty.accounting_information.social_charges if counterparty.accounting_information.social_charges else 0
+#     else:
+#         vat = party.vat if party is not None and party.vat else 0
+#         social_charges = party.accounting_information.social_charges if party is not None and party.accounting_information.social_charges else 0
+#     if invoice.vat or invoice.vat == 0:
+#         vat = invoice.vat
+#     if invoice.social_charges or invoice.social_charges == 0:
+#         social_charges = invoice.social_charges
+#     return vat, social_charges
+
+# def banking_block(entry, invoice, styles, banking=None):
+#     elements = list()
+#     if banking is None:
+#         bankings = entry.banking.all() if entry else None
+#         if bankings:
+#             if bankings.filter(currency=invoice.base_currency).exists():
+#                 banking = bankings.filter(currency=invoice.base_currency).first()
+#             elif bankings.filter(primary=True).exists():
+#                 banking = bankings.filter(primary=True).first()
+#         else:
+#             return elements
+#     elements.append(Paragraph('{}'.format(banking.institute), styles['Default-Linebreak-Before']))
+#     if banking.institute_additional:
+#         elements.append(Paragraph('{}'.format(banking.institute_additional), styles['Default']))
+#     elements.append(Paragraph('IBAN: {}'.format(banking.iban), styles['Default']))
+#     if banking.swift_bic:
+#         elements.append(Paragraph('SWIFT: {}'.format(banking.swift_bic), styles['Default']))
+#     return elements
+
+
+def address_block(entry, invoice, styles, right=False, address=None, tax_id=None):
+    elements = list()
+    if address is None:
+        addresses = entry.addresses.all() if entry is not None else None
+        if addresses:
+            if addresses.filter(primary=True).exists():
+                address = addresses.filter(primary=True).first()
+            elif addresses.count() > 0:
+                address = addresses.first()
+        else:
+            return elements
+
+    if right:
+        default_style = styles["Default-Right"]
+        default_linebreak_style = styles["Default-Right-Linebreak"]
+    else:
+        default_style = styles["Default"]
+        default_linebreak_style = styles["Default-Linebreak"]
+
+    casted_entry = entry.get_casted_entry()
+    if entry.is_company:
+        elements.append(Paragraph("<b>{0.name}</b>".format(casted_entry), default_style))
+    else:
+        elements.append(Paragraph("<b>{0.first_name} {0.last_name}</b>".format(casted_entry), default_style))
+
+    elements.append(Paragraph(address.street, default_style))
+    if address.street_additional is not None and address.street_additional != "":
+        elements.append(Paragraph(address.street_additional, default_style))
+    elements.append(Paragraph("{} {}".format(address.zip, address.geography_city), default_style))
+    elements.append(Paragraph(address.geography_city.parent.parent.name, default_linebreak_style))
+
+    if tax_id and entry.entry_accounting_information.tax_id:
+        elements.append(Paragraph(f"VAT: {entry.entry_accounting_information.tax_id}", default_linebreak_style))
+
+    return elements
+
+
+def city_and_date_block(invoice, styles, entry=None, city=None, date=None):
+    elements = list()
+    if date is None:
+        date = invoice.invoice_date
+    if city is None:
+        primary_address = entry.primary_address_contact() if entry else None
+        if primary_address:
+            city = primary_address.geography_city
+    if city:
+        elements.append(Paragraph("{}, {:%d.%m.%Y}".format(city, date), styles["Default-Right-Linebreak"]))
+    else:
+        elements.append(Paragraph("{:%d.%m.%Y}".format(date), styles["Default-Right-Linebreak"]))
+    return elements
+
+
+def logo_block(image):
+    # print(image)
+    reportlab_image = utils.ImageReader(image)
+    width, height = reportlab_image.getSize()
+    ratio = float(width) / float(height)
+    image = Image(image, width=30 * ratio, height=30)
+    return image, ratio
+
+
+def signature_block(signees, styles):
+    elements = list()
+    if signees:
+        elements.append(Paragraph("Best Regards,", styles["Default-Double-Linebreak-With-Before"]))
+        for signee in signees:
+            if signee is not None and signee.signature.name is not None and signee.signature.name != "":
+                reportlab_image = utils.ImageReader(signee.signature)
+                width, height = reportlab_image.getSize()
+                ratio = float(width) / float(height)
+
+                image = Image(signee.signature, width=50 * ratio, height=50)
+                image.hAlign = "LEFT"
+                elements.append(image)
+                elements.append(Paragraph("{}".format(signee.computed_str), styles["Default"]))
+    return elements
+
+
+def add_text_block_with_context(text, invoice, styles):
+    elements = list()
+    if text:
+        elements.append(Paragraph("", styles["Default-Linebreak"]))
+        elements.append(Paragraph(Template(text).render(Context(invoice.get_context())), styles["Default-Linebreak"]))
+    return elements
+
+
+def add_transfer_block(invoice, receiver, styles, total_amount_gross):
+    elements = list()
+
+    if invoice.is_counterparty_invoice:
+        text = f"The amount of <b>{invoice.invoice_currency} {format_invoice_number(total_amount_gross)}</b> will be transfered to the following bank account:"
+    else:
+        text = f"Please transfer <b>{invoice.invoice_currency} {format_invoice_number(total_amount_gross)}</b> to the following bank account:"
+
+    elements.append(Paragraph(text, styles["Default-Linebreak-Before"]))
+
+    bank_accounts = receiver.banking.all()
+    if bank_accounts.exists():
+        try:
+            bank_account = bank_accounts.get(currency=invoice.invoice_currency)
+        except Exception:
+            bank_account = bank_accounts.first()
+
+        elements.append(Paragraph(bank_account.institute, styles["Default"]))
+
+        if bank_account.institute_additional:
+            elements.append(Paragraph(bank_account.institute_additional, styles["Default"]))
+
+        if bank_account.iban and bank_account.iban != "":
+            elements.append(Paragraph(f"IBAN: {bank_account.iban}", styles["Default"]))
+        if bank_account.swift_bic:
+            elements.append(Paragraph(f"SWIFT: {bank_account.swift_bic}", styles["Default"]))
+        if bank_account.additional_information and bank_account.additional_information != "":
+            elements.append(Paragraph(bank_account.additional_information, styles["Default"]))
+
+    return elements
+
+
+def get_gross_and_net_value(invoice):
+    multiplier = 1 if not invoice.is_counterparty_invoice else -1
+
+    total_gross = 0
+    total_net = 0
+    for booking_entry in invoice.booking_entries.all():
+        if booking_entry.currency != invoice.invoice_currency:
+            conversion_rate = booking_entry.currency.convert(booking_entry.booking_date, invoice.invoice_currency)
+            total_net += multiplier * booking_entry.net_value * conversion_rate
+            total_gross += multiplier * booking_entry.gross_value * conversion_rate
+        else:
+            total_net += multiplier * booking_entry.net_value
+            total_gross += multiplier * booking_entry.gross_value
+
+    return total_gross, total_net
+
+
+def add_booking_entries(invoice, styles, inverse=False):
+    multiplier = 1 if not invoice.is_counterparty_invoice else -1
+
+    tables = list()
+    for vat in invoice.booking_entries.all().distinct("vat").values_list("vat", flat=True):
+        table_data = list()
+
+        table_data.append([Paragraph("", styles["Default"])] * 2)
+        table_data.append(
+            [
+                Paragraph("Title", styles["Default-Table-Header"]),
+                Paragraph("Amount", styles["Default-Table-Header-Right"]),
+            ]
+        )
+
+        for booking_entry in invoice.booking_entries.filter(vat=vat).order_by("title"):
+            title_col = [Paragraph(f"{booking_entry.title}", styles["Default"])]
+            amount_col = list()
+
+            if booking_entry.currency != invoice.invoice_currency:
+                conversion_rate = booking_entry.currency.convert(booking_entry.booking_date, invoice.invoice_currency)
+
+                title_col.append(
+                    Paragraph(
+                        f"<i>1.00 {booking_entry.currency.key} = {conversion_rate:.4f} {invoice.invoice_currency.key}</i>",
+                        styles["Annotation"],
+                    )
+                )
+
+                amount_col.append(
+                    Paragraph(
+                        f"<i>{format_invoice_number(multiplier * conversion_rate * booking_entry.gross_value)} {invoice.invoice_currency.key}</i>",
+                        styles["Default-Right"],
+                    )
+                )
+                amount_col.append(
+                    Paragraph(
+                        f"{format_invoice_number(multiplier * booking_entry.gross_value)} {booking_entry.currency}",
+                        styles["Annotation-Right"],
+                    )
+                )
+            else:
+                amount_col.append(
+                    Paragraph(
+                        f"{format_invoice_number(multiplier * booking_entry.gross_value)} {booking_entry.currency}",
+                        styles["Default-Right"],
+                    )
+                )
+
+            if (
+                (params := booking_entry.parameters)
+                and (from_date := params.get("from_date"))
+                and (to_date := params.get("to_date"))
+            ):
+                title_col.append(
+                    Paragraph(
+                        f"<i>{from_date} - {to_date}</i>",
+                        styles["Annotation"],
+                    )
+                )
+
+            table_data.append([title_col, amount_col])
+
+        total_gross, total_net = get_gross_and_net_value(invoice)
+        table_data.append([Paragraph("", styles["Default"])] * 2)
+        table_data.append(
+            [
+                [
+                    Paragraph("<strong>Total Amount</strong>", styles["Default"]),
+                    Paragraph(f"<i>Vat: {vat*100:.2f}%</i>", styles["Annotation"]),
+                    Paragraph(f"Total Amount (excl. {vat*100:.2f}% VAT)", styles["Annotation"]),
+                ],
+                [
+                    Paragraph(
+                        f"<strong>{format_invoice_number(total_gross)} {invoice.invoice_currency}</strong>",
+                        styles["Default-Right"],
+                    ),
+                    Paragraph(
+                        f"<i>{format_invoice_number(total_gross - total_net)} {invoice.invoice_currency}</i>",
+                        styles["Annotation-Right"],
+                    ),
+                    Paragraph(
+                        f"{format_invoice_number(total_net)} {invoice.invoice_currency}",
+                        styles["Annotation-Right"],
+                    ),
+                ],
+            ]
+        )
+        table = Table(table_data, colWidths=[A4[0] - 6.4 * cm, 3.5 * cm])
+        table.setStyle(
+            TableStyle(
+                [
+                    ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#f37200")),
+                    ("BACKGROUND", (0, 1), (-1, 1), colors.HexColor("#f38a32")),
+                    ("VALIGN", (0, 0), (-1, -1), "TOP"),
+                ]
+            )
+        )
+        tables.append(table)
+
+    return tables

wbaccounting/generators/__init__.py

@@ -0,0 +1,6 @@
+from django.conf import settings
+
+from .base import AbstractBookingEntryGenerator
+
+if settings.DEBUG:
+    from .base import TestGenerator

wbaccounting/generators/base.py

@@ -0,0 +1,120 @@
+import abc
+from contextlib import suppress
+from datetime import date
+from importlib import import_module
+from typing import Callable, Iterable
+
+from django.conf import settings
+from django.db.models import QuerySet
+from wbaccounting.models.booking_entry import BookingEntry
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.directory.models import Entry
+
+GENERATE_BOOKING_ENTRIES = Callable[[date, date, Entry], list[BookingEntry]]
+
+
+def register_generator(name: str) -> Callable:
+    def decorator(func: Callable) -> Callable:
+        setattr(func, "_is_booking_entry_generator", True)
+        setattr(func, "_booking_entry_generator_name", name)
+        return func
+
+    return decorator
+
+
+def get_all_booking_entry_choices() -> Iterable[tuple[str, str]]:
+    for app in settings.INSTALLED_APPS:
+        with suppress(ModuleNotFoundError):
+            import_module(f"{app}.generators")
+
+    for subclass in AbstractBookingEntryGenerator.__subclasses__():
+        yield f"{subclass.__module__}.{subclass.__name__}", subclass.TITLE
+
+
+class AbstractBookingEntryGenerator(abc.ABC):
+    """
+    An abstract base class designed to define a template for generating and managing
+    booking entries within a financial or accounting system.
+
+    This class outlines the necessary operations for generating a series of booking
+    entries based on a given date range and counterparty, as well as merging backlinks
+    for the generated booking entries.
+
+    Attributes:
+        TITLE (str): A class-level attribute that provides a title or a descriptive name for the
+                     generator implementation. This should be overridden in concrete subclasses
+                     to provide a specific title.
+    """
+
+    TITLE = ""
+
+    @staticmethod
+    @abc.abstractmethod
+    def generate_booking_entries(from_date: date, to_date: date, counterparty: Entry) -> Iterable[BookingEntry]:
+        """
+        Generates a sequence of booking entries for a specified date range and counterparty.
+
+        This abstract method must be implemented by subclasses to provide the logic for
+        generating booking entries based on the provided criteria.
+
+        Args:
+            from_date (date): The start date of the period for which booking entries are to be generated.
+            to_date (date): The end date of the period for which booking entries are to be generated.
+            counterparty (Entry): The counterparty associated with the booking entries to be generated.
+
+        Returns:
+            Iterable[BookingEntry]: A sequence of BookingEntry instances generated for the specified
+                                    criteria.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """
+        raise NotImplementedError()
+
+    @staticmethod
+    @abc.abstractmethod
+    def merge_backlinks(booking_entries: QuerySet[BookingEntry]) -> dict:
+        """
+        Merges backlinks for a collection of booking entries, to consolidate
+        related entries to insert a single backling in an invoice.
+
+        This abstract method should be implemented by subclasses to provide specific
+        logic for merging or updating backlinks of booking entries.
+
+        Args:
+            booking_entries (Iterable[BookingEntry]): A sequence of BookingEntry instances
+                                                     to be merged or updated.
+
+        Returns:
+            dict: A dictionary or other structured data indicating the results of the
+                  merge operation, specific to the implementation.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """
+        raise NotImplementedError()
+
+
+def generate_booking_entries(_class: type[AbstractBookingEntryGenerator], from_date: date, to_date: date, counterparty: Entry):
+    booking_entries = _class.generate_booking_entries(from_date, to_date, counterparty)
+    for booking_entry in booking_entries:
+        booking_entry.save()
+
+
+class TestGenerator(AbstractBookingEntryGenerator):
+    TITLE = "Test Generator"
+
+    @staticmethod
+    def generate_booking_entries(from_date: date, to_date: date, counterparty: Entry) -> Iterable[BookingEntry]:
+        yield BookingEntry(
+            title="Test Booking Entry",
+            counterparty=counterparty,
+            booking_date=date.today(),
+            reference_date=date.today(),
+            net_value=100,
+            currency=Currency.objects.first(),
+        )
+
+    @staticmethod
+    def merge_backlinks(booking_entries: Iterable[BookingEntry]) -> dict:
+        return {}

wbaccounting/io/handlers/transactions.py

@@ -0,0 +1,32 @@
+from decimal import Decimal
+from typing import Any
+
+from django.db import models
+from django.db.models import Value
+from django.db.models.functions import Replace
+from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
+from wbcore.contrib.directory.models import BankingContact
+from wbcore.contrib.io.imports import ImportExportHandler
+
+
+class TransactionImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbaccounting.Transaction"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _deserialize(self, data: dict[str, Any]):
+        data["currency"] = self.currency_handler.process_object({"key": data["currency"]}, read_only=True)[0]
+        data["bank_account"] = BankingContact.objects.annotate(
+            stripped_iban=Replace("iban", Value(" "), Value(""))
+        ).get(stripped_iban=data["bank_account"].replace(" ", ""))
+        data["value"] = Decimal(data["value"])
+        return super()._deserialize(data)
+
+    def _get_instance(self, data: dict[str, Any], history: models.QuerySet | None = None, **kwargs) -> Any | None:
+        if _hash := data.get("_hash", None):
+            qs = self.model.objects.filter(_hash=_hash)
+            if qs.exists():
+                return qs.first()
+        return super()._get_instance(data, history, **kwargs)

wbaccounting/io/parsers/societe_generale_lux.py

@@ -0,0 +1,49 @@
+import csv
+import datetime
+import hashlib
+
+from schwifty import IBAN
+
+# Bank specific Information for Societe Generale Luxembourg
+BANK_COUNTRY_CODE = "LU"
+BANK_CODE = "060"
+
+
+def parse(import_source):
+    # Load file into a CSV DictReader
+    csv_file = import_source.file.open(mode="rt")
+
+    # Read file into a CSV Dict Reader
+    csv_reader = csv.DictReader(csv_file, delimiter=";")
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+    for transaction in csv_reader:
+        if amount := transaction.get("Amount", None):
+            booking_date = datetime.datetime.strptime(transaction["Accounting date"], "%Y/%m/%d").date()
+            value_date = datetime.datetime.strptime(transaction["Value date"], "%Y/%m/%d").date()
+            currency = transaction["Account currency"]
+            value = float(amount.replace(",", "."))
+            description = transaction["Transaction main description"]
+            bank_account = str(
+                IBAN.generate(BANK_COUNTRY_CODE, bank_code=BANK_CODE, account_code=transaction["Account number"])
+            )
+            item = {
+                "booking_date": booking_date.strftime("%Y-%m-%d"),
+                "value_date": value_date.strftime("%Y-%m-%d"),
+                "currency": currency,
+                "value": value,
+                "description": description,
+                "bank_account": bank_account,
+            }
+            _hash = hashlib.sha256()
+            for field in item.values():
+                _hash.update(str(field).encode())
+
+            item["_hash"] = _hash.hexdigest()
+            data.append(item)
+
+    csv_file.close()
+    return {
+        "data": data,
+    }

wbaccounting/io/parsers/societe_generale_lux_prenotification.py

@@ -0,0 +1,60 @@
+import hashlib
+from contextlib import suppress
+from datetime import datetime
+
+import pandas as pd
+from wbportfolio.models import Product
+
+
+def parse(import_source):
+    csv_file = import_source.file.open()
+    df = pd.read_csv(csv_file)
+    df = df[~df["Isin"].isnull()]
+    df["Trade date"] = df["Trade date"].ffill()
+
+    df_sub = df[
+        ["Trade date", "Isin", "Quantity Sub", "Amount Sub class ccy", "Value date Sub", "Nav Class ccy", "Ccy Class"]
+    ]
+    df_sub = df_sub.rename(
+        columns={"Quantity Sub": "quantity", "Amount Sub class ccy": "amount", "Value date Sub": "value_date"}
+    )
+    df_red = df[
+        ["Trade date", "Isin", "Quantity Red", "Amount Red Class ccy", "Value date Red", "Nav Class ccy", "Ccy Class"]
+    ]
+    df_red = df_red.rename(
+        columns={"Quantity Red": "quantity", "Amount Red Class ccy": "amount", "Value date Red": "value_date"}
+    )
+    df_red["quantity"] = df_red["quantity"] * -1
+    df_red["amount"] = df_red["amount"] * -1
+    df = pd.concat([df_sub, df_red])
+    df["value"] = df["amount"] + (df["quantity"] * df["Nav Class ccy"])
+
+    df = df[df["value"] != 0]
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+    for transaction in df.to_dict(orient="records"):
+        _hash = hashlib.sha256()
+        for field in transaction.values():
+            _hash.update(str(field).encode())
+
+        description = f'Trade ({transaction["Isin"]}): {transaction["quantity"]} shares and {transaction["amount"]} {transaction["Ccy Class"]}.'
+
+        with suppress(Product.DoesNotExist):
+            bank_account = Product.objects.get(isin=transaction["Isin"]).bank_account.iban
+            data.append(
+                {
+                    "booking_date": datetime.strptime(transaction["Trade date"], "%d/%m/%Y").strftime("%Y-%m-%d"),
+                    "value_date": datetime.strptime(transaction["value_date"], "%d/%m/%Y").strftime("%Y-%m-%d"),
+                    "currency": transaction.get("Ccy Class"),
+                    "value": float(transaction["value"]),
+                    "description": description,
+                    "bank_account": bank_account,
+                    "prenotification": True,
+                    "_hash": _hash.hexdigest(),
+                }
+            )
+
+    return {
+        "data": data,
+    }