我想通过使用 MSPID 为不同组织创建访问权限

一分耕耘，一分收获！既然打开了这篇文章《我想通过使用 MSPID 为不同组织创建访问权限》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

我的想法是使用 mspid。所以我会获取组织的 mspid，如果它是错误的 mspid，那么它将返回一条错误消息，如果它是正确的 mspid，则继续。在我的代码中，我只在deleteasset函数中执行此操作，但我想在createasset、updateasset、transferasset和deleteasset函数中执行此操作。

问题是，当我在命令行上使用 createasset 函数时，它给出了这个错误：

对等链代码调用“${target_tls_options[@]}”-c mychannel -n basic -c '{"function":"createasset","args":["asset1","andrew faure", "20","无","o+","青霉素","无","家庭医生","腿骨折","10/05/2022"]}' 错误：调用期间背书失败。响应：状态：500消息：“模拟错误：无法执行事务9446e0c320832b92f06ea56f577a29e9a5ec94c276329cb1d31bb8a85581138d：无法启动链码basic_1.0：605aa3a69a8107c9c7b5fc2207255423 5d3ea827b0eefbffae29f0c9998bf0e6：链码注册失败：容器退出时显示 2"

没有 mspid，系统可以正常工作。但是，我需要 mspid 才能创建对组织的访问权限。

我是 hyperledger 和 go 语言的新手。如果有人能提供帮助，我将非常感激

package chaincode

import (

"encoding/json"
"fmt"
"github.com/hyperledger/fabric-chaincode-go/pkg/cid"
"github.com/hyperledger/fabric-chaincode-go/shim"
"github.com/hyperledger/fabric-contract-api-go/contractapi"
)

 // SmartContract provides functions for managing an Asset
 type SmartContract struct {
     contractapi.Contract

 }
 type Asset struct {
      ID                             string `json:"ID"`
      Owner                          string `json:"Owner"`
      Age                            int    `json:"Age"`
      MedicalFamilyHistory           string `json:"MedicalFamilyHistory"`
      BloodType                      string `json:"BloodType"`
      Allergies                      string `json:"Allergies"`
      Medication                     string `json:"Medication"`
      DataSharedWith                 string `json:"DataSharedWith"`
      CurrentIssue             string `json:"CurrentIssue"`
      Date                     string `json:"Date"`
  }
