public async Task <IActionResult> Edit(int id)
{
var service = await _serviceRepository.Get(id);
if (service != null)
{
EditServiceViewModel editServiceViewModel = new EditServiceViewModel()
{
Id = service.Id,
Name = service.Name,
Description = service.Description,
Login = service.Login,
Password = service.Password,
SharedSecretOut = service.SharedSecretOut,
APIKeyOut = service.APIKeyOut,
SharedSecretIn = service.SharedSecretIn,
APIKeyIn = service.APIKeyIn,
SharedSecretEnc = service.SharedSecretEnc,
APIKeyEnc = service.APIKeyEnc,
Status = service.Status,
Services = await _serviceRepository.Select()
};
return(View(editServiceViewModel));
}
return(RedirectToAction("Get"));
}
public ActionResult Update(int serviceid)
{
var inRecord = _db.Services.FirstOrDefault(serv => serv.ServiceId == serviceid);
if (inRecord == null)
{
return(RedirectToAction(nameof(Index)));
}
var updateModel = new EditServiceViewModel {
ServiceId = inRecord.ServiceId,
Name = inRecord.Name,
Description = inRecord.Description,
Price = inRecord.Price
};
//since services does not have a field to see if specific or not, check values of model and manufacturer
//if not set for one then it is not specific
if (inRecord.Manufacturer == null || inRecord.Model == null)
{
updateModel.NotSpecific = true;
}
else
{
updateModel.NotSpecific = false;
updateModel.Manufacturer = inRecord.Manufacturer;
updateModel.Model = inRecord.Model;
}
return(View(updateModel));
}
public IActionResult Edit(EditServiceViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var service = this._context.Services.FirstOrDefault(s => s.Id == model.Id);
if (service != null)
{
service.Vehicle = model.Vehicle;
service.Description = model.Description;
service.ServiceType = model.ServiceType;
service.Price = model.Price;
this._context.Services.Update(service);
this._context.SaveChanges();
return(RedirectToAction("Index", new { Id = model.Id }));
}
return(View());
}
public ActionResult EditService(string serviceId)
{
var service = _servService.GetServiceById(serviceId);
var model = new EditServiceViewModel()
{
Id = service.Id.ToString(),
ServiceName = service.ServiceName,
Properties = service.Properties,
TariffList = new List <EditTariffViewModel>()
};
foreach (var tariff in service.TariffList)
{
model.TariffList.Add(new EditTariffViewModel()
{
Id = tariff.Id.ToString(),
Service_Id = tariff.Service_Id.ToString(),
TariffName = tariff.TariffName,
TariffProperties = tariff.TariffProperties,
Price = tariff.Price,
ValidityPeriod = tariff.ValidityPeriod.Days
});
}
return(View(model));
}
public async Task <IActionResult> EditService(EditServiceViewModel viewModel)
{
if (ModelState.IsValid)
{
var service = await _esbModelContext.Services.FindAsync(viewModel.ServiceID);
if (service == null)
{
return(NotFound());
}
service.ActiveStatus = viewModel.ActiveStatus ? 1 : 0;
service.FullDescription = viewModel.FullDescription;
service.GroupName = viewModel.GroupName;
service.Name = viewModel.Name;
if (service.Type != viewModel.Type)
{
//TODO: 服务协定类型改变，清空协定定义，将来可以设置转换功能。
service.Type = viewModel.Type;
service.FullDescription = "";
}
_esbModelContext.Update(service);
await _esbModelContext.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(viewModel));
}
}
public IHttpActionResult Put(EditServiceViewModel model)
{
var service = Mapper.Map <EditServiceViewModel, EditServiceTransport>(model);
ServiceManager.UpdateService(service);
return(Ok());
}
public async Task <IActionResult> EditService(int?id)
{
EditServiceViewModel viewModel = await _esbModelContext.Services.FindAsync(id);
if (viewModel == null)
{
return(NotFound());
}
return(View(viewModel));
}
public IActionResult Edit(EditServiceViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
serviceService.Update(vm.Id, vm.Title, vm.Description, GetStringFromFile(vm.NewIcon));
return(RedirectToIndex());
}
public async Task <IActionResult> Edit(int?id)
{
if (id != null)
{
Service service = await db.Services.FirstOrDefaultAsync(t => t.ServiceID == id);
if (service == null)
{
ErrorViewModel error = new ErrorViewModel
{
RequestId = "Error! There is no record in the database with the id passed = " + id
};
return(View("Error", error));
}
Dictionary <string, int> clients = new Dictionary <string, int>();
Dictionary <string, int> rooms = new Dictionary <string, int>();
Dictionary <string, int> workers = new Dictionary <string, int>();
foreach (var item in db.Clients)
{
clients.Add(item.ClientFIO, item.ClientID);
}
foreach (var item in db.Rooms)
{
rooms.Add(item.RoomType, item.RoomID);
}
foreach (var item in db.Workers)
{
workers.Add(item.WorkerFIO, item.WorkerID);
}
EditServiceViewModel model = new EditServiceViewModel
{
Id = service.ServiceID,
ServiceName = service.ServiceName,
ServiceDescription = service.ServiceDescription,
EntryDate = service.EntryDate,
DepartureDate = service.DepartureDate,
ClientID = service.Client.ClientID,
RoomID = service.Room.RoomID,
WorkerID = service.Worker.WorkerID
};
ViewBag.clients = clients;
ViewBag.rooms = rooms;
ViewBag.workers = workers;
return(View(model));
}
else
{
ErrorViewModel error = new ErrorViewModel {
RequestId = "Error! Missing id in query parameters"
};
return(View("Error", error));
}
}
public ActionResult Update(int serviceid, EditServiceViewModel editPending)
{
var inRecord = _db.Services.FirstOrDefault(serv => serv.ServiceId == serviceid);
if (inRecord == null)
{
return(RedirectToAction(nameof(Index)));
}
if (!ModelState.IsValid)
{
return(View(editPending));
}
bool nameExists = false;
//create a variable to store conflicting service
var confliction = new Service();
// check if the manufacturer and model fields are empty
//convert to lowercase so that difference in capitals does not matter
if (editPending.Manufacturer == null && editPending.Model == null)
{
nameExists = _db.Services.Any(ser => ser.Name.ToLower() == editPending.Name.ToLower() && ser.Model == null && ser.Manufacturer == null);
confliction = _db.Services.FirstOrDefault(ser => ser.Name.ToLower() == editPending.Name.ToLower() && ser.Model == null && ser.Manufacturer == null);
}
else
{
nameExists = _db.Services.Any(
ser => ser.Name.ToLower() == editPending.Name.ToLower() && ser.Model == editPending.Model && ser.Manufacturer == editPending.Manufacturer);
confliction = _db.Services.FirstOrDefault(
ser => ser.Name.ToLower() == editPending.Name.ToLower() && ser.Model == editPending.Model && ser.Manufacturer == editPending.Manufacturer);
}
//check if a entry is already in the database with the same name, for specified model and manufacturer
if (nameExists)
{
//only give error if the service in record that has the same name is not the same as the one being updated
if (confliction.ServiceId != inRecord.ServiceId)
{
ModelState.AddModelError("", "That service already exists in the database!");
return(View(editPending));
}
}
inRecord.Name = editPending.Name;
inRecord.Description = editPending.Description;
inRecord.Price = editPending.Price;
_db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(EditServiceViewModel model)
{
try
{
Service service = await db.Services.Include("Client").Include("Worker").Include("Room").FirstOrDefaultAsync(t => t.ServiceID == model.Id);
if (ModelState.IsValid)
{
if (service == null)
{
ErrorViewModel error = new ErrorViewModel
{
RequestId = "Error! Empty model sent"
};
return(View("Error", error));
}
}
Dictionary <string, int> clients = new Dictionary <string, int>();
Dictionary <string, int> workers = new Dictionary <string, int>();
Dictionary <string, int> rooms = new Dictionary <string, int>();
foreach (var item in db.Clients)
{
clients.Add(item.ClientFIO, item.ClientID);
}
foreach (var item in db.Workers)
{
workers.Add(item.WorkerFIO, item.WorkerID);
}
foreach (var item in db.Rooms)
{
rooms.Add(item.RoomType, item.RoomID);
}
service.ServiceName = model.ServiceName;
service.ServiceDescription = model.ServiceDescription;
service.EntryDate = model.EntryDate;
service.DepartureDate = model.DepartureDate;
service.ClientID = model.ClientID;
service.RoomID = model.RoomID;
service.WorkerID = model.ClientID;
ViewBag.clients = clients;
ViewBag.workers = workers;
ViewBag.rooms = rooms;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
}
return(View(model));
}
public IActionResult Edit(Service service)
{
TempData.Keep();
if (!ModelState.IsValid)
{
EditServiceViewModel vm = new EditServiceViewModel
{
Service = service,
Categories = _categoriesRepo.Categories
.OrderBy(c => c.Name)
};
return(View(vm));
}
_servicesRepo.Save(service);
TempData["updated"] = true;
return(RedirectToAction("Admin", new { filter = TempData["filter"] }));
}
public IActionResult Edit(int id)
{
Service service = serviceService.GetById(id);
if (service == null)
{
return(RedirectToIndex());
}
EditServiceViewModel vm = new EditServiceViewModel
{
Id = id,
Title = service.Title,
Description = service.Description,
Icon = service.Icon
};
return(View(vm));
}
public IActionResult Edit(int id)
{
TempData.Keep();
Service service = _servicesRepo.Services.Where(s => s.Id == id).FirstOrDefault();
if (service == null)
{
return(NotFound());
}
EditServiceViewModel vm = new EditServiceViewModel
{
Service = service,
Categories = _categoriesRepo.Categories
.OrderBy(c => c.Name)
};
ViewBag.UpdatedService = TempData["updated"];
return(View(vm));
}
public async Task <IActionResult> EditServicePost(EditServiceViewModel model)
{
var result = await _monitor.EditService(model, GetCurrentUserAsync().Result.UserName);
if (result.Succeeded)
{
_toastNotification.AddSuccessToastMessage(result.OkMessage, new ToastrOptions()
{
PositionClass = ToastPositions.TopCenter
});
return(RedirectToAction("ListService", new { id = model.DatabaseSystemId }));
}
_toastNotification.AddErrorToastMessage(result.Errors, new ToastrOptions()
{
PositionClass = ToastPositions.TopCenter
});
ViewBag.DataBaseList = _monitor.DatabaseSystemList(model.DatabaseSystemId);
return(RedirectToAction(nameof(EditService), model.Id));
}
public ActionResult EditService(EditServiceViewModel model)
{
if (ModelState.IsValid)
{
if (model.TariffList == null || model.TariffList.Count < 1)
{
ModelState.AddModelError("TariffList", "Добавьте хотя бы один тариф");
return(View(model));
}
ServiceDTO service = new ServiceDTO()
{
Id = Guid.Parse(model.Id),
ServiceName = model.ServiceName,
Properties = model.Properties,
IsInUse = true,
CurrentUsers = 0,
TariffList = new List <TariffDTO>()
};
Guid id;
foreach (var tariff in model.TariffList)
{
var res = Guid.TryParse(tariff.Id, out id);
service.TariffList.Add(new TariffDTO()
{
Id = id,
Service_Id = tariff.Service_Id,
Price = tariff.Price,
TariffName = tariff.TariffName,
TariffProperties = tariff.TariffProperties,
ValidityPeriodTicks = tariff.ValidityPeriod * 864000000000
});
}
_servService.UpdateService(service);
return(RedirectToAction("ServiceIndex"));
}
else
{
return(View(model));
}
}
public async Task <SystemSucceededTask> EditService(EditServiceViewModel model, string userName)
{
var oldService = _serviceRepository.GetById(model.Id);
if (oldService == null)
{
_logger.InformationLog("Service not found", "Edit Service", string.Empty, userName);
return(SystemSucceededTask.Failed("Service: " + model.Name + " edited unsuccessful",
string.Empty, false, true));
}
oldService.Active = model.Active;
oldService.DatabaseSystem = _systemRepository.GetById(model.DatabaseSystemId);
oldService.Hostname = model.Hostname;
oldService.Ip = model.Ip;
oldService.LoginName = model.LoginName;
oldService.Name = model.Name;
oldService.Named = model.Named;
oldService.LoginPassword = model.LoginPassword == "ChangeMe".ToUpper()
? oldService.LoginPassword
: _customRepository.SetEncryption(model.LoginPassword);
oldService.UpdatedOn = DateTimeOffset.Now;
try
{
await _serviceRepository.SaveChangesAsync();
_logger.InformationLog("Service: " + model.Name + " edited successfully", "Edit Service",
string.Empty, userName);
return(SystemSucceededTask.Success("Service: " + model.Name + " edited successfully"));
}
catch (Exception ex)
{
_logger.InformationLog(ex.Message, "Edit Service", ex.InnerException.Message, userName);
return(SystemSucceededTask.Failed("Service: " + model.Name + " edited successful",
ex.InnerException.Message, true, false));
}
}
public async Task <IActionResult> EditService(EditServiceViewModel model)
{
if ((model.Service?.Id ?? 0) != 0)
{
using (var repo = new ServiceRepository())
{
await repo.UpdateAsync(model.Service);
return(View(model));
}
}
if (!string.IsNullOrWhiteSpace(model.Service?.Name))
{
using (var repo = new ServiceRepository())
{
await repo.AddAsync(model.Service);
return(View(model));
}
}
return(View(model));
}
public async Task <IActionResult> EditServices(int subCategoryId)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var specialist = await _specialistService.FindAsync(userId, true);
if (!specialist.SpecialistSubCategories.Any(m => m.SubCategoryId == subCategoryId))
{
return(RedirectToAction("Index"));
}
var allServices = await _categoryService.GetServicesAsync(subCategoryId);
var specialistServices = specialist.SpecialistServices;
var servicesViewModel = new List <EditServiceViewModel>();
foreach (var service in allServices)
{
var serviceViewModel = new EditServiceViewModel();
serviceViewModel.Service = service;
serviceViewModel.SpecialistService = specialistServices.FirstOrDefault(m => m.ServiceId == service.Id);
servicesViewModel.Add(serviceViewModel);
}
return(View(servicesViewModel.ToArray()));
}
public async Task <IActionResult> Edit(EditServiceViewModel serviceModel, int id)
{
if (ModelState.IsValid)
{
Service service = new Service()
{
Name = serviceModel.Name,
Description = serviceModel.Description,
Login = serviceModel.Login,
Password = serviceModel.Password,
SharedSecretOut = serviceModel.SharedSecretOut,
APIKeyOut = serviceModel.APIKeyOut,
SharedSecretIn = serviceModel.SharedSecretIn,
APIKeyIn = serviceModel.APIKeyIn,
SharedSecretEnc = serviceModel.SharedSecretEnc,
APIKeyEnc = serviceModel.APIKeyEnc,
Status = serviceModel.Status
};
await _serviceRepository.Update(service, id);
}
return(RedirectToAction("List"));
}
