/// <summary>
/// Удалить обслуживание
/// </summary>
/// <param name="entity"></param>
public void RemoveMaintenance(MaintenanceActual entity)
{
var lastMaintenanceMap = LastMaintenance.ToDictionary(x => x.MaintenanceType.Id);
//восстанавливаем данные из снимка
entity.Snapshot.ToList().ForEach(x =>
{
var last = lastMaintenanceMap[x.MaintenanceType.Id];
last.UsageFromLastMaintenance = x.UsageFromLastMaintenance;
last.LastMaintenanceDate = x.LastMaintenanceDate;
});
//если это текущее обслуживание, то сбрасываем его
if (!entity.IsFinalized() && CurrentMaintenance == entity)
{
CurrentMaintenance = null;
}
maintenance.Remove(entity);
}
/// <summary>
/// Установка следующего обслуживания(данные для индикатора следующего ремонта)
/// </summary>
public void SetNextMaintenance()
{
//чтобы рассчитать следующее обслуживание нужно сравнить по всем обслуживаниям разницу наработки норма-факт и взять меньшую разницу
var intervals = Intervals.ToList();
intervals.Sort();
var intervalsMap = intervals.ToDictionary(x => x.MaintenanceType.Id);
var lastUsageMap = LastMaintenance.ToDictionary(x => x.MaintenanceType.Id, x => x.UsageFromLastMaintenance);
MaintenanceType next = null;
int? fact = 0;
int? norm = 0;
int? normMax = 0;
intervals.ForEach(interval =>
{
var usage = lastUsageMap[interval.MaintenanceType.Id];
if (
next == null ||
//сравниваем значения как по величине так и по модулю, на случай если ремонт пропущен и разница минусовая
(interval.MinUsage - usage < norm - fact &&
Math.Abs(interval.MinUsage.Value - usage.Value) < Math.Abs(norm.Value - fact.Value))
)
{
next = interval.MaintenanceType;
norm = interval.MinUsage;
normMax = interval.MaxUsage;
fact = usage;
}
});
NextMaintenance = next;
NextUsageFact = fact;
NextUsageNorm = norm;
NextUsageNormMax = normMax;
}
/// <summary>
/// Спланировать работы по обслуживанию
/// </summary>
/// <param name="period">Период планирования</param>
/// <param name="offer">Предложение обслуживания</param>
/// <param name="offerReason">Причина предложения</param>
public void PlanningMaintenance(Period period, MaintenanceType offer = null, MaintenanceReason offerReason = null)
{
//если оборудование не эксплуатируется, то ничего не планируем
if (CurrentOperatingState != OperatingState.Operating)
{
return;
}
//проверяем предыдущий период если план невыполнен то переносим в след период
var prevPlan = plans.FirstOrDefault(x => x.MaintenanceDate >= period.Prev().Start() && x.MaintenanceDate <= period.Prev().End());
if (prevPlan != null && !maintenance.Any(x => x.StartMaintenance >= period.Prev().Start() && x.StartMaintenance <= period.Prev().End()))
{
plans.Add(new MaintenancePlan(
this,
prevPlan.MaintenanceType,
period.Start(),
true,
false,
prevPlan.OfferReason
));
return;
}
///сортируем интервалы по величине ремонта (самый крупный будет первым)
var intervals = Intervals.ToList();
intervals.Sort();
var intervalsMap = intervals.ToDictionary(x => x.MaintenanceType.Id);
var lastDateMap = LastMaintenance.ToDictionary(x => x.MaintenanceType.Id, x => x.LastMaintenanceDate);
var lastUsageMap = LastMaintenance.ToDictionary(x => x.MaintenanceType.Id, x => x.UsageFromLastMaintenance);
var hours = period.Hours();
intervals.Any(interval =>
{
var type = interval.MaintenanceType.Id;
if (!lastUsageMap.ContainsKey(type))
{
var newLast = new LastMaintenance(interval.MaintenanceType, null, null)
{
Object = this
};
lastMaintenance.Add(newLast);
lastUsageMap.Add(type, 0);
lastDateMap.Add(type, null);
}
//проверка по наработке
if (interval.MinUsage != null)
{
var fork = interval.MaxUsage - interval.MinUsage;
var targetUsage = fork >= 5000 ? interval.MinUsage.Value + fork / 2 : interval.MinUsage.Value;
if (lastUsageMap[type].Value >= targetUsage)
{
//дата проведения обслуживания
var date = period.Start().AddDays((interval.MinUsage.Value - lastUsageMap[type].Value) / 24);
//если дата ремонта выходит за пределы периода, то устонавливаем её в пределы периода
if (date > period.End())
{
date = period.End();
}
if (date < period.Start())
{
date = period.Start();
}
plans.Add(new MaintenancePlan(this, interval.MaintenanceType, date));
return(true);
}
}
//проверка по времени
if (interval.PeriodQuantity != null)
{
//todo сделать проверку интервалов по времени
}
//проверка по предложению
if (offer != null && offer.Id == type)
{
plans.Add(new MaintenancePlan(this, interval.MaintenanceType, period.Start(), false, true, offerReason));
return(true);
}
return(false);
});
}
/// <summary>
/// Откатить отчёт
/// </summary>
public void DiscardReport()
{
//Если оборудование демонтировано, то отчёт не откатываем
if (CurrentOperatingState == OperatingState.UnMounted)
{
return;
}
var CurrentPeriod = Report.Period;
var PrevPeriod = CurrentPeriod.Prev();
Report.Period = PrevPeriod;
//восстанавливаем план
var plan = plans.FirstOrDefault(x => x.MaintenanceDate >= CurrentPeriod.Start() && x.MaintenanceDate <= CurrentPeriod.End());
if (plan != null)
{
//если было предложение то восстанавливаем его
if (plan.IsOffer)
{
Report.OfferForPlan = plan.MaintenanceType;
Report.ReasonForOffer = plan.OfferReason;
}
plans.Remove(plan);
}
//Востанавливаем наработку
var prevUsageAfter = usage.Where(x => x.EndUsage == PrevPeriod.End() && x.StartUsage > PrevPeriod.Start()).FirstOrDefault();
if (prevUsageAfter != null) //наработка после ремонта
{
RemoveUsage(prevUsageAfter);
}
Report.UsageAfterMaintenance = prevUsageAfter?.Usage ?? 0;
var prevMaintenance = maintenance.Where(x => x.StartMaintenance >= PrevPeriod.Start()).FirstOrDefault();
if (prevMaintenance != null)
{
Report.ActualMaintenanceType = prevMaintenance.MaintenanceType;
Report.StartMaintenance = prevMaintenance.StartMaintenance;
Report.EndMaintenance = prevMaintenance.EndMaintenance;
RemoveMaintenance(prevMaintenance);
}
var notFinalized = maintenance.Where(x => x.EndMaintenance >= PrevPeriod.Start() && x.StartMaintenance < PrevPeriod.Start()).FirstOrDefault();
if (notFinalized != null)
{
var lastMaintenanceMap = LastMaintenance.ToDictionary(x => x.MaintenanceType.Id);
notFinalized.Snapshot.ToList().ForEach(x =>
{
var last = lastMaintenanceMap[x.MaintenanceType.Id];
last.UsageFromLastMaintenance = x.UsageFromLastMaintenance;
last.LastMaintenanceDate = x.LastMaintenanceDate;
});
Report.ActualMaintenanceType = notFinalized.MaintenanceType;
Report.EndMaintenance = notFinalized.EndMaintenance;
Report.StartMaintenance = notFinalized.StartMaintenance;
notFinalized.EndMaintenance = null;
CurrentMaintenance = notFinalized;
}
var prevUsageBefore = usage.Where(x => x.StartUsage == PrevPeriod.Start()).FirstOrDefault();
if (prevUsageBefore != null)//наработка до ремонта
{
RemoveUsage(prevUsageBefore);
}
Report.UsageBeforeMaintenance = prevUsageBefore?.Usage ?? 0;
if (Parent != null)
{
var parentUsage = Parent.usage.Where(x => x.StartUsage >= PrevPeriod.Start() && x.EndUsage <= PrevPeriod.End()).Sum(x => x.Usage);
Report.UsageParent = parentUsage;
}
else
{
Report.UsageParent = 0;
}
if (Children.Any())
{
Children.ToList().ForEach(x =>
{
if (x.Report.Period.period == CurrentPeriod.period)
{
x.Report.UsageParent = 0;
}
});
}
//восстанавливаем состояние
var lastState = operatingStates.FirstOrDefault(x => x.StartDate >= PrevPeriod.Start());
operatingStates.Where(x => x.StartDate >= PrevPeriod.Start()).ToList().ForEach(x => operatingStates.Remove(x));
if (CurrentMaintenance != null)
{
CurrentOperatingState = OperatingState.Maintenance;
}
else if (lastState != null && lastState.State == OperatingState.Reserve)
{
CurrentOperatingState = OperatingState.Reserve;
}
else
{
CurrentOperatingState = operatingStates.OrderBy(x => x.StartDate).LastOrDefault()?.State ?? OperatingState.Operating;
}
Report.State = CurrentOperatingState.Value;
SetNextMaintenance();
}
public override void Merge(MaintenanceObject entity, IRepository repository)
{
entity.TechIndex = TechIndex;
entity.Plant = repository.Get <Plant>(PlantId.Value);
entity.Site = Site;
entity.Group = repository.Get <ObjectGroup>(GroupId);
SetSpecifications(entity, repository);
//Если введена дата ввода в эксплуатацию, то вводим в эксплуатацию
if (entity.CurrentOperatingState == OperatingState.Mounted && StartOperating != null)
{
var period = Period == null ? new Period(DateTime.Now) : new Period(Period.Value);
entity.PutIntoOperating(StartOperating.Value, period);
}
//Если родитель был
if (entity.Parent != null)
{
//Если родитель получен
if (ParentId != null)
{
//Если полученный родитель не равен тому, который был
if (ParentId != entity.Parent.Id)
{
var newParent = repository.Get <MaintenanceObject>(ParentId.Value);
entity.ClearParent();
newParent.AddChild(entity);
repository.Save(newParent);
}
}
//Если родитель был, но его убрали
else
{
entity.ClearParent();
}
}
//Если родителя небыло
else
{
//Если родитель был установлен
if (ParentId != null)
{
var parent = repository.Get <MaintenanceObject>(ParentId.Value);
parent.AddChild(entity);
repository.Save(parent);
}
}
var dtoMap = LastMaintenance.ToDictionary(x => x.MaintenanceTypeId);
entity.LastMaintenance.ToList().ForEach(last =>
{
if (dtoMap.ContainsKey(last.MaintenanceType.Id))
{
var _dto = dtoMap[last.MaintenanceType.Id];
last.LastMaintenanceDate = _dto.LastMaintenanceDate;
last.UsageFromLastMaintenance = _dto.UsageFromLastMaintenance;
}
});
entity.SetNextMaintenance();
}