wbcommission 1.52.1__tar.gz → 1.52.2rc0__tar.gz

{wbcommission-1.52.1 → wbcommission-1.52.2rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbcommission
-Version: 1.52.1
+Version: 1.52.2rc0
 Summary: A workbench module for managing human resources.
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 Requires-Dist: reportlab==3.*

{wbcommission-1.52.1 → wbcommission-1.52.2rc0}/wbcommission/analytics/marginality.py

@@ -71,10 +71,10 @@ class MarginalityCalculator:
 
         # Build the fees dataframe where product id is the index and colum are the every fees type available and value are the amount.
         fees = Fees.valid_objects.filter(
-            transaction_date__lte=bday_to_date,
-            transaction_date__gte=bday_from_date,
+            fee_date__lte=bday_to_date,
+            fee_date__gte=bday_from_date,
             transaction_subtype__in=self.FEE_MAP.keys(),
-            linked_product__in=products,
+            product__in=products,
         ).annotate(
             fee_type=Case(
                 *[When(transaction_subtype=k, then=Value(v)) for k, v in self.FEE_MAP.items()],
@@ -82,9 +82,9 @@ class MarginalityCalculator:
             )
         )
         self.df_fees = pd.DataFrame(
-            fees.values_list("linked_product", "fee_type", "total_value", "transaction_date", "calculated"),
-            columns=["linked_product", "fee_type", "total_value", "transaction_date", "calculated"],
-        ).rename(columns={"linked_product": "id", "transaction_date": "date"})
+            fees.values_list("product", "fee_type", "total_value", "fee_date", "calculated"),
+            columns=["product", "fee_type", "total_value", "fee_date", "calculated"],
+        ).rename(columns={"product": "id", "fee_date": "date"})
         self.df_fees["date"] = pd.to_datetime(self.df_fees["date"])
 
         self.df_fees = (

{wbcommission-1.52.1 → wbcommission-1.52.2rc0}/wbcommission/models/account_service.py

@@ -31,13 +31,13 @@ class AccountRebateManager:
         # get the fees as a multi-index matrix
         self.df_fees = pd.DataFrame(
             Fees.valid_objects.filter(
-                linked_product__in=claim_products,
+                product__in=claim_products,
                 transaction_subtype__in=self.FEE_MAP[self.commission_type_key],
-            ).values("linked_product", "transaction_date", "total_value")
+            ).values("product", "fee_date", "total_value")
         )
         if not self.df_fees.empty:
             self.df_fees = (
-                self.df_fees.rename(columns={"linked_product": "product", "transaction_date": "date"})
+                self.df_fees.rename(columns={"product": "product", "fee_date": "date"})
                 .groupby(["product", "date"])
                 .sum()
                 .total_value.astype(float)

{wbcommission-1.52.1 → wbcommission-1.52.2rc0}/wbcommission/models/signals.py

@@ -31,15 +31,15 @@ def post_fees_save_for_rebate_computation(sender, instance, created, **kwargs):
     # if a new commission line is created, we create a general rule
     if (
         created
-        and (date.today() - instance.transaction_date).days
+        and (date.today() - instance.fee_date).days
         <= global_preferences_registry.manager()["wbcommission__days_to_recompute_rebate_from_fees_threshold"]
     ):  # we make sure that the fee won't trigger rebate computation if they are created too much in the past
         for root_account in Account.objects.filter(level=0):
             if Claim.objects.filter(
-                account__in=root_account.get_descendants(include_self=True), product=instance.linked_product
+                account__in=root_account.get_descendants(include_self=True), product=instance.product
             ).exists():
                 manage_rebate_as_task.delay(
                     root_account.id,
-                    start_date=instance.transaction_date,
-                    only_content_object_ids=[instance.linked_product.id],
+                    start_date=instance.fee_date,
+                    only_content_object_ids=[instance.product.id],
                 )

{wbcommission-1.52.1 → wbcommission-1.52.2rc0}/wbcommission/tests/analytics/test_marginality.py

@@ -21,14 +21,14 @@ def _create_fixture(product, val_date, net_value=100, outstanding_shares=100):
         instrument=product, net_value=net_value, outstanding_shares=outstanding_shares, calculated=False, date=val_date
     ).net_value  # create a price of AUM 100*100
     management_fees_1 = FeesFactory.create(
-        linked_product=product, transaction_date=val_date, transaction_subtype="MANAGEMENT", calculated=False
+        product=product, fee_date=val_date, transaction_subtype="MANAGEMENT", calculated=False
     ).total_value
     performance_fees_1 = FeesFactory.create(
-        linked_product=product, transaction_date=val_date, transaction_subtype="PERFORMANCE", calculated=False
+        product=product, fee_date=val_date, transaction_subtype="PERFORMANCE", calculated=False
     ).total_value
     performance_crys_fees_1 = FeesFactory.create(
-        linked_product=product,
-        transaction_date=val_date,
+        product=product,
+        fee_date=val_date,
         transaction_subtype="PERFORMANCE_CRYSTALIZED",
         calculated=False,
     ).total_value

