func (t *AssetManagementChaincode) assign(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
fmt.Println("Assigning Asset...")
if len(args) != 2 {
return nil, errors.New("Incorrect number of arguments. Expecting 2")
}
asset := args[0]
owner, err := base64.StdEncoding.DecodeString(args[1])
if err != nil {
fmt.Printf("Error decoding [%v] \n", err)
return nil, errors.New("Failed decodinf owner")
}
// Recover the role that is allowed to make assignments
assignerRole, err := stub.GetState("assignerRole")
if err != nil {
fmt.Printf("Error getting role [%v] \n", err)
return nil, errors.New("Failed fetching assigner role")
}
callerRole, err := stub.ReadCertAttribute("role")
if err != nil {
fmt.Printf("Error reading attribute [%v] \n", err)
return nil, fmt.Errorf("Failed fetching caller role. Error was [%v]", err)
}
caller := string(callerRole[:])
assigner := string(assignerRole[:])
if caller != assigner {
fmt.Printf("Caller is not assigner - caller %v assigner %v\n", caller, assigner)
return nil, fmt.Errorf("The caller does not have the rights to invoke assign. Expected role [%v], caller role [%v]", assigner, caller)
}
account, err := attr.GetValueFrom("account", owner)
if err != nil {
fmt.Printf("Error reading account [%v] \n", err)
return nil, fmt.Errorf("Failed fetching recipient account. Error was [%v]", err)
}
// Register assignment
myLogger.Debugf("New owner of [%s] is [% x]", asset, owner)
ok, err := stub.InsertRow("AssetsOwnership", shim.Row{
Columns: []*shim.Column{
&shim.Column{Value: &shim.Column_String_{String_: asset}},
&shim.Column{Value: &shim.Column_Bytes{Bytes: account}}},
})
if !ok && err == nil {
fmt.Println("Error inserting row")
return nil, errors.New("Asset was already assigned.")
}
return nil, err
}
// Init intializes the chaincode by reading the transaction attributes and storing
// the attrbute values in the state
func (t *SimpleChaincode) Init(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
attributes, err := stub.CertAttributes()
if err != nil {
return nil, err
}
for _, att := range attributes {
fmt.Println("Writting attribute " + att)
var attVal []byte
attVal, err = stub.ReadCertAttribute(att)
if err != nil {
return nil, err
}
err = stub.PutState(att, attVal)
if err != nil {
return nil, err
}
}
return nil, nil
}
func (t *AssetManagementChaincode) assign(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
if len(args) != 2 {
return nil, errors.New("Incorrect number of arguments. Expecting 2")
}
asset := args[0]
owner := []byte(args[1])
// Recover the role that is allowed to make assignments
assignerRole, err := stub.GetState("assignerRole")
if err != nil {
return nil, errors.New("Failed fetching assigner role")
}
// Verify the role of the caller
// Only users with this role can invoker assign
callerRole, err := stub.ReadCertAttribute("role")
if err != nil {
return nil, errors.New("Failed fetching caller role")
}
if string(callerRole[:]) != string(assignerRole[:]) {
return nil, errors.New("The caller does not have the rights to invoke assign")
}
// Register assignment
myLogger.Debug("New owner of [%s] is [% x]", asset, owner)
ok, err := stub.InsertRow("AssetsOwnership", shim.Row{
Columns: []*shim.Column{
&shim.Column{Value: &shim.Column_String_{String_: asset}},
&shim.Column{Value: &shim.Column_Bytes{Bytes: owner}}},
})
if !ok && err == nil {
return nil, errors.New("Asset was already assigned.")
}
return nil, err
}
//Invoke Transaction makes increment counter
func (t *AuthorizableCounterChaincode) Invoke(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
if function != "increment" {
return nil, errors.New("Invalid invoke function name. Expecting \"increment\"")
}
val, err := stub.ReadCertAttribute("position")
fmt.Printf("Position => %v error %v \n", string(val), err)
isOk, _ := stub.VerifyAttribute("position", []byte("Software Engineer")) // Here the ABAC API is called to verify the attribute, just if the value is verified the counter will be incremented.
if isOk {
counter, err := stub.GetState("counter")
if err != nil {
return nil, err
}
var cInt int
cInt, err = strconv.Atoi(string(counter))
if err != nil {
return nil, err
}
cInt = cInt + 1
counter = []byte(strconv.Itoa(cInt))
stub.PutState("counter", counter)
}
return nil, nil
}
func (t *AssetManagementChaincode) transfer(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
if len(args) != 2 {
return nil, errors.New("Incorrect number of arguments. Expecting 2")
}
asset := args[0]
newOwner, err := base64.StdEncoding.DecodeString(args[1])
if err != nil {
fmt.Printf("Error decoding [%v] \n", err)
return nil, errors.New("Failed decoding owner")
}
// Verify the identity of the caller
// Only the owner can transfer one of his assets
var columns []shim.Column
col1 := shim.Column{Value: &shim.Column_String_{String_: asset}}
columns = append(columns, col1)
row, err := stub.GetRow("AssetsOwnership", columns)
if err != nil {
return nil, fmt.Errorf("Failed retrieving asset [%s]: [%s]", asset, err)
}
prvOwner := row.Columns[1].GetBytes()
myLogger.Debugf("Previous owener of [%s] is [% x]", asset, prvOwner)
if len(prvOwner) == 0 {
return nil, fmt.Errorf("Invalid previous owner. Nil")
}
// Verify ownership
callerAccount, err := stub.ReadCertAttribute("account")
if err != nil {
return nil, fmt.Errorf("Failed fetching caller account. Error was [%v]", err)
}
if bytes.Compare(prvOwner, callerAccount) != 0 {
return nil, fmt.Errorf("Failed verifying caller ownership.")
}
newOwnerAccount, err := attr.GetValueFrom("account", newOwner)
if err != nil {
return nil, fmt.Errorf("Failed fetching new owner account. Error was [%v]", err)
}
// At this point, the proof of ownership is valid, then register transfer
err = stub.DeleteRow(
"AssetsOwnership",
[]shim.Column{shim.Column{Value: &shim.Column_String_{String_: asset}}},
)
if err != nil {
return nil, errors.New("Failed deliting row.")
}
_, err = stub.InsertRow(
"AssetsOwnership",
shim.Row{
Columns: []*shim.Column{
&shim.Column{Value: &shim.Column_String_{String_: asset}},
&shim.Column{Value: &shim.Column_Bytes{Bytes: newOwnerAccount}},
},
})
if err != nil {
return nil, errors.New("Failed inserting row.")
}
return nil, nil
}