def get_agent_type(self, product_id):
self.logger.info(
'========== Start get product - agent types relations ==========')
params = {'product_id': product_id}
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.PRODUCT_AGENT_TYPE,
headers=self._get_headers(),
loggers=self.logger,
params=params)
relations = data['relations']
API_Logger.post_logging(loggers=self.logger,
params=params,
response=relations,
status_code=status_code,
is_getting_list=True)
self.logger.info(
'========== Finished get product - agent types relations =========='
)
agent_types = []
for item in relations:
agent_type_id = item['agent_type_id']
agent_types.append(agent_type_id)
return agent_types
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 get_context_data(self, **kwargs):
product_id = self.kwargs['product_id']
self.logger.info('========== Start get product details ==========')
params = {"id": product_id, 'paging': False}
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.GET_PRODUCT_DETAIL,
headers=self._get_headers(),
loggers=self.logger,
params=params)
API_Logger.post_logging(loggers=self.logger,
params=params,
response=data,
status_code=status_code,
is_getting_list=False)
self.logger.info('========== Finished get product details ==========')
product = data['products'][0]
if not product['denomination']:
product['denomination'] = ['']
product['product_category_id'] = product['product_category']['id']
context = {"product": product}
context['cbo_agent_types'] = self.get_agent_type(product_id)
self.set_ui_list(context)
return context
def _upload_via_api(request, file, function_id, logger):
myHeader = get_auth_header(request.user)
#
myHeader["content-type"] = None
myHeader["content-type"] = None
myHeader["Content-Type"] = None
is_success, status_code, status_message, data = RestFulClient.upload(
url=UPLOAD_FILE,
files={'file_data': file},
headers=myHeader,
loggers=logger,
params={'function_id': function_id},
timeout=settings.GLOBAL_TIMEOUT)
API_Logger.post_logging(loggers=logger,
params={
'file_data': file._name,
'function_id': function_id
},
response=data,
status_code=status_code,
is_getting_list=True)
if not is_success:
data = []
return data
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 post(self, request, *args, **kwargs):
self.logger.info('========== Start update shop category ==========')
shop_category_id = kwargs['id']
form = request.POST
params = {
'name' : form['name'],
'description' : form['description']
}
url = api_settings.EDIT_SHOP_CATEGORIES.format(shop_category_id=shop_category_id)
is_success, status_code, status_message, data = RestFulClient.put(url,
self._get_headers(),
self.logger, params)
API_Logger.put_logging(loggers=self.logger, params=params, response=data,
status_code=status_code)
if is_success:
messages.add_message(
request,
messages.SUCCESS,
'Updated data successfully'
)
self.logger.info('========== Finish update shop category ==========')
return redirect('shop_category:shop_category_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 reject voucher refunds ==========')
data = request.POST.copy()
refundRequestIds = json.loads(data.get("refundRequestIds"))
reason = data.get("reason")
url = api_settings.VOUCHER_REFUND_APPROVE_PATH
data = {"refund_request_ids": refundRequestIds, "reason": reason}
is_success, status_code, status_message, data = RestFulClient.delete_return_data(
url, headers=self._get_headers(), loggers=self.logger, params=data)
self.logger.info('========== Finish reject voucher refunds ==========')
if is_success:
messages.add_message(self.request, messages.SUCCESS,
"System is processing, please wait a while")
return JsonResponse({"is_success": is_success})
else:
return JsonResponse({
"is_success": is_success,
"status_code": status_code,
"status_message": status_message,
"data": data
})
def _reject_balance_adjustment_list(self, data):
self.logger.info(
'========== Start reject balance adjustment list==========')
url = api_settings.ORDER_BAL_ADJUST_PATH
referenceIds = json.loads(data.get("referenceIds"))
data = {"reference_ids": referenceIds, "reason": data.get("reason")}
is_success, status_code, status_message, data = RestFulClient.delete_return_data(
url, headers=self._get_headers(), loggers=self.logger, params=data)
if is_success:
messages.add_message(
self.request, messages.SUCCESS,
str(len(referenceIds)) +
" adjustments being Rejected. Please wait a while and check again later"
)
return JsonResponse({"is_success": is_success})
else:
return JsonResponse({
"is_success": is_success,
"status_code": status_code,
"status_message": status_message,
"data": data
})
def search_system_user(cls,
headers=None,
logger=None,
username=None,
email=None,
user_id=None,
status=None,
paging=None,
page_index=None):
params = {}
if username is not '' and username is not None:
params['username'] = username
if email is not '' and email is not None:
params['email'] = email
if user_id is not '' and user_id is not None:
params['user_id'] = user_id
if status is not None:
if status == 'Active':
params['is_suspended'] = False
if status == 'Suspended':
params['is_suspended'] = True
if paging is not '' and paging is not None:
params['paging'] = paging
if page_index and page_index.isdigit():
params['page_index'] = int(page_index)
is_success, status_code, status_message, data = RestFulClient.post(
api_settings.SEARCH_SYSTEM_USER, headers, logger, params)
return is_success, status_code, status_message, 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 _add_user_role(self, role_id, user_id):
url = api_settings.USER_ROLE_PATH.format(role_id=role_id)
params = {'user_id': int(user_id)}
is_success_add, status_code_add, status_message_add, data = RestFulClient.post(
url, self._get_headers(), self.logger, params=params)
return is_success_add
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 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 get_call_method(self):
self.logger.info('========== Start getting spi call method ==========')
success, status_code, data = RestFulClient.get(
url=api_settings.SPI_CALL_METHOD_PATH,
loggers=self.logger,
headers=self._get_headers())
self.logger.info('========== finish get spi call method ==========')
return data
def get_spi_types(self):
self.logger.info('========== Start getting spi url types ==========')
success, status_code, data = RestFulClient.get(
url=api_settings.SPI_TYPES_PATH,
loggers=self.logger,
headers=self._get_headers())
self.logger.info('========== finish get spi url types ==========')
return data
def get_campaign_amount_limit(self, campaign_id):
url = GET_RULE_AMOUNT_LIMIT.format(rule_id=campaign_id)
success, status_code, data = RestFulClient.get(
url=url, loggers=self.logger, headers=self._get_headers())
API_Logger.get_logging(loggers=self.logger,
params={},
response=data,
status_code=status_code)
return data
def get_campaign_detail(self, campaign_id):
url = GET_CAMPAIGNS_DETAIL.format(bak_rule_id=campaign_id)
success, status_code, data = RestFulClient.get(
url=url, loggers=self.logger, headers=self._get_headers())
API_Logger.get_logging(loggers=self.logger,
params={},
response=data,
status_code=status_code)
return data
def _get_choices_types(self):
url = settings.DOMAIN_NAMES + SOF_TYPES_URL
success, status_code, data = RestFulClient.get(
url=url, loggers=self.logger, headers=self._get_headers())
API_Logger.get_logging(loggers=self.logger,
params={},
response=data,
status_code=status_code)
return {'sof_types': data}
def send(cls, method, url, params, request, description=None, log_count_field=None):
loggers = build_logger(request, __name__)
if description:
loggers.info("===== Start {} =====".format(description))
headers = build_auth_header_from_request(request)
if len(params) > 0:
loggers.info("Request data: {} ".format(params))
if method == 'GET':
is_success, status_code, data = RestFulClient.get(url, loggers, headers)
status_message = None
elif method == 'POST':
is_success, status_code, status_message, data = RestFulClient.post(url, headers, loggers, params)
elif method == 'PUT':
is_success, status_code, status_message, data = RestFulClient.put(url, headers, loggers, params)
elif method == 'DELETE':
is_success, status_code, status_message = RestFulClient.delete(url, headers, loggers, params)
data = None
if status_code in ["access_token_expire", 'authentication_fail', 'invalid_access_token']:
raise InvalidAccessToken(status_message)
if log_count_field:
log_data = data
for field in log_count_field.split('.'):
if field == "data":
continue
if log_data:
log_data = log_data.get(field, {})
else:
log_data = {}
count = len(log_data)
loggers.info('Response count: {}'.format(count))
else:
loggers.info('Response data: {}'.format(data))
if description:
loggers.info("===== Finish {} =====".format(description))
return is_success, status_code, status_message, data
def _get_card_sof_transaction(self, body):
success, status_code, status_message, data = RestFulClient.post(url=self.search_card_transaction,
headers=self._get_headers(),
loggers=self.logger,
params=body)
data = data or {}
API_Logger.post_logging(loggers=self.logger, params=body, response=data.get('card_sof_transactions', []),
status_code=status_code, is_getting_list=True)
return data, success, status_message
def _getWalletViewInDay(self):
url = api_settings.CONFIGURATION_DETAIL_URL.format(
scope=self.paymentScopeName,
key=self.walletViewTransactionHistoryInDaysKey)
success, status_code, data = RestFulClient.get(
url=url, loggers=self.logger, headers=self._get_headers())
if success:
return data.get("value")
else:
return None
def _get_preload_currencies_dropdown(self):
url = api_settings.GET_ALL_PRELOAD_CURRENCY_URL
is_success, status_code, data = RestFulClient.get(
url, loggers=self.logger, headers=self._get_headers())
if is_success:
return data
else:
# return empty list data
return []
def set_ui_list(self, context):
self.logger.info('========== Start get category list ==========')
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.GET_CATEGORIES,
headers=self._get_headers(),
loggers=self.logger,
params={})
categories = data['product_categories']
categories = [x for x in categories if not x['is_deleted']]
context['categories'] = categories
API_Logger.post_logging(loggers=self.logger,
params={},
response=categories,
status_code=status_code,
is_getting_list=True)
self.logger.info('========== Finished get category list ==========')
self.logger.info('========== Start get service list ==========')
is_success, status_code, data = RestFulClient.get(
url=api_settings.SERVICE_LIST_URL,
headers=self._get_headers(),
loggers=self.logger)
API_Logger.get_logging(loggers=self.logger,
params={},
response=data,
status_code=status_code)
context['services'] = data
self.logger.info('========== Finished get service list ==========')
self.logger.info('========== Start get agent type list ==========')
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.AGENT_TYPES_LIST_URL,
headers=self._get_headers(),
loggers=self.logger,
params={})
API_Logger.post_logging(loggers=self.logger,
params={},
response=data,
status_code=status_code,
is_getting_list=True)
context['agent_types'] = data
self.logger.info('========== Finished get agent type list ==========')
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 create_fraud_ticket(self, params):
success, status_code, message, data = RestFulClient.post(
url=CREATE_FRAUD_TICKET,
headers=self._get_headers(),
loggers=self.logger,
params=params)
API_Logger.post_logging(loggers=self.logger, params=params,
response=data, status_code=status_code)
return success, data, message
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 get_action_types_list(self):
self.logger.info('========== Start get action type list ==========')
success, status_code, data = RestFulClient.get(
url=api_settings.GET_ACTION_TYPE,
loggers=self.logger,
headers=self._get_headers())
API_Logger.get_logging(loggers=self.logger,
params={},
response=data,
status_code=status_code)
self.logger.info('========== finish get action type list ==========')
return data
def get_roles(self):
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.ROLE_LIST,
headers=self._get_headers(),
loggers=self.logger)
self.logger.info("Have {} roles in database".format(len(data)))
if is_success:
return data
else:
return []
def get_spi_list(self, service_command_id):
self.logger.info('========== Start getting SPI url list ==========')
success, status_code, data = RestFulClient.get(
url=api_settings.SPI_LIST_PATH.format(service_command_id),
loggers=self.logger,
headers=self._get_headers())
API_Logger.get_logging(loggers=self.logger,
params={},
response=data,
status_code=status_code)
self.logger.info('========== finish get SPI url list ==========')
return success, status_code, data
def update_spi(self, spi_url_id, params):
path = api_settings.SPI_UPDATE_PATH.format(spiUrlId=spi_url_id)
success, status_code, message, data = RestFulClient.put(
url=path,
headers=self._get_headers(),
loggers=self.logger,
params=params)
API_Logger.put_logging(loggers=self.logger,
params=params,
response=data,
status_code=status_code)
return success, status_code, message, data
