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

wbportfolio/viewsets/orders/orders.py

@@ -0,0 +1,277 @@
+from decimal import Decimal
+
+from django.contrib.messages import error, info
+from django.db.models import (
+    Case,
+    CharField,
+    F,
+    Func,
+    Sum,
+    Value,
+    When,
+)
+from django.shortcuts import get_object_or_404
+from django.utils.functional import cached_property
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbcore.utils.strings import format_number
+from wbcore.viewsets.mixins import OrderableMixin
+
+from wbportfolio.import_export.resources.trades import OrderProposalTradeResource
+from wbportfolio.models import Order, OrderProposal
+from wbportfolio.serializers import (
+    OrderOrderProposalListModelSerializer,
+    OrderOrderProposalModelSerializer,
+    ReadOnlyOrderOrderProposalModelSerializer,
+)
+
+from ...filters.orders import OrderFilterSet
+from ...permissions import IsPortfolioManager
+from ..mixins import UserPortfolioRequestPermissionMixin
+from .configs import (
+    OrderOrderProposalButtonConfig,
+    OrderOrderProposalDisplayConfig,
+    OrderOrderProposalEndpointConfig,
+)
+from .configs.buttons.orders import ExecutionInstructionSerializer
+
+
+class OrderOrderProposalModelViewSet(
+    UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, OrderableMixin, viewsets.ModelViewSet
+):
+    IDENTIFIER = "wbportfolio:order"
+    IMPORT_ALLOWED = True
+    ordering = (
+        "order_proposal",
+        "order",
+    )
+    ordering_fields = (
+        "underlying_instrument__name",
+        "underlying_instrument_isin",
+        "underlying_instrument_ticker",
+        "underlying_instrument_refinitiv_identifier_code",
+        "underlying_instrument_instrument_type",
+        "target_weight",
+        "effective_weight",
+        "effective_shares",
+        "target_shares",
+        "shares",
+        "weighting",
+    )
+    IDENTIFIER = "wbportfolio:order"
+    search_fields = ("underlying_instrument__name",)
+    queryset = Order.objects.none()
+    filterset_class = OrderFilterSet
+
+    display_config_class = OrderOrderProposalDisplayConfig
+    endpoint_config_class = OrderOrderProposalEndpointConfig
+    serializer_class = OrderOrderProposalModelSerializer
+    button_config_class = OrderOrderProposalButtonConfig
+
+    @cached_property
+    def order_proposal(self):
+        return get_object_or_404(OrderProposal, pk=self.kwargs["order_proposal_id"])
+
+    @cached_property
+    def portfolio_total_asset_value(self):
+        return self.order_proposal.portfolio_total_asset_value
+
+    def has_import_permission(self, request) -> bool:  # allow import only on draft order proposal
+        return super().has_import_permission(request) and self.order_proposal.status == OrderProposal.Status.DRAFT
+
+    def get_import_resource_kwargs(self):
+        resource_kwargs = super().get_import_resource_kwargs()
+        resource_kwargs["columns_mapping"] = {"underlying_instrument": "underlying_instrument__isin"}
+        return resource_kwargs
+
+    def get_resource_class(self):
+        return OrderProposalTradeResource
+
+    def get_aggregates(self, queryset, *args, **kwargs):
+        agg = {}
+        if queryset.exists():
+            noncash_aggregates = queryset.filter(underlying_instrument__is_cash=False).aggregate(
+                sum_target_weight=Sum(F("target_weight")),
+                sum_effective_weight=Sum(F("effective_weight")),
+                sum_target_total_value_fx_portfolio=Sum(F("target_total_value_fx_portfolio")),
+                sum_effective_total_value_fx_portfolio=Sum(F("effective_total_value_fx_portfolio")),
+            )
+            # weights aggregates
+            cash_sum_effective_weight = self.order_proposal.total_effective_portfolio_weight - (
+                noncash_aggregates["sum_effective_weight"] or Decimal(0)
+            )
+            cash_sum_target_cash_weight = Decimal("1.0") - (noncash_aggregates["sum_target_weight"] or Decimal(0))
+            noncash_sum_effective_weight = noncash_aggregates["sum_effective_weight"] or Decimal(0)
+            noncash_sum_target_weight = noncash_aggregates["sum_target_weight"] or Decimal(0)
+            sum_buy_weight = queryset.filter(weighting__gte=0).aggregate(s=Sum(F("weighting")))["s"] or Decimal(0)
+            sum_sell_weight = queryset.filter(weighting__lt=0).aggregate(s=Sum(F("weighting")))["s"] or Decimal(0)
+
+            # shares aggregates
+            cash_sum_effective_total_value_fx_portfolio = cash_sum_effective_weight * self.portfolio_total_asset_value
+            cash_sum_target_total_value_fx_portfolio = cash_sum_target_cash_weight * self.portfolio_total_asset_value
+            noncash_sum_effective_total_value_fx_portfolio = noncash_aggregates[
+                "sum_effective_total_value_fx_portfolio"
+            ] or Decimal(0)
+            noncash_sum_target_total_value_fx_portfolio = noncash_aggregates[
+                "sum_target_total_value_fx_portfolio"
+            ] or Decimal(0)
+            sum_buy_total_value_fx_portfolio = queryset.filter(total_value_fx_portfolio__gte=0).aggregate(
+                s=Sum(F("total_value_fx_portfolio"))
+            )["s"] or Decimal(0)
+            sum_sell_total_value_fx_portfolio = queryset.filter(total_value_fx_portfolio__lt=0).aggregate(
+                s=Sum(F("total_value_fx_portfolio"))
+            )["s"] or Decimal(0)
+
+            agg = {
+                "effective_weight": {
+                    "Cash": format_number(cash_sum_effective_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Non-Cash": format_number(noncash_sum_effective_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Total": format_number(
+                        noncash_sum_effective_weight + cash_sum_effective_weight,
+                        decimal=Order.ORDER_WEIGHTING_PRECISION,
+                    ),
+                },
+                "target_weight": {
+                    "Cash": format_number(cash_sum_target_cash_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Non-Cash": format_number(noncash_sum_target_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Total": format_number(
+                        cash_sum_target_cash_weight + noncash_sum_target_weight,
+                        decimal=Order.ORDER_WEIGHTING_PRECISION,
+                    ),
+                },
+                "effective_total_value_fx_portfolio": {
+                    "Cash": format_number(cash_sum_effective_total_value_fx_portfolio, decimal=6),
+                    "Non-Cash": format_number(noncash_sum_effective_total_value_fx_portfolio, decimal=6),
+                    "Total": format_number(
+                        cash_sum_effective_total_value_fx_portfolio + noncash_sum_effective_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
+                },
+                "target_total_value_fx_portfolio": {
+                    "Cash": format_number(cash_sum_target_total_value_fx_portfolio, decimal=6),
+                    "Non-Cash": format_number(noncash_sum_target_total_value_fx_portfolio, decimal=6),
+                    "Total": format_number(
+                        cash_sum_target_total_value_fx_portfolio + noncash_sum_target_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
+                },
+                "weighting": {
+                    "Cash Flow": format_number(
+                        sum_sell_weight + sum_buy_weight,
+                        decimal=Order.ORDER_WEIGHTING_PRECISION,
+                    ),
+                    "Buy": format_number(sum_buy_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Sell": format_number(sum_sell_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                },
+                "total_value_fx_portfolio": {
+                    "Cash Flow": format_number(
+                        cash_sum_target_total_value_fx_portfolio - cash_sum_effective_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
+                    "Buy": format_number(sum_buy_total_value_fx_portfolio, decimal=6),
+                    "Sell": format_number(sum_sell_total_value_fx_portfolio, decimal=6),
+                },
+            }
+
+        return agg
+
+    def get_serializer_class(self):
+        if self.order_proposal.status != OrderProposal.Status.DRAFT and not self.order_proposal.can_be_confirmed:
+            return ReadOnlyOrderOrderProposalModelSerializer
+        if not self.new_mode and "pk" not in self.kwargs:
+            serializer_base_class = OrderOrderProposalListModelSerializer
+        else:
+            serializer_base_class = OrderOrderProposalModelSerializer
+        if not self.order_proposal.portfolio_total_asset_value:
+
+            class OnlyWeightSerializerClass(serializer_base_class):
+                class Meta(serializer_base_class.Meta):
+                    read_only_fields = list(serializer_base_class.Meta.read_only_fields) + [
+                        "shares",
+                        "target_shares",
+                        "total_value_fx_portfolio",
+                        "target_total_value_fx_portfolio",
+                    ]
+
+            return OnlyWeightSerializerClass
+        return serializer_base_class
+
+    def add_messages(self, request, queryset=None, paginated_queryset=None, instance=None, initial=False):
+        if self.orders.exists() and self.order_proposal.status in [
+            OrderProposal.Status.PENDING,
+            OrderProposal.Status.DRAFT,
+        ]:
+            total_target_weight = self.orders.aggregate(c=Sum(F("target_weight")))["c"] or Decimal(0)
+            if round(total_target_weight, 8) != 1:
+                info(
+                    request,
+                    "The total target weight does not equal 1. To avoid automatic cash allocation, please adjust the order weights to sum up to 1. Otherwise, a cash component will be added when this order proposal is submitted.",
+                )
+            if self.orders.filter(has_warnings=True).exists():
+                error(
+                    request,
+                    "Some orders failed preparation. To resolve this, please revert the order proposal to draft, review and correct the orders, and then resubmit.",
+                )
+
+    @cached_property
+    def orders(self):
+        qs = self.order_proposal.get_orders()
+        if not self.is_portfolio_manager:
+            return qs.none()
+        return qs
+
+    def get_queryset(self):
+        return (
+            self.orders.filter(underlying_instrument__is_cash=False)
+            .annotate(  # .exclude(underlying_instrument__is_cash=True)
+                underlying_instrument_isin=F("underlying_instrument__isin"),
+                underlying_instrument_ticker=F("underlying_instrument__ticker"),
+                underlying_instrument_refinitiv_identifier_code=F("underlying_instrument__refinitiv_identifier_code"),
+                underlying_instrument_instrument_type=Case(
+                    When(
+                        underlying_instrument__parent__is_security=True,
+                        then=F("underlying_instrument__parent__instrument_type__short_name"),
+                    ),
+                    default=F("underlying_instrument__instrument_type__short_name"),
+                ),
+                underlying_instrument_exchange=F("underlying_instrument__exchange__name"),
+                effective_total_value_fx_portfolio=F("effective_weight") * Value(self.portfolio_total_asset_value),
+                target_total_value_fx_portfolio=F("target_weight") * Value(self.portfolio_total_asset_value),
+                portfolio_currency=F("portfolio__currency__symbol"),
+                underlying_instrument_currency=F("underlying_instrument__currency__symbol"),
+                security=F("underlying_instrument__parent"),
+                company=F("underlying_instrument__parent__parent"),
+                execution_instruction_parameters_repr=Func(
+                    "execution_instruction_parameters",
+                    function="string_agg",
+                    template="(SELECT string_agg(key || '=' || value, ',') FROM jsonb_each_text(%(expressions)s))",
+                    output_field=CharField(),
+                ),
+                execution_date=F("execution_trade__transaction_date"),
+                execution_price=F("execution_trade__price"),
+                execution_traded_shares=F("execution_trade__shares"),
+            )
+            .select_related(
+                "underlying_instrument", "underlying_instrument__parent", "underlying_instrument__parent__parent"
+            )
+        )
+
+    @action(detail=True, methods=["PUT"], permission_classes=[IsPortfolioManager])
+    def changeexecutioninstruction(self, request, pk=None, order_proposal_id=None, **kwargs):
+        serializer = ExecutionInstructionSerializer(data=request.data)
+        order_proposal = get_object_or_404(OrderProposal, pk=order_proposal_id)
+        if serializer.is_valid(raise_exception=True):
+            parameters = dict(serializer.data)
+            orders_to_update = order_proposal.orders.all()
+            execution_instruction = parameters.pop("execution_instruction")
+            apply_execution_instruction_to_all_orders = parameters.pop("apply_execution_instruction_to_all_orders")
+            execution_parameters = {k: v for k, v in parameters.items() if v}
+            if not apply_execution_instruction_to_all_orders:
+                orders_to_update = orders_to_update.filter(id=pk)
+            orders_to_update.update(
+                execution_instruction=execution_instruction, execution_instruction_parameters=execution_parameters
+            )
+
+        return Response({"send": True})

wbportfolio/viewsets/portfolios.py

@@ -2,6 +2,7 @@ from contextlib import suppress
 from datetime import date, datetime
 
 import pandas as pd
+from celery import chain
 from django.db.models import OuterRef, Q, Subquery, Sum
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
@@ -14,6 +15,7 @@ from rest_framework.reverse import reverse
 from wbcore import viewsets
 from wbcore.contrib.currency.models import Currency
 from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.contrib.notifications.dispatch import send_notification_as_task
 from wbcore.pandas import fields as pf
 from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbfdm.models import Instrument
@@ -21,11 +23,11 @@ from wbfdm.models import Instrument
 from wbportfolio.filters import PortfolioFilterSet, PortfolioTreeGraphChartFilterSet
 from wbportfolio.models import (
     AssetPosition,
+    OrderProposal,
     Portfolio,
     PortfolioPortfolioThroughModel,
     Rebalancer,
     RebalancingModel,
-    TradeProposal,
 )
 from wbportfolio.models.portfolio import compute_lookthrough_as_task
 from wbportfolio.serializers import (
@@ -35,6 +37,8 @@ from wbportfolio.serializers import (
 )
 
 from ..models.graphs.portfolio import PortfolioGraph
+from ..models.utils import adjust_quote_as_task
+from ..permissions import IsPortfolioManager
 from .configs import (
     PortfolioButtonConfig,
     PortfolioDisplayConfig,
@@ -77,7 +81,7 @@ class PortfolioModelViewSet(UserPortfolioRequestPermissionMixin, InternalUserPer
         "last_asset_under_management_usd",
         "last_positions",
         "automatic_rebalancer",
-        "last_trade_proposal_date",
+        "last_order_proposal_date",
         "is_manageable",
         "is_tracked",
         "only_weighting",
@@ -111,8 +115,8 @@ class PortfolioModelViewSet(UserPortfolioRequestPermissionMixin, InternalUserPer
                     .annotate(s=Sum("shares"))
                     .values("s")[:1]
                 ),
-                last_trade_proposal_date=Subquery(
-                    TradeProposal.objects.filter(portfolio=OuterRef("pk"))
+                last_order_proposal_date=Subquery(
+                    OrderProposal.objects.filter(portfolio=OuterRef("pk"))
                     .order_by("-trade_date")
                     .values("trade_date")[:1]
                 ),
@@ -123,10 +127,10 @@ class PortfolioModelViewSet(UserPortfolioRequestPermissionMixin, InternalUserPer
     def rebalance(self, request, pk=None):
         if date_str := request.POST.get("trade_date", None):
             trade_date = datetime.strptime(date_str, "%Y-%m-%d")
-            trade_proposal, _ = TradeProposal.objects.get_or_create(portfolio_id=pk, trade_date=trade_date)
-            trade_proposal.reset_trades()
+            order_proposal, _ = OrderProposal.objects.get_or_create(portfolio_id=pk, trade_date=trade_date)
+            order_proposal.reset_orders()
             return Response(
-                {"endpoint": reverse("wbportfolio:tradeproposal-detail", args=[trade_proposal.id], request=request)}
+                {"endpoint": reverse("wbportfolio:orderproposal-detail", args=[order_proposal.id], request=request)}
             )
         raise HttpResponse("Bad Request", status=400)
 
@@ -147,8 +151,8 @@ class PortfolioModelViewSet(UserPortfolioRequestPermissionMixin, InternalUserPer
             activation_date = datetime.strptime(request.POST["activation_date"], "%Y-%m-%d")
             rebalancing_model = get_object_or_404(RebalancingModel, pk=request.POST["rebalancing_model"])
             frequency = request.POST["frequency"]
-            approve_trade_proposal_automatically = (
-                request.POST.get("approve_trade_proposal_automatically", "false") == "true"
+            apply_order_proposal_automatically = (
+                request.POST.get("apply_order_proposal_automatically", "false") == "true"
             )
 
             rebalancer, _ = Rebalancer.objects.update_or_create(
@@ -157,7 +161,7 @@ class PortfolioModelViewSet(UserPortfolioRequestPermissionMixin, InternalUserPer
                     "rebalancing_model": rebalancing_model,
                     "frequency": frequency,
                     "activation_date": activation_date,
-                    "approve_trade_proposal_automatically": approve_trade_proposal_automatically,
+                    "apply_order_proposal_automatically": apply_order_proposal_automatically,
                 },
             )
             return Response(
@@ -178,6 +182,26 @@ class PortfolioModelViewSet(UserPortfolioRequestPermissionMixin, InternalUserPer
 
         return HttpResponse("Bad arguments", status=400)
 
+    @action(detail=False, methods=["POST"], permission_classes=[IsPortfolioManager])
+    def adjustquote(self, request, pk=None):
+        old_quote = get_object_or_404(Instrument, pk=request.POST["old_quote"])
+        new_quote = get_object_or_404(Instrument, pk=request.POST["new_quote"])
+        adjust_after = parse_date(request.data["adjust_after"]) if "adjust_after" in request.data else None
+        only_portfolio_ids = request.data["only_portfolios"].split(",") if "only_portfolios" in request.data else []
+
+        chain(
+            adjust_quote_as_task.si(
+                old_quote.id, new_quote.id, adjust_after=adjust_after, only_portfolio_ids=only_portfolio_ids
+            ),
+            send_notification_as_task.si(
+                "wbportfolio.portfolio.action_done",
+                f"Quote adjustment from {old_quote} to {new_quote} is done",
+                "The associated positions and orders were successfully adjusted",
+                request.user.id,
+            ),
+        ).apply_async()
+        return HttpResponse("Ok", status=200)
+
 
 class PortfolioPortfolioThroughModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
     serializer_class = PortfolioPortfolioThroughModelSerializer
@@ -242,9 +266,9 @@ class TopDownPortfolioCompositionPandasAPIView(UserPortfolioRequestPermissionMix
     @cached_property
     def last_rebalancing_date(self) -> date | None:
         if self.composition_portfolio and self.last_effective_date:
-            with suppress(TradeProposal.DoesNotExist):
+            with suppress(OrderProposal.DoesNotExist):
                 return (
-                    self.composition_portfolio.trade_proposals.filter(trade_date__lte=self.last_effective_date)
+                    self.composition_portfolio.order_proposals.filter(trade_date__lte=self.last_effective_date)
                     .latest("trade_date")
                     .trade_date
                 )

wbportfolio/viewsets/positions.py

@@ -10,7 +10,7 @@ from wbcore.pandas import fields as pf
 from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbcore.serializers import decorator
 from wbcore.utils.strings import format_number
-from wbfdm.models import Classification, ClassificationGroup, Instrument, InstrumentType
+from wbfdm.models import Classification, ClassificationGroup, Instrument
 
 from wbportfolio.filters import (
     AggregatedAssetPositionLiquidityFilter,
@@ -19,6 +19,7 @@ from wbportfolio.filters import (
 from wbportfolio.filters.positions import GroupbyChoice
 from wbportfolio.models import AssetPosition, Portfolio
 
+from ..constants import EQUITY_TYPE_KEYS
 from .configs import (
     AggregatedAssetPositionLiquidityDisplayConfig,
     AggregatedAssetPositionLiquidityEndpointConfig,
@@ -212,7 +213,7 @@ class AggregatedAssetPositionLiquidityPandasView(InternalUserPermissionMixin, Ex
 
         # Take the liquidity query for the two dates.
         qs_assets = queryset.filter(
-            underlying_instrument__instrument_type=InstrumentType.EQUITY,
+            underlying_instrument__instrument_type__key__in=EQUITY_TYPE_KEYS,
             date__in=[historic_date, compared_date],
         ).values(
             "date",

wbportfolio/viewsets/products.py

@@ -317,16 +317,16 @@ class ProductPerformanceFeesModelViewSet(
             if date_lte is None and date_gte is None:
                 date_gte, date_lte = get_start_and_end_date_from_date(date.today())
 
-            fees = Fees.valid_objects.filter(linked_product=OuterRef("pk"))
+            fees = Fees.valid_objects.filter(product=OuterRef("pk"))
             if date_gte:
-                fees = fees.filter(transaction_date__gte=date_gte)
+                fees = fees.filter(fee_date__gte=date_gte)
             if date_lte:
-                fees = fees.filter(transaction_date__lte=date_lte)
+                fees = fees.filter(fee_date__lte=date_lte)
 
             management_fees = Coalesce(
                 Subquery(
                     fees.filter(transaction_subtype=Fees.Type.MANAGEMENT)
-                    .values("linked_product")
+                    .values("product")
                     .annotate(sum_management_fees=Sum("total_value"))
                     .values("sum_management_fees")[:1],
                     output_field=FloatField(),
@@ -340,7 +340,7 @@ class ProductPerformanceFeesModelViewSet(
                         Q(transaction_subtype=Fees.Type.PERFORMANCE)
                         | Q(transaction_subtype=Fees.Type.PERFORMANCE_CRYSTALIZED)
                     )
-                    .values("linked_product")
+                    .values("product")
                     .annotate(sum_performance_fees_net=Sum("total_value"))
                     .values("sum_performance_fees_net")[:1],
                     output_field=FloatField(),
@@ -367,7 +367,7 @@ class ProductPerformanceFeesModelViewSet(
                     sum_total_usd=F("sum_management_fees_usd") + F("sum_performance_fees_net_usd"),
                 )
                 .select_related("currency")
-                .prefetch_related("transactions", "prices")
+                .prefetch_related("fees", "prices")
             )
             return qs
 

wbportfolio/viewsets/{transactions/rebalancing.py → rebalancing.py}

@@ -8,8 +8,8 @@ from wbportfolio.serializers import (
     RebalancingModelRepresentationSerializer,
 )
 
-from ..configs.display import RebalancerDisplayConfig
-from ..configs.endpoints import RebalancerEndpointConfig
+from .configs.display import RebalancerDisplayConfig
+from .configs.endpoints import RebalancerEndpointConfig
 
 
 class RebalancingModelRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):

wbportfolio/viewsets/transactions/__init__.py

@@ -13,16 +13,11 @@ from .claim import (
     ProfitAndLossPandasView,
 )
 from .fees import (
-    FeesAggregatedPortfolioPandasView,
+    FeesAggregatedProductPandasView,
     FeesModelViewSet,
-    FeesPortfolioModelViewSet,
-)
-from .rebalancing import RebalancingModelRepresentationViewSet, RebalancerRepresentationViewSet, RebalancerModelViewSet
-from .trade_proposals import (
-    TradeProposalModelViewSet,
-    TradeProposalPortfolioModelViewSet,
-    TradeProposalRepresentationViewSet,
+    FeesProductModelViewSet,
 )
+
 from .trades import (
     CustodianDistributionInstrumentChartViewSet,
     CustomerDistributionInstrumentChartViewSet,
@@ -32,10 +27,4 @@ from .trades import (
     TradeModelViewSet,
     TradePortfolioModelViewSet,
     TradeRepresentationViewSet,
-    TradeTradeProposalModelViewSet,
-)
-from .transactions import (
-    TransactionModelViewSet,
-    TransactionPortfolioModelViewSet,
-    TransactionRepresentationViewSet,
 )

wbportfolio/viewsets/transactions/fees.py

@@ -8,28 +8,28 @@ from wbcore.pandas import fields as pf
 from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbcore.serializers import decorator
 from wbcore.utils.strings import format_number
+from wbcore.viewsets import ModelViewSet
 
-from wbportfolio.filters import FeesAggregatedFilter, FeesFilter, FeesPortfolioFilterSet
+from wbportfolio.filters import FeesAggregatedFilter, FeesFilter, FeesProductFilterSet
 from wbportfolio.models import Fees
 from wbportfolio.serializers import FeesModelSerializer
 
 from ..configs import (
     FeeEndpointConfig,
-    FeesAggregatedPortfolioPandasDisplayConfig,
-    FeesAggregatedPortfolioPandasEndpointConfig,
-    FeesAggregatedPortfolioTitleConfig,
+    FeesAggregatedProductPandasDisplayConfig,
+    FeesAggregatedProductPandasEndpointConfig,
+    FeesAggregatedProductTitleConfig,
     FeesButtonConfig,
     FeesDisplayConfig,
-    FeesPortfolioDisplayConfig,
-    FeesPortfolioEndpointConfig,
-    FeesPortfolioTitleConfig,
+    FeesProductDisplayConfig,
+    FeesProductEndpointConfig,
+    FeesProductTitleConfig,
     FeesTitleConfig,
 )
 from ..mixins import UserPortfolioRequestPermissionMixin
-from .transactions import TransactionModelViewSet
 
 
-class FeesModelViewSet(TransactionModelViewSet):
+class FeesModelViewSet(UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, ModelViewSet):
     filter_backends = (
         DjangoFilterBackend,
         filters.OrderingFilter,
@@ -56,27 +56,27 @@ class FeesModelViewSet(TransactionModelViewSet):
 
     def get_queryset(self):
         if self.is_manager:
-            return super().get_queryset().select_related("import_source", "linked_product")
+            return super().get_queryset().select_related("import_source", "product")
         return Fees.objects.none()
 
 
-class FeesPortfolioModelViewSet(FeesModelViewSet):
-    IDENTIFIER = "wbportfolio:portfolio-fees"
+class FeesProductModelViewSet(FeesModelViewSet):
+    IDENTIFIER = "wbportfolio:product-fees"
 
-    filterset_class = FeesPortfolioFilterSet
+    filterset_class = FeesProductFilterSet
 
-    display_config_class = FeesPortfolioDisplayConfig
-    title_config_class = FeesPortfolioTitleConfig
-    endpoint_config_class = FeesPortfolioEndpointConfig
+    display_config_class = FeesProductDisplayConfig
+    title_config_class = FeesProductTitleConfig
+    endpoint_config_class = FeesProductEndpointConfig
 
     def get_queryset(self):
         if self.is_portfolio_manager:
-            return super().get_queryset().filter(portfolio=self.portfolio)
+            return super().get_queryset().filter(product=self.product)
 
         return Fees.objects.none()
 
 
-class FeesAggregatedPortfolioPandasView(
+class FeesAggregatedProductPandasView(
     UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, ExportPandasAPIViewSet
 ):
     IDENTIFIER = "wbportfolio:aggregetedfees"
@@ -85,9 +85,9 @@ class FeesAggregatedPortfolioPandasView(
 
     queryset = Fees.valid_objects.all()
 
-    display_config_class = FeesAggregatedPortfolioPandasDisplayConfig
-    title_config_class = FeesAggregatedPortfolioTitleConfig
-    endpoint_config_class = FeesAggregatedPortfolioPandasEndpointConfig
+    display_config_class = FeesAggregatedProductPandasDisplayConfig
+    title_config_class = FeesAggregatedProductTitleConfig
+    endpoint_config_class = FeesAggregatedProductPandasEndpointConfig
 
     pandas_fields = pf.PandasFields(
         fields=(
@@ -153,7 +153,7 @@ class FeesAggregatedPortfolioPandasView(
 
     def get_queryset(self):
         if self.is_portfolio_manager:
-            qs = super().get_queryset().filter(portfolio=self.portfolio)
+            qs = super().get_queryset().filter(product=self.product)
             return qs.annotate(
                 currency_fx_rate_usd=CurrencyFXRates.get_fx_rates_subquery(
                     "fee_date", currency="currency", lookup_expr="exact"