def post(self, request, *args, **kwargs):
self.logger.info('========== Start create card provider ==========')
provider_name = request.POST.get('provider_name')
params = {}
if not provider_name:
return render(request, self.template_name)
params['name'] = provider_name
self.logger.info('Params: {}'.format(params))
success, status_code, status_message, data = RestFulClient.post(url=self.url,
headers=self._get_headers(),
loggers=self.logger,
timeout=settings.GLOBAL_TIMEOUT,
params=params)
self.logger.info('========== Finish create card provider ==========')
if success:
messages.add_message(
request,
messages.SUCCESS,
'Add provider successfully'
)
return redirect('card_provider:card_provider')
else:
if status_code in ['access_token_expire', 'authentication_fail',
'invalid_access_token', 'authentication_fail']:
self.logger.info(
"{} for {} username".format(status_message, self.request.user))
raise InvalidAccessToken(status_message)
messages.add_message(
request,
messages.ERROR,
status_message
)
return render(request, self.template_name)
def get_context_data(self, **kwargs):
self.logger.info('========== Start get shop type detail ==========')
context = super(EditView, self).get_context_data(**kwargs)
shop_type_id = context['shop_type_id']
self.logger.info(
"Searching shop type with [{}] shop type id".format(shop_type_id))
params = {'id': shop_type_id}
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.GET_LIST_SHOP_TYPE,
headers=self._get_headers(),
loggers=self.logger,
params=params)
self.logger.info("Params: {} ".format(params))
if is_success:
data = data['shop_types'][0]
self.logger.info('Response_content: {}'.format(data))
context['form'] = data
self.logger.info(
'========== Finish get shop type detail ==========')
return context
elif (status_code == "access_token_expire") or (
status_code
== 'authentication_fail') or (status_code
== 'invalid_access_token'):
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
def post(self, request, *args, **kwargs):
form = request.POST
context = {'form': form}
list_shop_type = get_all_shop_type(self)
context['list_shop_type'] = list_shop_type
list_shop_category = get_all_shop_category(self)
context['list_shop_category'] = list_shop_category
self.logger.info('========== Start Adding new shop ==========')
shop = convert_form_to_shop(form)
success, status_code, message, data = RestFulClient.post(
url=api_settings.CREATE_SHOP,
params=shop,
loggers=self.logger,
headers=self._get_headers())
self.logger.info("Params: {} ".format(shop))
if success:
self.logger.info('========== Finish Adding new shop ==========')
messages.add_message(request, messages.SUCCESS,
'Added data successfully')
return redirect(get_back_url(request, reverse('shop:shop_list')))
elif (status_code == "access_token_expire") or (
status_code
== 'authentication_fail') or (status_code
== 'invalid_access_token'):
self.logger.info("{} for {} username".format(
status_message, self.request.user))
raise InvalidAccessToken(status_message)
else:
return render(request, self.template_name, context)
def _list_categories(self):
self.logger.info('========== Start get category list ==========')
api_path = api_settings.GET_CATEGORIES
body = {
"paging": False
}
success, status_code, status_message, data = RestFulClient.post(url=api_path,
headers=self._get_headers(),
loggers=self.logger,
params=body,
timeout=settings.GLOBAL_TIMEOUT)
self.logger.info("Params: {} ".format(body))
if success:
data = data['product_categories']
self.logger.info("Response_content_count:{}".format(len(data)))
self.logger.info('========== Finish get category list ==========')
return data
elif (status_code == "access_token_expire") or (status_code == 'authentication_fail') or (
status_code == 'invalid_access_token'):
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
else:
return None
def get(self, request, *args, **kwargs):
self.logger.info('========== Start getting provider detail ==========')
context = super(DetailView, self).get_context_data(**kwargs)
provider_id = context['provider_id']
url = GET_DETAIL_PROVIDER.format(provider_id=provider_id)
is_success, status_code, data = RestFulClient.get(
url=url, headers=self._get_headers(), loggers=self.logger)
if is_success:
if data is None or data == "":
data = []
else:
if status_code in [
"access_token_expire", 'authentication_fail',
'invalid_access_token'
]:
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
data = []
messages.add_message(self.request, messages.ERROR,
"Something went wrong")
self.logger.info('Response_content: {}'.format(data))
is_permission_edit = check_permissions_by_user(self.request.user,
'SYS_EDIT_PROVIDER')
context['is_permission_edit'] = is_permission_edit
context['data'] = data
self.logger.info(
'========== Finish getting provider detail ==========')
return render(request, self.template_name, context)
def get(self, request, *args, **kwargs):
context = super(SmartCardDelete, self).get_context_data(**kwargs)
self.logger.info('========== Start deleting agent smartcard ==========')
agent_id = context.get('agent_id')
smartcard_id = context.get('smartcard_id')
url = DELETE_AGENT_SMART_CARD_PATH.format(agent_id, smartcard_id)
success, status_code, message = RestFulClient.delete(
url=url,
headers=self._get_headers(),
loggers=self.logger,
)
API_Logger.delete_logging(loggers=self.logger,
status_code=status_code)
self.logger.info('========== Finished deleting agent smartcard ==========')
if success:
messages.add_message(
self.request,
messages.SUCCESS,
'Delete agent smartcard successfully'
)
elif status_code in ["access_token_expire", 'authentication_fail', 'invalid_access_token']:
self.logger.info("{} for {} username".format(message, self.request.user))
raise InvalidAccessToken(message)
else:
messages.add_message(
self.request,
messages.ERROR,
"Got error and can not delete smartcard"
)
return redirect('agents:agent-smartcard', agent_id=agent_id)
def post(self, request, *args, **kwargs):
self.logger.info('========== Start update role entity ==========')
role_id = kwargs['role_id']
name = request.POST.get('name', '')
description = request.POST.get('description', '')
params = {
'name': name,
'description': description,
'is_page_level': True
}
url = api_settings.ROLE_UPDATE_PATH.format(role_id=role_id)
is_success, status_code, status_message, data = RestFulClient.put(
url, self._get_headers(), self.logger, params)
if is_success:
messages.add_message(request, messages.SUCCESS,
'Updated role entity successfully')
self.logger.info('========== End update role entity ==========')
return redirect('authentications:role_list')
elif (status_code == "access_token_expire") or (
status_code
== 'authentication_fail') or (status_code
== 'invalid_access_token'):
self.logger.info("{} for {} username".format(
status_message, self.request.user))
raise InvalidAccessToken(status_message)
def post(self, request, *args, **kwargs):
self.logger.info('========== Start get card provider list ==========')
context = super(CardProviderList, self).get_context_data(**kwargs)
provider_name = request.POST.get('provider_name')
params = {}
if provider_name:
params['name'] = provider_name
self.logger.info('Params: {}'.format(params))
is_success, status_code, status_message, data = RestFulClient.post(
url=self.url,
headers=self._get_headers(),
loggers=self.logger,
timeout=settings.GLOBAL_TIMEOUT,
params=params)
if not is_success:
if status_code in [
"access_token_expire", 'authentication_fail',
'invalid_access_token'
]:
self.logger.info("{}".format(status_message))
raise InvalidAccessToken(status_message)
self.logger.info('Response_content_count: {}'.format(len(data)))
is_permission_detail = check_permissions_by_user(
self.request.user, 'SYS_VIEW_DETAIL_PROVIDER')
is_permission_edit = check_permissions_by_user(self.request.user,
'SYS_EDIT_PROVIDER')
for i in data:
i['is_permission_detail'] = is_permission_detail
i['is_permission_edit'] = is_permission_edit
context.update({'data': data, 'provider_name': provider_name})
self.logger.info('========== Finish get card provider list ==========')
return render(request, self.template_name, context)
def _get_currencies_list(self):
self.logger.info('========== Start get currency list ==========')
url = GET_ALL_CURRENCY_URL
is_success, status_code, data = RestFulClient.get(
url=url, headers=self._get_headers(), loggers=self.logger)
if is_success:
if data is None or data == "":
data = []
else:
if status_code in [
"access_token_expire", 'authentication_fail',
'invalid_access_token'
]:
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
data = []
self.logger.info('Response_content_count: {}'.format(len(data)))
self.logger.info('========== Finish get currency list ==========')
if len(data) > 0:
value = data.get('value', None)
if value is not None:
currency_list = [i.split('|') for i in value.split(',')]
return currency_list
else:
return []
else:
return []
def post(self, request, *args, **kwargs):
self.logger.info('========== Start update provider detail ==========')
context = super(UpdateView, self).get_context_data(**kwargs)
provider_id = context['provider_id']
url = UPDATE_CARED_PROVIDER.format(provider_id=provider_id)
provider_name = request.POST.get('provider_name')
params = {
'name': provider_name
}
self.logger.info('Params: {}'.format(params))
is_success, status_code, status_message, data = RestFulClient.put(url=url,
headers=self._get_headers(),
loggers=self.logger,
timeout=settings.GLOBAL_TIMEOUT,
params=params)
if not is_success:
if status_code in ["access_token_expire", 'authentication_fail', 'invalid_access_token']:
self.logger.info("{}".format(status_message))
raise InvalidAccessToken(status_message)
self.logger.info('========== Finish update provider detail ==========')
messages.add_message(request, messages.SUCCESS, 'Update provider successfully')
return redirect('card_provider:card_provider')
def get_context_data(self, **kwargs):
self.logger.info(
'========== Start showing Blocked Devices page ==========')
context = super(BlockedDevicesList, self).get_context_data(**kwargs)
param = {}
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.SEARCH_TICKET,
headers=self._get_headers(),
loggers=self.logger,
params=param)
if is_success:
self.logger.info("Response_content_count:{}".format(len(data)))
context['devices'] = [i for i in data if i['is_deleted'] == False]
context['can_unblock_device'] = self.check_membership(
['CAN_DELETE_FRAUD_TICKET'])
device_count = 0
for ticket in context['devices']:
if ticket['action'] == 'register customer':
device_count += 1
context['total_devices'] = device_count
elif (status_code == "access_token_expire") or (
status_code
== 'authentication_fail') or (status_code
== 'invalid_access_token'):
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
self.logger.info(
'========== Finished showing Blocked Devices page ==========')
return context
def get_context_data(self, **kwargs):
context = super(SPIView, self).get_context_data(**kwargs)
service_command_id = kwargs.get('service_command_id')
if not service_command_id:
raise Http404
success, status_code, data = self.get_spi_list(service_command_id)
if success:
data_spi_call_method = self.get_call_method()
spi_types = self.get_spi_types()
context['data'] = data
context['data_spi_call_method'] = data_spi_call_method
context['spi_types'] = spi_types
context['add_spi_url_msg'] = self.request.session.pop(
'add_spi_url_msg', None)
context['spi_update_msg'] = self.request.session.pop(
'spi_update_msg', None)
context['spi_delete_msg'] = self.request.session.pop(
'spi_delete_msg', None)
context['api_version'] = api_settings.API_VERSION
return context
elif status_code in [
"access_token_expire", 'authentication_fail',
'invalid_access_token'
]:
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
def get_context_data(self, **kwargs):
context = super(RoleList, self).get_context_data(**kwargs)
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.ROLE_LIST,
headers=self._get_headers(),
loggers=self.logger)
permissions = {}
permissions['is_permission_detail'] = check_permissions_by_user(
self.request.user, 'CAN_VIEW_ROLE')
permissions['is_permission_edit'] = check_permissions_by_user(
self.request.user, 'CAN_EDIT_ROLE')
permissions['is_permission_delete'] = check_permissions_by_user(
self.request.user, 'CAN_DELETE_ROLE')
permissions['is_permission_manage'] = check_permissions_by_user(
self.request.user, 'CAN_MANAGE_PERM_FOR_ROLE')
if is_success:
self.logger.info("Roles have [{}] role in database".format(
len(data)))
context['roles'] = data
context['permissions'] = permissions
elif (status_code == "access_token_expire") or (
status_code
== 'authentication_fail') or (status_code
== 'invalid_access_token'):
self.logger.info("{} for {} username".format(
status_message, self.request.user))
raise InvalidAccessToken(status_message)
return context
def get_auth_header(user):
client_id = settings.CLIENTID
client_secret = settings.CLIENTSECRET
try:
auth = Authentications.objects.get(user=user)
access_token = auth.access_token
correlation_id = auth.correlation_id
except Exception as e:
raise InvalidAccessToken("{}".format(e))
return build_auth_header(client_id, client_secret, correlation_id, access_token)
def create_bank(cls, headers, params, logger):
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.CREATE_BANK_PROFILE_PATH, headers=headers, loggers=logger, params=params
)
if not is_success:
if status_code in ["access_token_expire", 'authentication_fail', 'invalid_access_token']:
logger.info("{}".format(status_message))
raise InvalidAccessToken(status_message)
return is_success, status_code, status_message, data
def post(self, request, *args, **kwargs):
self.logger.info('========== Start update customer device ==========')
mobile_device_id = kwargs['device_id']
customer_id = kwargs['customer_id']
form = request.POST
if form['channel_type_id'] == '1':
params = {
'channel_type_id': form['channel_type_id'],
'channel_id': form['channel_id'],
'device_name': form['device_name'],
'device_model': form['device_model'],
'device_unique_reference': form['device_unique_reference'],
'os': form['os'],
'os_version': form['os_version'],
'display_size_in_inches': form['display_size_in_inches'],
'pixel_counts': form['pixel_counts'],
'unique_number': form['unique_number'],
'mac_address': form['mac_address'],
'serial_number': form['serial_number'],
'network_provider_name': form['network_provider_name'],
'public_ip_address': form['public_ip_address'],
'app_version': form['app_version'],
'supporting_file_1': form['supporting_file_1'],
'supporting_file_2': form['supporting_file_2']
}
elif form['channel_type_id'] == '2':
params = {
'channel_type_id': form['channel_type_id'],
'channel_id': form['channel_id'],
'mac_address': form['mac_address'],
'network_provider_name': form['network_provider_name'],
'public_ip_address': form['public_ip_address'],
'supporting_file_1': form['supporting_file_1'],
'supporting_file_2': form['supporting_file_2']
}
url = api_settings.CUSTOMER_UPDATE_DEVICE_URL.format(mobile_device_id)
is_success, status_code, status_message, data = RestFulClient.put(url,
self._get_headers(),
self.logger, params)
self.logger.info("Params: {} ".format(params))
if is_success:
messages.add_message(
request,
messages.SUCCESS,
'Updated data successfully'
)
self.logger.info('========== Finish update customer device ==========')
return redirect('customers:customer_management_summary', customerId=customer_id)
elif (status_code == "access_token_expire") or (status_code == 'authentication_fail') or (
status_code == 'invalid_access_token'):
raise InvalidAccessToken(status_message)
def _delete_role_permission(self, url, params_to_delete):
headers = self._get_headers()
self.logger.info("Header: [{}]".format(headers))
is_success_delete, status_code_delete, status_message_delete = RestFulClient.delete(url=url,
headers=headers,
loggers=self.logger,
params=params_to_delete)
if (status_code_delete == "access_token_expire") or (status_code_delete == 'authentication_fail') or (
status_code_delete == 'invalid_access_token'):
self.logger.info("{} for {} username".format(status_message_delete, self.request.user))
raise InvalidAccessToken(status_message_delete)
return is_success_delete
def post(self, request, *args, **kwargs):
self.logger.info('========== User start updating password ==========')
url = api_settings.CHANGE_PASSWD
old_password = request.POST.get('old_password')
new_password = request.POST.get('new_password')
body = {
'old_password': encrypt_text(old_password),
'new_password': encrypt_text(new_password),
}
success, status_code, message, data = RestFulClient.put(
url=url,
headers=self._get_headers(),
loggers=self.logger,
timeout=settings.GLOBAL_TIMEOUT,
params=body)
self.logger.info('========== User finish updating password ==========')
if success:
return render(request,
self.template_name,
context={'update_passwd_success': True})
else:
if status_code in [
"access_token_expire", 'authentication_fail',
'invalid_access_token'
]:
self.logger.info("{}".format(message))
raise InvalidAccessToken(message)
body = {
'old_password': old_password,
'new_password': new_password,
"confirm_new_password":
request.POST.get('confirm_new_password')
}
if status_code.lower() in ["invalid_request"]:
messages.add_message(
request, messages.ERROR,
"Password change failed as it not met password criteria or old password didn’t match. Please review and try again."
)
else:
messages.add_message(
request, messages.ERROR,
"Password change failed. Please try again or contact support."
)
return render(request, self.template_name, body)
def _add_role_permission(self, role_id, params_to_insert):
headers = self._get_headers()
self.logger.info("Header: [{}]".format(headers))
url = api_settings.ROLE_PERMISSION_PATH.format(role_id=role_id)
self.logger.info("Adding permission to to [{}] role".format(params_to_insert))
is_success, status_code, status_message, data = RestFulClient.post(url=url,
headers=headers,
loggers=self.logger,
params=params_to_insert)
if (status_code == "access_token_expire") or (status_code == 'authentication_fail') or (
status_code == 'invalid_access_token'):
self.logger.info("{} for {} username".format(status_message, self.request.user))
raise InvalidAccessToken(status_message)
return is_success
def delete_permission(cls, id, headers, logger):
url = api_settings.PERMISSION_DETAIL_PATH.format(permission_id=id)
is_success, status_code, status_message = RestFulClient.delete(
url=url, headers=headers, loggers=logger)
if not is_success:
if status_code in [
"access_token_expire", 'authentication_fail',
'invalid_access_token'
]:
logger.info("{}".format(status_message))
raise InvalidAccessToken(status_message)
return is_success, status_code, status_message
def get_bank_details(cls, params, headers, logger):
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.GET_BANK_PROFILE_REPORT_PATH, headers=headers, loggers=logger, params=params
)
if not is_success:
if status_code in ["access_token_expire", 'authentication_fail', 'invalid_access_token']:
logger.info("{}".format(status_message))
raise InvalidAccessToken(status_message)
if is_success and len(data) > 0:
bank_detail = data[0]
return is_success, status_code, status_message, bank_detail
def get(self, request, *args, **kwargs):
context = super(CustomerManagementSummary, self).get_context_data(**kwargs)
customerId = int(context['customerId'])
permissions = check_permission_customer_management(self)
if not permissions['CAN_VIEW_CUSTOMER_MANAGEMENT']:
if permissions['CAN_ACCESS_CUSTOMER_DEVICE_TAB']:
return redirect('customers:customer_management_device', customerId=int(context['customerId']))
context.update(
{'customerId': customerId,
'permissions': permissions
})
if permissions['CAN_ACCESS_CUSTOMER_DEVICE_TAB']:
self.logger.info('========== Start getting Devices list ==========')
data, success, status_message = self._get_devices(customerId)
if success:
devices_list = data.get("devices", [])
page = data.get("page", {})
summary_device_list = list(devices_list)
if len(devices_list) > 5:
summary_device_list = devices_list[:5]
supported_channels = get_supported_channels(self)
access_channel_permissions = get_channel_permissions_list(self, customerId)
dict_channels = {int(x['id']): x for x in supported_channels}
id_channels_permissions = {int(x['channel']['id']) for x in access_channel_permissions}
for id, channel in dict_channels.items():
if id in id_channels_permissions:
channel['grant_permission'] = True
else:
channel['grant_permission'] = False
supported_channels = dict_channels.values()
context.update(
{'total_result': page.get('total_elements', 0),
'summary_device_list': summary_device_list,
'supported_channels': supported_channels
})
elif (status_message == "access_token_expire") or (status_message == 'authentication_fail') or (
status_message == 'invalid_access_token'):
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
self.logger.info('========== Finish getting Devices list ==========')
return render(request, self.template_name, context)
def get_agent_detail(self, id):
api_path = api_settings.AGENT_DETAIL_PATH
params = {'id': id}
success, status_code, status_message, data = RestFulClient.post(
url=api_path,
headers=self._get_headers(),
loggers=self.logger,
params=params)
if success:
return data['agents'][0]
elif (status_code == "access_token_expire") or (
status_code
== 'authentication_fail') or (status_code
== 'invalid_access_token'):
raise InvalidAccessToken(status_message)
def get_permissions(cls, headers, params, logger):
is_success, status_code, status_message, permissions = RestFulClient.post(
url=api_settings.PERMISSION_LIST,
headers=headers,
loggers=logger,
params=params)
if not is_success:
if status_code in [
"access_token_expire", 'authentication_fail',
'invalid_access_token'
]:
logger.info("{}".format(status_message))
raise InvalidAccessToken(status_message)
return is_success, status_code, status_message, permissions
def get_rule(self):
url = GET_RULE
self.logger.info('========== Start get rule list ==========')
is_success, status_code, data = RestFulClient.get(url=url, headers=self._get_headers(), loggers=self.logger)
if is_success:
if data is None or data == "":
data = []
else:
if status_code in ["access_token_expire", 'authentication_fail', 'invalid_access_token']:
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
data = []
self.logger.info('Response_content_count: {}'.format(len(data)))
self.logger.info('========== Finish get rule list ==========')
return data
def get_context_data(self, **kwargs):
self.logger.info(
'========== Start getting balance adjustment detail ==========')
context = super(BalanceAdjustmentDetailView,
self).get_context_data(**kwargs)
reference_id = context['ReferenceId']
body = {'reference_id': reference_id}
url = api_settings.BALANCE_ADJUSTMENT_PATH
#url = 'http://localhost:43931/additional_detail' # status: REJECT_FAIL
#url = 'http://localhost:43932/additional_detail' # status: APPROVE_FAIL
#url = 'http://localhost:43933/additional_detail' # status: Created
is_success, status_code, status_message, data = RestFulClient.post(
url=url,
headers=self._get_headers(),
loggers=self.logger,
params=body)
if not is_success:
if status_code in [
"access_token_expire", 'authentication_fail',
'invalid_access_token'
]:
self.logger.info("{}".format(status_message))
raise InvalidAccessToken(status_message)
API_Logger.get_logging(loggers=self.logger,
params={},
response=data,
status_code=status_code)
permissions = {}
permissions['SYS_BAL_ADJUST_APPROVE'] = check_permissions_by_user(
self.request.user, 'SYS_BAL_ADJUST_APPROVE')
balanceAdjustmentRespone = data['balance_adjustment_reference'][0]
referenceServiceGroupInfo = self._get_service_group_detail(
balanceAdjustmentRespone['reference_service_group_id'])
referenceServiceInfo = self._get_service_detail(
balanceAdjustmentRespone['reference_service_id'])
context = {
'order': data['balance_adjustment_reference'][0],
'referenceServiceGroupInfo': referenceServiceGroupInfo,
'referenceServiceInfo': referenceServiceInfo,
'show_buttons': True,
'permissions': permissions
}
self.logger.info(
'========== Finish getting balance adjustment detail ==========')
return context
def _get_all_permission(self):
if getattr(self, '_permissions', None) is None:
is_success_permissions, status_code_permissions, status_message_permissions, data_permissions = RestFulClient.post(
url=api_settings.PERMISSION_LIST,
headers=self._get_headers(),
loggers=self.logger)
if (status_code_permissions == "access_token_expire") or (
status_code_permissions == 'authentication_fail') or (
status_code_permissions == 'invalid_access_token'):
self.logger.info("{} for {} username".format(status_message_permissions, self.request.user))
raise InvalidAccessToken(status_message_permissions)
if is_success_permissions:
self._permissions = data_permissions
else:
self._permissions = []
return self._permissions
def get_services_list(self):
self.logger.info('========== Start Getting services list ==========')
url = SERVICE_LIST_URL
is_success, status_code, data = RestFulClient.get(
url=url, headers=self._get_headers(), loggers=self.logger)
if is_success:
self.logger.info("Response_content_count:{}".format(len(data)))
elif (status_code == "access_token_expire") or (
status_code
== 'authentication_fail') or (status_code
== 'invalid_access_token'):
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
self.logger.info('========== Finish Get services list ==========')
return data
def post(self, request, *args, **kwargs):
self.logger.info('========== Start update permission entities of role ==========')
update_roles = request.POST.getlist('roles')
roles = [int(i) for i in update_roles]
role_id = kwargs['role_id']
params = {
'role_id': int(role_id)
}
is_success_role_perm, status_code_role_perm, status_message_role_perm, data_role_perm = RestFulClient.post(
url=api_settings.PERMISSION_LIST,
headers=self._get_headers(),
loggers=self.logger, params=params)
if (status_code_role_perm == "access_token_expire") or (status_code_role_perm == 'authentication_fail') or (
status_code_role_perm == 'invalid_access_token'):
self.logger.info("{} for {} username".format(status_message_role_perm, self.request.user))
raise InvalidAccessToken(status_message_role_perm)
role_permission_id = [x['id'] for x in data_role_perm]
permissions_to_insert = [scope for scope in roles if scope not in role_permission_id]
permissions_to_delete = [scope for scope in role_permission_id if scope not in roles]
self.logger.info("Delete list permission id [{}]".format(permissions_to_delete))
self.logger.info("Add list permission id [{}]".format(permissions_to_insert))
url = api_settings.ROLE_PERMISSION_PATH.format(role_id=role_id)
params_to_delete = {
'permissions': permissions_to_delete
}
params_to_insert = {
'permissions': permissions_to_insert
}
if len(params_to_delete['permissions']) > 0:
is_success_delete = self._delete_role_permission(url, params_to_delete)
if len(params_to_insert['permissions']) > 0:
is_success_add = self._add_role_permission(role_id, params_to_insert)
request.session['msg'] = 'Updated data successfully'
self.logger.info('========== End update permission entities of role ==========')
return redirect('authentications:role_manage_permission', role_id=role_id)
def get_service_list(self):
url = api_settings.SERVICE_LIST_URL
is_success, status_code, data = RestFulClient.get(
url, headers=self._get_headers(), loggers=self.logger)
if is_success:
if data is None or data == "":
data = []
else:
if status_code in [
"access_token_expire", 'authentication_fail',
'invalid_access_token'
]:
self.logger.info("{}".format(data))
raise InvalidAccessToken(data)
data = []
self.logger.info('Response_content_count: {}'.format(len(data)))
return data
