protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
_initialDocumentArray.Clear();
_resultDocumentArray.Clear();
AnimatedThreadWorker.ReportProgress(0, "load");
_initialDocumentArray.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListRevisionDTO, CheckListRevision>(new []
{
new Filter("OperatorId", _operatorId),
new Filter("ManualId", _manual.ItemId)
}));
foreach (var revision in _initialDocumentArray.Where(i => i.Type == RevisionType.Revision))
{
revision.CurrentStatus = _initialDocumentArray.FirstOrDefault(i => i.ItemId == revision.EditionId).Status;
}
foreach (var edition in _initialDocumentArray.Where(i => i.Type == RevisionType.Edition))
{
edition.CurrentStatus = edition.Status;
}
AnimatedThreadWorker.ReportProgress(70, "filter directives");
FilterItems(_initialDocumentArray, _resultDocumentArray);
AnimatedThreadWorker.ReportProgress(100, "Complete");
}
private void AnimatedThreadWorkerDoLoad(object sender, DoWorkEventArgs e)
{
_updateChecks.Clear();
_updateChecks.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <PelSpecialistDTO, PelSpecialist>(new Filter("AuditId", _auditId)));
foreach (var rec in _updateChecks)
{
rec.Specialist = _specialists.FirstOrDefault(i => i.ItemId == rec.SpecialistId);
}
var ids = _updateChecks.Select(i => i.SpecialistId);
if (ids.Any())
{
_addedChecks.AddRange(_specialists.Where(q => !ids.Contains(q.ItemId)).Select(i => new PelSpecialist
{
SpecialistId = i.ItemId,
Specialist = i,
AuditId = _auditId
}));
}
else
{
_addedChecks.AddRange(_specialists.Select(i => new PelSpecialist
{
SpecialistId = i.ItemId,
Specialist = i,
AuditId = _auditId
}));
}
}
private void AnimatedThreadWorkerDoLoad(object sender, DoWorkEventArgs e)
{
_workPackageSpecialists.Clear();
_initialDocumentArray.Clear();
_wpSpecialists.Clear();
_initialDocumentArray.AddRange(GlobalObjects.CasEnvironment.NewLoader.GetObjectListAll <SpecialistDTO, Specialist>(loadChild: true));
var aircraftModels = GlobalObjects.CasEnvironment.NewLoader.GetObjectList <AccessoryDescriptionDTO, AircraftModel>(new Filter("ModelingObjectTypeId", 7));
foreach (var specialist in _initialDocumentArray)
{
foreach (var license in specialist.Licenses)
{
if (license.AircraftTypeID > 0)
{
license.AircraftType = aircraftModels.FirstOrDefault(a => a.ItemId == license.AircraftTypeID);
}
}
}
_workPackageSpecialists.AddRange(GlobalObjects.CasEnvironment.NewLoader.GetObjectListAll <WorkPackageSpecialistsDTO, WorkPackageSpecialists>(new Filter("WorkPackageId", _currentWorkPackage.ItemId)));
var specialistIds = _workPackageSpecialists.Select(w => w.SpecialistId).ToArray();
if (specialistIds.Length > 0)
{
_wpSpecialists.AddRange(_initialDocumentArray.Where(s => specialistIds.Any(id => id == s.ItemId)));
}
FilterItems(_initialDocumentArray, _resultDocumentArray);
}
protected override void AnimatedThreadWorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
_directivesViewer.SetItemsArray(_resultTrackRecordArray.Where(i => i.FlightNumberPeriod != null).ToArray());
_directivesViewer.Focus();
headerControl.PrintButtonEnabled = _directivesViewer.ItemsCount != 0;
}
protected override void AnimatedThreadWorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Cancelled)
{
return;
}
if (firstLoad)
{
if (_initialPeriodArray.Count > 0)
{
dateTimePickerDateFrom.Value = _initialPeriodArray.Min(f => f.DepartureDate);
dateTimePickerDateTo.Value = _initialPeriodArray.Max(f => f.ArrivalDate);
}
else
{
dateTimePickerDateFrom.Value = DateTimeExtend.GetCASMinDateTime();
dateTimePickerDateTo.Value = DateTime.Today;
}
}
firstLoad = false;
filterPeriod = false;
foreach (var flightNumber in _resultFlightsArray.OrderBy(f => f.FlightNo.FullName))
{
var periods = _resultPeriodArray.Where(f => f.FlightNumberId == flightNumber.ItemId);
if (periods.Any())
{
_result.Add(flightNumber);
foreach (var period in periods)
{
_result.Add(period);
}
}
}
var res = new List <IFlightNumberParams>();
foreach (var item in _result)
{
if (item is FlightNumber)
{
res.Add(item as FlightNumber);
var component = (FlightNumber)item;
var items = _result
.Where(lvi =>
lvi is FlightNumberPeriod &&
((FlightNumberPeriod)lvi).FlightNumberId == component.ItemId).Select(i => i);
res.AddRange(items.OfType <FlightNumberPeriod>());
}
}
_directivesViewer.SetItemsArray(res.ToArray());
_directivesViewer.Focus();
headerControl.PrintButtonEnabled = _directivesViewer.ItemsCount != 0;
}
private void comboBox1_TextUpdate(object sender, EventArgs e)
{
var _filterString = comboBox1.Text;
comboBox1.Items.Clear();
foreach (var dic in _initialTrackArray.Where(i => i.ToString().ToLowerInvariant().Contains(_filterString.ToLowerInvariant())))
{
comboBox1.Items.Add(dic);
}
comboBox1.DropDownStyle = ComboBoxStyle.DropDown;
comboBox1.SelectionStart = _filterString.Length;
}
private void AnimatedThreadWorkerDoLoad(object sender, DoWorkEventArgs e)
{
_addedChecks.Clear();
_addedChecks.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectListAll <CheckListDTO, CheckLists>(new Filter("EditionId", _parent.EditionId), loadChild: true)
.ToList());
_levels.Clear();
_levels = GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <FindingLevelsDTO, FindingLevels>(new []
{
new Filter("OperatorId", _operatorId),
new Filter("ProgramTypeId", _manual.ProgramTypeId),
});
var revisions = new List <CheckListRevision>();
var revIds = _addedChecks.Where(i => i.RevisionId.HasValue).Select(i => i.RevisionId.Value).Distinct();
if (revIds.Any())
{
revisions.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListRevisionDTO, CheckListRevision>(new List <Filter>()
{
new Filter("ItemId", values: revIds),
}));
}
foreach (var check in _addedChecks)
{
check.EditionNumber = _parent.Number.ToString();
check.RevisionNumber = revisions.FirstOrDefault(i => i.ItemId == check.RevisionId)?.Number.ToString() ?? "";
if (check.CheckUIType == CheckUIType.Iosa)
{
check.Level = _levels.FirstOrDefault(i => i.ItemId == check.Settings.LevelId) ??
FindingLevels.Unknown;
}
else if (check.CheckUIType == CheckUIType.Safa)
{
check.Level = _levels.FirstOrDefault(i => i.ItemId == check.SettingsSafa.LevelId) ??
FindingLevels.Unknown;
}
else if (check.CheckUIType == CheckUIType.Icao)
{
check.Level = _levels.FirstOrDefault(i => i.ItemId == check.SettingsIcao.LevelId) ??
FindingLevels.Unknown;
}
check.Remains = Lifelength.Null;
check.Condition = ConditionState.Satisfactory;
}
}
private void ComboSpecializationSelectedIndexChanged(object sender, EventArgs e)
{
Occupation occupation = comboSpecialization.SelectedItem as Occupation;
comboSpecialist.Items.Clear();
if (occupation != null)
{
comboSpecialist.Items.AddRange(_specialists.Where(s => s.Occupation == occupation).ToArray());
comboSpecialist.SelectedItem = _specialists.GetItemById(occupation.ItemId);
}
else
{
comboSpecialist.SelectedItem = null;
}
}
private void BackgroundWorkerRunWorkerLoadCompleted(object sender, RunWorkerCompletedEventArgs e)
{
comboBoxCustomer.Items.Clear();
comboBoxCustomer.Items.AddRange(_supplierArray.ToArray());
comboBoxCustomer.Items.Add(Supplier.Unknown);
comboBoxCustomer.SelectedItem = _flightTrack.Supplier;
foreach (var flightNumber in _resultFlightsArray.OrderBy(f => f.FlightNo.FullName))
{
var periods = _resultPeriodArray.Where(f => f.FlightNumberId == flightNumber.ItemId);
if (periods.Any())
{
_resultArray.Add(flightNumber);
foreach (var period in periods)
{
_resultArray.Add(period);
}
}
}
flightNumberListViewAll.SetItemsArray(_resultArray.ToArray());
flightNumberListView2.SetItemsArray(_addedItems.ToArray());
}
private void AnimatedThreadWorkerDoLoad(object sender, DoWorkEventArgs e)
{
if (_maintenanceCheck == null || _currentAircraft == null)
{
e.Cancel = true;
return;
}
if (_records == null)
{
_records = new CommonCollection <MaintenanceCheckBindTaskRecord>();
}
_records.Clear();
if (_recordsTasks == null)
{
_recordsTasks = new CommonCollection <BaseEntityObject>();
}
_recordsTasks.Clear();
if (_mpdForSelect == null)
{
_mpdForSelect = new CommonCollection <MaintenanceDirective>();
}
_mpdForSelect.Clear();
_animatedThreadWorker.ReportProgress(0, "load binded tasks");
var preResult = new List <MaintenanceCheckBindTaskRecord>();
try
{
preResult.AddRange(GlobalObjects.WorkPackageCore.GetMaintenanceBingTasksRecords(_workPackage.ItemId));
_records.AddRange(preResult.Where(r => r.CheckId == _maintenanceCheck.ItemId));
_recordsTasks.AddRange(_records.Where(r => r.Task != null && r.Task is BaseEntityObject).Select(r => r.Task as BaseEntityObject));
if (_maintenanceCheck.Grouping)
{
MaintenanceNextPerformance mnp = _maintenanceCheck.GetNextPergormanceGroupWhereCheckIsSenior();
if (mnp != null && mnp.PerformanceGroup != null && mnp.PerformanceGroup.Checks.Count > 0)
{
_recordsTasks.AddRange(mnp.PerformanceGroup.Checks.SelectMany(mc => mc.BindMpds).ToArray());
}
else
{
_recordsTasks.AddRange(_maintenanceCheck.BindMpds.ToArray());
}
}
else
{
_recordsTasks.AddRange(_maintenanceCheck.BindMpds.ToArray());
}
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while load Maintenance check bing tasks records", ex);
}
if (_animatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_animatedThreadWorker.ReportProgress(50, "calculation of Maintenance Directives");
try
{
_mpdForSelect.AddRange(_workPackage.MaintenanceDirectives);
_mpdForSelect.AddRange(_workPackage.ComponentDirectives.Where(dd => dd.MaintenanceDirective != null)
.Select(dd => dd.MaintenanceDirective).Distinct());
foreach (MaintenanceCheckBindTaskRecord record in preResult.Where(record => record.TaskType == SmartCoreType.MaintenanceDirective &&
_mpdForSelect.FirstOrDefault(m => m.ItemId == record.TaskId) != null))
{
_mpdForSelect.RemoveById(record.TaskId);
}
foreach (MaintenanceDirective mpd in _allWpChecks.SelectMany(mc => mc.BindMpds))
{
_mpdForSelect.RemoveById(mpd.ItemId);
}
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while load directives for select", ex);
}
if (_animatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_animatedThreadWorker.ReportProgress(75, "calculate directives for select");
//try
//{
// _mpdForSelect.AddRange(GlobalObjects.CasEnvironment.Loader.GetMaintenanceDirectives(_maintenanceCheck.ParentAircraft));
//}
//catch (Exception ex)
//{
// Program.Provider.Logger.Log("Error while calculate directives for select", ex);
//}
if (_animatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_animatedThreadWorker.ReportProgress(100, "binding complete");
}
protected override void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
{
backgroundWorker.ReportProgress(50);
try
{
Invoke(new Action(() => listViewCompliance.Items.Clear()));
}
catch (Exception)
{
}
if (_currentComponent == null)
{
e.Cancel = true;
return;
}
var parentAircraft = GlobalObjects.AircraftsCore.GetParentAircraft(_currentComponent);
var lastRecords = new List <AbstractRecord>();
var nextPerformances = new List <NextPerformance>();
var allWorkPackagesIncludedTask = new CommonCollection <WorkPackage>();
var openPubWorkPackagesIncludedTask = new CommonCollection <WorkPackage>();
var closedWorkPackages = new CommonCollection <WorkPackage>();
var taskThatIncludeInWorkPackage = new List <IDirective>();
lastRecords.AddRange(_currentComponent.TransferRecords.ToArray());
lastRecords.AddRange(_currentComponent.ChangeLLPCategoryRecords.ToArray());
lastRecords.AddRange(_currentComponent.ActualStateRecords.ToArray());
//Объекты для в котороые будет извлекаться информация
//из записеи о перемещении
var lastDestination = "";
//прогнозируемый ресурс
//если известна родительская деталь данной директивы,
//то ее текущая наработка и средняя утилизация
//используются в качестве ресурсов прогноза
//для расчета всех просроченных выполнений
var forecastData = new ForecastData(DateTime.Now,
GlobalObjects.AverageUtilizationCore.GetAverageUtillization(_currentComponent),
GlobalObjects.CasEnvironment.Calculator.GetCurrentFlightLifelength(_currentComponent));
foreach (var directive in _currentComponent.ComponentDirectives)
{
if (directive.IsAffect().GetValueOrDefault(true))
{
//расчет след. выполнений директивы.
//если известен ресурс прогноза, то будут расчитаны все просрочнные выполнения
//если неизвестне, то только первое
//GlobalObjects.PerformanceCalculator.GetNextPerformance(directive, forecastData);
nextPerformances.AddRange(directive.NextPerformances);
lastRecords.AddRange(directive.PerformanceRecords.ToArray());
if (backgroundWorker.CancellationPending)
{
e.Cancel = true;
return;
}
taskThatIncludeInWorkPackage.Add(directive);
}
else
{
var bindedItems = GlobalObjects.BindedItemsCore.GetBindedItemsFor(parentAircraft.ItemId, directive);
foreach (var bindedItem in bindedItems)
{
if (bindedItem is MaintenanceDirective)
{
var mpd = (MaintenanceDirective)bindedItem;
//прогнозируемый ресурс
//если известна родительская деталь данной директивы,
//то ее текущая наработка и средняя утилизация
//используются в качестве ресурсов прогноза
//для расчета всех просроченных выполнений
//расчет след. выполнений директивы.
//если известен ресурс прогноза, то будут расчитаны все просрочнные выполнения
//если неизвестне, то только первое
GlobalObjects.PerformanceCalculator.GetNextPerformance(mpd, forecastData);
nextPerformances.AddRange(mpd.NextPerformances);
lastRecords.AddRange(mpd.PerformanceRecords.ToArray());
taskThatIncludeInWorkPackage.Add(mpd);
}
}
}
}
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
if (_openPubWorkPackages == null)
{
_openPubWorkPackages = new CommonCollection <WorkPackage>();
}
_openPubWorkPackages.Clear();
//загрузка рабочих пакетов для определения
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft, WorkPackageStatus.Opened));
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft, WorkPackageStatus.Published));
allWorkPackagesIncludedTask.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft, WorkPackageStatus.All, taskThatIncludeInWorkPackage));
#region Добавление в список просроченных выполнений
//и сравнение их с открытыми и опубликованными рабочими пакетами
openPubWorkPackagesIncludedTask.AddRange(
allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Opened ||
wp.Status == WorkPackageStatus.Published));
//сбор всех записей рабочих пакетов для удобства фильтрации
var openPubWpRecords =
openPubWorkPackagesIncludedTask.SelectMany(wp => wp.WorkPakageRecords).ToList();
//LINQ запрос для сортировки записей по дате
var sortNextRecords = (from record in nextPerformances
orderby GetDate(record) descending
select record).ToList();
for (int i = 0; i < sortNextRecords.Count; i++)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackagesIncludedTask.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
//поиск записи в рабочих пакетах по данному чеку
//чей номер группы выполнения (по записи) совпадает с расчитанным
var parentDirective = sortNextRecords[i].Parent;
//номер выполнения
int parentCountPerf;
if (parentDirective.LastPerformance != null)
{
parentCountPerf = parentDirective.LastPerformance.PerformanceNum <= 0
? 1
: parentDirective.LastPerformance.PerformanceNum;
}
else
{
parentCountPerf = 0;
}
parentCountPerf += parentDirective.NextPerformances.IndexOf(sortNextRecords[i]);
parentCountPerf += 1;
var wpr = openPubWpRecords.FirstOrDefault(r => r.PerformanceNumFromStart == parentCountPerf &&
r.WorkPackageItemType == parentDirective.SmartCoreObjectType.ItemId &&
r.DirectiveId == parentDirective.ItemId);
if (wpr != null)
{
var wp = openPubWorkPackagesIncludedTask.GetItemById(wpr.WorkPakageId);
//запись о выполнении блокируется найденым пакетом
sortNextRecords[i].BlockedByPackage = wp;
//последующие записи о выполнении так же должны быть заблокированы
for (int j = i - 1; j >= 0; j--)
{
//блокировать нужно все рабочие записи, или до первой записи,
//заблокированной другим рабочим пакетом
if (sortNextRecords[j].BlockedByPackage != null ||
sortNextRecords[j].Condition != ConditionState.Overdue)
{
break;
}
if (sortNextRecords[j].Parent == parentDirective)
{
sortNextRecords[j].BlockedByPackage = wp;
Invoke(new Action <int, Color>(SetItemColor), j, Color.FromArgb(Highlight.GrayLight.Color));
}
}
}
Invoke(new Action <NextPerformance>(AddListViewItem), sortNextRecords[i]);
}
#endregion
#region Добавление в список записей о произведенных выполнениях
//и сравнение их с закрытыми рабочими пакетами
closedWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Closed));
//LINQ запрос для сортировки записей по дате
var sortLastRecords = (from record in lastRecords
orderby record.RecordDate ascending
select record).ToList();
var items = new List <KeyValuePair <AbstractRecord, string[]> >();
for (int i = 0; i < sortLastRecords.Count; i++)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackagesIncludedTask.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
string[] subs;
if (sortLastRecords[i] is DirectiveRecord)
{
var directiveRecord = (DirectiveRecord)sortLastRecords[i];
subs = new[]
{
directiveRecord.WorkType,
UsefulMethods.NormalizeDate(directiveRecord.RecordDate),
directiveRecord.OnLifelength != null
? directiveRecord.OnLifelength.ToString()
: "",
"",
"",
directiveRecord.Remarks
};
}
else if (sortLastRecords[i] is TransferRecord)
{
TransferRecord transferRecord = (TransferRecord)sortLastRecords[i];
string currentDestination, destinationObject;
DestinationHelper.GetDestination(transferRecord, out currentDestination, out destinationObject);
subs = new[]
{
lastDestination != ""
? "Transfered " + destinationObject + " from " + lastDestination + " to " + currentDestination
: "Transfered " + destinationObject + " to " + currentDestination,
UsefulMethods.NormalizeDate(transferRecord.TransferDate),
transferRecord.OnLifelength.ToString(),
"",
"",
transferRecord.Remarks,
};
lastDestination = currentDestination;
}
else if (sortLastRecords[i] is ComponentLLPCategoryChangeRecord)
{
ComponentLLPCategoryChangeRecord llpRecord = (ComponentLLPCategoryChangeRecord)sortLastRecords[i];
LLPLifeLimitCategory toCategory = llpRecord.ToCategory;
subs = new[]
{
"Changed to " + toCategory,
UsefulMethods.NormalizeDate(llpRecord.RecordDate),
llpRecord.OnLifelength.ToString(),
"",
"",
llpRecord.Remarks,
};
}
else if (sortLastRecords[i] is ActualStateRecord)
{
ActualStateRecord actualStateRecord = (ActualStateRecord)sortLastRecords[i];
subs = new[]
{
"Actual state:",
UsefulMethods.NormalizeDate(actualStateRecord.RecordDate.Date),
actualStateRecord.OnLifelength != null
? actualStateRecord.OnLifelength.ToString()
: "",
"",
"",
actualStateRecord.Remarks,
};
}
else
{
subs = new[]
{
"Unknown record ",
UsefulMethods.NormalizeDate(sortLastRecords[i].RecordDate),
sortLastRecords[i].OnLifelength.ToString(),
"",
"",
sortLastRecords[i].Remarks,
};
}
items.Add(new KeyValuePair <AbstractRecord, string[]>(sortLastRecords[i], subs));
}
#endregion
for (int i = items.Count - 1; i >= 0; i--)
{
WorkPackage workPackage = null;
if (items[i].Key is AbstractPerformanceRecord)
{
var apr = items[i].Key as AbstractPerformanceRecord;
workPackage = closedWorkPackages.FirstOrDefault(wp => wp.ItemId == apr.DirectivePackageId);
}
Invoke(new Action <AbstractRecord, string[], WorkPackage>(AddListViewItem), items[i].Key, items[i].Value, workPackage);
}
allWorkPackagesIncludedTask.Clear();
openPubWorkPackagesIncludedTask.Clear();
closedWorkPackages.Clear();
backgroundWorker.ReportProgress(100);
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
_initialDocumentArray.Clear();
_resultDocumentArray.Clear();
AnimatedThreadWorker.ReportProgress(0, "load directives");
if (_type == CheckListType.Routine)
{
_currentRoutineId = _parentId;
var records = GlobalObjects.CaaEnvironment.NewLoader
.GetObjectListAll <RoutineAuditRecordDTO, RoutineAuditRecord>(new Filter("RoutineAuditId", _parentId), loadChild: true).ToList();
var routine = GlobalObjects.CaaEnvironment.NewLoader
.GetObjectById <RoutineAuditDTO, SmartCore.CAA.RoutineAudits.RoutineAudit>(_parentId);
var manuals = GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <StandartManualDTO, SmartCore.CAA.StandartManual.StandartManual>(new []
{
new Filter("OperatorId", new [] { _operatorId, -1 }.Distinct()),
new Filter("ProgramTypeId", routine.Settings.TypeId),
});
_manual = manuals.FirstOrDefault();
var ids = records.Select(i => i.CheckListId);
if (ids.Any())
{
_initialDocumentArray.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectListAll <CheckListDTO, CheckLists>(new Filter("ItemId", ids), loadChild: true));
}
var revisions = new List <CheckListRevision>();
var revedIds = _initialDocumentArray.Where(i => i.RevisionId.HasValue).Select(i => i.RevisionId.Value).Distinct().ToList();
revedIds.AddRange(_initialDocumentArray.Select(i => i.EditionId).Distinct());
if (revedIds.Any())
{
revisions.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListRevisionDTO, CheckListRevision>(new List <Filter>()
{
new Filter("ItemId", values: revedIds),
}));
}
foreach (var check in _initialDocumentArray)
{
check.RevisionNumber = revisions.FirstOrDefault(i => i.ItemId == check.RevisionId)?.Number.ToString() ?? "";
check.EditionNumber = revisions.FirstOrDefault(i => i.ItemId == check.RevisionId)?.Number.ToString() ?? "";
}
}
else
{
var editions = GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListRevisionDTO, CheckListRevision>(new List <Filter>()
{
new Filter("Status", (byte)EditionRevisionStatus.Current),
new Filter("Type", (byte)RevisionType.Edition),
new Filter("ManualId", _manual.ItemId),
});
if (editions.Any())
{
var edition = editions.FirstOrDefault();
_initialDocumentArray.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectListAll <CheckListDTO, CheckLists>(new Filter("EditionId", edition.ItemId), loadChild: true));
var revisions = new List <CheckListRevision>();
var revIds = _initialDocumentArray.Where(i => i.RevisionId.HasValue).Select(i => i.RevisionId.Value).Distinct();
if (revIds.Any())
{
revisions.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListRevisionDTO, CheckListRevision>(new List <Filter>()
{
new Filter("ItemId", values: revIds),
}));
}
foreach (var check in _initialDocumentArray)
{
check.RevisionNumber = revisions.FirstOrDefault(i => i.ItemId == check.RevisionId)?.Number.ToString() ?? "";
check.EditionNumber = edition.Number.ToString();
}
}
}
var levels = GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <FindingLevelsDTO, FindingLevels>(new []
{
new Filter("OperatorId", _operatorId),
new Filter("ProgramTypeId", _manual.ProgramTypeId),
});
foreach (var check in _initialDocumentArray)
{
if (check.CheckUIType == CheckUIType.Iosa)
{
check.Level = levels.FirstOrDefault(i => i.ItemId == check.Settings.LevelId) ??
FindingLevels.Unknown;
}
else if (check.CheckUIType == CheckUIType.Safa)
{
check.Level = levels.FirstOrDefault(i => i.ItemId == check.SettingsSafa.LevelId) ??
FindingLevels.Unknown;
}
else if (check.CheckUIType == CheckUIType.Icao)
{
check.Level = levels.FirstOrDefault(i => i.ItemId == check.SettingsIcao.LevelId) ??
FindingLevels.Unknown;
}
check.Remains = Lifelength.Null;
check.Condition = ConditionState.Satisfactory;
}
AnimatedThreadWorker.ReportProgress(40, "filter directives");
AnimatedThreadWorker.ReportProgress(70, "filter directives");
FilterItems(_initialDocumentArray, _resultDocumentArray);
AnimatedThreadWorker.ReportProgress(100, "Complete");
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
_maintenanceChecks.Clear();
_maintenanceZeroChecks.Clear();
_groupLifelengths.Clear();
_groupLifelengthsForZeroCheck.Clear();
_initialMaintenanceDirectives.Clear();
_initialZeroMaintenanceDirectives.Clear();
AnimatedThreadWorker.ReportProgress(0, "load records");
#region Загрузка
try
{
var checks =
GlobalObjects.CasEnvironment.NewLoader.GetObjectListAll <MTOPCheckDTO, MTOPCheck>(
new Filter("ParentAircraftId", CurrentAircraft.ItemId), true, true);
_maintenanceChecks.AddRange(checks.Where(i => !i.IsDeleted));
_maintenanceChecksDeleted.AddRange(checks.Where(i => i.IsDeleted));
var baseComponents = GlobalObjects.ComponentCore.GetAicraftBaseComponents(CurrentAircraft.ItemId);
var components = GlobalObjects.ComponentCore.GetComponents(baseComponents.ToList());
var componentDirectives = components.SelectMany(i => i.ComponentDirectives);
var mpds = GlobalObjects.MaintenanceCore.GetMaintenanceDirectives(CurrentAircraft);
foreach (var componentDirective in componentDirectives)
{
foreach (var items in componentDirective.ItemRelations.Where(i =>
i.FirtsItemTypeId == SmartCoreType.MaintenanceDirective.ItemId ||
i.SecondItemTypeId == SmartCoreType.MaintenanceDirective.ItemId))
{
var id = componentDirective.IsFirst == true ? items.SecondItemId : items.FirstItemId;
componentDirective.MaintenanceDirective = mpds.FirstOrDefault(i => i.ItemId == id);
}
}
_initialMaintenanceDirectives.AddRange(mpds);
_initialMaintenanceDirectives.AddRange(GlobalObjects.DirectiveCore.GetDirectives(CurrentAircraft, DirectiveType.All).ToList());
_initialMaintenanceDirectives.AddRange(componentDirectives);
var bindedItemsDict = GlobalObjects.BindedItemsCore.GetBindedItemsFor(CurrentAircraft.ItemId,
_initialMaintenanceDirectives.Where(m => m is MaintenanceDirective)
.Cast <MaintenanceDirective>().Where(m =>
m.WorkItemsRelationType == WorkItemsRelationType.CalculationDepend));
CalculateMaintenanceDirectives(_initialMaintenanceDirectives, bindedItemsDict);
}
catch (Exception exception)
{
Program.Provider.Logger.Log("Error while load records", exception);
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
AnimatedThreadWorker.ReportProgress(50, "Calculate MTOP");
#region асчет
foreach (var check in _maintenanceChecks)
{
foreach (var record in check.PerformanceRecords)
{
record.Parent = check;
}
}
foreach (var check in _maintenanceChecksDeleted)
{
foreach (var record in check.PerformanceRecords)
{
record.Parent = check;
}
}
if (_maintenanceChecks.Count > 0)
{
//Берем утилизацию с Frame
var frame = GlobalObjects.CasEnvironment.BaseComponents.FirstOrDefault(i =>
i.ParentAircraftId == CurrentAircraft.ItemId &&
Equals(i.BaseComponentType, BaseComponentType.Frame));
_averageUtilization = frame.AverageUtilization;
var lastCompliance = _maintenanceChecks.Where(i => !i.IsZeroPhase).SelectMany(i => i.PerformanceRecords)
.OrderByDescending(i => i.RecordDate).FirstOrDefault();
GlobalObjects.MTOPCalculator.CalculateMtopChecks(_maintenanceChecks, _averageUtilization);
_groupLifelengths = GlobalObjects.MTOPCalculator.CalculateGroupNew(_maintenanceChecks
.Where(i => !i.Thresh.IsNullOrZero() && !i.IsZeroPhase).ToList());
GlobalObjects.MTOPCalculator.CalculateNextPerformance(
_maintenanceChecks.Where(i => !i.IsZeroPhase).ToList(), frame.StartDate, _groupLifelengths,
CurrentAircraft, _averageUtilization, lastCompliance);
GlobalObjects.MTOPCalculator.CalculateNextPerformance(
_maintenanceChecks.Where(i => !i.IsZeroPhase).ToList(), frame.StartDate, _groupLifelengths,
CurrentAircraft, _averageUtilization, lastCompliance, true);
GlobalObjects.MTOPCalculator.CalculatePhase(_initialMaintenanceDirectives,
_maintenanceChecks.Where(i => !i.Thresh.IsNullOrZero() && !i.IsZeroPhase).ToList(),
_averageUtilization);
_maintenanceZeroChecks = _maintenanceChecks.Where(i => i.IsZeroPhase).ToList();
var lowerZeroCheck = _maintenanceZeroChecks.Where(i => !i.Thresh.IsNullOrZero()).OrderBy(i => i.Thresh)
.FirstOrDefault();
if (lowerZeroCheck != null)
{
lastCompliance = _maintenanceChecks.Where(i => i.IsZeroPhase).SelectMany(i => i.PerformanceRecords)
.OrderByDescending(i => i.RecordDate).FirstOrDefault();
GlobalObjects.MTOPCalculator.CalculateMtopChecks(_maintenanceZeroChecks, _averageUtilization);
_groupLifelengthsForZeroCheck =
GlobalObjects.MTOPCalculator.CalculateGroupNew(_maintenanceZeroChecks);
GlobalObjects.MTOPCalculator.CalculateNextPerformance(_maintenanceZeroChecks, frame.StartDate,
_groupLifelengthsForZeroCheck, CurrentAircraft, _averageUtilization, lastCompliance);
GlobalObjects.MTOPCalculator.CalculateNextPerformance(_maintenanceZeroChecks, frame.StartDate,
_groupLifelengthsForZeroCheck, CurrentAircraft, _averageUtilization, lastCompliance, true);
_initialZeroMaintenanceDirectives.AddRange(_initialMaintenanceDirectives
.Where(i => i.MTOPPhase?.FirstPhase == 0).ToArray());
GlobalObjects.MTOPCalculator.CalculatePhase(_initialZeroMaintenanceDirectives,
_maintenanceChecks.Where(i => !i.Thresh.IsNullOrZero() && i.IsZeroPhase).ToList(),
_averageUtilization, true);
}
foreach (var d in _initialZeroMaintenanceDirectives)
{
_initialMaintenanceDirectives.Remove(d);
}
//var q = _maintenanceChecks.Where(i => !i.IsZeroPhase).SelectMany(i => i.NextPerformances);
//var last = _maintenanceChecks.Where(i => !i.IsZeroPhase).SelectMany(i => i.PerformanceRecords).OrderByDescending(i => i.RecordDate).FirstOrDefault();
//var group = last.GroupName;
//var value = Lifelength.Null;
//foreach (var performance in q.OrderBy(i => i.PerformanceSource.Days))
//{
// if (value.Days == performance.PerformanceSource.Days)
// {
// performance.Group = group --;
// }
// else
// {
// performance.Group = group++;
// }
// value = performance.PerformanceSource;
//}
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
#region Фильтрация директив
AnimatedThreadWorker.ReportProgress(70, "filter records");
FilterItems(_initialMaintenanceDirectives, _resultMaintenanceDirectives);
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
AnimatedThreadWorker.ReportProgress(90, "filter records");
FilterZeroItems(_initialZeroMaintenanceDirectives, _resultZeroMaintenanceDirectives);
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
AnimatedThreadWorker.ReportProgress(100, "Complete");
}
private void UpdateInformation()
{
if (_contextMenuStrip == null)
{
InitToolStripMenuItems();
}
listViewCompliance.Items.Clear();
if (CheckItems == null)
{
return;
}
var lastRecords = new List <MaintenanceCheckRecord>();
var nextPerformances = new List <NextPerformance>();
//Поиск и заполнение просроченных директив и записей о перемещении
//Объекты для в которые будет извлекаться информация
//из записеи о перемещении
string[] subs;
ListViewItem newItem;
var aircraftFrame = GlobalObjects.ComponentCore.GetBaseComponentById(_currentAircraft.AircraftFrameId);
//прогнозируемый ресурс
var forecastData = new ForecastData(DateTime.Now, aircraftFrame.AverageUtilization,
GlobalObjects.CasEnvironment.Calculator.GetCurrentFlightLifelength(_currentAircraft));
//GlobalObjects.CasEnvironment.Calculator.GetNextPerformanceGroup(CheckItems, _currentAircraft.Schedule, forecastData);
foreach (MaintenanceCheck check in CheckItems)
{
if (check.Grouping)
{
foreach (MaintenanceNextPerformance mnp in check.GetPergormanceGroupWhereCheckIsSenior())
{
//Добавляются все выполнения, дата которых меньше нынешней
//плюс еще одно выполнение дата которого выше нынешней
nextPerformances.Add(mnp);
if (mnp.PerformanceDate != null && mnp.PerformanceDate > DateTime.Now)
{
break;
}
}
}
else
{
foreach (NextPerformance mnp in check.NextPerformances)
{
//Добавляются все выполнения, дата которых меньше нынешней
//плюс еще одно выполнение дата которого выше нынешней
nextPerformances.Add(mnp);
if (mnp.PerformanceDate != null && mnp.PerformanceDate > DateTime.Now)
{
break;
}
}
}
lastRecords.AddRange(check.PerformanceRecords.ToArray());
foreach (MaintenanceDirective mpd in check.BindMpds)
{
GlobalObjects.PerformanceCalculator.GetNextPerformance(mpd, forecastData);
}
}
////////////////////////////////////////////
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
if (_openPubWorkPackages == null)
{
_openPubWorkPackages = new CommonCollection <WorkPackage>();
}
_openPubWorkPackages.Clear();
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(_currentAircraft, WorkPackageStatus.Opened));
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(_currentAircraft, WorkPackageStatus.Published));
var allWorkPackagesIncludedTask = new CommonCollection <WorkPackage>();
var openPubWorkPackages = new CommonCollection <WorkPackage>();
var closedWorkPackages = new CommonCollection <WorkPackage>();
allWorkPackagesIncludedTask.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(_currentAircraft,
WorkPackageStatus.All,
CheckItems.Select(m => (IDirective)m).ToList()));
#region Добавление в список просроченных выполнений
//и сравнение их с открытыми и опубликованными рабочими пакетами
openPubWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Opened ||
wp.Status == WorkPackageStatus.Published));
//сбор всех записей рабочих пакетов для удобства фильтрации
List <WorkPackageRecord> openPubWPRecords = new List <WorkPackageRecord>();
foreach (WorkPackage openWorkPackage in openPubWorkPackages)
{
openPubWPRecords.AddRange(openWorkPackage.WorkPakageRecords);
}
//LINQ запрос для сортировки записей по дате
List <NextPerformance> sortNextRecords = (from record in nextPerformances
orderby record.GetPerformanceDateOrDefault() descending
select record).ToList();
for (int i = 0; i < sortNextRecords.Count; i++)
{
//поиск записи в рабочих пакетах по данному чеку
//чей номер группы выполнения (по записи) совпадает с расчитанным
MaintenanceCheck check = (MaintenanceCheck)sortNextRecords[i].Parent;
//if (check.Name == "5C")
//{
//}
//номер выполнения
int parentCountPerf;
if (check.LastPerformance != null)
{
parentCountPerf = check.LastPerformance.NumGroup <= 0
? 1
: check.LastPerformance.NumGroup;
}
else
{
parentCountPerf = 0;
}
if (check.Grouping)
{
MaintenanceNextPerformance mnp = sortNextRecords[i] as MaintenanceNextPerformance;
if (mnp != null)
{
parentCountPerf = mnp.PerformanceGroupNum;
}
else
{
parentCountPerf += check.NextPerformances.IndexOf(sortNextRecords[i]);
parentCountPerf += 1;
}
}
else
{
parentCountPerf += check.NextPerformances.IndexOf(sortNextRecords[i]);
parentCountPerf += 1;
}
WorkPackageRecord wpr =
openPubWPRecords.Where(r => r.PerformanceNumFromStart == parentCountPerf &&
r.WorkPackageItemType == check.SmartCoreObjectType.ItemId &&
r.DirectiveId == check.ItemId).FirstOrDefault();
if (wpr != null)
{
WorkPackage wp = openPubWorkPackages.GetItemById(wpr.WorkPakageId);
//запись о выполнении блокируется найденым пакетом
sortNextRecords[i].BlockedByPackage = wp;
//последующие записи о выполнении так же должны быть заблокированы
for (int j = i - 1; j >= 0; j--)
{
//блокировать нужно все рабочие записи, или до первой записи,
//заблокированной другим рабочим пакетом
if (sortNextRecords[j].BlockedByPackage != null &&
sortNextRecords[j].Parent == check ||
sortNextRecords[j].Condition != ConditionState.Overdue)
{
break;
}
if (sortNextRecords[j].Parent == check)
{
sortNextRecords[j].BlockedByPackage = wp;
listViewCompliance.Items[j].BackColor = Color.FromArgb(Highlight.GrayLight.Color);
}
}
}
string type = check.Schedule ? " (Schedule) " : " (Store) ";
string resource = check.Resource.ToString();
string grouping = check.Grouping ? " (Group)" : "";
string stringNumGr = (sortNextRecords[i] is MaintenanceNextPerformance
? ((MaintenanceNextPerformance)sortNextRecords[i]).PerformanceGroupNum.ToString()
: "N/A") + type + resource + grouping;
subs = new[] {
stringNumGr,
sortNextRecords[i].Title,
sortNextRecords[i].PerformanceDate != null
? UsefulMethods.NormalizeDate((DateTime)sortNextRecords[i].PerformanceDate)
: "N/A",
sortNextRecords[i].PerformanceSource.ToString(),
"",
};
newItem = new ListViewItem(subs)
{
Group = listViewCompliance.Groups["next"],
Tag = sortNextRecords[i],
BackColor = UsefulMethods.GetColor(sortNextRecords[i])
};
listViewCompliance.Items.Add(newItem);
}
#endregion
#region Добавление в список записей о произведенных выполнениях
//и сравнение их с закрытыми рабочими пакетами
closedWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Closed));
//сбор всех записей рабочих пакетов для удобства фильтрации
List <WorkPackageRecord> closedWPRecords = new List <WorkPackageRecord>();
foreach (WorkPackage closedWorkPackage in closedWorkPackages)
{
closedWPRecords.AddRange(closedWorkPackage.WorkPakageRecords);
}
List <MaintenanceCheckRecordGroup> maintenanceCheckRecordGroups = new List <MaintenanceCheckRecordGroup>();
foreach (MaintenanceCheckRecord record in lastRecords)
{
//Поиск коллекции групп, в которую входят группы с нужными критериями
//по плану, группировка и основному ресурсу
if (record.ParentCheck.Grouping)
{
MaintenanceCheckRecordGroup recordGroup = maintenanceCheckRecordGroups
.FirstOrDefault(g => g.Schedule == record.ParentCheck.Schedule &&
g.Grouping == record.ParentCheck.Grouping &&
g.Resource == record.ParentCheck.Resource &&
g.GroupComplianceNum == record.NumGroup);
if (recordGroup != null)
{
//Коллекция найдена
//Поиск в ней группы чеков с нужным типом
recordGroup.Records.Add(record);
}
else
{
//Коллекции с нужными критериями нет
//Созадние и добавление
recordGroup =
new MaintenanceCheckRecordGroup(record.ParentCheck.Schedule, record.ParentCheck.Grouping,
record.ParentCheck.Resource, record.NumGroup);
recordGroup.Records.Add(record);
maintenanceCheckRecordGroups.Add(recordGroup);
}
}
else
{
MaintenanceCheckRecordGroup recordGroup =
new MaintenanceCheckRecordGroup(record.ParentCheck.Schedule, record.ParentCheck.Grouping,
record.ParentCheck.Resource);
recordGroup.Records.Add(record);
maintenanceCheckRecordGroups.Add(recordGroup);
}
}
List <object> tempRecords = new List <object>();
tempRecords.AddRange(maintenanceCheckRecordGroups.ToArray());
tempRecords.AddRange(_currentAircraft.MaintenanceProgramChangeRecords.ToArray());
List <object> sortLastRecords =
tempRecords.OrderByDescending(tr => (tr is MaintenanceCheckRecordGroup
? ((MaintenanceCheckRecordGroup)tr).LastGroupComplianceDate
: tr is AbstractRecord
? ((AbstractRecord)tr).RecordDate
: DateTimeExtend.GetCASMinDateTime()))
.ToList();
foreach (object t in sortLastRecords)
{
if (t is MaintenanceCheckRecordGroup)
{
MaintenanceCheckRecordGroup mcrg = (MaintenanceCheckRecordGroup)t;
MaintenanceCheckRecord directiveRecord = mcrg.Records.First();
MaintenanceCheck parentDirective = (MaintenanceCheck)directiveRecord.Parent;
newItem = GetListViewItem(mcrg);
WorkPackage workPackage =
closedWorkPackages.Where(wp => wp.ItemId == directiveRecord.DirectivePackageId).FirstOrDefault();
if (workPackage != null)
{
//запись о выполнении блокируется найденым пакетом
directiveRecord.DirectivePackage = workPackage;
newItem.BackColor = Color.FromArgb(Highlight.Grey.Color);
newItem.ToolTipText =
"Perform of the task:" + parentDirective.Name +
"\nadded by Work Package:" +
"\n" + directiveRecord.DirectivePackage.Title +
"\nTo remove a performance of task, you need to exclude task from this work package," +
"\nor delete the work package ";
}
listViewCompliance.Items.Add(newItem);
}
else if (t is MaintenanceProgramChangeRecord)
{
MaintenanceProgramChangeRecord mpcr = (MaintenanceProgramChangeRecord)t;
subs = new[]
{
"N/A",
"Changet to " + mpcr.MSG,
UsefulMethods.NormalizeDate(mpcr.RecordDate),
mpcr.OnLifelength.ToString(),
"",
};
newItem = new ListViewItem(subs)
{
Group = listViewCompliance.Groups["last"],
Tag = mpcr,
BackColor = Color.FromArgb(Highlight.GrayLight.Color)
};
listViewCompliance.Items.Add(newItem);
}
}
#endregion
if (_toolStripMenuItemsWorkPackages != null)
{
foreach (ToolStripMenuItem item in _toolStripMenuItemsWorkPackages.DropDownItems)
{
item.Click -= AddToWorkPackageItemClick;
}
_toolStripMenuItemsWorkPackages.DropDownItems.Clear();
foreach (WorkPackage workPackage in _openPubWorkPackages)
{
ToolStripMenuItem item = new ToolStripMenuItem(workPackage.Title);
item.Click += AddToWorkPackageItemClick;
item.Tag = workPackage;
_toolStripMenuItemsWorkPackages.DropDownItems.Add(item);
}
}
ButtonAdd.Enabled = false;
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
_initialDocumentArray.Clear();
_resultDocumentArray.Clear();
AnimatedThreadWorker.ReportProgress(0, "load");
if (_parent.Type == RevisionType.Edition)
{
_initialDocumentArray.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListDTO, CheckLists>(new []
{
new Filter("EditionId", _parent.ItemId),
new Filter("ManualId", _manual.ItemId),
}));
var revisions = new List <CheckListRevision>();
var revIds = _initialDocumentArray.Where(i => i.RevisionId.HasValue).Select(i => i.RevisionId.Value).Distinct();
if (revIds.Any())
{
revisions.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListRevisionDTO, CheckListRevision>(new List <Filter>()
{
new Filter("ItemId", values: revIds),
}));
}
foreach (var check in _initialDocumentArray)
{
check.RevisionNumber = revisions.FirstOrDefault(i => i.ItemId == check.RevisionId)?.Number.ToString() ?? "";
check.EditionNumber = _parent.Number.ToString();
}
}
else
{
var records = GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListRevisionRecordDTO, CheckListRevisionRecord>(new []
{
new Filter("ParentId", _parent.ItemId),
});
if (records.Any())
{
var ids = records.Select(i => i.CheckListId);
_initialDocumentArray.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListDTO, CheckLists>(new Filter("ItemId", ids), getDeleted: true));
var edition = GlobalObjects.CaaEnvironment.NewLoader.GetObjectById <CheckListRevisionDTO, CheckListRevision>(_parent.Settings.EditionId);
foreach (var check in _initialDocumentArray)
{
var rec = records.FirstOrDefault(i => i.CheckListId == check.ItemId);
if (rec != null)
{
check.Changes = string.Join(", ", rec.Settings.ModData.Select(i => i.Key));
}
check.RevisionStatus = records.FirstOrDefault(i => i.CheckListId == check.ItemId)?.Settings?.RevisionCheckType ?? RevisionCheckType.None;
check.EditionNumber = edition.Number.ToString();
check.RevisionNumber = _parent.Number.ToString();
}
}
}
var levels = GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <FindingLevelsDTO, FindingLevels>(new []
{
new Filter("OperatorId", _operatorId),
new Filter("ProgramTypeId", _manual.ProgramTypeId),
});
foreach (var check in _initialDocumentArray)
{
if (check.CheckUIType == CheckUIType.Iosa)
{
check.Level = levels.FirstOrDefault(i => i.ItemId == check.Settings.LevelId) ??
FindingLevels.Unknown;
}
else
{
check.Level = levels.FirstOrDefault(i => i.ItemId == check.SettingsSafa.LevelId) ??
FindingLevels.Unknown;
}
check.Remains = Lifelength.Null;
check.Condition = ConditionState.Satisfactory;
}
AnimatedThreadWorker.ReportProgress(70, "filter directives");
FilterItems(_initialDocumentArray, _resultDocumentArray);
AnimatedThreadWorker.ReportProgress(100, "Complete");
}
protected override void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
{
backgroundWorker.ReportProgress(50);
Invoke(new Action(() => listViewCompliance.Items.Clear()));
if (_currentDirective == null)
{
e.Cancel = true;
return;
}
List <AbstractRecord> lastRecords = new List <AbstractRecord>();
List <NextPerformance> nextPerformances = new List <NextPerformance>();
//прогнозируемый ресурс
//если известна родительская деталь данной директивы,
//то ее текущая наработка и средняя утилизация
//используются в качестве ресурсов прогноза
//для расчета всех просроченных выполнений
ForecastData forecastData = null;
Aircraft parentAircraft = null;
if (_currentDirective.ParentBaseComponent != null)
{
//если известна родительская деталь данной директивы,
//то ее текущая наработка и средняя утилизация
//используются в качестве ресурсов прогноза
//для расчета всех просроченных выполнений
forecastData = new ForecastData(DateTime.Now,
_currentDirective.ParentBaseComponent.AverageUtilization,
GlobalObjects.CasEnvironment.Calculator.GetCurrentFlightLifelength(_currentDirective.ParentBaseComponent));
parentAircraft = GlobalObjects.AircraftsCore.GetAircraftById(_currentDirective.ParentBaseComponent.ParentAircraftId);//TODO:(Evgenii Babak) пересмотреть использование ParentAircrafId здесь
}
//расчет след. выполнений директивы.
//если известен ресурс прогноза, то будут расчитаны все просрочнные выполнения
//если неизвестне, то только первое
//GlobalObjects.PerformanceCalculator.GetNextPerformance(_currentDirective, forecastData);
nextPerformances.AddRange(_currentDirective.NextPerformances);
lastRecords.AddRange(_currentDirective.PerformanceRecords.ToArray());
////////////////////////////////////////////
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
if (_openPubWorkPackages == null)
{
_openPubWorkPackages = new CommonCollection <WorkPackage>();
}
_openPubWorkPackages.Clear();
if (backgroundWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft, WorkPackageStatus.Opened));
if (backgroundWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft, WorkPackageStatus.Published));
CommonCollection <WorkPackage> allWorkPackagesIncludedTask = new CommonCollection <WorkPackage>();
CommonCollection <WorkPackage> openPubWorkPackagesIncludedTask = new CommonCollection <WorkPackage>();
CommonCollection <WorkPackage> closedWorkPackages = new CommonCollection <WorkPackage>();
if (backgroundWorker.CancellationPending)
{
e.Cancel = true;
return;
}
allWorkPackagesIncludedTask.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft,
WorkPackageStatus.All,
new IDirective[] { _currentDirective }));
#region Добавление в список просроченных выполнений
//и сравнение их с открытыми и опубликованными рабочими пакетами
openPubWorkPackagesIncludedTask.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Opened ||
wp.Status == WorkPackageStatus.Published));
//сбор всех записей рабочих пакетов для удобства фильтрации
List <WorkPackageRecord> openPubWpRecords = openPubWorkPackagesIncludedTask.SelectMany(wp => wp.WorkPakageRecords).ToList();
//LINQ запрос для сортировки записей по дате
List <NextPerformance> sortNextRecords = (from record in nextPerformances
orderby GetDate(record) descending
select record).ToList();
for (int i = 0; i < sortNextRecords.Count; i++)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackagesIncludedTask.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
//поиск записи в рабочих пакетах по данному чеку
//чей номер группы выполнения (по записи) совпадает с расчитанным
Directive directive = (Directive)sortNextRecords[i].Parent;
//номер выполнения
int parentCountPerf;
if (directive.LastPerformance != null)
{
parentCountPerf = directive.LastPerformance.PerformanceNum <= 0
? 1
: directive.LastPerformance.PerformanceNum;
}
else
{
parentCountPerf = 0;
}
parentCountPerf += directive.NextPerformances.IndexOf(sortNextRecords[i]);
parentCountPerf += 1;
WorkPackageRecord wpr =
openPubWpRecords.Where(r => r.PerformanceNumFromStart == parentCountPerf &&
r.WorkPackageItemType == directive.SmartCoreObjectType.ItemId &&
r.DirectiveId == directive.ItemId).FirstOrDefault();
if (wpr != null)
{
WorkPackage wp = openPubWorkPackagesIncludedTask.GetItemById(wpr.WorkPakageId);
//запись о выполнении блокируется найденым пакетом
sortNextRecords[i].BlockedByPackage = wp;
//последующие записи о выполнении так же должны быть заблокированы
for (int j = i - 1; j >= 0; j--)
{
//блокировать нужно все рабочие записи, или до первой записи,
//заблокированной другим рабочим пакетом
if (sortNextRecords[j].BlockedByPackage != null ||
sortNextRecords[j].Condition != ConditionState.Overdue)
{
break;
}
if (sortNextRecords[j].Parent == directive)
{
sortNextRecords[j].BlockedByPackage = wp;
Invoke(new Action <int, Color>(SetItemColor), new object[] { j, Color.FromArgb(Highlight.GrayLight.Color) });
}
}
}
Invoke(new Action <NextPerformance>(AddListViewItem), sortNextRecords[i]);
}
#endregion
#region Добавление в список записей о произведенных выполнениях
//и сравнение их с закрытыми рабочими пакетами
closedWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Closed));
//LINQ запрос для сортировки записей по дате
List <AbstractRecord> sortLastRecords = (from record in lastRecords
orderby record.RecordDate descending
select record).ToList();
////////////////////////////////////////////
foreach (AbstractRecord t in sortLastRecords)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackagesIncludedTask.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
DirectiveRecord directiveRecord = (DirectiveRecord)t;
WorkPackage workPackage =
closedWorkPackages.Where(wp => wp.ItemId == directiveRecord.DirectivePackageId).FirstOrDefault();
Invoke(new Action <AbstractPerformanceRecord, WorkPackage>(AddListViewItem),
new object[] { t, workPackage });
}
#endregion
allWorkPackagesIncludedTask.Clear();
openPubWorkPackagesIncludedTask.Clear();
closedWorkPackages.Clear();
backgroundWorker.ReportProgress(100);
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
_initialDocumentArray.Clear();
_resultDocumentArray.Clear();
AnimatedThreadWorker.ReportProgress(0, "load directives");
_audit = GlobalObjects.CaaEnvironment.NewLoader.GetObjectById <CAAAuditDTO, CAAAudit>(_parentId);
var records = GlobalObjects.CaaEnvironment.NewLoader
.GetObjectListAll <CAAAuditRecordDTO, CAAAuditRecord>(new Filter("AuditId", _parentId), loadChild: true).ToList();
_currentRoutineId = records.Select(i => i.RoutineAuditId).FirstOrDefault();
_routineAudit = GlobalObjects.CaaEnvironment.NewLoader.GetObjectById <RoutineAuditDTO, SmartCore.CAA.RoutineAudits.RoutineAudit>(_currentRoutineId.Value);
var manuals = GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <StandartManualDTO, SmartCore.CAA.StandartManual.StandartManual>(new []
{
new Filter("OperatorId", new [] { _operatorId, -1 }.Distinct()),
new Filter("ProgramTypeId", _routineAudit.Settings.TypeId),
});
_manual = manuals.FirstOrDefault();
var routines = GlobalObjects.CaaEnvironment.NewLoader
.GetObjectListAll <RoutineAuditRecordDTO, RoutineAuditRecord>(new Filter("RoutineAuditId", _currentRoutineId), loadChild: true).ToList();
var ids = new List <int>();
if (_type == CheckListAuditType.Admin)
{
if (_audit.Settings.Status == RoutineStatus.Published)
{
var ds = GlobalObjects.CaaEnvironment.NewLoader.Execute($@"select CheckListId from dbo.AuditChecks
where AuditId in ({_parentId}) and IsDeleted = 0 and WorkflowStageId = {_stage.Value}");
var dt = ds.Tables[0];
ids.AddRange(from DataRow dr in dt.Rows select(int) dr[0]);
}
else
{
ids = routines.Select(i => i.CheckListId).Distinct().ToList();
}
}
else
{
var condition = _stage.HasValue ? $" and ac.WorkflowStageId = {_stage}" : "";
var ds = GlobalObjects.CaaEnvironment.NewLoader.Execute($@"SELECT rec.CheckListId
FROM [AuditPelRecords] rec
cross apply
(
select SpecialistId as Auditor from [dbo].[PelSpecialist] where ItemId = rec.AuditorId
) as auditor
cross apply
(
select SpecialistId as Auditee from [dbo].[PelSpecialist] where ItemId = rec.AuditeeId
) as auditee
cross apply
(
select JSON_VALUE(SettingsJSON, '$.WorkflowStageId') as WorkflowStageId from [dbo].AuditChecks
where AuditId = rec.AuditId and CheckListId = rec.CheckListId
) as ac
where rec.AuditId in ({_parentId}) and rec.IsDeleted = 0 {condition}
and (auditor.Auditor = {GlobalObjects.CaaEnvironment.IdentityUser.PersonnelId} or auditee.Auditee = {GlobalObjects.CaaEnvironment.IdentityUser.PersonnelId})");
var dt = ds.Tables[0];
ids.AddRange(from DataRow dr in dt.Rows select(int) dr[0]);
}
if (ids.Any())
{
var filter = new List <Filter>()
{
new Filter("CheckListId", ids),
new Filter("AuditId", _audit.ItemId)
};
if (_stage.HasValue)
{
filter.Add(new Filter("WorkflowStageId", _stage.Value));
}
var auditChecks = GlobalObjects.CaaEnvironment.NewLoader
.GetObjectListAll <AuditCheckDTO, AuditCheck>(filter, loadChild: true).ToList();
_initialDocumentArray.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectListAll <CheckListDTO, CheckLists>(new Filter("ItemId", ids), loadChild: true, true));
var revisions = new List <CheckListRevision>();
var revedIds = _initialDocumentArray.Where(i => i.RevisionId.HasValue).Select(i => i.RevisionId.Value).Distinct().ToList();
revedIds.AddRange(_initialDocumentArray.Select(i => i.EditionId).Distinct());
if (revedIds.Any())
{
revisions.AddRange(GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <CheckListRevisionDTO, CheckListRevision>(new List <Filter>()
{
new Filter("ItemId", values: revedIds),
}));
}
foreach (var check in _initialDocumentArray)
{
check.AuditCheck = auditChecks.FirstOrDefault(i => i.CheckListId == check.ItemId);
check.RevisionNumber = revisions.FirstOrDefault(i => i.ItemId == check.RevisionId)?.Number.ToString() ?? "";
check.EditionNumber = revisions.FirstOrDefault(i => i.ItemId == check.RevisionId)?.Number.ToString() ?? "";
}
}
var pelRecords = GlobalObjects.CaaEnvironment.NewLoader
.GetObjectListAll <AuditPelRecordDTO, AuditPelRecord>(new Filter("AuditId", _parentId));
if (records.Any())
{
var pelSpec = GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <PelSpecialistDTO, PelSpecialist>(new Filter("AuditId", _parentId));
var specIds = pelSpec.Select(i => i.SpecialistId);
var specialists = GlobalObjects.CaaEnvironment.NewLoader
.GetObjectListAll <CAASpecialistDTO, Specialist>(new Filter("ItemId", specIds),
loadChild: true);
foreach (var specialist in specialists)
{
specialist.Operator = GlobalObjects.CaaEnvironment.AllOperators.FirstOrDefault(i => i.ItemId == specialist.OperatorId) ?? AllOperators.Unknown;
}
foreach (var pel in pelSpec)
{
pel.Specialist = specialists.FirstOrDefault(i => i.ItemId == pel.SpecialistId);
}
var dsTransfer = GlobalObjects.CaaEnvironment.NewLoader.Execute($@";WITH cte AS
(
SELECT *,
ROW_NUMBER() OVER (PARTITION BY CheckListId ORDER BY Created DESC) AS rn
FROM [CheckListTransfer] where AuditId = {_parentId}
)
SELECT CheckListId, [From], [To]
FROM cte
WHERE rn = 1 and IsDeleted = 0");
var transfers = dsTransfer.Tables[0].Rows.OfType <DataRow>().Select(i => new
{
CheckListId = (int)i[0],
From = (int)i[1],
To = (int)i[2],
});
foreach (var rec in pelRecords)
{
rec.CheckList = _initialDocumentArray.FirstOrDefault(i => i.ItemId == rec.CheckListId);
rec.Auditor = pelSpec.FirstOrDefault(i => i.ItemId == rec.AuditorId)?.Specialist ?? Specialist.Unknown;
rec.Auditee = pelSpec.FirstOrDefault(i => i.ItemId == rec.AuditeeId)?.Specialist ?? Specialist.Unknown;
var tr = transfers.FirstOrDefault(i => i.CheckListId == rec.CheckListId);
if (tr != null)
{
rec.CurrentAuditor = pelSpec.FirstOrDefault(i => i.SpecialistId == tr.To)?.Specialist ?? Specialist.Unknown;
}
}
}
var levels = GlobalObjects.CaaEnvironment.NewLoader.GetObjectList <FindingLevelsDTO, FindingLevels>(new []
{
new Filter("OperatorId", _operatorId),
new Filter("ProgramTypeId", _manual.ProgramTypeId),
});
foreach (var check in _initialDocumentArray)
{
check.PelRecord = pelRecords.FirstOrDefault(i => i.CheckListId == check.ItemId);
if (check.PelRecord?.CurrentAuditor?.ItemId == GlobalObjects.CaaEnvironment.IdentityUser.PersonnelId)
{
check.IsEditable = true;
}
if (check.CheckUIType == CheckUIType.Iosa)
{
check.Level = levels.FirstOrDefault(i => i.ItemId == check.Settings.LevelId) ??
FindingLevels.Unknown;
}
else if (check.CheckUIType == CheckUIType.Safa)
{
check.Level = levels.FirstOrDefault(i => i.ItemId == check.SettingsSafa.LevelId) ??
FindingLevels.Unknown;
}
else if (check.CheckUIType == CheckUIType.Icao)
{
check.Level = levels.FirstOrDefault(i => i.ItemId == check.SettingsIcao.LevelId) ??
FindingLevels.Unknown;
}
check.Remains = Lifelength.Null;
check.Condition = ConditionState.Satisfactory;
}
AnimatedThreadWorker.ReportProgress(40, "filter directives");
AnimatedThreadWorker.ReportProgress(70, "filter directives");
FilterItems(_initialDocumentArray, _resultDocumentArray);
AnimatedThreadWorker.ReportProgress(100, "Complete");
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
var initialZeroMaintenanceDirectives = new CommonCollection <MaintenanceDirective>();
var initialMaintenanceDirectives = new CommonCollection <MaintenanceDirective>();
_result.Clear();
_initial.Clear();
_groupLifelengths.Clear();
_groupLifelengthsForZeroCheck.Clear();
if (!_isFirstLoad)
{
AnimatedThreadWorker.ReportProgress(0, "load checks");
var checks = GlobalObjects.CasEnvironment.NewLoader.GetObjectListAll <MTOPCheckDTO, MTOPCheck>(new Filter("ParentAircraftId", CurrentAircraft.ItemId), true).ToList();
foreach (var check in checks)
{
foreach (var record in check.PerformanceRecords)
{
record.Parent = check;
}
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
AnimatedThreadWorker.ReportProgress(10, "load MPDs");
initialMaintenanceDirectives.AddRange(GlobalObjects.MaintenanceCore.GetMaintenanceDirectives(CurrentAircraft));
var bindedItemsDict = GlobalObjects.BindedItemsCore.GetBindedItemsFor(CurrentAircraft.ItemId,
initialMaintenanceDirectives.Where(m => m.WorkItemsRelationType == WorkItemsRelationType.CalculationDepend));
CalculateMaintenanceDirectives(initialMaintenanceDirectives.ToList(), bindedItemsDict);
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
AnimatedThreadWorker.ReportProgress(50, "calculation");
if (checks.Count > 0)
{
//Берем утилизацию с Frame
var frame = GlobalObjects.CasEnvironment.BaseComponents.FirstOrDefault(i =>
i.ParentAircraftId == CurrentAircraft.ItemId && Equals(i.BaseComponentType, BaseComponentType.Frame));
var avg = _currentForecast.ForecastDatas[0].AverageUtilization;
var lastCompliance = checks.SelectMany(i => i.PerformanceRecords).OrderByDescending(i => i.RecordDate)
.FirstOrDefault();
GlobalObjects.MTOPCalculator.CalculateMtopChecks(checks, avg);
_groupLifelengths = GlobalObjects.MTOPCalculator.CalculateGroupNew(checks.Where(i => !i.Thresh.IsNullOrZero() && !i.IsZeroPhase).ToList());
GlobalObjects.MTOPCalculator.CalculateNextPerformance(checks.Where(i => !i.IsZeroPhase).ToList(),
frame.StartDate, _groupLifelengths, CurrentAircraft, avg, lastCompliance);
GlobalObjects.MTOPCalculator.CalculatePhaseWithPerformance(initialMaintenanceDirectives, checks.Where(i => !i.Thresh.IsNullOrZero() && !i.IsZeroPhase).ToList(), avg, _currentForecast.ForecastDatas[0].LowerLimit, _currentForecast.ForecastDatas[0].ForecastDate);
var maintenanceZeroChecks = checks.Where(i => i.IsZeroPhase).ToList();
var lowerZeroCheck = maintenanceZeroChecks.Where(i => !i.Thresh.IsNullOrZero()).OrderBy(i => i.Thresh)
.FirstOrDefault();
if (lowerZeroCheck != null)
{
GlobalObjects.MTOPCalculator.CalculateMtopChecks(maintenanceZeroChecks, avg);
_groupLifelengthsForZeroCheck = GlobalObjects.MTOPCalculator.CalculateGroupNew(checks.Where(i => !i.Thresh.IsNullOrZero() && i.IsZeroPhase).ToList());
GlobalObjects.MTOPCalculator.CalculateNextPerformance(maintenanceZeroChecks, frame.StartDate,
_groupLifelengthsForZeroCheck, CurrentAircraft, avg, lastCompliance);
initialZeroMaintenanceDirectives.AddRange(initialMaintenanceDirectives
.Where(i => i.MTOPPhase?.FirstPhase == 0).ToArray());
GlobalObjects.MTOPCalculator.CalculatePhaseWithPerformance(initialZeroMaintenanceDirectives, maintenanceZeroChecks, avg, _currentForecast.ForecastDatas[0].LowerLimit, _currentForecast.ForecastDatas[0].ForecastDate, true);
}
foreach (var d in initialZeroMaintenanceDirectives)
{
initialMaintenanceDirectives.Remove(d);
}
_initial.AddRange(initialMaintenanceDirectives.SelectMany(i => i.MtopNextPerformances));
_initial.AddRange(initialZeroMaintenanceDirectives.SelectMany(i => i.MtopNextPerformances));
}
#region Фильтрация директив
AnimatedThreadWorker.ReportProgress(75, "filter directives");
FilterItems(_initial, _result);
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
#region Load WP
AnimatedThreadWorker.ReportProgress(75, "filter Work Packages");
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
if (_openPubWorkPackages == null)
{
_openPubWorkPackages = new CommonCollection <WorkPackage>();
}
_openPubWorkPackages.Clear();
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(CurrentAircraft, WorkPackageStatus.Opened));
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(CurrentAircraft, WorkPackageStatus.Published));
//сбор всех записей рабочих пакетов для удобства фильтрации
List <WorkPackageRecord> openWPRecords = new List <WorkPackageRecord>();
foreach (WorkPackage openWorkPackage in _openPubWorkPackages)
{
openWPRecords.AddRange(openWorkPackage.WorkPakageRecords);
}
#endregion
#region Загрузка Котировочных ордеров
AnimatedThreadWorker.ReportProgress(95, "Load Quotations");
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
if (_openPubQuotations == null)
{
_openPubQuotations = new CommonCollection <RequestForQuotation>();
}
BaseEntityObject parent = CurrentAircraft ?? (BaseEntityObject)CurrentOperator;
_openPubQuotations.Clear();
_openPubQuotations.AddRange(GlobalObjects.PurchaseCore.GetRequestForQuotation(parent, new[] { WorkPackageStatus.Opened, WorkPackageStatus.Published }));
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
AnimatedThreadWorker.ReportProgress(100, "Completed");
}
}
protected override void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
{
//TODO:(Evgenii Babak) много повторяющегося кода, требуется оптимизация
backgroundWorker.ReportProgress(50);
Invoke(new Action(() => listViewCompliance.Items.Clear()));
if (_currentDirective == null)
{
e.Cancel = true;
return;
}
var lastRecords = new List <AbstractPerformanceRecord>();
var nextPerformances = new List <NextPerformance>();
if (_openPubWorkPackages == null)
{
_openPubWorkPackages = new CommonCollection <WorkPackage>();
}
_openPubWorkPackages.Clear();
var parentAircraft = GlobalObjects.AircraftsCore.GetAircraftById(_currentDirective.ParentBaseComponent.ParentAircraftId); //TODO:(Evgenii Babak) пересмотреть использование ParentAircrafId здесь
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft, WorkPackageStatus.Opened));
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft, WorkPackageStatus.Published));
var allWorkPackagesIncludedTask = new CommonCollection <WorkPackage>();
var openPubWorkPackages = new CommonCollection <WorkPackage>();
var closedWorkPackages = new CommonCollection <WorkPackage>();
if (_currentDirective.IsAffect().GetValueOrDefault(true))
{
//Поиск и заполнение просроченных директив и записей о перемещении
//Объекты для в которые будет извлекаться информация
//из записеи о перемещении
//прогнозируемый ресурс
var forecastData = new ForecastData(DateTime.Now,
_currentDirective.ParentBaseComponent.AverageUtilization,
GlobalObjects.CasEnvironment.Calculator.GetCurrentFlightLifelength(_currentDirective.ParentBaseComponent));
//расчет след. выполнений директивы.
//если известен ресурс прогноза, то будут расчитаны все просрочнные выполнения
//если неизвестне, то только первое
//GlobalObjects.PerformanceCalculator.GetNextPerformance(_currentDirective, forecastData);
nextPerformances.AddRange(_currentDirective.NextPerformances);
lastRecords.AddRange(_currentDirective.PerformanceRecords.ToArray());
////////////////////////////////////////////
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackages(parentAircraft, WorkPackageStatus.Opened, true));
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackages(parentAircraft, WorkPackageStatus.Published, true));
allWorkPackagesIncludedTask.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft,
WorkPackageStatus.All,
new IDirective[] { _currentDirective }));
#region Добавление в список просроченных выполнений
//и сравнение их с открытыми и опубликованными рабочими пакетами
openPubWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Opened ||
wp.Status == WorkPackageStatus.Published));
//сбор всех записей рабочих пакетов для удобства фильтрации
List <WorkPackageRecord> openPubWpRecords = openPubWorkPackages.SelectMany(wp => wp.WorkPakageRecords).ToList();
//LINQ запрос для сортировки записей по дате
List <NextPerformance> sortNextRecords = (from record in nextPerformances
orderby GetDate(record) descending
select record).ToList();
for (int i = 0; i < sortNextRecords.Count; i++)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackages.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
//поиск записи в рабочих пакетах по данному чеку
//чей номер группы выполнения (по записи) совпадает с расчитанным
MaintenanceDirective directive = (MaintenanceDirective)sortNextRecords[i].Parent;
//номер выполнения
int parentCountPerf;
if (directive.LastPerformance != null)
{
parentCountPerf = directive.LastPerformance.PerformanceNum <= 0
? 1
: directive.LastPerformance.PerformanceNum;
}
else
{
parentCountPerf = 0;
}
parentCountPerf += directive.NextPerformances.IndexOf(sortNextRecords[i]);
parentCountPerf += 1;
WorkPackageRecord wpr =
openPubWpRecords.FirstOrDefault(r => r.PerformanceNumFromStart == parentCountPerf &&
r.WorkPackageItemType == directive.SmartCoreObjectType.ItemId &&
r.DirectiveId == directive.ItemId);
if (wpr != null)
{
WorkPackage wp = openPubWorkPackages.GetItemById(wpr.WorkPakageId);
//запись о выполнении блокируется найденым пакетом
sortNextRecords[i].BlockedByPackage = wp;
//последующие записи о выполнении так же должны быть заблокированы
for (int j = i - 1; j >= 0; j--)
{
//блокировать нужно все рабочие записи, или до первой записи,
//заблокированной другим рабочим пакетом
if (sortNextRecords[j].BlockedByPackage != null ||
sortNextRecords[j].Condition != ConditionState.Overdue)
{
break;
}
if (sortNextRecords[j].Parent == directive)
{
sortNextRecords[j].BlockedByPackage = wp;
Invoke(new Action <int, Color>(SetItemColor), new object[] { j, Color.FromArgb(Highlight.GrayLight.Color) });
}
}
}
Invoke(new Action <NextPerformance>(AddListViewItem), sortNextRecords[i]);
}
#endregion
#region Добавление в список записей о произведенных выполнениях
//и сравнение их с закрытыми рабочими пакетами
closedWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Closed));
//LINQ запрос для сортировки записей по дате
List <AbstractPerformanceRecord> sortLastRecords = (from record in lastRecords
orderby record.RecordDate descending
select record).ToList();
////////////////////////////////////////////
for (int i = 0; i < sortLastRecords.Count(); i++)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackages.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
DirectiveRecord directiveRecord = (DirectiveRecord)sortLastRecords[i];
WorkPackage workPackage =
closedWorkPackages.Where(wp => wp.ItemId == directiveRecord.DirectivePackageId).FirstOrDefault();
if (workPackage != null)
{
Invoke(new Action <AbstractPerformanceRecord, WorkPackage, MaintenanceCheckRecord>(AddListViewItem),
new object[] { sortLastRecords[i], workPackage, null });
}
else if (directiveRecord.MaintenanceCheckRecordId > 0)
{
var mcr = GlobalObjects.CasEnvironment.NewLoader.GetObject <DirectiveRecordDTO, MaintenanceCheckRecord>(new Filter("ItemId", directiveRecord.MaintenanceCheckRecordId));
if (mcr != null)
{
mcr.ParentCheck = GlobalObjects.CasEnvironment.NewLoader.GetObjectById <MaintenanceCheckDTO, MaintenanceCheck>(mcr.ParentId);
}
Invoke(new Action <AbstractPerformanceRecord, WorkPackage, MaintenanceCheckRecord>(AddListViewItem),
new object[] { sortLastRecords[i], workPackage, mcr });
}
else
{
Invoke(new Action <AbstractPerformanceRecord, WorkPackage>(AddListViewItem),
new object[] { sortLastRecords[i], workPackage });
}
}
#endregion
}
else
{
//Поиск и заполнение просроченных директив и записей о перемещении
//Объекты для в которые будет извлекаться информация
//из записеи о перемещении
//прогнозируемый ресурс
foreach (var directive in _bindedItems)
{
if (directive is ComponentDirective)
{
var componentDirective = (ComponentDirective)directive;
var detail = componentDirective.ParentComponent ?? _currentDirective.ParentBaseComponent;
//прогнозируемый ресурс
//если известна родительская деталь данной директивы,
//то ее текущая наработка и средняя утилизация
//используются в качестве ресурсов прогноза
//для расчета всех просроченных выполнений
var forecastData = new ForecastData(DateTime.Now,
GlobalObjects.AverageUtilizationCore.GetAverageUtillization(detail),
GlobalObjects.CasEnvironment.Calculator.GetCurrentFlightLifelength(detail));
//расчет след. выполнений директивы.
//если известен ресурс прогноза, то будут расчитаны все просрочнные выполнения
//если неизвестне, то только первое
GlobalObjects.PerformanceCalculator.GetNextPerformance(componentDirective, forecastData);
nextPerformances.AddRange(componentDirective.NextPerformances);
lastRecords.AddRange(componentDirective.PerformanceRecords.ToArray());
}
}
var directiveRecords = _bindedItems.SelectMany(dd => dd.PerformanceRecords.Cast <DirectiveRecord>());
lastRecords.AddRange(_currentDirective.PerformanceRecords
.Where(performanceRecord => directiveRecords.Count(d => d.MaintenanceDirectiveRecordId == performanceRecord.ItemId) == 0)
.Cast <AbstractPerformanceRecord>());
////////////////////////////////////////////
//загрузка рабочих пакетов для определения
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft, WorkPackageStatus.Opened));
_openPubWorkPackages.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft, WorkPackageStatus.Published));
allWorkPackagesIncludedTask.AddRange(GlobalObjects.WorkPackageCore.GetWorkPackagesLite(parentAircraft,
WorkPackageStatus.All,
_bindedItems));
#region Добавление в список просроченных выполнений
//и сравнение их с открытыми и опубликованными рабочими пакетами
openPubWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Opened ||
wp.Status == WorkPackageStatus.Published));
//сбор всех записей рабочих пакетов для удобства фильтрации
List <WorkPackageRecord> openPubWpRecords = new List <WorkPackageRecord>();
foreach (WorkPackage openWorkPackage in openPubWorkPackages)
{
openPubWpRecords.AddRange(openWorkPackage.WorkPakageRecords);
}
//LINQ запрос для сортировки записей по дате
List <NextPerformance> sortNextRecords = (from record in nextPerformances
orderby GetDate(record) descending
select record).ToList();
for (int i = 0; i < sortNextRecords.Count; i++)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackages.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
//поиск записи в рабочих пакетах по данному чеку
//чей номер группы выполнения (по записи) совпадает с расчитанным
ComponentDirective directive = (ComponentDirective)sortNextRecords[i].Parent;
//номер выполнения
int parentCountPerf;
if (directive.LastPerformance != null)
{
parentCountPerf = directive.LastPerformance.PerformanceNum <= 0
? 1
: directive.LastPerformance.PerformanceNum;
}
else
{
parentCountPerf = 0;
}
parentCountPerf += directive.NextPerformances.IndexOf(sortNextRecords[i]);
parentCountPerf += 1;
WorkPackageRecord wpr =
openPubWpRecords.Where(r => r.PerformanceNumFromStart == parentCountPerf &&
r.WorkPackageItemType == directive.SmartCoreObjectType.ItemId &&
r.DirectiveId == directive.ItemId).FirstOrDefault();
if (wpr != null)
{
WorkPackage wp = openPubWorkPackages.GetItemById(wpr.WorkPakageId);
//запись о выполнении блокируется найденым пакетом
sortNextRecords[i].BlockedByPackage = wp;
//последующие записи о выполнении так же должны быть заблокированы
for (int j = i - 1; j >= 0; j--)
{
//блокировать нужно все рабочие записи, или до первой записи,
//заблокированной другим рабочим пакетом
if (sortNextRecords[j].BlockedByPackage != null ||
sortNextRecords[j].Condition != ConditionState.Overdue)
{
break;
}
if (sortNextRecords[j].Parent == directive)
{
sortNextRecords[j].BlockedByPackage = wp;
Invoke(new Action <int, Color>(SetItemColor), new object[] { j, Color.FromArgb(Highlight.GrayLight.Color) });
}
}
}
Invoke(new Action <NextPerformance>(AddListViewItem), sortNextRecords[i]);
}
#endregion
#region Добавление в список записей о произведенных выполнениях
//и сравнение их с закрытыми рабочими пакетами
closedWorkPackages.AddRange(allWorkPackagesIncludedTask.Where(wp => wp.Status == WorkPackageStatus.Closed));
//LINQ запрос для сортировки записей по дате
List <AbstractPerformanceRecord> sortLastRecords = (from record in lastRecords
orderby record.RecordDate descending
select record).ToList();
////////////////////////////////////////////
for (int i = 0; i < sortLastRecords.Count; i++)
{
if (backgroundWorker.CancellationPending)
{
allWorkPackagesIncludedTask.Clear();
openPubWorkPackages.Clear();
closedWorkPackages.Clear();
e.Cancel = true;
return;
}
WorkPackage workPackage =
closedWorkPackages.FirstOrDefault(wp => wp.ItemId == sortLastRecords[i].DirectivePackageId);
Invoke(new Action <AbstractPerformanceRecord, WorkPackage>(AddListViewItem),
new object[] { sortLastRecords[i], workPackage });
}
#endregion
}
allWorkPackagesIncludedTask.Clear();
openPubWorkPackages.Clear();
closedWorkPackages.Clear();
backgroundWorker.ReportProgress(100);
}