Impalcato TypeScript Chaincode Project

Blockchain App Builder prende l'input dal file delle specifiche e genera un progetto di codice concatenato impalcato completamente funzionale. Il progetto contiene classi e funzioni generate automaticamente, metodi CRUD, metodi SDK, convalida automatica degli argomenti, marshalling/un-marshalling e capacità di persistenza trasparente (ORM).

Se il progetto chaincode utilizza la lingua TypeScript, il progetto scaffolded contiene tre file principali:
  • main.ts
  • <chaincodeName>.model.ts
  • <chaincodeName>.controller.ts
Tutte le librerie necessarie vengono installate e inserite in un package. Il file tsconfig.json contiene la configurazione necessaria per compilare e creare il progetto TypeScript.

Il file <chaincodeName>.model.ts nella sottodirectory model contiene più definizioni di asset e il file <chaincodeName>.controller.ts nella sottodirectory controller contiene il comportamento degli asset e i metodi CRUD.

I decoratori in model.ts e controller.ts forniscono supporto per funzioni come la convalida automatica degli argomenti, il marshalling/unmarshalling degli argomenti, la capacità di persistenza trasparente (ORM) e la chiamata di query avanzate.

Di riferimento:

dati

Ogni classe di modello estende la classe OchainModel, che dispone di un'ulteriore proprietà di sola lettura denominata assetType. Questa proprietà può essere utilizzata per recuperare solo asset di questo tipo. Eventuali modifiche a questa proprietà vengono ignorate durante la creazione e l'aggiornamento dell'asset. Il valore predefinito della proprietà è <modelName>.

La classe OchainModel applica i comportamenti del decoratore alle proprietà della classe.
@Id('supplierId')
export class Supplier extends OchainModel<Supplier> {
    public readonly assetType = 'supplier';
    @Mandatory()
    @Validate(yup.string()) 
    public supplierId: string;

Decorator

Decoratori di classi
@Id(identifier)
Questo decoratore identifica la proprietà che definisce in modo univoco l'asset sottostante. Questa proprietà viene utilizzata come chiave del record, che rappresenta questo asset nello stato del codice concatenato. Questo decoratore viene applicato automaticamente quando viene impalcato un nuovo progetto TypeScript. L'argomento identifier del decorator acquisisce il valore dal file di specifica.
@Id('supplierId')
export class Supplier extends OchainModel{
...
}
Decoratori di proprietà
È possibile utilizzare più decoratori di proprietà. I decoratori sono risolti in ordine dall'alto verso il basso.
@Mandatory()
Questo decoratore contrassegna la proprietà seguente come obbligatoria, in modo che non possa essere saltata durante il salvataggio nel libro contabile. Se saltato, viene restituito un errore.
@Mandatory()
public supplierID: string;
@Default(param)
Questo decorator indica che la proprietà seguente ha un valore predefinito. Il valore predefinito nell'argomento (param) viene utilizzato quando la proprietà viene saltata durante il salvataggio nel libro contabile.
@Default('open for business')
@Validate(yup.string())
public remarks: string;
@Validate(param)
La proprietà che segue questo decoratore viene convalidata in base allo schema specificato dal parametro. L'argomento param accetta uno schema yup e più metodi di schema possono essere concatenati per aggiungere convalide complesse. Per ulteriori informazioni, vedere https://www.npmjs.com/package/yup.
@Validate(yup.number().min(3))
public productsShipped: number;
@ReadOnly(param)
Questo decoratore di proprietà contrassegna la proprietà sottostante come di sola lettura. Il valore nell'argomento, ad esempio param, viene utilizzato quando la proprietà viene salvata nel libro contabile. Una volta impostato, il valore non può essere modificato o rimosso.
@ReadOnly('digicur')
public token_name: string;
@Embedded(PropertyClass)
Questo decoratore di proprietà contrassegna la proprietà sottostante come un bene incorporabile. Prende la classe incorporabile come parametro. Questa classe deve estendere la classe EmbeddedModel. Questo requisito è convalidato dal decoratore.
Nell'esempio seguente, la classe Employee ha una proprietà denominata address di tipo Address, che verrà incorporata nell'asset Employee. Questo è indicato dal decoratore @Embedded(). 
export class Employee extends OchainModel<Employee> {

