wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/contrib/company_portfolio/serializers.py

@@ -0,0 +1,303 @@
+from django.conf import settings
+from rest_framework.reverse import reverse
+from wbcore import serializers
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.directory.models import Company, Entry, Person
+from wbcore.contrib.directory.serializers.companies import (
+    CompanyModelListSerializer as BaseCompanyModelListSerializer,
+)
+from wbcore.contrib.directory.serializers.companies import (
+    CompanyModelSerializer as BaseCompanyModelSerializer,
+)
+from wbcore.contrib.directory.serializers.entries import (
+    CompanyRepresentationSerializer as BaseCompanyRepresentationSerializer,
+)
+from wbcore.contrib.directory.serializers.persons import (
+    PersonModelListSerializer as BasePersonModelListSerializer,
+)
+from wbcore.contrib.directory.serializers.persons import (
+    PersonModelSerializer as BasePersonModelSerializer,
+)
+from wbcore.contrib.geography.serializers import GeographyRepresentationSerializer
+from wbcore.serializers.fields.types import DisplayMode
+
+from .constants import DEFAULT_PORTFOLIO_DATA_UPDATE_TASK_INTERVAL_MINUTES
+from .models import (
+    AssetAllocation,
+    AssetAllocationType,
+    CompanyPortfolioData,
+    GeographicFocus,
+)
+
+HELP_TEXT = f" (Updated every {DEFAULT_PORTFOLIO_DATA_UPDATE_TASK_INTERVAL_MINUTES} minutes)"
+
+
+def _get_assets_under_management_kwargs(field_name):
+    field = getattr(CompanyPortfolioData, field_name).field
+    return {
+        "max_digits": field.max_digits,
+        "decimal_places": field.decimal_places,
+        "label": field.verbose_name,
+        "help_text": field.help_text + HELP_TEXT,
+        "display_mode": DisplayMode.SHORTENED,
+        "required": False,
+    }
+
+
+def _get_investment_discretion_kwargs():
+    field = CompanyPortfolioData.investment_discretion.field
+    return {
+        "choices": field.choices,
+        "default": field.default,
+        "help_text": field.help_text + HELP_TEXT,
+        "label": field.verbose_name,
+    }
+
+
+def _get_potential_kwargs():
+    return {
+        "decimal_places": CompanyPortfolioData.potential.field.decimal_places,
+        "max_digits": CompanyPortfolioData.potential.field.max_digits,
+        "help_text": CompanyPortfolioData.potential.field.help_text + HELP_TEXT,
+        "display_mode": DisplayMode.SHORTENED,
+        "read_only": True,
+    }
+
+
+def get_portfolio_data(validated_data, method="get"):
+    method = getattr(validated_data, method)
+
+    assets_under_management = method("asset_under_management", None)
+    assets_under_management_currency_id = method("assets_under_management_currency", None)
+    investment_discretion = method("investment_discretion", None)
+
+    if isinstance(assets_under_management_currency_id, Currency):
+        assets_under_management_currency_id = assets_under_management_currency_id.id
+
+    return validated_data, {
+        "assets_under_management": assets_under_management,
+        "assets_under_management_currency_id": assets_under_management_currency_id,
+        "investment_discretion": investment_discretion,
+    }
+
+
+def update_portfolio_data(company_portfolio_data, portfolio_data):
+    if assets_under_management := portfolio_data["assets_under_management"]:
+        company_portfolio_data.assets_under_management = assets_under_management
+
+    if assets_under_management_currency_id := portfolio_data["assets_under_management_currency_id"]:
+        company_portfolio_data.assets_under_management_currency_id = assets_under_management_currency_id
+
+    if investment_discretion := portfolio_data["investment_discretion"]:
+        company_portfolio_data.investment_discretion = investment_discretion
+
+    company_portfolio_data.save()
+
+
+class CompanyPortfolioDataMixin(serializers.ModelSerializer):
+    asset_under_management = serializers.DecimalField(
+        **_get_assets_under_management_kwargs(field_name="assets_under_management"),
+    )
+    invested_assets_under_management_usd = serializers.DecimalField(
+        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")
+
+    # Not sure why read_only_fields does not work...
+    tier = serializers.ChoiceField(
+        read_only=True, choices=Company.Tiering.choices, help_text=settings.DEFAULT_TIERING_HELP_TEXT
+    )
+
+    class Meta:
+        model = Entry
+        read_only_fields = ("tier",)
+        decorators = {
+            "asset_under_management": serializers.decorator(
+                position="left", value="{{assets_under_management_currency_repr}}"
+            ),
+            "potential": serializers.decorator(
+                decorator_type="text", position="left", value="{{assets_under_management_currency_repr}}"
+            ),
+            "invested_assets_under_management_usd": serializers.decorator(
+                decorator_type="text", position="left", value="$"
+            ),
+        }
+
+        fields = (
+            "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",
+        )
+
+
+class CompanyModelSerializer(CompanyPortfolioDataMixin, BaseCompanyModelSerializer):
+    SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES = BasePersonModelSerializer
+
+    def update(self, instance, validated_data):
+        validated_data, portfolio_data = get_portfolio_data(validated_data)
+        updated_instance = super().update(instance, validated_data)
+        update_portfolio_data(updated_instance.portfolio_data, portfolio_data)
+
+        return updated_instance
+
+    def create(self, validated_data):
+        validated_data, portfolio_data = get_portfolio_data(validated_data, method="pop")
+        created_instance = super().create(validated_data)
+        update_portfolio_data(created_instance.portfolio_data, portfolio_data)
+
+        return created_instance
+
+    @serializers.register_resource()
+    def extra_additional_resources(self, instance, request, user):
+        return {
+            "asset_allocation_table": reverse(
+                "company_portfolio:companyassetallocation-list", kwargs={"company_id": instance.id}, request=request
+            ),
+            "geographic_focus_table": reverse(
+                "company_portfolio:companygeographicfocus-list", kwargs={"company_id": instance.id}, request=request
+            ),
+        }
+
+    class Meta(CompanyPortfolioDataMixin.Meta, BaseCompanyModelSerializer.Meta):
+        model = Company
+        read_only_fields = (
+            *BaseCompanyModelSerializer.Meta.read_only_fields,
+            *CompanyPortfolioDataMixin.Meta.read_only_fields,
+        )
+        fields = (
+            *BaseCompanyModelSerializer.Meta.fields,
+            *CompanyPortfolioDataMixin.Meta.fields,
+            "assets_under_management_currency",
+            "_assets_under_management_currency",
+            "potential_currency",
+            "_potential_currency",
+        )
+
+
+class CompanyModelListSerializer(CompanyPortfolioDataMixin, BaseCompanyModelListSerializer):
+    SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES = BaseCompanyModelListSerializer
+
+    class Meta(CompanyPortfolioDataMixin.Meta, BaseCompanyModelListSerializer.Meta):
+        model = Company
+        fields = (*BaseCompanyModelListSerializer.Meta.fields, *CompanyPortfolioDataMixin.Meta.fields)
+
+
+class PersonModelSerializer(CompanyPortfolioDataMixin, BasePersonModelSerializer):
+    SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES = BasePersonModelSerializer
+
+    asset_under_management = serializers.DecimalField(
+        **_get_assets_under_management_kwargs(field_name="assets_under_management"),
+        read_only=True,
+    )
+    investment_discretion = serializers.ChoiceField(**_get_investment_discretion_kwargs(), read_only=True)
+
+    class Meta(CompanyPortfolioDataMixin.Meta, BasePersonModelSerializer.Meta):
+        model = Person
+        read_only_fields = (
+            *BasePersonModelSerializer.Meta.read_only_fields,
+            *CompanyPortfolioDataMixin.Meta.fields,
+            *CompanyPortfolioDataMixin.Meta.read_only_fields,
+        )
+        fields = (
+            *BasePersonModelSerializer.Meta.fields,
+            *CompanyPortfolioDataMixin.Meta.fields,
+            "assets_under_management_currency",
+            "_assets_under_management_currency",
+            "potential_currency",
+            "_potential_currency",
+        )
+
+
+class PersonModelListSerializer(CompanyPortfolioDataMixin, BasePersonModelListSerializer):
+    investment_discretion = serializers.ChoiceField(**_get_investment_discretion_kwargs(), read_only=True)
+    SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES = BasePersonModelListSerializer
+
+    class Meta(CompanyPortfolioDataMixin.Meta, BasePersonModelListSerializer.Meta):
+        model = Person
+        fields = (*BasePersonModelListSerializer.Meta.fields, *CompanyPortfolioDataMixin.Meta.fields)
+        read_only_fields = fields
+
+
+class AssetAllocationTypeRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="company_portfolio:assetallocationtyperepresentation-detail")
+
+    class Meta:
+        model = AssetAllocationType
+        fields = ("id", "name", "_detail")
+
+
+class AssetAllocationTypeModelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = AssetAllocationType
+        fields = ("id", "name", "_additional_resources")
+
+
+class AssetAllocationModelSerializer(serializers.ModelSerializer):
+    _asset_type = AssetAllocationTypeRepresentationSerializer(source="asset_type")
+    _company = BaseCompanyRepresentationSerializer(source="company")
+    company = serializers.PrimaryKeyRelatedField(
+        default=serializers.DefaultFromGET("company"), queryset=Company.objects.all(), label="Company"
+    )
+    comment = serializers.TextAreaField(default="")
+
+    class Meta:
+        percent_fields = ("percent", "max_investment")
+        model = AssetAllocation
+        fields = (
+            "id",
+            "company",
+            "_company",
+            "asset_type",
+            "_asset_type",
+            "percent",
+            "max_investment",
+            "comment",
+            "_additional_resources",
+        )
+
+
+class GeographicFocusModelSerializer(serializers.ModelSerializer):
+    _country = GeographyRepresentationSerializer(source="country")
+    company = serializers.PrimaryKeyRelatedField(
+        default=serializers.DefaultFromGET("company"), queryset=Company.objects.all(), label="Company"
+    )
+    _company = BaseCompanyRepresentationSerializer(source="company")
+    comment = serializers.TextAreaField(default="")
+
+    class Meta:
+        percent_fields = ("percent",)
+        model = GeographicFocus
+        fields = (
+            "id",
+            "company",
+            "_company",
+            "country",
+            "_country",
+            "percent",
+            "comment",
+            "_additional_resources",
+        )

