wbaccounting 2.2.1__py2.py3-none-any.whl

wbaccounting/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

wbaccounting/admin/__init__.py

@@ -0,0 +1,5 @@
+from .booking_entry import BookingEntryInline, BookingEntryModelAdmin
+from .entry_accounting_information import EntryAccountingInformationModelAdmin
+from .invoice_type import InvoiceTypeModelAdmin
+from .invoice import InvoiceModelAdmin
+from .transactions import TransactionModelAdmin

wbaccounting/admin/booking_entry.py

@@ -0,0 +1,53 @@
+from datetime import date
+
+from django.contrib import admin
+from wbaccounting.models import BookingEntry, Invoice
+from wbcore.contrib.directory.models import Entry
+
+
+class BookingEntryInline(admin.TabularInline):
+    model = BookingEntry
+    fields = ("booking_date", "net_value", "vat")
+    ordering = ("vat", "title")
+
+    def has_add_permission(self, request, obj=None):
+        return False
+
+
+@admin.register(BookingEntry)
+class BookingEntryModelAdmin(admin.ModelAdmin):
+    list_display = (
+        "title",
+        "booking_date",
+        "net_value",
+        "vat",
+        "currency",
+        "payment_date",
+        "counterparty",
+        "reference_date",
+    )
+    search_fields = ["counterparty__computed_str"]
+    autocomplete_fields = ("counterparty", "currency")
+
+    # TODO: Remove or adjust.
+    def create_invoice(self, request, queryset):
+        counterparty = list(set(queryset.values_list("counterparty__id", flat=True)))
+        if len(counterparty) == 1:
+            counterparty = Entry.objects.get(id=counterparty[0])
+            invoice = Invoice.objects.create(
+                title=f"Rebate Invoice {counterparty.computed_str} ({queryset.earliest('from_date').from_date:%d.%m.%Y} - {queryset.latest('to_date').to_date:%d.%m.%Y})",
+                invoice_date=date.today(),
+                reference_date=date.today(),
+                counterparty=counterparty,
+                invoice_currency=counterparty.entry_accounting_information.default_currency,
+                is_counterparty_invoice=True,
+            )
+            queryset.update(invoice=invoice)
+            invoice.save()
+
+        else:
+            print("-------------------------------")  # noqa: T201
+            print(f"Too many counterparties selected ({len(counterparty)})")  # noqa: T201
+            print("-------------------------------")  # noqa: T201
+
+    actions = [create_invoice]

wbaccounting/admin/entry_accounting_information.py

@@ -0,0 +1,10 @@
+from django.contrib import admin
+from wbaccounting.models import EntryAccountingInformation
+
+
+@admin.register(EntryAccountingInformation)
+class EntryAccountingInformationModelAdmin(admin.ModelAdmin):
+    list_display = ("entry", "send_mail", "counterparty_is_private")
+    autocomplete_fields = ["default_currency", "entry", "email_to", "email_cc", "email_bcc", "exempt_users"]
+
+    search_fields = ["entry__computed_str"]

wbaccounting/admin/invoice.py

@@ -0,0 +1,26 @@
+from django.contrib import admin
+from wbaccounting.admin import BookingEntryInline
+from wbaccounting.models import Invoice
+from wbcore.contrib.documents.admin import DocumentInLine
+
+
+@admin.register(Invoice)
+class InvoiceModelAdmin(admin.ModelAdmin):
+    fsm_field = ["status"]
+    search_fields = ("counterparty__computed_str", "title", "invoice_type__name")
+    list_display = (
+        "status",
+        "title",
+        "gross_value",
+        "net_value",
+        "invoice_date",
+        "invoice_currency",
+        "counterparty",
+        "invoice_type",
+        "reference_date",
+    )
+
+    autocomplete_fields = ("counterparty",)
+    inlines = [BookingEntryInline, DocumentInLine]
+
+    raw_id_fields = ["counterparty", "invoice_currency", "invoice_type"]

