fabric 智能合约开发

1.智能合约状态图

2.实现功能,通过背书,签收机制实现任务在各部门流转

3.相关sdk

1. Chaincode接口 {Init,Invoke}方法
2. ChaincodeStubInterface接口

　　　　1.GetTxTimestamp

　　　　2.CreateCompositeKey

　　       3.GetQueryResult

              4.GetHistoryForKey

              5.SetEvent　　

              6.GetStateByPartialCompositeKey

              7.GetFunctionAndParameters

              8.PutState

              9.DelState

              10.GetStateByRange

4.代码架构图

5.开发环境(centos7.4,goland)

6.global.go代码

package global

import "github.com/hyperledger/fabric/common/flogging"

const (
    PrescriptionBlockchain_State_NewPublish     ="NewPublish"
    PrescriptionBlockchain_State_EndrWaitSign   ="EndrWaitSign"
    PrescriptionBlockchain_state_EndrSigned     ="EndrSigned"
    HospitalNO_DayTime_PrescriptionID_IndexName ="hospitalno~daytime-prescriptionid"
    PatientID_PrescriptionID_IndexName          ="patientid~prescriptionid"
    State_PrescriptionID_IndexName              ="state~prescriptionid"
    PendingReceivePrescriptionDeptID_PrescriptionID_IndexName="pendingreceiveprescriptiondeptid~prescriptionid"
    ReceivingPrescriptionDeptID_PrescriptionID_IndexName="receivingprescriptiondeptid~prescriptionid"
    OpenPrescriptionDeptID_PrescriptionID_IndexName="openprescriptiondeptid~prescriptionid"
)
var(
    Logger =flogging.MustGetLogger("PrescriptionChaincode")
)

7.prescriptionentity.go代码

package model

type PrescriptionBlockchain struct {
    PrescriptionID string `json:"PrescriptionID"`
    HospitalNO string `json:"HospitalNO"`
    PatientID string `json:"PatientID"`
    GenerationTime string `json:"GenerationTime"`
    PrescriptionSummary string `json:"PrescriptionSummary"`
    OpenPrescriptionDeptID string `json:"OpenPrescriptionDeptID"`
    OpenPrescriptionDoctorID string `json:"OpenPrescriptionDoctorID"`
    PendingReceivePrescriptionDeptID string `json:"PendingReceivePrescriptionDeptID"`
    PendingReceivePrescriptionWorkID string `json:"PendingReceivePrescriptionWorkID"`
    ReceivingPrescriptionDeptID string `json:"ReceivingPrescriptionDeptID"`
    ReceivingPrescriptionWorkID string `json:"ReceivingPrescriptionWorkID"`
    State string `json:"State"`
    History []HistoryItem `json:"History"`
}
type HistoryItem struct {
    TxId string `json:"TxId"`
    PrescriptionBlockchain PrescriptionBlockchain `json:"PrescriptionBlockchain"`
}
type ChaincodeRet struct {
    Code int // 0 success otherwise 1
    Des  string //description
}

8.prescriptioninvoke.go代码

package operation

import (
    "github.com/hyperledger/fabric/core/chaincode/shim"
    "github.com/hyperledger/fabric/protos/peer"
    "fmt"
    "github.com/prescriptionserver/chaincode/go/prescription/model"
    "encoding/json"
    "github.com/prescriptionserver/chaincode/go/prescription/global"
    "time"
)

