/// <summary>
/// Execute the plan, returning current plan state. If the PlanState is
/// InProgress, Execute will need to be called again during the next
/// update tick.
/// </summary>
public void Execute(List <StateVariable> worldState)
{
while (tasks.Count > 0)
{
var task = tasks.Dequeue();
ActiveTask = task;
if (!task.ConditionsAreValid(worldState))
{
ActiveTask = task;
PlanState = PlanState.Failed;
return;
}
switch (ExecuteTask(task))
{
case ActionState.Error:
PlanState = PlanState.Failed;
return;
case ActionState.InProgress:
tasks.Enqueue(task);
PlanState = PlanState.InProgress;
return;
case ActionState.Success:
ApplyEffects(worldState, task.effects);
continue;
}
}
PlanState = PlanState.Completed;
}
// Manual mapping method to resolve DO-1164.
public static PlanDTO MapPlanToDto(PlanDO curPlanDO)
{
var subPlanDTOList = curPlanDO.ChildNodes.OfType <SubplanDO>()
.OrderBy(x => x.Ordering)
.ToList()
.Select((SubplanDO x) =>
{
var pntDTO = Mapper.Map <FullSubplanDto>(x);
pntDTO.Activities = x.ChildNodes.OrderBy(y => y.Ordering).Select(Mapper.Map <ActivityDTO>).ToList();
return(pntDTO);
}).ToList();
var result = new PlanDTO()
{
Description = curPlanDO.Description,
Id = curPlanDO.Id,
Name = curPlanDO.Name,
PlanState = PlanState.IntToString(curPlanDO.PlanState),
Visibility = new PlanVisibilityDTO()
{
Hidden = curPlanDO.Visibility.BooleanValue()
},
StartingSubPlanId = curPlanDO.StartingSubPlanId,
SubPlans = subPlanDTOList,
Fr8UserId = curPlanDO.Fr8AccountId,
Tag = curPlanDO.Tag,
Category = curPlanDO.Category,
LastUpdated = curPlanDO.LastUpdated
};
return(result);
}
public void Reset(Plan plan)
{
tasks.Clear();
foreach (var i in plan)
{
tasks.Enqueue(i);
}
PlanState = PlanState.Waiting;
}
void Update()
{
plan.Clear();
// if (view.Plan != null)
// foreach (var i in view.Plan)
// plan.Add(i.name);
planState = view.PlanRunner.PlanState;
if (view.PlanRunner.ActiveTask != null)
{
activeTask = view.PlanRunner.ActiveTask.name;
}
actionState = view.PlanRunner.ActiveState;
}
public PlanState GetCurrentPlanState(DateTime?date = null)
{
var dt = date ?? DateTime.UtcNow;
PlanState res = null;
try
{
var plan = _storage.GetActualPlan(dt);
if (plan != null)
{
var st = plan.StartDate;
var en = plan.EndDate;
var bc = _storage.GetBaseCurrency();
var transactions = _storage.GetTransactions(st, en);
var days = Math.Ceiling(plan.EndDate.Subtract(st).TotalDays);
var alreadySpent = transactions.Where(t => t.Amount < 0 && t.TransactionDate < dt.Date).Sum(t => - 1 * t.BaseCurrencyAmount);
var todaySpent = transactions.Where(t => t.Amount < 0 && t.TransactionDate >= dt.Date && t.TransactionDate <= dt).Sum(t => - 1 * t.BaseCurrencyAmount);
var curDayNumber = Math.Floor(dt.Subtract(st).TotalDays);
var dailyBudget = (plan.Amount - alreadySpent) / (days - curDayNumber);
var planSeconds = plan.EndDate.Subtract(st).TotalSeconds;
//number of seconds that will be at end of day
var currentSeconds = _convertor.GetUtcDateTime(new DateTime(dt.Year, dt.Month, dt.Day, 23, 59, 59)).Subtract(st).TotalSeconds;
var plannedSpent = plan.Amount * (currentSeconds / planSeconds);
res = new PlanState
{
PlanId = plan.Id,
StartDate = plan.StartDate,
EndDate = plan.EndDate,
DayLimit = dailyBudget,
PlanLimit = plan.Amount,
PlanSpent = alreadySpent + todaySpent,
DaySpent = todaySpent,
PlannedSpend = plannedSpent,
Currency = bc.Code
};
}
}
catch (Exception e)
{
_logger.Write(Severities.Error, "Cannot calculate plan status", e);
}
return(res);
}
public async Task <PlanState> GetPlanState(string id)
{
PlanState res = new();
var op = _master.AddSynchronousOp(() =>
{
var ps = _master.GetPlanState(id);
if (ps is null)
{
throw HttpException.NotFound();
}
res = new PlanState(id, ps);
});
await op.WaitAsync();
return(res);
}
public static void ConfigureAutoMapper()
{
Mapper.CreateMap <PlanDO, PlanNoChildrenDTO>().ForMember(a => a.Id, opts => opts.ResolveUsing(ad => ad.Id))
.ForMember(a => a.Category, opts => opts.ResolveUsing(ad => ad.Category))
.ForMember(a => a.Description, opts => opts.ResolveUsing(ad => ad.Description))
.ForMember(a => a.LastUpdated, opts => opts.ResolveUsing(ad => ad.LastUpdated))
.ForMember(a => a.Name, opts => opts.ResolveUsing(ad => ad.Name))
.ForMember(a => a.PlanState, opts => opts.ResolveUsing(ad => PlanState.IntToString(ad.PlanState)))
.ForMember(a => a.StartingSubPlanId, opts => opts.ResolveUsing(ad => ad.StartingSubPlanId))
.ForMember(a => a.Tag, opts => opts.ResolveUsing(ad => ad.Tag))
.ForMember(a => a.Visibility, opts => opts.ResolveUsing(ad => new PlanVisibilityDTO()
{
Hidden = ad.Visibility.BooleanValue()
}));
Mapper.CreateMap <PlanNoChildrenDTO, PlanDO>().ForMember(a => a.Id, opts => opts.ResolveUsing(ad => ad.Id))
.ForMember(a => a.Category, opts => opts.ResolveUsing(ad => ad.Category))
.ForMember(a => a.Description, opts => opts.ResolveUsing(ad => ad.Description))
.ForMember(a => a.LastUpdated, opts => opts.ResolveUsing(ad => ad.LastUpdated))
.ForMember(a => a.Name, opts => opts.ResolveUsing(ad => ad.Name))
.ForMember(a => a.PlanState, opts => opts.ResolveUsing(ad => PlanState.StringToInt(ad.PlanState)))
.ForMember(a => a.StartingSubPlanId, opts => opts.ResolveUsing(ad => ad.StartingSubPlanId))
.ForMember(a => a.Tag, opts => opts.ResolveUsing(ad => ad.Tag))
.ForMember(a => a.Visibility, opts => opts.ResolveUsing(ad => ad.Visibility?.PlanVisibilityValue()));
Mapper.CreateMap <ActivityNameDTO, ActivityTemplateDO>()
.ForMember(activityTemplateDO => activityTemplateDO.Name, opts => opts.ResolveUsing(e => e.Name))
.ForMember(activityTemplateDO => activityTemplateDO.Version, opts => opts.ResolveUsing(e => e.Version));
Mapper.CreateMap <PlanNoChildrenDTO, PlanDO>();
Mapper.CreateMap <PlanDO, PlanNoChildrenDTO>();
Mapper.CreateMap <ActivityDO, ActivityDTO>();
Mapper.CreateMap <ActivityTemplateDTO, ActivityTemplateSummaryDTO>()
.ForMember(x => x.Name, opts => opts.MapFrom(src => src.Name))
.ForMember(x => x.Version, opts => opts.MapFrom(src => src.Version))
.ForMember(x => x.TerminalName, opts => opts.MapFrom(src => src.Terminal.Name))
.ForMember(x => x.TerminalVersion, opts => opts.MapFrom(src => src.Terminal.Version));
Mapper.CreateMap <Fr8AccountDO, UserDTO>()
.ForMember(dto => dto.EmailAddress, opts => opts.ResolveUsing(e => e.EmailAddress.Address))
.ForMember(dto => dto.Status, opts => opts.ResolveUsing(e => e.State.Value));
}
private void CheckForPlan()
{
if (_currentPath != null)
{
return;
}
if (_currentPlan != null)
{
return;
}
var goal = new PlanGoal
{
Food = HomeCity.CurrentFood + 10,
Wood = HomeCity.CurrentWood + 10,
};
var curState = new PlanState
{
Merchant = this,
Location = HomeCity,
Goal = goal,
Food = HomeCity.CurrentFood,
Wood = HomeCity.CurrentWood,
Gold = HomeCity.CurrentMoney,
Action = PlanAction.Start,
};
var astar = new AStar <PlanState>();
var result = astar.RunToCompletion(curState, goal);
if (result == AStarResult.Failed)
{
if (FindClosestNode() != HomeCity.WalkNode)
{
CurrentGoal = HomeCity.WalkNode;
}
return;
}
_currentPlan = astar.TraverseFromGoal().Reverse().ToList();
}
public BambooBuild(
BambooServer server, string key, string projectName, string masterPlanKey,
BuildResult result, int number, string relativeTime,
string duration, int successfulTests, int failedTests, string reason, PlanState state,
ICollection <RelatedIssue> relatedIssues)
{
MasterPlanKey = masterPlanKey;
ProjectKey = key.Split(new[] { '-' })[0];
ProjectName = projectName;
Server = server;
Key = key;
Result = result;
Number = number;
RelativeTime = relativeTime;
Duration = duration;
SuccessfulTests = successfulTests;
FailedTests = failedTests;
Reason = reason;
State = state;
RelatedIssues = relatedIssues;
}
private async Task RemoveInactiveExistingPlans(IHubCommunicator hubCommunicator, string plan_name, AuthorizationToken authToken)
{
try
{
var existingPlans = (await hubCommunicator.GetPlansByName(plan_name, PlanVisibility.Internal)).ToList();
if (existingPlans.Count > 0)
{
//active MADSE plans are likely related to another DS account
var plansForRemoval = existingPlans
.Where(val =>
(val.PlanState == PlanState.IntToString(PlanState.Inactive)) || //or all from above
!(val.SubPlans.Any() && val.SubPlans.ElementAt(0).Activities.Any() &&
val.SubPlans.ElementAt(0).Activities[1].ActivityTemplate.Name == "Save_All_Payload_To_Fr8_Warehouse")).ToList();
foreach (var plan in plansForRemoval)
{
await hubCommunicator.DeletePlan(plan.Id);
}
Logger.Info($"Removed {plansForRemoval.Count} obsolete MADSE plan");
}
}
catch (Exception exc) { Logger.Info("Failed to remove obsolete MADSE plan"); }
}
private bool UpdatePlanState(PlanState state)
{
PlanHeader header = (PlanHeader)BindingSource.Current;
if (header == null)
{
if (TransferMessageEvent != null)
{
TransferMessageEvent("No Entry");
}
return false;
}
if (header.State != PlanState.New && state == PlanState.New)
{
if (TransferMessageEvent != null)
{
TransferMessageEvent("New state can be started.");
}
return false;
}
int val = Service.UpdatePlanState(header.Id, (int)state);
if (val >= 2)
{
header.State = state;
this.BindingSource.EndEdit();
if (CurrentChanged != null)
{
CurrentChanged(header);
}
}
return (val < 2 ? false : true);
}
/// <summary>
/// Updates the state of the plan add-on.
/// </summary>
/// <param name="planId">The plan id.</param>
/// <param name="addOnId">The add-on id.</param>
/// <param name="newState">The new state.</param>
public Task <PlanAddOnReference> UpdatePlanAddOnStateAsync(string planId, string addOnId, PlanState newState)
{
var input = new PlanAddOnReference()
{
AddOnId = addOnId
};
Uri requestUri = this.CreateRequestUri(string.Format(CultureInfo.InvariantCulture, RelativePaths.PlanAddOn, planId, addOnId));
return(this.SendAsync <PlanAddOnReference, PlanAddOnReference>(this.CreateRequestUri(RelativePaths.PlanAddOns), HttpMethod.Put, input));
}
public LaunchSequencer launchSequencer; // non-null only when plan is running
public PlanRuntimeInfo(ILaunchPlan plan)
{
this.Plan = plan;
launchSequencer = new LaunchSequencer();
State = new PlanState();
}
private PlanConfig()
{
_planState = new PlanState(this);
}
private void Awake()
{
planState = new PlanState(this);
}
public void SetPlanState(string planName, PlanState state)
{
var rti = planRTInfo[planName];
rti.State = state;
}
private PlanInformation(PlanState planStatus, int daysLeft)
{
PlanState = planStatus;
DaysLeft = daysLeft;
}
public PlanResultDTO GetForUser(IUnitOfWork unitOfWork, Fr8AccountDO account, PlanQueryDTO planQueryDTO, bool isAdmin = false)
{
//lets make sure our inputs are correct
planQueryDTO = planQueryDTO ?? new PlanQueryDTO();
planQueryDTO.Page = planQueryDTO.Page ?? 1;
planQueryDTO.Page = planQueryDTO.Page < 1 ? 1 : planQueryDTO.Page;
planQueryDTO.PlanPerPage = planQueryDTO.PlanPerPage ?? DefaultPlanPageSize;
planQueryDTO.PlanPerPage = planQueryDTO.PlanPerPage < MinPlanPageSize ? MinPlanPageSize : planQueryDTO.PlanPerPage;
planQueryDTO.IsDescending = planQueryDTO.IsDescending ?? planQueryDTO.OrderBy?.StartsWith("-") ?? true;
if (planQueryDTO.OrderBy?.StartsWith("-") == true)
{
planQueryDTO.OrderBy = planQueryDTO.OrderBy.Substring(1);
}
var planQuery = unitOfWork.PlanRepository.GetPlanQueryUncached()
.Where(x => x.Visibility == PlanVisibility.Standard);
if (planQueryDTO.AppsOnly)
{
planQuery = planQueryDTO.Id == null
? planQuery.Where(pt => pt.IsApp == true)
: planQuery.Where(pt => pt.Id == planQueryDTO.Id && pt.IsApp == true);
if (account.OrganizationId.HasValue)
{
// If the current user belongs to some organization,
// display all apps for that organization
planQuery = planQuery.Where(pt => pt.Fr8Account.OrganizationId == account.OrganizationId);
}
else
{
// If user does not belong to an org, just display his/her own apps.
planQuery = planQuery.Where(pt => pt.Fr8Account.Id == account.Id);
}
}
else
{
planQuery = planQueryDTO.Id == null
? planQuery.Where(pt => pt.Fr8Account.Id == account.Id)
: planQuery.Where(pt => pt.Id == planQueryDTO.Id && pt.Fr8Account.Id == account.Id);
}
planQuery = !string.IsNullOrEmpty(planQueryDTO.Category)
? planQuery.Where(c => c.Category == planQueryDTO.Category)
: planQuery.Where(c => string.IsNullOrEmpty(c.Category));
if (!string.IsNullOrEmpty(planQueryDTO.Filter))
{
planQuery = planQuery.Where(c => c.Name.Contains(planQueryDTO.Filter) || c.Description.Contains(planQueryDTO.Filter));
}
if (planQueryDTO.AppsOnly)
{
planQuery = planQuery.Where(c => c.IsApp == true);
}
int?planState = null;
if (planQueryDTO.Status != null)
{
planState = PlanState.StringToInt(planQueryDTO.Status);
}
planQuery = planState == null
? planQuery.Where(pt => pt.PlanState != PlanState.Deleted)
: planQuery.Where(pt => pt.PlanState == planState);
// Lets allow ordering with just name for now
if (planQueryDTO.OrderBy == "name")
{
planQuery = planQueryDTO.IsDescending.Value
? planQuery.OrderByDescending(p => p.Name)
: planQuery.OrderBy(p => p.Name);
}
else
{
planQuery = planQueryDTO.IsDescending.Value
? planQuery.OrderByDescending(p => p.LastUpdated)
: planQuery.OrderBy(p => p.LastUpdated);
}
var totalPlanCountForCurrentCriterias = planQuery.Count();
planQuery = planQuery.Skip(planQueryDTO.PlanPerPage.Value * (planQueryDTO.Page.Value - 1))
.Take(planQueryDTO.PlanPerPage.Value);
return(new PlanResultDTO
{
Plans = planQuery.ToList().Select(Mapper.Map <PlanNoChildrenDTO>).ToList(),
CurrentPage = planQueryDTO.Page.Value,
TotalPlanCount = totalPlanCountForCurrentCriterias
});
}
public void SetPlanState(string planName, PlanState state)
{
localOps.SetPlanState(planName, state);
}
private Expression CreateRandomQueryPlan(IList<QueryPredicate> expressions, IList<TableName> sourceList, IList<Expression> sourceListExps, Expression joinGraph)
{
Expression static_expression = null;
// For each input expression
foreach (QueryPredicate expr in expressions) {
// Find all static expressions (not dependant on terms in the current
// query context) and make a single static expression to resolve it.
int depend_on_count = expr.dependant_on.Count;
// No dependants
if (depend_on_count == 0) {
// Create the static expression if there is one,
static_expression = static_expression == null
? expr.expression
: new FunctionExpression("@and_sql", new Expression[] {static_expression, expr.expression});
}
// Mark up index information
MarkUpIndexCandidates(expr.expression);
// Mark up fact information
if (FactStatistics.CanBeFact(expr.expression)) {
Expression derefExp = QueryCostModel.DereferenceExpression(joinGraph, expr.expression);
if (derefExp != null) {
expr.expression.SetArgument("fact_id", FactStatistics.ToFactId(derefExp));
}
}
}
// Create the sort function
Expression sortFunction = null;
if (sortComposite != null) {
sortFunction = (Expression) sortComposite.Clone();
// Mark up any index information on the composite
MarkUpIndexCandidates(sortFunction);
}
// Create the cost model
QueryCostModel costModel = new QueryCostModel(transaction);
// The list of the best plans in the current iteration
List<PlanState> plans1 = new List<PlanState>();
int[] walkIteration = new int[1];
long plan_seed = DateTime.Now.Ticks; // Arbitary starting seed value
int cost_iterations = 0;
// Randomly schedule
for (int i = 0; i < 64; ++i) {
// Produce a random plan
IList<QueryPredicate> predOrder = ShufflePredicateOrder(expressions, 1.0d);
Expression result = ProduceRandomPlan(plan_seed, predOrder, sourceListExps, joinGraph, sortFunction,
static_expression);
// Cost it out
costModel.ClearGraph(result);
costModel.Cost(result, Double.PositiveInfinity, walkIteration);
++cost_iterations;
double currentCostTime = result.CostTime;
if (plans1.Count < 8 ||
plans1[plans1.Count - 1].cost > currentCostTime) {
// If it's a good plan, add it to the plan list
PlanState state1 = new PlanState(plan_seed, predOrder, currentCostTime);
int pos = plans1.BinarySearch(state1);
if (pos < 0) {
pos = -(pos + 1);
}
plans1.Insert(pos, state1);
}
// Ensure the list of good plans isn't more than 48
if (plans1.Count > 48) {
plans1.RemoveAt(plans1.Count - 1);
}
// Increment the plan seed
plan_seed += 500000;
}
// Now go through the list from the end to the start and shuffle the
// predicates. If a better plan is found we insert it back into the list.
for (int i = plans1.Count - 1; i >= 0; --i) {
int tryCount;
int graphMessChance;
if (i <= 2) {
tryCount = 32;
graphMessChance = 120;
} else if (i <= 3) {
tryCount = 32;
graphMessChance = 120;
} else if (i <= 5) {
tryCount = 24;
graphMessChance = 60;
} else if (i <= 8) {
tryCount = 18;
graphMessChance = 30;
} else if (i <= 16) {
tryCount = 18;
graphMessChance = 10;
} else {
tryCount = 12;
graphMessChance = 1;
}
int worse_plans_count = 0;
for (int n = 0; n < tryCount; ++n) {
PlanState curState = plans1[i];
plan_seed = curState.seed;
int bestI = System.Math.Min(plans1.Count - 1, 4);
double costToBeat = plans1[bestI].cost;
// Shuffle the predicate order of this plan
IList<QueryPredicate> predOrder = ShufflePredicateOrder(curState.predicate_order, 0.012d);
// 10% chance that we change the seed also,
if (i > 14 ||
new Random().Next(graphMessChance) == 0) {
plan_seed = plan_seed + 1;
}
Expression result = ProduceRandomPlan(plan_seed, predOrder, sourceListExps, joinGraph, sortFunction,
static_expression);
// Cost it out
costModel.ClearGraph(result);
costModel.Cost(result, costToBeat, walkIteration);
++cost_iterations;
if (result.IsCostSet) {
double currentCostTime = result.CostTime;
// If it's a better plan, feed it back into the list
if (currentCostTime < curState.cost &&
currentCostTime < costToBeat) {
// If it's a good plan, add it to the plan list
PlanState state1 = new PlanState(plan_seed, predOrder, currentCostTime);
// NOTE; this doesn't add the entry to the list if there exists
// an entry that's the same cost and seed.
int pos = plans1.BinarySearch(state1);
if (pos < 0) {
pos = -(pos + 1);
plans1.Insert(pos, state1);
++i;
}
} else {
if (currentCostTime > costToBeat) {
++worse_plans_count;
}
}
}
}
// Remove all plans down to i
for (int n = plans1.Count - 1; n >= System.Math.Max(i, 8); --n) {
plans1.RemoveAt(n);
}
}
// Make up the best plan from the seed,
PlanState state = plans1[0];
Expression bestExp = ProduceRandomPlan(state.seed, state.predicate_order, sourceListExps, joinGraph, sortFunction,
static_expression);
// Make sure the cost information is correct for this graph before printing
// it out
costModel.ClearGraph(bestExp);
costModel.Cost(bestExp, Double.PositiveInfinity, new int[1]);
return bestExp;
}
public void ConfigureAutoMapper()
{
Mapper.CreateMap <PlanDO, PlanNoChildrenDTO>().ForMember(a => a.Id, opts => opts.ResolveUsing(ad => ad.Id))
.ForMember(a => a.Category, opts => opts.ResolveUsing(ad => ad.Category))
.ForMember(a => a.Description, opts => opts.ResolveUsing(ad => ad.Description))
.ForMember(a => a.LastUpdated, opts => opts.ResolveUsing(ad => ad.LastUpdated))
.ForMember(a => a.Name, opts => opts.ResolveUsing(ad => ad.Name))
.ForMember(a => a.PlanState, opts => opts.ResolveUsing(ad => PlanState.IntToString(ad.PlanState)))
.ForMember(a => a.StartingSubPlanId, opts => opts.ResolveUsing(ad => ad.StartingSubPlanId))
.ForMember(a => a.Tag, opts => opts.ResolveUsing(ad => ad.Tag))
.ForMember(a => a.Visibility, opts => opts.ResolveUsing(ad => new PlanVisibilityDTO()
{
Hidden = ad.Visibility.BooleanValue()
}));
Mapper.CreateMap <PlanNoChildrenDTO, PlanDO>().ForMember(a => a.Id, opts => opts.ResolveUsing(ad => ad.Id))
.ForMember(a => a.Category, opts => opts.ResolveUsing(ad => ad.Category))
.ForMember(a => a.Description, opts => opts.ResolveUsing(ad => ad.Description))
.ForMember(a => a.LastUpdated, opts => opts.ResolveUsing(ad => ad.LastUpdated))
.ForMember(a => a.Name, opts => opts.ResolveUsing(ad => ad.Name))
.ForMember(a => a.PlanState, opts => opts.ResolveUsing(ad => PlanState.StringToInt(ad.PlanState)))
.ForMember(a => a.StartingSubPlanId, opts => opts.ResolveUsing(ad => ad.StartingSubPlanId))
.ForMember(a => a.Tag, opts => opts.ResolveUsing(ad => ad.Tag))
.ForMember(a => a.Visibility, opts => opts.ResolveUsing(ad => ad.Visibility?.PlanVisibilityValue()));
Mapper.CreateMap <ActivityDO, ActivityDTO>().ForMember(a => a.Id, opts => opts.ResolveUsing(ad => ad.Id))
.ForMember(a => a.RootPlanNodeId, opts => opts.ResolveUsing(ad => ad.RootPlanNodeId))
.ForMember(a => a.ParentPlanNodeId, opts => opts.ResolveUsing(ad => ad.ParentPlanNodeId))
.ForMember(a => a.ChildrenActivities, opts => opts.ResolveUsing(ad => ad.ChildNodes.OfType <ActivityDO>().OrderBy(da => da.Ordering)))
.ForMember(a => a.ActivityTemplate, opts => opts.ResolveUsing(GetActivityTemplate))
.ForMember(a => a.AuthToken, opts => opts.ResolveUsing(ad => ad.AuthorizationToken));
Mapper.CreateMap <ActivityDTO, ActivityDO>().ForMember(a => a.Id, opts => opts.ResolveUsing(ad => ad.Id))
.ForMember(a => a.RootPlanNodeId, opts => opts.ResolveUsing(ad => ad.RootPlanNodeId))
.ForMember(a => a.ParentPlanNodeId, opts => opts.ResolveUsing(ad => ad.ParentPlanNodeId))
//.ForMember(a => a.ActivityTemplate, opts => opts.Ignore())
.ForMember(a => a.ActivityTemplateId, opts => opts.ResolveUsing(GetActivityTemplateId))
//.ForMember(a => a.CrateStorage, opts => opts.ResolveUsing(ad => Newtonsoft.Json.JsonConvert.SerializeObject(ad.CrateStorage)))
.ForMember(a => a.ChildNodes, opts => opts.ResolveUsing(ad => MapActivities(ad.ChildrenActivities)))
.ForMember(a => a.AuthorizationTokenId, opts => opts.ResolveUsing(ad => ad.AuthToken != null && ad.AuthToken.Id != null ? new Guid(ad.AuthToken.Id) : (Guid?)null));
Mapper.CreateMap <ActivityTemplateDO, ActivityTemplateSummaryDTO>()
.ForMember(x => x.Name, opts => opts.ResolveUsing(x => x.Name))
.ForMember(x => x.Version, opts => opts.ResolveUsing(x => x.Version))
.ForMember(x => x.TerminalName, opts => opts.ResolveUsing(x => x.Terminal.Name))
.ForMember(x => x.TerminalVersion, opts => opts.ResolveUsing(x => x.Terminal.Version));
Mapper.CreateMap <ActivityTemplateDO, ActivityTemplateDTO>()
.ForMember(x => x.Id, opts => opts.ResolveUsing(x => x.Id))
.ForMember(x => x.Name, opts => opts.ResolveUsing(x => x.Name))
.ForMember(x => x.Version, opts => opts.ResolveUsing(x => x.Version))
.ForMember(x => x.Terminal, opts => opts.ResolveUsing(GetTerminal))
.ForMember(x => x.NeedsAuthentication, opts => opts.ResolveUsing(x => x.NeedsAuthentication));
Mapper.CreateMap <Fr8AccountDO, ManageUserVM>()
.ForMember(mu => mu.HasLocalPassword, opts => opts.ResolveUsing(account => !string.IsNullOrEmpty(account.PasswordHash)))
.ForMember(mu => mu.HasGoogleToken, opts => opts.Ignore())
.ForMember(mu => mu.GoogleSpreadsheets, opts => opts.Ignore());
Mapper.CreateMap <UserVM, EmailAddressDO>()
.ForMember(userDO => userDO.Address, opts => opts.ResolveUsing(e => e.EmailAddress));
Mapper.CreateMap <UserVM, Fr8AccountDO>()
.ForMember(userDO => userDO.Id, opts => opts.ResolveUsing(e => e.Id))
.ForMember(userDO => userDO.FirstName, opts => opts.ResolveUsing(e => e.FirstName))
.ForMember(userDO => userDO.LastName, opts => opts.ResolveUsing(e => e.LastName))
.ForMember(userDO => userDO.UserName, opts => opts.ResolveUsing(e => e.UserName))
.ForMember(userDO => userDO.EmailAddress, opts => opts.ResolveUsing(e => new EmailAddressDO {
Address = e.EmailAddress
}))
.ForMember(userDO => userDO.Roles, opts => opts.Ignore());
Mapper.CreateMap <PageDefinitionDTO, PageDefinitionDO>()
.ForMember(dest => dest.Url, opts => opts.Ignore())
.ForMember(dest => dest.Tags, opts => opts.MapFrom(
x => x.Tags.Split(new[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries).ToList()));
Mapper.CreateMap <PageDefinitionDO, PageDefinitionDTO>()
.ForMember(dest => dest.Tags, opts => opts.MapFrom(x => string.Join(", ", x.Tags)));
}
/// <summary>
/// Updates the state of the plan add-on.
/// </summary>
/// <param name="planId">The plan id.</param>
/// <param name="addOnId">The add-on id.</param>
/// <param name="newState">The new state.</param>
public Task<PlanAddOnReference> UpdatePlanAddOnStateAsync(string planId, string addOnId, PlanState newState)
{
var input = new PlanAddOnReference()
{
AddOnId = addOnId
};
Uri requestUri = this.CreateRequestUri(string.Format(CultureInfo.InvariantCulture, RelativePaths.PlanAddOn, planId, addOnId));
return this.SendAsync<PlanAddOnReference, PlanAddOnReference>(this.CreateRequestUri(RelativePaths.PlanAddOns), HttpMethod.Put, input);
}
private PlanConfig()
{
_planState = new PlanState(this);
}
private void ExecutePlan()
{
if (_currentPath != null)
{
return;
}
if (_currentAction == null)
{
if (_currentPlan == null)
{
return;
}
if (_currentPlan.Count == 0)
{
_currentPlan = null;
return;
}
_currentAction = _currentPlan[0];
_currentPlan.RemoveAt(0);
CurrentGoal = _currentAction.Location.WalkNode;
}
else
{
var them = _currentAction.Location;
float price;
switch (_currentAction.Action)
{
case PlanAction.Start:
break;
case PlanAction.BuyWood:
price = them.GetPrice(RESOURCES.WOOD) * 5;
HomeCity.CurrentWood += 5;
HomeCity.CurrentMoney -= price;
them.CurrentWood -= 5;
them.CurrentMoney += price;
break;
case PlanAction.SellWood:
price = them.GetPrice(RESOURCES.WOOD) * 5;
HomeCity.CurrentWood -= 5;
HomeCity.CurrentMoney += price;
them.CurrentWood += 5;
them.CurrentMoney -= price;
break;
case PlanAction.BuyFood:
price = them.GetPrice(RESOURCES.FOOD) * 5;
HomeCity.CurrentFood += 5;
HomeCity.CurrentMoney -= price;
them.CurrentFood -= 5;
them.CurrentMoney += price;
break;
case PlanAction.SellFood:
price = them.GetPrice(RESOURCES.FOOD) * 5;
HomeCity.CurrentFood -= 5;
HomeCity.CurrentMoney += price;
them.CurrentFood += 5;
them.CurrentMoney -= price;
break;
default:
throw new ArgumentOutOfRangeException();
}
_currentAction = null;
}
}
private void Awake()
{
planState = new PlanState(this);
performActionState = new PerformActionState(this);
moveToState = new MoveToState(this);
}
private static void InitTree(Layer3DPlanTreePad pad, TreeList parentTree, IDataSource ds, List <Plan> allPlans, Dictionary <int, int> ViewPlanIds)
{
List <Plan> list = new List <Plan>();
List <Plan> list2 = new List <Plan>();
if ((allPlans != null) && (allPlans.Count > 0))
{
List <int> list3 = ViewPlanIds.Keys.ToList <int>();
if ((list3 != null) && (list3.Count > 0))
{
foreach (Plan plan in allPlans)
{
if (list3.Contains(plan.PlanID))
{
list2.Add(plan);
}
list.Add(plan);
}
}
else
{
foreach (Plan plan2 in allPlans)
{
list.Add(plan2);
}
}
}
List <Project> list4 = SelectProjects(ds, "1=1");
List <int> projIds = new List <int>();
foreach (Project project in list4)
{
projIds.Add(project.ProjectID);
}
//**********加权限 控制可见性 修改**********
//****************************************
List <Project> list6 = new List <Project>();//当前用户
if ((projIds != null) && (projIds.Count > 0))
{
foreach (Project project2 in list4)
{
if (projIds.Contains(project2.ProjectID))
{
list6.Add(project2);
}
}
}
ProjectManagerLayer pml = new ProjectManagerLayer()
{
Name = "建设项目"
};
TreeListNode nodepml = parentTree.AppendNode(new object[] { pml.Name }, (TreeListNode)null);
if (pml != null)
{
pml.LogicTree = pad;
pml.OwnNode = nodepml;
pml.Visible = nodepml.Checked = true;
}
ProjectLayerService.Instance.ProjectsRoot = pml;
CompletedProjectManagerLayer cpml = new CompletedProjectManagerLayer()
{
Name = "竣工项目"
};
TreeListNode nodecpml = parentTree.AppendNode(new object[] { cpml.Name }, (TreeListNode)null);
if (cpml != null)
{
cpml.LogicTree = pad;
cpml.OwnNode = nodecpml;
cpml.Visible = nodecpml.Checked = true;
}
ProjectLayerService.Instance.CompletedProjectRoot = cpml;
FormallyProjectManagerLayer fpml = new FormallyProjectManagerLayer()
{
Name = "正式项目"
};
TreeListNode nodefpml = parentTree.AppendNode(new object[] { fpml.Name }, (TreeListNode)null);
if (fpml != null)
{
fpml.LogicTree = pad;
fpml.OwnNode = nodefpml;
fpml.Visible = nodefpml.Checked = true;
}
ProjectLayerService.Instance.FormallyProjectRoot = fpml;
if ((list6 != null) && (list6.Count > 0))
{
foreach (Project project3 in list6)
{
ProjectGroupLayer class2 = null;
List <Plan> list7 = new List <Plan>();
PlanState formally = PlanState.New;
foreach (Plan plan4 in list)
{
if (plan4.ProjectID == project3.ProjectID)
{
if (plan4.PlanState == PlanState.Formally)
{
formally = PlanState.Formally;
}
else if (plan4.PlanState == PlanState.Completed)
{
formally = PlanState.Completed;
}
if (list2.Contains(plan4))
{
list7.Add(plan4);
}
}
}
foreach (Plan plan6 in list7)
{
list2.Remove(plan6);
}
foreach (Plan plan7 in list7)
{
list.Remove(plan7);
}
switch (formally)
{
case PlanState.New:
class2 = ProjectLayerService.Instance.ProjectsRoot.CreateProject(project3);
break;
case PlanState.Formally:
class2 = ProjectLayerService.Instance.FormallyProjectRoot.CreateProject(project3);
break;
case PlanState.Completed:
class2 = ProjectLayerService.Instance.CompletedProjectRoot.CreateProject(project3);
break;
}
if (class2 != null)
{
class2.SetTerrainModifier(project3.ProjectRemark1, project3.ProjectElevation);
foreach (Plan plan8 in list7)
{
Plan plan = plan8.Clone();
UrbanPlan plan10 = new UrbanPlan(ref plan);
PlanGroupLayer class3 = class2.CreatePlan(ref plan10);
}
}
}
}
}
public void SetPlanState(string planName, PlanState state)
{
impl.SetPlanState(planName, state);
}
public override int GetHashCode()
{
return(PlanState.GetHashCode() ^ DaysLeft.GetHashCode());
}
