wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/serializers/products.py

@@ -0,0 +1,331 @@
+from decimal import Decimal
+
+from django.contrib.contenttypes.models import ContentType
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.directory.serializers import (
+    CompanyRepresentationSerializer,
+    EntryRepresentationSerializer,
+)
+from wbcore.contrib.geography.serializers import GeographyRepresentationSerializer
+from wbfdm.models import Instrument
+from wbfdm.serializers.instruments.instruments import InstrumentModelSerializer
+from wbportfolio.models import Portfolio, Product
+from wbportfolio.serializers.portfolios import PortfolioRepresentationSerializer
+
+from .product_group import ProductGroupRepresentationSerializer
+from .synchronization import PriceComputationRepresentationSerializer
+
+
+class ProductRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:product-detail")
+    bank_name = wb_serializers.CharField(read_only=True)
+
+    class Meta:
+        model = Product
+        fields = ("id", "computed_str", "isin", "name", "bank_name", "_detail")
+
+
+class ProductCustomerRepresentationSerializer(ProductRepresentationSerializer):
+    label_key = "{{name}} - {{isin}} ({{bank_name}})"
+
+    class Meta:
+        model = Product
+        fields = ("id", "isin", "name", "bank_name")
+
+
+class ProductUnlinkedRepresentationSerializer(ProductRepresentationSerializer):
+    class Meta(ProductRepresentationSerializer.Meta):
+        model = Product
+        fields = ("id", "isin", "name")
+
+
+class ProductListModelSerializer(
+    InstrumentModelSerializer,
+):
+    _bank = CompanyRepresentationSerializer(source="bank")
+    _parent = ProductGroupRepresentationSerializer(source="parent")
+    _white_label_customers = EntryRepresentationSerializer(source="white_label_customers", many=True)
+    current_total_issuer_fees = wb_serializers.DecimalField(
+        default=Decimal(0), read_only=True, max_digits=6, decimal_places=4, label="Issue Fees"
+    )
+    current_bank_fees = wb_serializers.DecimalField(
+        default=Decimal(0), read_only=True, max_digits=6, decimal_places=4, label="Bank Fees"
+    )
+    current_management_fees = wb_serializers.DecimalField(
+        default=Decimal(0), read_only=True, max_digits=6, decimal_places=4, label="Management Fees"
+    )
+    current_performance_fees = wb_serializers.DecimalField(
+        default=Decimal(0), read_only=True, max_digits=6, decimal_places=4, label="Performance Fees"
+    )
+
+    # AUM based info
+    net_value = wb_serializers.FloatField(label="Net Value", required=False, read_only=True)
+    assets_under_management = wb_serializers.FloatField(
+        label="Assets under Management", required=False, default=0, read_only=True
+    )
+    assets_under_management_usd = wb_serializers.FloatField(
+        label="Assets under Management in USD", required=False, default=0, read_only=True
+    )
+    sum_shares = wb_serializers.FloatField(default=0, read_only=True)
+    is_white_label = wb_serializers.BooleanField(read_only=True)
+
+    # NNM annotations
+    nnm_weekly = wb_serializers.FloatField(label="NNM Weekly", required=False, default=0, read_only=True)
+    nnm_monthly = wb_serializers.FloatField(label="NNM Monthly", required=False, default=0, read_only=True)
+    nnm_year_to_date = wb_serializers.FloatField(label="NNM YTD", required=False, default=0, read_only=True)
+    nnm_yearly = wb_serializers.FloatField(label="NNM YEARLY", required=False, default=0, read_only=True)
+    # general info
+    is_invested = wb_serializers.BooleanField(default=True, read_only=True)
+
+    @wb_serializers.register_resource()
+    def additional_resources(self, instance, request, user):
+        additional_resources = dict()
+        additional_resources["peers"] = (
+            reverse("wbfdm:instrument-relatedinstrument-list", args=[instance.id], request=request)
+            + "?related_type=PEER"
+        )
+        additional_resources["benchmarks"] = (
+            reverse("wbfdm:instrument-relatedinstrument-list", args=[instance.id], request=request)
+            + "?related_type=BENCHMARK"
+        )
+        return additional_resources
+
+    class Meta(InstrumentModelSerializer.Meta):
+        decorators = {
+            "share_price": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "net_value": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "assets_under_management": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "assets_under_management_usd": wb_serializers.decorator(decorator_type="text", position="left", value="$"),
+            "nnm_weekly": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "nnm_monthly": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "nnm_year_to_date": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "nnm_yearly": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+        }
+        percent_fields = [
+            "current_bank_fees",
+            "current_management_fees",
+            "current_performance_fees",
+            "current_total_issuer_fees",
+        ]
+        model = Product
+        read_only_fields = [
+            "share_price",
+            "initial_high_water_mark",
+            "issue_price",
+            "last_valuation_date",
+            "last_price_date",
+            *InstrumentModelSerializer.Meta.read_only_fields,
+        ]
+        fields = (
+            "id",
+            "name",
+            "name_repr",
+            "bank",
+            "_bank",
+            "parent",
+            "_parent",
+            "description",
+            "share_price",
+            "initial_high_water_mark",
+            "current_total_issuer_fees",
+            "current_management_fees",
+            "current_performance_fees",
+            "current_bank_fees",
+            "currency",
+            "_currency",
+            "isin",
+            "ticker",
+            "net_value",
+            "sum_shares",
+            "assets_under_management",
+            "assets_under_management_usd",
+            "nnm_weekly",
+            "nnm_monthly",
+            "nnm_year_to_date",
+            "nnm_yearly",
+            "is_white_label",
+            "last_valuation_date",
+            "last_price_date",
+            "is_invested",
+            "white_label_customers",
+            "_white_label_customers",
+            "_additional_resources",
+            "_classifications",
+            "classifications",
+        )
+
+
+class ProductModelSerializer(ProductListModelSerializer):
+    id_repr = wb_serializers.CharField(source="id", read_only=True, label="ID")
+
+    _jurisdiction = GeographyRepresentationSerializer(source="jurisdiction", filter_params={"level": 1})
+
+    is_next_factsheet_available = wb_serializers.BooleanField(default=False, read_only=True)
+
+    _portfolios = PortfolioRepresentationSerializer(source="portfolios", many=True)
+    _price_computation = PriceComputationRepresentationSerializer(source="price_computation")
+
+    @wb_serializers.register_resource()
+    def additional_resources(self, instance, request, user):
+        additional_resources = dict()
+
+        if user.profile.is_internal or user.is_superuser:
+            additional_resources[
+                "aum"
+            ] = f'{reverse("wbportfolio:aumtable-list", args=[], request=request)}?product={instance.id}&group_by=ACCOUNT'
+            additional_resources["claims"] = reverse(
+                "wbportfolio:product-claim-list",
+                args=[instance.id],
+                request=request,
+            )
+
+            if portfolio := instance.portfolio:
+                additional_resources["preferredclassification"] = reverse(
+                    "wbportfolio:portfolio-preferredclassification-list",
+                    args=[portfolio.id],
+                    request=request,
+                )
+                product_ct = ContentType.objects.get_for_model(Product)
+                instrument_ct = ContentType.objects.get_for_model(Instrument)
+                portfolio_cd = ContentType.objects.get_for_model(Portfolio)
+                additional_resources["risk_incidents"] = (
+                    reverse("wbcompliance:riskrule-list", args=[], request=request)
+                    + f"?checked_object_relationships=[({product_ct.id},{instance.id}),({instrument_ct.id},{instance.id}),({portfolio_cd.id},{portfolio.id})]"
+                )
+        return additional_resources
+
+    class Meta(ProductListModelSerializer.Meta):
+        fields = (
+            "id_repr",
+            "bank",
+            "_bank",
+            "share_price",
+            "initial_high_water_mark",
+            "current_bank_fees",
+            "current_management_fees",
+            "current_performance_fees",
+            "current_total_issuer_fees",
+            "white_label_customers",
+            "_white_label_customers",
+            "type_of_return",
+            "asset_class",
+            "legal_structure",
+            "investment_index",
+            "liquidity",
+            "risk_scale",
+            "jurisdiction",
+            "_jurisdiction",
+            "is_next_factsheet_available",
+            "external_webpage",
+            "issue_price",
+            "is_invested",
+            "net_value",
+            "last_valuation_date",
+            "assets_under_management",
+            "assets_under_management_usd",
+            "nnm_weekly",
+            "nnm_monthly",
+            "nnm_year_to_date",
+            "nnm_yearly",
+            "is_white_label",
+            "parent",
+            "_parent",
+            "_portfolios",
+            "portfolios",
+            "_price_computation",
+            "price_computation",
+        ) + InstrumentModelSerializer.Meta.fields
+
+
+class ProductCustomerModelSerializer(ProductListModelSerializer):
+    bank_repr = wb_serializers.CharField(read_only=True)
+    currency_symbol = wb_serializers.CharField(read_only=True)
+
+    class Meta:
+        model = Product
+        decorators = {
+            "net_value": wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}"),
+        }
+        fields = (
+            "id",
+            "name",
+            "isin",
+            "bank_repr",
+            "currency_symbol",
+            "ticker",
+            "net_value",
+        )
+
+
+class ProductFeesModelSerializer(wb_serializers.ModelSerializer):
+    _currency = CurrencyRepresentationSerializer(source="currency")
+
+    sum_management_fees = wb_serializers.FloatField(
+        label="Bank Fees",
+        required=False,
+        read_only=True,
+        decorators=[{"position": "left", "value": "{{_currency.symbol}}"}],
+    )
+    sum_management_fees_usd = wb_serializers.FloatField(
+        label="USD",
+        required=False,
+        read_only=True,
+        decorators=[{"position": "left", "value": "$"}],
+    )
+    sum_performance_fees_net = wb_serializers.FloatField(
+        label="Bank Fees",
+        required=False,
+        read_only=True,
+        decorators=[{"position": "left", "value": "{{_currency.symbol}}"}],
+    )
+    sum_performance_fees_net_usd = wb_serializers.FloatField(
+        label="USD",
+        required=False,
+        read_only=True,
+        decorators=[{"position": "left", "value": "$"}],
+    )
+    sum_total = wb_serializers.FloatField(
+        label="USD",
+        required=False,
+        read_only=True,
+        decorators=[{"position": "left", "value": "{{_currency.symbol}}"}],
+    )
+    sum_total_usd = wb_serializers.FloatField(
+        label="USD",
+        required=False,
+        read_only=True,
+        decorators=[{"position": "left", "value": "$"}],
+    )
+
+    class Meta:
+        model = Product
+        fields = (
+            "id",
+            "computed_str",
+            "isin",
+            "ticker",
+            "currency",
+            "_currency",
+            "sum_management_fees",
+            "sum_management_fees_usd",
+            "sum_performance_fees_net",
+            "sum_performance_fees_net_usd",
+            "sum_total",
+            "sum_total_usd",
+        )