type PrescriptionInvoke struct {
    Stub shim.ChaincodeStubInterface
    Args []string
}
func (p *PrescriptionInvoke) Publish() peer.Response {

    if len(p.Args) != 1{
        return shim.Error("Incorrect number of arguments. Expecting 1")
    }
    fmt.Println("- start publish prescription")
    var pbcn model.PrescriptionBlockchain
    err := json.Unmarshal([]byte(p.Args[0]), &pbcn)
    if err != nil{
        return shim.Error("PrescriptionChaincode Invoke publish unmarshal failed")
    }
    pq := PrescriptionQuery{
        Stub:p.Stub,
    }
    _, exists := pq.GetPbcnByPid(pbcn.PrescriptionID)
    if exists{
        res := GetRetString(1,
            "PrescriptionChaincode Invoke publish failed : the PrescriptionID has exist ")
        shim.Error(res)
    }
    timestamp, err := p.Stub.GetTxTimestamp()
    if err != nil{
        res := GetRetString(1,"PrescriptionChaincode Invoke publish failed :get time stamp failed")
        return shim.Error(res)
    }
    global.Logger.Error("%s",timestamp)
    dayTime :=time.Now().Format("2010-11-11")
    pbcn.State=global.PrescriptionBlockchain_State_NewPublish
     if !p.put(pbcn){
         res :=GetRetString(1,"PrescriptionChaincode Invoke publish put prescription failed")
         return shim.Error(res)
     }
    hospitalNODayTimePrescriptionIDIndexKey,err :=p.Stub.CreateCompositeKey(global.HospitalNO_DayTime_PrescriptionID_IndexName,
        []string{pbcn.HospitalNO,dayTime,pbcn.PrescriptionID})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode Invoke publish create"+
            " hospitalno_daytime_prescriptionid composite key failed")
        return shim.Error(res)
    }
    err = p.Stub.PutState(hospitalNODayTimePrescriptionIDIndexKey,
        []byte(time.Now().Format("2017-11-20 12:56:56")))
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode Invoke publish put"+
            " hospitalno_daytime_prescriptionid search table failed")
        return shim.Error(res)
    }
    patientIDPrescriptionIDIndexKey,err:=p.Stub.CreateCompositeKey(global.PatientID_PrescriptionID_IndexName,
        []string{pbcn.PatientID,pbcn.PrescriptionID})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode Invoke publish"+
            " create patientid_prescriptionid composite key failed")
        return shim.Error(res)
    }
    err = p.Stub.PutState(patientIDPrescriptionIDIndexKey,[]byte{0x00})
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode Invoke publish put"+
            " patientid_prescriptionid search table failed")
        return shim.Error(res)
    }
    statePrescriptionIDIndexKey,err := p.Stub.CreateCompositeKey(global.State_PrescriptionID_IndexName,
        []string{pbcn.State,pbcn.PrescriptionID})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode Invoke publish"+
            " create state_prescriptionid composite key failed")
        return shim.Error(res)
    }
    err = p.Stub.PutState(statePrescriptionIDIndexKey,[]byte{0x00})
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode Invoke publish put"+
            " state_prescriptionid search table failed")
        return shim.Error(res)
    }
    openPrescriptionDeptIDPrescriptionIDIndexKey,err :=p.Stub.CreateCompositeKey(global.OpenPrescriptionDeptID_PrescriptionID_IndexName,
        []string{pbcn.OpenPrescriptionDeptID,pbcn.PrescriptionID})
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode Invoke publish"+
            "create openprescriptiondeptid_prescriptionid composite key failed")
        return shim.Error(res)
    }
    err = p.Stub.PutState(openPrescriptionDeptIDPrescriptionIDIndexKey,[]byte{0x00})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode Invoke putlish put"+
            "openprescriptiondeptid_prescriptionid composite key failed")
        return shim.Error(res)
    }
    res :=GetRetByte(0,"invoke publish success")
    return shim.Success(res)
}
func (p *PrescriptionInvoke) put(pbcn model.PrescriptionBlockchain) bool {
    bytes, err := json.Marshal(pbcn)
    if err != nil{
        return false
    }
    err = p.Stub.PutState(pbcn.PrescriptionID,bytes)
    if err != nil{
        return false
    }
    return true
}
func (p *PrescriptionInvoke) Endorse() peer.Response {
    if len(p.Args)<3{
        res:=GetRetString(1,"PrescriptionChaincode Invoke endorse args<3")
        return shim.Error(res)
    }
    pq := PrescriptionQuery{
        Stub:p.Stub,
    }
    pbcn, b := pq.GetPbcnByPid(p.Args[0])
    if !b{
        res:=GetRetString(1,"PrescriptionChaincode Invoke endorse get prescription error")
        return shim.Error(res)
    }
    if pbcn.OpenPrescriptionDoctorID == p.Args[1]{
        res:=GetRetString(1,"PrescriptionChaincode Invoke endorse failed:"+
            "PendingReceivePrescriptionID should not be same with OpenPrescriptionDoctorID")
        return shim.Error(res)
    }
    if pbcn.ReceivingPrescriptionWorkID==p.Args[1]{
        res:=GetRetString(1,"PrescriptionChaincode Invoke endorse failed:"+
            "PendingReceivePrescriptionID should not be same with ReceivingPrescriptionWorkID")
        return shim.Error(res)
    }
    pbcn.PendingReceivePrescriptionDeptID=p.Args[1]
    pbcn.PendingReceivePrescriptionWorkID=p.Args[2]
    pbcn.State=global.PrescriptionBlockchain_State_EndrWaitSign
    pbcn.ReceivingPrescriptionDeptID=""
    pbcn.ReceivingPrescriptionWorkID=""
    b=p.put(pbcn)
    if !b{
        res:=GetRetString(1,"PrescriptionChaincode Invoke endorse put error")
        return shim.Error(res)
    }
    pendingReceivePrescriptionDeptIDPrescriptionIDIndexKey,err:=p.Stub.CreateCompositeKey(global.PendingReceivePrescriptionDeptID_PrescriptionID_IndexName,
        []string{pbcn.PendingReceivePrescriptionDeptID,pbcn.PrescriptionID})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode Invoke endorse"+
            " create pendingreceiveprescriptiondeptid_prescriptionid composite key failed")
        return shim.Error(res)
    }
    err = p.Stub.PutState(pendingReceivePrescriptionDeptIDPrescriptionIDIndexKey,[]byte{0x00})
    if err != nil {
        res :=GetRetString(1,"PrescriptionChaincode Invoke endorse"+
            " put PendingReceivePrescriptionDeptIDPrescriptionIDIndexKey error")
        return shim.Error(res)
    }
    res:=GetRetByte(0,"invoke endorse success")
    return shim.Success(res)
}
func (p *PrescriptionInvoke) Accept() peer.Response {
    if len(p.Args) <3{
        res:=GetRetString(1,"PrescriptionChaincode Invoke accept args<3")
        return shim.Error(res)
    }
    pq:= PrescriptionQuery{
        Stub:p.Stub,
    }
    pbcn,b:=pq.GetPbcnByPid(p.Args[0])
    if !b{
        res:=GetRetString(1,"PrescriptionChaincode Invoke accept get prescription error")
        return shim.Error(res)
    }
    if pbcn.PendingReceivePrescriptionDeptID != p.Args[1]{
        res:=GetRetString(1,"PrescriptionChaincode Invoke accept error:"+
            "PendingReceivePrescriptionDeptID is not consistent with ReceivingPrescriptionDeptID")
        return shim.Error(res)
    }
    if pbcn.PendingReceivePrescriptionWorkID != p.Args[2]{
        res:=GetRetString(1,"PrescriptionChaincode Invoke accept error:"+
            "PendingReceivePrescriptionWorkID is not consistent with ReceivingPrescriptionWorkID")
        return shim.Error(res)
    }
    pbcn.PendingReceivePrescriptionDeptID=""
    pbcn.PendingReceivePrescriptionWorkID=""
    pbcn.ReceivingPrescriptionDeptID=p.Args[1]
    pbcn.ReceivingPrescriptionWorkID=p.Args[2]
    pbcn.State=global.PrescriptionBlockchain_state_EndrSigned
    b = p.put(pbcn)
    if !b{
        res :=GetRetString(1,"PrescriptionChaincode Invoke accept put error")
        return shim.Error(res)
    }
    receivingPrescriptionDeptIDIndexKey,err:=p.Stub.CreateCompositeKey(global.ReceivingPrescriptionDeptID_PrescriptionID_IndexName,
        []string{pbcn.ReceivingPrescriptionDeptID,pbcn.PrescriptionID})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode Invoke accept"+
            " create receivingprescriptiondeptid_prescriptionid composite key failed")
        return shim.Error(res)
    }
    err=p.Stub.PutState(receivingPrescriptionDeptIDIndexKey,[]byte{0x00})
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode Invoke accept"+
            " put ReceivingPrescriptionDeptIDPrescriptionIDIndexKey error")
        return shim.Error(res)
    }
    res:=GetRetByte(0,"invoke accept success")
    return shim.Success(res)
}

