fabric-sdk-go client开发

1.代码结构图

2.prescription-client-config.yaml文件

name: "chaoyang-prescription-network"
description: "chao yang hospital prescription network"
version: 1.0.0
client:
  organization: cyorg.bjgoodwill.com
  logging:
    level: info
  cryptoconfig:
    path: ${GOPATH}/src/github.com/prescriptionserver/client/go/crypto-config
    #path: /opt/app/fabric/cli/user/cyorg.bjgoodwill.com/Admin-peer0cyorg.bjgoodwill..com
  credentialStore:
    path: /tmp/state-store
    cryptoStore:
      path: /tmp/msp
  BCCSP:
    security:
     enabled: true
     default:
      provider: "SW"
     hashAlgorithm: "SHA2"
     softVerify: true
     level: 256
  tlsCerts:
    systemCertPool: false
    client:
      key:
        path:
        #path: /opt/app/fabric/cli/user/cyorg.bjgoodwill.com/Admin-peer0.cyorg.bjgoodwill.com/tls/client.key
      cert:
        path:
        #path: /opt/app/fabric/cli/user/cyorg.bjgoodwill.com/Admin-peer0.cyorg.bjgoodwill.com/tls/client.crt
channels:
  prescriptionchannel:
    peers:
      peer0.cyorg.bjgoodwill.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true
    policies:
      queryChannelConfig:
        minResponses: 1
        maxTargets: 1
        retryOpts:
          attempts: 5
          initialBackoff: 500ms
          maxBackoff: 5s
          backoffFactor: 2.0
          
  prescriptionmultiorgchannel:

    peers:
      peer0.cyorg.bjgoodwill.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true

      peer0.jhorg.bjgoodwill.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true

      peer0.wjworg.bjgoodwill.com:
        endorsingPeer: true
        chaincodeQuery: true
        ledgerQuery: true
        eventSource: true

    # [Optional]. The application can use these options to perform channel operations like retrieving channel
    # config etc.
    policies:
      #[Optional] options for retrieving channel configuration blocks
      queryChannelConfig:
        #[Optional] min number of success responses (from targets/peers)
        minResponses: 1
        #[Optional] channel config will be retrieved for these number of random targets
        maxTargets: 1
        #[Optional] retry options for query config block
        retryOpts:
          #[Optional] number of retry attempts
          attempts: 5
          #[Optional] the back off interval for the first retry attempt
          initialBackoff: 500ms
          #[Optional] the maximum back off interval for any retry attempt
          maxBackoff: 5s
          #[Optional] he factor by which the initial back off period is exponentially incremented
          backoffFactor: 2.0

organizations:
  cyorg.bjgoodwill.com:
    mspid: CYOrgMSP
    cryptoPath: peerOrganizations/cyorg.bjgoodwill.com/users/Admin@cyorg.bjgoodwill.com/msp/
    #cryptoPath: msp/
    peers:
      - peer0.cyorg.bjgoodwill.com
    certificateAuthorities:
      - ca.cyorg.bjgoodwill.com
  
  jhorg.bjgoodwill.com:
    mspid: JHOrgMSP
    # This org's MSP store (absolute path or relative to client.cryptoconfig)
    cryptoPath:  peerOrganizations/jhorg.bjgoodwill.com/users/Admin@jhorg.bjgoodwill.com/msp
    peers:
      - peer0.jhorg.bjgoodwill.com
    certificateAuthorities:
      - ca.jhorg.bjgoodwill.com
  
  wjworg.bjgoodwill.com:
    mspid: WJWOrgMSP
    # This org's MSP store (absolute path or relative to client.cryptoconfig)
    cryptoPath:  peerOrganizations/wjworg.bjgoodwill.com/users/Admin@wjworg.bjgoodwill.com/msp
    peers:
      - peer0.wjworg.bjgoodwill.com
    certificateAuthorities:
      - ca.wjworg.bjgoodwill.com 
     # Orderer Org name
  ordererorg:
      # Membership Service Provider ID for this organization
      mspID: "PrescriptionOrdererMSP"

      # Needed to load users crypto keys and certs for this org (absolute path or relative to global crypto path, DEV mode)
      cryptoPath: ordererOrganizations/bjgoodwill.com/users/Admin@bjgoodwill.com/msp

orderers:
  orderer.bjgoodwill.com:
    url: grpc://192.168.229.136:7050
    grpcOptions:
      ssl-target-name-override: orderer.bjgoodwill.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
      allow-insecure: false
    tlsCACerts:
      path: ${GOPATH}/src/github.com/prescriptionserver/client/go/crypto-config/ordererOrganizations/bjgoodwill.com/tlsca/tlsca.bjgoodwill.com-cert.pem
      #path: /opt/app/fabric/cli/user/member1.example.com/Admin-peer0.member1.example.com/tlsca.member1.example.com-cert.pem
