wbcommission 2.2.1__py2.py3-none-any.whl

wbcommission/reports/customer_report.py

@@ -0,0 +1,299 @@
+from datetime import date
+from decimal import Decimal
+from io import BytesIO
+
+import xlsxwriter
+from celery import shared_task
+from django.db.models import Case, F, Sum, When
+from wbcommission.models import CommissionType, Rebate
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.directory.models import Entry
+from wbcrm.models.accounts import (
+    Account,
+    AccountRole,
+    AccountRoleType,
+    AccountRoleValidity,
+)
+from wbfdm.models import InstrumentPrice
+from wbportfolio.models.transactions.claim import Claim
+from xlsxwriter.utility import xl_rowcol_to_cell
+
+from .utils import create_report_and_send
+
+AccountCustomer = None
+
+
+@shared_task(queue="commission")
+def create_customer_report_and_send_as_task(user_id: int, recipient_id: int, start_date: date, end_date: date):
+    user = User.objects.get(id=user_id)
+    recipient = Entry.objects.get(id=recipient_id)
+    create_report_and_send(user, recipient, start_date, end_date, create_report)
+
+
+def create_report(user, customer, start_date, end_date):
+    output = BytesIO()
+    workbook = xlsxwriter.Workbook(output, {"in_memory": True})
+
+    base_format = workbook.add_format({"font_name": "Liberation Sans", "font_size": 10})
+    bold_format = workbook.add_format({"font_name": "Liberation Sans", "font_size": 10, "bold": True})
+    decimal_format = workbook.add_format({"font_name": "Liberation Sans", "font_size": 10, "num_format": "#,##.00"})
+    bold_decimal_format = workbook.add_format(
+        {"font_name": "Liberation Sans", "font_size": 10, "num_format": "#,##.00", "bold": True}
+    )
+    percent_format = workbook.add_format({"font_name": "Liberation Sans", "font_size": 10, "num_format": "#,##.00 %"})
+    bold_percent_format = workbook.add_format(
+        {"font_name": "Liberation Sans", "font_size": 10, "num_format": "#,##.00 %", "bold": True}
+    )
+
+    # HERE STARTS THE FIRST WORKSHEET
+    worksheet_products = workbook.add_worksheet(f"Products ({end_date:%d.%m.%Y})")
+
+    worksheet_products.write_string(0, 0, "Product", bold_format)
+    worksheet_products.write_string(0, 1, "Currency", bold_format)
+    worksheet_products.write_string(0, 2, "Price", bold_format)
+    worksheet_products.write_string(0, 3, "Price USD", bold_format)
+    worksheet_products.write_string(0, 4, "Direct Assets", bold_format)
+    worksheet_products.write_string(0, 5, "Direct Assets USD", bold_format)
+    worksheet_products.write_string(0, 6, "Indirect Assets", bold_format)
+    worksheet_products.write_string(0, 7, "Indirect Assets USD", bold_format)
+    worksheet_products.write_string(0, 8, "Total Assets USD", bold_format)
+
+    worksheet_products.write_formula(1, 5, "=SUM(F4:F99999)", bold_decimal_format)
+    worksheet_products.write_formula(1, 7, "=SUM(H4:H99999)", bold_decimal_format)
+    worksheet_products.write_formula(1, 8, "=SUM(I4:I99999)", bold_decimal_format)
+
+    fx_rates = CurrencyFXRates.get_fx_rates_subquery(end_date)
+    customer_accounts = Account.get_accounts_for_customer(customer)
+    valid_customer_roles = (
+        AccountRole.objects.filter(entry=customer)
+        .annotate(is_currently_valid=AccountRoleValidity.get_role_validity_subquery(date.today()))
+        .filter(is_currently_valid=True)
+    )
+    account_types = AccountRoleType.objects.filter(id__in=valid_customer_roles.values("role_type"))
+
+    user_claims = Claim.objects.filter_for_customer(customer, include_related_roles=True).filter_for_user(
+        user, validity_date=date.today()
+    )
+    products = (
+        user_claims.filter(
+            date__lte=end_date,
+            status=Claim.Status.APPROVED,
+        )
+        .annotate(
+            owner_asset_shares=Case(When(account__in=customer_accounts, then=F("shares")), default=Decimal(0)),
+            **{
+                f"{account_type.key}_assets_shares": Case(
+                    When(
+                        account__in=valid_customer_roles.filter(role_type=account_type).values("account"),
+                        then=F("shares"),
+                    ),
+                    default=Decimal(0),
+                )
+                for account_type in account_types
+            },
+        )
+        .values("product")
+        .annotate(
+            price=InstrumentPrice.subquery_closest_value(
+                "net_value", val_date=end_date, instrument_pk_name="product__pk"
+            ),
+            product_id=F("product_id"),
+            title=F("product__name"),
+            currency=F("product__currency__symbol"),
+            sum_shares=Sum("shares"),
+            fx_rate=fx_rates,
+            sum_owner_assets_shares=Sum("owner_asset_shares"),
+            **{
+                f"sum_{account_type.key}_assets_shares": Sum(f"{account_type.key}_assets_shares")
+                for account_type in account_types
+            },
+        )
+        .order_by("title")
+    )
+    for row, product in enumerate(products, start=3):
+        product_cell = xl_rowcol_to_cell(row, 0)
+        currency_cell = xl_rowcol_to_cell(row, 1)
+        price_cell = xl_rowcol_to_cell(row, 2)
+        price_usd_cell = xl_rowcol_to_cell(row, 3)
+        owner_assets_cell = xl_rowcol_to_cell(row, 4)
+        owner_assets_usd_cell = xl_rowcol_to_cell(row, 5)
+        account_role_cells = dict()
+        account_role_cells_usd = dict()
+        index = 6
+        for account_type in account_types:
+            account_role_cells[account_type.key] = xl_rowcol_to_cell(row, index)
+            account_role_cells_usd[account_type.key] = xl_rowcol_to_cell(row, index + 1)
+            index += 2
+        total_assets_usd_cell = xl_rowcol_to_cell(row, index)
+
+        worksheet_products.write_string(product_cell, product["title"], base_format)
+        worksheet_products.write_string(currency_cell, product["currency"], base_format)
+        worksheet_products.write_number(price_cell, product["price"], decimal_format)
+        worksheet_products.write_formula(price_usd_cell, f"{price_cell} * {product['fx_rate']}", decimal_format)
+
+        worksheet_products.write_formula(
+            owner_assets_cell, f"{product['sum_owner_assets_shares']} * {price_cell}", decimal_format
+        )
+        worksheet_products.write_formula(
+            owner_assets_usd_cell, f"{owner_assets_cell} * {product['fx_rate']}", decimal_format
+        )
+
+        for account_type in account_types:
+            worksheet_products.write_formula(
+                account_role_cells[account_type.key],
+                f"{product[f'sum_{account_type.key}_assets_shares']} * {price_cell}",
+                decimal_format,
+            )
+            worksheet_products.write_formula(
+                account_role_cells_usd[account_type.key],
+                f"{account_role_cells[account_type.key]} * {product['fx_rate']}",
+                decimal_format,
+            )
+        worksheet_products.write_formula(
+            total_assets_usd_cell,
+            " + ".join([owner_assets_usd_cell] + list(account_role_cells_usd.values())),
+            decimal_format,
+        )
+
+    # HERE STARTS THE SECOND WORKSHEET
+    worksheet_trade_performance = workbook.add_worksheet(f"Trades ({end_date:%d.%m.%Y})")
+
+    worksheet_trade_performance.write_string(0, 0, "Trade Date", bold_format)
+    worksheet_trade_performance.write_string(0, 1, "Shares", bold_format)
+    worksheet_trade_performance.write_string(0, 2, "Bank", bold_format)
+    worksheet_trade_performance.write_string(0, 3, "Root Account", bold_format)
+    worksheet_trade_performance.write_string(0, 4, "Account", bold_format)
+    worksheet_trade_performance.write_string(0, 5, "Product", bold_format)
+    worksheet_trade_performance.write_string(0, 6, "Price (Trade Date)", bold_format)
+    worksheet_trade_performance.write_string(0, 7, "Net Value (Trade Date)", bold_format)
+    worksheet_trade_performance.write_string(0, 8, "Net Value (Trade Date) USD", bold_format)
+    worksheet_trade_performance.write_string(0, 9, f"Price ({end_date:%d.%m.%Y})", bold_format)
+    worksheet_trade_performance.write_string(0, 10, f"Net Value ({end_date:%d.%m.%Y})", bold_format)
+    worksheet_trade_performance.write_string(0, 11, f"Net Value ({end_date:%d.%m.%Y}) USD", bold_format)
+    worksheet_trade_performance.write_string(0, 12, "Performance", bold_format)
+
+    worksheet_trade_performance.write_formula(1, 8, "=SUM(I4:I99999)", bold_decimal_format)
+    worksheet_trade_performance.write_formula(1, 11, "=SUM(L4:L99999)", bold_decimal_format)
+    worksheet_trade_performance.write_formula(1, 12, "=(L2/I2)-1", bold_percent_format)
+
+    fx_rates_date = CurrencyFXRates.get_fx_rates_subquery("date")
+
+    fx_rates_end = CurrencyFXRates.get_fx_rates_subquery(end_date)
+
+    claims = (
+        user_claims.filter(
+            date__lte=end_date,
+            status=Claim.Status.APPROVED,
+        )
+        .annotate(
+            price_date=InstrumentPrice.subquery_closest_value("net_value", instrument_pk_name="product__pk"),
+            price_end=InstrumentPrice.subquery_closest_value(
+                "net_value", val_date=end_date, instrument_pk_name="product__pk"
+            ),
+            fx_rates_date=fx_rates_date,
+            fx_rates_end=fx_rates_end,
+        )
+        .order_by("date")
+    ).select_related("product", "account")
+
+    for row, claim in enumerate(claims, start=3):
+        trade_date_cell = xl_rowcol_to_cell(row, 0)
+        shares_cell = xl_rowcol_to_cell(row, 1)
+        bank_cell = xl_rowcol_to_cell(row, 2)
+        root_account_cell = xl_rowcol_to_cell(row, 3)
+        account_cell = xl_rowcol_to_cell(row, 4)
+        product_cell = xl_rowcol_to_cell(row, 5)
+        price_trade_cell = xl_rowcol_to_cell(row, 6)
+        net_value_trade_cell = xl_rowcol_to_cell(row, 7)
+        net_value_usd_trade_cell = xl_rowcol_to_cell(row, 8)
+        price_end_cell = xl_rowcol_to_cell(row, 9)
+        net_value_end_cell = xl_rowcol_to_cell(row, 10)
+        net_value_usd_end_cell = xl_rowcol_to_cell(row, 11)
+        performance_cell = xl_rowcol_to_cell(row, 12)
+
+        worksheet_trade_performance.write_string(trade_date_cell, f"{claim.date:%d.%m.%Y}", base_format)
+        worksheet_trade_performance.write_number(shares_cell, claim.shares, decimal_format)
+        worksheet_trade_performance.write_string(bank_cell, claim.bank, base_format)
+        worksheet_trade_performance.write_string(root_account_cell, claim.account.get_root().title, base_format)
+        worksheet_trade_performance.write_string(account_cell, str(claim.account), base_format)
+        worksheet_trade_performance.write_string(product_cell, claim.product.title, base_format)
+
+        worksheet_trade_performance.write_number(
+            price_trade_cell, claim.price_date or claim.product.share_price, decimal_format
+        )
+        worksheet_trade_performance.write_formula(
+            net_value_trade_cell, f"={shares_cell}*{price_trade_cell}", decimal_format
+        )
+        worksheet_trade_performance.write_formula(
+            net_value_usd_trade_cell, f"={net_value_trade_cell}*{claim.fx_rates_date}", decimal_format
+        )
+
+        worksheet_trade_performance.write_number(price_end_cell, claim.price_end, decimal_format)
+        worksheet_trade_performance.write_formula(
+            net_value_end_cell, f"={shares_cell}*{price_end_cell}", decimal_format
+        )
+        worksheet_trade_performance.write_formula(
+            net_value_usd_end_cell, f"={net_value_end_cell}*{claim.fx_rates_end}", decimal_format
+        )
+
+        worksheet_trade_performance.write_formula(
+            performance_cell, f"=({net_value_usd_end_cell}/{net_value_usd_trade_cell})-1", percent_format
+        )
+
+    # HERE STARTS THE THIRD WORKSHEET
+    worksheet_rebates = workbook.add_worksheet(f"Rebates ({start_date:%d.%m.%Y}-{end_date:%d.%m.%Y})")
+
+    worksheet_rebates.write_string(0, 0, "Date", bold_format)
+    worksheet_rebates.write_string(0, 1, "Product", bold_format)
+    worksheet_rebates.write_string(0, 2, "Account", bold_format)
+    for index, commission_type in enumerate(CommissionType.objects.all()):
+        worksheet_rebates.write_string(0, index + 3, f"{commission_type.name.title()} Fees", bold_format)
+        worksheet_rebates.write_formula(
+            1, index + 3, f"=SUM({chr(ord('@') + (index + 3))}3]:E99999)", bold_decimal_format
+        )
+
+    rebates_for_user = Rebate.objects.filter_for_user(user, validity_date=date.today())
+    rebates = (
+        rebates_for_user.filter(recipient=customer, date__gte=start_date, date__lte=end_date)
+        .select_related("account", "product")
+        .annotate(
+            **{
+                f"{commission_type.key}__value": Case(
+                    When(commission_type=commission_type, then=F("value")), default=Decimal(0)
+                )
+                for commission_type in CommissionType.objects.all()
+            }
+        )
+        .values("date", "account", "product")
+        .annotate(
+            product_title=F("product__name"),
+            account_id=F("account__id"),
+            account_title=F("account__computed_str"),
+            **{
+                f"sum_{commission_type.key}_value": Sum(f"{commission_type.key}__value")
+                for commission_type in CommissionType.objects.all()
+            },
+        )
+        .order_by("date", "product", "account_id")
+    )
+
+    for row, rebate in enumerate(rebates, start=4):
+        date_cell = xl_rowcol_to_cell(row, 0)
+        product_cell = xl_rowcol_to_cell(row, 1)
+        account_cell = xl_rowcol_to_cell(row, 2)
+
+        worksheet_rebates.write_string(date_cell, f"{rebate['date']:%d.%m.%Y}", base_format)
+        worksheet_rebates.write_string(product_cell, rebate["product_title"], base_format)
+        worksheet_rebates.write_string(account_cell, rebate["account_title"], base_format)
+        for index, commission_type in enumerate(CommissionType.objects.all()):
+            cell = xl_rowcol_to_cell(row, 3 + index)
+            worksheet_rebates.write_number(cell, rebate[f"sum_{commission_type.key}_value"], decimal_format)
+
+    workbook.close()
+    output.seek(0)
+    return (
+        output,
+        "customer_report_{}_{}_{}.xlsx".format(customer.computed_str, start_date, end_date),
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    )

