protected void HandleUpdateException(Result failure, object dto, bool clearPostData)
{
//TODO: Need to research how to turn off automatic model validation if doing it in application service layer
//Clears all Post Data
if (clearPostData)
{
ModelState.Clear();
}
switch (failure.ErrorType)
{
case ErrorType.ObjectValidationFailed:
ModelState.AddValidationErrors(failure.ObjectValidationErrors);
break;
case ErrorType.ConcurrencyConflict:
ModelState.AddValidationErrors(failure.ObjectValidationErrors);
if (dto is IDtoConcurrencyAware)
{
((IDtoConcurrencyAware)dto).RowVersion = failure.NewRowVersion;
}
//Update RowVersion on DTO
break;
default:
ModelState.AddModelError("", Messages.UnknownError);
break;
}
}
public virtual ActionResult RemarkDetailConfirmed(TotalPortal.ViewModels.Helpers.RemarkDetailViewModel voidDetailViewModel)
{
try
{
TEntity entity = this.GetEntityAndCheckAccessLevel(voidDetailViewModel.ID, GlobalEnums.AccessLevel.Readable);
if (entity == null)
{
throw new System.ArgumentException("Lỗi hủy dữ liệu", "BadRequest.");
}
TDto dto = Mapper.Map <TDto>(entity);
if (this.GenericService.SaveRemarkDetail(dto, voidDetailViewModel.DetailID, voidDetailViewModel.Remarks))
{
ModelState.Clear(); ////https://weblog.west-wind.com/posts/2012/apr/20/aspnet-mvc-postbacks-and-htmlhelper-controls-ignoring-model-changes
//IMPORTANT NOTES: ASP.NET MVC Postbacks and HtmlHelper Controls ignoring Model Changes
//HtmlHelpers controls (like .TextBoxFor() etc.) don't bind to model values on Postback, but rather get their value directly out of the POST buffer from ModelState. Effectively it looks like you can't change the display value of a control via model value updates on a Postback operation.
//When MVC binds controls like @Html.TextBoxFor() or @Html.TextBox(), it always binds values on a GET operation. On a POST operation however, it'll always used the AttemptedValue to display the control. MVC binds using the ModelState on a POST operation, not the model's value
//So, if you want the behavior that I was expecting originally you can actually get it by clearing the ModelState in the controller code: ModelState.Clear();
//voidDetailViewModel.Remarks = voidDetailViewModel.Remarks;
return(View("RemarkDetailSuccess", voidDetailViewModel));
}
else
{
throw new System.ArgumentException("Lỗi hủy dữ liệu", "Dữ liệu này không thể hủy được.");
}
}
catch (Exception exception)
{
ModelState.AddValidationErrors(exception);
return(RedirectToAction("RemarkDetail", new { @id = voidDetailViewModel.ID, @detailId = voidDetailViewModel.DetailID }));
}
}
public async Task <IActionResult> CreateLoan(CreateLoanCommand command)
{
try
{
var response = await Mediator.Send(command);
if (response.HasRequestError)
{
ViewBag.Status = new Status {
Type = Type.danger, Message = response.ErrorMessage
};
return(View());
}
}
catch (ValidationException e)
{
ModelState.AddValidationErrors(e);
return(View());
}
ViewBag.Status = new Status {
Type = Type.success, Message = "Loan was successfully created"
};
return(View());
}
protected virtual bool Save(TSimpleViewModel simpleViewModel)
{
try
{
if (!ModelState.IsValid)
{
return(false); //Check Viewmodel IsValid
}
TDto dto = simpleViewModel; // Mapper.Map<TSimpleViewModel, TDto>(simpleViewModel);//Convert from Viewmodel to DTO
if (!this.TryValidateModel(dto))
{
return(false); //Check DTO IsValid
}
else
if (this.GenericService.Save(dto))
{
simpleViewModel.SetID(dto.GetID());
this.BackupViewModelToSession(simpleViewModel);
return(true);
}
else
{
return(false);
}
}
catch (Exception exception)
{
ModelState.AddValidationErrors(exception);
return(false);
}
}
public ActionResult Index(SearchContactViewModel searchContactViewModel)
{
try
{
searchContactViewModel.PagedResult = _contactCrudService.Search(searchContactViewModel.PagedFilter);
}
catch (ValidationException ex)
{
ModelState.AddValidationErrors(ex);
}
return(View(searchContactViewModel));
}
public async Task <ActionResult> Index(SearchContactViewModel searchContactViewModel)
{
try
{
searchContactViewModel.PagedResult = await this.contactApplicationService.SearchAsync(searchContactViewModel.PagedFilter);
}
catch (ValidationException ex)
{
ModelState.AddValidationErrors(ex);
}
return(View(searchContactViewModel));
}
public ActionResult Active(int profileId)
{
try
{
this.accountServices.SetActiveProfileToUser(profileId);
this.AddNotification("New profile selected.", NotificationType.SUCCESS);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
catch (ValidationErrors verror)
{
ModelState.AddValidationErrors(verror);
this.AddValidationErrorNotification(verror, NotificationType.ERROR);
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
public ActionResult Create(WorkoutSessionViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
ServiceFactory.WorkoutSession.Create(Model);
}
catch (ValidationErrors propertyErrors)
{
ModelState.AddValidationErrors(propertyErrors);
}
}
return(View("CreateForWorkout", viewModel));
}
public ActionResult Create(WorkoutViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
ServiceFactory.Workout.Create(Model);
return(Index());
}
catch (ValidationErrors propertyErrors)
{
ModelState.AddValidationErrors(propertyErrors);
}
}
return(View("Create"));
}
public ActionResult Edit(ContactInfoDetailDto contactInfoDetailDto)
{
if (ModelState.IsValid)
{
try
{
this.contactApplicationService.UpdateContactInfoAsync(contactInfoDetailDto);
return(RedirectToAction("Edit", "Contacts", new { id = contactInfoDetailDto.ContactId }));
}
catch (ValidationException ex)
{
ModelState.AddValidationErrors(ex);
}
}
return(View(contactInfoDetailDto));
}
public ActionResult Create(MuscleViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
var fromDatabase = ServiceFactory.Muscle.Create(Model);
var viewModelFromDatabase = MapperFactory.GetMapper <Muscle, MuscleViewModel>().GetViewModel(fromDatabase);
return(View("Details", viewModelFromDatabase));
}
catch (ValidationErrors propertyErrors)
{
ModelState.AddValidationErrors(propertyErrors);
}
}
return(View(viewModel));
}
public ActionResult Create(ExerciseViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
var viewModelSaved = ServiceFactory.Exercise.Create(Model);
return(RedirectToAction("Details", new { Id = viewModelSaved.Id }));
}
catch (ValidationErrors propertyErrors)
{
ModelState.AddValidationErrors(propertyErrors);
}
}
viewModel.ListMuscles = ServiceFactory.Muscle.GetAllSelector();
return(View(viewModel));
}
public ActionResult Create(ContactInfoDetailDto contactInfoDetailDto)
{
if (ModelState.IsValid)
{
try
{
_contactCrudService.CreateContactInfo(contactInfoDetailDto);
return(RedirectToAction("Edit", "Contacts", new { id = contactInfoDetailDto.ContactId }));
}
catch (ValidationException ex)
{
ModelState.AddValidationErrors(ex);
}
}
return(View(contactInfoDetailDto));
}
public ActionResult Create(ContactDetailDto contact)
{
if (ModelState.IsValid)
{
try
{
_contactCrudService.CreateContact(contact);
return(RedirectToAction("Index"));
}
catch (ValidationException ex)
{
ModelState.AddValidationErrors(ex);
}
}
return(View(contact));
}
public async Task <IActionResult> Create(CreateRoleModel model)
{
if (ModelState.IsValid)
{
var result = await createRoleService.CreateRoleAsync(model);
if (result.Succeeded)
{
long roleId = (await getRolesService.GetRoleByNameAsync(model.Name !)).Id;
return(RedirectToAction("Detail", new { id = roleId }));
}
ModelState.AddValidationErrors(result);
}
return(View("Create", new CreateRoleViewModel(model)));
}
public ActionResult Create(WorkoutSessionExerciseViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
ServiceFactory.WorkoutSessionExercise.Create(Model);
}
catch (ValidationErrors propertyErrors)
{
ModelState.AddValidationErrors(propertyErrors);
}
}
WorkoutSessionViewModel x = ServiceFactory.WorkoutSessionExercise.GetWorkoutSessionWithWorkoutSessionExercise(Model.WorkoutSession.Id);
return(View("Index", x));
}
public ActionResult Edit(ContactDetailDto contact)
{
if (ModelState.IsValid)
{
try
{
_contactCrudService.UpdateContact(contact);
return(RedirectToAction("Index"));
}
catch (ValidationException ex)
{
ModelState.AddValidationErrors(ex);
}
}
contact.ContactInfos = _contactCrudService.GetContactInfosForContact(contact.Id).ToList();
return(View(contact));
}
public async Task <ActionResult> Create(ContactDetailDto contact)
{
if (ModelState.IsValid)
{
try
{
await this.contactApplicationService.CreateContactAsync(contact);
return(RedirectToAction("Index"));
}
catch (ValidationException ex)
{
ModelState.AddValidationErrors(ex);
}
}
return(View(contact));
}
public async Task <IActionResult> Create(SensorModel model)
{
if (ModelState.IsValid)
{
var result = await createSensorService.CreateSensorAsync(model);
if (result.ValidationResult.Succeeded)
{
return(RedirectToAction("Detail", new { Id = result.Value }));
}
ModelState.AddValidationErrors(result.ValidationResult);
}
var vm = await CreateAndFillViewModelAsync(model, true);
return(View("Detail", vm));
}
public async Task <IActionResult> Update(RoleModel model)
{
if (ModelState.IsValid)
{
var result = await updateRoleService.UpdateRoleAsync(model);
if (result.Succeeded)
{
return(RedirectToAction("Detail", new { id = model.Id }));
}
ModelState.AddValidationErrors(result);
}
var permissions = await getPermissionsService.GetRolePermissionsAsync(model.Id);
return(View("Detail", new DetailRoleViewModel(model, permissions)));
}
public async Task <ActionResult> Edit(ContactDetailDto contact)
{
if (ModelState.IsValid)
{
try
{
await this.contactApplicationService.UpdateContactAsync(contact);
return(RedirectToAction("Index"));
}
catch (ValidationException ex)
{
ModelState.AddValidationErrors(ex);
}
}
contact.ContactInfos = (await this.contactApplicationService.GetContactInfosForContactAsync(contact.Id)).ToList();
return(View(contact));
}
public virtual ActionResult HoldConfirmed(LabViewModel labViewModel)
{
try
{
if (this.labService.ToggleHold(labViewModel))
{
return(RedirectToAction("Edit", new { id = labViewModel.GetID() }));
}
else
{
throw new System.ArgumentException("Lỗi hold hoặc release", "Dữ liệu này không thể hold hoặc release.");
}
}
catch (Exception exception)
{
ModelState.AddValidationErrors(exception);
return(RedirectToAction("Hold", labViewModel.GetID()));
}
}
public async Task <IActionResult> Detail(PermissionModel model)
{
if (ModelState.IsValid)
{
var result = await updatePermissionService.UpdateAsync(model);
if (result.Succeeded)
{
return(RedirectToAction("Detail", new { id = model.Id }));
}
ModelState.AddValidationErrors(result);
}
return(View("Detail", new PermissionViewModel(model)
{
CanEdit = await permissionVerificationService.HasPermissionAsync(User.Identity.Name !, "Administration.Permission.Edit"),
IsCreatePage = false
}));
public virtual ActionResult DeleteConfirmed(int id)
{
try
{
if (this.GenericService.Delete(id))
{
return(RedirectToAction("Index"));
}
else
{
throw new System.ArgumentException("Lỗi xóa dữ liệu", "Dữ liệu này không thể xóa được.");
}
}
catch (Exception exception)
{
ModelState.AddValidationErrors(exception);
return(RedirectToAction("Delete", id));
}
}
public virtual ActionResult ApproveConfirmed(TSimpleViewModel simpleViewModel)
{
try
{
if (this.GenericService.ToggleApproved(simpleViewModel))
{
return(RedirectToAction((simpleViewModel.Approved && simpleViewModel.EditAfterUnApprove) || (!simpleViewModel.Approved && simpleViewModel.EditAfterApprove) ? "Edit" : "Index", new { id = simpleViewModel.GetID() }));
}
else
{
throw new System.ArgumentException("Lỗi vô hiệu dữ liệu", "Dữ liệu này không thể vô hiệu.");
}
}
catch (Exception exception)
{
ModelState.AddValidationErrors(exception);
return(RedirectToAction("Approve", simpleViewModel.GetID()));
}
}
public virtual ActionResult AlterConfirmed(TSimpleViewModel simpleViewModel)
{
try
{
if (this.GenericService.Alter(simpleViewModel))
{
return(RedirectToAction("Index"));
}
else
{
throw new System.ArgumentException("Lỗi vô hiệu dữ liệu", "Dữ liệu này không thể vô hiệu.");
}
}
catch (Exception exception)
{
ModelState.AddValidationErrors(exception);
return(View("Alter", this.TailorViewModel(simpleViewModel, false, true)));
//return RedirectToAction("Alter", simpleViewModel.GetID());
}
}
public async Task <IActionResult> Login(LoginCommand command, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
try
{
var isSuccess = await Mediator.Send(command);
if (isSuccess)
{
return(RedirectToLocal(returnUrl));
}
ModelState.AddModelError("Password", "Invalid email or password");
}
catch (ValidationException e)
{
ModelState.AddValidationErrors(e);
}
return(View());
}
public async Task <IActionResult> Update(UserModel model, List <long> roles)
{
// isn't admin and he isn't trying to change his own password
if (!await IsAuthorizedToChangeUserSettings(model.Id))
{
return(Unauthorized());
}
if (ModelState.IsValid)
{
// if user attempts to update roles and is not admin => error
var storedRoles = (await getRolesService.GetUserRolesAsync(model.Id)).Select(x => x.Id).ToList();
if (!storedRoles.UnorderedEquals(roles) && !await permissionVerificationService.HasPermissionAsync(User.Identity.Name !, "Administration.User.EditAll"))
{
return(Unauthorized());
}
var result = await updateUserService.AddToOrRemoveFromRolesAsync(model.Id, roles);
if (result.Succeeded)
{
return(RedirectToAction("Detail", new { id = model.Id }));
}
ModelState.AddValidationErrors(result);
}
var availableRoles = await getRolesService.GetAllRolesAsync();
var permissions = await getPermissionsService.GetAllUserPermissionsWithRolesAsync(model.Id);
return(View("Detail", new DetailUserViewModel(model, roles,
(List <RoleModel>)availableRoles, (List <PermissionRoleModel>)permissions)
{
CanDelete = User.Identity.Name != model.UserName,
CanEditRoles = await permissionVerificationService.HasPermissionAsync(User.Identity.Name !, "Administration.User.EditAll")
}));
public virtual ActionResult VoidConfirmed(TSimpleViewModel simpleViewModel)
{
try
{
if (simpleViewModel.VoidTypeID == null || simpleViewModel.VoidTypeID <= 0)
{
throw new System.ArgumentException("Lỗi hủy dữ liệu", "Vui lòng nhập lý do hủy đơn hàng.");
}
if (this.GenericService.ToggleVoid(simpleViewModel))
{
return(RedirectToAction((simpleViewModel.InActive && simpleViewModel.EditAfterVoid) || (!simpleViewModel.InActive && simpleViewModel.EditAfterUnVoid) ? "Edit" : "Index", new { id = simpleViewModel.GetID() }));
}
else
{
throw new System.ArgumentException("Lỗi duyệt dữ liệu", "Dữ liệu này không thể duyệt được.");
}
}
catch (Exception exception)
{
ModelState.AddValidationErrors(exception);
return(RedirectToAction("Void", simpleViewModel.GetID()));
}
}
public virtual ActionResult ChangeExpiryDateConfirmed(ExpiryDateViewModel expiryDateViewModel)
{
try
{
if (expiryDateViewModel.ExpiryDate == null || expiryDateViewModel.Remarks == null || expiryDateViewModel.Remarks.Trim() == "")
{
throw new System.ArgumentException("Lỗi gia hạn sử dụng", "Vui lòng nhập ngày và số hồ sơ gia hạn.");
}
GoodsArrival entity = this.GetEntityAndCheckAccessLevel(expiryDateViewModel.GoodsArrivalID, GlobalEnums.AccessLevel.Readable);
if (entity == null)
{
throw new System.ArgumentException("Lỗi gia hạn sử dụng", "BadRequest.");
}
if (this.goodsArrivalService.ChangeExpiryDate(expiryDateViewModel.GoodsArrivalID, expiryDateViewModel.GoodsArrivalDetailID, expiryDateViewModel.ExpiryDate, expiryDateViewModel.Remarks))
{
ModelState.Clear(); ////https://weblog.west-wind.com/posts/2012/apr/20/aspnet-mvc-postbacks-and-htmlhelper-controls-ignoring-model-changes
//IMPORTANT NOTES: ASP.NET MVC Postbacks and HtmlHelper Controls ignoring Model Changes
//HtmlHelpers controls (like .TextBoxFor() etc.) don't bind to model values on Postback, but rather get their value directly out of the POST buffer from ModelState. Effectively it looks like you can't change the display value of a control via model value updates on a Postback operation.
//When MVC binds controls like @Html.TextBoxFor() or @Html.TextBox(), it always binds values on a GET operation. On a POST operation however, it'll always used the AttemptedValue to display the control. MVC binds using the ModelState on a POST operation, not the model's value
//So, if you want the behavior that I was expecting originally you can actually get it by clearing the ModelState in the controller code: ModelState.Clear();
//voidDetailViewModel.Remarks = voidDetailViewModel.Remarks;
return(View("ChangeExpiryDateSuccess", expiryDateViewModel));
}
else
{
throw new System.ArgumentException("Lỗi gia hạn sử dụng", "Lỗi gia hạn sử dụng.");
}
}
catch (Exception exception)
{
ModelState.AddValidationErrors(exception);
return(RedirectToAction("ChangeExpiryDate", new { @id = expiryDateViewModel.GoodsArrivalID, @detailId = expiryDateViewModel.GoodsArrivalDetailID }));
}
}