wbportfolio/serializers/reconciliations.py

@@ -0,0 +1,171 @@
+from typing import TYPE_CHECKING, Any
+
+from rest_framework.reverse import reverse
+from wbcore import serializers
+from wbcore.contrib.authentication.serializers import UserRepresentationSerializer
+from wbcore.utils.urls import new_mode
+from wbcrm.models import Account
+from wbcrm.serializers.accounts import AccountRepresentationSerializer
+from wbportfolio.models import AccountReconciliation
+from wbportfolio.models.reconciliations import AccountReconciliationLine
+from wbportfolio.serializers.products import ProductRepresentationSerializer
+
+if TYPE_CHECKING:
+    from rest_framework.request import Request
+    from wbcore.contrib.authentication.models import User
+
+
+class AccountReconciliationModelSerializer(serializers.ModelSerializer):
+    creator = serializers.PrimaryKeyRelatedField(required=False)
+    _creator = UserRepresentationSerializer(source="creator")
+    account = serializers.PrimaryKeyRelatedField(default=serializers.DefaultFromGET("account"))
+    _account = AccountRepresentationSerializer(source="account")
+    approved_by = serializers.PrimaryKeyRelatedField(required=False)
+    _approved_by = UserRepresentationSerializer(source="approved_by")
+
+    def validate(self, data: dict) -> dict:
+        data["creator"] = self.context["request"].user
+        if account := data.get("account", None):
+            account = account[0] if isinstance(account, list) else account
+            data["account"] = Account.objects.get(id=account)
+        return data
+
+    @serializers.register_resource()
+    def register_lines(self, instance: AccountReconciliation, request: "Request", user: "User") -> dict[str, str]:
+        return {
+            "lines": reverse(
+                "wbportfolio:accountreconciliation-accountreconciliationline-list", args=[instance.id], request=request
+            )
+        }
+
+    @serializers.register_resource()
+    def register_reconcile(self, instance: AccountReconciliation, request: "Request", user: "User") -> dict[str, str]:
+        if instance.approved_dt:
+            return {}
+
+        if not user.is_internal:
+            if hasattr(instance, "unequal_exists") and instance.unequal_exists:
+                return {
+                    "disagree_customer": reverse(
+                        "wbportfolio:accountreconciliation-disagree-customer", args=[instance.id], request=request
+                    )
+                }
+            elif hasattr(instance, "unequal_exists") and not instance.unequal_exists:
+                return {
+                    "agree_customer": reverse(
+                        "wbportfolio:accountreconciliation-agree-customer", args=[instance.id], request=request
+                    )
+                }
+
+        return {}
+
+    @serializers.register_resource()
+    def register_claims(self, instance: AccountReconciliation, request: "Request", user: "User") -> dict[str, str]:
+        return {
+            "claims": reverse("wbportfolio:account-claim-list", args=[instance.account.id], request=request),
+            "add-claim": new_mode(reverse("wbportfolio:claim-list", request=request)),
+        }
+
+    @serializers.register_resource()
+    def register_recompute(self, instance: AccountReconciliation, request: "Request", user: "User") -> dict[str, str]:
+        if instance.approved_dt:
+            return {}
+
+        if user.is_internal:
+            return {
+                "recalculate": reverse(
+                    "wbportfolio:accountreconciliation-recompute", args=[instance.id], request=request
+                ),
+                "notify": reverse("wbportfolio:accountreconciliation-notify", args=[instance.id], request=request),
+            }
+
+        return {}
+
+    class Meta:
+        model = AccountReconciliation
+        fields = (
+            "id",
+            "reconciliation_date",
+            "creator",
+            "_creator",
+            "approved_by",
+            "_approved_by",
+            "approved_dt",
+            "account",
+            "_account",
+            "_additional_resources",
+        )
+
+
+class AccountReconciliationLineModelSerializer(serializers.ModelSerializer):
+    _product = ProductRepresentationSerializer(source="product")
+    is_equal = serializers.BooleanField(read_only=True)
+
+    assets_under_management = serializers.IntegerField(
+        read_only=True,
+        decorators=[serializers.decorator(position="left", value="{{currency_key}}", decorator_type="text")],
+    )
+    assets_under_management_external = serializers.IntegerField(
+        read_only=True,
+        decorators=[serializers.decorator(position="left", value="{{currency_key}}", decorator_type="text")],
+    )
+    assets_under_management_diff = serializers.IntegerField(
+        read_only=True,
+        decorators=[serializers.decorator(position="left", value="{{currency_key}}", decorator_type="text")],
+    )
+    shares_diff = serializers.IntegerField(read_only=True)
+    nominal_value_diff = serializers.IntegerField(read_only=True)
+    pct_diff = serializers.DecimalField(read_only=True, max_digits=5, decimal_places=4)
+
+    price = serializers.DecimalField(read_only=True, max_digits=18, decimal_places=2, label="Price")
+
+    currency = serializers.CharField(required=False)
+    currency_key = serializers.CharField(required=False)
+
+    @serializers.register_resource()
+    def register_claims(self, instance: AccountReconciliationLine, request: "Request", user: "User") -> dict[str, str]:
+        return {
+            "product-claims": f'{reverse("wbportfolio:account-claim-list", args=[instance.reconciliation.account.id], request=request)}?product={instance.product.id}',
+            "add-product-claim": new_mode(
+                f'{reverse("wbportfolio:claim-list", request=request)}?product={instance.product.id}'
+            ),
+        }
+
+    def validate(self, data: dict[str, Any]) -> dict[str, Any]:
+        # If we get either external shares or external nominal value, we have to set the other one explicitly to None
+        # to be sure that the other side is correctly computed inside the save method
+        if "shares_external" not in data and "nominal_value_external" in data:
+            data["shares_external"] = None
+
+        if "shares_external" in data and "nominal_value_external" not in data:
+            data["nominal_value_external"] = None
+
+        return super().validate(data)
+
+    class Meta:
+        model = AccountReconciliationLine
+        read_only_fields = ("product", "shares", "nominal_value")
+        decorators = {"price": serializers.decorator(position="left", value="{{currency_key}}", decorator_type="text")}
+        percent_fields = ["pct_diff"]
+        fields = (
+            "id",
+            "reconciliation",
+            "price",
+            "price_date",
+            "currency",
+            "currency_key",
+            "product",
+            "_product",
+            "shares",
+            "nominal_value",
+            "assets_under_management",
+            "shares_external",
+            "nominal_value_external",
+            "assets_under_management_external",
+            "shares_diff",
+            "nominal_value_diff",
+            "assets_under_management_diff",
+            "pct_diff",
+            "is_equal",
+            "_additional_resources",
+        )

