Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.google.gson.Gson;

import com.google.gson.reflect.TypeToken;

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.common.model.ProfitMandiResponse;

import com.spice.profitmandi.common.web.client.RestClient;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

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

import com.spice.profitmandi.dao.entity.fofo.FofoStore;

import com.spice.profitmandi.dao.entity.user.Device;

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

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

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.catalog.DeviceRepository;

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

import com.spice.profitmandi.service.AuthService;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.user.RetailerService;

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 org.apache.http.NameValuePair;

import org.apache.http.client.utils.URLEncodedUtils;

import org.apache.http.message.BasicNameValuePair;

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.ui.Model;

import org.springframework.ui.ModelMap;

import org.springframework.web.bind.annotation.*;

import javax.servlet.http.Cookie;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.transaction.Transactional;

import java.lang.reflect.Type;

import java.time.LocalDateTime;

import java.util.*;

import java.util.stream.Collectors;

@Controller

@Transactional

public class LoginController {

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

	@Autowired

	private GoogleTokenUtil googleTokenUtil;

	@Autowired

	private RoleManager roleManager;

	@Autowired

	private DeviceRepository deviceRepository;

	@Autowired

	private RetailerRepository retailerRepository;

	@Autowired

	private RetailerService retailerService;

	@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 RestClient restClient;

	@Autowired

	private CookiesProcessor cookiesProcessor;

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

	private String googleApiKey;

	@Value("${app.token.url}")

	private String appTokenUrl;

	@Value("${angular.app.url}")

	private String appUrl;

	@Value("${admin.token}")

	private String adminToken;

	@Autowired

	private AuthService authService;

	@Autowired

	private AuthRepository authRepository;

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

	public String loginPage(HttpServletRequest request, HttpServletResponse response, 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.FOFO.toString());

			Role roleFofoAdmin = roleRepository.selectByName(RoleType.FOFO_ADMIN.toString());

			if (fofoDetails.getRoleIds().contains(roleFofoAdmin.getId())) {

				redirectUrl = "/dashboard";

			} else if (fofoDetails.getRoleIds().contains(roleRetailer.getId())

					&& fofoDetails.getRoleIds().contains(roleFofo.getId())) {

				FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoDetails.getFofoId());

