Subversion Repositories SmartDukaan

Rev

Rev 30561 | Rev 32721 | Go to most recent revision | View as "text/plain" | Blame | Compare with Previous | Last modification | View Log | RSS feed

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 (authUser != null) {
                                registeredUser = userRepository.selectByEmailId(authUser.getEmailId());
                        } else if (promoterRepository.selectMappedByEmailId(email) != null) {
                                Promoter promoter = promoterRepository.selectMappedByEmailId(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");
                LOGGER.info("userinfo1 {}", userInfo);
                User user = null;
                if (userInfo.getUserId() > -1) {
                        user = userRepository.selectById(userInfo.getUserId());
                        String city = user.getCity();

                        if (!(userInfo.getEmail() == null || user.getEmailId().indexOf("@smartdukaan.com") == -1)) {
                                String userName = null;
                                if (user.getSecondryEmailId() != null && user.getSecondryEmailId().equals(userInfo.getEmail())) {

                                        userName = user.getFirstName() + " " + user.getLastName();
                                } else {
                                        AuthUser authUser = authRepository.selectByGmailId(userInfo.getEmail());
                                        LOGGER.info("authUser {}", authUser);
                                        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 {

                                LOGGER.info("userinfo4 {}", userInfo);
                                user = userRepository.selectByEmailId(userInfo.getEmail());
                        } catch (ProfitMandiBusinessException e1) {
                        }
                        if (user == null) {
                                try {
                                        LOGGER.info("userinfo8 {}", userInfo);
                                        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;
        }

}