wbportfolio/serializers/registers.py

@@ -0,0 +1,72 @@
+from rest_framework.reverse import reverse
+from wbcore import serializers
+from wbcore.contrib.geography.serializers import GeographyRepresentationSerializer
+from wbportfolio.models import Register
+
+
+class RegisterRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="wbportfolio:register-detail")
+
+    class Meta:
+        model = Register
+        fields = ("id", "computed_str", "_detail")
+
+
+class RegisterModelSerializer(serializers.ModelSerializer):
+    _custodian_country = GeographyRepresentationSerializer(source="custodian_country", filter_params={"level": 1})
+    _custodian_city = GeographyRepresentationSerializer(source="custodian_city", filter_params={"level": 3})
+    _outlet_city = GeographyRepresentationSerializer(source="outlet_city", filter_params={"level": 3})
+    _outlet_country = GeographyRepresentationSerializer(source="outlet_country", filter_params={"level": 1})
+    _citizenship = GeographyRepresentationSerializer(source="citizenship", filter_params={"level": 1})
+    _residence = GeographyRepresentationSerializer(source="residence", filter_params={"level": 1})
+
+    @serializers.register_only_instance_resource()
+    def trades(self, instance, request, user, **kwargs):
+        if instance.trades.exists():
+            base_url = reverse("wbportfolio:trade-list", request=request)
+            return {"trades": f"{base_url}?register={instance.id}"}
+        return {}
+
+    class Meta:
+        model = Register
+        fields = (
+            "id",
+            "register_reference",
+            "register_name_1",
+            "register_name_2",
+            "global_register_reference",
+            "external_register_reference",
+            "custodian_reference",
+            "custodian_name_1",
+            "custodian_name_2",
+            "custodian_address",
+            "custodian_postcode",
+            "custodian_city",
+            "custodian_country",
+            "sales_reference",
+            "dealer_reference",
+            "outlet_reference",
+            "outlet_name",
+            "outlet_address",
+            "outlet_postcode",
+            "outlet_city",
+            "_outlet_city",
+            "outlet_country",
+            "citizenship",
+            "residence",
+            "investor_type",
+            "status",
+            "status_message",
+            "opened",
+            "opened_reference_1",
+            "opened_reference_2",
+            "updated_reference_1",
+            "updated_reference_2",
+            # Related Fields
+            "_custodian_country",
+            "_custodian_city",
+            "_outlet_country",
+            "_citizenship",
+            "_residence",
+            "_additional_resources",
+        )

