wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/models/instruments/instrument_relationships.py

@@ -0,0 +1,251 @@
+from django.core.validators import MaxValueValidator, MinValueValidator
+from django.db import models
+from django.db.models.signals import m2m_changed
+from django.dispatch import receiver
+from rest_framework.reverse import reverse
+from wbcore.contrib.tags.models import TagModelMixin
+from wbcore.models import WBModel
+from wbcore.signals import pre_merge
+
+
+class InstrumentClassificationRelatedInstrument(models.Model):
+    class Type(models.TextChoices):
+        PARTNER = "PARTNER", "Partner"
+        SUPPLIER = "SUPPLIER", "Supplier"
+        PEER = "PEER", "Peer"
+        COMPETITOR = "COMPETITOR", "Competitor"
+        BIGGEST_THREAT = "BIGGEST_THREAT", "Biggest Threat"
+        CUSTOMER = "CUSTOMER", "Customer"
+
+    related_instrument_type = models.CharField(max_length=16, choices=Type.choices, null=True, blank=True)
+    classified_instrument = models.ForeignKey(
+        to="wbfdm.InstrumentClassificationThroughModel",
+        related_name="classification_instrument_relationships",
+        on_delete=models.CASCADE,
+    )
+    related_instrument = models.ForeignKey(
+        to="wbfdm.Instrument",
+        limit_choices_to=(models.Q(instrument_type__is_classifiable=True) & models.Q(level=0)),
+        related_name="instrument_classification_related",
+        on_delete=models.CASCADE,
+    )
+
+    def __str__(self) -> str:
+        return f"{self.classified_instrument} {self.related_instrument}"
+
+
+class InstrumentClassificationThroughModel(TagModelMixin, models.Model):
+    instrument = models.ForeignKey(
+        "wbfdm.Instrument",
+        on_delete=models.CASCADE,
+        related_name="classifications_through",
+        limit_choices_to=(models.Q(instrument_type__is_classifiable=True) & models.Q(level=0)),
+    )
+    classification = models.ForeignKey(
+        "wbfdm.Classification",
+        on_delete=models.CASCADE,
+        related_name="instruments_through",
+    )
+    is_favorite = models.BooleanField(default=False)
+    reason = models.TextField(default="", blank=True, verbose_name="Reason for the choice")
+    pure_player = models.BooleanField(default=False, help_text="Pure Players Companies", verbose_name="Pure Player")
+    top_player = models.BooleanField(default=False, help_text="Top Players Companies", verbose_name="Top Player")
+    percent_of_revenue = models.DecimalField(
+        decimal_places=4,
+        max_digits=5,
+        null=True,
+        blank=True,
+        verbose_name="% of revenue",
+        validators=[MinValueValidator(0), MaxValueValidator(1)],
+    )
+    related_instruments = models.ManyToManyField(
+        to="wbfdm.Instrument",
+        limit_choices_to=(models.Q(instrument_type__is_classifiable=True) & models.Q(level=0)),
+        through=InstrumentClassificationRelatedInstrument,
+        through_fields=("classified_instrument", "related_instrument"),
+        blank=True,
+    )
+
+    def get_tag_detail_endpoint(self):
+        return reverse("wbfdm:classifiedinstrument-detail", [self.id])
+
+    def get_tag_representation(self):
+        return f"{self.instrument} - {self.classification}"
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(name="unique_classifiedinstruments", fields=["instrument", "classification"])
+        ]
+
+    def __str__(self) -> str:
+        return f"{self.instrument} {self.classification}"
+
+    def save(self, *args, **kwargs):
+        if self.pure_player and not self.percent_of_revenue:
+            self.percent_of_revenue = 1
+        return super().save(*args, **kwargs)
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbfdm:instrumentclassificationrelationship"
+
+
+class InstrumentFavoriteGroup(WBModel):
+    name = models.CharField(max_length=256)
+    instruments = models.ManyToManyField(
+        "wbfdm.Instrument",
+        related_name="favorite_groups",
+        blank=True,
+        verbose_name="Favorite Instruments Group",
+        limit_choices_to=models.Q(children__isnull=True),
+    )
+    owner = models.ForeignKey(
+        "directory.Person", on_delete=models.CASCADE, blank=True, null=True, related_name="favorite_instruments_groups"
+    )
+    public = models.BooleanField(default=False, help_text="If set to True, this group will be available to everyone.")
+    primary = models.BooleanField(
+        default=False,
+        help_text="If set to True, this group will be set as default filter for instrument based viewset (Only one primary group allowed).",
+    )
+
+    def __str__(self):
+        return self.name
+
+    def save(self, *args, **kwargs):
+        if self.primary:
+            InstrumentFavoriteGroup.objects.filter(owner=self.owner, primary=True).exclude(id=self.id).update(
+                primary=False
+            )
+        return super().save(*args, **kwargs)
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbfdm:favoritegroup-list"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{name}} - (Public: {{public}})"
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbfdm:favoritegroup"
+
+
+class RelatedInstrumentThroughModel(models.Model):
+    class RelatedTypeChoices(models.TextChoices):
+        BENCHMARK = "BENCHMARK", "Benchmark"
+        PEER = "PEER", "Peer"
+        RISK_INSTRUMENT = "RISK_INSTRUMENT", "Risk Instrument"
+
+    instrument = models.ForeignKey(
+        "wbfdm.Instrument",
+        on_delete=models.CASCADE,
+        related_name="related_instruments_through",
+        limit_choices_to=models.Q(children__isnull=True),
+    )
+    related_instrument = models.ForeignKey(
+        "wbfdm.Instrument",
+        on_delete=models.CASCADE,
+        related_name="dependent_instruments_through",
+        limit_choices_to=models.Q(children__isnull=True),
+    )
+    is_primary = models.BooleanField(default=False)
+    related_type = models.CharField(
+        max_length=32, default=RelatedTypeChoices.BENCHMARK, choices=RelatedTypeChoices.choices
+    )
+
+    class Meta:
+        unique_together = ("instrument", "related_instrument", "is_primary", "related_type")
+
+    def save(self, *args, **kwargs):
+        qs = RelatedInstrumentThroughModel.objects.filter(
+            instrument=self.instrument, related_type=self.related_type, is_primary=True
+        ).exclude(id=self.id)
+        if self.is_primary:
+            qs.update(is_primary=False)
+        elif not qs.exists():
+            self.is_primary = True
+        return super().save(*args, **kwargs)
+
+
+@receiver(m2m_changed, sender="wbfdm.RelatedInstrumentThroughModel")
+def add_related_instrument(sender, instance, action, pk_set, **kwargs):
+    if action == "post_add" and pk_set:
+        for related_instrument_id in pk_set:
+            through = RelatedInstrumentThroughModel.objects.filter(
+                instrument=instance.id, related_instrument=related_instrument_id
+            ).first()
+            through.save()
+    if action == "post_remove" and pk_set:
+        qs = RelatedInstrumentThroughModel.objects.filter(instrument=instance, related_type=instance.related_type)
+        if not qs.filter(is_primary=True).exists():
+            instance = qs.first()
+            instance.is_primary = True
+            instance.save()
+
+
+@receiver(m2m_changed, sender="wbfdm.InstrumentClassificationThroughModel")
+def add_classification(sender, instance, action, pk_set, **kwargs):
+    if action == "post_add" and pk_set:
+        for classification_id in pk_set:
+            if through := InstrumentClassificationThroughModel.objects.filter(
+                instrument=instance.id, classification=classification_id
+            ).first():
+                through.save()
+
+
+@receiver(pre_merge, sender="wbfdm.Instrument")
+def pre_merge_instrument(sender: models.Model, merged_object, main_object, **kwargs):
+    """
+    Reassign all merged instrument preferred classification relationship to the main instrument
+    """
+    # For every favorite group where the merged instrument is present, we remove it and assign the main instrument instad
+    for favorite_group in InstrumentFavoriteGroup.objects.filter(instruments=merged_object):
+        favorite_group.instruments.remove(merged_object)
+        favorite_group.instruments.add(main_object)
+
+    # For all related instruments relationship of the merged instrument, we reassign them to the main instrument if they don't exist yet. The relationship is then deleted.
+    for through in RelatedInstrumentThroughModel.objects.filter(instrument=merged_object):
+        RelatedInstrumentThroughModel.objects.get_or_create(
+            instrument=main_object,
+            related_instrument=through.related_instrument,
+            is_primary=through.is_primary,
+            related_type=through.related_type,
+        )
+        through.delete()
+    # We also reassign the reverse related instrument relationship where the merged instrument is the related instrument.
+    for through in RelatedInstrumentThroughModel.objects.filter(related_instrument=merged_object):
+        RelatedInstrumentThroughModel.objects.get_or_create(
+            instrument=through.instrument,
+            related_instrument=main_object,
+            is_primary=through.is_primary,
+            related_type=through.related_type,
+        )
+        through.delete()
+
+    # For all classification relationships of the merged instrument, we reassign them to the main instrument if they don't exist yet. The relationship is then deleted.
+    for through in InstrumentClassificationThroughModel.objects.filter(instrument=merged_object):
+        new_rel, created = InstrumentClassificationThroughModel.objects.get_or_create(
+            instrument=main_object,
+            classification=through.classification,
+            defaults={
+                "is_favorite": through.is_favorite,
+                "reason": through.reason,
+                "pure_player": through.pure_player,
+                "top_player": through.top_player,
+                "percent_of_revenue": through.percent_of_revenue,
+            },
+        )
+        for related_instrument in through.related_instruments.all():
+            if related_instrument not in new_rel.related_instruments.all():
+                new_rel.related_instruments.add(related_instrument)
+        through.delete()
+
+    # We also reassign the reverse classification relationship where the merged instrument is the related instrument.
+    for through in InstrumentClassificationThroughModel.objects.filter(related_instruments=merged_object):
+        through.related_instruments.remove(merged_object)
+        through.related_instruments.add(main_object)

