wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/tests/viewsets/test_assets.py

@@ -0,0 +1,67 @@
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from rest_framework.test import APIRequestFactory
+from wbportfolio.viewsets.positions import AggregatedAssetPositionLiquidityPandasView
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestPandasViewSet:
+    def test_get_dataframe(self, instrument_price_factory, asset_position_factory, equity, portfolio, weekday):
+        request = APIRequestFactory().get("")
+        request.query_params = dict()
+        # Make instances of AP, instrument prices.
+        i1 = instrument_price_factory.create(
+            instrument=equity,
+            date=weekday,
+            volume_50d=1000,
+            net_value=10,
+            instrument__currency__key="USD",
+        )
+        i2 = instrument_price_factory.create(
+            instrument=equity,
+            date=(i1.date - BDay(1)).date(),
+            volume_50d=1100,
+            net_value=11,
+            instrument__currency__key="USD",
+        )
+        a1 = asset_position_factory.create(
+            portfolio=portfolio,
+            portfolio__currency__key="USD",
+            underlying_instrument=i1.instrument,
+            date=i1.date,
+            initial_shares=1000,
+        )
+        a2 = asset_position_factory.create(
+            portfolio=portfolio,
+            portfolio__currency__key="USD",
+            underlying_instrument=i1.instrument,
+            date=i2.date,
+            initial_shares=1000,
+        )
+
+        # Make an empty df
+        request.GET = request.GET.copy()
+        request.GET.update(
+            {
+                "historic_date": (i1.date - BDay(2)).date().strftime("%Y-%m-%d"),
+                "compared_date": (i1.date - BDay(3)).date().strftime("%Y-%m-%d"),
+                "bigger_than_x": 1,
+            }
+        )
+        df_empty = AggregatedAssetPositionLiquidityPandasView(request=request)._get_dataframe()
+
+        # Run the function with existing second_date in asset_position
+        request.GET["compared_date"] = i2.date.strftime("%Y-%m-%d")
+
+        # Run with 2 existing dates.
+        request.GET["historic_date"] = i1.date.strftime("%Y-%m-%d")
+        df = AggregatedAssetPositionLiquidityPandasView(request=request)._get_dataframe()
+        # Coverage:
+        assert df_empty.empty  # df is empty
+        # Unit tests:
+        s_i1 = df.set_index("id").loc[i1.instrument.id]
+        assert s_i1.at["liquidity_first_date"] == round(a1.initial_shares / (i1.volume_50d * 0.33), 2)
+        assert s_i1.at["liquidity_second_date"] == round(a2.initial_shares / (i2.volume_50d * 0.33), 2)

wbportfolio/tests/viewsets/test_performances.py

