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 PlanNodeMock(params PlanDO[] plans)
{
foreach (var planDo in plans)
{
_plans.Add(planDo.Id);
var plan = planDo;
PlanTreeHelper.Visit(planDo, x => PlanNodes[x.Id] = plan);
}
}
public PlanStorageProviderMonitor(PlanNodeDO planNode)
{
PlanTreeHelper.Visit(planNode, (x, y) =>
{
x.ParentPlanNodeId = y != null ? y.Id : (Guid?)null;
x.ParentPlanNode = y;
});
_planNode = planNode;
}
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 void CanAddPlanWithEmptyDefaultIds()
{
var provider = new PersistentPlanStorage(null);
var cache = new PlanCache(new ExpirationStrategyMock());
var repository = new PlanRepository(new PlanStorage(cache, provider));
var refPlan = GenerateTestPlan();
PlanTreeHelper.Visit(refPlan, x => x.Id = Guid.Empty);
repository.Add(refPlan);
repository.SaveChanges();
PlanTreeHelper.Visit(refPlan, x => Assert.IsTrue(x.Id != Guid.Empty));
var loadedPlan = provider.LoadPlan(Guid.Empty);
AssertEquals(refPlan, loadedPlan);
}
public PlanDTO CrateTemplate(Guid planId, string userId)
{
PlanDO clonedPlan;
using (var uow = _unitOfWorkFactory.Create())
{
var plan = _planService.GetPlanByActivityId(uow, planId);
clonedPlan = (PlanDO)PlanTreeHelper.CloneWithStructure(plan);
}
clonedPlan.PlanState = PlanState.Inactive;
//linearlize tree structure
var planTree = clonedPlan.GetDescendants();
var idsMap = new Dictionary <Guid, Guid>();
foreach (var planNodeDO in planTree)
{
var oldId = planNodeDO.Id;
planNodeDO.Id = Guid.NewGuid();
planNodeDO.Fr8Account = null;
planNodeDO.Fr8AccountId = null;
var activity = planNodeDO as ActivityDO;
if (activity != null)
{
activity.AuthorizationToken = null;
}
idsMap.Add(oldId, planNodeDO.Id);
}
foreach (var activity in planTree.OfType <ActivityDO>())
{
activity.CrateStorage = _crateManager.EmptyStorageAsStr(); // UpdateCrateStorage(activity.CrateStorage, idsMap);
}
return(PlanMappingHelper.MapPlanToDto(clonedPlan));
}
public PlanDO Clone(Guid planId)
{
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var currentUser = _security.GetCurrentAccount(uow);
var targetPlan = (PlanDO)GetPlanByActivityId(uow, planId);
if (targetPlan == null)
{
return(null);
}
var cloneTag = "Cloned From " + planId;
//we should clone this plan for current user
//let's clone the plan entirely
var clonedPlan = (PlanDO)PlanTreeHelper.CloneWithStructure(targetPlan);
clonedPlan.Description = clonedPlan.Name + " - " + "Customized for User " + currentUser.UserName + " on " + DateTime.Now;
clonedPlan.PlanState = PlanState.Inactive;
clonedPlan.Tag = cloneTag;
clonedPlan.IsApp = false; // we don't want apps to duplicate when launching
clonedPlan.AppLaunchURL = null;
//linearlize tree structure
var planTree = clonedPlan.GetDescendantsOrdered();
//let's replace old id's of cloned plan with new id's
//and update account information
//TODO maybe we should do something about authorization tokens too?
Dictionary <Guid, PlanNodeDO> parentMap = new Dictionary <Guid, PlanNodeDO>();
foreach (var planNodeDO in planTree)
{
var oldId = planNodeDO.Id;
planNodeDO.Id = Guid.NewGuid();
planNodeDO.Fr8Account = currentUser;
//if (planNodeDO is ActivityDO)
//{
// (planNodeDO as ActivityDO).AuthorizationTokenId = null;
//}
parentMap.Add(oldId, planNodeDO);
planNodeDO.ChildNodes = new List <PlanNodeDO>();
if (planNodeDO.ParentPlanNodeId != null)
{
PlanNodeDO newParent;
//find parent from old parent id map
if (parentMap.TryGetValue(planNodeDO.ParentPlanNodeId.Value, out newParent))
{
//replace parent id with parent's new id
planNodeDO.ParentPlanNodeId = newParent.Id;
newParent.ChildNodes.Add(planNodeDO);
}
else
{
//this should never happen
throw new Exception("Unable to clone plan");
}
}
else
{
//this should be a plan because it has null ParentId
uow.PlanRepository.Add(planNodeDO as PlanDO);
}
}
//lets update all existing ids in crateStorages of new activities
//there might be some fields or crates published with sourceActivityId
foreach (var idMap in parentMap)
{
foreach (var planNodeDO in planTree)
{
var activity = planNodeDO as ActivityDO;
if (activity == null)
{
continue;
}
var oldId = idMap.Key.ToString();
var newId = idMap.Value.Id.ToString();
activity.CrateStorage = activity.CrateStorage.Replace(oldId, newId);
}
}
//save new cloned plan
uow.SaveChanges();
return(clonedPlan);
}
}
public List <PlanNodeDO> GetDescendantsOrdered()
{
return(PlanTreeHelper.LinearizeOrdered(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);
}
}