wbportfolio/serializers/roles.py

@@ -0,0 +1,60 @@
+from rest_framework import serializers
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbfdm.serializers import InvestableInstrumentRepresentationSerializer
+from wbportfolio.models import PortfolioRole
+
+
+class PortfolioRoleModelSerializer(wb_serializers.ModelSerializer):
+    """Model Serializer for Portfolio Roles"""
+
+    _person = PersonRepresentationSerializer(source="person")
+    _instrument = InvestableInstrumentRepresentationSerializer(source="instrument")
+
+    def create(self, validated_data):
+        instrument = validated_data.get("instrument", None)
+        role_type = validated_data.get("role_type")
+
+        if instrument is not None and role_type in [
+            PortfolioRole.RoleType.MANAGER,
+            PortfolioRole.RoleType.RISK_MANAGER,
+        ]:
+            raise serializers.ValidationError(
+                {"instrument": [PortfolioRole.default_error_messages["manager"].format(model="instrument")]}
+            )
+
+        return super().create(validated_data)
+
+    def update(self, instance, validated_data):
+        instrument = validated_data.get("instrument", None)
+        role_type = validated_data.get("role_type", instance.role_type)
+
+        if instrument is not None and role_type in [
+            PortfolioRole.RoleType.MANAGER,
+            PortfolioRole.RoleType.RISK_MANAGER,
+        ]:
+            raise serializers.ValidationError(
+                {"instrument": [PortfolioRole.default_error_messages["manager"].format(model="instrument")]}
+            )
+
+        return super().update(instance, validated_data)
+
+    class Meta:
+        model = PortfolioRole
+        fields = (
+            "id",
+            "role_type",
+            "person",
+            "_person",
+            "start",
+            "end",
+            "weighting",
+            "instrument",
+            "_instrument",
+        )
+
+
+class PortfolioRoleProjectModelSerializer(PortfolioRoleModelSerializer):
+    """Model Serializer for Portfolio Roles for Products"""
+
+    role_type = wb_serializers.ChoiceField(choices=PortfolioRole.RoleType.choices)