public void SetPlannedMonth(ScheduleRecordModel scheduleRecordModel, string month)
{
if (scheduleRecordModel == null)
{
return;
}
MaintenanceRecord record = GetCurrentRecord(scheduleRecordModel);
if (string.IsNullOrEmpty(month))
{
record.IsPlanned = false;
record.ActualMaintenanceDate = null;
record.ActualMaintenanceType = null;
record.PlannedMaintenanceDate = GetNewDate(record, null);
scheduleRecordModel.IsPlanned = false;
scheduleRecordModel.PlannedMonth = string.Empty;
scheduleRecordModel.ActualMonth = string.Empty;
scheduleRecordModel.ActualMaintenanceType = null;
}
else
{
record.IsPlanned = true;
scheduleRecordModel.IsPlanned = true;
scheduleRecordModel.PlannedMonth = month;
record.PlannedMaintenanceDate = GetNewDate(record, month);
}
dataBase.MaintenanceRecords.Update(record);
dataBase.Save();
}
public void RescheduleRecord(AdditionalDevice additionalDevice, MaintenanceRecord record)
{
record.IsRescheduled = true;
MaintenanceRecord addedRecord = new MaintenanceRecord();
MaintenanceRecord nextRecord = additionalDevice.MaintenanceRecords.OrderBy(x => x.PlannedMaintenanceDate)
.FirstOrDefault(x => x.PlannedMaintenanceDate > record.PlannedMaintenanceDate);
if (nextRecord != null && nextRecord.PlannedMaintenanceDate.Year != record.PlannedMaintenanceDate.Year + 1)
{
addedRecord.PlannedMaintenanceDate = record.PlannedMaintenanceDate.AddYears(1);
addedRecord.MaintainedEquipment = additionalDevice;
addedRecord.PlannedMaintenanceType = record.PlannedMaintenanceType;
dataBase.MaintenanceRecords.Create(addedRecord);
}
else if (nextRecord != null && nextRecord.PlannedMaintenanceType.Name.Contains("В"))
{
return;
}
else if (record.PlannedMaintenanceType.Name.Contains("В"))
{
nextRecord.PlannedMaintenanceType = GetCurrentCycle(additionalDevice).MaintenanceYears.First(x => x.MaintenanceType.Name.Contains("В")).MaintenanceType;
dataBase.MaintenanceRecords.Update(nextRecord);
}
else if (record.PlannedMaintenanceType.Name.Contains("К") && !nextRecord.PlannedMaintenanceType.Name.Contains("К"))
{
nextRecord.PlannedMaintenanceType = GetCurrentCycle(additionalDevice).MaintenanceYears.First(x => x.MaintenanceType.Name.Contains("К")).MaintenanceType;
dataBase.MaintenanceRecords.Update(nextRecord);
}
else
{
return;
}
dataBase.Save();
}
public string EditRecord(MaintenanceRecord record)
{
try
{
if (record.Status == "未保养")
{
record.Status = "O";
}
else if (record.Status == "进行中")
{
record.Status = "D";
}
else
{
record.Status = "N";
}
var result = RestProxy.MaintenanceRecordServiceProxy.Edit(record);
if (result.HasError)
{
return("修改失败:" + result.Errors[0].ErrorMessage);
}
else
{
return("修改成功");
}
}
catch (RestException ex)
{
return("系统异常:" + ex.Message);
}
}
private ObservableCollection <RelayDeviceModel> getCollectionDeviceModel(IEnumerable <RelayDevice> relayDevices)
{
ObservableCollection <RelayDeviceModel> deviceModels = new ObservableCollection <RelayDeviceModel>();
List <RelayDevice> devices = dataBase.RelayDevices.GetAll().Intersect(relayDevices).ToList();
foreach (RelayDevice device in devices)
{
RelayDevice relayDevice = dataBase.RelayDevices.Read(device.MaintainedEquipmentId);
RelayDeviceModel relayDeviceModel = new RelayDeviceModel();
relayDeviceModel.MaintainedEquipmentId = relayDevice.MaintainedEquipmentId;
relayDeviceModel.Name = relayDevice.Name;
relayDeviceModel.InputYear = relayDevice.InputYear.Value;
relayDeviceModel.MaintenancePeriod = relayDevice.MaintenancePeriod;
if (relayDevice.LastRecovery != null)
{
relayDeviceModel.LastRecovery = relayDevice.LastRecovery.Value;
}
MaintenanceRecord record = relayDevice.MaintenanceRecords.Where(x => x.ActualMaintenanceDate != null).Last();
relayDeviceModel.LastMaintenanceDate = record.ActualMaintenanceDate.Value;
relayDeviceModel.LastMaintenanceType = record.ActualMaintenanceType;
record = relayDevice.MaintenanceRecords.Where(x => x.ActualMaintenanceDate == null).First();
relayDeviceModel.PlannedMaintenanceDate = record.PlannedMaintenanceDate;
relayDeviceModel.PlannedMaintenanceType = record.PlannedMaintenanceType;
relayDeviceModel.ElementBase = relayDevice.ElementBase;
deviceModels.Add(relayDeviceModel);
}
return(deviceModels);
}
public ObservableCollection <AdditionalDeviceModel> GetAll(Attachment attachment)
{
ObservableCollection <AdditionalDeviceModel> additionalDeviceModels = new ObservableCollection <AdditionalDeviceModel>();
foreach (AdditionalDevice additionalDevice in attachment.AdditionalDevices)
{
AdditionalDeviceModel additionalDeviceModel = new AdditionalDeviceModel();
additionalDeviceModel.MaintainedEquipmentId = additionalDevice.MaintainedEquipmentId;
additionalDeviceModel.Name = additionalDevice.Name;
additionalDeviceModel.InputYear = additionalDevice.InputYear;
additionalDeviceModel.MaintenancePeriod = additionalDevice.MaintenancePeriod;
if (additionalDevice.LastRecovery != null)
{
additionalDeviceModel.LastRecovery = additionalDevice.LastRecovery.Value;
}
MaintenanceRecord record = additionalDevice.MaintenanceRecords.Where(x => x.ActualMaintenanceDate != null).Last();
additionalDeviceModel.LastMaintenanceDate = record.ActualMaintenanceDate.Value;
additionalDeviceModel.LastMaintenanceType = record.ActualMaintenanceType;
record = additionalDevice.MaintenanceRecords.Where(x => x.ActualMaintenanceDate == null).FirstOrDefault();
if (record != null)
{
additionalDeviceModel.PlannedMaintenanceDate = record.PlannedMaintenanceDate;
additionalDeviceModel.PlannedMaintenanceType = record.PlannedMaintenanceType;
}
additionalDeviceModels.Add(additionalDeviceModel);
}
return(additionalDeviceModels);
}
public ActionResult DeleteConfirmed(int id)
{
MaintenanceRecord maintenanceRecord = db.MaintenanceRecords.Find(id);
db.MaintenanceRecords.Remove(maintenanceRecord);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static RestServiceResponse Add(MaintenanceRecord maintenanceRecord)
{
return(new ServiceClientBase("operate-maintenance-record").Call <RestServiceResponse <MaintenanceRecord> >(new RestServiceRequest <MaintenanceRecord>()
{
Body = maintenanceRecord,
ActionName = "Add"
}));
}
public IActionResult CreateUpdateMaintenanceRecord(MaintenanceRecord record)
{
var langRequest = Request.HttpContext.Features.Get <IRequestCultureFeature>();
var culture = langRequest.RequestCulture.Culture;
var _lang = culture.ToString();
if (record.RecordId != 0) // update
{
var getRecordById = _db.MaintenanceRecords.Find(record.RecordId);
if (getRecordById == null)
{
var result = new
{
status = 400,
message = (_lang == "en-US") ? "Specified Maintenance Record infromation does not exist" : "指定されたメンテナンス記録は存在しません。",
};
return(Json(result));
}
else
{
getRecordById.RecordDate = record.RecordDate;
getRecordById.Title = record.Title;
getRecordById.Note = record.Note;
_db.MaintenanceRecords.Update(getRecordById);
_db.SaveChanges();
var result = new
{
status = 200,
message = (_lang == "en-US") ? "Category information was updated." : "メンテナンス記録情報を更新しました。",
};
return(Json(result));
}
}
else // insert
{
var maintenance = new MaintenanceRecord()
{
MachineId = record.MachineId,
UserId = record.UserId,
RecordDate = record.RecordDate,
Title = record.Title,
Note = record.Note
};
_db.MaintenanceRecords.Add(maintenance);
_db.SaveChanges();
var result = new
{
status = 200,
message = (_lang == "en-US") ? "Category information was registed." : "メンテナンス記録情報を登録しました。",
};
return(Json(result));
}
}
public ActionResult Edit([Bind(Include = "maintId,equipId,maintType,cost,date")] MaintenanceRecord maintenanceRecord)
{
if (ModelState.IsValid)
{
db.Entry(maintenanceRecord).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.equipId = new SelectList(db.Equips, "equipId", "name", maintenanceRecord.equipId);
return(View(maintenanceRecord));
}
public void SetActualMonth(ScheduleRecordModel scheduleRecordModel, string month)
{
if (scheduleRecordModel == null || string.IsNullOrEmpty(month))
{
return;
}
MaintenanceRecord record = GetCurrentRecord(scheduleRecordModel);
record.ActualMaintenanceDate = GetNewDate(record, month);
dataBase.MaintenanceRecords.Update(record);
dataBase.Save();
}
public void MarkActualRecord(Substation substation, DateTime date)
{
MaintenanceRecord record = substation.MaintenanceRecords.FirstOrDefault(x => x.ActualMaintenanceDate == null && x.IsPlanned == true && x.IsRescheduled == false);
if (record == null)
{
return;
}
MaintenanceType type = dataBase.MaintenanceTypes.GetAll().First(x => x.Name == "осмотр");
record.ActualMaintenanceDate = date;
record.ActualMaintenanceType = type;
dataBase.Save();
}
// GET: MaintenanceRecords/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MaintenanceRecord maintenanceRecord = db.MaintenanceRecords.Find(id);
if (maintenanceRecord == null)
{
return(HttpNotFound());
}
return(View(maintenanceRecord));
}
private DateTime GetNewDate(MaintenanceRecord record, string month)
{
if (string.IsNullOrEmpty(month))
{
return(new DateTime(record.PlannedMaintenanceDate.Year, 1, 1));
}
string[] array = DateTimeFormatInfo.CurrentInfo.MonthNames;
DateTime dateTime = record.PlannedMaintenanceDate;
if (!array.Contains(month))
{
return(DateTime.Now);
}
return(new DateTime(dateTime.Year, Array.IndexOf(array, month) + 1, dateTime.Day));
}
// GET: MaintenanceRecords/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MaintenanceRecord maintenanceRecord = db.MaintenanceRecords.Find(id);
if (maintenanceRecord == null)
{
return(HttpNotFound());
}
ViewBag.equipId = new SelectList(db.Equips, "equipId", "name", maintenanceRecord.equipId);
return(View(maintenanceRecord));
}
public void MarkActualRecord(MaintainedEquipmentByCycle equpment, DateTime date, MaintenanceType type)
{
MaintenanceRecord record = equpment.MaintenanceRecords.FirstOrDefault(x => x.ActualMaintenanceDate == null && x.IsPlanned == true && x.IsRescheduled == false);
if (record == null)
{
return;
}
record.ActualMaintenanceDate = date;
record.ActualMaintenanceType = type;
if ((equpment is Device) && type.Name.Contains("В") || type.Name.Contains("Н"))
{
((Device)equpment).LastRecovery = date;
}
dataBase.Save();
}
/// <summary>
/// Initialize MaintenanceRecord object from form
/// </summary>
public MaintenanceRecord MaintenanceForAircraft()
{
MaintenanceRecord mr = new MaintenanceRecord();
mr.LastAltimeter = mfbLastAltimeter.Date;
mr.LastAnnual = mfbLastAnnual.Date;
mr.LastELT = mfbLastELT.Date;
mr.LastStatic = mfbLastPitotStatic.Date;
mr.LastTransponder = mfbLastTransponder.Date;
mr.LastVOR = mfbLastVOR.Date;
mr.LastNewEngine = mfbLastEngine.Value;
mr.Last100 = mfbLast100.Value;
mr.LastOilChange = mfbLastOil.Value;
mr.RegistrationExpiration = mfbRenewalDue.Date;
return(mr);
}
public void SetActualType(ScheduleRecordModel scheduleRecordModel, string type)
{
if (scheduleRecordModel == null || string.IsNullOrEmpty(type))
{
return;
}
MaintenanceRecord record = GetCurrentRecord(scheduleRecordModel);
MaintenanceType maintenanceType = dataBase.MaintenanceTypes.GetAll().FirstOrDefault(x => x.Name == type);
if (maintenanceType != null)
{
record.ActualMaintenanceType = maintenanceType;
dataBase.MaintenanceRecords.Update(record);
dataBase.Save();
}
}
public IActionResult OnGet(int?id)
{
MaintenanceRecord = new MaintenanceRecord();
if (id != null)
{
MaintenanceRecord = _unitOfWork.MaintenanceRecord.GetFirstOrDefault(mr => mr.Id == id);
if (MaintenanceRecord == null)
{
return(NotFound());
}
}
return(Page());
}
public void Update(Substation t)
{
List <MaintenanceRecord> deleteMaintenanceRecords = t.MaintenanceRecords.Where(x => x.ActualMaintenanceDate == null &&
!(x.IsPlanned || x.IsRescheduled)).ToList();
foreach (MaintenanceRecord deletedRecord in deleteMaintenanceRecords)
{
dataBase.MaintenanceRecords.Delete(deletedRecord);
}
dataBase.Save();
MaintenanceType type = dataBase.MaintenanceTypes.GetAll().First(x => x.Name == "осмотр");
List <MaintenanceRecord> maintenanceRecords = dataBase.Substations.Read(t.MaintainedEquipmentId).MaintenanceRecords;
MaintenanceRecord record;
int section = 12 / t.InspectionsFrequency.Count;
int currentYear = 0;
if (maintenanceRecords.Count == 0)
{
currentYear = t.InputYear.Value;
}
else
{
currentYear = t.MaintenanceRecords.Max(x => x.PlannedMaintenanceDate.Year) + 1;
}
for (int year = currentYear; year <= currentYear + 10; year++)
{
for (int i = 1; i <= t.InspectionsFrequency.Count; i++)
{
record = new MaintenanceRecord();
if (t.InspectionsFrequency.Count == 12)
{
record.PlannedMaintenanceDate = new DateTime(year, section * i, 1);
}
else
{
record.PlannedMaintenanceDate = new DateTime(year, 1, 1);
}
record.PlannedMaintenanceType = type;
record.IsPlanned = false;
record.IsRescheduled = false;
record.MaintainedEquipment = t;
dataBase.MaintenanceRecords.Create(record);
}
}
dataBase.Substations.Update(t);
dataBase.Save();
}
public EditMaintenanceRecordViewData(Person currentPerson, List <Models.Organization> organizations,
Models.TreatmentBMP treatmentBMP, bool isNew, Models.FieldVisit fieldVisit, EditAttributesViewData editMaintenanceRecordObservationsViewData) : base(currentPerson, fieldVisit, Models.FieldVisitSection.Maintenance)
{
SubsectionName = "Edit Maintenance Record";
IsNew = isNew;
EditMaintenanceRecordObservationsViewData = editMaintenanceRecordObservationsViewData;
AllOrganizations = organizations.OrderBy(x => x.OrganizationName).ToSelectListWithDisabledEmptyFirstRow(x => x.OrganizationID.ToString(CultureInfo.InvariantCulture),
x => x.OrganizationName, "Choose an Organization");
AllMaintenanceRecordTypes = MaintenanceRecordType.All.ToSelectListWithDisabledEmptyFirstRow(
x => x.MaintenanceRecordTypeID.ToString(CultureInfo.InvariantCulture),
x => x.MaintenanceRecordTypeDisplayName, "Choose a type");
TreatmentBMPUrl = treatmentBMP.GetDetailUrl();
MaintenanceRecordUrl = MaintenanceRecord?.GetDetailUrl();
}
private int countPipesMissing(MaintenanceRecord record)
{
int sum = 0;
foreach (bool[] ba in record.valvesPerPipeSystem_Rotating)
{
sum += ba.Count(false);
}
foreach (bool[] ba in record.valvesPerPipeSystem_StateChanges)
{
sum += ba.Count(false);
}
foreach (bool[] ba in record.fansPerPipeSystem)
{
sum += ba.Count(false);
}
return(sum);
}
public IActionResult Edit(MaintenanceRecordViewModel obj)
{
//check for valid view model
if (ModelState.IsValid)
{
using (MaintenanceRecordDBContext db = new MaintenanceRecordDBContext())
{
//object for view model
MaintenanceRecord mr = obj.NewMaintenanceRecord;
//retrieve primary key/id from route data
mr.MaintenanceRecordId = Guid.Parse(RouteData.Values["id"].ToString());
//update record status
db.Entry(mr).State = EntityState.Modified;
db.SaveChanges();
}
}
return(RedirectToAction("Index"));
}
// GET: MaintenanceRecords/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MaintenanceRecord maintenanceRecord = db.MaintenanceRecords.Find(id);
if (maintenanceRecord == null)
{
return(HttpNotFound());
}
List <String> equipType = new List <String>(new string[] { "", "" });
if (maintenanceRecord.TblEquip.type == "Truck" || maintenanceRecord.TblEquip.type == "Trailer")
{
//get the id from the proper table
foreach (var item in db.Vehicles)
{
if (item.equipId == maintenanceRecord.TblEquip.equipId)
{
equipType[0] = item.vehId.ToString();
}
}
equipType[1] = "vehicle";
}
else
{
foreach (var item in db.Tools)
{
if (item.equipId == maintenanceRecord.TblEquip.equipId)
{
equipType[0] = item.toolId.ToString();
}
}
equipType[1] = "tool";
}
ViewBag.equipType = equipType;
return(View(maintenanceRecord));
}
public string AddRecord(MaintenanceRecord record)
{
try
{
var result = RestProxy.MaintenanceRecordServiceProxy.Add(record);
if (result.HasError)
{
return("添加失败:" + result.Errors[0].ErrorMessage);
}
else
{
return("添加成功");
}
}
catch (RestException ex)
{
return("系统异常:" + ex.Message);
}
}
public ObservableCollection <AdditionalWorkModel> GetAll(RelayDevice device)
{
ObservableCollection <AdditionalWorkModel> additionalWorkModels = new ObservableCollection <AdditionalWorkModel>();
foreach (AdditionalWork combineDevice in device.CombineDevices)
{
AdditionalWorkModel additionalWorkModel = new AdditionalWorkModel();
additionalWorkModel.MaintainedEquipmentId = combineDevice.MaintainedEquipmentId;
additionalWorkModel.Name = combineDevice.Name;
additionalWorkModel.InputYear = combineDevice.InputYear;
MaintenanceRecord record = combineDevice.MaintenanceRecords.Where(x => x.ActualMaintenanceDate != null).Last();
additionalWorkModel.LastMaintenanceDate = record.ActualMaintenanceDate.Value;
additionalWorkModel.LastMaintenanceType = record.ActualMaintenanceType;
record = combineDevice.MaintenanceRecords.Where(x => x.ActualMaintenanceDate == null).First();
additionalWorkModel.PlannedMaintenanceDate = record.PlannedMaintenanceDate;
additionalWorkModel.PlannedMaintenanceType = record.PlannedMaintenanceType;
additionalWorkModels.Add(additionalWorkModel);
}
return(additionalWorkModels);
}
public static MaintenanceRecordSource BuildMaintenanceRecordSource(MaintenanceRecord maintenanceRecord)
{
if (maintenanceRecord == null)
{
return(null);
}
var maintenanceRecordSource = new MaintenanceRecordSource();
maintenanceRecordSource.Content = maintenanceRecord.Content;
maintenanceRecordSource.DeviceInfo = DeviceInfoTransfer.BuildDeviceInfoSource(maintenanceRecord.DeviceInfo);
maintenanceRecordSource.Id = maintenanceRecord.Id;
maintenanceRecordSource.MaintainBeginTime = Utility.ConvertDateTime(maintenanceRecord.MaintainBeginTime);
maintenanceRecordSource.MaintainEndTime = Utility.ConvertDateTime(maintenanceRecord.MaintainEndTime);
maintenanceRecordSource.MaintenancePlan = MaintenancePlanTransfer.BuildMaintenancePlanSource(maintenanceRecord.MaintenancePlan);
maintenanceRecordSource.Persons = maintenanceRecord.Persons;
maintenanceRecordSource.Remark = maintenanceRecord.Remark;
maintenanceRecordSource.ScheduleTime = Utility.ConvertDateTime(maintenanceRecord.ScheduleTime);
maintenanceRecordSource.Status = typeof(MaintenanceRecordStatus).GetValueByEnum(maintenanceRecord.Status);
return(maintenanceRecordSource);
}
public static MaintenanceRecord BuildMaintenanceRecord(MaintenanceRecordSource maintenanceRecordSource)
{
if (maintenanceRecordSource == null)
{
return(null);
}
var maintenanceRecord = new MaintenanceRecord();
maintenanceRecord.Content = maintenanceRecordSource.Content;
maintenanceRecord.CreationDate = Utility.ConvertDateTime(maintenanceRecordSource.CreationDate);
maintenanceRecord.DeviceInfo = DeviceInfoTransfer.BuildDeviceInfo(maintenanceRecordSource.DeviceInfo);
maintenanceRecord.Id = maintenanceRecordSource.Id;
maintenanceRecord.MaintainBeginTime = Utility.ConvertDateTime(maintenanceRecordSource.MaintainBeginTime);
maintenanceRecord.MaintainEndTime = Utility.ConvertDateTime(maintenanceRecordSource.MaintainEndTime);
maintenanceRecord.MaintenancePlan = MaintenancePlanTransfer.BuildMaintenancePlan(maintenanceRecordSource.MaintenancePlan);
maintenanceRecord.ModifiedDate = Utility.ConvertDateTime(maintenanceRecordSource.ModifiedDate);
maintenanceRecord.Persons = maintenanceRecordSource.Persons;
maintenanceRecord.Remark = maintenanceRecordSource.Remark;
maintenanceRecord.ScheduleTime = Utility.ConvertDateTime(maintenanceRecordSource.ScheduleTime);
maintenanceRecord.Status = (MaintenanceRecordStatus)typeof(MaintenanceRecordStatus).GetEnumByValue(maintenanceRecordSource.Status);
return(maintenanceRecord);
}
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);
}
}
private void OnEnable()
{
Log.Verbose("Starting maintenance mode...");
room = Ets.Room;
pipes = room.GetGame <PipesGame>();
lighting.SwitchAllLights(LightSetting.On);
success = false;
readInitialState = true;
record = new MaintenanceRecord();
// pipes
List <int> valvesPerPipeSystem = new List <int>();
List <int> fansPerPipeSystem = new List <int>();
foreach (PipeSystem ps in pipes.PipeSystems())
{
valvesPerPipeSystem.Add(ps.ValveCount);
fansPerPipeSystem.Add(ps.FanCount);
}
initialValveStates = new bool[valvesPerPipeSystem.Count][];
record.valvesPerPipeSystem_Rotating = new bool[valvesPerPipeSystem.Count][];
record.valvesPerPipeSystem_StateChanges = new bool[valvesPerPipeSystem.Count][];
for (int i = 0; i < valvesPerPipeSystem.Count; i++)
{
initialValveStates[i] = new bool[valvesPerPipeSystem[i]];
record.valvesPerPipeSystem_Rotating[i] = new bool[valvesPerPipeSystem[i]];
record.valvesPerPipeSystem_StateChanges[i] = new bool[valvesPerPipeSystem[i]];
}
record.fansPerPipeSystem = new bool[fansPerPipeSystem.Count][];
for (int i = 0; i < fansPerPipeSystem.Count; i++)
{
record.fansPerPipeSystem[i] = new bool[fansPerPipeSystem[i]];
}
foreach (Fan f in pipes.Fans())
{
room.Physical.SetFanState(f.Row, f.PositionInRow, true);
}
// crane
record.craneButtons = new bool[CratesGame.ButtonCount];
// dynamite
initialHoleStates = new int[DynamiteGame.HoleCount];
record.holes = new bool[DynamiteGame.HoleCount];
// trigger
record.triggerButtons = new bool[TriggersGame.ButtonCount];
Color[] colors = new Color[TriggersGame.LedCount];
for (int i = 0; i < colors.Length; i++)
{
colors[i] = Color.blue;
}
room.Physical.SetLEDColors(colors);
Log.Verbose("Maintenance mode started. Waiting for input...");
}
public void Update(MaintenanceRecord t)
{
throw new NotImplementedException();
}
