Fabric实践（二）：用户收入支出记录Chaincode
摘要
在上一篇文章中实现了一个简单的用户登陆验证的Chaincode，接下实现用于记录用户收支情况的Chaincode
Chaincode
/**
* file:journal_chaincode.go
**/
package main
import (
"bytes"
"encoding/json"
"fmt"
"strconv"
"github.com/hyperledger/fabric/core/chaincode/shim"
pb "github.com/hyperledger/fabric/protos/peer"
)
type JournalChaincode struct{}
type Journal struct {
Id string `json:"id"`
Date int `json:"date"`
Cost int `json:"cost"`
Label string `json:"label"`
Description string `json:"description"`
UserName string `json:"username"`
Type string `json:"type"` // expenditure/earning
}
type ResInfo struct {
Status bool `json:"status"`
Msg string `json:"msg"`
}
func (t *ResInfo) error(msg string) {
t.Status = false
t.Msg = msg
}
func (t *ResInfo) ok(msg string) {
t.Status = true
t.Msg = msg
}
func (t *ResInfo) response() pb.Response {
resJson, err := json.Marshal(t)
if err != nil {
return shim.Error("Failed to generate json result " + err.Error())
}
return shim.Success(resJson)
}
func main() {
err := shim.Start(new(JournalChaincode))
if err != nil {
fmt.Printf("Error starting Simple chaincode: %s", err)
}
}
type process func(shim.ChaincodeStubInterface, []string) *ResInfo
// Init initializes chaincode
// ===========================
func (t *JournalChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
return shim.Success(nil)
}
func (t *JournalChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
function, args := stub.GetFunctionAndParameters()
fmt.Println("invoke is running " + function)
// Handle different functions
if function == "newJournal" { //create a new marble
return t.newJournal(stub, args)
} else if function == "delJournal" {
return t.delJournal(stub, args)
} else if function == "updateJournal" {
return t.updateJournal(stub, args)
} else if function == "queryJournal" {
return t.queryJournal(stub, args)
}
fmt.Println("invoke did not find func: " + function) //error
return shim.Error("Received unknown function invocation")
}
func (t *JournalChaincode) newJournal(stub shim.ChaincodeStubInterface, args []string) pb.Response {
return t.handleProcess(stub, args, 7, func(shim.ChaincodeStubInterface, []string) *ResInfo {
ri := &ResInfo{true, ""}
_id := args[0]
_date, _ := strconv.Atoi(args[1])
_cost, _ := strconv.Atoi(args[2])
_label := args[3]
_description := args[4]
_username := args[5]
_type := args[6]
_journal := &Journal{_id, _date, _cost, _label, _description, _username, _type}
_ejson, err := json.Marshal(_journal)
if err != nil {
ri.error(err.Error())
} else {
_old, err := stub.GetState(_id)
if err != nil {
ri.error(err.Error())
} else if _old != nil {
ri.error("the journal has exists")
} else {
err := stub.PutState(_id, _ejson)
if err != nil {
ri.error(err.Error())
} else {
ri.ok("")
}
}
}
return ri
})
}
func (t *JournalChaincode) delJournal(stub shim.ChaincodeStubInterface, args []string) pb.Response {
return t.handleProcess(stub, args, 1, func(shim.ChaincodeStubInterface, []string) *ResInfo {
ri := &ResInfo{true, ""}
_id := args[0]
_journal, err := stub.GetState(_id)
if err != nil {
ri.error(err.Error())
} else {
if _journal == nil {
ri.ok("Warnning journal does not exists")
} else {
err := stub.DelState(_id)
if err != nil {
ri.error(err.Error())
} else {
ri.ok("")
}
}
}
return ri
})
}
func (t *JournalChaincode) updateJournal(stub shim.ChaincodeStubInterface, args []string) pb.Response {
return t.handleProcess(stub, args, 7, func(shim.ChaincodeStubInterface, []string) *ResInfo {
ri := &ResInfo{true, ""}
_id := args[0]
_date, _ := strconv.Atoi(args[1])
_cost, _ := strconv.Atoi(args[2])
_label := args[3]
_description := args[4]
_username := args[5]
_type := args[6]
newJournal := &Journal{_id, _date, _cost, _label, _description, _username, _type}
_journal, err := stub.GetState(_id)
if err != nil {
ri.error(err.Error())
} else {
if _journal == nil {
ri.error("Error the journal does not exists")
} else {
_ejson, err := json.Marshal(newJournal)
if err != nil {
ri.error(err.Error())
} else {
err := stub.PutState(_id, _ejson)
if err != nil {
ri.error(err.Error())
} else {
ri.ok("")
}
}
}
}
return ri
})
}
func (t *JournalChaincode) queryJournal(stub shim.ChaincodeStubInterface, args []string) pb.Response {
return t.handleProcess(stub, args, 1, func(shim.ChaincodeStubInterface, []string) *ResInfo {
ri := &ResInfo{true, ""}
queryString := args[0]
queryResults, err := getQueryResultForQueryString(stub, queryString)
if err != nil {
ri.error(err.Error())
} else {
ri.ok(string(queryResults))
}
return ri
})
}
func getQueryResultForQueryString(stub shim.ChaincodeStubInterface, queryString string) ([]byte, error) {
fmt.Printf("- getQueryResultForQueryString queryString:\n%s\n", queryString)
resultsIterator, err := stub.GetQueryResult(queryString)
if err != nil {
return nil, err
}
defer resultsIterator.Close()
// buffer is a JSON array containing QueryRecords
var buffer bytes.Buffer
buffer.WriteString("[")
bArrayMemberAlreadyWritten := false
for resultsIterator.HasNext() {
queryResponse, err := resultsIterator.Next()
if err != nil {
return nil, err
}
// Add a comma before array members, suppress it for the first array member
if bArrayMemberAlreadyWritten == true {
buffer.WriteString(",")
}
buffer.WriteString("{\"Key\":")
buffer.WriteString("\"")
buffer.WriteString(queryResponse.Key)
buffer.WriteString("\"")
buffer.WriteString(", \"Record\":")
// Record is a JSON object, so we write as-is
buffer.WriteString(string(queryResponse.Value))
buffer.WriteString("}")
bArrayMemberAlreadyWritten = true
}
buffer.WriteString("]")
fmt.Printf("- getQueryResultForQueryString queryResult:\n%s\n", buffer.String())
return buffer.Bytes(), nil
}
func (t *JournalChaincode) handleProcess(stub shim.ChaincodeStubInterface, args []string, expectNum int, f process) pb.Response {
res := &ResInfo{false, ""}
err := t.checkArgs(args, expectNum)
if err != nil {
res.error(err.Error())
} else {
res = f(stub, args)
}
return res.response()
}
func (t *JournalChaincode) checkArgs(args []string, expectNum int) error {
if len(args) != expectNum {
return fmt.Errorf("Incorrect number of arguments. Expecting " + strconv.Itoa(expectNum))
}
for p := 0; p < len(args); p++ {
if len(args[p]) <= 0 {
return fmt.Errorf(strconv.Itoa(p+1) + "nd argument must be a non-empty string")
}
}
return nil
}
本文中的Chaincode与上一篇文章中最大的区别是新增了如下类型和方法
type process func(shim.ChaincodeStubInterface, []string) *ResInfo
func (t *JournalChaincode) handleProcess(stub shim.ChaincodeStubInterface, args []string, expectNum int, f process) pb.Response 上一篇文章中的Chaincode有很多重复代码，尤其是在参数检查部分，所以在本文中我们利用go语言可以将方法作为函数参数传递的特性，使用上述方法以减少重复代码。
type Journal struct {
Id string `json:"id"`
Date int `json:"date"`
Cost int `json:"cost"`
Label string `json:"label"`
Description string `json:"description"`
UserName string `json:"username"`
Type string `json:"type"` // expenditure/earning
}这个结构体就是用于保存用户收入/支出记录的结构体。
Id 应该为每一条记录都不相同的，
Date 为记录日期，可以是时间戳或者保存日期如 20180101
Cost 为金额，注意这里用的是int 之所以不用float或者double 是因为计算机不能精确地对浮点型进行计算，所以这里用int ,如花费人民币的话，那么cost的单位就应该是是分
Label 为该记录的标签，如“餐饮”，“购物”
Description 为该记录的描述信息
Type 为类型 expenditure 表示 支出 earning 表示收入Chaincode中提供了对记录的 “新增”、“更新”、“删除”、”查询”功能。
部署测试
类似于上一篇文章，我们需要将该Chaincode目录映射的cli中。
- ~/Workspace/fabric-study/journal:/opt/gopath/src/github.com/chaincode/journal使用以下命令进行测试
export CHANNEL_NAME=mychannel
peer chaincode install -n journal -v 1.0 -p github.com/chaincode/journal
peer chaincode instantiate -o orderer.example.com:7050 --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n journal -v 1.0 -c '{"Args":["init"]}' -P "OR ('Org0MSP.peer','Org1MSP.peer')"
peer chaincode invoke -o orderer.example.com:7050 --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n journal -c '{"Args":["newJournal","123456","20180102","1000","canyin","wufan","alphags","expenditure"]}'
peer chaincode invoke -o orderer.example.com:7050 --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n journal -c '{"Args":["newJournal","235142","20180102","1000","canyin","wufan","alphags","earning"]}'
peer chaincode invoke -o orderer.example.com:7050 --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n journal -c '{"Args":["updateJournal","235142","20180103","2000","canyin","wufan","alphags","earning"]}'
peer chaincode invoke -o orderer.example.com:7050 --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n journal -c '{"Args":["queryJournal","{\"selector\": {\"username\":\"alphags\",\"date\":{\"$gt\":20180102}}}"]}'
peer chaincode invoke -o orderer.example.com:7050 --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C $CHANNEL_NAME -n journal -c '{"Args":["delJournal","235142"]}'
这里需要注意，我们通过Fauxton查看couchdb中的数据时可以看到，我们的记录是明文存储的，为了保证匿名性，其实我们是需要对用户名进行加密后再存储的。
最后
至此我们准备好了两个Chaincode 一个用于用户验证，一个用于记录收支信息。接下来我们要使用nodejs 搭建一个简单的web服务器，该web服务操作通过上述两个Chaincode操作数据，并为用户提供服务。