async def submitSchema(self,
schema: Schema) -> Schema:
schema = schema._replace(seqId=self._schemaId)
self._schemaId += 1
self._schemasByKey[schema.getKey()] = schema
self._schemasById[schema.seqId] = schema
return schema
def testSchemaFromToDict():
schema = Schema(name='schemaName',
version='1.0',
schemaType='CL',
attrNames=['attr1', 'attr2', 'attr3'],
issuerId='issuer1')
assert schema == Schema.fromStrDict(schema.toStrDict())
async def getSchema(self, id: ID) -> Optional[Schema]:
data = None
if id.schemaKey:
op = {
TARGET_NYM: id.schemaKey.issuerId,
TXN_TYPE: GET_SCHEMA,
DATA: {
NAME: id.schemaKey.name,
VERSION: id.schemaKey.version,
}
}
data, seqNo = await self._sendGetReq(op)
else:
op = {TXN_TYPE: GET_TXNS, DATA: id.schemaId}
res, seqNo = await self._sendGetReq(op)
if res and res[TXN_TYPE] == SCHEMA:
data = res[DATA]
data[ORIGIN] = res[IDENTIFIER]
if not data:
raise SchemaNotFoundError('No schema with ID={} and key={}'.format(
id.schemaId, id.schemaKey))
return Schema(name=data[NAME],
version=data[VERSION],
attrNames=data[ATTR_NAMES],
issuerId=data[ORIGIN],
seqId=seqNo)
async def getSchema(self, id: ID) -> Optional[Schema]:
data = None
issuer_id = None
if id.schemaKey:
issuer_id = id.schemaKey.issuerId
op = {
TARGET_NYM: issuer_id,
TXN_TYPE: GET_SCHEMA,
DATA: {
NAME: id.schemaKey.name,
VERSION: id.schemaKey.version,
}
}
data, seqNo = await self._sendGetReq(op)
else:
op = {
f.LEDGER_ID.nm: DOMAIN_LEDGER_ID,
TXN_TYPE: GET_TXNS,
DATA: id.schemaId
}
res, seqNo = await self._sendGetReq(op)
if res and get_type(res) == SCHEMA:
issuer_id = get_from(res)
data = get_payload_data(res)[DATA]
if not data or ATTR_NAMES not in data:
raise SchemaNotFoundError('No schema with ID={} and key={}'.format(
id.schemaId, id.schemaKey))
return Schema(name=data[NAME],
version=data[VERSION],
attrNames=data[ATTR_NAMES],
issuerId=issuer_id,
seqId=seqNo)
async def genSchema(self, name, version, attrNames) -> Schema:
"""
Generates and submits Schema.
:param name: schema name
:param version: schema version
:param attrNames: a list of attributes the schema contains
:return: submitted Schema
"""
schema = Schema(name, version, attrNames, self.issuerId)
return await self.wallet.submitSchema(schema)
def test_can_not_submit_schema_with_empty_attr_names(looper, public_repo,
stewardWallet):
schema = Schema(name='newSchema',
version='4.0',
attrNames=[],
issuerId=stewardWallet.defaultId,
seqId=None)
with pytest.raises(OperationError) as ex_info:
looper.run(public_repo.submitSchema(schema))
ex_info.match("attr_names in schema can not be empty")
async def submitSchema(self, schema: Schema) -> Schema:
data = {
NAME: schema.name,
VERSION: schema.version,
ATTR_NAMES: schema.attrNames
}
op = {TXN_TYPE: SCHEMA, DATA: data}
_, seqNo = await self._sendSubmitReq(op)
if seqNo:
schema = schema._replace(issuerId=self.wallet.defaultId,
seqId=seqNo)
return schema
async def submitSchema(self, schema: Schema) -> Schema:
op = {
TXN_TYPE: SCHEMA,
DATA: {
NAME: schema.name,
VERSION: schema.version,
ATTR_NAMES: ",".join(schema.attrNames)
}
}
data, seqNo = await self._sendSubmitReq(op)
if not seqNo:
return None
schema = schema._replace(issuerId=self.wallet.defaultId, seqId=seqNo)
return schema
async def getSchema(self, id: ID) -> Optional[Schema]:
op = {
TARGET_NYM: id.schemaKey.issuerId,
TXN_TYPE: GET_SCHEMA,
DATA: {
NAME: id.schemaKey.name,
VERSION: id.schemaKey.version,
}
}
data, seqNo = await self._sendGetReq(op)
return Schema(name=data[NAME],
version=data[VERSION],
attrNames=data[ATTR_NAMES].split(","),
issuerId=data[ORIGIN],
seqId=seqNo) if data else None
async def submitSchema(self, schema: Schema) -> Schema:
data = {
NAME: schema.name,
VERSION: schema.version,
ATTR_NAMES: ",".join(schema.attrNames)
}
op = {
TXN_TYPE: SCHEMA,
DATA: JsonSerializer.dumps(data, toBytes=False)
}
_, seqNo = await self._sendSubmitReq(op)
if seqNo:
schema = schema._replace(issuerId=self.wallet.defaultId,
seqId=seqNo)
return schema
async def submitSchema(self,
schema: Schema) -> Schema:
data = {
NAME: schema.name,
VERSION: schema.version,
ATTR_NAMES: schema.attrNames
}
op = {
TXN_TYPE: SCHEMA,
DATA: data
}
_, seqNo = await self._sendSubmitReq(op)
if seqNo:
schema = schema._replace(issuerId=self.wallet.defaultId,
seqId=seqNo)
return schema
async def getSchema(self, id: ID) -> Schema:
op = {
TARGET_NYM: id.schemaKey.issuerId,
TXN_TYPE: GET_SCHEMA,
DATA: {
NAME: id.schemaKey.name,
VERSION: id.schemaKey.version,
}
}
try:
data, seqNo = await self._sendGetReq(op)
except TimeoutError:
logger.error('Operation timed out {}'.format(op))
return None
return Schema(name=data[NAME],
version=data[VERSION],
schemaType=data[TYPE],
attrNames=data[ATTR_NAMES].split(","),
issuerId=data[ORIGIN],
seqId=seqNo)
async def submitSchema(self, schema: Schema) -> Schema:
op = {
TXN_TYPE: SCHEMA,
DATA: {
NAME: schema.name,
VERSION: schema.version,
TYPE: schema.schemaType,
ATTR_NAMES: ",".join(schema.attrNames)
}
}
try:
data, seqNo = await self._sendSubmitReq(op)
except TimeoutError:
logger.error('Operation timed out {}'.format(op))
return None
if not seqNo:
return None
schema = schema._replace(issuerId=self.wallet.defaultId, seqId=seqNo)
return schema
def schemaDefGvt(stewardWallet):
return Schema('GVT', '1.0', GVT.attribNames(), 'CL',
stewardWallet.defaultId)
def schemaDefGvt(stewardWallet):
return Schema(name='GVT',
version='1.0',
attrNames=GVT.attribNames(),
issuerId=stewardWallet.defaultId,
seqId=None)
def _cacheSchema(self, schema: Schema):
self._schemasByKey[schema.getKey()] = schema
if schema.seqId:
self._schemasById[schema.seqId] = schema
def schema(request, stewardWallet):
return Schema(name='GVT',
version='1.0' if request.param == 'revocation' else '2.0',
attrNames=GVT.attribNames(),
issuerId=stewardWallet.defaultId,
seqId=None)
