def post(self, request, *args, **kwargs):
self.logger.info('========== Start approve 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.post(
url, headers=self._get_headers(), loggers=self.logger, params=data)
self.logger.info(
'========== Finish approve 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 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 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):
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 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(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 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 _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 _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 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 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_bank_sof_list(self, body):
success, status_code, status_message, data = RestFulClient.post(
url=self.searchcustomerbanksofurl,
headers=self._get_headers(),
loggers=self.logger,
params=body)
data = data or {}
API_Logger.post_logging(loggers=self.logger,
params=body,
response=data.get('bank_sofs', []),
status_code=status_code,
is_getting_list=True)
return data, success, status_message
def add_spi(self, service_command_id, params):
self.logger.info(
"========== Start adding SPI URL by service command ==========")
path = api_settings.SPI_ADD_PATH.format(service_command_id)
success, status_code, message, data = RestFulClient.post(
url=path,
headers=self._get_headers(),
loggers=self.logger,
params=params)
self.logger.info("param is : {}".format(params))
self.logger.info(
"========== Finish adding SPI URL by service command ==========")
return success, status_code, message, data
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 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 create_condition(self, rule_id, mechanic_id, params):
success, status_code, message, data = RestFulClient.post(
url=api_settings.CREATE_CONDITION.format(rule_id=rule_id,
mechanic_id=mechanic_id),
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 _do_approval(self, request):
self.logger.info(
'========== Start Approve balance adjustment order ==========')
reference_id = request.POST.get('reference_id')
url = api_settings.APPROVE_BAL_ADJUST_PATH.format(
reference_id=reference_id)
#url = 'http://localhost:4393/general_error_approval'
body = {'reason': request.POST.get('reason_for_approval_or_reject')}
is_success, status_code, status_message, data = RestFulClient.post(
url=url,
headers=self._get_headers(),
loggers=self.logger,
params=body)
API_Logger.post_logging(loggers=self.logger,
params=body,
response=data,
status_code=status_code)
self.logger.info(
'========== Finish Approve balance adjustment order ==========')
if is_success:
messages.add_message(request, messages.SUCCESS,
'Payment is approved successfully')
return redirect('balance_adjustment:balance_adjustment_list')
elif status_code.lower() in ["general_error"]:
error_msg = 'Other error, please contact system administrator'
return self._handle_error(error_msg, reference_id)
# If get error timeout, response as success to client
elif status_code.lower() in [
"external_call_timeout", "internal_call_timeout",
"sof_timeout", "timeout"
]:
self.logger.info(
'get timeout error from server but considers as success to client'
)
messages.add_message(request, messages.SUCCESS,
'Payment is approved successfully')
return redirect('balance_adjustment:balance_adjustment_list')
elif status_message == 'timeout':
messages.add_message(
request, messages.ERROR,
'Request timed-out, please try again or contact system administrator'
)
return redirect('balance_adjustment:balance_adjustment_detail',
ReferenceId=reference_id)
else:
return self._handle_error(status_message, reference_id)
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_user_role(self, user_id):
params = {'user_id': user_id}
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.ROLE_LIST,
headers=self._get_headers(),
loggers=self.logger,
params=params)
self.logger.info("User have {} role id".format(data))
if is_success:
if len(data) > 0:
return data[0]
else:
return {}
else:
return []
def get_context_data(self, **kwargs):
self.logger.info('========== Start get role entity ==========')
context = super(RoleEditView, self).get_context_data(**kwargs)
role_id = context['role_id']
self.logger.info("Searching role with [{}] role id".format(role_id))
params = {'id': role_id}
is_success, status_code, status_message, data = RestFulClient.post(
url=api_settings.ROLE_LIST,
headers=self._get_headers(),
loggers=self.logger,
params=params)
if is_success:
context['role'] = data[0]
self.logger.info('========== End get role entity ==========')
return context
def _get_transaction_history_list(self, body):
success, status_code, status_message, data = RestFulClient.post(
url=api_settings.BALANCE_MOVEMENT_LIST_PATH,
headers=self._get_headers(),
loggers=self.logger,
params=body,
timeout=settings.GLOBAL_TIMEOUT)
data = data or {}
order_balance_movements = data.get('order_balance_movements', [])
page = data.get("page", {})
API_Logger.post_logging(loggers=self.logger,
params=body,
response=order_balance_movements,
status_code=status_code,
is_getting_list=True)
return order_balance_movements, page, success, status_message
def get_card_list(self, body):
api_path = api_settings.CARD_LIST_PATH
# api_path = 'http://localhost:4693/search_card_profile'
success, status_code, status_message, data = RestFulClient.post(url=api_path,
headers=self._get_headers(),
loggers=self.logger,
params=body,
timeout=settings.GLOBAL_TIMEOUT)
data = data or {}
API_Logger.post_logging(loggers=self.logger, params=body, response=data.get('cards', []),
status_code=status_code, is_getting_list=True)
return data, success, status_message
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_otp_list(self, body):
is_success, status_code, status_message, data = RestFulClient.post(url=api_settings.OTP_URL,
headers=self._get_headers(),
loggers=self.logger,
params=body)
if not is_success:
data = {'otps': []}
messages.add_message(
self.request,
messages.ERROR,
status_message
)
API_Logger.post_logging(loggers=self.logger, params=body, response=data['otps'],
status_code=status_code, is_getting_list=True)
return data, is_success
def _create_refund_request(self, voucher_refund_request):
url = CREATE_REFUND_REQUEST
params = voucher_refund_request
is_success, status_code, status_message, data = RestFulClient.post(
url=url,
headers=self._get_headers(),
loggers=self.logger,
params=params,
timeout=settings.GLOBAL_TIMEOUT)
API_Logger.post_logging(loggers=self.logger,
params=params,
response=data,
status_code=status_code)
if not is_success:
data = []
return data['voucher_refund_id']
def _get_cash_sof_list(self, user_id, user_type):
self.logger.info('========== Start getting cash sof list ==========')
body = {}
body['user_id'] = int(user_id)
body['user_type'] = int(user_type)
success, status_code, status_message, data = RestFulClient.post(
url=CASH_SOFS_URL,
headers=self._get_headers(),
params=body,
loggers=self.logger)
data = data or {}
API_Logger.post_logging(loggers=self.logger,
params=body,
response=data.get('cash_sofs', []),
status_code=status_code,
is_getting_list=True)
self.logger.info('========== Finish getting cash sof list ==========')
return 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
