/**
* Should allow us to query the value of the protected strings in the ledger
* Args:
* 0 strkey: The key under which the protected string is stored
*/
func (t *SimpleChaincode) getstring(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var strkey string // The key associated with the string we want to find
var strvalBytes []byte // The actual value of the string
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 1")
}
// Which string do we want?
strkey = args[0]
// Get the value of the string from the ledger
strvalBytes, err := stub.GetState(strkey)
if err != nil {
jsonResp := "{\"Error\": \"Failed to get state for " + strkey + "\"}"
return nil, errors.New(jsonResp)
}
if strvalBytes == nil {
jsonResp := "{\"Error\":\"Nil amount for " + strkey + "\"}"
return nil, errors.New(jsonResp)
}
jsonResp := "{\"StringKey\":\"" + strkey + "\", \"Value\":\"" + string(strvalBytes) + "\"}"
fmt.Printf("Query Response:%s\n", jsonResp)
return strvalBytes, nil
}
func GetAllCPs(stub *shim.ChaincodeStub) ([]CP, error) {
var allCPs []CP
// Get list of all the keys
keysBytes, err := stub.GetState("PaperKeys")
if err != nil {
fmt.Println("Error retrieving paper keys")
return nil, errors.New("Error retrieving paper keys")
}
var keys []string
err = json.Unmarshal(keysBytes, &keys)
if err != nil {
fmt.Println("Error unmarshalling paper keys")
return nil, errors.New("Error unmarshalling paper keys")
}
// Get all the cps
for _, value := range keys {
cpBytes, err := stub.GetState(value)
var cp CP
err = json.Unmarshal(cpBytes, &cp)
if err != nil {
fmt.Println("Error retrieving cp " + value)
return nil, errors.New("Error retrieving cp " + value)
}
fmt.Println("Appending CP" + value)
allCPs = append(allCPs, cp)
}
return allCPs, nil
}
func (t *Vehicle) update_registration(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
regBytes, err := stub.GetState("Reg")
reg := string(regBytes)
if err != nil {
return nil, errors.New("Failed to get state")
}
statusBytes, err := stub.GetState("Status")
status, err := strconv.Atoi(string(statusBytes))
if err != nil {
return nil, errors.New("Failed to get state")
}
if status == 1 || status == 2 {
reg = args[0]
} else {
return nil, errors.New("Permission denied")
}
err = stub.PutState("Reg", []byte(reg))
return nil, nil
}
// Query callback representing the query of a chaincode
func (t *SimpleChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
if function != "query" {
return nil, errors.New("Invalid query function name. Expecting \"query\"")
}
var A string // Entities
var err error
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting name of the person to query")
}
A = args[0]
// Get the state from the ledger
Avalbytes, err := stub.GetState(A)
if err != nil {
jsonResp := "{\"Error\":\"Failed to get state for " + A + "\"}"
return nil, errors.New(jsonResp)
}
if Avalbytes == nil {
jsonResp := "{\"Error\":\"Nil amount for " + A + "\"}"
return nil, errors.New(jsonResp)
}
jsonResp := "{\"Name\":\"" + A + "\",\"Amount\":\"" + string(Avalbytes) + "\"}"
fmt.Printf("Query Response:%s\n", jsonResp)
return Avalbytes, nil
}
// ============================================================================================================================
// findMarble4Trade - look for a matching marble that this user owns and return it
// ============================================================================================================================
func findMarble4Trade(stub *shim.ChaincodeStub, user string, color string, size int) (m Marble, err error) {
var fail Marble
fmt.Println("- start find marble 4 trade")
fmt.Println("looking for " + user + ", " + color + ", " + strconv.Itoa(size))
//get the marble index
marblesAsBytes, err := stub.GetState(marbleIndexStr)
if err != nil {
return fail, errors.New("Failed to get marble index")
}
var marbleIndex []string
json.Unmarshal(marblesAsBytes, &marbleIndex) //un stringify it aka JSON.parse()
for i := range marbleIndex { //iter through all the marbles
//fmt.Println("looking @ marble name: " + marbleIndex[i]);
marbleAsBytes, err := stub.GetState(marbleIndex[i]) //grab this marble
if err != nil {
return fail, errors.New("Failed to get marble")
}
res := Marble{}
json.Unmarshal(marbleAsBytes, &res) //un stringify it aka JSON.parse()
//fmt.Println("looking @ " + res.User + ", " + res.Color + ", " + strconv.Itoa(res.Size));
//check for user && color && size
if strings.ToLower(res.User) == strings.ToLower(user) && strings.ToLower(res.Color) == strings.ToLower(color) && res.Size == size {
fmt.Println("found a marble: " + res.Name)
fmt.Println("! end find marble 4 trade")
return res, nil
}
}
fmt.Println("- end find marble 4 trade - error")
return fail, errors.New("Did not find marble to use in this trade")
}
func (t *SimpleChaincode) transfer(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var v Vehicle
var err error
var bytes []byte
bytes, err = stub.GetState(args[0])
if err != nil {
return nil, errors.New("Error retrieving vehicle with v5cID = " + args[0])
}
err = json.Unmarshal(bytes, &v)
if err != nil {
return nil, errors.New("Corrupt vehicle record")
}
v.Owner = args[1]
bytes, err = json.Marshal(v)
if err != nil {
return nil, errors.New("Error creating vehicle record")
}
err = stub.PutState(v.V5cID, bytes)
if err != nil {
return nil, err
}
return nil, nil
}
// ============================================================================================================================
// Set User Permission on Marble
// ============================================================================================================================
func (t *SimpleChaincode) set_user(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var err error
// 0 1
// "name", "bob"
if len(args) < 2 {
return nil, errors.New("Incorrect number of arguments. Expecting 2")
}
fmt.Println("- start set user")
fmt.Println(args[0] + " - " + args[1])
marbleAsBytes, err := stub.GetState(args[0])
if err != nil {
return nil, errors.New("Failed to get thing")
}
res := Marble{}
json.Unmarshal(marbleAsBytes, &res) //un stringify it aka JSON.parse()
res.User = args[1] //change the user
jsonAsBytes, _ := json.Marshal(res)
err = stub.PutState(args[0], jsonAsBytes) //rewrite the marble with id as key
if err != nil {
return nil, err
}
fmt.Println("- end set user")
return nil, nil
}
// ============================================================================================================================
// Delete - remove a key/value pair from state
// ============================================================================================================================
func (t *SimpleChaincode) Delete(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 1")
}
name := args[0]
err := stub.DelState(name) //remove the key from chaincode state
if err != nil {
return nil, errors.New("Failed to delete state")
}
//get the marble index
marblesAsBytes, err := stub.GetState(marbleIndexStr)
if err != nil {
return nil, errors.New("Failed to get marble index")
}
var marbleIndex []string
json.Unmarshal(marblesAsBytes, &marbleIndex) //un stringify it aka JSON.parse()
//remove marble from index
for i, val := range marbleIndex {
fmt.Println(strconv.Itoa(i) + " - looking at " + val + " for " + name)
if val == name { //find the correct marble
fmt.Println("found marble")
marbleIndex = append(marbleIndex[:i], marbleIndex[i+1:]...) //remove it
for x := range marbleIndex { //debug prints...
fmt.Println(string(x) + " - " + marbleIndex[x])
}
break
}
}
jsonAsBytes, _ := json.Marshal(marbleIndex) //save new index
err = stub.PutState(marbleIndexStr, jsonAsBytes)
return nil, nil
}
// ============================================================================================================================
// Set User Permissions
// ============================================================================================================================
func (t *SimpleChaincode) set_user_perms(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var err error
carAsBytes, err := stub.GetState(args[0])
if err != nil {
return nil, errors.New("Failed to get car profile")
}
res := Car{}
json.Unmarshal(carAsBytes, &res)
fmt.Println(res)
for i, perm := range res.Users {
if perm.UserId == args[1] { //find the correct user
res.Users[i].Permissions[0] = args[2] //set new perm, dsh - to do make this input as array of all perms
fmt.Println(res.Users[i].Permissions)
break
}
}
// Write the state back to the ledger
jsonAsBytes, _ := json.Marshal(res)
err = stub.PutState(args[0], jsonAsBytes)
if err != nil {
return nil, err
}
return nil, nil
}
/**
* Should allow us to query the value of the protected strings in the ledger
* Args:
* stub: The blockchain that holds the string we're want.
* strkey: The key under which the string is stored.
*/
func (t *SimpleChaincode) getstring(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var strkey string
var strvalBytes []byte // The actual value of the string
if(len(args) != 1) {
return nil, errors.New("Incorrect number of arguments. Expecting 1");
}
// Which string do we want?
strkey = args[0];
// Get the value of the string from the ledger
strvalBytes, err := stub.GetState(strkey)
if err != nil {
jsonResp := "{\"Error\": \"Failed to get state for " + strkey + "\"}"
return nil, errors.New(jsonResp)
}
if strvalBytes == nil {
jsonResp := "{\"Error\":\"Nil amount for " + strkey + "\"}"
return nil, errors.New(jsonResp)
}
// Add quotes to the string or it will cause an invalid json to be created.
strvalBytes = []byte(fmt.Sprintf("\"%s\"", string(strvalBytes)))
jsonResp := "{\"StringKey\":\"" + strkey + "\",\"Value\":\"" + string(strvalBytes) + "\"}"
fmt.Printf("Query Response:%s\n", jsonResp)
return strvalBytes, nil
}
func (t *Vehicle) update_colour(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
colourBytes, err := stub.GetState("Colour")
colour := string(colourBytes)
if err != nil {
return nil, errors.New("Failed to get state")
}
statusBytes, err := stub.GetState("Status")
status, err := strconv.Atoi(string(statusBytes))
if err != nil {
return nil, errors.New("Failed to get state")
}
if status == 1 || status == 2 {
colour = args[0]
} else {
return nil, errors.New("Permission denied")
}
err = stub.PutState("Colour", []byte(colour))
return nil, nil
}
// Query callback representing the query of a chaincode
func (t *systemChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
if function != "query" {
return nil, errors.New("Invalid query function name. Expecting \"query\"")
}
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 1")
}
key := args[0]
if key != system_validity_period_key {
return nil, errors.New("Incorrect key. Expecting " + system_validity_period_key)
}
// Get the state from the ledger
vp, err := stub.GetState(key)
if err != nil {
jsonResp := "{\"Error\":\"Failed to get state for " + key + "\"}"
return nil, errors.New(jsonResp)
}
if vp == nil {
jsonResp := "{\"Error\":\"Nil value for " + key + "\"}"
return nil, errors.New(jsonResp)
}
jsonResp := "{\"Name\":\"" + key + "\",\"Value\":\"" + string(vp) + "\"}"
fmt.Printf("Query Response:%s\n", jsonResp)
return []byte(jsonResp), nil
}
func (t *Vehicle) get_attribute(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
state, err := stub.GetState(args[0])
if err != nil {
return nil, errors.New("Failed to get state")
}
jsonResp := "{\"" + args[0] + "\":\"" + string(state) + "\"}"
fmt.Printf("Query Response:%s\n", jsonResp)
return []byte(jsonResp), nil
}
// ============================================================================================================================
// Init Marble - create a new marble, store into chaincode state
// ============================================================================================================================
func (t *SimpleChaincode) init_marble(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var err error
// 0 1 2 3
// "asdf", "blue", "35", "bob"
if len(args) != 4 {
return nil, errors.New("Incorrect number of arguments. Expecting 4")
}
fmt.Println("- start init marble")
if len(args[0]) <= 0 {
return nil, errors.New("1st argument must be a non-empty string")
}
if len(args[1]) <= 0 {
return nil, errors.New("2nd argument must be a non-empty string")
}
if len(args[2]) <= 0 {
return nil, errors.New("3rd argument must be a non-empty string")
}
if len(args[3]) <= 0 {
return nil, errors.New("4th argument must be a non-empty string")
}
size, err := strconv.Atoi(args[2])
if err != nil {
return nil, errors.New("3rd argument must be a numeric string")
}
color := strings.ToLower(args[1])
user := strings.ToLower(args[3])
str := `{"name": "` + args[0] + `", "color": "` + color + `", "size": ` + strconv.Itoa(size) + `, "user": "******"}`
err = stub.PutState(args[0], []byte(str)) //store marble with id as key
if err != nil {
return nil, err
}
//get the marble index
marblesAsBytes, err := stub.GetState(marbleIndexStr)
if err != nil {
return nil, errors.New("Failed to get marble index")
}
var marbleIndex []string
json.Unmarshal(marblesAsBytes, &marbleIndex) //un stringify it aka JSON.parse()
//append
marbleIndex = append(marbleIndex, args[0]) //add marble name to index list
fmt.Println("! marble index: ", marbleIndex)
jsonAsBytes, _ := json.Marshal(marbleIndex)
err = stub.PutState(marbleIndexStr, jsonAsBytes) //store name of marble
fmt.Println("- end init marble")
return nil, nil
}
// Transaction makes payment of X units from A to B
func (t *SimpleChaincode) invoke(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var A, B string // Entities
var Aval, Bval int // Asset holdings
var X int // Transaction value
var err error
if len(args) != 3 {
return nil, errors.New("Incorrect number of arguments. Expecting 3")
}
A = args[0]
B = args[1]
// Get the state from the ledger
// TODO: will be nice to have a GetAllState call to ledger
Avalbytes, err := stub.GetState(A)
if err != nil {
return nil, errors.New("Failed to get state")
}
if Avalbytes == nil {
return nil, errors.New("Entity not found")
}
Aval, _ = strconv.Atoi(string(Avalbytes))
Bvalbytes, err := stub.GetState(B)
if err != nil {
return nil, errors.New("Failed to get state")
}
if Avalbytes == nil {
return nil, errors.New("Entity not found")
}
Bval, _ = strconv.Atoi(string(Bvalbytes))
// Perform the execution
X, err = strconv.Atoi(args[2])
Aval = Aval - X
Bval = Bval + X
fmt.Printf("Aval = %d, Bval = %d\n", Aval, Bval)
// Write the state back to the ledger
err = stub.PutState(A, []byte(strconv.Itoa(Aval)))
if err != nil {
return nil, err
}
err = stub.PutState(B, []byte(strconv.Itoa(Bval)))
if err != nil {
return nil, err
}
return nil, nil
}
// ============================================================================================================================
// Get Permissions - get permissions form the car profile
// ============================================================================================================================
func (t *SimpleChaincode) get_permissions(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var err error
carAsBytes, err := stub.GetState(args[0])
if err != nil {
return nil, errors.New("Failed to get car profile")
}
res := Car{}
json.Unmarshal(carAsBytes, &res)
fmt.Println(res)
jsonAsBytes, _ := json.Marshal(res.Users)
return jsonAsBytes, nil
}
// ============================================================================================================================
// Read Names return list of variables in state space
// ============================================================================================================================
func (t *SimpleChaincode) ReadNames(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var err error
var ben = "_ben_knows"
var storedNames string
storedNamesAsBytes, err := stub.GetState(ben)
if err != nil {
return nil, errors.New("Failed to get ben")
}
storedNames = string(storedNamesAsBytes)
fmt.Println(storedNames)
return storedNamesAsBytes, nil
}
func getMortgageStateFull(stub *shim.ChaincodeStub) (map[string]interface{}, error) {
// Get mortgage state from ledger
fmt.Printf("Reading mortgage state from shared ledger...\n")
var state map[string]interface{}
key := "myMortgageState"
bytes, err := stub.GetState(key)
if err != nil || bytes == nil {
return nil, myError("No mortage state in ledger")
}
err = json.Unmarshal(bytes, &state)
if err != nil {
return nil, myError("Cannot unmarshal mortage state")
}
return state, nil
}
func GetCompany(companyID string, stub *shim.ChaincodeStub) (Account, error) {
var company Account
companyBytes, err := stub.GetState(accountPrefix + companyID)
if err != nil {
fmt.Println("Account not found " + companyID)
return company, errors.New("Account not found " + companyID)
}
err = json.Unmarshal(companyBytes, &company)
if err != nil {
fmt.Println("Error unmarshalling account " + companyID)
return company, errors.New("Error unmarshalling account " + companyID)
}
return company, nil
}
// ============================================================================================================================
// Remember Me - remember the name of variables we stored in ledger
// ============================================================================================================================
func (t *SimpleChaincode) remember_me(stub *shim.ChaincodeStub, name string) ([]byte, error) { //dsh - to do, should probably not exist here, move to stub
var err error
var ben = "_ben_knows"
var storedNames string
storeNamesAsBytes, err := stub.GetState(ben)
if err != nil {
return nil, errors.New("Failed to get ben")
}
storedNames = string(storeNamesAsBytes)
// Write the state back to the ledger
err = stub.PutState(ben, []byte(storedNames+","+name)) //dsh - to do, should probably be json
if err != nil {
return nil, err
}
return nil, nil
}
// ============================================================================================================================
// Read - read a variable from chaincode state
// ============================================================================================================================
func (t *SimpleChaincode) read(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var name, jsonResp string
var err error
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting name of the var to query")
}
name = args[0]
valAsbytes, err := stub.GetState(name) //get the var from chaincode state
if err != nil {
jsonResp = "{\"Error\":\"Failed to get state for " + name + "\"}"
return nil, errors.New(jsonResp)
}
return valAsbytes, nil //send it onward
}
func GetCP(cpid string, stub *shim.ChaincodeStub) (CP, error) {
var cp CP
cpBytes, err := stub.GetState(cpid)
if err != nil {
fmt.Println("Error retrieving cp " + cpid)
return cp, errors.New("Error retrieving cp " + cpid)
}
err = json.Unmarshal(cpBytes, &cp)
if err != nil {
fmt.Println("Error unmarshalling cp " + cpid)
return cp, errors.New("Error unmarshalling cp " + cpid)
}
return cp, nil
}
func (t *SimpleChaincode) Read(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var err error
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting name")
}
// Get the state from the ledger
Avalbytes, err := stub.GetState(args[0])
if err != nil {
jsonResp := "{\"Error\":\"Failed to get state for " + args[0] + "\"}"
return nil, errors.New(jsonResp)
}
strResp := `"` + string(Avalbytes) + `"`
return []byte(strResp), nil
}
func (t *SimpleChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
//need one arg
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 'v5cID'")
}
var err error
bytes, err := stub.GetState(args[0])
if err != nil {
return nil, errors.New("Error retrieving vehicle with v5cID = " + args[0])
}
fmt.Printf("Found vehicle bytes:%d\n", len(bytes))
fmt.Printf("Found vehicle:\n%s\n", string(bytes))
return bytes, nil
}
//==============================================================================================================================
// retrieve_v5c - Gets the state of the data at v5cID in the ledger then converts it from the stored
// JSON into the Vehicle struct for use in the contract. Returns the Vehcile struct.
// Returns empty v if it errors.
//==============================================================================================================================
func (t *Chaincode) retrieve_v5c(stub *shim.ChaincodeStub, v5cID string) (Vehicle, error) {
var v Vehicle
bytes, err := stub.GetState(v5cID)
if err != nil {
return v, errors.New("Error retrieving vehicle with v5cID = " + v5cID)
}
err = json.Unmarshal(bytes, &v)
if err != nil {
return v, errors.New("Corrupt vehicle record")
}
return v, nil
}
// Query callback representing the query of a chaincode
func (t *SimpleChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
switch function {
case "get":
if len(args) < 1 {
return nil, errors.New("get operation must include one argument, a key")
}
key := args[0]
value, err := stub.GetState(key)
if err != nil {
return nil, fmt.Errorf("get operation failed. Error accessing state: %s", err)
}
return value, nil
case "keys":
keysIter, err := stub.RangeQueryState("", "")
if err != nil {
return nil, fmt.Errorf("keys operation failed. Error accessing state: %s", err)
}
defer keysIter.Close()
var keys []string
for keysIter.HasNext() {
key, _, err := keysIter.Next()
if err != nil {
return nil, fmt.Errorf("keys operation failed. Error accessing state: %s", err)
}
keys = append(keys, key)
}
jsonKeys, err := json.Marshal(keys)
if err != nil {
return nil, fmt.Errorf("keys operation failed. Error marshaling JSON: %s", err)
}
return jsonKeys, nil
default:
return nil, errors.New("Unsupported operation")
}
}
//==============================================================================================================================
// get_logs - Takes a users name and returns the logs they are entitled to. If they are the regulator they see all logs
// otherwise it calls a function to get the users logs
//==============================================================================================================================
func (t *Chaincode) get_logs(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
bytes, err := stub.GetState("Vehicle_Log")
if err != nil {
return nil, errors.New("Unable to get logs")
}
var eh LogsHolder
err = json.Unmarshal(bytes, &eh)
if err != nil {
return nil, errors.New("Corrupt logs record")
}
ecert, err := t.get_ecert(stub, args[0])
if err != nil {
return nil, err
}
role, err := t.check_role(stub, []string{string(ecert)})
if err != nil {
return nil, err
}
if role == ROLE_AUTHORITY { // Return all logs if authority
repNull := strings.Replace(string(bytes), "null", "[]", 1) // If the array is blank it has the json value null so we need to make it an empty array
return []byte(repNull), nil
} else {
return t.get_users_logs(stub, eh, args[0])
}
}
// ============================================================================================================================
// Attach License - edit license field in car profile
// ============================================================================================================================
func (t *SimpleChaincode) attach_license(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var err error
carAsBytes, err := stub.GetState(args[0])
if err != nil {
return nil, errors.New("Failed to get car profile")
}
res := Car{}
json.Unmarshal(carAsBytes, &res)
fmt.Println(res)
res.Data.License = args[1]
jsonAsBytes, _ := json.Marshal(res)
// Write the state back to the ledger
err = stub.PutState(args[0], jsonAsBytes)
if err != nil {
return nil, err
}
return nil, nil
}
func (t *Vehicle) scrap_merchant_to_scrap(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
statusBytes, err := stub.GetState("Status")
status, err := strconv.Atoi(string(statusBytes))
if err != nil {
return nil, errors.New("Failed to get state")
}
scrappedBytes, err := stub.GetState("Scrapped")
scrapped, err := strconv.ParseBool(string(scrappedBytes))
if err != nil {
return nil, errors.New("Failed to get state")
}
ownerBytes, err := stub.GetState("Owner")
owner := string(ownerBytes)
if err != nil {
return nil, errors.New("Failed to get state")
}
if !scrapped && owner == "Cray Bros (London) Ltd" && status == 4 {
scrapped = true
} else {
return nil, errors.New("Permission denied")
}
err = stub.PutState("Scrapped", []byte(strconv.FormatBool(scrapped)))
return nil, nil
}
func (t *Vehicle) update_model(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
modelBytes, err := stub.GetState("Model")
model := string(modelBytes)
if err != nil {
return nil, errors.New("Failed to get state")
}
statusBytes, err := stub.GetState("Status")
status, err := strconv.Atoi(string(statusBytes))
if err != nil {
return nil, errors.New("Failed to get state")
}
ownerBytes, err := stub.GetState("Owner")
owner := string(ownerBytes)
if err != nil {
return nil, errors.New("Failed to get state")
}
if status == 1 && owner == "Toyota" {
model = args[0]
} else {
return nil, errors.New("Permission denied")
}
err = stub.PutState("Model", []byte(model))
return nil, nil
}