wbportfolio/contrib/company_portfolio/tasks.py

@@ -0,0 +1,19 @@
+from datetime import date
+
+from celery import shared_task
+from tqdm import tqdm
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.directory.models import Company, Entry
+
+from .models import Updater
+
+
+@shared_task(queue="portfolio")
+def update_all_portfolio_data(val_date: date | None = None):
+    if not val_date:
+        val_date = CurrencyFXRates.objects.latest("date").date
+    updater = Updater(val_date)
+    account_owners = Entry.objects.filter(accounts__isnull=False)
+    qs = Company.objects.filter(id__in=account_owners)
+    for company in tqdm(qs, total=qs.count()):
+        updater.update_company_data(company)

wbportfolio/contrib/company_portfolio/tests/conftest.py

@@ -0,0 +1,161 @@
+from datetime import date
+
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbcompliance.factories.risk_management import (
+    RiskRuleFactory,
+    RuleBackendFactory,
+    RuleThresholdFactory,
+)
+from wbcore.contrib.authentication.factories import (
+    InternalUserFactory,
+    SuperUserFactory,
+)
+from wbcore.contrib.currency.factories import CurrencyFactory, CurrencyFXRatesFactory
+from wbcore.contrib.directory.factories.entries import (
+    CompanyFactory,
+    CompanyTypeFactory,
+    CustomerStatusFactory,
+    EntryFactory,
+    PersonFactory,
+)
+from wbcore.contrib.geography.factories import CityFactory, CountryFactory, StateFactory
+from wbcore.contrib.io.factories import (
+    DataBackendFactory,
+    ImportSourceFactory,
+    ParserHandlerFactory,
+    ProviderFactory,
+    SourceFactory,
+)
+from wbcrm.factories import AccountFactory, AccountRoleFactory, AccountWithOwnerFactory
+from wbfdm.factories import (
+    CashFactory,
+    ClassificationFactory,
+    ClassificationGroupFactory,
+    EquityFactory,
+    ExchangeFactory,
+    InstrumentFactory,
+    InstrumentListFactory,
+    InstrumentPriceFactory,
+    InstrumentTypeFactory,
+)
+from wbportfolio.factories import (
+    AdjustmentFactory,
+    AssetPositionFactory,
+    ClaimFactory,
+    CustodianFactory,
+    CustomerTradeFactory,
+    DividendTransactionsFactory,
+    FeesFactory,
+    IndexFactory,
+    IndexProductFactory,
+    InstrumentPortfolioThroughModelFactory,
+    ManagerPortfolioRoleFactory,
+    ModelPortfolioFactory,
+    ModelPortfolioWithBaseProductFactory,
+    NegativeClaimFactory,
+    PortfolioFactory,
+    ProductFactory,
+    ProductGroupFactory,
+    ProductGroupRepresentantFactory,
+    ProductPortfolioRoleFactory,
+    TradeFactory,
+    TradeProposalFactory,
+    WhiteLabelProductFactory,
+)
+from wbportfolio.factories.synchronization import (
+    CrontabScheduleFactory,
+    PeriodicTaskFactory,
+    PortfolioSynchronizationFactory,
+    PriceComputationFactory,
+    SynchronizationTaskFactory,
+)
+
+from ..factories import (
+    AssetAllocationFactory,
+    AssetAllocationTypeFactory,
+    GeographicFocusFactory,
+)
+
+from wbcore.tests.conftest import *  # isort:skip
+
+
+fake = Faker()
+
+register(AccountFactory)
+register(AccountWithOwnerFactory)
+register(AccountRoleFactory)
+
+register(ImportSourceFactory)
+register(DataBackendFactory)
+register(ProviderFactory)
+register(SourceFactory)
+register(ParserHandlerFactory)
+
+register(AssetPositionFactory)
+register(ProductFactory)
+register(ProductGroupFactory)
+register(ProductGroupRepresentantFactory)
+register(PortfolioFactory)
+register(InstrumentPortfolioThroughModelFactory)
+register(ModelPortfolioFactory)
+register(ModelPortfolioWithBaseProductFactory, "model_portfolio_with_base_product")
+register(TradeFactory)
+register(CustomerTradeFactory)
+register(TradeProposalFactory)
+register(DividendTransactionsFactory)
+register(FeesFactory)
+register(WhiteLabelProductFactory, "white_label_product")
+register(InstrumentPriceFactory)
+register(IndexProductFactory, "index_product")
+register(CurrencyFXRatesFactory)
+register(ProductPortfolioRoleFactory, "product_portfolio_role")
+register(ManagerPortfolioRoleFactory, "manager_portfolio_role")
+
+register(CurrencyFactory)
+register(CityFactory)
+register(StateFactory)
+register(CountryFactory)
+register(ContinentFactory)
+
+register(CompanyFactory)
+register(PersonFactory)
+register(InternalUserFactory)
+register(EntryFactory)
+register(CustomerStatusFactory)
+register(CompanyTypeFactory)
+
+register(UserFactory)
+register(SuperUserFactory, "superuser")
+register(CustodianFactory)
+
+register(CrontabScheduleFactory)
+register(PeriodicTaskFactory)
+register(SynchronizationTaskFactory)
+register(PortfolioSynchronizationFactory)
+register(PriceComputationFactory)
+register(AdjustmentFactory)
+register(IndexFactory)
+
+
+register(RuleThresholdFactory)
+register(RiskRuleFactory)
+register(RuleBackendFactory)
+
+register(ClaimFactory)
+register(NegativeClaimFactory, "negative_claim")
+
+register(InstrumentFactory)
+register(InstrumentTypeFactory)
+register(EquityFactory, "equity")
+register(CashFactory, "cash")
+register(InstrumentListFactory)
+register(ExchangeFactory)
+register(ClassificationFactory)
+register(ClassificationGroupFactory)
+
+register(AssetAllocationTypeFactory)
+register(AssetAllocationFactory)
+register(GeographicFocusFactory)
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbportfolio"))

