public async Task <ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new User { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, AccountImage = model.AccountImage?.ToByteArray() }; var result = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (result.Succeeded) { var currentUser = await _userManager.FindByEmailAsync(user.Email).ConfigureAwait(false); await _userManager.AddToRoleAsync(currentUser.Id, "User").ConfigureAwait(false); await _signInManager.SignInAsync(user, isPersistent : false, rememberBrowser : true).ConfigureAwait(false); Logger.Log.Info($"Был зарегистрирован новый пользователь {user.Email}"); return(View("DisplayEmail")); } ModelState.AddModelErrors(result.Errors.Select(x => new ValidationResult(x))); } // If we got this far, something failed, redisplay form return(View(model)); }
public IActionResult Put(long id, [FromBody] Calibration model) { try { if (!ModelState.IsValid) { return(InvalidModelStateResult()); } if (!validateEntity(model)) { return(InvalidModelStateResult()); } var modelStateDic = repository.ValidateEntity(model); if (modelStateDic.Count > 0) { ModelState.AddModelErrors(modelStateDic); return(InvalidModelStateResult()); } if (repository.Get().Count(a => a.CalibrationId.Equals(model.CalibrationId)) == 0) { return(NotFound(Constants.ErrorMessages.NotFoundEntity)); } return(Accepted(repository.Update(model))); } catch (Exception ex) { logger.LogError(ex.GetExceptionMessages()); return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.UpdateError)); } }
public virtual object SaveEdit(string pagePath, Page pageInput, User currentUser) { string pageToEditPath = pagePath.Substring(0, pagePath.Length - ("/" + PageMode.Edit).Length); if (pageToEditPath.Length == pagePath.Length) { return(null); } Page page = pageService.GetPage(pageToEditPath); if (page == null) { return(null); } ValidationStateDictionary validationState; pageService.EditPage(page, pageInput.Parent, pageInput, out validationState); if (!validationState.IsValid) { ModelState.AddModelErrors(validationState); return(Edit(pageToEditPath)); } page = pageService.GetPage(pageInput.Slug, pageInput.Parent.ID); return(Redirect(Url.AppPath(page.Path))); }
public ActionResult CreateGoal(GroupGoalFormModel goal) { GroupGoal groupgoal = Mapper.Map <GroupGoalFormModel, GroupGoal>(goal); var groupUser = groupUserService.GetGroupUser(User.Identity.GetUserId(), goal.GroupId); groupgoal.GroupUserId = groupUser.GroupUserId; //groupgoal.GroupUser = groupUser; //if (groupgoal.AssignedTo == null) //{ // groupgoal.AssignedGroupUserId = null; //} var errors = groupGoalService.CanAddGoal(groupgoal, groupUpdateService).ToList(); ModelState.AddModelErrors(errors); if (ModelState.IsValid) { //groupgoal.GroupUser.UserId = ((SocialGoalUser)(User.Identity)).UserId; groupGoalService.CreateGroupGoal(groupgoal); return(RedirectToAction("Index", new { id = goal.GroupId })); } //goal.Group = groupService.GetGroup(goal.GroupUser.GroupId); var metrics = metricService.GetMetrics(); var focuss = focusService.GetFocussOfGroup(goal.GroupId); goal.Metrics = metrics.ToSelectListItems(-1); goal.Foci = focuss.ToSelectListItems(-1); return(View(goal)); }
// Bind(Include = "...") is used to avoid overposting attacks public async Task <ActionResult> EditInscripcion(EditOwnInscripcionViewModel viewModel) { try { Usuario user = await _usuarioEndpoint.GetCurrentUsuario(token : _userSession.BearerToken); viewModel.SetAlumno(user.Id); var entity = _mapper.Map <Inscripcion>(viewModel.Inscripcion); if (entity.State == null) { entity.State = Inscripcion.InscripcionStates.Active; } await _inscripcionEndpoint.Put(entity, _userSession.BearerToken); } catch (UnauthorizedRequestException) { return(RedirectToAction("AccessDeniedPartial", "Error")); } catch (BadRequestException ex) { viewModel.SetEstadosAsSelectList(); ModelState.AddModelErrors(ex.Errors); return(PartialView("_EditOwnInscripcion", viewModel)); } catch (Exception ex) { return(RedirectToAction("SpecificErrorPartial", "Error", new { error = ex.Message })); } return(Content("OK")); }
public ActionResult Save(CategoryFormModel form) { if (ModelState.IsValid) { //TODO: Create Automapper form => command var command = new CreateOrUpdateCategoryCommand() { CategoryId = form.CategoryId, Name = form.Name, Description = form.Description }; IEnumerable <ValidationResult> errors = commandBus.Validate(command); ModelState.AddModelErrors(errors); if (ModelState.IsValid) { var result = commandBus.Submit(command); if (result.Success) { return(RedirectToAction("Index")); } } } if (form.CategoryId == 0) { return(View("Create", form)); } else { return(View("Edit", form)); } }
public ActionResult Save(PostProfileFormModel form) { if (ModelState.IsValid) { var command = Mapper.Map <PostProfileFormModel, CreateOrUpdatePostProfileCommand>(form); IEnumerable <ValidationResult> errors = commandBus.Validate(command); ModelState.AddModelErrors(errors); if (ModelState.IsValid) { var result = commandBus.Submit(command); if (result.Success) { return(RedirectToAction("Index")); } } } //if fail if (form.ProfileId == 0) { return(View("Create", form)); } else { return(View("Edit", form)); } }
public async Task <IActionResult> XhrEdit(ControllerModels.Messages.EditInput input) { var message = await DbContext.Messages.FirstOrDefaultAsync(m => m.Id == input.Id); if (message is null || message.Deleted) { throw new HttpNotFoundError(); } if (message.PostedById != UserContext.ApplicationUser.Id && !UserContext.IsAdmin) { throw new HttpForbiddenError(); } if (ModelState.IsValid) { var result = await MessageRepository.EditMessage(input); ModelState.AddModelErrors(result.Errors); if (ModelState.IsValid) { await ForumHub.Clients.All.SendAsync("updated-message", new HubModels.Message { TopicId = result.TopicId, MessageId = result.MessageId }); return(Ok()); } } var errors = ModelState.Keys.Where(k => ModelState[k].Errors.Count > 0).Select(k => new { propertyName = k, errorMessage = ModelState[k].Errors[0].ErrorMessage }); return(new JsonResult(errors)); }
public async Task <IActionResult> AddThought(int id, int smiley) { var message = await DbContext.Messages.FirstOrDefaultAsync(m => m.Id == id); if (message is null || message.Deleted) { throw new HttpNotFoundError(); } if (ModelState.IsValid) { var result = await MessageRepository.AddThought(id, smiley); ModelState.AddModelErrors(result.Errors); if (ModelState.IsValid) { await ForumHub.Clients.All.SendAsync("updated-message", new HubModels.Message { TopicId = result.TopicId, MessageId = result.MessageId }); var redirectPath = Url.DisplayMessage(result.TopicId, result.MessageId); return(Redirect(redirectPath)); } } return(ForumViewResult.RedirectToReferrer(this)); }
// Bind(Include = "...") is used to avoid overposting attacks public async Task <ActionResult> Edit(MvcDepartamentoModel departamento) { try { var entity = _mapper.Map <Departamento>(departamento); await _departamentoEndpoint.Put(entity, _userSession.BearerToken); } catch (UnauthorizedRequestException) { return(RedirectToAction("AccessDeniedPartial", "Error")); } catch (BadRequestException ex) { ModelState.AddModelErrors(ex.Errors); return(PartialView("_Edit", departamento)); } catch (Exception ex) { return(RedirectToAction("SpecificErrorPartial", "Error", new { error = ex.Message })); } return(Content("OK")); }
public async Task <IActionResult> XhrReply(ControllerModels.Messages.CreateReplyInput input) { if (input.Id > 0) { var message = await DbContext.Messages.FirstOrDefaultAsync(m => m.Id == input.Id); if (message is null || message.Deleted) { throw new HttpNotFoundError(); } } if (ModelState.IsValid) { var result = await MessageRepository.CreateReply(input); ModelState.AddModelErrors(result.Errors); if (ModelState.IsValid) { await ForumHub.Clients.All.SendAsync("new-reply", new HubModels.Message { TopicId = result.TopicId, MessageId = result.MessageId }); return(Ok()); } } var errors = ModelState.Keys.Where(k => ModelState[k].Errors.Count > 0).Select(k => new { propertyName = k, errorMessage = ModelState[k].Errors[0].ErrorMessage }); return(new JsonResult(errors)); }
public virtual ActionResult Edit(TIdType id, TEditModel viewModel) { if (!ModelState.IsValid) { // Send the errors to the debug console. ModelState.OutputErrors(); PopulateEditModel(viewModel); return(EditFailed(viewModel)); } var entity = GetEntity(id); if (entity == null) { return(HttpNotFound()); } var errors = ProcessEdit(entity, viewModel); if (errors.Any()) { ModelState.AddModelErrors(errors); PopulateEditModel(viewModel); return(EditFailed(viewModel)); } return(EditSucceeded(viewModel, entity)); }
public async Task <ActionResult> Edit(EditMateriaViewModel viewModel) { try { var entity = _mapper.Map <Materia>(viewModel.Materia); await _materiaEndpoint.Put(entity, _userSession.BearerToken); } catch (UnauthorizedRequestException) { return(RedirectToAction("AccessDeniedPartial", "Error")); } catch (BadRequestException ex) { IEnumerable <Departamento> entities = await _departamentoEndpoint.GetAll(_userSession.BearerToken); var departamentos = _mapper.Map <IEnumerable <MvcDepartamentoModel> >(entities); viewModel.SetDepartamentosAsSelectList(departamentos); ModelState.AddModelErrors(ex.Errors); return(PartialView("_Edit", viewModel)); } catch (Exception ex) { return(RedirectToAction("SpecificErrorPartial", "Error", new { error = ex.Message })); } return(Content("OK")); }
//[ValidateAntiForgeryToken] public async Task <IActionResult> Register([FromBody] RegisterUserInfoDTO model) { if (model == null) { throw new ArgumentNullException(nameof(model)); } var user = new IdentityUser { UserName = model.UserName, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.NewPassword); ActionResult actionResult; if (!result.Succeeded) { var errorDescriptions = result.Errors.Select(x => x.Description); Logger.LogError($"Tried to register user '{model.Email}', but failed. Errors:\n {string.Join("; ", errorDescriptions)}"); ModelState.AddModelErrors(result.GetFormatedErrors()); actionResult = BadRequest(ModelState); } else { Logger.LogInformation($"User '{model.Email}' created a new account with password."); actionResult = Ok(user); } return(actionResult); }
public async Task <ActionResult> CreateHorario(CreateOwnHorarioConsultaViewModel viewModel) { try { Usuario user = await _usuarioEndpoint.GetCurrentUsuario(token : _userSession.BearerToken); viewModel.SetProfesor(user.Id); var horarioConsulta = _mapper.Map <HorarioConsulta>(source: viewModel.HorarioConsulta); await _horarioConsultaEndpoint.Post(horarioConsulta, _userSession.BearerToken); } catch (UnauthorizedRequestException) { return(RedirectToAction("AccessDenied", "Error")); } catch (BadRequestException ex) { IEnumerable <Materia> entities = await _materiaEndpoint.GetAll(_userSession.BearerToken);; var materias = _mapper.Map <IEnumerable <MvcMateriaModel> >(source: entities); viewModel.SetMateriasAsSelectList(materias); viewModel.SetDiasSemanaAsSelectList(); ModelState.AddModelErrors(ex.Errors); return(PartialView("_CreateOwnHorario", viewModel)); } catch (Exception ex) { return(RedirectToAction("SpecificError", "Error", new { error = ex.Message })); } return(Content("OK")); }
public async Task <IActionResult> CompleteWithEmailAsync([FromQuery] SignUpCompleteWithEmailViewModel model) { User user = await UserManager.FindByEmailAsync(model.Email); if (user == null) { ModelState.AddModelError("Email", ApiError.NotFound); } else if (user.EmailConfirmed) { ModelState.AddModelError("Email", ApiError.AlreadyCompleted); } else { IdentityResult result = await UserManager.ConfirmEmailAsync(user, model.Token); if (result.Succeeded) { await SignInManager.SignInAsync(user, false); return(Redirect("/email-confirmed")); } else { ModelState.AddModelErrors(result); } } return(BadRequest(ModelState)); }
public IActionResult SendToken(HomeSendToken m) { if (ModelState.IsValid) { if (m.Token.Equals("none", StringComparison.OrdinalIgnoreCase)) { throw new AppException("None is one bad-ass code which we do not accept."); } if (m.Token.Equals("everything", StringComparison.OrdinalIgnoreCase)) { ModelState.AddModelError(string.Empty, "Too greedy token!"); } if (m.Token.Equals("secret", StringComparison.OrdinalIgnoreCase)) { try { throw new AppException("It is secret, you know. No clue."); } catch (AppException ex) { ModelState.AddModelErrors(ex); } } if (m.Token.Equals("error", StringComparison.OrdinalIgnoreCase)) { throw new Exception("Error!"); } } return(View("Contact", m)); }
// Bind(Include = "...") is used to avoid overposting attacks public async Task <ActionResult> Edit(EditHorarioConsultaFechadoViewModel viewModel) { try { var entity = _mapper.Map <HorarioConsultaFechado>(viewModel.HorarioConsultaFechado); await _horarioConsultaFechadoEndpoint.Put(entity, _userSession.BearerToken); } catch (UnauthorizedRequestException) { return(RedirectToAction("AccessDeniedPartial", "Error")); } catch (BadRequestException ex) { var horariosConsultaTask = _horarioConsultaEndpoint.GetAll(_userSession.BearerToken); await Task.WhenAll(horariosConsultaTask); var horariosConsulta = _mapper.Map <IEnumerable <MvcHorarioConsultaModel> >(source: horariosConsultaTask.Result); viewModel.SetHorariosConsultaAsSelectList(horariosConsulta); viewModel.SetEstadosAsSelectList(); ModelState.AddModelErrors(ex.Errors); return(PartialView("_Edit", viewModel)); } catch (Exception ex) { return(RedirectToAction("SpecificErrorPartial", "Error", new { error = ex.Message })); } return(Content("OK")); }
public ActionResult Edit(int id, FormCollection forms) { if (id == 0) { CmsMenu newMenu = new CmsMenu() { Title = forms.GetValue("Title").AttemptedValue, Description = forms.GetValue("Description").AttemptedValue, Type = forms.GetValue("Type").AttemptedValue }; if (newMenu.IsValid) { return(this.CreateNewMenu(newMenu)); } ModelState.AddModelErrors(newMenu.GetRuleViolations()); return(View(newMenu)); } CmsMenu menu = this.menuService.LoadMenu(id); UpdateModel(menu, forms.ToValueProvider()); this.menuService.SaveMenu(menu); TempData["SuccessResult"] = "Menu was successfully saved"; return(this.View(menu)); }
public async Task <IActionResult> Put(int id, [FromBody] ProductViewModel productViewModel) { try { if (ModelState.IsValid) { var product = _mapper.Map <Product>(productViewModel); var validationResult = await _productHandler.CanUpdate(id, product); if (validationResult == null) { product.Id = id; var result = await _productService.Update(product); if (result.ValidationResults.Count == 0) { return(Ok("Product modified successfully!")); } ModelState.AddModelErrors(result.ValidationResults); } ModelState.AddModelError(validationResult); } } catch (Exception ex) { var exceptionMessage = await Helpers.GetErrors(ex); ModelState.AddModelError(new ValidationResult(exceptionMessage)); } return(BadRequest(ModelState.GetErrors())); }
public async Task <IActionResult> Post([FromBody] PurchaseOrder model) { try { if (!ModelState.IsValid) { return(this.InvalidModelStateResult <PurchaseOrdersController>(logger)); } var modelStateDic = repository.ValidateEntity(model); if (modelStateDic.Count > 0) { ModelState.AddModelErrors(modelStateDic); return(this.InvalidModelStateResult <PurchaseOrdersController>(logger)); } var result = await repository.CreateAsync(model); return(Accepted(result)); } catch (Exception ex) { logger.LogError(ex.GetExceptionMessages()); return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.CreateError)); } }
public IHttpActionResult Login(LoginRequestModel requestModel) { if (ModelState.IsValid) { AccountCommand accountCommand = Mapper.Map <AccountCommand>(requestModel); IEnumerable <ValidationResult> validations = commandDispatcher.Validate(accountCommand); ModelState.AddModelErrors(validations); if (ModelState.IsValid) { AccountByUsernameQuery query = new AccountByUsernameQuery(requestModel.Username); Account account = queryDispatcher.Dispatch <AccountByUsernameQuery, Account>(query); AuthCommand loginCommand = new AuthCommand(account.Id, requestModel.RememberMe); Authentication authentication = commandDispatcher.Dispatch <AuthCommand, Authentication>(loginCommand); AccountResponseModel responseModel = Mapper .Map <AccountResponseModel>(authentication) .Map(account); return(Ok(responseModel)); } } return(BadRequest(ModelState)); }
public async Task <ActionResult> Subscribe( [Bind(Include = "HorarioConsultaFechadoId, Observation, Topic")] MvcInscripcionModel inscripcion) { try { Usuario user = await _usuarioEndpoint.GetCurrentUsuario(token : _userSession.BearerToken); inscripcion.State = MvcInscripcionModel.InscripcionStates.Active; inscripcion.AlumnoId = user.Id; var entity = _mapper.Map <Inscripcion>(source: inscripcion); await _inscripcionEndpoint.Post(entity, _userSession.BearerToken); } catch (UnauthorizedRequestException) { return(RedirectToAction("AccessDeniedPartial", "Error")); } catch (BadRequestException ex) { HorarioConsultaFechado entity = await _horarioConsultaFechadoEndpoint.Get(inscripcion.HorarioConsultaFechadoId, _userSession.BearerToken); var horarioFechado = _mapper.Map <MvcHorarioConsultaFechadoModel>(source: entity); inscripcion.HorarioConsultaFechado = horarioFechado; ModelState.AddModelErrors(ex.Errors); return(PartialView("_Subscribe", inscripcion)); } catch (Exception ex) { return(RedirectToAction("SpecificErrorPartial", "Error", new { error = ex.Message })); } return(Content("OK")); }
public async Task <IActionResult> Reset(ResetPasswordCommand command) { if (!ModelState.IsValid) { return(View(command)); } var response = await this.Mediator.Send(command); if (response.IsFailure) { ModelState.AddModelErrors(response.Errors); command.NewPassword = string.Empty; command.ConfirmNewPassword = string.Empty; return(View(command)); } return(RedirectToAction("Result", new ResultViewModel { IsSuccess = true, Title = "Reset Password", Description = "You can reset your password", Messages = new List <string>() { "You're password has been successfully changed!" } })); }
public IActionResult Post([FromBody] Calibration model) { try { if (!ModelState.IsValid) { return(InvalidModelStateResult()); } if (!validateEntity(model)) { return(InvalidModelStateResult()); } var modelStateDic = repository.ValidateEntity(model); if (modelStateDic.Count > 0) { ModelState.AddModelErrors(modelStateDic); return(InvalidModelStateResult()); } return(Accepted(repository.Create(model))); } catch (Exception ex) { logger.LogError(ex.GetExceptionMessages()); return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.CreateError)); } }
public async Task <IActionResult> Put(int id, [FromBody] CategoryViewModel categoryViewModel) { try { if (ModelState.IsValid) { var category = _mapper.Map <Category>(categoryViewModel); var validationResult = await _categoryHandler.CanUpdate(id, category); if (validationResult == null) { category.Id = id; var result = await _categoryService.Update(category); if (result.ValidationResults.Count == 0) { return(Ok("Category modified successfully!")); } ModelState.AddModelErrors(result.ValidationResults); } ModelState.AddModelError(validationResult); } } catch (Exception ex) { var exceptionMessage = await Helpers.GetErrors(ex); ModelState.AddModelError(new ValidationResult(exceptionMessage)); } return(BadRequest(ModelState.GetErrors())); }
public ActionResult ChangePassword(ChangePasswordFormModel form) { if (ModelState.IsValid) { EFMVCUser efmvcUser = HttpContext.User.GetEFMVCUser(); var command = new ChangePasswordCommand { UserId = efmvcUser.UserId, OldPassword = form.OldPassword, NewPassword = form.NewPassword }; IEnumerable <ValidationResult> errors = commandBus.Validate(command); ModelState.AddModelErrors(errors); if (ModelState.IsValid) { var result = commandBus.Submit(command); if (result.Success) { return(RedirectToAction("ChangePasswordSuccess")); } else { ModelState.AddModelError("", "The current password is incorrect or the new password is invalid."); } } } // If we got this far, something failed, redisplay form return(View(form)); }
public IHttpActionResult Register(RegisterRequestModel requestModel) { if (ModelState.IsValid) { UsernameCommand uniqueUsernameCommand = new UsernameCommand(requestModel.Username); IEnumerable <ValidationResult> validations = commandDispatcher.Validate(uniqueUsernameCommand); ModelState.AddModelErrors(validations); if (ModelState.IsValid) { AccountCommand accountCommand = new AccountCommand(requestModel.Username, requestModel.Password); Account account = commandDispatcher.Dispatch <AccountCommand, Account>(accountCommand); AuthCommand authCommand = new AuthCommand(account.Id, false); Authentication authentication = commandDispatcher.Dispatch <AuthCommand, Authentication>(authCommand); AccountResponseModel responseModel = Mapper .Map <AccountResponseModel>(authentication) .Map(account); return(Ok(responseModel)); } } return(BadRequest(ModelState)); }
public ActionResult Edit(GoalFormModel editGoal) { Goal goalToEdit = Mapper.Map <GoalFormModel, Goal>(editGoal); var errors = goalService.CanAddGoal(goalToEdit, updateService); ModelState.AddModelErrors(errors); if (ModelState.IsValid) { goalService.EditGoal(goalToEdit); return(RedirectToAction("Index", new { id = editGoal.GoalId })); } else { var metrics = metricService.GetMetrics(); var goalstatus = goalStatusService.GetGoalStatus(); var goal = goalService.GetGoal(editGoal.GoalId); if (goal.Metric != null) { editGoal.Metrics = metrics.ToSelectListItems(goal.Metric.MetricId); } else { editGoal.Metrics = metrics.ToSelectListItems(-1); } return(View(editGoal)); } }
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await _userManager.FindByNameAsync(model.Email).ConfigureAwait(false); if (user == null) { // Don't reveal that the user does not exist return(RedirectToAction("ResetPasswordConfirmation", "Account")); } var result = await _userManager.ResetPasswordAsync(user.Id, model.Code, model.Password).ConfigureAwait(false); if (result.Succeeded) { Logger.Log.Info($"Пользователь {user.Email} сбросил пароль"); return(RedirectToAction("ResetPasswordConfirmation", "Account")); } ModelState.AddModelErrors(result.Errors.Select(x => new ValidationResult(x))); return(View()); }