{wbcommission-1.52.1 → wbcommission-1.52.2rc0}/wbcommission/tests/models/test_account_service.py

@@ -21,18 +21,18 @@ class TestAccountService(AccountManagerFixture):
         mngt_fees = fees_factory.create(transaction_subtype="MANAGEMENT")
         perf_fees = fees_factory.create(  # noqa
             transaction_subtype="PERFORMANCE",
-            transaction_date=mngt_fees.transaction_date,
-            linked_product=mngt_fees.linked_product,
+            fee_date=mngt_fees.fee_date,
+            product=mngt_fees.product,
         )  # noqa
         claim_factory.create(
             account=management_account_manager.root_account,
-            trade=customer_trade_factory.create(underlying_instrument=mngt_fees.linked_product),
+            trade=customer_trade_factory.create(underlying_instrument=mngt_fees.product),
             status="APPROVED",
         )
         management_account_manager.initialize()
 
         assert (
-            management_account_manager.get_commission_pool(mngt_fees.linked_product, mngt_fees.transaction_date)
+            management_account_manager.get_commission_pool(mngt_fees.product, mngt_fees.fee_date)
             == mngt_fees.total_value
         )
 
@@ -42,24 +42,24 @@ class TestAccountService(AccountManagerFixture):
         mngt_fees = fees_factory.create(transaction_subtype="MANAGEMENT")
         perf_fees = fees_factory.create(
             transaction_subtype="PERFORMANCE",
-            transaction_date=mngt_fees.transaction_date,
-            linked_product=mngt_fees.linked_product,
+            fee_date=mngt_fees.fee_date,
+            product=mngt_fees.product,
         )
         perf2_fees = fees_factory.create(
             transaction_subtype="PERFORMANCE_CRYSTALIZED",
-            transaction_date=mngt_fees.transaction_date,
-            linked_product=mngt_fees.linked_product,
+            fee_date=mngt_fees.fee_date,
+            product=mngt_fees.product,
         )
 
         claim_factory.create(
             account=performance_account_manager.root_account,
-            trade=customer_trade_factory.create(underlying_instrument=mngt_fees.linked_product),
+            trade=customer_trade_factory.create(underlying_instrument=mngt_fees.product),
             status="APPROVED",
         )
         performance_account_manager.initialize()
 
         assert (
-            performance_account_manager.get_commission_pool(mngt_fees.linked_product, mngt_fees.transaction_date)
+            performance_account_manager.get_commission_pool(mngt_fees.product, mngt_fees.fee_date)
             == perf_fees.total_value + perf2_fees.total_value
         )
 
@@ -70,30 +70,25 @@ class TestAccountService(AccountManagerFixture):
         calculated_fees = fees_factory.create(calculated=True, transaction_subtype="MANAGEMENT")
         claim_factory.create(
             account=management_account_manager.root_account,
-            trade=customer_trade_factory.create(underlying_instrument=calculated_fees.linked_product),
+            trade=customer_trade_factory.create(underlying_instrument=calculated_fees.product),
             status="APPROVED",
         )
         management_account_manager.initialize()
 
         assert (
-            management_account_manager.get_commission_pool(
-                calculated_fees.linked_product, calculated_fees.transaction_date
-            )
+            management_account_manager.get_commission_pool(calculated_fees.product, calculated_fees.fee_date)
             == calculated_fees.total_value
         )
         # Check that is there is a non calculated fees, it is used instead of the calculated one
         fees = fees_factory.create(transaction_subtype=calculated_fees.transaction_subtype, calculated=False)
         claim_factory.create(
             account=management_account_manager.root_account,
-            trade=customer_trade_factory.create(underlying_instrument=fees.linked_product),
+            trade=customer_trade_factory.create(underlying_instrument=fees.product),
             status="APPROVED",
         )
         management_account_manager.initialize()
 
