public TaskData(TaskDef def, TargetList targets, BaseCharacter character, int ticksToPerform = 0)
{
this.def = def;
this.targets = targets;
this.character = character;
this.ticksToPerform = ticksToPerform;
}
protected void output_bindings_code(Func <SC.IDictionary> fun, string codeStr)
{
TaskDef tsk = _curTask != null ? _curTask : (TaskDef)_currentCompositeTask;
string k = DslUtil.TaskOutputDataBindingKey(tsk.Id);
_variableBinds[k] = fun;
}
private ITaskTracker MakeTaskTracker(TaskDef def)
{
FoodTaskDef foodTaskDef = def as FoodTaskDef;
if (foodTaskDef != null)
{
return(new FoodTaskTracker(this, foodTaskDef));
}
else
{
TargetTaskDef targetTaskDef = def as TargetTaskDef;
if (targetTaskDef != null)
{
return(new TargetTaskTracker(this, targetTaskDef));
}
else
{
PointTaskDef pointTaskDef = def as PointTaskDef;
if (pointTaskDef != null)
{
return(new PointTaskTracker(this, pointTaskDef));
}
else
{
throw new System.ArgumentException("Unknown task definition given.");
}
}
}
}
internal void ParseMethod(Token tok)
{
Advance(); //past 'method
Token nameToken = CurrentToken;
Advance(); //past name
//
ExpertDef parent = (ExpertDef)CurrentNode;
TaskDef methodDef = parent.CreateTaskDef(nameToken, AstNodeKind.TaskDef);
//
ParseTrigger(methodDef);
ParseProperties(methodDef);
//
if (CurrentToken == null)
{
return;
}
//else
PushTaskDef(methodDef);
PushNode(methodDef.ProcedureDef);
do
{
CreateState(CurrentList);
ParseMethodItem(methodDef);
PopState();
} while (Advance());
PopNode();
PopTaskDef();
}
protected void multi_instance_split_expression(Func <object> dataSplitQuery, string code)
{
TaskDef tsk = _curTask != null ? _curTask : (TaskDef)_currentCompositeTask;
string k = DslUtil.TaskMultiInstanceSplitKey(tsk.Id);
tsk.MultiInstanceSplitExpression = string.IsNullOrEmpty(code) ? "# compiled code block" : code;
_variableBinds[k] = dataSplitQuery;
}
protected void GenerateBaseTaskScripts(TaskDef td)
{
if (td.Variables != null)
{
foreach (var vd in td.Variables.Where(x => !string.IsNullOrEmpty(x.DefaultValueExpr)))
{
GenExpression(DslUtil.TaskVariableDefaultKey(td.Id, vd.Name), vd.DefaultValueExpr);
}
}
if (td.InputDataBindings != null)
{
foreach (var bnd in td.InputDataBindings.Where(x => x.BindType == DataBindingType.Expr))
{
GenExpression(DslUtil.TaskVarInBindingKey(td.Id, bnd.Target), bnd.Source);
}
}
if (td.OutputDataBindings != null)
{
foreach (var bnd in td.OutputDataBindings.Where(x => x.BindType == DataBindingType.Expr))
{
GenExpression(DslUtil.TaskVarOutBindingKey(td.Id, bnd.Target), bnd.Source);
}
}
if (td.InputParameterBindings != null)
{
foreach (var bnd in td.InputParameterBindings.Where(x => x.BindType == DataBindingType.Expr))
{
GenExpression(DslUtil.TaskParamInBindingKey(td.Id, bnd.Target), bnd.Source);
}
}
if (td.OutputParameterBindings != null)
{
foreach (var bnd in td.OutputParameterBindings.Where(x => x.BindType == DataBindingType.Expr))
{
GenExpression(DslUtil.TaskParamOutBindingKey(td.Id, bnd.Target), bnd.Source);
}
}
if (td.IsMultiInstance)
{
GenExpression(DslUtil.TaskMultiInstanceSplitKey(td.Id), td.MultiInstanceSplitExpression);
}
if (!string.IsNullOrEmpty(td.BeforeEnableScript))
{
GenStatement(DslUtil.TaskScriptKey(td.Id, "BeforeEnable"), td.BeforeEnableScript);
}
if (!string.IsNullOrEmpty(td.AfterCompleteScript))
{
GenStatement(DslUtil.TaskScriptKey(td.Id, "AfterComplete"), td.AfterCompleteScript);
}
if (!string.IsNullOrEmpty(td.AfterEnableScript))
{
GenStatement(DslUtil.TaskScriptKey(td.Id, "AfterEnable"), td.AfterEnableScript);
}
}
protected void GenerateScript(TaskDef td)
{
if (td is CompositeTaskDef)
{
GenerateScript((CompositeTaskDef)td);
}
else
{
GenerateScript((AtomicTaskDef)td);
}
}
public virtual void Activate(ITaskExecutionContext ctx, ProcessDef processDef, IProcessScriptRuntime scriptRuntime)
{
Context = ctx;
ProcessDefinition = processDef;
TaskDefinition = processDef.GetRequiredTask(this.TaskId);
ScriptRuntime = scriptRuntime;
if (TaskDefinition == null)
{
throw new Exception("Task not found in process definition: " + this.TaskId);
}
}
void ParseMethodItem(TaskDef parent)
{
switch (CurrentToken.Kind)
{
case TokenKind.Precondition:
ParsePrecondition(parent.ProcedureDef);
break;
default:
ParseTaskItem(parent.ProcedureDef);
break;
}
}
public void ExecuteChildTaskOutputDataBinding(CompositeTaskInstance ti, TaskDef childTask, Dictionary <string, object> childOutputData, ITaskExecutionContext ctx)
{
if (string.IsNullOrEmpty(ti.InstanceId) ||
string.IsNullOrEmpty(ti.TaskId) ||
string.IsNullOrEmpty(ti.ProcessDefinitionId) ||
string.IsNullOrEmpty(ti.ProcessInstanceId))
{
throw new Exception("Task not inited properly");
}
_pd.SetTaskInstanceInfo(ti, ctx);
_pd.SetOutputData(childOutputData);
_pd.SetInputData(null);
var ctd = childTask.Parent;
if (childTask.AutoBindVariables && ctd.Variables != null)
{
foreach (var vd in ctd.Variables)
{
if (childOutputData.ContainsKey(vd.Name))
{
ti.TaskData[vd.Name] = childOutputData[vd.Name];
}
}
}
if (childTask.OutputDataBindings != null)
{
foreach (var bd in childTask.OutputDataBindings)
{
switch (bd.BindType)
{
case DataBindingType.CopyVar:
ti.TaskData[bd.Target] = childOutputData[bd.Source];
break;
case DataBindingType.Literal:
ti.TaskData[bd.Target] = bd.Source;
break;
case DataBindingType.Expr:
string k = DslUtil.TaskVarOutBindingKey(childTask.Id, bd.Target);
if (!_pd._exprs.ContainsKey(k))
{
throw new Exception("!");
}
ti.TaskData[bd.Target] = _pd._exprs[k]();
break;
}
}
}
}
void ParseTrigger(TaskDef taskDef)
{
TriggerStmt triggerDecl = new TriggerStmt(taskDef);
PushNode(triggerDecl);
ExprSeq exprSeq = ParseExprSeq();
PopNode();
//
triggerDecl.ExprSeq = exprSeq;
taskDef.TriggerDef = triggerDecl;
bool isCreator = taskDef.IsCreator;
taskDef.Parent.AddTriggerDef(taskDef.TriggerDef, isCreator);
}
void ParseTaskMessage(ClauseExpr messageDef)
{
Advance(); //past 'task
//
TaskDef taskDef = CurrentTaskDef.CreateSubtaskDef();
messageDef.MessageTag.TaskDef = taskDef;
//
ParseProperties(taskDef);
//
PushTaskDef(taskDef);
ParseTaskItems(taskDef.ProcedureDef);
PopTaskDef();
//
messageDef.MakeCallback();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JObject ob = JObject.Load(reader);
string s = ob.Value <string>("TaskType");
if (string.IsNullOrEmpty(s))
{
s = ob.Value <string>("$type");
}
if (s == null)
{
throw new Exception("task type missing: " + ob.ToString());
}
bool composite = s.IndexOf("composite", StringComparison.InvariantCultureIgnoreCase) >= 0;
TaskDef tsk = composite ? (TaskDef) new CompositeTaskDef() : new AtomicTaskDef();
serializer.Populate(ob.CreateReader(), tsk);
return(tsk);
}
protected TaskInstance CreateTaskInstance(TaskDef td)
{
if (td is CompositeTaskDef)
{
return(new CompositeTaskInstance());
}
AtomicTaskDef at = td as AtomicTaskDef;
switch (at.TaskType)
{
case NGinnTaskType.Empty:
return(new EmptyTaskInstance());
case NGinnTaskType.Timer:
return(new TimerTaskInstance());
case NGinnTaskType.Debug:
return(new DebugTaskInstance());
case NGinnTaskType.Manual:
return(new ManualTaskInstance());
case NGinnTaskType.SendMessage:
return(new SendMessageTaskInstance());
case NGinnTaskType.ReceiveMessage:
return(new AwaitMessageTaskInstance());
case NGinnTaskType.Custom:
if (string.IsNullOrEmpty(td.ImplementationClass))
{
throw new Exception("ImplementationClass missing");
}
Type t = Type.GetType(td.ImplementationClass);
var ti = (TaskInstance)Activator.CreateInstance(t);
return(ti);
default:
return(new EmptyTaskInstance());
}
}
//
public void PushTaskDef(TaskDef def)
{
TaskDefStack.Push(def);
}
public void InitializeNewTask(TaskInstance ti, Dictionary <string, object> inputData, ITaskExecutionContext ctx)
{
if (string.IsNullOrEmpty(ti.InstanceId) ||
string.IsNullOrEmpty(ti.TaskId) ||
string.IsNullOrEmpty(ti.ProcessDefinitionId) ||
string.IsNullOrEmpty(ti.ProcessInstanceId))
{
throw new Exception("Task not inited properly");
}
_pd.SetTaskInstanceInfo(ti, ctx);
TaskDef td = _def.GetRequiredTask(ti.TaskId);
if (td.Variables != null)
{
foreach (var vd in td.Variables)
{
if (vd.VariableDir == ProcessModel.Data.VariableDef.Dir.In ||
vd.VariableDir == ProcessModel.Data.VariableDef.Dir.InOut)
{
if (inputData.ContainsKey(vd.Name))
{
ti.TaskData[vd.Name] = inputData[vd.Name];
}
}
if (!ti.TaskData.ContainsKey(vd.Name))
{
var k = DslUtil.TaskVariableDefaultKey(td.Id, vd.Name);
if (_pd._variableBinds.ContainsKey(k))
{
ti.TaskData[vd.Name] = _pd._variableBinds[k]();
}
else if (!string.IsNullOrEmpty(vd.DefaultValueExpr))
{
ti.TaskData[vd.Name] = vd.DefaultValueExpr; //TODO: add type conversion
}
else if (vd.IsRequired)
{
throw new NGinnBPM.ProcessModel.Exceptions.DataValidationException("Required variable missing: " + vd.Name).SetTaskId(ti.TaskId).SetProcessDef(ti.ProcessDefinitionId);
}
}
}
}
//now initialize task parameters
if (td.InputParameterBindings != null)
{
foreach (var bd in td.InputParameterBindings)
{
var pi = ti.GetType().GetProperty(bd.Target);
if (pi == null)
{
throw new NGinnBPM.ProcessModel.Exceptions.TaskParameterInvalidException(bd.Target, "Property not found: " + bd.Target).SetTaskId(ti.TaskId);
}
string k = DslUtil.TaskParamInBindingKey(td.Id, bd.Target);
if (bd.BindType == DataBindingType.Expr)
{
pi.SetValue(ti, _pd._variableBinds[k](), null);
}
else if (bd.BindType == DataBindingType.CopyVar)
{
pi.SetValue(ti, ti.TaskData.ContainsKey(bd.Source) ? ti.TaskData[bd.Source] : null, null);
}
else if (bd.BindType == DataBindingType.Literal)
{
pi.SetValue(ti, Convert.ChangeType(bd.Source, pi.PropertyType), null);
}
else
{
throw new Exception();
}
}
}
string ks = DslUtil.TaskScriptKey(ti.TaskId, "_paramInit");
if (_pd._taskScripts.ContainsKey(ks))
{
_pd._taskScripts[ks]();
}
}
public Dictionary <string, object> PrepareChildTaskInputData(CompositeTaskInstance cti, TaskDef childTask, ITaskExecutionContext ctx)
{
_pd.SetTaskInstanceInfo(cti, ctx);
string k1 = DslUtil.TaskInputDataBindingKey(childTask.Id);
if (_pd._variableBinds.ContainsKey(k1))
{
//get full data record
SC.IDictionary dic = (SC.IDictionary)_pd._variableBinds[k1]();
return(ToTaskData(dic));
}
Dictionary <string, object> ret = new Dictionary <string, object>();
if (childTask.Variables != null)
{
if (childTask.AutoBindVariables)
{
foreach (var vd in childTask.Variables)
{
if (vd.VariableDir == ProcessModel.Data.VariableDef.Dir.In ||
vd.VariableDir == ProcessModel.Data.VariableDef.Dir.InOut)
{
//TODO add type conversion/control
if (cti.TaskData.ContainsKey(vd.Name))
{
ret[vd.Name] = cti.TaskData[vd.Name];
}
}
}
}
if (childTask.InputDataBindings != null)
{
foreach (var bd in childTask.InputDataBindings)
{
if (bd.BindType == DataBindingType.CopyVar)
{
ret[bd.Target] = cti.TaskData[bd.Source];
}
else if (bd.BindType == DataBindingType.Literal)
{
ret[bd.Target] = bd.Source;
}
else if (bd.BindType == DataBindingType.Expr)
{
string k = DslUtil.TaskVarInBindingKey(childTask.Id, bd.Target);
if (!_pd._variableBinds.ContainsKey(k))
{
throw new Exception("Fail: missing delegate: " + k);
}
ret[bd.Target] = _pd._variableBinds[k]();
}
}
}
}
return(ret);
}
public IEnumerable <Dictionary <string, object> > PrepareMultiInstanceTaskInputData(CompositeTaskInstance cti, TaskDef childTask, ITaskExecutionContext ctx)
{
if (!childTask.IsMultiInstance)
{
throw new Exception();
}
var k = DslUtil.TaskMultiInstanceSplitKey(childTask.Id);
Func <object> fun = _pd._variableBinds[k];
if (fun == null)
{
throw new Exception();
}
_pd.SetTaskInstanceInfo(cti, ctx);
SC.IEnumerable enu;
var val = fun();
enu = val is SC.IEnumerable ? (SC.IEnumerable)val : new object[] { val };
List <Dictionary <string, object> > ret = new List <Dictionary <string, object> >();
foreach (object item in enu)
{
if (item is Dictionary <string, object> )
{
ret.Add((Dictionary <string, object>)item);
}
else if (item is SC.IDictionary)
{
ret.Add(ToTaskData((SC.IDictionary)item));
}
else
{
throw new Exception();
}
}
return(ret);
/*
* ITaskScript scr = Context.ScriptManager.GetTaskScript(this.ParentProcess, taskId);
* Task tsk = MyTask.RequireTask(taskId);
* scr.TaskContext = Context;
* Dictionary<string, object> srcData = new Dictionary<string, object>(TaskData);
* scr.SourceData = srcData;
* object obj = scr.EvalMultiInstanceSplitQuery();
* IEnumerable enu;
* if (obj is IEnumerable)
* enu = (IEnumerable)obj;
* else
* {
* ArrayList al = new ArrayList();
* al.Add(obj);
* enu = al;
* }
* List<Dictionary<string, object>> lst = new List<Dictionary<string, object>>();
*
* foreach (object v in enu)
* {
* srcData[tsk.MultiInstanceItemAlias] = v;
* lst.Add(ExecuteInputDataBindings(scr, tsk));
* }
* return lst;
*/
throw new NotImplementedException();
}
protected internal TimeLimitTaskTracker(TaskDef def)
{
this.timeLimit = int.Parse(def.TimeLimit, System.Globalization.CultureInfo.CurrentCulture);
this.stepReward = def.StepReward;
timeLeft = timeLimit;
}
public Task(TaskDef def)
{
this.def = def;
this.ticksToPerform = def.ticksToPerform;
}
public Task(TaskDef def, int ticksToPerform) : this(def) {
this.ticksToPerform = ticksToPerform;
}
public Task(TaskDef def, TargetList targets, int ticksToPerform) : this(def, targets)
{
this.ticksToPerform = ticksToPerform;
}
public Task(TaskDef def, TargetList targets) : this(def) {
this.targets = targets;
this.ticksToPerform = def.ticksToPerform;
}