9.prescriptionquery.go代码

package operation

import (
    "github.com/prescriptionserver/chaincode/go/prescription/model"
    "github.com/hyperledger/fabric/core/chaincode/shim"
    "encoding/json"
    "github.com/hyperledger/fabric/protos/peer"
    "github.com/prescriptionserver/chaincode/go/prescription/global"
    "bytes"
)

type PrescriptionQuery struct {
    Stub shim.ChaincodeStubInterface
    Args []string
}

func (p *PrescriptionQuery) GetPbcnByPid(pid string)(model.PrescriptionBlockchain,bool) {
    var pbcn model.PrescriptionBlockchain
    bytes, err := p.Stub.GetState(pid)
    if bytes == nil {
        return pbcn, false
    }
    err =json.Unmarshal(bytes,&pbcn)
    if err != nil{
        return pbcn,false
    }
    return pbcn,true
}
func (p *PrescriptionQuery) GetPbcnsByOpdid() peer.Response {
    if len(p.Args) != 1{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyopdid args!=1")
        return shim.Error(res)
    }
    pspnsIterator,err :=p.Stub.GetStateByPartialCompositeKey(global.OpenPrescriptionDeptID_PrescriptionID_IndexName,
        []string{p.Args[0]})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyopdid"+
            "getstatebypartialcompositekey error")
        return shim.Error(res)
    }
    defer pspnsIterator.Close()
    var pbcns []model.PrescriptionBlockchain
    for pspnsIterator.HasNext() {
        kv,err:=pspnsIterator.Next()
        if err != nil{
            res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyopdid iterator.next error")
            return shim.Error(res)
        }
        _, compositeKey, err := p.Stub.SplitCompositeKey(kv.Key)
        if err != nil{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyopdid"+
                "split composite key error")
            return shim.Error(res)
        }
        if len(compositeKey) <2{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyopdid"+
                "composite keys len<2")
            return shim.Error(res)
        }
        pbcn, b := p.GetPbcnByPid(compositeKey[1])
        if !b{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyopdid getpbcnbypid error")
            return shim.Error(res)
        }
        pbcns =append(pbcns,pbcn)
    }
    pbcndata,err :=json.Marshal(pbcns)
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyopdid json marshal error")
        return shim.Error(res)
    }
    return shim.Success(pbcndata)
}
func (p *PrescriptionQuery) GetPbcnsByPrpdid() peer.Response {
    if len(p.Args) != 1{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyprpdid args!=1")
        return shim.Error(res)
    }
    pspnsIterator,err :=p.Stub.GetStateByPartialCompositeKey(
        global.PendingReceivePrescriptionDeptID_PrescriptionID_IndexName,
        []string{p.Args[0]})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyprpdid"+
            "getstatebypartialcompositekey error")
        return shim.Error(res)
    }
    defer pspnsIterator.Close()
    var pbcns []model.PrescriptionBlockchain
    for pspnsIterator.HasNext() {
        kv,err:=pspnsIterator.Next()
        if err != nil{
            res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyprpdid iterator.next error")
            return shim.Error(res)
        }
        _, compositeKey, err := p.Stub.SplitCompositeKey(kv.Key)
        if err != nil{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyprpdid"+
                "split composite key error")
            return shim.Error(res)
        }
        if len(compositeKey) <2{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyprpdid"+
                "composite keys len<2")
            return shim.Error(res)
        }
        pbcn, b := p.GetPbcnByPid(compositeKey[1])
        if !b{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyprpdid getpbcnbypid error")
            return shim.Error(res)
        }
        pbcns =append(pbcns,pbcn)
    }
    pbcndata,err :=json.Marshal(pbcns)
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyprpdid json marshal error")
        return shim.Error(res)
    }
    return shim.Success(pbcndata)
}
func (p *PrescriptionQuery) GetPbcnsByState() peer.Response {
    if len(p.Args) != 1{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbystate args!=1")
        return shim.Error(res)
    }
    pspnsIterator,err :=p.Stub.GetStateByPartialCompositeKey(global.State_PrescriptionID_IndexName,
        []string{p.Args[0]})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbystate"+
            "getstatebypartialcompositekey error")
        return shim.Error(res)
    }
    defer pspnsIterator.Close()
    var pbcns []model.PrescriptionBlockchain
    for pspnsIterator.HasNext() {
        kv,err:=pspnsIterator.Next()
        if err != nil{
            res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbystate iterator.next error")
            return shim.Error(res)
        }
        _, compositeKey, err := p.Stub.SplitCompositeKey(kv.Key)
        if err != nil{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbystate"+
                "split composite key error")
            return shim.Error(res)
        }
        if len(compositeKey) <2{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbystate"+
                "composite keys len<2")
            return shim.Error(res)
        }
        pbcn, b := p.GetPbcnByPid(compositeKey[1])
        if !b{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbystate getpbcnbypid error")
            return shim.Error(res)
        }
        pbcns =append(pbcns,pbcn)
    }
    pbcndata,err :=json.Marshal(pbcns)
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbystate json marshal error")
        return shim.Error(res)
    }
    return shim.Success(pbcndata)
}
func (p *PrescriptionQuery) GetPbcnsByPtnid() peer.Response {
    if len(p.Args) != 1{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyptnid args!=1")
        return shim.Error(res)
    }
    pspnsIterator,err :=p.Stub.GetStateByPartialCompositeKey(global.PatientID_PrescriptionID_IndexName,
        []string{p.Args[0]})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyptnid"+
            "getstatebypartialcompositekey error")
        return shim.Error(res)
    }
    defer pspnsIterator.Close()
    var pbcns []model.PrescriptionBlockchain
    for pspnsIterator.HasNext() {
        kv,err:=pspnsIterator.Next()
        if err != nil{
            res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyptnid iterator.next error")
            return shim.Error(res)
        }
        _, compositeKey, err := p.Stub.SplitCompositeKey(kv.Key)
        if err != nil{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyptnid"+
                "split composite key error")
            return shim.Error(res)
        }
        if len(compositeKey) <2{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyptnid"+
                "composite keys len<2")
            return shim.Error(res)
        }
        pbcn, b := p.GetPbcnByPid(compositeKey[1])
        if !b{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyptnid getpbcnbypid error")
            return shim.Error(res)
        }
        pbcns =append(pbcns,pbcn)
    }
    pbcndata,err :=json.Marshal(pbcns)
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyptnid json marshal error")
        return shim.Error(res)
    }
    return shim.Success(pbcndata)
}
func (p *PrescriptionQuery) GetPbcnsByRpdid() peer.Response {
    if len(p.Args) != 1{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyrpdid args!=1")
        return shim.Error(res)
    }
    pspnsIterator,err :=p.Stub.GetStateByPartialCompositeKey(
        global.ReceivingPrescriptionDeptID_PrescriptionID_IndexName,
        []string{p.Args[0]})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyrpdid"+
            "getstatebypartialcompositekey error")
        return shim.Error(res)
    }
    defer pspnsIterator.Close()
    var pbcns []model.PrescriptionBlockchain
    for pspnsIterator.HasNext() {
        kv,err:=pspnsIterator.Next()
        if err != nil{
            res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyrpdid iterator.next error")
            return shim.Error(res)
        }
        _, compositeKey, err := p.Stub.SplitCompositeKey(kv.Key)
        if err != nil{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyrpdid"+
                "split composite key error")
            return shim.Error(res)
        }
        if len(compositeKey) <2{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyrpdid"+
                "composite keys len<2")
            return shim.Error(res)
        }
        pbcn, b := p.GetPbcnByPid(compositeKey[1])
        if !b{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyrpdid getpbcnbypid error")
            return shim.Error(res)
        }
        pbcns =append(pbcns,pbcn)
    }
    pbcndata,err :=json.Marshal(pbcns)
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyrpdid json marshal error")
        return shim.Error(res)
    }
    return shim.Success(pbcndata)
}
func (p *PrescriptionQuery) GetPbcnsByHndt() peer.Response {
    if len(p.Args) !=2{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyhndt args !=2")
        return shim.Error(res)
    }
    pspnsIterator,err :=p.Stub.GetStateByPartialCompositeKey(global.HospitalNO_DayTime_PrescriptionID_IndexName,
        []string{p.Args[0],p.Args[1]})
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyhndt"+
            "getstatebypartialcompositekey error")
        return shim.Error(res)
    }
    defer pspnsIterator.Close()
    var pbcns []model.PrescriptionBlockchain
    for pspnsIterator.HasNext() {
        kv,err:=pspnsIterator.Next()
        if err != nil{
            res:=GetRetString(1,"PrescriptionChaincode query getpbcnsbyhndt iterator.next error")
            return shim.Error(res)
        }
        _, compositeKey, err := p.Stub.SplitCompositeKey(kv.Key)
        if err != nil{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyhndt"+
                "split composite key error")
            return shim.Error(res)
        }
        if len(compositeKey) <3{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyhndt"+
                "composite keys len<3")
            return shim.Error(res)
        }
        pbcn, b := p.GetPbcnByPid(compositeKey[2])
        if !b{
            res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyhndt getpbcnbypid error")
            return shim.Error(res)
        }
        pbcns =append(pbcns,pbcn)
    }
    pbcndata,err :=json.Marshal(pbcns)
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnsbyhndt json marshal error")
        return shim.Error(res)
    }
    return shim.Success(pbcndata)
}
func (p *PrescriptionQuery) GetHistoryByPid() peer.Response  {
    if len(p.Args) != 1{
        res :=GetRetString(1,"PrescriptionChaincode query gethistorybypid args!=1")
        return shim.Error(res)
    }
    pbcn, b := p.GetPbcnByPid(p.Args[0])
    if !b{
        res :=GetRetString(1,"PrescriptionChaincode query gethistorybypid get prescription error")
        return shim.Error(res)
    }
    historyIterator, err := p.Stub.GetHistoryForKey(p.Args[0])
    if err != nil{
        res:=GetRetString(1,"PrescriptionChaincode query gethistorybypid"+
            "get history for key error")
        return shim.Error(res)
    }
    defer historyIterator.Close()
    var historyItems []model.HistoryItem
    var hispbcn model.PrescriptionBlockchain
    for historyIterator.HasNext(){
        hisData, err := historyIterator.Next()
        if err != nil{
            res :=GetRetString(1,"PrescriptionChaincode query gethistorybypid"+
                "history iterator next error")
            return shim.Error(res)
        }
        hisItem :=model.HistoryItem{
            TxId:hisData.TxId,
        }
        if hisData.Value ==nil{
            hisItem.PrescriptionBlockchain=model.PrescriptionBlockchain{}
        }else {
            err = json.Unmarshal(hisData.Value, &hispbcn)
            if err != nil {
                res := GetRetString(1, "PrescriptionChaincode query gethistorybypid"+
                    "json unmarshal error")
                return shim.Error(res)
            }
            hisItem.PrescriptionBlockchain=hispbcn
        }
        historyItems = append(historyItems,hisItem)
    }
    pbcn.History=historyItems
    pbcndata,err :=json.Marshal(pbcn)
    if err != nil{
        res := GetRetString(1, "PrescriptionChaincode query gethistorybypid"+
            "json marshal error")
        return shim.Error(res)
    }
    return shim.Success(pbcndata)
}
func (p *PrescriptionQuery) GetPbcnByPrescriptionID() peer.Response {
    pbcn,b:=p.GetPbcnByPid(p.Args[0])
    if !b{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnbyprescriptionid get pbcn error")
        return shim.Error(res)
    }
    pbcnData, err := json.Marshal(pbcn)
    if err != nil{
        res :=GetRetString(1,"PrescriptionChaincode query getpbcnbyprescriptionid json marshal error")
        return shim.Error(res)
    }
    return shim.Success(pbcnData)
}
func (p *PrescriptionQuery) GetResultByQueryString() peer.Response {
    if len(p.Args) != 1{
        res :=GetRetString(1,"PrescriptionChaincode query getresultbyquerystring args!=1")
        return shim.Error(res)
    }
    resultsIterator, err := p.Stub.GetQueryResult(p.Args[0])
    if err != nil {
        res :=GetRetString(1,"PrescriptionChaincode query getresultbyquerystring"+
            "get query result error")
        return shim.Error(res)
    }
    defer resultsIterator.Close()

    var datas bytes.Buffer
    datas.WriteString("[")

    arrayState := false
    for resultsIterator.HasNext() {
        queryData, err := resultsIterator.Next()
        if err != nil {
            res :=GetRetString(1,"PrescriptionChaincode query getresultbyquerystring"+
                "results iterator next error")
            return shim.Error(res)
        }
        if arrayState == true {
            datas.WriteString(",")
        }
        datas.WriteString("{"Key":")
        datas.WriteString(""")
        datas.WriteString(queryData.Key)
        datas.WriteString(""")

        datas.WriteString(", "Record":")
        // Record is a JSON object, so we write as-is
        datas.WriteString(string(queryData.Value))
        datas.WriteString("}")
        arrayState = true
    }
    datas.WriteString("]")
    
    return shim.Success(datas.Bytes())
}

