private IList <WorkflowTransition> ToWorkflowTransitions(IEnumerable <SqlWorkflowTransition> sqlWorkflowTransitions, int currentUserId)
{
return(sqlWorkflowTransitions.Select(wt =>
{
var transition = new WorkflowTransition
{
Id = wt.WorkflowEventId,
ToState = new WorkflowState
{
WorkflowId = wt.WorkflowId,
Id = wt.ToStateId,
Name = wt.ToStateName
},
FromState = new WorkflowState
{
WorkflowId = wt.WorkflowId,
Id = wt.FromStateId,
Name = wt.FromStateName
},
Name = string.IsNullOrWhiteSpace(wt.WorkflowEventName) ?
$"To: {wt.ToStateName}" :
wt.WorkflowEventName,
WorkflowId = wt.WorkflowId
};
transition.Triggers.AddRange(ToWorkflowTriggers(SerializationHelper.FromXml <XmlWorkflowEventTriggers>(wt.Triggers), currentUserId));
return transition;
}).ToList());
}
/// <summary>
/// Creates the workflow.
/// </summary>
/// <param name="id">Id to use for this workflow.</param>
/// <param name="externalServiceUrl">External URL to invoke.</param>
/// <param name="serviceIdentityTokenSource">The token source to use when authenticating to external services.</param>
/// <param name="serializerSettingsProvider">The serialization settings provider.</param>
/// <param name="externalServiceActionLogger">The logger for <see cref="InvokeExternalServiceAction"/>s.</param>
/// <returns>The workflow definition.</returns>
public static Workflow Create(
string id,
string externalServiceUrl,
IServiceIdentityAccessTokenSource serviceIdentityTokenSource,
IJsonSerializerSettingsProvider serializerSettingsProvider,
ILogger <InvokeExternalServiceAction> externalServiceActionLogger)
{
var workflow = new Workflow(
id,
"External Action workflow",
"Simple workflow using an external action");
WorkflowState waitingToRun = workflow.CreateState(displayName: "Waiting to run");
WorkflowState done = workflow.CreateState(displayName: "Done");
workflow.SetInitialState(waitingToRun);
WorkflowTransition transition = waitingToRun.CreateTransition(done);
var action = new InvokeExternalServiceAction(
serviceIdentityTokenSource,
serializerSettingsProvider,
externalServiceActionLogger)
{
Id = Guid.NewGuid().ToString(),
AuthenticateWithManagedServiceIdentity = true,
MsiAuthenticationResource = "foobar",
ExternalUrl = externalServiceUrl,
ContextItemsToInclude = new[] { "include1", "include2" },
};
transition.Actions.Add(action);
return(workflow);
}
public void AggregateActionTests()
{
//arrange
var actionList = new List <IAction <string, Customer> >
{
new ActionOne(),
new ActionTwo()
};
var sut = new AggregateAction <string, Customer>(actionList);
var customer = new Customer {
Id = 2, Name = "Test Customer"
};
var wf = new DefaultWorkflow <Customer>(Guid.NewGuid().ToString(),
Mock.SimpleWorkflowDefinition(),
customer);
var graph = wf.ToDotGraph();
graph.ShouldNotBeNullOrEmpty();
output.WriteLine(graph);
var trigger = wf.PermittedTriggers.First();
var state = wf.CurrentState;
var transition = new WorkflowTransition <string, Customer>();
sut.Execute(wf, transition);
}
public static WorkflowTransitionDto FromDomain(WorkflowTransition transition)
{
var result = new WorkflowTransitionDto {
Expression = transition.Expression, Roles = transition.Roles?.ToArray()
};
return(result);
}
public static void AddTraceAction(this WorkflowTransition transition)
{
var action = new TraceAction {
Message = $"Executing transition '{transition.DisplayName}'"
};
transition.Actions.Add(action);
}
public void WorkflowTransitionCollectionAddNew()
{
var sut = new WorkflowTransitionCollection<string,Customer>();
var t = new WorkflowTransition<string,Customer>(new WorkflowState<string, Customer>("Start"),
new WorkflowState<string,Customer>("End"),
new WorkflowTrigger<string>("trigger1"));
sut.Add(t);
sut.Count.ShouldBe(1);
}
public static WorkflowTransitionDto?FromWorkflowTransition(WorkflowTransition transition)
{
if (transition == null)
{
return(null);
}
return(new WorkflowTransitionDto {
Expression = transition.Expression, Roles = transition.Roles
});
}
public WorkflowTransition ToTransition()
{
var roles = Roles;
if (!string.IsNullOrEmpty(Role))
{
roles = new[] { Role };
}
return(WorkflowTransition.When(Expression, roles));
}
private void UpdateWorkflowState(IWorkflow workflow, WorkflowResult result, WorkflowTransition transition)
{
if (result.NewState.Name != null && (workflow.CurrentState == null || result.NewState.Name != workflow.CurrentState.Name))
{
workflow.CurrentState = result.NewState;
if (transition != null)
{
workflow.CurrentState.Entry = transition;
}
}
}
private bool CanUse(WorkflowTransition transition, NamedContentData data, ClaimsPrincipal user)
{
if (!string.IsNullOrWhiteSpace(transition.Role))
{
if (!user.Claims.Any(x => x.Type == ClaimTypes.Role && x.Value == transition.Role))
{
return(false);
}
}
if (!string.IsNullOrWhiteSpace(transition.Expression))
{
return(scriptEngine.Evaluate("data", data, transition.Expression));
}
return(true);
}
/// <summary>
/// Processes the specified workflow, executing the specified <paramref name="transition"/> with the given <paramref name="request"/>
/// </summary>
/// <param name="workflow">The workflow.</param>
/// <param name="transition">The transition.</param>
/// <param name="request">The request.</param>
public void Process(IWorkflow workflow, WorkflowTransition transition, WorkflowRequest request)
{
Log.DebugFormat("Process({0}, {1}, {2})", workflow, transition, request);
//TODO: Block concurrent calls to Start/Process?
Unloaded.Reset();
Result = new WorkflowResult();
Application = CreateWorkflowApplication(null);
if (!CheckForRunnableInstance())
{
Application.Load(workflow.WorkflowInstanceId);
}
else
{
Application.LoadRunnableInstance();
}
Application.ResumeBookmark(transition.Name, request);
}
/// <summary>
/// Processes the specified activity.
/// </summary>
/// <param name="activity">The activity.</param>
/// <param name="workflow">The workflow.</param>
/// <param name="transition">The transition.</param>
/// <param name="request">The request.</param>
/// <param name="timeout">The timeout.</param>
public void Process(Activity activity, IWorkflow workflow, WorkflowTransition transition, WorkflowRequest request, TimeSpan timeout)
{
//Guard.AgainstNull(() => activity);
//Guard.AgainstNull(() => workflow);
//Guard.AgainstNull(() => transition);
//Guard.AgainstNull(() => request);
var instance = new IntellitideWorkflowInstance(activity, FrameworkEnvironment.Instance.Container);
using (new TransactionScope(TransactionScopeOption.Suppress))
{
instance.Process(workflow, transition, request);
if (!instance.WaitOne(timeout))
{
throw new TimeoutException("Timeout waiting for unload from workflow engine");
}
}
UpdateWorkflowState(workflow, instance.Result, transition);
}
/// <summary>
/// Processes the specified workflow, executing the specified <paramref name="transition"/> with the given <paramref name="request"/>
/// </summary>
/// <param name="workflow">The workflow.</param>
/// <param name="transition">The transition.</param>
/// <param name="request">The request.</param>
public void Process(WorkflowInstance workflow, WorkflowTransition transition, WorkflowRequest request)
{
Log.Debug($"Process({workflow}, {transition}, {request})");
//TODO: Block concurrent calls to Start/Process?
Unloaded.Reset();
Result = new WorkflowResult();
Application = CreateWorkflowApplication(workflow, false);
//UnloadApplication(Application);
if (!CheckForRunnableInstance())
{
Application.Load(workflow.InstanceId);
}
else
{
Application.LoadRunnableInstance();
}
Application.ResumeBookmark(transition.Name, request);
}
public void Should_serialize_and_deserialize()
{
var workflow = new Workflow(
Status.Draft, new Dictionary <Status, WorkflowStep>
{
[Status.Draft] = new WorkflowStep(
new Dictionary <Status, WorkflowTransition>
{
[Status.Published] = WorkflowTransition.When("Expression", "Role1", "Role2")
},
"#00ff00",
NoUpdate.When("Expression", "Role1", "Role2"))
}, new List <DomainId> {
DomainId.NewGuid()
}, "MyName");
var serialized = workflow.SerializeAndDeserialize();
serialized.Should().BeEquivalentTo(workflow);
}
public void Should_serialize_and_deserialize()
{
var workflow = new Workflow(
Status.Draft,
new Dictionary <Status, WorkflowStep>
{
[Status.Draft] = new WorkflowStep(
new Dictionary <Status, WorkflowTransition>
{
[Status.Published] = WorkflowTransition.When("Expression", "Role1", "Role2")
}.ToReadonlyDictionary(),
"#00ff00",
NoUpdate.When("Expression", "Role1", "Role2"))
}.ToReadonlyDictionary(),
ReadonlyList.Create(DomainId.NewGuid()), "MyName");
var serialized = workflow.SerializeAndDeserialize();
Assert.Equal(workflow, serialized);
}
public async Task ExecuteInternal_WhenSynchronouTriggersErrors_ThrowsConflictException()
{
// Arrange
_artifactVersionsRepository.Setup(t => t.IsItemDeleted(ArtifactId))
.ReturnsAsync(false);
_applicationSettingsRepositoryMock.Setup(t => t.GetTenantInfo(It.IsAny <IDbTransaction>())).ReturnsAsync(new TenantInfo()
{
TenantId = Guid.NewGuid().ToString()
});
var vcArtifactInfo = new VersionControlArtifactInfo
{
Id = ArtifactId,
VersionCount = CurrentVersionId,
LockedByUser = new UserGroup
{
Id = UserId
}
};
_artifactVersionsRepository.Setup(t => t.GetVersionControlArtifactInfoAsync(ArtifactId, null, UserId))
.ReturnsAsync(vcArtifactInfo);
var fromState = new WorkflowState
{
Id = FromStateId,
WorkflowId = WorkflowId,
Name = "Ready"
};
_workflowRepository.Setup(t => t.GetStateForArtifactAsync(UserId, ArtifactId, int.MaxValue, true))
.ReturnsAsync(fromState);
var toState = new WorkflowState
{
Id = ToStateId,
Name = "Close",
WorkflowId = WorkflowId
};
var transition = new WorkflowTransition()
{
FromState = fromState,
Id = TransitionId,
ToState = toState,
WorkflowId = WorkflowId,
Name = "Ready to Closed"
};
_workflowRepository.Setup(
t => t.GetTransitionForAssociatedStatesAsync(UserId, ArtifactId, WorkflowId, FromStateId, ToStateId, TransitionId))
.ReturnsAsync(transition);
var workflowEventAction = new Mock <IWorkflowEventAction>();
workflowEventAction.Setup(a => a.ValidateAction(It.IsAny <IExecutionParameters>())).Returns(new PropertySetResult(-1, -1, ""));
var triggerContainer = new WorkflowTriggersContainer();
triggerContainer.SynchronousTriggers.Add(new WorkflowEventTrigger()
{
Action = workflowEventAction.Object,
Name = "Test'"
});
_workflowRepository.Setup(
t => t.GetWorkflowEventTriggersForTransition(UserId, ArtifactId, WorkflowId, FromStateId, ToStateId, TransitionId))
.ReturnsAsync(triggerContainer);
_workflowRepository.Setup(t => t.ChangeStateForArtifactAsync(UserId, ArtifactId, It.IsAny <WorkflowStateChangeParameterEx>(), It.IsAny <IDbTransaction>()))
.ReturnsAsync((WorkflowState)null);
// Act
await _stateChangeExecutor.Execute();
}
public WorkflowTransition ToWorkflowTransition()
{
return WorkflowTransition.When(Expression, Roles);
}
public async Task ExecuteInternal_StateChangeAndPublish_CallsBoth()
{
// Arrange
_artifactVersionsRepository.Setup(t => t.IsItemDeleted(ArtifactId))
.ReturnsAsync(false);
_applicationSettingsRepositoryMock.Setup(t => t.GetTenantInfo(It.IsAny <IDbTransaction>())).ReturnsAsync(new TenantInfo()
{
TenantId = Guid.NewGuid().ToString()
});
var vcArtifactInfo = new VersionControlArtifactInfo
{
Id = ArtifactId,
VersionCount = CurrentVersionId,
LockedByUser = new UserGroup
{
Id = UserId
}
};
_artifactVersionsRepository.Setup(t => t.GetVersionControlArtifactInfoAsync(ArtifactId, null, UserId))
.ReturnsAsync(vcArtifactInfo);
var fromState = new WorkflowState
{
Id = FromStateId,
WorkflowId = WorkflowId,
Name = "Ready"
};
_workflowRepository.Setup(t => t.GetStateForArtifactAsync(UserId, ArtifactId, int.MaxValue, true))
.ReturnsAsync(fromState);
var toState = new WorkflowState
{
Id = ToStateId,
Name = "Close",
WorkflowId = WorkflowId
};
var transition = new WorkflowTransition()
{
FromState = fromState,
Id = TransitionId,
ToState = toState,
WorkflowId = WorkflowId,
Name = "Ready to Closed"
};
_workflowRepository.Setup(
t => t.GetTransitionForAssociatedStatesAsync(UserId, ArtifactId, WorkflowId, FromStateId, ToStateId, TransitionId))
.ReturnsAsync(transition);
_workflowRepository.Setup(
t => t.GetWorkflowEventTriggersForTransition(UserId, ArtifactId, WorkflowId, FromStateId, ToStateId, TransitionId))
.ReturnsAsync(new WorkflowTriggersContainer());
_workflowRepository.Setup(t => t.ChangeStateForArtifactAsync(UserId, ArtifactId, It.IsAny <WorkflowStateChangeParameterEx>(), It.IsAny <IDbTransaction>()))
.ReturnsAsync((WorkflowState)null);
// Act
await _stateChangeExecutor.Execute();
// Assert
_workflowRepository.Verify(t => t.GetStateForArtifactAsync(UserId, ArtifactId, int.MaxValue, true));
_versionControlService.Verify(t => t.PublishArtifacts(It.IsAny <PublishParameters>(), It.IsAny <IDbTransaction>()));
}
public async Task ExecuteInternal_CouldNotChangeState_ReturnsFailedResult()
{
// Arrange
_artifactVersionsRepository.Setup(t => t.IsItemDeleted(ArtifactId))
.ReturnsAsync(false);
_applicationSettingsRepositoryMock.Setup(t => t.GetTenantInfo(It.IsAny <IDbTransaction>())).ReturnsAsync(new TenantInfo()
{
TenantId = Guid.NewGuid().ToString()
});
var vcArtifactInfo = new VersionControlArtifactInfo
{
Id = ArtifactId,
VersionCount = CurrentVersionId,
LockedByUser = new UserGroup
{
Id = UserId
}
};
_artifactVersionsRepository.Setup(t => t.GetVersionControlArtifactInfoAsync(ArtifactId, null, UserId))
.ReturnsAsync(vcArtifactInfo);
var fromState = new WorkflowState
{
Id = FromStateId,
WorkflowId = WorkflowId,
Name = "Ready"
};
_workflowRepository.Setup(t => t.GetStateForArtifactAsync(UserId, ArtifactId, int.MaxValue, true))
.ReturnsAsync(fromState);
var toState = new WorkflowState
{
Id = ToStateId,
Name = "Close",
WorkflowId = WorkflowId
};
var transition = new WorkflowTransition()
{
FromState = fromState,
Id = TransitionId,
ToState = toState,
WorkflowId = WorkflowId,
Name = "Ready to Closed"
};
_workflowRepository.Setup(
t => t.GetTransitionForAssociatedStatesAsync(UserId, ArtifactId, WorkflowId, FromStateId, ToStateId, TransitionId))
.ReturnsAsync(transition);
_workflowRepository.Setup(
t => t.GetWorkflowEventTriggersForTransition(UserId, ArtifactId, WorkflowId, FromStateId, ToStateId, TransitionId))
.ReturnsAsync(new WorkflowTriggersContainer());
_workflowRepository.Setup(t => t.ChangeStateForArtifactAsync(UserId, ArtifactId, It.IsAny <WorkflowStateChangeParameterEx>(), It.IsAny <IDbTransaction>()))
.ReturnsAsync((WorkflowState)null);
// Act
var result = await _stateChangeExecutor.Execute();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(QueryResultCode.Failure, result.ResultCode);
}
public JsonWorkflowTransition(WorkflowTransition transition)
{
Roles = transition.Roles?.ToArray();
Expression = transition.Expression;
}
public async Task GetTransitionsAsync_ChangeStateForArtifactAsync_SuccessfullyCallsRepo()
{
// Arrange
int itemId = 1;
int userId = 1;
int workflowId = 4;
int fromStateId = 2;
int toStateId = 5;
const int transitionId = 10;
var vcArtifactInfo = new VersionControlArtifactInfo
{
Id = itemId,
VersionCount = 10,
LockedByUser = new UserGroup
{
Id = userId
}
};
_artifactVersionsRepositoryMock.Setup(t => t.IsItemDeleted(itemId))
.ReturnsAsync(false);
_artifactVersionsRepositoryMock.Setup(t => t.GetVersionControlArtifactInfoAsync(itemId, null, 1))
.ReturnsAsync(vcArtifactInfo);
_applicationSettingsRepositoryMock.Setup(t => t.GetTenantInfo(It.IsAny <IDbTransaction>())).ReturnsAsync(new TenantInfo()
{
TenantId = Guid.NewGuid().ToString()
});
var wfStateChangeParam = new WorkflowStateChangeParameter
{
CurrentVersionId = 10,
ToStateId = toStateId,
FromStateId = fromStateId,
TransitionId = transitionId
};
var fromState = new WorkflowState
{
Id = fromStateId,
WorkflowId = workflowId,
Name = "Ready"
};
var toState = new WorkflowState
{
Id = toStateId,
Name = "Close",
WorkflowId = workflowId
};
_workflowRepositoryMock.Setup(t => t.GetStateForArtifactAsync(userId, itemId, int.MaxValue, true))
.ReturnsAsync(fromState);
var transition = new WorkflowTransition()
{
FromState = fromState,
Id = transitionId,
ToState = toState,
WorkflowId = workflowId,
Name = "Ready to Closed"
};
_workflowRepositoryMock.Setup(
t => t.GetTransitionForAssociatedStatesAsync(userId, itemId, workflowId, fromStateId, toStateId, transitionId))
.ReturnsAsync(transition);
_workflowRepositoryMock.Setup(
t => t.GetWorkflowEventTriggersForTransition(userId, itemId, workflowId, fromStateId, toStateId, transitionId))
.ReturnsAsync(new WorkflowTriggersContainer());
_workflowRepositoryMock.Setup(t => t.ChangeStateForArtifactAsync(1, itemId, It.IsAny <WorkflowStateChangeParameterEx>(), It.IsAny <IDbTransaction>()))
.ReturnsAsync(toState);
// Act
var result = await _workflowServiceMock.ChangeStateForArtifactAsync(1, "admin", itemId, wfStateChangeParam);
// Assert
Assert.AreEqual(toState, result.Item);
Assert.AreEqual(QueryResultCode.Success, result.ResultCode);
}
/// <summary>
/// Creates an instance of a ficticious workflow for testing purposes.
/// </summary>
/// <param name="id">The id to give the new workflow.</param>
/// <param name="workflowMessageQueue">The message queue to send workflow messages via.</param>
/// <returns>
/// The new <see cref="Workflow" />.
/// </returns>
/// <remarks>
/// <para>
/// The workflow generated is shown in the following diagram:
/// </para>
/// <code>
/// Start
/// |
/// |
/// +-------v-------+
/// | |
/// | Initializing |
/// | |
/// +-------+-------+
/// |
/// | Create
/// |
/// +-------v-------+
/// | |
/// | Waiting for |
/// +------+ documentation |
/// | | |
/// | +-------+-------+
/// | |
/// Edit | Publish
/// (incomplete) |
/// | +-------v-------+ +---------------+
/// | | | | |
/// +------+ Published | Deprecate | Deprecated |
/// | +---------------> (end) |
/// +------> | | |
/// | +--+---------+--+ +---------------+
/// | | |
/// Edit +---------+ | Delete
/// (complete) |
/// +------------v--+
/// | |
/// | Deleted |
/// | (end) |
/// | |
/// +---------------+
/// </code>
/// <para>
/// To assist with testing it has the following notable points:
/// <list type="bullet">
/// <item>
/// <description>
/// The initial state, "Initializing" will validate the context properties
/// and self-trigger a transition to "Waiting for documentation.
/// </description>
/// </item>
/// <item>
/// <description>
/// Every state has a TraceAction added to its entry and exit actions lists
/// so that tests can verify the expected actions were called in the expected
/// order.
/// </description>
/// </item>
/// <item>
/// <description>
/// Every transition has a TraceAction added to it for the same reason.
/// </description>
/// </item>
/// </list>
/// </para>
/// </remarks>
public static Workflow Create(string id, IWorkflowMessageQueue workflowMessageQueue)
{
var dataCatalogItemRepositoryFactory = new DataCatalogItemRepositoryFactory();
var workflow = new Workflow(
id,
"Data Catalog item workflow",
"Controls the lifecycle of a data catalog item");
WorkflowState initializing = workflow.CreateState(displayName: "Waiting for initialization");
WorkflowState waitingForDocumentation = workflow.CreateState(displayName: "Waiting for documentation");
WorkflowState published = workflow.CreateState(displayName: "Published");
WorkflowState deleted = workflow.CreateState(displayName: "Deleted");
WorkflowState deprecated = workflow.CreateState(displayName: "Deprecated");
workflow.SetInitialState(initializing);
initializing.EntryConditions.Add(
new ContextItemsPresentCondition {
RequiredContextItems = new[] { "Identifier", "Type" }
});
initializing.AddTraceActionForEntry();
initializing.EntryActions.Add(new SendCreateCatalogItemTriggerAction(workflowMessageQueue));
initializing.AddTraceActionForExit();
waitingForDocumentation.AddTraceActionForEntry();
waitingForDocumentation.AddTraceActionForExit();
waitingForDocumentation.ExitConditions.Add(
new ContextItemsPresentCondition {
RequiredContextItems = new[] { "AllowWaitingForDocumentationExit" }
});
published.AddTraceActionForEntry();
published.AddTraceActionForExit();
published.EntryConditions.Add(
new ContextItemsPresentCondition {
RequiredContextItems = new[] { "AllowPublishedEntry" }
});
deleted.AddTraceActionForEntry();
deleted.AddTraceActionForExit();
deprecated.AddTraceActionForEntry();
deprecated.AddTraceActionForExit();
WorkflowTransition createCatalogItemTransition =
initializing.CreateTransition(waitingForDocumentation, displayName: "Create catalog item");
createCatalogItemTransition.Conditions.Add(
new TriggerContentTypeCondition
{
TriggerContentType = CreateCatalogItemTrigger.RegisteredContentType,
});
createCatalogItemTransition.Conditions.Add(new CatalogItemIdCondition());
createCatalogItemTransition.Actions.Add(new CreateCatalogItemAction(dataCatalogItemRepositoryFactory));
createCatalogItemTransition.AddTraceAction();
WorkflowTransition waitingForDocumentationEditTransition =
waitingForDocumentation.CreateTransition(waitingForDocumentation, displayName: "Edit");
waitingForDocumentationEditTransition.Conditions.Add(
new TriggerContentTypeCondition {
TriggerContentType = EditCatalogItemTrigger.RegisteredContentType
});
waitingForDocumentationEditTransition.Conditions.Add(new CatalogItemIdCondition());
waitingForDocumentationEditTransition.Actions.Add(
new ApplyCatalogItemPatchAction(dataCatalogItemRepositoryFactory));
waitingForDocumentationEditTransition.AddTraceAction();
WorkflowTransition waitingForDocumentationPublishTransition =
waitingForDocumentation.CreateTransition(published, displayName: "Publish");
waitingForDocumentationPublishTransition.Conditions.Add(
new TriggerContentTypeCondition
{
TriggerContentType = PublishCatalogItemTrigger.RegisteredContentType,
});
waitingForDocumentationPublishTransition.Conditions.Add(new CatalogItemIdCondition());
waitingForDocumentationPublishTransition.Conditions.Add(
new CatalogItemCompleteCondition(dataCatalogItemRepositoryFactory));
waitingForDocumentationPublishTransition.AddTraceAction();
WorkflowTransition publishedEditCompleteTransition =
published.CreateTransition(published, displayName: "Edit (complete)");
publishedEditCompleteTransition.Conditions.Add(
new TriggerContentTypeCondition {
TriggerContentType = EditCatalogItemTrigger.RegisteredContentType
});
publishedEditCompleteTransition.Conditions.Add(new CatalogItemIdCondition());
publishedEditCompleteTransition.Conditions.Add(
new CatalogItemWillBeCompleteCondition(dataCatalogItemRepositoryFactory)
{
ExpectedResult = true
});
publishedEditCompleteTransition.Actions.Add(
new ApplyCatalogItemPatchAction(dataCatalogItemRepositoryFactory));
publishedEditCompleteTransition.AddTraceAction();
WorkflowTransition publishedEditIncompleteTransition =
published.CreateTransition(waitingForDocumentation, displayName: "Edit (incomplete)");
publishedEditIncompleteTransition.Conditions.Add(
new TriggerContentTypeCondition {
TriggerContentType = EditCatalogItemTrigger.RegisteredContentType
});
publishedEditIncompleteTransition.Conditions.Add(new CatalogItemIdCondition());
publishedEditIncompleteTransition.Conditions.Add(
new CatalogItemWillBeCompleteCondition(dataCatalogItemRepositoryFactory)
{
ExpectedResult = false
});
publishedEditIncompleteTransition.Actions.Add(
new ApplyCatalogItemPatchAction(dataCatalogItemRepositoryFactory));
publishedEditIncompleteTransition.AddTraceAction();
WorkflowTransition publishedDeleteTransition = published.CreateTransition(deleted, displayName: "Delete");
publishedDeleteTransition.Conditions.Add(
new TriggerContentTypeCondition
{
TriggerContentType = DeleteCatalogItemTrigger.RegisteredContentType,
});
publishedDeleteTransition.Conditions.Add(new CatalogItemIdCondition());
publishedDeleteTransition.AddTraceAction();
WorkflowTransition publishedDeprecateTransition = published.CreateTransition(deprecated, displayName: "Deprecate");
publishedDeprecateTransition.Conditions.Add(
new TriggerContentTypeCondition
{
TriggerContentType = DeprecateCatalogItemTrigger.RegisteredContentType,
});
publishedDeprecateTransition.Conditions.Add(new CatalogItemIdCondition());
publishedDeprecateTransition.AddTraceAction();
return(workflow);
}
public static WorkflowTransitionDto FromWorkflowTransition(WorkflowTransition transition)
{
return(new WorkflowTransitionDto {
Expression = transition.Expression, Roles = transition.Roles?.ToArray()
});
}
public void Execute(IWorkflow <string, Customer> workflow, WorkflowTransition <string, Customer> transition)
{
WriteLine($"ActionThree action executed: {workflow.GetType().Name}. Context Object: {workflow.Context.GetType().Name}");
}
public async Task ExecuteAsync(IWorkflow <string, Customer> workflow, WorkflowTransition <string, Customer> transition)
{
//TODO: implement async
throw new NotImplementedException();
}
public JsonWorkflowTransition(WorkflowTransition transition)
{
SimpleMapper.Map(transition, this);
}
public static SocketDesignGraph Build()
{
ScanState scanState = new ScanState()
{
Name = ScanState.Identifier
};
RectifyState rectifyState = new RectifyState()
{
Name = RectifyState.Identifier
};
SocketDesignState socketState = new SocketDesignState()
{
Name = SocketDesignState.Identifier
};
SocketDesignGraph graph = new SocketDesignGraph();
WorkflowBuilder builder = new WorkflowBuilder(graph);
graph.AddState(scanState);
graph.AddState(rectifyState);
graph.AddState(socketState);
WorkflowTransition toRectify = graph.AddTransition(scanState, rectifyState);
toRectify.BeforeTransition.Add(() => {
OG.Context.TransformManager.SetActiveGizmoType(TransformManager.NoGizmoType);
OGActions.InitializeLegFromScan();
});
WorkflowTransition toSocket = graph.AddTransition(rectifyState, socketState);
toSocket.BeforeTransition.Add(() => {
OG.Context.TransformManager.SetActiveGizmoType(TransformManager.NoGizmoType);
});
WorkflowTransition backToRectify = graph.AddTransition(socketState, rectifyState);
backToRectify.BeforeTransition.Add(() => {
OG.Context.TransformManager.SetActiveGizmoType(TransformManager.NoGizmoType);
});
// scan tool states
var trimScanTool = builder.AddState(OGWorkflow.TrimScanState, OGActions.BeginTrimScanTool);
builder.AddTransition(scanState, trimScanTool, OGWorkflow.TrimScanStartT, OGActions.CanTrimScan, null, null);
builder.AddTransition(trimScanTool, scanState, OGWorkflow.TrimScanAcceptT, OGActions.CanAcceptTrimScanTool, OGActions.AcceptTrimScanTool, null);
builder.AddTransition(trimScanTool, scanState, OGWorkflow.TrimScanCancelT, null, OGActions.CancelTrimScanTool, null);
var alignScanTool = builder.AddState(OGWorkflow.AlignScanState, OGActions.BeginAlignScanTool);
builder.AddTransition(scanState, alignScanTool, OGWorkflow.AlignScanStartT, OGActions.CanAlignScan, null, null);
builder.AddTransition(alignScanTool, scanState, OGWorkflow.AlignScanAcceptT, OGActions.CanAcceptAlignScanTool, OGActions.AcceptAlignScanTool, null);
builder.AddTransition(alignScanTool, scanState, OGWorkflow.AlignScanCancelT, null, OGActions.CancelAlignScanTool, null);
// rectify tool states
var drawAreaTool = builder.AddState(OGWorkflow.DrawAreaState, OGActions.BeginDrawAreaTool);
builder.AddTransition(rectifyState, drawAreaTool, OGWorkflow.DrawAreaStartT, OGActions.CanDrawArea, null, null);
builder.AddTransition(drawAreaTool, rectifyState, OGWorkflow.DrawAreaExitT, null, OGActions.EndDrawAreaTool, null);
var deformRingTool = builder.AddState(OGWorkflow.AddDeformRingState, OGActions.BeginDeformRingTool);
builder.AddTransition(rectifyState, deformRingTool, OGWorkflow.AddDeformRingStartT, OGActions.CanAddDeformRing, null, null);
builder.AddTransition(deformRingTool, rectifyState, OGWorkflow.AddDeformRingAcceptT, OGActions.CanAcceptDeformRingTool, OGActions.AcceptDeformRingTool, null);
builder.AddTransition(deformRingTool, rectifyState, OGWorkflow.AddDeformRingCancelT, null, OGActions.CancelDeformRingTool, null);
var sculptAreaTool = builder.AddState(OGWorkflow.SculptAreaState, OGActions.BeginSculptCurveTool);
builder.AddTransition(rectifyState, sculptAreaTool, OGWorkflow.SculptAreaStartT, OGActions.CanSculptCurve, null, null);
builder.AddTransition(sculptAreaTool, rectifyState, OGWorkflow.SculptAreaExitT, null, OGActions.EndSculptCurveTool, null);
// socket tool states
var drawTrimlineTool = builder.AddState(OGWorkflow.DrawTrimlineState, OGActions.BeginDrawTrimLineTool);
builder.AddTransition(socketState, drawTrimlineTool, OGWorkflow.DrawTrimlineStartT, OGActions.CanDrawTrimLine, null, null);
builder.AddTransition(drawTrimlineTool, socketState, OGWorkflow.DrawTrimlineExitT, null, OGActions.EndDrawTrimLineTool, null);
var planeTrimlineTool = builder.AddState(OGWorkflow.PlaneTrimlineState, OGActions.BeginPlaneTrimLineTool);
builder.AddTransition(socketState, planeTrimlineTool, OGWorkflow.PlaneTrimlineStartT, OGActions.CanAddPlaneTrimLine, null, null);
builder.AddTransition(planeTrimlineTool, socketState, OGWorkflow.PlaneTrimlineAcceptT, OGActions.CanAcceptPlaneTrimLineTool, OGActions.AcceptPlaneTrimLineTool, null);
builder.AddTransition(planeTrimlineTool, socketState, OGWorkflow.PlaneTrimlineCancelT, null, OGActions.CancelPlaneTrimLineTool, null);
var sculptTrimlineTool = builder.AddState(OGWorkflow.SculptTrimlineState, OGActions.BeginSculptCurveTool);
builder.AddTransition(socketState, sculptTrimlineTool, OGWorkflow.SculptTrimlineStartT, OGActions.CanSculptCurve, null, null);
builder.AddTransition(sculptTrimlineTool, socketState, OGWorkflow.SculptTrimlineExitT, null, OGActions.EndSculptCurveTool, null);
graph.LogF = DebugUtil.Log; // print debug output
return(graph);
}
public static void ProcessWorkflow(this RigOapChecklist rigOapChecklist, IRigOapChecklistWorkflowService rigOapChecklistWorkflowService, IWorkflowEngineService workflowEngineService, IWorkflowService workflowService, WorkflowTransition transition, WorkflowRequest request, ILog log)
{
var workflow = workflowService.GetActiveWorkflow(rigOapChecklist.OapChecklist.OapType.ChecklistLayoutId.Value);
//Create the Workflow Activity
var workflowActivity = workflow.GetActivity(rigOapChecklist.Id);
if (workflowActivity == null)
{
log.Error($" Workflow Activity was not found for checklist : { rigOapChecklist.Id}");
return;
}
//Create the RigOapChecklistWorkflow instance
var rigChecklistWorkflow = rigOapChecklistWorkflowService.GetWorkflowByChecklist(rigOapChecklist.Id);
if (rigChecklistWorkflow == null)
{
log.Error($" Workflow instance was not found for checklist : { rigOapChecklist.Id}");
return;
}
var version = new Version(workflow.Major, workflow.Minor);
//Start the Workflow Instance and All the store the instance details
//Get the Current Principal And Assign Him to Workflow to
workflowEngineService.Process(workflowActivity, version, rigChecklistWorkflow, transition, request);
}
public JsonWorkflowTransition(WorkflowTransition client)
{
SimpleMapper.Map(client, this);
}
private void UpdateWorkflowState(WorkflowInstance workflow, WorkflowResult result, WorkflowTransition transition)
{
if (result.NewState?.Name != null && (workflow.WorkflowState?.Name == null || result.NewState?.Name != workflow.WorkflowState?.Name))
{
workflow.WorkflowState = result.NewState;
if (transition != null)
{
workflow.Transition = transition;
}
}
}
