public int UpdateDueByDates(PlanningApp planningApp) //Called when inserting a new state to an existing planning app
{
int statesUpdated = 0;
if (!planningApp.Completed())
{
var prevState = new PlanningAppState();
var currState = planningApp.Current();
var resetCurrent = planningApp.Current();
while (currState != null)
{
if (!planningApp.isFirstState(currState))
{
prevState = planningApp.SeekPrev();
currState.AggregateDueByDate(prevState);
}
else
{
currState.SetDueByDateFrom(planningApp.StartDate); //First State In Project
}
statesUpdated++;
currState = planningApp.Next(currState);
}
//Set original state
planningApp.SetCurrent(resetCurrent);
}
return(statesUpdated);
}
public void UpdateCustomDueByDate(PlanningAppState planningAppState, DateTime dueByDate)
{
int daysDiff;
if (dueByDate > planningAppState.DueByDate)
{
daysDiff = planningAppState.DueByDate.GetBusinessDays(dueByDate, new List <DateTime>());//Move dates forward
}
else
{
daysDiff = dueByDate.GetBusinessDays(planningAppState.DueByDate, new List <DateTime>()) * -1; //Move dates back
}
if (daysDiff != 0)
{ //Date are different so customise
if (planningAppState.CustomDurationSet == true)
{
planningAppState.CustomDuration += daysDiff;
}
else
{
planningAppState.CustomDurationSet = true;
planningAppState.CustomDuration = (planningAppState.state.CompletionTime + daysDiff);
}
}
}
public DateTime SetMinDueByDate(PlanningApp planningApp, PlanningAppState planningAppState)
{
DateTime minDueByDate = new DateTime();
if (!planningApp.Completed())
{
var current = planningApp.Current();
var currentDate = SystemDate.Instance.date;
if (planningApp.isFirstState(planningAppState))
{
minDueByDate = currentDate.AddBusinessDays(1); //Add one day
}
else if (planningAppState.CurrentState == true)
{
minDueByDate = currentDate.AddBusinessDays(1);
}
else if (planningApp.SeekPrev(planningAppState).DueByDate <= currentDate)
{
minDueByDate = currentDate.AddBusinessDays(1);
}
else
{
minDueByDate = planningApp.SeekPrev(planningAppState).DueByDate.AddBusinessDays(1);
}
}
return(minDueByDate);
}
public PlanningApp InsertPlanningState(PlanningApp planningApp, int GeneratorOrder, StateInitialiser generator, StateInitialiserState stateInitialiserState)
{
if (!CanInsertState(planningApp, GeneratorOrder, stateInitialiserState))
{
return(planningApp);
}
PlanningAppState newPlanningAppState = new PlanningAppState();
newPlanningAppState.state = stateInitialiserState;
foreach (var stateInitialiserStateCustomField in newPlanningAppState.state.StateInitialiserStateCustomFields)
{
newPlanningAppState.customFields
.Add(new PlanningAppStateCustomField {
StateInitialiserStateCustomFieldId = stateInitialiserStateCustomField.StateInitialiserCustomFieldId
});
}
//Console.WriteLine("Adding States " + stateInitialiserState.Name + " To Planning App");
newPlanningAppState.GeneratorOrder = GeneratorOrder;
newPlanningAppState.GeneratorName = generator.Name;
newPlanningAppState.StateStatus = statusList.Where(s => s.Name == StatusList.OnTime).SingleOrDefault();
planningApp.PlanningAppStates.Add(newPlanningAppState);
return(planningApp);
}
public async Task <PlanningApp> AppendGenerator(PlanningApp planningApp, int SequenceId, int NewGeneratorId)
{
var currentDate = DateService.GetCurrentDate();
PlanningAppState newPlanningAppState = new PlanningAppState();
var generator = await StateInitialiserRepository.GetStateInitialiser(NewGeneratorId);
var generatorExists = planningApp.OrderedPlanningAppStates.Any(ps => ps.GeneratorOrder == SequenceId);
//increase SequenceId of all future generators ad insert new one
if (generatorExists)
{
planningApp.PlanningAppStates
.Where(g => g.GeneratorOrder >= SequenceId)
.Select(g => { g.GeneratorOrder++; return(g); })
.ToList();
}
foreach (var state in generator.OrderedStates)
{
InsertPlanningState(planningApp, SequenceId, generator, state);
}
UpdateDueByDates(planningApp);
return(planningApp);
}
public bool IsValid(PlanningAppState planningAppState)
{
foreach (var template in planningAppState.state.StateInitialiserStateCustomFields)
{
var value = planningAppState.customFields
.Where(r => r.StateInitialiserStateCustomFieldId == template.StateInitialiserCustomFieldId).SingleOrDefault();
if (string.IsNullOrWhiteSpace(value.StrValue) && template.StateInitialiserCustomField.isMandatory)
{
return(false);
}
}
return(true);
}
public int CompleteState(PlanningAppState planningAppState)
{
if (CompletionDate > planningAppState.DueByDate)
{
planningAppState.StateStatus = statusList.Where(s => s.Name == StatusList.Overran).SingleOrDefault();
}
else
{
planningAppState.StateStatus = statusList.Where(s => s.Name == StatusList.Complete).SingleOrDefault();
}
planningAppState.CompletionDate = CompletionDate;
planningAppState.CurrentState = false;
//return days diff
return(planningAppState.DueByDate.GetBusinessDays(CompletionDate, new List <DateTime>()));
}
public PlanningApp RemoveGenerator(PlanningApp planningApp, int SequenceId, int GeneratorId)
{
var currentDate = DateService.GetCurrentDate();
PlanningAppState newPlanningAppState = new PlanningAppState();
//var generator = await StateInitialiserRepository.GetStateInitialiser(GeneratorId);
var statesToDelete = planningApp.PlanningAppStates.Where(s => s.GeneratorOrder == SequenceId).ToList();
foreach (var planningAppState in statesToDelete)
{
planningApp.PlanningAppStates.Remove(planningAppState);
}
//Shift states up
planningApp.OrderedPlanningAppStates
.Where(g => g.GeneratorOrder >= SequenceId)
.Select(g => { g.GeneratorOrder--; return(g); })
.ToList();
UpdateDueByDates(planningApp);
return(planningApp);
}
public void Update(PlanningAppState planningAppState)
{
vegaDbContext.Update(planningAppState);
}
public void Remove(PlanningAppState planningAppState)
{
vegaDbContext.Remove(planningAppState);
}
public PlanningAppStateCustomField getPlanningAppStateCustomField(PlanningAppState planningAppState, int resourceId)
{
return(planningAppState.customFields
.Where(r => r.StateInitialiserStateCustomFieldId == resourceId).SingleOrDefault());
}
