github.com/TIBCOSoftware/flogo-lib@v0.5.9/core/trigger/legacy.go (about)

     1  package trigger
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  
     7  	"github.com/TIBCOSoftware/flogo-lib/core/action"
     8  	"github.com/TIBCOSoftware/flogo-lib/core/data"
     9  	"github.com/TIBCOSoftware/flogo-lib/logger"
    10  )
    11  
    12  // Deprecated: Temporarily generated for backwards compatibility support
    13  type LegacyRunner struct {
    14  	currentRunner   action.Runner
    15  	triggerMetadata *Metadata
    16  	handlers        map[*HandlerConfig]*Handler
    17  	actToHandlers   map[action.Action]*Handler
    18  }
    19  
    20  func NewLegacyRunner(runner action.Runner, metadata *Metadata) *LegacyRunner {
    21  	return &LegacyRunner{currentRunner: runner, triggerMetadata: metadata, handlers: make(map[*HandlerConfig]*Handler), actToHandlers: make(map[action.Action]*Handler)}
    22  }
    23  
    24  func (lr *LegacyRunner) RegisterHandler(h *Handler) {
    25  	lr.handlers[h.config] = h
    26  	lr.actToHandlers[h.act] = h
    27  }
    28  
    29  func (lr *LegacyRunner) Run(ctx context.Context, act action.Action, uri string, options interface{}) (code int, data interface{}, err error) {
    30  
    31  	newOptions := make(map[string]interface{})
    32  	newOptions["deprecated_options"] = options
    33  
    34  	results, err := lr.RunAction(ctx, act, newOptions)
    35  
    36  	if len(results) != 0 {
    37  		defData, ok := results["data"]
    38  		if ok {
    39  			data = defData.Value()
    40  		}
    41  		defCode, ok := results["code"]
    42  		if ok {
    43  			code = defCode.Value().(int)
    44  		}
    45  	}
    46  
    47  	return code, data, err
    48  }
    49  
    50  func (lr *LegacyRunner) RunAction(ctx context.Context, act action.Action, options map[string]interface{}) (results map[string]*data.Attribute, err error) {
    51  
    52  	trgHandler, trgData := lr.getHandler(ctx, act)
    53  	return trgHandler.Handle(ctx, trgData)
    54  }
    55  
    56  func (*LegacyRunner) Execute(ctx context.Context, act action.Action, inputs map[string]*data.Attribute) (results map[string]*data.Attribute, err error) {
    57  	//only called by handler so not needed
    58  
    59  	return nil, errors.New("not supported")
    60  }
    61  
    62  func (lr *LegacyRunner) getHandler(ctx context.Context, act action.Action) (*Handler, map[string]interface{}) {
    63  	var values map[string]interface{}
    64  	var handler *Handler
    65  
    66  	if ctx != nil {
    67  		var exists bool
    68  		ctxData, exists := ExtractContextData(ctx)
    69  
    70  		if exists {
    71  			values = attrsToData(ctxData.Attrs)
    72  			if ctxData.HandlerCfg != nil {
    73  				handler = lr.handlers[ctxData.HandlerCfg]
    74  			}
    75  
    76  		}
    77  	}
    78  
    79  	if handler == nil {
    80  		handler = lr.actToHandlers[act]
    81  	}
    82  
    83  	if handler == nil {
    84  		logger.Warn("Unable to determine handler, creating generic one")
    85  		handler = NewHandler(nil, act, lr.triggerMetadata.Output, lr.triggerMetadata.Reply, lr.currentRunner)
    86  	}
    87  
    88  	return handler, values
    89  }
    90  
    91  func attrsToData(attrs []*data.Attribute) map[string]interface{} {
    92  
    93  	if attrs == nil {
    94  		return nil
    95  	}
    96  
    97  	values := make(map[string]interface{}, len(attrs))
    98  
    99  	for _, attr := range attrs {
   100  		values[attr.Name()] = attr
   101  	}
   102  
   103  	return values
   104  }