def access_service(did, service_agreement_id, service_endpoint, account,
destination_folder, config, index):
cache_key = Gateway._generate_cache_key(account.address,
service_agreement_id, did)
if cache_key not in Gateway._tokens_cache:
grant_token = generate_access_grant_token(account,
service_agreement_id,
did)
access_token = Gateway.fetch_token(grant_token, config)
Gateway._tokens_cache[cache_key] = access_token
else:
access_token = Gateway._tokens_cache[cache_key]
consume_url = Gateway._create_access_url(service_endpoint,
service_agreement_id, index)
headers = {"Authorization": f"Bearer {access_token}"}
response = Gateway._http_client.get(consume_url,
headers=headers,
stream=True)
if not response.ok:
raise ValueError(response.text)
file_name = Gateway._get_file_name(response)
Gateway.write_file(response, destination_folder, file_name
or f'file-{index}')
return response
def test_nft_access_no_agreement(client, provider_account, consumer_account):
ddo = get_nft_ddo(provider_account, providers=[provider_account.address])
nft_amounts = 1
keeper = keeper_instance()
keeper.nft_upgradeable.transfer_nft(ddo.asset_id, consumer_account.address,
nft_amounts, provider_account)
no_agreement_id = '0x'
# generate the grant token
grant_token = generate_access_grant_token(consumer_account,
no_agreement_id,
ddo.did,
uri="/nft-access")
# request access token
response = client.post("/api/v1/gateway/services/oauth/token",
data={
"grant_type":
NeverminedJWTBearerGrant.GRANT_TYPE,
"assertion": grant_token
})
access_token = response.get_json()["access_token"]
index = 0
endpoint = BaseURLs.ASSETS_URL + '/nft-access/%s/%d' % (no_agreement_id,
index)
response = client.get(endpoint,
headers={"Authorization": f"Bearer {access_token}"})
assert response.status == '200 OK'
assert len(
keeper.did_registry.get_provenance_method_events(
'USED', did_bytes=did_to_id_bytes(ddo.did))) >= 1
def test_nft_access_no_balance(client, provider_account, consumer_account):
ddo = get_nft_ddo(provider_account, providers=[provider_account.address])
no_agreement_id = '0x'
# generate the grant token
grant_token = generate_access_grant_token(consumer_account,
no_agreement_id,
ddo.did,
uri="/nft-access")
# request access token
response = client.post("/api/v1/gateway/services/oauth/token",
data={
"grant_type":
NeverminedJWTBearerGrant.GRANT_TYPE,
"assertion": grant_token
})
assert response.status_code == 400
index = 0
access_token = '123'
endpoint = BaseURLs.ASSETS_URL + '/nft-access/%s/%d' % (no_agreement_id,
index)
response = client.get(endpoint,
headers={"Authorization": f"Bearer {access_token}"})
assert response.status != '200 OK'
def test_nft_access(client, provider_account, consumer_account):
keeper = keeper_instance()
ddo = get_nft_ddo(provider_account, providers=[provider_account.address])
asset_id = ddo.asset_id
nft_amounts = 1
keeper.nft_upgradeable.transfer_nft(asset_id, consumer_account.address,
nft_amounts, provider_account)
assert keeper.nft_upgradeable.balance(consumer_account.address,
asset_id) >= nft_amounts
nft_access_service_agreement = ServiceAgreement.from_ddo(
ServiceTypes.NFT_ACCESS, ddo)
agreement_id = ServiceAgreement.create_new_agreement_id()
(nft_access_cond_id, nft_holder_cond_id
) = nft_access_service_agreement.generate_agreement_condition_ids(
agreement_id, asset_id, consumer_account.address, keeper)
print('NFT_ACCESS_DID: ' + asset_id)
keeper.nft_access_template.create_agreement(
agreement_id, asset_id, [nft_holder_cond_id, nft_access_cond_id],
nft_access_service_agreement.conditions_timelocks,
nft_access_service_agreement.conditions_timeouts,
consumer_account.address, consumer_account)
event = keeper.nft_access_template.subscribe_agreement_created(
agreement_id, 15, None, (), wait=True, from_block=0)
assert event, "Agreement event is not found, check the keeper node's logs"
# generate the grant token
grant_token = generate_access_grant_token(consumer_account,
agreement_id,
ddo.did,
uri="/nft-access")
# request access token
response = client.post("/api/v1/gateway/services/oauth/token",
data={
"grant_type":
NeverminedJWTBearerGrant.GRANT_TYPE,
"assertion": grant_token
})
access_token = response.get_json()["access_token"]
index = 0
endpoint = BaseURLs.ASSETS_URL + '/nft-access/%s/%d' % (agreement_id,
index)
response = client.get(endpoint,
headers={"Authorization": f"Bearer {access_token}"})
assert response.status == '200 OK'
assert len(
keeper.did_registry.get_provenance_method_events(
'USED', did_bytes=did_to_id_bytes(ddo.did))) >= 1
def test_access(client, provider_account, consumer_account):
for method in constants.ConfigSections.DECRYPTION_METHODS:
ddo = get_registered_ddo(provider_account,
providers=[provider_account.address],
auth_service=method)
# initialize an agreement
agreement_id = place_order(provider_account, ddo, consumer_account)
keeper = keeper_instance()
index = 0
event = keeper.access_template.subscribe_agreement_created(
agreement_id, 15, None, (), wait=True, from_block=0)
assert event, "Agreement event is not found, check the keeper node's logs"
consumer_balance = keeper.token.get_token_balance(
consumer_account.address)
if consumer_balance < 50:
keeper.dispenser.request_tokens(50 - consumer_balance,
consumer_account)
sa = ServiceAgreement.from_ddo(ServiceTypes.ASSET_ACCESS, ddo)
lock_payment(agreement_id, ddo.asset_id, sa, amounts, receivers,
consumer_account)
event = keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id, 15, None, (), wait=True, from_block=0)
assert event, "Lock reward condition fulfilled event is not found, check the keeper node's logs"
# Consume using url index
# generate the grant token
grant_token = generate_access_grant_token(consumer_account,
agreement_id, ddo.did)
# request access token
response = client.post("/api/v1/gateway/services/oauth/token",
data={
"grant_type":
NeverminedJWTBearerGrant.GRANT_TYPE,
"assertion": grant_token
})
access_token = response.get_json()["access_token"]
endpoint = BaseURLs.ASSETS_URL + '/access/%s/%d' % (agreement_id,
index)
response = client.get(
endpoint, headers={"Authorization": f"Bearer {access_token}"})
agreement = keeper.agreement_manager.get_agreement(agreement_id)
cond_ids = agreement.condition_ids
assert keeper.condition_manager.get_condition_state(
cond_ids[0]) == ConditionState.Fulfilled.value
assert keeper.condition_manager.get_condition_state(
cond_ids[1]) == ConditionState.Fulfilled.value
assert keeper.condition_manager.get_condition_state(
cond_ids[2]) == ConditionState.Fulfilled.value
assert response.status == '200 OK'
assert len(
keeper.did_registry.get_provenance_method_events(
'USED', did_bytes=did_to_id_bytes(ddo.did))) == 1