wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/models/reconciliations/account_reconciliation_lines.py

@@ -0,0 +1,192 @@
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+from django.db import models
+from django.db.models import Case, F, Q, When
+from django.db.models.functions import Cast
+from django.utils.translation import gettext_lazy as _
+from wbcore.models import WBModel
+from wbcrm.models import Account
+from wbfdm.models.instruments import InstrumentPrice
+from wbportfolio.models.transactions.claim import Claim
+
+if TYPE_CHECKING:
+    from wbportfolio.models import AccountReconciliation
+
+
+class AccountReconciliationLineQuerySet(models.QuerySet):
+    def update_or_create_for_reconciliation(self, reconciliation: "AccountReconciliation"):
+        holding_per_product = (
+            Claim.objects.filter(
+                status=Claim.Status.APPROVED,
+                account__in=reconciliation.account.get_descendants(include_self=True),
+                account__status=Account.Status.OPEN,
+                date__lte=reconciliation.reconciliation_date,
+            )
+            .values("product")
+            .annotate(
+                holdings=models.Sum("shares"),
+                price=InstrumentPrice.subquery_closest_value(
+                    "net_value", val_date=reconciliation.reconciliation_date, instrument_pk_name="product_id"
+                ),
+                price_date=InstrumentPrice.subquery_closest_value(
+                    "date", val_date=reconciliation.reconciliation_date, instrument_pk_name="product_id"
+                ),
+            )
+            .filter(~Q(holdings=0))
+            .values("product_id", "holdings", "price", "price_date")
+        )
+        lines = []
+        for holding in holding_per_product:
+            line = AccountReconciliationLine(
+                reconciliation=reconciliation,
+                product_id=holding["product_id"],
+                shares=holding["holdings"],
+                shares_external=holding["holdings"],
+                price=holding["price"],
+                price_date=holding["price_date"],
+            )
+            line.calculate_fields()
+            lines.append(line)
+
+        return AccountReconciliationLine.objects.bulk_create(
+            lines,
+            update_conflicts=True,
+            update_fields=["shares", "nominal_value", "price", "price_date"],
+            unique_fields=["reconciliation", "product"],
+        )
+
+    def annotate_currency(self) -> "AccountReconciliationLineQuerySet":
+        return self.annotate(currency=F("product__currency__symbol"))
+
+    def annotate_currency_key(self) -> "AccountReconciliationLineQuerySet":
+        return self.annotate(currency_key=F("product__currency__key"))
+
+    def annotate_assets_under_management(self) -> "AccountReconciliationLineQuerySet":
+        return self.annotate(assets_under_management=F("shares") * F("price"))
+
+    def annotate_assets_under_management_external(self) -> "AccountReconciliationLineQuerySet":
+        return self.annotate(assets_under_management_external=F("shares_external") * F("price"))
+
+    def annotate_is_equal(self) -> "AccountReconciliationLineQuerySet":
+        return self.annotate(
+            is_equal=models.Case(
+                models.When(shares=F("shares_external"), then=True), default=False, output_field=models.BooleanField()
+            )
+        )
+
+    def annotate_shares_diff(self) -> "AccountReconciliationLineQuerySet":
+        return self.annotate(shares_diff=F("shares_external") - F("shares"))
+
+    def annotate_pct_diff(self) -> "AccountReconciliationLineQuerySet":
+        ff = models.FloatField()
+        return self.annotate(
+            pct_diff=Case(
+                When(~Q(shares=0), then=(Cast("shares_external", ff) - Cast("shares", ff)) / Cast("shares", ff)),
+                default=None,
+            )
+        )
+
+    def annotate_nominal_value_diff(self) -> "AccountReconciliationLineQuerySet":
+        return self.annotate(nominal_value_diff=F("nominal_value_external") - F("nominal_value"))
+
+    def annotate_assets_under_management_diff(self) -> "AccountReconciliationLineQuerySet":
+        """Annotates the AuM diff. This will fail if annotate_assets_under_management was not called beforehand"""
+        return self.annotate(
+            assets_under_management_diff=F("assets_under_management_external") - F("assets_under_management")
+        )
+
+
+class AccountReconciliationLine(WBModel):
+    reconciliation = models.ForeignKey(
+        to="wbportfolio.AccountReconciliation",
+        related_name="lines",
+        on_delete=models.CASCADE,
+    )
+
+    product = models.ForeignKey(
+        to="wbportfolio.Product",
+        related_name="account_reconciliation_lines",
+        on_delete=models.CASCADE,
+    )
+
+    price = models.DecimalField(
+        decimal_places=4,
+        max_digits=18,
+        default=Decimal(0),
+        help_text=_("The last share price of the product"),
+    )
+
+    price_date = models.DateField()
+
+    shares = models.DecimalField(
+        decimal_places=4,
+        max_digits=18,
+        default=Decimal(0),
+        help_text=_("The number of shares computed through the Workbench"),
+    )
+    nominal_value = models.DecimalField(
+        decimal_places=4,
+        max_digits=18,
+        default=Decimal(0),
+        help_text=_("The nominal value computed through the Workbench"),
+    )
+    shares_external = models.DecimalField(
+        decimal_places=4,
+        max_digits=18,
+        default=Decimal(0),
+        help_text=_(
+            "The number of shares externally provided through the Account holder. Initially set to the number of shares computed through the Workbench"
+        ),
+    )
+    nominal_value_external = models.DecimalField(
+        decimal_places=4,
+        max_digits=18,
+        default=Decimal(0),
+        help_text=_(
+            "The nominal value externally provided through the Account holder. Initially set to the number of shares computed through the Workbench"
+        ),
+    )
+
+    objects = AccountReconciliationLineQuerySet.as_manager()
+
+    class Meta:
+        verbose_name = _("Account Reconciliation (Product)")
+        verbose_name_plural = _("Account Reconciliation (Products)")
+        constraints = [
+            models.UniqueConstraint(fields=["reconciliation", "product"], name="unique_reconcilation_product"),
+        ]
+
+    def save(self, *args, **kwargs):
+        self.calculate_fields()
+        super().save(*args, **kwargs)
+
+    def calculate_fields(self):
+        if self.shares is not None:
+            self.nominal_value = self.shares * self.product.share_price
+        elif self.nominal_value is not None:
+            self.shares = self.nominal_value / self.product.share_price
+
+        if self.shares_external is not None:
+            self.nominal_value_external = self.shares_external * self.product.share_price
+        elif self.nominal_value_external is not None:
+            self.shares_external = self.nominal_value_external / self.product.share_price
+
+    def __str__(self) -> str:
+        return f"{self.reconciliation}: {self.product} {self.shares} shares"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:accountreconciliationline"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbportfolio:accountreconciliationlinerepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{reconciliation}}"

