wbportfolio 1.52.0__py2.py3-none-any.whl → 1.52.2rc0__py2.py3-none-any.whl

wbportfolio/admin/__init__.py

@@ -8,5 +8,5 @@ from .product_groups import ProductGroupAdmin
 from .portfolio import PortfolioModelAdmin
 from .registers import RegisterModelAdmin
 from .roles import PortfolioRoleAdmin
-from .transactions import DividendAdmin, FeesAdmin, TradeAdmin, TransactionModelAdmin
+from .transactions import DividendAdmin, FeesAdmin, TradeAdmin
 from .reconciliations import AccountReconciliationAdmin

wbportfolio/admin/transactions/__init__.py

@@ -1,4 +1,3 @@
-from .transactions import TransactionModelAdmin  # isort:skip
 from .claim import ClaimModelAdmin
 from .dividends import DividendAdmin
 from .fees import FeesAdmin

wbportfolio/admin/transactions/dividends.py

@@ -1,15 +1,51 @@
 from django.contrib import admin
 
-from wbportfolio.admin.transactions import TransactionModelAdmin
 from wbportfolio.models import DividendTransaction
 
 
 @admin.register(DividendTransaction)
-class DividendAdmin(TransactionModelAdmin):
+class DividendAdmin(admin.ModelAdmin):
+    search_fields = ["portfolio__name", "underlying_instrument__computed_str"]
+    list_filter = ("distribution_method", "portfolio")
+    list_display = (
+        "distribution_method",
+        "portfolio",
+        "underlying_instrument",
+        "value_date",
+        "currency",
+        "currency_fx_rate",
+        "total_value",
+        "total_value_fx_portfolio",
+    )
     fieldsets = (
-        ("Transactions Information", TransactionModelAdmin.fieldsets[0][1]),
         (
             "Dividend Information",
-            {"fields": (("retrocession",),)},
+            {
+                "fields": (
+                    (
+                        "portfolio",
+                        "underlying_instrument",
+                        "import_source",
+                    ),
+                    ("ex_date", "record_date", "value_date"),
+                    ("currency", "currency_fx_rate"),
+                    ("price", "shares", "retrocession"),
+                    ("total_value", "total_value_gross"),
+                    ("total_value_fx_portfolio", "total_value_gross_fx_portfolio"),
+                    ("created", "updated"),
+                    ("comment",),
+                )
+            },
         ),
     )
+    readonly_fields = [
+        "total_value",
+        "total_value_gross",
+        "total_value_fx_portfolio",
+        "total_value_gross_fx_portfolio",
+        "created",
+        "updated",
+    ]
+    autocomplete_fields = ["portfolio", "underlying_instrument", "currency"]
+    ordering = ("-value_date",)
+    raw_id_fields = ["import_source"]

wbportfolio/admin/transactions/fees.py

@@ -1,27 +1,36 @@
 from django.contrib import admin
-from django.db.models import Prefetch
 
-from wbportfolio.admin.transactions import TransactionModelAdmin
-from wbportfolio.models import Fees, Portfolio
+from wbportfolio.models import Fees
 from wbportfolio.models.transactions.fees import FeeCalculation
 
 
 @admin.register(Fees)
-class FeesAdmin(TransactionModelAdmin):
-    list_filter = [*TransactionModelAdmin.list_filter, "linked_product"]
-    list_display = ["transaction_subtype", *TransactionModelAdmin.list_display[1:], "calculated"]
+class FeesAdmin(admin.ModelAdmin):
+    list_filter = ["product"]
+    list_display = [
+        "transaction_subtype",
+        "fee_date",
+        "product",
+        "currency",
+        "total_value",
+    ]
     fieldsets = (
-        ("Transaction Information", TransactionModelAdmin.fieldsets[0][1]),
-        ("Fees Information", {"fields": (("transaction_subtype", "calculated", "linked_product"),)}),
+        (
+            "Fees Information",
+            {
+                "fields": (
+                    ("transaction_subtype", "calculated", "fee_date", "product"),
+                    ("currency", "currency_fx_rate"),
+                    ("total_value", "total_value_fx_portfolio"),
+                    ("created", "updated"),
+                )
+            },
+        ),
     )
-    autocomplete_fields = [*TransactionModelAdmin.autocomplete_fields, "linked_product"]
+    autocomplete_fields = ["currency", "product"]
 
     def get_queryset(self, request):
