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）
}