wbportfolio/models/reconciliations/account_reconciliations.py

@@ -0,0 +1,102 @@
+from contextlib import suppress
+
+from django.db import models
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+# from django.utils.translation import gettext_lazy as _
+from dynamic_preferences.registries import global_preferences_registry
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbcore.contrib.notifications.utils import create_notification_type
+from wbportfolio.models.reconciliations.account_reconciliation_lines import (
+    AccountReconciliationLine,
+)
+from wbportfolio.models.reconciliations.reconciliations import Reconciliation
+
+
+class AccountReconciliationQuerySet(models.QuerySet):
+    def create(self, **kwargs) -> models.QuerySet["AccountReconciliation"]:
+        reconciliation = super().create(**kwargs)
+        AccountReconciliationLine.objects.update_or_create_for_reconciliation(reconciliation)
+        return reconciliation
+
+    def filter_for_user(self, user: User) -> models.QuerySet["AccountReconciliation"]:
+        if user.is_superuser or user.is_internal:
+            return self
+
+        if not user.has_perm("wbportfolio.view_accountreconciliation"):
+            return self.none()
+
+        return self.filter(
+            account__roles__role_type__key="reconciliation-manager",
+            account__roles__entry_id=user.profile_id,
+        )
+
+
+class AccountReconciliation(Reconciliation):
+    lines: models.QuerySet[AccountReconciliationLine]
+
+    account = models.ForeignKey(
+        to="wbcrm.Account",
+        related_name="wbportfolio_reconciliations",
+        on_delete=models.CASCADE,
+    )
+
+    objects = AccountReconciliationQuerySet.as_manager()
+
+    class Meta:
+        verbose_name = "Account Holdings Reconciliation"
+        verbose_name_plural = "Account Holdings Reconciliations"
+        constraints = [
+            models.UniqueConstraint(fields=["reconciliation_date", "account"], name="unique_date_account"),
+        ]
+        notification_types = [
+            create_notification_type(
+                "wbportfolio.account_reconciliation.notify",
+                "Account Reconciliation Events",
+                "A notification that informs the user about an account reconciliation event.",
+                email=True,
+            ),
+        ]
+
+    def __str__(self) -> str:
+        return f"{self.account} ({self.reconciliation_date:%d.%m.%Y})"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:accountreconciliation"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbportfolio:accountreconciliationrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{account}} {{reconciliation_date}}"
+
+    def notify(self, update: bool = False):
+        registry = global_preferences_registry.manager()
+        title = registry["wbportfolio__account_holding_reconciliation_notification_title"]
+        body = registry[f"wbportfolio__account_holding_reconciliation_notification_body{'_update' if update else ''}"]
+        for role in self.account.roles.filter(role_type__key="reconciliation-manager"):
+            with suppress(User.DoesNotExist):
+                user = User.objects.get(profile_id=role.entry.id)
+                send_notification(
+                    code="wbportfolio.account_reconciliation.notify",
+                    title=title,
+                    body=body.format(account=self.account, reconciliation_date=self.reconciliation_date),
+                    user=user,
+                    reverse_name="wbportfolio:accountreconciliation-detail",
+                    reverse_args=[self.id],
+                )
+
+
+@receiver(post_save, sender=AccountReconciliation)
+def notify_on_create(sender, instance: AccountReconciliation, created: bool, **kwargs):
+    if created:
+        instance.notify()