wbcommission/reports/utils.py

@@ -0,0 +1,30 @@
+from contextlib import suppress
+from datetime import date
+
+from django.core.mail import EmailMultiAlternatives
+from django.template.loader import get_template
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.directory.models import Entry
+from wbcore.utils.html import convert_html2text
+
+AccountCustomer = None
+
+
+def create_report_and_send(user: User, customer: Entry, start_date: date, end_date: date, report_callback):
+    with suppress(ValueError):
+        report_stream, file_name, file_extension = report_callback(user, customer, start_date, end_date)
+
+        html = get_template("portfolio/email/customer_report.html")
+
+        context = {"profile": user, "customer": customer}
+        html_content = html.render(context)
+
+        msg = EmailMultiAlternatives("Report", body=convert_html2text(html_content), to=[user.email])
+        msg.attach_alternative(html_content, "text/html")
+        report_stream.seek(0)
+        msg.attach(
+            file_name,
+            report_stream.read(),
+            file_extension,
+        )
+        msg.send()

wbcommission/serializers/__init__.py

@@ -0,0 +1,3 @@
+from .rebate import RebateModelSerializer, RebateProductMarginalitySerializer
+from .commissions import CommissionTypeRepresentationSerializer, CommissionTypeModelSerializer
+from .signals import *

