Develop

README.md

@@ -65,58 +65,88 @@ First we start off with loading the `TupleDescriptor`. It accepts a JSON string
 Next create a `RuleSession` and add all the `Rule`s with their `Condition`s and `Actions`s.
 
 	//Create a RuleSession
-	rs, _ := ruleapi.GetOrCreateRuleSession("asession")
+	rs, _ := ruleapi.GetOrCreateRuleSession("asession", "")
 
 	//// check for name "Bob" in n1
 	rule := ruleapi.NewRule("n1.name == Bob")
-	rule.AddCondition("c1", []string{"n1"}, checkForBob, nil)
-	rule.SetAction(checkForBobAction)
-	rule.SetContext("This is a test of context")
+	rule.AddCondition("c1", []string{"n1"}, checkForBob, events)
+	serviceCfg := &config.ServiceDescriptor{
+		Name:     "checkForBobAction",
+		Function: checkForBobAction,
+		Type:     "function",
+	}
+	aService,_ := ruleapi.NewActionService(serviceCfg)
+	rule.SetActionService(aService)
+	rule.SetContext(events)
 	rs.AddRule(rule)
-	fmt.Printf("Rule added: [%s]\n", rule.GetName())
 
 	// check for name "Bob" in n1, match the "name" field in n2,
 	// in effect, fire the rule when name field in both tuples is "Bob"
 	rule2 := ruleapi.NewRule("n1.name == Bob && n1.name == n2.name")
-	rule2.AddCondition("c1", []string{"n1"}, checkForBob, nil)
-	rule2.AddCondition("c2", []string{"n1", "n2"}, checkSameNamesCondition, nil)
-	rule2.SetAction(checkSameNamesAction)
+	rule2.AddCondition("c1", []string{"n1"}, checkForBob, events)
+	rule2.AddCondition("c2", []string{"n1", "n2"}, checkSameNamesCondition, events)
+	serviceCfg2 := &config.ServiceDescriptor{
+		Name:     "checkSameNamesAction",
+		Function: checkSameNamesAction,
+		Type:     "function",
+	}
+	aService2,_ := ruleapi.NewActionService(serviceCfg2)
+	rule2.SetActionService(aService2)
+	rule2.SetContext(events)
 	rs.AddRule(rule2)
-	fmt.Printf("Rule added: [%s]\n", rule2.GetName())
-
-	//Finally, start the rule session before asserting tuples
-	//Your startup function, if registered will be invoked here
+
+	// check for name in n1, match the env variable "name"
+	rule3 := ruleapi.NewRule("n1.name == envname")
+	rule3.AddCondition("c1", []string{"n1"}, checkSameEnvName, events)
+	serviceCfg3 := &config.ServiceDescriptor{
+		Name:     "checkSameEnvNameAction",
+		Function: checkSameEnvNameAction,
+		Type:     "function",
+	}
+	aService3,_ := ruleapi.NewActionService(serviceCfg3)
+	rule3.SetActionService(aService3)
+	rule3.SetContext(events)
+	rs.AddRule(rule3)
+
+	//set a transaction handler
+	rs.RegisterRtcTransactionHandler(txHandler, nil)
+	//Start the rule session
 	rs.Start(nil)
 
 Here we create and assert the actual `Tuple's` which will be evaluated against the `Rule's` `Condition's` defined above.
 
 	//Now assert a "n1" tuple
-	fmt.Println("Asserting n1 tuple with name=Tom")
 	t1, _ := model.NewTupleWithKeyValues("n1", "Tom")
 	t1.SetString(nil, "name", "Tom")
 	rs.Assert(nil, t1)
 
 	//Now assert a "n1" tuple
-	fmt.Println("Asserting n1 tuple with name=Bob")
 	t2, _ := model.NewTupleWithKeyValues("n1", "Bob")
 	t2.SetString(nil, "name", "Bob")
 	rs.Assert(nil, t2)
 
 	//Now assert a "n2" tuple
-	fmt.Println("Asserting n2 tuple with name=Bob")
 	t3, _ := model.NewTupleWithKeyValues("n2", "Bob")
 	t3.SetString(nil, "name", "Bob")
 	rs.Assert(nil, t3)
 
+	//Now assert a "n1" tuple
+	t4, _ := model.NewTupleWithKeyValues("n1", "Smith")
+	t4.SetString(nil, "name", "Smith")
+	rs.Assert(nil, t4)
+
 Finally, once all `Rule` `Condition's` are evaluated and `Action's` are executed, we can `Retract` all the `Tuple's` from the `RuleSession` and unregister the RuleSession.
 
 	//Retract tuples
 	rs.Retract(nil, t1)
 	rs.Retract(nil, t2)
 	rs.Retract(nil, t3)