wbportfolio/models/reconciliations/reconciliations.py

@@ -0,0 +1,25 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from wbcore.models import WBModel
+
+
+class Reconciliation(WBModel):
+    reconciliation_date = models.DateField()
+
+    creator = models.ForeignKey(
+        to="authentication.User",
+        on_delete=models.PROTECT,
+        related_name="+",
+    )
+    approved_by = models.ForeignKey(
+        to="authentication.User",
+        on_delete=models.PROTECT,
+        null=True,
+        blank=True,
+        verbose_name=_("Approved By"),
+        related_name="+",
+    )
+    approved_dt = models.DateTimeField(null=True, blank=True, verbose_name=_("Approved Timestamp"))
+
+    class Meta:
+        abstract = True

wbportfolio/models/registers.py

@@ -0,0 +1,132 @@
+from django.db import models
+from wbcore.contrib.io.mixins import ImportMixin
+from wbcore.models import WBModel
+from wbportfolio.import_export.handlers.register import RegisterImportHandler
+
+
+class Register(ImportMixin, WBModel):
+    import_export_handler_class = RegisterImportHandler
+
+    class RegisterStatus(models.TextChoices):
+        ACTIVE = ("ACTIVE", "Active")
+        INACTIVE = ("INACTIVE", "Inactive")
+        WARNING = ("WARNING", "Warning")
+
+    class RegisterInvestorType(models.TextChoices):
+        BANK = ("BANK", "Bank and Financial Institution")
+        NOMINEE = ("NOMINEE", "Nominee")
+        GLOBAL = ("GLOBAL", "Global")
+        NON_FINANCIAL_ENTITY = ("NON_FINANCIAL_ENTITY", "Non Financial Entities/Corporate")
+
+    register_reference = models.CharField(max_length=255, unique=True)
+    register_name_1 = models.CharField(max_length=255)
+    register_name_2 = models.CharField(max_length=255, default="")
+    global_register_reference = models.CharField(max_length=255, default="")
+    external_register_reference = models.CharField(max_length=255, default="")
+
+    custodian_reference = models.CharField(max_length=255)
+    custodian_name_1 = models.CharField(max_length=255)
+    custodian_name_2 = models.CharField(max_length=255, default="")
+    custodian_address = models.TextField(default="", blank=True)
+    custodian_postcode = models.CharField(max_length=255, default="")
+
+    custodian_city = models.ForeignKey(
+        "geography.Geography",
+        related_name="register_custodian_city_registers",
+        on_delete=models.PROTECT,
+        limit_choices_to={"level": 3},
+        null=True,
+        blank=True,
+    )
+    custodian_country = models.ForeignKey(
+        "geography.Geography",
+        related_name="register_custodian_country_registers",
+        on_delete=models.PROTECT,
+        limit_choices_to={"level": 1},
+        null=True,
+        blank=True,
+    )
+
+    sales_reference = models.CharField(max_length=255, default="")
+    dealer_reference = models.CharField(max_length=255, default="")
+
+    outlet_reference = models.CharField(max_length=255)
+    outlet_name = models.CharField(max_length=255)
+    outlet_address = models.TextField(default="", blank=True)
+    outlet_postcode = models.CharField(max_length=255, default="")
+
+    outlet_city = models.ForeignKey(
+        "geography.Geography",
+        related_name="register_outlet_city_registers",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        limit_choices_to={"level": 3},
+    )
+    outlet_country = models.ForeignKey(
+        "geography.Geography",
+        related_name="register_outlet_country_registers",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        limit_choices_to={"level": 1},
+    )
+
+    citizenship = models.ForeignKey(
+        "geography.Geography",
+        related_name="register_citizenship_registers",
+        on_delete=models.PROTECT,
+        limit_choices_to={"level": 1},
+        null=True,
+        blank=True,
+    )
+    residence = models.ForeignKey(
+        "geography.Geography",
+        related_name="register_residence_registers",
+        on_delete=models.PROTECT,
+        limit_choices_to={"level": 1},
+        null=True,
+        blank=True,
+    )
+
+    investor_type = models.CharField(
+        max_length=24, choices=RegisterInvestorType.choices, default=RegisterInvestorType.BANK
+    )
+    status = models.CharField(max_length=8, choices=RegisterStatus.choices, default=RegisterStatus.ACTIVE)
+    status_message = models.TextField(default="", blank=True)
+
+    opened = models.DateField()
+    opened_reference_1 = models.CharField(max_length=255, default="")
+    opened_reference_2 = models.CharField(max_length=255, default="")
+
+    updated_reference_1 = models.CharField(max_length=255, default="")
+    updated_reference_2 = models.CharField(max_length=255, default="")
+
+    computed_str = models.CharField(max_length=255, null=True, blank=True)
+
+    def __str__(self) -> str:
+        return f"{self.register_reference}: {self.register_name_1} {self.register_name_2}"
+
+    class Meta:
+        verbose_name = "Register"
+        verbose_name_plural = "Registers"
+
+    def save(self, *args, **kwargs):
+        self.computed_str = str(self)
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:register"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbportfolio:registerrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{computed_str}}"

