Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;
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.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
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.Role;
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.RoleRepository;
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;

@Controller
@Transactional
public class LoginController {

        private static final Logger LOGGER = LogManager.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 RoleRepository roleRepository;
        
        @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 fofoDetails = cookiesProcessor.getCookiesObject(request);
                        LOGGER.info("Request session is already exist, should be redirect to as per roles assigned");
                        String redirectUrl = null;
                        
                        Role roleRetailer = roleRepository.selectByName(RoleType.RETAILER.toString());
                        Role roleFofo = roleRepository.selectByName(RoleType.RETAILER.toString());
                        Role roleFofoAdmin = roleRepository.selectByName(RoleType.RETAILER.toString());
                        
                        if ((fofoDetails.getRoleIds().contains(roleRetailer.getId()) && fofoDetails.getRoleIds().contains(roleFofo.getId()) || (fofoDetails.getRoleIds().contains(roleFofoAdmin.getId())))) {
                                redirectUrl = "/dashboard";
                        } else {
                                redirectUrl = "/login";
                        }
                        return "redirect:" + redirectUrl;
                }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<Integer> roleIds = new HashSet<>();
                fofoDetails.setRoleIds(roleIds);
                //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 [{}]", emailId);
                        }
                        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++){
                                                roleIds.add(userRoles.get(index).getRoleId());
                                        }
                                        List<Role> roles = roleRepository.selectByIds(roleIds);
                                        for(Role role : roles) {
                                                if(role.getName().equals(RoleType.RETAILER.toString())) {
                                                        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 = null;
                        
                        Role roleRetailer = roleRepository.selectByName(RoleType.RETAILER.toString());
                        Role roleFofo = roleRepository.selectByName(RoleType.RETAILER.toString());
                        Role roleFofoAdmin = roleRepository.selectByName(RoleType.RETAILER.toString());
                        
                        if ((fofoDetails.getRoleIds().contains(roleRetailer.getId()) && fofoDetails.getRoleIds().contains(roleFofo.getId()) || (fofoDetails.getRoleIds().contains(roleFofoAdmin.getId())))) {
                                redirectUrl = "/dashboard";
                        } else {
                                redirectUrl = "/login";
                        }
                        
                        if(!redirectUrl.equals("/login")){
                                user.setLoginTimestamp(LocalDateTime.now());
                                userRepository.persist(user);
                                this.addCookiesToResponse(fofoDetails, request, response);
                                LOGGER.info("Requested token email_id is valid, user login to system, shoud be redirect to {}", redirectUrl);
                                model.addAttribute("response", 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("response", mvcResponseSender.createResponseString(profitMandiBusinessException.getCode(), false, "/error"));
                        return "response";
                }
        }
        
        private void addCookiesToResponse(LoginDetails fofoDetails, HttpServletRequest request, HttpServletResponse response) {
                List<String> roleIds = new ArrayList<>();
                
                for(int roleId : fofoDetails.getRoleIds()) {
                        roleIds.add(String.valueOf(roleId));
                }
                Cookie cookieRoleIds = new Cookie(ProfitMandiConstants.ROLE_IDS, String.join(",", roleIds));
                cookieRoleIds.setDomain(request.getServerName());
                cookieRoleIds.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(cookieRoleIds);
        }
        
        @RequestMapping(value = "/logout", method = RequestMethod.GET)
        public String logout(HttpServletRequest request, @ModelAttribute("model") ModelMap model, HttpServletResponse response) throws Exception{
                try{
                        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                        User user = null;
                        try{
                                user = userRepository.selectByEmailId(loginDetails.getEmailId());
                        }catch(ProfitMandiBusinessException profitMandiBusinessException){
                                LOGGER.error("User not found with given emailId", profitMandiBusinessException);
                        }
                        if(user == null){
                                user = userRepository.selectBySecondryEmailId(loginDetails.getEmailId());
                        }
                        user.setLogoutTimestamp(LocalDateTime.now());
                        userRepository.persist(user);
                        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";
                }
        }
        
}