com.miserablemind.butter.apps.butterApp.controller.guest.SignUpController.java Source code

Introduction

Here is the source code for com.miserablemind.butter.apps.butterApp.controller.guest.SignUpController.java

Source

package com.miserablemind.butter.apps.butterApp.controller.guest;

import com.miserablemind.butter.apps.butterApp.ConfigButterApp;
import com.miserablemind.butter.apps.butterApp.forms.SignUpForm;
import com.miserablemind.butter.domain.model.user.user.AppUser;
import com.miserablemind.butter.domain.model.user.user.UserManager;
import com.miserablemind.butter.domain.model.user.user.UserTakenException;
import com.miserablemind.butter.domain.model.user.user_activity.UserActivityManager;
import com.miserablemind.butter.domain.service.email.EmailManager;
import com.miserablemind.butter.helpers.Utilities;
import com.miserablemind.butter.resolvers.user.ActiveUser;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.util.Date;

/*
 * Miserable Mind
 * http://www.butter.miserablemind.com
 * The MIT License (MIT)
 */

/**
 * Sign Up Controller that handles user sign up page and sign up form submit.
 *
 * @author <a href="http://www.miserablemind.com" target="_blank">miserablemind</a>
 */
@Controller
@RequestMapping("/signup")
public class SignUpController {

    private static final Logger logger = Logger.getLogger(SignUpController.class);

    private static final String REDIRECTED_FROM_POST = "redirectedFromPost";

    @Autowired
    private UserManager userManager;

    @Autowired
    private UserActivityManager activityManager;

    @Autowired
    private EmailManager emailManager;

    @Autowired
    private ConfigButterApp appConfig;

    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    /**
     * Renders a page with sign up form.
     *
     * @param user  active session user
     * @param model model used for passing SignUpForm object to view
     * @return logical view name if user is logged out, otherwise a redirect to home page
     */
    @RequestMapping(method = RequestMethod.GET)
    public String handleGet(@ActiveUser AppUser user, ModelMap model) {

        if (null != user)
            return "redirect:" + "/";

        model.addAttribute("signUpForm", new SignUpForm());
        return "guest/signup";

    }

    /**
     * Handles POST data after user submits sign up form.
     *
     * @param signUpForm   the data of the form user submitted signing up
     * @param result       result of the binding data to SignUpForm
     * @param request      HTTP request to get the user session for manual log in in case of sign up success
     * @param redirectData autowired RedirectAttributes object to pass flash attributes to, so the method after redirect knows it was not accessed directly.
     * @return in case of failure logical name of the same view, otherwise redirect to a thank you page
     */
    @RequestMapping(method = RequestMethod.POST)
    public String handlePost(@ModelAttribute("signUpForm") @Valid SignUpForm signUpForm, BindingResult result,
            HttpServletRequest request, RedirectAttributes redirectData) {

        if (result.hasErrors())
            return "guest/signup";

        try {
            String encodedPassword = this.passwordEncoder.encode(signUpForm.getPassword());
            AppUser userForRegistration = new AppUser(null, encodedPassword, signUpForm.getEmail(), false,
                    signUpForm.getUsername(), true, new Date(), new Date());

            String verificationToken = Utilities.generateUUID();
            this.userManager.registerUser(userForRegistration, verificationToken);

            AppUser appUser = this.manuallyLogUserIn(signUpForm, request);
            this.emailManager.sendEmailVerification(appUser, verificationToken, this.appConfig);

            redirectData.addFlashAttribute(REDIRECTED_FROM_POST, true);

            return "redirect:" + "/signup/thank-you";
        } catch (UserTakenException e) {
            if (e.isUsernameTaken())
                result.rejectValue("username", "UsernameExists");
            if (e.isEmailTaken())
                result.rejectValue("email", "EmailExists");
        }

        return "guest/signup";
    }

    /**
     * Sign Up Thank You age after successful sign up.
     *
     * @param model used to check if page is not being accessed directly (flash attribute is populated)
     * @return logical view of a template for the page, or redirect to home page if page is being tried to access directly
     */
    @RequestMapping("/thank-you")
    public String handleThankYouPage(ModelMap model) {

        if (null != model.get(REDIRECTED_FROM_POST))
            return "redirect:" + "/";

        return "user/signup-thank-you";
    }

    /**
     * Logs User In from SignUpForm data.
     * <p>Used after successful sign up, so the user can explore the app right away.</p>
     *
     * @param signUpForm data of the form user submitted signing up
     * @param request    request to get visitors active session
     * @return {@link AppUser} if success, otherwise {@code null}
     */
    private AppUser manuallyLogUserIn(SignUpForm signUpForm, HttpServletRequest request) {

        AppUser appUser = this.userManager.loadUserByUsername(signUpForm.getUsername());

        if (appUser == null) {
            logger.warn("Could Not manually log in New User After Sign Up " + signUpForm.getUsername());
            return null;
        }

        this.activityManager.userSignedUp(appUser.getId());
        Authentication authentication = new UsernamePasswordAuthenticationToken(appUser, signUpForm.getPassword(),
                appUser.getAuthorities());
        SecurityContextHolder.getContext().setAuthentication(authentication);
        request.getSession().setAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY,
                SecurityContextHolder.getContext());
        return appUser;

    }

}