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.RequestBody;

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.Location;

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.entity.fofo.FofoStore;

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

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

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

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 FofoStoreRepository fofoStoreRepository;

	@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";

		}

	}

	@RequestMapping(value = "/partner/location", method = RequestMethod.PUT)

	public String setLocation(HttpServletRequest request, Model model, @RequestBody Location location)

			throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		boolean response = true;

		FofoStore fs = fofoStoreRepository.selectByRetailerId(loginDetails.getFofoId());

		if (fs.getLatitude() == null) {

			fs.setLatitude(location.getLatitude());

			fs.setLongitude(location.getLongitude());

			fofoStoreRepository.persist(fs);

		}

		model.addAttribute("response", response);

		return "response";

	}

}