public IActionResult Edit(int id, EditInspectionViewModel customerSchedule)
        {
            if (id != customerSchedule.InspectionId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    if (_cusSchService.EditInspection(customerSchedule))
                    {
                        return(RedirectToAction("Index", "Home"));
                    }
                    else
                    {
                        return(NotFound());
                    }
                }
                catch
                {
                    return(View("Error", new ErrorViewModel {
                        RequestId = "Could not update please try again"
                    }));
                }
            }

            return(View(customerSchedule));
        }
        public async Task <IActionResult> Edit(EditInspectionViewModel model)
        {
            var all_insp = await _context.Inspections.Include(i => i.InspectionSpace).ToListAsync();

            var inspection = all_insp.Find(i => i.Id == model.InspectionId);

            if (inspection == null)
            {
                ViewBag.ErrorMessage = $"Проверки с ID = {model.InspectionId} не найдены";
                return(View("NotFound"));
            }
            else
            {
                if (ModelState.IsValid)
                {
                    inspection.Name            = model.InspectionName;
                    inspection.StartDate       = model.StartDate;
                    inspection.EndDate         = model.EndDate;
                    inspection.IterationNumber = model.IterationNumber;

                    try
                    {
                        _context.Update(inspection);
                        await _context.SaveChangesAsync();
                    }
                    catch (DbUpdateConcurrencyException)
                    {
                        if (!InspectionExists(inspection.Id))
                        {
                            return(NotFound());
                        }
                        else
                        {
                            throw;
                        }
                    }

                    if (model.FilePUD != null)
                    {
                        inspection = await _context.Inspections
                                     .FirstOrDefaultAsync(item => item.Name == model.InspectionName &&
                                                          item.InspectionSpace.Id == model.SpaceId &&
                                                          item.StartDate == model.StartDate &&
                                                          item.EndDate == model.EndDate &&
                                                          item.IterationNumber == model.IterationNumber);

                        FileReader fileReader = new FileReader(_context);
                        await fileReader.UploadPUDToDatabase(model.FilePUD, inspection);
                    }

                    return(RedirectToAction("Index", "Inspections", new { id = model.SpaceId }));
                }

                return(View(model));
            }
        }
        public IActionResult Edit(int insp_id)
        {
            Technical_inspection inspection = db.Inspections.Include(i => i.Car).FirstOrDefault(i => i.Id == insp_id);

            if (inspection == null)
            {
                return(View());
            }
            EditInspectionViewModel viewModel = new EditInspectionViewModel
            {
                Id              = insp_id,
                Car_Id          = inspection.Car.Id,
                Date_inspection = inspection.Date_inspection,
                Number          = inspection.Number,
                Remarks         = inspection.Remarks
            };

            return(View(viewModel));
        }
        public async Task <IActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var all_insp = await _context.Inspections.Include(i => i.InspectionSpace).Include(i => i.CriteriaList).Include(i => i.UserList).ToListAsync();

            var inspection = all_insp.Find(i => i.Id == id);

            var all_check_crit = await _context.CheckVsCriterias.Include(i => i.Criteria).Include(i => i.Check).ToListAsync();

            if (inspection == null)
            {
                return(NotFound());
            }

            EditInspectionViewModel model = new EditInspectionViewModel()
            {
                InspectionId    = inspection.Id,
                SpaceId         = inspection.InspectionSpace.Id,
                InspectionName  = inspection.Name,
                StartDate       = inspection.StartDate,
                EndDate         = inspection.EndDate,
                IterationNumber = inspection.IterationNumber,
                Criterias       = new List <Criteria>(),
                Users           = new List <string>()
            };

            foreach (CheckVsCriteria cvc in inspection.CriteriaList)
            {
                model.Criterias.Add(cvc.Criteria);
            }

            foreach (ApplicationUser user in inspection.UserList)
            {
                model.Users.Add(user.RealName);
            }

            return(View(model));
        }
        public bool EditInspection(EditInspectionViewModel editInspection)
        {
            if (CustomerScheduleExists(editInspection.InspectionId))
            {
                if (editInspection.EditedScheduleDate != null)
                {
                    var scheduleOfInterest = _ctx.CustomerSchedules.Where(c => c.CustomerScheduleId == editInspection.InspectionId).SingleOrDefault();
                    scheduleOfInterest.ScheduledTime = editInspection.EditedScheduleDate;
                    scheduleOfInterest.State         = editInspection.CancelSchedule ? Enums.InspectionState.Canceled : scheduleOfInterest.State;

                    try
                    {
                        _ctx.Update(scheduleOfInterest);
                        _ctx.SaveChanges();
                        return(true);
                    }
                    catch { }
                }
            }
            return(false);
        }
        public IActionResult Edit(EditInspectionViewModel inspViewModel)
        {
            Technical_inspection _insp = db.Inspections.Include(i => i.Car).FirstOrDefault(i => i.Id == inspViewModel.Id);

            if (inspViewModel.Date_inspection < _insp.Car.Release)
            {
                ModelState.AddModelError("Date_inspection", "дата осмотра должна быть позже даты выпуска автомобиля");
            }
            else if (db.Inspections.FirstOrDefault(i => i.Number == inspViewModel.Number && i.Id != inspViewModel.Id) != null)
            {
                ModelState.AddModelError("Number", "такой номер карты уже записан");
            }
            if (ModelState.IsValid)
            {
                _insp.Number          = inspViewModel.Number;
                _insp.Date_inspection = inspViewModel.Date_inspection;
                _insp.Remarks         = inspViewModel.Remarks;
                db.SaveChanges();

                return(RedirectToAction("getInspections", new { car_id = inspViewModel.Car_Id }));
            }
            return(View(inspViewModel));
        }