wbcommission/serializers/commissions.py

@@ -0,0 +1,26 @@
+from wbcommission.models import CommissionType
+from wbcore import serializers as wb_serializers
+
+
+class CommissionTypeRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcommission:commissiontype-detail")
+
+    class Meta:
+        model = CommissionType
+        fields = (
+            "id",
+            "name",
+            "key",
+            "_detail",
+        )
+
+
+class CommissionTypeModelSerializer(wb_serializers.ModelSerializer):
+    class Meta:
+        model = CommissionType
+        read_only_fields = ("key",)
+        fields = (
+            "id",
+            "name",
+            "key",
+        )

wbcommission/serializers/rebate.py

@@ -0,0 +1,87 @@
+from wbcommission.models import Rebate
+from wbcore import serializers as wb_serializers
+
+
+class RebateModelSerializer(wb_serializers.ModelSerializer):
+    id = wb_serializers.PrimaryKeyField()
+    value_usd = wb_serializers.FloatField(read_only=True)
+
+    class Meta:
+        model = Rebate
+        fields = ("id", "value_usd")
+
+
+class RebateProductMarginalitySerializer(wb_serializers.Serializer):
+    id = wb_serializers.PrimaryKeyField()
+    title = wb_serializers.CharField(read_only=True)
+    currency_symbol = wb_serializers.CharField(read_only=True)
+    sum_management_fees = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Management Fees")
+    sum_performance_fees = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Management Rebates")
+    sum_crystalized_performance_fees = wb_serializers.DecimalField(
+        max_digits=16, decimal_places=2, label="Crystalized Performance Fees"
+    )
+    sum_management_rebates = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Performance Fees")
+    sum_performance_rebates = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Performance Rebates")
+    marginality_management = wb_serializers.DecimalField(
+        max_digits=16, decimal_places=2, label="Marginality Management"
+    )
+    marginality_performance = wb_serializers.DecimalField(
+        max_digits=16, decimal_places=2, label="Marginality Performance"
+    )
+
+    total_fees = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Total Fees")
+    total_rebates = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Total Rebates")
+    total_marginality = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Total Marginality")
+
+    total_fees_usd = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Total Fees (USD)")
+    total_rebates_usd = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Total Rebates (USD)")
+    total_usd = wb_serializers.DecimalField(max_digits=16, decimal_places=2, label="Total Net (USD)")
+
+    class Meta:
+        percent_fields = [
+            "marginality_management",
+            "marginality_performance",
+            "total_marginality",
+        ]
+        decorators = {
+            "sum_management_fees": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{currency_symbol}}"
+            ),
+            "sum_performance_fees": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{currency_symbol}}"
+            ),
+            "sum_management_rebates": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{currency_symbol}}"
+            ),
+            "sum_performance_rebates": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{currency_symbol}}"
+            ),
+            "total_fees": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{currency_symbol}}"
+            ),
+            "total_rebates": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{currency_symbol}}"
+            ),
+            "total_fees_usd": wb_serializers.decorator(decorator_type="text", position="left", value="$"),
+            "total_rebates_usd": wb_serializers.decorator(decorator_type="text", position="left", value="$"),
+        }
+
+        fields = (
+            "id",
+            "title",
+            "currency_symbol",
+            "sum_management_fees",
+            "sum_performance_fees",
+            "sum_crystalized_performance_fees",
+            "sum_management_rebates",
+            "sum_performance_rebates",
+            "marginality_management",
+            "marginality_performance",
+            "total_fees",
+            "total_rebates",
+            "total_marginality",
+            "total_fees_usd",
+            "total_rebates_usd",
+            "total_usd",
+        )
+        read_only_fields = fields

