chaincode(11.04).go

package main

import (
	"encoding/json"
    "fmt"
    "strconv"
    "strings"
    "github.com/hyperledger/fabric/tree/release-1.1/core/chaincode/shim"
    pb "github.com/hyperledger/fabric/tree/release-1.1/protos/peer"
)
type CollegeChainCode struct{	
}

//member数据结构体
type Member struct{
    MemberID string `json:MemberID`                           //帐号ID
    MemberPassword string `json:MemberPassword`               //密码
    MemberInfo PeerInfo `json:MemberInfo`                     //帐号信息
    MemberProduct []ProInfo `json:MemberProduct`              //个人产权
    MemberPermission []string `json:MemberPermission`         //个人权限
    MemberWallet int `json:MemberWallet`                      //WALLET
}

type MemberAllInfo struct{
    MemberID string `json:MemberID`
    MemberInfo PeerInfo `json:MemberInfo`
    Memberproduct []ProInfo `json:Memberproduct`
    MemberWallet int `json:MemberWallet`
}

//个人信息
type PeerInfo struct{
    MemberPetName string `json:MemberPetName`                 //昵称
    MemberSex string `json:MemberSex`                         //性别
    // FoodMFGDate string `json:FoodMFGDate`                  //出生日期
    // FoodEXPDate string `json:FoodEXPDate`                  
    MemberProfile string `json:MemberProfile`                 //个人简介
    /* 身份证和真名待定，如果要设必须只能自己可见*/                         
    MemberIDcard string `json:MemberIDcard`                   //身份证
    MemberName string `json:MemberName`                       //真名
    /*  */
    MemberDevo string `json:MemberDevo`                       //贡献度
    MemberEmail string `json:MemberEmail`                     //邮箱
}
type ProInfo struct{
    ProID string `json:ProID`                                 //产权ID
    ProName string `json:ProName`                             //产权名称
    ProSpeech string `json:ProSpeech`                         //产权内容
    ProOwnerID string `json:ProOwnerID`                       //产权拥有者
    ProPrice int `json:ProPrice`                              //产权价格
}

type ResInfo struct {                                         //返回结果信息
    Status bool `json:Status`                                 //密码true or false
    Msg string `json:Msg`                                     //信息
}

func (a *CollegeChainCode) Init(stub shim.ChaincodeStubInterface) pb.Response {
    return shim.Success(nil)
}

func (a *CollegeChainCode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    fn,args := stub.GetFunctionAndParameters()
    if fn == "addPeerInfo"{
        return a.addPeerInfo(stub,args)
    } else if fn == "addProInfo"{
        return a.addProInfo(stub,args)
    } else if fn == "getMember"{
        return a.getMember(stub,args)
    } else if fn == "getPeerInfo"{
        return a.getPeerInfo(stub,args)
    } else if fn == "getProInfo"{
        return a.getProInfo(stub,args)
    } else if fn == "transaction"{
        return a.transaction(stub,args)
    } else if fn == "checkPassword"{
        return a.checkPassword(stub,args)
    }

    return shim.Error("Recevied unkown function invocation")
}

func (a *CollegeChainCode) addPeerInfo(stub shim.ChaincodeStubInterface, args []string) pb.Response {
    var err error 
    var Members Member

    if len(args) !=8 {
        return shim.Error("Incorrect number of arguments.")
    }
    Members.MemberID = args[0]
    if Members.MemberID == ""{
        return shim.Error("MemberID can not be empty.")
    }
    
    Members.MemberInfo.MemberPetName = args[1]
    Members.MemberInfo.sex = args[2]
    Members.MemberInfo.MemberProfile = args[3]
    Members.MemberInfo.MemberIDcard = args[4]
    Members.MemberInfo.MemberName = args[5]
    Members.MemberInfo.MemberDevo = args[6]
    Members.MemberInfo.MemberEmail = args[7]
    PeerInfosJSONasBytes,err := json.Marshal(Members)
    if err != nil{
        return shim.Error(err.Error())
    }
    err = stub.PutState(Members.MemberID,PeerInfosJSONasBytes)
    if err != nil{
        return shim.Error(err.Error())
    }
    return shim.Success(nil)
}

