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;

    //Changed to 2000 as per policy

    private static final int PER_REFERRAL_EARNING=2000;

    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 loginRequest) throws Exception {

        String email = loginRequest.getEmail() != null ? loginRequest.getEmail() : googleLoginProcessor.process(loginRequest.getToken());

        return responseSender.ok(getAuthTokenMap(email, loginRequest));

    }

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

    public ResponseEntity<?> unregisteredToken() throws Exception {

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

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

        responseMap.put(ProfitMandiConstants.REGISTERED, false);

        return responseSender.ok(responseMap);

    }

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

    public ResponseEntity<?> checkForUpdate(HttpServletRequest request, @RequestParam int version) {

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

        responseMap.put("appVersion", ProfitMandiConstants.B2B_APP_VERSION);

        responseMap.put("appUrl", ProfitMandiConstants.B2B_APP_URL);

        if (version == ProfitMandiConstants.B2B_APP_VERSION) {

            responseMap.put("updateAvailable", false);

        } else {

            responseMap.put("updateAvailable", true);

        }

        return responseSender.ok(responseMap);

    }

    private Map<String, Object> getAuthTokenMap(String email, GoogleLoginRequest loginRequest) 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 (loginRequest.getPassword() != null) {

                registeredUser = userService.authenticate(email, loginRequest.getPassword());

            } else 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 = partnerTypeChangeService.getBestPartner(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 {

            if (loginRequest.getPassword() != null) {

                user = userService.authenticate(email, loginRequest.getPassword());

            } else {

                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_FORGOT_PASSWORD, method = RequestMethod.POST)

    public ResponseEntity<?> forgotPassword(@RequestBody GoogleLoginRequest loginRequest) throws Exception {

        userService.resetPassword(loginRequest.getEmail());

        return responseSender.ok(true);

    }

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

    public ResponseEntity<?> changePassword(@RequestBody EmailPassword emailPassword) throws Exception {

        User user = userService.authenticate(emailPassword.getEmail(), emailPassword.getPassword());

        if (user != null){

            boolean response = userService.changePassword(user, emailPassword.getNewPassword());

            return responseSender.ok(response);

        }

        return responseSender.ok(false);

    }

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

        // Case 1: When userId is present in token

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

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

            // Special FOFO Associate handling for smartdukaan domain

            boolean isSmartDukaanEmail = userInfo.getEmail() != null

                    && user.getEmailId() != null

                    && user.getEmailId().contains("@smartdukaan.com");

            if (isSmartDukaanEmail) {

                String userName;

                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 {

            // Case 2: When userId is not present, try locate by emails

            try {

                LOGGER.info("userinfo4 {}", userInfo);

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

            } catch (ProfitMandiBusinessException e1) {

                LOGGER.warn("Failed to fetch user by primary email: {}", userInfo.getEmail(), e1);

            }

            if (user == null) {

                try {

                    LOGGER.info("userinfo8 {}", userInfo);

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

                } catch (ProfitMandiBusinessException e1) {

                    LOGGER.info("Unregistered user: {}", userInfo.getEmail());

                }

            }

        }

        if (user != null) {

            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 for {}", user.getEmailId());

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

            // generate new token if roles have been updated

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

                String[] roleIdStrings = roleIds.stream().map(String::valueOf).toArray(String[]::new);

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

                responseMap.put("newAuthToken", newToken);

            }

            // if user is retailer

            Set<Integer> roleIdsSet = new HashSet<>(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.isActive() || user.isActivated()) {

                    if (roleManager.isPartner(roleIdsSet)) {

                        FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(saholicUser.getId());

                        if (fofoStore.isActive()) {

                            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 {

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

        }

        GoogleLoginRequest loginRequest = new GoogleLoginRequest();

        loginRequest.setToken(adminToken);

        loginRequest.setEmail(emailId);

        loginRequest.setType("Internal");

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

    }

    @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 approvedRefferalCount = previousMonthapprovedRefferalbeforeSixteen.size()

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

                    + preCurrMonthtransferred.size();

            rfm = new RefferalEarningModel();

            rfm.setActualEarning(approvedRefferalCount * PER_REFERRAL_EARNING);

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

            rfm.setPendingRefferal(0);

            rfm.setApprovedRefferal(approvedRefferalCount);

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

        rfm.setMinimumEarning(confirmedRefferalValue * PER_REFERRAL_EARNING);

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