@@ -0,0 +1,72 @@
+from decimal import Decimal
+
+import pytest
+from django.test.client import RequestFactory
+from faker import Faker
+from pandas.tseries.offsets import BDay, BMonthEnd, BYearEnd
+from rest_framework.reverse import reverse
+from rest_framework.test import force_authenticate
+from wbportfolio.factories import InstrumentPriceFactory, ProductFactory
+from wbportfolio.viewsets.product_performance import PerformanceComparisonPandasView
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestPerformanceComparisonPandasView:
+    @classmethod
+    def populated_product_and_get_prices(cls):
+        product = ProductFactory.create()
+        last_date = (fake.date_object() - BDay(0)).date()
+        date_t1 = (last_date - BDay(1)).date()  # t-1 date
+        date_m1 = (last_date - BMonthEnd(1)).date()  # last month latest date
+        date_y1 = (last_date - BYearEnd(1)).date()  # last year latest date
+        date_inception = (last_date - BYearEnd(2)).date()  # some random date to represent inception
+
+        last_price = InstrumentPriceFactory.create(instrument=product, date=last_date, calculated=False)
+        t1 = InstrumentPriceFactory.create(instrument=product, date=date_t1, calculated=False)
+        InstrumentPriceFactory.create(instrument=product, date=date_t1, calculated=True)  # Create noise
+
+        m1 = InstrumentPriceFactory.create(instrument=product, date=date_m1, calculated=False)
+        InstrumentPriceFactory.create(instrument=product, date=date_m1, calculated=True)  # Create noise
+        InstrumentPriceFactory.create(
+            instrument=product, date=(fake.date_between(date_m1, date_t1) - BDay(0)).date(), calculated=False
+        )  # Create noise
+
+        y1 = InstrumentPriceFactory.create(instrument=product, date=date_y1, calculated=False)
+        InstrumentPriceFactory.create(instrument=product, date=date_y1, calculated=True)  # Create noise
+        InstrumentPriceFactory.create(
+            instrument=product, date=(fake.date_between(date_y1, date_m1) - BDay(0)).date(), calculated=False
+        )  # Create noise
+
+        inception = InstrumentPriceFactory.create(instrument=product, date=date_inception, calculated=False)
+        InstrumentPriceFactory.create(instrument=product, date=date_inception, calculated=True)  # Create noise
+        InstrumentPriceFactory.create(
+            instrument=product, date=(fake.date_between(date_inception, date_y1) - BDay(0)).date(), calculated=False
+        )  # Create noise
+
+        product.last_valuation_date = last_date
+        product.inception_date = date_inception
+        product.save()
+        last_price.refresh_from_db()
+        m1.refresh_from_db()
+
+        return last_price.net_value, t1.net_value, m1.net_value, y1.net_value, inception.net_value
+
+    def test_simple_performance(self, superuser):
+        """
+        Basic test to check that the given performance are correct
+        """
+        last_price, t1, m1, y1, inception = self.populated_product_and_get_prices()
+
+        url = reverse("wbportfolio:productperformancecomparison-list")
+        request = RequestFactory().get(url)
+        force_authenticate(request, user=superuser)
+        view = PerformanceComparisonPandasView.as_view({"get": "list"})
+        response = view(request)
+        res = response.data["results"][0]
+        assert pytest.approx(Decimal(res["instrument_last_valuation_price"]), rel=Decimal(1e-4)) == last_price
+        assert pytest.approx(Decimal(res["perf_last_day"]), rel=Decimal(1e-4)) == last_price / t1 - Decimal(1)
+        assert pytest.approx(Decimal(res["perf_month_to_date"]), rel=Decimal(1e-4)) == last_price / m1 - Decimal(1)
+        assert pytest.approx(Decimal(res["perf_year_to_date"]), rel=Decimal(1e-4)) == last_price / y1 - Decimal(1)
+        assert pytest.approx(Decimal(res["perf_inception"]), rel=Decimal(1e-4)) == last_price / inception - Decimal(1)

wbportfolio/tests/viewsets/test_products.py

