project-flogo/developers

package main

import (
    "context"
    "fmt"

    logg "github.com/project-flogo/contrib/activity/log"
    "github.com/project-flogo/core/activity"
    "github.com/project-flogo/core/api"
    "github.com/project-flogo/core/engine"
    "github.com/project-flogo/core/support/log"
    "github.com/project-flogo/core/trigger"

    "errors"
    "github.com/edgexfoundry/app-functions-sdk-go/appcontext"
    "github.com/edgexfoundry/app-functions-sdk-go/appsdk"
    "github.com/edgexfoundry/app-functions-sdk-go/pkg/transforms"
    "os"
)

// trigger starts here
type HandlerSettings struct{}

var triggerMd = trigger.NewMetadata(&HandlerSettings{})

func init() {
    _ = trigger.Register(&Trigger{}, &Factory{})
}

type Factory struct{}

// Metadata implements trigger.Factory.Metadata
func (*Factory) Metadata() *trigger.Metadata {
    return triggerMd
}

// New implements trigger.Factory.New
func (*Factory) New(config *trigger.Config) (trigger.Trigger, error) {
    return &Trigger{}, nil
}

type Trigger struct {
    logger   log.Logger
    handlers []trigger.Handler
}

// Init implements trigger.Init
func (t *Trigger) Initialize(ctx trigger.InitContext) error {
    t.logger = ctx.Logger()
    t.handlers = ctx.GetHandlers()
    return nil
}

// Start implements ext.Trigger.Start
func (t *Trigger) Start() error {
    fmt.Println("flogo trigger just started")
    //Assume you just have one handler.
    go edgexEventCatcher(t.handlers[0])
    return nil
}

// Stop implements ext.Trigger.Stop
func (t *Trigger) Stop() error {
    fmt.Println("flogo trigger stopped")
    return nil
}

type callHandler struct {
    handler trigger.Handler
}

// edgex
func edgexEventCatcher(handler trigger.Handler) {
    // turn off secure mode for examples. Not recommended for production
    os.Setenv("EDGEX_SECURITY_SECRET_STORE", "false")
    // 1) First thing to do is to create an instance of the EdgeX SDK, giving it a service key
    edgexSdk := &appsdk.AppFunctionsSDK{ServiceKey: "sampleFilterJSON"}
    // 2) Next, we need to initialize the SDK
    if err := edgexSdk.Initialize(); err != nil {
        edgexSdk.LoggingClient.Error(fmt.Sprintf("SDK initialization failed: %v\n", err))
        os.Exit(-1)
    }
    // 3) Shows how to access the application's specific configuration settings.
    deviceNames, err := edgexSdk.GetAppSettingStrings("DeviceNames")
    if err != nil {
        edgexSdk.LoggingClient.Error(err.Error())
        os.Exit(-1)
    }
    edgexSdk.LoggingClient.Info(fmt.Sprintf("Filtering for devices &v", deviceNames))
    // 4) This is our pipeline configuration, the collection of functions to
    // execute every time an event is triggered.
    callHandler := &callHandler{handler: handler}
    if err = edgexSdk.SetFunctionsPipeline(
        transforms.NewFilter(deviceNames).FilterByDeviceName,
        transforms.NewConversion().TransformToJSON,
        callHandler.printXMLToConsole,
    ); err != nil {
        edgexSdk.LoggingClient.Error(fmt.Sprintf("SDK SetPipeline failed: %v\n", err))
        os.Exit(-1)
    }
    // 5) Lastly, we'll go ahead and tell the SDK to "start" and begin listening for events to trigger the pipeline.
    err = edgexSdk.MakeItRun()
    if err != nil {
        edgexSdk.LoggingClient.Error("MakeItRun returned error: ", err.Error())
        os.Exit(-1)
    }
    os.Exit(0)
}

func (c *callHandler) printXMLToConsole(edgexcontext *appcontext.Context, params ...interface{}) (bool, interface{}) {
    if len(params) < 1 {
        // We didn't receive a result
        return false, errors.New("No Data Received")
    }
    println(params[0].(string))
    // Leverage the built in logging service in EdgeX
    edgexcontext.LoggingClient.Debug("JSON printed to console")

    //Here go and call flows, and data goes to flow
    triggerData := map[string]interface{}{}
    triggerData["jsonData"] = params
    results, err := c.handler.Handle(context.Background(), triggerData)
    //You can handle returned result and possible error. 
    println(err)
    println(results)
    return true, nil
}