wbaccounting/admin/invoice_type.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+from wbaccounting.models import InvoiceType
+
+
+@admin.register(InvoiceType)
+class InvoiceTypeModelAdmin(admin.ModelAdmin):
+    search_fields = ("name", "processor")
+    list_display = ("id", "name", "processor")

wbaccounting/admin/transactions.py

@@ -0,0 +1,16 @@
+from django.contrib import admin
+from wbaccounting.models import Transaction
+
+
+@admin.register(Transaction)
+class TransactionModelAdmin(admin.ModelAdmin):
+    list_display = ["booking_date", "value_date", "value", "bank_account", "prenotification"]
+
+    raw_id_fields = ["import_source"]
+
+    autocomplete_fields = [
+        "bank_account",
+        "from_bank_account",
+        "to_bank_account",
+        "currency",
+    ]

wbaccounting/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class WbaccountingConfig(AppConfig):
+    name = "wbaccounting"

wbaccounting/dynamic_preferences_registry.py

@@ -0,0 +1,107 @@
+from django.conf import settings
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import (
+    IntegerPreference,
+    LongStringPreference,
+    ModelMultipleChoicePreference,
+    StringPreference,
+)
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.directory.models import Person
+
+accounting_section = Section("wbaccounting")
+
+
+def format_invoice_number(number):
+    global_preferences = global_preferences_registry.manager()
+    ts = global_preferences["wbaccounting__invoice_thousand_seperator"]
+    ds = global_preferences["wbaccounting__invoice_decimal_seperator"]
+    if not number:
+        number = 0
+    s = "{:,.2f}".format(number)
+    s = s.replace(",", "//")
+    s = s.replace(".", "\\")
+
+    return s.replace("//", ts).replace("\\", ds)
+
+
+@global_preferences_registry.register
+class DefaultEntryAccountingInformationCurrency(StringPreference):
+    section = accounting_section
+    name = "default_entry_account_information_currency_key"
+    default = "CHF"
+
+    verbose_name = "The currency key used for the default currency of newly created entry accounting informations."
+
+    def validate(self, value):
+        if not Currency.objects.filter(key=value).exists():
+            return ValueError("The specified currency key is not valid")
+
+
+@global_preferences_registry.register
+class ExternalEmailAddress(StringPreference):
+    section = accounting_section
+    name = "external_email_address"
+    default = ""
+
+    verbose_name = "External Email Address"
+    help_text = "The Email Address used to send Invoices to the external party."
+
+
+@global_preferences_registry.register
+class InvoiceEmailBody(LongStringPreference):
+    section = accounting_section
+    name = "invoice_email_body"
+    default = ""
+
+    verbose_name = "The default E-Mail Body used for emailing Invoices"
+
+
+@global_preferences_registry.register
+class InvoiceThousandSeperatorPreference(StringPreference):
+    section = accounting_section
+    name = "invoice_thousand_seperator"
+    default = ","
+
+    verbose_name = "Invoice Thousand Seperator"
+    help_text = "Thousand Seperator for Invoices"
+
+
+@global_preferences_registry.register
+class InvoiceDecimalSeperatorPreference(StringPreference):
+    section = accounting_section
+    name = "invoice_decimal_seperator"
+    default = "."
+
+    verbose_name = "Invoice Decimal Seperator"
+    help_text = "Decimal Seperator for Invoices"
+
+
+@global_preferences_registry.register
+class InvoiceSignerPreference(ModelMultipleChoicePreference):
+    section = accounting_section
+    name = "invoice_signers"
+    queryset = Person.objects.all()
+    default = None
+    verbose_name = "Invoice Signers"
+
+
+@global_preferences_registry.register
+class InvoiceCompanyPreference(IntegerPreference):
+    section = accounting_section
+    name = "invoice_company"
+    default = 0
+
+    verbose_name = "Invoice Company"
+    help_text = "The PK of the company who issues the invoices"
+
+
+@global_preferences_registry.register
+class DefaultFromEmailAddressPreference(StringPreference):
+    section = accounting_section
+    name = "default_from_email_address"
+    default = settings.DEFAULT_FROM_EMAIL
+
+    verbose_name = "The default from email address"
+    help_text = "The default from email address used to send invoice"

