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);
}
public void TransitionContext_AddError_TransitionHasErrors()
{
// Arrange
Switcher switcher = new Switcher
{
Type = OnOffWorkflow.TYPE
};
var context = new TransitionContext(switcher);
var error = "Some error";
// Act
context.AddError(error);
// Assert
Assert.IsNotNull(context);
Assert.IsFalse(context.HasVariables);
Assert.IsTrue(context.HasErrors);
}
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);
}
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);
}
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);
}
public async Task <TriggerResult> TriggerAsync(TriggerParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
var entity = param.Instance as IEntityWorkflow;
if (entity == null)
{
// going the non EF way!
_logger.LogTrace($@"Processing a non '${param.Instance.Type}'
entity instance.");
var execution = GetExecution(param.Instance.Type);
return(execution.Trigger(param));
}
TriggerResult result = null;
using (var transaction = _context.Database.BeginTransaction())
{
try
{
Workflow workflow = null;
_logger.LogTrace($@"Processing an '${param.Instance.Type}'
entity instance with Id = ${entity.Id}.");
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(
ex,
$"Error in triggering: {param.Instance.Type}, EntityId: {entity.Id}"
);
var transitionContext = new TransitionContext(param.Instance);
transitionContext.AddError(ex.ToString());
result = new TriggerResult(
param.TriggerName,
transitionContext,
false
);
}
}
return(result);
}