github.com/s7techlab/cckit@v0.10.5/examples/payment/cc_enc_manual_ondemand_with_mapping.go (about)

     1  package payment
     2  
     3  import (
     4  	"github.com/s7techlab/cckit/examples/payment/schema"
     5  	"github.com/s7techlab/cckit/extensions/debug"
     6  	"github.com/s7techlab/cckit/extensions/encryption"
     7  	"github.com/s7techlab/cckit/router"
     8  	p "github.com/s7techlab/cckit/router/param"
     9  	"github.com/s7techlab/cckit/state"
    10  	m "github.com/s7techlab/cckit/state/mapping"
    11  )
    12  
    13  // Chaincode WITH schema mapping
    14  // and encrypting data on demand (if encrypting key is provided in transient map)
    15  func NewEncryptOnDemandPaymentCC() *router.Chaincode {
    16  	r := router.New(`encrypted-on-demand`).
    17  		Pre(encryption.ArgsDecryptIfKeyProvided). //  encrypted args optional - key can be provided in transient map
    18  		Init(router.EmptyContextHandler)
    19  
    20  	debug.AddHandlers(r, `debug`)
    21  
    22  	r.Use(m.MapStates(StateMappings)) // use state mappings
    23  	r.Use(m.MapEvents(EventMappings)) // use state mappings
    24  
    25  	r.Group(`payment`).
    26  		Invoke(`Create`, invokePaymentCreateManualEncryptWithMapping, p.String(`type`), p.String(`id`), p.Int(`amount`)).
    27  		Query(`List`, queryPaymentsWithMapping, p.String(`type`)).
    28  		Query(`Get`, queryPaymentWithMapping, p.String(`type`), p.String(`id`))
    29  
    30  	return router.NewChaincode(r)
    31  }
    32  
    33  // Payment creation chaincode function handler - can be used in encryption and no encryption mode
    34  func invokePaymentCreateManualEncryptWithMapping(c router.Context) (interface{}, error) {
    35  	var (
    36  		paymentType   = c.ParamString(`type`)
    37  		paymentId     = c.ParamString(`id`)
    38  		paymentAmount = c.ParamInt(`amount`)
    39  		s             state.State
    40  		e             state.Event
    41  		err           error
    42  		returnVal     []byte
    43  	)
    44  
    45  	// Explicit encrypted state wrapper with key from transient map if key provided
    46  	if s, err = encryption.StateWithTransientKeyIfProvided(c); err != nil {
    47  		return nil, err
    48  	}
    49  
    50  	returnVal = []byte(paymentId)
    51  	// return encrypted val if key provided
    52  	if key, _ := encryption.KeyFromTransient(c); key != nil {
    53  		returnVal, err = encryption.Encrypt(key, paymentId)
    54  	}
    55  
    56  	if e, err = encryption.EventWithTransientKeyIfProvided(c); err != nil {
    57  		return nil, err
    58  	}
    59  
    60  	if err = e.Set(&schema.PaymentEvent{Type: paymentType, Id: paymentId, Amount: int32(paymentAmount)}); err != nil {
    61  		return nil, err
    62  	}
    63  	return returnVal, s.Put(&schema.Payment{Type: paymentType, Id: paymentId, Amount: int32(paymentAmount)})
    64  }
    65  
    66  func queryPaymentsWithMapping(c router.Context) (interface{}, error) {
    67  	var (
    68  		//paymentType = c.ParamString(`type`)
    69  		s   state.State
    70  		err error
    71  	)
    72  	// Explicit encrypted state wrapper with key from transient map if key provided
    73  	if s, err = encryption.StateWithTransientKeyIfProvided(c); err != nil {
    74  		return nil, err
    75  	}
    76  	return s.List(&schema.Payment{})
    77  }
    78  
    79  // Payment query chaincode function handler - can be used in encryption and no encryption mode
    80  func queryPaymentWithMapping(c router.Context) (interface{}, error) {
    81  	var (
    82  		paymentType = c.ParamString(`type`)
    83  		paymentId   = c.ParamString(`id`)
    84  		s           state.State
    85  		err         error
    86  	)
    87  	if s, err = encryption.StateWithTransientKeyIfProvided(c); err != nil {
    88  		return nil, err
    89  	}
    90  	return s.Get(&schema.Payment{Type: paymentType, Id: paymentId})
    91  }