add support for skipped expenses api (#118)

apps/fyle/helpers.py

@@ -1,14 +1,105 @@
 import json
 import requests
+from typing import List
 from django.conf import settings
+from django.db.models import Q
 
 from fyle_integrations_platform_connector import PlatformConnector
 
 from apps.workspaces.models import FyleCredential, ExportSetting
 from apps.accounting_exports.models import AccountingExport
+from apps.fyle.models import ExpenseFilter
 from apps.fyle.constants import DEFAULT_FYLE_CONDITIONS
 
 
+def construct_expense_filter(expense_filter):
+    constructed_expense_filter = {}
+    # If the expense filter is a custom field
+    if expense_filter.is_custom:
+        # If the operator is not isnull
+        if expense_filter.operator != 'isnull':
+            # If the custom field is of type SELECT and the operator is not_in
+            if expense_filter.custom_field_type == 'SELECT' and expense_filter.operator == 'not_in':
+                # Construct the filter for the custom property
+                filter1 = {
+                    f'custom_properties__{expense_filter.condition}__in': expense_filter.values
+                }
+                # Invert the filter using the ~Q operator and assign it to the constructed expense filter
+                constructed_expense_filter = ~Q(**filter1)
+            else:
+                # If the custom field is of type NUMBER, convert the values to integers
+                if expense_filter.custom_field_type == 'NUMBER':
+                    expense_filter.values = [int(value) for value in expense_filter.values]
+                # If the expense filter is a custom field and the operator is yes or no(checkbox)
+                if expense_filter.custom_field_type == 'BOOLEAN':
+                    expense_filter.values[0] = True if expense_filter.values[0] == 'true' else False
+                # Construct the filter for the custom property
+                filter1 = {
+                    f'custom_properties__{expense_filter.condition}__{expense_filter.operator}':
+                        expense_filter.values[0] if len(expense_filter.values) == 1 and expense_filter.operator != 'in'
+                        else expense_filter.values
+                }
+                # Assign the constructed filter to the constructed expense filter
+                constructed_expense_filter = Q(**filter1)
+
+        # If the expense filter is a custom field and the operator is isnull
+        elif expense_filter.operator == 'isnull':
+            # Determine the value for the isnull filter based on the first value in the values list
+            expense_filter_value: bool = True if expense_filter.values[0].lower() == 'true' else False
+            # Construct the isnull filter for the custom property
+            filter1 = {
+                f'custom_properties__{expense_filter.condition}__isnull': expense_filter_value
+            }
+            # Construct the exact filter for the custom property
+            filter2 = {
+                f'custom_properties__{expense_filter.condition}__exact': None
+            }
+            if expense_filter_value:
+                # If the isnull filter value is True, combine the two filters using the | operator and assign it to the constructed expense filter
+                constructed_expense_filter = Q(**filter1) | Q(**filter2)
+            else:
+                # If the isnull filter value is False, invert the exact filter using the ~Q operator and assign it to the constructed expense filter
+                constructed_expense_filter = ~Q(**filter2)
+
+    # For all non-custom fields
+    else:
+        # Construct the filter for the non-custom field
+        filter1 = {
+            f'{expense_filter.condition}__{expense_filter.operator}':
+                expense_filter.values[0] if len(expense_filter.values) == 1 and expense_filter.operator != 'in'
+                else expense_filter.values
+        }
+        # Assign the constructed filter to the constructed expense filter
+        constructed_expense_filter = Q(**filter1)
+
+    # Return the constructed expense filter
+    return constructed_expense_filter
+
+
+def construct_expense_filter_query(expense_filters: List[ExpenseFilter]):
+    final_filter = None
+    join_by = None
+
+    for expense_filter in expense_filters:
+        constructed_expense_filter = construct_expense_filter(expense_filter)
+
+        # If this is the first filter, set it as the final filter
+        if expense_filter.rank == 1:
+            final_filter = (constructed_expense_filter)
+
+        # If join by is AND, OR
+        elif expense_filter.rank != 1:
+            if join_by == 'AND':
+                final_filter = final_filter & (constructed_expense_filter)
+            else:
+                final_filter = final_filter | (constructed_expense_filter)
+
+        # Set the join type for the additonal filter
+        join_by = expense_filter.join_by
+
+    return final_filter
+
+
 def post_request(url, body, refresh_token=None):
     """
     Create a HTTP post request.

apps/fyle/migrations/0002_expense_is_skipped.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1.2 on 2023-12-18 05:26
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('fyle', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='expense',
+            name='is_skipped',
+            field=models.BooleanField(default=False, help_text='Expense is skipped or not', null=True),
+        ),
+    ]

apps/fyle/models.py

@@ -99,6 +99,7 @@ class Expense(BaseForeignWorkspaceModel):
     spent_at = CustomDateTimeField(help_text='Expense spent at')
     approved_at = CustomDateTimeField(help_text='Expense approved at')
     posted_at = CustomDateTimeField(help_text='Date when the money is taken from the bank')
+    is_skipped = models.BooleanField(null=True, default=False, help_text='Expense is skipped or not')
     expense_created_at = CustomDateTimeField(help_text='Expense created at')
     expense_updated_at = CustomDateTimeField(help_text='Expense created at')
     fund_source = StringNotNullField(help_text='Expense fund source')

apps/fyle/tasks.py

@@ -12,7 +12,8 @@
 
 from apps.accounting_exports.models import AccountingExport
 from apps.workspaces.models import ExportSetting, Workspace, FyleCredential
-from apps.fyle.models import Expense
+from apps.fyle.models import Expense, ExpenseFilter
+from apps.fyle.helpers import construct_expense_filter_query
 from apps.fyle.exceptions import handle_exceptions
 
 SOURCE_ACCOUNT_MAP = {
@@ -24,6 +25,31 @@
 logger.level = logging.INFO
 
 
+def get_filtered_expenses(workspace: int, expense_objects: list, expense_filters: list):
+    """
+    function to get filtered expense objects
+    """
+
+    expenses_object_ids = [expense_object.id for expense_object in expense_objects]
+    final_query = construct_expense_filter_query(expense_filters)
+
+    Expense.objects.filter(
+        final_query,
+        id__in=expenses_object_ids,
+        accountingexport__isnull=True,
+        org_id=workspace.org_id
+    ).update(is_skipped=True)
+
+    filtered_expenses = Expense.objects.filter(
+        is_skipped=False,
+        id__in=expenses_object_ids,
+        accountingexport__isnull=True,
+        org_id=workspace.org_id
+    )
+
+    return filtered_expenses
+
+
 def import_expenses(workspace_id, accounting_export: AccountingExport, source_account_type, fund_source_key):
     """
     Common logic for importing expenses from Fyle
@@ -58,9 +84,14 @@ def import_expenses(workspace_id, accounting_export: AccountingExport, source_ac
 
             setattr(workspace, f"{fund_source_map.get(fund_source_key)}_last_synced_at", datetime.now())
             workspace.save()
-            expenses_object = Expense.create_expense_objects(expenses, workspace_id)
+            expense_objects = Expense.create_expense_objects(expenses, workspace_id)
+
+            expense_filters = ExpenseFilter.objects.filter(workspace_id=workspace_id).order_by('rank')
+            if expense_filters:
+                expense_objects = get_filtered_expenses(workspace, expense_objects, expense_filters)
+
             AccountingExport.create_accounting_export(
-                expenses_object,
+                expense_objects,
                 fund_source=fund_source_key,
                 workspace_id=workspace_id
             )

apps/fyle/urls.py

@@ -25,7 +25,8 @@
     FyleFieldsView,
     DependentFieldSettingView,
     ExportableAccountingExportView,
-    AccountingExportSyncView
+    AccountingExportSyncView,
+    SkippedExpenseView
 )
 
 
@@ -40,6 +41,7 @@
     path('expense_fields/', CustomFieldView.as_view(), name='fyle-expense-fields'),
     path('fields/', FyleFieldsView.as_view(), name='fyle-fields'),
     path('dependent_field_settings/', DependentFieldSettingView.as_view(), name='dependent-field'),
+    path('expenses/', SkippedExpenseView.as_view(), name='expenses'),
 ]
 
 fyle_dimension_paths = [

apps/fyle/views.py

@@ -11,9 +11,10 @@
     FyleFieldsSerializer,
     DependentFieldSettingSerializer
 )