func(a *CollegeChainCode) addProInfo(stub shim.ChaincodeStubInterface,args []string) pb.Response{
    var Members Member
    var ProInfoitem ProInfo

    if len(args) != 6{
        return shim.Error("Incorrect number of arguments")
    }

    MemberID := args[0]                                         //获得该member当前的状态
    Memberbyte, err := stub.GetState(MemberID)
    if err != nil {
        return shim.Error("Failed to get state")
    }
    if Memberbyte == nil {
        return shim.Error("Entity not found")
    }
    err = json.Unmarshal(Memberbyte, &Members)
    if err != nil {
        return shim.Error("Failed to decode JSON")
    }

    ProInfoitem.ProID = args[1]
    ProInfoitem.ProName = args[2]
    ProInfoitem.ProSpeech = args[3]
    ProInfoitem.ProOwnerID = args[4]
    X, err = strconv.Atoi(args[5])                             //string转换为int
    if err != nil {
        return shim.Error("Invalid transaction amount")
    }
    ProInfoitem.ProPrice = X
    Members.Memberproduct = append(Members.Memberproduct, ProInfoitem)

    ProInfoJsonAsBytes, err := json.Marshal(Members)
    if err != nil {
        return shim.Error(err.Error())
    }
    err = stub.PutState(Members.MemberID, ProInfoJsonAsBytes)
    if err != nil{
        return shim.Error(err.Error())
    }
    return shim.Success(nil)
}

func(a *CollegeChainCode) getMember(stub shim.ChaincodeStubInterface,args []string) pb.Response{
    if len(args) != 1{                                       //没发现调用？？？？？？？？？？？？？？？？
        return shim.Error("Incorrect number of arguments.")
    }
    MemberID := args[0]
    resultsIterator,err := stub.GetHistoryForKey(MemberID)
    if err != nil {
        return shim.Error(err.Error())
    }
    defer resultsIterator.Close()
    
    var MemberAllInfo MemberAllInfo

    for resultsIterator.HasNext(){
        var Members Member
        response,err :=resultsIterator.Next()
        if err != nil {
             return shim.Error(err.Error())
        }
        json.Unmarshal(response.Value,&Members)
        if Members.MemberInfo.MemberPetName !=""{
            MemberAllInfo.MemberInfo = Members.MemberInfo
        }else if Members.Memberproduct != nil{
            MemberAllInfo.Memberproduct = Members.Memberproduct
        }/*else if Members.Wallet.LogMission !=""{
            MemberAllInfo.Wallet = append(MemberAllInfo.Wallet,Members.Wallet)*/
        }

    }
    
    jsonsAsBytes,err := json.Marshal(MemberAllInfo)
    if err != nil{
        return shim.Error(err.Error())
    }

    return shim.Success(jsonsAsBytes)
}
 

func(a *CollegeChainCode) getPeerInfo(stub shim.ChaincodeStubInterface,args []string) pb.Response{
    /*？*/
    if len(args) != 1{
        return shim.Error("Incorrect number of arguments.")
    }
    MemberID := args[0]
    resultsIterator,err := stub.GetHistoryForKey(MemberID)
    if err != nil {
        return shim.Error(err.Error())
    }
    defer resultsIterator.Close()
    
    var MemberInfo PeerInfo

    for resultsIterator.HasNext(){
        var Members Member
        response,err :=resultsIterator.Next()
        if err != nil {
            return shim.Error(err.Error())
        }
        json.Unmarshal(response.Value,&Members)
        if Members.MemberInfo.MemberPetName != ""{
            MemberInfo = Members.MemberInfo
            continue
        }
    }
    jsonsAsBytes,err := json.Marshal(MemberInfo)   
    if err != nil {
        return shim.Error(err.Error())
    }
    return shim.Success(jsonsAsBytes)
}

func(a *CollegeChainCode) getProInfo(stub shim.ChaincodeStubInterface,args []string) pb.Response{
 
    if len(args) !=1{
        return shim.Error("Incorrect number of arguments.")
    }
    MemberID := args[0]
    resultsIterator,err := stub.GetHistoryForKey(MemberID)

    if err != nil{
        return shim.Error(err.Error())
    }
    defer resultsIterator.Close()
    
    var Memberproduct []ProInfo
    for resultsIterator.HasNext(){
        var Members Member
        response,err := resultsIterator.Next()
        if err != nil{
            return shim.Error(err.Error())
        }
        json.Unmarshal(response.Value,&Members)
        if Members.Memberproduct != nil{
            Memberproduct = Members.Memberproduct
            continue
        }
    }
    jsonsAsBytes,err := json.Marshal(Memberproduct)
    if err != nil{
        return shim.Error(err.Error())
    }
    return shim.Success(jsonsAsBytes)
}

