///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void FilterItems(IEnumerable <WorkPackage> initialCollection, ICommonCollection <WorkPackage> resultCollection)
{
if (_filter == null || _filter.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (var pd in initialCollection)
{
//if (pd.MaintenanceCheck != null && pd.MaintenanceCheck.Name == "2C")
//{
// pd.MaintenanceCheck.ToString();
//}
if (_filter.FilterTypeAnd)
{
var acceptable = true;
foreach (var filter in _filter)
{
acceptable = filter.Acceptable(pd); if (!acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
var acceptable = true;
foreach (var filter in _filter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
protected void FilterItems(ICommonCollection initialCollection, ICommonCollection resultCollection)
{
if (_filter == null || _filter.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (BaseEntityObject pd in initialCollection)
{
//if (pd.MaintenanceCheck != null && pd.MaintenanceCheck.Name == "2C")
//{
// pd.MaintenanceCheck.ToString();
//}
if (_filter.FilterTypeAnd)
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
acceptable = filter.Acceptable(pd); if (!acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void AdditionalFilterItems(IEnumerable <BaseEntityObject> initialCollection, ICommonCollection <BaseEntityObject> resultCollection)
{
if (_additionalfilter == null || _additionalfilter.Count == 0)
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (BaseEntityObject pd in initialCollection)
{
//if (pd.MaintenanceCheck != null && pd.MaintenanceCheck.Name == "2C")
//{
// pd.MaintenanceCheck.ToString();
//}
if (_additionalfilter.FilterTypeAnd)
{
bool acceptable = true;
foreach (ICommonFilter filter in _additionalfilter)
{
acceptable = filter.Acceptable(pd); if (!acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
bool acceptable = true;
foreach (ICommonFilter filter in _additionalfilter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void FilterItems(IEnumerable <NextPerformance> initialCollection, ICommonCollection <NextPerformance> resultCollection)
{
if (_filter == null || _filter.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (NextPerformance pd in initialCollection)
{
//if (pd.Parent != null && pd.Parent is MaintenanceCheck && ((MaintenanceCheck)pd.Parent).Name == "C02")
//{
// pd.ToString();
//}
if (_filter.FilterTypeAnd)
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
acceptable = filter.Acceptable(pd); if (!acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
public void RegisterAircraft(Aircraft aircraft, int operatorId)
{
if (operatorId <= 0)
{
throw new Exception("1650: Can not add aircraft to not existing operator");
}
// Сохраняем воздушное судно в базе
aircraft.OperatorId = operatorId;
_newKeeper.Save(aircraft);
_aircrafts.Add(aircraft);
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void FilterItems(IEnumerable <ILogistic> initialCollection, ICommonCollection <ILogistic> resultCollection)
{
if (_filter == null || _filter.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (var pd in initialCollection)
{
if (_filter.FilterTypeAnd)
{
var acceptable = true;
foreach (var filter in _filter)
{
acceptable = filter.Acceptable(pd as BaseEntityObject);
}
if (!acceptable)
{
break;
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
var acceptable = true;
foreach (var filter in _filter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd as BaseEntityObject); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
///<summary>
///</summary>
///<param name="initialCollection"></param>
///<param name="resultCollection"></param>
private void FilterItems(IEnumerable <MailRecords> initialCollection, ICommonCollection <MailRecords> resultCollection)
{
if (_filter == null || _filter.All(i => i.Values.Length == 0))
{
resultCollection.Clear();
resultCollection.AddRange(initialCollection);
return;
}
resultCollection.Clear();
foreach (var pd in initialCollection)
{
if (_filter.FilterTypeAnd)
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
acceptable = filter.Acceptable(pd); if (!acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
else
{
bool acceptable = true;
foreach (ICommonFilter filter in _filter)
{
if (filter.Values == null || filter.Values.Length == 0)
{
continue;
}
acceptable = filter.Acceptable(pd); if (acceptable)
{
break;
}
}
if (acceptable)
{
resultCollection.Add(pd);
}
}
}
}
public void CalculateMaintenanceDirectives(IList <MaintenanceDirective> maintenanceDirectives, Dictionary <IBindedItem, List <IDirective> > bindedItemsDict)
{
foreach (var mpd in maintenanceDirectives)
{
GlobalObjects.MTOPCalculator.CalculateDirectiveNew(mpd);
if (bindedItemsDict.ContainsKey(mpd))
{
var bindedItems = bindedItemsDict[mpd];
foreach (var bindedItem in bindedItems)
{
if (bindedItem is ComponentDirective)
{
GlobalObjects.MTOPCalculator.CalculateDirectiveNew(bindedItem as ComponentDirective);
var firstNextPerformance =
bindedItemsDict[mpd].SelectMany(t => t.NextPerformances).OrderBy(n => n.NextPerformanceDate).FirstOrDefault();
if (firstNextPerformance == null)
{
continue;
}
mpd.BindedItemNextPerformance = firstNextPerformance;
mpd.BindedItemNextPerformanceSource = firstNextPerformance.NextPerformanceSource ?? Lifelength.Null;
mpd.BindedItemRemains = firstNextPerformance.Remains ?? Lifelength.Null;
mpd.BindedItemNextPerformanceDate = firstNextPerformance.NextPerformanceDate;
mpd.BindedItemCondition = firstNextPerformance.Condition ?? ConditionState.NotEstimated;
}
}
}
_initialDirectiveArray.Add(mpd);
}
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
_initialDirectiveArray.Clear();
_resultDirectiveArray.Clear();
AnimatedThreadWorker.ReportProgress(0, "load directives");
if (!string.IsNullOrEmpty(TextBoxFilter.Text))
{
var dir = new List <Directive>();
try
{
dir.AddRange(GlobalObjects.DirectiveCore.GetDirectivesFromAllAircrafts(DirectiveType.AirworthenessDirectives, TextBoxFilter.Text, TextBoxFilterParagraph.Text));
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while loading directives", ex);
}
AnimatedThreadWorker.ReportProgress(40, "filter directives");
#region Калькуляция состояния директив
AnimatedThreadWorker.ReportProgress(60, "calculation of directives");
foreach (Directive pd in dir)
{
var aircrraft =
GlobalObjects.AircraftsCore.GetAircraftById(pd.ParentBaseComponent?.ParentAircraftId ?? -1);
if (aircrraft != null)
{
GlobalObjects.MTOPCalculator.CalculateDirectiveNew(pd);
_initialDirectiveArray.Add(pd);
}
}
AnimatedThreadWorker.ReportProgress(70, "filter directives");
FilterItems(_initialDirectiveArray, _resultDirectiveArray);
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
AnimatedThreadWorker.ReportProgress(100, "Complete");
}
}
private void GetFromClipboard()
{
try
{
var format = typeof(Document[]).FullName;
if (string.IsNullOrEmpty(format))
{
return;
}
if (!Clipboard.ContainsData(format))
{
return;
}
var documents = (Document[])Clipboard.GetData(format);
if (documents == null)
{
return;
}
var objectsToPaste = new List <Document>();
foreach (var document in documents)
{
document.Parent = _currentItem;
document.ParentId = _currentItem.ItemId;
_initialDocumentArray.Add(document);
document.ContractNumber += " Copy";
objectsToPaste.Add(document);
}
if (objectsToPaste.Count > 0)
{
documentationListView.InsertItems(objectsToPaste.ToArray());
}
}
catch (Exception ex)
{
MessageBox.Show("Error while inserting new object(s). \n" + ex);
Program.Provider.Logger.Log(ex);
}
finally
{
Clipboard.Clear();
}
}
public static void SetFileByFileLinkType(this ICommonCollection <ItemFileLink> files, int typeId, AttachedFile file, FileLinkType fileLinkType)
{
var link = files.FirstOrDefault(i => i.LinkType == (short)fileLinkType);
if (link != null)
{
link.File = file;
}
else if (file != null)
{
files.Add(new ItemFileLink
{
ParentTypeId = typeId,
LinkType = (short)fileLinkType,
File = file
});
}
}
private void ButtonCreateAircraftClick(object sender, EventArgs e)
{
if (listViewMain.SelectedItems.Count == 0)
{
return;
}
string message;
if (!ValidateData(out message))
{
message += "\nAbort operation";
MessageBox.Show(message, (string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
string typeName = _type.Name;
DialogResult confirmResult =
MessageBox.Show(listViewMain.SelectedItems.Count == 1
? "Do you really want to delete " + typeName + " " + listViewMain.SelectedItems[0].Tag + "?"
: "Do you really want to delete selected " + typeName + "s?", "Confirm delete operation",
MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
if (confirmResult == DialogResult.Yes)
{
_deletedObjects.Clear();
foreach (ListViewItem directive in listViewMain.SelectedItems)
{
_deletedObjects.Add((BaseEntityObject)directive.Tag);
}
_animatedThreadWorker.DoWork -= AnimatedThreadWorkerDoLoad;
_animatedThreadWorker.DoWork += AnimatedThreadWorkerDoCreate;
_animatedThreadWorker.RunWorkerCompleted -= BackgroundWorkerRunWorkerLoadCompleted;
_animatedThreadWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerCreateCompleted;
_animatedThreadWorker.RunWorkerAsync();
}
}
/// <summary>
/// Метод возвращает массив директив
/// </summary>
/// <returns>Массив директив</returns>
public virtual ICommonCollection GetItemsArray()
{
try
{
int count = itemsListView.Items.Count;
Type genericType = typeof(CommonCollection <>);
Type genericList = genericType.MakeGenericType(_viewedType);
ICommonCollection returnDetailArray = (ICommonCollection)Activator.CreateInstance(genericList);
if (count > 0)
{
for (int i = 0; i < count; i++)
{
returnDetailArray.Add(itemsListView.Items[i].Tag as BaseEntityObject);
}
}
return(returnDetailArray);
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while building collection", ex);
return(null);
}
}
private void UpdateInformation()
{
if (_currentItem == null)
{
return;
}
_initialDocumentArray.Clear();
_resultDocumentArray.Clear();
if (_firstLoad)
{
_firstLoad = false;
if (_currentItem.EmployeeFlights.Count > 0)
{
dateTimePickerDateFrom.Value = _currentItem.EmployeeFlights.FirstOrDefault().RecordDate;
dateTimePickerDateTo.Value = _currentItem.EmployeeFlights.LastOrDefault().RecordDate;
}
}
foreach (var t in _currentItem.EmployeeFlights)
{
if (t.FlightDate >= dateTimePickerDateFrom.Value &&
t.FlightDate <= dateTimePickerDateTo.Value)
{
_initialDocumentArray.Add(t);
}
}
//_initialDocumentArray.AddRange(_currentItem.EmployeeFlights.ToArray());
FilterItems(_initialDocumentArray, _resultDocumentArray);
employeeFlightListView.Flights = new AircraftFlightCollection(_initialDocumentArray.ToArray());
employeeFlightListView.SetItemsArray(_resultDocumentArray.ToArray());
employeeFlightListView.Focus();
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
_initialDirectiveArray.Clear();
_resultDirectiveArray.Clear();
_preResultDirectiveArray.Clear();
var transfer = new List <TransferRecord>();
transfer.AddRange(GlobalObjects.TransferRecordCore.GetPreTransferRecordsFrom(_currentBaseComponent));
var preResult = new List <Component>();
preResult.AddRange(transfer.Select(i => i.ParentComponent).ToList());
AnimatedThreadWorker.ReportProgress(50, "filter components");
InitialFilterItems(preResult, _initialDirectiveArray);
preResult.Clear();
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#region Калькуляция состояния компонентов
AnimatedThreadWorker.ReportProgress(70, "calculation of components");
foreach (Component detail in _initialDirectiveArray)
{
GlobalObjects.PerformanceCalculator.GetNextPerformance(detail);
_preResultDirectiveArray.Add(detail);
foreach (ComponentDirective detailDirective in detail.ComponentDirectives)
{
GlobalObjects.PerformanceCalculator.GetNextPerformance(detailDirective);
_preResultDirectiveArray.Add(detailDirective);
}
}
AdditionalFilterItems(_preResultDirectiveArray, _resultDirectiveArray);
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
#region Сравнение с рабочими пакетами
AnimatedThreadWorker.ReportProgress(90, "comparison with the Work Packages");
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
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);
}
foreach (IDirective dir in _resultDirectiveArray)
{
if (dir.NextPerformances == null || dir.NextPerformances.Count <= 0)
{
continue;
}
BaseEntityObject baseObject = (BaseEntityObject)dir;
//Проход по всем след. выполнениям чека и записям в рабочих пакетах
//для поиска перекрывающихся выполнений
List <NextPerformance> performances = dir.NextPerformances;
foreach (NextPerformance np in performances)
{
//поиск записи в рабочих пакетах по данному чеку
//чей номер группы выполнения (по записи) совпадает с расчитанным
WorkPackageRecord wpr =
openWPRecords.FirstOrDefault(r => r.PerformanceNumFromStart == np.PerformanceNum &&
r.WorkPackageItemType == baseObject.SmartCoreObjectType.ItemId &&
r.DirectiveId == baseObject.ItemId);
if (wpr != null)
{
np.BlockedByPackage = _openPubWorkPackages.GetItemById(wpr.WorkPakageId);
}
}
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
#region Загрузка Котировочных ордеров
AnimatedThreadWorker.ReportProgress(95, "Load Quotations");
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
if (_openPubQuotations == null)
{
_openPubQuotations = new CommonCollection <RequestForQuotation>();
}
_openPubQuotations.Clear();
_openPubQuotations.AddRange(GlobalObjects.PurchaseCore.GetRequestForQuotation(CurrentAircraft, new[] { WorkPackageStatus.Opened, WorkPackageStatus.Published }));
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
AnimatedThreadWorker.ReportProgress(100, "Complete");
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
AnimatedThreadWorker.ReportProgress(0, "load components");
var resultCollection = new ComponentCollection();
_preResultDirectiveArray.Clear();
_resultDirectiveArray.Clear();
_removedComponents.Clear();
_removedTransfers.Clear();
_waitRemoveConfirmComponents.Clear();
_waitRemoveConfirmTransfers.Clear();
_installedComponents.Clear();
_installedTransfers.Clear();
#region Загрузка всех компонентов
resultCollection = GlobalObjects.ComponentCore.GetSupplierProcessing();
//////////////////////////////////////////////////////
// проверка на установленные компоненты //
//////////////////////////////////////////////////////
var lastInstalledDetails = resultCollection.GetLastInstalledComponentsOnProcessing();
foreach (var component in lastInstalledDetails)
{
_installedComponents.Add(component);
_installedTransfers.Add(component.TransferRecords.GetLast());
//удаление данного компонента из коллекции
//т.к. его отображать не нужно
resultCollection.Remove(component);
}
//////////////////////////////////////////////////////
// проверка на удаленные компоненты //
//////////////////////////////////////////////////////
//извлечение из базы данных всех записей о перемещении
//компонентов с данного базового агрегата
var records = new TransferRecordCollection();
records.AddRange(GlobalObjects.TransferRecordCore.GetLastTransferRecordsFromSuppliers().ToArray());
records.AddRange(GlobalObjects.TransferRecordCore.GetLastTransferRecordsFromSpecialist().ToArray());
foreach (var record in records)
{
//загрузка и БД детали, которой пренадлежит данная запись о перемещении
var component = GlobalObjects.ComponentCore.GetComponentById(record.ParentId);
if (component == null)
{
continue;
}
if (record.DODR)
{
//если перемещение подтверждено, то деталь записывается в "перемещенные"
//окна "TransferedDetails"
if (_removedComponents.CompareAndAdd(component))
{
_removedTransfers.Add(record);
}
}
else
{
//если перемещение не подтверждено, то деталь записывается в
//"ожидабщие подтверждения" окна "TransferedDetails"
if (_waitRemoveConfirmComponents.CompareAndAdd(component))
{
_waitRemoveConfirmTransfers.Add(record);
}
}
}
#endregion
#region Слияние компонентов в одну коллекцию
AnimatedThreadWorker.ReportProgress(40, "calculation of components");
foreach (var component in resultCollection)
{
_preResultDirectiveArray.Add(component);
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
AdditionalFilterItems(_preResultDirectiveArray, _resultDirectiveArray);
AnimatedThreadWorker.ReportProgress(100, "calculation over");
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
_initialDirectiveArray.Clear();
_resultDirectiveArray.Clear();
AnimatedThreadWorker.ReportProgress(0, "load directives");
try
{
if (_currentForecast == null)
{
var aircrafts = GlobalObjects.AircraftsCore.GetAllAircrafts();
foreach (var aircraft in aircrafts)
{
_initialDirectiveArray.AddRange(GlobalObjects.DirectiveCore.GetDeferredItems(null, aircraft));
}
}
else
{
AnimatedThreadWorker.ReportProgress(20, "calculation directives");
GlobalObjects.AnalystCore.GetDirectives(_currentForecast, _currentPrimaryDirectiveType);
DirectiveCollection dirC = _currentForecast.DirectiveCollections[_currentPrimaryDirectiveType];
foreach (Directive directive in dirC)
{
_initialDirectiveArray.Add(directive);
}
}
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while loading directives", ex);
}
AnimatedThreadWorker.ReportProgress(40, "filter directives");
if (_adType != ADType.None)
{
List <Directive> forDeleting =
_initialDirectiveArray.Where(primaryDirective => primaryDirective.ADType != _adType).ToList();
foreach (Directive directive in forDeleting)
{
_initialDirectiveArray.Remove(_initialDirectiveArray.GetItemById(directive.ItemId));
}
}
#region Калькуляция состояния директив
AnimatedThreadWorker.ReportProgress(60, "calculation of directives");
foreach (Directive pd in _initialDirectiveArray)
{
//GlobalObjects.PerformanceCalculator.GetNextPerformance(pd);
GlobalObjects.MTOPCalculator.CalculateDirectiveNew(pd);
}
AnimatedThreadWorker.ReportProgress(70, "filter directives");
FilterItems(_initialDirectiveArray, _resultDirectiveArray);
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
#region Сравнение с рабочими пакетами
AnimatedThreadWorker.ReportProgress(90, "comparison with the Work Packages");
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
if (_openPubWorkPackages == null)
{
_openPubWorkPackages = new CommonCollection <WorkPackage>();
}
_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);
}
foreach (Directive task in _resultDirectiveArray)
{
if (task == null || task.NextPerformances == null || task.NextPerformances.Count <= 0)
{
continue;
}
//Проход по всем след. выполнениям чека и записям в рабочих пакетах
//для поиска перекрывающихся выполнений
List <NextPerformance> performances = task.NextPerformances;
foreach (NextPerformance np in performances)
{
//поиск записи в рабочих пакетах по данному чеку
//чей номер группы выполнения (по записи) совпадает с расчитанным
WorkPackageRecord wpr =
openWPRecords.Where(r => r.PerformanceNumFromStart == np.PerformanceNum &&
r.WorkPackageItemType == task.SmartCoreObjectType.ItemId &&
r.DirectiveId == task.ItemId).FirstOrDefault();
if (wpr != null)
{
np.BlockedByPackage = _openPubWorkPackages.GetItemById(wpr.WorkPakageId);
}
}
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
#region Загрузка Котировочных ордеров
AnimatedThreadWorker.ReportProgress(95, "Load Quotations");
//загрузка рабочих пакетов для определения
//перекрытых ими выполнений задач
if (_openPubQuotations == null)
{
_openPubQuotations = new CommonCollection <RequestForQuotation>();
}
_openPubQuotations.Clear();
_openPubQuotations.AddRange(GlobalObjects.PurchaseCore.GetRequestForQuotation(CurrentAircraft, new[] { WorkPackageStatus.Opened, WorkPackageStatus.Published }));
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
AnimatedThreadWorker.ReportProgress(100, "Complete");
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
_initialDirectiveArray.Clear();
_preResultDirectiveArray.Clear();
_resultDirectiveArray.Clear();
if (!string.IsNullOrEmpty(TextBoxFilter.Text))
{
ComponentCollection preResult = new ComponentCollection();
ComponentCollection componentCollection = new ComponentCollection();
var temp = GlobalObjects.ComponentCore.GetComponentsAll(TextBoxFilter.Text).ToArray();
foreach (var component in temp)
{
var a = GlobalObjects.AircraftsCore.GetAircraftById(component.ParentBaseComponent?.ParentAircraftId ?? -1);
if (a != null)
{
componentCollection.Add(component);
}
}
var ids = new List <int>();
foreach (var component in componentCollection)
{
var lastTr = component.TransferRecords.GetLast();
if (lastTr?.DestinationObjectType == SmartCoreType.BaseComponent)
{
component.ParentBaseComponent = GlobalObjects.ComponentCore.GetBaseComponentById(lastTr.DestinationObjectId);
}
foreach (var componentDirective in component.ComponentDirectives)
{
foreach (var items in componentDirective.ItemRelations.Where(i =>
i.FirtsItemTypeId == SmartCoreType.MaintenanceDirective.ItemId ||
i.SecondItemTypeId == SmartCoreType.MaintenanceDirective.ItemId))
{
ids.Add(componentDirective.IsFirst == true ? items.SecondItemId : items.FirstItemId);
}
}
}
var mpd = GlobalObjects.MaintenanceCore.GetMaintenanceDirectiveList(ids);
foreach (var component in componentCollection)
{
foreach (var componentDirective in component.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 = mpd.FirstOrDefault(i => i.ItemId == id);
}
}
}
AnimatedThreadWorker.ReportProgress(50, "filter components");
InitialFilterItems(componentCollection, _initialDirectiveArray);
preResult.Clear();
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#region Калькуляция состояния компонентов
AnimatedThreadWorker.ReportProgress(70, "calculation of components");
var lldData = GlobalObjects.CasEnvironment.Loader
.GetObjectList <ComponentLLPCategoryData>(new ICommonFilter[]
{
new CommonFilter <int>(ComponentLLPCategoryData.ComponentIdProperty,
SmartCore.Filters.FilterType.In, _initialDirectiveArray.Select(i => i.ItemId).ToArray()),
});
var llpchangeRec = GlobalObjects.CasEnvironment.Loader
.GetObjectList <ComponentLLPCategoryChangeRecord>(new ICommonFilter[]
{
new CommonFilter <int>(ComponentLLPCategoryChangeRecord.ParentIdProperty,
SmartCore.Filters.FilterType.In, _initialDirectiveArray.Select(i => i.ItemId).ToArray()),
});
foreach (Component detail in _initialDirectiveArray)
{
detail.LLPData.Clear();
detail.LLPData.AddRange(lldData.Where(i => i.ComponentId == detail.ItemId));
detail.ChangeLLPCategoryRecords.Clear();
detail.ChangeLLPCategoryRecords.AddRange(llpchangeRec.Where(i => i.ParentId == detail.ItemId));
GlobalObjects.MTOPCalculator.CalculateDirectiveNew(detail);
_preResultDirectiveArray.Add(detail);
foreach (ComponentDirective detailDirective in detail.ComponentDirectives)
{
GlobalObjects.MTOPCalculator.CalculateDirectiveNew(detailDirective);
_preResultDirectiveArray.Add(detailDirective);
}
}
AdditionalFilterItems(_preResultDirectiveArray, _resultDirectiveArray);
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
AnimatedThreadWorker.ReportProgress(100, "Complete");
}
}
