def get_verifications(event, context):
query_parameters = event["queryStringParameters"]
if "type" not in query_parameters:
raise BadRequestException()
response = VerificationManager().get_verifications(query_parameters)
return generate_lambda_response(StatusCode.OK, {"status": ResponseStatus.SUCCESS, "data": response, "error": {}},
cors_enabled=True)
def initiate(event, context):
payload = json.loads(event["body"])
username = event["requestContext"]["authorizer"]["claims"]["email"]
required_keys = ["type"]
if not validate_dict(payload, required_keys):
raise BadRequestException()
response = VerificationManager().initiate_verification(payload, username)
return generate_lambda_response(StatusCode.CREATED,
{"status": ResponseStatus.SUCCESS, "data": response, "error": {}},
cors_enabled=True)
def test_initiate_verification_with_jumio(self, mock_requests_post, mock_boto_utils, mock_jumio_repo,
mock_verification_repo):
username = "******"
verification_details = {
"type": "JUMIO",
"entity_id": username
}
response = VerificationManager().initiate_verification(verification_details, username)
self.assertEqual(response["redirect_url"],
"https://yourcompany.netverify.com/web/v4/app?locale=en-GB&authorizationToken=xxx")
def get_pending_individual_verification(self):
individual_verification_list = VerificationManager(
).get_pending_individual_verification(
limit=MAX_INDIVIDUAL_SLACK_LISTING)
slack_blocks = self.generate_slack_listing_blocks(
individual_verification_list)
slack_payload = {"blocks": slack_blocks}
response = requests.post(url=SLACK_APPROVAL_CHANNEL_URL,
data=json.dumps(slack_payload))
logger.info(f"{response.status_code} | {response.text}")
def test_initiate_verification_with_allowed_domain_users(self, mock_requests_post, mock_boto_utils, mock_jumio_repo,
mock_verification_repo):
username = "******"
verification_details = {
"type": "JUMIO",
"entity_id": username
}
response = VerificationManager().initiate_verification(verification_details, username)
self.assertEqual(response["redirect_url"],
"")
def callback(event, context):
logger.info(f"received event from jumio for callback {event}")
payload = event["body"]
path_parameters = event["pathParameters"]
if "verification_id" not in path_parameters:
raise BadRequestException()
verification_id = path_parameters["verification_id"]
response = VerificationManager().callback(verification_id, payload)
return generate_lambda_response(StatusCode.CREATED,
{"status": ResponseStatus.SUCCESS, "data": response, "error": {}},
cors_enabled=True)
def submit(event, context):
logger.info(f"received submit from jumio {event}")
query_parameters = event["queryStringParameters"]
path_parameters = event["pathParameters"]
if "transactionStatus" not in query_parameters:
raise BadRequestException()
status = query_parameters["transactionStatus"]
verification_id = path_parameters["verification_id"]
redirect_url = VerificationManager().submit(verification_id, status)
return generate_lambda_response(StatusCode.FOUND, {"status": ResponseStatus.SUCCESS, "data": {}, "error": {}},
cors_enabled=True, headers={"location": redirect_url})
def get_status(event, context):
query_parameters = event["queryStringParameters"]
if "type" not in query_parameters:
raise BadRequestException()
verification_type = query_parameters["type"]
if verification_type == VerificationType.JUMIO.value:
entity_id = event["requestContext"]["authorizer"]["claims"]["email"]
elif verification_type == VerificationType.DUNS.value:
entity_id = query_parameters["entity_id"]
else:
raise Exception("Invalid verification type")
response = VerificationManager().get_status_for_entity(entity_id)
return generate_lambda_response(StatusCode.OK, {"status": ResponseStatus.SUCCESS, "data": response, "error": {}},
cors_enabled=True)
def callback(event, context):
logger.info(f"received event from verification for callback {event}")
payload = event["body"]
path_parameters = event["queryStringParameters"]
if "verification_id" not in path_parameters and "entity_id" not in path_parameters:
raise BadRequestException()
entity_id = path_parameters.get("entity_id")
verification_id = path_parameters.get("verification_id")
response = VerificationManager().callback(payload,
verification_id=verification_id,
entity_id=entity_id)
return generate_lambda_response(StatusCode.CREATED, {
"status": ResponseStatus.SUCCESS,
"data": response,
"error": {}
},
cors_enabled=True)
def process_approval_comment(self, state, comment, individual_username):
verification = individual_repository.get_verification(
username=individual_username)
if verification.status in [
IndividualVerificationStatus.PENDING.value,
IndividualVerificationStatus.REJECTED.value,
IndividualVerificationStatus.CHANGE_REQUESTED.value
]:
VerificationManager().callback(json.dumps({
"verificationStatus":
state,
"comment":
comment,
"reviewed_by":
self._username
}),
entity_id=individual_username)
else:
logger.info("Approval type is not valid")
def test_submit(self, mock_boto_utils, mock_jumio_repo, mock_verification_repo):
verification_id = uuid4().hex
username = "******"
user_reference_id = "6a7e9b7d8a9e61566a7bd24345cbebdbea08389f"
created_at = datetime.utcnow()
mock_verification = Verification(id=verification_id, type="JUMIO", entity_id=username,
status=VerificationStatus.PENDING.value, requestee=username,
created_at=created_at, updated_at=created_at)
mock_verification_repo.get_verification = Mock(return_value=mock_verification)
mock_verification_repo.update_status = Mock()
mock_jumio_verification = JumioVerification(
verification_id=verification_id, username=username, user_reference_id=user_reference_id,
created_at=created_at, redirect_url="url", verification_status=JumioVerificationStatus.PENDING.value,
transaction_status=JumioTransactionStatus.PENDING.value)
mock_jumio_repo.update_transaction_status = Mock(return_value=mock_jumio_verification)
response = VerificationManager().submit(verification_id, "SUCCESS")
self.assertEqual(response, DAPP_POST_JUMIO_URL)