Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.user;

import com.spice.profitmandi.dao.enumuration.warehouse.WarehouseStatus;

import com.spice.profitmandi.service.warehouse.BillingWarehouseService;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.google.common.hash.Hashing;

import com.google.gson.Gson;

import com.spice.profitmandi.common.enumuration.ActivationType;

import com.spice.profitmandi.common.enumuration.FofoType;

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

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

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

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

import com.spice.profitmandi.dao.entity.catalog.BrandCatalog;

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

import com.spice.profitmandi.dao.entity.dtr.User;

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

import com.spice.profitmandi.dao.entity.inventory.State;

import com.spice.profitmandi.dao.entity.logistics.AST;

import com.spice.profitmandi.dao.entity.logistics.ASTRepository;

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

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

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

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

import com.spice.profitmandi.dao.enumuration.fofo.PaymentOptionType;

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

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

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

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

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

import com.spice.profitmandi.dao.repository.inventory.StateRepository;

import com.spice.profitmandi.dao.repository.trialOnboarding.TrialFormRepository;

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

import com.spice.profitmandi.service.PostOfficeService;

import com.spice.profitmandi.service.SellerService;

import com.spice.profitmandi.service.catalog.BrandsService;

import in.shop2020.model.v1.user.CartStatus;

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

import org.springframework.cache.annotation.Cacheable;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.stereotype.Component;

import org.springframework.transaction.annotation.Transactional;

import java.nio.charset.StandardCharsets;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.YearMonth;

import java.time.format.DateTimeFormatter;

import java.util.*;

import java.util.function.Function;

import java.util.stream.Collectors;

import java.util.stream.Stream;

@Component

public class RetailerServiceImpl implements RetailerService {

    @Autowired

    private BillingWarehouseService billingWarehouseService;

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

    private static final String[] TRIAL_CODE_CREATION_AUDIENCE = new String[]{"amit.gupta@smartdukaan.com"};

    //private static final String [] TRIAL_CODE_CREATION_AUDIENCE = new String[]{};

    @Autowired

    private RetailerRepository retailerRepository;

    @Autowired

    private SellerService sellerService;

    @Autowired

    private RetailerBlockBrandsRepository retailerBlockBrandsRepository;

    @Autowired

    private UserAccountRepository userAccountRepository;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    Gson gson;

    @Autowired

    private UserRepository userRepository;

    @Autowired

    ObjectMapper objectMapper;

    @Autowired

    private CartRepository cartRepository;

    @Autowired

    private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

    @Autowired

    private AddressRepository addressRepository;

    @Autowired

    private ShopRepository shopRepository;

    @Autowired

    private ShopAddressRepository shopAddressRepository;

    @Autowired

    private UserRoleRepository userRoleRepository;

    @Autowired

    private DocumentRepository documentRepository;

    @Autowired

    private RetailerContactRepository retailerContactRepository;

    @Autowired

    private StateRepository stateRepository;

    @Autowired

    private TrialFormRepository trialFormRepository;

    @Autowired

    @Qualifier("userUserRepository")

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

    @Autowired

    private DistrictMasterRepository districtMasterRepository;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private ASTRepository aSTRepository;

    @Autowired

    private PostOfficeService postOfficeService;

    @Autowired

    private PaymentOptionRepository paymentOptionRepository;

    @Autowired

    private FofoPartnerPaymentOptionRepository fofoPartnerPaymentOptionRepository;

    @Autowired

    private RoleRepository roleRepository;

    @Autowired

    private StoreTimelineTatService storeTimelineTatService;

    @Autowired

    private PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

    @Autowired

    private PartnerOnboardingVerificationRepository partnerOnboardingVerificationRepository;

    @Autowired

    private PincodePartnerRepository pincodePartnerRepository;

    @Autowired

    SchemeInOutRepository schemeInOutRepository;

    @Autowired

    OfferPayoutRepository offerPayoutRepository;

    @Autowired

    PartnerTypeChangeService partnerTypeChangeService;

    @Autowired

    BrandsService brandsService;

    @Autowired

    private JavaMailSender googleMailSender;

    @Override

