def post(self, request, *args, **kwargs):
"""
Post Tenant mapping view
"""
tenant_mapping_payload = request.data
assert_valid(tenant_mapping_payload is not None,
'Request body is empty')
mapping_utils = MappingUtils(kwargs['workspace_id'])
tenant_mapping_object = mapping_utils.create_or_update_tenant_mapping(
tenant_mapping_payload)
return Response(data=self.serializer_class(tenant_mapping_object).data,
status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
"""
Post workspace general settings
"""
general_settings_payload = request.data
assert_valid(general_settings_payload is not None,
'Request body is empty')
workspace_id = kwargs['workspace_id']
general_settings = create_or_update_general_settings(
general_settings_payload, workspace_id)
return Response(data=self.serializer_class(general_settings).data,
status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
"""
Create BankTransaction from expense group
"""
expense_group_id = request.data.get('expense_group_id')
task_log_id = request.data.get('task_log_id')
assert_valid(expense_group_id is not None, 'Expense ids not found')
assert_valid(task_log_id is not None, 'Task Log id not found')
expense_group = ExpenseGroup.objects.get(pk=expense_group_id)
task_log = TaskLog.objects.get(pk=task_log_id)
create_bank_transaction(expense_group, task_log)
return Response(data={}, status=status.HTTP_200_OK)
def post(self, request, **kwargs):
"""
Post Settings
"""
schedule_enabled = request.data.get('schedule_enabled')
assert_valid(schedule_enabled is not None,
'Schedule enabled cannot be null')
hours = request.data.get('hours')
assert_valid(hours is not None, 'Hours cannot be left empty')
settings = schedule_sync(workspace_id=kwargs['workspace_id'],
schedule_enabled=schedule_enabled,
hours=hours)
return Response(data=WorkspaceScheduleSerializer(settings).data,
status=status.HTTP_200_OK)
def post(self, request, **kwargs):
"""
Post of Fyle Credentials
"""
try:
authorization_code = request.data.get('code')
workspace = Workspace.objects.get(id=kwargs['workspace_id'])
refresh_token = auth_utils.generate_fyle_refresh_token(
authorization_code)['refresh_token']
fyle_user = auth_utils.get_fyle_user(refresh_token)
org_id = fyle_user['org_id']
org_name = fyle_user['org_name']
assert_valid(
workspace.fyle_org_id and workspace.fyle_org_id == org_id,
'Please select the correct Fyle account - {0}'.format(
workspace.name))
workspace.name = org_name
workspace.fyle_org_id = org_id
workspace.save()
fyle_credentials, _ = FyleCredential.objects.update_or_create(
workspace_id=kwargs['workspace_id'],
defaults={
'refresh_token': refresh_token,
})
return Response(
data=FyleCredentialSerializer(fyle_credentials).data,
status=status.HTTP_200_OK)
except fyle_exc.UnauthorizedClientError:
return Response({'message': 'Invalid Authorization Code'},
status=status.HTTP_403_FORBIDDEN)
except fyle_exc.NotFoundClientError:
return Response({'message': 'Fyle Application not found'},
status=status.HTTP_404_NOT_FOUND)
except fyle_exc.WrongParamsError:
return Response({'message': 'Some of the parameters are wrong'},
status=status.HTTP_400_BAD_REQUEST)
except fyle_exc.InternalServerError:
return Response({'message': 'Wrong/Expired Authorization code'},
status=status.HTTP_401_UNAUTHORIZED)
def create_or_update_general_mapping(self, general_mapping: Dict):
"""
Create or update General mappings
:param general_mapping: general mapping payload
:return: general mappings objects
"""
general_settings: WorkspaceGeneralSettings = WorkspaceGeneralSettings.objects.get(
workspace_id=self.__workspace_id)
params = {
'bank_account_name': None,
'bank_account_id': None,
'payment_account_name': None,
'payment_account_id': None
}
if general_settings.corporate_credit_card_expenses_object == 'BANK TRANSACTION':
assert_valid(
'bank_account_name' in general_mapping
and general_mapping['bank_account_name'],
'bank account name field is blank')
assert_valid(
'bank_account_id' in general_mapping
and general_mapping['bank_account_id'],
'bank account id field is blank')
params['bank_account_name'] = general_mapping.get(
'bank_account_name')
params['bank_account_id'] = general_mapping.get('bank_account_id')
if general_settings.sync_fyle_to_xero_payments:
assert_valid(
'payment_account_name' in general_mapping
and general_mapping['payment_account_name'],
'payment account name field is blank')
assert_valid(
'payment_account_id' in general_mapping
and general_mapping['payment_account_id'],
'payment account id field is blank')
params['payment_account_name'] = general_mapping.get(
'payment_account_name')
params['payment_account_id'] = general_mapping.get(
'payment_account_id')
general_mapping_object, _ = GeneralMapping.objects.update_or_create(
workspace_id=self.__workspace_id, defaults=params)
schedule_payment_creation(sync_fyle_to_xero_payments=general_settings.
sync_fyle_to_xero_payments,
workspace_id=self.__workspace_id)
return general_mapping_object
def create_or_update_tenant_mapping(self, tenant_mapping: Dict):
"""
Create or update Tenant mappings
:param tenant_mapping: project mapping payload
:return: tenant mappings objects
"""
assert_valid(
'tenant_name' in tenant_mapping and tenant_mapping['tenant_name'],
'tenant name field is blank')
assert_valid(
'tenant_id' in tenant_mapping and tenant_mapping['tenant_id'],
'tenant id field is blank')
tenant_mapping_object, _ = TenantMapping.objects.update_or_create(
workspace_id=self.__workspace_id,
defaults={
'tenant_name': tenant_mapping['tenant_name'],
'tenant_id': tenant_mapping['tenant_id']
})
return tenant_mapping_object
def create_or_update_general_settings(general_settings_payload: Dict,
workspace_id):
"""
Create or update general settings
:param workspace_id:
:param general_settings_payload: general settings payload
:return:
"""
assert_valid(
'reimbursable_expenses_object' in general_settings_payload
and general_settings_payload['reimbursable_expenses_object'],
'reimbursable_expenses_object field is blank')
assert_valid('auto_map_employees' in general_settings_payload,
'auto_map_employees field is missing')
if general_settings_payload['auto_map_employees']:
assert_valid(
general_settings_payload['auto_map_employees']
in ['EMAIL', 'NAME', 'EMPLOYEE_CODE'],
'auto_map_employees can have only EMAIL / NAME / EMPLOYEE_CODE')
workspace_general_settings = WorkspaceGeneralSettings.objects.filter(
workspace_id=workspace_id).first()
map_merchant_to_contact = True
if workspace_general_settings:
map_merchant_to_contact = workspace_general_settings.map_merchant_to_contact
general_settings, _ = WorkspaceGeneralSettings.objects.update_or_create(
workspace_id=workspace_id,
defaults={
'reimbursable_expenses_object':
general_settings_payload['reimbursable_expenses_object'],
'corporate_credit_card_expenses_object':
general_settings_payload['corporate_credit_card_expenses_object']
if 'corporate_credit_card_expenses_object'
in general_settings_payload and
general_settings_payload['corporate_credit_card_expenses_object']
else None,
'sync_fyle_to_xero_payments':
general_settings_payload['sync_fyle_to_xero_payments'],
'sync_xero_to_fyle_payments':
general_settings_payload['sync_xero_to_fyle_payments'],
'import_categories':
general_settings_payload['import_categories'],
'auto_map_employees':
general_settings_payload['auto_map_employees'],
'auto_create_destination_entity':
general_settings_payload['auto_create_destination_entity'],
'map_merchant_to_contact':
map_merchant_to_contact
})
if general_settings.map_merchant_to_contact and \
general_settings.corporate_credit_card_expenses_object == 'BANK TRANSACTION':
expense_group_settings = ExpenseGroupSettings.objects.get(
workspace_id=workspace_id)
ccc_expense_group_fields = expense_group_settings.corporate_credit_card_expense_group_fields
ccc_expense_group_fields.append('expense_id')
expense_group_settings.corporate_credit_card_expense_group_fields = list(
set(ccc_expense_group_fields))
expense_group_settings.save()
schedule_payment_creation(general_settings.sync_fyle_to_xero_payments,
workspace_id)
schedule_xero_objects_status_sync(
sync_xero_to_fyle_payments=general_settings.sync_xero_to_fyle_payments,
workspace_id=workspace_id)
schedule_reimbursements_sync(
sync_xero_to_fyle_payments=general_settings.sync_xero_to_fyle_payments,
workspace_id=workspace_id)
schedule_categories_creation(
import_categories=general_settings.import_categories,
workspace_id=workspace_id)
schedule_auto_map_employees(general_settings_payload['auto_map_employees'],
workspace_id)
return general_settings
