public async Task ProcessItemsAsync()
{
while (Items.Count > 0)
{
var item = Dequeue();
if (item == null)
{
continue;
}
try
{
_logger.LogTrace($"Processing work item {item.ToString()}");
TriggerResult triggerResult = await ProcessItemAsync(item);
await this.HandleTriggerResult(triggerResult, item);
}
catch (Exception ex)
{
_logger.LogError("Processing work item failed", ex, item);
item.Error = $"{ex.Message} - {ex.StackTrace}";
item.Retries++;
Enqueue(item);
}
}
await Task.CompletedTask;
}
public void TriggerResult_NewInstanceWithVariables_CreatesANewInstance()
{
// Arrange
var trigger = "SwitchOn";
Switcher switcher = new Switcher
{
Type = OnOffWorkflow.TYPE
};
var transitionContext = new TransitionContext(switcher);
var variable = new SwitcherWorkflowVariable(true);
transitionContext.SetVariable <SwitcherWorkflowVariable>(
SwitcherWorkflowVariable.KEY,
variable);
var canTrigger = true;
// Act
var result = new TriggerResult(trigger, transitionContext, canTrigger);
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.CanTrigger);
Assert.IsFalse(result.IsAborted);
Assert.AreSame(result.TriggerName, trigger);
Assert.IsFalse(result.HasErrors);
Assert.AreSame(result.CurrentState, switcher.State);
var v = result.GetVariable <SwitcherWorkflowVariable>(SwitcherWorkflowVariable.KEY);
Assert.IsNotNull(v);
Assert.IsTrue(v.CanSwitch);
}
public async Task <TriggerResult> CheckLinkedSecurityUser(EntityModel model, List <dynamic> entities, TriggerExecutionContext context, dynamic options)
{
foreach (var entity in entities)
{
entity.Name = entity.FirstName + " " + entity.LastName;
SecurityUser user = await SecurityUser.SelectByKey(entity.Id);
if (user == null)
{
user = new SecurityUser()
{
Id = entity.Id,
Name = entity.Name,
Email = entity.Email
};
await user.ApplyAsync();
}
else
{
if (user.Name != entity.Name || user.Email != entity.Email)
{
user.StartTracking();
user.Name = entity.Name;
user.Email = entity.Email;
await user.ApplyAsync();
}
}
await EmployeeBusiness.CheckDefaultRole(user.Id, "Users");
}
return(TriggerResult.Success());
}
public void it_should_not_be_possible_to_change_EventIds()
{
HttpResponseMessage response = Substitute.For<HttpResponseMessage>();
response.StatusCode = HttpStatusCode.OK;
response.Content = new StringContent(TriggerResultHelper.TRIGGER_RESPONSE_JSON);
var triggerResult = new TriggerResult(response, TriggerResultHelper.TRIGGER_RESPONSE_JSON);
triggerResult.EventIds.Add("fish", "pie");
}
public void it_should_not_be_possible_to_change_EventIds()
{
HttpResponseMessage response = Substitute.For <HttpResponseMessage>();
response.StatusCode = HttpStatusCode.OK;
response.Content = new StringContent(TriggerResultHelper.TRIGGER_RESPONSE_JSON);
var triggerResult = new TriggerResult(response, TriggerResultHelper.TRIGGER_RESPONSE_JSON);
triggerResult.EventIds.Add("fish", "pie");
}
public TriggerResult Trigger(TriggerParam param)
{
if (param == null)
{
throw new InvalidOperationException(nameof(param));
}
var entity = param.Instance as IEntityWorkflow;
if (entity == null)
{
throw new Exception("No entity given!");
}
TriggerResult result = null;
using (var transaction = this._context.Database.BeginTransaction())
{
try
{
Workflow workflow = null;
var execution = GetExecution(param.Instance.Type);
_context.SaveChanges(); // so entity id gets resolved!
workflow = FindOrCreate(
entity.Id,
param.Instance.Type,
param.Instance.State,
entity.Assignee
);
result = execution.Trigger(param);
if (!result.IsAborted)
{
PersistWorkflow(workflow, param);
_context.SaveChanges();
transaction.Commit();
}
}
catch (Exception ex)
{
transaction.Rollback();
_logger.LogError(
$"Error in triggering: {param.Instance.Type}, EntityId: {entity.Id}",
ex.StackTrace
);
}
}
return(result);
}
private async Task <TriggerResult> TriggerForPersistingInstance(TriggerParam param)
{
TriggerResult result;
using (var transaction = this.repository.Database.BeginTransaction())
{
try
{
Workflow workflow = null;
var execution = this.GetExecution(param.Instance.Type);
var entity = param.Instance as IWorkflowInstanceEntity;
await this.repository.ApplyChangesAsync(); // so entity id gets resolved!
workflow = await this.FindOrCreate(
entity.Id,
param.Instance.Type,
param.Instance.State
);
this.EnsureWorkflowVariables(workflow, param);
result = execution.Trigger(param);
if (!result.IsAborted)
{
await this.PersistWorkflow(workflow, param, result);
await this.repository.ApplyChangesAsync();
transaction.Commit();
}
}
catch (Exception ex)
{
transaction.Rollback();
this.logger.LogError(
"Trigger with TriggerParameter: {TriggerParameter} failed! {Exception}",
LogHelper.SerializeObject(param),
ex
);
var transitionContext = new TransitionContext(param.Instance);
transitionContext.AddError(ex.ToString());
result = new TriggerResult(
param.TriggerName,
transitionContext,
false
);
}
}
return(result);
}
private async Task PersistWorkflow(
Workflow workflow,
TriggerParam param,
TriggerResult result
)
{
if (workflow == null)
{
throw new ArgumentNullException(nameof(workflow));
}
// persisting workflow variables
if (param.HasVariables)
{
foreach (var v in param.Variables)
{
var variable = workflow.WorkflowVariables
.FirstOrDefault(variables => variables.Type == v.Key);
if (variable != null)
{
variable.Content = JsonConvert.SerializeObject(v.Value);
}
else
{
workflow.AddVariable(v.Value);
}
}
}
// keeping workflow entity nsync
var entity = param.Instance as IWorkflowInstanceEntity;
var assignableEntity = param.Instance as IAssignableWorkflow;
if (entity != null)
{
workflow.Type = entity.Type;
workflow.Assignee = assignableEntity.Assignee;
workflow.AddHistoryItem(workflow.State, entity.State, this.userContext.UserName);
workflow.State = entity.State;
}
// treating AutoTrigger
if (result.HasAutoTrigger)
{
this.repository.AddAutoTrigger(result.AutoTrigger, entity);
}
if (await this.WorkflowIsCompleted(param))
{
workflow.Completed = SystemTime.Now();
}
}
/// <summary>
/// Execute
/// </summary>
/// <returns></returns>
public TriggerResult Execute()
{
if (Operators.DefaultArg(botTriggerParameters.GetParameter <bool>("execute"), false))
{
FSharpList <MyBotParameter> myBotParameters = FSharpList <MyBotParameter> .Cons(new MyBotParameter("OpenBetPosition.Stake", 2.0), FSharpList <MyBotParameter> .Empty);
return(TriggerResult.NewExecuteActionBotOnSelectionWithParameters(selection, myBotParameters));
}
return(TriggerResult.EndExecution);
}
public async Task <ActionResult> DisplayTriggerResult()
{
var result = await _repository.CreateTrigger();
var model = new TriggerResult
{
Result = result
};
return(View(model));
}
/// <summary>
///
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
protected MarkupString FormatterResult(TriggerResult result)
{
var content = result switch
{
TriggerResult.Success => ("success", "成功"),
TriggerResult.Error => ("danger", "故障"),
TriggerResult.Cancelled => ("info", "取消"),
TriggerResult.Timeout => ("warning", "超時"),
_ => ("info", "未設置")
};
return(new MarkupString($"<button class=\"btn btn-sm btn-{content.Item1}\"><span>{content.Item2}<span></button>"));
}
public void CanTrigger_InitialStateIsOff_CanTriggerToStateOn()
{
// Arrange
Switcher switcher = new Switcher
{
Type = OnOffWorkflow.TYPE
};
WorkflowExecution execution = new WorkflowExecution(new OnOffWorkflow());
// Act
TriggerResult result = execution.CanTrigger(new TriggerParam("SwitchOn", switcher));
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(true, result.CanTrigger);
}
private WorkflowTriggerInfo ToWorkflowTriggerInfo(Holiday holiday, TriggerResult result = null)
{
WorkflowTriggerInfo info;
if (result == null || !result.HasErrors)
{
IEnumerable <TriggerResult> triggerResults = this._workflowEngine.GetTriggers(holiday);
var triggers = triggerResults.Select(x => x.TriggerName);
info = WorkflowTriggerInfo.createForSuccess(triggers);
}
else
{
info = WorkflowTriggerInfo.createForError(result.Errors);
}
return(info);
}
public async Task <TriggerResult> SetFields(EntityModel model, List <dynamic> entities, TriggerExecutionContext context, dynamic options)
{
DynamicEntity fields = options as DynamicEntity;
if (fields != null)
{
foreach (DynamicEntity entity in entities)
{
foreach (var field in fields.Dictionary)
{
entity.TrySetMember(field.Key, await ReplaceVariable(field.Value, model));
}
}
}
return(TriggerResult.Success());
}
public void Trigger_InitialStateIsOff_StateIsOn()
{
// Arrange
Switcher switcher = new Switcher
{
Type = OnOffWorkflow.TYPE
};
WorkflowExecution execution = new WorkflowExecution(new OnOffWorkflow());
// Act
TriggerResult result = execution.Trigger(new TriggerParam("SwitchOn", switcher));
// Assert
Assert.IsNotNull(switcher);
Assert.AreEqual("On", result.CurrentState);
Assert.IsNotNull(result);
Assert.AreEqual("SwitchOn", result.TriggerName);
}
private async Task HandleTriggerResult(TriggerResult triggerResult, WorkItem item)
{
if (triggerResult.HasErrors || triggerResult.IsAborted)
{
item.Error = string.Join(" - ", triggerResult.Errors);
_logger.LogError("HandleTriggerResult", item.Error, triggerResult);
item.Retries++;
Enqueue(item);
}
else
{
if (item.Id > 0)
{
// Delete it from db if it was once persisted!
await DeleteWorkItem(item);
}
}
}
public static TriggerResult CheckTrigger(IBehaviorExecutionContext context)
{
var result = new TriggerResult {Active = false};
if (context != null && !ExecutionComplete)
{
var gestureInfoList = context.GetGestureInfoList("Greet_Left");
var gestureInfo = gestureInfoList.FirstOrDefault(s=>s.Confidence > 90);
if (gestureInfo.Active && gestureInfo.Confidence > 90)
{
Console.WriteLine("Gesture trigger received : {0} - {1}", gestureInfo.Name, gestureInfo.Confidence);
result.HumanId = gestureInfo.HumanId;
result.HumanInLoop = true;
result.Active = true;
}
}
return result;
}
public void trigger(List <CommandParser.Command> commands, int fromIndex = 0)
{
for (int i = fromIndex; i < commands.Count; ++i)
{
_asyncCommands = null;
_asyncCommandIndex = -1;
TriggerResult result = trigger(commands[i].name, commands[i].args);
if (result == TriggerResult.Error)
{
break;
}
else if (result == TriggerResult.Async)
{
_asyncCommands = commands;
_asyncCommandIndex = i + 1;
break;
}
}
}
public void Trigger_InitialStateIsOn_StateIsOff()
{
// Arrange
Switcher switcher = new Switcher
{
Type = OnOffWorkflow.TYPE,
State = "On"
};
WorkflowExecution execution = new WorkflowExecution(new OnOffWorkflow());
// Act
TriggerResult result = execution.Trigger(new TriggerParam("SwitchOff", switcher));
// Assert
Assert.NotNull(switcher);
Assert.Equal("Off", result.CurrentState);
Assert.NotNull(result);
Assert.Equal("SwitchOff", result.TriggerName);
Assert.False(result.HasAutoTrigger);
}
public static async Task <WorkflowTriggerInfo> ToWorkflowTriggerInfo(
this IWorkflowEngineService workflowEngine,
IWorkflow instance,
TriggerResult result = null)
{
WorkflowTriggerInfo info;
if (result == null || !result.HasErrors)
{
IEnumerable <TriggerResult> triggerResults = await workflowEngine.GetTriggersAsync(instance);
var triggers = triggerResults.Select(x => x.TriggerName);
info = WorkflowTriggerInfo.createForSuccess(triggers);
}
else
{
info = WorkflowTriggerInfo.createForError(result.Errors);
}
return(info);
}
public void TriggerResult_NewInstance_CreatesANewInstance()
{
// Arrange
var trigger = "SwitchOn";
Switcher switcher = new Switcher
{
Type = OnOffWorkflow.TYPE
};
var transitionContext = new TransitionContext(switcher);
var canTrigger = true;
// Act
var result = new TriggerResult(trigger, transitionContext, canTrigger);
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.CanTrigger);
Assert.IsFalse(result.IsAborted);
Assert.AreSame(result.TriggerName, trigger);
Assert.IsFalse(result.HasErrors);
Assert.AreSame(result.CurrentState, switcher.State);
}
private async Task HandleTriggerResult(TriggerResult triggerResult, WorkItem item)
{
if (triggerResult.HasErrors || triggerResult.IsAborted)
{
item.Error = string.Join(" - ", triggerResult.Errors);
_logger.LogError(
"Bad TriggerResult: {TriggerResult}",
LogHelper.SerializeObject(triggerResult)
);
item.Retries++;
await Enqueue(item);
}
else
{
if (item.Id > 0)
{
// Delete it from db if it was once persisted!
await DeleteWorkItem(item);
}
}
}
public void CanTrigger_InitialStateIsOff_CanNotTriggerToStateOn()
{
// Arrange
Switcher switcher = new Switcher
{
Type = OnOffWorkflow.TYPE
};
WorkflowExecution execution = new WorkflowExecution(new OnOffWorkflow());
var variables = new Dictionary <string, WorkflowVariableBase>();
var variable = new SwitcherWorkflowVariable(false);
variables.Add(SwitcherWorkflowVariable.KEY, variable);
var triggerParam = new TriggerParam("SwitchOn", switcher, variables);
// Act
TriggerResult result = execution.CanTrigger(triggerParam);
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(false, result.CanTrigger);
}
public async Task ProcessItemsAsync()
{
_logger.LogTrace("Triggering job queue for doing work");
while (Items.Count > 0)
{
var item = Dequeue();
if (item == null)
{
continue;
}
TriggerResult triggerResult = await ProcessItemAsync(item);
if (triggerResult.HasErrors || triggerResult.IsAborted)
{
_logger.LogError(
"ProcessingWorkItemFailed",
string.Join("-", triggerResult.Errors),
triggerResult
);
item.Retries++;
Enqueue(item);
}
else
{
if (item.Id > 0)
{
// Delete it from db if it was once persisted!
await DeleteWorkItem(item);
}
}
}
await Task.CompletedTask;
}
public async Task <TriggerResult> InitDocument(EntityModel model, List <dynamic> entities, TriggerExecutionContext context, dynamic options)
{
var user = DWKitRuntime.Security.CurrentUser;
var schemes = DWKitRuntime.Metadata.GetWorkflowByForm(model.Name);
foreach (var entity in entities)
{
if (entity.Id == null)
{
var initialState = schemes.Count == 0 ?
new WorkflowState()
{
Name = "", SchemeCode = "", VisibleName = ""
} :
await WorkflowInit.Runtime.GetInitialStateAsync(schemes[0]);
entity.AuthorId = user.GetOperationUserId();
entity.author = user.GetOperationUserName();
entity.State = initialState.Name;
entity.stateName = initialState.VisibleName;
}
}
return(TriggerResult.Success());
}
public async Task <TriggerResult> TriggerAsync(TriggerParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
_logger.LogTrace("TriggerAsync {Instance}", JsonConvert.SerializeObject(
param.Instance,
new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
})
);
var entity = param.Instance as IEntityWorkflow;
if (entity == null)
{
// going the non EF way!
var execution = GetExecution(param.Instance.Type);
return(execution.Trigger(param));
}
TriggerResult result = null;
using (var transaction = _context.Database.BeginTransaction())
{
try
{
Workflow workflow = null;
var execution = GetExecution(param.Instance.Type);
await _context.SaveChangesAsync(); // so entity id gets resolved!
workflow = FindOrCreate(
entity.Id,
param.Instance.Type,
param.Instance.State,
entity.Assignee
);
EnsureWorkflowVariables(workflow, param);
result = execution.Trigger(param);
if (!result.IsAborted)
{
await PersistWorkflow(workflow, param);
await _context.SaveChangesAsync();
transaction.Commit();
}
}
catch (Exception ex)
{
transaction.Rollback();
_logger.LogError(
"TriggerAsync",
ex,
"TriggerAsync failed: {Param}",
JsonConvert.SerializeObject(param, new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
})
);
var transitionContext = new TransitionContext(param.Instance);
transitionContext.AddError(ex.ToString());
result = new TriggerResult(
param.TriggerName,
transitionContext,
false
);
}
}
return(result);
}
public bool ExecuteCyclic(IBehaviorExecutionContext context, TriggerResult trigger)
{
if (!CyclicActionsComplete && InitActionsComplete)
{
// CYCLIC_BLOCK
var var_af0d9ba5_7f8e_6560_8d24_b70a9ba0510b= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("Taro, we received a stop command.", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_af0d9ba5_7f8e_6560_8d24_b70a9ba0510b);
var var_3e5335a3_9a1f_a44a_be41_4d9a6ea6e64b= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Taro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("Yes, Let us go to rest position", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_3e5335a3_9a1f_a44a_be41_4d9a6ea6e64b);
var var_aa5dbbc8_6eea_8066_b55f_b7d1125178e2 = new List<Task>();
var var_71a15906_a3c2_8bd7_9262_a96cf5b603aa = new Action( () =>
{
var var_eba9448d_1a8b_7cea_9257_b15d34f07cc1= new BehaviorInfo
{
BehaviorName = "Take Rest",
RobotName = "Hiro",Parameters = new Dictionary<string, object>()
};
BehaviorModuleHelper.Execute(context, var_eba9448d_1a8b_7cea_9257_b15d34f07cc1);
});
var var_67c4371e_7f29_7ef8_83de_ba7819f3b264 = new Action( () =>
{
var var_189a9b7e_37dc_f4b2_9a38_b8bdbc780275= new BehaviorInfo
{
BehaviorName = "Take Rest",
RobotName = "Taro",Parameters = new Dictionary<string, object>()
};
BehaviorModuleHelper.Execute(context, var_189a9b7e_37dc_f4b2_9a38_b8bdbc780275);
});
var_aa5dbbc8_6eea_8066_b55f_b7d1125178e2.Add(Task.Run(var_71a15906_a3c2_8bd7_9262_a96cf5b603aa));
var_aa5dbbc8_6eea_8066_b55f_b7d1125178e2.Add(Task.Run(var_67c4371e_7f29_7ef8_83de_ba7819f3b264));
Task.WaitAll(var_aa5dbbc8_6eea_8066_b55f_b7d1125178e2.ToArray());
System.Console.WriteLine("Parallel action execution complete");
if (ExecutionLifetime == BehaviorExecutionLifetime.once)
{
CyclicActionsComplete = true;
}
else if (ExecutionLifetime == BehaviorExecutionLifetime.until)
{
var complete = ExecutionUntil(context);
CyclicActionsComplete = !complete;
}
}
return CyclicActionsComplete;
}
public bool ExecuteCyclic(IBehaviorExecutionContext context, TriggerResult trigger)
{
if (!CyclicActionsComplete && InitActionsComplete)
{
// CYCLIC_BLOCK
var var_ebbaffde_15bc_9860_a6bf_509b6d6a59a6 = new List<Task>();
var var_c9a06f4b_8778_dcec_bbc4_38221887afe2 = new Action( () =>
{
var var_58933fdd_5ef9_050e_8b8c_4bbd0c74246c= new BehaviorInfo{BehaviorName = "Dance",RobotName = "Hiro"};
BehaviorModuleHelper.Execute(context, var_58933fdd_5ef9_050e_8b8c_4bbd0c74246c);
});
var var_b0843968_09f4_bf69_b462_30f80c3d6d92 = new Action( () =>
{
var var_73dea3ca_51c6_79be_8608_d6d0d2e3743b= new BehaviorInfo{BehaviorName = "Dance",RobotName = "Taro"};
BehaviorModuleHelper.Execute(context, var_73dea3ca_51c6_79be_8608_d6d0d2e3743b);
});
var_ebbaffde_15bc_9860_a6bf_509b6d6a59a6.Add(Task.Run(var_c9a06f4b_8778_dcec_bbc4_38221887afe2));
var_ebbaffde_15bc_9860_a6bf_509b6d6a59a6.Add(Task.Run(var_b0843968_09f4_bf69_b462_30f80c3d6d92));
Task.WaitAll(var_ebbaffde_15bc_9860_a6bf_509b6d6a59a6.ToArray());
System.Console.WriteLine("Parallel action execution complete");
if (ExecutionLifetime == BehaviorExecutionLifetime.once)
{
CyclicActionsComplete = true;
}
else if (ExecutionLifetime == BehaviorExecutionLifetime.until)
{
var complete = ExecutionUntil(context);
CyclicActionsComplete = !complete;
}
}
return CyclicActionsComplete;
}
public bool ExecuteCyclic(IBehaviorExecutionContext context, TriggerResult trigger)
{
if (!CyclicActionsComplete && InitActionsComplete)
{
// CYCLIC_BLOCK
var var_e13f4a25_80e3_f7f2_a729_20d6aee5d4ba= new BehaviorInfo
{
BehaviorName = "Move To",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"translation", BehaviorModuleHelper.CreateBehaviorParameterOptions("0", false, "float")},
{"rotation", BehaviorModuleHelper.CreateBehaviorParameterOptions("1", false, "float")},
{"human", BehaviorModuleHelper.CreateBehaviorParameterOptions("1", false, "float")},
{"dist", BehaviorModuleHelper.CreateBehaviorParameterOptions(1.50, false, "float")},
{"x", BehaviorModuleHelper.CreateBehaviorParameterOptions(0.0, true, "float")},
{"y", BehaviorModuleHelper.CreateBehaviorParameterOptions(0.0, true, "float")},
{"theta", BehaviorModuleHelper.CreateBehaviorParameterOptions(0.0, true, "float")}
}
};
if (context.RefreshApproachParameters(var_e13f4a25_80e3_f7f2_a729_20d6aee5d4ba, trigger)) {
BehaviorModuleHelper.Execute(context, var_e13f4a25_80e3_f7f2_a729_20d6aee5d4ba);
}
var var_32c9179f_0614_11f8_bd1a_a0649c1d0667= new BehaviorInfo
{
BehaviorName = "Move To",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"translation", BehaviorModuleHelper.CreateBehaviorParameterOptions("1", false, "float")},
{"rotation", BehaviorModuleHelper.CreateBehaviorParameterOptions("0", false, "float")},
{"human", BehaviorModuleHelper.CreateBehaviorParameterOptions("1", false, "float")},
{"dist", BehaviorModuleHelper.CreateBehaviorParameterOptions(1.50, false, "float")},
{"x", BehaviorModuleHelper.CreateBehaviorParameterOptions(1.50, true, "float")},
{"y", BehaviorModuleHelper.CreateBehaviorParameterOptions(0.0, true, "float")},
{"theta", BehaviorModuleHelper.CreateBehaviorParameterOptions(0.0, true, "float")}
}
};
if (context.RefreshApproachParameters(var_32c9179f_0614_11f8_bd1a_a0649c1d0667, trigger)) {
BehaviorModuleHelper.Execute(context, var_32c9179f_0614_11f8_bd1a_a0649c1d0667);
}
var var_d2a5e02f_8c19_33cc_b240_3413036630d9= new BehaviorInfo{BehaviorName = "wish",RobotName = "Hiro"};
BehaviorModuleHelper.Execute(context, var_d2a5e02f_8c19_33cc_b240_3413036630d9);
var var_4330a2d9_5d64_7429_b18b_06083d44a70c= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("I am Nao! Welcome to Edo-Tokyo museum.", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_4330a2d9_5d64_7429_b18b_06083d44a70c);
var var_dcbc2f6b_2259_fd93_8d04_797fa191107c= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("The Edo-Tokyo museum is a museum of the history of Tokyo during the Edo period", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_dcbc2f6b_2259_fd93_8d04_797fa191107c);
var var_d6b52600_4ab0_f757_af15_6dd8587e5942= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("It was established in 1993", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_d6b52600_4ab0_f757_af15_6dd8587e5942);
var var_22bdaaf8_a7e1_dca9_b981_f684fe9a8dc3= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("It has lifetime replica of the Nihonbashi, which was the bridge leading into Edo", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_22bdaaf8_a7e1_dca9_b981_f684fe9a8dc3);
var var_6bb0f235_782b_5862_b6ac_80bd1345d345= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("It also has scaled down models of towns and building from the Edo, Meiji and Showa periods", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_6bb0f235_782b_5862_b6ac_80bd1345d345);
var var_37cdbb14_89b3_3d26_a4a5_a1d9bc2ec861= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("The museum was designed by Kiyonori Kikutake", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_37cdbb14_89b3_3d26_a4a5_a1d9bc2ec861);
var var_2c28ab2f_d8fa_9b1f_820e_bd3f802bf637= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("I hope you will enjoy your visit to Edo-Tokyo museum", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_2c28ab2f_d8fa_9b1f_820e_bd3f802bf637);
var var_c76e0ccc_3577_ba62_9f4d_394436f0b6cc= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions("Have a nice day!", true, "string")}
}
};
BehaviorModuleHelper.Execute(context, var_c76e0ccc_3577_ba62_9f4d_394436f0b6cc);
if (ExecutionLifetime == BehaviorExecutionLifetime.once)
{
CyclicActionsComplete = true;
}
else if (ExecutionLifetime == BehaviorExecutionLifetime.until)
{
var complete = ExecutionUntil(context);
CyclicActionsComplete = !complete;
}
}
return CyclicActionsComplete;
}
public TriggerResultException(TriggerResult r)
{
status = r;
}
private async Task ProcessItemInternal(WorkItem item)
{
TriggerResult triggerResult = await this.ProcessItemAsync(item);
await this.HandleTriggerResult(triggerResult, item);
}
public bool ExecuteExit(IBehaviorExecutionContext context, TriggerResult trigger)
{
if (!ExitActionsComplete && CyclicActionsComplete)
{
// EXIT_BLOCK
// EXIT_BLOCK_HERE
ExitActionsComplete = true;
}
return ExitActionsComplete;
}
public void it_should_have_no_event_id_value_when_a_v7_protocol_200_response_is_returned()
{
var triggerResult = new TriggerResult(V7_PROTOCOL_SUCCESSFUL_RESPONSE, "{}");
Assert.AreEqual(0, triggerResult.EventIds.Count);
}
public TriggerResultException(TriggerResult r)
{
status = r;
}
public void it_should_treat_a_v7_protocol_200_response_as_a_successful_request()
{
var triggerResult = new TriggerResult(V7_PROTOCOL_SUCCESSFUL_RESPONSE, "{}");
Assert.AreEqual(HttpStatusCode.OK, triggerResult.StatusCode);
}
private async Task <TriggerResult> TriggerForPersistingInstance(TriggerParam param)
{
TriggerResult result;
var entity = param.Instance as IEntityWorkflow;
using (var transaction = _context.Database.BeginTransaction())
{
try
{
Workflow workflow = null;
var execution = GetExecution(param.Instance.Type);
await _context.SaveChangesAsync(); // so entity id gets resolved!
workflow = FindOrCreate(
entity.Id,
param.Instance.Type,
param.Instance.State,
entity.Assignee
);
EnsureWorkflowVariables(workflow, param);
result = execution.Trigger(param);
if (!result.IsAborted)
{
await PersistWorkflow(workflow, param);
if (result.HasAutoTrigger)
{
CreateWorkItemEntry(result.AutoTrigger, entity);
}
await _context.SaveChangesAsync();
transaction.Commit();
}
}
catch (Exception ex)
{
transaction.Rollback();
_logger.LogError(
"Trigger with TriggerParameter: {TriggerParameter} failed! {Exception}",
LogHelper.SerializeObject(param),
ex
);
var transitionContext = new TransitionContext(param.Instance);
transitionContext.AddError(ex.ToString());
result = new TriggerResult(
param.TriggerName,
transitionContext,
false
);
}
}
return(result);
}
public static TriggerResult CheckTrigger(IBehaviorExecutionContext context)
{
var result = new TriggerResult {Active = false};
if (context != null && !ExecutionComplete)
{
var voiceCommand = context.GetVoiceCommand("STOP");
if (voiceCommand.Active && voiceCommand.Confidence > 80)
{
Console.WriteLine("Voice trigger received : {0} - {1}", voiceCommand.Name, voiceCommand.Confidence);
result.Active = true;
}
}
return result;
}
public bool ExecuteInit(IBehaviorExecutionContext context, TriggerResult trigger)
{
if (!InitActionsComplete)
{
// INIT_BLOCK
// INIT_BLOCK_HERE
InitActionsComplete = true;
}
return InitActionsComplete;
}
public void it_should_have_no_event_id_value_when_a_v7_protocol_200_response_is_returned()
{
var triggerResult = new TriggerResult(V7_PROTOCOL_SUCCESSFUL_RESPONSE, "{}");
Assert.AreEqual(0, triggerResult.EventIds.Count);
}
public bool ExecuteCyclic(IBehaviorExecutionContext context, TriggerResult trigger)
{
if (!CyclicActionsComplete && InitActionsComplete)
{
// CYCLIC_BLOCK
if (count == 1) {
var var_4cb4bb22_b20c_ffff_82d4_9a629b6d9712= string.Format("You have completed the exercise {0} time!",count);
var var_aab31148_d989_dbc4_99a9_607c437ff1f9= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions(var_4cb4bb22_b20c_ffff_82d4_9a629b6d9712, true, "string")},
}
};
BehaviorModuleHelper.Execute(context, var_aab31148_d989_dbc4_99a9_607c437ff1f9);
} else {
var var_474e66e3_dfef_9670_b4a0_9dca1102d7ba= string.Format("You have completed the exercise {0} times!",count);
var var_64f27bb6_60e3_0d16_b68b_52c3ee3e11ed= new BehaviorInfo
{
BehaviorName = "Say Expressively",
RobotName = "Hiro",Parameters = new Dictionary<string, object>
{
{"msg", BehaviorModuleHelper.CreateBehaviorParameterOptions(var_474e66e3_dfef_9670_b4a0_9dca1102d7ba, true, "string")},
}
};
BehaviorModuleHelper.Execute(context, var_64f27bb6_60e3_0d16_b68b_52c3ee3e11ed);
}
if (ExecutionLifetime == BehaviorExecutionLifetime.once)
{
CyclicActionsComplete = true;
}
else if (ExecutionLifetime == BehaviorExecutionLifetime.until)
{
var complete = ExecutionUntil(context);
CyclicActionsComplete = !complete;
}
}
return CyclicActionsComplete;
}
public void it_should_treat_a_v7_protocol_200_response_as_a_successful_request()
{
var triggerResult = new TriggerResult(V7_PROTOCOL_SUCCESSFUL_RESPONSE, "{}");
Assert.AreEqual(HttpStatusCode.OK, triggerResult.StatusCode);
}
public bool Execute(IBehaviorExecutionContext context, TriggerResult trigger)
{
try
{
ExecuteInit(context, trigger);
ExecuteCyclic(context, trigger);
ExecuteExit(context, trigger);
System.Console.WriteLine(@"Lifetime: {3} Init : {0}, Cyclic: {1}, Exit: {2}", InitActionsComplete,
CyclicActionsComplete,
ExitActionsComplete, ExecutionLifetime);
}
catch (BehaviorCanceledException ex)
{
Console.WriteLine(@"Execution canceled : {0}, {1} ,{2}", GetUid(), ex.Message, ex.StackTrace);
}
return ExecutionComplete;
}
private async Task <TriggerResult> TriggerForPersistingInstance(TriggerParam param)
{
TriggerResult result;
var dbFacadeRepository = this.repository as IDatabaseFacadeRepository;
if (dbFacadeRepository == null)
{
var msg = "Please register a custom IWorkflowEngineService - implementation!"
+ Environment.NewLine + "The default implementation relies on a "
+ "transactional database that exposes the DatabaseFacade property "
+ "in the Microsoft.EntityFrameworkCore.Infrastructure namespace.";
throw new InvalidOperationException(msg);
}
using (var transaction = dbFacadeRepository.Database.BeginTransaction())
{
try
{
Workflow workflow = null;
var execution = this.GetExecution(param.Instance.Type);
var entity = param.Instance as IWorkflowInstanceEntity;
await this.repository.ApplyChangesAsync(); // so entity id gets resolved!
workflow = await this.FindOrCreate(
entity.Id,
param.Instance.Type,
param.Instance.State
);
this.EnsureWorkflowVariables(workflow, param);
result = execution.Trigger(param);
if (!result.IsAborted)
{
await this.PersistWorkflow(workflow, param, result);
await this.repository.ApplyChangesAsync();
transaction.Commit();
}
}
catch (Exception ex)
{
transaction.Rollback();
this.logger.LogError(
"Trigger with TriggerParameter: {TriggerParameter} failed! {Exception}",
LogHelper.SerializeObject(param),
ex
);
var transitionContext = new TransitionContext(param.Instance);
transitionContext.AddError(ex.ToString());
result = new TriggerResult(
param.TriggerName,
transitionContext,
false
);
}
}
return(result);
}
