public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Address,City,State,Zip,Email,OwnerId,status")] Contact contact)
{
if (id != contact.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(contact);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContactExists(contact.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(contact));
}
public async Task <IActionResult> Edit(int id, [Bind("UserReqId,FloorNum,CubeNum,DidNum,DualMon,RemoAcc,RemoLap,Mobile,UserStatus,UserName")] UserRequirements userRequirements)
{
if (id != userRequirements.UserReqId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(userRequirements);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserRequirementsExists(userRequirements.UserReqId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(userRequirements));
}
public async Task <IActionResult> Edit(int id, [Bind("Username,Password,UserLogId")] User user)
{
if (id != user.UserLogId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(user);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(user.UserLogId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(user));
}
public async Task <IActionResult> Edit(int id, [Bind("VmsroleGroupId,AccountGroup,AdminSupport,Assignor,Auditor,CliServiDeptMgr,CliServiGroup,CommercialGroup,ContractorQc,Itgroup,ProcessingShippingGroup,QcsupervisorLead,Qc,SalesGroup,StatusGroup,VendorRelationsGroup")] VmsRolegroup vmsRolegroup)
{
if (id != vmsRolegroup.VmsroleGroupId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(vmsRolegroup);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VmsRolegroupExists(vmsRolegroup.VmsroleGroupId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(vmsRolegroup));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name")] Department department)
{
if (id != department.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(department);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DepartmentExists(department.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(department));
}
public async Task <IActionResult> Edit(int id, [Bind("UserId,LastName,FirstName,Department,Office,ManagerName,IsManager,DateStart,DateEnd")] UserTable userTable)
{
if (id != userTable.UserId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(userTable);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserTableExists(userTable.UserId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(userTable));
}
public async Task <IActionResult> Edit(int id, [Bind("AppId,VmsroleGroup,AddAccess,Otsaccess,BporoleGroup,LrvroleGroup,Mas500Access")] Applicationaccess applicationaccess)
{
if (id != applicationaccess.AppId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(applicationaccess);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ApplicationaccessExists(applicationaccess.AppId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AddAccess"] = new SelectList(_context.AddiAccess, "AddiAccessId", "AddiAccessId", applicationaccess.AddAccess);
ViewData["BporoleGroup"] = new SelectList(_context.BpoRolegroup, "Bpoid", "Bpoid", applicationaccess.BporoleGroup);
ViewData["LrvroleGroup"] = new SelectList(_context.LrvRolegroup, "LrvId", "LrvId", applicationaccess.LrvroleGroup);
ViewData["Otsaccess"] = new SelectList(_context.OtsAccess, "OtsAccessId", "OtsAccessId", applicationaccess.Otsaccess);
ViewData["VmsroleGroup"] = new SelectList(_context.VmsRolegroup, "VmsroleGroupId", "VmsroleGroupId", applicationaccess.VmsroleGroup);
return(View(applicationaccess));
}
public async Task <IActionResult> Edit(int id, [Bind("IdCategorie,Nom")] Categorie categorie)
{
if (id != categorie.IdCategorie)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(categorie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CategorieExists(categorie.IdCategorie))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(categorie));
}
public async Task <IActionResult> Edit(LibViewModel model)
{
model.SetModel(await _context.Categorie.ToListAsync());
model.Lib.IdCategorie = Convert.ToInt32(model.CategorieSelected);
if (ModelState.IsValid)
{
try
{
if (model.Lib.IdLib != 0)
{
_context.Update(model.Lib);
}
else
{
_context.Lib.Add(model.Lib);
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LibExists(model.Lib.IdLib))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public async Task <IActionResult> Edit(int id, [Bind("OtsAccessId,Return,MultiAssign,DeleteOrder,ToReassign,RecreateOrder,AppraisalTagShip,MaintainTagReasons,MaintainClariReasons,AuditAdmin,DisputeQueueAccess")] OtsAccess otsAccess)
{
if (id != otsAccess.OtsAccessId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(otsAccess);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OtsAccessExists(otsAccess.OtsAccessId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(otsAccess));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,IsDone,Priority")] ToDo toDo)
{
if (id != toDo.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(toDo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ToDoExists(toDo.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(toDo));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Nome,Checked")] Item item)
{
if (id != item.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(item);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItemExists(item.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(item));
}
public async Task <IActionResult> Edit(int id, [Bind("Bpoid,Bpoadmin,ContractQc,FdicQc,HoldOrders,MarkOrdersShipped,QcBasic,QcPlus,QcSupervisor,ViewRules")] BpoRolegroup bpoRolegroup)
{
if (id != bpoRolegroup.Bpoid)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(bpoRolegroup);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BpoRolegroupExists(bpoRolegroup.Bpoid))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(bpoRolegroup));
}
public async Task <IActionResult> Edit(int id, [Bind("LrvId,LrvAdmin,FannieQc,RegularQc,AllQueues")] LrvRolegroup lrvRolegroup)
{
if (id != lrvRolegroup.LrvId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(lrvRolegroup);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LrvRolegroupExists(lrvRolegroup.LrvId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(lrvRolegroup));
}
public async Task <IActionResult> Edit(int id, [Bind("AddiAccessId,Pci,Fdic,Crm,CopyOf")] AddiAccess addiAccess)
{
if (id != addiAccess.AddiAccessId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(addiAccess);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AddiAccessExists(addiAccess.AddiAccessId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(addiAccess));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Title,TrailerUrl,ShortDescription,Genre,LongDescription,Actors")] Movie movie)
{
if (id != movie.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> Edit(int id, [Bind("TodayDate,RequestType,RequestByName,EffectiveStart,EffectiveEnd,RequestId")] Requestinfo requestinfo)
{
if (id != requestinfo.RequestId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(requestinfo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RequestinfoExists(requestinfo.RequestId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(requestinfo));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task UpdateAsync(Seller obj)
{
bool hasAny = await _context.Seller.AnyAsync(x => x.ID == obj.ID);
if (!hasAny)
{
throw new NotFoundException("Id not found");
}
try
{
_context.Update(obj);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
