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.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.cs.DemoPartnerAccessService;

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

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

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

    JWTUtil jwtUtil;

    @Autowired

    private ResponseSender<?> responseSender;

    // Referrals whose approval (or creation, if approval ts is missing) falls before

    // TIER_POLICY_EFFECTIVE_DATE keep the flat legacy payout; everything from that date

    // onward uses the monthly tier: 1 → 3000, 2 → 4000, 3+ → 5000 (applied to the whole month).

    private static final int LEGACY_PER_REFERRAL_EARNING = 2000;

    private static final LocalDate TIER_POLICY_EFFECTIVE_DATE = LocalDate.of(2026, 1, 19);

    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 DemoPartnerAccessService demoPartnerAccessService;

    @Autowired

    private PositionRepository positionRepository;

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

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

    }

    /** A partner whose store is SUSPENDED or CLOSED is logged out; retailers without a store are not affected. */

    private void assertStoreCanLogin(int retailerId) throws ProfitMandiBusinessException {

        FofoStore fofoStore;

        try {

            fofoStore = fofoStoreRepository.selectByRetailerId(retailerId);

        } catch (ProfitMandiBusinessException e) {

            return;

        }

        assertStoreCanLogin(fofoStore);

    }

    private void assertStoreCanLogin(FofoStore fofoStore) throws ProfitMandiBusinessException {

        if (!fofoStore.getStoreStatus().canLogin()) {

            throw new ProfitMandiBusinessException("STORE_LOGIN_BLOCKED", fofoStore.getCode(), "Your store " + fofoStore.getCode() + " is "

                    + fofoStore.getStoreStatus().name().toLowerCase() + ". Please contact your sales manager.");

        }

    }

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

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

                return responseMap;

            }

        } else {

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

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

            assertStoreCanLogin(retailerId);

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

                        assertStoreCanLogin(fofoStore);

                        responseMap.put("storeStatus", fofoStore.getStoreStatus().name());

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

                            if(fofoStore.isTrial()) {

                                responseMap.put("fofoTrialEndDate", fofoStore.getTrialEnd());

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

                            }

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

    }

    /**

     * React admin partner list. Broader than v1 {@link #getPartners}: Sales, RBM, ABM,

     * Category, Training and BI positions all see their assigned partners (v1 only

     * mapped Sales/RBM/ABM, so the other HO roles got an empty list), and any user

     * with a Technology position sees every active partner across the catalogue —

     * tech ops has no region/partner scope.

     *

     * Angular's /getPartners is intentionally unchanged. This method exists only so

     * the v2 React route can call it without regressing the Angular v1 behaviour.

     */

    public ResponseEntity<?> getPartnersV2(HttpServletRequest request, String gmailId, int offset, int limit)

            throws ProfitMandiBusinessException {

        AuthUser authUser = authRepository.selectByGmailId(gmailId);

        if (authUser == null) {

            LOGGER.warn("No auth user found for gmailId: {}", gmailId);

            return responseSender.badRequest("No user found for the provided email");

        }

        // Expanded HO roster for assigned-partner visibility. If you need another

        // category to see partners on the React page, add it here — nothing else.

        List<Integer> partnerVisibleCategoryIds = Arrays.asList(

                ProfitMandiConstants.TICKET_CATEGORY_SALES,

                ProfitMandiConstants.TICKET_CATEGORY_RBM,

                ProfitMandiConstants.TICKET_CATEGORY_ABM,

                ProfitMandiConstants.TICKET_CATEGORY_CATEGORY,

                ProfitMandiConstants.TICKET_CATEGORY_TRAINING,

                ProfitMandiConstants.TICKET_CATEGORY_BUSINESSINTELLIGENT);

        Set<String> emails = new HashSet<>();

        boolean isTechUser = positionRepository.selectAllByAuthUserId(authUser.getId()).stream()

                .anyMatch(p -> p != null && p.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_TECHNOLOGY);

        if (isTechUser) {

            // Tech ops override: union of every partner any HO user is mapped to.

            // Using the mapping (not a bare fofo-store scan) keeps the "active +

            // assigned" filter that the rest of the admin uses, so tech sees the

            // same universe operators see, not a wider raw-DB set.

            Map<String, Set<String>> fullMap = csService.getAuthUserPartnerEmailMappingByCategoryIds(partnerVisibleCategoryIds);

            for (Set<String> perUser : fullMap.values()) {

                if (perUser != null) emails.addAll(perUser);

            }

        } else {

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

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

            if (mine != null) {

                emails.addAll(mine);

            }

        }

        emails.addAll(demoPartnerAccessService.getDemoPartnerEmails(authUser.getId()));

        if (emails.isEmpty()) {

            LOGGER.info("No partner emails found for v2 user: {}", gmailId);

            return responseSender.ok(new ArrayList<>());

        }

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

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

        for (User user : users) {

            try {

                Integer accountKey = userAccountRepository.selectSaholicAccountKeySafe(user.getId());

                if (accountKey == null) {

                    LOGGER.warn("No usable saholic account for userId: {}", user.getId());

                    continue;

                }

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

                if (userInfo == null) {

                    LOGGER.warn("No user info found for accountKey: {}", accountKey);

                    continue;

                }

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

                if (customRetailer == null) {

                    LOGGER.warn("No custom retailer found for userInfoId: {}", userInfo.getId());

                    continue;

                }

                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.setStoreCode(customRetailer.getCode());

                partner.setCity(customRetailer.getAddress() != null ? customRetailer.getAddress().getCity() : null);

                partner.setUserId(user.getId());

                partners.add(partner);

            } catch (Exception e) {

                LOGGER.error("Error processing partner for userId: {}", user.getId(), e);

            }

        }

        return responseSender.ok(partners);

    }

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

        if (authUser == null) {

            LOGGER.warn("No auth user found for gmailId: {}", gmailId);

            return responseSender.badRequest("No user found for the provided email");

        }

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

        // Copy: the mapping is a shared cached object and must not carry demo partners.

        Set<String> emails = new HashSet<>();

        if (storeGuyMap.get(authUser.getEmailId().toLowerCase()) != null) {

            emails.addAll(storeGuyMap.get(authUser.getEmailId().toLowerCase()));

        }

        emails.addAll(demoPartnerAccessService.getDemoPartnerEmails(authUser.getId()));

        LOGGER.info("emails: {}", emails);

        if (emails == null || emails.isEmpty()) {

            LOGGER.info("No partner emails found for user: {}", gmailId);

            return responseSender.ok(new ArrayList<>());

        }

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

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

        for (User user : users) {

            try {

                Integer accountKey = userAccountRepository.selectSaholicAccountKeySafe(user.getId());

                if (accountKey == null) {

                    LOGGER.warn("No usable saholic account for userId: {}", user.getId());

                    continue;

                }

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

                if (userInfo == null) {

                    LOGGER.warn("No user info found for accountKey: {}", accountKey);

                    continue;

                }

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

                if (customRetailer == null) {

                    LOGGER.warn("No custom retailer found for userInfoId: {}", userInfo.getId());

                    continue;

                }

                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.setStoreCode(customRetailer.getCode());

                partner.setCity(customRetailer.getAddress() != null ? customRetailer.getAddress().getCity() : null);

                partner.setUserId(user.getId());

                partners.add(partner);

            } catch (Exception e) {

                LOGGER.error("Error processing partner for userId: {}", user.getId(), e);

            }

        }

        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 = gmailRelaySender.createMimeMessage();

        MimeMessageHelper helper = new MimeMessageHelper(message, true);

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

        helper.setSubject(subject);

        helper.setText(messageText, true);

        helper.setTo(email);

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

        helper.setFrom(senderAddress);

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

            List<Refferal> previousMonthConfirmedList = new ArrayList<>();

            previousMonthConfirmedList.addAll(previousMonthapprovedRefferalAfterSixteen);

            previousMonthConfirmedList.addAll(previousMonthtransferredRefferalAfterSixteen);

            previousMonthConfirmedList.addAll(previousMonthapprovedRefferalbeforeSixteen);

            previousMonthConfirmedList.addAll(previousMonthtransferredRefferalbeforeSixteen);