func(a *CollegeChainCode) transaction(stub shim.ChaincodeStubInterface,args []string) pb.Response{
    var Buyer, Owner string                            //买家与卖家的ID
    var Pro string                                     //产品的ID
    var Bwallet, Owallet int                           //买家钱包余额与卖家钱包余额
    var Price int                                      //产品价格
    var err error

    if len(args) != 2 {
        return shim.Error("Incorrect number of arguments. Expecting function followed by 2 names")
    }

    Buyer = args[0]
    Pro = args[1]
    //获得卖主ID与产品价格
    Probyte, err := stub.GetState(Pro)
    if err != nil {
        return shim.Error("Failed to get state")
    }
    if Probyte == nil {
        return shim.Error("Entity not found")
    }
    var ProSelled ProInfo
    err = json.Unmarshal(Probyte, &ProSelled)           //反序列化
    if err != nil {
        return shim.Error("Failed to decode JSON")
    }
    Owner = ProSelled.ProOwnerID
    Price = ProSelled.ProPrice
    //获得买主余额
    Buyerbytes, err := stub.GetState(Buyer)
    if err != nil {
        return shim.Error("Failed to get state")
    }
    if Buyerbytes == nil {
        return shim.Error("Entity not found")
    }
    var BuyerInfo MemberInfo
    err = json.Unmarshal(Buyerbytes, &BuyerInfo)
    if err != nil {
        return shim.Error("Failed to decode JSON")
    }
    Bwallet = BuyerInfo.MemberWallet
    //获取卖主余额
    Ownerbytes, err := stub.GetState(Owner)
    if err != nil {
        return shim.Error("Failed to get state")
    }
    if Ownerbytes == nil {
        return shim.Error("Entity not found")
    }
    var OwnerInfo MemberInfo
    err = json.Unmarshal(Ownerbytes, &OwnerInfo)
    if err != nil {
        return shim.Error("Failed to decode JSON")
    }
    Owallet = OwnerInfo.MemberWallet

    if Bwallet < Price {
        return shim.Error("Do not have enough money")
    }
    //余额转移计算
    Bwallet = Bwallet - Price
    Owallet = Owallet + Price
    BuyerInfo.MemberPermission = append(BuyerInfo.MemberPermission, Pro)
    BuyerInfo.MemberWallet = Bwallet
    OwnerInfo.MemberWallet = Owallet

    // 将改变后的值写入状态数据库中
    BuyerInfoJSONasBytes, err := json.Marshal(BuyerInfo)
    if err != nil{
        return shim.Error(err.Error())
    }
    err = stub.PutState(BuyerInfo.MemberID, BuyerInfoJSONasBytes)
    if err != nil {
        return shim.Error(err.Error())
    }

    OwnerInfoJSONasBytes, err := json.Marshal(OwnerInfo)
    if err != nil{
        return shim.Error(err.Error())
    }
    err = stub.PutState(OwnerInfo.MemberID, OwnerInfoJSONasBytes)
    if err != nil {
        return shim.Error(err.Error())
    }

    return shim.Success(nil)
}

func (t *ResInfo) No(msg string) {
    t.Status = false
    t.Msg = msg
}

func (t *ResInfo) Ok(msg string) {
    t.Status = true
    t.Msg = msg
}

func (t *ResInfo) result() pb.Response {
    resJson, err := json.Marshal(t)
    if err != nil {
        return shim.Error(err.Error())
    }
    return shim.Success(resJson)
}

func (a *CollegeChainCode) checkPassword(stub shim.ChaincodeStubInterface, args []string) pb.Response {
    res := &ResInfo{false, ""}
    if len(args) != 2 {
        return shim.Error("Incorrect number of arguments. Expecting function followed by a name and a password")
    }
    MemberID = args[0]
    Password = args[1]
    //获取用户真实密码
    MemberInfobytes, err := stub.GetState(MemberID)
    if err != nil {
        return shim.Error("Failed to get state")
    }
    if Buyerbytes == nil {
        return shim.Error("Member is not exists")                         //检查用户名是否存在
    }
    var MemberInfos MemberInfo
    err = json.Unmarshal(MemberInfobytes, &MemberInfos)
    if err != nil {
        return shim.Error("Failed to decode JSON")
    }
    Password_True = MemberInfos.MemberPassword
    //比较输入密码与真实密码
    if strings.Compare(Password, Password_True) == 0 {
        res.Ok("")
    }
    else{
        res.No("The password is wrong")
    }
    return res.result()
}

func main(){
     err := shim.Start(new(CollegeChainCode))
     if err != nil {
         fmt.Printf("Error starting cool chaincode: %s ",err)
     }
}