Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.fasterxml.jackson.annotation.JsonProperty;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.spice.profitmandi.common.ResponseCodeHolder;

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

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

import com.spice.profitmandi.common.util.JWTUtil;

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

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

import com.spice.profitmandi.common.web.util.ResponseSender;

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.fofo.PartnerOnBoardingPanel;

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

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

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

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

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

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

import com.spice.profitmandi.dao.enumuration.transaction.PartnerOnBoardingStatus;

import com.spice.profitmandi.dao.model.CreateRefferalRequest;

import com.spice.profitmandi.dao.model.DateRangeModel;

import com.spice.profitmandi.dao.model.UserCart;

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

import com.spice.profitmandi.dao.repository.cs.CsService;

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

import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeService;

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.dao.repository.user.PromoterRepository;

import com.spice.profitmandi.service.AuthService;

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

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

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

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

import com.spice.profitmandi.web.controller.checkout.OrderController;

import com.spice.profitmandi.web.enumuration.UserStatus;

import com.spice.profitmandi.web.processor.GoogleLoginProcessor;

import com.spice.profitmandi.web.req.RefferalEarning;

import com.spice.profitmandi.web.req.RefferalEarningModel;

import com.spice.profitmandi.web.req.UserRequest;

import com.spice.profitmandi.web.res.Partner;

import io.swagger.annotations.ApiImplicitParam;

import io.swagger.annotations.ApiImplicitParams;

import org.apache.http.client.ClientProtocolException;

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.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.mail.javamail.MimeMessageHelper;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

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

import javax.mail.MessagingException;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeMessage;

import javax.servlet.http.HttpServletRequest;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.YearMonth;

import java.time.ZoneOffset;

import java.util.*;

import java.util.stream.Collectors;

/**

 * @author ashikali

 */

@Controller

@Transactional(rollbackFor = Throwable.class)

public class UserController {

	@Autowired

	private ResponseSender<?> responseSender;

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

	@Value("${notifications.api.host}")

	private String nodeHost;

	@Autowired

	private MobileAppSettingsRepository mobileAppSettingsRepository;

	@Value("${notifications.api.port}")

	private int nodePort;

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

	private String validAdminToken;

	@Autowired

	private UserRepository userRepository;

	@Autowired

	private com.spice.profitmandi.dao.repository.user.UserRepository userUserRepository;

	@Autowired

	private RetailerRepository retailerRepository;

	@Autowired

	private UserRoleRepository userRoleRepository;

	@Autowired

	private PartnerTypeChangeService partnerTypeChangeService;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Autowired

	private AuthService authService;

	@Autowired

	private AddressRepository addressRepository;

	@Autowired

	private GoogleLoginProcessor googleLoginProcessor;

	@Autowired

	private UserService userService;

	@Autowired

	private CsService csService;

	@Autowired

	private RestClient restClient;

	@Autowired

	private RoleManager roleManager;

	@Autowired

	private RoleRepository roleRepository;

	@Autowired

	private AuthRepository authRepository;

	@Autowired

	private ObjectMapper objectMapper;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private RefferalRepository refferalRepository;

	@Autowired

	private PromoterRepository promoterRepository;

	@Autowired

	JavaMailSender mailSender;

	@RequestMapping(value = ProfitMandiConstants.URL_USER_GOOGLE_LOGIN, method = RequestMethod.POST)

	public ResponseEntity<?> googleLogin(HttpServletRequest request, @RequestBody GoogleLoginRequest googleLoginRequest)

			throws Exception {

		String email = googleLoginProcessor.process(googleLoginRequest.getToken());

		return responseSender.ok(getAuthTokenMap(email));

	}

