github.com/s7techlab/cckit@v0.10.5/examples/insurance/app/invoke_repairshop.go (about)

     1  package app
     2  
     3  import "github.com/hyperledger/fabric-chaincode-go/shim"
     4  import (
     5  	"encoding/json"
     6  
     7  	pb "github.com/hyperledger/fabric-protos-go/peer"
     8  )
     9  
    10  func listRepairOrders(stub shim.ChaincodeStubInterface, args []string) pb.Response {
    11  	resultsIterator, err := stub.GetStateByPartialCompositeKey(prefixRepairOrder, []string{})
    12  	if err != nil {
    13  		return shim.Error(err.Error())
    14  	}
    15  	defer resultsIterator.Close()
    16  
    17  	results := []interface{}{}
    18  	for resultsIterator.HasNext() {
    19  		kvResult, err := resultsIterator.Next()
    20  		if err != nil {
    21  			return shim.Error(err.Error())
    22  		}
    23  
    24  		repairOrder := RepairOrder{}
    25  		err = json.Unmarshal(kvResult.Value, &repairOrder)
    26  		if err != nil {
    27  			return shim.Error(err.Error())
    28  		}
    29  		if repairOrder.Ready {
    30  			continue
    31  		}
    32  
    33  		result := struct {
    34  			UUID         string `json:"uuid"`
    35  			ClaimUUID    string `json:"claim_uuid"`
    36  			ContractUUID string `json:"contract_uuid"`
    37  			Item         Item   `json:"item"`
    38  		}{}
    39  		err = json.Unmarshal(kvResult.Value, &result)
    40  		if err != nil {
    41  			return shim.Error(err.Error())
    42  		}
    43  		prefix, keyParts, err := stub.SplitCompositeKey(kvResult.Key)
    44  		if err != nil {
    45  			return shim.Error(err.Error())
    46  		}
    47  		if len(keyParts) == 0 {
    48  			result.UUID = prefix
    49  		} else {
    50  			result.UUID = keyParts[0]
    51  		}
    52  		results = append(results, result)
    53  	}
    54  
    55  	resultsAsBytes, err := json.Marshal(results)
    56  	if err != nil {
    57  		return shim.Error(err.Error())
    58  	}
    59  	return shim.Success(resultsAsBytes)
    60  }
    61  
    62  func completeRepairOrder(stub shim.ChaincodeStubInterface, args []string) pb.Response {
    63  	if len(args) != 1 {
    64  		return shim.Error("Invalid argument count.")
    65  	}
    66  
    67  	input := struct {
    68  		UUID string `json:"uuid"`
    69  	}{}
    70  	err := json.Unmarshal([]byte(args[0]), &input)
    71  	if err != nil {
    72  		return shim.Error(err.Error())
    73  	}
    74  
    75  	repairOrderKey, err := stub.CreateCompositeKey(prefixRepairOrder, []string{input.UUID})
    76  	if err != nil {
    77  		return shim.Error(err.Error())
    78  	}
    79  
    80  	repairOrderBytes, _ := stub.GetState(repairOrderKey)
    81  	if len(repairOrderBytes) == 0 {
    82  		return shim.Error("Could not find the repair order")
    83  	}
    84  
    85  	repairOrder := RepairOrder{}
    86  	err = json.Unmarshal(repairOrderBytes, &repairOrder)
    87  	if err != nil {
    88  		return shim.Error(err.Error())
    89  	}
    90  
    91  	// Marking repair order as ready
    92  	repairOrder.Ready = true
    93  
    94  	repairOrderBytes, err = json.Marshal(repairOrder)
    95  	if err != nil {
    96  		return shim.Error(err.Error())
    97  	}
    98  	err = stub.PutState(repairOrderKey, repairOrderBytes)
    99  	if err != nil {
   100  		return shim.Error(err.Error())
   101  	}
   102  
   103  	// Reflect changes in the corresponding claim
   104  	claimKey, err := stub.CreateCompositeKey(prefixClaim, []string{repairOrder.ContractUUID, repairOrder.ClaimUUID})
   105  	if err != nil {
   106  		return shim.Error(err.Error())
   107  	}
   108  	claimBytes, _ := stub.GetState(claimKey)
   109  	if claimBytes != nil {
   110  		claim := Claim{}
   111  		err := json.Unmarshal(claimBytes, &claim)
   112  		if err != nil {
   113  			return shim.Error(err.Error())
   114  		}
   115  
   116  		claim.Repaired = true
   117  		claimBytes, err = json.Marshal(claim)
   118  		if err != nil {
   119  			return shim.Error(err.Error())
   120  		}
   121  
   122  		err = stub.PutState(claimKey, claimBytes)
   123  		if err != nil {
   124  			return shim.Error(err.Error())
   125  		}
   126  	}
   127  
   128  	return shim.Success(nil)
   129  }