func (s *SmartContract) CreateAsset(ctx contractapi.TransactionContextInterface, id 
      string, owner string, age int, medicalFamilyHistory string, bloodType string, 
      allergies string, medication string, dataSharedWith string, currentIssue 
      string, date string) error {
exists, err := s.AssetExists(ctx, id)
if err != nil {
    return err
}
if exists {
    return fmt.Errorf("the asset %s already exists", id)
}

asset := Asset{
    ID:                     id,
    Owner:                  owner,
    Age:                    age,
    MedicalFamilyHistory:   medicalFamilyHistory,
    BloodType:              bloodType,
    Allergies:              allergies,
    Medication:             medication,
    DataSharedWith:         dataSharedWith,  
    CurrentIssue:       currentIssue,
    Date:           date,
}
assetJSON, err := json.Marshal(asset)
if err != nil {
    return err
}

return ctx.GetStub().PutState(id, assetJSON)
}
func (s *SmartContract) ReadAsset(ctx contractapi.TransactionContextInterface, id 
  string) (*Asset, error) {
    assetJSON, err := ctx.GetStub().GetState(id)
    if err != nil {
        return nil, fmt.Errorf("failed to read from world state: %v", err)
    }
    if assetJSON == nil {
        return nil, fmt.Errorf("the asset %s does not exist", id)
    }

    var asset Asset
    err = json.Unmarshal(assetJSON, &asset)
    if err != nil {
        return nil, err
    }

    return &asset, nil
}
func (s *SmartContract) UpdateAsset(ctx contractapi.TransactionContextInterface, id 
string, owner string, age int, medicalFamilyHistory string, bloodType string, 
allergies string, medication string, dataSharedWith string, currentIssue string, date 
string) error {
    exists, err := s.AssetExists(ctx, id)
    if err != nil {
        return err
    }
    if !exists {
        return fmt.Errorf("the asset %s does not exist", id)
    }

    // overwriting original asset with new asset
    asset := Asset{
        ID:                     id,
        Owner:                  owner,
        Age:                    age,
        MedicalFamilyHistory:   medicalFamilyHistory,
        BloodType:              bloodType,
        Allergies:              allergies,
        Medication:             medication,
        DataSharedWith:         dataSharedWith, 
        CurrentIssue:       currentIssue,
        Date:           date,
    }
    assetJSON, err := json.Marshal(asset)
    if err != nil {
        return err
    }

    return ctx.GetStub().PutState(id, assetJSON)
}
func (s *SmartContract) DeleteAsset(ctx contractapi.TransactionContextInterface, stub 
shim.ChaincodeStubInterface, id string) error {
    msp, err := s.GetMSPID(stub)
    if err != nil {
        return err
    }

    // The error is with "Org1MSP" becuase I found out that mspid is Org1MSP
    if msp != "org1MSP" {
        return fmt.Errorf("Wrong Organisation, this organisation does not have access 
                          to this function")
    }
    
    exists, err := s.AssetExists(ctx, id)
    if err != nil {
        return err
    }

    if !exists {
        return fmt.Errorf("the asset %s does not exist", id)
    }

    return ctx.GetStub().DelState(id)
}
func (s *SmartContract) AssetExists(ctx contractapi.TransactionContextInterface, id 
 string) (bool, error) {
    assetJSON, err := ctx.GetStub().GetState(id)
    if err != nil {
        return false, fmt.Errorf("failed to read from world state: %v", err)
    }

    return assetJSON != nil, nil
}
func (s *SmartContract) TransferAsset(ctx contractapi.TransactionContextInterface, id 
  string, newOwner string) (string, error) {
    
    asset, err := s.ReadAsset(ctx, id)
    if err != nil {
        return "", err
    }

    oldOwner := asset.Owner
    asset.Owner = newOwner

    assetJSON, err := json.Marshal(asset)
    if err != nil {
        return "", err
    }

    err = ctx.GetStub().PutState(id, assetJSON)
    if err != nil {
        return "", err
    }

    return oldOwner, nil
}

func (s *SmartContract) GetAllAssets(ctx contractapi.TransactionContextInterface) 
([]*Asset, error) {
    // range query with empty string for startKey and endKey does an
    // open-ended query of all assets in the chaincode namespace.
    resultsIterator, err := ctx.GetStub().GetStateByRange("", "")
    if err != nil {
        return nil, err
    }
    defer resultsIterator.Close()

    var assets []*Asset
    for resultsIterator.HasNext() {
        queryResponse, err := resultsIterator.Next()
        if err != nil {
            return nil, err
        }

        var asset Asset
        err = json.Unmarshal(queryResponse.Value, &asset)
        if err != nil {
            return nil, err
        }
        assets = append(assets, &asset)
    }

    return assets, nil
}

func (s *SmartContract) GetMSPID(stub shim.ChaincodeStubInterface) (string, error) {
// Get the Client ID object
    clientId, err := cid.New(stub)
    if err != nil {
    // Handle error
    }
    
    mspid, err := clientId.GetMSPID()
    if err != nil {
       // Handle error
    }
    

    
//  mspId, err := cid.GetMSPID(stub)
//  if err != nil {
//      return err
//  }
    // The error is with "Org1MSP" becuase I found out that mspid is Org1MSP
//  if mspId != "Org1MSP" {
//      return fmt.Errorf(mspId)
//  }
    return mspid, nil

}

正确答案

请查看下面的结构示例链代码。在这个智能合约中，他们正在验证 MSPID。

此处为https://github.com/hyperledger/fabric-samples/blob/main/asset-transfer-private-data/chaincode-go/chaincode/asset_transfer.go[![enter图像描述]1]1

到这里，我们也就讲完了《我想通过使用 MSPID 为不同组织创建访问权限》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！