private void ThrowIfMovingExpandLockedWorkItem(WorkItemTransition transition)
{
if (WorkflowRepository.IsExpandLockedWorkItem(transition.WorkItem))
{
throw new InvalidOperationException("Item is expandlocked and cannot be moved");
}
}
private void ThrowIfViolatingWipLimit(WorkItemTransition transition)
{
if (!WipLimitChecker.CanAcceptWorkItem(transition.WorkItem.MoveTo(transition.WorkStep, _timeSource.GetTime())))
{
throw new WipLimitViolationException(transition.WorkItem, transition.WorkStep);
}
}
private void Move(WorkItem workItem, WorkStep toStep)
{
var transition = new WorkItemTransition(workItem, toStep);
ThrowIfMovingParallelLockedWorkItem(transition);
ThrowIfMovingExpandLockedWorkItem(transition);
ThrowIfViolatingWipLimit(transition);
if (IsMovingWithinParallelStep(transition))
{
MoveToWithinParallelStep(transition);
}
else
{
ThrowIfMovingToWithinExpandStep(transition);
ThrowIfMovingToStepWithWrongClass(transition);
CleanUpIfMovingFromExpandStep(transition);
transition = AttemptMergeIfMovingChildOfParallelledWorkItem(transition);
transition = CreateTransitionIfMovingToExpandStep(transition);
var resultTransition = DoMove(transition);
TryUpdatingExpandLockIfMovingChildOfExpandedWorkItem(resultTransition);
}
}
private void TryUpdatingExpandLockIfMovingChildOfExpandedWorkItem(WorkItemTransition resultTransition)
{
if (WorkflowRepository.IsChildOfExpandedWorkItem(resultTransition.WorkItem))
{
TryUpdatingExpandLockOnParent(resultTransition.WorkItem);
}
}
private void ThrowIfMovingToStepWithWrongClass(WorkItemTransition transition)
{
if (!WorkflowRepository.IsValidWorkStepForWorkItem(transition.WorkItem, transition.WorkStep))
{
throw new InvalidOperationException("Invalid step for work item");
}
}
private void ThrowIfMovingParallelLockedWorkItem(WorkItemTransition transition)
{
if (WorkflowRepository.IsParallelLockedWorkItem(transition.WorkItem))
{
throw new InvalidOperationException("Work item is locked for parallel work");
}
}
private WorkItemTransition DoMove(WorkItemTransition transition)
{
var movedWorkItem = transition.WorkItem.MoveTo(transition.WorkStep, _timeSource.GetTime());
WorkflowRepository.UpdateWorkItem(movedWorkItem);
return(new WorkItemTransition(movedWorkItem, transition.WorkStep));
}
private WorkItemTransition CreateTransitionIfMovingToExpandStep(WorkItemTransition transition)
{
if (WorkflowRepository.IsExpandStep(transition.WorkStep))
{
CreateTransientWorkSteps(transition.WorkItem, transition.WorkStep);
}
return(transition);
}
private void ThrowIfMovingToWithinExpandStep(WorkItemTransition transition)
{
WorkStep dummyStep;
if (!WorkflowRepository.IsExpandStep(transition.WorkStep) && !WorkflowRepository.IsWithinTransientStep(transition.WorkStep, out dummyStep) && WorkflowRepository.IsWithinExpandStep(transition.WorkStep))
{
throw new InvalidOperationException("Cannot move item to within expand step");
}
}
private bool IsMovedUnderneathParallelParent(WorkItemTransition transition, out WorkItem parallelParent)
{
if (WorkflowRepository.IsChildOfParallelledWorkItem(transition.WorkItem, out parallelParent))
{
return(transition.WorkStep.Path.StartsWith(parallelParent.Path));
}
return(false);
}
private WorkItemTransition AttemptMergeIfMovingChildOfParallelledWorkItem(WorkItemTransition transition)
{
if (WorkflowRepository.IsMergeableParallelledChild(transition.WorkItem, transition.WorkStep))
{
var workItemToMove = MergeParallelWorkItems(transition);
transition = new WorkItemTransition(workItemToMove, transition.WorkStep);
}
return(transition);
}
private WorkItemTransition AttemptMergeIfMovingChildOfParallelledWorkItem(WorkItemTransition transition)
{
if (WorkflowRepository.IsMergeableParallelledChild(transition.WorkItem, transition.WorkStep))
{
var workItemToMove = MergeParallelWorkItems(transition);
transition = new WorkItemTransition(workItemToMove, transition.WorkStep);
}
return transition;
}
private void LockAndMoveToParallelRoot(WorkItemTransition transition)
{
ThrowIfMovingToStepWithWrongClass(transition);
var lockedAndMovedItem = transition.WorkItem
.MoveTo(transition.WorkStep, _timeSource.GetTime())
.UpdateStatus(WorkItemStatus.ParallelLocked);
WorkflowRepository.UpdateWorkItem(lockedAndMovedItem);
if (WorkflowRepository.IsInExpandStep(transition.WorkItem))
{
CleanUpIfMovingFromExpandStep(transition);
}
}
private IEnumerable <string> GetPathsToTraverseForParallelStep(WorkItemTransition transition)
{
IEnumerable <string> pathsBetweenRootAndTarget;
WorkItem parallelParent;
if (IsMovedUnderneathParallelParent(transition, out parallelParent))
{
var commonRootStepPath = WorkflowPath.FindCommonRoot(parallelParent.Path, transition.WorkStep.Path);
pathsBetweenRootAndTarget = WorkflowPath.GetPathsBetween(commonRootStepPath, transition.WorkStep.Path).Skip(1);
}
else
{
var commonRootStepPath = WorkflowPath.FindCommonRoot(transition.WorkItem.Path, transition.WorkStep.Path);
pathsBetweenRootAndTarget = WorkflowPath.GetPathsBetween(commonRootStepPath, transition.WorkStep.Path);
}
return(pathsBetweenRootAndTarget);
}
private WorkItem MergeParallelWorkItems(WorkItemTransition transition)
{
var unlockedParentWorkItem = WorkflowRepository.GetWorkItem(transition.WorkItem.Parent.Id).UpdateStatus(WorkItemStatus.Normal);
WorkflowRepository.UpdateWorkItem(unlockedParentWorkItem);
foreach (var childWorkItem in WorkflowRepository.GetChildWorkItems(transition.WorkItem.Parent).ToList())
{
if (WorkflowRepository.IsExpandStep(transition.WorkStep))
{
CleanUpIfMovingFromExpandStep(new WorkItemTransition(childWorkItem, transition.WorkStep));
}
WorkflowRepository.DeleteWorkItem(childWorkItem.Id);
}
return(unlockedParentWorkItem);
}
private void MoveToWithinParallelStep(WorkItemTransition transition)
{
var newTransition = transition;
if (!WorkflowRepository.IsValidWorkStepForWorkItem(transition.WorkItem, transition.WorkStep))
{
newTransition = TraverseParallelMoveHierarchy(transition);
}
ThrowIfMovingToStepWithWrongClass(newTransition);
CleanUpIfMovingFromExpandStep(newTransition);
newTransition = AttemptMergeIfMovingChildOfParallelledWorkItem(newTransition);
var resultTransition = DoMove(newTransition);
TryUpdatingExpandLockIfMovingChildOfExpandedWorkItem(resultTransition);
}
private WorkItem CreateParallelledChildrenAndReturnWorkItemToMove(WorkItemTransition transition, WorkStep parallelStep)
{
var helper = new ParallelStepHelper(WorkflowRepository);
var splitWorkItems = helper.SplitForParallelism(transition.WorkItem, parallelStep);
foreach (var splitWorkItem in splitWorkItems)
{
WorkflowRepository.CreateWorkItem(splitWorkItem);
WorkStep expandStep;
var isInExpandStep = WorkflowRepository.IsInExpandStep(transition.WorkItem, out expandStep);
if (isInExpandStep)
{
CreateTransientWorkSteps(splitWorkItem, expandStep);
}
}
var idToMove = ParallelStepHelper.GetParallelId(transition.WorkItem.Id, parallelStep, transition.WorkStep);
var workItemToMove = splitWorkItems.First(wi => wi.Id == idToMove);
return(workItemToMove);
}
private WorkItemTransition TraversePathsForParallelStep(WorkItemTransition transition, IEnumerable <string> pathsBetweenRootAndTarget)
{
var currentWorkItem = transition.WorkItem;
WorkStep parentWorkStep = null;
foreach (var inBetweenPath in pathsBetweenRootAndTarget)
{
var currentWorkStep = WorkflowRepository.GetWorkStep(inBetweenPath);
var currentTransition = new WorkItemTransition(currentWorkItem, currentWorkStep);
if (parentWorkStep != null && WorkflowRepository.IsParallelStep(parentWorkStep))
{
var transitionToParallelRoot = new WorkItemTransition(currentWorkItem, parentWorkStep);
LockAndMoveToParallelRoot(transitionToParallelRoot);
currentWorkItem = CreateParallelledChildrenAndReturnWorkItemToMove(currentTransition, parentWorkStep);
}
parentWorkStep = currentWorkStep;
}
return(new WorkItemTransition(currentWorkItem, transition.WorkStep));
}
private void ThrowIfMovingToStepWithWrongClass(WorkItemTransition transition)
{
if (!WorkflowRepository.IsValidWorkStepForWorkItem(transition.WorkItem, transition.WorkStep))
{
throw new InvalidOperationException("Invalid step for work item");
}
}
private void ThrowIfMovingParallelLockedWorkItem(WorkItemTransition transition)
{
if (WorkflowRepository.IsParallelLockedWorkItem(transition.WorkItem))
{
throw new InvalidOperationException("Work item is locked for parallel work");
}
}
private void ThrowIfMovingExpandLockedWorkItem(WorkItemTransition transition)
{
if (WorkflowRepository.IsExpandLockedWorkItem(transition.WorkItem))
{
throw new InvalidOperationException("Item is expandlocked and cannot be moved");
}
}
private void MoveToWithinParallelStep(WorkItemTransition transition)
{
var newTransition = transition;
if (!WorkflowRepository.IsValidWorkStepForWorkItem(transition.WorkItem, transition.WorkStep))
{
newTransition = TraverseParallelMoveHierarchy(transition);
}
ThrowIfMovingToStepWithWrongClass(newTransition);
CleanUpIfMovingFromExpandStep(newTransition);
newTransition = AttemptMergeIfMovingChildOfParallelledWorkItem(newTransition);
var resultTransition = DoMove(newTransition);
TryUpdatingExpandLockIfMovingChildOfExpandedWorkItem(resultTransition);
}
private bool IsMovingWithinParallelStep(WorkItemTransition transition)
{
return(WorkflowRepository.IsWithinParallelStep(transition.WorkStep));
}
private void TryUpdatingExpandLockIfMovingChildOfExpandedWorkItem(WorkItemTransition resultTransition)
{
if (WorkflowRepository.IsChildOfExpandedWorkItem(resultTransition.WorkItem))
{
TryUpdatingExpandLockOnParent(resultTransition.WorkItem);
}
}
private WorkItemTransition TraverseParallelMoveHierarchy(WorkItemTransition transition)
{
var pathsBetweenRootAndTarget = GetPathsToTraverseForParallelStep(transition);
return TraversePathsForParallelStep(transition, pathsBetweenRootAndTarget);
}
private bool IsMovingWithinParallelStep(WorkItemTransition transition)
{
return WorkflowRepository.IsWithinParallelStep(transition.WorkStep);
}
private bool IsMovedUnderneathParallelParent(WorkItemTransition transition, out WorkItem parallelParent)
{
if (WorkflowRepository.IsChildOfParallelledWorkItem(transition.WorkItem, out parallelParent))
{
return transition.WorkStep.Path.StartsWith(parallelParent.Path);
}
return false;
}
private IEnumerable<string> GetPathsToTraverseForParallelStep(WorkItemTransition transition)
{
IEnumerable<string> pathsBetweenRootAndTarget;
WorkItem parallelParent;
if (IsMovedUnderneathParallelParent(transition, out parallelParent))
{
var commonRootStepPath = WorkflowPath.FindCommonRoot(parallelParent.Path, transition.WorkStep.Path);
pathsBetweenRootAndTarget = WorkflowPath.GetPathsBetween(commonRootStepPath, transition.WorkStep.Path).Skip(1);
}
else
{
var commonRootStepPath = WorkflowPath.FindCommonRoot(transition.WorkItem.Path, transition.WorkStep.Path);
pathsBetweenRootAndTarget = WorkflowPath.GetPathsBetween(commonRootStepPath, transition.WorkStep.Path);
}
return pathsBetweenRootAndTarget;
}
private WorkItemTransition DoMove(WorkItemTransition transition)
{
var movedWorkItem = transition.WorkItem.MoveTo(transition.WorkStep,_timeSource.GetTime());
WorkflowRepository.UpdateWorkItem(movedWorkItem);
return new WorkItemTransition(movedWorkItem, transition.WorkStep);
}
private void CleanUpIfMovingFromExpandStep(WorkItemTransition transition)
{
var remover = new WorkItemRemover(WorkflowRepository);
remover.CleanUpIfInExpandStep(transition.WorkItem);
}
private void ThrowIfMovingToWithinExpandStep(WorkItemTransition transition)
{
WorkStep dummyStep;
if (!WorkflowRepository.IsExpandStep(transition.WorkStep) && !WorkflowRepository.IsWithinTransientStep(transition.WorkStep, out dummyStep) && WorkflowRepository.IsWithinExpandStep(transition.WorkStep))
{
throw new InvalidOperationException("Cannot move item to within expand step");
}
}
private void LockAndMoveToParallelRoot(WorkItemTransition transition)
{
ThrowIfMovingToStepWithWrongClass(transition);
var lockedAndMovedItem = transition.WorkItem
.MoveTo(transition.WorkStep, _timeSource.GetTime())
.UpdateStatus(WorkItemStatus.ParallelLocked);
WorkflowRepository.UpdateWorkItem(lockedAndMovedItem);
if (WorkflowRepository.IsInExpandStep(transition.WorkItem))
{
CleanUpIfMovingFromExpandStep(transition);
}
}
private void ThrowIfViolatingWipLimit(WorkItemTransition transition)
{
if(!WipLimitChecker.CanAcceptWorkItem(transition.WorkItem.MoveTo(transition.WorkStep,_timeSource.GetTime())))
{
throw new WipLimitViolationException(transition.WorkItem,transition.WorkStep);
}
}
private WorkItem MergeParallelWorkItems(WorkItemTransition transition)
{
var unlockedParentWorkItem = WorkflowRepository.GetWorkItem(transition.WorkItem.Parent.Id).UpdateStatus(WorkItemStatus.Normal);
WorkflowRepository.UpdateWorkItem(unlockedParentWorkItem);
foreach (var childWorkItem in WorkflowRepository.GetChildWorkItems(transition.WorkItem.Parent).ToList())
{
if (WorkflowRepository.IsExpandStep(transition.WorkStep))
{
CleanUpIfMovingFromExpandStep(new WorkItemTransition(childWorkItem, transition.WorkStep));
}
WorkflowRepository.DeleteWorkItem(childWorkItem.Id);
}
return unlockedParentWorkItem;
}
private WorkItemTransition TraversePathsForParallelStep(WorkItemTransition transition, IEnumerable<string> pathsBetweenRootAndTarget)
{
var currentWorkItem = transition.WorkItem;
WorkStep parentWorkStep = null;
foreach (var inBetweenPath in pathsBetweenRootAndTarget)
{
var currentWorkStep = WorkflowRepository.GetWorkStep(inBetweenPath);
var currentTransition = new WorkItemTransition(currentWorkItem,currentWorkStep);
if (parentWorkStep != null && WorkflowRepository.IsParallelStep(parentWorkStep))
{
var transitionToParallelRoot = new WorkItemTransition(currentWorkItem, parentWorkStep);
LockAndMoveToParallelRoot(transitionToParallelRoot);
currentWorkItem = CreateParallelledChildrenAndReturnWorkItemToMove(currentTransition, parentWorkStep);
}
parentWorkStep = currentWorkStep;
}
return new WorkItemTransition(currentWorkItem, transition.WorkStep);
}
private void Move(WorkItem workItem, WorkStep toStep)
{
var transition = new WorkItemTransition(workItem, toStep);
ThrowIfMovingParallelLockedWorkItem(transition);
ThrowIfMovingExpandLockedWorkItem(transition);
ThrowIfViolatingWipLimit(transition);
if (IsMovingWithinParallelStep(transition))
{
MoveToWithinParallelStep(transition);
}
else
{
ThrowIfMovingToWithinExpandStep(transition);
ThrowIfMovingToStepWithWrongClass(transition);
CleanUpIfMovingFromExpandStep(transition);
transition = AttemptMergeIfMovingChildOfParallelledWorkItem(transition);
transition = CreateTransitionIfMovingToExpandStep(transition);
var resultTransition = DoMove(transition);
TryUpdatingExpandLockIfMovingChildOfExpandedWorkItem(resultTransition);
}
}
private WorkItemTransition TraverseParallelMoveHierarchy(WorkItemTransition transition)
{
var pathsBetweenRootAndTarget = GetPathsToTraverseForParallelStep(transition);
return(TraversePathsForParallelStep(transition, pathsBetweenRootAndTarget));
}
private void CleanUpIfMovingFromExpandStep(WorkItemTransition transition)
{
var remover = new WorkItemRemover(WorkflowRepository);
remover.CleanUpIfInExpandStep(transition.WorkItem);
}
private WorkItem CreateParallelledChildrenAndReturnWorkItemToMove(WorkItemTransition transition, WorkStep parallelStep)
{
var helper = new ParallelStepHelper(WorkflowRepository);
var splitWorkItems = helper.SplitForParallelism(transition.WorkItem, parallelStep);
foreach (var splitWorkItem in splitWorkItems)
{
WorkflowRepository.CreateWorkItem(splitWorkItem);
WorkStep expandStep;
var isInExpandStep = WorkflowRepository.IsInExpandStep(transition.WorkItem, out expandStep);
if (isInExpandStep)
{
CreateTransientWorkSteps(splitWorkItem, expandStep);
}
}
var idToMove = ParallelStepHelper.GetParallelId(transition.WorkItem.Id, parallelStep, transition.WorkStep);
var workItemToMove = splitWorkItems.First(wi => wi.Id == idToMove);
return workItemToMove;
}
private WorkItemTransition CreateTransitionIfMovingToExpandStep(WorkItemTransition transition)
{
if (WorkflowRepository.IsExpandStep(transition.WorkStep))
{
CreateTransientWorkSteps(transition.WorkItem, transition.WorkStep);
}
return transition;
}