wbportfolio/contrib/company_portfolio/tests/test_models.py

@@ -0,0 +1,161 @@
+from datetime import date, timedelta
+from decimal import Decimal
+
+import pytest
+from django.conf import settings
+from dynamic_preferences.registries import global_preferences_registry
+from faker import Faker
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.directory.factories import CompanyFactory, CustomerStatusFactory
+from wbcore.contrib.directory.models import Company
+from wbportfolio.contrib.company_portfolio.models import (
+    CompanyPortfolioData,
+    get_client_customer_status,
+    get_lost_client_customer_status,
+    get_returning_client_customer_status,
+    get_tpm_customer_status,
+)
+
+fake = Faker()
+
+
+def custom_get_potential(company_portfolio_data, val_date: date):
+    return val_date
+
+
+def custom_get_tiering(company_portfolio_data, aum: Decimal):
+    return aum
+
+
+@pytest.mark.django_db
+class TestCompanyPortfolioDataUpdater:
+    @pytest.fixture
+    def company_portfolio_data(self):
+        company = CompanyFactory.create()
+        usd = Currency.objects.get_or_create(key="USD")[0]
+        global_preferences = global_preferences_registry.manager()
+        global_preferences["wbportfolio__tpm_customer_status"] = CustomerStatusFactory.create(title="TPM")
+        global_preferences["wbportfolio__client_customer_status"] = CustomerStatusFactory.create(title="Client")
+        return CompanyPortfolioData.objects.get_or_create(
+            company=company, defaults={"potential_currency": usd, "assets_under_management_currency": usd}
+        )[0]
+
+    def test_get_assets_under_management_usd(self, company_portfolio_data, claim):
+        claim.account.owner = company_portfolio_data.company
+        claim.account.save()
+        claim.status = "APPROVED"
+        claim.save()
+        assert company_portfolio_data.get_assets_under_management_usd(claim.date - timedelta(days=1)) == Decimal(0)
+        assert (
+            company_portfolio_data.get_assets_under_management_usd(claim.date)
+            == claim.shares * claim.product.valuations.get(date=claim.date).net_value
+        )
+
+    def test__get_default_potential(
+        self, company_portfolio_data, weekday, currency_fx_rates_factory, asset_allocation_factory
+    ):
+        currency_fx_rates_factory.create(
+            currency=company_portfolio_data.assets_under_management_currency, date=weekday, value=Decimal(1)
+        )
+
+        initial_aum = Decimal(1000)
+        invested_aum = Decimal(100)
+        company_portfolio_data.assets_under_management = initial_aum
+        company_portfolio_data.invested_assets_under_management_usd = invested_aum
+
+        asset_allocation_1 = asset_allocation_factory.create(
+            company=company_portfolio_data.company, percent=Decimal(0.8), max_investment=Decimal(0.2)
+        )
+        asset_allocation_2 = asset_allocation_factory.create(
+            company=company_portfolio_data.company, percent=Decimal(0.2), max_investment=Decimal(0.3)
+        )
+        asset_allocation_1.refresh_from_db()
+        asset_allocation_2.refresh_from_db()
+        assert (
+            company_portfolio_data._get_default_potential(weekday)
+            == initial_aum * asset_allocation_1.percent * asset_allocation_1.max_investment
+            + initial_aum * asset_allocation_2.percent * asset_allocation_2.max_investment
+            - invested_aum
+        )
+
+    def test__get_default_tiering_for_client(self, company_portfolio_data):
+        company_portfolio_data.company.customer_status = get_client_customer_status()
+        company_portfolio_data.company.save()
+
+        company_portfolio_data.invested_assets_under_management_usd = fake.pydecimal(
+            min_value=10, max_value=100
+        ) / Decimal(100)
+        assert company_portfolio_data._get_default_tiering(Decimal(1)) == Company.Tiering.ONE
+
+        company_portfolio_data.invested_assets_under_management_usd = fake.pydecimal(
+            min_value=5, max_value=10
+        ) / Decimal(100)
+        assert company_portfolio_data._get_default_tiering(Decimal(1)) == Company.Tiering.TWO
+
+        company_portfolio_data.invested_assets_under_management_usd = fake.pydecimal(
+            min_value=2, max_value=5
+        ) / Decimal(100)
+        assert company_portfolio_data._get_default_tiering(Decimal(1)) == Company.Tiering.THREE
+
+        company_portfolio_data.invested_assets_under_management_usd = fake.pydecimal(
+            min_value=1, max_value=2
+        ) / Decimal(100)
+        assert company_portfolio_data._get_default_tiering(Decimal(1)) == Company.Tiering.FOUR
+
+        company_portfolio_data.invested_assets_under_management_usd = fake.pydecimal(max_value=1) / Decimal(100)
+        assert company_portfolio_data._get_default_tiering(Decimal(1)) == Company.Tiering.FIVE
+
+    def test_get_customer_status(self, company_portfolio_data):
+        # without AUM, the method should return the company customer status
+        assert company_portfolio_data.get_customer_status() == company_portfolio_data.company.customer_status
+
+        # add unvalid AUM
+        company_portfolio_data.invested_assets_under_management_usd = -10
+        assert (
+            company_portfolio_data.get_customer_status() == company_portfolio_data.company.customer_status
+        )  # unvalid aum will return as no aum
+
+        # add positive AUM
+        company_portfolio_data.invested_assets_under_management_usd = fake.pydecimal(positive=True)
+        assert (
+            company_portfolio_data.get_customer_status() == get_client_customer_status()
+        )  # unvalid aum will return as no aum
+
+        # ensure TPM are not considered as client even if they have AUM
+        company_portfolio_data.company.customer_status = get_tpm_customer_status()
+        company_portfolio_data.company.save()
+        assert company_portfolio_data.get_customer_status() == get_tpm_customer_status()
+
+    def test_get_lost_customer_status(self, company_portfolio_data):
+        company_portfolio_data.company.customer_status = get_client_customer_status()
+        company_portfolio_data.company.save()
+
+        company_portfolio_data.invested_assets_under_management_usd = None
+        assert company_portfolio_data.get_customer_status() == get_lost_client_customer_status()
+
+    def test_returning_customer_status(self, company_portfolio_data):
+        company_portfolio_data.company.customer_status = get_lost_client_customer_status()
+        company_portfolio_data.company.save()
+
+        company_portfolio_data.invested_assets_under_management_usd = fake.pydecimal(positive=True)
+        assert company_portfolio_data.get_customer_status() == get_returning_client_customer_status()
+
+    def test_staying_returning_customer_status(self, company_portfolio_data):
+        company_portfolio_data.company.customer_status = get_returning_client_customer_status()
+        company_portfolio_data.company.save()
+
+        company_portfolio_data.invested_assets_under_management_usd = fake.pydecimal(positive=True)
+        assert company_portfolio_data.get_customer_status() == get_returning_client_customer_status()
+
+    def test_get_potential_from_custom_method(self, company_portfolio_data, weekday):
+        settings.PORTFOLIO_COMPANY_DATA_POTENTIAL_METHOD = (
+            "wbportfolio.contrib.company_portfolio.tests.test_models.custom_get_potential"
+        )
+        assert company_portfolio_data.get_potential(weekday) == weekday
+
+    @pytest.mark.parametrize("total_aum", [fake.pydecimal()])
+    def test_get_tiering_from_custom_method(self, company_portfolio_data, total_aum):
+        settings.PORTFOLIO_COMPANY_DATA_TIERING_METHOD = (
+            "wbportfolio.contrib.company_portfolio.tests.test_models.custom_get_potential"
+        )
+        assert company_portfolio_data.get_tiering(total_aum) == total_aum

wbportfolio/contrib/company_portfolio/urls.py

@@ -0,0 +1,29 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from .viewsets import (
+    AssetAllocationModelViewSet,
+    AssetAllocationTypeModelViewSet,
+    AssetAllocationTypeRepresentationViewSet,
+    GeographicFocusModelViewSet,
+)
+
+router = WBCoreRouter()
+
+router.register(
+    r"assetallocationtyperepresentation",
+    AssetAllocationTypeRepresentationViewSet,
+    basename="assetallocationtyperepresentation",
+)
+router.register(r"assetallocationtype", AssetAllocationTypeModelViewSet, basename="assetallocationtype")
+router.register(r"assetallocation", AssetAllocationModelViewSet, basename="assetallocation")
+router.register(r"geographicfocus", GeographicFocusModelViewSet, basename="geographicfocus")
+
+company_router = WBCoreRouter()
+company_router.register(r"companyassetallocation", AssetAllocationModelViewSet, basename="companyassetallocation")
+company_router.register(r"companygeographicfocus", GeographicFocusModelViewSet, basename="companygeographicfocus")
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("crmcompany/<int:company_id>/", include(company_router.urls)),
+]