public DirectiveRecordView(DirectiveRecord source)
{
if (source == null)
{
return;
}
Id = source.Id;
NumGroup = source.NumGroup;
RecordTypeID = source.RecordTypeID;
ParentID = source.ParentID;
ParentTypeId = source.ParentTypeId;
Remarks = source.Remarks;
RecordDate = source.RecordDate;
WorkPackageID = source.WorkPackageID;
Dispatched = source.Dispatched;
Completed = source.Completed;
Reference = source.Reference;
ODR = source.ODR;
MaintenanceOrganization = source.MaintenanceOrganization;
MaintenanceDirectiveRecordId = source.MaintenanceDirectiveRecordId;
MaintenanceCheckRecordId = source.MaintenanceCheckRecordId;
PerformanceNum = source.PerformanceNum.HasValue ? source.PerformanceNum.Value : 0;
IsControlPoint = source.IsControlPoint;
ComplianceCheckName = source.ComplianceCheckName;
OnLifelength = Lifelength.ConvertFromByteArray(source.OnLifelength);
Unused = Lifelength.ConvertFromByteArray(source.Unused);
CalculatedPerformanceSource = Lifelength.ConvertFromByteArray(source.CalculatedPerformanceSource);
Overused = Lifelength.ConvertFromByteArray(source.Overused);
}
private void CreateAndSavePerformanceForBindedItems(ComponentDirective componentDirective, DirectiveRecord directiveRecord)
{
if (componentDirective.ParentComponent != null && componentDirective.ParentComponent.ParentAircraftId > 0)
{
var bindedItem = _bindedItemsCore.GetBindedItemsFor(componentDirective.ParentComponent.ParentAircraftId, componentDirective).SingleOrDefault();
if (bindedItem is MaintenanceDirective)
{
var mpd = bindedItem as MaintenanceDirective;
var newPerformance = new DirectiveRecord(directiveRecord)
{
MaintenanceDirectiveRecordId = -1,
//TODO:(Evgenii Babak) Выяснить почему при создании записи берем наработку на начало дня, но в отчетах, для записей о выполнении пересчитываем наработку, и выводим наработку на конец дня
OnLifelength = _calculator.GetFlightLifelengthOnStartOfDay(mpd.ParentBaseComponent, directiveRecord.RecordDate),
Parent = mpd,
ParentId = mpd.ItemId
};
_newKeeper.Save(newPerformance, false);
directiveRecord.MaintenanceDirectiveRecordId = newPerformance.ItemId;
_newKeeper.Save(directiveRecord);
}
}
}
public void SmartCoreFileTest_DirectiveRecord()
{
var enviroment = GetEnviroment();
var directiveRecord = new DirectiveRecord
{
AttachedFile = new AttachedFile {
FileName = "AttachedFile.test"
},
Parent = new Document()
};
enviroment.NewKeeper.Save(directiveRecord, true);
Assert.IsTrue(directiveRecord.ItemId > 0, "ItemId должен быть больше 0");
var forCheck = enviroment.NewLoader.GetObject <DirectiveRecordDTO, DirectiveRecord>(new Filter("ItemId", directiveRecord.ItemId), true);
enviroment.NewKeeper.Delete(directiveRecord);
Assert.IsTrue(forCheck != null, "значение не должно быть null");
Assert.AreEqual(forCheck.Files.Count, 1, "Кол-во файлов должно быть 1");
Assert.IsTrue(forCheck.AttachedFile != null);
Assert.AreEqual(forCheck.AttachedFile.FileName, "AttachedFile.test");
}
public void Export()
{
var env = GetEnviroment();
var aircraftCore = new AircraftsCore(env.Loader, env.NewKeeper, env.NewLoader);
var itemRelationCore = new ItemsRelationsDataAccess(env);
var componentCore = new ComponentCore(env, env.Loader, env.NewLoader, env.NewKeeper, aircraftCore, itemRelationCore);
var mpdCore = new MaintenanceCore(env, env.NewLoader, env.NewKeeper, itemRelationCore, aircraftCore);
var aircraftFlightCore = new AircraftFlightCore(env, env.Loader, env.NewLoader, null, null, componentCore, null, aircraftCore);
var calc = new Calculator(env, componentCore, aircraftFlightCore, aircraftCore);
aircraftCore.LoadAllAircrafts();
var aircraft = aircraftCore.GetAircraftById(2316);
var mpds = mpdCore.GetMaintenanceDirectives(aircraft);
int q = 0;
var ds = ExcelToDataTableUsingExcelDataReader(@"D:\MPD.xlsx");
foreach (DataTable table in ds.Tables)
{
foreach (DataRow row in table.Rows)
{
var mpd = mpds.FirstOrDefault(i => i.TaskNumberCheck == row[0].ToString());
if (mpd == null)
{
continue;
}
var record = new DirectiveRecord
{
Parent = mpd,
ParentId = mpd.ItemId,
OnLifelength = new Lifelength(),
};
if (int.TryParse(row[2].ToString(), out var hour))
{
record.OnLifelength.Hours = hour;
}
if (int.TryParse(row[3].ToString(), out var cycle))
{
record.OnLifelength.Cycles = cycle;
}
if (DateTime.TryParse(row[4].ToString(), out var date))
{
record.RecordDate = date;
}
var res = calc.GetFlightLifelengthOnStartOfDay(aircraft, date);
if ((hour > 0 || cycle > 0) && date != DateTime.MinValue)
{
record.OnLifelength.Days = res.Days;
//Trace.WriteLine(row[0].ToString());
env.NewKeeper.Save(record);
}
}
}
}
///<summary>
///</summary>
///<param name="currentDirective"></param>
///<param name="currentRecord"></param>
public DirectiveComplianceDialog(IDirective currentDirective, DirectiveRecord currentRecord)
: this()
{
_currentDirective = currentDirective;
_currentDirectiveRecord = currentRecord;
_animatedThreadWorker.DoWork += AnimatedThreadWorkerDoLoad;
_animatedThreadWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerLoadCompleted;
}
/// <summary>
/// Создает форму для добавления записи Compliance работе агрегата
/// </summary>
/// <param name="detail">Агрегат</param>
public ComplianceForm(AbstractDetail detail)
{
currentDetail = detail;
currentRecord = new DirectiveRecord();
mode = ScreenMode.Add;
InitializeComponent();
UpdateDetailDirectiveList();
UpdateInformation();
}
/// <summary>
/// Создает форму для добавления записи Compliance директиве
/// </summary>
/// <param name="directive">Директива</param>
public ComplianceForm(BaseDetailDirective directive)
{
currentDirective = directive;
currentRecord = new DirectiveRecord();
mode = ScreenMode.Add;
InitializeComponent();
UpdateWorkTypes();
UpdateInformation();
}
public Lifelength GetFlightLifelengthOnEndOfDay(DirectiveRecord record)
{
object parent = record.Parent;
if (parent == null)
{
throw new Exception($"1537: Performance record {record.RecordType} ({record.ItemId}:{record.ParentId}) referst to null object");
}
//
var date = record.RecordDate;
// Обрабатываем объекты
if (parent is ComponentDirective componentDirective)
{
// Запись принадлежит работе по агрегату
// Агрегат / Базовый агрегат
if (componentDirective.ParentComponent.IsBaseComponent)
{
return(GetFlightLifelengthOnEndOfDay((BaseComponent)componentDirective.ParentComponent, date));
}
if (!componentDirective.ParentComponent.IsBaseComponent)
{
return(GetFlightLifelengthOnEndOfDay(componentDirective.ParentComponent, date));
}
throw new Exception($"1543: Can not get parent object for component directive {componentDirective.ItemId}");
}
if (parent is Directive directive1)
{
var bd = directive1.ParentBaseComponent;
if (bd == null)
{
throw new Exception($"1550: Parent object for directive {directive1.ItemId} is set to null");
}
return(GetFlightLifelengthOnEndOfDay(bd, date));
}
if (parent is MaintenanceDirective directive)
{
var a = directive.ParentBaseComponent;
if (a == null)
{
throw new Exception($"1550: Parent object for directive {directive.ItemId} is set to null");
}
return(GetFlightLifelengthOnEndOfDay(a, date));
}
if (parent is Procedure p)
{
var op = p.ParentOperator;
if (op == null)
{
throw new Exception($"1550: Parent object for directive {p.ItemId} is set to null");
}
return(GetFlightLifelengthOnEndOfDay(op, date));
}
throw new Exception($"1545: Can not recognize parent object {parent.GetType()} for record {record.RecordType} ({record.ItemId}:{record.ParentId})");
}
///<summary>
///</summary>
///<param name="currentDirective"></param>
///<param name="nextPerformance"></param>
public DirectiveComplianceDialog(IDirective currentDirective, NextPerformance nextPerformance)
: this()
{
_currentDirective = currentDirective;
_currentDirectiveRecord = DirectiveRecord.CreateInstance(nextPerformance);
_nextPerformance = nextPerformance;
_animatedThreadWorker.DoWork += AnimatedThreadWorkerDoLoad;
_animatedThreadWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerLoadCompleted;
}
private void AddListViewItem(AbstractRecord record, string[] subs, WorkPackage workPackage)
{
Color foreColor = Color.Black;
if (record is ActualStateRecord)
{
foreColor = Color.FromArgb(0, 122, 122, 122);
}
ListViewItem newItem = new ListViewItem(subs)
{
Group = listViewCompliance.Groups[1],
Tag = record,
ForeColor = foreColor
};
if (record is AbstractPerformanceRecord)
{
AbstractPerformanceRecord apr = (AbstractPerformanceRecord)record;
if (workPackage != null)
{
//запись о выполнении блокируется найденым пакетом
apr.DirectivePackage = workPackage;
newItem.BackColor = Color.FromArgb(Highlight.Grey.Color);
newItem.ToolTipText =
"Perform of the task:" + apr.Parent +
"\nadded by Work Package:" +
"\n" + apr.DirectivePackage.Title +
"\nTo remove a performance of task, you need to exclude task from this work package," +
"\nor delete the work package ";
}
else if (apr is DirectiveRecord)
{
DirectiveRecord dr = apr as DirectiveRecord;
if (dr.MaintenanceDirectiveRecordId > 0)
{
DirectiveRecord mdr = GlobalObjects.CasEnvironment.NewLoader.GetObjectById <DirectiveRecordDTO, DirectiveRecord>(dr.MaintenanceDirectiveRecordId);
if (mdr != null && mdr.ParentType == SmartCoreType.MaintenanceDirective)
{
MaintenanceDirective md = GlobalObjects.MaintenanceCore.GetMaintenanceDirective(mdr.ParentId);
if (md != null)
{
newItem.ToolTipText =
"Perform of the task:" + dr.WorkType +
"\nadded by MPD Item:" +
"\n" + md.TaskNumberCheck;
}
}
}
}
}
//listViewCompliance.Items.Insert(index, newItem);
listViewCompliance.Items.Add(newItem);
}
private void ButtonDeleteClick(object sender, EventArgs e)
{
if (listViewCompliance.SelectedItems.Count == 0 ||
!(listViewCompliance.SelectedItems[0].Tag is DirectiveRecord))
{
return;
}
DirectiveRecord record = (DirectiveRecord)listViewCompliance.SelectedItems[0].Tag;
if (record.DirectivePackage != null)
{
MessageBox.Show("Perform of the task:" + listViewCompliance.SelectedItems[0].Text +
"\nadded by Work Package:" +
"\n" + record.DirectivePackage.Title +
"\nTo remove a performance of task, you need to exclude task from this work package," +
"\nor delete the work package ",
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.OK,
MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button1);
return;
}
if (record.MaintenanceCheck != null)
{
MessageBox.Show("Perform of the task:" + listViewCompliance.SelectedItems[0].Text +
"\nadded by Maintenance check:" +
"\n" + record.MaintenanceCheck.Name +
"\nTo remove a performance of task, you need to exclude perform of task from perform of maintenance check," +
"\nor delete the perform of maintenance check ",
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.OK,
MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button1);
return;
}
switch (MessageBox.Show(@"Delete this compliance " + record.RecordType + " ?", (string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation,
MessageBoxDefaultButton.Button2))
{
case DialogResult.Yes:
GlobalObjects.PerformanceCore.Delete(record);
InvokeComplianceAdded(null);
break;
case DialogResult.No:
//arguments.Cancel = true;
break;
}
}
private void AddListViewItem(AbstractPerformanceRecord apr, WorkPackage workPackage)
{
DirectiveRecord directiveRecord = (DirectiveRecord)apr;
string workTypeString = "";
StaticDictionary workType;
if (directiveRecord.Parent is MaintenanceDirective)
{
MaintenanceDirective parentDirective = (MaintenanceDirective)directiveRecord.Parent;
workType = parentDirective.WorkType;
workTypeString = parentDirective.WorkType.ToString();
}
else if (directiveRecord.Parent is ComponentDirective)
{
ComponentDirective parentDirective = (ComponentDirective)directiveRecord.Parent;
workType = parentDirective.DirectiveType;
workTypeString = parentDirective.DirectiveType + " of " + parentDirective.ParentComponent.Description;
}
else
{
workType = MaintenanceDirectiveTaskType.Unknown;
}
string[] subs = new[] {
workTypeString,
UsefulMethods.NormalizeDate(directiveRecord.RecordDate),
directiveRecord.OnLifelength != null
? directiveRecord.OnLifelength.ToString()
: "",
directiveRecord.Remarks,
};
ListViewItem newItem = new ListViewItem(subs)
{
Group = listViewCompliance.Groups[1],
Tag = directiveRecord
};
if (workPackage != null)
{
//запись о выполнении блокируется найденым пакетом
apr.DirectivePackage = workPackage;
newItem.BackColor = Color.FromArgb(Highlight.Grey.Color);
newItem.ToolTipText =
"Perform of the task:" + workType +
"\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);
}
/// <summary>
/// </summary>
/// <param name="currentDirective"></param>
/// <param name="nextPerformances"></param>
/// <param name="averageUtilization"></param>
/// <param name="nextPerformance"></param>
public DirectiveComplianceDialog(IDirective currentDirective, List <NextPerformance> nextPerformances,
AverageUtilization averageUtilization)
: this()
{
_currentDirective = currentDirective;
_currentDirectiveRecord = DirectiveRecord.CreateInstance(nextPerformances.FirstOrDefault());
_nextPerformance = nextPerformances.FirstOrDefault();
_nextPerformances = nextPerformances;
_averageUtilization = averageUtilization;
checkBox1.Visible = true;
_animatedThreadWorker.DoWork += AnimatedThreadWorkerDoLoad;
_animatedThreadWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerLoadCompleted;
}
private void AddListViewItem(AbstractPerformanceRecord apr, WorkPackage workPackage,
MaintenanceCheckRecord mcr)
{
DirectiveRecord directiveRecord = (DirectiveRecord)apr;
MaintenanceDirective parentDirective = (MaintenanceDirective)directiveRecord.Parent;
string[] subs = new[] {
parentDirective.WorkType.ToString(),
UsefulMethods.NormalizeDate(directiveRecord.RecordDate),
directiveRecord.OnLifelength != null
? directiveRecord.OnLifelength.ToString()
: "",
"",
"",
directiveRecord.Remarks,
};
ListViewItem newItem = new ListViewItem(subs)
{
Group = listViewCompliance.Groups[1],
Tag = directiveRecord
};
if (workPackage != null)
{
//запись о выполнении блокируется найденым пакетом
apr.DirectivePackage = workPackage;
newItem.BackColor = Color.FromArgb(Highlight.Grey.Color);
newItem.ToolTipText =
"Perform of the task:" + parentDirective.WorkType +
"\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 ";
}
else if (directiveRecord.MaintenanceCheckRecordId > 0 && mcr != null && mcr.ParentCheck != null)
{
MaintenanceCheck mc = mcr.ParentCheck;
directiveRecord.MaintenanceCheck = mc;
newItem.BackColor = Color.FromArgb(Highlight.Grey.Color);
newItem.ToolTipText =
"Perform of the task:" + parentDirective.WorkType +
"\nadded by Maintenance Check:" +
"\n" + mc.Name +
"\nTo remove a performance of task, you need to delete performance of maintenance check";
}
listViewCompliance.Items.Add(newItem);
}
/// <summary>
/// Сохранение измененных данных в редактируемом элементе
/// </summary>
public void SaveData()
{
generalDataAndPerformanceControl.SaveData();
attributesAndParametersControl.SaveData();
try
{
currentDirective.Save(true);
if (currentDirective.DirectiveType == DirectiveTypeCollection.Instance.SBDirectiveType || currentDirective.DirectiveType == DirectiveTypeCollection.Instance.ADDirectiveType)
{
if (generalDataAndPerformanceControl.Supersedes != "")
{
BaseDetailDirective directive = GetDirectiveByTitle(generalDataAndPerformanceControl.Supersedes);
if (directive != null)
{
if (currentDirective.Paragraph == "" && directive.Paragraph == "")
{
directive.SupersededBy = currentDirective.Title;
directive.Save();
}
DirectiveRecord record = new DirectiveRecord();
record.RecordType = RecordTypesCollection.Instance.DirectiveSupersedingRecordType;
directive.AddRecord(record);
}
}
if (generalDataAndPerformanceControl.SupersededBy != "")
{
BaseDetailDirective directive = GetDirectiveByTitle(generalDataAndPerformanceControl.SupersededBy);
if (directive != null)
{
if (currentDirective.Paragraph == "" && directive.Paragraph == "")
{
directive.Supersedes = currentDirective.Title;
directive.Save();
}
DirectiveRecord record = new DirectiveRecord();
record.RecordType = RecordTypesCollection.Instance.DirectiveSupersedingRecordType;
currentDirective.AddRecord(record);
}
}
}
ReloadDirective();
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while saving data", ex);
}
}
public void DeleteDirectiveRecordTest()
{
var enviroment = GetEnviroment();
var performanceCore = new PerformanceCore(enviroment.NewKeeper, enviroment.Keeper, enviroment.Calculator, null);
var mpd = new MaintenanceDirective
{
Remarks = "Test"
};
enviroment.NewKeeper.Save(mpd);
var directiveRecordForMpdFirst = new DirectiveRecord
{
MaintenanceDirectiveRecordId = mpd.ItemId,
Parent = mpd,
Remarks = "Test"
};
enviroment.NewKeeper.Save(directiveRecordForMpdFirst);
var directiveRecordForMpdSecond = new DirectiveRecord
{
MaintenanceDirectiveRecordId = directiveRecordForMpdFirst.ItemId,
Remarks = "Test"
};
enviroment.NewKeeper.Save(directiveRecordForMpdSecond);
performanceCore.Delete(directiveRecordForMpdFirst);
//Загрузка 1 и 2 DirectiveRecord
var forCheckFirst = enviroment.NewLoader.GetObject <DirectiveRecordDTO, DirectiveRecord>(new Filter("ItemId", directiveRecordForMpdFirst.ItemId), getDeleted: true);
var forCheckSecond = enviroment.NewLoader.GetObject <DirectiveRecordDTO, DirectiveRecord>(new Filter("MaintenanceDirectiveRecordId", directiveRecordForMpdFirst.ItemId), getDeleted: true);
//Проверка что оба DirectiveRecord - a помечены как удаленные
Assert.IsTrue(forCheckFirst.IsDeleted);
Assert.IsTrue(forCheckSecond.IsDeleted);
//Удаление из БД
enviroment.NewKeeper.Delete(mpd);
enviroment.NewKeeper.Delete(directiveRecordForMpdFirst, false, false);
enviroment.NewKeeper.Delete(directiveRecordForMpdSecond, false, false);
}
/// <summary>
/// Удаляет запись о выполнении директивы
/// </summary>
/// <param name="directiveRecord"></param>
public void Delete(DirectiveRecord directiveRecord)
{
if (directiveRecord.Dispatched == new DateTime(0001, 01, 01))
{
directiveRecord.Dispatched = DateTimeExtend.GetCASMinDateTime();
}
directiveRecord.IsDeleted = true;
_newKeeper.Save(directiveRecord);
// нужно обнулить математический аппарат объекта, которому принадлежит запись о выполнении
// а также удалить выполнение директивы из коллекции выполнений директивы
IDirective parent = directiveRecord.Parent;
if (parent == null)
{
throw new Exception("1040: Failed to specify directive record parent type");
}
ICommonFilter filter = null;
if (parent is MaintenanceCheck)
{
filter = new CommonFilter <int>(DirectiveRecord.MaintenanceCheckRecordIdProperty, directiveRecord.ItemId);
}
else if (parent is MaintenanceDirective)
{
filter = new CommonFilter <int>(DirectiveRecord.MaintenanceDirectiveRecordIdProperty, directiveRecord.ItemId);
}
else if (parent is ComponentDirective)
{
if (directiveRecord.MaintenanceDirectiveRecordId > 0)
{
filter = new CommonFilter <int>(DirectiveRecord.MaintenanceDirectiveRecordIdProperty, directiveRecord.ItemId);
}
}
if (filter != null)
{
_keeper.MarkAsDeleted <DirectiveRecord>(new[] { filter });
}
parent.PerformanceRecords.Remove(directiveRecord);
}
/// <summary>
/// Создает форму для редактирования записи Compliance директивы
/// </summary>
/// <param name="directiveRecord">Запись Compliance</param>
public ComplianceForm(DirectiveRecord directiveRecord)
{
mode = ScreenMode.Edit;
currentRecord = directiveRecord;
if (directiveRecord.Parent is BaseDetailDirective)
{
currentDirective = (BaseDetailDirective)directiveRecord.Parent;
InitializeComponent();
UpdateWorkTypes();
}
else
{
currentDetail = (AbstractDetail)directiveRecord.Parent.Parent;
InitializeComponent();
UpdateDetailDirectiveList();
}
UpdateInformation();
}
private void CreateAndSavePerformanceForBindedItems(MaintenanceDirective mpd, AbstractPerformanceRecord performance)
{
var bindedItems = _bindedItemsCore.GetBindedItemsFor(mpd.ParentBaseComponent.ParentAircraftId, mpd);
foreach (var bindedItem in bindedItems)
{
if (bindedItem is ComponentDirective)
{
var componentDirective = (ComponentDirective)bindedItem;
var newPerformance = new DirectiveRecord(performance)
{
MaintenanceDirectiveRecordId = performance.ItemId,
Parent = componentDirective,
//TODO:(Evgenii Babak) Выяснить почему при создании записи берем наработку на начало дня, но в отчетах, для записей о выполнении пересчитываем наработку, и выводим наработку на конец дня
OnLifelength = _calculator.GetFlightLifelengthOnStartOfDay(componentDirective.ParentComponent, performance.RecordDate),
ParentId = componentDirective.ItemId
};
_newKeeper.Save(newPerformance, false);
}
}
}
private void AddDirectiveRecord(Component component, ComponentDirective componentDirective)
{
// Если у MPD Item есть записи о выполнении,
//то их нужно внести в записи о выполнении новой задачи по компоненту
if (_maintenanceDirective.LastPerformance != null)
{
//Получение записи об установке агрегата
TransferRecord tr = component.TransferRecords.GetLast();
//Необходимо ввести только те записи, что могли быть выполнены после установки агрегата
var performanceRecords = _maintenanceDirective.PerformanceRecords.Where(dr => dr.RecordDate >= tr.TransferDate);
foreach (DirectiveRecord performanceRecord in performanceRecords)
{
var newPerformance = new DirectiveRecord(performanceRecord);
newPerformance.MaintenanceDirectiveRecordId = performanceRecord.ItemId;
newPerformance.OnLifelength =
GlobalObjects.CasEnvironment.Calculator.GetFlightLifelengthOnStartOfDay(component, newPerformance.RecordDate);
GlobalObjects.PerformanceCore.RegisterPerformance(componentDirective, newPerformance, registerPerformanceForBindedItems: false);
}
}
}
/// <summary>
/// Данные работы обновляются по введенным значениям
/// </summary>
private bool SaveData()
{
if (_nextPerformances != null)
{
foreach (var performance in _nextPerformances)
{
var newRecord = DirectiveRecord.CreateInstance(performance);
newRecord.Parent = performance.Parent;
newRecord.RecordDate = dateTimePicker1.Value;
newRecord.Remarks = textBox_Remarks.Text;
newRecord.OnLifelength = lifelengthViewer_LastCompliance.Lifelength;
newRecord.PerformanceNum = performance.Group;
if (fileControl.GetChangeStatus())
{
fileControl.ApplyChanges();
newRecord.AttachedFile = fileControl.AttachedFile;
}
newRecord.Completed = true;
try
{
GlobalObjects.PerformanceCore.RegisterPerformance(newRecord.Parent, newRecord);
if (newRecord.Document?.ParentId <= 0)
{
newRecord.Document.ParentId = newRecord.ItemId;
GlobalObjects.CasEnvironment.NewKeeper.Save(newRecord.Document);
}
if (checkBox1.Checked && !checkClosed)
{
checkClosed = true;
var rec = performance.Parent as MaintenanceDirective;
var checkRecord = new MTOPCheckRecord
{
RecordDate = dateTimePicker1.Value,
CheckName = performance.ParentCheck.Name,
GroupName = performance.Group,
CalculatedPerformanceSource = lifelengthViewer_LastCompliance.Lifelength,
ParentId = performance.ParentCheck.ItemId,
Remarks = "Closed by Mtop Forecast",
AverageUtilization = _averageUtilization
};
GlobalObjects.CasEnvironment.NewKeeper.Save(checkRecord);
}
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while saving performance for directive", ex);
return(false);
}
}
return(true);
}
else
{
_currentDirectiveRecord.RecordDate = dateTimePicker1.Value;
_currentDirectiveRecord.Remarks = textBox_Remarks.Text;
_currentDirectiveRecord.OnLifelength = lifelengthViewer_LastCompliance.Lifelength;
if (fileControl.GetChangeStatus())
{
fileControl.ApplyChanges();
_currentDirectiveRecord.AttachedFile = fileControl.AttachedFile;
}
_currentDirectiveRecord.Completed = true;
try
{
if (_currentDirectiveRecord.ItemId <= 0)
{
GlobalObjects.PerformanceCore.RegisterPerformance(_currentDirective, _currentDirectiveRecord);
}
else
{
GlobalObjects.CasEnvironment.Manipulator.Save(_currentDirectiveRecord);
}
//if(_needActualState)
// GlobalObjects.ComponentCore.RegisterActualState(_currentDirective.LifeLengthParent,
// dateTimePicker1.Value,
// _currentDirectiveRecord.OnLifelength);
if (_currentDirectiveRecord.Document?.ParentId <= 0)
{
_currentDirectiveRecord.Document.ParentId = _currentDirectiveRecord.ItemId;
GlobalObjects.CasEnvironment.NewKeeper.Save(_currentDirectiveRecord.Document);
}
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while saving performance for directive", ex);
return(false);
}
return(true);
}
}
/// <summary>
/// Добавляется элемент в таблицу данных
/// </summary>
/// <param name="reportedComponentобавлямая директива</param>
/// <param name="destinationDataSet">Таблица, в которую добавляется элемент</param>
private void AddDirectiveToDataset(Component reportedComponent, LandingGearStatusDataSet destinationDataSet)
{
Lifelength total = GlobalObjects.CasEnvironment.Calculator.GetCurrentFlightLifelength(reportedComponent);
string domTtsnTcsn = SmartCore.Auxiliary.Convert.GetDateFormat(reportedComponent.ManufactureDate, "/");
if (domTtsnTcsn != "")
{
domTtsnTcsn += "\n";
}
domTtsnTcsn += total.ToHoursMinutesAndCyclesStrings("FH", "FC");
string position = reportedComponent.Position;
string pos = "";
string dwgItem = "";
string pattern = @"\d+";
Regex r = new Regex(pattern);
Match m = r.Match(position);
if (m.Success)
{
pos = position.Substring(0, m.Index);
dwgItem = position.Substring(m.Index);
}
ComponentRecordType workType = ComponentRecordType.Unknown;
ComponentDirective overhaul =
reportedComponent.ComponentDirectives.FirstOrDefault(dd => dd.DirectiveType == ComponentRecordType.Overhaul);
Lifelength interval = Lifelength.Null;
Lifelength used = Lifelength.Null;
Lifelength remain = Lifelength.Null;
string lastPerformanceDateString = "";
string lastPerformanceHours = "";
string lastPerformanceCycles = "";
if (overhaul != null)
{
if (overhaul.LastPerformance != null)
{
DirectiveRecord lastPerformance = overhaul.LastPerformance;
interval = overhaul.Threshold.RepeatInterval;
lastPerformanceDateString =
SmartCore.Auxiliary.Convert.GetDateFormat(lastPerformance.RecordDate, "/");
lastPerformanceHours = lastPerformance.OnLifelength.ToHoursMinutesFormat("FH");
lastPerformanceCycles = lastPerformance.OnLifelength.Cycles != null &&
lastPerformance.OnLifelength.Cycles != 0
? lastPerformance.OnLifelength.Cycles.ToString()
: "";
used = total - lastPerformance.OnLifelength;
used.Resemble(interval);
}
else
{
interval = overhaul.Threshold.FirstPerformanceSinceNew;
used = new Lifelength(total);
used.Resemble(interval);
}
workType = overhaul.DirectiveType;
remain = new Lifelength(overhaul.Remains);
}
destinationDataSet.ItemsTable.AddItemsTableRow(
dwgItem,
reportedComponent.ATAChapter.ToString(),
reportedComponent.PartNumber,
reportedComponent.SerialNumber,
pos,
reportedComponent.Description,
reportedComponent.MaintenanceControlProcess.ToString(),
SmartCore.Auxiliary.Convert.GetDateFormat(reportedComponent.TransferRecords.GetLast().TransferDate, "/"),
reportedComponent.LifeLimit.ToHoursMinutesAndCyclesStrings("FH", "FC"),
total.ToHoursMinutesAndCyclesStrings("FH", "FC"),
reportedComponent.Remains.ToHoursMinutesAndCyclesStrings("FH", "FC"),
workType.ToString(),
interval.ToHoursMinutesAndCyclesStrings("FH", "FC"),
lastPerformanceDateString,
lastPerformanceHours,
lastPerformanceCycles,
used.Days != null ? used.Days.ToString() : "",
used.Hours != null ? used.Hours.ToString() : "",
used.Cycles != null ? used.Cycles.ToString(): "",
used.ToHoursMinutesAndCyclesStrings("FH", "FC"),
"", "", "",
remain.ToHoursMinutesAndCyclesStrings("FH", "FC"),
reportedComponent.Condition.ToString(),
reportedComponent.ManHours,
reportedComponent.Cost,
reportedComponent.Kits.ToString(),
"",
reportedComponent.Remarks,
reportedComponent.Status.ToString(),
domTtsnTcsn);
}
/// <summary>
/// Данные работы обновляются по введенным значениям
/// </summary>
private void SaveData()
{
foreach (WorkPackageClosingDataGridViewRow row in dataGridViewItems.Rows.OfType <WorkPackageClosingDataGridViewRow>())
{
if ((bool)row.Cells[ColumnClosed.Index].Value == false)
{
continue;
}
try
{
DateTime performDate = (DateTime)row.Cells[ColumnDate.Index].Value;
if (row.ClosingItem is Procedure)
{
Procedure dir = (Procedure)row.ClosingItem;
DirectiveRecord directiveRecord = (DirectiveRecord)row.Record;
if (directiveRecord.ItemId <= 0)
{
directiveRecord.Completed = true;
directiveRecord.RecordType = DirectiveRecordType.Perfromed;
directiveRecord.RecordTypeId = DirectiveRecordType.Perfromed.ItemId;
directiveRecord.Remarks = "Audit " + _currentAudit.Title + " Close " + dir.ProcedureType.CommonName + " Procedure";
}
directiveRecord.RecordDate = performDate;
Lifelength performanceSource;
directiveRecord.OnLifelength = Lifelength.TryParse((string)row.Cells[ColumnHours.Index].Value,
(string)row.Cells[ColumnCycles.Index].Value,
(string)row.Cells[ColumnDays.Index].Value,
out performanceSource) ? performanceSource : Lifelength.Zero;
GlobalObjects.PerformanceCore.RegisterPerformance(dir, directiveRecord, _currentAudit);
}
}
catch (Exception ex)
{
Program.Provider.Logger.Log("Error while saving performance for directive", ex);
}
}
//_closingItems.All(item => item.SaveData());
IEnumerable <MaintenanceCheck> closedChecks =
dataGridViewItems.Rows.OfType <WorkPackageClosingDataGridViewRow>()
.Where(ci => ci.ClosingItem is MaintenanceCheck)
.Select(ci => ci.ClosingItem as MaintenanceCheck);
foreach (MaintenanceCheck mc in closedChecks)
{
MaintenanceCheckRecord mcRecord =
mc.PerformanceRecords.FirstOrDefault(pr => pr.DirectivePackageId == _currentAudit.ItemId);
if (mcRecord == null)
{
continue;
}
IEnumerable <DirectiveRecord> bindedMpdsRecords =
dataGridViewItems.Rows.OfType <WorkPackageClosingDataGridViewRow>()
.Where(ci => ci.ClosingItem is MaintenanceDirective)
.Select(ci => ci.ClosingItem as MaintenanceDirective)
.Where(mpd => mpd.MaintenanceCheck != null &&
mpd.MaintenanceCheck.ItemId == mc.ItemId &&
mpd.PerformanceRecords.FirstOrDefault(pr => pr.DirectivePackageId == _currentAudit.ItemId) != null)
.Select(mpd => mpd.PerformanceRecords.FirstOrDefault(pr => pr.DirectivePackageId == _currentAudit.ItemId));
foreach (DirectiveRecord mpdsRecord in bindedMpdsRecords)
{
mpdsRecord.MaintenanceCheckRecordId = mcRecord.ItemId;
GlobalObjects.NewKeeper.Save(mpdsRecord, false);
}
}
}
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 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);
}
private void ButtonDeleteClick(object sender, EventArgs e)
{
if (listViewCompliance.SelectedItems.Count == 0)
{
return;
}
if (listViewCompliance.SelectedItems[0].Tag is DirectiveRecord)
{
DirectiveRecord record = (DirectiveRecord)listViewCompliance.SelectedItems[0].Tag;
if (record.DirectivePackage != null)
{
MessageBox.Show("Perform of the task:" + listViewCompliance.SelectedItems[0].Text +
"\nadded by Work Package:" +
"\n" + record.DirectivePackage.Title +
"\nTo remove a performance of task, you need to exclude task from this work package," +
"\nor delete the work package ",
(string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.OK,
MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button1);
return;
}
switch (MessageBox.Show(@"Delete this compliance " + record.RecordType + " ?", (string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation,
MessageBoxDefaultButton.Button2))
{
case DialogResult.Yes:
GlobalObjects.PerformanceCore.Delete(record);
InvokeComplianceAdded(null);
break;
case DialogResult.No:
break;
}
}
else if (listViewCompliance.SelectedItems[0].Tag is ActualStateRecord)
{
ActualStateRecord record = (ActualStateRecord)listViewCompliance.SelectedItems[0].Tag;
switch (MessageBox.Show(@"Delete this actual state record ?", (string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation,
MessageBoxDefaultButton.Button2))
{
case DialogResult.Yes:
GlobalObjects.ComponentCore.DeleteActualStateRecord(record);
InvokeComplianceAdded(null);
break;
case DialogResult.No:
break;
}
}
else if (listViewCompliance.SelectedItems[0].Tag is ComponentLLPCategoryChangeRecord)
{
ComponentLLPCategoryChangeRecord record = (ComponentLLPCategoryChangeRecord)listViewCompliance.SelectedItems[0].Tag;
if (record.ParentComponent == null)
{
record.ParentComponent = _currentComponent;
}
switch (MessageBox.Show(@"Delete this LLP category change record ?", (string)new GlobalTermsProvider()["SystemName"],
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation,
MessageBoxDefaultButton.Button2))
{
case DialogResult.Yes:
GlobalObjects.ComponentCore.DeleteLLPCategoryChangeRecord(record);
InvokeComplianceAdded(null);
break;
case DialogResult.No:
break;
}
}
}
/// <summary>
/// Добавить выполнение работы к задаче
/// </summary>
/// <param name="performance"></param>
/// <param name="saveAttachedFile"></param>
public void Save(AbstractPerformanceRecord performance, bool saveAttachedFile = true)
{
if (performance == null)
{
return;
}
var type = AuditOperation.Created;
if (performance.ItemId > 0)
{
type = AuditOperation.Changed;
}
performance.CorrectorId = _casEnvironment.IdentityUser.ItemId;
_casEnvironment.Keeper.Save(performance, saveAttachedFile);
_auditRepository.WriteAsync(performance, type, _casEnvironment.IdentityUser);
if (performance.Parent.PerformanceRecords.GetItemById(performance.ItemId) == null)
{
performance.Parent.PerformanceRecords.Add(performance);
}
if (performance.Parent is MaintenanceDirective)
{
DirectiveRecord ddr = _casEnvironment.NewLoader.GetObjectListAll <DirectiveRecordDTO, DirectiveRecord>(new Filter("MaintenanceDirectiveRecordId", performance.ItemId)).FirstOrDefault();
if (ddr != null)
{
ComponentDirective dd = _casEnvironment.NewLoader.GetObject <ComponentDirectiveDTO, ComponentDirective>(new Filter("ItemId", ddr.ParentId));
if (dd != null)
{
BaseComponent bd = _componentCore.GetBaseComponentById(dd.ComponentId);
if (bd != null)
{
ddr.OnLifelength =
_casEnvironment.Calculator.GetFlightLifelengthOnStartOfDay(bd, performance.RecordDate);
}
else
{
General.Accessory.Component d = _componentCore.GetComponentById(dd.ComponentId);
if (d != null)
{
ddr.OnLifelength = _casEnvironment.Calculator.GetFlightLifelengthOnStartOfDay(d, performance.RecordDate);
}
}
}
ddr.RecordDate = performance.RecordDate;
_casEnvironment.NewKeeper.Save(ddr, saveAttachedFile);
}
}
else if (performance.Parent is ComponentDirective)
{
DirectiveRecord ddr = performance as DirectiveRecord;
if (ddr != null)
{
DirectiveRecord mpdRecord = _casEnvironment.NewLoader.GetObject <DirectiveRecordDTO, DirectiveRecord>(new Filter("ItemId", ddr.MaintenanceDirectiveRecordId));
if (mpdRecord != null)
{
MaintenanceDirective md = _maintenanceCore.GetMaintenanceDirective(mpdRecord.ParentId);
if (md != null)
{
mpdRecord.OnLifelength = _casEnvironment.Calculator.GetFlightLifelengthOnStartOfDay(md.ParentBaseComponent, ddr.RecordDate);
}
mpdRecord.RecordDate = ddr.RecordDate;
_casEnvironment.NewKeeper.Save(mpdRecord, saveAttachedFile);
}
}
}
}
/// <summary>
/// Обновляет значения полей
/// </summary>
public override void FillControls()
{
BeginUpdate();
dateTimePicker1.ValueChanged -= DateTimePicker1ValueChanged;
if (MaintenanceDirective != null)
{
textBoxMpdItem.Text = MaintenanceDirective.TaskNumberCheck;
if (_maintenanceCheckRecord != null)
{
_maintenanceDirectiveRecord =
MaintenanceDirective.PerformanceRecords
.FirstOrDefault(pr => pr.MaintenanceCheckRecordId == _maintenanceCheckRecord.ItemId);
}
checkBoxClose.Checked = _maintenanceDirectiveRecord != null;
dateTimePicker1.Value = _maintenanceDirectiveRecord != null ? _maintenanceDirectiveRecord.RecordDate : DateTime.Today;
#region Определение ограничений по ресурсу и дате выполнения
if (_maintenanceDirectiveRecord != null && _maintenanceDirectiveRecord.ItemId > 0)
{
//редактируется старая запись
int index = MaintenanceDirective.PerformanceRecords.IndexOf(_maintenanceDirectiveRecord);
if (index == 0)
{
//редактируется первая запись о выполнении
_prevPerfDate = null;
if (MaintenanceDirective.PerformanceRecords.Count > 1)
{
//было сделано много записей о выполнении
_nextPerfDate = MaintenanceDirective.PerformanceRecords[index + 1].RecordDate;
}
else if (MaintenanceDirective.NextPerformances.Count > 0)
{
//была сделана одна запись о выполнении и есть "след. выполнения"
_nextPerfDate = MaintenanceDirective.NextPerformances[0].PerformanceDate;
}
else
{
_nextPerfDate = null;
}
}
else if (index < MaintenanceDirective.PerformanceRecords.Count - 1)
{
//редактируется запись из середины списка записей о выполнении
_prevPerfDate = MaintenanceDirective.PerformanceRecords[index - 1].RecordDate;
_nextPerfDate = MaintenanceDirective.PerformanceRecords[index + 1].RecordDate;
}
else //(index == _currentDirective.PerformanceRecords.Count - 1)
{
//редактируется запись из середины списка записей о выполнении
_prevPerfDate = MaintenanceDirective.PerformanceRecords[index - 1].RecordDate;
if (MaintenanceDirective.NextPerformances.Count > 0)
{
//запись о выполнении сделана последней и есть "след. выполнения"
_nextPerfDate = MaintenanceDirective.NextPerformances[0].PerformanceDate;
}
else
{
_nextPerfDate = null;
}
}
}
else
{
//редактируется новая запись
//int index = MaintenanceDirective.NextPerformances.IndexOf(_nextPerformance);
//if (index == 0)
//{
// //редактируется первое "след.выполнение"
// if (MaintenanceDirective.LastPerformance != null)
// {
// //была сделана запись о выполнении
// _prevPerfDate = MaintenanceDirective.LastPerformance.RecordDate;
// _prevPerfLifelength =
// GlobalObjects.CasEnvironment.Calculator.GetLifelength(MaintenanceDirective.LifeLengthParent,
// _prevPerfDate.Value);
// }
// else
// {
// _prevPerfDate = null;
// _prevPerfLifelength = null;
// }
// if (MaintenanceDirective.NextPerformances.Count > 1)
// {
// //"след. выполнений" больше одного
// _nextPerfDate = MaintenanceDirective.NextPerformances[1].PerformanceDate;
// _nextPerfLifelength = MaintenanceDirective.NextPerformances[1].PerformanceSource;
// }
// else
// {
// _nextPerfDate = null;
// _nextPerfLifelength = null;
// }
//}
//else if (index < MaintenanceDirective.NextPerformances.Count - 1)
//{
// //редактируется запись из середины списка "след. выполнений"
// _prevPerfDate = MaintenanceDirective.NextPerformances[index - 1].PerformanceDate;
// _prevPerfLifelength = MaintenanceDirective.NextPerformances[index - 1].PerformanceSource;
// _nextPerfDate = MaintenanceDirective.NextPerformances[index + 1].PerformanceDate;
// _nextPerfLifelength = MaintenanceDirective.NextPerformances[index + 1].PerformanceSource;
//}
//else //(index == _currentDirective.NextPerformances.Count - 1)
//{
// //редактируется запись из середины списка записей о выполнении
// _prevPerfDate = MaintenanceDirective.NextPerformances[index - 1].PerformanceDate;
// _prevPerfLifelength = MaintenanceDirective.NextPerformances[index - 1].PerformanceSource;
// _nextPerfDate = null;
// _nextPerfLifelength = null;
//}
}
#endregion
}
dateTimePicker1.ValueChanged += DateTimePicker1ValueChanged;
EndUpdate();
}
/*
* Перегружаемые методы
*/
#region public override void ApplyChanges()
/// <summary>
/// Применить к объекту сделанные изменения на контроле.
/// Если не все данные удовлетворяют формату ввода (например при вводе чисел), свойства объекта не изменяются, возвращается false
/// Вызов base.ApplyChanges() обязателен
/// </summary>
/// <returns></returns>
public override void ApplyChanges()
{
if (MaintenanceDirective != null)
{
if (_maintenanceDirectiveRecord != null && checkBoxClose.Checked == false)
{
_maintenanceDirectiveRecord.IsDeleted = true;
}
if (_maintenanceDirectiveRecord != null && checkBoxClose.Checked)
{
_maintenanceDirectiveRecord.RecordDate = dateTimePicker1.Value;
}
if (!MaintenanceDirective.IsClosed && _maintenanceDirectiveRecord == null && checkBoxClose.Checked)
{
DirectiveRecord apr = null;
if (MaintenanceDirective.PerformanceRecords.Count > 0)
{
//Поиск записи о выполнении задачи программы обслуживания
//которая могла бы подойти под создаваемую запись
//о выполнении чека программы обслуживания
double?days;
if (MaintenanceDirective.MaintenanceCheck != null &&
MaintenanceDirective.MaintenanceCheck.ParentAircraft != null)
{
var a = MaintenanceDirective.MaintenanceCheck.ParentAircraft;
var partInterval = MaintenanceDirective.MaintenanceCheck.Interval * 0.2;
var aircraftFrame = GlobalObjects.ComponentCore.GetBaseComponentById(a.AircraftFrameId);
var averageUtilization = GlobalObjects.AverageUtilizationCore.GetAverageUtillization(aircraftFrame);
days = AnalystHelper.GetApproximateDays(partInterval, averageUtilization);
}
else
{
var partInterval = MaintenanceDirective.RepeatInterval * 0.2;
days = AnalystHelper.GetApproximateDays(partInterval, MaintenanceDirective.ParentBaseComponent.AverageUtilization);
}
IEnumerable <DirectiveRecord> aprs = null;
if (days != null && days > 0)
{
double daysValue = Convert.ToDouble(days);
//Производится поиск записей о выполнении дата выполнения которых лежит
//в заданном диапозоне
aprs = MaintenanceDirective.PerformanceRecords.Where(
pr => pr.RecordDate >= dateTimePicker1.Value.AddDays(-daysValue) &&
pr.RecordDate <= dateTimePicker1.Value.AddDays(daysValue));
}
if (aprs != null && aprs.Count() > 0)
{
if (aprs.Count() == 1)
{
apr = aprs.First();
}
else
{
DirectiveRecord min = null;
double minDays = int.MaxValue;
foreach (DirectiveRecord record in aprs)
{
if (min == null)
{
min = record;
minDays = Math.Abs((min.RecordDate - dateTimePicker1.Value).TotalDays);
continue;
}
double candidateMin = Math.Abs((record.RecordDate - dateTimePicker1.Value).TotalDays);
if (candidateMin < minDays)
{
min = record;
minDays = candidateMin;
}
}
apr = min;
}
}
}
if (apr != null)
{
_maintenanceDirectiveRecord = apr;
}
else
{
NextPerformance performance =
MaintenanceDirective.NextPerformances.FirstOrDefault(p => p.PerformanceDate != null &&
p.PerformanceDate.Value.Date == dateTimePicker1.Value) ??
MaintenanceDirective.NextPerformances.LastOrDefault(p => p.PerformanceDate != null &&
p.PerformanceDate < dateTimePicker1.Value) ??
MaintenanceDirective.NextPerformances.FirstOrDefault(p => p.PerformanceDate != null &&
p.PerformanceDate > dateTimePicker1.Value);
_maintenanceDirectiveRecord = new DirectiveRecord
{
PerformanceNum = performance != null ? performance.PerformanceNum : 0,
Parent = MaintenanceDirective,
ParentId = MaintenanceDirective.ItemId,
RecordDate = dateTimePicker1.Value
};
}
}
}
base.ApplyChanges();
}
/// <summary>
/// Добавляется элемент в таблицу данных
/// </summary>
/// <param name="reportedDirective">Добавлямая директива</param>
/// <param name="destinationDataSet">Таблица, в которую добавляется элемент</param>
private void AddDirectiveToDataset(object reportedDirective, ComponentListDataSet destinationDataSet)
{
//if (!DefaultFilter.Acceptable(directive))
// return;
Component component;
ComponentDirective directive;
NextPerformance nextDueAtAircraftUtilization = null;
DirectiveRecord lastPerformance = null;
string positionString = "";
string remarks = "", condition = "";
string workType = "", lastComplianceDate = "", nextComplianceDate = "", ampReference = "";
double mansHours = 0, cost = 0;
DateTime installationDate = DateTimeExtend.GetCASMinDateTime();
string kits = "", equipment = "", status = "";
Lifelength lifeLimit, componentCurrent = Lifelength.Null;
Lifelength repeat = Lifelength.Null, lastCompliance = Lifelength.Null;
Lifelength used = Lifelength.Null, nextPerformanceSource = Lifelength.Null, remain = Lifelength.Null;
if (reportedDirective is ComponentDirective)
{
directive = (ComponentDirective)reportedDirective;
component = directive.ParentComponent;
positionString = component.TransferRecords.GetLast().Position;
installationDate = component.TransferRecords.GetLast().TransferDate;
componentCurrent = directive.ParentComponent.IsBaseComponent
? GlobalObjects.CasEnvironment.Calculator.GetCurrentFlightLifelength((BaseComponent)component)
: GlobalObjects.CasEnvironment.Calculator.GetCurrentFlightLifelength(component);
remarks = directive.Remarks;
workType = directive.DirectiveType.ToString();
repeat = directive.Threshold.RepeatInterval;
lifeLimit = component.LifeLimit;
//nextCompliance = GlobalObjects.CasEnvironment.Calculator.GetNextPerformance(directive);
GlobalObjects.PerformanceCalculator.GetNextPerformance(directive);
nextPerformanceSource = directive.NextPerformanceSource;
if (directive.MaintenanceDirective != null)
{
ampReference = directive.MaintenanceDirective.TaskNumberCheck;
}
if (nextPerformanceSource != null && directive.Status != DirectiveStatus.Closed)
{
nextComplianceDate = directive.NextPerformanceDate != null
? ((DateTime)directive.NextPerformanceDate).ToString(
new GlobalTermsProvider()["DateFormat"].ToString())
: "";
remain.Add(nextPerformanceSource);
remain.Substract(componentCurrent);
used.Add(componentCurrent);
if (_reportedAircraft != null)
{
nextDueAtAircraftUtilization = new NextPerformance
{
PerformanceDate = directive.NextPerformanceDate,
PerformanceSource = GlobalObjects.CasEnvironment.Calculator.GetCurrentFlightLifelength(_reportedAircraft)
};
nextDueAtAircraftUtilization.PerformanceSource.Add(remain);
}
}
else
{
nextPerformanceSource = Lifelength.Null;
}
if (directive.LastPerformance != null && directive.Status != DirectiveStatus.Closed)
{
lastPerformance = directive.LastPerformance;
lastComplianceDate =
directive.LastPerformance.RecordDate.ToString(new GlobalTermsProvider()["DateFormat"].ToString());
lastCompliance = directive.LastPerformance.OnLifelength;
used.Substract(lastCompliance);
used.Resemble(directive.Threshold.RepeatInterval);
remain.Resemble(directive.Threshold.RepeatInterval);
if (nextDueAtAircraftUtilization != null)
{
nextDueAtAircraftUtilization.PerformanceSource.Resemble(directive.Threshold.RepeatInterval);
}
}
else
{
used.Resemble(directive.Threshold.FirstPerformanceSinceNew);
remain.Resemble(directive.Threshold.FirstPerformanceSinceNew);
if (nextDueAtAircraftUtilization != null)
{
nextDueAtAircraftUtilization.PerformanceSource.Resemble(directive.Threshold.FirstPerformanceSinceNew);
}
}
int num = 1;
foreach (AccessoryRequired kit in directive.Kits)
{
kits += num + ": " + kit.PartNumber + "\n";
num++;
}
condition = directive.Condition.ToString();
}
//Если объект является деталью или базовой деталью с директивами
//то надо возвратится, т.к. данные по детали/базовой детали будут
//добавлены при добавлении их директив в набор данных
//Если деталь.базовая деталь без директив, тогда в набор данных надо добавить и данные сразу
else if (reportedDirective is Component)
{
component = (Component)reportedDirective;
lifeLimit = component.LifeLimit;
if (component.ComponentDirectives.Count != 0)
{
return;
}
}
else
{
throw new ArgumentException();
}
Lifelength lifeLimitUsed = Lifelength.Null;
lifeLimitUsed.Add(componentCurrent);
lifeLimitUsed.Resemble(lifeLimit);
Lifelength lifeLimitRemain = Lifelength.Null;
lifeLimitRemain.Add(lifeLimit);
lifeLimitRemain.Substract(componentCurrent);
lifeLimitRemain.Resemble(lifeLimit);
//string status = "";
//if (.Status == DirectiveStatus.Closed) status = "C";
//if (directive.Status == DirectiveStatus.Open) status = "O";
//if (directive.Status == DirectiveStatus.Repetative) status = "R";
//if (directive.Status == DirectiveStatus.NotApplicable) status = "N/A";
destinationDataSet.ItemsTable.AddItemsTableRow(component.ATAChapter.ShortName,
ampReference,
component.PartNumber,
component.SerialNumber,
positionString,
component.Description,
component.MaintenanceControlProcess.ToString(),
installationDate,
lifeLimit.Days != null ? lifeLimit.Days.ToString() : "",
lifeLimit.Hours != null ? lifeLimit.Hours.ToString() : "",
lifeLimit.Cycles != null ? lifeLimit.Cycles.ToString() : "",
lifeLimitUsed.Days != null
? lifeLimitUsed.Days.ToString()
: "",
lifeLimitUsed.Hours != null
? lifeLimitUsed.Hours.ToString()
: "",
lifeLimitUsed.Cycles != null
? lifeLimitUsed.Cycles.ToString()
: "",
lifeLimitRemain.Days != null
? lifeLimitRemain.Days.ToString()
: "",
lifeLimitRemain.Hours != null
? lifeLimitRemain.Hours.ToString()
: "",
lifeLimitRemain.Cycles != null
? lifeLimitRemain.Cycles.ToString()
: "",
workType,
repeat.Days != null
? repeat.Days.ToString()
: "",
repeat.Hours != null
? repeat.Hours.ToString()
: "",
repeat.Cycles != null
? repeat.Cycles.ToString()
: "",
repeat.ToHoursMinutesAndCyclesStrings(" FH", " FC"),
lastComplianceDate,
lastCompliance.Hours != null
? lastCompliance.Hours.ToString()
: "",
lastCompliance.Cycles != null
? lastCompliance.Cycles.ToString()
: "",
lastPerformance != null
? lastPerformance.ToStrings("/")
: "",
used.Days != null ? used.Days.ToString() : "",
used.Hours != null ? used.Hours.ToString() : "",
used.Cycles != null ? used.Cycles.ToString() : "",
nextComplianceDate,
nextPerformanceSource.Hours != null
? nextPerformanceSource.Hours.ToString()
: "",
nextPerformanceSource.Cycles != null
? nextPerformanceSource.Cycles.ToString()
: "",
nextDueAtAircraftUtilization != null
? nextDueAtAircraftUtilization.ToStrings("/")
: "",
remain.Days != null ? remain.Days.ToString() : "",
remain.Hours != null ? remain.Hours.ToString() : "",
remain.Cycles != null ? remain.Cycles.ToString() : "",
remain.ToHoursMinutesAndCyclesStrings(" FH", " FC"),
condition, mansHours, cost, kits,
equipment, remarks, status);
}