wbportfolio/models/roles.py

@@ -0,0 +1,208 @@
+from datetime import date, timedelta
+
+from django.db import models
+from django.db.models import Q
+from django.dispatch import receiver
+from wbcore.contrib.directory.signals import deactivate_profile
+from wbcore.signals import pre_merge
+from wbfdm.models import Instrument
+
+
+class PortfolioRole(models.Model):
+    default_error_messages = {
+        "manager": "If role type is Manager or Risk Manager, no {model} can be selected.",
+        "product_index": "Not both Product and Index can be selected.",
+        "start_end": "If a start and end date are selected, then the end date has be after the start date.",
+    }
+
+    class RoleType(models.TextChoices):
+        MANAGER = "MANAGER", "Manager"
+        RISK_MANAGER = "RISK_MANAGER", "Risk Manager"
+        PORTFOLIO_MANAGER = "PORTFOLIO_MANAGER", "Portfolio Manager"
+        ANALYST = "ANALYST", "Analyst"
+
+    role_type = models.CharField(max_length=24, choices=RoleType.choices, verbose_name="Type")
+    person = models.ForeignKey(
+        "directory.Person",
+        related_name="portfolio_roles",
+        on_delete=models.CASCADE,
+        verbose_name="Person",
+    )
+
+    start = models.DateField(null=True, blank=True, verbose_name="Start")
+    end = models.DateField(null=True, blank=True, verbose_name="End")
+
+    instrument = models.ForeignKey(
+        "wbfdm.Instrument",
+        related_name="portfolio_roles",
+        null=True,
+        blank=True,
+        limit_choices_to=models.Q(children__isnull=True),
+        on_delete=models.CASCADE,
+        verbose_name="Instrument",
+    )
+
+    weighting = models.FloatField(default=1, verbose_name="Weight")
+
+    class Meta:
+        verbose_name = "Portfolio Role"
+        verbose_name_plural = "Portfolio Roles"
+
+    def __str__(self):
+        return f"{self.role_type} {self.person.computed_str}"
+
+    def save(self, *args, **kwargs):
+        assert (
+            self.role_type in [self.RoleType.MANAGER, self.RoleType.RISK_MANAGER] and not self.instrument
+        ) or self.role_type in [
+            self.RoleType.PORTFOLIO_MANAGER,
+            self.RoleType.ANALYST,
+        ], self.default_error_messages[
+            "manager"
+        ].format(
+            model="instrument"
+        )
+
+        assert (self.start and self.end and self.start < self.end) or (
+            not self.start or not self.end
+        ), self.default_error_messages["start_end"]
+
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def is_manager(cls, person):
+        """Determines whether a person can access manager things (or is a superuser)
+
+        Arguments:
+            person {crm.Person} -- The person to be checked
+
+        Returns:
+            bool -- Can manage or not
+        """
+
+        today = date.today()
+
+        manager = cls.objects.filter(
+            Q(person=person)
+            & Q(role_type__in=[cls.RoleType.MANAGER, cls.RoleType.RISK_MANAGER])
+            & (Q(start__isnull=True) | Q(start__lte=today))
+            & (Q(end__isnull=True) | Q(end__gte=today))
+        )
+
+        return person.user_account.is_superuser or manager.exists()
+
+    @classmethod
+    def is_portfolio_manager(cls, person, instrument=None, portfolio=None, include_superuser=True):
+        """Determines whether a person can access portfolio manager things (or is a superuser/manager)
+
+        Arguments:
+            person {crm.Person} -- The person to be checked
+
+        Returns:
+            bool -- Can manage or not
+        """
+        today = date.today()
+        manager = cls.objects.filter(
+            (
+                Q(person=person)
+                & Q(role_type__in=[cls.RoleType.PORTFOLIO_MANAGER, cls.RoleType.MANAGER, cls.RoleType.RISK_MANAGER])
+            )
+            & (Q(start__isnull=True) | Q(start__lte=today))
+            & (Q(end__isnull=True) | Q(end__gte=today))
+        )
+
+        if instrument:
+            manager = manager.filter(
+                Q(instrument=instrument)
+                | Q(instrument__isnull=True)
+                | Q(role_type__in=[cls.RoleType.MANAGER, cls.RoleType.RISK_MANAGER])
+            )
+        elif portfolio:
+            manager = manager.filter(
+                Q(instrument__in=portfolio.instruments.all())
+                | Q(instrument__isnull=True)
+                | Q(role_type__in=[cls.RoleType.MANAGER, cls.RoleType.RISK_MANAGER])
+            )
+
+        if include_superuser:
+            return person.user_account.is_superuser or manager.exists()
+        return manager.exists()
+
+    @classmethod
+    def is_analyst(cls, person, instrument=None, portfolio=None, include_superuser=True):
+        """Determines whether a person can access analyst things (or is a superuser/manager/portfolio manager)
+
+        Arguments:
+            person {crm.Person} -- The person to be checked
+
+        Returns:
+            bool -- Can manage or not
+        """
+        today = date.today()
+        manager = cls.objects.filter(
+            Q(person=person)
+            & (Q(start__isnull=True) | Q(start__lte=today))
+            & (Q(end__isnull=True) | Q(end__gte=today))
+        )
+
+        if instrument:
+            manager = manager.filter(
+                Q(instrument=instrument)
+                | Q(instrument__isnull=True)
+                | Q(role_type__in=[cls.RoleType.PORTFOLIO_MANAGER, cls.RoleType.MANAGER, cls.RoleType.RISK_MANAGER])
+            )
+        elif portfolio:
+            manager = manager.filter(
+                Q(instrument__in=portfolio.instruments.all())
+                | Q(instrument__isnull=True)
+                | Q(role_type__in=[cls.RoleType.PORTFOLIO_MANAGER, cls.RoleType.MANAGER, cls.RoleType.RISK_MANAGER])
+            )
+        if include_superuser:
+            return person.user_account.is_superuser or manager.exists()
+        return manager.exists()
+
+    @classmethod
+    def portfolio_managers(cls):
+        today = date.today()
+        return (
+            cls.objects.filter(
+                Q(role_type=cls.RoleType.PORTFOLIO_MANAGER)
+                & (Q(start__isnull=True) | Q(start__lte=today))
+                & (Q(end__isnull=True) | Q(end__gte=today))
+            )
+            .values("person")
+            .distinct("person")
+        )
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:portfoliorole"
+
+
+@receiver(deactivate_profile)
+def handle_user_deactivation(sender, instance, substitute_profile=None, **kwargs):
+    deactivation_date = date.today() - timedelta(days=1)
+    for role in PortfolioRole.objects.filter(person=instance, end__isnull=True):
+        role.end = deactivation_date
+        role.save()
+        if (
+            substitute_profile
+            and not PortfolioRole.objects.filter(
+                person=substitute_profile, end__isnull=True, instrument=role.instrument
+            ).exists()
+        ):
+            PortfolioRole.objects.create(
+                instrument=role.instrument,
+                person=substitute_profile,
+                role_type=role.role_type,
+                start=deactivation_date,
+                weighting=role.weighting,
+            )
+
+
+@receiver(pre_merge, sender="wbfdm.Instrument")
+def pre_merge_instrument(sender: models.Model, merged_object: Instrument, main_object: Instrument, **kwargs):
+    """
+    Simply reassign the portfolio roles linked to the merged instrument to the main instrument
+    """
+    merged_object.portfolio_roles.update(instrument=main_object)

wbportfolio/models/synchronization/__init__.py

@@ -0,0 +1,3 @@
+from .portfolio_synchronization import PortfolioSynchronization
+from .price_computation import PriceComputation
+from .synchronization import SynchronizationTask