wbfdm/models/instruments/instrument_requests.py

@@ -0,0 +1,196 @@
+from typing import Any, Dict, Optional
+
+from django.db import models
+from django_fsm import FSMField, transition
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.geography.models import Geography
+from wbcore.contrib.icons import WBIcon
+from wbcore.contrib.tags.models import Tag
+from wbcore.enums import RequestType
+from wbcore.metadata.configs.buttons import ActionButton, ButtonDefaultColor
+from wbcore.models import WBModel
+from wbfdm.models.instruments.classifications import Classification
+
+from .instruments import Instrument, InstrumentType
+
+
+class InstrumentRequest(WBModel):
+    class Status(models.TextChoices):
+        PENDING = "PENDING", "Pending"
+        APPROVED = "APPROVED", "Approved"
+        DENIED = "DENIED", "Denied"
+        DRAFT = "DRAFT", "Draft"
+
+    status = FSMField(
+        default=Status.DRAFT,
+        choices=Status.choices,
+        verbose_name="Status",
+        help_text="The Request Status (default to Pending)",
+    )
+    requester = models.ForeignKey(
+        "directory.Person",
+        related_name="instrument_requests",
+        on_delete=models.SET_NULL,
+        verbose_name="Requester",
+        null=True,
+        blank=True,
+    )
+    handler = models.ForeignKey(
+        "directory.Person",
+        related_name="handled_instrument_requests",
+        on_delete=models.SET_NULL,
+        verbose_name="Handler",
+        null=True,
+        blank=True,
+    )
+    notes = models.TextField(null=True, blank=True, verbose_name="Notes")
+    created = models.DateTimeField(auto_now_add=True, verbose_name="Created", help_text="The request creation time")
+    instrument_data = models.JSONField(default=dict, verbose_name="Instrument Data")
+    created_instrument = models.OneToOneField(
+        "wbfdm.Instrument", on_delete=models.CASCADE, blank=True, null=True, related_name="creation_request"
+    )
+
+    def __str__(self):
+        return f'Instrument Request - {self.Status[self.status].label} ({"".join([f"{k}={v}" for k, v in self.instrument_data.items()])})'
+
+    @property
+    def deserialize_instrument_data(self) -> tuple[Dict[str, Any], Dict[str, Any]]:
+        instrument_data = self.instrument_data.copy()
+        many_to_many_data = dict()
+        if currency_id := instrument_data.get("currency", None):
+            instrument_data["currency"] = Currency.objects.filter(id=currency_id).first()
+        if country_id := instrument_data.get("country", None):
+            instrument_data["country"] = Geography.countries.filter(id=country_id).first()
+        if instrument_type_id := instrument_data.get("instrument_type", None):
+            instrument_data["instrument_type"] = InstrumentType.objects.get(id=instrument_type_id)
+        if tags_list := instrument_data.pop("tags", None):
+            many_to_many_data["tags"] = [Tag.objects.filter(id=tag_id).first() for tag_id in tags_list]
+        if classifications_list := instrument_data.pop("classifications", None):
+            many_to_many_data["classifications"] = [
+                Classification.objects.filter(id=classification_id).first()
+                for classification_id in classifications_list
+            ]
+        instrument_data["is_investable_universe"] = True
+        return instrument_data, many_to_many_data
+
+    def _check_already_existing_instrument(self):
+        return (
+            (isin := self.instrument_data.get("isin", None)) and Instrument.objects.filter(isin=isin).exists()
+        ) or (
+            (ric := self.instrument_data.get("refinitiv_identifier_code", None))
+            and Instrument.objects.filter(refinitiv_identifier_code=ric).exists()
+        )
+
+    @transition(
+        field=status,
+        source=[Status.PENDING],
+        target=Status.APPROVED,
+        permission=lambda instance, user: user.has_perm("wbfdm.administrate_instrument"),
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                color=ButtonDefaultColor.WARNING,
+                identifiers=("wbfdm:instrumentrequest",),
+                icon=WBIcon.APPROVE.icon,
+                key="approve",
+                label="Approve",
+                action_label="Approve",
+                description_fields="<p>You are sure to approve this request?</p>",
+            )
+        },
+    )
+    def approve(self, by: Optional[User] = None, **kwargs):
+        deserialize_instrument_data, many_to_many_data = self.deserialize_instrument_data
+        created_instrument = Instrument.objects.create(**deserialize_instrument_data)
+        for key, items in many_to_many_data.items():
+            getattr(created_instrument, key).set(items)
+        if profile := getattr(by, "profile", None):
+            self.handler = profile
+        self.created_instrument = created_instrument
+
+    def can_approve(self):
+        if self._check_already_existing_instrument():
+            return {"non_field_errors": "An instrument already exists with the proposed identifier"}
+
+    @transition(
+        field=status,
+        source=[Status.PENDING],
+        target=Status.DENIED,
+        permission=lambda instance, user: user.has_perm("wbfdm.administrate_instrument"),
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                color=ButtonDefaultColor.WARNING,
+                identifiers=("wbfdm:instrumentrequest",),
+                icon=WBIcon.DENY.icon,
+                key="deny",
+                label="Deny",
+                action_label="Deny",
+                description_fields="<p>You are sure to deny this request?</p>",
+            )
+        },
+    )
+    def deny(self, by: Optional[User] = None, **kwargs):
+        if profile := getattr(by, "profile", None):
+            self.handler = profile
+
+    @transition(
+        field=status,
+        source=[Status.DENIED],
+        target=Status.DRAFT,
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                color=ButtonDefaultColor.WARNING,
+                identifiers=("wbfdm:instrumentrequest",),
+                icon=WBIcon.SEND.icon,
+                key="backtodraft",
+                label="Back To Draft",
+                action_label="Back To Draft",
+                description_fields="<p>You are sure to put this request back to draft?</p>",
+            )
+        },
+    )
+    def backtodraft(self, by: Optional[User] = None, **kwargs):
+        pass
+
+    @transition(
+        field=status,
+        source=[Status.DRAFT],
+        target=Status.PENDING,
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                color=ButtonDefaultColor.WARNING,
+                identifiers=("wbfdm:instrumentrequest",),
+                icon=WBIcon.SEND.icon,
+                key="submit",
+                label="Submit",
+                action_label="Submit",
+                description_fields="<p>You are sure to submit this request back?</p>",
+            )
+        },
+    )
+    def submit(self, by: Optional[User] = None, **kwargs):
+        pass
+
+    def can_submit(self) -> Dict[str, Any]:
+        if self._check_already_existing_instrument():
+            return {"non_field_errors": "An instrument already exists with the proposed identifier"}
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbfdm:instrumentrequestrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "Request {{id}} ({{status}})"
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbfdm:instrumentrequest"