Hyperledger Fabric v1.4的私人和公共数据-Coinmonks
//链码
包主
导入(
“字节”
“编码/ json”
“ fmt”
“ strconv”
“时间”
“ github.com/hyperledger/fabric/core/chaincode/shim”
pb“ github.com/hyperledger/fabric/protos/peer”
)
输入SimpleChaincode struct {
}
输入命令struct {
ObjectType字符串`json:“ docType”`
Order_raw_material_id字符串`json:“ order_raw_material_id”`
Manufacturer_id字符串`json:“ manufacturer_id”`
Provider_id字符串`json:“ provider_id”`
Material_name字符串`json:“ material_name”`
Order_medicine_id字符串`json:“ order_medicine_id”`
数量字符串`json:“ quantity”`
状态字符串`json:“ status”`
}
键入orderPrivateDetails struct {
价格字符串`json:“ price”`
}
func main(){
错误:= shim.Start(new(SimpleChaincode))
如果err= nil {
fmt.Printf(“启动简单链码时出错:%s”,错误)
}
}
func(t * SimpleChaincode)Init(stub shim.ChaincodeStubInterface)pb.Response {
返回shim.Success(nil)
}
func(t * SimpleChaincode)调用(存根shim.ChaincodeStubInterface)pb.Response {
函数,args:= stub.GetFunctionAndParameters()
fmt.Println(“调用正在运行” +函数)
如果函数==“ initOrder” {
返回t.initOrder(stub,args)
} else if function ==“ changeStatus” {
返回t.changeStatus(stub,args)
} else if function ==“ changeProvider_id” {
返回t.changeProvider_id(stub,args)
} else if function ==“ changeQuantity” {
返回t.changeQuantity(stub,args)
} else if function ==“ readOrder” {
返回t.readOrder(stub,args)
} else if function ==“ getHistoryForOrder” {
返回t.getHistoryForOrder(stub,args)
} else if function ==“ getOrdersByRange” {
返回t.getOrdersByRange(stub,args)
} else if function ==“ queryOrderByOrder_medicine_id” {
返回t.queryOrderByOrder_medicine_id(stub,args)
} else if function ==“ readOrderPrivateDetails” {
返回t.readOrderPrivateDetails(stub,args)
} else if function ==“ changeOrderPrivateDetails” {
返回t.changeOrderPrivateDetails(stub,args)
}
fmt.Println(“调用未找到函数:” +函数)
返回shim.Error(“接收到的未知函数调用”)
}
func(t * SimpleChaincode)initOrder(stub shim.ChaincodeStubInterface,args()string)pb.Response {
var err错误
如果len(args)= 7 {
return shim.Error(“参数数量不正确。应为7”)
}
fmt.Println(“-开始初始化顺序”)
如果len(args(0))<= 0 {
return shim.Error(“第一个参数必须为非空字符串”)
}
如果len(args(1))<= 0 {
return shim.Error(“第二个参数必须是非空字符串”)
}
如果len(args(2))<= 0 {
return shim.Error(“第三个参数必须是非空字符串”)
}
如果len(args(3))<= 0 {
return shim.Error(“第四个参数必须为非空字符串”)
}
如果len(args(4))<= 0 {
return shim.Error(“第5个参数必须为非空字符串”)
}
如果len(args(5))<= 0 {
return shim.Error(“第六个参数必须是一个非空字符串”)
}
如果len(args(6))<= 0 {
return shim.Error(“第7个参数必须为非空字符串”)
}
orderName:= args(0)
Manufacturer_id:= args(1)
provider_id:= args(2)
material_name:=参数(3)
order_medicine_id:=参数(4)
数量:= args(5)
状态:= args(6)
orderAsBytes,err:= stub.GetState(orderName)
如果err= nil {
返回shim.Error(“无法获得订单:” + err.Error())
} if orderAsBytes= nil {
fmt.Println(“此orderName已经存在:” + orderName)
return shim.Error(“此orderName已经存在:” + orderName)
}
objectType:=“订单”
订单:=&order {对象类型,订单名称,制造商ID,提供商ID,物料名称,订单医学ID,数量,状态}
orderJSONasBytes,err:= json.Marshal(顺序)
如果err= nil {
返回shim.Error(err.Error())
}
err = stub.PutState(orderName,orderJSONasBytes)
如果err= nil {
返回shim.Error(err.Error())
}
// ====创建带有价格的订单私人详细信息对象,将其编组为JSON,然后保存为状态====
transMap,错误:= stub.GetTransient()
如果err= nil {
返回shim.Error(“出现瞬态错误:” + err.Error())
}
如果_,确定:= transMap(“ order”); 好 {
return shim.Error(“订单必须是瞬态映射中的键”)
}
如果len(transMap(“ order”))== 0 {
return shim.Error(“瞬态映射中的顺序值必须是非空的JSON字符串”)
}
键入orderTransientInput struct {
价格字符串`json:“ price”`
}
var orderInput orderTransientInput
err = json.Unmarshal(transMap(“ order”),&orderInput)
如果err= nil {
返回shim.Error(“无法解码JSON的” +字符串(transMap(“ order”)))
}
orderPrivateDetails:=&orderPrivateDetails {
价格:orderInput.Price,
}
orderPrivateDetailsBytes,err:= json.Marshal(orderPrivateDetails)
如果err= nil {
返回shim.Error(err.Error())
}
err = stub.PutPrivateData(“ collectionMaterialOrderPrivateDetails”,orderName,orderPrivateDetailsBytes)
如果err= nil {
返回shim.Error(err.Error())
}
indexName:=“ order_medicine_id”
order_medicine_idIndexKey,err:= stub.CreateCompositeKey(indexName,()string {order.Order_medicine_id,order.Order_raw_material_id})
如果err= nil {
返回shim.Error(err.Error())
}
值:=()byte {0x00}
stub.PutState(order_medicine_idIndexKey,值)
fmt.Println(“-结束初始化顺序”)
返回shim.Success(nil)
}
func(t * SimpleChaincode)readOrder(stub shim.ChaincodeStubInterface,args()string)pb.Response {
var名称,jsonResp字符串
var err错误
如果len(args)= 1 {
return shim.Error(“参数数量错误。期望查询的订单名称”)
}
名称= args(0)
valAsbytes,err:= stub.GetState(name)
如果err= nil {
jsonResp =“ {”错误“:”无法获取“ +名称+” “}”的状态
返回shim.Error(jsonResp)
}否则,如果valAsbytes == nil {
jsonResp =“ {”错误“:”订单不存在:“ +名称+” “}”
返回shim.Error(jsonResp)
}
返回shim.Success(valAsbytes)
}
func(t * SimpleChaincode)changeStatus(stub shim.ChaincodeStubInterface,args()string)pb.Response {
如果len(args)<2 {
return shim.Error(“参数数量不正确。应为2”)
}
orderName:= args(0)
newStatus:= args(1)
fmt.Println(“-start changeStatus”,orderName,newStatus)
orderAsBytes,err:= stub.GetState(orderName)
如果err= nil {
返回shim.Error(“无法获得订单:” + err.Error())
}否则,如果orderAsBytes == nil {
返回shim.Error(“订单不存在”)
}
statusToChange:=订单{}
err = json.Unmarshal(orderAsBytes,&statusToChange)
如果err= nil {
返回shim.Error(err.Error())
}
statusToChange.Status = newStatus
orderJSONasBytes,_:= json.Marshal(statusToChange)
err = stub.PutState(orderName,orderJSONasBytes)
如果err= nil {
返回shim.Error(err.Error())
}
fmt.Println(“-end changeStatus(success)”)
返回shim.Success(nil)
}
func(t * SimpleChaincode)changeProvider_id(stub shim.ChaincodeStubInterface,args()string)pb.Response {
如果len(args)<2 {
return shim.Error(“参数数量不正确。应为2”)
}
orderName:= args(0)
newProvider_id:= args(1)
fmt.Println(“-start changeStatus”,orderName,newProvider_id)
orderAsBytes,err:= stub.GetState(orderName)
如果err= nil {
返回shim.Error(“无法获得订单:” + err.Error())
}否则,如果orderAsBytes == nil {
返回shim.Error(“订单不存在”)
}
provider_idToChange:=订单{}
err = json.Unmarshal(orderAsBytes,&provider_idToChange)
如果err= nil {
返回shim.Error(err.Error())
}
orderJSONasBytes,_:= json.Marshal(provider_idToChange)
err = stub.PutState(orderName,orderJSONasBytes)
如果err= nil {
返回shim.Error(err.Error())
}
fmt.Println(“-end changeStatus(success)”)
返回shim.Success(nil)
}
func(t * SimpleChaincode)changeQuantity(stub shim.ChaincodeStubInterface,args()string)pb.Response {
如果len(args)<2 {
return shim.Error(“参数数量不正确。应为2”)
}
orderName:= args(0)
newQuantity:= args(1)
fmt.Println(“-start changeStatus”,orderName,newQuantity)
orderAsBytes,err:= stub.GetState(orderName)
如果err= nil {
返回shim.Error(“无法获得订单:” + err.Error())
}否则,如果orderAsBytes == nil {
返回shim.Error(“订单不存在”)
}
QuantityToChange:=订单{}
err = json.Unmarshal(orderAsBytes,&quantityToChange)
如果err= nil {
返回shim.Error(err.Error())
}
QuantityToChange.Quantity = newQuantity
orderJSONasBytes,_:= json.Marshal(quantityToChange)
err = stub.PutState(orderName,orderJSONasBytes)
如果err= nil {
返回shim.Error(err.Error())
}
fmt.Println(“-end changeStatus(success)”)
返回shim.Success(nil)
}
func(t * SimpleChaincode)queryOrderByOrder_medicine_id(stub shim.ChaincodeStubInterface,args()string)pb.Response {
如果len(args)<1 {
return shim.Error(“参数数量不正确。应为1”)
}
order_medicine_id:=参数(0)
queryString:= fmt.Sprintf(“ {” selector “:{” docType “:” order “,” order_medicine_id “:”%s “}}”,order_medicine_id)
queryResults,err:= getQueryResultForQueryString(stub,queryString)
如果err= nil {
返回shim.Error(err.Error())
}
返回shim.Success(queryResults)
}
func getQueryResultForQueryString(stub shim.ChaincodeStubInterface,queryString string)(()byte,error){
fmt.Printf(“-getQueryResultForQueryString queryString: n%s n”,queryString)
resultsIterator,err:= stub.GetQueryResult(queryString)
如果err= nil {
返回nil,err
}
延迟resultsIterator.Close()
缓冲区,错误:= ConstructQueryResponseFromIterator(resultsIterator)
如果err= nil {
返回nil,err
}
fmt.Printf(“-getQueryResultForQueryString queryResult: n%s n”,buffer.String())
返回buffer.Bytes(),无
}
func ConstructQueryResponseFromIterator(resultsIterator shim.StateQueryIteratorInterface)(* bytes.Buffer,错误){
var buffer bytes.Buffer
buffer.WriteString(“(”)
bArrayMemberAlreadyWritten:=否
对于resultsIterator.HasNext(){
queryResponse,err:= resultsIterator.Next()
如果err= nil {
返回nil,err
}
如果bArrayMemberAlreadyWritten == true {
buffer.WriteString(“,”)
}
buffer.WriteString(“ {” Key “:”)
buffer.WriteString(“ ”“)
buffer.WriteString(queryResponse.Key)
buffer.WriteString(“ ”“)
buffer.WriteString(“,”记录“:”)
buffer.WriteString(string(queryResponse.Value))
buffer.WriteString(“}”)
bArrayMemberAlreadyWritten = true
}
buffer.WriteString(“)”)
return&buffer,无
}
func(t * SimpleChaincode)getHistoryForOrder(stub shim.ChaincodeStubInterface,args()string)pb.Response {
如果len(args)<1 {
return shim.Error(“参数数量不正确。应为1”)
}
orderName:= args(0)
fmt.Printf(“-start getHistoryForOrder:%s n”,orderName)
resultsIterator,err:= stub.GetHistoryForKey(orderName)
如果err= nil {
返回shim.Error(err.Error())
}
延迟resultsIterator.Close()
var buffer bytes.Buffer
buffer.WriteString(“(”)
bArrayMemberAlreadyWritten:=否
对于resultsIterator.HasNext(){
响应,错误:= resultsIterator.Next()
如果err= nil {
返回shim.Error(err.Error())
}
如果bArrayMemberAlreadyWritten == true {
buffer.WriteString(“,”)
}
buffer.WriteString(“ {” TxId “:”)
buffer.WriteString(“ ”“)
buffer.WriteString(response.TxId)
buffer.WriteString(“ ”“)
buffer.WriteString(“,” Value “:”)
如果response.IsDelete {
buffer.WriteString(“ null”)
}其他{
buffer.WriteString(string(response.Value))
}
buffer.WriteString(“,” Timestamp “:”)
buffer.WriteString(“ ”“)
buffer.WriteString(time.Unix(response.Timestamp.Seconds,int64(response.Timestamp.Nanos))。String())
buffer.WriteString(“ ”“)
buffer.WriteString(“,” IsDelete “:”)
buffer.WriteString(“ ”“)
buffer.WriteString(strconv.FormatBool(response.IsDelete))
buffer.WriteString(“ ”“)
buffer.WriteString(“}”)
bArrayMemberAlreadyWritten = true
}
buffer.WriteString(“)”)
fmt.Printf(“-getHistoryForOrder返回: n%s n”,buffer.String())
返回shim.Success(buffer.Bytes())
}
func(t * SimpleChaincode)getOrdersByRange(stub shim.ChaincodeStubInterface,args()string)pb.Response {
如果len(args)<2 {
return shim.Error(“参数数量不正确。应为2”)
}
startKey:=参数(0)
endKey:=参数(1)
resultsIterator,err:= stub.GetStateByRange(startKey,endKey)
如果err= nil {
返回shim.Error(err.Error())
}
延迟resultsIterator.Close()
缓冲区,错误:= ConstructQueryResponseFromIterator(resultsIterator)
如果err= nil {
返回shim.Error(err.Error())
}
fmt.Printf(“-getOrdersByRange queryResult: n%s n”,buffer.String())
返回shim.Success(buffer.Bytes())
}
func(t * SimpleChaincode)readOrderPrivateDetails(stub shim.ChaincodeStubInterface,args()string)pb.Response {
var名称,jsonResp字符串
var err错误
如果len(args)= 1 {
return shim.Error(“参数数量错误。期望查询的订单名称”)
}
名称= args(0)
valAsbytes,err:= stub.GetPrivateData(“ collectionMaterialOrderPrivateDetails”,name)//从链码状态获取订单私有详细信息
如果err= nil {
jsonResp =“ {” Error “:”无法获取“ +名称+”的私人详细信息:“ + err.Error()+” “}”
返回shim.Error(jsonResp)
}否则,如果valAsbytes == nil {
jsonResp =“ {”错误“:”订单私人详细信息不存在:“ +名称+” “}”
返回shim.Error(jsonResp)
}
返回shim.Success(valAsbytes)
}
func(t * SimpleChaincode)changeOrderPrivateDetails(stub shim.ChaincodeStubInterface,args()string)pb.Response {
如果len(args)<2 {
return shim.Error(“参数数量不正确。应为2”)
}
orderName:= args(0)
newPrice:= args(1)
fmt.Println(“-start changeStatus”,orderName,newPrice)
orderAsBytes,错误:= stub.GetPrivateData(“ collectionMaterialOrderPrivateDetails”,orderName)
如果err= nil {
返回shim.Error(“无法获得订单:” + err.Error())
}否则,如果orderAsBytes == nil {
返回shim.Error(“订单不存在”)
}
priceToChange:= orderPrivateDetails {}
err = json.Unmarshal(orderAsBytes,&priceToChange)
如果err= nil {
返回shim.Error(err.Error())
}
priceToChange.Price = newPrice
orderJSONasBytes,_:= json.Marshal(priceToChange)
err = stub.PutPrivateData(“ collectionMaterialOrderPrivateDetails”,orderName,orderJSONasBytes)
如果err= nil {
返回shim.Error(err.Error())
}
fmt.Println(“-end changeStatus(success)”)
返回shim.Success(nil)
}