    public Map<String, Object> getByEmailIdOrMobileNumber(String emailIdOrMobileNumber) throws ProfitMandiBusinessException {

        User user = null;

        try {

            user = userRepository.selectByEmailIdOrMobileNumber(emailIdOrMobileNumber);

        } catch (ProfitMandiBusinessException profitMandiBusinessException) {

        }

        if (user == null) {

            try {

                user = userRepository.selectBySecondryEmailId(emailIdOrMobileNumber);

            } catch (ProfitMandiBusinessException profitMandiBusinessException) {

            }

        }

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

        map.put("stateNames", stateRepository.selectAll().stream().map(State::getName).collect(Collectors.toList()));

        LOGGER.info("user - {}", user);

        if (user != null) {

            List<UserRole> userRoles = userRoleRepository.selectByUserId(user.getId());

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

            map.put("userRoles", userRoles);

            map.put("user", user);

            // map.put("retailer", retailer);

            map.put("fofoRole", this.containsRoleType(userRoles, role.getId()));

            map.put("userRoleNames", this.toString(userRoles));

            try {

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

                Retailer retailer = retailerRepository.selectById(retailerId);

                map.put("retailer", retailer);

                // This screen edits manual brand blocks only. Ineligibility (commitment/DMS) is

                // derived and enforced at order time, so the dropdown offers every brand.

                Set<String> brands = brandsService.getBrandsToDisplay(3).stream()

                        .map(BrandCatalog::getName).collect(Collectors.toSet());

                List<String> retailerBlockBrands = retailerBlockBrandsRepository.selectAllByRetailer(retailer.getId())

                        .stream().map(x -> x.getBlockBrands()).collect(Collectors.toList());

                map.put("brands", brands);

                map.put("retailerBlockBrands", retailerBlockBrands);

                try {

                    FofoStore gstStore = fofoStoreRepository.selectByRetailerId(retailer.getId());

                    map.put("gstNumber", gstStore != null ? gstStore.getGstNumber() : null);

                } catch (ProfitMandiBusinessException e) {

                    LOGGER.error("FofoStore not found for GST lookup");

                }

                try {

                    int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailer.getId());

                    Address retailerAddress = addressRepository.selectById(retailerAddressId);

                    map.put("retailerAddress", retailerAddress);

                    State state = stateRepository.selectByName(retailerAddress.getState());

                    // LOGGER.info("retailerAddress.." + retailerAddress);

                    List<DistrictMaster> districtMasters = districtMasterRepository.selectByStateShortName(state.getShortName());

                    map.put("districtMasters", districtMasters);

                    // LOGGER.info("districtMasters" + districtMasters);

                    List<Shop> shops = shopRepository.selectByRetailerId(retailer.getId());

                    map.put("shops", shops);

                    this.addAddress(shops);

                    if (this.containsRoleType(userRoles, role.getId())) {

                        try {

                            FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(retailerId);

                            map.put("fofoStore", fofoStore);

                            List<AST> astDetail = postOfficeService.getAreasAndTerritoriesByStateName(retailerAddress.getState());

                            LOGGER.info("astDetail {}", astDetail);

                            map.put("astDetail", astDetail);

                            // map.put("counterSize", fofoStore.getCounterSize().toString());

                            // LOGGER.info("fofoStore" + fofoStore);

                        } catch (ProfitMandiBusinessException profitMandiBusinessException) {

                            LOGGER.error("FofoStore code not found");

                        }

                    }

                    // LOGGER.info("shops" + shops);

                } catch (ProfitMandiBusinessException profitMandiBusinessException) {

                    LOGGER.error("Retailer Registered Address not found");

                }

            } catch (ProfitMandiBusinessException profitMandiBusinessException) {

                LOGGER.error("Retailer not found in user_account");

            }

        } else {

            try {

                TrialForm trialForm = trialFormRepository.selectByEmailOrMobile(emailIdOrMobileNumber);

                LOGGER.info("trialForm - {}", trialForm);

                map.put("trialForm", gson.toJson(trialForm));

            } catch (Exception e) {

                LOGGER.error("Retailer not found in user_account");

            }

        }