-        return (
-            super()
-            .get_queryset(request)
-            .prefetch_related(Prefetch("portfolio", queryset=Portfolio.objects.all().only("id", "name")))
-        )
+        return super().get_queryset(request).select_related("product", "currency")
 
     def calculate(self, request, queryset):
         for fees in queryset:
@@ -29,6 +38,7 @@ class FeesAdmin(TransactionModelAdmin):
 
     calculate.short_description = "Recalculate selected Fees"
     actions = [calculate]
+    readonly_fields = ["total_value_fx_portfolio", "created", "updated"]
 
 
 @admin.register(FeeCalculation)

wbportfolio/admin/transactions/trades.py

@@ -1,45 +1,67 @@
 from django.contrib import admin
 
-from wbportfolio.admin.transactions import TransactionModelAdmin
 from wbportfolio.models import Trade, TradeProposal
 
 
 @admin.register(Trade)
-class TradeAdmin(TransactionModelAdmin):
-    search_fields = [*TransactionModelAdmin.search_fields, "bank"]
-    list_filter = (*TransactionModelAdmin.list_filter, "pending")
+class TradeAdmin(admin.ModelAdmin):
+    search_fields = ["portfolio__name", "underlying_instrument__computed_str", "bank"]
+    list_filter = ("portfolio", "pending")
     list_display = (
-        "transaction_subtype",
         "status",
+        "transaction_subtype",
+        "transaction_date",
+        "underlying_instrument",
+        "portfolio",
         "shares",
         "price",
+        "total_value",
         "pending",
         "marked_for_deletion",
         "exclude_from_history",
-        *TransactionModelAdmin.list_display[1:],
+        "import_source",
     )
+
     readonly_fields = [
         "_effective_weight",
         "_target_weight",
         "_effective_shares",
         "_target_shares",
+        "total_value",
+        "total_value_gross",
+        "total_value_fx_portfolio",
+        "total_value_gross_fx_portfolio",
+        "created",
+        "updated",
     ]
     fieldsets = (
-        ("Transaction Information", TransactionModelAdmin.fieldsets[0][1]),
         (
-            "Trade Information",
+            "Transaction Information",
             {
                 "fields": (
-                    ("transaction_subtype", "status", "pending", "marked_for_deletion", "exclude_from_history"),
-                    ("price", "price_gross"),
-                    ("register", "custodian", "bank", "external_identifier2"),
+                    ("transaction_subtype", "status"),
+                    ("pending", "marked_for_deletion", "exclude_from_history"),
+                    (
+                        "portfolio",
+                        "underlying_instrument",
+                        "import_source",
+                    ),
+                    ("transaction_date", "book_date", "value_date"),
+                    ("price", "currency", "currency_fx_rate"),
+                    ("total_value", "total_value_gross"),
+                    ("total_value_fx_portfolio", "total_value_gross_fx_portfolio"),
                     ("_effective_weight", "_target_weight", "weighting"),
                     ("_effective_shares", "_target_shares", "shares"),
+                    ("register", "custodian", "bank", "external_id", "external_id_alternative"),
+                    ("created", "updated"),
+                    ("comment",),
                 )
             },
         ),
     )
-    autocomplete_fields = [*TransactionModelAdmin.autocomplete_fields, "register", "custodian"]
+    autocomplete_fields = ["portfolio", "underlying_instrument", "currency", "register", "custodian"]
+    ordering = ("-transaction_date",)
+    raw_id_fields = ["import_source", "underlying_instrument", "portfolio", "register", "custodian"]
 
 
 @admin.register(TradeProposal)

wbportfolio/defaults/fees/default.py

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

wbportfolio/factories/__init__.py

@@ -22,6 +22,5 @@ from .products import IndexProductFactory, ProductFactory, WhiteLabelProductFact
 from .reconciliations import AccountReconciliationFactory, AccountReconciliationLineFactory
 from .roles import ManagerPortfolioRoleFactory, ProductPortfolioRoleFactory
 from .trades import CustomerTradeFactory, TradeFactory, TradeProposalFactory
-from .transactions import TransactionFactory
 from .indexes import IndexFactory
 from .rebalancing import (RebalancingModelFactory, RebalancerFactory)

wbportfolio/factories/dividends.py

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

wbportfolio/factories/fees.py

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

wbportfolio/factories/trades.py

@@ -1,4 +1,6 @@
 import random
+from datetime import timedelta
+from decimal import Decimal
 
 import factory
 from faker import Faker
