/// <summary>
/// Создаёт экземпляр элемента управления, отображающего список неснижаемого запаса на складе
/// </summary>
/// <param name="currentStore">Склад, которому принадлежат записи о неснижаемом запасе</param>
/// <param name="resultCollection"></param>
/// <param name="beginGroup">Описывает своиство класса StockDetailInfo, по которому нужно сделать первичную группировку</param>
public ShouldBeOnStockListScreen(Store currentStore, ComponentCollection resultCollection,
PropertyInfo beginGroup = null)
: base(typeof(StockComponentInfo), beginGroup)
{
if (currentStore == null)
{
throw new ArgumentNullException("currentStore");
}
_resultCollection = resultCollection;
CurrentStore = currentStore;
StatusTitle = "Should be on Stock";
}
/// <summary>
/// Производит очистку ресурсов страницы
/// </summary>
public override void DisposeScreen()
{
CancelAsync();
if (_performanceControl != null)
{
_performanceControl.CancelAsync();
}
if (_complianceControl != null)
{
_complianceControl.CalcelAsync();
}
AnimatedThreadWorker.Dispose();
if (_itemPrintReportHistory != null)
{
_itemPrintReportHistory.Dispose();
}
if (_itemPrintReportRecords != null)
{
_itemPrintReportRecords.Dispose();
}
if (_itemPrintReportEngineRecords != null)
{
_itemPrintReportEngineRecords.Dispose();
}
if (_buttonPrintMenuStrip != null)
{
_buttonPrintMenuStrip.Dispose();
}
_currentComponent = null;
if (_baseComponentComponents != null)
{
_baseComponentComponents.Clear();
}
_baseComponentComponents = null;
Dispose(true);
}
private void ToolStripMenuItemOpenClick(object sender, EventArgs e)
{
ComponentCollection selected = new ComponentCollection();
foreach (BaseEntityObject o in _directivesViewer.SelectedItems)
{
if (o is ComponentDirective)
{
selected.CompareAndAdd(((ComponentDirective)o).ParentComponent);
}
if (o is Component)
{
selected.CompareAndAdd((Component)o);
}
}
foreach (Component t in selected)
{
var refE = new ReferenceEventArgs();
DisplayerParams dp = null;
string regNumber = "";
if (t is BaseComponent)
{
if (((BaseComponent)t).BaseComponentType.ItemId == 4)
{
regNumber = t.ToString();
}
else
{
dp = ScreenAndFormManager.GetBaseComponentScreen((BaseComponent)t);
}
}
else
{
dp = ScreenAndFormManager.GetComponentScreen(t);
}
refE.SetParameters(dp);
InvokeDisplayerRequested(refE);
}
}
private void ButtonAddClick(object sender, EventArgs e)
{
if (listViewTasksForSelect.SelectedItems.Count == 0)
{
return;
}
if (_maintenanceDirective.IsFirst == null)
{
_maintenanceDirective.NormalizeItemRelations();
comboBoxRelationType.SelectedValue = ItemRelationHelper.ConvertBLItemRelationToUIITem(_maintenanceDirective.WorkItemsRelationType, false);
}
//коллекция элементов которые нужно добавить в список, содержащий все связные задачи
var itemsToInsert = new CommonCollection <BaseEntityObject>();
//Список выбранных задач по компонентам для привязки
var selectedDirectives = listViewTasksForSelect.SelectedItems.OfType <ComponentDirective>().ToList();
//Коллекция выбранных компонентов для привязки
var selectedComponents = new ComponentCollection(listViewTasksForSelect.SelectedItems.OfType <Component>());
if (selectedComponents.Count == 0 && selectedDirectives.Count == 0)
{
return;
}
//список уже призязанных задач по компонетам
var bindedDirectives = listViewBindedTasks.SelectedItems.OfType <ComponentDirective>().ToList();
//Объединенный список выбранных и привязанных компонентов
var concatenatedDirectives = selectedDirectives.Concat(bindedDirectives);
foreach (ComponentDirective dd in concatenatedDirectives)
{
if (concatenatedDirectives.Count(d => d.ComponentId == dd.ComponentId) > 1)
{
//проверка, не выбраны ли 2 или более задач по одному компоненту для привязки
//т.к. MPD Item может быть привязан только к одной задаче каждого выбранного компонента
string parentComponent;
if (dd.ParentComponent != null)
{
parentComponent = dd.ParentComponent.SerialNumber;
}
else
{
parentComponent = "Component ID: " + dd.ComponentId;
}
MessageBox.Show("the MPD Item can not be bound to two or more tasks of a one component:" +
"\n" + parentComponent,
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
try
{
var singleItemRelation = dd.ItemRelations.SingleOrDefault();
if (singleItemRelation != null &&
!CheckThatItemHaveRelationsOnlyWithProvidedItem(dd.IsFirst.HasValue && dd.IsFirst.Value,
singleItemRelation, _maintenanceDirective.ItemId,
SmartCoreType.MaintenanceDirective.ItemId))
{
//Проверка не имеет ли выбранная задача по компоненту привязки к другой задаче
string parentComponent;
if (dd.ParentComponent != null)
{
parentComponent = dd.ParentComponent.SerialNumber;
}
else
{
parentComponent = "Component ID: " + dd.ComponentId;
}
MessageBox.Show("You can not select a task: " +
"\n" + parentComponent + " " + dd.DirectiveType +
"\n" + "because task already has a binding",
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
}
catch (InvalidOperationException)
{
ItemRelationHelper.ShowDialogIfItemLinksCountMoreThanOne($"Component {dd.PartNumber}", dd.ItemRelations.Count);
}
catch (Exception ex)
{
Program.Provider.Logger.Log(ex);
}
}
//Удаление из коллекции выбранных компонентов тех компонентов,
//задачи по которым содержатся в коллекции selectedDirectives
foreach (ComponentDirective directive in selectedDirectives)
{
selectedComponents.RemoveById(directive.ComponentId);
}
//Производится привязка выбранных задач по компонентам к выполнению данного MPD
foreach (ComponentDirective dd in selectedDirectives.Where(d => d.ItemRelations.Count == 0))
{
try
{
//TODO:(Evgenii Babak) проверить использования свойств
dd.MPDTaskType = _maintenanceDirective.WorkType;
dd.FaaFormFile = _maintenanceDirective.TaskCardNumberFile;
dd.FaaFormFileId = _maintenanceDirective.TaskCardNumberFile != null
? _maintenanceDirective.TaskCardNumberFile.ItemId
: -1;
AddComponentAndDirectiveToBindedItemsCollections(dd.ParentComponent, dd, itemsToInsert, _bindedItems, _newBindedItems);
//Удаление задачи по компоненту из элемента управления содержащего список всех задач
listViewTasksForSelect.RemoveItem(dd);
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while save bind task record", ex);
}
}
//Производится привязка выбранных компонентов к выполнению данного MPD
//В результате предыдущих манипуляций в коллекции выбранных компонентов
//должны остаться компоненты у которых либо нет задач, либо не одна не была выбрана
foreach (Component selectedComponent in selectedComponents)
{
if (selectedComponent.ComponentDirectives.Count == 0)
{
//Выбранный компонент не имеет задач.
//Для привязки необходимо создать задачу
if (MessageBox.Show("Component:" +
"\n" + selectedComponent +
"\n" + "has no directives!" +
"\n" +
"\n" + "Create and save directive for this MPD Item?",
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation)
!= DialogResult.Yes)
{
continue;
}
}
else if (selectedComponent.ComponentDirectives.All(dd => dd.ItemRelations.Any(i => !CheckThatItemHaveRelationsOnlyWithProvidedItem(dd.IsFirst.HasValue && dd.IsFirst.Value,
i,
_maintenanceDirective.ItemId,
SmartCoreType.MaintenanceDirective.ItemId))))
{
//Выбранный компонент имеет задачи
//Но все они привязаны к другим задачам
if (MessageBox.Show("Component:" +
"\n" + selectedComponent +
"\n" + "has directives, but they are bound to other tasks" +
"\n" +
"\n" + "Create and save directive for this MPD Item?",
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation)
!= DialogResult.Yes)
{
continue;
}
}
else if (selectedComponent.ComponentDirectives.Count > 0)
{
//Выбранный компонент имеет задачи
//Но ни одна из его задач не была выбрана для привязки
//Необходимо задать вопрос: создать ли овую задачу для привязки
//или пользователь должен быбрать задачу для привязки сам из имеющихся задач по компоненту
if (MessageBox.Show("Component:" +
"\n" + selectedComponent +
"\n" + "has a tasks, but none of them is selected for binding!" +
"\n" +
"\n" + "Create and save directive for this MPD Item, or You choose task to bind yourself" +
"\n" +
"\n" + "Yes - Create and Save directive" +
"\n" + "No - You choose task to bind yourself",
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation)
!= DialogResult.Yes)
{
continue;
}
}
try
{
var neComponentDirective = new ComponentDirective();
neComponentDirective.DirectiveType = (ComponentRecordType)ComponentRecordType.Items.GetByShortName(_maintenanceDirective.WorkType.ShortName);
neComponentDirective.ManHours = _maintenanceDirective.ManHours;
neComponentDirective.Cost = _maintenanceDirective.Cost;
neComponentDirective.Kits.Clear();
neComponentDirective.Kits.AddRange(_maintenanceDirective.Kits.ToArray());
neComponentDirective.Remarks = _maintenanceDirective.Remarks;
neComponentDirective.HiddenRemarks = _maintenanceDirective.HiddenRemarks;
neComponentDirective.MPDTaskType = _maintenanceDirective.WorkType;
neComponentDirective.FaaFormFile = _maintenanceDirective.TaskCardNumberFile;
neComponentDirective.FaaFormFileId = _maintenanceDirective.TaskCardNumberFile != null
? _maintenanceDirective.TaskCardNumberFile.ItemId
: -1;
neComponentDirective.ComponentId = selectedComponent.ItemId;
neComponentDirective.ParentComponent = selectedComponent;
MaintenanceDirectiveThreshold mdt = _maintenanceDirective.Threshold;
ComponentDirectiveThreshold ddt = neComponentDirective.Threshold;
ddt.FirstPerformanceSinceNew = mdt.FirstPerformanceSinceNew;
ddt.FirstNotification = mdt.FirstNotification;
ddt.RepeatInterval = mdt.RepeatInterval;
ddt.RepeatNotification = mdt.RepeatNotification;
ddt.FirstPerformanceConditionType = mdt.FirstPerformanceConditionType;
AddComponentAndDirectiveToBindedItemsCollections(selectedComponent, neComponentDirective, itemsToInsert, _bindedItems, _newBindedItems);
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while save bind task record", ex);
}
}
listViewBindedTasks.InsertItems(itemsToInsert);
}
private void AnimatedThreadWorkerDoLoad(object sender, DoWorkEventArgs e)
{
if (_maintenanceDirective == null || _currentAircraft == null)
{
e.Cancel = true;
return;
}
if (_bindedItems == null)
{
_bindedItems = new CommonCollection <BaseEntityObject>();
}
_bindedItems.Clear();
if (_itemsForSelect == null)
{
_itemsForSelect = new CommonCollection <BaseEntityObject>();
}
_itemsForSelect.Clear();
_animatedThreadWorker.ReportProgress(0, "load binded tasks");
ComponentCollection dc = null;
try
{
dc = GlobalObjects.ComponentCore.GetComponents(_currentAircraft.ItemId);
var baseComp = GlobalObjects.ComponentCore.GetAicraftBaseComponents(_currentAircraft.ItemId);
var directivesIds = baseComp.SelectMany(i => i.ComponentDirectives).Select(d => d.ItemId);
var itemsRelations = GlobalObjects.ItemsRelationsDataAccess.GetRelations(directivesIds,
SmartCoreType.ComponentDirective.ItemId);
if (itemsRelations.Count > 0)
{
foreach (var directive in baseComp.SelectMany(i => i.ComponentDirectives))
{
directive.ItemRelations.Clear();
directive.ItemRelations.AddRange(itemsRelations.Where(i =>
i.FirstItemId == directive.ItemId ||
i.SecondItemId ==
directive.ItemId)); //TODO:(Evgenii Babak)не использовать Where
}
}
dc.AddRange(baseComp);
//Определение списка привязанных задач и компонентов
List <ComponentDirective> bindedDirectives =
dc.SelectMany(d => d.ComponentDirectives.Where(dd => dd.ItemRelations.IsAnyRelationWith(_maintenanceDirective)))
.ToList();
List <Component> bindedComponents =
bindedDirectives.Where(dd => dd.ParentComponent != null)
.Select(dd => dd.ParentComponent)
.Distinct()
.ToList();
_bindedItems.AddRange(bindedDirectives.ToArray());
_bindedItems.AddRange(bindedComponents.ToArray());
//Определение списка непривязанных задач и компонентов
List <ComponentDirective> directivesForSelect =
dc.SelectMany(d => d.ComponentDirectives.Where(dd => dd.ItemRelations.Count == 0 || !dd.ItemRelations.IsAllRelationWith(_maintenanceDirective)))
.ToList();
List <Component> componentsForSelect = dc.ToList();
_itemsForSelect.AddRange(directivesForSelect.ToArray());
_itemsForSelect.AddRange(componentsForSelect.ToArray());
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while load Maintenance directive bing details records", ex);
}
if (_animatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_animatedThreadWorker.ReportProgress(50, "calculation of Components");
if (dc != null)
{
foreach (var component in dc)
{
GlobalObjects.PerformanceCalculator.GetNextPerformance(component);
foreach (var dd in component.ComponentDirectives)
{
GlobalObjects.PerformanceCalculator.GetNextPerformance(dd);
}
}
dc.Clear();
}
if (_animatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_animatedThreadWorker.ReportProgress(75, "calculate directives for select");
if (_animatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_animatedThreadWorker.ReportProgress(100, "binding 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");
}
}
protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
{
GlobalObjects.ComponentCore.ReloadActualStateRecordForBaseComponents(_currentComponent.ParentAircraftId);
#region Загрузка элементов
AnimatedThreadWorker.ReportProgress(0, "load component");
try
{
if (_currentComponent.ItemId > 0)
{
if (_currentComponent is BaseComponent)
{
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_currentComponent = GlobalObjects.ComponentCore.GetFullBaseComponent(_currentComponent.ItemId);
var types = new[] { SmartCoreType.BaseComponent.ItemId, SmartCoreType.ComponentDirective.ItemId };
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
//Загрузка документов
var documents = GlobalObjects.CasEnvironment.Loader.GetObjectList <Document>(new ICommonFilter[]
{
new CommonFilter <int>(Document.ParentIdProperty, _currentComponent.ItemId),
new CommonFilter <int>(Document.ParentTypeIdProperty, FilterType.In, types)
});
_currentComponent.ChangeLLPCategoryRecords.Clear();
_currentComponent.ChangeLLPCategoryRecords
.AddRange(GlobalObjects.CasEnvironment.NewLoader
.GetObjectList <ComponentLLPCategoryChangeRecordDTO, ComponentLLPCategoryChangeRecord>(
new Filter("ParentId", _currentComponent.ItemId), true));
_workParams = GlobalObjects.CasEnvironment.NewLoader
.GetObjectList <ComponentWorkInRegimeParamDTO, ComponentWorkInRegimeParams>(
new List <Filter>()
{
new Filter("ComponentId", _currentComponent.ItemId)
});
if (documents.Count > 0)
{
var crs = GlobalObjects.CasEnvironment.GetDictionary <DocumentSubType>()
.GetByFullName("Component CRS Form") as DocumentSubType;
var shipping =
GlobalObjects.CasEnvironment.GetDictionary <DocumentSubType>()
.GetByFullName("Shipping document") as DocumentSubType;
var docShipping = documents.FirstOrDefault(d =>
d.ParentId == _currentComponent.ItemId &&
d.ParentTypeId == SmartCoreType.BaseComponent.ItemId &&
d.DocumentSubType.ItemId == shipping.ItemId);
if (docShipping != null)
{
_currentComponent.Document = docShipping;
_currentComponent.Document.Parent = _currentComponent;
}
var docCrs = documents.FirstOrDefault(d =>
d.ParentId == _currentComponent.ItemId &&
d.ParentTypeId == SmartCoreType.BaseComponent.ItemId &&
d.DocumentSubType.ItemId == crs.ItemId);
if (docCrs != null)
{
_currentComponent.DocumentCRS = docCrs;
_currentComponent.DocumentCRS.Parent = _currentComponent;
}
}
if (_currentComponent.ComponentDirectives.Count > 0)
{
var directivesIds = _currentComponent.ComponentDirectives.Select(d => d.ItemId);
var itemsRelations = GlobalObjects.ItemsRelationsDataAccess.GetRelations(directivesIds,
SmartCoreType.ComponentDirective.ItemId);
foreach (var directive in _currentComponent.ComponentDirectives)
{
var docCd = documents.FirstOrDefault(d =>
d.ParentId == directive.ItemId &&
d.ParentTypeId == SmartCoreType.ComponentDirective.ItemId);
if (docCd != null)
{
directive.Document = docCd;
directive.Document.Parent = directive;
}
if (itemsRelations.Count > 0)
{
//Сделан такой костыль для того что был когда то баг что записи не грузились и создавалось несколько связок и вылетало предупреждение
if (itemsRelations.Count > 1)
{
var max = itemsRelations.Max(i => i.Updated);
var deleted = new List <ItemsRelation>();
foreach (var relation in itemsRelations)
{
if (max.Equals(relation.Updated))
{
continue;
}
GlobalObjects.NewKeeper.Delete(relation);
deleted.Add(relation);
}
foreach (var itemsRelation in deleted)
{
itemsRelations.Remove(itemsRelation);
}
}
directive.ItemRelations.Clear();
directive.ItemRelations.AddRange(itemsRelations.Where(i =>
i.FirstItemId == directive.ItemId ||
i.SecondItemId ==
directive.ItemId)); //TODO:(Evgenii Babak)не использовать Where
}
}
}
}
else
{
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
_currentComponent = GlobalObjects.ComponentCore.GetComponentById(_currentComponent.ItemId);
}
}
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while loading component", ex);
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
#region Калькуляция состояния директив
AnimatedThreadWorker.ReportProgress(40, "calculation of component");
var conditionState = GlobalObjects.PerformanceCalculator.GetConditionState(_currentComponent);
foreach (var directive in _currentComponent.ComponentDirectives)
{
GlobalObjects.MTOPCalculator.CalculateDirectiveNew(directive);
}
Invoke(new Action <ConditionState>(cs => statusControl.ConditionState = cs), conditionState);
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
if (_baseComponentHeaderControl != null && _currentComponent is BaseComponent)
{
#region Проверка состояния компонентов
if (_baseComponentComponents != null)
{
_baseComponentComponents.Clear();
}
_baseComponentComponents = GlobalObjects.ComponentCore.GetComponents((BaseComponent)_currentComponent);
if (_baseComponentComponents.Count == 0)
{
_baseComponentHeaderControl.ComponentsStatus = Statuses.NotActive;
_baseComponentHeaderControl.ComponentsLLPStatus = Statuses.NotActive;
}
else
{
#region проверка Component Status
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
AnimatedThreadWorker.ReportProgress(47, "Check Components: Component Status");
Statuses allComponentStatus = Statuses.NotActive;
foreach (Component detail in _baseComponentComponents)
{
ConditionState directiveCond = GlobalObjects.PerformanceCalculator.GetConditionState(detail);
if (directiveCond == ConditionState.NotEstimated && allComponentStatus == Statuses.NotActive)
{
allComponentStatus = Statuses.NotActive;
}
if (directiveCond == ConditionState.Satisfactory && allComponentStatus != Statuses.Notify)
{
allComponentStatus = Statuses.Satisfactory;
}
if (directiveCond == ConditionState.Notify)
{
allComponentStatus = Statuses.Notify;
}
if (directiveCond == ConditionState.Overdue)
{
allComponentStatus = Statuses.NotSatisfactory;
break;
}
}
_baseComponentHeaderControl.ComponentsStatus = allComponentStatus;
#endregion
#region проверка LLP Status
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
AnimatedThreadWorker.ReportProgress(51, "Check Components: LLP Status");
IEnumerable <Component> llp = _baseComponentComponents
.Where(d => d.ParentBaseComponent != null && d.ParentBaseComponent.BaseComponentTypeId == BaseComponentType.Engine.ItemId);//TODO:(Evgenii Babak) заменить на использование ComponentCore
Statuses bdComponentLLPStatus = Statuses.NotActive;
foreach (Component llpDetail in llp)
{
ConditionState directiveCond = GlobalObjects.PerformanceCalculator.GetConditionState(llpDetail);
if (directiveCond == ConditionState.NotEstimated && bdComponentLLPStatus == Statuses.NotActive)
{
bdComponentLLPStatus = Statuses.NotActive;
}
if (directiveCond == ConditionState.Satisfactory && bdComponentLLPStatus != Statuses.Notify)
{
bdComponentLLPStatus = Statuses.Satisfactory;
}
if (directiveCond == ConditionState.Notify)
{
bdComponentLLPStatus = Statuses.Notify;
}
if (directiveCond == ConditionState.Overdue)
{
bdComponentLLPStatus = Statuses.NotSatisfactory;
break;
}
}
_baseComponentHeaderControl.ComponentsStatus = bdComponentLLPStatus;
#endregion
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
#region Проверка состояния директив
AnimatedThreadWorker.ReportProgress(55, "Check Directives");
DirectiveCollection directives = GlobalObjects.DirectiveCore.GetDirectives((BaseComponent)_currentComponent, DirectiveType.All);
if (directives.Count == 0)
{
_baseComponentHeaderControl.ADStatus = Statuses.NotActive;
_baseComponentHeaderControl.EOStatus = Statuses.NotActive;
_baseComponentHeaderControl.SBStatus = Statuses.NotActive;
}
else
{
#region проверка ADStatus
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
AnimatedThreadWorker.ReportProgress(55, "Check Directives: AD Status");
Statuses allADStatus = Statuses.NotActive;
IEnumerable <Directive> ads =
directives.Where(p => p.DirectiveType == DirectiveType.AirworthenessDirectives);
foreach (Directive primaryDirective in ads)
{
ConditionState directiveCond = GlobalObjects.PerformanceCalculator.GetConditionState(primaryDirective);
if (directiveCond == ConditionState.NotEstimated && allADStatus == Statuses.NotActive)
{
allADStatus = Statuses.NotActive;
}
if (directiveCond == ConditionState.Satisfactory && allADStatus != Statuses.Notify)
{
allADStatus = Statuses.Satisfactory;
}
if (directiveCond == ConditionState.Notify)
{
allADStatus = Statuses.Notify;
}
if (directiveCond == ConditionState.Overdue)
{
allADStatus = Statuses.NotSatisfactory;
break;
}
}
_baseComponentHeaderControl.ADStatus = allADStatus;
#endregion
#region проверка EO Status
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
AnimatedThreadWorker.ReportProgress(61, "Check Directives: Engineering order Status");
Statuses allEOStatus = Statuses.NotActive;
IEnumerable <Directive> eos =
directives.Where(p => p.DirectiveType == DirectiveType.EngineeringOrders ||
p.EngineeringOrders != "" ||
p.EngineeringOrderFile != null);
foreach (Directive primaryDirective in eos)
{
ConditionState directiveCond = GlobalObjects.PerformanceCalculator.GetConditionState(primaryDirective);
if (directiveCond == ConditionState.NotEstimated && allEOStatus == Statuses.NotActive)
{
allEOStatus = Statuses.NotActive;
}
if (directiveCond == ConditionState.Satisfactory && allEOStatus != Statuses.Notify)
{
allEOStatus = Statuses.Satisfactory;
}
if (directiveCond == ConditionState.Notify)
{
allEOStatus = Statuses.Notify;
}
if (directiveCond == ConditionState.Overdue)
{
allEOStatus = Statuses.NotSatisfactory;
break;
}
}
_baseComponentHeaderControl.EOStatus = allEOStatus;
#endregion
#region проверка SB Status
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
AnimatedThreadWorker.ReportProgress(66, "Check Directives: Service bulletins Status");
Statuses allSBStatus = Statuses.NotActive;
IEnumerable <Directive> sbs =
directives.Where(p => p.DirectiveType == DirectiveType.SB ||
p.ServiceBulletinNo != "" ||
p.ServiceBulletinFile != null);
foreach (Directive primaryDirective in sbs)
{
ConditionState directiveCond = GlobalObjects.PerformanceCalculator.GetConditionState(primaryDirective);
if (directiveCond == ConditionState.NotEstimated && allSBStatus == Statuses.NotActive)
{
allSBStatus = Statuses.NotActive;
}
if (directiveCond == ConditionState.Satisfactory && allSBStatus != Statuses.Notify)
{
allSBStatus = Statuses.Satisfactory;
}
if (directiveCond == ConditionState.Notify)
{
allSBStatus = Statuses.Notify;
}
if (directiveCond == ConditionState.Overdue)
{
allSBStatus = Statuses.NotSatisfactory;
break;
}
}
_baseComponentHeaderControl.SBStatus = allSBStatus;
#endregion
}
//Очистка коллекции для предотвращения утечек памяти
directives.Clear();
#endregion
}
if (AnimatedThreadWorker.CancellationPending)
{
e.Cancel = true;
return;
}
#endregion
#region Сравнение с рабочими пакетами
AnimatedThreadWorker.ReportProgress(90, "comparison with the Work Packages");
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");
}
