Expense creation from Slack (both form as well as DE flow)

.pylintrc

@@ -61,6 +61,7 @@ confidence=
 # no Warning level messages displayed, use "--disable=all --enable=classes
 # --disable=W".
 disable=print-statement,
+        consider-using-f-string,
         parameter-unpacking,
         unpacking-in-except,
         old-raise-syntax,

fyle_slack_app/fyle/expenses/views.py

@@ -1,18 +1,252 @@
-from typing import Dict
+from typing import Dict, List
+
+import datetime
+
+from django.core.cache import cache
 
 from fyle.platform.platform import Platform
 
 from fyle_slack_app.fyle.utils import get_fyle_sdk_connection
 from fyle_slack_app.models.users import User
+from fyle_slack_app.fyle import utils as fyle_utils
+from fyle_slack_app.libs import assertions, http
 
-
+# pylint: disable=too-many-public-methods
 class FyleExpense:
+
     connection: Platform = None
 
     def __init__(self, user: User) -> None:
         self.connection = get_fyle_sdk_connection(user.fyle_refresh_token)
 
 
+    def get_expense_fields(self, query_params: Dict) -> Dict:
+        return self.connection.v1beta.spender.expense_fields.list(query_params=query_params)
+
+
+    def get_default_expense_fields(self) -> Dict:
+        default_expense_fields_query_params = {
+            'offset': 0,
+            'limit': '50',
+            'order': 'created_at.desc',
+            'column_name': 'in.(purpose, txn_dt, vendor_id, cost_center_id, project_id)',
+            'is_enabled': 'eq.{}'.format(True),
+            'is_custom': 'eq.{}'.format(False)
+        }
+
+        return self.get_expense_fields(default_expense_fields_query_params)
+
+
+    def get_custom_fields_by_category_id(self, category_id: str) -> Dict:
+        custom_fields_query_params = {
+            'offset': 0,
+            'limit': '50',
+            'order': 'created_at.desc',
+            'column_name': 'not_in.(purpose, txn_dt, spent_at, merchant, vendor_id, cost_center_id)',
+            'is_enabled': 'eq.{}'.format(True),
+            'category_ids': 'cs.[{}]'.format(int(category_id))
+        }
+
+        return self.get_expense_fields(custom_fields_query_params)
+
+
+    def get_categories(self, query_params: Dict) -> Dict:
+        return self.connection.v1beta.spender.categories.list(query_params=query_params)
+
+
+    def get_projects(self, query_params: Dict) -> Dict:
+        return self.connection.v1beta.spender.projects.list(query_params=query_params)
+
+    def get_merchants(self, query_params: Dict) -> Dict:
+        return self.connection.v1beta.spender.merchants.list(query_params=query_params)
+
+    def get_cost_centers(self, query_params: Dict) -> Dict:
+        return self.connection.v1beta.spender.cost_centers.list(query_params=query_params)
+
+
+    def get_expenses(self, query_params: Dict) -> Dict:
+        return self.connection.v1beta.spender.expenses.list(query_params=query_params)
+
+
+    def get_reports(self, query_params: Dict) -> Dict:
+        return self.connection.v1beta.spender.reports.list(query_params=query_params)
+
+
+    def get_employees(self, query_params: Dict) -> Dict:
+        return self.connection.v1beta.spender.employees.list(query_params=query_params)
+
+
+    def get_places_autocomplete(self, query: str) -> Dict:
+        return self.connection.v1beta.common.places_autocomplete.list(q=query)
+
+
+    def get_place_by_place_id(self, place_id: str) -> Dict:
+        return self.connection.v1beta.common.places.get_by_id(place_id)
+
+
+    def get_exchange_rate(self, from_currency: str, to_currency: str) -> Dict:
+        current_date = datetime.datetime.today().strftime('%Y-%m-%d')
+        exchange_rate = self.connection.v1beta.common.currencies_exchange_rate.get(
+            from_currency, to_currency, current_date
+        )
+        return exchange_rate['data']['exchange_rate']
+
+
+    def check_project_availability(self) -> bool:
+        projects_query_params = {
+            'offset': 0,
+            'limit': '1',
+            'order': 'created_at.desc',
+            'is_enabled': 'eq.{}'.format(True)
+        }
+
+        projects = self.get_projects(projects_query_params)
+
+        is_project_available = True if projects['count'] > 0 else False
+
+        return is_project_available
+
+
+    def check_cost_center_availability(self) -> bool:
+        cost_centers_query_params = {
+            'offset': 0,
+            'limit': '1',
+            'order': 'created_at.desc',
+            'is_enabled': 'eq.{}'.format(True)
+        }
+
+        cost_centers = self.get_cost_centers(cost_centers_query_params)
+
+        is_cost_center_available = True if cost_centers['count'] > 0 else False
+
+        return is_cost_center_available
+
+
+    def upsert_expense(self, expense_payload: Dict, refresh_token: str) -> Dict:
+        access_token = fyle_utils.get_fyle_access_token(refresh_token)
+        cluster_domain = fyle_utils.get_cluster_domain(refresh_token)
+
+        url = '{}/platform/v1/spender/expenses'.format(cluster_domain)
+        headers = {
+            'content-type': 'application/json',
+            'Authorization': 'Bearer {}'.format(access_token)
+        }
+
+        expense_payload = {
+            'data': expense_payload
+        }
+
+        response = http.post(url, json=expense_payload, headers=headers)
+        assertions.assert_valid(response.status_code == 200, 'Error creating expense')
+        return response.json()['data']
+
+
+    @staticmethod
+    def get_currencies():
+        return ['ADP','AED','AFA','ALL','AMD','ANG','AOA','ARS','ATS','AUD','AWG','AZM','BAM','BBD','BDT','BEF','BGL','BGN','BHD','BIF','BMD','BND','BOB','BOV','BRL','BSD','BTN','BWP','BYB','BZD','CAD','CDF','CHF','CLF','CLP','CNY','COP','CRC','CUP','CVE','CYP','CZK','DEM','DJF','DKK','DOP','DZD','ECS','ECV','EEK','EGP','ERN','ESP','ETB','EUR','FIM','FJD','FKP','FRF','GBP','GEL','GHC','GIP','GMD','GNF','GRD','GTQ','GWP','GYD','HKD','HNL','HRK','HTG','HUF','IDE','IDR','IEP','ILS','INR','IQD','IRR','ISK','ITL','JMD','JOD','JPY','KES','KGS','KHR','KMF','KPW','KRW','KWD','KYD','KZT','LAK','LBP','LKR','LRD','LSL','LTL','LUF','LVL','LYD','MAD','MDL','MGF','MKD','MMK','MNT','MOP','MRO','MTL','MUR','MVR','MWK','MXN','MXV','MYR','MZM','NAD','NGN','NIO','NLG','NOK','NPR','NZD','OMR','PAB','PEN','PGK','PHP','PKR','PLN','PTE','PYG','QAR','ROL','RUB','RUR','RWF','RYR','SAR','SBD','SCR','SDP','SEK','SGD','SHP','SIT','SKK','SLL','SOS','SRG','STD','SVC','SYP','SZL','THB','TJR','TMM','TND','TOP','TPE','TRL','TTD','TWD','TZS','UAH','UGX','USD','USN','USS','UYU','UZS','VEB','VND','VUV','WST','XAF','XCD','XDR','XEU','XOF','XPF','YER','YUN','ZAR','ZMK','ZRN','ZWD']
+
+
+    @staticmethod
+    def get_expense_fields_mandatory_mapping(expense_fields: List[Dict]) -> Dict:
+        mandatory_fields_mapping = {
+            'purpose': False,
+            'txn_dt': False,
+            'vendor_id': False,
+            'project_id': False,
+            'cost_center_id': False
+        }
+
+        for field in expense_fields['data']:
+            if field['column_name'] in mandatory_fields_mapping:
+                mandatory_fields_mapping[field['column_name']] = field['is_mandatory']
+
+        return mandatory_fields_mapping
+
+
+    @staticmethod
+    def get_expense_form_details(user: User, view_id: str) -> Dict:
+
+        fyle_expense = FyleExpense(user)
+
+        fyle_profile = fyle_utils.get_fyle_profile(user.fyle_refresh_token)
+
+        home_currency = fyle_profile['org']['currency']
+
+        default_expense_fields = fyle_expense.get_default_expense_fields()
+
+        mandatory_fields_mapping = fyle_expense.get_expense_fields_mandatory_mapping(default_expense_fields)
+
+        is_project_available = fyle_expense.check_project_availability()
+        is_cost_center_available = fyle_expense.check_cost_center_availability()
+
+        # Create a expense fields render property and set them optional in the form
+        fields_render_property = {
+            'project': {
+                'is_project_available': is_project_available,
+                'is_mandatory': mandatory_fields_mapping['project_id']
+            },
+            'cost_center': {
+                'is_cost_center_available': is_cost_center_available,
+                'is_mandatory': mandatory_fields_mapping['cost_center_id']
+            },
+            'purpose': mandatory_fields_mapping['purpose'],
+            'transaction_date': mandatory_fields_mapping['txn_dt'],
+            'vendor': mandatory_fields_mapping['vendor_id']
+        }
+
+        additional_currency_details = {
+            'home_currency': home_currency
+        }
+
+        add_to_report = 'existing_report'
+
+        expense_form_details = {
+            'fields_render_property': fields_render_property,
+            'additional_currency_details': additional_currency_details,
+            'add_to_report': add_to_report
+        }
+
+        cache_key = '{}.form_metadata'.format(view_id)
+        cache.set(cache_key, expense_form_details, 3600)
+
+        return expense_form_details
+
+
+    @staticmethod
+    def get_current_expense_form_details(slack_payload: Dict) -> Dict:
+
+        cache_key = '{}.form_metadata'.format(slack_payload['view']['id'])
+        form_metadata =  cache.get(cache_key)
+
+        fields_render_property = form_metadata['fields_render_property']
+
+        additional_currency_details = form_metadata.get('additional_currency_details')
+
+        add_to_report = form_metadata.get('add_to_report')
+
+        current_ui_blocks = slack_payload['view']['blocks']
+
+        project = form_metadata.get('project')
+
+        custom_field_blocks = []
+
+        for block in current_ui_blocks:
+            if 'custom_field' in block['block_id'] or 'additional_field' in block['block_id']:
+                custom_field_blocks.append(block)
+
+        if len(custom_field_blocks) == 0:
+            custom_field_blocks = None
+
+        current_form_details = {
+            'fields_render_property': fields_render_property,
+            'selected_project': project,
+            'additional_currency_details': additional_currency_details,
+            'add_to_report': add_to_report,
+            'custom_fields': custom_field_blocks
+        }
+        return current_form_details
+
+
     def get_expense_by_id(self, expense_id: str) -> Dict:
         query_params = {
             'id': 'eq.{}'.format(expense_id),

fyle_slack_app/slack/commands/handlers.py

@@ -6,14 +6,15 @@
 
 from fyle.platform import exceptions
 
-from fyle_slack_app import tracking
 from fyle_slack_app.libs import utils, assertions, logger
 from fyle_slack_app.fyle.utils import get_fyle_oauth_url, get_fyle_profile
 from fyle_slack_app.models import User, NotificationPreference
 from fyle_slack_app.slack.ui.common_messages import IN_PROGRESS_MESSAGE
 from fyle_slack_app.slack.ui.dashboard import messages as dashboard_messages
 from fyle_slack_app.slack.ui.notifications import preference_messages as notification_preference_messages
+from fyle_slack_app.slack.ui.expenses import messages as expense_messages
 from fyle_slack_app.slack import utils as slack_utils
+from fyle_slack_app import tracking
 
 
 logger = logger.get_logger(__name__)
@@ -26,10 +27,11 @@ class SlackCommandHandler:
     def _initialize_command_handlers(self):
         self._command_handlers = {
             'fyle_unlink_account': self.handle_fyle_unlink_account,
-            'fyle_notification_preferences': self.handle_fyle_notification_preferences
+            'fyle_notification_preferences': self.handle_fyle_notification_preferences,
+            'expense_form': self.handle_expense_form
         }
 
-    def handle_invalid_command(self, user_id: str, team_id: str, user_dm_channel_id: str) -> JsonResponse:
+    def handle_invalid_command(self, user_id: str, team_id: str, user_dm_channel_id: str, trigger_id: str) -> JsonResponse:
         slack_client = slack_utils.get_slack_client(team_id)
 
         slack_client.chat_postMessage(
@@ -39,14 +41,14 @@ def handle_invalid_command(self, user_id: str, team_id: str, user_dm_channel_id:
         return JsonResponse({}, status=200)
 
 
-    def handle_slack_command(self, command: str, user_id: str, team_id: str, user_dm_channel_id: str) -> Callable:
+    def handle_slack_command(self, command: str, user_id: str, team_id: str, user_dm_channel_id: str, trigger_id: str) -> Callable:
 
         # Initialize slack command handlers
         self._initialize_command_handlers()
 
         handler = self._command_handlers.get(command, self.handle_invalid_command)
 
-        return handler(user_id, team_id, user_dm_channel_id)
+        return handler(user_id, team_id, user_dm_channel_id, trigger_id)
 
 
     def handle_fyle_unlink_account(self, user_id: str, team_id: str, user_dm_channel_id: str) -> JsonResponse:
@@ -86,7 +88,7 @@ def update_home_tab_with_pre_auth_message(self, user_id: str, team_id: str) -> N
         slack_client.views_publish(user_id=user_id, view=pre_auth_message_view)
 
 
-    def handle_fyle_notification_preferences(self, user_id: str, team_id: str, user_dm_channel_id: str) -> JsonResponse:
+    def handle_fyle_notification_preferences(self, user_id: str, team_id: str, user_dm_channel_id: str, trigger_id: str) -> JsonResponse:
         user = utils.get_or_none(User, slack_user_id=user_id)
         assertions.assert_found(user, 'Slack user not found')
 
@@ -110,6 +112,25 @@ def handle_fyle_notification_preferences(self, user_id: str, team_id: str, user_
         return JsonResponse({}, status=200)
 
 
+    def handle_expense_form(self, user_id: str, team_id: str, user_dm_channel_id: str, trigger_id: str):
+        user = utils.get_or_none(User, slack_user_id=user_id)
+
+        slack_client = slack_utils.get_slack_client(team_id)
+
+        loading_modal = expense_messages.expense_form_loading_modal(title='Create Expense', loading_message='Loading the best expense form :zap:')
+
+        response = slack_client.views_open(user=user_id, view=loading_modal, trigger_id=trigger_id)
+
+        async_task(
+            'fyle_slack_app.slack.commands.tasks.open_expense_form',
+            user,
+            team_id,
+            response['view']['id']
+        )
+
+        return JsonResponse({}, status=200)
+
+
     def track_fyle_account_unlinked(self, user: User) -> None:
         event_data = {
             'asset': 'SLACK_APP',

fyle_slack_app/slack/commands/tasks.py

@@ -6,6 +6,8 @@
 from fyle_slack_app.models import User, UserSubscriptionDetail
 from fyle_slack_app.models.user_subscription_details import SubscriptionType
 from fyle_slack_app.slack.commands.handlers import SlackCommandHandler
+from fyle_slack_app.fyle.expenses.views import FyleExpense
+from fyle_slack_app.slack.ui.expenses import messages as expense_messages
 
 
 logger = logger.get_logger(__name__)
@@ -98,3 +100,16 @@ def fyle_unlink_account(user_id: str, team_id: str, user_dm_channel_id: str, mes
         blocks=message_block,
         ts=message_ts
     )
+
+
+def open_expense_form(user: User, team_id: str, view_id: str) -> None:
+
+    slack_client = slack_utils.get_slack_client(team_id)
+
+    expense_form_details = FyleExpense.get_expense_form_details(user, view_id)
+
+    expense_form = expense_messages.expense_dialog_form(
+        **expense_form_details
+    )
+
+    slack_client.views_update(view=expense_form, view_id=view_id)

fyle_slack_app/slack/commands/views.py

@@ -10,8 +10,9 @@ def post(self, request: HttpRequest, command: str) -> HttpResponse:
         team_id = request.POST['team_id']
         user_id = request.POST['user_id']
         user_dm_channel_id = request.POST['channel_id']
+        trigger_id = request.POST['trigger_id']
 
-        self.handle_slack_command(command, user_id, team_id, user_dm_channel_id)
+        self.handle_slack_command(command, user_id, team_id, user_dm_channel_id, trigger_id)
 
         # Empty "" HttpResponse beacause for slash commands slack return the response as message to user
         return HttpResponse("", status=200)

fyle_slack_app/slack/events/tasks.py

@@ -2,15 +2,13 @@
 from slack_sdk import WebClient
 
 from django.conf import settings
-
 from fyle_slack_app.fyle.expenses.views import FyleExpense
 
 from fyle_slack_app.fyle.utils import get_fyle_oauth_url
 from fyle_slack_app.libs import utils, assertions, logger
 from fyle_slack_app.models import Team, User, UserSubscriptionDetail
 from fyle_slack_app.models.user_subscription_details import SubscriptionType
 from fyle_slack_app.fyle import utils as fyle_utils
-
 from fyle_slack_app.slack.interactives.block_action_handlers import BlockActionHandler
 from fyle_slack_app.slack import utils as slack_utils
 from fyle_slack_app.slack.ui.authorization import messages