@PostMapping("/")
public String checkPersonInfo(@Valid PersonForm personForm, BindingResult bindingResult) {

	if (bindingResult.hasErrors()) {
		return "form";
	}

	return "redirect:/results";
}

        

@PostMapping("/")
public String checkForm(@Valid UserForm userForm, BindingResult bindingResult,
		RedirectAttributes atts) {

	if (bindingResult.hasErrors()) {
		return "form";
	}

	atts.addAttribute("name", userForm.getName());
	atts.addAttribute("email", userForm.getEmail());

	return "redirect:/showInfo";
}

        

@RequestMapping(value = "/addStudent", method = RequestMethod.POST)
public String addStudent(@ModelAttribute("student") @Validated Student student, 
		BindingResult bindingResult, Model model) {

	if (bindingResult.hasErrors()) {
		return "addStudent";
	}
	model.addAttribute("name", student.getName());
	model.addAttribute("age", student.getAge());
	model.addAttribute("id", student.getId());

	return "result";
}

        

@RequestMapping(method = RequestMethod.POST)
public String submitForm(@ModelAttribute("employee") EmployeeVO employeeVO,
                        BindingResult result, SessionStatus status)
{
     
    //Validation code
    validator.validate(employeeVO, result);
     
    //Check validation errors
    if (result.hasErrors()) {
        return "addEmployee";
    }
     
    //Store the employee information in database
    //manager.createNewRecord(employeeVO);
     
    //Mark Session Complete
    status.setComplete();
    return "redirect:addNew/success";
}

        

@RequestMapping(method = RequestMethod.POST)
  public String handlePostRequest (@Valid @ModelAttribute("user") User user,
                                   BindingResult bindingResult, Model model) {
      if (bindingResult.hasErrors()) {
          return "user-registration";
      }

      userService.saveUser(user);
      return "registration-done";
  }

        

@RequestMapping(value = "/new", method = RequestMethod.POST)
public String createEvent(@Valid CreateEventForm createEventForm, BindingResult result,
        RedirectAttributes redirectAttributes) {
    if (result.hasErrors()) {
        return "events/create";
    }
    CalendarUser attendee = calendarService.findUserByEmail(createEventForm.getAttendeeEmail());
    if (attendee == null) {
        result.rejectValue("attendeeEmail", "attendeeEmail.missing",
                "Could not find a user for the provided Attendee Email");
    }
    if (result.hasErrors()) {
        return "events/create";
    }
    Event event = new Event();
    event.setAttendee(attendee);
    event.setDescription(createEventForm.getDescription());
    event.setOwner(userContext.getCurrentUser());
    event.setSummary(createEventForm.getSummary());
    event.setWhen(createEventForm.getWhen());
    calendarService.createEvent(event);
    redirectAttributes.addFlashAttribute("message", "Successfully added the new event");
    return "redirect:/events/my";
}

        

@RequestMapping(value = "/categories/new", method = RequestMethod.POST)
public String addCategory(@Valid CategoryDTO categoryDTO,
                          BindingResult result,
                          SessionStatus status,
                          RedirectAttributes attributes) {
    if (result.hasErrors()) {
        return ADMIN_CATEGORIES_VIEW;
    } else {

        Category category = postService.createCategory(categoryDTO);
        logger.info("Category Added: {}", category.getCategoryValue());
        status.setComplete();

        webUI.addFeedbackMessage(attributes, FEEDBACK_MESSAGE_CATEGORY_ADDED, category.getCategoryValue());
        return "redirect:/admin/posts/categories";
    }
}

        

PostMapping("/create")
public String createUser(@Valid CreateUserForm form,
                         BindingResult bindingResult,
                         RedirectAttributes redirectAttributes) {
    if (bindingResult.hasErrors()) {
        redirectAttributes.addFlashAttribute("flashMessage", "admin.users.create.error." + bindingResult.getFieldError().getField());

        return "redirect:/admin/users";
    }
    boolean error = false;
    try{
    	userCreationService.create(form.toUisUser());
    }catch(ValidationException e){
    	error = true;
        redirectAttributes.addFlashAttribute("flashMessage", "admin.users.create.error.email");
    }
    if(!error){
    	redirectAttributes.addFlashAttribute("flashMessage", "admin.users.create.success");
    }
    
    return "redirect:/admin/users";
}

        

public String signup(@Valid SignupForm signupForm, BindingResult result, RedirectAttributes redirectAttributes) {
    if(result.hasErrors()) {
        return "signup/form";
    }

    String email = signupForm.getEmail();
    if(calendarService.findUserByEmail(email) != null) {
        result.rejectValue("email", "errors.signup.email", "Email address is already in use.");
        return "signup/form";
    }

    CalendarUser user = new CalendarUser();
    user.setEmail(email);
    user.setFirstName(signupForm.getFirstName());
    user.setLastName(signupForm.getLastName());
    user.setPassword(signupForm.getPassword());

    logger.info("CalendarUser: {}", user);

    int id = calendarService.createUser(user);
    user.setId(id);
    userContext.setCurrentUser(user);

    redirectAttributes.addFlashAttribute("message", "You have successfully signed up and logged in.");
    return "redirect:/";
}

        

@RequestMapping(value = "/comment/add", method = RequestMethod.POST)
public CommentDTO createComment(@Valid @RequestBody CommentDTO commentDTO, BindingResult br){
    if(br.hasErrors()){return null;}
    if(userService.getPrincipal() == null){
        CommentDTO errorDTO = new CommentDTO();
        errorDTO.setErrorAccess(true);
        return errorDTO;
    }
    User user = userService.getUserBySsoId(userService.getPrincipal(), true);
    Comment comment = new Comment(user.getName(), user.getSsoId(), commentDTO.getCommentBody());
    articleService.addComment(comment, commentDTO.getArticleID());
    Long commentID = commentService.saveComment(comment);
    return new CommentDTO(user.getName(), user.getSsoId(), commentID, commentDTO.getCommentBody(), "just now", commentDTO.getArticleID(), false);
}