@@ -0,0 +1,92 @@
+from datetime import date
+
+import pytest
+from django.contrib.auth.models import Permission
+from django.db import models
+from django.test.client import RequestFactory
+from faker import Faker
+from psycopg.types.range import DateRange
+from rest_framework.reverse import reverse
+from rest_framework.test import force_authenticate
+from wbfdm.models import InstrumentPrice
+from wbportfolio.models import InstrumentPortfolioThroughModel, Product
+from wbportfolio.viewsets import ProductModelViewSet
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestProductModelViewSet:
+    def create_queryset(self, portfolio_factory, product_factory, instrument_price_factory, customer_trade_factory):
+        for portfolio, product in zip(
+            portfolio_factory.create_batch(4, invested_timespan=DateRange(date.min, date.max))
+            + portfolio_factory.create_batch(2, invested_timespan=DateRange(date.min, date.max)),
+            product_factory.create_batch(6),
+        ):
+            InstrumentPortfolioThroughModel.objects.update_or_create(
+                instrument=product, defaults={"portfolio": portfolio}
+            )
+            prices = instrument_price_factory.create_batch(10, instrument=product, calculated=False)
+            for price in prices:
+                trade = customer_trade_factory.create(
+                    transaction_date=price.date, underlying_instrument=product, portfolio=product.primary_portfolio
+                )
+                price.outstanding_shares = trade.shares
+                price.save()
+
+    def test_list(self, superuser):
+        url = reverse("wbportfolio:product-list")
+        request = RequestFactory().get(url)
+        force_authenticate(request, user=superuser)
+        view = ProductModelViewSet.as_view({"get": "list"})
+        response = view(request)
+        assert response.status_code == 200
+
+    def test_get_aggregates(
+        self, superuser, portfolio_factory, product_factory, instrument_price_factory, customer_trade_factory
+    ):
+        url = reverse("wbportfolio:product-list")
+        self.create_queryset(portfolio_factory, product_factory, instrument_price_factory, customer_trade_factory)
+
+        request = RequestFactory().get(f'{url}?price_date={InstrumentPrice.objects.latest("date").date}')
+        request.user = superuser
+        force_authenticate(request, user=superuser)
+
+        view = ProductModelViewSet(request=request)
+        view.request = request
+        queryset = view.get_queryset()
+        agg = view.get_aggregates(queryset, queryset)
+        aum = float(
+            queryset.filter(is_invested=True).aggregate(s=models.Sum("assets_under_management_usd"))["s"] or 0.0
+        )
+        assert float(list(agg["assets_under_management_usd"].values())[0]) == pytest.approx(aum, rel=1e-4)
+
+    def test_queryset_superuser(self, superuser, product_factory):
+        url = reverse("wbportfolio:product-list")
+        request = RequestFactory().get(url)
+        force_authenticate(request, user=superuser)
+        view = ProductModelViewSet.as_view({"get": "list"})
+        product_factory.create_batch(5)
+        response = view(request)
+        assert response.status_code == 200
+        ids = [r["id"] for r in response.data["results"]]
+        assert set(ids) == set(list(Product.objects.values_list("id", flat=True)))
+
+    def test_queryset_normaluser(self, user, product_factory, person_factory):
+        url = reverse("wbportfolio:product-list")
+        request = RequestFactory().get(url)
+        permission = Permission.objects.get(codename="view_product", content_type__app_label="wbportfolio")
+        user.user_permissions.add(permission)
+        force_authenticate(request, user=user)
+        view = ProductModelViewSet.as_view({"get": "list"})
+        public_product = product_factory.create()
+        white_label_product = product_factory.create()
+        white_label_product.white_label_customers.add(user.profile)
+
+        other_client_product = product_factory.create()
+        other_client_product.white_label_customers.add(person_factory.create())
+
+        response = view(request)
+        assert response.status_code == 200
+        ids = [r["id"] for r in response.data["results"]]
+        assert set(ids) == set([public_product.id, white_label_product.id])

wbportfolio/tests/viewsets/transactions/test_claims.py