        return map;

    }

    private boolean containsRoleType(List<UserRole> userRoles, int roleId) {

        return userRoles != null && userRoles.stream().anyMatch(ur -> ur.getRoleId() == roleId);

    }

    private List<UserRole> addRole(List<UserRole> userRoles, int userId, int roleId) {

        if (userRoles == null) {

            userRoles = new ArrayList<>();

        }

        if (!this.containsRoleType(userRoles, roleId)) {

            UserRole userRole = new UserRole();

            userRole.setUserId(userId);

            userRole.setRoleId(roleId);

            try {

                userRoleRepository.persist(userRole);

            } catch (ProfitMandiBusinessException e) {

                LOGGER.error("UserRole is already exist");

            }

            userRoles.add(userRole);

        }

        return userRoles;

    }

    private List<UserRole> removeRole(List<UserRole> userRoles, int userId, int roleId) {

        if (userRoles == null) {

            userRoles = new ArrayList<>();

            return userRoles;

        }

        try {

            userRoles.remove(userRoleRepository.deleteByRoleUserId(userId, roleId));

        } catch (Exception e) {

        }

        return userRoles;

    }

    @SuppressWarnings("unchecked")

    @Override

    @Transactional(rollbackFor = Throwable.class)

    public Map<String, Object> updateRetailerDetails(UpdateRetailerRequest updateRetailerRequest) throws

            ProfitMandiBusinessException {

        this.validateGstNumbers(updateRetailerRequest);

        Map<String, Object> map = this.getByEmailIdOrMobileNumber(updateRetailerRequest.getEmailIdOrMobileNumber());

        User dtrUser = (User) map.get("user");

        if (updateRetailerRequest.isFofo()) {

            Retailer resolvedRetailer = (Retailer) map.get("retailer");

            if (resolvedRetailer == null) {

                // This save would mint a brand-new identity chain. Mandate: a partner

                // gets a new store code only after the old store is closed, and the

                // re-onboarding must reuse the partner's real email (takeover below) —

                // never a variant email that forks a duplicate chain.

                this.guardAgainstDuplicatePartnerChain(updateRetailerRequest);

            } else if (updateRetailerRequest.isActive()) {

                FofoStore existingStore = this.selectStoreOrNull(resolvedRetailer.getId());

                if (existingStore != null && existingStore.isClosed()) {

                    this.takeoverClosedStoreIdentity(existingStore, map);

                }

            }

        }

        dtrUser = this.createUser(dtrUser, updateRetailerRequest);

        map.put("user", dtrUser);

        List<UserRole> userRoles = (List<UserRole>) map.get("userRoles");

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

        userRoles = this.addRole(userRoles, dtrUser.getId(), roleUser.getId());

        Retailer retailer = (Retailer) map.get("retailer");

        retailer = this.updateRetailer(dtrUser, retailer, updateRetailerRequest);

        map.put("retailer", retailer);

        // Ensure the dtr login's bridge rows point at the current identity. Repairs

        // recreated logins and repoints the login after a closed-store takeover.

        userAccountRepository.upsert(dtrUser.getId(), AccountType.saholic, retailer.getId());

        try {

            com.spice.profitmandi.dao.entity.user.User identity = userUserRepository.selectById(retailer.getId());

            if (identity.getActiveCartId() > 0) {

                userAccountRepository.upsert(dtrUser.getId(), AccountType.cartId, identity.getActiveCartId());

            }

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("Error ensuring cartId UserAccount for userId: {}", dtrUser.getId(), e);

        }

        List<String> retailerBlockBrands = retailerBlockBrandsRepository.selectAllByRetailer(retailer.getId()).stream().map(x -> x.getBlockBrands()).collect(Collectors.toList());

        LOGGER.info("retailerBlockBrands" + retailerBlockBrands);

        if (!retailerBlockBrands.isEmpty()) {

            retailerBlockBrandsRepository.deleteBrands(retailer.getId());

        }

        List<String> requestedBlockBrands = updateRetailerRequest.getBlocksBrands() != null

                ? updateRetailerRequest.getBlocksBrands() : new ArrayList<>();

        for (String blockBrand : requestedBlockBrands) {

            RetailerBlockBrands retailerBlockBrand = new RetailerBlockBrands();

            retailerBlockBrand.setFofoId(retailer.getId());

            retailerBlockBrand.setBlockBrands(blockBrand);

            retailerBlockBrandsRepository.persist(retailerBlockBrand);

        }

        map.put("retailerBlockBrands", retailerBlockBrands);

        Role roleRetailer = roleRepository.selectByName(RoleType.RETAILER.toString());

        userRoles = this.addRole(userRoles, dtrUser.getId(), roleRetailer.getId());

        Role roleFofo = roleRepository.selectByName(RoleType.FOFO.toString());

        if (updateRetailerRequest.isFofo()) {

            userRoles = this.addRole(userRoles, dtrUser.getId(), roleFofo.getId());

        } else {

            userRoles = this.removeRole(userRoles, dtrUser.getId(), roleFofo.getId());

        }

        map.put("fofoRole", this.containsRoleType(userRoles, roleFofo.getId()));

        if (this.containsRoleType(userRoles, roleFofo.getId())) {

            this.createDefaultPaymentOption(retailer.getId());

        }

        map.put("userRoles", userRoles);

        map.put("userRoleNames", this.toString(userRoles));

        Address retailerAddress = (Address) map.get("retailerAddress");

        retailerAddress = this.updateRetailerAddress(retailerAddress, updateRetailerRequest.getAddress(), retailer.getId());

        map.put("retailerAddress", retailerAddress);

        if (updateRetailerRequest.isFofo()) {

            FofoStore fofoStore = this.createFofoStoreCodeByRetailerId(retailer.getId(), updateRetailerRequest.getDistrictName(), retailerAddress.getState(), updateRetailerRequest);

            map.put("fofoStore", fofoStore);

            if (fofoStore.isClosed() && updateRetailerRequest.isActive()) {

                throw new ProfitMandiBusinessException("Store Closed", "Store Permanently Closed",

                        "This store is permanently closed and cannot be reactivated");

            }

            fofoStore.setActive(updateRetailerRequest.isActive());

            List<AST> astDetail = postOfficeService.getAreasAndTerritoriesByStateName(retailerAddress.getState());

            map.put("astDetail", astDetail);

        }

        map.put("gstNumber", updateRetailerRequest.getGstNumber());

        this.updateSaholicUser(retailer.getId(), retailerAddress.getId());

        List<Shop> shops = (List<Shop>) map.get("shops");

        if (shops == null) {

            shops = new ArrayList<>();

            map.put("shops", shops);

        }

        this.updateRetailerShops(shops, updateRetailerRequest.getShops(), retailer.getId(), retailerAddress);

        return map;

    }

    private FofoStore selectStoreOrNull(int retailerId) {

        try {

            return fofoStoreRepository.selectByRetailerId(retailerId);

        } catch (ProfitMandiBusinessException e) {

            return null;

        }

    }

    /**

     * The onboarding screen carries the partner's GSTIN in two boxes that both read "GST NUMBER":

     * the retailer one (dtr.retailer.number) and the store one (fofo_store.gst_number, which is

     * what billing reads and what goes to NIC as the recipient). Neither was validated, so

     * DLSH1660 was saved with the LOI's pincode (110095) in the store box while the retailer box

     * held the real 07CMEPR1110C1ZO - an invoice NIC would refuse.

     * <p>

     * Both are normalised and checked here, before any write, and must agree when both are

     * present: across 1,800 partners on record they already do, bar the one that caused this.

     */

    private void validateGstNumbers(UpdateRetailerRequest updateRetailerRequest)

            throws ProfitMandiBusinessException {

        String storeGstin = StringUtils.normalizeGstNumber(updateRetailerRequest.getGstNumber());

        String retailerGstin = StringUtils.normalizeGstNumber(updateRetailerRequest.getNumber());

        if (!StringUtils.isValidGstNumber(storeGstin)) {

            throw new ProfitMandiBusinessException("gstNumber", storeGstin, "RTLR_1020");

        }

        if (!StringUtils.isValidGstNumber(retailerGstin)) {

            throw new ProfitMandiBusinessException("number", retailerGstin, "RTLR_1020");

        }

        if (isNotBlank(storeGstin) && isNotBlank(retailerGstin) && !storeGstin.equals(retailerGstin)) {

            throw new ProfitMandiBusinessException("gstNumber", storeGstin + " / " + retailerGstin, "RTLR_1021");

        }

        // Persist what was validated, so the same registration is never stored two ways.

        updateRetailerRequest.setGstNumber(storeGstin);

        updateRetailerRequest.setNumber(retailerGstin);

    }

    private static boolean isNotBlank(String value) {

        return value != null && !value.isEmpty();

    }

    private void guardAgainstDuplicatePartnerChain(UpdateRetailerRequest updateRetailerRequest)

            throws ProfitMandiBusinessException {

        User byMobile = null;

        try {

            byMobile = userRepository.selectByMobileNumber(updateRetailerRequest.getUserMobileNumber());

        } catch (ProfitMandiBusinessException e) {

            // no dtr user with this mobile

        }

        if (byMobile != null) {

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

            FofoStore store = accountKey != null ? this.selectStoreOrNull(accountKey) : null;

            if (store != null) {

                if (!store.isClosed()) {

                    throw new ProfitMandiBusinessException("Open store exists", store.getCode(),

                            "Partner mobile " + updateRetailerRequest.getUserMobileNumber()

                                    + " already owns open store " + store.getCode()

                                    + ". Close it first, or use email-change to keep the same code.");

                }

                throw new ProfitMandiBusinessException("Closed store exists", store.getCode(),

                        "Old store " + store.getCode() + " is closed. Re-onboard using the partner's existing email "

                                + byMobile.getEmailId() + " and a new code will be issued automatically.");

            }

        }

        // Same GST is normal (one GSTIN per entity per state; parallel outlets share it).

        // Block only when a sibling store is in limbo: dormant (REVIVAL) or deactivated

        // without being closed — the signature of a revival being forked instead of the

        // old code being closed or revived in place.

        List<FofoStore> limboGstStores = fofoStoreRepository.selectAllOpenByGstNumber(updateRetailerRequest.getGstNumber())

                .stream()

                .filter(s -> !s.isInternal())

                .filter(s -> s.getActivationType() == ActivationType.REVIVAL || !s.isActive())

                .collect(Collectors.toList());

        if (!limboGstStores.isEmpty()) {

            String codes = limboGstStores.stream().map(FofoStore::getCode).collect(Collectors.joining(", "));

            throw new ProfitMandiBusinessException("Dormant store exists for GST", codes,

                    "GST " + updateRetailerRequest.getGstNumber() + " has store(s) " + codes

                            + " that are dormant or deactivated but not closed. Close them or revive them on the same code before creating a new store.");

        }

    }

    private void takeoverClosedStoreIdentity(FofoStore oldStore, Map<String, Object> map) {

        // Mandate: closed stores are never reopened. Re-onboarding with the partner's

        // real contacts issues a fresh code on the same dtr login: free the old

        // identity's email so the new user.user can take it over, then drop the old

        // chain from the resolution map so the save proceeds as a fresh onboarding.

        try {

            com.spice.profitmandi.dao.entity.user.User oldIdentity = userUserRepository.selectById(oldStore.getId());

            String tombstone = "closed." + oldStore.getId() + "." + oldIdentity.getEmailId();

            if (tombstone.length() > 128) {

                tombstone = tombstone.substring(0, 128);

            }

            oldIdentity.setEmailId(tombstone);

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("Takeover: identity not found for closed store {}", oldStore.getId(), e);

        }

        LOGGER.info("Takeover: closed store {} ({}) — issuing new code on the same login", oldStore.getCode(), oldStore.getId());

        map.remove("retailer");

        map.remove("retailerAddress");

        map.remove("shops");

        map.remove("fofoStore");

    }

    private void createDefaultPaymentOption(int fofoId) {

        List<Integer> paymentOptionIds = fofoPartnerPaymentOptionRepository.selectPaymentOptionIdsByFofoId(fofoId);

        if (paymentOptionIds.isEmpty()) {

            PaymentOption paymentOption = null;

            try {

                paymentOption = paymentOptionRepository.selectByName(PaymentOptionType.CASH.toString());

            } catch (ProfitMandiBusinessException profitMandiBusinessException) {

                paymentOption = new PaymentOption();

                paymentOption.setName(PaymentOptionType.CASH.toString());

                paymentOptionRepository.persist(paymentOption);

            }

            FofoPartnerPaymentOption fofoPartnerPaymentOption = new FofoPartnerPaymentOption();

            fofoPartnerPaymentOption.setFofoId(fofoId);

            fofoPartnerPaymentOption.setPaymentOptionId(paymentOption.getId());

            fofoPartnerPaymentOptionRepository.persist(fofoPartnerPaymentOption);

        }

    }

    private User createUser(User user, UpdateRetailerRequest updateRetailerRequest) throws

            ProfitMandiBusinessException {

        User dtrUser = null;

        try {

            dtrUser = userRepository.selectByMobileNumber(updateRetailerRequest.getUserMobileNumber());

        } catch (ProfitMandiBusinessException e) {

            //Ignore the exception

        }

        if (dtrUser != null && (user == null || user.getId() != dtrUser.getId()))

            throw new ProfitMandiBusinessException("Mobile already exist", updateRetailerRequest.getUserMobileNumber(), dtrUser.getEmailId());

        User dtrUserByEmail = null;

        try {

            dtrUserByEmail = userRepository.selectByEmailId(updateRetailerRequest.getUserEmailId());

        } catch (ProfitMandiBusinessException e) {

            //ignore the exception

        }

        if (user != null && dtrUserByEmail != null && user.getId() != dtrUserByEmail.getId())

            throw new ProfitMandiBusinessException("Email already exist", updateRetailerRequest.getUserEmailId(), "");

        if (user == null) {

            user = new User();

            user.setCity("");

            user.setPinCode(0);

            user.setState("");

            user.setPassword("");

            user.setMobile_verified(false);

            user.setReferral_url("");

            user.setGroup_id(1);

            user.setStatus(1);

            user.setActivated(true);

            user.setCreateTimestamp(LocalDateTime.now());

        }

        user.setActivated(updateRetailerRequest.isActive());

        user.setFirstName(updateRetailerRequest.getUserFirstName());

        user.setLastName(updateRetailerRequest.getUserLastName());

        user.setMobileNumber(updateRetailerRequest.getUserMobileNumber());

        user.setEmailId(updateRetailerRequest.getUserEmailId());

        user.setUsername(updateRetailerRequest.getUserEmailId());

        user.setUpdateTimestamp(LocalDateTime.now());

        userRepository.persist(user);

        return user;

    }

    private int createSaholicUser(User user, String retailerName) {

        com.spice.profitmandi.dao.entity.user.User saholicUser = null;

        try {

            saholicUser = userUserRepository.selectByEmailId(user.getEmailId());

        } catch (ProfitMandiBusinessException e) {

            LOGGER.info("User doesnt exist in old system");

        }

        if (saholicUser == null) {

            Cart cart = new Cart();

            cart.setCartStatus(CartStatus.ACTIVE);

            cartRepository.persist(cart);

            saholicUser = new com.spice.profitmandi.dao.entity.user.User();

            saholicUser.setEmailId(user.getEmailId());

            saholicUser.setName(retailerName);

            saholicUser.setActiveCartId(cart.getId());

            saholicUser.setCreateTimestamp(LocalDateTime.now());

            userUserRepository.persist(saholicUser);

            userAccountRepository.upsert(user.getId(), AccountType.saholic, saholicUser.getId());

            userAccountRepository.upsert(user.getId(), AccountType.cartId, saholicUser.getActiveCartId());

            LOGGER.info("created....");

        }

        return saholicUser.getId();

    }

    private com.spice.profitmandi.dao.entity.user.User createSaholicUser(

            LoginRequestResponseModel loginRequestResponseModel) {

        com.spice.profitmandi.dao.entity.user.User saholicUser = null;

        try {

            saholicUser = userUserRepository.selectByEmailId(loginRequestResponseModel.getEmail());

            saholicUser.setCreateTimestamp(LocalDateTime.now());

        } catch (ProfitMandiBusinessException e) {

            LOGGER.info("User doesnt exist in old system");

        }

        if (saholicUser == null) {

            Cart cart = new Cart();

            cart.setCartStatus(CartStatus.ACTIVE);

            cartRepository.persist(cart);

            saholicUser = new com.spice.profitmandi.dao.entity.user.User();

            saholicUser.setPassword(getHash256(loginRequestResponseModel.getPassword()));

            saholicUser.setEmailId(loginRequestResponseModel.getEmail());

            saholicUser.setName(loginRequestResponseModel.getCustomerName());

            saholicUser.setActiveCartId(cart.getId());

            saholicUser.setCreateTimestamp(LocalDateTime.now());

            loginRequestResponseModel.setPassword(null);

            userUserRepository.persist(saholicUser);

        }

        return saholicUser;

    }

    private Retailer updateRetailer(User user, Retailer retailer, UpdateRetailerRequest updateRetailerRequest) throws

            ProfitMandiBusinessException {

        if (retailer == null) {

            LOGGER.info("createSaholicUser.....");

            int saholicUserId = this.createSaholicUser(user, updateRetailerRequest.getName());

            retailer = new Retailer();

            retailer.setId(saholicUserId);

        }

        retailer.setActive(updateRetailerRequest.isActive());

        user.setActivated(updateRetailerRequest.isActive());//

        // this.createRole(user.getId(), RoleType.RETAILER);

        retailer.setName(updateRetailerRequest.getName());

        retailer.setNumber(updateRetailerRequest.getNumber());

        if (updateRetailerRequest.getNumber() == null || updateRetailerRequest.getNumber().isEmpty()) {

            retailer.setType(RetailerType.UNREGISTERED_SHOP);

        } else {

            retailer.setType(RetailerType.GSTIN);

        }

        if (updateRetailerRequest.getDocumentId() > 0) {

            if (retailer.getDocumentId() != null && retailer.getDocumentId() != updateRetailerRequest.getDocumentId()) {

                try {

                    documentRepository.deleteById(retailer.getDocumentId());

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

            retailer.setDocumentId(updateRetailerRequest.getDocumentId());

            documentRepository.markDocumentAsPersisted(updateRetailerRequest.getDocumentId());

        }

        retailerRepository.persist(retailer);

        return retailer;

    }

    private void updateSaholicUser(int retailerId, int retailerAddressId) {

        try {

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

            user.setAddressId(retailerAddressId);

            Cart cart = cartRepository.selectById(user.getActiveCartId());

            cart.setAddressId(retailerAddressId);

        } catch (ProfitMandiBusinessException e) {

        }

    }

    private Address updateRetailerAddress(Address address, CustomAddress customAddress, int retailerId) throws

            ProfitMandiBusinessException {

        if (address == null) {

            // Try to find existing address via RetailerRegisteredAddress (handles case where

            // dtr.user was deleted but retailer/address still exist in database)

            try {

                int existingAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailerId);

                address = addressRepository.selectById(existingAddressId);

            } catch (ProfitMandiBusinessException e) {

                // No existing address found for this retailer

            }

            if (address != null) {

                // Existing address found - update it

                this.updateAddress(address, customAddress);

                RetailerRegisteredAddress retailerRegisteredAddress = retailerRegisteredAddressRepository.selectByRetailerId(retailerId);

                retailerRegisteredAddress.setAddressId(address.getId());

                retailerRegisteredAddressRepository.persist(retailerRegisteredAddress);

            } else {

                // Truly new address

                address = new Address();

                address.setRetaierId(retailerId);

                this.updateAddress(address, customAddress);

                final RetailerRegisteredAddress retailerRegisteredAddress = new RetailerRegisteredAddress();

                retailerRegisteredAddress.setRetailerId(retailerId);

                retailerRegisteredAddress.setAddressId(address.getId());

                retailerRegisteredAddressRepository.persist(retailerRegisteredAddress);

            }

        } else {

            this.updateAddress(address, customAddress);

            RetailerRegisteredAddress retailerRegisteredAddress = retailerRegisteredAddressRepository.selectByRetailerId(retailerId);

            retailerRegisteredAddress.setAddressId(address.getId());

            retailerRegisteredAddressRepository.persist(retailerRegisteredAddress);

        }

        return address;

    }

    private void updateAddress(Address address, CustomAddress customAddress) throws ProfitMandiBusinessException {

        address.setName(customAddress.getName());

        address.setPhoneNumber(customAddress.getPhoneNumber());

        address.setLine1(customAddress.getLine1());

        address.setLine2(customAddress.getLine2());

        address.setCity(customAddress.getCity());

        address.setPinCode(customAddress.getPinCode());

        State state = stateRepository.selectByName(customAddress.getState());

        if (state == null) {

            throw new ProfitMandiBusinessException("State name", "Invalid State - Pls Contact Technology", "Invalid State - Pls Contact Technology");

        }

        address.setState(state.getName());

        addressRepository.persist(address);

        LOGGER.info("Address Updated" + address);

    }

    private void updateRetailerShops(List<Shop> shops, Set<CustomShop> customShops, int retailerId, Address

            sameAsRetailerAddressValue) throws ProfitMandiBusinessException {

        if (shops.isEmpty()) {

            for (CustomShop customShop : customShops) {

                Shop shop = new Shop();

                this.createOrUpdateShop(shop, customShop, retailerId, sameAsRetailerAddressValue);

                shops.add(shop);

            }

        } else {

            for (Shop shop : shops) {

                for (CustomShop customShop : customShops) {

                    if (shop.getId() == customShop.getShopId()) {

                        this.createOrUpdateShop(shop, customShop, retailerId, sameAsRetailerAddressValue);

                    }

                }

            }

            for (CustomShop customShop : customShops) {

                if (customShop.getShopId() == 0) {

                    Shop shop = new Shop();

                    this.createOrUpdateShop(shop, customShop, retailerId, sameAsRetailerAddressValue);

                    shops.add(shop);

                }

            }

        }

    }

    private void createOrUpdateShop(Shop shop, CustomShop customShop, int retailerId, Address

            sameAsRetailerAddressValue) throws ProfitMandiBusinessException {

        shop.setRetailerId(retailerId);

        shop.setName(customShop.getName());

        if (customShop.getDocumentId() > 0) {

            if (shop.getDocumentId() != null && shop.getDocumentId() != customShop.getDocumentId()) {

                try {

                    documentRepository.deleteById(shop.getDocumentId());

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

            shop.setDocumentId(customShop.getDocumentId());

            documentRepository.markDocumentAsPersisted(customShop.getDocumentId());

        }

        if (shop.getAddressId() == null) {

            Address address = null;

            if (customShop.isSameAsRetailerAddress()) {

                address = sameAsRetailerAddressValue;

            } else {

                // shop.setDocumentId(customShop.getDocumentId());

                address = new Address();

                this.updateAddress(address, customShop.getAddress());

            }

            shop.setAddressId(address.getId());

            shop.setAddress(address);

            shopRepository.persist(shop);

            ShopAddress shopAddress = null;

            try {

                shopAddress = shopAddressRepository.selectByShopId(shop.getId());

                shopAddress.setAddressId(address.getId());

            } catch (ProfitMandiBusinessException profitMandiBusinessException) {

                shopAddress = new ShopAddress();

                shopAddress.setAddressId(address.getId());

                shopAddress.setShopId(shop.getId());

            }

            shopAddressRepository.persist(shopAddress);

        } else {

            Address address = null;

            try {

                address = addressRepository.selectById(shop.getAddressId());

                CustomAddress customAddress = customShop.getAddress();

                if (!(address.getName().equals(customAddress.getName()) && address.getLine1().equals(customAddress.getLine1()) && address.getLine2().equals(customAddress.getLine2()) && address.getCity().equals(customAddress.getCity()) && address.getPinCode().equals(customAddress.getPinCode()) && address.getState().equals(customAddress.getState()))) {

                    address = new Address();

                    ShopAddress shopAddress = shopAddressRepository.selectByShopId(shop.getId());

                    this.updateAddress(address, customAddress);

                    shopAddress.setAddressId(address.getId());

                    shopAddressRepository.persist(shopAddress);

                    shop.setAddress(address);

                    shopRepository.persist(shop);

                }

            } catch (Exception e) {

                if (customShop.isSameAsRetailerAddress()) {

                    address = sameAsRetailerAddressValue;

                } else {

                    // shop.setDocumentId(customShop.getDocumentId());

                    address = new Address();

                    this.updateAddress(address, customShop.getAddress());

                }

                shop.setAddressId(address.getId());

                shop.setAddress(address);

                shopRepository.persist(shop);

                ShopAddress shopAddress = null;

                try {

                    shopAddress = shopAddressRepository.selectByShopId(shop.getId());

                    shopAddress.setAddressId(address.getId());

                } catch (ProfitMandiBusinessException profitMandiBusinessException) {

                    shopAddress = new ShopAddress();

                    shopAddress.setAddressId(address.getId());

                    shopAddress.setShopId(shop.getId());

                }

                shopAddressRepository.persist(shopAddress);

            }

        }

    }

    private void addAddress(List<Shop> shops) throws ProfitMandiBusinessException {

        Set<Integer> shopIds = this.toShopIds(shops);

        if (shopIds.isEmpty()) {

            return;

        }

        List<ShopAddress> shopAddresses = shopAddressRepository.selectByShopIds(shopIds);

        Map<Integer, Address> addressIdAddressMap = this.toAddressIdAddressMap(shopAddresses);

        for (Shop shop : shops) {

            shop.setAddress(addressIdAddressMap.get(shop.getAddressId()));

        }

    }

    private Map<Integer, Address> toAddressIdAddressMap(List<ShopAddress> shopAddresses) throws ProfitMandiBusinessException {

        Map<Integer, Address> addressIdAddressMap = new HashMap<>();

        List<Integer> addressIds = this.toAddressIds(shopAddresses);

        List<Address> addresses = addressRepository.selectByIds(addressIds);

        for (Address address : addresses) {

            addressIdAddressMap.put(address.getId(), address);

        }

        return addressIdAddressMap;

    }

    private List<Integer> toAddressIds(List<ShopAddress> shopAddresses) {

        return shopAddresses.stream()

                .map(ShopAddress::getAddressId)

                .collect(Collectors.toList());

    }

    private Set<Integer> toShopIds(List<Shop> shops) {

        return shops.stream()

                .map(Shop::getId)

                .collect(Collectors.toSet());

    }

    private String toString(List<UserRole> userRoles) throws ProfitMandiBusinessException {

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

        for (UserRole userRole : userRoles) {

            roleIds.add(userRole.getRoleId());

        }

        List<Role> roles = roleRepository.selectByIds(roleIds);

        Function<Role, String> roleToNameFunction = role -> String.valueOf(role.getName());

        Set<String> userRoleStrings = roles.stream().map(roleToNameFunction).collect(Collectors.toSet());

        return String.join(", ", userRoleStrings);

    }

    // A store's warehouse is where its orders are allocated, so only an ACTIVE one may be newly assigned; a store

    // already on a suspended warehouse can still be saved without moving it.

    private void requireAssignableWarehouse(int warehouseId, Integer previousWarehouseId)

            throws ProfitMandiBusinessException {

        if (previousWarehouseId != null && previousWarehouseId == warehouseId) {

            return;

        }

        WarehouseStatus status = billingWarehouseService.getStatus(warehouseId);

        if (status != WarehouseStatus.ACTIVE) {

            throw new ProfitMandiBusinessException("warehouseId", warehouseId, "Warehouse "

                    + billingWarehouseService.getName(warehouseId, String.valueOf(warehouseId)) + " is "

                    + (status == null ? "not a billing warehouse" : status.name().toLowerCase())

                    + " - partner stores can only be assigned to an active warehouse");

        }

    }

    private FofoStore createFofoStoreCodeByRetailerId(int retailerId, String districtName, String

            stateName, UpdateRetailerRequest updateRetailerRequest) throws ProfitMandiBusinessException {

        FofoStore fofoStore = null;

        try {

            fofoStore = fofoStoreRepository.selectByRetailerId(retailerId);

            fofoStore.setActivationType(ActivationType.ACTIVE);

        } catch (ProfitMandiBusinessException profitMandiBusinessException) {

        }

        if (fofoStore != null) {

            int previousWarehouseId = fofoStore.getWarehouseId();

            FofoType previousFofoType = fofoStore.getFofoType();

            fofoStore.setCounterSize(updateRetailerRequest.getCountersize());

            fofoStore.setAstId(updateRetailerRequest.getAstId());

            fofoStore.setMinimumInvestment(updateRetailerRequest.getMinInvestment());

            this.requireAssignableWarehouse(updateRetailerRequest.getWarehouseId(), previousWarehouseId);

            fofoStore.setWarehouseId(updateRetailerRequest.getWarehouseId());

            fofoStore.setCounterPotential(updateRetailerRequest.getCounterPotential());

            fofoStore.setFofoType(updateRetailerRequest.getFofoType());

            fofoStore.setGstNumber(updateRetailerRequest.getGstNumber());

            // An INTERNAL store bills movements to its warehouse's address, so moving it (or making it internal)

            // must carry the new warehouse's address across; the retailer address saved above is replaced.

            if (fofoStore.getFofoType() == FofoType.INTERNAL

                    && (previousWarehouseId != fofoStore.getWarehouseId() || previousFofoType != FofoType.INTERNAL)) {

                sellerService.syncInternalStoreAddress(fofoStore);

            }

            // The store already exists but its code may never have reached the onboarding

            // panel (e.g. verification approved while another dtr user held the partner's

            // mobile, so the approval-time linker resolved the wrong account). Re-saving the

            // form previously did nothing for the panel because linking only ran on NEW

            // store creation. Link here too; the method is a no-op if the panel already

            // has a code.

            this.linkStoreCodeToOnboardingPanel(fofoStore, updateRetailerRequest.getUserMobileNumber(), retailerId);

        } else {

            int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailerId);

            Address retailerAddress = addressRepository.selectById(retailerAddressId);

            // StateInfo stateInfo = null;

            State stateInfo = null;

            try {

                stateInfo = stateRepository.selectByName(retailerAddress.getState());

                // stateInfo = Utils.getStateInfo(retailerAddress.getState());

            } catch (Exception e) {

                // TODO Auto-generated catch block

                e.printStackTrace();