def test_application_cancel(self): """ Test if the supplychain processor can cancel an application. """ try: validator = self.validator factory = self.factory record_id = "serial number" agent_pub_key = factory.public_key application_addr = Addressing.application_address(record_id) # 1. -> Send a set transaction # <- Expect a state get request validator.send( factory.create_application_cancel_tp_process_request( record_id, agent_pub_key, Application.OWNER)) # test for application existance received = self.expect_get([application_addr]) application = factory.create_application(record_id, agent_pub_key, Application.OWNER, Application.OPEN) self.respond_get(received, [(application_addr, application)]) # Update application application.status = Application.CANCELED received = self.expect_set([(application_addr, application)]) self.respond_set(received, [application_addr]) self.expect_ok() except Exception: LOGGER.exception("test_application_cancel exception") raise
def _application_cancel(self, state, originator, data): txn_data = ApplicationCancelPayload() txn_data.ParseFromString(data) application_addr = Addressing.application_address( txn_data.record_identifier) state_items = self._get(state, [application_addr]) # check that the application exists applications = state_items.get(application_addr, None) application = self._find_application( applications, txn_data.applicant, txn_data.record_identifier, txn_data.type) if application is None: raise InvalidTransaction("Application does not exists.") # verify the txn signer is qualified to accept the application if application.applicant != originator: raise InvalidTransaction("Only Applicant can cancel Application.") # update the application application.status = Application.CANCELED # send back the updated application list self._set(state, [(application_addr, applications)])
def _application_cancel(self, state, originator, data): txn_data = ApplicationCancelPayload() txn_data.ParseFromString(data) application_addr = Addressing.application_address( txn_data.record_identifier) state_items = self._get(state, [application_addr]) # check that the application exists applications = state_items.get(application_addr, None) application = self._find_application(applications, txn_data.applicant, txn_data.record_identifier, txn_data.type) if application is None: raise InvalidTransaction("Application does not exists.") # verify the txn signer is qualified to accept the application if application.applicant != originator: raise InvalidTransaction("Only Applicant can cancel Application.") # update the application application.status = Application.CANCELED # send back the updated application list self._set(state, [(application_addr, applications)])
def _application_accept(self, state, originator, data): txn_data = ApplicationAcceptPayload() txn_data.ParseFromString(data) record_addr = Addressing.record_address(txn_data.record_identifier) application_addr = Addressing.application_address( txn_data.record_identifier) state_items = self._get(state, [application_addr, record_addr]) # check that the application exists applications = state_items.get(application_addr, None) application = self._find_application(applications, txn_data.applicant, txn_data.record_identifier, txn_data.type) if application is None: raise InvalidTransaction("Application does not exists.") # check that the recorf exists records = state_items.get(record_addr, None) record = self._find_record(records, application.record_identifier) if record is None: raise InvalidTransaction("Record does not exists.") if record.final: raise InvalidTransaction("Record is final, no updates can be " + "made.") # verify the txn signer is qualified to accept the application if application.type == Application.OWNER: owner = record.owners[len(record.owners) - 1] if owner.agent_identifier != originator: raise InvalidTransaction( "Application can only be accepted by owner.") elif application.type == Application.CUSTODIAN: custodian = record.custodians[len(record.custodians) - 1] if custodian.agent_identifier != originator: raise InvalidTransaction( "Application can only be accepted by custodian.") else: raise InvalidTransaction("Invalid application type.") # update the application application.status = Application.ACCEPTED # update the record if application.type == Application.OWNER: agent_record = record.owners.add() elif application.type == Application.CUSTODIAN: agent_record = record.custodians.add() agent_record.agent_identifier = application.applicant agent_record.start_time = txn_data.timestamp # send back the updated application list self._set(state, [(application_addr, applications), (record_addr, records)])
def _application_accept(self, state, originator, data): txn_data = ApplicationAcceptPayload() txn_data.ParseFromString(data) record_addr = Addressing.record_address(txn_data.record_identifier) application_addr = Addressing.application_address( txn_data.record_identifier) state_items = self._get(state, [application_addr, record_addr]) # check that the application exists applications = state_items.get(application_addr, None) application = self._find_application( applications, txn_data.applicant, txn_data.record_identifier, txn_data.type) if application is None: raise InvalidTransaction("Application does not exists.") # check that the recorf exists records = state_items.get(record_addr, None) record = self._find_record(records, application.record_identifier) if record is None: raise InvalidTransaction("Record does not exists.") if record.final: raise InvalidTransaction("Record is final, no updates can be " + "made.") # verify the txn signer is qualified to accept the application if application.type == Application.OWNER: owner = record.owners[len(record.owners) - 1] if owner.agent_identifier != originator: raise InvalidTransaction( "Application can only be accepted by owner.") elif application.type == Application.CUSTODIAN: custodian = record.custodians[len(record.custodians) - 1] if custodian.agent_identifier != originator: raise InvalidTransaction( "Application can only be accepted by custodian.") else: raise InvalidTransaction("Invalid application type.") # update the application application.status = Application.ACCEPTED # update the record if application.type == Application.OWNER: agent_record = record.owners.add() elif application.type == Application.CUSTODIAN: agent_record = record.custodians.add() agent_record.agent_identifier = application.applicant agent_record.start_time = txn_data.timestamp # send back the updated application list self._set(state, [(application_addr, applications), (record_addr, records)])
def application_create(self, record_identifier, application_type, terms="", creation_time=None, wait=None): outputs = [Addressing.application_address(record_identifier)] inputs = outputs + [Addressing.agent_address(self.public_key), Addressing.record_address(record_identifier)] return self._send_txn( SupplyChainPayload.APPLICATION_CREATE, ApplicationCreatePayload( record_identifier=record_identifier, creation_time=creation_time or int(time.time()), type=application_type, terms=terms), inputs=inputs, outputs=outputs, wait=wait)
def application_cancel(self, record_identifier, application_type, wait=None): outputs = [Addressing.application_address(record_identifier), Addressing.record_address(record_identifier)] inputs = outputs + [Addressing.agent_address(self.public_key), Addressing.record_address(record_identifier)] return self._send_txn( SupplyChainPayload.APPLICATION_CANCEL, ApplicationCancelPayload( record_identifier=record_identifier, applicant=self._public_key, type=application_type), inputs=inputs, outputs=outputs, wait=wait)
def test_create_application(self): """ Test if the supplychain processor can create a application. """ try: validator = self.validator factory = self.factory record_id = "serial number" record_addr = Addressing.record_address(record_id) agent_pub_key = factory.public_key agent_addr = Addressing.agent_address(agent_pub_key) application_addr = Addressing.application_address(record_id) timestamp = int(time.time()) terms = "Please take this." # 1. -> Send a set transaction # <- Expect a state get request validator.send(factory.create_application_tp_process_request( agent_pub_key, record_id, timestamp, Application.OWNER, terms)) # test for record existance received = self.expect_get( [agent_addr, application_addr, record_addr]) agent = factory.create_agent(agent_pub_key) record = factory.create_record(record_id) self.respond_get(received, [(agent_addr, agent), (application_addr, None), (record_addr, record)]) # Expect test for existance application = factory.create_application( record_id, agent_pub_key, Application.OWNER, Application.OPEN, timestamp, terms) received = self.expect_set([(application_addr, application)]) self.respond_set(received, [application_addr]) self.expect_ok() except Exception: LOGGER.exception("test_create_application exception") raise
def test_application_accept(self): """ Test if the supplychain processor can create a application. """ try: validator = self.validator factory = self.factory applicant_id = "applicant pub key" record_id = "serial number" record_addr = Addressing.record_address(record_id) agent_pub_key = factory.public_key application_addr = Addressing.application_address(record_id) timestamp = int(time.time()) # 1. -> Send a set transaction # <- Expect a state get request validator.send( factory.create_application_accept_tp_process_request( record_id, applicant_id, Application.OWNER, timestamp)) # test for application and record existance received = self.expect_get([application_addr, record_addr]) application = factory.create_application( record_id, applicant_id, Application.OWNER, Application.OPEN) record = factory.create_record(record_id) factory.add_agent_record(record.owners, agent_pub_key) self.respond_get(received, [(application_addr, application), (record_addr, record)]) # Update record and application application.status = Application.ACCEPTED factory.add_agent_record(record.owners, applicant_id, timestamp) received = self.expect_set( [(application_addr, application), (record_addr, record)]) self.respond_set(received, [application_addr, record_addr]) self.expect_ok() except Exception: LOGGER.exception("test_application_accept exception") raise
def application_get(self, record_identifier, applicant, application_type): address = Addressing.application_address(record_identifier) result = self._send_get("state/{}".format(address)) try: data = self._get_result_data(result) applications = _decode_application_container(data) return next( (app for app in applications.entries if app.record_identifier == record_identifier and app.applicant == applicant and app.type == application_type), None) except BaseException: return None
def application_accept(self, record_identifier, applicant, application_type, timestamp=None, wait=None): outputs = [Addressing.application_address(record_identifier), Addressing.record_address(record_identifier)] inputs = outputs + [Addressing.agent_address(self.public_key), Addressing.record_address(record_identifier)] return self._send_txn( SupplyChainPayload.APPLICATION_ACCEPT, ApplicationAcceptPayload( record_identifier=record_identifier, applicant=applicant, type=application_type, timestamp=timestamp or time.time()), inputs=inputs, outputs=outputs, wait=wait)
def application_get(self, record_identifier, applicant, application_type): address = Addressing.application_address(record_identifier) result = self._send_get("state/{}".format(address)) try: data = self._get_result_data(result) applications = _decode_application_container(data) return next((app for app in applications.entries if app.record_identifier == record_identifier and app.applicant == applicant and app.type == application_type ), None) except BaseException: return None
def create_application_cancel_tp_process_request(self, record_id, applicant_id, application_type): record_addr = Addressing.record_address(record_id) agent_pub_key = self.public_key agent_addr = Addressing.agent_address(agent_pub_key) application_addr = Addressing.application_address(record_id) inputs = [agent_addr, application_addr, record_addr] outputs = [application_addr] return self.create_tp_process_request( SupplyChainPayload.APPLICATION_CANCEL, ApplicationCancelPayload(record_identifier=record_id, applicant=applicant_id, type=application_type), inputs, outputs)
def _application_create(self, state, originator, data): txn_data = ApplicationCreatePayload() txn_data.ParseFromString(data) agent_addr = Addressing.agent_address(originator) record_addr = Addressing.record_address(txn_data.record_identifier) application_addr = Addressing.application_address( txn_data.record_identifier) state_items = self._get(state, [agent_addr, application_addr, record_addr]) # check that the agent and record exists agents = state_items.get(agent_addr, None) if self._find_agent(agents, originator) is None: raise InvalidTransaction("Agent is not registered.") records = state_items.get(record_addr, None) record = self._find_record(records, txn_data.record_identifier) if record is None: raise InvalidTransaction("Record does not exist.") if record.final: raise InvalidTransaction("Record is final, no updates can be " + "proposed.") # check that the application does not exists applications = state_items.get(application_addr, ApplicationContainer()) application = self._find_application(applications, originator, txn_data.record_identifier, txn_data.type) if application is not None: raise InvalidTransaction("Application already exists.") # create the new application application = applications.entries.add() application.record_identifier = txn_data.record_identifier application.applicant = originator application.creation_time = txn_data.creation_time application.type = txn_data.type application.status = Application.OPEN application.terms = txn_data.terms # send back the updated application list self._set(state, [(application_addr, applications)])
def test_create_application(self): """ Test if the supplychain processor can create a application. """ try: validator = self.validator factory = self.factory record_id = "serial number" record_addr = Addressing.record_address(record_id) agent_pub_key = factory.public_key agent_addr = Addressing.agent_address(agent_pub_key) application_addr = Addressing.application_address(record_id) timestamp = int(time.time()) terms = "Please take this." # 1. -> Send a set transaction # <- Expect a state get request validator.send( factory.create_application_tp_process_request( agent_pub_key, record_id, timestamp, Application.OWNER, terms)) # test for record existance received = self.expect_get( [agent_addr, application_addr, record_addr]) agent = factory.create_agent(agent_pub_key) record = factory.create_record(record_id) self.respond_get(received, [(agent_addr, agent), (application_addr, None), (record_addr, record)]) # Expect test for existance application = factory.create_application(record_id, agent_pub_key, Application.OWNER, Application.OPEN, timestamp, terms) received = self.expect_set([(application_addr, application)]) self.respond_set(received, [application_addr]) self.expect_ok() except Exception: LOGGER.exception("test_create_application exception") raise
def _application_create(self, state, originator, data): txn_data = ApplicationCreatePayload() txn_data.ParseFromString(data) agent_addr = Addressing.agent_address(originator) record_addr = Addressing.record_address(txn_data.record_identifier) application_addr = Addressing.application_address( txn_data.record_identifier) state_items = self._get(state, [agent_addr, application_addr, record_addr]) # check that the agent and record exists agents = state_items.get(agent_addr, None) if self._find_agent(agents, originator) is None: raise InvalidTransaction("Agent is not registered.") records = state_items.get(record_addr, None) record = self._find_record(records, txn_data.record_identifier) if record is None: raise InvalidTransaction("Record does not exist.") if record.final: raise InvalidTransaction("Record is final, no updates can be " + "proposed.") # check that the application does not exists applications = state_items.get(application_addr, ApplicationContainer()) application = self._find_application( applications, originator, txn_data.record_identifier, txn_data.type) if application is not None: raise InvalidTransaction("Application already exists.") # create the new application application = applications.entries.add() application.record_identifier = txn_data.record_identifier application.applicant = originator application.creation_time = txn_data.creation_time application.type = txn_data.type application.status = Application.OPEN application.terms = txn_data.terms # send back the updated application list self._set(state, [(application_addr, applications)])
def test_application_accept(self): """ Test if the supplychain processor can create a application. """ try: validator = self.validator factory = self.factory applicant_id = "applicant pub key" record_id = "serial number" record_addr = Addressing.record_address(record_id) agent_pub_key = factory.public_key application_addr = Addressing.application_address(record_id) timestamp = int(time.time()) # 1. -> Send a set transaction # <- Expect a state get request validator.send( factory.create_application_accept_tp_process_request( record_id, applicant_id, Application.OWNER, timestamp)) # test for application and record existance received = self.expect_get([application_addr, record_addr]) application = factory.create_application(record_id, applicant_id, Application.OWNER, Application.OPEN) record = factory.create_record(record_id) factory.add_agent_record(record.owners, agent_pub_key) self.respond_get(received, [(application_addr, application), (record_addr, record)]) # Update record and application application.status = Application.ACCEPTED factory.add_agent_record(record.owners, applicant_id, timestamp) received = self.expect_set([(application_addr, application), (record_addr, record)]) self.respond_set(received, [application_addr, record_addr]) self.expect_ok() except Exception: LOGGER.exception("test_application_accept exception") raise
def application_cancel(self, record_identifier, application_type, wait=None): outputs = [ Addressing.application_address(record_identifier), Addressing.record_address(record_identifier) ] inputs = outputs + [ Addressing.agent_address(self.public_key), Addressing.record_address(record_identifier) ] return self._send_txn(SupplyChainPayload.APPLICATION_CANCEL, ApplicationCancelPayload( record_identifier=record_identifier, applicant=self._public_key, type=application_type), inputs=inputs, outputs=outputs, wait=wait)
def application_create(self, record_identifier, application_type, terms="", creation_time=None, wait=None): outputs = [Addressing.application_address(record_identifier)] inputs = outputs + [ Addressing.agent_address(self.public_key), Addressing.record_address(record_identifier) ] return self._send_txn( SupplyChainPayload.APPLICATION_CREATE, ApplicationCreatePayload(record_identifier=record_identifier, creation_time=creation_time or int(time.time()), type=application_type, terms=terms), inputs=inputs, outputs=outputs, wait=wait)
def test_application_cancel(self): """ Test if the supplychain processor can cancel an application. """ try: validator = self.validator factory = self.factory record_id = "serial number" agent_pub_key = factory.public_key application_addr = Addressing.application_address(record_id) # 1. -> Send a set transaction # <- Expect a state get request validator.send( factory.create_application_cancel_tp_process_request( record_id, agent_pub_key, Application.OWNER)) # test for application existance received = self.expect_get([application_addr]) application = factory.create_application( record_id, agent_pub_key, Application.OWNER, Application.OPEN) self.respond_get( received, [(application_addr, application)]) # Update application application.status = Application.CANCELED received = self.expect_set([(application_addr, application)]) self.respond_set(received, [application_addr]) self.expect_ok() except Exception: LOGGER.exception("test_application_cancel exception") raise
def application_accept(self, record_identifier, applicant_public_key, application_type, timestamp=None, wait=None): outputs = [ Addressing.application_address(record_identifier), Addressing.record_address(record_identifier) ] inputs = outputs + [ Addressing.agent_address(self.public_key), Addressing.record_address(record_identifier) ] return self._send_txn(SupplyChainPayload.APPLICATION_ACCEPT, ApplicationAcceptPayload( record_identifier=record_identifier, applicant=applicant_public_key, type=application_type, timestamp=timestamp or int(time.time())), inputs=inputs, outputs=outputs, wait=wait)