wbaccounting/factories/__init__.py

@@ -0,0 +1,10 @@
+from .booking_entry import BookingEntryFactory
+from .entry_accounting_information import (
+    CompanyAccountingFactory,
+    EntryAccountingInformationFactory,
+)
+from .invoice import (
+    InvoiceFactory,
+    InvoiceTypeFactory,
+)
+from .transactions import TransactionFactory, LocalCurrencyTransactionFactory

wbaccounting/factories/booking_entry.py

@@ -0,0 +1,21 @@
+import factory
+from factory.fuzzy import FuzzyDecimal
+from wbaccounting.models import BookingEntry
+
+
+class BookingEntryFactory(factory.django.DjangoModelFactory):
+    class Meta:  # type: ignore
+        model = BookingEntry
+
+    # resolved
+    title = factory.Faker("text", max_nb_chars=64)
+    booking_date = factory.Faker("date_between", start_date="+2d", end_date="+3d")
+    payment_date = factory.Faker("date_object")
+    reference_date = factory.Faker("date_object")
+    gross_value = factory.Faker("pydecimal", right_digits=4, min_value=0, max_value=99999999999)
+    net_value = factory.Faker("pydecimal", right_digits=4, min_value=0, max_value=99999999999)
+    vat = FuzzyDecimal(0, 0.9, 4)
+    currency = factory.SelfAttribute("invoice.invoice_currency")
+
+    invoice = factory.SubFactory("wbaccounting.factories.InvoiceFactory")
+    counterparty = factory.SubFactory("wbcore.contrib.directory.factories.EntryFactory")

wbaccounting/factories/entry_accounting_information.py

