wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/contrib/company_portfolio/viewsets.py

@@ -0,0 +1,195 @@
+from datetime import date
+
+from django.db.models import F, OuterRef, Subquery, Sum
+from django.utils.functional import cached_property
+from wbcore import viewsets
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.directory.models import EmployerEmployeeRelationship
+from wbcore.contrib.directory.serializers import NewPersonModelSerializer
+from wbcore.contrib.directory.serializers import (
+    PersonModelSerializer as BasePersonModelSerializer,
+)
+from wbcore.contrib.directory.viewsets.entries import (
+    CompanyModelViewSet as OriginalCompanyModelViewSet,
+)
+from wbcore.contrib.directory.viewsets.entries import (
+    PersonModelViewSet as OriginalPersonModelViewSet,
+)
+from wbcore.utils.strings import format_number
+
+from .configs import (
+    AssetAllocationDisplay,
+    AssetAllocationModelEndpointConfig,
+    CompanyModelDisplay,
+    CompanyPreviewConfig,
+    GeographicFocusDisplay,
+    GeographicFocusModelEndpointConfig,
+    PersonModelDisplay,
+)
+from .filters import CompanyFilter, PersonFilter
+from .models import AssetAllocation, AssetAllocationType, GeographicFocus
+from .serializers import (
+    AssetAllocationModelSerializer,
+    AssetAllocationTypeModelSerializer,
+    AssetAllocationTypeRepresentationSerializer,
+    CompanyModelListSerializer,
+    CompanyModelSerializer,
+    GeographicFocusModelSerializer,
+    PersonModelListSerializer,
+    PersonModelSerializer,
+)
+
+
+class CompanyModelViewSet(OriginalCompanyModelViewSet):
+    LIST_DOCUMENTATION = "wbportfolio/markdown/documentation/company.md"
+    display_config_class = CompanyModelDisplay
+    preview_config_class = CompanyPreviewConfig
+    filterset_class = CompanyFilter
+    ordering_fields = OriginalCompanyModelViewSet.ordering_fields + (
+        "invested_assets_under_management_usd__nulls_last",
+        "potential__nulls_last",
+        "asset_under_management__nulls_last",
+    )
+
+    @cached_property
+    def fx_rate_date(self) -> date:
+        try:
+            return CurrencyFXRates.objects.latest("date").date
+        except CurrencyFXRates.DoesNotExist:
+            return date.today()
+
+    def get_serializer_class(self):
+        if self.get_action() in ["list", "list-metadata"]:
+            return CompanyModelListSerializer
+        return CompanyModelSerializer
+
+    def get_aggregates(self, queryset, **kwargs):
+        sum_potential = queryset.aggregate(sum_potential=Sum("potential")).get("sum_potential", 0.0)
+        sum_assets_under_management_usd = queryset.aggregate(
+            sum_assets_under_management_usd=Sum("assets_under_management_usd")
+        ).get("sum_assets_under_management_usd", 0.0)
+        sum_invested_assets_under_management_usd = queryset.aggregate(
+            sum_invested_assets_under_management_usd=Sum("invested_assets_under_management_usd")
+        ).get("sum_invested_assets_under_management_usd", 0.0)
+        return {
+            "potential": {"Σ": format_number(sum_potential)},
+            "asset_under_management": {"Σ": format_number(sum_assets_under_management_usd)},
+            "invested_assets_under_management_usd": {"Σ": format_number(sum_invested_assets_under_management_usd)},
+        }
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                asset_under_management=F("portfolio_data__assets_under_management"),
+                assets_under_management_currency=F("portfolio_data__assets_under_management_currency"),
+                assets_under_management_currency_repr=F("portfolio_data__assets_under_management_currency__symbol"),
+                fx=CurrencyFXRates.get_fx_rates_subquery(
+                    self.fx_rate_date, currency="assets_under_management_currency", lookup_expr="exact"
+                ),
+                assets_under_management_usd=F("asset_under_management") * F("fx"),
+                invested_assets_under_management_usd=F("portfolio_data__invested_assets_under_management_usd"),
+                investment_discretion=F("portfolio_data__investment_discretion"),
+                potential=F("portfolio_data__potential"),
+                potential_currency=F("portfolio_data__potential_currency"),
+            )
+        )
+
+
+class PersonModelViewSet(OriginalPersonModelViewSet):
+    LIST_DOCUMENTATION = "wbportfolio/markdown/documentation/person.md"
+    display_config_class = PersonModelDisplay
+    filterset_class = PersonFilter
+    ordering_fields = OriginalPersonModelViewSet.ordering_fields + (
+        "invested_assets_under_management_usd__nulls_last",
+        "asset_under_management__nulls_last",
+        "potential",
+    )
+    serializer_class = PersonModelSerializer
+
+    def get_serializer_class(self) -> BasePersonModelSerializer:
+        if self.get_action() in ["list", "list-metadata"]:
+            return PersonModelListSerializer
+        elif "pk" not in self.kwargs:
+            return NewPersonModelSerializer
+        return super().get_serializer_class()
+
+    def get_queryset(self):
+        qs = super().get_queryset()
+        qs = qs.annotate(
+            asset_under_management=Subquery(
+                EmployerEmployeeRelationship.objects.filter(primary=True, employee__id=OuterRef("id")).values(
+                    "employer__portfolio_data__assets_under_management"
+                )[:1],
+            ),
+            asset_under_management_currency_repr=Subquery(
+                EmployerEmployeeRelationship.objects.filter(primary=True, employee__id=OuterRef("id")).values(
+                    "employer__portfolio_data__assets_under_management_currency__key"
+                )[:1],
+            ),
+            invested_assets_under_management_usd=Subquery(
+                EmployerEmployeeRelationship.objects.filter(primary=True, employee__id=OuterRef("id")).values(
+                    "employer__portfolio_data__invested_assets_under_management_usd"
+                )[:1],
+            ),
+            potential=Subquery(
+                EmployerEmployeeRelationship.objects.filter(primary=True, employee__id=OuterRef("id")).values(
+                    "employer__portfolio_data__potential"
+                )[:1],
+            ),
+            potential_currency=Subquery(
+                EmployerEmployeeRelationship.objects.filter(primary=True, employee__id=OuterRef("id")).values(
+                    "employer__portfolio_data__potential_currency"
+                )[:1],
+            ),
+            assets_under_management_currency=Subquery(
+                EmployerEmployeeRelationship.objects.filter(primary=True, employee__id=OuterRef("id")).values(
+                    "employer__portfolio_data__assets_under_management_currency"
+                )[:1],
+            ),
+            investment_discretion=EmployerEmployeeRelationship.objects.filter(
+                primary=True, employee__id=OuterRef("id")
+            ).values("employer__portfolio_data__investment_discretion")[:1],
+        )
+        return qs
+
+
+class AssetAllocationTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = AssetAllocationType.objects.all()
+    serializer_class = AssetAllocationTypeRepresentationSerializer
+
+
+class AssetAllocationTypeModelViewSet(viewsets.ModelViewSet):
+    queryset = AssetAllocationType.objects.all()
+    serializer_class = AssetAllocationTypeModelSerializer
+
+
+class AssetAllocationModelViewSet(viewsets.ModelViewSet):
+    queryset = AssetAllocation.objects.all()
+    serializer_class = AssetAllocationModelSerializer
+
+    display_config_class = AssetAllocationDisplay
+    endpoint_config_class = AssetAllocationModelEndpointConfig
+
+    def get_queryset(self):
+        qs = super().get_queryset()
+        if company_id := self.kwargs.get("company_id", None):
+            qs = qs.filter(company_id=company_id)
+        return qs.select_related(
+            "asset_type",
+            "company",
+        )
+
+
+class GeographicFocusModelViewSet(viewsets.ModelViewSet):
+    queryset = GeographicFocus.objects.all()
+    serializer_class = GeographicFocusModelSerializer
+
+    display_config_class = GeographicFocusDisplay
+    endpoint_config_class = GeographicFocusModelEndpointConfig
+
+    def get_queryset(self):
+        if company_id := self.kwargs.get("company_id", None):
+            return super().get_queryset().filter(company_id=company_id)
+        return super().get_queryset()

