Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import javax.servlet.http.Cookie;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

import org.springframework.ui.ModelMap;

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.bind.annotation.RequestParam;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.dao.entity.dtr.Retailer;

import com.spice.profitmandi.dao.entity.dtr.User;

import com.spice.profitmandi.dao.entity.dtr.UserAccount;

import com.spice.profitmandi.dao.entity.dtr.UserRole;

import com.spice.profitmandi.dao.enumuration.dtr.AccountType;

import com.spice.profitmandi.dao.enumuration.dtr.RoleType;

import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;

import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;

import com.spice.profitmandi.dao.repository.dtr.UserRepository;

import com.spice.profitmandi.dao.repository.dtr.UserRoleRepository;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.GoogleTokenUtil;

import com.spice.profitmandi.web.util.MVCResponseSender;

import com.spice.profitmandi.web.util.Utils;

@Controller

@Transactional

public class LoginController {

	private static final Logger LOGGER = LoggerFactory.getLogger(LoginController.class);

	@Autowired

	private GoogleTokenUtil googleTokenUtil;

	@Autowired

	private RetailerRepository retailerRepository;

	@Autowired

	private UserRepository userRepository;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Autowired

	private UserRoleRepository userRoleRepository;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Value("${google.api.key}")

	private String googleApiKey;

	@RequestMapping(value = "/login", method = RequestMethod.GET)

	public String loginPage(HttpServletRequest request, Model model) throws Exception{

		LOGGER.info("Context Path is {}", request.getContextPath());

		try{

			LoginDetails details = cookiesProcessor.getCookiesObject(request);

			LOGGER.info("Request session is already exist, should be redirect to as per roles assigned");

			return "redirect:" + Utils.getRedictUrlFromLogin(details);

		}catch(ProfitMandiBusinessException profitMandiBusinessException){

			model.addAttribute("googleApiKey", googleApiKey);

			model.addAttribute("appContextPath", request.getContextPath());

			return "login";

		}

	}

	@RequestMapping(value = "/", method = RequestMethod.GET)

	public String home(){

		return "redirect:/login";

	}

	@RequestMapping(value = "/login", method = RequestMethod.POST)

	public String login(HttpServletRequest request, HttpServletResponse response, @RequestParam(name = ProfitMandiConstants.TOKEN) String token, Model model) throws Exception{

		LoginDetails fofoDetails = new LoginDetails();

		Set<RoleType> roleTypes = new HashSet<>();

		fofoDetails.setRoleTypes(roleTypes);

		//fofoDetails.setFofo(false);

		try{

			//if role is retailer then FOFO_ID is retailerId else it is userid as normal user's wont have retailer id. 

			String emailId = googleTokenUtil.getEmailId(token);

			fofoDetails.setEmailId(emailId);

			fofoDetails.setFofoId(-1);

			//fofoDetails.setFofo(false);

			User user = null;

			try{

				user = userRepository.selectByEmailId(emailId);

			}catch(ProfitMandiBusinessException profitMandiBusinessException){

				LOGGER.error("User not found with given emailId", profitMandiBusinessException);

			}

			if(user == null){

				try{

					user = userRepository.selectBySecondryEmailId(emailId);

				}catch(ProfitMandiBusinessException profitMandiBusinessException){

					LOGGER.error("User not found with given emailId", profitMandiBusinessException);

				}

			}

			if(user != null){

				fofoDetails.setFofoId(user.getId());

				try {

					List<UserRole> userRoles = userRoleRepository.selectByUserId(user.getId());

					for(int index = 0; index < userRoles.size(); index++){

						roleTypes.add(userRoles.get(index).getRoleType());

					}

					if(roleTypes.contains(RoleType.RETAILER)) {

						UserAccount userAccounts = userAccountRepository.selectByUserIdType(user.getId(), AccountType.saholic);

						Retailer retailer = retailerRepository.selectById(userAccounts.getAccountKey());

						fofoDetails.setFofoId(retailer.getId());

						//fofoDetails.setFofo(retailer.isFofo());

					}

				} catch(ProfitMandiBusinessException pmbe) {

					LOGGER.error("Data Inconsistent", pmbe);

				}

			}

			String redirectUrl = Utils.getRedictUrlFromLogin(fofoDetails);

			if(!redirectUrl.equals("/login")){

				this.addCookiesToResponse(fofoDetails, request, response);

				LOGGER.info("Requested token email_id is valid, user login to system, shoud be redirect to {}", redirectUrl);

				model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_OK_1002", true, request.getContextPath() + redirectUrl));

			}else{

				LOGGER.error("Requested token email_id is not valid, please try to login");

				throw new ProfitMandiBusinessException(ProfitMandiConstants.EMAIL_ID, fofoDetails.getEmailId(), "RTLR_1000");

			}

			return "response";

		} catch(ProfitMandiBusinessException profitMandiBusinessException){

			LOGGER.error("Error : ", profitMandiBusinessException);

			model.addAttribute("loginResponse", mvcResponseSender.createResponseString(profitMandiBusinessException.getCode(), false, "/error"));

			return "response";

		}

	}

	private void addCookiesToResponse(LoginDetails fofoDetails, HttpServletRequest request, HttpServletResponse response) {

		List<String> roleNames = new ArrayList<>();

		for(RoleType roleType : fofoDetails.getRoleTypes()) {

			roleNames.add(roleType.toString());

		}

		Cookie cookieRoleNames = new Cookie(ProfitMandiConstants.ROLE_NAMES, String.join(",", roleNames));

		cookieRoleNames.setDomain(request.getServerName());

		cookieRoleNames.setPath(request.getContextPath());

		Cookie cookieFofoId = new Cookie(ProfitMandiConstants.FOFO_ID, String.valueOf(fofoDetails.getFofoId()));

		cookieFofoId.setDomain(request.getServerName());

		cookieFofoId.setPath(request.getContextPath());

		Cookie cookieEmailId = new Cookie(ProfitMandiConstants.EMAIL_ID, fofoDetails.getEmailId());

		cookieEmailId.setDomain(request.getServerName());

		cookieEmailId.setPath(request.getContextPath());

		response.addCookie(cookieFofoId);

		response.addCookie(cookieEmailId);

		response.addCookie(cookieRoleNames);

	}

	@RequestMapping(value = "/logout", method = RequestMethod.GET)

	public String logout(HttpServletRequest request, @ModelAttribute("model") ModelMap model, HttpServletResponse response) throws Exception{

		try{

			cookiesProcessor.removeCookies(request, response);

			LOGGER.info("Logout is successfull, should be redirect to /login");

			return "redirect:/login";

		}catch(ProfitMandiBusinessException profitMandiBusinessException){

			LOGGER.info("Error occured while removing requested cookies, should be redirect to /login");

			return "redirect:/login";

		}

	}

}