def consume(ocn, account, agreement_id, method='download'): agreement = ocn.agreements.get(agreement_id) did = id_to_did(agreement.did) token = decrypt(ocn, account, did) if method == 'download': return consume_download(ocn, account, did, agreement_id, token) elif method == 'get': return consume_get(ocn, did, token)
def agreements_create_prepared(ctx, agreement_id, service_id, signature): ocean, account = ctx.obj['ocean'], ctx.obj['account'] agreement = ocean.agreements.get(agreement_id) result = ocean.agreements.create(id_to_did(agreement.did), service_id, agreement_id, signature, account.address, account) echo({ "result": result })
def consume_agreement(ocean, agreement_id, method): agreement = ocean.agreements.get(agreement_id) did = id_to_did(agreement.did) service_endpoint, secret = credentials(ocean, did) return consume(did, agreement_id, service_endpoint, secret, method, ocean=ocean)
def handle_agreement_created(event=None, agreement_id=None, ocean=None, *args, **kwargs): time.sleep(3) consumer = event['args'].get('_accessConsumer', None) provider = event['args'].get('_accessProvider', None) if provider == ocean.account.address: did = id_to_did(ocean.agreements.get(agreement_id).did) return {'did': did, 'consumer': consumer, 'provider': provider}
def add_data(self, data, value): """ Add a resolved event data item to the list of resolved items as this could be the last item in the chain. :param data: dictionary of the DIDRegistry event data :param value: formated value depending on the data['value_type'] string, bytes32 """ self._items.append(data) if data['value_type'] == VALUE_TYPE_DID: self._value = id_to_did(value) else: self._value = value
def access(ocn, account, agreement_id, consumer): if agreement_id == 'all': response = False for _agreement_id in list_agreements(ocn, account, account.address): try: response = access(ocn, account, _agreement_id, consumer) except Exception as e: print(e) return response ocean_conditions = OceanConditions(Keeper.get_instance()) agreement = ocn.agreements.get(agreement_id) return ocean_conditions.grant_access(agreement_id, id_to_did(agreement.did), consumer, account)
def test_id_to_did(): test_id = '%s' % secrets.token_hex(32) valid_did_text = 'did:op:{}'.format(test_id) assert id_to_did(test_id) == valid_did_text # accept hex string from Web3 py assert id_to_did(Web3.toHex(hexstr=test_id)) == valid_did_text # accepts binary value assert id_to_did(Web3.toBytes(hexstr=test_id)) == valid_did_text with pytest.raises(TypeError): id_to_did(None) with pytest.raises(TypeError): id_to_did({'bad': 'value'}) assert id_to_did('') == 'did:op:0'
def list_assets(address=None, ocean=None): did_list = [ id_to_did(Web3Provider.get_web3().toHex(_id)[2:]) for _id in DIDRegistry.get_instance().contract_concise.getDIDRegisterIds() ] if address: if address == 'me': address = ocean.account.address result = [] for did in did_list: try: asset_owner = ocean.assets.resolve( did).as_dictionary()['publicKey'][0]['owner'] if asset_owner == address: result += [did] except ValueError: pass return result return did_list
def create_from_metadata(cls, metadata, service_endpoint): """return a new Asset object from a metadata dictionary""" # calc the asset id asset_id = hashlib.sha256( json.dumps(metadata['base']).encode('utf-8')).hexdigest() # generate a DID from an asset_id new_did = id_to_did(asset_id) # create a new DDO new_ddo = DDO(new_did) # add a signature private_password = new_ddo.add_signature() # add the service endpoint with the meta data new_ddo.add_service(ServiceTypes.METADATA, service_endpoint, values={DDO_SERVICE_METADATA_KEY: metadata}) # add the static proof new_ddo.add_proof(0, private_password) # create the asset object this_asset = cls(ddo=new_ddo) logging.debug("Asset {} created from metadata {} ".format( this_asset.asset_id, metadata)) return this_asset
def consume(): """Allows download of asset data file. --- tags: - services consumes: - application/json parameters: - name: consumerAddress in: query description: The consumer address. required: true type: string - name: serviceAgreementId in: query description: The ID of the service agreement. required: true type: string - name: url in: query description: This URL is only valid if Brizo acts as a proxy. Consumer can't download using the URL if it's not through Brizo. required: true type: string responses: 200: description: Redirect to valid asset url. 400: description: One of the required attributes is missing. 401: description: Invalid asset data. 500: description: Error """ data = request.args required_attributes = ['serviceAgreementId', 'consumerAddress'] msg, status = check_required_attributes(required_attributes, data, 'consume') if msg: return msg, status if not (data.get('url') or (data.get('signature') and data.get('index'))): return f'Either `url` or `signature and index` are required in the call to "consume".', 400 try: provider_account = get_provider_account(ocn) agreement_id = data.get('serviceAgreementId') consumer_address = data.get('consumerAddress') asset_id = ocn.agreements.get(agreement_id).did did = id_to_did(asset_id) if ocn.agreements.is_access_granted(agreement_id, did, consumer_address): logger.info('Connecting through Osmosis to generate the sign url.') url = data.get('url') try: if not url: signature = data.get('signature') index = int(data.get('index')) address = Keeper.get_instance().ec_recover( agreement_id, signature) if address.lower() != consumer_address.lower(): msg = f'Invalid signature {signature} for ' \ f'consumerAddress {consumer_address} and documentId {did}.' raise ValueError(msg) asset = ocn.assets.resolve(did) urls_str = ocn.secret_store.decrypt( asset_id, asset.encrypted_files, provider_account) urls = json.loads(urls_str) if index >= len(urls): raise ValueError(f'url index "{index}"" is invalid.') url = urls[index]['url'] osm = Osmosis(url, config_file) download_url = osm.data_plugin.generate_url(url) logger.debug("Osmosis generate the url: %s", download_url) try: if request.range: headers = {"Range": request.headers.get('range')} response = requests_session.get(download_url, headers=headers, stream=True) else: headers = { "Content-Disposition": f'attachment;filename={url.split("/")[-1]}' } response = requests_session.get(download_url, headers=headers, stream=True) return Response(io.BytesIO(response.content).read(), response.status_code, headers=headers) except Exception as e: logger.error(e) return "Error getting the url content: %s" % e, 401 except Exception as e: logger.error(e) return "Error generating url: %s" % e, 401 else: msg = "Invalid consumer address and/or service agreement id, " \ "or consumer address does not have permission to consume this asset." logger.warning(msg) return msg, 401 except Exception as e: logger.error("Error- " + str(e)) return "Error : " + str(e), 500
def get_agreement_from_id(ocn, agreement_id): agreement = ocn.agreements.get(agreement_id) did = id_to_did(agreement.did) return get_agreement_from_did(ocn, did)
def consume_agreement(ocean, account, agreement_id, method): agreement = ocean.agreements.get(agreement_id) did = id_to_did(agreement.did) service_endpoint, url, token = credentials(ocean, account, did) return consume(ocean, account, did, agreement_id, service_endpoint, url, token, method)