public async Task <IActionResult> Delete(DeleteViewModel model)
{
try
{
var findItem = await _shopRepository.GetSingleAsync(model.Id, x => x.Wells);
if (findItem == null)
{
return(NotFound());
}
///Каскадно удаляем сначала все скважины в цехе, т.к. EF настроен как OnDelete(DeleteBehavior.Restrict)
if (findItem.Wells.Any())
{
_wellRepository.DeleteRange(findItem.Wells);
}
///Затем удаляем сам цех
_shopRepository.Delete(findItem);
return(Ok());
}
catch (Exception e)
{
Log.Error(e, "ShopController.Delete");
return(BadRequest(_messageModelBuilder.CreateModel("500", e.Message)));
}
}
public async Task <IActionResult> Delete(
[FromRoute] string appId,
[FromRoute] string recordName)
{
var user = await GetCurrentUserAsync();
var app = await _dbContext.Apps.FindAsync(appId);
if (app == null)
{
return(NotFound());
}
if (app.CreatorId != user.Id)
{
return(Unauthorized());
}
var model = new DeleteViewModel(user)
{
AppId = appId,
RecordName = recordName,
AppName = app.AppName
};
return(View(model));
}
public async Task <IActionResult> Delete(DeleteViewModel model)
{
var user = await GetCurrentUserAsync();
if (!ModelState.IsValid)
{
model.ModelStateValid = false;
model.Recover(user);
return(View(model));
}
try
{
await _sitesService.DeleteSiteAsync(await accesstoken, user.SiteName);
user.SiteName = string.Empty;
await _dbContext.SaveChangesAsync();
return(RedirectToAction(nameof(CreateSite)));
}
catch (AiurUnexceptedResponse e)
{
ModelState.AddModelError(string.Empty, e.Response.Message);
model.ModelStateValid = false;
model.Recover(user);
return(View(model));
}
}
public async Task <IActionResult> DeletePersonalData(DeleteViewModel model)
{
ViewBag.ActiveTab = 3;
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!await _userManager.CheckPasswordAsync(user, model.Password))
{
ModelState.AddModelError(string.Empty, "Password not correct.");
return(View("MyAccount", new AccountViewModel()));
}
var result = await _userManager.DeleteAsync(user);
var userId = await _userManager.GetUserIdAsync(user);
if (!result.Succeeded)
{
throw new InvalidOperationException($"Unexpected error occurred deleteing user with ID '{userId}'.");
}
await _signInManager.SignOutAsync();
_logger.LogInformation("User with ID '{UserId}' deleted themselves.", userId);
return(Redirect("~/"));
}
public async Task <ActionResult> Index(IndexViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
Guid?notificationId;
if (model.IsExportNotification.GetValueOrDefault())
{
notificationId = await mediator.SendAsync(new GetNotificationIdByNumber(model.NotificationNumber));
}
else
{
notificationId = await mediator.SendAsync(new GetImportNotificationIdByNumber(model.NotificationNumber));
}
if (notificationId == null)
{
ModelState.AddModelError("NotificationNumber", DeleteNotificationControllerResources.NumberNotExist);
return(View(model));
}
var deleteModel = new DeleteViewModel(model, notificationId.GetValueOrDefault());
return(RedirectToAction("Check", deleteModel));
}
public async Task <IActionResult> Delete([FromRoute] ulong server, [FromRoute] uint quote)
{
var authEntry = HttpContext.GetAuthEntry();
if (authEntry is null)
{
return(Redirect("/login"));
}
var userGuilds = await userService.GetAllowedUserGuilds(authEntry);
if (!userGuilds.Any(x => x.Id == server))
{
return(Unauthorized());
}
var named_audio = await quoteBotRepo.GetNamedAudioByAudioOwnerId(quote);
if (named_audio.AudioOwner.OwnerId != server)
{
return(BadRequest());
}
var viewModel = new DeleteViewModel(named_audio, server);
return(View(viewModel));
}
public DeleteView(ClassEx selectedClassEx = null, TeacherEx selectedTeacher = null) // tjek om det er teacherex eller class
{
InitializeComponent();
if (viewModel == null)
{
viewModel = new DeleteViewModel();
}
if (selectedClassEx != null) // er det teacher eller class der ønskes slettet?
{
viewModel.ViewstateObject = Enums.ViewstateObject.Class;
viewModel.CurrentClass = selectedClassEx;
datagridClassesEx.Visibility = Visibility.Hidden;
cbListofTeachers.Visibility = Visibility.Hidden;
butAssociate.Visibility = Visibility.Hidden;
}
else if (selectedTeacher != null)
{
viewModel.ViewstateObject = Enums.ViewstateObject.Teacher;
viewModel.CurrentTeacherEx = selectedTeacher;
listboxStudents.Visibility = Visibility.Hidden;
cbListofClasses.Visibility = Visibility.Hidden;
}
DataContext = viewModel;
InitializeEvents();
}
public ActionResult Delete(string username) // máme username poslané pomocí GET
{
if (username == null) // neplatné username!
{
TempData.Add("error", "Před smazáním musíte vybrat existujícího uživatele.");
return(RedirectToAction("Users", "Account"));
}
DeleteViewModel DVM = new DeleteViewModel();
try
{
ApplicationUser user = UserManager.FindByName(username);
if (user.UserName == User.Identity.Name) // jedná se o právě přihlášeného uživatele (admina)
{
TempData.Add("error", "Nemůžete smazat svůj uživatelský účet.");
return(RedirectToAction("Users", "Account")); // sám sebe nesmí mazat
}
else if (!UserManager.IsInRole(user.Id, "user")) // nejedná se o uživatele v roli "user"!
{
TempData.Add("error", "Lze mazat pouze uživateli v roli 'user', nikoli jiné administrátory.");
return(RedirectToAction("Users", "Account"));
}
// DVM.UserId = user.Id;
DVM.UserName = username;
return(View(DVM)); // formulář pro potvrzení smazání uživatele
}
catch // asi bylo neplatné username!
{
TempData.Add("error", "Uživatele '" + username + "' nelze smazat (uživatel neexistuje).");
return(RedirectToAction("Users", "Account"));
}
}
public async Task <IActionResult> Delete([FromBody] DeleteViewModel model)
{
_context.Clients.Remove(await _context.Clients.SingleOrDefaultAsync(c => c.Id == model.Id));
await _context.SaveChangesAsync();
return(Ok());
}
public IActionResult Index(DeleteViewModel viewModel)
{
try
{
if (ModelState.IsValid)
{
if (_redisRepository.Exists(viewModel.KeyToDelete))
{
_redisRepository.Delete(viewModel.KeyToDelete);
new SetTempDataMessage()
.Display(TempData, "OK", $"The key {viewModel.KeyToDelete} has been removed.");
}
else
{
new SetTempDataMessage()
.Display(TempData, "Warning", $"Key {viewModel.KeyToDelete} was not found.", SetTempDataMessage.CssClassNameEnum.alert_warning);
}
}
}
catch (Exception ex)
{
new SetTempDataMessage()
.Display(TempData, "Error", ex.Message, SetTempDataMessage.CssClassNameEnum.alert_danger);
}
return(View(viewModel));
}
public ActionResult Delete(DeleteViewModel vmDelete)
{
try
{
if (!ModelState.IsValid)
{
TempData["ErrorMessage"] = "Problem deleting record. Try again.";
return(RedirectToAction("Index", "AccountTransaction"));
}
// update db
if (!_businessService.AccountTransactionService.DeleteTransaction(vmDelete.Id))
{
ViewData["ErrorMessage"] = "Problem deleting record";
return(View("Delete", vmDelete));
}
TempData["SuccessMessage"] = "Record deleted";
return(RedirectToAction("Index", "AccountTransaction"));
}
catch (Exception)
{
TempData["ErrorMessage"] = "Encountered Problem";
return(RedirectToAction("Index", "AccountTransaction"));
}
}
// GET: AccountabilityTypes/Delete/5
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
var accountabilityType = await _context.AccountabilityTypes
.SingleOrDefaultAsync(m => m.AccountabilityTypeId == id);
if (accountabilityType == null)
{
return(NotFound());
}
DeleteViewModel vm = new DeleteViewModel()
{
AccountabilityType = accountabilityType
};
vm.AffectedAccountabilities = await _context.Accountabilities.Where(x =>
x.AccountabilityTypeId == accountabilityType.AccountabilityTypeId)
.Include(x => x.Accountable)
.Include(x => x.Commissioner)
.ToListAsync();
vm.CanDelete = vm.AffectedAccountabilities.Count < 1;
return(View(vm));
}
public ActionResult DeleteConfirmed(DeleteViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
ApplicationUser user = UserManager.FindByName(model.UserName);
UserManager.Delete(user); // odstranění uživatele
TempData.Add("Message", "Uživatel '" + model.UserName + "' byl smazán.");
return(RedirectToAction("Users", "Account"));
}
catch
{
TempData.Add("error", "Uživatele '" + model.UserName + "' se nepodařilo smazat.");
return(RedirectToAction("Users", "Account"));
}
/*
* WebSenateModels webSenateModels = db.WebSenateModels.Find(id);
* db.WebSenateModels.Remove(webSenateModels);
* db.SaveChanges();
* return RedirectToAction("Index");
*/
}
public async Task <IActionResult> Delete(DeleteViewModel model)
{
var user = await GetCurrentUserAsync();
var app = await _dbContext.Apps.FindAsync(model.AppId);
if (app == null)
{
return(NotFound());
}
if (app.CreatorId != user.Id)
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
model.Recover(user, app.AppName);
return(View(model));
}
try
{
var token = await _appsContainer.AccessToken(app.AppId, app.AppSecret);
await _recordsService.DeleteRecordAsync(token, model.RecordName);
return(RedirectToAction(nameof(AppsController.ViewApp), "Apps", new { id = app.AppId, JustHaveUpdated = true }));
}
catch (AiurUnexpectedResponse e)
{
ModelState.AddModelError(string.Empty, e.Response.Message);
model.Recover(user, app.AppName);
return(View(model));
}
}
public async Task <ActionResult> Delete(DeleteViewModel user)
{
if (ModelState.IsValid)
{
var userFound = await UserManager.FindByIdAsync(user.UserId);
if (userFound == null)
{
ModelState.AddModelError("", "Usuário não encontrado.");
}
else
{
var result = await UserManager.DeleteAsync(userFound);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
AddErrors(result);
}
}
return(View(user));
}
public async Task <IActionResult> Delete(int userId)
{
var user = await Authorize();
if (user == null)
{
return(RedirectToAction("Login", "Auth", new { fallbackUrl = HttpContext.Request.Path }));
}
if (!user.Roles.Any(r => r.Name == "Администратор"))
{
return(Unauthorized());
}
if (UserRepository.Get(userId) != null)
{
var deleteVM = new DeleteViewModel
{
ConfirmUrl = Url.Action(nameof(DeleteConfirm), new { userId }),
FallbackUrl = Url.Action(nameof(AdminPanel))
};
return(View("_ConfirmDelete", deleteVM)); //Страница подтверждения удаления
}
else
{
return(NotFound());
}
}
public void Then_Sets_ReservationId(
GetReservationResult getReservationResult)
{
var viewModel = new DeleteViewModel(getReservationResult);
viewModel.Id.Should().Be(getReservationResult.ReservationId);
}
public async Task <IActionResult> Delete(DeleteViewModel viewModel)
{
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction("Index", "Home"));
}
var product = await this._dbContext
.Products
.FirstOrDefaultAsync(x => x.Id == viewModel.Id);
if (product == null)
{
return(this.RedirectToAction("Index", "Home"));
}
this._dbContext
.Products
.Remove(product);
await this._dbContext
.SaveChangesAsync();
return(this.RedirectToAction("Index", "Home"));
}
public void Then_Sets_AccountLegalEntityName(
GetReservationResult getReservationResult)
{
var viewModel = new DeleteViewModel(getReservationResult);
viewModel.AccountLegalEntityName.Should().Be(getReservationResult.AccountLegalEntityName);
}
public async Task <IActionResult> DeleteAsync(DeleteViewModel viewModel)
{
if (!ModelState.IsValid)
{
ViewData["ErrorMessage"] = "Invalid form submission.";
return(PartialView("_DeleteStock", viewModel));
}
BaseResponse _Response = new BaseResponse();
string _UserIDString = __UserManager.GetUserId(User);
if (Guid.TryParse(_UserIDString, out Guid userUID))
{
_Response = await __StockManager.DeleteAsync(new UserUIDAndUIDRequest { UID = viewModel.UID, UserUID = userUID });
}
else
{
_Response.Success = false;
_Response.ErrorMessage = $"You do not have permission to delete the {ENTITY_NAME}";
}
if (!_Response.Success)
{
return(RedirectToAction("Index", "Stock", new { Area = "Stock", errorMessage = _Response.ErrorMessage }));
}
return(RedirectToAction("Index", "Stock", new { Area = "Stock", successMessage = $"{GlobalConstants.SUCCESS_ACTION_PREFIX} deleted {ENTITY_NAME}" }));
}
public void Then_Sets_CourseDescription(
GetReservationResult getReservationResult)
{
var viewModel = new DeleteViewModel(getReservationResult);
viewModel.CourseDescription.Should().Be(getReservationResult.Course.CourseDescription);
}
public DeleteDialog(string text)
{
InitializeComponent();
var vm = new DeleteViewModel(text);
DataContext = vm;
}
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(this.NotFound());
}
var product = await this._dbContext
.Products
.FirstOrDefaultAsync(x => x.Id == id);
if (product == null)
{
return(this.RedirectToAction("Index", "Home"));
}
var viewModel = new DeleteViewModel()
{
Id = product.Id,
Name = product.Name,
Description = product.Description,
Price = product.Price,
Type = product.Type
};
return(this.View(viewModel));
}
public async Task <IActionResult> Delete(DeleteViewModel model)
{
int?sUKPRN = Session.GetInt32("UKPRN");
int UKPRN;
if (!sUKPRN.HasValue)
{
return(RedirectToAction("Index", "Home", new { errmsg = "Please select a Provider." }));
}
else
{
UKPRN = sUKPRN ?? 0;
}
switch (model.MigrationDeleteOptions)
{
case MigrationDeleteOptions.DeleteMigrations:
await _courseService.ArchiveCourseRunsByUKPRN(UKPRN);
return(View("../Migration/DeleteConfirmed/Index"));
case MigrationDeleteOptions.Cancel:
return(RedirectToAction("Index", "PublishCourses", new { publishMode = PublishMode.Migration }));
default:
return(RedirectToAction("index"));
}
}
public ActionResult Delete(DeleteViewModel model)
{
if (this.ModelState.IsValid)
{
var journals = this.journalRepository.All;
var issns = GetISSNs(model);
var journalsISSNs = journals.Select(j => j.ISSN).ToSet(StringComparer.InvariantCultureIgnoreCase);
var issnsFound = issns.Intersect(journalsISSNs).ToList();
var issnsNotFound = issns.Except(journalsISSNs).ToList();
var journalsToDelete = journals.Where(j => issnsFound.Contains(j.ISSN)).ToList();
foreach (var journal in journalsToDelete)
{
this.journalRepository.Delete(journal);
}
this.journalRepository.Save();
this.Session[FoundISSNsSessionKey] = issnsFound;
this.Session[NotFoundISSNsSessionKey] = issnsNotFound;
return(this.RedirectToAction("Deleted"));
}
return(this.View(model));
}
public void Delete_GET_passes_correct_book_and_searchSortPageParams_to_view()
{
// Arrange
string searchString = "H3J";
string sortCol = "name";
string nextOrder = SearchSortPageViewModel.SORT_ORDER_ASC;
string currentOrder = SearchSortPageViewModel.SORT_ORDER_ASC;
int page = 1;
int pageSize = 5;
int id = 1;
SearchSortPageViewModel sspVM = new SearchSortPageViewModel(searchString, sortCol, currentOrder, nextOrder, page, pageSize);
RecordViewModel rVM = new RecordViewModel(sspVM, id);
// Act
ViewResult result = controller.Delete(rVM) as ViewResult;
DeleteViewModel deleteVM = (DeleteViewModel)result.ViewData.Model;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(id, deleteVM.Book.ID);
Assert.AreEqual("BBB", deleteVM.Book.Name);
Assert.IsNotNull(deleteVM.SearchSortPageParams);
Assert.AreEqual(searchString, deleteVM.SearchSortPageParams.SearchString);
Assert.AreEqual(sortCol, deleteVM.SearchSortPageParams.SortCol);
Assert.AreEqual(nextOrder, deleteVM.SearchSortPageParams.NextOrder);
Assert.AreEqual(page, deleteVM.SearchSortPageParams.Page);
Assert.AreEqual(pageSize, deleteVM.SearchSortPageParams.PageSize);
}
public async Task<ActionResult> Index(IndexViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
Guid? notificationId;
if (model.IsExportNotification.GetValueOrDefault())
{
notificationId = await mediator.SendAsync(new GetNotificationIdByNumber(model.NotificationNumber));
}
else
{
notificationId = await mediator.SendAsync(new GetImportNotificationIdByNumber(model.NotificationNumber));
}
if (notificationId == null)
{
ModelState.AddModelError("NotificationNumber", DeleteNotificationControllerResources.NumberNotExist);
return View(model);
}
var deleteModel = new DeleteViewModel(model, notificationId.GetValueOrDefault());
return RedirectToAction("Check", deleteModel);
}
public async Task <IActionResult> Delete([FromBody] DeleteViewModel model)
{
if (model.Id <= 0)
{
return(BadRequest());
}
var modelo = await _context.SalesStates.FirstOrDefaultAsync(x => x.Id == model.Id);
modelo.Enabled = false;
_context.Entry(modelo).State = EntityState.Modified;
if (modelo == null)
{
return(NotFound());
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Exception
return(BadRequest());
}
return(Ok());
}
public ActionResult Delete(DeleteViewModel vmDelete)
{
try
{
// transfer vm to dto
var dtoAsset = _unitOfWork.Assets.Get(vmDelete.Id);
if (dtoAsset != null)
{
dtoAsset.IsActive = false;
// update db
_unitOfWork.CommitTrans();
// display view with message
TempData["SuccessMessage"] = "Record Deleted";
return(RedirectToAction("Index", "Asset"));
}
TempData["ErrorMessage"] = "Unable to delete record. Try again.";
return(RedirectToAction("Index", "Asset"));
}
catch (Exception)
{
TempData["ErrorMessage"] = "Encountered problem";
return(RedirectToAction("Index", "Asset"));
}
}
public async Task <ActionResult> Delete(Guid id, DeleteViewModel model)
{
var movementId = await mediator.SendAsync(new GetMovementIdIfExists(id, model.Number.Value));
bool result = false;
if (movementId.HasValue)
{
result = await mediator.SendAsync(new DeleteMovement(movementId.Value));
await this.auditService.AddMovementAudit(this.mediator,
id, model.Number.Value,
User.GetUserId(),
MovementAuditType.Deleted);
}
var confirmModel = new ConfirmViewModel
{
Number = model.Number,
Success = result,
NotificationId = id
};
return(RedirectToAction("Confirm", confirmModel));
}
public IActionResult Delete(int id)
{
var data = _classifyService.Get(id);
var result = DeleteViewModel.Convert(data.Id, data.Content);
return(View("_Delete", result));
}
public async Task<ActionResult> Delete(Guid id, DeleteViewModel model)
{
var movementId = await mediator.SendAsync(new GetImportMovementIdIfExists(id, model.Number.Value));
bool result = false;
if (movementId.HasValue)
{
result = await mediator.SendAsync(new DeleteMovement(movementId.Value));
}
var confirmModel = new ConfirmViewModel
{
Number = model.Number,
Success = result,
NotificationId = id
};
return RedirectToAction("Confirm", confirmModel);
}
public ActionResult Delete(DeleteViewModel model)
{
// Actually delete the notification
return View("Confirm", model);
}
public ActionResult Check(DeleteViewModel model)
{
return View(model);
}
public ActionResult Delete(int? id)
{
if (id == null)
{
throw new HttpException(400, "Bad Request");
}
var documentCategory = DocumentCategoryService.FindById(id.Value);
if (documentCategory == null)
{
throw new HttpException(404, "Not Found");
}
var deleteViewModel = new DeleteViewModel()
{
DocumentCategoryId = documentCategory.DocumentCategoryId,
Name = documentCategory.Name,
Description = documentCategory.Description
};
return View(deleteViewModel);
}
