基于hyperledger联盟链的汽车轨迹追溯系统
一、koa架构整理
在完成之前的六个流程之后，已经完成一个简易的可交互的前后端系统，在此基础上进行系统开发
之前的后端架构可移植性不好，这里进行后端架构的整理
在controller文件夹下建立工具模块tool.js
用于封装所有与区块链相关的业务(交易，查询，根据hash回溯交易）
const Fabric_Client = require('fabric-client');
const path = require('path');
const os = require('os')
const util = require('util')
const fs = require('fs');
// const theStotePath = '/home/zatnr/文档/sitpProject/20210302/carChain/app/hfc-key-store';
const theStotePath = './hfc-key-store';
async function excuteQuery (sendRequest) {
const title = 'admin page'
let result = ''
var fabric_client = new Fabric_Client();
var key = "name"
// setup the fabric network
var channel = fabric_client.newChannel('mychannel');
var peer = fabric_client.newPeer('grpc://localhost:7051');
channel.addPeer(peer);
//
var member_user = null;
// var store_path = path.join(os.homedir(), '.hfc-key-store');
var store_path = path.join(theStotePath);
console.log('Store path:'+store_path);
// create the key value store as defined in the fabric-client/config/default.json 'key-value-store' setting
result = await Fabric_Client.newDefaultKeyValueStore({ path: store_path
}).then((state_store) => {
// assign the store to the fabric client
fabric_client.setStateStore(state_store);
var crypto_suite = Fabric_Client.newCryptoSuite();
// use the same location for the state store (where the users' certificate are kept)
// and the crypto store (where the users' keys are kept)
var crypto_store = Fabric_Client.newCryptoKeyStore({path: store_path});
crypto_suite.setCryptoKeyStore(crypto_store);
fabric_client.setCryptoSuite(crypto_suite);
// get the enrolled user from persistence, this user will sign all requests
return fabric_client.getUserContext('user1', true);
}).then((user_from_store) => {
if (user_from_store && user_from_store.isEnrolled()) {
console.log('Successfully loaded user1 from persistence');
member_user = user_from_store;
} else {
throw new Error('Failed to get user1.... run registerUser.js');
}
// queryTuna - requires 1 argument, ex: args: ['4'],
const request = sendRequest;
// send the query proposal to the peer
return channel.queryByChaincode(request);
}).then((query_responses) => {
console.log("Query has completed, checking results");
// query_responses could have more than one results if there multiple peers were used as targets
if (query_responses && query_responses.length == 1) {
if (query_responses[0] instanceof Error) {
console.error("error from query = ", query_responses[0]);
result = "Could not locate tuna"
} else {
console.log("Response is ", query_responses[0].toString());
return query_responses[0].toString()
}
} else {
console.log("No payloads were returned from query");
result = "Could not locate tuna"
}
}).catch((err) => {
console.error('Failed to query successfully :: ' + err);
result = 'Failed to query successfully :: ' + err
});
// await ctx.render('index', {
// title, result
// })
return result
}
async function executeTranSaction(sendRequest){
console.log(`request.....${sendRequest}`)
var fabric_client = new Fabric_Client();
// setup the fabric network
var channel = fabric_client.newChannel('mychannel');
var peer = fabric_client.newPeer('grpc://localhost:7051');
var order = fabric_client.newOrderer('grpc://localhost:7050')
channel.addOrderer(order);
channel.addPeer(peer);
var member_user = null;
// var store_path = path.join(os.homedir(), '.hfc-key-store');
var store_path = path.join(theStotePath);
console.log('Store path:'+store_path);
// create the key value store as defined in the fabric-client/config/default.json 'key-value-store' setting
let result = await Fabric_Client.newDefaultKeyValueStore({ path: store_path
}).then((state_store) => {
// assign the store to the fabric client
fabric_client.setStateStore(state_store);
var crypto_suite = Fabric_Client.newCryptoSuite();
// use the same location for the state store (where the users' certificate are kept)
// and the crypto store (where the users' keys are kept)
var crypto_store = Fabric_Client.newCryptoKeyStore({path: store_path});
crypto_suite.setCryptoKeyStore(crypto_store);
fabric_client.setCryptoSuite(crypto_suite);
// get the enrolled user from persistence, this user will sign all requests
return fabric_client.getUserContext('user1', true);
}).then((user_from_store) => {
if (user_from_store && user_from_store.isEnrolled()) {
console.log('Successfully loaded user1 from persistence');
member_user = user_from_store;
} else {
throw new Error('Failed to get user1.... run registerUser.js');
}
// get a transaction id object based on the current user assigned to fabric client
tx_id = fabric_client.newTransactionID();
console.log("Assigning transaction_id: ", tx_id._transaction_id);
// recordTuna - requires 5 args, ID, vessel, location, timestamp,holder - ex: args: ['10', 'Hound', '-12.021, 28.012', '1504054225', 'Hansel'],
// send proposal to endorser
sendRequest.txId = tx_id;
console.log("sendRequest...."+sendRequest.txId)
const request = sendRequest;
// send the transaction proposal to the peers
return channel.sendTransactionProposal(request);
}).then((results) => {
var proposalResponses = results[0];
var proposal = results[1];
let isProposalGood = false;
if (proposalResponses && proposalResponses[0].response &&
proposalResponses[0].response.status === 200) {
isProposalGood = true;
console.log('Transaction proposal was good');
} else {
console.error('Transaction proposal was bad');
}
if (isProposalGood) {
console.log(util.format(
'Successfully sent Proposal and received ProposalResponse: Status - %s, message - "%s"',
proposalResponses[0].response.status, proposalResponses[0].response.message));
// build up the request for the orderer to have the transaction committed
var request = {
proposalResponses: proposalResponses,
proposal: proposal
};
// set the transaction listener and set a timeout of 30 sec
// if the transaction did not get committed within the timeout period,
// report a TIMEOUT status
var transaction_id_string = tx_id.getTransactionID(); //Get the transaction ID string to be used by the event processing
var promises = [];
var sendPromise = channel.sendTransaction(request);
promises.push(sendPromise); //we want the send transaction first, so that we know where to check status
// get an eventhub once the fabric client has a user assigned. The user
// is required bacause the event registration must be signed
//------------------------------------------------------------
// let event_hub = fabric_client.newEventHub('grpc://localhost:7053');
// // let event_hub = new ChannelEventHub(channel, peer);
// //接下来设置EventHub，用于监听Transaction是否成功写入，这里也是启用了TLS
// let data = fs.readFileSync('/home/fabric/Documents/carChain/basic-network/crypto-config/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt');
// let grpcOpts = {
// 'pem': Buffer.from(data).toString(),
// 'ssl-target-name-override': "peer0.org1.example.com"
// }
// event_hub.setPeerAddr('grpc://localhost:7053',grpcOpts);
// event_hub.connect();
// console.log('data:'+data);
// console.log('grpcOpts.pem:'+grpcOpts.pem);
//------------------------------------------------------------
let event_hub = channel.newChannelEventHub('localhost:7051');
//------------------------------------------------------------
// using resolve the promise so that result status may be processed
// under the then clause rather than having the catch clause process
// the status
let txPromise = new Promise((resolve, reject) => {
let handle = setTimeout(() => {
event_hub.disconnect();
resolve({event_status : 'TIMEOUT'}); //we could use reject(new Error('Trnasaction did not complete within 30 seconds'));
}, 3000);
event_hub.connect();
event_hub.registerTxEvent(transaction_id_string, (tx, code) => {
// this is the callback for transaction event status
// first some clean up of event listener
clearTimeout(handle);
event_hub.unregisterTxEvent(transaction_id_string);
event_hub.disconnect();
// now let the application know what happened
var return_status = {event_status : code, tx_id : transaction_id_string};
if (code !== 'VALID') {
console.error('The transaction was invalid, code = ' + code);
resolve(return_status); // we could use reject(new Error('Problem with the tranaction, event status ::'+code));
} else {
//-------------------------------------------------------------------------------------------
//console.log('The transaction has been committed on peer ' + event_hub._ep._endpoint.addr);
//-------------------------------------------------------------------------------------------
console.log('The transaction has been committed on peer ' + event_hub.getPeerAddr());
//-------------------------------------------------------------------------------------------
resolve(return_status);
}
}, (err) => {
//this is the callback if something goes wrong with the event registration or processing
reject(new Error('There was a problem with the eventhub ::'+err));
});
});
promises.push(txPromise);
return Promise.all(promises);
} else {
console.error('Failed to send Proposal or receive valid response. Response null or status is not 200. exiting...');
throw new Error('Failed to send Proposal or receive valid response. Response null or status is not 200. exiting...');
}
}).then((results) => {
console.log('Send transaction promise and event listener promise have completed');
// check the results in the order the promises were added to the promise all list
if (results && results[0] && results[0].status === 'SUCCESS') {
console.log('Successfully sent transaction to the orderer.');
//res.send(tx_id.getTransactionID());
return tx_id.getTransactionID();
} else {
console.error('Failed to order the transaction. Error code: ' + response.status);
}
if(results && results[1] && results[1].event_status === 'VALID') {
console.log('Successfully committed the change to the ledger by the peer');
//res.send(tx_id.getTransactionID());
return tx_id.getTransactionID();
} else {
console.log('Transaction failed to be committed to the ledger due to ::'+results[1].event_status);
}
}).catch((err) => {
console.error('Failed to invoke successfully :: ' + err);
});
return result
}
async function excuteRecall ( hash ) {
var fabric_client = new Fabric_Client();
var key = "name"
// setup the fabric network
var channel = fabric_client.newChannel('mychannel');
var peer = fabric_client.newPeer('grpc://localhost:7051');
channel.addPeer(peer);
//
var member_user = null;
// var store_path = path.join(os.homedir(), '.hfc-key-store');
var store_path = path.join(theStotePath);
console.log('Store path:'+store_path);
// create the key value store as defined in the fabric-client/config/default.json 'key-value-store' setting
result = await Fabric_Client.newDefaultKeyValueStore({ path: store_path
}).then((state_store) => {
// assign the store to the fabric client
fabric_client.setStateStore(state_store);
var crypto_suite = Fabric_Client.newCryptoSuite();
// use the same location for the state store (where the users' certificate are kept)
// and the crypto store (where the users' keys are kept)
var crypto_store = Fabric_Client.newCryptoKeyStore({path: store_path});
crypto_suite.setCryptoKeyStore(crypto_store);
fabric_client.setCryptoSuite(crypto_suite);
// get the enrolled user from persistence, this user will sign all requests
return fabric_client.getUserContext('user1', true);
}).then((user_from_store) => {
if (user_from_store && user_from_store.isEnrolled()) {
console.log('Successfully loaded user1 from persistence');
member_user = user_from_store;
} else {
throw new Error('Failed to get user1.... run registerUser.js');
}
// send the query proposal to the peer
return channel.queryBlockByTxID(hash,peer,true,false);
// return channel.queryByChaincode(request);
}).then((query_responses) => {
console.log("Query has completed, checking results");
// query_responses could have more than one results if there multiple peers were used as targets
if (query_responses) {
if (query_responses[0] instanceof Error) {
console.error("error from query = ", query_responses[0]);
result = "Could not locate tuna"
} else {
console.log("Response is ", query_responses);
return query_responses
}
} else {
console.log("No payloads were returned from query");
result = "Could not locate tuna"
}
}).catch((err) => {
console.error('Failed to query successfully :: ' + err);
result = 'Failed to query successfully :: ' + err
});
// await ctx.render('index', {
// title, result
// })
return result
}
exports.excuteQuery = excuteQuery
exports.executeTranSaction = executeTranSaction
exports.excuteRecall = excuteRecall
修改调用层
const tool = require('./tool')
module.exports = {
//插入轨迹
async insertTrail (ctx) {
const queryBody = ctx.request.query;
const Trid = queryBody.Trid;
console.log(`Trid.....${Trid}`)
const jsonStr = queryBody.jsonStr;
console.log(`jsonStr.....${jsonStr}`)
var tx_id = null;
const request = {
//targets : --- letting this default to the peers assigned to the channel
chaincodeId: 'trail',
fcn: 'insertTrail',
args : [Trid,jsonStr],
chainId: 'mychannel',
txId: tx_id
};
ctx.body = await tool.executeTranSaction(request);
},
//查询所有轨迹
async searchAllTrail ( ctx ) {
var tx_id = null;
const request = {
chaincodeId: 'trail',
txId: tx_id,
fcn: 'searchAllTrail',
args: [""],
};
ctx.body = await tool.excuteQuery(request);
},
async searchOneTrail ( ctx ) {
const queryBody = ctx.request.query;
const trid = queryBody.trid;
console.log(`trid.....${trid}`)
var tx_id = null;
const request = {
chaincodeId: 'trail',
txId: tx_id,
fcn: 'searchOneTrail',
args: [trid],
};
ctx.body = await tool.excuteQuery(request);
},
//删除轨迹（世界状态）
async deleteTrail (ctx) {
const queryBody = ctx.request.query;
const Trid = queryBody.Trid;
console.log(`Trid.....${Trid}`)
var tx_id = null;
const request = {
//targets : --- letting this default to the peers assigned to the channel
chaincodeId: 'trail',
fcn: 'deleteTrail',
args : [Trid],
chainId: 'mychannel',
txId: tx_id
};
ctx.body = await this.executeTranSaction(request);
},
//更新轨迹（世界状态）
async updateTrail (ctx) {
const queryBody = ctx.request.query;
const Trid = queryBody.Trid;
console.log(`Trid.....${Trid}`)
const jsonStr = queryBody.jsonStr;
console.log(`jsonStr.....${jsonStr}`)
var tx_id = null;
const request = {
//targets : --- letting this default to the peers assigned to the channel
chaincodeId: 'trail',
fcn: 'updateTrail',
args : [Trid,jsonStr],
chainId: 'mychannel',
txId: tx_id
};
ctx.body = await tool.executeTranSaction(request)
},
// 回溯交易
async searchBlockByHash ( ctx ) {
const queryBody = ctx.request.query;
const hash = queryBody.hash;
console.log(`hash.....${hash}`)
ctx.body = await tool.excuteRecall(hash)
},
async searchTrailByid ( ctx ) {
const queryBody = ctx.request.query;
const userid = queryBody.userid;
var tx_id = null;
console.log(`userid.....${userid}`)
console.log(userid);
const request = {
chaincodeId: 'trail',
txId: tx_id,
fcn: 'searchTrailByid',
args: [userid],
};
ctx.body = await tool.excuteQuery(request);
},
// 获取对应id所有数据的存放记录（可以查询到原始数据）
async getHistoryForTrail ( ctx ) {
const queryBody = ctx.request.query;
const trid = queryBody.trid;
console.log(`trid.....${trid}`)
console.log(trid);
var tx_id = null;
const request = {
chaincodeId: 'trail',
txId: tx_id,
fcn: 'getHistoryForTrail',
args: [trid],
};
ctx.body = await tool.excuteQuery(request)
},
// 查询所有在世界状态上删除的轨迹数据
async getDeletedTrails ( ctx ) {
var tx_id = null;
const request = {
chaincodeId: 'trail',
txId: tx_id,
fcn: 'getDeletedTrails',
args: [""],
};
ctx.body = await tool.excuteQuery(request)
},
}
以便后续进行进一步的业务逻辑集成
二、链码整理
package main
import(
"fmt"
"encoding/json"
"bytes"
"github.com/hyperledger/fabric/core/chaincode/shim"
"github.com/hyperledger/fabric/protos/peer"
)
type TrailChaincode struct {
}
type point struct{
Locationx float64 `json:"locationx"`
Locationy float64 `json:"locationy"`
// Speed float64 `json:"speed"`
// Locatetime int `json:"locatetime"`
// Direction float64 `json:"direction"`
// Height float64 `json:"height"`
}
type Trail struct {
Username string `json:"username"`
Userid string `json:"userid"`
Devid string `json:"devid"`
Devstr string`json:"devstr"`
Trid string `json:"trid"`
Points []point `json:"points"`
Mile float64 `json:"mile"`
State bool `json:"state"`
Hash string `json:"hash"`
}
type DeletedTrails struct {
Num int `json:"num"`
Trids []string `json:"trids"`
}
func (t *TrailChaincode) Init(stub shim.ChaincodeStubInterface) peer.Response {
//-------------------------------------------------------------
var deletedTrails DeletedTrails
deletedTrailsAsBytes, _ := json.Marshal(deletedTrails)
err := stub.PutState("deletedTrails", deletedTrailsAsBytes)
if err != nil {
shim.Error(err.Error())
}
//-------------------------------------------------------------
return shim.Success(nil)
}
func (t *TrailChaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response {
fn , args := stub.GetFunctionAndParameters()
if fn == "insertTrail" {
return t.insertTrail(stub,args)
} else if fn == "searchAllTrail" {
return t.searchAllTrail(stub,args)
} else if fn == "searchOneTrail" {
return t.searchOneTrail(stub,args)
} else if fn == "deleteTrail" {
return t.deleteTrail(stub,args)
} else if fn == "updateTrail" {
return t.updateTrail(stub,args)
} else if fn == "searchTrailByid" {
return t.searchTrailByid(stub,args)
} else if fn == "getHistoryForTrail" {
return t.getHistoryForTrail(stub,args)
} else if fn == "getDeletedTrails" {
return t.getDeletedTrails(stub,args)
}
return shim.Error("Invoke 调用方法有误！")
}
func (t *TrailChaincode) insertTrail(stub shim.ChaincodeStubInterface , args []string) peer.Response{
//序列化
// trail := Trail{}
// jsonStr := args[0]
// err := json.Unmarshal([]byte(jsonStr), &trail)
// if err != nil {
// return shim.Error(err.Error())
// }
// accBytes, err := json.Marshal(trail)
// if err != nil {
// return shim.Error(err.Error())
// }
//保存数据
// err = stub.PutState(trail.trid, accBytes)
Trid := args[0]
jsonStr := args[1]
err := stub.PutState(Trid, []byte(jsonStr))
if err != nil {
shim.Error(err.Error())
}
return shim.Success([]byte("insert 写入账本成功！"))
}
func (t *TrailChaincode) updateTrail(stub shim.ChaincodeStubInterface , args []string) peer.Response{
Trid := args[0]
jsonStr := args[1]
err := stub.PutState(Trid, []byte(jsonStr))
if err != nil {
shim.Error(err.Error())
}
return shim.Success([]byte("insert 更新账本成功！"))
}
//查询所有的轨迹
func (t *TrailChaincode) deleteTrail(stub shim.ChaincodeStubInterface , args []string) peer.Response{
Trid := args[0]
err := stub.DelState(Trid)
if err != nil {
shim.Error(err.Error())
}
//-----------------------------------------------------------------
//记录删除的轨迹编号
result, err2 := stub.GetState("deletedTrails")
if err2 != nil {
return shim.Error("查询轨迹失败！")
}
//查询已删除的轨迹编号类
var deletedTrails DeletedTrails
err3 := json.Unmarshal([]byte(result),&deletedTrails)
if err3 != nil {
return shim.Error(err3.Error())
}
deletedTrails.Num += 1;
deletedTrails.Trids = append(deletedTrails.Trids, Trid)
//删除数+1，append删除的轨迹编号
deletedTrailsAsBytes, _ := json.Marshal(deletedTrails)
err4 := stub.PutState("deletedTrails", deletedTrailsAsBytes)
if err4 != nil {
shim.Error(err4.Error())
}
//重新转bytes放入
//-----------------------------------------------------------------
return shim.Success([]byte("delete 删除账本成功！"))
}
//删除指定轨迹
func (t *TrailChaincode) searchAllTrail(stub shim.ChaincodeStubInterface, args []string) peer.Response{
fmt.Println("start searchAllTrail")
// 获取所有用户的票数
resultIterator, err := stub.GetStateByRange("","")
if err != nil {
return shim.Error("查询所有的轨迹失败！")
}
defer resultIterator.Close()
var buffer bytes.Buffer
buffer.WriteString("[")
isWritten := false
for resultIterator.HasNext() {
queryResult , err := resultIterator.Next()
if err != nil {
return shim.Error(err.Error())
}
if isWritten == true {
buffer.WriteString(",")
}
buffer.WriteString(string(queryResult.Value))
isWritten = true
}
buffer.WriteString("]")
fmt.Printf("查询结果：\n%s\n",buffer.String())
fmt.Println("end searchAllTrail")
return shim.Success(buffer.Bytes())
}
//查询所有的轨迹
func (t *TrailChaincode) searchOneTrail(stub shim.ChaincodeStubInterface, args []string) peer.Response{
fmt.Println("start searchOneTrail")
trid := args[0]
result, err := stub.GetState(trid)
if err != nil {
return shim.Error("查询所有的轨迹失败！")
}
return shim.Success(result)
}
func SliceRemove(s []Trail, index int) []Trail {
return append(s[:index], s[index+1:]...)
}
//通过电话号查所有轨迹
func (t *TrailChaincode) searchTrailByid(stub shim.ChaincodeStubInterface, args []string) peer.Response{
idpar := args[0]
var revMsg Trail
fmt.Println("start searchTrailByid")
var trails []Trail;
// 获取所有用户的票数
resultIterator, err := stub.GetStateByRange("","")
if err != nil {
return shim.Error("查询所有的轨迹失败！")
}
defer resultIterator.Close()
// var buffer bytes.Buffer
// buffer.WriteString("[")
// isWritten := false
for resultIterator.HasNext() {
queryResult , err := resultIterator.Next()
if err != nil {
return shim.Error(err.Error())
}
// if isWritten == true {
// buffer.WriteString(",")
// }
err1 := json.Unmarshal([]byte(queryResult.Value),&revMsg)
// shim.Error(revMsg)
if err1 != nil {
return shim.Error(err.Error())
}
if revMsg.Userid == idpar {
// str, err2 := json.Marshal(revMsg)
// if err2 != nil {
// return shim.Error(err.Error())
// }
// buffer.WriteString(string(str))
trails = append(trails, revMsg)
// isWritten = true
}
// else { isWritten = false }
}
// buffer.WriteString("]")
if len(trails) != 0 {
trails = SliceRemove(trails,len(trails)-1)
}
fmt.Printf("- searchTrailByid returning:\n%s", trails)
//change to array of bytes
trailsAsBytes, _ := json.Marshal(trails) //convert to array of bytes
return shim.Success(trailsAsBytes)
}
func (t *TrailChaincode) getHistoryForTrail(stub shim.ChaincodeStubInterface, args []string) peer.Response{
type AuditHistory struct {
TxId string `json:"txId"`
Value Trail `json:"value"`
}
var history []AuditHistory
var trail Trail
if len(args) != 1 {
return shim.Error("参数个数错误，应为1!")
}
trid := args[0]
fmt.Printf("- 开始历史回溯: %s\n", trid)
// Get History
resultsIterator, err := stub.GetHistoryForKey(trid)
if err != nil {
return shim.Error(err.Error())
}
defer resultsIterator.Close()
for resultsIterator.HasNext() {
historyData, err := resultsIterator.Next()
if err != nil {
return shim.Error(err.Error())
}
var tx AuditHistory
tx.TxId = historyData.TxId //copy transaction id over
json.Unmarshal(historyData.Value, &trail) //un stringify it aka JSON.parse()
if historyData.Value == nil { //trail has been deleted
var emptyTrail Trail
tx.Value = emptyTrail //copy nil trail
} else {
json.Unmarshal(historyData.Value, &trail) //un stringify it aka JSON.parse()
tx.Value = trail //copy trail over
}
history = append(history, tx) //add this tx to the list
}
fmt.Printf("- getHistoryForTrail returning:\n%s", history)
//change to array of bytes
historyAsBytes, _ := json.Marshal(history) //convert to array of bytes
return shim.Success(historyAsBytes)
}
// 查询删除过的轨迹信息
func (t *TrailChaincode) getDeletedTrails(stub shim.ChaincodeStubInterface, args []string) peer.Response{
type AuditHistory struct {
TxId string `json:"txId"`
Value Trail `json:"value"`
}
var finalhistory []AuditHistory
var history []AuditHistory
var trail Trail
// Get History
result, _ := stub.GetState("deletedTrails")
//查询已删除的轨迹编号类
var deletedTrails DeletedTrails
json.Unmarshal([]byte(result),&deletedTrails)
//[]byte转结构体
for _, trid := range deletedTrails.Trids {
resultsIterator, err := stub.GetHistoryForKey(trid)
if err != nil {
return shim.Error(err.Error())
}
defer resultsIterator.Close()
for resultsIterator.HasNext() {
historyData, err := resultsIterator.Next()
if err != nil {
return shim.Error(err.Error())
}
var tx AuditHistory
tx.TxId = historyData.TxId //copy transaction id over
json.Unmarshal(historyData.Value, &trail) //un stringify it aka JSON.parse()
if historyData.Value == nil { //trail has been deleted
var emptyTrail Trail
tx.Value = emptyTrail //copy nil trail
} else {
json.Unmarshal(historyData.Value, &trail) //un stringify it aka JSON.parse()
tx.Value = trail //copy trail over
}
history = append(history, tx) //add this tx to the list
}
if history[len(history)-1].Value.Userid == "" {
finalhistory = append(finalhistory, history[len(history)-2])
}
history = []AuditHistory{}
}
fmt.Printf("- getfinalhistory returning:\n%s", finalhistory)
//change to array of bytes
finalhistoryAsBytes, _ := json.Marshal(finalhistory) //convert to array of bytes
return shim.Success(finalhistoryAsBytes)
}
func main(){
err := shim.Start(new(TrailChaincode))
if err != nil {
fmt.Println("Trail chaincode start err")
}
}