@@ -0,0 +1,46 @@
+import factory
+from factory.fuzzy import FuzzyDecimal
+from wbaccounting.models import EntryAccountingInformation
+from wbcore.contrib.directory.factories import CompanyFactory, EmailContactFactory
+
+
+class EntryAccountingInformationFactory(factory.django.DjangoModelFactory):
+    class Meta:  # type: ignore
+        model = EntryAccountingInformation
+
+    entry = factory.SubFactory("wbcore.contrib.directory.factories.EntryFactory")
+    tax_id = factory.Faker("text", max_nb_chars=64)
+    vat = FuzzyDecimal(0, 0.9, 4)
+    send_mail = factory.Faker("pybool")
+    counterparty_is_private = False
+
+    email_body = factory.Faker("paragraph")
+
+    @factory.post_generation
+    def post(self, create, extracted, **kwargs):
+        if isinstance(self, EntryAccountingInformationFactory) and not create:
+            self.email_to.add(EmailContactFactory.create())
+            self.email_cc_add(EmailContactFactory.create())
+            self.email_bcc.add(EmailContactFactory.create())
+
+        if isinstance(self, dict):
+            self["email_to"] = [EmailContactFactory.create().id]
+            self["email_cc"] = [EmailContactFactory.create().id]
+            self["email_bcc"] = [EmailContactFactory.create().id]
+
+    @factory.post_generation
+    def exempt_users(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for user in extracted:
+                self.exempt_users.add(user)
+
+    default_currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+
+
+class CompanyAccountingFactory(CompanyFactory):
+    entry_accounting_information = factory.RelatedFactory(
+        "wbaccounting.factories.EntryAccountingInformationFactory", "entry"
+    )

wbaccounting/factories/invoice.py

@@ -0,0 +1,43 @@
+import factory
+from wbaccounting.models import Invoice, InvoiceType
+
+
+class InvoiceFactory(factory.django.DjangoModelFactory):
+    class Meta:  # type: ignore
+        model = Invoice
+
+    title = factory.Faker("text", max_nb_chars=64)
+    invoice_date = factory.Faker("date_object")
+    reference_date = factory.Faker("date_object")
+    invoice_currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyUSDFactory")
+
+    counterparty = factory.SubFactory("wbcore.contrib.directory.factories.EntryFactory")
+    invoice_type = factory.SubFactory("wbaccounting.factories.InvoiceTypeFactory")
+
+    text_above = factory.Faker("text")
+    text_below = factory.Faker("text")
+
+    # @factory.post_generation
+    # def invoice_document(self, create, extracted, **kwargs):
+    #     self.refresh_invoice_document(override_status=True)
+
+    # is_counterparty_invoice
+
+    # @classmethod
+    # def _create(cls, model_class, *args, **kwargs):
+    #     company = CompanyFactory()
+    #     signee = PersonSignatureFactory()
+    #     global_preferences_registry.manager()["wbaccounting__invoice_company"] = company.id
+    #     global_preferences_registry.manager()["wbaccounting__invoice_signers"] = Person.objects.filter(id=signee.id)
+    #     """Override the default ``_create`` with our custom call."""
+    #     manager = cls._get_manager(model_class)
+    #     # The default would use ``manager.create(*args, **kwargs)``
+    #     return manager.create(*args, **kwargs)
+
+
+class InvoiceTypeFactory(factory.django.DjangoModelFactory):
+    name = factory.Sequence(lambda n: f"Invoice Type {n}")
+    processor = factory.Faker("text", max_nb_chars=64)
+
+    class Meta:  # type: ignore
+        model = InvoiceType

wbaccounting/factories/transactions.py

@@ -0,0 +1,32 @@
+from decimal import Decimal
+
+import factory
+from wbaccounting.models import Transaction
+
+
+class AbstractTransactionFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Transaction
+        abstract = True
+
+    booking_date = factory.Faker("date_between", start_date="+2d", end_date="+3d")
+    value_date = factory.Faker("date_object")
+
+    bank_account = factory.SubFactory("wbcore.contrib.directory.factories.BankingContactFactory")
+    from_bank_account = factory.SubFactory("wbcore.contrib.directory.factories.BankingContactFactory")
+    to_bank_account = factory.SubFactory("wbcore.contrib.directory.factories.BankingContactFactory")
+
+    @factory.post_generation
+    def set_currency(self, create, extracted, **kwargs):
+        if isinstance(self, dict):
+            self["currency"] = self["bank_account"].currency
+        else:
+            self.currency = self.bank_account.currency
+
+
+class TransactionFactory(AbstractTransactionFactory):
+    value = factory.Faker("pydecimal", min_value=Decimal(0.1), max_value=Decimal(10000000))
+
+
+class LocalCurrencyTransactionFactory(AbstractTransactionFactory):
+    value_local_ccy = factory.Faker("pydecimal", min_value=Decimal(0.1), max_value=Decimal(10000000))

wbaccounting/files/invoice_document_file.py

@@ -0,0 +1,134 @@
+import logging
+from contextlib import suppress
+from io import BytesIO
+
+from dynamic_preferences.registries import global_preferences_registry
+from reportlab import platypus
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.units import cm
+from reportlab.platypus import BaseDocTemplate, NextPageTemplate, PageTemplate
+from reportlab.platypus.frames import Frame
+from wbaccounting.files import utils as invoice_utils
+from wbcore.contrib.directory.models import Entry
+
+logger = logging.getLogger("wbaccounting.files.invoice_document_file")
+
+
+def generate_file(invoice):
+    debug = 0
+
+    total_gross_value, total_net_value = invoice_utils.get_gross_and_net_value(invoice)
+    show_tax_id = total_gross_value != total_net_value
+
+    styles = invoice_utils.get_styles()
+
+    output = BytesIO()
+    doc = BaseDocTemplate(output, pagesize=A4, rightMargin=10, leftMargin=10, topMargin=10, bottomMargin=10)
+
+    global_preferences = global_preferences_registry.manager()
+    invoice_company = Entry.objects.get(id=global_preferences["wbaccounting__invoice_company"])
+    signees = global_preferences["wbaccounting__invoice_signers"]
+
+    logo_ratio = 0
+    logo = None
+    try:
+        logo, logo_ratio = invoice_utils.logo_block(invoice_company.profile_image)
+    except ValueError:
+        pass
+    logo_frame = Frame(
+        x1=0,
+        y1=A4[1] - (30 + 1 * cm),
+        width=30 * logo_ratio + 1.5 * cm,
+        height=30 + 1 * cm,
+        leftPadding=1.5 * cm,
+        bottomPadding=0,
+        rightPadding=0,
+        topPadding=1 * cm,
+        id="logo_frame",
+        showBoundary=debug,
+    )
+
+    address_frame = Frame(
+        x1=A4[0] - (12 * cm),
+        y1=A4[1] - (6 * cm),
+        width=12 * cm,
+        height=6 * cm,
+        leftPadding=0,
+        bottomPadding=0,
+        rightPadding=1.5 * cm,
+        topPadding=2.5 * cm,
+        id="address_frame",
+        showBoundary=debug,
+    )
+
+    content_frame = Frame(
+        x1=0,
+        y1=0,
+        width=A4[0],
+        height=A4[1] - (6 * cm),
+        leftPadding=1.5 * cm,
+        bottomPadding=1 * cm,
+        rightPadding=1.5 * cm,
+        topPadding=0,
+        id="content_frame",
+        showBoundary=debug,
+    )
+
+    content_frame2 = Frame(
+        x1=0,
+        y1=0,
+        width=A4[0],
+        height=A4[1],
+        leftPadding=1.5 * cm,
+        bottomPadding=1 * cm,
+        rightPadding=1.5 * cm,
+        topPadding=1 * cm,
+        id="content_frame2",
+        showBoundary=debug,
+    )
+
+    doc.addPageTemplates(
+        [
+            PageTemplate(id="TitlePage", frames=[logo_frame, address_frame, content_frame]),
+            PageTemplate(id="OtherPage", frames=[content_frame2]),
+        ]
+    )
+
+    elements = list()
+    elements.append(NextPageTemplate(["OtherPage"]))
+    if logo:
+        elements.append(logo)
+    elements.append(platypus.FrameBreak("address_frame"))
+
+    if invoice.is_counterparty_invoice:
+        elements.extend(invoice_utils.address_block(invoice_company, invoice, styles, right=True))
+    else:
+        elements.extend(invoice_utils.address_block(invoice.counterparty, invoice, styles, right=True))
+
+    elements.append(platypus.FrameBreak("content_frame"))
+    elements.extend(invoice_utils.city_and_date_block(invoice, styles, entry=invoice_company))
+
+    if invoice.is_counterparty_invoice:
+        elements.extend(invoice_utils.address_block(invoice.counterparty, invoice, styles, tax_id=show_tax_id))
+    else:
+        elements.extend(invoice_utils.address_block(invoice_company, invoice, styles, tax_id=show_tax_id))
+
+    elements.extend(invoice_utils.add_text_block_with_context(invoice.text_above, invoice, styles))
+    elements.extend(invoice_utils.add_booking_entries(invoice, styles, False))
+    elements.extend(invoice_utils.add_text_block_with_context(invoice.text_below, invoice, styles))
+    elements.extend(
+        invoice_utils.add_transfer_block(
+            invoice,
+            invoice_company if not invoice.is_counterparty_invoice else invoice.counterparty,
+            styles,
+            total_gross_value,
+        )
+    )
+    with suppress(ValueError):
+        elements.extend(invoice_utils.signature_block(signees, styles))
+    doc.build(elements)
+
+    pdf = output.getvalue()
+    output.close()
+
+    return pdf