wbportfolio/defaults/fees/default.py

@@ -0,0 +1,92 @@
+from wbfdm.models import Cash, InstrumentPrice
+from wbportfolio.models import FeeProductPercentage, Fees, Product
+
+
+def fees_calculation(price_id):
+    price = InstrumentPrice.objects.get(id=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
+
+    if previous_price:
+        shares = product.total_shares(previous_price.date)
+        multiplicator = shares * previous_price.net_value
+    else:
+        shares = product.total_shares(price.date)
+        multiplicator = shares * product.share_price
+
+    product_net_management_fees = product.get_fees_percent(price.date, FeeProductPercentage.Type.MANAGEMENT)
+    product_net_performance_fees = product.get_fees_percent(price.date, FeeProductPercentage.Type.PERFORMANCE)
+    product_gross_performance_fees = product.get_fees_percent(
+        price.date, FeeProductPercentage.Type.PERFORMANCE, net=False
+    )
+
+    if previous_price and previous_price.date.weekday() == 4:
+        # The previous InstrumentPrice was a Friday. This means we have to calculate for the weekend
+        previous_total_value = shares * previous_price.net_value
+
+        sat_bank_fees = (product.bank_fees / 360) * previous_total_value
+        sat_management_fees = (product_net_management_fees / 360) * previous_total_value
+        previous_total_value = previous_total_value - sat_bank_fees - sat_management_fees
+
+        sun_bank_fees = (product.bank_fees / 360) * previous_total_value
+        sun_management_fees = (product_net_management_fees / 360) * previous_total_value
+        previous_total_value = previous_total_value - sun_bank_fees - sun_management_fees
+
+        mon_bank_fees = (product.bank_fees / 360) * previous_total_value
+        mon_management_fees = (product_net_management_fees / 360) * previous_total_value
+        bank_fees = sat_bank_fees + sun_bank_fees + mon_bank_fees
+        management_fees = sat_management_fees + sun_management_fees + mon_management_fees
+    else:
+        bank_fees = (product.bank_fees / 360) * multiplicator
+        management_fees = (product_net_management_fees / 360) * multiplicator
+
+    value = (
+        price.net_value or price.gross_value
+    )  # Flipped around, so that if we have a good net price from the bank, we rather use that one. Issue is, that if the gross price is completely off, the performance fees can be really really high.
+    multiplicator = max(0, value - product.get_high_water_mark(price.date)) * shares
+    performance_fees_net = product_net_performance_fees * multiplicator
+    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,
+        "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,
+        "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,
+        "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/defaults/portfolio/default_rebalancing.py

@@ -0,0 +1,45 @@
+from datetime import date
+from decimal import Decimal
+from typing import Any, Dict, Optional
+
+import pandas as pd
+from wbportfolio.models import Portfolio
+
+
+def callback(
+    portfolio: Portfolio,
+    sync_date: date,
+    rebalancing_freq: Optional[str] = "B",
+    equally_weighted: Optional[bool] = False,
+    composite: Optional[bool] = False,
+    base_assets: Optional[Dict] = dict(),
+    **kwargs: Any,
+):
+    """Recursively calculates the position for a portfolio
+
+    Arguments:
+        portfolio {portfolio.Portfolio} -- The Portfolio on which the assets will be computed
+        sync_date {datetime.date} -- The date on which the assets will be computed
+
+    Keyword Arguments:
+        portfolio {portfolio.Portfolio} -- The core portfolio from which the computed position are created (default: {None})
+        adjusted_weighting {int} -- the adjusted weight of the current level of index (default: {1})
+        adjusted_currency_fx_rate {int} -- the adjusted currency exchange rate on the current level of index (default: {1})
+
+    Yields:
+        tuple[dict, dict] -- Two dictionaries: One with filter parameters and one with default values
+    """
+    assets = portfolio.assets.filter(date=sync_date)
+    if composite:
+        last_trade_proposals = portfolio.trade_proposals.filter(trade_date__lte=sync_date)
+        if last_trade_proposals.exists():
+            base_assets = last_trade_proposals.latest("trade_date").base_assets
+    if assets.exists() and assets.filter(date=sync_date).exists():
+        for asset in assets.all():
+            new_weight = asset.weighting
+            if pd.date_range(end=sync_date, periods=1, freq=rebalancing_freq)[0] == pd.Timestamp(sync_date):
+                if equally_weighted:
+                    new_weight = Decimal(1 / assets.count())
+                elif base_assets and (proposed_weight := base_assets.get(asset.underlying_instrument.id, None)):
+                    new_weight = proposed_weight
+            yield asset._build_dto(), asset._build_dto(new_weight)

wbportfolio/dynamic_preferences_registry.py

@@ -0,0 +1,58 @@
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import (
+    IntegerPreference,
+    LongStringPreference,
+    StringPreference,
+)
+
+portfolio = Section("wbportfolio")
+commission = Section("wbcommission")
+
+
+@global_preferences_registry.register
+class TimedeltaImportInstrumentPrice(IntegerPreference):
+    section = portfolio
+    name = "timedelta_import_instrument_price"
+    default = 2
+
+    verbose_name = "The Timedelta for the instrument price import windows"
+
+
+@global_preferences_registry.register
+class DaysToRecomputeRebateFromFeesThreshold(IntegerPreference):
+    section = commission
+    name = "days_to_recompute_rebate_from_fees_threshold"
+    default = 90  # 1 quarter
+
+    verbose_name = "Number of Days to recompute rebate from fees"
+
+
+@global_preferences_registry.register
+class MonthlyNetNewMoneyTarget(IntegerPreference):
+    section = portfolio
+    name = "monthly_nnm_target"
+    default = int(1e6)
+
+    verbose_name = "Monthly Net New Money Target"
+
+
+@global_preferences_registry.register
+class AccountHoldingReconciliationNotificationTitle(StringPreference):
+    section = portfolio
+    name = "account_holding_reconciliation_notification_title"
+    default = "Account Holdings Reconciliation"
+
+
+@global_preferences_registry.register
+class AccountHoldingReconciliationNotificationBody(LongStringPreference):
+    section = portfolio
+    name = "account_holding_reconciliation_notification_body"
+    default = """To validate your holdings, please review the reconciliation for the account {account} on {reconciliation_date}."""
+
+
+@global_preferences_registry.register
+class AccountHoldingReconciliationNotificationBodyUpdate(LongStringPreference):
+    section = portfolio
+    name = "account_holding_reconciliation_notification_body_update"
+    default = """A reconcilation has been updated and requires your review. Please review the reconciliation for the account {account} on {reconciliation_date}."""

wbportfolio/factories/__init__.py

@@ -0,0 +1,35 @@
+from .adjustments import AdjustmentFactory
+from .assets import AssetPositionFactory
+from .claim import (
+    ApprovedClaimFactory,
+    ClaimFactory,
+    NegativeClaimFactory,
+    PositiveClaimFactory,
+)
+from .custodians import CustodianFactory
+from .dividends import DividendTransactionsFactory
+from .fees import FeesFactory
+from wbfdm.factories.instrument_prices import InstrumentPriceFactory
+from .portfolios import (
+    InstrumentPortfolioThroughModelFactory,
+    ModelPortfolioFactory,
+    ModelPortfolioWithBaseProductFactory,
+    PortfolioFactory,
+)
+from .portfolio_swing_pricings import PortfolioSwingPricingFactory
+from .portfolio_cash_targets import PortfolioCashTargetFactory
+from .portfolio_cash_flow import DailyPortfolioCashFlowFactory
+from .product_groups import ProductGroupFactory, ProductGroupRepresentantFactory
+from .products import IndexProductFactory, ProductFactory, WhiteLabelProductFactory
+from .reconciliations import AccountReconciliationFactory, AccountReconciliationLineFactory
+from .roles import ManagerPortfolioRoleFactory, ProductPortfolioRoleFactory
+from .synchronization import (
+    CrontabScheduleFactory,
+    PeriodicTaskFactory,
+    PortfolioSynchronizationFactory,
+    PriceComputationFactory,
+    SynchronizationTaskFactory,
+)
+from .trades import CustomerTradeFactory, TradeFactory, TradeProposalFactory
+from .transactions import TransactionFactory
+from .indexes import IndexFactory

wbportfolio/factories/adjustments.py

@@ -0,0 +1,17 @@
+import factory
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbportfolio.models import Adjustment
+
+fake = Faker()
+
+
+class AdjustmentFactory(factory.django.DjangoModelFactory):
+    date = factory.LazyAttribute(lambda o: (fake.future_date() + BDay(0)).date())
+    instrument = factory.SubFactory("wbfdm.factories.instruments.InstrumentFactory")
+    factor = factory.Faker("pydecimal", min_value=2, max_value=10)
+    last_handler = factory.SubFactory("wbcore.contrib.directory.factories.entries.PersonFactory")
+    status = Adjustment.Status.PENDING
+
+    class Meta:
+        model = Adjustment

wbportfolio/factories/assets.py

@@ -0,0 +1,75 @@
+import random
+from datetime import date, timedelta
+from decimal import Decimal
+
+import factory
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbfdm.factories import InstrumentPriceFactory
+from wbportfolio.models import AssetPosition
+
+
+def get_weekday(o):
+    if o.underlying_instrument.id and o.underlying_instrument.assets.exists():
+        latest_position = o.underlying_instrument.assets.latest("date").date
+    else:
+        latest_position = date(2020, 1, 1)
+
+    latest_position += timedelta(days=1)
+    while latest_position.weekday() > 4:
+        latest_position += timedelta(days=1)
+
+    return latest_position
+
+
+class AssetPositionFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = AssetPosition
+        django_get_or_create = ("portfolio", "underlying_instrument", "date", "portfolio_created")
+
+    underlying_instrument = factory.SubFactory("wbfdm.factories.instruments.InstrumentFactory")
+
+    date = factory.LazyAttribute(lambda o: get_weekday(o))
+    asset_valuation_date = factory.LazyAttribute(lambda o: o.date)
+
+    initial_price = factory.Faker("pydecimal", min_value=100, max_value=120, right_digits=4)
+    underlying_instrument_price = factory.LazyAttribute(
+        lambda o: InstrumentPriceFactory.create(
+            instrument=o.underlying_instrument, calculated=False, date=o.date, net_value=o.initial_price
+        )
+    )
+
+    initial_shares = factory.LazyAttribute(lambda o: Decimal(random.randint(10, 10000)))
+    initial_currency_fx_rate = Decimal(1)
+    weighting = factory.LazyAttribute(lambda o: Decimal(random.random()))
+
+    portfolio = factory.SubFactory("wbportfolio.factories.portfolios.PortfolioFactory")
+    portfolio_created = None
+
+    currency = factory.LazyAttribute(lambda o: o.underlying_instrument.currency)
+    currency_fx_rate_instrument_to_usd = factory.LazyAttribute(
+        lambda o: CurrencyFXRates.objects.get_or_create(
+            currency=o.currency, date=o.date, defaults={"value": Decimal(1.0)}
+        )[0]
+    )
+
+    is_estimated = False
+
+    @classmethod
+    def _create(cls, model_class, *args, **kwargs):
+        if (asset_valuation_date := kwargs.get("asset_valuation_date", None)) and (
+            currency := kwargs.get("currency", None)
+        ):
+            kwargs["currency_fx_rate_instrument_to_usd"] = CurrencyFXRates.objects.get_or_create(
+                date=asset_valuation_date, currency=currency, defaults={"value": 1.0}
+            )[0]
+        if (asset_valuation_date := kwargs.get("asset_valuation_date", None)) and (
+            portfolio := kwargs.get("portfolio", None)
+        ):
+            kwargs["currency_fx_rate_portfolio_to_usd"] = CurrencyFXRates.objects.get_or_create(
+                date=asset_valuation_date, currency=portfolio.currency, defaults={"value": 1.0}
+            )[0]
+        return super()._create(model_class, *args, **kwargs)
+
+    # @factory.pre
+    # def generate_currency_rates(self, create, extracted, **kwargs):
+    #

wbportfolio/factories/claim.py

@@ -0,0 +1,39 @@
+import factory
+from pandas.tseries.offsets import BDay
+from wbfdm.factories.instrument_prices import InstrumentPriceFactory
+from wbportfolio.models.transactions.claim import Claim
+
+
+class ClaimFactory(factory.django.DjangoModelFactory):
+    status = Claim.Status.DRAFT
+    account = factory.SubFactory("wbcrm.factories.AccountFactory")
+    trade = factory.SubFactory("wbportfolio.factories.CustomerTradeFactory")
+    product = factory.LazyAttribute(lambda x: x.trade.product)
+    claimant = factory.SubFactory("wbcore.contrib.directory.factories.entries.PersonFactory")
+    creator = factory.SubFactory("wbcore.contrib.directory.factories.entries.PersonFactory")
+    date = factory.LazyAttribute(lambda x: (x.trade.transaction_date - BDay(0)).date())
+    bank = factory.Faker("company")
+    reference = factory.Faker("company")
+    shares = factory.LazyAttribute(lambda x: x.trade.shares)
+    nominal_amount = factory.LazyAttribute(lambda x: x.shares * x.product.share_price)
+    external_id = factory.Sequence(lambda n: f"{n:06}")
+
+    @factory.post_generation
+    def create_product_val(self, create, extracted, **kwargs):
+        if extracted is None or extracted is True:
+            InstrumentPriceFactory.create(instrument=self.product, date=self.date, calculated=False)
+
+    class Meta:
+        model = Claim
+
+
+class PositiveClaimFactory(ClaimFactory):
+    shares = factory.Faker("pydecimal", min_value=0, max_value=1000000)
+
+
+class NegativeClaimFactory(ClaimFactory):
+    shares = factory.Faker("pydecimal", min_value=-1000000, max_value=0)
+
+
+class ApprovedClaimFactory(ClaimFactory):
+    status = Claim.Status.APPROVED

wbportfolio/factories/custodians.py

@@ -0,0 +1,11 @@
+import factory
+from wbportfolio.models import Custodian
+
+
+class CustodianFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("company")
+    mapping = factory.List([factory.Faker("company") for _ in range(5)])
+
+    class Meta:
+        model = Custodian
+        django_get_or_create = ("name",)

wbportfolio/factories/dividends.py

@@ -0,0 +1,14 @@
+import random
+
+import factory
+from wbportfolio.models import DividendTransaction
+
+from .transactions import TransactionFactory
+
+
+class DividendTransactionsFactory(TransactionFactory):
+    class Meta:
+        model = DividendTransaction
+
+    shares = factory.LazyAttribute(lambda o: random.randint(10, 10000))
+    price = factory.LazyAttribute(lambda o: random.randint(10, 10000))

wbportfolio/factories/fees.py

@@ -0,0 +1,15 @@
+import factory
+from faker import Faker
+from wbportfolio.models import Fees
+
+from .transactions import TransactionFactory
+
+faker = Faker()
+
+
+class FeesFactory(TransactionFactory):
+    class Meta:
+        model = Fees
+
+    transaction_subtype = factory.Faker("random_element", elements=[x[0] for x in Fees.Type.choices])
+    linked_product = factory.SubFactory("wbportfolio.factories.ProductFactory")

wbportfolio/factories/indexes.py

@@ -0,0 +1,17 @@
+import random
+
+import factory
+from faker import Faker
+from wbfdm.factories import InstrumentFactory, InstrumentTypeFactory
+from wbportfolio.models import Index
+
+fake = Faker()
+
+
+class IndexFactory(InstrumentFactory):
+    risk_scale = factory.LazyAttribute(lambda o: random.randint(1, 7))
+
+    instrument_type = factory.LazyAttribute(lambda o: InstrumentTypeFactory.create(name="Index", key="index"))
+
+    class Meta:
+        model = Index

wbportfolio/factories/portfolio_cash_flow.py

@@ -0,0 +1,20 @@
+import factory
+from faker import Faker
+from wbportfolio.factories.portfolios import PortfolioFactory
+from wbportfolio.models import DailyPortfolioCashFlow
+
+fake = Faker()
+
+
+class DailyPortfolioCashFlowFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = DailyPortfolioCashFlow
+
+    value_date = factory.Faker("date")
+    portfolio = factory.SubFactory(PortfolioFactory)
+
+    total_assets = factory.Faker("pydecimal", left_digits=7, right_digits=4, min_value=0.01)
+    cash = factory.Faker("pydecimal", left_digits=7, right_digits=4, min_value=0.01)
+    cash_flow_forecast = factory.LazyAttribute(lambda o: fake.pydecimal(min_value=0.01, max_value=o.total_assets))
+
+    pending = factory.Faker("pybool")

wbportfolio/factories/portfolio_cash_targets.py

@@ -0,0 +1,15 @@
+import factory
+from wbportfolio.factories.portfolios import PortfolioFactory
+from wbportfolio.models import PortfolioCashTarget
+
+
+class PortfolioCashTargetFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = PortfolioCashTarget
+
+    valid_date = factory.Faker("date")
+    portfolio = factory.SubFactory(PortfolioFactory)
+    min_target = factory.Faker("pydecimal", left_digits=0, right_digits=4, max_value=0.01)
+    target = factory.Faker("pydecimal", left_digits=0, right_digits=4, max_value=0.01)
+    max_target = factory.Faker("pydecimal", left_digits=0, right_digits=4, min_value=0.01)
+    comment = factory.Faker("paragraph", nb_sentences=1)