@@ -6,15 +8,20 @@ from pandas._libs.tslibs.offsets import BDay
 
 from wbportfolio.models import Trade, TradeProposal
 
-from .transactions import TransactionFactory
-
 fake = Faker()
 
 
-class TradeFactory(TransactionFactory):
+class TradeFactory(factory.django.DjangoModelFactory):
     class Meta:
         model = Trade
 
+    currency_fx_rate = Decimal(1.0)
+    fees = Decimal(0.0)
+    portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
+    underlying_instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+    transaction_date = factory.Faker("date_object")
+    value_date = factory.LazyAttribute(lambda o: o.transaction_date + timedelta(days=1))
     bank = factory.Faker("company")
     marked_for_deletion = False
     shares = factory.Faker("pydecimal", min_value=10, max_value=1000, right_digits=4)

wbportfolio/filters/transactions/__init__.py

@@ -10,7 +10,7 @@ from .claim import (
     NegativeTermimalAccountPerProductFilterSet,
     ProfitAndLossPandasFilter,
 )
-from .fees import FeesAggregatedFilter, FeesFilter, FeesPortfolioFilterSet
+from .fees import FeesAggregatedFilter, FeesFilter, FeesProductFilterSet
 from .trades import (
     SubscriptionRedemptionFilterSet,
     SubscriptionRedemptionPortfolioFilterSet,
@@ -18,4 +18,3 @@ from .trades import (
     TradeInstrumentFilterSet,
     TradePortfolioFilter,
 )
-from .transactions import TransactionFilterSet, TransactionPortfolioFilterSet

wbportfolio/filters/transactions/fees.py

@@ -4,10 +4,10 @@ from wbcore.pandas.filterset import PandasFilterSetMixin
 
 from wbportfolio.models import Fees
 
-from .transactions import TransactionFilterSet, get_transaction_default_date_range
+from .utils import get_transaction_default_date_range
 
 
-class FeesFilter(TransactionFilterSet):
+class FeesFilter(wb_filters.FilterSet):
     """FilterSet for Fees
 
     Currently filters:
@@ -21,23 +21,20 @@ class FeesFilter(TransactionFilterSet):
         initial=get_transaction_default_date_range,
         required=True,
     )
-    total_value_usd__gte = total_value_usd__lte = transaction_underlying_type = transaction_date = None
 
     class Meta:
         model = Fees
         fields = {
             "transaction_subtype": ["exact"],
             "currency_fx_rate": ["gte", "exact", "lte"],
-            "portfolio": ["exact"],
+            "product": ["exact"],
             "currency": ["exact"],
             "total_value": ["gte", "exact", "lte"],
             "total_value_fx_portfolio": ["gte", "exact", "lte"],
-            "total_value_gross": ["gte", "exact", "lte"],
-            "total_value_gross_fx_portfolio": ["gte", "exact", "lte"],
         }
 
 
-class FeesPortfolioFilterSet(FeesFilter):
+class FeesProductFilterSet(FeesFilter):
     portfolio = None
 
     class Meta:
@@ -49,13 +46,11 @@ class FeesPortfolioFilterSet(FeesFilter):
             "currency": ["exact"],
             "total_value": ["gte", "exact", "lte"],
             "total_value_fx_portfolio": ["gte", "exact", "lte"],
-            "total_value_gross": ["gte", "exact", "lte"],
-            "total_value_gross_fx_portfolio": ["gte", "exact", "lte"],
         }
 
 
 class FeesAggregatedFilter(PandasFilterSetMixin, wb_filters.FilterSet):
-    transaction_date = wb_filters.DateRangeFilter(
+    fee_date = wb_filters.DateRangeFilter(
         label="Date Range",
         method=wb_filters.DateRangeFilter.base_date_range_filter_method,
         required=True,

wbportfolio/filters/transactions/trades.py

@@ -5,14 +5,28 @@ from wbcore import filters as wb_filters
 from wbcrm.models.accounts import Account
 from wbfdm.models import Classification, Instrument
 
-from wbportfolio.models import Product, Trade
+from wbportfolio.models import Portfolio, Product, Trade
 from wbportfolio.models.transactions.claim import Claim
 
 from .mixins import OppositeSharesFieldMethodMixin
-from .transactions import TransactionFilterSet
+from .utils import get_transaction_default_date_range
 
 
-class TradeFilter(OppositeSharesFieldMethodMixin, TransactionFilterSet):
+class TradeFilter(OppositeSharesFieldMethodMixin, wb_filters.FilterSet):
+    transaction_date = wb_filters.DateRangeFilter(
+        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
+        label="Date Range",
+        initial=get_transaction_default_date_range,
+    )
+
+    portfolio = wb_filters.ModelChoiceFilter(
+        label="Portfolio",
+        queryset=Portfolio.objects.all(),
+        endpoint=Portfolio.get_representation_endpoint(),
+        value_key=Portfolio.get_representation_value_key(),
+        label_key=Portfolio.get_representation_label_key(),
+    )
+
     # we have to redefine the mixin fields because django_filters does not allow class extension with mixin
     opposite_shares = wb_filters.NumberFilter(
         field_name="shares",
@@ -28,10 +42,6 @@ class TradeFilter(OppositeSharesFieldMethodMixin, TransactionFilterSet):
         lookup_icon="≈±",
         lookup_label="Opposite Approximate (+- 10%)",
     )
-    transaction_date = wb_filters.DateRangeFilter(
-        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
-        label="Date Range",
-    )
     underlying_instrument = wb_filters.ModelChoiceFilter(
         label="Instrument",
         queryset=Instrument.objects.all(),
@@ -69,7 +79,6 @@ class TradeFilter(OppositeSharesFieldMethodMixin, TransactionFilterSet):
     #     value_key=Register.get_representation_value_key(),
     #     label_key = Register.get_representation_label_key(),
     # )
-    total_value_usd__gte = total_value_usd__lte = transaction_underlying_type = None
     marked_for_deletion = wb_filters.BooleanFilter(
         label="Marked For Deletion", initial=False, field_name="marked_for_deletion", lookup_expr="exact"
     )

wbportfolio/filters/transactions/utils.py

@@ -0,0 +1,42 @@
+from datetime import date, timedelta
+
+from psycopg.types.range import DateRange
+
+from wbportfolio.models import Fees, Trade
+
+
+def get_transaction_gte_default(field, request, view):
+    filter_date = date.today() - timedelta(days=90)
+    qs = Trade.objects.none()
+    if "instrument_id" in view.kwargs:
+        qs = Trade.objects.filter(underlying_instrument__id=view.kwargs["instrument_id"])
+    elif "portfolio_id" in view.kwargs:
+        qs = Trade.objects.filter(portfolio__id=view.kwargs["portfolio_id"])
+    if qs.exists():
+        filter_date = qs.earliest("transaction_date").transaction_date
+    return filter_date
+
+
+def get_transaction_underlying_type_choices(*args):
+    models = [Fees, Trade]
+    choices = []
+    for model in models:
+        for choice in model.Type.choices:
+            choices.append(choice)
+    return choices
+
+
+def get_transaction_lte_default(field, request, view):
+    filter_date = date.today() + timedelta(days=7)
+    qs = Trade.objects.none()
+    if "instrument_id" in view.kwargs:
+        qs = Trade.objects.filter(underlying_instrument__id=view.kwargs["instrument_id"])
+    elif "portfolio_id" in view.kwargs:
+        qs = Trade.objects.filter(portfolio__id=view.kwargs["portfolio_id"])
+    if qs.exists():
+        filter_date = qs.latest("transaction_date").transaction_date
+    return filter_date
+
+
+def get_transaction_default_date_range(*args, **kwargs):
+    return DateRange(get_transaction_gte_default(*args, **kwargs), get_transaction_lte_default(*args, **kwargs))

wbportfolio/import_export/handlers/dividend.py

@@ -19,7 +19,7 @@ class DividendImportHandler(ImportExportHandler):
         self.currency_handler = CurrencyImportHandler(self.import_source)
 
     def _deserialize(self, data):
-        data["transaction_date"] = datetime.strptime(data["transaction_date"], "%Y-%m-%d").date()
+        data["ex_date"] = datetime.strptime(data["ex_date"], "%Y-%m-%d").date()
         data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
         from wbportfolio.models import Portfolio
 
@@ -42,12 +42,12 @@ class DividendImportHandler(ImportExportHandler):
 
     def _get_instance(self, data, history=None, **kwargs):
         self.import_source.log += "\nGet DividendTransaction Instance."
-        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Underlying={data['underlying_instrument']} Date={data['transaction_date']}"
+        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Underlying={data['underlying_instrument']} Date={data['ex_date']}"
         dividends = history if history is not None else self.model.objects
 
         dividends = dividends.filter(
             portfolio=data["portfolio"],
-            transaction_date=data["transaction_date"],
+            ex_date=data["ex_date"],
             value_date=data["value_date"],
             underlying_instrument=data["underlying_instrument"],
             price_gross=data["price_gross"],
@@ -63,10 +63,10 @@ class DividendImportHandler(ImportExportHandler):
     def _get_history(self: models.Model, history: Dict[str, Any]) -> models.QuerySet:
         from wbportfolio.models import Product
 
-        val_date = datetime.strptime(history["transaction_date"], "%Y-%m-%d")
+        val_date = datetime.strptime(history["value_date"], "%Y-%m-%d")
         try:
             product = Product.objects.get(**history.get("product", {}))
-            dividends = self.model.objects.filter(transaction_date__lte=val_date, portfolio=product.primary_portfolio)
+            dividends = self.model.objects.filter(ex_date__lte=val_date, portfolio=product.primary_portfolio)
             if underlying_instrument_data := history.get("underlying_instrument"):
                 if isinstance(underlying_instrument_data, dict):
                     dividends = dividends.filter(
@@ -83,8 +83,8 @@ class DividendImportHandler(ImportExportHandler):
         self.import_source.log += (
             "It was a historical import and the following DividendTransaction have to be deleted:"
         )
-        for dividend in history.order_by("transaction_date"):
+        for dividend in history.order_by("value_date"):
             self.import_source.log += (
-                f"\n{dividend.transaction_date:%d.%m.%Y}: {dividend.shares} {dividend.price} ==> Deleted"
+                f"\n{dividend.value_date:%d.%m.%Y}: {dividend.shares} {dividend.price} ==> Deleted"
             )
             dividend.delete()

wbportfolio/import_export/handlers/fees.py

@@ -3,7 +3,6 @@ from datetime import datetime
 from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
 from wbcore.contrib.io.exceptions import DeserializationError
 from wbcore.contrib.io.imports import ImportExportHandler
-from wbfdm.models.instruments import Cash
 
 
 class FeesImportHandler(ImportExportHandler):
@@ -14,31 +13,22 @@ class FeesImportHandler(ImportExportHandler):
         self.currency_handler = CurrencyImportHandler(self.import_source)
 
     def _deserialize(self, data):
-        data["transaction_date"] = datetime.strptime(data["transaction_date"], "%Y-%m-%d").date()
-        data["fee_date"] = data["transaction_date"]
-        if value_date_str := data.get("value_date", None):
-            data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
-        if book_date_str := data.get("book_date", None):
-            data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
-
-        from wbportfolio.models import Portfolio, Product
+        data["fee_date"] = datetime.strptime(
+            data.get("fee_date", data.pop("transaction_date", None)), "%Y-%m-%d"
+        ).date()
+        from wbportfolio.models import Product
 
         try:
-            linked_product_data = data.pop("linked_product", None)
-            if isinstance(linked_product_data, dict):
-                data["linked_product"] = Product.objects.get(**linked_product_data)
+            product_data = data.pop("product", None)
+            if isinstance(product_data, dict):
+                data["product"] = Product.objects.get(**product_data)
             else:
-                data["linked_product"] = Product.objects.get(id=linked_product_data)
+                data["product"] = Product.objects.get(id=product_data)
         except Product.DoesNotExist:
             raise DeserializationError("There is no valid linked product for in this row.")
 
-        if "porfolio" in data:
-            data["portfolio"] = Portfolio.all_objects.get(id=data["portfolio"])
-        else:
-            data["portfolio"] = data["linked_product"].primary_portfolio
-        data["underlying_instrument"] = Cash.objects.filter(currency=data["portfolio"].currency).first()
         if "currency" not in data:
-            data["currency"] = data["portfolio"].currency
+            data["currency"] = data["product"].currency
         else:
             data["currency"] = self.currency_handler.process_object(data["currency"], read_only=True)[0]
         data["currency_fx_rate"] = 1.0
@@ -48,9 +38,9 @@ class FeesImportHandler(ImportExportHandler):
 
     def _get_instance(self, data, history=None, **kwargs):
         self.import_source.log += "\nGet Fees Instance."
-        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Date={data['transaction_date']}"
+        self.import_source.log += f"\nParameter: Product={data['product']} Date={data['fee_date']}"
         fees = self.model.objects.filter(
-            linked_product=data["linked_product"],
+            product=data["product"],
             fee_date=data["fee_date"],
             transaction_subtype=data["transaction_subtype"],
             calculated=data["calculated"],