public IActionResult Update(int id, [FromBody] MaintenanceItem item)
{
if (item == null)
{
return(BadRequest());
}
MaintenanceItem maintenanceItem = _context.MAINTENANCE_ITEMS.Find(id);
if (maintenanceItem == null)
{
return(NotFound());
}
maintenanceItem.INDICATION = item.INDICATION;
maintenanceItem.KEY_POINT = item.KEY_POINT;
maintenanceItem.NOTE = item.NOTE;
maintenanceItem.PERIOD = item.PERIOD;
maintenanceItem.PROJECT_NAME = item.PROJECT_NAME;
maintenanceItem.RESPONSIBLE = item.RESPONSIBLE;
maintenanceItem.DETAIL = item.DETAIL;
_context.MAINTENANCE_ITEMS.Update(maintenanceItem);
_context.SaveChanges();
return(Ok(maintenanceItem));
}
public async Task <IActionResult> PutMaintenanceItem(Guid id, MaintenanceItem maintenanceItem)
{
if (id != maintenanceItem.ItemId)
{
return(BadRequest());
}
await maintenanceItemService.PutMaintenanceItem(maintenanceItem);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!maintenanceItemService.MaintenanceItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task PostMaintenanceItem(MaintenanceItem maintenanceItem)
{
_context.MaintenanceItems.Add(maintenanceItem);
List <ScheduleItemComputer> scheduleItemComputerList = await(from sic in _context.ScheduleItemComputers
where sic.ItemId == maintenanceItem.ItemId
select new ScheduleItemComputer
{
Id = sic.Id,
}).ToListAsync();
if (scheduleItemComputerList.Count() > 0)
{
ScheduleMaintenanceItem scheduleMaintenanceItem;
List <ScheduleMaintenanceItem> scheduleMaintenanceItems = new List <ScheduleMaintenanceItem>();
Schedule schedule;
List <Schedule> schedules = new List <Schedule>();
var registrationDate = DateTime.Now;
var dateYearsPeriod = registrationDate.AddYears(4).Year;
foreach (var scheduleItemComputer in scheduleItemComputerList)
{
scheduleMaintenanceItem = new ScheduleMaintenanceItem();
scheduleMaintenanceItem.Id = Guid.NewGuid();
scheduleMaintenanceItem.ScheduleItemComputerId = scheduleItemComputer.Id;
scheduleMaintenanceItem.MaintenanceId = maintenanceItem.MaintenanceId;
scheduleMaintenanceItems.Add(scheduleMaintenanceItem);
}
foreach (var scheduleMI in scheduleMaintenanceItems)
{
var dateAddMonth = registrationDate;
while (dateAddMonth.Year < dateYearsPeriod)
{
schedule = new Schedule();
schedule.Id = Guid.NewGuid();
schedule.ScheduleMaintenanceItemId = scheduleMI.Id;
schedule.Status = Status.Pending;
dateAddMonth = dateAddMonth.AddMonths(maintenanceItem.Period);
schedule.MaintenanceDate = dateAddMonth;
schedules.Add(schedule);
}
}
_context.ScheduleMaintenanceItems.AddRange(scheduleMaintenanceItems);
_context.Schedules.AddRange(schedules);
}
}
private void DeleteMaintenanceItemButton_Click(object sender, RoutedEventArgs e)
{
if (SelectedCompleteItem != null)
{
DeleteSelectedCompleteItem();
}
else if (SelectedMaintenanceItem != null)
{
MaintenanceItems.Remove(SelectedMaintenanceItem);
SelectedMaintenanceItem = null;
DrawMaintenanceItems();
}
}
public async Task <ApiResult> SaveMItem(MaintenanceItem maintenanceItem)
{
ApiResult ret = new ApiResult();
try
{
ret.data = await _repo.SaveMItem(maintenanceItem);
}
catch (Exception ex)
{
ret.code = Code.Failure;
ret.msg = ex.Message;
}
return(ret);
}
public static bool InsertIntoDB(MaintenanceItem pItem)
{
try
{
using (DB_FleetServiceEntities db = new DB_FleetServiceEntities()) {
db.MaintenanceItem.Add(pItem);
db.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message);
}
}
public static MaintenanceItem setDataToItem(MaintenanceItemViewModel pItem)
{
if (pItem.code.Trim() == "")
{
throw new Exception("El código de referencia del árticulo de mantenimiento no puede ser vacío");
}
if (pItem.name.Trim() == "")
{
throw new Exception("El nombre del árticulo de mantenimiento no puede ser vacío");
}
if (pItem.presentationUnit == null)
{
throw new Exception("El árticulo de mantenimiento debe tener asignada una presentación");
}
if (pItem.type == null)
{
throw new Exception("El árticulo de mantenimiento debe tener asociado un tipo. Sí es Material o Mano de obra");
}
if (pItem.category == null)
{
throw new Exception("El árticulo de mantenimiento debe tener asociado una categoría. Sí es Mandatorio o Consultivo");
}
MaintenanceItem ItemDB = new MaintenanceItem();
ItemDB.mi_code = pItem.code.ToUpper();
ItemDB.mi_name = pItem.name.ToUpper();
ItemDB.mi_description = (pItem.description != null) ? pItem.description.ToUpper() : "";
ItemDB.tmi_id = (int)pItem.type.id;
ItemDB.pu_id = (int)pItem.presentationUnit.id;
if (pItem.category != null)
{
ItemDB.mict_id = (int)pItem.category.id;
}
ItemDB.mi_referencePrice = pItem.referencePrice;
ItemDB.mi_state = true;
ItemDB.mi_handleTax = (bool)pItem.handleTax;
ItemDB.mi_registrationDate = DateTime.Now;
return(ItemDB);
}
public IActionResult Delete(int id)
{
MaintenanceItem maintenanceItem = _context.MAINTENANCE_ITEMS.Find(id);
if (maintenanceItem == null)
{
return(NotFound());
}
_context.MAINTENANCE_ITEMS.Remove(maintenanceItem);
var infoItems = from i in _context.INFO_ITEMS
where i.MAINTENANCE_ITEM.Equals(id)
select i;
foreach (InfoItem i in infoItems)
{
_context.INFO_ITEMS.Remove(i);
}
_context.SaveChanges();
return(Ok());
}
public async Task <ActionResult <MaintenanceItem> > PostMaintenanceItem(MaintenanceItem maintenanceItem)
{
await maintenanceItemService.PostMaintenanceItem(maintenanceItem);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (maintenanceItemService.MaintenanceItemExists(maintenanceItem.ItemId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetMaintenanceItems", new { itemId = maintenanceItem.ItemId }, maintenanceItem));
}
public async Task <ActionResult <MaintenanceItemEditViewModel> > GetMaintenanceItem(Guid itemId, Guid maintenanceId)
{
MaintenanceItem maintenanceItem = await _context.MaintenanceItems
.Include(m => m.Maintenance)
.Include(i => i.Item)
.Where(mi => mi.ItemId == itemId && mi.MaintenanceId == maintenanceId)
.FirstOrDefaultAsync();
if (maintenanceItem == null)
{
return(null);
}
var maintenance = await _context.Maintenances.FindAsync(maintenanceId);
MaintenanceItemEditViewModel maintenanceItemEditViewModel = new MaintenanceItemEditViewModel()
{
Maintenance = maintenance,
MaintenanceItem = maintenanceItem
};
return(maintenanceItemEditViewModel);
}
private void SetSelectedItem(MaintenanceItem maintenanceItem)
{
if (maintenanceItem == null)
{
return;
}
if (SelectedMaintenanceItem != null && SelectedMaintenanceItem != maintenanceItem)
{
SelectedMaintenanceItem.Actions = MaintenanceItemActions.Text;
}
SelectedMaintenanceItem = maintenanceItem;
if (SelectedMaintenanceItem != null)
{
MaintenanceItemActions.Text = SelectedMaintenanceItem.Actions;
MaintenanceItemActions.IsReadOnly = false;
SelectedCompleteItem = null;
DrawCompleteItems();
}
else
{
MaintenanceItemActions.IsReadOnly = true;
}
}
private void AddMaintenanceItemButton_Click(object sender, RoutedEventArgs e)
{
MaintenanceItem maintenanceItem = new MaintenanceItem()
{
Name = "New Maintenance Item",
MaintenanceIntervalType = MaintenanceIntervalType.DateAndMileage,
MonthsMaintenanceInterval = 12,
MilesMaintenanceInterval = 12000,
Actions = string.Empty
};
EditMaintenanceItemDlg editMaintenanceItemDlg = new EditMaintenanceItemDlg(maintenanceItem)
{
Owner = this,
WindowStartupLocation = WindowStartupLocation.CenterOwner,
};
if ((bool)editMaintenanceItemDlg.ShowDialog())
{
MaintenanceItems.Add(maintenanceItem);
SelectedMaintenanceItem = maintenanceItem;
DrawMaintenanceItems();
}
}
public async Task PutMaintenanceItem(MaintenanceItem maintenanceItem)
{
_context.Entry(maintenanceItem).State = EntityState.Modified;
var scheduleItemComputersId = await(from sic in _context.ScheduleItemComputers
where sic.ItemId == maintenanceItem.ItemId
select new
{
sic.Id
}).ToListAsync();
if (scheduleItemComputersId.Count() > 0)
{
List <ScheduleMaintenanceItem> scheduleMaintenanceItemsList = new List <ScheduleMaintenanceItem>();
foreach (var sicId in scheduleItemComputersId)
{
var smiList = await _context.ScheduleMaintenanceItems.Where(smi => smi.ScheduleItemComputerId == sicId.Id &&
smi.MaintenanceId == maintenanceItem.MaintenanceId)
.ToListAsync();
scheduleMaintenanceItemsList.AddRange(smiList);
}
if (scheduleMaintenanceItemsList.Count > 0)
{
//List<Schedule> schedulesList = new List<Schedule>();
foreach (var smiObj in scheduleMaintenanceItemsList)
{
var schedulesList = await _context.Schedules.Where(s => s.ScheduleMaintenanceItemId == smiObj.Id).ToListAsync();
//schedulesList.AddRange(sList);
if (schedulesList.Count > 0)
{
var scheduleStatusLastDate = DateTime.Now;
var scheduleStatusPending = schedulesList.Where(sl => sl.Status == Status.Pending).ToList();
if (schedulesList.Where(sl => sl.Status != Status.Pending).Any())
{
scheduleStatusLastDate = schedulesList.Where(sl => sl.Status != Status.Pending)
.OrderByDescending(sl => sl.MaintenanceDate)
.Select(sl => sl.MaintenanceDate)
.FirstOrDefault();
}
var dateYearsPeriod = scheduleStatusLastDate.AddYears(4).Year;
var dateAddMonth = scheduleStatusLastDate;
Schedule schedule;
List <Schedule> schedules = new List <Schedule>();
while (dateAddMonth.Year < dateYearsPeriod)
{
schedule = new Schedule();
schedule.Id = Guid.NewGuid();
schedule.ScheduleMaintenanceItemId = smiObj.Id;
schedule.Status = Status.Pending;
dateAddMonth = dateAddMonth.AddMonths(maintenanceItem.Period);
schedule.MaintenanceDate = dateAddMonth;
schedules.Add(schedule);
}
if (scheduleStatusPending.Count > 0)
{
_context.Schedules.RemoveRange(scheduleStatusPending);
}
_context.Schedules.AddRange(schedules);
}
}
}
}
}
public EditMaintenanceItemDlg(MaintenanceItem maintenanceItem)
{
this.maintenanceItem = maintenanceItem;
InitializeComponent();
ApplyBindings();
}
public ActionResult SaveMItem(MaintenanceItem maintenanceItem)
{
var ret = _service.SaveMItem(maintenanceItem);
return(Ok(ret.Result));
}