-        assert (
-            management_account_manager.get_commission_pool(fees.linked_product, fees.transaction_date)
-            == fees.total_value
-        )
+        assert management_account_manager.get_commission_pool(fees.product, fees.fee_date) == fees.total_value
 
     @pytest.mark.parametrize("val_date", [fake.past_date()])
     def test_get_terminal_account_holding_ratio(

{wbcommission-1.52.1 → wbcommission-1.52.2rc0}/wbcommission/tests/models/test_commission.py

@@ -420,14 +420,10 @@ class TestCommissionType:
     ):
         val_date = (val_date + BDay(0)).date()
         val_date_1 = (val_date - BDay(1)).date()
-        fees_factory.create(linked_product=product, transaction_date=val_date_1, transaction_subtype="PERFORMANCE")
-        fees_factory.create(linked_product=product, transaction_date=val_date_1, transaction_subtype="MANAGEMENT")
-        perf_fees = fees_factory.create(
-            linked_product=product, transaction_date=val_date, transaction_subtype="PERFORMANCE"
-        )
-        mngt_fees = fees_factory.create(
-            linked_product=product, transaction_date=val_date, transaction_subtype="MANAGEMENT"
-        )
+        fees_factory.create(product=product, fee_date=val_date_1, transaction_subtype="PERFORMANCE")
+        fees_factory.create(product=product, fee_date=val_date_1, transaction_subtype="MANAGEMENT")
+        perf_fees = fees_factory.create(product=product, fee_date=val_date, transaction_subtype="PERFORMANCE")
+        mngt_fees = fees_factory.create(product=product, fee_date=val_date, transaction_subtype="MANAGEMENT")
         sub2 = customer_trade_factory.create(
             underlying_instrument=product,
             transaction_subtype=Trade.Type.SUBSCRIPTION,

{wbcommission-1.52.1 → wbcommission-1.52.2rc0}/wbcommission/tests/models/test_rebate.py

@@ -43,9 +43,9 @@ class TestRebateModel(AccountManagerFixture):
         mock_fct.return_value = [
             (
                 commission.account,
-                fees.transaction_date,
+                fees.fee_date,
                 commission,
-                fees.linked_product,
+                fees.product,
                 commission.crm_recipient,
                 rebate_value,
                 dict(),
@@ -54,8 +54,8 @@ class TestRebateModel(AccountManagerFixture):
         Rebate.manage_rebate(commission.account)
         new_rebate = Rebate.objects.get(
             commission=commission,
-            product=fees.linked_product,
-            date=fees.transaction_date,
+            product=fees.product,
+            date=fees.fee_date,
             recipient=commission.crm_recipient,
         )
         assert new_rebate.value == rebate_value
@@ -64,9 +64,9 @@ class TestRebateModel(AccountManagerFixture):
         mock_fct.return_value = [
             (
                 commission.account,
-                fees.transaction_date,
+                fees.fee_date,
                 commission,
-                fees.linked_product,
+                fees.product,
                 commission.crm_recipient,
                 rebate_value * 2,
                 dict(),
@@ -81,9 +81,9 @@ class TestRebateModel(AccountManagerFixture):
         mock_fct.return_value = [
             (
                 commission.account,
-                fees.transaction_date,
+                fees.fee_date,
                 new_commission,
-                fees.linked_product,
+                fees.product,
                 new_commission.crm_recipient,
                 rebate_value,
                 dict(),
@@ -95,8 +95,8 @@ class TestRebateModel(AccountManagerFixture):
         assert (
             Rebate.objects.get(
                 commission=new_commission,
-                product=fees.linked_product,
-                date=fees.transaction_date,
+                product=fees.product,
+                date=fees.fee_date,
                 recipient=new_commission.crm_recipient,
             ).value
             == rebate_value