fx-shared-models 0.2.6__tar.gz → 0.2.7__tar.gz

{fx_shared_models-0.2.6/fx_shared_models.egg-info → fx_shared_models-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fx-shared-models
-Version: 0.2.6
+Version: 0.2.7
 Summary: Shared models for FX Backend
 Home-page: https://github.com/fxbackend/fx-shared-models
 Author: FX Backend

{fx_shared_models-0.2.6 → fx_shared_models-0.2.7/fx_shared_models.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fx-shared-models
-Version: 0.2.6
+Version: 0.2.7
 Summary: Shared models for FX Backend
 Home-page: https://github.com/fxbackend/fx-shared-models
 Author: FX Backend

{fx_shared_models-0.2.6 → fx_shared_models-0.2.7}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_namespace_packages
 
 setup(
     name='fx-shared-models',
-    version='0.2.6',
+    version='0.2.7',
     packages=find_namespace_packages(include=['shared_models*']),
     install_requires=[
         'Django>=3.0',

{fx_shared_models-0.2.6 → fx_shared_models-0.2.7}/shared_models/__init__.py

@@ -3,4 +3,4 @@ Shared models package for FX Backend
 Contains Customer, System Settings, and IB Commission models
 """
 
-__version__ = '0.2.6'  
+__version__ = '0.2.7'  

{fx_shared_models-0.2.6 → fx_shared_models-0.2.7}/shared_models/ib_commission/services/commission_calculator_service.py

@@ -71,14 +71,6 @@ class CommissionCalculatorService:
         # Get customer from account
         customer = account.customer
         
-        # Find mapping for this customer
-        client_mapping = ClientIBMapping.objects.filter(
-            customer=customer
-        ).first()
-        
-        if not client_mapping:
-            return {'distributions': [], 'client_deduction': 0, 'client_server_id': None, 'is_processed': False}
-        
         # Determine which rules to apply based on entry type
         is_entry = entry in [cls.ENTRY_IN, cls.ENTRY_INOUT]  # Entry or InOut
         is_exit = entry in [cls.ENTRY_OUT, cls.ENTRY_OUT_BY]  # Exit or OutBy
@@ -88,16 +80,25 @@ class CommissionCalculatorService:
         if is_exit:
             rule_filter = {'commission_type': cls.REBATE_TYPE}
         
-        # Find applicable rules
+        # Find applicable rules - this will also find the client mapping
         applicable_rules = cls._find_applicable_rules(
-            client_mapping.direct_ib_customer_id, 
-            mt5_login,
-            symbol, 
-            order_type,
+            ib_id=None,  # Will be determined in _find_applicable_rules
+            mt5_account_id=mt5_login,
+            symbol=symbol, 
+            order_type=order_type,
+            customer=customer,
+            account=account,
             **rule_filter
         )
         
-        if not applicable_rules:
+        if not applicable_rules or not applicable_rules.get('rules'):
+            return {'distributions': [], 'client_deduction': 0, 'client_server_id': None, 'is_processed': False}
+        
+        # Get the client mapping and rules from the result
+        client_mapping = applicable_rules.get('client_mapping')
+        rules = applicable_rules.get('rules')
+        
+        if not client_mapping:
             return {'distributions': [], 'client_deduction': 0, 'client_server_id': None, 'is_processed': False}
         
         distributions = []
@@ -112,7 +113,7 @@ class CommissionCalculatorService:
                 client_account=account,
                 mt5_login=mt5_login,
                 commission_type=cls.COMMISSION_TYPE if is_entry else cls.REBATE_TYPE,
-                rule=applicable_rules[0],  # Use first rule for tracking
+                rule=rules[0],  # Use first rule for tracking
                 amount=Decimal('0.0'),  # Will be updated after calculation
                 processed_time=datetime.now(),
                 trade_open_time=datetime.now(),  # Should be from deal data
@@ -272,14 +273,18 @@ class CommissionCalculatorService:
             if is_exit:
                 rule_filter = {'commission_type': cls.REBATE_TYPE}
                 
-            applicable_rules = cls._find_applicable_rules(
+            result = cls._find_applicable_rules(
                 ib_id=ib_id,
                 mt5_account_id=client_mapping.mt5_login,
                 symbol='*',
                 order_type='*',
+                customer=client_mapping.customer,
+                account=client_mapping.account,
                 **rule_filter
             )
             
+            applicable_rules = result.get('rules', [])
+            
             for rule in applicable_rules:
                 # Calculate base amount from rule
                 base_amount = cls._calculate_amount_from_rule(
@@ -410,76 +415,114 @@ class CommissionCalculatorService:
         return amount
     
     @classmethod
-    def _find_applicable_rules(cls, ib_id, mt5_account_id, symbol, order_type, **kwargs):
+    def _find_applicable_rules(cls, ib_id, mt5_account_id, symbol, order_type, customer=None, account=None, **kwargs):
         """
         Find applicable commission rules for a given deal.
         
         Args:
-            ib_id: The IB ID
+            ib_id: The IB ID (can be None, will be determined from client mapping)
             mt5_account_id: The MT5 account ID
             symbol: The trading symbol
             order_type: The order type
+            customer: The customer who made the trade
+            account: The account used for the trade
             **kwargs: Additional filters for rules (e.g., commission_type='REBATE')
             
         Returns:
-            A list of applicable rules
+            Dictionary containing:
+            - rules: A list of applicable rules
+            - client_mapping: The client mapping used to find the rules
         """
-        # Find all active agreements for this IB
-        ib_agreements = IBAgreementMember.objects.filter(
-            customer_id=ib_id,
-            agreement__is_active=True
-        ).values_list('agreement_id', flat=True)
+        client_mapping = None
+        
+        # PRIORITY 1: Find client mapping with account and mt5_login
+        if mt5_account_id:
+            # Try to find account-specific mapping first
+            client_mapping = ClientIBMapping.objects.filter(
+                mt5_login=mt5_account_id,
+                is_active=True
+            ).first()
+        
+        # PRIORITY 2: If no account-specific mapping, try to find customer mapping
+        if not client_mapping and customer:
+            client_mapping = ClientIBMapping.objects.filter(
+                customer=customer,
+                is_active=True
+            ).first()
         
-        # Find account agreements for the MT5 account (specific override)
-        # Check both the mt5_login field and account.mt5_login
+        # If no client mapping found, return empty result
+        if not client_mapping:
+            return {
+                'rules': [],
+                'client_mapping': None
+            }
+        
+        # Get the IB ID from the client mapping if not provided
+        if not ib_id:
+            ib_id = client_mapping.direct_ib_customer_id
+        
+        # PRIORITY 1: Check for account-specific agreement overrides
         account_agreements = IBAccountAgreement.objects.filter(
-            models.Q(mt5_login=mt5_account_id) | 
-            models.Q(account__login=mt5_account_id),
-            agreement_id__in=ib_agreements,
+            mt5_login=mt5_account_id,
+            ib_customer_id=ib_id,
             is_active=True
         ).values_list('agreement_id', flat=True)
         
-        # If no specific account agreements exist, use the client-IB mapping agreement
-        if not account_agreements:
-            # Try to find a mapping to see if there's a specific agreement for this client
-            client_mapping = ClientIBMapping.objects.filter(
-                models.Q(mt5_login=mt5_account_id) |
-                models.Q(account__login=mt5_account_id),
-                direct_ib_customer_id=ib_id
-            ).first()
+        # If account-specific agreements exist, use those
+        if account_agreements:
+            # Find rules matching the criteria from account-specific agreements
+            rules_query = IBCommissionRule.objects.filter(
+                agreement_id__in=account_agreements,
+                is_active=True
+            ).filter(
+                models.Q(symbol__iexact=symbol) | models.Q(symbol='*')
+            ).filter(
+                models.Q(order_type__iexact=order_type) | models.Q(order_type='*')
+            )
             
-            if not client_mapping:
-                return []
+            # Apply additional filters if provided
+            if kwargs:
+                rules_query = rules_query.filter(**kwargs)
             
-            # If client mapping has a specific agreement, use that
-            if client_mapping.agreement_id:
-                account_agreements = [client_mapping.agreement_id]
-            else:
-                # Otherwise, use all of the IB's agreements
-                account_agreements = ib_agreements
+            # Order by priority
+            rules = rules_query.order_by('priority')
             
-            # If still no applicable agreements, return empty list
-            if not account_agreements:
-                return []
-        
-        # Find rules matching the criteria
-        rules_query = IBCommissionRule.objects.filter(
-            agreement_id__in=account_agreements,
-            is_active=True
-        ).filter(
-            models.Q(symbol__iexact=symbol) | models.Q(symbol='*')
-        ).filter(
-            models.Q(order_type__iexact=order_type) | models.Q(order_type='*')
-        )
-        
-        # Apply additional filters if provided
-        if kwargs:
-            rules_query = rules_query.filter(**kwargs)
-        
-        # Order by priority
-        rules = rules_query.order_by('priority')
+            if rules:
+                return {
+                    'rules': list(rules),
+                    'client_mapping': client_mapping
+                }
+        
+        # If client mapping exists and has a specific agreement, use that
+        if client_mapping and client_mapping.agreement_id:
+            # Find rules matching the criteria from the client mapping agreement
+            rules_query = IBCommissionRule.objects.filter(
+                agreement_id=client_mapping.agreement_id,
+                is_active=True
+            ).filter(
+                models.Q(symbol__iexact=symbol) | models.Q(symbol='*')
+            ).filter(
+                models.Q(order_type__iexact=order_type) | models.Q(order_type='*')
+            )
+            
+            # Apply additional filters if provided
+            if kwargs:
+                rules_query = rules_query.filter(**kwargs)
+            
+            # Order by priority
+            rules = rules_query.order_by('priority')
+            
+            if rules:
+                return {
+                    'rules': list(rules),
+                    'client_mapping': client_mapping
+                }
         
-        return list(rules)
+        # If we get here, no applicable rules were found
+        return {
+            'rules': [],
+            'client_mapping': client_mapping
+        }
     
     @classmethod
     def _calculate_client_deduction(cls, distributions):