def post():
"""POST method handler, creates registration requests."""
tracking_id = uuid.uuid4()
try:
args = RegDetails.curate_args(request)
schema = RegistrationDetailsSchema()
file = request.files.get('file')
validation_errors = schema.validate(args)
if validation_errors:
return Response(app.json_encoder.encode(validation_errors),
status=CODES.get("UNPROCESSABLE_ENTITY"),
mimetype=MIME_TYPES.get("APPLICATION_JSON"))
if file:
file_name = file.filename.split("/")[-1]
response = Utilities.store_file(file, tracking_id)
if response:
return Response(
json.dumps(response),
status=CODES.get("UNPROCESSABLE_ENTITY"),
mimetype=MIME_TYPES.get("APPLICATION_JSON"))
response = Utilities.process_reg_file(file_name, tracking_id,
args)
if isinstance(response, list):
response = RegDetails.create(args, tracking_id)
else:
return Response(
app.json_encoder.encode(response),
status=CODES.get("UNPROCESSABLE_ENTITY"),
mimetype=MIME_TYPES.get("APPLICATION_JSON"))
else:
Utilities.create_directory(tracking_id)
response = RegDetails.create(args, tracking_id)
db.session.commit()
response = schema.dump(response, many=False).data
return Response(json.dumps(response),
status=CODES.get("OK"),
mimetype=MIME_TYPES.get("APPLICATION_JSON"))
except Exception as e: # pragma: no cover
db.session.rollback()
app.logger.exception(e)
Utilities.remove_directory(tracking_id)
app.logger.exception(e)
data = {
'message': [
_('Registration request failed, check upload path or database connection'
)
]
}
return Response(app.json_encoder.encode(data),
status=CODES.get('INTERNAL_SERVER_ERROR'),
mimetype=MIME_TYPES.get('APPLICATION_JSON'))
finally:
db.session.close()
def create_registration(data, tracking_id):
""" Helper method to create a registration request"""
return RegDetails.create(data, tracking_id)
def post(self):
"""POST method handler, creates registration requests."""
tracking_id = uuid.uuid4()
try:
# get the posted data
args = RegDetails.curate_args(request)
# create Marshmallow object
schema = RegistrationDetailsSchema()
# validate CNIC number
if not args['cnic'] or not args['cnic'].isdigit():
messages = {
'from': 'DRS-USSD',
'to': args['msisdn'],
'content': "CNIC number is mandatory and must be digits only."
}
self.messages_list.append(messages.copy())
print("Printing the jasmin message")
print(messages)
jasmin_send_response = Jasmin.send_batch(self.messages_list, network=args['network'])
app.logger.info("Jasmin API response: " + str(jasmin_send_response.status_code))
return Response(app.json_encoder.encode({"message": "CNIC number is mandatory and must be digits only."}), status=CODES.get("UNPROCESSABLE_ENTITY"),
mimetype=MIME_TYPES.get("APPLICATION_JSON"))
# Multi SIM Validation
response = ast.literal_eval(args['imeis'])
message = DeviceDetailsRoutes.multi_sim_validate(response)
if message is True:
pass
elif message is False:
messages = {
'from': 'DRS-USSD',
'to': args['msisdn'],
'content': "Something went wrong, please try again later"
}
self.messages_list.append(messages.copy())
print("Printing the jasmin message")
print(self.messages_list)
jasmin_send_response = Jasmin.send_batch(self.messages_list, network=args['network'])
app.logger.info("Jasmin API response: " + str(jasmin_send_response.status_code))
data = {'message': "Something went wrong while checking multi sim check please try again later!"}
return Response(app.json_encoder.encode(data), status=CODES.get('UNPROCESSABLE_ENTITY'),
mimetype=MIME_TYPES.get('APPLICATION_JSON'))
else:
# create messages for user if any
changed_msgs = []
for key1, val1 in message.items():
for key2, val2 in val1.items():
val2 = Ussd_helper.check_forbidden_string(val2)
changed_dict = {key2:val2}
changed_msgs.append(changed_dict)
messages = {
'from': 'DRS-USSD',
'to': args['msisdn'],
'content': val2
}
self.messages_list.append(messages.copy())
# message = changed_msgs
print("Printing the jasmin message")
print(self.messages_list)
jasmin_send_response = Jasmin.send_batch(self.messages_list, network = args['network'])
app.logger.info("Jasmin API response: " + str(jasmin_send_response.status_code))
data = {'message': changed_msgs}
return Response(app.json_encoder.encode(data), status=CODES.get('UNPROCESSABLE_ENTITY'),
mimetype=MIME_TYPES.get('APPLICATION_JSON'))
# validate posted data
validation_errors = schema.validate(args)
if validation_errors:
for key, value in validation_errors.items():
str_val = ''
if key == "imeis":
if isinstance(value[0], dict):
for k_i, v_i in value[0].items():
str_val = str_val + str(v_i[0] + ' ' + args['imeis'][0][k_i])+". "
else:
print(validation_errors)
str_val = str_val + str(value[0])
else:
if key == "msisdn":
if isinstance(value, list):
str_val = str_val + str(value[0])
messages = {
'from': 'DRS-USSD',
'to': args['msisdn'],
'content': key +':' + str(value[0]) if not dict else str(str_val)
}
self.messages_list.append(messages.copy())
print("Printing the jasmin messages")
print(self.messages_list)
jasmin_send_response = Jasmin.send_batch(self.messages_list, network = args['network'])
app.logger.info("Jasmin API response: " + str(jasmin_send_response.status_code))
return Response(app.json_encoder.encode(validation_errors), status=CODES.get("UNPROCESSABLE_ENTITY"),
mimetype=MIME_TYPES.get("APPLICATION_JSON"))
else:
# call KeyCloak for admin Token
admin_token_data = Key_cloak.get_admin_token()
# call KeyCloak with token for
user_data = Key_cloak.check_user_get_data(args, admin_token_data)
# if user is created, a password is set for it
arguments = Ussd_helper.set_args_dict_for_regdetails(args, user_data)
reg_response = RegDetails.create(arguments, tracking_id)
db.session.commit()
# get GSMA information and make device call. we get the device id
if reg_response.id:
schema2 = rdSchema()
response = schema2.dump(reg_response, many=False).data
# Todo: add logging here or below after condition check
log = EsLog.new_request_serialize(response, 'USSD Registration', method='Post',
imeis=arguments['imeis'])
EsLog.insert_log(log)
# get the tac from an imei in the dict and search for GSMA record
tac = arguments['imeis'][0][0][0:8]
gsma_url = str(app.config['CORE_BASE_URL']+app.config['API_VERSION'])+str('/tac/'+tac)
# get GSMA record against each TAC and match them with IMEIs count given in list
gsma_response = requests.get(gsma_url).json()
if gsma_response["gsma"] is None:
# GSMA record not found for the said TAC
messages = {
'from': 'DRS-USSD',
'to': args['msisdn'],
'content': "No record found for TAC:" + str(tac)
}
self.messages_list.append(messages.copy())
print("Printing the jasmin messages")
print(self.messages_list)
jasmin_send_response = Jasmin.send_batch(self.messages_list, network = args['network'])
app.logger.info("Jasmin API response: " + str(jasmin_send_response.status_code))
data = {'message': messages['content']}
return Response(app.json_encoder.encode(data), status=CODES.get('UNPROCESSABLE_ENTITY'),
mimetype=MIME_TYPES.get('APPLICATION_JSON'))
else:
# set device data args
device_arguments = Ussd_helper.set_args_dict_for_devicedetails(reg_response, arguments, gsma_response)
reg_details = RegDetails.get_by_id(reg_response.id)
if reg_details:
device_arguments.update({'reg_details_id': reg_details.id})
else:
device_arguments.update({'reg_details_id': ''})
device_arguments.update({'device_type': 'Smartphone'})
reg_device = RegDevice.create(device_arguments)
reg_device.technologies = DeviceTechnology.create(
reg_device.id, device_arguments.get('technologies'), True)
device_status = 'Pending Review'
reg_details.update_status(device_status)
DeviceQuotaModel.get_or_create(reg_response.user_id, 'ussd')
Utilities.create_directory(tracking_id)
db.session.commit()
device_schema = DeviceDetailsSchema()
device_serialize_data = device_schema.dump(reg_device, many=False).data
log = EsLog.new_device_serialize(device_serialize_data, request_type="USSD Device Registration",
regdetails=reg_details,
reg_status=device_status, method='Post')
EsLog.insert_log(log)
Device.create(reg_details, reg_device.id, ussd=True)
# delay the process 5 seconds to complete the process
time.sleep(5)
# get the device details
reg_details = RegDetails.get_by_id(reg_response.id)
status_msg = Ussd_helper.set_message_for_user_info(reg_details.status)
# if reg_details.status == 6:
status_msg = status_msg + " Your device tracking id is: " + str(reg_details.id)
# send user a details about device
messages = {
'from': 'DRS-USSD',
'to': args['msisdn'],
'content': status_msg
}
self.messages_list.append(messages.copy())
# send username and password to the new user
if 'password' in user_data:
messages = {
'from': 'DRS-USSD',
'to': args['msisdn'],
'content': "New user credentials are, username: "******" and password: "******"Jasmin API response: " + str(jasmin_send_response.status_code))
app.logger.info("Printing the message array in CLI mode.")
app.logger.info(self.messages_list)
response = {
'message': 'Device registration has been processed successfully.'
}
if status_msg:
response['status_response'] = status_msg
return Response(json.dumps(response), status=CODES.get("OK"),
mimetype=MIME_TYPES.get("APPLICATION_JSON"))
else:
# error in regdetails
messages = {
'from': 'DRS-USSD',
'to': args['msisdn'],
'content': "Registration request failed, check upload path or database connection"
}
self.messages_list.append(messages.copy())
jasmin_send_response = Jasmin.send_batch(self.messages_list, network = args['network'])
app.logger.info("Jasmin API response: " + str(jasmin_send_response.status_code))
# response = schema.dump(response, many=False).data
data = {'message': [_('Device undergone the process. Please hold your breath.')]}
return Response(app.json_encoder.encode(data), status=CODES.get('UNPROCESSABLE_ENTITY'),
mimetype=MIME_TYPES.get('APPLICATION_JSON'))
except Exception as e: # pragma: no cover
db.session.rollback()
app.logger.exception(e)
data = {
'message': [_('Registration request failed, check upload path or database connection')]
}
return Response(app.json_encoder.encode(data), status=CODES.get('INTERNAL_SERVER_ERROR'),
mimetype=MIME_TYPES.get('APPLICATION_JSON'))
finally:
db.session.close()