peers:
  peer0.cyorg.bjgoodwill.com:
    url: grpc://192.168.229.138:7051
    eventUrl: grpc://192.168.229.138:7053
    grpcOptions:
      ssl-target-name-override: peer0.cyorg.bjgoodwill.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
      allow-insecure: false
    tlsCACerts:
      path: ${GOPATH}/src/github.com/prescriptionserver/client/go/crypto-config/peerOrganizations/cyorg.bjgoodwill.com/tlsca/tlsca.cyorg.bjgoodwill.com-cert.pem
      #path: /opt/app/fabric/cli/user/cyorg.bjgoodwill.com/Admin-peer0.cyorg.bjgoodwill.com/tls/ca.crt
 
  peer0.jhorg.bjgoodwill.com:
    url: peer0.jhorg.bjgoodwill.com:7051
    eventUrl: peer0.jhorg.bjgoodwill.com:7053
    grpcOptions:
      ssl-target-name-override: peer0.jhorg.bjgoodwill.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
      allow-insecure: false
    tlsCACerts:
      path: ${GOPATH}/src/github.com/prescriptionserver/client/go/crypto-config/peerOrganizations/jhorg.bjgoodwill.com/tlsca/tlsca.jhorg.bjgoodwill.com-cert.pem
      #path: /opt/app/fabric/cli/user/member1.example.com/Admin-peer0.member1.example.com/tls/ca.crt
      
  peer0.wjworg.bjgoodwill.com:
    url: peer0.wjworg.bjgoodwill.com:7051
    eventUrl: peer0.wjworg.bjgoodwill.com:7053
    grpcOptions:
      ssl-target-name-override: peer0.wjworg.bjgoodwill.com
      keep-alive-time: 0s
      keep-alive-timeout: 20s
      keep-alive-permit: false
      fail-fast: false
      allow-insecure: false
    tlsCACerts:
      path: ${GOPATH}/src/github.com/prescriptionserver/client/go/crypto-config/peerOrganizations/wjworg.bjgoodwill.com/tlsca/tlsca.wjworg.bjgoodwill.com-cert.pem
      #path: /opt/app/fabric/cli/user/member1.example.com/Admin-peer0.member1.example.com/tls/ca.crt
certificateAuthorities:
  ca.fbi.citizens.com:
    url: https://192.168.229.138:7054
    tlsCACerts:
      # Comma-Separated list of paths
      path: ${GOPATH}/src/github.com/prescriptionserver/client/go/crypto-config/peerOrganizations/cyorg.bjgoodwill.com/tlsca/tlsca.cyorg.bjgoodwill.com-cert.pem
      # Client key and cert for SSL handshake with Fabric CA
      client:
        key:
          path: ${GOPATH}/src/github.com/prescriptionserver/client/go/crypto-config/peerOrganizations/cyorg.bjgoodwill.com/users/User1@cyorg.bjgoodwill.com/tls/client.key
        cert:
          path: ${GOPATH}/src/github.com/prescriptionserver/client/go/crypto-config/peerOrganizations/cyorg.bjgoodwill.com/users/User1@cyorg.bjgoodwill.com/tls/client.crt

    # Fabric-CA supports dynamic user enrollment via REST APIs. A "root" user, a.k.a registrar, is
    # needed to enroll and invoke new users.
    registrar:
      enrollId: admin
      enrollSecret: adminpw
    # [Optional] The optional name of the CA.
    caName: ca.cyorg.bjgoodwill.com

entityMatchers:
  orderer:
    - pattern: (w*)orderer.bjgoodwill.com(w*)
      urlSubstitutionExp: grpc://orderer.bjgoodwill.com:7050
      sslTargetOverrideUrlSubstitutionExp: orderer.bjgoodwill.com
      mappedHost: orderer.bjgoodwill.com

3.prescriptionclient.yaml文件

prescriptionclient:
  fabricsdk:
    configfile: ./client/go/config/prescription-client-config.yaml
  resmgmt:
    orgname: cyorg.bjgoodwill.com
    orgadmin: Admin
  channel:
    channelconfig: /src/github.com/prescriptionserver/client/go/channel-artifacts/prescription.tx
    channelid: prescriptionchannel
    username: User1
  msp:
    orgname: cyorg.bjgoodwill.com
    mspid: CYOrgMSP
  filepath:
    configfilepath: ./client/go/config/prescriptionclient.yaml

4.config.go代码

package util

import (
    "encoding/json"
    "io/ioutil"
    "github.com/prescriptionserver/client/go/global"
    "log"
)

var prescriptionclientconfig []byte

type PrescriptionClientConfig struct {
    PrescriptionClient PrescriptionClient `yaml:"prescriptionclient"`
}
type PrescriptionClient struct {
    FabricSDK FabricSDK `yaml:"fabricsdk"`
    ResMgmt ResMgmt `yaml:"resmgmt"`
    Channel Channel `yaml:"channel"`
    Msp Msp `yaml:"msp"`
    FilePath FilePath `yaml:"filepath"`
}
type FabricSDK struct {
    ConfigFile string `yaml:"configfile"`
}
type Channel struct {
    ChannelConfig string `yaml:"channelconfig"`
    ChannelID string `yaml:"channelid"`
    UserName string `yaml:"username"`
}
type ResMgmt struct {
    OrgName string `yaml:"orgname"`
    OrgAdmin string `yaml:"orgadmin"`
}
type Msp struct {
    OrgName string `yaml:"orgname"`
    MSPID string `yaml:"mspid"`
}
type FilePath struct {
    ConfigFilePath string `yaml:"configfilepath"`
}

