def test_invite_members(self, mock_invoke_lambda):
mock_invoke_lambda.return_value = None
test_org_uuid = uuid4().hex
owner_username = "******"
org_repo.add_organization(
DomainOrganization(test_org_uuid, "org_id", "org_dummy",
"ORGANIZATION", ORIGIN, "description",
"short_description", "https://test.io",
ORG_CONTACTS, {}, "ipfs_hash", "123456879", [],
[], [], []), owner_username,
OrganizationStatus.PUBLISHED.value)
new_org_members = [{
"username": "******"
}, {
"username": "******"
}, {
"username": "******"
}]
OrganizationPublisherService(
test_org_uuid, owner_username).invite_members(new_org_members)
invited_org_members = org_repo.get_org_member(
org_uuid=test_org_uuid,
status=OrganizationMemberStatus.PENDING.value)
if len(invited_org_members) == 3:
assert True
else:
assert False
def test_submit_organization_for_approval_after_onboarding_approved(self, mock_boto, mock_ipfs):
username = "******"
test_org_uuid = uuid4().hex
test_org_id = "org_id"
username = "******"
payload = {
"org_id": test_org_id, "org_uuid": test_org_uuid, "org_name": "test_org", "org_type": "organization",
"metadata_ipfs_uri": "", "duns_no": "123456789", "origin": ORIGIN, "registration_id": "",
"registration_type": "",
"description": "this is description", "short_description": "this is short description",
"url": "https://dummy.dummy", "contacts": "",
"assets": {"hero_image": {"url": "", "ipfs_hash": ""}},
"org_address": ORG_ADDRESS, "groups": json.loads(ORG_GROUPS),
"state": {}
}
organization = OrganizationFactory.org_domain_entity_from_payload(payload)
org_repo.add_organization(organization, username, OrganizationStatus.ONBOARDING_APPROVED.value)
OrganizationPublisherService(test_org_uuid, username) \
.update_organization(payload, OrganizationActions.SUBMIT.value)
org_db_model = org_repo.session.query(Organization).first()
if org_db_model is None:
assert False
else:
if org_db_model.org_state[0].state == OrganizationStatus.ONBOARDING_APPROVED.value:
assert True
else:
assert False
def test_get_member(self, mock_invoke_lambda):
test_org_uuid = uuid4().hex
owner_username = "******"
org_repo.add_organization(
DomainOrganization(test_org_uuid, "org_id", "org_dummy",
"ORGANIZATION", ORIGIN, "description",
"short_description", "https://test.io",
ORG_CONTACTS, {}, "ipfs_hash", "123456879", [],
[], [], []), owner_username,
OrganizationStatus.PUBLISHED.value)
members = OrganizationPublisherService(
test_org_uuid, owner_username).get_member(owner_username)
if isinstance(members, list) and len(members) == 1:
members[0].pop("invited_on")
members[0].pop("updated_on")
self.assertDictEqual(
members[0], {
'username': owner_username,
'address': "",
'status': 'ACCEPTED',
'role': 'OWNER'
})
else:
assert False
def test_edit_organization_after_change_requested(self, mock_invoke_lambda,
mock_boto, mock_ipfs):
username = "******"
test_org_uuid = uuid4().hex
test_org_id = "org_id"
groups = OrganizationFactory.group_domain_entity_from_group_list_payload(
json.loads(ORG_GROUPS))
org_repo.add_organization(
DomainOrganization(test_org_uuid, test_org_id, "org_dummy",
OrganizationType.INDIVIDUAL.value, ORIGIN, "",
"", "", [], {}, "", "", groups, [], [], []),
username, OrganizationStatus.CHANGE_REQUESTED.value)
payload = json.loads(ORG_PAYLOAD_MODEL)
payload["org_uuid"] = test_org_uuid
payload["org_id"] = test_org_id
OrganizationPublisherService(test_org_uuid, username) \
.update_organization(payload, OrganizationActions.DRAFT.value)
org_db_model = org_repo.session.query(Organization).first()
if org_db_model is None:
assert False
organization = OrganizationFactory.org_domain_entity_from_repo_model(
org_db_model)
org_dict = organization.to_response()
org_dict["state"] = {}
org_dict["groups"] = []
org_dict["assets"]["hero_image"]["url"] = ""
expected_organization = json.loads(ORG_RESPONSE_MODEL)
expected_organization["org_id"] = test_org_id
expected_organization["groups"] = []
expected_organization["org_uuid"] = test_org_uuid
self.assertDictEqual.__self__.maxDiff = None
self.assertDictEqual(expected_organization, org_dict)
def test_org_verification_individual(self, mock_boto_utils,
mock_ipfs_utils):
username = "******"
for count in range(0, 3):
org_id = uuid4().hex
org_repo.add_organization(
DomainOrganization(org_id, org_id, f"org_{org_id}",
OrganizationType.INDIVIDUAL.value, ORIGIN,
"", "", "", [], {}, "", "", [], [], [], []),
username, OrganizationStatus.ONBOARDING.value)
for count in range(0, 3):
org_id = uuid4().hex
org_repo.add_organization(
DomainOrganization(org_id, org_id, f"org_{org_id}",
OrganizationType.INDIVIDUAL.value, ORIGIN,
"", "", "", [], {}, "", "", [], [], [], []),
username, OrganizationStatus.APPROVED.value)
OrganizationPublisherService(None, None).update_verification(
"INDIVIDUAL",
verification_details={
"updated_by": "TEST_CASES",
"status": "APPROVED",
"username": username
})
organization = org_repo.get_organizations(
OrganizationStatus.ONBOARDING_APPROVED.value)
self.assertEqual(len(organization), 3)
def test_create_organization(self, mock_boto, mock_ipfs):
username = "******"
payload = {
"org_id": "",
"org_uuid": "",
"org_name": "test_org",
"org_type": "organization",
"metadata_ipfs_uri": "",
"duns_no": "123456789",
"origin": ORIGIN,
"description": "",
"short_description": "",
"url": "https://dummy.dummy",
"contacts": "",
"assets": {
"hero_image": {
"url": "",
"ipfs_hash": ""
}
},
"org_address": ORG_ADDRESS,
"groups": json.loads(ORG_GROUPS),
"state": {}
}
response = OrganizationPublisherService(
None, username).create_organization(payload)
org_db_model = org_repo.session.query(Organization).first()
if org_db_model is not None:
assert True
else:
assert False
def get_all_org(event, context):
logger.info(event)
username = event["requestContext"]["authorizer"]["claims"]["email"]
response = OrganizationPublisherService(None, username).get_all_org_for_user()
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def update_org(event, context):
payload = json.loads(event["body"])
path_parameters = event["pathParameters"]
required_keys = []
action = event["queryStringParameters"].get("action", None)
username = event["requestContext"]["authorizer"]["claims"]["email"]
org_uuid = path_parameters["org_uuid"]
if not validate_dict(payload, required_keys):
raise BadRequestException()
org_service = OrganizationPublisherService(org_uuid, username)
if action in [OrganizationActions.DRAFT.value, OrganizationActions.SUBMIT.value]:
response = org_service.update_organization(payload, action)
else:
raise Exception("Invalid action")
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def test_org_publish_to_ipfs(self, mock_json_to_file_util, mock_test_network_publish, mock_ipfs_utils):
test_org_id = uuid4().hex
username = "******"
org_repo.add_organization(
DomainOrganization(test_org_id, "org_id", "org_dummy", "ORGANIZATION", ORIGIN, "", "",
"", [], {}, "", "", [], [], [], []),
username, OrganizationStatus.APPROVED.value)
response = OrganizationPublisherService(test_org_id, username).publish_org_to_ipfs()
self.assertEqual(response["metadata_ipfs_uri"], "ipfs://Q12PWP")
def get_list_of_org_pending_for_approval(self):
list_of_org_pending_for_approval = OrganizationPublisherService(None, None) \
.get_approval_pending_organizations(MAX_SERVICES_SLACK_LISTING)
slack_blocks = self.generate_slack_blocks_for_org_listing_template(
list_of_org_pending_for_approval)
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_register_member(self):
test_org_uuid = uuid4().hex
owner_username = "******"
org_repo.add_organization(
DomainOrganization(test_org_uuid, "org_id", "org_dummy",
"ORGANIZATION", ORIGIN, "description",
"short_description", "https://test.io",
ORG_CONTACTS, {}, "ipfs_hash", "123456879", [],
[], [], []), owner_username,
OrganizationStatus.PUBLISHED.value)
member_username = "******"
member_invite_code = uuid4().hex
org_repo.add_item(
OrganizationMember(username=member_username,
org_uuid=test_org_uuid,
role=Role.MEMBER.value,
address="",
status=OrganizationMemberStatus.PENDING.value,
transaction_hash="0x123",
invite_code=member_invite_code,
invited_on=datetime.utcnow(),
updated_on=datetime.utcnow()))
member_wallet_address = "0x962FD47b5afBc8D03025cE52155890667E58dEBA"
self.assertRaises(
Exception,
OrganizationPublisherService(test_org_uuid,
member_username).register_member,
"1234", "0x9876")
OrganizationPublisherService(test_org_uuid, member_username)\
.register_member(member_invite_code, member_wallet_address)
members = org_repo.session.query(OrganizationMember).filter(OrganizationMember.org_uuid == test_org_uuid)\
.filter(OrganizationMember.username == member_username) \
.all()
if len(members) == 1:
org_member = members[0]
if org_member.status == OrganizationMemberStatus.ACCEPTED.value \
and org_member.address == member_wallet_address:
assert True
else:
assert False
else:
assert False
def get_member(event, context):
username = event["requestContext"]["authorizer"]["claims"]["email"]
path_parameters = event["pathParameters"]
org_uuid = path_parameters["org_uuid"]
member_username = path_parameters["username"]
response = OrganizationPublisherService(org_uuid, username).get_member(member_username)
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def org_verification(event, context):
query_parameters = event["queryStringParameters"]
if "verification_type" not in query_parameters:
raise BadRequestException()
verification_type = query_parameters["verification_type"]
response = OrganizationPublisherService(None, None).update_verification(verification_type, query_parameters)
return generate_lambda_response(
StatusCode.CREATED,
{"status": "success", "data": response, "error": {}}, cors_enabled=False
)
def create_organization(event, context):
payload = json.loads(event["body"])
required_keys = []
username = event["requestContext"]["authorizer"]["claims"]["email"]
if not validate_dict(payload, required_keys):
raise BadRequestException()
response = OrganizationPublisherService(None, username).create_organization(payload)
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def verify_org_id(event, context):
logger.info(event)
query_parameters = event["queryStringParameters"]
if "org_id" not in query_parameters:
raise BadRequestException()
org_id = query_parameters["org_id"]
response = OrganizationPublisherService(None, None).get_org_id_availability_status(org_id)
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def get_group_for_org(event, context):
path_parameters = event["pathParameters"]
username = event["requestContext"]["authorizer"]["claims"]["email"]
if "org_uuid" not in path_parameters:
raise BadRequestException()
org_uuid = path_parameters["org_uuid"]
response = OrganizationPublisherService(org_uuid, username).get_groups_for_org()
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def verify_code(event, context):
username = event["requestContext"]["authorizer"]["claims"]["email"]
query_string_parameters = event["queryStringParameters"]
if "invite_code" not in query_string_parameters:
raise BadRequestException()
invite_code = query_string_parameters["invite_code"]
response = OrganizationPublisherService(None, username).verify_invite(invite_code)
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def get_org_for_admin(event, context):
logger.info(event)
query_parameters = event["queryParameters"]
response = OrganizationPublisherService(
None, None).get_for_admin(query_parameters)
return generate_lambda_response(StatusCode.OK, {
"status": "success",
"data": response,
"error": {}
},
cors_enabled=True)
def save_transaction_hash_for_publish_org(event, context):
payload = json.loads(event["body"])
path_parameters = event["pathParameters"]
username = event["requestContext"]["authorizer"]["claims"]["email"]
if "org_uuid" not in path_parameters:
raise BadRequestException()
org_uuid = path_parameters["org_uuid"]
response = OrganizationPublisherService(org_uuid, username).save_transaction_hash_for_publish_org(payload)
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def register_member(event, context):
username = event["requestContext"]["authorizer"]["claims"]["email"]
payload = json.loads(event["body"])
if "invite_code" not in payload and "wallet_address" not in payload:
raise BadRequestException()
invite_code = payload["invite_code"]
wallet_address = payload["wallet_address"]
response = OrganizationPublisherService(None, username).register_member(invite_code, wallet_address)
return generate_lambda_response(
StatusCode.CREATED,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def test_edit_organization_with_org_id(self, mock_boto, mock_ipfs):
username = "******"
test_org_uuid = uuid4().hex
test_org_id = "org_id"
groups = OrganizationFactory.group_domain_entity_from_group_list_payload(json.loads(ORG_GROUPS))
org_repo.add_organization(
DomainOrganization(test_org_uuid, test_org_id, "org_dummy", "ORGANIZATION", ORIGIN, "", "",
"", [], {}, "", "", groups, [], [], []),
username, OrganizationStatus.PUBLISHED.value)
payload = json.loads(ORG_PAYLOAD_MODEL)
payload["org_uuid"] = test_org_uuid
self.assertRaises(OperationNotAllowed, OrganizationPublisherService(test_org_uuid, username)
.update_organization, payload, OrganizationActions.DRAFT.value)
def test_get_org_for_admin(self, mock_boto, mock_ipfs):
test_org_uuid = uuid4().hex
username = "******"
org_repo.add_organization(
DomainOrganization(test_org_uuid, "org_id", "org_dummy",
"ORGANIZATION", ORIGIN, "", "", "", [], {}, "",
"", [], [], [], []), username,
OrganizationStatus.APPROVED.value)
org = OrganizationPublisherService(None, None).get_for_admin(
{"status": OrganizationStatus.APPROVED.value})
if len(org) != 1:
assert False
assert True
def delete_members(event, context):
username = event["requestContext"]["authorizer"]["claims"]["email"]
payload = json.loads(event["body"])
path_parameters = event["pathParameters"]
if "org_uuid" not in path_parameters or "members" not in payload:
raise BadRequestException()
org_uuid = path_parameters["org_uuid"]
org_members = payload["members"]
response = OrganizationPublisherService(org_uuid, username).delete_members(org_members)
return generate_lambda_response(
StatusCode.CREATED,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def test_org_verification_organization(self, mock_boto_utils, mock_ipfs_utils, mock_email):
username = "******"
org_id = "test_org_id"
org_uuid = "test_org_uuid"
org_repo.add_organization(DomainOrganization(org_uuid, org_id, f"org_{org_id}",
OrganizationType.ORGANIZATION.value, ORIGIN, "",
"", "", [], {}, "", "", [], [], [], []),
username, OrganizationStatus.ONBOARDING.value)
OrganizationPublisherService(None, None).update_verification(
"DUNS", verification_details={"updated_by": "TEST_CASES", "comment": "approved",
"status": "APPROVED", "org_uuid": org_uuid})
organization = org_repo.get_org(OrganizationStatus.ONBOARDING_APPROVED.value)
self.assertEqual(len(organization), 1)
def get_all_members(event, context):
username = event["requestContext"]["authorizer"]["claims"]["email"]
path_parameters = event["pathParameters"]
query_parameters = event["queryStringParameters"]
if "org_uuid" not in path_parameters:
raise BadRequestException()
org_uuid = path_parameters["org_uuid"]
status = query_parameters.get("status", None)
role = query_parameters.get("role", None)
response = OrganizationPublisherService(org_uuid, username).get_all_member(status, role, query_parameters)
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def test_publish_members(self):
test_org_uuid = uuid4().hex
owner_username = "******"
org_repo.add_organization(
DomainOrganization(
test_org_uuid, "org_id", "org_dummy",
"ORGANIZATION", ORIGIN, "description",
"short_description", "https://test.io", ORG_CONTACTS, {}, "ipfs_hash", "123456879", [], [], [], []),
owner_username, OrganizationStatus.PUBLISHED.value)
new_org_members = [
{
"username": "******",
"address": "0x123"
},
{
"username": "******",
"address": "0x234"
},
{
"username": "******",
"address": "0x345"
}
]
org_repo.add_all_items(
[
OrganizationMember(
username=member["username"],
org_uuid=test_org_uuid,
role=Role.MEMBER.value,
address=member["address"],
status=OrganizationMemberStatus.ACCEPTED.value,
transaction_hash="0x123",
invite_code=uuid4().hex,
invited_on=datetime.utcnow(),
updated_on=datetime.utcnow()
) for member in new_org_members
]
)
OrganizationPublisherService(test_org_uuid, owner_username).publish_members("0x123", new_org_members)
org_members = org_repo.session.query(OrganizationMember).filter(OrganizationMember.org_uuid == test_org_uuid)\
.filter(OrganizationMember.status == OrganizationMemberStatus.PUBLISH_IN_PROGRESS.value).all()
if len(org_members) == 3:
assert True
else:
assert False
def test_notify_user_on_start_of_onboarding_process(self, mock_invoke_lambda):
recipients = ["*****@*****.**"]
org_publisher_service = OrganizationPublisherService(username=None, org_uuid=None)
org_publisher_service.notify_user_on_start_of_onboarding_process(org_id="dummy", recipients=recipients)