	private Map<String, Object> getAuthTokenMap(String email) throws Exception {

		String name = authService.getNameByEmailId(email);

		Map<String, Object> responseMap = new HashMap<>(2);

		LOGGER.info("User Name from getNameByEmailId({}) is {}", email, name);

		if (name != null) {

			User registeredUser = null;

			AuthUser authUser = authRepository.selectByGmailId(email);

			if (authRepository.selectByGmailId(email) != null) {

				registeredUser = userRepository.selectByEmailId(authUser.getEmailId());

			} else if (promoterRepository.isExistByEmailId(email)) {

				Promoter promoter = promoterRepository.selectByEmailId(email);

				int userId = userAccountRepository.selectUserIdByRetailerId(promoter.getRetailerId());

				registeredUser = userRepository.selectById(userId);

			} else if (userRepository.isExistBySecondryEmailId(email)) {

				registeredUser = userRepository.selectBySecondryEmailId(email);

			}

			LOGGER.info("4");

			List<Integer> roleIds = userRoleRepository.selectRoleIdsByUserId(registeredUser.getId());

			String[] roleTypes = new String[roleIds.size()];

			int index = 0;

			for (int roleId : roleIds) {

				roleTypes[index++] = String.valueOf(roleId);

			}

			int retailerId;

			try {

				retailerId = userAccountRepository.selectRetailerIdByUserId(registeredUser.getId());

			} catch (Exception e) {

				Set<Integer> authUserPartnerSet = csService.getAuthUserPartnerIdMapping().get(authUser.getEmailId());

				if (authUserPartnerSet != null && authUserPartnerSet.size() > 0) {

					retailerId = authUserPartnerSet.stream().findFirst().get();

					FofoStore fs = fofoStoreRepository.selectByRetailerId(retailerId);

					retailerId = ProfitMandiConstants.WAREHOUSE_NSSPL_PARTNER_MAP.get(fs.getWarehouseId());

				} else {

					com.spice.profitmandi.dao.entity.user.User user = userUserRepository.selectByEmailId(Utils.SYSTEM_PARTNER);

					retailerId = user.getId();

				}

			}

			responseMap.put(ProfitMandiConstants.TOKEN,

					JWTUtil.create(email, registeredUser.getId(), retailerId, roleTypes));

			LOGGER.info(

					"Param value for email, registeredUser.getId(), retailerId, roleTypes are {}, {}, {} and {}",

					email, registeredUser.getId(), retailerId, Arrays.asList(roleTypes));

			responseMap.put(ProfitMandiConstants.REGISTERED, true);

			return responseMap;

		}

		User user = null;

		try {

			user = userRepository.selectByEmailId(email);

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

		}

		if (user == null) {

			try {

				user = userRepository.selectByEmailId(email);

			} catch (ProfitMandiBusinessException profitMandiBusinessException) {

				responseMap.put(ProfitMandiConstants.TOKEN, JWTUtil.create(email));

				responseMap.put(ProfitMandiConstants.REGISTERED, false);

			}

		} else {

			List<Integer> roleIds = userRoleRepository.selectRoleIdsByUserId(user.getId());

			int retailerId = userAccountRepository.selectRetailerIdByUserId(user.getId());

			String[] roleTypes = new String[roleIds.size()];

			int index = 0;

			for (int roleId : roleIds) {

				roleTypes[index++] = String.valueOf(roleId);

			}

			responseMap.put(ProfitMandiConstants.TOKEN, JWTUtil.create(user.getId(), retailerId, roleTypes));

			responseMap.put(ProfitMandiConstants.REGISTERED, true);

		}

		return responseMap;

	}

	@RequestMapping(value = "/store/token/{storeCode}", method = RequestMethod.GET)

	public ResponseEntity<?> googleLogin(HttpServletRequest request, @PathVariable String storeCode)

			throws ProfitMandiBusinessException {

		LOGGER.info("StoreCode {}", storeCode);

		return responseSender.ok(googleLoginProcessor.processStore(storeCode));

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_TOKEN_IS_EXPIRED, method = RequestMethod.GET)

	public ResponseEntity<?> tokenIsExpired(HttpServletRequest request, @RequestParam(name = "token") String token)

			throws ProfitMandiBusinessException {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		return responseSender.ok(JWTUtil.isExpired(token));

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_DETAIL_BY_TOKEN, method = RequestMethod.GET)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	public ResponseEntity<?> tokenInfo(HttpServletRequest request) throws Throwable {

		Map<String, Object> responseMap = new HashMap<>();

		UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

		User user = null;

		if (userInfo.getUserId() > -1) {

			user = userRepository.selectById(userInfo.getUserId());

			String city = user.getCity();

			if (!(userInfo.getEmail() == null || user.getEmailId().equalsIgnoreCase(userInfo.getEmail()))) {

				String userName = null;

				if (user.getSecondryEmailId() != null && user.getSecondryEmailId().equals(userInfo.getEmail())) {

					userName = user.getFirstName() + " " + user.getLastName();

				} else {

					AuthUser authUser = authRepository.selectByGmailId(userInfo.getEmail());

					if (authUser == null || !authUser.isActive()) {

						responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.NOT_REGISTERED.getValue());

						responseMap.put(ProfitMandiConstants.EMAIL_ID, userInfo.getEmail());

						return responseSender.ok(responseMap);

					}

					userName = authUser.getName();

				}

				responseMap.put(ProfitMandiConstants.USER_ID, userInfo.getUserId());

				responseMap.put(ProfitMandiConstants.USER_NAME, userName);

				responseMap.put(ProfitMandiConstants.USER_STATUS, "fofoAssociate");

				responseMap.put(ProfitMandiConstants.EMAIL_ID, userInfo.getEmail());

				responseMap.put("storeUrl", "");

				return responseSender.ok(responseMap);

			}

		} else {

			try {

				user = userRepository.selectByEmailId(userInfo.getEmail());

			} catch (ProfitMandiBusinessException e1) {

			}

			if (user == null) {

				try {

					user = userRepository.selectBySecondryEmailId(userInfo.getEmail());

				} catch (ProfitMandiBusinessException e1) {

					LOGGER.info("Uneregistered user", userInfo.getEmail());

				}

			}

		}