@@ -0,0 +1,146 @@
+import pytest
+from faker import Faker
+from rest_framework.reverse import reverse
+from rest_framework.test import APIClient, APIRequestFactory
+from wbcore.contrib.authentication.factories.users import UserFactory
+from wbcore.contrib.directory.factories import EntryFactory
+from wbcore.contrib.directory.models import Entry
+from wbcore.utils.strings import format_number
+from wbcrm.factories.accounts import AccountFactory, AccountRoleFactory
+from wbcrm.models import Account
+from wbportfolio.factories.claim import ClaimFactory
+from wbportfolio.models.transactions.claim import Claim
+from wbportfolio.viewsets.transactions.claim import (
+    ClaimAccountModelViewSet,
+    ClaimAPIModelViewSet,
+    ClaimEntryModelViewSet,
+    ClaimModelViewSet,
+    ClaimProductModelViewSet,
+    ClaimRepresentationViewSet,
+    ClaimTradeModelViewSet,
+    ConsolidatedTradeSummaryDistributionChart,
+    ConsolidatedTradeSummaryTableView,
+    CumulativeNNMChartView,
+    NegativeTermimalAccountPerProductModelViewSet,
+    ProfitAndLossPandasView,
+)
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestClaimModelViewSet:
+    def test_aggregate(self, claim):
+        view = ClaimModelViewSet()
+        queryset = Claim.objects.all()
+        agg = view.get_aggregates(queryset, paginated_queryset=queryset)
+        assert agg["shares"]["Σ"] == format_number(claim.shares, decimal=4)
+
+    @pytest.fixture
+    def account_user(self):
+        # True, we create a superuser
+
+        # if fake.pybool():
+        #     user = UserFactory.create(is_superuser=True)
+        # else:
+        user = UserFactory.create(is_superuser=False)
+        entry = Entry.objects.get(id=user.profile.id)
+
+        # Create a bunch of account and roles
+        public_account = AccountFactory.create(is_public=True, owner=EntryFactory.create())
+        child_public_account = AccountFactory.create(parent=public_account, owner=EntryFactory.create())
+        ClaimFactory.create(account=public_account)
+        ClaimFactory.create(account=child_public_account)
+        AccountRoleFactory.create(account=public_account, entry=entry)
+        AccountRoleFactory.create(account=public_account)
+        private_account = AccountFactory.create(is_public=False, owner=EntryFactory.create())
+        child_private_account = AccountFactory.create(parent=private_account, owner=EntryFactory.create())
+        ClaimFactory.create(account=private_account)
+        ClaimFactory.create(account=child_private_account)
+        return user
+
+    @pytest.mark.parametrize(
+        "viewset_class",
+        [
+            ClaimAPIModelViewSet,
+            ClaimRepresentationViewSet,
+            ClaimModelViewSet,
+            ClaimAccountModelViewSet,
+            ClaimProductModelViewSet,
+            ClaimEntryModelViewSet,
+            ClaimTradeModelViewSet,
+            ConsolidatedTradeSummaryTableView,
+            ConsolidatedTradeSummaryDistributionChart,
+            CumulativeNNMChartView,
+            ProfitAndLossPandasView,
+        ],
+    )
+    def test_ensure_permission_on_account(self, account_user, viewset_class):
+        """
+        We ensure that all claims viewset doesn't show more that what the user is allowed to see.
+        For claim, the allowed claim are all the claims where the account is among the account they is allowed to see
+        """
+        allowed_accounts = Account.objects.filter_for_user(account_user)
+        allowed_claims = Claim.objects.filter(account__in=allowed_accounts)
+
+        request = APIRequestFactory().get("")
+        request.user = account_user
+        viewset = viewset_class(
+            request=request,
+            kwargs={
+                "entry_id": allowed_accounts.first().owner.id,
+                "account_id": allowed_accounts.filter(parent__isnull=False).first().id,
+                "product_id": allowed_claims.first().product.id,
+                "trade_id": allowed_claims.first().trade.id,
+            },
+        )
+        assert allowed_claims.exists()
+        assert allowed_claims.count() < Claim.objects.count()  # Ensure that the filtering works
+        for claim in viewset.get_queryset():
+            assert claim in allowed_claims
+
+    def test_ensure_permission_on_terminal_account_negative_sum_view(
+        self, user, negative_claim_factory, account_with_owner_factory
+    ):
+        entry = Entry.objects.get(id=user.profile.id)
+
+        request = APIRequestFactory().get("")
+        request.user = user
+        viewset = NegativeTermimalAccountPerProductModelViewSet(request=request)
+        # Create a bunch of account and roles
+        public_account = account_with_owner_factory.create(is_public=True)
+        AccountRoleFactory.create(account=public_account, entry=entry)
+
+        # create two negative claim, one only for an account the user can see
+        private_account = account_with_owner_factory.create(is_public=False)
+        public_claim = negative_claim_factory.create(account=public_account)  # noqa
+        private_claim = negative_claim_factory.create(account=private_account)  # noqa
+
+        assert set(viewset.get_queryset().values_list("account_id", flat=True)) == {public_account.id}
+
+    def test_claim_validate_product_valuations_exist(
+        self, claim_factory, super_user, weekday, instrument_price_factory
+    ):
+        claim = claim_factory.create(create_product_val=False, date=weekday)
+        client = APIClient()
+        url = reverse("wbportfolio:claim-submit", args=[claim.id])
+        client.force_authenticate(user=super_user)
+        response = client.patch(url)
+        assert response.status_code == 412
+        # check that the response contains "date", which means the error was detected on the "date" field
+        assert response.json()["date"]
+
+        # test that estimated price don't count
+        instrument_price_factory.create(instrument=claim.product, date=weekday, calculated=True)
+        response = client.patch(url)
+        assert response.status_code == 412
+
+        # With a valid price we can now submit
+        instrument_price_factory.create(instrument=claim.product, date=weekday, calculated=False)
+        response = client.patch(url)
+        assert response.status_code == 200
+
+        url = reverse("wbportfolio:claim-approve", args=[claim.id])
+        client.force_authenticate(user=super_user)
+        response = client.patch(url)
+        assert response.status_code == 200

wbportfolio/urls.py