func GetPrescriptionClientConfig() (pcc *PrescriptionClientConfig,err error) {
    err = json.Unmarshal(prescriptionclientconfig,&pcc)
    return pcc,err
}
func init()  {
    var err error
    prescriptionclientconfig,err =ioutil.ReadFile(global.ConfigFile)
    if err != nil{
        global.Logger.Errorf("prescriptionclient.yaml file get error: %v",err)
        log.Fatalf("prescriptionclient.yaml file get error: %v",err)
    }
}

5.ecslfabricsdk.go代码

package encapsulation

import (
    "github.com/hyperledger/fabric-sdk-go/pkg/fabsdk"
    "sync"
    "github.com/prescriptionserver/client/go/global"
    "github.com/hyperledger/fabric-sdk-go/pkg/core/config"
    "github.com/prescriptionserver/client/go/util"
    "github.com/hyperledger/fabric-sdk-go/pkg/client/channel"
    "github.com/hyperledger/fabric-sdk-go/pkg/client/event"
)

type EcslFabricSDK struct {
    sdk *fabsdk.FabricSDK
}

var (
    efsdk *EcslFabricSDK
    once sync.Once
)

func GetEcslFabricSDKInstance() (*EcslFabricSDK,error) {
    var err error
    once.Do(func() {
        cf, e := util.GetPrescriptionClientConfig()
        if e != nil{
            global.Logger.Errorf("load prescriptionclient.yaml file error: %v
",err)
            err=e
        }else {
            configProvider :=config.FromFile(cf.PrescriptionClient.FabricSDK.ConfigFile)
            sdk,err :=fabsdk.New(configProvider)
            if err != nil{
                global.Logger.Errorf("initialize fabsdk error: %v
",err)
            }else {
                efsdk=&EcslFabricSDK{
                    sdk:sdk,
                }
                err = nil
            }
        }

    })
    return efsdk,err
}
func (efsdk *EcslFabricSDK) GetChannelAndEventClient(channelid string,
    username string)(channelclient *channel.Client,eventclient *event.Client,err error) {
    sdk, err := GetEcslFabricSDKInstance()
    if err != nil{
        return nil,nil,err
    }
    clientcontext := sdk.sdk.ChannelContext(channelid, fabsdk.WithUser(username))
    channelclient,err = channel.New(clientcontext)
    if err != nil{
        return channelclient,nil,err
    }
    eventclient,err =event.New(clientcontext)
    return channelclient,eventclient,err
}
func (efsdk *EcslFabricSDK) GetChannelClient(channelid string,
    username string) (channelclient *channel.Client,err error) {
    sdk, err := GetEcslFabricSDKInstance()
    if err != nil{
        return nil,err
    }
    clientcontext :=sdk.sdk.ChannelContext(channelid,fabsdk.WithUser(username))
    channelclient,err =channel.New(clientcontext)
    return channelclient,err
}
func (efsdk *EcslFabricSDK) Close()  {
    if efsdk != nil{
        efsdk.sdk.Close()
        efsdk= nil
    }
}

6.ecslresmgmt.go代码

package encapsulation

import (
    "github.com/hyperledger/fabric-sdk-go/pkg/client/resmgmt"
    "errors"
    "github.com/hyperledger/fabric-sdk-go/pkg/fabsdk"
    "log"
    "github.com/prescriptionserver/client/go/global"
    "github.com/prescriptionserver/client/go/util"
    "os"
    mspc "github.com/hyperledger/fabric-sdk-go/pkg/client/msp"
    msp2 "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/msp"
    "github.com/hyperledger/fabric-sdk-go/pkg/common/errors/retry"
    "strings"
    "github.com/hyperledger/fabric-sdk-go/third_party/github.com/hyperledger/fabric/protos/peer"
    "github.com/hyperledger/fabric-sdk-go/pkg/fab/ccpackager/gopackager"
    "github.com/hyperledger/fabric-sdk-go/third_party/github.com/hyperledger/fabric/common/cauthdsl"
)

type EcslResmgmtClient struct {
    OrgName       string
    OrgAdmin      string
    ConfigFile    string
    initialized   bool
    resMgmtClient *resmgmt.Client
    efsdk     *EcslFabricSDK
}

func (e *EcslResmgmtClient) Initialize() error {
    if e.OrgAdmin=="" || e.OrgName=="" || e.ConfigFile==""{
        return errors.New("orgname or orgadmin or configfile is not null")
    }
    if e.initialized{
        global.Logger.Error("ecslresmgmtclient initialize again !")
        return nil
    }
    sdk,err := GetEcslFabricSDKInstance()
    if err != nil{
        return err
    }
    e.efsdk=sdk
    log.Printf("ecsl fabric sdk created")
    resourceManagerClientContext := e.efsdk.sdk.Context(fabsdk.WithUser(e.OrgAdmin),fabsdk.WithOrg(e.OrgName))
    if err != nil{
        return err
    }
    resMgmtClient,err:=resmgmt.New(resourceManagerClientContext)
    if err != nil{
        return err
    }
    e.resMgmtClient =resMgmtClient
    e.initialized=true
    return nil
}
func (e *EcslResmgmtClient) CreateChannel(channelid string,targetpeerendpoint string,
    orgname string,orgadmin string,ordererid string) error {
    if channelid == "" || targetpeerendpoint==""{
        return errors.New("channeldid or target peer endpoint is not null")
    }
    if e.ChannelExists(channelid,targetpeerendpoint){
        return errors.New("channelid already exists")
    }
    if e.initialized == false{
        err :=e.Initialize()
        if err != nil{
            return err
        }
    }
    cf,err:= util.GetPrescriptionClientConfig()
    if err != nil{
        return err
    }
    mspclient ,err:= mspc.New(e.efsdk.sdk.Context(),mspc.WithOrg(orgname))
    if err != nil{
        return err
    }
    adminidentity,err := mspclient.GetSigningIdentity(orgadmin)
    if err != nil{
        return err
    }
    req:=resmgmt.SaveChannelRequest{
        ChannelID:channelid,
        ChannelConfigPath:os.Getenv("GOPATH") + cf.PrescriptionClient.Channel.ChannelConfig,
        SigningIdentities:[]msp2.SigningIdentity{adminidentity},
    }
    response, err := e.resMgmtClient.SaveChannel(req,resmgmt.WithOrdererEndpoint(ordererid))
    if err != nil || response.TransactionID == ""{
        return err
    }
    log.Println("channel created success")
    return nil
}
func (e *EcslResmgmtClient) JoinChannel(channelid string,ordererid string) error{
    if channelid =="" || ordererid==""{
        return errors.New("join channel ordererid or channelid is not null")
    }
    if e.initialized == false{
        err:=e.Initialize()
        if err != nil{
            return err
        }
    }
    err := e.resMgmtClient.JoinChannel(channelid, resmgmt.WithRetry(retry.DefaultResMgmtOpts),
        resmgmt.WithOrdererEndpoint(ordererid))
    return err
}
func (e *EcslResmgmtClient) IsInitialized() bool {
    return e.initialized
}
func (e *EcslResmgmtClient) ChannelExists(channelid string, targetpeerendpoint ...string) bool {
    if e.initialized ==false{
        err:=e.Initialize()
        if err != nil{
            global.Logger.Errorf("channel exists error: %v
",err)
            return false
        }
    }else {
        response, err := e.resMgmtClient.QueryChannels(resmgmt.WithTargetEndpoints(targetpeerendpoint...))
        if err != nil{
            global.Logger.Errorf("channel exists function query channels error: %v
",err)
            return false
        }
        if response != nil{
            for _,channel:=range response.Channels{
                if channel.ChannelId == channelid{
                    return true
                }
            }
        }
    }
    return false
}
func (e *EcslResmgmtClient) ChaincodeInstallExists(chaincodeid string,peerendpoint string) bool {
    if chaincodeid =="" || peerendpoint==""{
        global.Logger.Error("chaincodeexists function chaincodeid or peerendpoint is not null 
")
        return  false
    }
    if e.initialized==false{
        err :=e.Initialize()
        if err != nil{
            global.Logger.Errorf("resmgmt initialize error: %v
",err)
            return false
        }
    }
    ccinsqes, err := e.resMgmtClient.QueryInstalledChaincodes(resmgmt.WithTargetEndpoints(peerendpoint))
    if err != nil || ccinsqes==nil{
        global.Logger.Errorf("resmgmt query installed chaincodes error : %v
",err)
        return false
    }
    for _,cc :=range ccinsqes.Chaincodes{
        if strings.EqualFold(cc.Name,chaincodeid){
            return true
        }
    }
    return false
}
func (e *EcslResmgmtClient) ChaincodeInstantiatedExists(chaincodeid string,peerendpoint string) bool {
    if chaincodeid =="" || peerendpoint==""{
        global.Logger.Error("chaincodeexists function chaincodeid or peerendpoint is not null 
")
        return  false
    }
    if e.initialized==false{
        err :=e.Initialize()
        if err != nil{
            global.Logger.Errorf("resmgmt initialize error: %v
",err)
            return false
        }
    }
    ccinstqes, err := e.resMgmtClient.QueryInstantiatedChaincodes(chaincodeid,
        resmgmt.WithTargetEndpoints(peerendpoint))
    if err != nil ||ccinstqes == nil{
        global.Logger.Errorf("chaincodeinstantiatedexists resmgmt query instantiated chaincodes error : %v
",err)
        return false
    }
    for _,cc :=range ccinstqes.Chaincodes{
        if strings.EqualFold(cc.Name,chaincodeid){
            return true
        }
    }
    return false
}
func (e *EcslResmgmtClient) GetInstantiatedChaincodes(channelid string,
    peerendpoint string) ([]*peer.ChaincodeInfo,error) {
    if channelid =="" || peerendpoint==""{
        global.Logger.Error("getchaincodes function channelid or peerendpoint is not null 
")
        return  nil,errors.New("getchaincodes function channelid or peerendpoint is not null")
    }
    if e.initialized==false{
        err :=e.Initialize()
        if err != nil{
            global.Logger.Errorf("getchaincodesresmgmt initialize error: %v
",err)
            return nil,err
        }
    }
    ccinstqes, err := e.resMgmtClient.QueryInstantiatedChaincodes(channelid,
        resmgmt.WithTargetEndpoints(peerendpoint))
    if err != nil ||ccinstqes == nil{
        return nil,err
    }
    return  ccinstqes.Chaincodes,nil
}
func (e *EcslResmgmtClient) GetInstalledChaincodes(
    peerendpoint string) ([]*peer.ChaincodeInfo,error)  {
    if peerendpoint==""{
        global.Logger.Error("getchaincodes function  peerendpoint is not null 
")
        return  nil,errors.New("getchaincodes function peerendpoint is not null")
    }
    if e.initialized==false{
        err :=e.Initialize()
        if err!= nil{
            global.Logger.Errorf("getchaincodesresmgmt initialize error: %v
",err)
            return nil,err
        }
    }
    ccinsqes, err := e.resMgmtClient.QueryInstalledChaincodes(resmgmt.WithTargetEndpoints(peerendpoint))
    if err != nil || ccinsqes==nil{
        global.Logger.Errorf("getchaincodes resmgmt query installed chaincodes error : %v
",err)
        return nil,err
    }
    return ccinsqes.Chaincodes,nil
}
func (e *EcslResmgmtClient) InstallChaincode(chaincodeid string,chaincodepath string,
    chaincodeversion string,peerendpoint string) error {
    if chaincodeid =="" ||chaincodepath==""||chaincodeversion==""||peerendpoint==""{
        return errors.New("install chaincode function with chaincodeid or"+
            " chaincodepath or chaincodeversion or peerendpoit is not null 
")
    }
    if e.initialized==false{
        err :=e.Initialize()
        if err != nil{
            global.Logger.Errorf("installchaincode resmgmt initialize error: %v
",err)
            return err
        }
    }
    ccpkg,err :=gopackager.NewCCPackage(chaincodepath,os.Getenv("GOPATH"))
    if err != nil{
        return err
    }
    if e.ChaincodeInstallExists(chaincodeid,peerendpoint){
        return errors.New("chaincodeid install already exists")
    }
     insccreq:=resmgmt.InstallCCRequest{
         Name:chaincodeid,
         Path:chaincodepath,
         Version:chaincodeversion,
         Package:ccpkg,
     }
    _,err = e.resMgmtClient.InstallCC(insccreq, resmgmt.WithRetry(retry.DefaultResMgmtOpts),
        resmgmt.WithTargetEndpoints(peerendpoint))
    return err
}
func (e *EcslResmgmtClient) InstantiatedChaincode(chaincodeid string,channelid string,
    chaincodeversion string,peerendpoint string,orgmspid string) error {
    if chaincodeid =="" ||channelid==""||chaincodeversion==""||peerendpoint==""{
        return errors.New("instantiated chaincode function with chaincodeid or"+
            " channelid or chaincodeversion or peerendpoit or orgmspid is not null 
")
    }
    if e.initialized==false{
        err :=e.Initialize()
        if err != nil{
            global.Logger.Errorf("installchaincode resmgmt initialize error: %v
",err)
            return err
        }
    }
    if e.ChaincodeInstantiatedExists(chaincodeid,peerendpoint){
        return errors.New("chaincode instantiated already exists")
    }
    ccpolicy :=cauthdsl.SignedByMspMember(orgmspid)
    instccreq:=resmgmt.InstantiateCCRequest{
        Name:chaincodeid,
        Path:os.Getenv("GOPATH"),
        Version:chaincodeversion,
        Args:[][]byte{[]byte("init"),[]byte("init")},
        Policy:ccpolicy,
    }
    resp, err := e.resMgmtClient.InstantiateCC(channelid, instccreq)
    if err != nil{
        return err
    }
    if resp.TransactionID==""{
        return errors.New("failed to instanitated chaincode")
    }
    return nil
}
func (e *EcslResmgmtClient) Close()  {
    if e != nil{
        e.efsdk.Close()
    }
}

7.clientglobal.go代码

package global

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


var(
    Logger =flogging.MustGetLogger("PrescriptionChaincode")
)

const (
    ConfigFile="./client/go/config/prescriptionclient.yaml"
)

8.prescriptionclientinvoke.go代码

package operation

import (
    "github.com/prescriptionserver/client/go/clientmodel"
    "errors"
    "encoding/json"
    "github.com/prescriptionserver/client/go/encapsulation"
    "strings"
    "github.com/hyperledger/fabric-sdk-go/pkg/client/channel"
    "log"
    "time"
    "fmt"
)

type PrescriptionClientInvoke struct {
    ChannelID   string
    UserName    string
    ChaincodeID string
    EventID     string
}

func (pc *PrescriptionClientInvoke) Publish(blockchain clientmodel.PrescriptionBlockchain) (string,error)  {
    if pc.ChannelID ==""||pc.ChaincodeID ==""||pc.UserName==""{
        return "",errors.New("client publish function channelid or username or chaincode is not null")
    }
    var args []string
    args = append(args,"publish")
    if blockchain.PrescriptionID=="" || blockchain.PrescriptionSummary==""{
        return "",errors.New("prescription block chain entity is not nil")
    }
    bytes, err := json.Marshal(blockchain)
    if err != nil{
        return "",err
    }
    transientdatamap := make(map[string][]byte)
    transientdatamap["result"]=[]byte("transient data in prescription invoke publish")
    ecslsdk ,err:= encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return "",err
    }
    //defer ecslsdk.Close()
    channelclient, eventclient, err := ecslsdk.GetChannelAndEventClient(pc.ChannelID, pc.UserName)
    if err != nil{
        return "" ,err
    }
    eventid:=""
    if strings.TrimSpace(pc.EventID)==""{
        eventid="eventPrescriptionInvokePublish"
    }else {
        eventid=pc.EventID
    }
    registration, chanevent, err := eventclient.RegisterChaincodeEvent(pc.ChaincodeID, eventid)
    if err != nil{
        return "",err
    }
    defer eventclient.Unregister(registration)
    chlreq := channel.Request{
        ChaincodeID:pc.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{bytes},
        TransientMap:transientdatamap,
    }
    response, err := channelclient.Execute(chlreq)
    if err != nil{
        return "",nil
    }
    select {
    case ccevent:=<-chanevent:
        log.Printf("received cc event: %v
",ccevent)
    case <-time.After(time.Second * 20):
        return "",fmt.Errorf("publish did not receive cc event for eventid: %s",eventid)
    }
    return string(response.TransactionID),nil
}
func (pc *PrescriptionClientInvoke) Endorse(pid string,prpdid string,
    prpwid string) (string,error) {
    if pc.ChannelID ==""||pc.ChaincodeID ==""||pc.UserName==""{
        return "",errors.New("client endorse function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(pid)=="" || strings.TrimSpace(prpdid)=="" || strings.TrimSpace(prpwid) ==""{
        return "",errors.New("client endorse function pid or prpdid or prpwid is not null")
    }
    var args []string
    args=append(args,"endorse")
    args=append(args,pid)
    args=append(args,prpdid)
    args=append(args,prpwid)
    transientdatamap :=make(map[string][]byte)
    transientdatamap["result"]=[]byte("transient data in prescription invoke endorse")
    ecslsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return "",err
    }
    channelclient, eventclient, err := ecslsdk.GetChannelAndEventClient(pc.ChannelID, pc.UserName)
    if err != nil{
        return "", nil
    }
    eventid:=""
    if strings.TrimSpace(pc.EventID)==""{
        eventid="eventPrescriptionInvokeEndorse"
    }else {
        eventid=pc.EventID
    }
    registration, chanevent, err := eventclient.RegisterChaincodeEvent(pc.ChaincodeID, eventid)
    if err != nil{
        return "", nil
    }
    defer eventclient.Unregister(registration)
    chlreq :=channel.Request{
        ChaincodeID:pc.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1]),[]byte(args[2]),[]byte(args[3])},
        TransientMap:transientdatamap,
    }
    response, err := channelclient.Execute(chlreq)
    if err != nil{
        return "", nil
    }
    select {
    case ccevent := <-chanevent:
        log.Printf("received cc event: %v
", ccevent)
    case <-time.After(time.Second * 20):
        return "", fmt.Errorf("endorse did not receive cc event for eventid: %s", eventid)
    }
    return string(response.TransactionID), nil
    //defer ecslsdk.Close()

}
func (pc *PrescriptionClientInvoke) Accept(pid string,rpdid string,rpwid string) (string,error) {
    if pc.ChannelID ==""||pc.ChaincodeID ==""||pc.UserName==""{
        return "",errors.New("client publish function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(pid)=="" || strings.TrimSpace(rpdid)=="" || strings.TrimSpace(rpwid) ==""{
        return "",errors.New("client accept function pid or rpdid or rpwid is not null")
    }
    var args []string
    args=append(args,"accept")
    args=append(args,pid)
    args=append(args,rpdid)
    args=append(args,rpwid)
    ecslsdk,err:=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return "", nil
    }
    channelclient, eventclient, err := ecslsdk.GetChannelAndEventClient(pc.ChannelID, pc.UserName)
    if err != nil{
        return "", nil
    }
    eventid :=""
    if strings.TrimSpace(pc.EventID)==""{
        eventid="eventPrescriptionInvokeAccept"
    }else {
        eventid=pc.EventID
    }
    registration, chanevent, err := eventclient.RegisterChaincodeEvent(pc.ChaincodeID, eventid)
    if err != nil{
        return "", nil
    }
    defer eventclient.Unregister(registration)
    transientdatamap := make(map[string][]byte)
    transientdatamap["result"]=[]byte("transient data in prescription invoke accept")
    chlreq:=channel.Request{
        ChaincodeID:pc.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1]),[]byte(args[2]),[]byte(args[3])},
        TransientMap:transientdatamap,
    }
    response, err := channelclient.Execute(chlreq)
    if err != nil{
        return "", nil
    }
    select {
    case ccevent:=<-chanevent:
        log.Printf("received cc event: %v
",ccevent)
    case <-time.After(time.Second*20):
        return "", fmt.Errorf("accept did not receive cc event for eventid: %s", eventid)
    }
    return string(response.TransactionID),nil
}

9.prescriptionclientquery.go代码

package operation

import (
    "github.com/prescriptionserver/client/go/clientmodel"
    "errors"
    "strings"
    "github.com/prescriptionserver/client/go/encapsulation"
    "github.com/hyperledger/fabric-sdk-go/pkg/client/channel"
    "encoding/json"
)

type PrescriptionClientQuery struct {
    ChannelID string
    ChaincodeID string
    UserName string
}

func (pcq *PrescriptionClientQuery) GetPbcnByPid(pid string) (pbcn clientmodel.PrescriptionBlockchain,
    err error) {
    if pcq.ChannelID ==""||pcq.ChaincodeID ==""||pcq.UserName==""{
        return pbcn,errors.New("client getpbcnbypid function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(pid) ==""{
        return pbcn,errors.New("client getpbcnbypid function pid is not null")
    }
    efsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return pbcn,err
    }
    channelclient, err := efsdk.GetChannelClient(pcq.ChannelID, pcq.UserName)
    if err != nil{
        return pbcn,err
    }
    var args []string
    args = append(args,"getpbcnbyprescriptionid")
    args=append(args,pid)
    chlreq := channel.Request{
        ChaincodeID:pcq.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1])},
    }
    response, err := channelclient.Query(chlreq)
    if err != nil{
        return pbcn,err
    }
    err = json.Unmarshal(response.Payload, &pbcn)
    return pbcn,err
}
func (pcq *PrescriptionClientQuery) GetPbcnsByOpdid(opdid string) (pbcns []clientmodel.PrescriptionBlockchain,err error) {
    if pcq.ChannelID ==""||pcq.ChaincodeID ==""||pcq.UserName==""{
        return pbcns,errors.New("client getpbcnbyopdid function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(opdid) ==""{
        return pbcns,errors.New("client getpbcnbyopdid function opdid is not null")
    }
    efsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return pbcns,err
    }
    channelclient, err := efsdk.GetChannelClient(pcq.ChannelID, pcq.UserName)
    if err != nil{
        return pbcns,err
    }
    var args []string
    args = append(args,"getpbcnbyopdid")
    args=append(args,opdid)
    chlreq := channel.Request{
        ChaincodeID:pcq.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1])},
    }
    response, err := channelclient.Query(chlreq)
    if err != nil{
        return pbcns,err
    }
    err = json.Unmarshal(response.Payload, &pbcns)
    return pbcns,err
}
func (pcq *PrescriptionClientQuery) GetPbcnsByPrpdid(prpdid string) (
    pbcns []clientmodel.PrescriptionBlockchain,err error) {
    if pcq.ChannelID ==""||pcq.ChaincodeID ==""||pcq.UserName==""{
        return pbcns,errors.New("client getpbcnbyprpdid function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(prpdid) ==""{
        return pbcns,errors.New("client getpbcnbyprpdid function prpdid is not null")
    }
    efsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return pbcns,err
    }
    channelclient, err := efsdk.GetChannelClient(pcq.ChannelID, pcq.UserName)
    if err != nil{
        return pbcns,err
    }
    var args []string
    args = append(args,"getpbcnbyprpdid")
    args=append(args,prpdid)
    chlreq := channel.Request{
        ChaincodeID:pcq.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1])},
    }
    response, err := channelclient.Query(chlreq)
    if err != nil{
        return pbcns,err
    }
    err = json.Unmarshal(response.Payload, &pbcns)
    return pbcns,err
}
func (pcq *PrescriptionClientQuery) GetPbcnsByState(state string) (
    pbcns []clientmodel.PrescriptionBlockchain,err error) {
    if pcq.ChannelID ==""||pcq.ChaincodeID ==""||pcq.UserName==""{
        return pbcns,errors.New("client getpbcnbystatefunction channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(state) ==""{
        return pbcns,errors.New("client getpbcnbystate function state is not null")
    }
    efsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return pbcns,err
    }
    channelclient, err := efsdk.GetChannelClient(pcq.ChannelID, pcq.UserName)
    if err != nil{
        return pbcns,err
    }
    var args []string
    args = append(args,"getpbcnbystate")
    args=append(args,state)
    chlreq := channel.Request{
        ChaincodeID:pcq.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1])},
    }
    response, err := channelclient.Query(chlreq)
    if err != nil{
        return pbcns,err
    }
    err = json.Unmarshal(response.Payload, &pbcns)
    return pbcns,err
}
func (pcq *PrescriptionClientQuery) GetPbcnsByPtnid(ptnid string) (
    pbcns []clientmodel.PrescriptionBlockchain,err error) {
    if pcq.ChannelID ==""||pcq.ChaincodeID ==""||pcq.UserName==""{
        return pbcns,errors.New("client getpbcnbyptnid function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(ptnid) ==""{
        return pbcns,errors.New("client getpbcnbyptnid function ptnid is not null")
    }
    efsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return pbcns,err
    }
    channelclient, err := efsdk.GetChannelClient(pcq.ChannelID, pcq.UserName)
    if err != nil{
        return pbcns,err
    }
    var args []string
    args = append(args,"getpbcnbyptnid")
    args=append(args,ptnid)
    chlreq := channel.Request{
        ChaincodeID:pcq.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1])},
    }
    response, err := channelclient.Query(chlreq)
    if err != nil{
        return pbcns,err
    }
    err = json.Unmarshal(response.Payload, &pbcns)
    return pbcns,err
}
func (pcq *PrescriptionClientQuery) GetPbcnsByRpdid(rpdid string) (
    pbcns []clientmodel.PrescriptionBlockchain,err error) {
    if pcq.ChannelID ==""||pcq.ChaincodeID ==""||pcq.UserName==""{
        return pbcns,errors.New("client getpbcnbyrpdid function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(rpdid) ==""{
        return pbcns,errors.New("client getpbcnbyrpdid function rpdid is not null")
    }
    efsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return pbcns,err
    }
    channelclient, err := efsdk.GetChannelClient(pcq.ChannelID, pcq.UserName)
    if err != nil{
        return pbcns,err
    }
    var args []string
    args = append(args,"getpbcnbyrpdid")
    args=append(args,rpdid)
    chlreq := channel.Request{
        ChaincodeID:pcq.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1])},
    }
    response, err := channelclient.Query(chlreq)
    if err != nil{
        return pbcns,err
    }
    err = json.Unmarshal(response.Payload, &pbcns)
    return pbcns,err
}
func (pcq *PrescriptionClientQuery) GetPbcnsByHndt(hospitalno string,daytime string) (
    pbcns []clientmodel.PrescriptionBlockchain,err error) {
    if pcq.ChannelID ==""||pcq.ChaincodeID ==""||pcq.UserName==""{
        return pbcns,errors.New("client getpbcnbyhndt function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(hospitalno) =="" || strings.TrimSpace(daytime)==""{
        return pbcns,errors.New("client getpbcnbyhndt function hospitalno or daytime is not null")
    }
    efsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return pbcns,err
    }
    channelclient, err := efsdk.GetChannelClient(pcq.ChannelID, pcq.UserName)
    if err != nil{
        return pbcns,err
    }
    var args []string
    args = append(args,"getpbcnbyhndt")
    args=append(args,hospitalno)
    args=append(args,daytime)
    chlreq := channel.Request{
        ChaincodeID:pcq.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1]),[]byte(args[2])},
    }
    response, err := channelclient.Query(chlreq)
    if err != nil{
        return pbcns,err
    }
    err = json.Unmarshal(response.Payload, &pbcns)
    return pbcns,err
}
func (pcq *PrescriptionClientQuery) GetHistoryByPid(pid string) (
    pbcn clientmodel.PrescriptionBlockchain,err error) {
    if pcq.ChannelID ==""||pcq.ChaincodeID ==""||pcq.UserName==""{
        return pbcn,errors.New("client gethistorybypid function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(pid) ==""{
        return pbcn,errors.New("client gethistorybypid function pid is not null")
    }
    efsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return pbcn,err
    }
    channelclient, err := efsdk.GetChannelClient(pcq.ChannelID, pcq.UserName)
    if err != nil{
        return pbcn,err
    }
    var args []string
    args = append(args,"gethistorybypid")
    args=append(args,pid)
    chlreq := channel.Request{
        ChaincodeID:pcq.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1])},
    }
    response, err := channelclient.Query(chlreq)
    if err != nil{
        return pbcn,err
    }
    err = json.Unmarshal(response.Payload, &pbcn)
    return pbcn,err
}
func (pcq *PrescriptionClientQuery) GetResultByQueryString(query string) (
    pbcns string,err error) {
    if pcq.ChannelID ==""||pcq.ChaincodeID ==""||pcq.UserName==""{
        return pbcns,errors.New("client getresultbyquerystring function channelid or username or chaincode is not null")
    }
    if strings.TrimSpace(query) ==""{
        return pbcns,errors.New("client getresultbyquerystring function query is not null")
    }
    efsdk,err :=encapsulation.GetEcslFabricSDKInstance()
    if err != nil{
        return pbcns,err
    }
    channelclient, err := efsdk.GetChannelClient(pcq.ChannelID, pcq.UserName)
    if err != nil{
        return pbcns,err
    }
    var args []string
    args = append(args,"getresultbyquerystring")
    args=append(args,query)
    chlreq := channel.Request{
        ChaincodeID:pcq.ChaincodeID,
        Fcn:args[0],
        Args:[][]byte{[]byte(args[1])},
    }
    response, err := channelclient.Query(chlreq)
    if err != nil{
        return pbcns,err
    }
    pbcns = string(response.Payload)
    return pbcns,err
}

10.prescription.go部份代码

package clientmodel

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"`
}

7.终于写的差不多了，后边还有前端,和elasticsearch数据处理，^_^最讨厌写前端呀，改了几个ecslresmgmt.go的错误