   public readonly assetType = 'employee';

   @Mandatory()
   @Validate(yup.string())
   public emplyeeID: string;

   @Mandatory()
   @Validate(yup.string().max(30))
   public firstName: string;

   @Mandatory()
   @Validate(yup.string().max(30))
   public lastName: string;

   @Validate(yup.number().positive().min(18))
   public age: number;

   @Embedded(Address)
   public address: Address;
}
export class Address extends EmbeddedModel<Address> {

   @Validate(yup.string())
   public street: string;

   @Validate(yup.string())
   public city: string;

   @Validate(yup.string())
   public state: string;

   @Validate(yup.string())
   public country: string;
}
Quando viene creata una nuova istanza della classe Address, tutte le proprietà della classe Address vengono convalidate automaticamente dal decoratore @Validate(). Si noti che la classe Address non dispone della proprietà assetType o del decoratore della classe @Id(). Questo cespite e le relative proprietà non vengono salvati separatamente nel libro contabile, ma vengono salvati insieme all'asset Employee. Gli asset incorporati sono classi definite dall'utente che fungono da tipi di valore. L'istanza di questa classe può essere memorizzata solo nel libro contabile come parte dell'oggetto contenente (asset OchainModel). Tutti i decoratori di cui sopra vengono applicati automaticamente in base al file di input durante l'impalcatura del progetto.
@Derived(STRATEGY, ALGORITHM, FORMAT)
Questo decoratore viene utilizzato per definire l'attributo derivato da altre proprietà. Questo decoratore ha due parametri obbligatori:
  • STRATEGY: accetta i valori CONCAT o HASH. Se si specifica HASH, il parametro aggiuntivo ALGORITHM è obbligatorio. L'algoritmo predefinito è sha256; è supportato anche md5.
  • FORMAT: consente di utilizzare un array di stringhe e valori di specifica per la strategia. 
@Id('supplierID')
export class Supplier extends OchainModel<Supplier> {

   public readonly assetType = 'supplier';

   @Mandatory()
   @Derived(STRATEGY.HASH.'sha256',['IND%1IND%2','license','name'])
   @Validate(yup.string())
   public supplierID: string;

   @Validate(yup.string().min(2).max(4))
   public license: string;