				if (!fofoStore.isActive()) {

					cookiesProcessor.removeCookies(request, response);

					throw new ProfitMandiBusinessException("", "", "");

				}

				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 = "/mobileapp", method = RequestMethod.GET)

	public String mobileApp(HttpServletRequest request, Model model, @RequestParam(defaultValue = "") String emailId)

			throws Exception {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {

			if (emailId.equals("")) {

				AuthUser authUser = authRepository.selectByEmailOrMobile(fofoDetails.getEmailId());

				model.addAttribute("authToken", getToken(authUser.getGmailId()));

			} else {

				model.addAttribute("authToken", getToken(emailId));

				model.addAttribute("androidId", getAndroidId(emailId));

			}

		} else {

			emailId = fofoDetails.getEmailId();

			model.addAttribute("authToken", getToken(emailId));

			model.addAttribute("androidId", getAndroidId(emailId));

		}

		model.addAttribute("appUrl", appUrl);

		return "mobileapp";

	}

	private String getAndroidId(String emailId) throws Exception {

		User user = userRepository.selectByEmailId(emailId);

		List<Device> devices = deviceRepository.selectByUserIdAndModifiedTimestamp(Arrays.asList(user.getId()),

				LocalDateTime.now().minusYears(2), LocalDateTime.now());

		if (devices.size() > 0) {

			Device device = devices.get(0);

			return device.getAndroidId();

		} else {

			return "";

		}

	}

	private String getToken(String emailId) throws Exception {

		List<NameValuePair> nameValuePairs = new ArrayList<>();

		nameValuePairs.add(new BasicNameValuePair("adminToken", this.adminToken));

		nameValuePairs.add(new BasicNameValuePair("emailId", emailId));

		String queryString = URLEncodedUtils.format(nameValuePairs, "UTF-8");

		String response = restClient.post(this.appTokenUrl + queryString,

				new HashMap<>(), new HashMap<>());

		Type t = new TypeToken<ProfitMandiResponse<Map<String, Object>>>() {

		}.getType();

		ProfitMandiResponse<Map<String, Object>> apiResponse = new Gson().fromJson(response, t);

		if (apiResponse.getStatusCode().equals("200")) {

			return (new StringBuilder((String) apiResponse.getResponse().get("token")).reverse().toString());

		} else {

			throw new Exception("Unauthorised access");

		}

	}

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

	public String adminLogin(HttpServletRequest request, Model model, HttpServletResponse response,

			@RequestParam int fofoId) throws Exception {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {

			int userId = userAccountRepository.selectUserIdByRetailerId(fofoId);

			User user = userRepository.selectById(userId);

			Set<Integer> roleIds = userRoleRepository.selectByUserId(userId).stream().map(x -> x.getRoleId())

					.collect(Collectors.toSet());

			LoginDetails newFofoDetails = new LoginDetails();

			newFofoDetails.setFofoId(fofoId);

			newFofoDetails.setRoleIds(roleIds);

			newFofoDetails.setEmailId(user.getEmailId());

			model.addAttribute("response1", true);

			this.addCookiesToResponse(newFofoDetails, request, response);

		} else {

			throw new ProfitMandiBusinessException("", "", "");

		}

		return "response";

	}

	@RequestMapping(value = "/login-as-partner-readonly", method = RequestMethod.GET)

	public String readonlyLogin(HttpServletRequest request, Model model, HttpServletResponse response,

			@RequestParam int fofoId) throws Exception {

		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

		if (roleManager.isAdmin(fofoDetails.getRoleIds())) {

			int userId = userAccountRepository.selectUserIdByRetailerId(fofoId);

			User user = userRepository.selectById(userId);

			Set<Integer> roleIds = userRoleRepository.selectByUserId(userId).stream().map(x -> x.getRoleId())

					.collect(Collectors.toSet());

			LoginDetails newFofoDetails = new LoginDetails();

			newFofoDetails.setFofoId(fofoId);

			newFofoDetails.setRoleIds(roleIds);

			newFofoDetails.setEmailId(user.getEmailId());

			newFofoDetails.setReadOnly(true);

			model.addAttribute("response1", true);

			this.addCookiesToResponse(newFofoDetails, request, response);

		} else {

			throw new ProfitMandiBusinessException("", "", "");

		}

		return "response";

	}

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

	public String login(HttpServletRequest request, HttpServletResponse response,

			@RequestParam(name = ProfitMandiConstants.TOKEN) String token,

			@RequestParam(name = ProfitMandiConstants.EMAIL_ID_OR_MOBILE_NUMBER, defaultValue = "") String emailIdOrMobileNumber,

			@RequestParam(name = "password", defaultValue = "") String password, Model model) throws Exception {

		LoginDetails fofoDetails = new LoginDetails();

		Set<Integer> roleIds = new HashSet<>();

		fofoDetails.setRoleIds(roleIds);

		String emailId = null;

		String name = null;

		try {

			// if role is retailer then FOFO_ID is retailerId else it is userid as normal

			// user's wont have retailer id.

			if (token == "") {

				if (authService.authenticate(emailIdOrMobileNumber, password)) {

					AuthUser authUser = authRepository.selectByEmailOrMobile(emailIdOrMobileNumber);

					if (authUser == null) {

						throw new ProfitMandiBusinessException("Authentication", "Email or Mobile",

								"Invalid Email Or Mobile");

					}

					emailId = authUser.getEmailId();

					name = authUser.getFirstName() + " " + authUser.getLastName();

					authUser.setLastLoginTimestamp(LocalDateTime.now());

					authRepository.persist(authUser);

				}

			} else {

				try {

					emailId = googleTokenUtil.getEmailId(token);

				} catch (Exception e) {

					// in case we cannot connect to google server.

					emailId = emailIdOrMobileNumber;

				}

			}

			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);

					model.addAttribute("response1", mvcResponseSender.createResponseString("RTLR_OK_1002", true,

							request.getContextPath() + "/login", "Email"));

					return "response";

				}

			}

			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 roleFofo = roleRepository.selectByName(RoleType.FOFO.toString());

			Role roleFofoAdmin = roleRepository.selectByName(RoleType.FOFO_ADMIN.toString());

			if (fofoDetails.getRoleIds().contains(roleFofo.getId())) {

				redirectUrl = "/dashboard";

				if (fofoDetails.getRoleIds().contains(roleFofo.getId())) {

				}

			} else {

				redirectUrl = "/login";

			}

			if (redirectUrl.equals("/dashboard")) {

				user.setLoginTimestamp(LocalDateTime.now());

				this.addCookiesToResponse(fofoDetails, request, response);

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

						redirectUrl);

				model.addAttribute("response1", mvcResponseSender.createResponseString("RTLR_OK_1002", true,

						request.getContextPath() + redirectUrl, name));

			} else {

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

				/**

				 * TODO:Amit This redirect should be handle.

				 */

				throw new ProfitMandiBusinessException(ProfitMandiConstants.EMAIL_ID, fofoDetails.getEmailId(),

						"RTLR_1000");

			}

			return "response";

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

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

			model.addAttribute("response1",

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

			return "response";

		} catch (Exception e) {

			e.printStackTrace();

			model.addAttribute("response1",

					mvcResponseSender.createResponseString(

							"You are not authorised! " + "Please contact the team if you feel this is incorrect", false,

							"/error"));

			return "response";

		}

	}

	@PostMapping(value = "/forgetPassword")

	public String forgetPasswordPage(

			@RequestParam(name = ProfitMandiConstants.EMAIL_ID, defaultValue = "") String emailId, Model model)

			throws Exception {

		LOGGER.info(emailId);

		authService.resetPassword(emailId);

		model.addAttribute("response1", mvcResponseSender.createResponseString(true));

		LOGGER.info("completed");

		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());

		Cookie cookieReadOnly = new Cookie(ProfitMandiConstants.READONLY_KEY, fofoDetails.isReadOnly() + "");

		cookieReadOnly.setDomain(request.getServerName());

		cookieReadOnly.setPath(request.getContextPath());

		response.addCookie(cookieFofoId);

		response.addCookie(cookieEmailId);

		response.addCookie(cookieRoleIds);

		response.addCookie(cookieReadOnly);

	}

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

		try {

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

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

				fs.setLatitude(location.getLatitude());

				fs.setLongitude(location.getLongitude());

			}

			model.addAttribute("response1", response);

		} catch (Exception e) {

			LOGGER.error("FofoStore Code not found of fofoId {}", loginDetails.getFofoId());

		}

		return "response";

	}

}