Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.io.IOException;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.YearMonth;

import java.util.ArrayList;

import java.util.Base64;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

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.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

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

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

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

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

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

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

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

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

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

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

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

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;

/**

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

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

	@Autowired

	private RefferalRepository refferalRepository;

	@Autowired

	private PromoterRepository promoterRepository;

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

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

			throws ProfitMandiBusinessException {

		return responseSender.ok(googleLoginProcessor.process(googleLoginRequest.getToken()));

	}

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

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

			throws ProfitMandiBusinessException {

		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 {

					userName = authService.getNameByEmailId(userInfo.getEmail());

				}

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

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

	}

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

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

		if (!adminToken.equals(validAdminToken)) {

			return responseSender.forbidden(null);

		}

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

		User user = null;

		try {

			user = userRepository.selectByEmailId(emailId);

		} catch (ProfitMandiBusinessException profitMandiBusinessException) {

		}

		if (user == null) {

			try {

				user = userRepository.selectBySecondryEmailId(emailId);

			} catch (ProfitMandiBusinessException profitMandiBusinessException) {

			}

		}

		if (user != null) {

			int retailerId = 0;

			try {

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

			} catch (ProfitMandiBusinessException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

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

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

			int index = 0;

			for (int roleId : roleIds) {

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

			}

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

			responseMap.put(ProfitMandiConstants.REGISTERED, true);

		} else {

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

			responseMap.put(ProfitMandiConstants.REGISTERED, false);

		}

		return responseSender.ok(responseMap);

	}

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

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

		return responseSender.ok(restClient.post(uri, params, headers));

	}

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

		return responseSender.ok(true);

	}

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

			if (approvedRefferal <= 4) {

				rfm.setActualEarning(approvedRefferal * 5000);

			} else if (approvedRefferal >= 5 && approvedRefferal <= 9) {

				rfm.setActualEarning(approvedRefferal * 10000);

			} else if (approvedRefferal > 10) {

				rfm.setActualEarning(approvedRefferal * 200000);

			}

			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;

		if (estimateRefferalValue <= 4) {

			rfm.setMaximumEarning(estimateRefferalValue * 5000);

		} else if (estimateRefferalValue >= 5 && estimateRefferalValue <= 9) {

			rfm.setMaximumEarning(estimateRefferalValue * 10000);

		} else if (estimateRefferalValue >= 10) {

			rfm.setMaximumEarning(200000);

		}

		if (confirmedRefferalValue <= 4) {

			rfm.setMinimumEarning(confirmedRefferalValue * 5000);

		} else if (confirmedRefferalValue >= 5 && confirmedRefferalValue <= 9) {

			rfm.setMinimumEarning(confirmedRefferalValue * 10000);

		} else if (confirmedRefferalValue >= 10) {

			rfm.setMinimumEarning(200000);

		}

		return rfm;

	}

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

	}

}