wbcommission/serializers/signals.py

@@ -0,0 +1,27 @@
+from django.dispatch import receiver
+from rest_framework.reverse import reverse
+from wbcore.contrib.directory.serializers import (
+    CompanyModelSerializer,
+    EntryModelSerializer,
+    PersonModelSerializer,
+)
+from wbcore.filters.defaults import current_quarter_date_end, current_quarter_date_start
+from wbcore.signals import add_instance_additional_resource
+
+
+# register the rebate and generate report addition resources to the entry model serializers
+@receiver(add_instance_additional_resource, sender=CompanyModelSerializer)
+@receiver(add_instance_additional_resource, sender=PersonModelSerializer)
+@receiver(add_instance_additional_resource, sender=EntryModelSerializer)
+def commission_adding_additional_resource(sender, serializer, instance, request, user, **kwargs):
+    start = current_quarter_date_start()
+    end = current_quarter_date_end()
+    res = {
+        "rebates": f'{reverse("wbcommission:rebatetable-list", args=[], request=request)}?group_by=PRODUCT&recipient={instance.id}&date={start:%Y-%m-%d},{end:%Y-%m-%d}',
+        "generate_customer_commission_report": f'{reverse("wbcommission:rebate-customerreport", request=request)}?recipient_id={instance.id}',
+    }
+    if user.has_perm("wbcommission.administrate_commission"):
+        res[
+            "generate_audit_commission_report"
+        ] = f'{reverse("wbcommission:rebate-auditreport", request=request)}?recipient_id={instance.id}'
+    return res