def test_registration_request_information_requested(flask_app, db): # pylint: disable=unused-argument
"""Verify that when any of the section is marked as information requested the
system automatically mark the whole request as information requested.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['11110673016888']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 7',
'user_id': 'reg-req-approve-rev-user-7'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-7', 'reg req approve rev user 7')
assert request
request_id = request.id
user_id = request.user_id
device_data = {
'brand': 'samsung',
'operating_system': 'android',
'model_name': 's9',
'model_num': '30jjd',
'device_type': 'Smartphone',
'technologies': '2G,3G,4G',
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
# create user quota
quota = DeviceQuota.create(user_id, 'individual')
assert quota
# approve all sections manually
RegComments.add('device_quota', 'test comment on section', 'reg-req-approve-rev-user-7',
'reg req approve rev user 7', 6, request_id)
RegComments.add('device_description', 'test comment on section', 'reg-req-approve-rev-user-7',
'reg req approve rev user 7', 6, request_id)
RegComments.add('imei_classification', 'test comment on section', 'reg-req-approve-rev-user-7',
'reg req approve rev user 7', 5, request_id)
RegComments.add('imei_registration', 'test comment on section', 'reg-req-approve-rev-user-7',
'reg req approve rev user 7', 6, request_id)
RegComments.add('approval_documents', 'test comment on section', 'reg-req-approve-rev-user-7',
'reg req approve rev user 7', 6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'reg-req-approve-rev-user-7'
}
rv = flask_app.put(SUBMIT_REVIEW_API, data=json.dumps(body_data), headers=headers)
assert rv.status_code == 201
data = json.loads(rv.data.decode('utf-8'))
assert data['status'] == 5
assert data['request_id'] == request_id
assert data['message'] == 'case {0} updated successfully'.format(request_id)
assert data['request_type'] == 'registration_request'
assert Notification.exist_users(user_id)
def test_user_device_quota(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api correctly responds the user's device quota."""
# registration request
reviewer_id = 'section-rev-1'
reviewer_name = 'section rev'
user_name = 'dev quota user'
user_id = 'dev_quota_user_1'
data = {
'device_count': 2,
'imei_per_device': 1,
'imeis': "[['86834403015010', '86834403015011']]",
'm_location': 'local',
'user_name': user_name,
'user_id': user_id
}
request = create_assigned_dummy_request(data, 'Registration', reviewer_id,
reviewer_name)
assert request
request_id = request.id
# create a device quota
quota = DeviceQuota.get_or_create(user_id, 3)
assert quota
# api call
rv = flask_app.get('{0}?request_id={1}'.format(DEVICE_QUOTA_API,
request_id))
assert rv.status_code == 200
response = json.loads(rv.data.decode('utf-8'))
assert response['allowed_import_quota'] == quota['reg_quota']
assert response['allowed_export_quota']
assert quota['user_id'] == user_id
assert response['request_device_count'] == 2
def test_registration_request_duplicated_imeis(flask_app, db): # pylint: disable=unused-argument
"""Verify that the system does not allow the request approval when
there are duplicated imeis in the request and responds properly.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['00010673016999']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 6',
'user_id': 'reg-req-approve-rev-user-6'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-6', 'reg req approve rev user 6')
assert request
request_id = request.id
user_id = request.user_id
# add duplicated imei to approvedimeis
approved_imei = ApprovedImeis('00010673016999', 673739, 'whitelist', 'update')
approved_imei.add()
device_data = {
'brand': 'samsung',
'operating_system': 'android',
'model_name': 's9',
'model_num': '30jjd',
'device_type': 'Smartphone',
'technologies': '2G,3G,4G',
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
# create user quota
quota = DeviceQuota.create(user_id, 'individual')
assert quota
# approve all sections manually
RegComments.add('device_quota', 'test comment on section', 'reg-req-approve-rev-user-6',
'reg req approve rev user 6', 6, request_id)
RegComments.add('device_description', 'test comment on section', 'reg-req-approve-rev-user-6',
'reg req approve rev user 6', 6, request_id)
RegComments.add('imei_classification', 'test comment on section', 'reg-req-approve-rev-user-6',
'reg req approve rev user 6', 6, request_id)
RegComments.add('imei_registration', 'test comment on section', 'reg-req-approve-rev-user-6',
'reg req approve rev user 6', 6, request_id)
RegComments.add('approval_documents', 'test comment on section', 'reg-req-approve-rev-user-6',
'reg req approve rev user 6', 6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'reg-req-approve-rev-user-6'
}
rv = flask_app.put(SUBMIT_REVIEW_API, data=json.dumps(body_data), headers=headers)
assert rv.status_code == 400
data = json.loads(rv.data.decode('utf-8'))
assert data['error'] == ['unable to approve case {0}, duplicated imeis found'.format(request_id)]
def test_registration_request_info_requested_status_priority(flask_app, db): # pylint: disable=unused-argument
"""Verify that the information requested section status has the 2nd highest priority means
when any of the section is marked as information requested the whole case will be marked as
information requested regardless of other section statuses.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['44414441016777']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 10',
'user_id': 'reg-req-approve-rev-user-10'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-10', 'reg req approve rev user 10')
assert request
request_id = request.id
user_id = request.user_id
device_data = {
'brand': 'samsung',
'operating_system': 'android',
'model_name': 's9',
'model_num': '30jjd',
'device_type': 'Smartphone',
'technologies': '2G,3G,4G',
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
# create user quota
quota = DeviceQuota.create(user_id, 'individual')
assert quota
# mark only one section as information requested
RegComments.add('device_quota', 'test comment on section', 'reg-req-approve-rev-user-10',
'reg req approve rev user 10', 6, request_id)
RegComments.add('device_description', 'test comment on section', 'reg-req-approve-rev-user-10',
'reg req approve rev user 10', 6, request_id)
RegComments.add('imei_classification', 'test comment on section', 'reg-req-approve-rev-user-7',
'reg req approve rev user 7', 5, request_id)
RegComments.add('imei_registration', 'test comment on section', 'reg-req-approve-rev-user-7',
'reg req approve rev user 7', 6, request_id)
RegComments.add('approval_documents', 'test comment on section', 'reg-req-approve-rev-user-7',
'reg req approve rev user 7', 6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'reg-req-approve-rev-user-10'
}
rv = flask_app.put(SUBMIT_REVIEW_API, data=json.dumps(body_data), headers=headers)
assert rv.status_code == 201
data = json.loads(rv.data.decode('utf-8'))
assert data['status'] == 5
assert data['request_id'] == request_id
def test_registration_request_rejected_status_priority(flask_app, db): # pylint: disable=unused-argument
"""Verify that the rejected section status have highest priority means
even if the first section is rejected, remaining are not reviewed, the
system allows the review submission and mark the request as rejected.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['33310001016666']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 9',
'user_id': 'reg-req-approve-rev-user-9'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-9',
'reg req approve rev user 9')
assert request
request_id = request.id
user_id = request.user_id
device_data = {
'brand': 'samsung',
'operating_system': 'android',
'model_name': 's9',
'model_num': '30jjd',
'device_type': 'Smartphone',
'technologies': '2G,3G,4G',
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
# create user quota
quota = DeviceQuota.create(user_id, 'individual')
assert quota
# reject device quota and mark device_description as info-requested
RegComments.add('device_quota', 'test comment on section',
'reg-req-approve-rev-user-9', 'reg req approve rev user 9',
7, request_id)
RegComments.add('device_description', 'test comment on section',
'reg-req-approve-rev-user-9', 'reg req approve rev user 9',
5, request_id)
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'reg-req-approve-rev-user-9'
}
rv = flask_app.put(SUBMIT_REVIEW_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 201
data = json.loads(rv.data.decode('utf-8'))
assert data['status'] == 7
assert data['request_id'] == request_id
def test_registration_request_any_section_none(flask_app, db): # pylint: disable=unused-argument
"""Verify that the system does not allow to submit the review when any
of the section is not reviewed or status is none.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['22210376016777']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 8',
'user_id': 'reg-req-approve-rev-user-8'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-8',
'reg req approve rev user 8')
assert request
request_id = request.id
user_id = request.user_id
device_data = {
'brand': 'samsung',
'operating_system': 'android',
'model_name': 's9',
'model_num': '30jjd',
'device_type': 'Smartphone',
'technologies': '2G,3G,4G',
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
# create user quota
quota = DeviceQuota.create(user_id, 'individual')
assert quota
# approve only 2 section, leave rest of them none
RegComments.add('device_quota', 'test comment on section',
'reg-req-approve-rev-user-8', 'reg req approve rev user 8',
6, request_id)
RegComments.add('device_description', 'test comment on section',
'reg-req-approve-rev-user-8', 'reg req approve rev user 8',
6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'reg-req-approve-rev-user-8'
}
rv = flask_app.put(SUBMIT_REVIEW_API,
data=json.dumps(body_data),
headers=headers)
assert rv.status_code == 400
data = json.loads(rv.data.decode('utf-8'))
assert data['error'] == [
'unable to update case {0}, complete review process'.format(request_id)
]
def create_device_quota(self, data):
"""Create a new device quotes for the user."""
if 'user_id' in data:
DeviceQuota.get_or_create(data['user_id'], 'importer')
def test_de_registration_request_approval(flask_app, db, app):
"""Verify that the system approves the request when all the sections are approved
and de-register imeis successfully.
"""
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['121621090005119']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 9',
'user_id': 'reg-req-approve-rev-user-9'
}
request = create_assigned_dummy_request(data, 'Registration',
'dereg-req-approve-rev-user-10', 'dereg req approve rev user 10')
assert request
request_id = request.id
user_id = request.user_id
device_data = {
'brand': 'samsung',
'operating_system': 'android',
'model_name': 's9',
'model_num': '30jjd',
'device_type': 'Smartphone',
'technologies': '2G,3G,4G',
'reg_id': request_id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
# create user quota
quota = DeviceQuota.create(user_id, 'individual')
assert quota
de_registration_data = {
'file': 'de-reg-test-file.txt',
'device_count': 1,
'user_id': 'dereg-req-approve-rev-user-10',
'user_name': 'dereg req approve rev user 10',
'reason': 'because we have to run tests successfully'
}
request = create_assigned_dummy_request(de_registration_data, 'De_Registration', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10')
device_data = {
'devices': """[
{
"tac": "12162109",
"model_name": "TA-1034",
"brand_name": "NOKIA",
"model_num": "TA-1034",
"technology": "NONE",
"device_type": "Mobile Phone/Feature phone",
"count": 2,
"operating_system": "N/A"
}
]""",
'dereg_id': request.id
}
request = create_dummy_devices(device_data, 'De_Registration', request, db, file_content=['121621090005119'],
file_path='{0}/{1}/{2}'.format(app.config['DRS_UPLOADS'], request.tracking_id,
de_registration_data.get('file')))
assert request
request_id = request.id
# add imei to approvedimeis as whitelist to de register
approved_imei = ApprovedImeis.get_imei('12162109000511')
approved_imei.status = 'whitelist'
approved_imei.delta_status = 'update'
ApprovedImeis.bulk_insert_imeis([approved_imei])
DeRegComments.add('device_description', 'test comment on section', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10', 6, request_id)
DeRegComments.add('imei_classification', 'test comment on section', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10', 6, request_id)
DeRegComments.add('imei_registration', 'test comment on section', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10', 6, request_id)
DeRegComments.add('approval_documents', 'test comment on section', 'dereg-req-approve-rev-user-10',
'dereg req approve rev user 10', 6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'de_registration_request',
'reviewer_id': 'dereg-req-approve-rev-user-10'
}
rv = flask_app.put(SUBMIT_REVIEW_API, data=json.dumps(body_data), headers=headers)
assert rv.status_code == 201
response = json.loads(rv.data.decode('utf-8'))
imei = ApprovedImeis.get_imei('12162109000511')
assert response['request_type'] == 'de_registration_request'
assert response['status'] == 6
assert response['request_id'] == request_id
assert imei.status == 'removed'
def test_registration_request_approval(flask_app, db): # pylint: disable=unused-argument
"""Verify that the api behave properly upon approval of the request."""
# only one section is reviewed and rejected
headers = {'Content-Type': 'application/json'}
data = {
'device_count': 1,
'imei_per_device': 1,
'imeis': "[['94310813016000']]",
'm_location': 'local',
'user_name': 'reg req approve rev user 5',
'user_id': 'reg-req-approve-rev-user-5'
}
request = create_assigned_dummy_request(data, 'Registration',
'reg-req-approve-rev-user-5', 'reg req approve rev user 5')
assert request
request_id = request.id
user_id = request.user_id
device_data = {
'brand': 'samsung',
'operating_system': 'android',
'model_name': 's9',
'model_num': '30jjd',
'device_type': 'Smartphone',
'technologies': '2G,3G,4G',
'reg_id': request.id
}
request = create_dummy_devices(device_data, 'Registration', request)
assert request
# create user quota
quota = DeviceQuota.create(user_id, 'individual')
assert quota
user_reg_quota = quota.reg_quota
# approve all sections manually
RegComments.add('device_quota', 'test comment on section', 'reg-req-approve-rev-user-5',
'reg req approve rev user 5', 6, request_id)
RegComments.add('device_description', 'test comment on section', 'reg-req-approve-rev-user-5',
'reg req approve rev user 5', 6, request_id)
RegComments.add('imei_classification', 'test comment on section', 'reg-req-approve-rev-user-5',
'reg req approve rev user 5', 6, request_id)
RegComments.add('imei_registration', 'test comment on section', 'reg-req-approve-rev-user-5',
'reg req approve rev user 5', 6, request_id)
RegComments.add('approval_documents', 'test comment on section', 'reg-req-approve-rev-user-5',
'reg req approve rev user 5', 6, request_id)
body_data = {
'request_id': request_id,
'request_type': 'registration_request',
'reviewer_id': 'reg-req-approve-rev-user-5'
}
rv = flask_app.put(SUBMIT_REVIEW_API, data=json.dumps(body_data), headers=headers)
assert rv.status_code == 201
data = json.loads(rv.data.decode('utf-8'))
assert data['status'] == 6
assert data['request_id'] == request_id
assert data['message'] == 'case {0} updated successfully'.format(request_id)
assert data['request_type'] == 'registration_request'
imei = ApprovedImeis.get_imei('94310813016000')
assert imei.status == 'whitelist'
assert imei.delta_status == 'add'
assert Notification.exist_users(user_id)
assert DeviceQuota.get(user_id).reg_quota == user_reg_quota - 1
def auto_approve(task_id, reg_details):
# TODO: Need to remove duplicated session which throws warning
from app.api.v1.resources.reviewer import SubmitReview
from app.api.v1.models.devicequota import DeviceQuota as DeviceQuotaModel
from app.api.v1.models.status import Status
from app.api.v1.models.eslog import EsLog
import json
sr = SubmitReview()
try:
result = Utilities.check_request_status(task_id)
section_status = 6
sections_comment = "Auto"
auto_approved_sections = [
'device_quota', 'device_description', 'imei_classification',
'imei_registration'
]
if result:
if result['non_compliant'] != 0 or result['stolen'] != 0 or result['compliant_active'] != 0 \
or result['provisional_non_compliant'] != 0:
sections_comment = sections_comment + ' Rejected, Device/s found in Non-Compliant State'
status = 'Rejected'
section_status = 7
message = 'Your request {id} has been rejected because Non-Compliant Device Found in it.'.format(
id=reg_details.id)
else:
sections_comment = sections_comment + ' Approved'
status = 'Approved'
message = 'Your request {id} has been Approved'.format(
id=reg_details.id)
if status == 'Approved':
# checkout device quota
imeis = DeRegDetails.get_normalized_imeis(reg_details)
user_quota = DeviceQuotaModel.get(reg_details.user_id)
current_quota = user_quota.reg_quota
user_quota.reg_quota = current_quota - len(imeis)
DeviceQuotaModel.commit_quota_changes(user_quota)
imeis = DeRegDetails.get_normalized_imeis(reg_details)
Utilities.de_register_imeis(imeis)
for section in auto_approved_sections:
DeRegDetails.add_comment(section, sections_comment,
reg_details.user_id,
'Auto Reviewed',
section_status,
reg_details.id)
sr._SubmitReview__generate_notification(
user_id=reg_details.user_id,
request_id=reg_details.id,
request_type='de-registration',
request_status=section_status,
message=message)
reg_details.summary = json.dumps({'summary': result})
reg_details.report = result.get('compliant_report_name')
reg_details.update_report_status('Processed')
reg_details.update_status(status)
reg_details.report_allowed = True
reg_details.save()
db.session.commit()
# create log
log = EsLog.auto_review(reg_details, "De-Registration Request",
'Post', status)
EsLog.insert_log(log)
return True
else:
reg_details.update_processing_status('Failed')
reg_details.update_report_status('Failed')
reg_details.update_status('Failed')
db.session.commit()
log = EsLog.auto_review(
reg_details, "De-Registration Request", 'Post',
Status.get_status_type(reg_details.status))
EsLog.insert_log(log)
except Exception as e: # pragma: no cover
app.logger.exception(e)
db.session.rollback()
reg_details.update_processing_status('Failed')
reg_details.update_status('Failed')
message = 'Your request {id} has failed please re-initiate device request'.format(
id=reg_details.id)
sr._SubmitReview__generate_notification(
user_id=reg_details.user_id,
request_id=reg_details.id,
request_type='registration',
request_status=7,
message=message)
db.session.commit()
# create log
log = EsLog.auto_review(reg_details, "De-Registration Request",
'Post',
Status.get_status_type(reg_details.status))
EsLog.insert_log(log)
def auto_approve(task_id, reg_details, flatten_imeis, app):
from app.api.v1.resources.reviewer import SubmitReview
from app.api.v1.models.devicequota import DeviceQuota as DeviceQuotaModel
from app.api.v1.models.eslog import EsLog
from app.api.v1.models.status import Status
import json
sr = SubmitReview()
try:
result = Utilities.check_request_status(task_id)
duplicate_imeis = RegDetails.get_duplicate_imeis(reg_details)
res = RegDetails.get_imeis_count(reg_details.user_id)
sections_comment = "Auto"
section_status = 6
auto_approved_sections = [
'device_quota', 'device_description', 'imei_classification',
'imei_registration'
]
if result:
flatten_imeis = Utilities.bulk_normalize(flatten_imeis)
if result['non_compliant'] != 0 or result['stolen'] != 0 or result['compliant_active'] != 0 \
or result['provisional_non_compliant'] != 0 or result['provisional_compliant'] != 0:
sections_comment = sections_comment + ' Rejected, Device/Devices found in Non-Compliant States'
status = 'Rejected'
section_status = 7
message = 'Your request {id} has been rejected'.format(
id=reg_details.id)
else:
sections_comment = sections_comment + ' Approved'
status = 'Approved'
message = 'Your request {id} has been Approved'.format(
id=reg_details.id)
if duplicate_imeis:
res.update({
'duplicated':
len(RegDetails.get_duplicate_imeis(reg_details))
})
Utilities.generate_imeis_file(duplicate_imeis,
reg_details.tracking_id,
'duplicated_imeis')
reg_details.duplicate_imeis_file = '{upload_dir}/{tracking_id}/{file}'.format(
upload_dir=app.config['DRS_UPLOADS'],
tracking_id=reg_details.tracking_id,
file='duplicated_imeis.txt')
sections_comment = "Auto"
status = 'Rejected'
sections_comment = sections_comment + ' Rejected, Duplicate IMEIS Found, Please check duplicate file'
section_status = 7
message = 'Your request {id} has been rejected because duplicate imeis found!'.format(
id=reg_details.id)
if status == 'Approved':
# checkout device quota
imeis = RegDetails.get_normalized_imeis(reg_details)
user_quota = DeviceQuotaModel.get(reg_details.user_id)
current_quota = user_quota.reg_quota
user_quota.reg_quota = current_quota - len(imeis)
DeviceQuotaModel.commit_quota_changes(user_quota)
sr._SubmitReview__update_to_approved_imeis(flatten_imeis)
else:
sr._SubmitReview__change_rejected_imeis_status(
flatten_imeis)
for section in auto_approved_sections:
RegDetails.add_comment(section, sections_comment,
reg_details.user_id,
'Auto Reviewed', section_status,
reg_details.id)
reg_details.summary = json.dumps({'summary': result})
reg_details.report = result.get('compliant_report_name')
reg_details.update_report_status('Processed')
reg_details.report_allowed = True
reg_details.update_status(status)
sr._SubmitReview__generate_notification(
user_id=reg_details.user_id,
request_id=reg_details.id,
request_type='registration',
request_status=section_status,
message=message)
reg_details.save()
db.session.commit()
# create log
log = EsLog.auto_review(reg_details, "Registration Request",
'Post', status)
EsLog.insert_log(log)
except Exception as e: # pragma: no cover
db.session.rollback()
reg_details.update_processing_status('Failed')
reg_details.update_status('Failed')
message = 'Your request {id} has failed please re-initiate device request'.format(
id=reg_details.id)
sr._SubmitReview__generate_notification(
user_id=reg_details.user_id,
request_id=reg_details.id,
request_type='registration',
request_status=7,
message=message)
db.session.commit()
app.logger.exception(e)
# create log
log = EsLog.auto_review(reg_details, "Registration Request",
'Post',
Status.get_status_type(reg_details.status))
EsLog.insert_log(log)
return True
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()
