wbcommission 2.2.1__py2.py3-none-any.whl

wbcommission/filters/signals.py

@@ -0,0 +1,44 @@
+from django.db.models import Q
+from django.dispatch import receiver
+from wbcore import filters as wb_filters
+from wbcore.contrib.directory.filters import EntryFilter
+from wbcore.signals.filters import add_filters
+from wbcrm.models.accounts import Account
+from wbportfolio.contrib.company_portfolio.filters import PersonFilter
+
+
+@receiver(add_filters, sender=EntryFilter)
+def add_account_filter(sender, request=None, *args, **kwargs):
+    def filter_account(queryset, name, value):
+        if value:
+            return queryset.filter(account_customers__account=value)
+        return queryset
+
+    return {
+        "account": wb_filters.ModelChoiceFilter(
+            label="Account",
+            field_name="account",
+            queryset=Account.objects.all(),
+            endpoint=Account.get_representation_endpoint(),
+            value_key=Account.get_representation_value_key(),
+            label_key=Account.get_representation_label_key(),
+            method=filter_account,
+        )
+    }
+
+
+@receiver(add_filters, sender=PersonFilter)
+def add_has_user_account_filter(sender, request=None, *args, **kwargs):
+    def filter_has_user_account(queryset, name, value):
+        if value is True:
+            return queryset.filter(Q(user_account__isnull=False))
+        elif value is False:
+            return queryset.filter(Q(user_account__isnull=True))
+        else:
+            return queryset
+
+    return {
+        "has_user_account": wb_filters.BooleanFilter(
+            field_name="has_user_account", label="Has User Account", method=filter_has_user_account
+        )
+    }

wbcommission/generators/__init__.py

@@ -0,0 +1,2 @@
+from .rebate_generator import RebateGenerator
+

wbcommission/generators/rebate_generator.py

@@ -0,0 +1,93 @@
+from collections import defaultdict
+from datetime import date, datetime
+from decimal import Decimal
+from functools import reduce
+from typing import Iterable
+
+from django.db.models import QuerySet, Sum
+from wbaccounting.generators.base import AbstractBookingEntryGenerator
+from wbaccounting.models import BookingEntry
+from wbcommission.models import Rebate
+from wbcore.contrib.directory.models import Entry
+from wbportfolio.models import Product
+
+
+class RebateGenerator(AbstractBookingEntryGenerator):
+    TITLE = "Rebate Generation"
+
+    @staticmethod
+    def generate_booking_entries(from_date: date, to_date: date, counterparty: Entry) -> Iterable[BookingEntry]:
+        rebates = Rebate.objects.filter(recipient=counterparty, date__gte=from_date, date__lte=to_date)
+
+        for product_id in rebates.distinct("product_id").values_list("product_id", flat=True):
+            product = Product.objects.get(id=product_id)
+
+            for rebate_key, rebate_title in (("management", "Management"), ("performance", "Performance")):
+                rebate_sum = (
+                    rebates.filter(product_id=product_id, commission_type__key=rebate_key)
+                    .aggregate(sum=Sum("value"))
+                    .get("sum")
+                    or 0.0
+                )
+                if rebate_sum > 0:
+                    yield BookingEntry(
+                        title=f"{product.name} {product.isin} {rebate_title} Fees",
+                        booking_date=date.today(),
+                        reference_date=to_date,
+                        gross_value=Decimal(-1 * rebate_sum),
+                        vat=Decimal(counterparty.entry_accounting_information.vat) or Decimal(0.0),
+                        currency=product.currency,
+                        counterparty=counterparty,
+                        parameters={
+                            "from_date": from_date.strftime("%d.%m.%Y"),
+                            "to_date": to_date.strftime("%d.%m.%Y"),
+                        },
+                        backlinks={
+                            "comm-rebates": {
+                                "title": "Rebates",
+                                "reverse": "wbcommission:rebatetable-list",
+                                "parameters": {
+                                    "date": f'{from_date.strftime("%Y-%m-%d")},{to_date.strftime("%Y-%m-%d")}',
+                                    "product": product_id,
+                                    "recipient": counterparty.id,
+                                    "group_by": "ACCOUNT",
+                                },
+                            },
+                        },
+                    )
+
+    @staticmethod
+    def _compare(d1: str, d2: str) -> str:
+        d1_lb, d1_ub = d1.split(",")
+        d2_lb, d2_ub = d2.split(",")
+
+        lb = min(datetime.strptime(d1_lb, "%Y-%m-%d"), datetime.strptime(d2_lb, "%Y-%m-%d"))
+        ub = max(datetime.strptime(d1_ub, "%Y-%m-%d"), datetime.strptime(d2_ub, "%Y-%m-%d"))
+
+        return f"{lb.strftime('%Y-%m-%d')},{ub.strftime('%Y-%m-%d')}"
+
+    @staticmethod
+    def _merge_key_into_dict(d: dict, key: str, value: dict) -> dict:
+        d[key]["title"] = value["title"]
+        d[key]["reverse"] = value["reverse"]
+        if "recipient" in value["parameters"]:
+            d[key]["parameters"]["recipient"] = value["parameters"]["recipient"]
+            d[key]["parameters"]["date"] = RebateGenerator._compare(
+                d[key]["parameters"].get("date", "9999-12-31,1111-01-01"), value["parameters"]["date"]
+            )
+        return d
+
+    @staticmethod
+    def _iter_backlinks(booking_entries: QuerySet) -> Iterable:
+        for backlink in booking_entries:
+            yield from backlink.items()
+
+    @staticmethod
+    def merge_backlinks(booking_entries: QuerySet[BookingEntry]) -> dict:
+        return reduce(
+            lambda d, v: RebateGenerator._merge_key_into_dict(d, *v),
+            RebateGenerator._iter_backlinks(
+                booking_entries.filter(backlinks__isnull=False).values_list("backlinks", flat=True)
+            ),
+            defaultdict(lambda: dict(parameters=dict())),
+        )