@@ -0,0 +1,247 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+from wbportfolio import viewsets
+
+router = WBCoreRouter()
+router.register(r"assetposition", viewsets.AssetPositionModelViewSet, basename="assetposition")
+router.register(r"adjustment", viewsets.AdjustmentModelViewSet, basename="adjustment")
+router.register(r"product", viewsets.ProductModelViewSet, basename="product")
+router.register(r"product_group", viewsets.ProductGroupModelViewSet, basename="product_group")
+router.register(r"productcustomer", viewsets.ProductCustomerModelViewSet, basename="productcustomer")
+router.register(r"productrepresentation", viewsets.ProductRepresentationViewSet, basename="productrepresentation")
+router.register(
+    r"product_grouprepresentation", viewsets.ProductGroupRepresentationViewSet, basename="product_grouprepresentation"
+)
+router.register(
+    r"custodianrepresentation", viewsets.CustodianRepresentationViewSet, basename="custodianrepresentation"
+)
+
+
+router.register(r"portfolio", viewsets.PortfolioModelViewSet, basename="portfolio")
+router.register(r"portfoliocashflow", viewsets.DailyPortfolioCashFlowModelViewSet, basename="portfoliocashflow")
+router.register(r"portfolioswingpricing", viewsets.PortfolioSwingPricingModelViewSet, basename="portfolioswingpricing")
+router.register(r"portfoliocashtarget", viewsets.PortfolioCashTargetModelViewSet, basename="portfoliocashtarget")
+router.register(r"modelportfolio", viewsets.ModelPortfolioModelViewSet, basename="modelportfolio")
+
+router.register(
+    r"portfoliorepresentation", viewsets.PortfolioRepresentationViewSet, basename="portfoliorepresentation"
+)
+router.register(
+    r"portfoliosynchronizationrepresentation",
+    viewsets.PortfolioSynchronizationRepresentationViewSet,
+    basename="portfoliosynchronizationrepresentation",
+)
+router.register(
+    r"pricecomputationrepresentation",
+    viewsets.PriceComputationRepresentationViewSet,
+    basename="pricecomputationrepresentation",
+)
+
+
+router.register(r"portfoliorole", viewsets.PortfolioRoleModelViewSet, basename="portfoliorole")
+
+
+router.register(r"transaction", viewsets.TransactionModelViewSet, basename="transaction")
+router.register(r"fees", viewsets.FeesModelViewSet, basename="fees")
+router.register(r"trade", viewsets.TradeModelViewSet, basename="trade")
+router.register(
+    r"subscriptionredemption", viewsets.SubscriptionRedemptionModelViewSet, basename="subscriptionredemption"
+)
+
+router.register(r"traderepresentation", viewsets.TradeRepresentationViewSet, basename="traderepresentation")
+router.register(
+    r"tradeproposalrepresentation", viewsets.TradeProposalRepresentationViewSet, basename="tradeproposalrepresentation"
+)
+router.register(
+    r"feesproductperformance", viewsets.ProductPerformanceFeesModelViewSet, basename="feesproductperformance"
+)
+router.register(r"aumchart", viewsets.InstrumentPriceAUMDataChartView, basename="aumchart")
+
+router.register(r"custodian", viewsets.CustodianModelViewSet, basename="custodian")
+
+router.register(r"tradeproposal", viewsets.TradeProposalModelViewSet, basename="tradeproposal")
+
+router.register(
+    r"assetandnetnewmoneyprogression",
+    viewsets.AssetAndNetNewMoneyProgressionChartViewSet,
+    basename="assetandnetnewmoneyprogression",
+)
+
+
+# Subrouter for Portfolio
+portfolio_router = WBCoreRouter()
+portfolio_router.register(
+    r"portfoliocashflow", viewsets.DailyPortfolioCashFlowModelViewSet, basename="portfolio-portfoliocashflow"
+)
+portfolio_router.register(r"asset", viewsets.AssetPositionPortfolioModelViewSet, basename="portfolio-asset")
+portfolio_router.register(r"contributor", viewsets.ContributorPortfolioChartView, basename="portfolio-contributor")
+portfolio_router.register(r"fees", viewsets.FeesPortfolioModelViewSet, basename="portfolio-fees")
+portfolio_router.register(r"transaction", viewsets.TransactionPortfolioModelViewSet, basename="portfolio-transaction")
+portfolio_router.register(r"trade", viewsets.TradePortfolioModelViewSet, basename="portfolio-trade")
+portfolio_router.register(
+    r"instrument", viewsets.InstrumentPortfolioThroughPortfolioModelViewSet, basename="portfolio-instrument"
+)
+portfolio_router.register(
+    r"preferredclassification",
+    viewsets.InstrumentPreferedClassificationThroughProductModelViewSet,
+    basename="portfolio-preferredclassification",
+)
+portfolio_router.register(
+    r"tradeproposal", viewsets.TradeProposalPortfolioModelViewSet, basename="portfolio-tradeproposal"
+)
+portfolio_router.register(
+    r"dependencyportfolio", viewsets.PortfolioPortfolioThroughModelViewSet, basename="portfolio-dependencyportfolio"
+)
+portfolio_router.register(
+    r"modelcompositionpandas",
+    viewsets.CompositionModelPortfolioPandasView,
+    basename="portfolio-modelcompositionpandas",
+)
+portfolio_router.register(
+    r"feesaggregated", viewsets.FeesAggregatedPortfolioPandasView, basename="portfolio-feesaggregated"
+)
+portfolio_router.register(
+    r"distributionchart",
+    viewsets.DistributionChartViewSet,
+    basename="portfolio-distributionchart",
+)
+portfolio_router.register(
+    r"distributiontable",
+    viewsets.DistributionTableViewSet,
+    basename="portfolio-distributiontable",
+)
+portfolio_router.register(
+    r"esgaggregation",
+    viewsets.ESGMetricAggregationPortfolioPandasViewSet,
+    basename="portfolio-esgaggregation",
+)
+
+router.register(r"register", viewsets.RegisterModelViewSet, basename="register")
+router.register(r"registerrepresentation", viewsets.RegisterRepresentationViewSet, basename="registerrepresentation")
+
+
+# Subrouter for Products
+product_router = WBCoreRouter()
+product_router.register(r"nominalchart", viewsets.NominalProductChartView, basename="product-nominalchart")
+product_router.register(r"aumchart", viewsets.AUMProductChartView, basename="product-aumchart")
+product_router.register(r"claim", viewsets.ClaimProductModelViewSet, basename="product-claim")
+
+# Subrouter for Trade Proposal
+trade_proposal_router = WBCoreRouter()
+trade_proposal_router.register(r"trade", viewsets.TradeTradeProposalModelViewSet, basename="tradeproposal-trade")
+
+trade_router = WBCoreRouter()
+trade_router.register(r"claim", viewsets.ClaimTradeModelViewSet, basename="trade-claim")
+
+instrument_router = WBCoreRouter()
+
+instrument_router.register(r"trade", viewsets.TradeInstrumentModelViewSet, basename="instrument-trade")
+instrument_router.register(
+    r"subscriptionredemption",
+    viewsets.SubscriptionRedemptionInstrumentModelViewSet,
+    basename="instrument-subscriptionredemption",
+)
+instrument_router.register(
+    r"custodiandistribution",
+    viewsets.CustodianDistributionInstrumentChartViewSet,
+    basename="instrument-custodiandistribution",
+)
+instrument_router.register(
+    r"customerdistribution",
+    viewsets.CustomerDistributionInstrumentChartViewSet,
+    basename="instrument-customerdistribution",
+)
+instrument_router.register(r"asset", viewsets.AssetPositionInstrumentModelViewSet, basename="instrument-asset")
+
+instrument_router.register(
+    r"portfoliorole", viewsets.PortfolioRoleInstrumentModelViewSet, basename="instrument-portfoliorole"
+)
+
+instrument_router.register(r"adjustment", viewsets.AdjustmentEquityModelViewSet, basename="instrument-adjustment")
+instrument_router.register(
+    r"assetpositionchart",
+    viewsets.AssetPositionUnderlyingInstrumentChartViewSet,
+    basename="instrument-assetpositionchart",
+)
+
+# app_name = 'wbportfolio'
+
+router.register(r"productperformance", viewsets.PerformancePandasView, basename="productperformance")
+router.register(
+    r"productperformancennmlist",
+    viewsets.ProductPerformanceNetNewMoneyListViewSet,
+    basename="productperformancennmlist",
+)
+router.register(
+    r"productperformancecomparison", viewsets.PerformanceComparisonPandasView, basename="productperformancecomparison"
+)
+router.register(r"productcashposition", viewsets.CashPositionPortfolioPandasAPIView, basename="productcashposition")
+router.register(r"assetpositiongroupby", viewsets.AssetPositionPandasView, basename="assetpositiongroupby")
+router.register(
+    r"aggregatedassetpositionliquidity",
+    viewsets.AggregatedAssetPositionLiquidityPandasView,
+    basename="aggregatedassetpositionliquidity",
+)
+
+router.register(r"accountreconciliation", viewsets.AccountReconciliationModelViewSet, basename="accountreconciliation")
+router.register(
+    r"accountreconciliationline", viewsets.AccountReconciliationLineModelViewSet, basename="accountreconciliationline"
+)
+
+account_reconciliation_router = WBCoreRouter()
+account_reconciliation_router.register(
+    r"accountreconciliationline",
+    viewsets.AccountReconciliationLineModelViewSet,
+    basename="accountreconciliation-accountreconciliationline",
+)
+
+# Claim routers
+router.register(r"claimrepresentation", viewsets.ClaimRepresentationViewSet, basename="claimrepresentation")
+router.register(r"claim", viewsets.ClaimModelViewSet, basename="claim")
+router.register(r"claim-api", viewsets.ClaimAPIModelViewSet, basename="claim-api")
+router.register(
+    r"negativeaccountproduct",
+    viewsets.NegativeTermimalAccountPerProductModelViewSet,
+    basename="negativeaccountproduct",
+)
+router.register(
+    r"aumtable",
+    viewsets.ConsolidatedTradeSummaryTableView,
+    basename="aumtable",
+)
+router.register(
+    r"consolidatedtradesummarydistributionchart",
+    viewsets.ConsolidatedTradeSummaryDistributionChart,
+    basename="consolidatedtradesummarydistributionchart",
+)
+router.register(
+    r"cumulativennmchart",
+    viewsets.CumulativeNNMChartView,
+    basename="cumulativennmchart",
+)
+
+router.register(
+    r"pnltable",
+    viewsets.ProfitAndLossPandasView,
+    basename="pnltable",
+)
+
+account_router = WBCoreRouter()
+account_router.register(r"claim", viewsets.ClaimAccountModelViewSet, basename="account-claim")
+
+
+entry_router = WBCoreRouter()
+entry_router.register(r"claim", viewsets.ClaimEntryModelViewSet, basename="entry-claim")
+
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("product/<int:product_id>/", include(product_router.urls)),
+    path("trade/<int:trade_id>/", include(trade_router.urls)),
+    path("portfolio/<int:portfolio_id>/", include(portfolio_router.urls)),
+    path("tradeproposal/<int:trade_proposal_id>/", include(trade_proposal_router.urls)),
+    path("instrument/<int:instrument_id>/", include(instrument_router.urls)),
+    path("account/<int:account_id>/", include(account_router.urls)),
+    path("entry/<int:entry_id>/", include(entry_router.urls)),
+    path("accountreconciliation/<int:accountreconciliation_id>/", include(account_reconciliation_router.urls)),
+]

wbportfolio/utils.py

@@ -0,0 +1,30 @@
+import re
+
+from fuzzywuzzy import process as fuzzywuzzy_process
+from fuzzywuzzy import utils
+
+
+def string_matching(s1, s2):
+    best_result = ("", 0)
+    for _s1 in s1.split(" "):
+        if _s1 in ["&"]:
+            continue
+        # validate query
+        if utils.full_process(_s1):
+            matches = fuzzywuzzy_process.extract(_s1, s2)
+            if matches[0][1] > best_result[1]:
+                best_result = matches[0]
+
+    return best_result
+
+
+def re_ric(input: str):
+    return set(re.findall(r"([A-Za-z0-9]{1,6}\.[A-Z]{1,2})(?:.)(?<!\.)", input))
+
+
+def re_bloomberg(input: str):
+    return set(re.findall(r"[A-Z]{2,5}(?:\-[A-Z]{2})?", input))
+
+
+def re_isin(input: str):
+    return set(re.findall(r"[A-Z]{2}[A-Z0-9]{9}[0-9]", input))