wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/contrib/company_portfolio/filters.py

@@ -1,6 +1,6 @@
 from wbcore import filters
-from wbcore.contrib.directory.filters import CompanyFilter as CF
-from wbcore.contrib.directory.filters import PersonFilter as PF
+from wbcore.contrib.directory.filters import CompanyFilter as BaseCompanyFilter
+from wbcore.contrib.directory.filters import PersonFilter as BasePersonFilter
 from wbcore.contrib.directory.models import Company, Person
 
 
@@ -99,29 +99,29 @@ class EntryPortfolioFilter(filters.FilterSet):
         return queryset
 
 
-class CompanyFilter(CF, EntryPortfolioFilter):
+class CompanyFilter(BaseCompanyFilter, EntryPortfolioFilter):
     @classmethod
     def get_filter_class_for_remote_filter(cls):
         """
         Define which filterset class sender to user for remote filter registration
         """
-        return CF
+        return BaseCompanyFilter
 
-    class Meta(CF.Meta):
+    class Meta(BaseCompanyFilter.Meta):
         fields = {
-            **CF.Meta.fields,
+            **BaseCompanyFilter.Meta.fields,
         }
 
 
-class PersonFilter(PF, EntryPortfolioFilter):
+class PersonFilter(BasePersonFilter, EntryPortfolioFilter):
     @classmethod
     def get_filter_class_for_remote_filter(cls):
         """
         Define which filterset class sender to user for remote filter registration
         """
-        return PF
+        return BasePersonFilter
 
-    class Meta(PF.Meta):
+    class Meta(BasePersonFilter.Meta):
         fields = {
-            **PF.Meta.fields,
+            **BasePersonFilter.Meta.fields,
         }

wbportfolio/contrib/company_portfolio/models.py

@@ -3,6 +3,7 @@ from datetime import date
 from decimal import Decimal
 
 from django.conf import settings
+from django.core.cache import cache
 from django.db import models
 from django.db.models.signals import post_save
 from django.dispatch import receiver
@@ -16,7 +17,12 @@ from wbportfolio.models import Claim, Product
 
 
 def get_total_assets_under_management(val_date: date) -> Decimal:
-    return sum([product.get_total_aum_usd(val_date) for product in Product.active_objects.all()])
+    cache_key = f"total_assets_under_management:{val_date.isoformat()}"
+    return cache.get_or_set(
+        cache_key,
+        lambda: sum([product.get_total_aum_usd(val_date) for product in Product.active_objects.all()]),
+        60 * 60 * 24,
+    )
 
 
 def get_lost_client_customer_status():
@@ -44,9 +50,8 @@ class Updater:
         self.val_date = val_date
         self.total_assets_under_management = get_total_assets_under_management(val_date)
 
-    def update_company_data(self, company):
+    def update_company_data(self, company_portfolio_data) -> tuple[str, str]:
         # save company portfolio data
