private List <string> GetMaintenanceTypes(MaintainedEquipmentByCycle equipment, IServiceUnitOfWork serviceUnitOfWork)
{
MaintenanceCycle maintenanceCycle = serviceUnitOfWork.MaintainedEquipmentsByCycleService
.GetCurrentCycle(equipment as MaintainedEquipmentByCycle);
return(maintenanceCycle.MaintenanceYears.GroupBy(x => x.MaintenanceType.Name).Select(x => x.Key).ToList());
}
public void Delete(MaintenanceCycle t)
{
if (GetAllMaintainedEquipments(t.MaintenanceCycleId).Count != 0)
{
return;
}
dataBase.MaintenanceCycles.Delete(t);
}
public void UpdateRecords(AdditionalWork t)
{
AdditionalWork oldCombineDevice = dataBase.AdditionalWorks.Read(t.MaintainedEquipmentId);
MaintenanceCycle maintenanceCycle = dataBase.MaintenanceCycles.Read(t.NormalMaintenanceCycle.MaintenanceCycleId);
updateCombineDeviceRecords(maintenanceCycle, oldCombineDevice);
dataBase.Save();
}
public List <MaintainedEquipmentByCycle> GetAllMaintainedEquipments(int cycleId)
{
MaintenanceCycle maintenanceCycle = dataBase.MaintenanceCycles.Read(cycleId);
List <MaintainedEquipmentByCycle> equipments = new List <MaintainedEquipmentByCycle>(maintenanceCycle.NormalEquipments);
equipments.AddRange(maintenanceCycle.ReducedEquipments);
return(equipments);
}
public MarkRecordViewModel(IServiceUnitOfWork serviceUnitOfWork, MaintainedEquipmentByCycle maintainedEquipmentByCycle)
{
this.serviceUnitOfWork = serviceUnitOfWork;
this.maintainedEquipmentByCycle = maintainedEquipmentByCycle;
int cycleId = serviceUnitOfWork.MaintainedEquipmentsByCycleService.GetCurrentCycle(maintainedEquipmentByCycle).MaintenanceCycleId;
MaintenanceCycle maintenanceCycle = serviceUnitOfWork.MaintenanceCycles.Get(cycleId);
MaintenanceTypes = new ObservableCollection <MaintenanceType>(maintenanceCycle.MaintenanceYears.GroupBy(x => x.MaintenanceType).Select(x => x.Key).ToList());
}
public void UpdateRecords(MaintenanceCycle deletedMaintenanceCycle, MaintenanceCycle newMaintenanceCycle, Device t)
{
if (t.NormalMaintenanceCycle.MaintenanceCycleId == deletedMaintenanceCycle.MaintenanceCycleId)
{
t.NormalMaintenanceCycle = newMaintenanceCycle;
}
if (t.ReducedMaintenanceCycle.MaintenanceCycleId == deletedMaintenanceCycle.MaintenanceCycleId)
{
t.ReducedMaintenanceCycle = newMaintenanceCycle;
}
UpdateRecords(newMaintenanceCycle, t);
}
/// <inheritdoc/>
public string ToDelimitedString()
{
CultureInfo culture = CultureInfo.CurrentCulture;
return(string.Format(
culture,
StringHelper.StringFormatSequence(0, 5, Configuration.FieldSeparator),
Id,
SterilizationType?.ToDelimitedString(),
SterilizationCycle?.ToDelimitedString(),
MaintenanceCycle?.ToDelimitedString(),
MaintenanceType?.ToDelimitedString()
).TrimEnd(Configuration.FieldSeparator.ToCharArray()));
}
public void CreateRecords(AdditionalWork t)
{
MaintenanceCycle maintenanceCycle = dataBase.MaintenanceCycles.Read(t.NormalMaintenanceCycle.MaintenanceCycleId);
int lastYear = maintenanceCycle.MaintenanceYears.Max(x => x.Year);
int initialYear = t.InputYear.Value;
for (int i = initialYear, maintainedYear = 0, currentYear = 0; i <= DateTime.Now.Year + 11; i++, maintainedYear++, currentYear++)
{
addNewRecord(maintenanceCycle, t, maintainedYear, initialYear, currentYear);
if (maintainedYear == lastYear)
{
maintainedYear = 0;
}
}
}
public void Update(MaintenanceCycleModel maintenanceCycleModel)
{
MaintenanceCycle maintenanceCycle = new MaintenanceCycle();
MaintenanceCycle oldMaintenanceCycle = dataBase.MaintenanceCycles.Read(maintenanceCycleModel.MaintenanceCycleId);
MaintenanceYear maintenanceYear;
List <MaintenanceType> maintenanceTypes = new List <MaintenanceType>(dataBase.MaintenanceTypes.GetAll());
while (oldMaintenanceCycle.MaintenanceYears.Count != 0)
{
dataBase.MaintenanceYears.Delete(oldMaintenanceCycle.MaintenanceYears.First());
}
dataBase.Save();
oldMaintenanceCycle.Name = maintenanceCycleModel.Name;
oldMaintenanceCycle.ShowName = maintenanceCycleModel.ShowName;
for (int i = 0; i < maintenanceCycleModel.MaintenanceTypes.Length; i++)
{
if (maintenanceCycleModel.MaintenanceTypes[i] != null)
{
maintenanceYear = new MaintenanceYear();
maintenanceYear.Year = i;
maintenanceYear.MaintenanceType = maintenanceTypes.First(x => x.Name == maintenanceCycleModel.MaintenanceTypes[i]);
maintenanceYear.MaintenanceCycle = oldMaintenanceCycle;
dataBase.MaintenanceYears.Create(maintenanceYear);
}
}
//dataBase.MaintenanceCycles.Update(maintenanceCycle);
dataBase.Save();
maintenanceCycle = dataBase.MaintenanceCycles.Read(oldMaintenanceCycle.MaintenanceCycleId);
List <MaintainedEquipmentByCycle> maintainedEquipmentsByCycle = GetAllMaintainedEquipments(maintenanceCycle.MaintenanceCycleId);
if (maintainedEquipmentsByCycle.Count != 0)
{
foreach (MaintainedEquipmentByCycle equipment in maintainedEquipmentsByCycle)
{
if (equipment is Device)
{
BaseDeviceService deviceService = new BaseDeviceService(dataBase);
deviceService.UpdateRecords(maintenanceCycle, (Device)equipment);
}
else if (equipment is AdditionalWork)
{
AdditionalWorkService combineDeviceService = new AdditionalWorkService(dataBase);
combineDeviceService.UpdateRecords(maintenanceCycle, (AdditionalWork)equipment);
}
}
dataBase.Save();
}
}
private void updateCombineDeviceRecords(MaintenanceCycle newMaintenanceCycle, AdditionalWork t)
{
List <MaintenanceRecord> deleteMaintenanceRecords = dataBase.AdditionalWorks.Read(t.MaintainedEquipmentId).MaintenanceRecords.FindAll(x => x.ActualMaintenanceDate == null &&
!(x.IsPlanned || x.IsRescheduled));
foreach (MaintenanceRecord record in deleteMaintenanceRecords)
{
dataBase.MaintenanceRecords.Delete(record);
}
List <MaintenanceRecord> maintenanceRecords = dataBase.AdditionalWorks.Read(t.MaintainedEquipmentId).MaintenanceRecords;
int lastYear = newMaintenanceCycle.MaintenanceYears.Max(x => x.Year);
int initialYear;
if (t.MaintenanceRecords.Count == 0)
{
initialYear = t.InputYear.Value;
for (int i = 0, maintainedYear = 0; i <= 10; i++, maintainedYear++)
{
addNewRecord(newMaintenanceCycle, t, maintainedYear, initialYear, i);
if (maintainedYear == lastYear)
{
maintainedYear = 0;
}
}
}
else
{
MaintenanceCycle oldMaintenanceCycle = dataBase.MaintenanceCycles.Read(t.NormalMaintenanceCycle.MaintenanceCycleId);
int nextMaintainedYear;
initialYear = maintenanceRecords.Last(x => x.PlannedMaintenanceType.Name == oldMaintenanceCycle.MaintenanceYears[0].MaintenanceType.Name).PlannedMaintenanceDate.Year;
nextMaintainedYear = maintenanceRecords.Last().PlannedMaintenanceDate.Year - initialYear + 1;
for (int i = 0, maintainedYear = nextMaintainedYear; i <= 10; i++, maintainedYear++)
{
if (checkYear(initialYear + nextMaintainedYear + i))
{
continue;
}
addNewRecord(newMaintenanceCycle, t, maintainedYear, initialYear, i + nextMaintainedYear);
if (maintainedYear == lastYear)
{
maintainedYear = 0;
}
}
}
}
public void UpdateRecords(MaintenanceCycle newMaintenanceCycle, Device t)
{
MaintenanceCycle maintenanceCycle = null;
if (t.Act == null || t.Act.Name == "Не указан" &&
t.NormalMaintenanceCycle.MaintenanceCycleId == newMaintenanceCycle.MaintenanceCycleId)
{
maintenanceCycle = newMaintenanceCycle;
}
else if (t.ReducedMaintenanceCycle.MaintenanceCycleId == newMaintenanceCycle.MaintenanceCycleId)
{
maintenanceCycle = newMaintenanceCycle;
}
if (maintenanceCycle != null)
{
updateDeviceRecords(maintenanceCycle, t);
}
}
private MaintenanceCycle AddEightNormalCycleHightVoltage()
{
MaintenanceCycle maintenanceCycle = new MaintenanceCycle();
maintenanceCycle.Name = "8 лет ПТО 110кВ";
maintenanceCycle.MaintenanceYears = new List <MaintenanceYear>();
maintenanceCycle.MaintenanceYears.Add(AddMaintenanceYear(0, "Н"));
maintenanceCycle.MaintenanceYears.Add(AddMaintenanceYear(1, "К-1"));
maintenanceCycle.MaintenanceYears.Add(AddMaintenanceYear(4, "К"));
maintenanceCycle.MaintenanceYears.Add(AddMaintenanceYear(8, "В"));
return(maintenanceCycle);
}
public void CreateRecords(Device t)
{
MaintenanceCycle maintenanceCycle = dataBase.MaintenanceCycles.Read(t.NormalMaintenanceCycle.MaintenanceCycleId);
bool changeCycle = false;
int startReducedCycle = 0;
if (t.Act != null && t.Act.Name != "Не указан")
{
if (t.Act.CreationDate.Month >= 10)
{
startReducedCycle = t.Act.CreationDate.Year + 1;
}
else
{
startReducedCycle = t.Act.CreationDate.Year;
}
changeCycle = true;
}
MaintenanceCycle continuationCycle = getContinuationCycle(maintenanceCycle);
MaintenanceYear recoverYear = maintenanceCycle.MaintenanceYears.First(x => x.MaintenanceType.Name.Contains("В"));
int initialYear = t.InputYear.Value;
int currentYear = 0;
for (int i = currentYear; i <= recoverYear.Year; i++)
{
addNewRecord(maintenanceCycle, t, i, initialYear, currentYear);
currentYear++;
}
for (int i = initialYear + currentYear, maintainedYear = 1; i <= DateTime.Now.Year + 11; i++, maintainedYear++)
{
if (changeCycle == true & (initialYear + currentYear) == startReducedCycle)
{
maintenanceCycle = dataBase.MaintenanceCycles.Read(t.ReducedMaintenanceCycle.MaintenanceCycleId);
continuationCycle = getContinuationCycle(maintenanceCycle);
recoverYear = maintenanceCycle.MaintenanceYears.First(x => x.MaintenanceType.Name.Contains("В"));
}
addNewRecord(continuationCycle, t, maintainedYear, initialYear, currentYear);
currentYear++;
if (maintainedYear == recoverYear.Year)
{
maintainedYear = 0;
}
}
}
public MaintenanceCycleModel Get(MaintenanceCycle maintenanceCycle)
{
MaintenanceCycle cycle = dataBase.MaintenanceCycles.Read(maintenanceCycle.MaintenanceCycleId);
MaintenanceCycleModel maintenanceCycleModel = new MaintenanceCycleModel();
maintenanceCycleModel.MaintenanceTypes = new string[9];
maintenanceCycleModel.MaintenanceCycleId = cycle.MaintenanceCycleId;
maintenanceCycleModel.Name = cycle.Name;
maintenanceCycleModel.ShowName = cycle.ShowName;
MaintenanceYear maintenanceYear = new MaintenanceYear();
for (int i = 0; i <= 8; i++)
{
maintenanceYear = cycle.MaintenanceYears.FirstOrDefault(x => x.Year == i);
if (maintenanceYear != null)
{
maintenanceCycleModel.MaintenanceTypes[i] = maintenanceYear.MaintenanceType.Name;
}
}
return(maintenanceCycleModel);
}
public MaintenanceCycle GetCurrentCycle(MaintainedEquipmentByCycle equpment)
{
MaintenanceCycle maintenanceCycle = null;
if (equpment is Device)
{
if (((Device)equpment).Act == null || ((Device)equpment).Act.Name == "Не указан")
{
return(equpment.NormalMaintenanceCycle);
}
else
{
return(equpment.ReducedMaintenanceCycle);
}
}
else if (equpment is AdditionalWork)
{
return(equpment.NormalMaintenanceCycle);
}
return(maintenanceCycle);
}
public void Delete(MaintenanceCycle deletedMaintenanceCycle, MaintenanceCycle newMaintenanceCycle)
{
List <MaintainedEquipmentByCycle> equipments = GetAllMaintainedEquipments(deletedMaintenanceCycle.MaintenanceCycleId);
if (equipments.Count != 0)
{
foreach (MaintainedEquipmentByCycle equipment in equipments)
{
if (equipment is Device)
{
BaseDeviceService deviceService = new BaseDeviceService(dataBase);
deviceService.UpdateRecords(deletedMaintenanceCycle, newMaintenanceCycle, (Device)equipment);
}
else if (equipment is AdditionalWork)
{
AdditionalWorkService combineDeviceService = new AdditionalWorkService(dataBase);
combineDeviceService.UpdateRecords(deletedMaintenanceCycle, newMaintenanceCycle, (AdditionalWork)equipment);
}
}
dataBase.Save();
}
}
public void UpdateRecords(Device t)
{
Device oldDevice = dataBase.Devices.Read(t.MaintainedEquipmentId);
MaintenanceCycle maintenanceCycle = null;
if (t.Act == null || t.Act.Name == "Не указан")
{
if (/*(oldDevice.NormalMaintenanceCycle.MaintenanceCycleId != t.NormalMaintenanceCycle.MaintenanceCycleId) ||*/
((oldDevice.Act != null || oldDevice.Act.Name != "Не указан") && (t.Act == null || t.Act.Name == "Не указан")))
{
maintenanceCycle = dataBase.MaintenanceCycles.Read(t.NormalMaintenanceCycle.MaintenanceCycleId);
}
}
else if (/*(oldDevice.ReducedMaintenanceCycle.MaintenanceCycleId != t.ReducedMaintenanceCycle.MaintenanceCycleId) ||*/
((oldDevice.Act == null || oldDevice.Act.Name == "Не указан") && (t.Act != null || t.Act.Name != "Не указан")))
{
maintenanceCycle = dataBase.MaintenanceCycles.Read(t.ReducedMaintenanceCycle.MaintenanceCycleId);
}
if (maintenanceCycle != null)
{
updateDeviceRecords(maintenanceCycle, oldDevice);
}
}
protected MaintenanceCycle getContinuationCycle(MaintenanceCycle maintenanceCycle)
{
MaintenanceCycle continuationCycle = new MaintenanceCycle();
continuationCycle.MaintenanceYears = new List <MaintenanceYear>();
MaintenanceYear recoverYear = maintenanceCycle.MaintenanceYears.First(x => x.MaintenanceType.Name.Contains("В"));
foreach (MaintenanceYear cycleYear in maintenanceCycle.MaintenanceYears)
{
MaintenanceYear newYear;
newYear = new MaintenanceYear();
newYear.MaintenanceType = new MaintenanceType();
if (cycleYear.Year == 0)
{
newYear.MaintenanceType.Name = recoverYear.MaintenanceType.Name;
}
else if (cycleYear.Year == 1)
{
MaintenanceYear desiredYear = maintenanceCycle.MaintenanceYears.FirstOrDefault(x => x.Year == (recoverYear.Year - 1));
if (desiredYear != null)
{
newYear.MaintenanceType.Name = desiredYear.MaintenanceType.Name;
}
else
{
continue;
}
}
else
{
newYear.MaintenanceType.Name = cycleYear.MaintenanceType.Name;
}
newYear.Year = cycleYear.Year;
continuationCycle.MaintenanceYears.Add(newYear);
}
return(continuationCycle);
}
protected void addNewRecord(MaintenanceCycle maintenanceCycle, MaintainedEquipment equipment, int maintainedYear, int initialYear, int currentYear)
{
MaintenanceRecord newRecord = new MaintenanceRecord();
MaintenanceYear year = maintenanceCycle.MaintenanceYears.FirstOrDefault(x => x.Year == maintainedYear);
if (year != null)
{
newRecord = new MaintenanceRecord();
newRecord.MaintainedEquipment = equipment;
if (DateTime.Now.Year > (initialYear + currentYear))
{
newRecord.ActualMaintenanceDate = new DateTime(initialYear + currentYear, 1, 1);
newRecord.ActualMaintenanceType = dataBase.MaintenanceTypes.GetAll().First(x => x.Name == year.MaintenanceType.Name);
newRecord.IsPlanned = true;
}
else if (DateTime.Now.Year == (initialYear + currentYear))
{
newRecord.IsPlanned = true;
}
newRecord.PlannedMaintenanceDate = new DateTime(initialYear + currentYear, 1, 1);
newRecord.PlannedMaintenanceType = dataBase.MaintenanceTypes.GetAll().First(x => x.Name == year.MaintenanceType.Name);
dataBase.MaintenanceRecords.Create(newRecord);
}
}
public void Create(MaintenanceCycleModel maintenanceCycleModel)
{
MaintenanceCycle maintenanceCycle = new MaintenanceCycle();
MaintenanceYear maintenanceYear;
List <MaintenanceType> maintenanceTypes = new List <MaintenanceType>(dataBase.MaintenanceTypes.GetAll());
maintenanceCycle.Name = maintenanceCycleModel.Name;
maintenanceCycle.ShowName = maintenanceCycleModel.ShowName;
maintenanceCycle.MaintenanceYears = new List <MaintenanceYear>();
dataBase.MaintenanceCycles.Create(maintenanceCycle);
for (int i = 0; i < maintenanceCycleModel.MaintenanceTypes.Length; i++)
{
if (maintenanceCycleModel.MaintenanceTypes[i] != null)
{
maintenanceYear = new MaintenanceYear();
maintenanceYear.Year = i;
maintenanceYear.MaintenanceType = maintenanceTypes.First(x => x.Name == maintenanceCycleModel.MaintenanceTypes[i]);
maintenanceYear.MaintenanceCycle = maintenanceCycle;
dataBase.MaintenanceYears.Create(maintenanceYear);
}
}
dataBase.MaintenanceCycles.Create(maintenanceCycle);
dataBase.Save();
}
public void UpdateRecords(MaintenanceCycle newMaintenanceCycle, AdditionalWork t)
{
updateCombineDeviceRecords(newMaintenanceCycle, t);
}
/// <summary>
/// Обновление графика устройства по циклу ТО
/// </summary>
/// <param name="maintenanceCycle">Новый цикл технического обслуживания</param>
/// <param name="device">Устройство для которого обновляется график</param>
protected void updateDeviceRecords(MaintenanceCycle maintenanceCycle, Device device)
{
List <MaintenanceRecord> deleteMaintenanceRecords = dataBase.Devices.Read(device.MaintainedEquipmentId).MaintenanceRecords.FindAll(x => x.ActualMaintenanceDate == null &&
!(x.IsPlanned || x.IsRescheduled));
foreach (MaintenanceRecord record in deleteMaintenanceRecords)
{
dataBase.MaintenanceRecords.Delete(record);
}
MaintenanceCycle continuationCycle = getContinuationCycle(maintenanceCycle);
MaintenanceYear recoverYear = maintenanceCycle.MaintenanceYears.First(x => x.MaintenanceType.Name.Contains("В"));
if (device.MaintenanceRecords.Count == 0)
{
int initialYear = device.InputYear.Value;
int currentYear = 0;
for (int i = 0; i <= recoverYear.Year; i++, currentYear++)
{
//if (checkYear(initialYear + currentYear)) continue;
addNewRecord(maintenanceCycle, device, i, initialYear, currentYear);
}
for (int i = currentYear, maintainedYear = 1; i <= DateTime.Now.Year + 10; i++, maintainedYear++, currentYear++)
{
if (maintainedYear > recoverYear.Year)
{
maintainedYear = 1;
}
//if (checkYear(initialYear + currentYear)) continue;
addNewRecord(continuationCycle, device, maintainedYear, initialYear, currentYear);
}
}
else
{
MaintenanceRecord lastRecoverMaintenanceRecord = device.MaintenanceRecords.FindLast(x => x.PlannedMaintenanceType.Name.Contains("В") ||
x.PlannedMaintenanceType.Name.Contains("Н"));
int initialYear = lastRecoverMaintenanceRecord.PlannedMaintenanceDate.Year;
int nextMaintainedYear;
if (DateTime.Now.Month > 1)
{
nextMaintainedYear = DateTime.Now.Year - initialYear + 1;
}
else
{
nextMaintainedYear = DateTime.Now.Year - initialYear;
}
int checkPeriod = recoverYear.Year - maintenanceCycle.MaintenanceYears.Last(x => x.MaintenanceType.Name.Contains("К")).Year;
if (checkYear(initialYear + recoverYear.Year))
{
addNewRecord(maintenanceCycle, device, recoverYear.Year, initialYear, nextMaintainedYear);
lastRecoverMaintenanceRecord = device.MaintenanceRecords.Last();
initialYear = lastRecoverMaintenanceRecord.PlannedMaintenanceDate.Year;
nextMaintainedYear = 1;
}
else if (checkPeriod != 1)
{
if (maintenanceCycle.MaintenanceYears.FirstOrDefault(x => x.Year == nextMaintainedYear - 1 && x.MaintenanceType.Name.Contains("К")) != null)
{
addNewRecord(maintenanceCycle, device, nextMaintainedYear - 1, initialYear, nextMaintainedYear);
nextMaintainedYear++;
}
else if (device.MaintenanceRecords.Last().PlannedMaintenanceType.Name.Contains("К") &&
maintenanceCycle.MaintenanceYears.FirstOrDefault(x => x.Year == nextMaintainedYear && x.MaintenanceType.Name.Contains("К")) != null &&
maintenanceCycle.MaintenanceYears.FirstOrDefault(x => x.Year == nextMaintainedYear + 1 && x.MaintenanceType.Name.Contains("К")) == null)
{
addNewRecord(maintenanceCycle, device, nextMaintainedYear, initialYear, nextMaintainedYear + 1);
nextMaintainedYear += 2;
}
}
int currentYear = 0;
if (lastRecoverMaintenanceRecord.PlannedMaintenanceType.Name.Contains("Н"))
{
for (int i = nextMaintainedYear; i <= recoverYear.Year; i++, currentYear++)
{
//if (checkYear(initialYear + nextMaintainedYear + currentYear)) continue;
addNewRecord(maintenanceCycle, device, i, initialYear, nextMaintainedYear + currentYear);
}
for (int i = currentYear, maintainedYear = 1; i <= 10; i++, maintainedYear++, currentYear++)
{
if (maintainedYear > recoverYear.Year)
{
maintainedYear = 1;
}
//if (checkYear(initialYear + nextMaintainedYear + currentYear)) continue;
addNewRecord(continuationCycle, device, maintainedYear, initialYear, nextMaintainedYear + currentYear);
}
}
else if (lastRecoverMaintenanceRecord.PlannedMaintenanceType.Name.Contains("В"))
{
for (int i = currentYear, maintainedYear = nextMaintainedYear; i <= 10; i++, maintainedYear++, currentYear++)
{
if (maintainedYear > recoverYear.Year)
{
maintainedYear = 1;
}
//if (checkYear(initialYear + nextMaintainedYear + currentYear)) continue;
addNewRecord(continuationCycle, device, maintainedYear, initialYear, nextMaintainedYear + currentYear);
}
}
}
//удалить потом
//device.LastRecovery = device.MaintenanceRecords.FindLast(x => x.ActualMaintenanceType != null && (x.ActualMaintenanceType.Name.Contains("В") ||
// x.ActualMaintenanceType.Name.Contains("Н"))).ActualMaintenanceDate;
dataBase.Save();
}
public void Update(MaintenanceCycle t)
{
dataBase.MaintenanceCycles.Update(t);
}
public void Read(IUnitOfWork unitOfWork)
{
Excel.Application excel = new Excel.Application();
string path = Directory.GetCurrentDirectory();
path += "\\data.xlsx";
excel.Workbooks.Open(path, Password: 1);
Excel.Worksheet workSheet = excel.ActiveSheet;
Excel.Range excelRange;
int lol = 0;
int randomNumber = 0;
Random rand = new Random();
List <string> liders = new List <string> {
"Бушланов", "Васькович", "Солодухин", "Шилько", "Цапкин"
};
List <string> shortName = new List <string> {
"П3", "П1", "П2", "Н", "В"
};
MaintainedEquipmentEnum equipmentEnum = MaintainedEquipmentEnum.None;
List <ManagementOrganization> organizations = new List <ManagementOrganization>();
List <Team> teams = new List <Team>();
List <Substation> substations = new List <Substation>();
List <Attachment> attachments = new List <Attachment>();
List <InspectionsFrequency> inspections = new List <InspectionsFrequency>();
List <ElementBase> elementBases = new List <ElementBase>();
List <MaintenanceYear> maintenanceYears = new List <MaintenanceYear>();
List <MaintenanceCycle> cycles = new List <MaintenanceCycle>();
List <Act> acts = new List <Act>();
List <MaintenanceType> maintenanceTypes = new List <MaintenanceType>();
TransformerType typeTranformer = new TransformerType();
typeTranformer.Name = "Неуказан";
unitOfWork.TransformerTypes.Create(typeTranformer);
unitOfWork.Save();
DistrictElectricalNetwork network = new DistrictElectricalNetwork();
network.Name = "Неуказан";
network.Head = "Неуказан";
unitOfWork.DistricElectricalNetworks.Create(network);
unitOfWork.Save();
VoltageClass voltageClass = new VoltageClass();
voltageClass.Name = "Не указан";
unitOfWork.VoltageClasses.Create(voltageClass);
unitOfWork.Save();
Manufacturer manufacturer = new Manufacturer();
manufacturer.Name = "Не указан";
unitOfWork.Manufacturers.Create(manufacturer);
unitOfWork.Save();
DeviceType deviceType = new DeviceType();
deviceType.Name = "Не указан";
unitOfWork.DeviceTypes.Create(deviceType);
unitOfWork.Save();
Act withoutAct = new Act();
withoutAct.Name = "Не указан";
withoutAct.CreationDate = new DateTime(2015, 2, 1);
unitOfWork.Acts.Create(withoutAct);
unitOfWork.Save();
for (int number = 0; number < liders.Count; number++)
{
Team newTeam = new Team();
newTeam.Leader = liders[number];
newTeam.Name = shortName[number];
teams.Add(newTeam);
unitOfWork.Teams.Create(newTeam);
unitOfWork.Save();
}
bool viewedAllSubstation = false;
int startRecord = 3;
int lastRecord = 400; //1875;
for (int i = startRecord; i <= lastRecord; i++)
{
excelRange = workSheet.Rows[i];
if (Convert.ToString(excelRange.Cells[1, 6].Value2) == "все устройства")
{
equipmentEnum = MaintainedEquipmentEnum.Substation;
}
else if (Convert.ToString(excelRange.Cells[1, 8].Value2) == null && Convert.ToString(excelRange.Cells[1, 10].Value2) != null)
{
equipmentEnum = MaintainedEquipmentEnum.AdditionalDevice;
}
else if (Convert.ToString(excelRange.Cells[1, 8].Value2) == null && Convert.ToString(excelRange.Cells[1, 10].Value2) == null)
{
equipmentEnum = MaintainedEquipmentEnum.CombineDevice;
}
else if (Convert.ToString(excelRange.Cells[1, 8].Value2) != null && Convert.ToString(excelRange.Cells[1, 10].Value2) != null)
{
equipmentEnum = MaintainedEquipmentEnum.Device;
}
if (equipmentEnum != MaintainedEquipmentEnum.Substation && !viewedAllSubstation)
{
if (lastRecord == i)
{
viewedAllSubstation = true;
i = startRecord;
}
continue;
}
if (equipmentEnum == MaintainedEquipmentEnum.Substation && viewedAllSubstation)
{
continue;
}
ManagementOrganization organization = new ManagementOrganization();
organization.Name = Convert.ToString(excelRange.Cells[1, 1].Value2);
if (!organizations.Exists(x => x.Name == organization.Name))
{
organizations.Add(organization);
unitOfWork.ManagementOrganizations.Create(organization);
unitOfWork.Save();
}
else
{
organization = organizations.Find(x => x.Name == organization.Name);
}
Team team = new Team();
string liderShortName = Convert.ToString(excelRange.Cells[1, 2].Value2);
team = teams.Find(x => x.Name == liderShortName);
Substation substation = new Substation();
substation.Name = Convert.ToString(excelRange.Cells[1, 3].Value2);
substation.Name = substation.Name.TrimEnd();
if (substations.Exists(x => x.Name == substation.Name))
{
if (!viewedAllSubstation)
{
continue;
}
substation = substations.Find(x => x.Name == substation.Name);
}
substation.Team = team;
substation.DistrictElectricalNetwork = network;
substation.TransformerType = typeTranformer;
Attachment attachment = new Attachment();
attachment.Name = Convert.ToString(excelRange.Cells[1, 5].Value2);
attachment.ManagementOrganization = organization;
attachment.VoltageClass = voltageClass;
switch (equipmentEnum)
{
case MaintainedEquipmentEnum.Substation:
{
InspectionsFrequency period = new InspectionsFrequency();
period.Name = Convert.ToString(excelRange.Cells[1, 10].Value2);
MaintenanceType type = new MaintenanceType();
type.Name = "осмотр";
if (!maintenanceTypes.Any(x => x.Name == type.Name))
{
maintenanceTypes.Add(type);
unitOfWork.MaintenanceTypes.Create(type);
unitOfWork.Save();
}
else
{
type = maintenanceTypes.Find(x => x.Name == type.Name);
}
MaintenanceRecord record = new MaintenanceRecord();
List <MaintenanceRecord> maintenanceRecords = new List <MaintenanceRecord>();
substation.InputYear = Convert.ToInt32(workSheet.Cells[1, 18].Value2);
if (period.Name.StartsWith("1 раз в месяц"))
{
period.Count = 12;
string inspection = excelRange.Cells[1, 10].Value2;
if (inspection != null)
{
for (int column = 18; column < 39; column++)
{
for (int workingMonth = 1; workingMonth <= 12; workingMonth++)
{
record = new MaintenanceRecord();
int year = Convert.ToInt32(workSheet.Cells[1, column].Value2);
record.PlannedMaintenanceDate = new DateTime(year, workingMonth, 1);
record.PlannedMaintenanceType = type;
if (year < DateTime.Now.Year || (year == DateTime.Now.Year && workingMonth <= DateTime.Now.Month))
{
record.ActualMaintenanceDate = new DateTime(year, workingMonth, 1);
record.ActualMaintenanceType = type;
}
maintenanceRecords.Add(record);
}
}
}
}
else if (period.Name.StartsWith("1 раз в 6"))
{
period.Count = 2;
for (int column = 18; column < 39; column++)
{
string inspection = excelRange.Cells[1, 10].Value2;
if (inspection != null)
{
for (int workingMonth = 1; workingMonth <= 2; workingMonth++)
{
record = new MaintenanceRecord();
int year = Convert.ToInt32(workSheet.Cells[1, column].Value2);
record.PlannedMaintenanceDate = new DateTime(year, 4 * workingMonth, 1);
record.PlannedMaintenanceType = type;
if (year < DateTime.Now.Year)
{
record.ActualMaintenanceDate = new DateTime(year, 4 * workingMonth, 1);
record.ActualMaintenanceType = type;
}
maintenanceRecords.Add(record);
}
}
}
}
else if (period.Name.StartsWith("1 раз в 12"))
{
period.Count = 1;
for (int column = 18; column < 39; column++)
{
string inspection = excelRange.Cells[1, 10].Value2;
if (inspection != null)
{
record = new MaintenanceRecord();
int year = Convert.ToInt32(workSheet.Cells[1, column].Value2);
record.PlannedMaintenanceDate = new DateTime(year, 5, 1);
record.PlannedMaintenanceType = type;
if (year < DateTime.Now.Year)
{
record.ActualMaintenanceDate = new DateTime(year, 5, 1);
record.ActualMaintenanceType = type;
}
maintenanceRecords.Add(record);
}
}
}
if (!inspections.Exists(x => x.Name == period.Name))
{
inspections.Add(period);
unitOfWork.InspectionsFrequencies.Create(period);
unitOfWork.Save();
}
else
{
period = inspections.Find(x => x.Name == period.Name);
}
if (!substations.Exists(x => x.Name == substation.Name))
{
substation.InspectionsFrequency = period;
substations.Add(substation);
unitOfWork.Substations.Create(substation);
unitOfWork.Save();
}
else
{
substation = substations.Find(x => x.Name == substation.Name);
}
foreach (MaintenanceRecord rec in maintenanceRecords)
{
rec.MaintainedEquipment = substation;
unitOfWork.MaintenanceRecords.Create(rec);
unitOfWork.Save();
}
break;
}
case MaintainedEquipmentEnum.Device:
{
RelayDevice device = new RelayDevice();
device.Name = Convert.ToString(excelRange.Cells[1, 6].Value2);
device.MaintenanceRecords = new List <MaintenanceRecord>();
ElementBase elementBase = new ElementBase();
elementBase.Name = Convert.ToString(excelRange.Cells[1, 8].Value2);
if (!elementBases.Exists(x => x.Name == elementBase.Name))
{
elementBases.Add(elementBase);
unitOfWork.ElementBases.Create(elementBase);
unitOfWork.Save();
}
else
{
elementBase = elementBases.Find(x => x.Name == elementBase.Name);
}
device.ElementBase = elementBase;
device.Manufacturer = manufacturer;
device.MaintenancePeriod = Convert.ToInt32(excelRange.Cells[1, 9].Value2);
device.ExpiryYear = Convert.ToInt32(excelRange.Cells[1, 12].Value2);
device.InputYear = Convert.ToInt32(excelRange.Cells[1, 13].Value2);
string lastRecovery = Convert.ToString(excelRange.Cells[1, 14].Value2);
if (lastRecovery != null)
{
string[] array = lastRecovery.Split('-', '/');
if (array.Count() < 3)
{
array = new string[] { array[0], array[1], "16" };
}
try
{
device.LastRecovery = new DateTime(2000 + Convert.ToInt32(array[2]), Convert.ToInt32(array[1]), 1);
}
catch (ArgumentOutOfRangeException)
{
device.LastRecovery = new DateTime(2000 + Convert.ToInt32(array[1]), Convert.ToInt32(array[2]), 1);
}
catch (FormatException)
{
try
{
device.LastRecovery = new DateTime(2000 + Convert.ToInt32(array[2]), Convert.ToInt32(array[3]), 1);
}
catch (Exception)
{
device.LastRecovery = new DateTime(2000 + Convert.ToInt32(array[3]), Convert.ToInt32(array[2]), 1);
}
}
}
MaintenanceCycle cycle = new MaintenanceCycle();
randomNumber++;
cycle.Name = randomNumber.ToString();
cycle.MaintenanceYears = new List <MaintenanceYear>();
cycle.ShowName = Convert.ToString(excelRange.Cells[1, 10].Value2);
device.NormalMaintenanceCycle = cycle;
device.ReducedMaintenanceCycle = cycle;
bool recoveryFound = false;
int year = 8;
List <MaintenanceRecord> maintenanceRecords = new List <MaintenanceRecord>();
MaintenanceRecord record = new MaintenanceRecord();
for (int column = 38; column >= 18; column--)
{
MaintenanceType maintenanceType = new MaintenanceType();
maintenanceType.Name = Convert.ToString(excelRange.Cells[1, column].Value2);
if (maintenanceType.Name == " ")
{
maintenanceType.Name = null;
}
if (maintenanceType.Name != null)
{
maintenanceType.Name = maintenanceType.Name.Trim();
}
if (maintenanceType.Name != null && !maintenanceTypes.Exists(x => x.Name.Equals(maintenanceType.Name, StringComparison.InvariantCultureIgnoreCase)))
{
maintenanceTypes.Add(maintenanceType);
unitOfWork.MaintenanceTypes.Create(maintenanceType);
unitOfWork.Save();
}
else if (maintenanceTypes.Exists(x => x.Name.Equals(maintenanceType.Name, StringComparison.InvariantCultureIgnoreCase)))
{
maintenanceType = maintenanceTypes.First(x => x.Name.Equals(maintenanceType.Name, StringComparison.InvariantCultureIgnoreCase));
}
if (maintenanceType.Name == "В" && year == 8)
{
recoveryFound = true;
}
if (maintenanceType.Name != null)
{
int workYear = Convert.ToInt32(workSheet.Cells[1, column].Value2);
record = new MaintenanceRecord();
record.PlannedMaintenanceDate = new DateTime(workYear, 5, 1);
record.PlannedMaintenanceType = maintenanceType;
if (workYear < DateTime.Now.Year)
{
record.ActualMaintenanceDate = new DateTime(workYear, 5, 1);
record.ActualMaintenanceType = maintenanceType;
record.IsPlanned = true;
}
maintenanceRecords.Add(record);
}
if (recoveryFound && year >= 0 && maintenanceType.Name != null)
{
MaintenanceYear maintenanceYear = new MaintenanceYear();
maintenanceYear.MaintenanceType = maintenanceType;
maintenanceYear.Year = year;
maintenanceYear.MaintenanceCycle = cycle;
cycle.MaintenanceYears.Add(maintenanceYear);
if (year == 0)
{
recoveryFound = false;
}
}
if (recoveryFound)
{
year--;
}
}
List <MaintenanceCycle> searchCycle = cycles.FindAll(x => x.MaintenanceYears.Count == cycle.MaintenanceYears.Count);
bool exist = false;
foreach (MaintenanceCycle maintananceCycle in searchCycle)
{
for (int j = 0; j < maintananceCycle.MaintenanceYears.Count; j++)
{
if (maintananceCycle.MaintenanceYears[j].MaintenanceType == cycle.MaintenanceYears[j].MaintenanceType &&
maintananceCycle.MaintenanceYears[j].Year == cycle.MaintenanceYears[j].Year)
{
exist = true;
}
else
{
exist = false;
break;
}
}
if (exist)
{
device.NormalMaintenanceCycle = maintananceCycle;
device.ReducedMaintenanceCycle = maintananceCycle;
break;
}
}
if (!exist)
{
cycles.Add(cycle);
List <MaintenanceYear> years = new List <MaintenanceYear>();
years.AddRange(cycle.MaintenanceYears);
cycle.MaintenanceYears.Clear();
unitOfWork.MaintenanceCycles.Create(cycle);
unitOfWork.Save();
foreach (MaintenanceYear obj in years)
{
unitOfWork.MaintenanceYears.Create(obj);
unitOfWork.Save();
}
}
attachment.Name = attachment.Name.Trim();
if (!attachments.Exists(x => x.Name == attachment.Name))
{
attachment.Substation = substations.FirstOrDefault(x => x.Name == substation.Name);
attachments.Add(attachment);
unitOfWork.Attachments.Create(attachment);
unitOfWork.Save();
lol++;
}
else
{
attachment = attachments.First(x => x.Name == attachment.Name);
}
device.Act = withoutAct;
string act = Convert.ToString(excelRange.Cells[1, 11].Value2);
if (act != null && !act.StartsWith("вкл"))
{
Act actOfService = new Act();
actOfService.Name = act;
if (!acts.Exists(x => x.Name == actOfService.Name))
{
acts.Add(actOfService);
string[] strings = actOfService.Name.Split(' ');
DateTime date;
DateTime.TryParse(strings[2], out date);
actOfService.CreationDate = date;
unitOfWork.Acts.Create(actOfService);
unitOfWork.Save();
}
else
{
actOfService = acts.Find(x => x.Name == actOfService.Name);
}
device.Act = actOfService;
}
device.DeviceType = deviceType;
device.Attachment = attachment;
unitOfWork.Devices.Create(device);
unitOfWork.Save();
maintenanceRecords.Reverse();
foreach (MaintenanceRecord rec in maintenanceRecords)
{
rec.MaintainedEquipment = device;
unitOfWork.MaintenanceRecords.Create(rec);
unitOfWork.Save();
}
break;
}
case MaintainedEquipmentEnum.CombineDevice:
{
AdditionalWork additionalWork = new AdditionalWork();
additionalWork.Name = Convert.ToString(excelRange.Cells[1, 6].Value2);
additionalWork.MaintenanceRecords = new List <MaintenanceRecord>();
if (additionalWork.Name.StartsWith("прохождение"))
{
int k = 1;
}
MaintenanceCycle cycle = new MaintenanceCycle();
cycle.MaintenanceYears = new List <MaintenanceYear>();
randomNumber++;
cycle.Name = randomNumber.ToString();
cycle.ShowName = Convert.ToString(excelRange.Cells[1, 10].Value2);
if (cycle.ShowName == null)
{
cycle.ShowName = "Не назначено имя";
}
additionalWork.NormalMaintenanceCycle = cycle;
additionalWork.ReducedMaintenanceCycle = cycle;
bool recoveryFound = false;
int year = 0;
List <MaintenanceRecord> maintenanceRecords = new List <MaintenanceRecord>();
MaintenanceRecord record = new MaintenanceRecord();
for (int column = 18; column <= 38; column++)
{
MaintenanceType maintenanceType = new MaintenanceType();
maintenanceType.Name = Convert.ToString(excelRange.Cells[1, column].Value2);
if (maintenanceType.Name == " ")
{
maintenanceType.Name = null;
}
if (maintenanceType.Name != null && !maintenanceTypes.Exists(x => x.Name.Equals(maintenanceType.Name, StringComparison.InvariantCultureIgnoreCase)))
{
maintenanceTypes.Add(maintenanceType);
unitOfWork.MaintenanceTypes.Create(maintenanceType);
unitOfWork.Save();
}
else if (maintenanceTypes.Exists(x => x.Name.Equals(maintenanceType.Name, StringComparison.InvariantCultureIgnoreCase)))
{
maintenanceType = maintenanceTypes.First(x => x.Name.Equals(maintenanceType.Name, StringComparison.InvariantCultureIgnoreCase));
}
if (maintenanceType.Name != null && year == 0)
{
recoveryFound = true;
}
if (maintenanceType.Name != null)
{
int workYear = Convert.ToInt32(workSheet.Cells[1, column].Value2);
record = new MaintenanceRecord();
record.PlannedMaintenanceDate = new DateTime(workYear, 5, 1);
record.PlannedMaintenanceType = maintenanceType;
if (workYear < DateTime.Now.Year)
{
record.ActualMaintenanceDate = new DateTime(workYear, 5, 1);
record.ActualMaintenanceType = maintenanceType;
record.IsPlanned = true;
}
maintenanceRecords.Add(record);
if (maintenanceRecords.Count == 1)
{
additionalWork.InputYear = Convert.ToInt32(workSheet.Cells[1, column].Value2);
}
}
if (recoveryFound && year <= 8 && maintenanceType.Name != null)
{
MaintenanceYear maintenanceYear = new MaintenanceYear();
maintenanceYear.MaintenanceType = maintenanceType;
maintenanceYear.Year = year;
maintenanceYear.MaintenanceCycle = cycle;
cycle.MaintenanceYears.Add(maintenanceYear);
if (year == 8)
{
recoveryFound = false;
}
}
if (recoveryFound)
{
year++;
}
}
List <MaintenanceCycle> searchCycle = cycles.FindAll(x => x.MaintenanceYears.Count == cycle.MaintenanceYears.Count);
bool exist = false;
foreach (MaintenanceCycle maintananceCycle in searchCycle)
{
for (int j = 0; j < maintananceCycle.MaintenanceYears.Count; j++)
{
if (maintananceCycle.MaintenanceYears[j].MaintenanceType == cycle.MaintenanceYears[j].MaintenanceType &&
maintananceCycle.MaintenanceYears[j].Year == cycle.MaintenanceYears[j].Year)
{
exist = true;
}
else
{
exist = false;
break;
}
}
if (exist)
{
additionalWork.NormalMaintenanceCycle = maintananceCycle;
additionalWork.ReducedMaintenanceCycle = maintananceCycle;
break;
}
}
if (!exist)
{
cycles.Add(cycle);
List <MaintenanceYear> years = new List <MaintenanceYear>();
cycle.MaintenanceYears.Reverse();
years.AddRange(cycle.MaintenanceYears);
cycle.MaintenanceYears.Clear();
unitOfWork.MaintenanceCycles.Create(cycle);
unitOfWork.Save();
foreach (MaintenanceYear obj in years)
{
unitOfWork.MaintenanceYears.Create(obj);
unitOfWork.Save();
}
}
additionalWork.Substation = substations.FirstOrDefault(x => x.Name == substation.Name);
unitOfWork.AdditionalWorks.Create(additionalWork);
unitOfWork.Save();
foreach (MaintenanceRecord rec in maintenanceRecords)
{
rec.MaintainedEquipment = additionalWork;
unitOfWork.MaintenanceRecords.Create(rec);
unitOfWork.Save();
}
break;
}
case MaintainedEquipmentEnum.AdditionalDevice:
{
AdditionalDevice additionalDevice = new AdditionalDevice();
additionalDevice.Name = Convert.ToString(excelRange.Cells[1, 6].Value2);
additionalDevice.MaintenanceRecords = new List <MaintenanceRecord>();
additionalDevice.MaintenancePeriod = 25;
string lastRecovery = Convert.ToString(excelRange.Cells[1, 14].Value2);
if (lastRecovery != null)
{
string[] array = lastRecovery.Split('-', '/');
if (array.Count() < 3)
{
array = new string[] { array[0], array[1], "16" };
}
try
{
additionalDevice.LastRecovery = new DateTime(2000 + Convert.ToInt32(array[2]), Convert.ToInt32(array[1]), 1);
}
catch (ArgumentOutOfRangeException)
{
additionalDevice.LastRecovery = new DateTime(2000 + Convert.ToInt32(array[1]), Convert.ToInt32(array[2]), 1);
}
catch (FormatException)
{
try
{
additionalDevice.LastRecovery = new DateTime(2000 + Convert.ToInt32(array[2]), Convert.ToInt32(array[3]), 1);
}
catch (Exception)
{
additionalDevice.LastRecovery = new DateTime(2000 + Convert.ToInt32(array[3]), Convert.ToInt32(array[2]), 1);
}
}
}
MaintenanceCycle cycle = new MaintenanceCycle();
cycle.MaintenanceYears = new List <MaintenanceYear>();
randomNumber++;
cycle.Name = randomNumber.ToString();
cycle.ShowName = Convert.ToString(excelRange.Cells[1, 10].Value2);
additionalDevice.NormalMaintenanceCycle = cycle;
additionalDevice.ReducedMaintenanceCycle = cycle;
bool recoveryFound = false;
int year = 0;
List <MaintenanceRecord> maintenanceRecords = new List <MaintenanceRecord>();
MaintenanceRecord record = new MaintenanceRecord();
for (int column = 18; column <= 38; column++)
{
MaintenanceType maintenanceType = new MaintenanceType();
maintenanceType.Name = Convert.ToString(excelRange.Cells[1, column].Value2);
if (maintenanceType.Name == " ")
{
maintenanceType.Name = null;
}
if (maintenanceType.Name != null && !maintenanceTypes.Exists(x => x.Name.Equals(maintenanceType.Name, StringComparison.InvariantCultureIgnoreCase)))
{
maintenanceTypes.Add(maintenanceType);
unitOfWork.MaintenanceTypes.Create(maintenanceType);
unitOfWork.Save();
}
else if (maintenanceTypes.Exists(x => x.Name.Equals(maintenanceType.Name, StringComparison.InvariantCultureIgnoreCase)))
{
maintenanceType = maintenanceTypes.First(x => x.Name.Equals(maintenanceType.Name, StringComparison.InvariantCultureIgnoreCase));
}
if (maintenanceType.Name != "В" && year == 0)
{
recoveryFound = true;
}
if (maintenanceType.Name != null)
{
int workYear = Convert.ToInt32(workSheet.Cells[1, column].Value2);
record = new MaintenanceRecord();
record.PlannedMaintenanceDate = new DateTime(workYear, 5, 1);
record.PlannedMaintenanceType = maintenanceType;
if (workYear < DateTime.Now.Year)
{
record.ActualMaintenanceDate = new DateTime(workYear, 5, 1);
record.ActualMaintenanceType = maintenanceType;
record.IsPlanned = true;
}
maintenanceRecords.Add(record);
}
if (recoveryFound && year >= 0 && maintenanceType.Name != null)
{
MaintenanceYear maintenanceYear = new MaintenanceYear();
maintenanceYear.MaintenanceType = maintenanceType;
maintenanceYear.Year = year;
maintenanceYear.MaintenanceCycle = cycle;
cycle.MaintenanceYears.Add(maintenanceYear);
if (year == 8)
{
recoveryFound = false;
}
}
if (recoveryFound)
{
year++;
}
}
additionalDevice.Act = withoutAct;
string act = Convert.ToString(excelRange.Cells[1, 11].Value2);
if (act != null)
{
Act actOfService = new Act();
actOfService.Name = act;
if (!acts.Any(x => x.Name == actOfService.Name))
{
string[] strings = actOfService.Name.Split(' ');
DateTime date;
DateTime.TryParse(strings[2], out date);
actOfService.CreationDate = date;
acts.Add(actOfService);
unitOfWork.Acts.Create(actOfService);
unitOfWork.Save();
}
else
{
actOfService = acts.Find(x => x.Name == actOfService.Name);
}
additionalDevice.Act = actOfService;
}
List <MaintenanceCycle> searchCycle = cycles.FindAll(x => x.MaintenanceYears.Count == cycle.MaintenanceYears.Count);
bool exist = false;
foreach (MaintenanceCycle maintananceCycle in searchCycle)
{
for (int j = 0; j < maintananceCycle.MaintenanceYears.Count; j++)
{
if (maintananceCycle.MaintenanceYears[j].MaintenanceType == cycle.MaintenanceYears[j].MaintenanceType &&
maintananceCycle.MaintenanceYears[j].Year == cycle.MaintenanceYears[j].Year)
{
exist = true;
}
else
{
exist = false;
break;
}
}
if (exist)
{
additionalDevice.NormalMaintenanceCycle = maintananceCycle;
additionalDevice.ReducedMaintenanceCycle = maintananceCycle;
break;
}
}
if (!exist)
{
cycles.Add(cycle);
List <MaintenanceYear> years = new List <MaintenanceYear>();
cycle.MaintenanceYears.Reverse();
years.AddRange(cycle.MaintenanceYears);
cycle.MaintenanceYears.Clear();
unitOfWork.MaintenanceCycles.Create(cycle);
unitOfWork.Save();
foreach (MaintenanceYear obj in years)
{
unitOfWork.MaintenanceYears.Create(obj);
unitOfWork.Save();
}
}
if (!attachments.Exists(x => x.Name == attachment.Name))
{
attachment.Substation = substations.FirstOrDefault(x => x.Name == substation.Name);
attachments.Add(attachment);
unitOfWork.Attachments.Create(attachment);
unitOfWork.Save();
}
else
{
attachment = attachments.First(x => x.Name == attachment.Name);
}
additionalDevice.Attachment = attachment;
unitOfWork.AdditionalDevices.Create(additionalDevice);
unitOfWork.Save();
foreach (MaintenanceRecord rec in maintenanceRecords)
{
rec.MaintainedEquipment = additionalDevice;
unitOfWork.MaintenanceRecords.Create(rec);
unitOfWork.Save();
}
break;
}
default:
{
break;
}
}
//unitOfWork.Save();
}
excel.Workbooks.Close();
}
public void UpdateRecords(MaintenanceCycle deletedMaintenanceCycle, MaintenanceCycle newMaintenanceCycle, AdditionalWork t)
{
t.NormalMaintenanceCycle = newMaintenanceCycle;
t.ReducedMaintenanceCycle = newMaintenanceCycle;
updateCombineDeviceRecords(newMaintenanceCycle, t);
}
public SelectingNewMaintenanceCycleViewModel(IServiceUnitOfWork serviceUnitOfWork, MaintenanceCycle maintenanceCycle)
{
this.serviceUnitOfWork = serviceUnitOfWork;
oldMaintenanceCycle = maintenanceCycle;
}
public void Create(MaintenanceCycle t)
{
dataBase.MaintenanceCycles.Create(t);
}