+from apps.accounting_exports.serializers import ExpenseSerializer
 
-from apps.workspaces.models import ExportSetting
-from apps.fyle.models import ExpenseFilter, DependentFieldSetting
+from apps.workspaces.models import ExportSetting, Workspace
+from apps.fyle.models import ExpenseFilter, DependentFieldSetting, Expense
 from apps.fyle.helpers import get_exportable_accounting_exports_ids
 from apps.fyle.queue import queue_import_reimbursable_expenses, queue_import_credit_card_expenses
 
@@ -112,3 +113,26 @@ def post(self, request, *args, **kwargs):
         return Response(
             status=status.HTTP_200_OK
         )
+
+
+class SkippedExpenseView(generics.ListAPIView):
+    """
+    List Skipped Expenses
+    """
+    serializer_class = ExpenseSerializer
+
+    def get_queryset(self):
+        start_date = self.request.query_params.get('start_date', None)
+        end_date = self.request.query_params.get('end_date', None)
+        org_id = Workspace.objects.get(id=self.kwargs['workspace_id']).org_id
+
+        filters = {
+            'org_id': org_id,
+            'is_skipped': True
+        }
+
+        if start_date and end_date:
+            filters['updated_at__range'] = [start_date, end_date]
+
+        queryset = Expense.objects.filter(**filters).order_by('-updated_at')
+        return queryset