   @Validate(yup.string().min(2).max(4))
   public name: string;
Decoratori di metodi
@Validator(…params)
Questo decoratore viene applicato ai metodi della classe principale del controller. Questo decoratore è importante per analizzare gli argomenti, convalidando contro tutti i decoratori della proprietà e restituendo un oggetto modello / tipo. I metodi del controller devono avere questo decoratore da richiamare. Richiede più modelli creati dall'utente o schemi yup come parametri.
L'ordine dei parametri deve essere esattamente lo stesso dell'ordine degli argomenti nel metodo.
Nell'esempio seguente, il riferimento al modello Supplier viene passato nel parametro che corrisponde al tipo asset nell'argomento del metodo. In fase di esecuzione, il decorator analizza e converte l'argomento del metodo in un oggetto JSON, esegue la convalida in base ai programmi di convalida Supplier e dopo la convalida riuscita converte l'oggetto JSON in un oggetto Supplier e lo assegna alla variabile asset. Quindi il metodo di base è finalmente chiamato.
@Validator(Supplier)
public async createSupplier(asset: Supplier) {
    return await this.Ctx.Model.save(asset);
}
Nell'esempio seguente vengono passati più riferimenti agli asset che corrispondono ai tipi di oggetto degli argomenti del metodo. Notare l'ordine dei parametri.
@Validator(Supplier, Manufacturer)
public async createProducts(supplier: Supplier, manufacturer: Manufacturer) {
}
Oltre ai riferimenti agli asset, gli oggetti dello schema yup possono essere passati anche se gli argomenti sono di tipo base. Nell'esempio seguente, supplierId e rawMaterialSupply sono rispettivamente di tipo string e number, quindi lo schema yup di tipo simile e l'ordine corretto vengono passati al decorator. Prendere nota del concatenamento dei metodi dello schema yup.
@Validator(yup.string(), yup.number().positive())
public async fetchRawMaterial(supplierID: string, rawMaterialSupply: number) {
	const supplier = await this.Ctx.Model.get(supplierID, Supplier);
	supplier.rawMaterialAvailable = supplier.rawMaterialAvailable + rawMaterialSupply;
	return await this.Ctx.Model.update(supplier);
}

ORM

La funzionalità di persistenza trasparente o ORM semplificato viene acquisita nella classe Model dell'oggetto Contesto (Ctx). Se il modello chiama uno qualsiasi dei seguenti metodi SDK, accedervi utilizzando this.Ctx.Model.

I seguenti metodi SDK implementano ORM:
  • save chiama il metodo Hyperledger Fabric putState.
  • get chiama il metodo Hyperledger Fabric getState.
  • update chiama il metodo Hyperledger Fabric putState.
  • delete chiama il metodo Hyperledger Fabric deleteState.
  • history chiama il metodo Hyperledger Fabric getHistoryForKey.
  • getByRange chiama il metodo Hyperledger Fabric getStateByRange.
  • getByRangeWithPagination chiama il metodo Hyperledger Fabric getStateByRangeWithPagination.
Per ulteriori informazioni, vedere: Metodi SDK.

Metodi SDK

Nota

A partire dalla versione 21.3.2, la modalità di accesso ai metodi ORM è cambiata. Eseguire il comando ochain --version per determinare la versione di Blockchain App Builder.

Nelle release precedenti, i metodi ORM venivano ereditati dalla classe OchainModel. Nella versione 21.3.2 e successive, i metodi sono definiti nella classe Model dell'oggetto Context (Ctx). Per chiamare questi metodi, accedervi utilizzando this.Ctx.Model.<method_name>.

L'esempio seguente mostra una chiamata di metodo nelle release precedenti.

@Validator(Supplier)
public async createSupplier(asset: Supplier){
    return await asset.save();
}

L'esempio seguente mostra una chiamata di metodo dalla versione 21.3.2 e successive:

@Validator(Supplier)
public async createSupplier(asset: Supplier) {
      return await this.Ctx.Model.save(asset);
}

Dopo l'aggiornamento alla versione 21.3.2, apportare questa modifica in tutti i progetti di codice concatenato creati con una versione precedente di Blockchain App Builder. Se si utilizza il comando sync per sincronizzare le modifiche tra il file di specifica e il codice sorgente, le modifiche vengono automaticamente apportate al controller per i metodi pronti all'uso. È comunque necessario risolvere manualmente eventuali conflitti.

save
Il metodo save aggiunge i dettagli del chiamante asset al libro contabile.
Questo metodo chiama Hyperledger Fabric putState internamente. Tutti i marshalling/unmarshalling sono gestiti internamente. Il metodo save fa parte della classe Model, a cui si accede utilizzando l'oggetto Ctx. 
Ctx.Model.save(asset: <Instance of Asset Class> , extraMetadata?: any) : Promise <any>
Parametri:
  • extraMetadata : any (facoltativo) – utilizzato per salvare i metadati separatamente dall'asset nel libro contabile.
Restituisce:
  • Promise<any> - Restituisce una promessa al completamento.
Esempio:
@Validator(Supplier)
public async createSupplier(asset: Supplier) {
	return await this.Ctx.Model.save(asset);
}
get
Il metodo get è un metodo della classe OchainModel, ereditato dalle classi di modelli concreti di {chaincodeName}.model.ts. Il metodo get fa parte della classe Model, a cui si accede utilizzando l'oggetto Ctx.
Per restituire un asset da un dato id, utilizzare il metodo del controller generico getAssetById. 
Ctx.Model.get(id: string, modelName: <Model Asset Class Name>) : Promise<asset>
Parametri:
  • id : string: chiave utilizzata per salvare i dati nel libro contabile.
  • modelName: <Model Asset Class Name>: (facoltativo) modello di classe asset da restituire.
Restituisce:
  • Promise: <Asset>: se il parametro modelName non viene fornito ed esistono dati nel libro contabile, viene restituito Promise<object>. Se il parametro id non esiste nel libro contabile, viene restituito un messaggio di errore. Se viene fornito il parametro modelName, viene restituito un oggetto di tipo <Asset>. Anche se qualsiasi asset con il dato id viene restituito dal libro contabile, questo metodo gestirà il casting nel tipo chiamante Asset. Se il cespite restituito dal libro contabile non è di tipo Asset, il metodo restituisce un errore. Questo controllo viene eseguito dalla proprietà assetType di sola lettura nella classe Model.
Esempio:
@Validator(yup.string())
public async getSupplierById(id: string) {
	const asset = await this.Ctx.Model.get(id, Supplier);
	return asset;
}
Nell'esempio, asset è di tipo Supplier.
update
Il metodo update aggiorna i dettagli del chiamante asset nel libro contabile. Questo metodo restituisce una promessa.
Questo metodo chiama Hyperledger Fabric putState internamente. Tutto il marshalling/unmarshalling è gestito internamente. Il metodo update fa parte della classe Model, a cui è possibile accedere utilizzando l'oggetto Ctx. 
Ctx.Model.update(asset: <Instance of Asset Class> , extraMetadata?: any) : Promise <any>
Parametri:
  • extraMetadata : any (facoltativo) – utilizzato per salvare i metadati separatamente dall'asset nel libro contabile.
Restituisce:
  • Promise<any> - Restituisce una promessa al completamento.
Esempio:
@Validator(Supplier)
public async updateSupplier(asset: Supplier) {
	return await this.Ctx.Model.update(asset);
}
delete
Questo elimina il cespite dal libro contabile fornito da id se esiste. Questo metodo chiama internamente il metodo Hyperledger Fabric deleteState. Il metodo delete fa parte della classe Model, a cui è possibile accedere utilizzando l'oggetto Ctx. 
Ctx.Model.delete(id: string): Promise <any>
Parametri:
  • id : string: chiave utilizzata per salvare i dati nel libro contabile.
Restituisce:
  • Promise <any> - Restituisce una promessa al completamento.
Esempio:
@Validator(yup.string())
public async deleteSupplier(id: string) {
	const result = await this.Ctx.Model.delete(id);
	return result;
}
history
Il metodo history fa parte della classe Model, a cui è possibile accedere utilizzando l'oggetto Ctx. Questo metodo restituisce la cronologia dei cespiti fornita da id dal libro contabile, se esistente.
Questo metodo chiama internamente il metodo Hyperledger Fabric getHistoryForKey. 
Ctx.Model.history(id: string): Promise <any>
Parametri:
  • id : string: chiave utilizzata per salvare i dati nel libro contabile.
Restituisce:
  • Promise <any[]> - Restituisce qualsiasi [] al completamento.
Esempio
@Validator(yup.string())
public async getSupplierHistoryById(id: string) {
	const result = await this.Ctx.Model.history(id);
	return result;
}
Esempio della cronologia asset restituita per getSupplierHistoryById:
[
    {
        "trxId": "8ef4eae6389e9d592a475c47d7d9fe6253618ca3ae0bcf77b5de57be6d6c3829",
        "timeStamp": 1602568005,
        "isDelete": false,
        "value": {
            "assetType": "supplier",
            "supplierId": "s01",
            "rawMaterialAvailable": 10,
            "license": "abcdabcdabcd",
            "expiryDate": "2020-05-28T18:30:00.000Z",
            "active": true
        }
    },
    {
        "trxId": "92c772ce41ab75aec2c05d17d7ca9238ce85c33795308296eabfd41ad34e1499",
        "timeStamp": 1602568147,
        "isDelete": false,
        "value": {
            "assetType": "supplier",
            "supplierId": "s01",
            "rawMaterialAvailable": 15,
            "license": "valid license",
            "expiryDate": "2020-05-28T18:30:00.000Z",
            "active": true
        }
    }
]
getByRange
Il metodo getByRange è un metodo statico della classe OchainModel ereditato dalle classi Model concrete di {chaincodeName}.model.ts.
Questo metodo restituisce una lista di asset compresi tra l'intervallo startId e endId. Questo metodo chiama internamente il metodo Hyperledger Fabric getStateByRange.
Se il parametro modelName non viene fornito, il metodo restituisce Promise<Object [ ] >. Se viene fornito il parametro modelName, il metodo gestisce il casting nel tipo Model del chiamante. Nell'esempio seguente, l'array dei risultati è di tipo Supplier. Se il cespite restituito dal libro contabile non è di tipo Model, non verrà incluso nell'elenco. Questo controllo viene eseguito dalla proprietà assetType di sola lettura nella classe Model.
Per restituire tutti gli asset compresi tra l'intervallo startId e endId, utilizzare il metodo controller generico getAssetsByRange. 
Ctx.Model.getByRange(startId: string, endId: string, modelName: <Asset Model Class Name> ): Promise <any>
Parametri:
  • startId : string – Chiave iniziale dell'intervallo, inclusa nell'intervallo.
  • endId : string: chiave finale dell'intervallo, esclusa dall'intervallo.
  • modelName: <Model Asset Class Name>: (facoltativo) modello di classe asset da restituire.
Restituisce:
  • Promise< Asset[ ] > - Restituisce l'array di <Asset> al completamento.
Esempio:
@Validator(yup.string(), yup.string())
public async getSupplierByRange(startId: string, endId: string) {
	const result = await this.Ctx.Model.getByRange(startId, endId, Supplier);
	return result;
}
getByRangeWithPagination
Il metodo getByRangeWithPagination è un metodo statico della classe OchainModel ereditato dalle classi Model concrete di {chaincodeName}.model.ts.
Questo metodo restituisce un elenco di asset compreso tra startId e endId. Questo metodo chiama internamente il metodo Hyperledger Fabric getStateByRangeWithPagination.
Se il parametro modelName non viene fornito, il metodo restituisce Promise<Object [ ] >. Se viene fornito il parametro modelName, il metodo gestisce il casting nel tipo Model del chiamante. Nell'esempio seguente, l'array dei risultati è di tipo Supplier. Se il cespite restituito dal libro contabile non è di tipo Model, non verrà incluso nell'elenco. Questo controllo viene eseguito dalla proprietà assetType di sola lettura nella classe Model.
Per restituire tutti gli asset compresi tra l'intervallo startId e endId, filtrati in base alle dimensioni della pagina e ai segnalibri, utilizzare il metodo controller generico getAssetsByRange. 
public async getByRangeWithPagination<T extends OchainModel<T>>(startId: string, endId: string, pageSize: number, bookmark?: string, instance?: new (data: any, skipMandatoryCheck: boolean, skipReadOnlyCheck: boolean) => T): Promise<T[]>
Parametri:
  • startId : string – Chiave iniziale dell'intervallo, inclusa nell'intervallo.
  • endId : string: chiave finale dell'intervallo, esclusa dall'intervallo.
  • pageSize : number: la dimensione della pagina della query.
  • bookmark : string: il segnalibro della query. L'output inizia da questo segnalibro.
  • modelName: <Model Asset Class Name>: (facoltativo) modello di classe asset da restituire.
Restituisce:
  • Promise< Asset[ ] > - Restituisce l'array di <Asset> al completamento.
getId
Quando il cespite ha una chiave derivata come Id, è possibile utilizzare questo metodo per ottenere un ID derivato. Questo metodo restituisce un errore se la chiave derivata contiene %t (indicatore orario).
Parametri:
  • object: l'oggetto deve contenere tutte le proprietà da cui dipende la chiave derivata.
Restituisce:
  • Restituisce la chiave derivata come stringa.
Esempio:
@Validator(yup.string(), yup.string())
  
public async customGetterForSupplier(license: string, name: string){
    let object = {
      license : license,
      name: name
    }
    const id = await this.Ctx.Model.getID(object);
    return this.Ctx.Model.get(id);
}

Per i metodi SDK del token, vedere gli argomenti in Supporto della tokenizzazione mediante Blockchain App Builder.

Controller

La classe del controller principale estende la classe OchainController. C'è solo un controller principale. 

export class TSProjectController extends OchainController{

È possibile creare un numero qualsiasi di classi, funzioni o file, ma solo i metodi definiti nella classe principale del controller sono richiamabili dall'esterno; il resto sono nascosti.

Metodi generati automaticamente

Come descritto in File di specifica di input, è possibile specificare i metodi CRUD da generare nel file di specifica. Ad esempio, se è stato specificato di generare tutti i metodi, il risultato sarà simile al codice seguente: 

@Validator(Supplier)
public async createSupplier(asset: Supplier) {
	return await this.Ctx.Model.save(asset);
}

@Validator(yup.string())
public async getSupplierById(id: string) {
	const asset = await this.Ctx.Model.get(id, Supplier);
	return asset;
}

@Validator(Supplier)
public async updateSupplier(asset: Supplier) {
	return await this.Ctx.Model.update(asset);
}

@Validator(yup.string())
public async deleteSupplier(id: string) {
	const result = await this.Ctx.Model.delete(id);
	return result;
}

@Validator(yup.string())
public async getSupplierHistoryById(id: string) {
	const result = await this.Ctx.Model.history(id);
	return result;
}

@Validator(yup.string(), yup.string())
public async getSupplierByRange(startId: string, endId: string) {
	const result = await this.Ctx.Model.getByRange(startId, endId, Supplier);
	return result;
}

Dettagli metodo controller

Oltre al modello precedente CRUD e metodi non CRUD, Blockchain App Builder fornisce il supporto pronto all'uso dal nostro controller per i seguenti metodi Hyperledger Fabric:
  • getAssetById
  • getAssetsByRange
  • getAssetHistoryById
  • query
  • queryWithPagination
  • generateCompositeKey
  • getByCompositeKey
  • getTransactionId
  • getTransactionTimestamp
  • getChannelID
  • getCreator
  • getSignedProposal
  • getArgs
  • getStringArgs
  • getMspID
  • getNetworkStub

Nota

Questi metodi sono disponibili con il contesto this in qualsiasi classe che estende la classe OChainController.
Ad esempio:
public async getModelById(id: string) {   
    const asset = await this.getAssetById(id); 
    return asset;
}
@Validator(yup.string(), yup.string())
public async getModelsByRange(startId: string, endId: string) { 
    const asset = await this.getAssetsByRange(startId, endId); 
    return asset;
}
public async getModelHistoryById(id: string) {
    const result = await this.getAssetHistoryById(id); 
    return result;
}
getAssetById
Il metodo getAssetById restituisce un asset in base a un ID specificato. Questo è un metodo generico e può essere utilizzato per ottenere asset di qualsiasi tipo. 
this.getAssetById(id: string): Promise<byte[]>
Parametri:
  • id : string: chiave utilizzata per salvare i dati nel libro contabile.
Restituisce:
  • Promise <byte [ ]>: promessa di restituzione al completamento. È necessario convertire byte[] in un oggetto.
getAssetsByRange
Il metodo getAssetsByRange restituisce tutti gli asset presenti da startId (incluso) a endId (escluso) indipendentemente dai tipi di asset. Questo è un metodo generico e può essere utilizzato per ottenere asset di qualsiasi tipo. 
this.getAssetsByRange(startId: string, endId: string):
Promise<shim.Iterators.StateQueryIterator>
Parametri:
  • startId : string – Chiave iniziale dell'intervallo, inclusa nell'intervallo.
  • endId : string: chiave finale dell'intervallo, esclusa dall'intervallo.
Restituisce:
  • Promise< shim.Iterators.StateQueryIterator>: restituisce un iteratore al completamento. Devi iterare su di esso.
getAssetHistoryById
Il metodo getAssetHistoryById restituisce l'iteratore della cronologia di un asset per un ID specificato. 
this.getAssetHistoryById(id: string):
Promise<shim.Iterators.HistoryQueryIterator>
Parametri:
  • id : string: chiave utilizzata per salvare i dati nel libro contabile.
Restituisce:
  • Promise<shim.Iterators.HistoryQueryIterator>: restituisce un iteratore di query della cronologia. Devi iterare su di esso.
query
Il metodo query esegue una query SQL/Couch DB avanzata sul libro contabile. Questo metodo è supportato solo per le distribuzioni remote su Oracle Blockchain Platform. Metodo generico per l'esecuzione di query SQL nel libro contabile. 
this.query(queryStr: string):
Promise<shim.Iterators.StateQueryIterator>
Parametri:
  • queryStr : string - Query Rich SQL/Couch DB.
Restituisce:
  • Promise<shim.Iterators.StateQueryIterator>: restituisce un iteratore di query di stato. Devi iterare su di esso.
queryWithPagination
Questo metodo esegue una query SQL/Couch DB avanzata sul libro contabile, filtrata in base alle dimensioni della pagina e ai segnalibri. Questo metodo è supportato solo per le distribuzioni remote su Oracle Blockchain Platform. Metodo generico per l'esecuzione di query SQL nel libro contabile.
public async queryWithPagination(query: string, pageSize: number, bookmark?: string)
Parametri:
  • query : string - Query Rich SQL/Couch DB.
  • pageSize : number: la dimensione della pagina della query.
  • bookmark : string: il segnalibro della query. L'output inizia da questo segnalibro.
Restituisce:
  • Promise<shim.Iterators.StateQueryIterator>: restituisce un iteratore di query di stato. Devi iterare su di esso.
generateCompositeKey
Questo metodo genera e restituisce la chiave composta in base al valore indexName e agli attributi specificati negli argomenti. 
this.generateCompositeKey(indexName: string, attributes:
string[]): string
Parametri:
  • indexName : string: tipo di oggetto della chiave utilizzata per salvare i dati nel libro contabile.
  • attributes: string[ ] - Attributi in base ai quali verrà formata una chiave composta.
Restituisce:
  • string: restituisce una chiave composta.
getByCompositeKey
Questo metodo restituisce l'asset che corrisponde alla chiave e alla colonna specificate nel parametro dell'attributo durante la creazione di una chiave composta. Il parametro indexOfId indica l'indice della chiave restituito nell'array del metodo stub SplitCompositeKey. Internamente questo metodo chiama i metodi getStateByPartialCompositeKey, splitCompositeKey e getState di Hyperledger Fabric. 
this.getByCompositeKey(key: string, columns: string[],
indexOfId: number): Promise<any []>
Parametri:
  • key: string: chiave utilizzata per salvare i dati nel libro contabile.
  • columns: string[ ] - Attributi in base ai quali viene generata una chiave.
  • indexOfId: number: indice dell'attributo da recuperare dalla chiave.
Restituisce:
  • Promise< any [ ] - Restituisce qualsiasi [] al completamento.
getTransactionId
Restituisce l'ID transazione per la richiesta di richiamo del codice concatenato corrente. L'ID transazione identifica in modo univoco la transazione nell'ambito del canale.
this.getTransactionId(): string
Parametri:
  • nessuno
Restituisce:
  • string: restituisce l'ID della transazione per la richiesta di richiamo del codice concatenato corrente.
getTransactionTimestamp
Restituisce l'indicatore orario durante la creazione della transazione. Questo è preso dalla transazione ChannelHeader, quindi indicherà l'indicatore orario del cliente e avrà lo stesso valore in tutti gli sponsor. 
this.getTransactionTimestamp(): Timestamp
Parametri:
  • id : string: chiave utilizzata per salvare i dati nel libro contabile.
Restituisce:
  • Timestamp: restituisce l'indicatore orario durante la creazione della transazione.
getChannelID
Restituisce l'ID canale per la proposta per il codice concatenato da elaborare.
this.getChannelID(): string
Parametri:
  • nessuno
Restituisce:
  • string: restituisce l'ID del canale.
getCreator
Restituisce l'oggetto di identità dell'autore sottomissione del richiamo del codice concatenato.
this.getCreator(): shim.SerializedIdentity
Parametri:
  • nessuno
Restituisce:
  • shim.SerializedIdentity: restituisce l'oggetto identità.
getSignedProposal
Restituisce un oggetto completamente decodificato della proposta di transazione firmata.
this.getSignedProposal():
shim.ChaincodeProposal.SignedProposal
Parametri:
  • nessuno
Restituisce:
  • shim.ChaincodeProposal.SignedProposal - Restituisce l'oggetto decodificato della proposta di transazione firmata.
getArgs
Restituisce gli argomenti come array di stringhe dalla richiesta di richiamo del codice concatenato.
this.getArgs(): string[]
Parametri:
  • nessuno
Restituisce:
  • string [ ]: restituisce gli argomenti come array di stringhe dal richiamo del codice concatenato.
getStringArgs
Restituisce gli argomenti come array di stringhe dalla richiesta di richiamo del codice concatenato.
this.getStringArgs(): string[]
Parametri:
  • nessuno
Restituisce:
  • string [ ]: restituisce gli argomenti come array di stringhe dal richiamo del codice concatenato.
getMspID
Restituisce l'ID MSP dell'identità di richiamo.
this.getMspID(): string
Parametri:
  • nessuno
Restituisce:
  • string: restituisce l'ID MSP dell'identità di richiamo.
getNetworkStub
Puoi accedere allo shim stub chiamando questo metodo. Questo può aiutarti a scrivere la tua implementazione di lavorare direttamente con gli asset.
this.getNetworkStub(): shim.ChaincodeStub
Parametri:
  • nessuno
Restituisce:
  • shim.ChaincodeStub - Restituisce lo stub della rete con codice concatenato.
invokeCrossChaincode
È possibile utilizzare questo metodo in un codice concatenato per chiamare una funzione in un altro codice concatenato. Entrambi i codici concatenati devono essere installati sullo stesso peer.
this.invokeCrossChaincode(chaincodeName: string, methodName: string, args: string[], channelName: string): Promise<any>
Parametri:
  • chaincodeName – Il nome del codice concatenato da chiamare.
  • methodName - Il nome del metodo da chiamare nel codice concatenato.
  • arg: l'argomento del metodo chiamante.
  • channelName - Il canale in cui si trova il codice concatenato da chiamare.
Restituisce:
  • Promise<any>: restituisce un oggetto JSON che contiene tre campi:
    • isValid - true se la chiamata è valida.
    • payload: l'output restituito dalla chiamata cross-chaincode come oggetto JSON.
    • message - Il messaggio restituito dalla chiamata cross-chaincode, in formato UTF-8.
invokeChaincode
Questo metodo chiama una funzione in un altro codice concatenato. Entrambi i codici concatenati devono essere installati sullo stesso peer.
this.invokeChaincode(chaincodeName: string, methodName: string, args: string[], channelName: string): Promise<any>
Parametri:
  • chaincodeName – Il nome del codice concatenato da chiamare.
  • methodName - Il nome del metodo da chiamare nel codice concatenato.
  • arg: l'argomento del metodo chiamante.
  • channelName - Il canale in cui si trova il codice concatenato da chiamare.
Restituisce:
  • Promise<any>: restituisce un oggetto JSON che contiene tre campi:
    • isValid - true se la chiamata è valida.
    • payload: l'output restituito dalla chiamata cross-chaincode come oggetto JSON.
    • message - Il messaggio restituito dalla chiamata cross-chaincode, in formato UTF-8.

Metodi personalizzati

I seguenti metodi personalizzati sono stati generati dal nostro file di specifica di esempio.

Il metodo executeQuery mostra come è possibile chiamare le query SQL rich. I validator rispetto agli argomenti vengono aggiunti automaticamente da Blockchain App Builder in base al tipo di argomento specificato nel file di specifica. 


/**
*
*	BDB sql rich queries can be executed in OBP CS/EE.
*	This method can be invoked only when connected to remote OBP CS/EE network.
*
*/
@Validator(yup.string()}
public async executeQuery(query: string) {
    const result = await OchainController.query(query); 
    return result;
}
@Validator(yup.string(), yup.number()}
public async fetchRawMaterial(supplierId: string, rawMaterialSupply: number) {
}
@Validator(yup.string(), yup.string(), yup.number())
public async getRawMaterialFromSupplier(manufacturerId: string, supplierId: string, rawMaterialSupply: number) {
}
@Validator(yup.string(), yup.number(), yup.number())
public async createProducts(manufacturerId: string, rawMaterialConsumed: number, productsCreated: number) {
}
public async sendProductsToDistribution() { 
}

Metodo inizializzazione

Nel controller viene fornito un metodo init personalizzato con una definizione vuota. Se si utilizza Blockchain App Builder per la distribuzione o l'aggiornamento, il metodo init viene richiamato automaticamente. Se si esegue la distribuzione o l'upgrade dalla console di Oracle Blockchain Platform, è necessario chiamare il metodo init manualmente. È possibile utilizzare uno strumento di terze parti come Postman per chiamare manualmente il metodo init. 

export class TestTsProjectController extends OchainController {
    public async init(params: any) { 
        return;
}

È quindi possibile utilizzare questo metodo per inizializzare qualsiasi stato dell'applicazione.