		if (user != null) {

			int retailerId = userAccountRepository.selectRetailerIdByUserId(user.getId());

			responseMap.put(ProfitMandiConstants.EMAIL_ID, user.getEmailId());

			responseMap.put(ProfitMandiConstants.USER_ID, user.getId());

			responseMap.put(ProfitMandiConstants.USER_NAME, user.getFirstName() + " " + user.getLastName());

			List<Integer> roleIds = userRoleRepository.selectRoleIdsByUserId(user.getId());

			// LOGGER.info("userRoles {} ", userRoles);

			// generate new token if roles have been updated

			if (userInfo.getRoleIds() == null || roleIds.size() != userInfo.getRoleIds().size()) {

				String[] roleIdStrings = new String[roleIds.size()];

				int index = 0;

				for (int roleId : roleIds) {

					roleIdStrings[index++] = String.valueOf(roleId);

				}

				String newToken = JWTUtil.create(user.getId(), retailerId, roleIdStrings);

				responseMap.put("newAuthToken", newToken);

			}

			// if user is retailer

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

			if (roleManager.isRetailer(roleIdsSet)) {

				UserCart uc = userAccountRepository.getUserCart(userInfo.getUserId());

				Retailer retailer = retailerRepository.selectById(uc.getUserId());

				com.spice.profitmandi.dao.entity.user.User saholicUser = userUserRepository.selectById(uc.getUserId());

				if (saholicUser.getAddressId() != null) {

					Address address = addressRepository.selectById(saholicUser.getAddressId());

					responseMap.put(ProfitMandiConstants.ADDRESS, address);

				}

				// if retailer is activated 1 then verified retailer

				// else if migrated is 1 then old retailer

				// also lets incoporte old process i.e is user is activated then also retailer

				// is verified retailer

				// else retailer is not verifed

				if (retailer.isActive() || user.isActivated()) {

					if (roleManager.isPartner(roleIdsSet)) {

						responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.FOFO.getValue());

						responseMap.put("storeUrl", retailerService.getAllFofoRetailerIdUrlMap().get(uc.getUserId()));

						responseMap.put("timelineStatus", this.getTimeLineStatus(uc.getUserId()));

					} else {

						responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.VERIFIED_RETAILER.getValue());

					}

				} else if (retailer.isMigrated()) {

					responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.RETAILER.getValue());

				} else {

					responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.NOT_VERIFIED_RETAILER.getValue());

				}

			} else if (roleManager.isUser(roleIdsSet)) {

				responseMap.put("userInfo", getRegisteredUserInfo(user));

				responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.REGISTERED.getValue());

			}

		} else {

			responseMap.put(ProfitMandiConstants.USER_STATUS, UserStatus.NOT_REGISTERED.getValue());

			responseMap.put(ProfitMandiConstants.EMAIL_ID, userInfo.getEmail());

		}

		return responseSender.ok(responseMap);

	}

	@Autowired

	FofoStoreRepository fofoStoreRepository;

	@Autowired

	PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

	@Autowired

	StoreTimelineTatService storeTimelineTatService;

	private boolean getTimeLineStatus(int fofoId) throws ProfitMandiBusinessException {

		FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);

		PartnerOnBoardingPanel partnerOnBoardingPanel = partnerOnBoardingPanelRepository.selectByCode(fs.getCode());

		boolean status = true;

		if (partnerOnBoardingPanel != null) {

			status = storeTimelineTatService.getTimelineCompleted(partnerOnBoardingPanel.getId());

		}

		LOGGER.info("status" + status);

		return status;

	}

	private RegisteredUserInfo getRegisteredUserInfo(User user) throws Throwable {

		RegisteredUserInfo ri = new RegisteredUserInfo();

		ri.setCity(user.getCity());

		ri.setFirstName(user.getFirstName());

		ri.setLastName(user.getLastName());

		ri.setPhone(user.getMobileNumber());

		ri.setPinCode(user.getPinCode());

		ri.setState(user.getState());

		return ri;

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER, method = RequestMethod.POST)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	public ResponseEntity<?> createUser(HttpServletRequest request, @RequestBody UserRequest userRequest)

			throws ProfitMandiBusinessException {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		User user = new User();

		user.setFirstName(userRequest.getFirstName());

		user.setLastName(userRequest.getLastName());

		user.setCity(userRequest.getCity());

		user.setPinCode(Integer.valueOf(userRequest.getPinCode()));

		user.setState(userRequest.getState());

		user.setMobileNumber(userRequest.getMobieNumber());

		user.setEmailId(userRequest.getEmailId());

		user.setUsername("");

		user.setPassword("");

		user.setMobile_verified(false);

		user.setReferral_url("");

		user.setGroup_id(1);

		user.setStatus(1);

		user.setActivated(false);

		user.setCreateTimestamp(LocalDateTime.now());

		user.setUpdateTimestamp(LocalDateTime.now());

		userRepository.persist(user);

		Role role = roleRepository.selectByName(RoleType.USER.toString());

		UserRole userRole = new UserRole();

		userRole.setRoleId(role.getId());

		userRole.setUserId(user.getId());

		userRoleRepository.persist(userRole);

		return responseSender.ok(ResponseCodeHolder.getMessage("USR_OK_1000"));

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_ID, method = RequestMethod.GET)

	public ResponseEntity<?> getById(HttpServletRequest request, @RequestParam(name = "id") int id)

			throws ProfitMandiBusinessException {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		return responseSender.ok(userRepository.selectById(id));

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_MOBILE_NUMBER, method = RequestMethod.GET)

	public ResponseEntity<?> getByMobileNumber(HttpServletRequest request,

											   @RequestParam(name = "mobileNumber") String mobileNumber) throws ProfitMandiBusinessException {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		return responseSender.ok(userRepository.selectByMobileNumber(mobileNumber));

	}

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	@RequestMapping(value = ProfitMandiConstants.URL_USER_ACTIVATE, method = RequestMethod.POST)

	public ResponseEntity<?> activateUser(HttpServletRequest request,

										  @RequestParam(name = "activationCode") String activationCode) throws Throwable {

		int userId = (int) request.getAttribute("userId");

		UserCart uc = userAccountRepository.getUserCart(userId);

		return responseSender.ok(userService.updateActivation(userId, uc.getUserId(), activationCode));

	}

	/*

	 * @ApiImplicitParams({

	 *

	 * @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true,

	 * dataType = "string", paramType = "header") })

	 *

	 * @RequestMapping(value = ProfitMandiConstants.URL_USER_NOTIFICATIONS, method =

	 * RequestMethod.GET) public ResponseEntity<?>

	 * getNofitications(HttpServletRequest request,

	 *

	 * @RequestParam(name = "androidId") String androidId, @RequestParam(name =

	 * "pageNumber") int pageNumber,

	 *

	 * @RequestParam(name = "pageSize") int pageSize) throws

	 * ProfitMandiBusinessException { int userId = (int)

	 * request.getAttribute("userId"); String restResponse = null; Map<String,

	 * String> params = new HashMap<>();

	 *

	 * String uri = "/getAllNotifications"; params.put("user_id", userId + "");

	 * params.put("android_id", androidId); params.put("limit", pageSize + "");

	 * params.put("offset", "" + ((pageNumber - 1) * pageSize)); try { restResponse

	 * = restClient.get(SchemeType.HTTP, nodeHost, nodePort, uri, params); } catch

	 * (HttpHostConnectException e) { throw new ProfitMandiBusinessException("", "",

	 * "Could not Connect to host"); }

	 *

	 * JsonArray result_json = Json.parse(restResponse).asArray();

	 *

	 * List<Notification> notifications = new ArrayList<>();

	 *

	 * for (JsonValue j : result_json) {

	 * notifications.add(toNotifiaction(j.asObject())); }

	 *

	 * return responseSender.ok(notifications); }

	 *

	 * private Notification toNotifiaction(JsonObject jsonObject) { Notification n =

	 * (Notification) (new Gson().fromJson(jsonObject.toString(),

	 * Notification.class)); if (n.getStatus().equals("opened") ||

	 * n.getStatus().equals("referrer") || n.getStatus().equals("seen")) {

	 * n.setSeen(true); } return n; }

	 */

	@RequestMapping(value = ProfitMandiConstants.URL_USER_IS_EXIST_MOBILE_NUMBER, method = RequestMethod.GET)

	public ResponseEntity<?> isMobileNumberExist(HttpServletRequest request,

												 @RequestParam(name = "mobileNumber") String mobileNumber) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		return responseSender.ok(userRepository.isExistByMobileNumber(mobileNumber));

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_EMAIL_ID, method = RequestMethod.GET)

	public ResponseEntity<?> getByEmailId(HttpServletRequest request, @RequestParam(name = "emailId") String emailId)

			throws ProfitMandiBusinessException {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		User user = null;

		try {

			user = userRepository.selectByEmailId(emailId);

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			user = userRepository.selectBySecondryEmailId(emailId);

		}

		return responseSender.ok(user);

	}

	@RequestMapping(value = ProfitMandiConstants.URL_USER_ROLE_ALL, method = RequestMethod.GET)

	public ResponseEntity<?> getAllRoles(HttpServletRequest request, @RequestParam(name = "id") int id) {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		return responseSender.ok(userRoleRepository.selectRolesByUserId(id));

	}

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	@RequestMapping(value = ProfitMandiConstants.URL_USER_SECONDRY_EMAIL_ID_AND_FOFO_STORE_CODE, method = RequestMethod.GET)

	public ResponseEntity<?> getSecondryEmailAndStoreCode(HttpServletRequest request)

			throws ProfitMandiBusinessException {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		int userId = (int) request.getAttribute(ProfitMandiConstants.USER_ID);

		return responseSender.ok(userService.getEmailsAndFofoStoreCodeByUserId(userId));

	}

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "-Token", required = true, dataType = "string", paramType = "header")})

	@RequestMapping(value = ProfitMandiConstants.URL_USER_SECONDRY_EMAIL_ID, method = RequestMethod.PUT)

	public ResponseEntity<?> updateSecondryEmailId(HttpServletRequest request,

												   @RequestParam(name = ProfitMandiConstants.SECONDRY_EMAIL_ID) String secondryEmailId) throws Throwable {

		int userId = (int) request.getAttribute("userId");

		User user = userRepository.selectById(userId);

		user.setSecondryEmailId(secondryEmailId);

		userRepository.persist(user);

		return responseSender.ok(ResponseCodeHolder.getMessage("USR_OK_1001"));

	}

	@RequestMapping(value = ProfitMandiConstants.URL_ADMIN_TOKEN, method = RequestMethod.POST)

	public ResponseEntity<?> getAdminToken(HttpServletRequest request,

										   @RequestParam(name = "adminToken") String adminToken, @RequestParam(name = "emailId") String emailId) throws Exception {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		if (!adminToken.equals(validAdminToken)) {

			return responseSender.forbidden(null);

		}

		return responseSender.ok(this.getAuthTokenMap(emailId));

	}

	@RequestMapping(value = "/mobileappsettings")

	public ResponseEntity<?> mobileAppSettings(HttpServletRequest request, @RequestParam(name = "t") int timestamp,

											   @RequestParam(name = "imeinumber") String imeinumber)

			throws ProfitMandiBusinessException, ClientProtocolException, IOException {

		final String uri = "http://192.168.158.89/mobileappsettings?t=" + timestamp + "&imeinumber=" + imeinumber;

		final String BASIC_AUTH = "Basic " + Base64.getEncoder().encodeToString("dtr:dtr18Feb2015".getBytes());

		Map<String, String> headers = new HashMap<>();

		Map<String, String> params = new HashMap<>();

		headers.put("Authorization", BASIC_AUTH);

		if (timestamp == 0) {

			return responseSender.ok(OrderController.APP_SETTINGS);

		} else {

			return responseSender.ok(OrderController.APP_SETTINGS_BLANK);

		}

	}

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

	public ResponseEntity<?> mobileAppSettings1(HttpServletRequest request, @RequestParam(name = "t") int timestamp,

												@RequestParam(name = "imeinumber") String imeinumber)

			throws ProfitMandiBusinessException, ClientProtocolException, IOException {

		LocalDateTime settingsLastUpdated = LocalDateTime.ofEpochSecond(timestamp, 0, ZoneOffset.ofHoursMinutes(5, 30));

		List<MobileAppSetting> mobileAppSettings = mobileAppSettingsRepository.getSettingAftera(settingsLastUpdated);

		List<MobileAppSettingsWrapper> mobileSettingsWrappersList = mobileAppSettings.stream()

				.map(x -> new MobileAppSettingsWrapper(x)).collect(Collectors.toList());

		SettingsWrapper wrapper = new SettingsWrapper(mobileSettingsWrappersList);

		LOGGER.info("Wrapper {}", wrapper);

		return responseSender.ok(objectMapper.writeValueAsString(wrapper));

	}

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

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	public ResponseEntity<?> getPartners(HttpServletRequest request, @RequestParam(name = "gmailId") String gmailId,

										 @RequestParam(value = "offset") int offset, @RequestParam(value = "limit") int limit)

			throws ProfitMandiBusinessException {

		AuthUser authUser = authRepository.selectByGmailId(gmailId);

		Map<String, Set<String>> storeGuyMap = csService.getAuthUserPartnerEmailMapping();

		Set<String> emails = storeGuyMap.get(authUser.getEmailId().toLowerCase());

		LOGGER.info("emails" + emails);

		List<User> users = userRepository.selectAllByEmails(new ArrayList<>(emails), offset, limit);

		List<Partner> partners = new ArrayList<>();

		for (User user : users) {

			UserAccount uc = userAccountRepository.selectSaholicByUserId(user.getId());

			com.spice.profitmandi.dao.entity.user.User userInfo = userUserRepository.selectById(uc.getAccountKey());

			CustomRetailer customRetailer = retailerService.getFofoRetailer(userInfo.getId());

			Partner partner = new Partner();

			partner.setBusinessName(customRetailer.getBusinessName());

			partner.setPartnerId(customRetailer.getPartnerId());

			partner.setCartId(customRetailer.getCartId());

			partner.setEmail(customRetailer.getEmail());

			partner.setGstNumber(customRetailer.getGstNumber());

			partner.setDisplayName(customRetailer.getDisplayName());

			partner.setCity(customRetailer.getAddress().getCity());

			partner.setUserId(user.getId());

			partners.add(partner);

		}

		LOGGER.info("partners" + partners);

		return responseSender.ok(partners);

	}

	@RequestMapping(value = "/user/refferal", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	public ResponseEntity<?> RefferalUser(HttpServletRequest request,

										  @RequestBody CreateRefferalRequest createRefferalRequest) throws Exception {

		Refferal refferal = new Refferal();

		refferal.setFirstName(createRefferalRequest.getFirstName());

		refferal.setLastName(createRefferalRequest.getLastName());

		refferal.setMobile(createRefferalRequest.getMobile());

		refferal.setState(createRefferalRequest.getState());

		refferal.setCity(createRefferalRequest.getCity());

		refferal.setCreatedTimestamp(LocalDateTime.now());

		refferal.setUpdatedTimestamp(LocalDateTime.now());

		refferal.setStatus(RefferalStatus.pending);

		if (createRefferalRequest.isFofoAssociate()) {

			AuthUser authUser = authRepository.selectByGmailId(createRefferalRequest.getReffereeEmail());

			if (authUser == null) {

				Promoter promoter = promoterRepository.selectByEmailId(createRefferalRequest.getReffereeEmail());

				refferal.setRefereeName(promoter.getName());

				refferal.setRefereeEmail(promoter.getEmail());

				refferal.setRefereeMobile(promoter.getMobile());

			} else {

				refferal.setRefereeName(authUser.getFirstName());

				refferal.setRefereeEmail(authUser.getGmailId());

				refferal.setRefereeMobile(authUser.getMobileNumber());

			}

		} else {

			User user = userRepository.selectByEmailId(createRefferalRequest.getReffereeEmail());

			refferal.setRefereeName(user.getFirstName());

			refferal.setRefereeEmail(user.getEmailId());

			refferal.setRefereeMobile(user.getMobileNumber());

		}

		refferalRepository.persist(refferal);

		List<PartnerOnBoardingPanel> pobs = partnerOnBoardingPanelRepository

				.selectAllByPhoneNumber((Long.parseLong(refferal.getMobile())));

		if (!pobs.isEmpty()) {

			List<PartnerOnBoardingStatus> ponbStatus = pobs.stream().map(x -> x.getStatus())

					.collect(Collectors.toList());

			if (ponbStatus.contains(PartnerOnBoardingStatus.open)) {

				refferal.setStatus(RefferalStatus.rejected);

				refferal.setRejectedReason("This is already a Smartdukaan Partner.");

			} else if (ponbStatus.contains(PartnerOnBoardingStatus.pending)) {

				refferal.setStatus(RefferalStatus.rejected);

				refferal.setRejectedReason("This is already a Smartdukaan Partner.");

			} else {

				this.sendEmailToValidate(refferal);

			}

		} else {

			this.sendEmailToValidate(refferal);

		}

		return responseSender.ok(true);

	}

	private void sendEmailToValidate(Refferal refferal) throws MessagingException, UnsupportedEncodingException {

		String subject = "Referral Validate Request for " + refferal.getRefereeEmail();

		String messageText = this.getMessageForReferral(refferal);

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message, true);

		String[] email = {"kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com", "sm@smartdukaan.com"};

		helper.setSubject(subject);

		helper.setText(messageText, true);

		helper.setTo(email);

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smartdukaan Alerts");

		helper.setFrom(senderAddress);

		mailSender.send(message);

	}

	private String getMessageForReferral(Refferal referral) {

		StringBuilder sb = new StringBuilder();

		sb.append("<html><body><p>Alert</p><p> Referral Requests:-</p>"

				+ "<br/><table style='border:1px solid black ;padding: 5px';>");

		sb.append("<tbody>\n" + "	    				<tr>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>RefereeName</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>Referee Email</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>Referral Name</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>Refferal Mobile</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>city</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>state</th>\n"

				+ "	    				</tr>");

		sb.append("<tr>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getRefereeName() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getRefereeEmail() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getFirstName() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getMobile() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getCity() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getState() + "</td>");

		sb.append("</tr>");

		sb.append("</tbody></table></body></html>");

		return sb.toString();

	}

	@RequestMapping(value = "/user/refferalAmount", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	public ResponseEntity<?> RefferalAmount(HttpServletRequest request, @RequestParam String refereeEmail)

			throws Exception {

		LocalDateTime ldt = LocalDate.now().atStartOfDay().withDayOfMonth(16);

		DateRangeModel drm = new DateRangeModel();

		List<RefferalEarningModel> refferAmountModel = new ArrayList<RefferalEarningModel>();

		RefferalEarningModel rfm = new RefferalEarningModel();

		long currentMonthEstimaterefferal = 0;

		long currentMonthConfirmedrefferal = 0;

		if (LocalDateTime.now().isBefore(ldt)) {

			List<Refferal> allPendingRefferalBeforeCurrentMonth = refferalRepository

					.selectByEmailIdAndStatusAndbeforeCurrentMonth(refereeEmail, RefferalStatus.pending);

			drm.setStartDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

			drm.setEndDate(LocalDateTime.now().withDayOfMonth(1));

			List<Refferal> previousMonthapprovedRefferalAfterSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(refereeEmail, RefferalStatus.approved, drm);

			List<Refferal> previousMonthtransferredRefferalAfterSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(refereeEmail, RefferalStatus.transferred, drm);

			drm.setStartDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(1));

			drm.setEndDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

			List<Refferal> previousMonthapprovedRefferalbeforeSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRanges(refereeEmail, RefferalStatus.approved, drm);

			List<Refferal> previousMonthtransferredRefferalbeforeSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRanges(refereeEmail, RefferalStatus.transferred, drm);

			long pendingRefferalBeforeCurrentMonth = allPendingRefferalBeforeCurrentMonth.size();

			long previousapprovedRefferalAfterSixteen = previousMonthapprovedRefferalAfterSixteen.size();

			long previoustransferredRefferalAfterSixteen = previousMonthtransferredRefferalAfterSixteen.size();

			long previousapprovedRefferalbeforeSixteen = previousMonthapprovedRefferalbeforeSixteen.size();

			long previoustransferredRefferalbeforeSixteen = previousMonthtransferredRefferalbeforeSixteen.size();

			long previousMonthEstimateRefferal = pendingRefferalBeforeCurrentMonth

					+ previousapprovedRefferalAfterSixteen + previousapprovedRefferalbeforeSixteen;

			long previousMonthConfirmedRefferal = previousapprovedRefferalAfterSixteen

					+ previoustransferredRefferalAfterSixteen + previousapprovedRefferalbeforeSixteen

					+ previoustransferredRefferalbeforeSixteen;

			rfm = refferAmountEarning(pendingRefferalBeforeCurrentMonth, previousMonthConfirmedRefferal,

					YearMonth.now().minusMonths(1));

			refferAmountModel.add(rfm);

			LOGGER.info("previousMonthPendingApprovedRefferal" + previousMonthEstimateRefferal);

			LOGGER.info("previousMonthApprovedTransfferedRefferal" + previousMonthConfirmedRefferal);

			List<Refferal> pendingofCurrentMonth = refferalRepository

					.selectByEmailIdAndStatusAndBetweenDates(refereeEmail, RefferalStatus.pending, YearMonth.now());

			List<Refferal> approvedofCurrentMonth = refferalRepository.selectByEmailIdAndStatusAndDatesBetweenTimestamp(

					refereeEmail, RefferalStatus.approved, YearMonth.now());

			List<Refferal> transferredofCurrentMonth = refferalRepository

					.selectByEmailIdAndStatusAndDatesBetweenTimestamp(refereeEmail, RefferalStatus.transferred,

							YearMonth.now());

			LOGGER.info("pendingofCurrentMonth" + pendingofCurrentMonth);

			long pendingofCurrentMonthCount = pendingofCurrentMonth.size();

			currentMonthEstimaterefferal = pendingofCurrentMonth.size() + approvedofCurrentMonth.size();

			currentMonthConfirmedrefferal = approvedofCurrentMonth.size() + transferredofCurrentMonth.size();

			rfm = refferAmountEarning(pendingofCurrentMonthCount, currentMonthConfirmedrefferal, YearMonth.now());

			refferAmountModel.add(rfm);

		} else if (LocalDateTime.now().isAfter(ldt)) {

			drm.setStartDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(1));

			drm.setEndDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

			List<Refferal> previousMonthapprovedRefferalbeforeSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRanges(refereeEmail, RefferalStatus.approved, drm);

			List<Refferal> previousMonthtransferredRefferalbeforeSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRanges(refereeEmail, RefferalStatus.transferred, drm);

			drm.setStartDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

			drm.setEndDate(LocalDateTime.now().withDayOfMonth(16));

			List<Refferal> previousAndcurrentMonthapprovedRefferal = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(refereeEmail, RefferalStatus.approved, drm);

			LocalDateTime currentMonthdate = LocalDateTime.now().withDayOfMonth(1);

			List<Refferal> preCurrMonthapproved = previousAndcurrentMonthapprovedRefferal.stream()

					.filter(x -> x.getCreatedTimestamp().isBefore(currentMonthdate)).collect(Collectors.toList());

			List<Refferal> previousAndcurrentMonthtransferredRefferal = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(refereeEmail, RefferalStatus.transferred, drm);

			List<Refferal> preCurrMonthtransferred = previousAndcurrentMonthtransferredRefferal.stream()

					.filter(x -> x.getCreatedTimestamp().isBefore(currentMonthdate)).collect(Collectors.toList());

			long approvedRefferal = previousMonthapprovedRefferalbeforeSixteen.size()

					+ previousMonthtransferredRefferalbeforeSixteen.size() + preCurrMonthapproved.size()

					+ preCurrMonthtransferred.size();

			rfm = new RefferalEarningModel();

			rfm.setActualEarning(approvedRefferal * 5000);

			rfm.setYearMonth(YearMonth.now().minusMonths(1));

			rfm.setPendingRefferal(0);

			rfm.setApprovedRefferal(approvedRefferal);

			refferAmountModel.add(rfm);

			List<Refferal> allpendingRefferal = refferalRepository.selectByEmailIdAndStatus(refereeEmail,

					RefferalStatus.pending);

			LOGGER.info("allpendingRefferal" + allpendingRefferal);

			drm.setStartDate(LocalDateTime.now().withDayOfMonth(16));

			drm.setEndDate(LocalDateTime.now().plusMonths(1).withDayOfMonth(1));

			List<Refferal> currentMonthapprovedRefferalAfterSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(refereeEmail, RefferalStatus.approved, drm);

			List<Refferal> currentMonthtransferredRefferalAfterSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(refereeEmail, RefferalStatus.transferred, drm);

			LOGGER.info("currentMonthapprovedRefferalAfterSixteen" + currentMonthapprovedRefferalAfterSixteen);

			drm.setStartDate(LocalDateTime.now().withDayOfMonth(1));

			drm.setEndDate(LocalDateTime.now().withDayOfMonth(16));

			List<Refferal> currentMonthapprovedRefferalbeforeSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRanges(refereeEmail, RefferalStatus.approved, drm);

			List<Refferal> currentMonthtransferredRefferalbeforeSixteen = refferalRepository

					.selectByEmailIdAndStatusAndDateRanges(refereeEmail, RefferalStatus.transferred, drm);

			LOGGER.info("currentMonthapprovedRefferalbeforeSixteen" + currentMonthapprovedRefferalbeforeSixteen);

			long pendingrefferalcount = allpendingRefferal.size();

			currentMonthConfirmedrefferal = currentMonthapprovedRefferalAfterSixteen.size()

					+ currentMonthtransferredRefferalAfterSixteen.size()

					+ currentMonthapprovedRefferalbeforeSixteen.size()

					+ currentMonthtransferredRefferalbeforeSixteen.size();

			rfm = refferAmountEarning(pendingrefferalcount, currentMonthConfirmedrefferal, YearMonth.now());

			refferAmountModel.add(rfm);

			LOGGER.info("currentMonthpendingApprovedrefferal" + currentMonthEstimaterefferal);

			LOGGER.info("currentMonthapprovedTransferredrefferal" + currentMonthConfirmedrefferal);

		}

		RefferalEarning re = new RefferalEarning();

		re.setTimestamp(LocalDateTime.now());

		re.setRefferalEarningModel(refferAmountModel);

		return responseSender.ok(re);

	}

	private RefferalEarningModel refferAmountEarning(long pendingRefferalValue, long confirmedRefferalValue,

													 YearMonth yearMonth) {

		RefferalEarningModel rfm = new RefferalEarningModel();

		rfm.setYearMonth(yearMonth);

		rfm.setPendingRefferal(pendingRefferalValue);

		rfm.setApprovedRefferal(confirmedRefferalValue);

		long estimateRefferalValue = pendingRefferalValue + confirmedRefferalValue;

		rfm.setMaximumEarning(estimateRefferalValue * 5000);

		rfm.setMinimumEarning(confirmedRefferalValue * 5000);

		return rfm;

	}

	@RequestMapping(value = "/user/getReferals", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	public ResponseEntity<?> getReferals(HttpServletRequest request, @RequestParam RefferalStatus status)

			throws Exception {

		int userId = (int) request.getAttribute("userId");

		User user = userRepository.selectById(userId);

		UserCart uc = userAccountRepository.getUserCart(userId);

		List<Refferal> refferals = refferalRepository.selectByEmailIdAndStatus(user.getEmailId(), status);

		return responseSender.ok(refferals);

	}

	@RequestMapping(value = "/user/partnerTarget", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	public ResponseEntity<?> PartnerTarget(HttpServletRequest request) throws Exception {

		int userId = (int) request.getAttribute(ProfitMandiConstants.USER_ID);

		int retailerId = userAccountRepository.selectRetailerIdByUserId(userId);

		PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(retailerId, LocalDate.now());

		return responseSender.ok(partnerType);

	}

	@RequestMapping(value = "/user/authUser", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

	@ApiImplicitParams({

			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

	public ResponseEntity<?> authUserDetail(HttpServletRequest request, @RequestParam int userId) throws Exception {

		User user = userRepository.selectById(userId);

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

		return responseSender.ok(authUser);

	}

}

class MobileAppSettingsWrapper {

	@JsonProperty(value = "Mobileappsetting")

	private MobileAppSetting mobileAppSettings;

	public MobileAppSettingsWrapper(MobileAppSetting mobileAppSettings) {

		super();

		this.mobileAppSettings = mobileAppSettings;

	}

	public MobileAppSetting getMobileAppSettings() {

		return mobileAppSettings;

	}

	public void setMobileAppSettings(MobileAppSetting mobileAppSettings) {

		this.mobileAppSettings = mobileAppSettings;

	}

	@Override

	public String toString() {

		return "MobileAppSettingsWrapper [mobileAppSettings=" + mobileAppSettings + "]";

	}

}

class SettingsWrapper {

	private List<MobileAppSettingsWrapper> settings;

	public SettingsWrapper(List<MobileAppSettingsWrapper> settings) {

		super();

		this.settings = settings;

	}

	@Override

	public String toString() {

		return "SettingsWrapper [settings=" + settings + "]";

	}

	public List<MobileAppSettingsWrapper> getSettings() {

		return settings;

	}

	public void setSettings(List<MobileAppSettingsWrapper> settings) {

		this.settings = settings;

	}

}