10.prescriptionchaincode.go代码

package main

import (
    "github.com/hyperledger/fabric/core/chaincode/shim"
    "log"
    "github.com/hyperledger/fabric/protos/peer"
    "github.com/prescriptionserver/chaincode/go/prescription/global"
    "github.com/prescriptionserver/chaincode/go/prescription/operation"
)
type PrescriptionChaincode struct {

}

func (p PrescriptionChaincode) Init(stub shim.ChaincodeStubInterface) peer.Response {
    return shim.Success(nil)
}
func (p *PrescriptionChaincode) Invoke(stub shim.ChaincodeStubInterface) peer.Response  {
    function,args := stub.GetFunctionAndParameters()
    global.Logger.Info("%s%s","PrescriptionChaincode function=",function)
    global.Logger.Info("%s%s","PrescriptionChaincode args=",args)
    pi :=operation.PrescriptionInvoke{
        Stub:stub,
        Args:args,
    }
    pq := operation.PrescriptionQuery{
        Stub:stub,
        Args:args,
    }
    if function == "publish" {
        return pi.Publish()
    } else if function == "endorse" {
        return pi.Endorse()
    } else if function == "accept" {
        return pi.Accept()
    }

    if function == "getpbcnbypid" {
        return pq.GetPbcnByPrescriptionID()
    } else if function == "getpbcnsbyopdid" {
        return pq.GetPbcnsByOpdid()
    } else if function == "getpbcnsbyprpdid" {
        return pq.GetPbcnsByPrpdid()
    }else if function == "getpbcnsbystate" {
        return pq.GetPbcnsByState()
    }else if function == "getpbcnsbyptnid" {
        return pq.GetPbcnsByPtnid()
    }else if function == "getpbcnsbyrpdid" {
        return pq.GetPbcnsByRpdid()
    }else if function == "getpbcnsbyhndt" {
        return pq.GetPbcnsByHndt()
    }else if function == "gethistorybypid" {
        return pq.GetHistoryByPid()
    }else if function == "getresultbyquerystring" {
        return pq.GetResultByQueryString()
    }

    res := operation.GetRetString(1,"PrescriptionChaincode Unkown method!")
    global.Logger.Info("%s",res)
    global.Logger.Infof("%s",res)
    return shim.Error(res)
}


func main() {
    if err := shim.Start(new (PrescriptionChaincode));err != nil{
        log.Printf("error starting prescription chaincode: %v",err)
    }
}

go client sdk的相关开发以后有时间补全吧，chaincode sdk相关的内容有时间了再补