def post(self, request, **kwargs):
"""
Post of QBO 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(update_fields=['name', 'fyle_org_id'])
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_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('employee_field_mapping' in general_settings_payload and general_settings_payload[
'employee_field_mapping'], 'employee_field_mapping field is blank')
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 general_settings_payload
['corporate_credit_card_expenses_object'] else None,
'employee_field_mapping': general_settings_payload['employee_field_mapping']
}
)
return general_settings
def create_or_update_general_mapping(self, general_mapping: Dict):
"""
Create or update general mapping
:param general_mapping: general mapping payload
:return:
"""
assert_valid(
'bank_account_name' in general_mapping
and general_mapping['bank_account_name'],
'employee email field is blank')
assert_valid(
'bank_account_id' in general_mapping
and general_mapping['bank_account_id'],
'vendor name field is blank')
# assert_valid('default_ccc_account_name' in general_mapping and general_mapping['default_ccc_account_name'],
# 'default ccc account name field is blank')
# assert_valid('default_ccc_account_id' in general_mapping and general_mapping['default_ccc_account_id'],
# 'default ccc account id field is blank')
general_mapping, _ = GeneralMapping.objects.update_or_create(
workspace_id=self.__workspace_id,
defaults={
'bank_account_name':
general_mapping.get('bank_account_name'),
'bank_account_id':
general_mapping.get('bank_account_id'),
'default_ccc_account_name':
general_mapping.get('default_ccc_account_name', ''),
'default_ccc_account_id':
general_mapping.get('default_ccc_account_id', '')
})
return general_mapping
def get(self, request, *args, **kwargs):
"""
Get task logs by ids
"""
task_log_ids = self.request.query_params.getlist('id', [])
assert_valid(task_log_ids != [], 'task log ids not found')
task_logs = TaskLog.objects.filter(id__in=task_log_ids).all()
return Response(
data=self.serializer_class(task_logs, many=True).data,
status=status.HTTP_200_OK
)
def create_or_update_category_mapping(self, category_mapping: Dict):
"""
Create or update category mappings
:param category_mapping: category mapping payload
:return: category mappings objects
"""
assert_valid(
'category' in category_mapping and category_mapping['category'],
'category field is blank')
assert_valid(
'sub_category' in category_mapping
and category_mapping['sub_category'],
'sub_category field is blank')
assert_valid(
'account_name' in category_mapping
and category_mapping['account_name'],
'account name field is blank')
assert_valid(
'account_id' in category_mapping
and category_mapping['account_id'], 'account id field is blank')
category_mapping_object, _ = CategoryMapping.objects.update_or_create(
category=category_mapping['category'],
sub_category=category_mapping['sub_category'],
workspace_id=self.__workspace_id,
defaults={
'account_name': category_mapping['account_name'],
'account_id': category_mapping['account_id']
})
return category_mapping_object
def post(self, request, *args, **kwargs):
"""
Post category mapping view
"""
category_mapping_payload = request.data
assert_valid(category_mapping_payload is not None, 'Request body is empty')
mapping_utils = MappingUtils(kwargs['workspace_id'])
category_mapping_object = mapping_utils.create_or_update_category_mapping(category_mapping_payload)
return Response(
data=self.serializer_class(category_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, **kwargs):
"""
Post of QBO Credentials
"""
try:
authorization_code = request.data.get('code')
realm_id = request.data.get('realm_id')
refresh_token = generate_qbo_refresh_token(authorization_code)
workspace = Workspace.objects.get(pk=kwargs['workspace_id'])
qbo_credentials = QBOCredential.objects.filter(
workspace=workspace).first()
if not qbo_credentials:
if workspace.qbo_realm_id:
assert_valid(
realm_id == workspace.qbo_realm_id,
'Please choose the correct Quickbooks online account')
qbo_credentials = QBOCredential.objects.create(
refresh_token=refresh_token,
realm_id=realm_id,
workspace=workspace)
workspace.qbo_realm_id = realm_id
workspace.save(update_fields=['qbo_realm_id'])
else:
assert_valid(
realm_id == qbo_credentials.realm_id,
'Please choose the correct aaaaa Quickbooks online account'
)
qbo_credentials.refresh_token = refresh_token
qbo_credentials.save()
return Response(data=QBOCredentialSerializer(qbo_credentials).data,
status=status.HTTP_200_OK)
except qbo_exc.UnauthorizedClientError:
return Response({'message': 'Invalid Authorization Code'},
status=status.HTTP_401_UNAUTHORIZED)
except qbo_exc.NotFoundClientError:
return Response({'message': 'QBO Application not found'},
status=status.HTTP_404_NOT_FOUND)
except qbo_exc.WrongParamsError as e:
return Response(json.loads(e.response),
status=status.HTTP_400_BAD_REQUEST)
except qbo_exc.InternalServerError:
return Response({'message': 'Wrong/Expired Authorization code'},
status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, *args, **kwargs):
"""
Create bill 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_bill(expense_group, task_log)
return Response(data={}, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
"""
Create general mappings
"""
general_mapping_payload = request.data
assert_valid(general_mapping_payload is not None, 'Request body is empty')
mapping_utils = MappingUtils(kwargs['workspace_id'])
general_mapping = mapping_utils.create_or_update_general_mapping(general_mapping_payload)
return Response(
data=self.serializer_class(general_mapping).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')
workspace_schedule_settings = schedule_sync(
workspace_id=kwargs['workspace_id'],
schedule_enabled=schedule_enabled,
hours=hours)
return Response(
data=WorkspaceScheduleSerializer(workspace_schedule_settings).data,
status=status.HTTP_200_OK)
def create_or_update_project_mapping(self, project_mapping: Dict):
"""
Create or update project mappings
:param project_mapping: project mapping payload
:return: project mappings objects
"""
assert_valid(
'project' in project_mapping and project_mapping['project'],
'project field is blank')
assert_valid(
'customer_display_name' in project_mapping
and project_mapping['customer_display_name'],
'customer name field is blank')
assert_valid(
'customer_id' in project_mapping
and project_mapping['customer_id'], 'customer id field is blank')
project_mapping_object, _ = ProjectMapping.objects.update_or_create(
project=project_mapping['project'],
workspace_id=self.__workspace_id,
defaults={
'customer_display_name':
project_mapping['customer_display_name'],
'customer_id': project_mapping['customer_id']
})
return project_mapping_object
def create_or_update_cost_center_mapping(self, cost_center_mapping: Dict):
"""
Create or update cost_center mappings
:param cost_center_mapping: cost_center mapping payload
:return: cost_center mappings objects
"""
assert_valid(
'cost_center' in cost_center_mapping
and cost_center_mapping['cost_center'],
'cost_center field is blank')
assert_valid(
'class_name' in cost_center_mapping
and cost_center_mapping['class_name'], 'class name field is blank')
assert_valid(
'class_id' in cost_center_mapping
and cost_center_mapping['class_id'], 'class id field is blank')
cost_center_mapping_object, _ = CostCenterMapping.objects.update_or_create(
cost_center=cost_center_mapping['cost_center'],
workspace_id=self.__workspace_id,
defaults={
'class_name': cost_center_mapping['class_name'],
'class_id': cost_center_mapping['class_id']
})
return cost_center_mapping_object
def create_or_update_employee_mapping(self, employee_mapping: Dict):
"""
Create or update employee mappings
:param employee_mapping: employee mapping payload
:return: employee mappings objects
"""
assert_valid(
'employee_email' in employee_mapping
and employee_mapping['employee_email'],
'employee email field is blank')
assert_valid(
'vendor_name' in employee_mapping
and employee_mapping['vendor_name'], 'vendor name field is blank')
assert_valid(
'vendor_id' in employee_mapping and employee_mapping['vendor_id'],
'vendor id field is blank')
employee_mapping_object, _ = EmployeeMapping.objects.update_or_create(
employee_email=employee_mapping['employee_email'].lower(),
workspace_id=self.__workspace_id,
defaults={
'vendor_display_name': employee_mapping['vendor_name'],
'vendor_id': employee_mapping['vendor_id']
})
return employee_mapping_object
def create_or_update_general_mapping(self, general_mapping: Dict):
"""
Create or update general mapping
:param general_mapping: general mapping payload
:return:
"""
general_settings = WorkspaceGeneralSettings.objects.get(workspace_id=self.__workspace_id)
params = {
'accounts_payable_name': None,
'accounts_payable_id': None,
'qbo_expense_account_name': None,
'qbo_expense_account_id': None,
'bank_account_name': None,
'bank_account_id': None,
'default_ccc_account_name': None,
'default_ccc_account_id': None,
'default_ccc_vendor_name': None,
'default_ccc_vendor_id': None
}
mapping_setting = MappingSetting.objects.filter(
Q(destination_field='VENDOR') | Q(destination_field='EMPLOYEE'),
source_field='EMPLOYEE', workspace_id=self.__workspace_id
).first()
if (mapping_setting.destination_field == 'VENDOR' or
general_settings.corporate_credit_card_expenses_object == 'BILL') and\
general_settings.reimbursable_expenses_object != 'EXPENSE':
assert_valid('accounts_payable_name' in general_mapping and general_mapping['accounts_payable_name'],
'account payable account name field is blank')
assert_valid('accounts_payable_id' in general_mapping and general_mapping['accounts_payable_id'],
'account payable account id field is blank')
params['accounts_payable_name'] = general_mapping.get('accounts_payable_name')
params['accounts_payable_id'] = general_mapping.get('accounts_payable_id')
if mapping_setting.destination_field == 'EMPLOYEE' and \
general_settings.reimbursable_expenses_object != 'EXPENSE':
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.corporate_credit_card_expenses_object and \
general_settings.corporate_credit_card_expenses_object != 'BILL':
assert_valid('default_ccc_account_name' in general_mapping and general_mapping['default_ccc_account_name'],
'default ccc account name field is blank')
assert_valid('default_ccc_account_id' in general_mapping and general_mapping['default_ccc_account_id'],
'default ccc account id field is blank')
params['default_ccc_account_name'] = general_mapping.get('default_ccc_account_name')
params['default_ccc_account_id'] = general_mapping.get('default_ccc_account_id')
if general_settings.corporate_credit_card_expenses_object == 'BILL':
assert_valid('default_ccc_vendor_name' in general_mapping and general_mapping['default_ccc_vendor_name'],
'default ccc vendor name field is blank')
assert_valid('default_ccc_vendor_id' in general_mapping and general_mapping['default_ccc_vendor_id'],
'default ccc vendor id field is blank')
params['default_ccc_vendor_name'] = general_mapping.get('default_ccc_vendor_name')
params['default_ccc_vendor_id'] = general_mapping.get('default_ccc_vendor_id')
if general_settings.sync_fyle_to_qbo_payments:
assert_valid(
'bill_payment_account_name' in general_mapping and general_mapping['bill_payment_account_name'],
'bill payment account name field is blank')
assert_valid(
'bill_payment_account_id' in general_mapping and general_mapping['bill_payment_account_id'],
'bill payment account id field is blank')
params['bill_payment_account_name'] = general_mapping.get('bill_payment_account_name')
params['bill_payment_account_id'] = general_mapping.get('bill_payment_account_id')
if general_settings.reimbursable_expenses_object == 'EXPENSE':
assert_valid('qbo_expense_account_name' in general_mapping and general_mapping['qbo_expense_account_name'],
'qbo expense account name field is blank')
assert_valid('qbo_expense_account_id' in general_mapping and general_mapping['qbo_expense_account_id'],
'qbo expense account id field is blank')
params['qbo_expense_account_name'] = general_mapping.get('qbo_expense_account_name')
params['qbo_expense_account_id'] = general_mapping.get('qbo_expense_account_id')
general_mapping_object, _ = GeneralMapping.objects.update_or_create(
workspace_id=self.__workspace_id,
defaults=params
)
schedule_bill_payment_creation(
sync_fyle_to_qbo_payments=general_settings.sync_fyle_to_qbo_payments,
workspace_id=self.__workspace_id
)
schedule_auto_map_ccc_employees(self.__workspace_id)
return general_mapping_object
def create_or_update_employee_mapping(self, employee_mapping: Dict):
"""
Create or update employee mappings
:param employee_mapping: employee mapping payload
:return: employee mappings objects
"""
params = {
'vendor_display_name': None,
'vendor_id': None,
'employee_display_name': None,
'employee_id': None,
'ccc_account_name': None,
'ccc_account_id': None
}
general_settings_queryset = WorkspaceGeneralSettings.objects.all()
general_settings = general_settings_queryset.get(
workspace_id=self.__workspace_id)
assert_valid(
'employee_email' in employee_mapping
and employee_mapping['employee_email'],
'employee email field is blank')
if general_settings.employee_field_mapping == 'VENDOR':
assert_valid(
'vendor_id' in employee_mapping
and employee_mapping['vendor_id'], 'vendor id field is blank')
assert_valid(
'vendor_display_name' in employee_mapping
and employee_mapping['vendor_display_name'],
'vendor display name is missing')
params['vendor_display_name'] = employee_mapping.get(
'vendor_display_name')
params['vendor_id'] = employee_mapping.get('vendor_id')
elif general_settings.employee_field_mapping == 'EMPLOYEE':
assert_valid(
'employee_display_name' in employee_mapping
and employee_mapping['employee_display_name'],
'employee_display_name field is blank')
assert_valid(
'employee_id' in employee_mapping
and employee_mapping['employee_id'],
'employee_id field is blank')
params['employee_display_name'] = employee_mapping.get(
'employee_display_name')
params['employee_id'] = employee_mapping.get('employee_id')
if general_settings.corporate_credit_card_expenses_object:
assert_valid(
'ccc_account_name' in employee_mapping
and employee_mapping['ccc_account_name'],
'ccc account name field is blank')
assert_valid(
'ccc_account_id' in employee_mapping
and employee_mapping['ccc_account_id'],
'ccc account id field is blank')
params['ccc_account_name'] = employee_mapping.get(
'ccc_account_name')
params['ccc_account_id'] = employee_mapping.get('ccc_account_id')
employee_mapping_object, _ = EmployeeMapping.objects.update_or_create(
employee_email=employee_mapping['employee_email'].lower(),
workspace_id=self.__workspace_id,
defaults=params)
return employee_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')
if 'auto_map_employees' in general_settings_payload and 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_vendor = True
if workspace_general_settings:
map_merchant_to_vendor = workspace_general_settings.map_merchant_to_vendor
# TODO: remove this hack once workspace settings are saved
if workspace_id == 98:
category_sync_version = 'v1'
else:
category_sync_version = workspace_general_settings.category_sync_version if workspace_general_settings else 'v2'
general_settings, _ = WorkspaceGeneralSettings.objects.update_or_create(
workspace_id=workspace_id,
category_sync_version=category_sync_version,
defaults={
'import_projects':
general_settings_payload['import_projects'],
'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'],
'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_qbo_payments':
general_settings_payload['sync_fyle_to_qbo_payments'],
'sync_qbo_to_fyle_payments':
general_settings_payload['sync_qbo_to_fyle_payments'],
'map_merchant_to_vendor':
map_merchant_to_vendor
})
if general_settings.map_merchant_to_vendor and \
general_settings.corporate_credit_card_expenses_object == 'CREDIT CARD PURCHASE':
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_projects_creation(
import_projects=general_settings.import_projects,
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)
schedule_auto_map_ccc_employees(workspace_id)
schedule_bill_payment_creation(general_settings.sync_fyle_to_qbo_payments,
workspace_id)
schedule_qbo_objects_status_sync(
sync_qbo_to_fyle_payments=general_settings.sync_qbo_to_fyle_payments,
workspace_id=workspace_id)
schedule_reimbursements_sync(
sync_qbo_to_fyle_payments=general_settings.sync_qbo_to_fyle_payments,
workspace_id=workspace_id)
return general_settings
def create_or_update_general_mapping(self, general_mapping: Dict):
"""
Create or update general mapping
:param general_mapping: general mapping payload
:return:
"""
queryset = WorkspaceGeneralSettings.objects.all()
general_settings = queryset.get(workspace_id=self.__workspace_id)
params = {
'accounts_payable_name': None,
'accounts_payable_id': None,
'bank_account_name': None,
'bank_account_id': None,
'default_ccc_account_name': None,
'default_ccc_account_id': None
}
if general_settings.employee_field_mapping == 'VENDOR':
assert_valid(
'accounts_payable_name' in general_mapping
and general_mapping['accounts_payable_name'],
'account payable account name field is blank')
assert_valid(
'accounts_payable_id' in general_mapping
and general_mapping['accounts_payable_id'],
'account payable account id field is blank')
params['accounts_payable_name'] = general_mapping.get(
'accounts_payable_name')
params['accounts_payable_id'] = general_mapping.get(
'accounts_payable_id')
if general_settings.employee_field_mapping == 'EMPLOYEE':
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.corporate_credit_card_expenses_object:
assert_valid(
'default_ccc_account_name' in general_mapping
and general_mapping['default_ccc_account_name'],
'default ccc account name field is blank')
assert_valid(
'default_ccc_account_id' in general_mapping
and general_mapping['default_ccc_account_id'],
'default ccc account id field is blank')
params['default_ccc_account_name'] = general_mapping.get(
'default_ccc_account_name')
params['default_ccc_account_id'] = general_mapping.get(
'default_ccc_account_id')
general_mapping, _ = GeneralMapping.objects.update_or_create(
workspace_id=self.__workspace_id, defaults=params)
return general_mapping
def create_or_update_general_mapping(self, general_mapping: Dict):
"""
Create or update general mapping
:param general_mapping: general mapping payload
:return:
"""
general_settings = WorkspaceGeneralSettings.objects.get(workspace_id=self.__workspace_id)
params = {
'accounts_payable_name': None,
'accounts_payable_id': None,
'bank_account_name': None,
'bank_account_id': None,
'default_ccc_account_name': None,
'default_ccc_account_id': None
}
mapping_setting = MappingSetting.objects.filter(
Q(destination_field='VENDOR') | Q(destination_field='EMPLOYEE'),
source_field='EMPLOYEE', workspace_id=self.__workspace_id
).first()
if mapping_setting.destination_field == 'VENDOR':
assert_valid('accounts_payable_name' in general_mapping and general_mapping['accounts_payable_name'],
'account payable account name field is blank')
assert_valid('accounts_payable_id' in general_mapping and general_mapping['accounts_payable_id'],
'account payable account id field is blank')
params['accounts_payable_name'] = general_mapping.get('accounts_payable_name')
params['accounts_payable_id'] = general_mapping.get('accounts_payable_id')
if mapping_setting.destination_field == 'EMPLOYEE':
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.corporate_credit_card_expenses_object:
assert_valid('default_ccc_account_name' in general_mapping and general_mapping['default_ccc_account_name'],
'default ccc account name field is blank')
assert_valid('default_ccc_account_id' in general_mapping and general_mapping['default_ccc_account_id'],
'default ccc account id field is blank')
params['default_ccc_account_name'] = general_mapping.get('default_ccc_account_name')
params['default_ccc_account_id'] = general_mapping.get('default_ccc_account_id')
general_mapping, _ = GeneralMapping.objects.update_or_create(
workspace_id=self.__workspace_id,
defaults=params
)
return general_mapping