wbcommission/migrations/0001_initial.py

@@ -0,0 +1,299 @@
+# Generated by Django 4.1.9 on 2023-06-28 12:21
+
+from decimal import Decimal
+
+import django.db.models.deletion
+import wbcommission.models.rebate
+from django.contrib.postgres.operations import BtreeGistExtension
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("wbcrm", "0005_account_accountrole_accountroletype_and_more"),
+        ("wbportfolio", "0046_add_product_default_account"),
+        ("directory", "0004_entry_is_draft_entry"),
+    ]
+
+    operations = [
+        BtreeGistExtension(),
+        migrations.CreateModel(
+            name="AccountCustomer",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                (
+                    "customer_type",
+                    models.CharField(
+                        choices=[("DIRECT", "Direct"), ("INDIRECT", "Indirect")],
+                        default="DIRECT",
+                        max_length=16,
+                        verbose_name="Customer Type",
+                    ),
+                ),
+                (
+                    "account",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="customers",
+                        to="wbcrm.account",
+                        verbose_name="Account",
+                    ),
+                ),
+                (
+                    "entry",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="account_customers",
+                        to="directory.entry",
+                        verbose_name="Customer",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Customer",
+                "verbose_name_plural": "Customers",
+                "notification_types": [
+                    (
+                        "wbcommission.accountcustomer.notify",
+                        "New Account Customer Notification",
+                        "Notifies you when a new account customer has been created",
+                        True,
+                        True,
+                        False,
+                    )
+                ],
+            },
+        ),
+        migrations.CreateModel(
+            name="CommissionAccountRole",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                (
+                    "role_type",
+                    models.CharField(
+                        choices=[("SALES", "Sales"), ("CUSTOMER_MANAGER", "Customer Manager")],
+                        default="SALES",
+                        max_length=16,
+                        verbose_name="Role Type",
+                    ),
+                ),
+                ("start", models.DateField(blank=True, null=True, verbose_name="Start")),
+                ("end", models.DateField(blank=True, null=True, verbose_name="End")),
+                ("weighting", models.FloatField(default=1, verbose_name="Weight")),
+                (
+                    "account",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="rebates_roles",
+                        to="wbcrm.account",
+                        verbose_name="Account Rebate roles",
+                    ),
+                ),
+                (
+                    "customer",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="rebate_account_customer",
+                        to="directory.entry",
+                        verbose_name="Customer",
+                    ),
+                ),
+                (
+                    "person",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="rebates_account_roles",
+                        to="directory.person",
+                        verbose_name="Person",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Commission Account Role",
+                "verbose_name_plural": "Commission Account Roles",
+            },
+        ),
+        migrations.CreateModel(
+            name="AccountCustomerCommissionConstraint",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                ("start_year", models.PositiveIntegerField(blank=True, null=True)),
+                ("end_year", models.PositiveIntegerField(blank=True, null=True)),
+                ("payable_year_end", models.BooleanField(default=True)),
+                ("payable_continous", models.BooleanField(default=True)),
+                (
+                    "customer",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="constraints",
+                        to="wbcommission.accountcustomer",
+                    ),
+                ),
+                (
+                    "products",
+                    models.ManyToManyField(blank=True, related_name="customer_constraints", to="wbportfolio.product"),
+                ),
+            ],
+            options={
+                "verbose_name": "Account Customer Commission Constraint",
+                "verbose_name_plural": "Account Customer Commission Constrains",
+            },
+        ),
+        migrations.CreateModel(
+            name="Rebate",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                ("date", models.DateField(verbose_name="Date")),
+                (
+                    "management_fees",
+                    models.DecimalField(
+                        decimal_places=4, default=Decimal(0.0), max_digits=16, verbose_name="Management Fees"
+                    ),
+                ),
+                (
+                    "pre_performance_fees",
+                    models.DecimalField(
+                        decimal_places=4,
+                        default=Decimal(0.0),
+                        max_digits=16,
+                        verbose_name="Pre Performance Fees",
+                    ),
+                ),
+                (
+                    "performance_fees",
+                    models.DecimalField(
+                        decimal_places=4, default=Decimal(0.0), max_digits=16, verbose_name="Performance Fees"
+                    ),
+                ),
+                (
+                    "account",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="rebates",
+                        to="wbcrm.account",
+                        verbose_name="Account",
+                    ),
+                ),
+                (
+                    "product",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="rebates",
+                        to="wbportfolio.product",
+                        verbose_name="Product",
+                    ),
+                ),
+                (
+                    "recipient",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="recipient_rebates",
+                        to="directory.entry",
+                        verbose_name="Recipient",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Rebate",
+                "verbose_name_plural": "Rebates",
+                "unique_together": {("date", "recipient", "account", "product")},
+                "index_together": {("date", "recipient", "product")},
+            },
+            bases=(wbcommission.models.rebate.BookingEntryCalculatedValueMixin, models.Model),
+        ),
+        migrations.CreateModel(
+            name="Commission",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                (
+                    "role_recipient",
+                    models.CharField(
+                        blank=True,
+                        choices=[
+                            ("portfolio_managers", "Portfolio Managers"),
+                            ("analysts", "Analysts"),
+                            ("sales", "Sales"),
+                            ("customer_managers", "Customer Managers"),
+                        ],
+                        max_length=32,
+                        null=True,
+                        verbose_name="Recipient Role",
+                    ),
+                ),
+                ("order", models.IntegerField()),
+                (
+                    "commission_type",
+                    models.CharField(
+                        choices=[
+                            ("net_management_fees", "Net Management Fees"),
+                            ("gross_management_fees", "Gross Management Fees"),
+                            ("net_performance_fees", "Net Performance Fees"),
+                            ("gross_performance_fees", "Gross Performance Fees"),
+                        ],
+                        default="net_management_fees",
+                        max_length=32,
+                        verbose_name="Type",
+                    ),
+                ),
+                ("start_date", models.DateField(verbose_name="Start Date")),
+                (
+                    "minimum_assets_under_management",
+                    models.IntegerField(default=0, verbose_name="Minimum AUM"),
+                ),
+                ("percent", models.FloatField(verbose_name="Percent")),
+                (
+                    "account",
+                    models.ForeignKey(
+                        limit_choices_to=models.Q(("is_terminal_account", True)),
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="account_commissions",
+                        to="wbcrm.account",
+                        verbose_name="Account",
+                    ),
+                ),
+                (
+                    "crm_recipient",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="recipient_commissions",
+                        to="directory.entry",
+                        verbose_name="Recipient",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Commission",
+                "verbose_name_plural": "Commissions",
+                "unique_together": {
+                    (
+                        "account",
+                        "order",
+                        "crm_recipient",
+                        "role_recipient",
+                        "start_date",
+                        "commission_type",
+                        "minimum_assets_under_management",
+                    )
+                },
+            },
+        ),
+    ]