+	rs.Retract(nil, t4)
 
 	//delete the rule
 	rs.DeleteRule(rule.GetName())
+	rs.DeleteRule(rule2.GetName())
+	rs.DeleteRule(rule3.GetName())
 
 	//unregister the session, i.e; cleanup
 	rs.Unregister()

activity/dtable/README.md

@@ -0,0 +1,46 @@
+# Decision Table
+This is a `flogo activity` based `Decision Table` implementation used inside a rules application. It can be invoked as rule action service. `Decision Table` provide a tabular way to build complex business rules. Each column can be created based on predefined properties. These properties are defined in the `tuple descriptor` used inside a rule application. Each row can be thought of as one rule in a table made up of many rules. The individual rules are often straightforward, as in the following example.
+
+Rule conditions:
+```
+person.age > 30
+person.gender == "male"
+```
+Rule actions:
+```
+application.status = "ACCEPTED"
+application.credit = 4000
+```
+A decision table can consist of hundreds, even thousands of rules each of which is executed only when its specific conditions are satisfied.
+
+## Usage
+
+The available activity `settings` are as follows:
+
+| Name   |  Type   | Description   |
+|:-----------|:--------|:--------------|
+| dTableFile | string |  Decision table file path (xlsx & csv extensions are supported) |
+
+A sample `decision table` definition is:
+```json
+    {
+        "name": "ApplicantSimple",
+        "description": "Simple Applicants approval dt",
+        "type": "activity",
+        "ref": "github.com/project-flogo/rules/activity/dtable",
+        "settings": {
+            "dTableFile":"creditcard-file.xlsx"
+        }
+    }
+
+```
+
+An example rule action service that invokes the above `ApplicantSimple` decision table is:
+```json
+    "actionService": {
+        "service": "ApplicantSimple",
+        "input": {
+            "message": "test ApplicantSimple"
+        }
+    }
+```

activity/dtable/activity.go

@@ -0,0 +1,64 @@
+package dtable
+
+import (
+	"context"
+
+	"github.com/project-flogo/core/activity"
+	"github.com/project-flogo/core/data/metadata"
+	"github.com/project-flogo/rules/common/model"
+	"github.com/project-flogo/rules/ruleapi"
+)
+
+func init() {
+	_ = activity.Register(&Activity{}, New)
+}
+
+// Activity decision table based rule action
+type Activity struct {
+	dtable ruleapi.DecisionTable
+}
+
+// New creates new decision table activity
+func New(ctx activity.InitContext) (activity.Activity, error) {
+	// Read settings
+	settings := &Settings{}
+	err := metadata.MapToStruct(ctx.Settings(), settings, true)
+	if err != nil {
+		return nil, err
+	}
+
+	// Read decision table from file
+	dtable, err := ruleapi.LoadDecisionTableFromFile(settings.DTableFile)
+	if err != nil {
+		return nil, err
+	}
+	// dtable.print()
+	err = dtable.Compile()
+	if err != nil {
+		return nil, err
+	}
+	// dtable.print()
+
+	// Read setting from init context
+	act := &Activity{
+		dtable: dtable,
+	}
+	return act, nil
+}
+
+// Metadata activity metadata
+func (a *Activity) Metadata() *activity.Metadata {
+	return activity.ToMetadata(&Input{})
+}
+
+// Eval implements decision table action
+func (a *Activity) Eval(ctx activity.Context) (done bool, err error) {
+
+	context := ctx.GetInput("ctx").(context.Context)
+	tuples := ctx.GetInput("tuples").(map[model.TupleType]model.Tuple)
+
+	// evaluate decision table
+	a.dtable.Apply(context, tuples)
+
+	return true, nil
+}

activity/dtable/activity_test.go

