public void CanLoadFromCacheUsingChildActivitiesId()
{
var expiration = new ExpirationStrategyMock();
var planId = new Guid(1, (short)0, (short)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0);
int calledTimes = 0;
var plan = LoadPlan(planId);
Func <Guid, PlanNodeDO> cacheMiss = x =>
{
calledTimes++;
return(plan);
};
var cache = new PlanCache(expiration);
var plan1 = cache.Get(new Guid(2, (short)0, (short)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0), cacheMiss);
Assert.IsTrue(AreEquals(plan1, plan));
foreach (var id in PlanTreeHelper.Linearize(plan).Select(x => x.Id))
{
Assert.IsTrue(AreEquals(plan, cache.Get(id, cacheMiss)));
}
Assert.AreEqual(1, calledTimes);
}
public async Task <PayloadDTO> Run(IUnitOfWork uow, ActivityDO curActivityDO, ActivityExecutionMode curActionExecutionMode, ContainerDO curContainerDO)
{
if (PlanTreeHelper.Linearize(_planNodes[curActivityDO.Id]).OfType <ActivityDO>().Any(x => x.Id == curActivityDO.Id))
{
Processed++;
}
await Task.Delay(1);
return(await _activity.Run(uow, curActivityDO, curActionExecutionMode, curContainerDO));
}
public PersistentPlanStorage(PlanNodeDO root)
{
if (root == null)
{
return;
}
foreach (var node in PlanTreeHelper.Linearize(root))
{
_storage[node.Id] = node;
}
}
public List <PlanNodeDO> GetDescendants()
{
return(PlanTreeHelper.Linearize(this));
}
private void SaveAndUpdateActivity(IUnitOfWork uow, ActivityDO submittedActiviy)
{
var isNewActivity = false;
PlanTreeHelper.Visit(submittedActiviy, x =>
{
if (x.Id == Guid.Empty)
{
if (Object.ReferenceEquals(x, submittedActiviy))
{
isNewActivity = true;
}
x.Id = Guid.NewGuid();
}
var activityDO = x as ActivityDO;
if (activityDO != null && activityDO.ActivityTemplateId == Guid.Empty)
{
var activityTemplate = activityDO.ActivityTemplate;
activityDO.ActivityTemplate = uow
.ActivityTemplateRepository
.GetQuery()
.Single(y => y.Name == activityTemplate.Name &&
y.Version == activityTemplate.Version &&
y.Terminal.Name == activityTemplate.Terminal.Name &&
y.Terminal.Version == activityTemplate.Terminal.Version);
activityDO.ActivityTemplateId = activityDO.ActivityTemplate.Id;
}
});
PlanNodeDO plan;
PlanNodeDO originalAction;
if (submittedActiviy.ParentPlanNodeId != null)
{
plan = uow.PlanRepository.Reload <PlanNodeDO>(submittedActiviy.ParentPlanNodeId);
if (plan == null)
{
throw new MissingObjectException($"Parent plan with Id {submittedActiviy.ParentPlanNodeId} doesn't exist");
}
originalAction = plan.ChildNodes.FirstOrDefault(x => x.Id == submittedActiviy.Id);
//This might mean that this plan's parent was changed
if (originalAction == null && !isNewActivity)
{
originalAction = uow.PlanRepository.GetById <PlanNodeDO>(submittedActiviy.Id);
if (originalAction != null)
{
var originalActionsParent = uow.PlanRepository.Reload <PlanNodeDO>(originalAction.ParentPlanNodeId);
originalActionsParent.ChildNodes.Remove(originalAction);
originalAction.ParentPlanNodeId = plan.Id;
}
}
}
else
{
originalAction = uow.PlanRepository.Reload <PlanNodeDO>(submittedActiviy.Id);
plan = originalAction.ParentPlanNode;
}
if (originalAction != null)
{
plan.ChildNodes.Remove(originalAction);
// Add child subplans.
foreach (var subPlan in originalAction.ChildNodes.OfType <SubplanDO>())
{
submittedActiviy.ChildNodes.Add(subPlan);
}
var originalActions = PlanTreeHelper.Linearize(originalAction)
.OfType <ActivityDO>()
.ToDictionary(x => x.Id, x => x);
foreach (var submitted in PlanTreeHelper.Linearize(submittedActiviy))
{
ActivityDO existingActivity;
if (originalActions.TryGetValue(submitted.Id, out existingActivity))
{
RestoreSystemProperties(existingActivity, (ActivityDO)submitted);
}
}
}
if (submittedActiviy.Ordering <= 0)
{
plan.AddChildWithDefaultOrdering(submittedActiviy);
}
else
{
plan.ChildNodes.Add(submittedActiviy);
}
}