-        company_portfolio_data = CompanyPortfolioData.objects.get_or_create(company=company)[0]
         if (
             invested_assets_under_management_usd := company_portfolio_data.get_assets_under_management_usd(
                 self.val_date
@@ -55,19 +60,11 @@ class Updater:
             company_portfolio_data.invested_assets_under_management_usd = invested_assets_under_management_usd
         if (potential := company_portfolio_data.get_potential(self.val_date)) is not None:
             company_portfolio_data.potential = potential
-        company_portfolio_data.save()
 
         # update the company object itself
-        if (tier := company_portfolio_data.get_tiering(self.total_assets_under_management)) is not None:
-            company.tier = tier
-        company.customer_status = company_portfolio_data.get_customer_status()
-        company.save()
-
-    # def update_all_companies(self, val_date: date):
-    #     for company in tqdm(qs, total=qs.count()):
-    #         with suppress(CompanyPortfolioData.DoesNotExist):
-    #             company_portfolio = CompanyPortfolioData.objects.get(company=company)
-    #             company_portfolio.update_data(date.today())
+        tier = company_portfolio_data.get_tiering(self.total_assets_under_management)
+        customer_status = company_portfolio_data.get_customer_status()
+        return customer_status, tier
 
 
 class CompanyPortfolioData(models.Model):
@@ -104,14 +101,6 @@ class CompanyPortfolioData(models.Model):
         verbose_name="AUM",
         help_text="The Assets under Management (AUM) that is managed by this company or this person's primary employer.",
     )
-    invested_assets_under_management_usd = models.DecimalField(
-        max_digits=17,
-        decimal_places=2,
-        null=True,
-        blank=True,
-        help_text="The invested Assets under Management (AUM).",
-        verbose_name="Invested AUM ($)",
-    )
 
     investment_discretion = models.CharField(
         max_length=21,
@@ -120,10 +109,6 @@ class CompanyPortfolioData(models.Model):
         help_text="What discretion this company or this person's primary employer has to invest its assets.",
         verbose_name="Investment Discretion",
     )
-
-    potential = models.DecimalField(
-        decimal_places=2, max_digits=19, null=True, blank=True, help_text=potential_help_text
-    )
     potential_currency = models.ForeignKey(
         to="currency.Currency",
         related_name="wbportfolio_potential_currencies",
@@ -132,6 +117,25 @@ class CompanyPortfolioData(models.Model):
         on_delete=models.PROTECT,
     )
 
+    # Dynamic fields
+    invested_assets_under_management_usd = models.DecimalField(
+        max_digits=17,
+        decimal_places=2,
+        null=True,
+        blank=True,
+        help_text="The invested Assets under Management (AUM).",
+        verbose_name="Invested AUM ($)",
+    )
+
+    potential = models.DecimalField(
+        decimal_places=2, max_digits=19, null=True, blank=True, help_text=potential_help_text
+    )
+
+    def update(self):
+        with suppress(CurrencyFXRates.DoesNotExist):
+            val_date = CurrencyFXRates.objects.latest("date").date
+            self.company.customer_status, self.company.tier = Updater(val_date).update_company_data(self)
+
     def get_assets_under_management_usd(self, val_date: date) -> Decimal:
         return Claim.objects.filter(status=Claim.Status.APPROVED).filter_for_customer(
             self.company
@@ -140,16 +144,17 @@ class CompanyPortfolioData(models.Model):
         )["invested_aum_usd"] or Decimal(0)
 
     def _get_default_potential(self, val_date: date) -> Decimal:
-        with suppress(CurrencyFXRates.DoesNotExist):
-            fx = CurrencyFXRates.objects.get(currency=self.assets_under_management_currency, date=val_date).value
+        if self.assets_under_management:
+            with suppress(CurrencyFXRates.DoesNotExist):
+                fx = CurrencyFXRates.objects.get(currency=self.assets_under_management_currency, date=val_date).value
 
-            aum_usd = self.assets_under_management / fx
-            aum_potential = Decimal(0)
-            for asset_allocation in self.company.asset_allocations.all():
-                aum_potential += aum_usd * asset_allocation.percent * asset_allocation.max_investment
-            invested_aum = self.invested_assets_under_management_usd or Decimal(0.0)
+                aum_usd = self.assets_under_management / fx
+                aum_potential = Decimal(0)
+                for asset_allocation in self.company.asset_allocations.all():
+                    aum_potential += aum_usd * asset_allocation.percent * asset_allocation.max_investment
+                invested_aum = self.invested_assets_under_management_usd or Decimal(0.0)
 
-            return aum_potential - invested_aum
+                return aum_potential - invested_aum
 
     def get_potential(self, val_date: date) -> Decimal:
         if module_path := getattr(settings, "PORTFOLIO_COMPANY_DATA_POTENTIAL_METHOD", None):
@@ -225,11 +230,6 @@ class CompanyPortfolioData(models.Model):
         verbose_name_plural = "Company Portfolio Data"
 
 
-@receiver(post_save, sender="directory.Company")
-def create_company_portfolio_data(sender, instance, created, **kwargs):
-    CompanyPortfolioData.objects.get_or_create(company=instance)
-
-
 class AssetAllocationType(WBModel):
     name = models.CharField(max_length=255)
     default_max_investment = models.DecimalField(
@@ -329,3 +329,33 @@ class GeographicFocus(models.Model):
     @classmethod
     def get_representation_label_key(cls):
         return "{{company}}: {{percent}} {{country}}"
+
+
+@receiver(post_save, sender=AssetAllocation)
+@receiver(post_save, sender=GeographicFocus)
+def post_save_company_data(sender, instance, created, **kwargs):
+    company = instance.company
+    portfolio_data, created = CompanyPortfolioData.objects.get_or_create(company=company)
+    if not created:
+        portfolio_data.update()
+        portfolio_data.save()
+        portfolio_data.company.save()
+
+
+@receiver(post_save, sender="directory.Company")
+def handle_company_portfolio_data(sender, instance, created, **kwargs):
+    # create default asset allocation type (equity 50/50)
+    if not instance.asset_allocations.exists():
+        equity_asset_type = AssetAllocationType.objects.get_or_create(name="Equity")[0]
+        AssetAllocation.objects.create(
+            company=instance,
+            asset_type=equity_asset_type,
+            percent=0.5,
+            max_investment=0.5,
+        )
+    if created:
+        portfolio_data, created = CompanyPortfolioData.objects.get_or_create(company=instance)
+        if not created:
+            portfolio_data.update()
+            portfolio_data.save()
+            portfolio_data.company.save()

wbportfolio/contrib/company_portfolio/scripts.py

@@ -1,8 +1,11 @@
+import logging
 import re
 
 from wbcore.contrib.currency.models import Currency
 from wbcore.contrib.directory.models import Company
 
+logger = logging.getLogger("pms")
+
 
 def get_currency_and_assets_under_management(
     aum_string, currency_mapping, default_currency, multiplier_mapping, default_multiplier
@@ -72,5 +75,7 @@ def assign_aum():
         portfolio_data.assets_under_management_currency = currency
         try:
             portfolio_data.save()
-        except Exception:
-            pass
+        except Exception as e:
+            logger.error(
+                f"while we try to save the customer portfolio aum data for {company}, we encounter the error: {e}"
+            )

wbportfolio/contrib/company_portfolio/serializers.py

@@ -91,7 +91,7 @@ def update_portfolio_data(company_portfolio_data, portfolio_data):
 
     if investment_discretion := portfolio_data["investment_discretion"]:
         company_portfolio_data.investment_discretion = investment_discretion
-
+    company_portfolio_data.update()
     company_portfolio_data.save()
 
 
@@ -103,22 +103,11 @@ class CompanyPortfolioDataMixin(serializers.ModelSerializer):
         read_only=True,
         **_get_assets_under_management_kwargs(field_name="invested_assets_under_management_usd"),
     )
-    investment_discretion = serializers.ChoiceField(**_get_investment_discretion_kwargs())
-    assets_under_management_currency = serializers.PrimaryKeyRelatedField(
-        required=False,
-        queryset=Currency.objects.all(),
-        default=None,
-        label=CompanyPortfolioData.assets_under_management_currency.field.verbose_name,
-    )
+
     assets_under_management_currency_repr = serializers.CharField(read_only=True, required=False)
-    _assets_under_management_currency = CurrencyRepresentationSerializer(source="assets_under_management_currency")
+
     potential = serializers.DecimalField(**_get_potential_kwargs())
-    potential_currency = serializers.PrimaryKeyRelatedField(
-        required=False,
-        queryset=Currency.objects.all(),
-        label=CompanyPortfolioData.potential_currency.field.verbose_name,
-    )
-    _potential_currency = CurrencyRepresentationSerializer(source="potential_currency")
+    investment_discretion = serializers.ChoiceField(**_get_investment_discretion_kwargs())
 
     # Not sure why read_only_fields does not work...
     tier = serializers.ChoiceField(
@@ -144,10 +133,6 @@ class CompanyPortfolioDataMixin(serializers.ModelSerializer):
             "asset_under_management",  # TODO: add an s after asset - After removing this field from the base model
             "assets_under_management_currency_repr",
             "invested_assets_under_management_usd",
-            "potential_currency",
-            "_potential_currency",
-            "assets_under_management_currency",
-            "_assets_under_management_currency",
             "investment_discretion",
             "potential",
             "tier",
@@ -156,6 +141,19 @@ class CompanyPortfolioDataMixin(serializers.ModelSerializer):
 
 class CompanyModelSerializer(CompanyPortfolioDataMixin, BaseCompanyModelSerializer):
     SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES = BasePersonModelSerializer
+    assets_under_management_currency = serializers.PrimaryKeyRelatedField(
+        required=False,
+        queryset=Currency.objects.all(),
+        default=None,
+        label=CompanyPortfolioData.assets_under_management_currency.field.verbose_name,
+    )
+    _assets_under_management_currency = CurrencyRepresentationSerializer(source="assets_under_management_currency")
+    potential_currency = serializers.PrimaryKeyRelatedField(
+        required=False,
+        queryset=Currency.objects.all(),
+        label=CompanyPortfolioData.potential_currency.field.verbose_name,
+    )
+    _potential_currency = CurrencyRepresentationSerializer(source="potential_currency")
 
     def update(self, instance, validated_data):
         validated_data, portfolio_data = get_portfolio_data(validated_data)
@@ -209,6 +207,20 @@ class CompanyModelListSerializer(CompanyPortfolioDataMixin, BaseCompanyModelList
 class PersonModelSerializer(CompanyPortfolioDataMixin, BasePersonModelSerializer):
     SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES = BasePersonModelSerializer
 
+    assets_under_management_currency = serializers.PrimaryKeyRelatedField(
+        required=False,
+        queryset=Currency.objects.all(),
+        default=None,
+        label=CompanyPortfolioData.assets_under_management_currency.field.verbose_name,
+    )
+    _assets_under_management_currency = CurrencyRepresentationSerializer(source="assets_under_management_currency")
+    potential_currency = serializers.PrimaryKeyRelatedField(
+        required=False,
+        queryset=Currency.objects.all(),
+        label=CompanyPortfolioData.potential_currency.field.verbose_name,
+    )
+    _potential_currency = CurrencyRepresentationSerializer(source="potential_currency")
+
     asset_under_management = serializers.DecimalField(
         **_get_assets_under_management_kwargs(field_name="assets_under_management"),
         read_only=True,
@@ -243,11 +255,9 @@ class PersonModelListSerializer(CompanyPortfolioDataMixin, BasePersonModelListSe
 
 
 class AssetAllocationTypeRepresentationSerializer(serializers.RepresentationSerializer):
-    _detail = serializers.HyperlinkField(reverse_name="company_portfolio:assetallocationtyperepresentation-detail")
-
     class Meta:
         model = AssetAllocationType
-        fields = ("id", "name", "_detail")
+        fields = ("id", "name")
 
 
 class AssetAllocationTypeModelSerializer(serializers.ModelSerializer):

wbportfolio/contrib/company_portfolio/tasks.py

@@ -19,5 +19,16 @@ def update_all_portfolio_data(val_date: date | None = None):
         has_account=Exists(Account.objects.filter(owner=OuterRef("pk"))),
         has_portfolio_data=Exists(CompanyPortfolioData.objects.filter(company=OuterRef("pk"))),
     )
+    company_objs = []
+    portfolio_data_objs = []
     for company in tqdm(qs, total=qs.count()):
-        updater.update_company_data(company)
+        portfolio_data = CompanyPortfolioData.objects.get_or_create(company=company)[0]
+        company.customer_status, company.tier = updater.update_company_data(portfolio_data)
+        portfolio_data_objs.append(portfolio_data)
+        company_objs.append(company)
+    if company_objs:
+        Company.objects.bulk_update(company_objs, ["customer_status", "tier"])
+    if portfolio_data_objs:
+        CompanyPortfolioData.objects.bulk_update(
+            portfolio_data_objs, ["invested_assets_under_management_usd", "potential"]
+        )

wbportfolio/contrib/company_portfolio/tests/conftest.py

@@ -60,7 +60,7 @@ from wbportfolio.factories import (
     ProductGroupRepresentantFactory,
     ProductPortfolioRoleFactory,
     TradeFactory,
-    TradeProposalFactory,
+    OrderProposalFactory,
     WhiteLabelProductFactory,
 )
 
@@ -95,7 +95,7 @@ register(ModelPortfolioFactory)
 register(ModelPortfolioWithBaseProductFactory, "model_portfolio_with_base_product")
 register(TradeFactory)
 register(CustomerTradeFactory)
-register(TradeProposalFactory)
+register(OrderProposalFactory)
 register(DividendTransactionsFactory)
 register(FeesFactory)
 register(WhiteLabelProductFactory, "white_label_product")

wbportfolio/defaults/fees/default.py

@@ -1,4 +1,4 @@
-from wbfdm.models import Cash, InstrumentPrice
+from wbfdm.models import InstrumentPrice
 
 from wbportfolio.models import FeeProductPercentage, Fees, Product
 
@@ -8,7 +8,6 @@ def fees_calculation(price_id):
     if price.calculated:
         raise ValueError("Cannot compute fees on calculated price")
     currency = price.instrument.currency
-    underlying_instrument = Cash.objects.filter(currency=currency).first()
     product = Product.objects.get(id=price.instrument.id)
     portfolio = product.portfolio
     previous_price = price.previous_price
@@ -54,40 +53,33 @@ def fees_calculation(price_id):
     performance_fees_gross = product_gross_performance_fees * multiplicator
     base_fields = [
         "total_value",
-        "total_value_fx_portfolio",
         "total_value_gross",
-        "total_value_gross_fx_portfolio",
     ]
     yield {
         "portfolio": portfolio,
-        "linked_product": product,
-        "transaction_date": price.date,
+        "product": product,
+        "fee_date": price.date,
         "transaction_subtype": Fees.Type.MANAGEMENT,
-        "underlying_instrument": underlying_instrument,
         "currency": currency,
         "calculated": True,
         **{f: management_fees for f in base_fields},
     }
     yield {
         "portfolio": portfolio,
-        "linked_product": product,
-        "transaction_date": price.date,
+        "product": product,
+        "fee_date": price.date,
         "transaction_subtype": Fees.Type.ISSUER,
-        "underlying_instrument": underlying_instrument,
         "currency": currency,
         "calculated": True,
         **{f: bank_fees for f in base_fields},
     }
     yield {
         "portfolio": portfolio,
-        "linked_product": product,
-        "transaction_date": price.date,
+        "product": product,
+        "fee_date": price.date,
         "transaction_subtype": Fees.Type.PERFORMANCE,
-        "underlying_instrument": underlying_instrument,
         "currency": currency,
         "calculated": True,
         "total_value": performance_fees_net,
-        "total_value_fx_portfolio": performance_fees_net,
         "total_value_gross": performance_fees_gross,
-        "total_value_gross_fx_portfolio": performance_fees_gross,
     }

wbportfolio/factories/__init__.py

@@ -21,7 +21,7 @@ from .product_groups import ProductGroupFactory, ProductGroupRepresentantFactory
 from .products import IndexProductFactory, ProductFactory, WhiteLabelProductFactory, ModelPortfolioWithBaseProductFactory
 from .reconciliations import AccountReconciliationFactory, AccountReconciliationLineFactory
 from .roles import ManagerPortfolioRoleFactory, ProductPortfolioRoleFactory
-from .trades import CustomerTradeFactory, TradeFactory, TradeProposalFactory
-from .transactions import TransactionFactory
+from .trades import CustomerTradeFactory, TradeFactory
+from .orders import OrderProposalFactory, OrderFactory
 from .indexes import IndexFactory
 from .rebalancing import (RebalancingModelFactory, RebalancerFactory)

wbportfolio/factories/assets.py

@@ -37,7 +37,7 @@ class AssetPositionFactory(factory.django.DjangoModelFactory):
     initial_price = factory.Faker("pydecimal", min_value=100, max_value=120, right_digits=4)
     underlying_quote_price = factory.LazyAttribute(
         lambda o: InstrumentPriceFactory.create(
-            instrument=o.underlying_instrument or o.underlying_quote,
+            instrument=o.underlying_quote or o.underlying_instrument,
             calculated=False,
             date=o.date,
             net_value=o.initial_price,

wbportfolio/factories/dividends.py

@@ -4,13 +4,18 @@ import factory
 
 from wbportfolio.models import DividendTransaction
 
-from .transactions import TransactionFactory
 
-
-class DividendTransactionsFactory(TransactionFactory):
+class DividendTransactionsFactory(factory.django.DjangoModelFactory):
     class Meta:
         model = DividendTransaction
 
+    currency_fx_rate = 1.0
+    portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
+    underlying_instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+    value_date = factory.Faker("date_object")
+    ex_date = factory.Faker("date_object")
+    record_date = factory.LazyAttribute(lambda o: o.ex_date)
     retrocession = 1.0
     shares = factory.LazyAttribute(lambda o: random.randint(10, 10000))
     price = factory.LazyAttribute(lambda o: random.randint(10, 10000))

wbportfolio/factories/fees.py

@@ -1,16 +1,20 @@
+import random
+
 import factory
 from faker import Faker
 
 from wbportfolio.models import Fees
 
-from .transactions import TransactionFactory
-
 faker = Faker()
 
 
-class FeesFactory(TransactionFactory):
+class FeesFactory(factory.django.DjangoModelFactory):
     class Meta:
         model = Fees
 
+    currency_fx_rate = 1.0
+    fee_date = factory.Faker("date_object")
+    total_value = factory.LazyAttribute(lambda o: random.randint(1, 1000))
     transaction_subtype = factory.Faker("random_element", elements=[x[0] for x in Fees.Type.choices])
-    linked_product = factory.SubFactory("wbportfolio.factories.ProductFactory")
+    product = factory.SubFactory("wbportfolio.factories.products.ProductFactory")
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")

wbportfolio/factories/orders/__init__.py

@@ -0,0 +1,2 @@
+from .order_proposals import OrderProposalFactory
+from .orders import OrderFactory

wbportfolio/factories/orders/order_proposals.py

@@ -0,0 +1,21 @@
+import factory
+from faker import Faker
+from pandas._libs.tslibs.offsets import BDay
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.currency.factories import CurrencyFactory
+
+from wbportfolio.factories import PortfolioFactory
+from wbportfolio.models import OrderProposal
+
+fake = Faker()
+
+
+class OrderProposalFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = OrderProposal
+
+    trade_date = factory.LazyAttribute(lambda o: (fake.date_object() + BDay(1)).date())
+    comment = factory.Faker("paragraph")
+    portfolio = factory.LazyAttribute(lambda o: PortfolioFactory.create(currency=CurrencyFactory.create(key="USD")))
+    creator = factory.LazyAttribute(lambda o: UserFactory.create().profile)
+    approver = factory.LazyAttribute(lambda o: UserFactory.create().profile)

wbportfolio/factories/orders/orders.py

@@ -0,0 +1,34 @@
+from decimal import Decimal
+
+import factory
+from faker import Faker
+from wbfdm.factories import InstrumentPriceFactory
+
+from wbportfolio.models import Order
+
+fake = Faker()
+
+
+class OrderFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Order
+
+    order_proposal = factory.SubFactory("wbportfolio.factories.OrderProposalFactory")
+    currency_fx_rate = Decimal(1.0)
+    fees = Decimal(0.0)
+    underlying_instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    shares = factory.Faker("pydecimal", min_value=10, max_value=1000, right_digits=4)
+
+    @factory.post_generation
+    def create_price(self, create, extracted, **kwargs):
+        if create:
+            if self.price:
+                p = InstrumentPriceFactory.create(
+                    instrument=self.underlying_instrument, date=self.value_date, calculated=False, net_value=self.price
+                )
+            else:
+                p = InstrumentPriceFactory.create(
+                    instrument=self.underlying_instrument, date=self.value_date, calculated=False
+                )
+            self.price = p.net_value
+            self.save()

wbportfolio/factories/portfolios.py

@@ -15,10 +15,11 @@ class PortfolioFactory(factory.django.DjangoModelFactory):
         model = Portfolio
 
     name = factory.Sequence(lambda n: f"Portfolio {n}")
-    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyUSDFactory")
     is_manageable = True
     is_tracked = True
     is_lookthrough = False
+    only_weighting = True
     invested_timespan = DateRange(date.min, date.max)
 
     @factory.post_generation

wbportfolio/factories/product_groups.py

@@ -21,10 +21,10 @@ class ProductGroupFactory(InstrumentFactory):
     paying_agent = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
 
     @factory.post_generation
-    def create_initial_portfolio(product_group, *args, **kwargs):
-        if product_group.id and not product_group.portfolios.exists():
+    def create_initial_portfolio(self, *args, **kwargs):
+        if self.id and not self.portfolios.exists():
             portfolio = PortfolioFactory.create()
-            InstrumentPortfolioThroughModel.objects.create(instrument=product_group, portfolio=portfolio)
+            InstrumentPortfolioThroughModel.objects.create(instrument=self, portfolio=portfolio)
 
 
 class ProductGroupRepresentantFactory(factory.django.DjangoModelFactory):

wbportfolio/factories/products.py

@@ -40,10 +40,10 @@ class ProductFactory(InstrumentFactory):
     instrument_type = factory.LazyAttribute(lambda o: InstrumentTypeFactory.create(name="Product", key="product"))
 
     @factory.post_generation
-    def create_initial_portfolio(product, *args, **kwargs):
-        if product.id and not product.portfolios.exists():
+    def create_initial_portfolio(self, *args, **kwargs):
+        if self.id and not self.portfolios.exists():
             portfolio = PortfolioFactory.create()
-            InstrumentPortfolioThroughModel.objects.create(instrument=product, portfolio=portfolio)
+            InstrumentPortfolioThroughModel.objects.create(instrument=self, portfolio=portfolio)
 
     # wbportfolio = factory.SubFactory(PortfolioFactory)
     # portfolio_computed = factory.SubFactory(PortfolioFactory)

wbportfolio/factories/rebalancing.py

@@ -18,6 +18,6 @@ class RebalancerFactory(factory.django.DjangoModelFactory):
     portfolio = factory.SubFactory("wbportfolio.factories.portfolios.PortfolioFactory")
     rebalancing_model = factory.SubFactory(RebalancingModelFactory)
     parameters = dict()
-    approve_trade_proposal_automatically = False
+    apply_order_proposal_automatically = False
     frequency = "RRULE:FREQ=MONTHLY;"
     activation_date = None