iterate/doWhile config fix; update doc (#111)

* iterate/doWhile config fix; update doc

* add iterator to test json

* temporarily remove invalid tests

* fix retry and loop config nil issues

Author: Frank Martinez

definition/definition.go

@@ -1,6 +1,7 @@
 package definition
 
 import (
+	"encoding/json"
 	"fmt"
 
 	"github.com/project-flogo/core/activity"
@@ -181,84 +182,108 @@ func (ac *ActivityConfig) OutputMapper() mapper.Mapper {
 	return ac.outputMapper
 }
 
-type loopCfg struct {
+type loopCfgDef struct {
 	Condition  string `md:"condition"`
-	IterateOn  string `md:"iterate"`
+	IterateOn  string `md:"iterateOn"`
 	Delay      int    `md:"delay"`
 	Accumulate bool   `md:"accumulate"`
+
+	//DEPRECATED
+	Iterate string `md:"iterate"`
 }
 
-type loop struct {
-	condition  expression.Expr
-	accumulate bool
-	delay      int
-	iterateOn  interface{}
+type LoopConfig struct {
+	condition      expression.Expr
+	accumulate     bool
+	delay          int
+	iterateOn      interface{}
+	accApplyOutput bool
 }
 
-func NewLoop(cfg *loopCfg, ef expression.Factory) (*loop, error) {
-	loop := &loop{}
+func newLoopCfg(loopCfgDef *loopCfgDef, accApplyOutput bool, ef expression.Factory) (*LoopConfig, error) {
+	loopCfg := &LoopConfig{accumulate: loopCfgDef.Accumulate, delay: loopCfgDef.Delay, accApplyOutput: accApplyOutput}
 	var err error
-	loop.accumulate = cfg.Accumulate
-	loop.delay = cfg.Delay
 
-	if cfg.Condition != "" {
-		if cfg.Condition[0] == '=' {
-			loop.condition, err = ef.NewExpr(cfg.Condition[1:])
+	if loopCfgDef.Condition != "" {
+		if loopCfgDef.Condition[0] == '=' {
+			loopCfg.condition, err = ef.NewExpr(loopCfgDef.Condition[1:])
 			if err != nil {
 				return nil, err
 			}
 		}
 	}
 
-	if cfg.IterateOn != "" {
-		if cfg.IterateOn[0] == '=' {
-			loop.iterateOn, err = ef.NewExpr(cfg.IterateOn[1:])
+	if loopCfgDef.IterateOn != "" {
+		if loopCfgDef.IterateOn[0] == '=' {
+			loopCfg.iterateOn, err = ef.NewExpr(loopCfgDef.IterateOn[1:])
 			if err != nil {
 				return nil, err
 			}
 		} else {
-			loop.iterateOn = cfg.IterateOn
+			loopCfg.iterateOn = loopCfgDef.IterateOn
 		}
 	}
 
-	return loop, nil
+	return loopCfg, nil
 }
 
-func (l *loop) Accumulated() bool {
+func (l *LoopConfig) Accumulate() bool {
 	return l.accumulate
 }
 
-func (l *loop) DowhileCondition() expression.Expr {
+func (l *LoopConfig) ApplyOutputOnAccumulate() bool {
+	return l.accApplyOutput
+}
+
+func (l *LoopConfig) Condition() expression.Expr {
 	return l.condition
 }
 
-func (l *loop) GetIterate() interface{} {
+func (l *LoopConfig) GetIterateOn() interface{} {
 	return l.iterateOn
 }
 
-func (l *loop) IterateEnabled() bool {
-	return l.iterateOn != nil
+func (l *LoopConfig) Delay() int {
+	return l.delay
 }
 
-func (l *loop) DowhileEnabled() bool {
-	return l.condition != nil
+type RetryOnErrConfig struct {
+	count    int
+	interval int
 }
 
-func (l *loop) Delay() int {
-	return l.delay
+func (r *RetryOnErrConfig) Count() int {
+	return r.count
 }
 
-type retryErrorCfg struct {
-	Count    int `md:"count"`
-	Interval int `md:"interval"`
+func (r *RetryOnErrConfig) Interval() int {
+	return r.interval
 }
 
-func (r *retryErrorCfg) RetryOnErrorCount() int {
-	return r.Count
+func (r *RetryOnErrConfig) MarshalJSON() ([]byte, error) {
+	return json.Marshal(&struct {
+		Count    int `md:"count"`
+		Interval int `md:"interval"`
+	}{
+		Count:    r.count,
+		Interval: r.interval,
+	})
 }
 
-func (r *retryErrorCfg) RetryOnErrorInterval() int {
-	return r.Interval
+// UnmarshalJSON implements json.Unmarshaler.UnmarshalJSON
+func (r *RetryOnErrConfig) UnmarshalJSON(data []byte) error {
+
+	ser := &struct {
+		Count    int `md:"count"`
+		Interval int `md:"interval"`
+	}{}
+
+	if err := json.Unmarshal(data, ser); err != nil {
+		return err
+	}
+	r.count = ser.Count
+	r.interval = ser.Interval
+	return nil
 }
 
 // Task is the object that describes the definition of
@@ -275,10 +300,8 @@ type Task struct {
 
 	settingsMapper mapper.Mapper
 
-	//For do-while and retry
-
-	loop          *loop
-	retryErrorCfg *retryErrorCfg
+	loopCfg          *LoopConfig
+	retryOnErrConfig *RetryOnErrConfig
 
 	toLinks   []*Link
 	fromLinks []*Link
@@ -308,19 +331,12 @@ func (task *Task) SettingsMapper() mapper.Mapper {
 	return task.settingsMapper
 }
 
-func (task *Task) RetryOnErrorEnabled() bool {
-	return task.retryErrorCfg.Count > 0
-}
-func (task *Task) RetryOnErrorCount() int {
-	return task.retryErrorCfg.Count
-}
-
-func (task *Task) RetryOnErrorInterval() int {
-	return task.retryErrorCfg.Interval
+func (task *Task) RetryOnErrConfig() *RetryOnErrConfig {
+	return task.retryOnErrConfig
 }
 
-func (task *Task) LoopConfig() *loop {
-	return task.loop
+func (task *Task) LoopConfig() *LoopConfig {
+	return task.loopCfg
 }
 
 // ToLinks returns the predecessor links of the task

definition/definition_ser.go

@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"github.com/project-flogo/core/app/resolve"
 	"github.com/project-flogo/core/data"
-	"strconv"
-
 	"github.com/project-flogo/core/data/coerce"
+	"strconv"
 
 	"github.com/project-flogo/core/activity"
 	"github.com/project-flogo/core/data/expression"
@@ -23,7 +22,7 @@ import (
 type DefinitionRep struct {
 	ExplicitReply bool                 `json:"explicitReply,omitempty"`
 	Name          string               `json:"name"`
-	ModelID       string               `json:"id,omitempty"`
+	ModelID       string               `json:"model,omitempty"`
 	Metadata      *metadata.IOMetadata `json:"metadata,omitempty"`
 	Tasks         []*TaskRep           `json:"tasks"`
 	Links         []*LinkRep           `json:"links,omitempty"`
@@ -151,12 +150,12 @@ func createTask(def *Definition, rep *TaskRep, ef expression.Factory) (*Task, er
 
 	mf := GetMapperFactory()
 
-	task.loop, err = getLoopCfg(rep.Settings, ef)
+	task.loopCfg, err = getLoopCfg(rep.Settings, task.typeID, ef)
 	if err != nil {
 		return nil, err
 	}
 
-	task.retryErrorCfg, err = getErrorCfg(rep.Settings)
+	task.retryOnErrConfig, err = getRetryOnErrCfg(rep.Settings)
 	if err != nil {
 		return nil, err
 	}
@@ -419,14 +418,20 @@ func createLink(tasks map[string]*Task, linkRep *LinkRep, id int, ef expression.
 	return link, nil
 }
 
-func getErrorCfg(settings map[string]interface{}) (*retryErrorCfg, error) {
-	retryErr := &retryErrorCfg{}
+func getRetryOnErrCfg(settings map[string]interface{}) (*RetryOnErrConfig, error) {
+
+	retrySetting, ok := settings["retryOnError"]
+	if !ok {
+		return nil, nil
+	}
 
-	retryCfgMap, err := coerce.ToObject(settings["retryOnError"])
+	retryErr := &RetryOnErrConfig{}
+
+	retryCfgMap, err := coerce.ToObject(retrySetting)
 	if err != nil {
 		return nil, err
 	}
-	count , exist := retryCfgMap["count"]
+	count, exist := retryCfgMap["count"]
 	if exist && count != nil {
 		strVal, ok := count.(string)
 		if ok && len(strVal) > 0 && strVal[0] == '=' {
@@ -439,10 +444,10 @@ func getErrorCfg(settings map[string]interface{}) (*retryErrorCfg, error) {
 		if err != nil {
 			return nil, fmt.Errorf("retryOnError count must be int")
 		}
-		retryErr.Count = cnt
+		retryErr.count = cnt
 	}
 
-	interval , exist := retryCfgMap["interval"]
+	interval, exist := retryCfgMap["interval"]
 	if exist && interval != nil {
 		strVal, ok := interval.(string)
 		if ok && len(strVal) > 0 && strVal[0] == '=' {
@@ -455,50 +460,62 @@ func getErrorCfg(settings map[string]interface{}) (*retryErrorCfg, error) {
 		if err != nil {
 			return nil, fmt.Errorf("retryOnError interval must be int")
 		}
-		retryErr.Interval = intervalInt
+		retryErr.interval = intervalInt
 	}
 
 	return retryErr, nil
-
 }
 
-func getLoopCfg(settings map[string]interface{}, ef expression.Factory) (*loop, error) {
-	loopCfg := &loopCfg{}
+func getLoopCfg(settings map[string]interface{}, taskType string, ef expression.Factory) (*LoopConfig, error) {
+
+	var lcd *loopCfgDef
+	var err error
+
+	//check for old configurations
+	if setting, ok := settings["loopConfig"]; ok {
+		lcd, err = getLoopCfgDef(setting)
+	} else if setting, ok := settings["doWhile"]; ok {
+		lcd, err = getLoopCfgDef(setting)
+		if accum,ok := settings["accumulate"];  lcd != nil && ok {
+			lcd.Accumulate, _ = coerce.ToBool(accum)
+		}
+	} else {
+		lcd, err = getLoopCfgDef(settings)
+	}
 
-	loopCfgMap, err := coerce.ToObject(settings["loopConfig"])
 	if err != nil {
 		return nil, err
 	}
 
-	if loopCfgMap != nil {
-		
-		err = metadata.MapToStruct(loopCfgMap, loopCfg, true)
-
-		if err != nil {
-			return nil, err
-		}
+	if lcd == nil {
+		return nil, nil
+	}
 
-	} else {
+	return newLoopCfg(lcd, taskType == "doWhile", ef)
+}
 
-		err = metadata.MapToStruct(settings, loopCfg, true)
+func getLoopCfgDef(setting interface{}) (*loopCfgDef, error) {
 
-		if err != nil {
-			return nil, err
-		}
-		dowhileObj, err := coerce.ToObject(settings["doWhile"])
-		if err != nil {
-				return nil, err
-		}
-		err = metadata.MapToStruct(dowhileObj, loopCfg, true)
+	settingMap, err := coerce.ToObject(setting)
+	if err != nil {
+		return nil, err
+	}
 
-		if err != nil {
-				return nil, err
-		}
+	lcd := &loopCfgDef{}
+	err = metadata.MapToStruct(settingMap, lcd, true)
+	if err != nil {
+		return nil, err
 	}
 
- 	return NewLoop(loopCfg, ef)
+	if lcd.IterateOn == "" {
+		lcd.IterateOn = lcd.Iterate
+	}
 
+	if lcd.Condition == "" && lcd.IterateOn == ""  {
+		return nil, nil
+	}
 
+	return lcd, nil
 }
 
 type initCtxImpl struct {