@@ -0,0 +1,179 @@
+package dtable
+
+import (
+	"context"
+	"testing"
+
+	"github.com/project-flogo/core/data/resolve"
+	"github.com/project-flogo/core/support/test"
+	"github.com/project-flogo/rules/common/model"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/project-flogo/core/data/mapper"
+)
+
+const tupleDescriptor = `[
+	{
+	   "name":"applicant",
+	   "properties":[
+		  {
+			 "name":"name",
+			 "pk-index":0,
+			 "type":"string"
+		  },
+		  {
+			 "name":"gender",
+			 "type":"string"
+		  },
+		  {
+			 "name":"age",
+			 "type":"int"
+		  },
+		  {
+			 "name":"address",
+			 "type":"string"
+		  },
+		  {
+			 "name":"hasDL",
+			 "type":"bool"
+		  },
+		  {
+			 "name":"ssn",
+			 "type":"long"
+		  },
+		  {
+			 "name":"income",
+			 "type":"double"
+		  },
+		  {
+			 "name":"maritalStatus",
+			 "type":"string"
+		  },
+		  {
+			 "name":"creditScore",
+			 "type":"int"
+		  },
+		  {
+			 "name":"status",
+			 "type":"string"
+		  },
+		  {
+			 "name":"eligible",
+			 "type":"bool"
+		  },
+		  {
+			 "name":"creditLimit",
+			 "type":"double"
+		  }
+	   ]
+	},
+	{
+	   "name":"processapplication",
+	   "ttl":0,
+	   "properties":[
+		  {
+			 "name":"ssn",
+			 "pk-index":0,
+			 "type":"long"
+		  },
+		  {
+			 "name":"start",
+			 "type":"bool"
+		  }
+	   ]
+	}
+]`
+
+var testApplicants = []map[string]interface{}{
+	{
+		"name":          "JohnDoe",
+		"gender":        "Male",
+		"age":           20,
+		"address":       "BoltonUK",
+		"hasDL":         true,
+		"ssn":           "1231231234",
+		"income":        45000,
+		"maritalStatus": "single",
+		"creditScore":   500,
+	},
+	{
+		"name":          "JaneDoe",
+		"gender":        "Female",
+		"age":           38,
+		"address":       "BoltonUK",
+		"hasDL":         false,
+		"ssn":           "2424354532",
+		"income":        32000,
+		"maritalStatus": "single",
+		"creditScore":   650,
+	},
+	{
+		"name":          "PrakashY",
+		"gender":        "Male",
+		"age":           30,
+		"address":       "RedwoodShore",
+		"hasDL":         true,
+		"ssn":           "2345342132",
+		"income":        150000,
+		"maritalStatus": "married",
+		"creditScore":   750,
+	},
+	{
+		"name":          "SandraW",
+		"gender":        "Female",
+		"age":           26,
+		"address":       "RedwoodShore",
+		"hasDL":         true,
+		"ssn":           "3213214321",
+		"income":        50000,
+		"maritalStatus": "single",
+		"creditScore":   625,
+	},
+}
+
+func TestNew(t *testing.T) {
+	err := model.RegisterTupleDescriptors(string(tupleDescriptor))
+
+	settings := &Settings{
+		DTableFile: "test_dtable.csv",
+	}
+	mf := mapper.NewFactory(resolve.GetBasicResolver())
+	initCtx := test.NewActivityInitContext(settings, mf)
+	act, err := New(initCtx)
+	assert.Nil(t, err)
+	assert.NotNil(t, act)
+}
+
+func TestEval(t *testing.T) {
+	err := model.RegisterTupleDescriptors(string(tupleDescriptor))
+
+	settings := &Settings{
+		DTableFile: "test_dtable.xlsx",
+	}
+	mf := mapper.NewFactory(resolve.GetBasicResolver())
+	initCtx := test.NewActivityInitContext(settings, mf)
+	act, err := New(initCtx)
+	assert.Nil(t, err)
+	assert.NotNil(t, act)
+
+	tuples := make(map[model.TupleType]model.Tuple)
+	tuple, err := model.NewTuple(model.TupleType("applicant"), testApplicants[0])
+	assert.Nil(t, err)
+	assert.NotNil(t, tuple)
+	tuples[tuple.GetTupleType()] = tuple
+
+	tc := test.NewActivityContext(act.Metadata())
+	tc.SetInput("ctx", context.Background())
+	tc.SetInput("tuples", tuples)
+	act.Eval(tc)
+
+	expectedStatus, err := tuple.GetString("status")
+	assert.Nil(t, err)
+	assert.Equal(t, "VISA-Granted", expectedStatus)
+	expectedEligible, err := tuple.GetBool("eligible")
+	assert.Nil(t, err)
+	assert.Equal(t, true, expectedEligible)
+	expectedCreditLimit, err := tuple.GetDouble("creditLimit")
+	assert.Nil(t, err)
+	assert.Equal(t, 2500.0, expectedCreditLimit)
+}