Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.eclipsesource.json.Json;

import com.eclipsesource.json.JsonArray;

import com.eclipsesource.json.JsonObject;

import com.eclipsesource.json.JsonValue;

import com.google.gson.Gson;

import com.google.gson.reflect.TypeToken;

import com.mongodb.BasicDBObject;

import com.mongodb.DBObject;

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

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

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

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

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

import com.spice.profitmandi.common.solr.SolrService;

import com.spice.profitmandi.common.web.client.RestClient;

import com.spice.profitmandi.common.web.util.ResponseSender;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.onboarding.BrandCommitRepository;

import com.spice.profitmandi.service.authentication.RoleManager;

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

import com.spice.profitmandi.service.integrations.pinelabs.PinelabsAffordabilityService;

import com.spice.profitmandi.service.integrations.pinelabs.PinelabsDeviceService;

import com.spice.profitmandi.service.integrations.pinelabs.PinelabsOfferCacheService;

import com.spice.profitmandi.service.integrations.pinelabs.dto.DownpaymentDetailsRequest;

import com.spice.profitmandi.service.integrations.pinelabs.dto.DownpaymentDetailsResponse;

import com.spice.profitmandi.service.integrations.pinelabs.dto.ImeiValidationResponse;

import com.spice.profitmandi.service.integrations.pinelabs.dto.OfferDiscoveryRequest;

import com.spice.profitmandi.service.integrations.pinelabs.dto.OfferDiscoveryResponse;

import com.spice.profitmandi.service.integrations.pinelabs.dto.OfferValidateRequest;

import com.spice.profitmandi.service.integrations.pinelabs.dto.OfferValidateResponse;

import com.spice.profitmandi.service.integrations.pinelabs.dto.PineLablsCreateOfferRequest;

import com.spice.profitmandi.service.integrations.pinelabs.dto.CreateOfferResponse;

import com.spice.profitmandi.service.integrations.pinelabs.dto.Tenure;

import com.spice.profitmandi.service.inventory.*;

import com.spice.profitmandi.service.pricecircular.PriceCircularItemModelNew;

import com.spice.profitmandi.service.pricecircular.PriceCircularModel;

import com.spice.profitmandi.service.pricecircular.PriceCircularService;

import com.spice.profitmandi.service.pricing.PricingService;

import com.spice.profitmandi.service.scheme.SchemeService;

import com.spice.profitmandi.web.res.DealBrands;

import com.spice.profitmandi.web.res.DealObjectResponse;

import com.spice.profitmandi.web.res.DealsResponse;

import io.swagger.annotations.ApiImplicitParam;

import io.swagger.annotations.ApiImplicitParams;

import io.swagger.annotations.ApiOperation;

import org.apache.commons.lang3.StringUtils;

import org.apache.http.conn.HttpHostConnectException;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.json.JSONArray;

import org.json.JSONObject;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

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

import javax.servlet.http.HttpServletRequest;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.*;

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.CompletionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class DealsController {

    private static final Logger logger = LogManager.getLogger(DealsController.class);

    private static final List<Integer> TAG_IDS = Arrays.asList(4);

    @Value("${python.api.host}")

    private String host;

    @Value("${new.solr.url}")

    private String solrUrl;

    @Value("${python.api.port}")

    private int port;

    @Autowired

    RestClient restClient;

    @Autowired

    SolrService solrService;

    @Autowired

    com.spice.profitmandi.web.services.SolrService webSolrService;

    @Autowired

    com.spice.profitmandi.web.services.HotDealEnrichmentService hotDealEnrichmentService;

    @Autowired

    private com.spice.profitmandi.web.services.PartnerSolrClient partnerSolrClient;

    @Autowired

    PinelabsAffordabilityService pinelabsAffordabilityService;

    @Autowired

    PinelabsDeviceService pinelabsDeviceService;

    // This is now unused as we are not supporting multiple companies.

    @Value("${gadgetCops.invoice.cc}")

    private String[] ccGadgetCopInvoiceTo;

    @Autowired

    private PricingService pricingService;

    @Autowired

    private CategoryRepository categoryRepository;

    @Autowired

    private SchemeService schemeService;

    @Autowired

    private SaholicInventoryService saholicInventoryService;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private ItemBucketService itemBucketService;

    @Autowired

    private UserAccountRepository userAccountRepository;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private ResponseSender<?> responseSender;

    @Autowired

    private TagListingRepository tagListingRepository;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private PriceCircularService priceCircularService;

    @Autowired

    private RoleManager roleManagerService;

    @Autowired

    private SuggestedPoDetailRepository suggestedPoDetailRepository;

    @Autowired

    private SuggestedPoRepository suggestedPoRepository;

    @Autowired

    private WebOfferRepository webOfferRepository;

    @Autowired

    private ComboModelRepository comboModelRepository;

    @Autowired

    private PinelabsOfferCacheService pinelabsOfferCacheService;

    @Autowired

    private BrandsService brandsService;

    @Autowired

    private BrandsRepository brandsRepository;

    @Autowired

    private WebListingRepository webListingRepository;

    @Autowired

    private WebProductListingRepository webProductListingRepository;

    @Autowired

    private CatalogFavouriteRepository catalogFavouriteRepository;

    @Autowired

    PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

    @Autowired

    PartnerDealerRepository partnerDealerRepository;

    @Autowired

    BrandCommitRepository brandCommitRepository;

    @Autowired

    CatalogRepository catalogRepository;

    @Autowired

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    List<String> filterableParams = Arrays.asList("brand");

    @RequestMapping(value = "/fofo/buckets", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getBuckets(HttpServletRequest request) throws ProfitMandiBusinessException {

        logger.info("Request " + request.getParameterMap());

        return responseSender.ok(itemBucketService.getBuckets(Optional.of(true)));

    }

    @RequestMapping(value = "/fofo/bucket", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getBucketDetails(HttpServletRequest request, @RequestParam int id) throws ProfitMandiBusinessException {

        List<ItemQuantityPojo> iqPojo = itemBucketService.getBucketDetails(id);

        Map<Integer, Integer> itemIdsQtyMap = iqPojo.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getQuantity()));

        Set<Integer> catalogIds = itemRepository.selectByIds(itemIdsQtyMap.keySet()).stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet());

        Map<String, String> params = new HashMap<>();

        List<String> mandatoryQ = new ArrayList<>();

        mandatoryQ.add(

                String.format("+catalogId_i:(%s) +{!parent which=\"id:catalog*\"}", StringUtils.join(catalogIds, " ")));

        params.put("start", "0");

        params.put("rows", "100");

        params.put("q", StringUtils.join(mandatoryQ, " "));

        params.put("fl", "*, [child parentFilter=id:catalog*]");

        params.put("wt", "json");

        int fofoId = userAccountRepository.getUserCart((int) request.getAttribute("userId")).getUserId();

        JSONArray docs = partnerSolrClient.selectDocs(params, fofoId);

        List<FofoCatalogResponse> dealResponse = getCatalogSingleSkuResponse(docs, itemIdsQtyMap);

        Bucket bucket = itemBucketService.getBuckets(Optional.of(true)).stream().filter(x -> x.getId() == id).collect(Collectors.toList()).get(0);

        bucket.setFofoCatalogResponses(dealResponse);

        return responseSender.ok(bucket);

    }

    @RequestMapping(value = "/fofo/suggestedPo", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getSuggestedPo(HttpServletRequest request, @RequestParam int id) throws ProfitMandiBusinessException {

        int userId = (int) request.getAttribute("userId");

        UserCart uc = userAccountRepository.getUserCart(userId);

        int fofoId = uc.getUserId();

        SuggestedPo  suggestedPo = suggestedPoRepository.selectAllOpenPoByFofoId(fofoId).get(0);

        if(suggestedPo == null){

            throw new ProfitMandiBusinessException("", "", "Open po is not available in list");

        }

        List<SuggestedPoDetail> mpd = suggestedPoDetailRepository.selectByPoId(suggestedPo.getId());

        Map<Integer, Integer> itemIdsQtyMap = mpd.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getQuantity()));

        Set<Integer> catalogIds = itemRepository.selectByIds(itemIdsQtyMap.keySet()).stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet());

                Map<String, String> params = new HashMap<>();

        List<String> mandatoryQ = new ArrayList<>();

        mandatoryQ.add(

                String.format("+catalogId_i:(%s) +{!parent which=\"id:catalog*\"}", StringUtils.join(catalogIds, " ")));

        params.put("start", "0");

        params.put("rows", "100");

        params.put("q", StringUtils.join(mandatoryQ, " "));

        params.put("fl", "*, [child parentFilter=id:catalog*]");

        params.put("wt", "json");

        JSONArray docs = partnerSolrClient.selectDocs(params, fofoId);

        List<FofoCatalogResponse> dealResponse = getCatalogSingleSkuResponse(docs, itemIdsQtyMap);

        return responseSender.ok(dealResponse);

    }

    @RequestMapping(value = "/suggestedPo/status", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    @ApiOperation(value = "")

    public ResponseEntity<?> changeSuggestedPoStatus(HttpServletRequest request, @RequestParam int id) throws ProfitMandiBusinessException {

        SuggestedPo suggestedPo = suggestedPoRepository.selectById(id);

        suggestedPo.setStatus("closed");

        //suggestedPo.setStatus(SuggestedPoStatus.valueOf("closed"));

        return responseSender.ok(true);

    }

    @RequestMapping(value = "/fofo/fovourites", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getFavourites(HttpServletRequest request) throws Exception {

        int userId = (int) request.getAttribute("userId");

        UserCart uc = userAccountRepository.getUserCart(userId);

        int fofoId = uc.getUserId();

        List<FofoCatalogResponse> dealResponse = new ArrayList<>();

        Set<Integer> catalogIds = catalogFavouriteRepository.selectBypartnerId(fofoId).stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());

        if (!catalogIds.isEmpty()) {

            dealResponse = webSolrService.dealResponse(catalogIds, fofoId);

            hotDealEnrichmentService.enrich(dealResponse);

        }

        return responseSender.ok(dealResponse);

    }

    @RequestMapping(value = "/favourites/manage", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    @ApiOperation(value = "")

    public ResponseEntity<?> mangeFavourites(HttpServletRequest request, @RequestParam int catalogId) throws ProfitMandiBusinessException {

        int userId = (int) request.getAttribute("userId");

        UserCart uc = userAccountRepository.getUserCart(userId);

        int fofoId = uc.getUserId();

        CatalogFavourite catalogFavourite = catalogFavouriteRepository.selectBypartnerAndCatalogId(fofoId, catalogId);

        if (catalogFavourite == null) {

            catalogFavourite = new CatalogFavourite();

            catalogFavourite.setCatalogId(catalogId);

            catalogFavourite.setFofoId(fofoId);

            catalogFavourite.setCreatedTimestamp(LocalDateTime.now());

            catalogFavouriteRepository.persist(catalogFavourite);

        } else {

            catalogFavouriteRepository.deleteByPartnerAndCatalogId(fofoId, catalogId);

        }

        return responseSender.ok(true);

    }

    private String getCommaSeparateTags(int userId) throws ProfitMandiBusinessException {

        UserCart uc = userAccountRepository.getUserCart(userId);

        List<Integer> tagIds = pricingService.getTagsIdsByRetailerId(uc.getUserId());

        List<String> strTagIds = new ArrayList<>();

        for (Integer tagId : tagIds) {

            strTagIds.add(String.valueOf(tagId));

        }

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

    }

    @RequestMapping(value = "/fofo/similar-models/{modelId}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> similarModels(HttpServletRequest httpServletRequest, @PathVariable int modelId) throws Throwable {

        UserInfo userInfo = (UserInfo) httpServletRequest.getAttribute("userInfo");

        //FofoStore fs = fofoStoreRepository.selectByRetailerId(userInfo.getRetailerId());

        JSONObject jsonObject = solrService.getContentByCatalogIds(Arrays.asList(modelId)).get(modelId);

        JSONArray similarModelsArray = jsonObject.getJSONArray("similarModels_ii");

        List<Integer> similarCatalogIds = new ArrayList<>();

        for (int j = 0; j < similarModelsArray.length(); j++) {

            similarCatalogIds.add(similarModelsArray.getInt(j));

        }

        Map<String, String> params = new HashMap<>();

        List<String> mandatoryQ = new ArrayList<>();

        mandatoryQ.add(String.format(

                "+{!parent which=\"catalogId_i:(" + StringUtils.join(similarCatalogIds, " ") + ")\"} AND active_b:true AND show_default_b:true"));

        params.put("q", StringUtils.join(mandatoryQ, " "));

        params.put("fl", "*, [child parentFilter=id:catalog* childFilter=active_b:true ]");

        params.put("wt", "json");

        params.put("rows", similarCatalogIds.size() + "");

        JSONArray docs = partnerSolrClient.selectDocs(params, userInfo.getRetailerId());

        return responseSender.ok(this.getCatalogResponse(docs, userInfo.getRetailerId()).stream().filter(x -> x.isInStock()).collect(Collectors.toList()));

    }

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    /**

     * Categories present among today's active hot deals (Solr facet over the curated

     * models), for the hot-deals page filter chips: [{"id": 3, "count": 4}, ...].

     */

    @RequestMapping(value = "/fofo/hotDeals/categories", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getHotDealCategories(HttpServletRequest request) throws Exception {

        List<Map<String, Object>> categories = new ArrayList<>();

        for (Map.Entry<Integer, Integer> entry

                : solrService.getHotDealCategoryFacet(hotDealCatalogIds()).entrySet()) {

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

            category.put("id", entry.getKey());

            category.put("count", entry.getValue());

            categories.add(category);

        }

        return responseSender.ok(categories);

    }

    /**

     * Brands present among the hot-deal models, for the hot-deals page brand chips:

     * [{"brand": "Samsung", "count": 4}, ...].

     *

     * <p>These are the ORIGINAL brands, held in Solr's oem_brand_s. Every hot-deal doc

     * reads "Hot Deal" in brand_ss, so that field would facet into one useless bucket.

     * The chip row is labelled simply "Brand" in both apps.

     */

    @RequestMapping(value = "/fofo/hotDeals/brands", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getHotDealBrands(HttpServletRequest request) throws Exception {

        List<Map<String, Object>> brands = new ArrayList<>();

        for (Map.Entry<String, Integer> entry

                : solrService.getHotDealBrandFacet(hotDealCatalogIds()).entrySet()) {

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

            brand.put("brand", entry.getKey());

            brand.put("count", entry.getValue());

            brands.add(brand);

        }

        return responseSender.ok(brands);

    }

    /**

     * The hot-deal catalog set: membership is brand membership, with no date window.

     * Shared by the two facet endpoints and the hotDeal listing branch.

     */

    private List<Integer> hotDealCatalogIds() {

        return new ArrayList<>(

                catalogRepository.selectCatalogIdsByBrand(ProfitMandiConstants.HOT_DEAL_BRAND));

    }

    @RequestMapping(value = "/fofo", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getFofo(HttpServletRequest request, @RequestParam(value = "categoryId", required = false, defaultValue = "3") String categoryId, @RequestParam(value = "offset") int offset,

         @RequestParam(value = "limit") int limit, @RequestParam(value = "sort", required = false) String sort, @RequestParam(value = "brand", required = false) String brand, @RequestParam(value = "subCategoryId", required = false, defaultValue = "0") int subCategoryId, @RequestParam(value = "q", required = false) String queryTerm, @RequestParam(value = "hotDeal", required = false) boolean hotDeal, @RequestParam(value = "endPoint", required = false) String endPoint,@RequestParam(value = "group", required = false) boolean group) throws Throwable {

        // Band-aid for URL '+' decode issue on brand names.

        // Front-end sends `brand=Ai+`. Depending on where along the request path the

        // '+' is decoded, the servlet may receive "Ai " (trailing space) or just "Ai"

        // (plus dropped entirely by the SPA before the request goes out).

        // Strategy: if the received value doesn't exist as a real brand in catalog.brand,

        // try appending '+' and see if THAT exists — if so, use it. Zero regression risk

        // for real brand names because the fallback only fires on unknown values.

        logger.info("getFofo received brand='{}' (len={})",

                brand, brand == null ? -1 : brand.length());

        if (brand != null && !brand.trim().isEmpty()) {

            String probe = brand.replaceAll("\\s+$", "");

            try {

                if (brandsRepository.selectByBrand(brand) == null

                        && (probe.equals(brand) || brandsRepository.selectByBrand(probe) == null)) {

                    String withPlus = probe + "+";

                    if (brandsRepository.selectByBrand(withPlus) != null) {

                        logger.info("getFofo brand fallback: '{}' -> '{}'", brand, withPlus);

                        brand = withPlus;

                    }

                }

            } catch (Exception e) {

                logger.warn("getFofo brand fallback lookup failed for '{}': {}", brand, e.getMessage());

            }

        }

        List<FofoCatalogResponse> dealResponse;

        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

        FofoStore fs = fofoStoreRepository.selectByRetailerId(userInfo.getRetailerId());

        sort = "w" + fs.getWarehouseId() + "_i desc";

        logger.info("endPoint {}", endPoint);

        logger.info("group Column {}", group);

        if (endPoint != null && !endPoint.trim().isEmpty()) {

            WebListing webListing = webListingRepository.selectByUrl(endPoint);

            dealResponse = this.getDealResponses(userInfo, fs, webListing, offset, limit);

        } else if (hotDeal) {

            // Hot deals are the SKUs carrying the Hot Deal brand. Solr's hot_deal_b derives

            // from the same brand, but the set is resolved here so the listing does not

            // depend on the last re-index.

            List<Integer> hotDealCatalogIds = hotDealCatalogIds();

            if (hotDealCatalogIds.isEmpty()) {

                dealResponse = new ArrayList<>();

            } else {

                // Cross-category by default; a category chip on the page sends categoryId

                // explicitly, and only then does it narrow the hot-deal listing

                String explicitCategory = request.getParameter("categoryId") != null ? categoryId : null;

                dealResponse = this.getCatalogResponse(

                        solrService.getSolrDocs(queryTerm, explicitCategory, offset, limit, sort, brand, subCategoryId, false, group, true,

                                brandsService.restrictedBrands(userInfo.getRetailerId()), hotDealCatalogIds), userInfo.getRetailerId());

            }

        } else {

            dealResponse = this.getCatalogResponse(

                    solrService.getSolrDocs(queryTerm, categoryId, offset, limit, sort, brand, subCategoryId, hotDeal, group, true,

                            brandsService.restrictedBrands(userInfo.getRetailerId())), userInfo.getRetailerId());

        }

        hotDealEnrichmentService.enrich(dealResponse);

        Map<Integer, List<Integer>> similarModelMap = dealResponse.stream().filter(x -> x.getSimilarModelIds() != null && x.getSimilarModelIds().size() > 0)

                .collect(Collectors.toMap(x -> x.getCatalogId(), x -> x.getSimilarModelIds()));

        Set<Integer> similarModelIds = similarModelMap.values().stream().flatMap(x -> x.stream()).collect(Collectors.toSet());

        logger.info("similarModelIds - {}", similarModelIds);

        if (similarModelIds.size() > 0) {

            Map<Integer, FofoCatalogResponse> similarCatalogResponsesMap = this.getSimpleDocs(fs, similarModelIds).stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));

            logger.info("Similar Catalog ResponseMap - {}", similarCatalogResponsesMap.keySet());

            for (FofoCatalogResponse deal : dealResponse) {

                if (similarModelMap.containsKey(deal.getCatalogId())) {

                    List<Integer> similarCatalogIds = similarModelMap.get(deal.getCatalogId());

                    logger.info("Similar Catalog Ids - {}", similarCatalogIds);

                    List<FofoCatalogResponse> similarModels = similarCatalogIds.stream().filter(x -> similarCatalogResponsesMap.containsKey(x)).map(x -> similarCatalogResponsesMap.get(x)).collect(Collectors.toList());

                    deal.setSimilarModels(similarModels);

                }

            }

        }

        return responseSender.ok(dealResponse);

    }

    private List<FofoCatalogResponse> getSimpleDocs(FofoStore fofoStore, Set<Integer> catalogIds) throws Exception {

        List<FofoCatalogResponse> fofoCatalogResponses = new ArrayList<>();

        Map<String, String> params = new HashMap<>();

        List<String> mandatoryQ = new ArrayList<>();

        mandatoryQ.add(String.format(

                "+{!parent which=\"catalogId_i:(" + StringUtils.join(catalogIds, " ") + ")\"} AND active_b:true AND show_default_b:true"));

        params.put("q", StringUtils.join(mandatoryQ, " "));

        params.put("fl", "*, [child parentFilter=id:catalog* childFilter=active_b:true ]");

        params.put("wt", "json");

        params.put("rows", catalogIds.size() + "");

        JSONArray docs = partnerSolrClient.selectDocs(params, fofoStore.getId());

        int warehouseId = fofoStore.getWarehouseId();

        Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = saholicInventoryService.getSaholicPOItems().get(warehouseId);

        // Pre-fetch all itemIds for batch CIS query

        List<Integer> allItemIds = new ArrayList<>();

        for (int i = 0; i < docs.length(); i++) {

            JSONObject doc = docs.getJSONObject(i);

            if (doc.has("_childDocuments_")) {

                for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {

                    allItemIds.add(doc.getJSONArray("_childDocuments_").getJSONObject(j).getInt("itemId_i"));

                }

            }

        }

        // Batch fetch CIS data

        Map<Integer, List<SaholicCISTable>> cisDataByItemId = saholicCISTableRepository

                .selectByItemWarehouse(allItemIds, warehouseId).stream()

                .collect(Collectors.groupingBy(SaholicCISTable::getItemId));

        for (int i = 0; i < docs.length(); i++) {

            JSONObject doc = docs.getJSONObject(i);

            FofoCatalogResponse fofoCatalogResponse = this.toFofoCatalogResponse(doc);

            if (doc.has("_childDocuments_")) {

                String modelColorClass = "grey";

                FofoAvailabilityInfo fdiAnyColour = null;

                // Iterating itemIds

                for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {

                    JSONObject childItem = doc.getJSONArray("_childDocuments_").getJSONObject(j);

                    int itemId = childItem.getInt("itemId_i");

                    List<SaholicCISTable> currentAvailability = cisDataByItemId.getOrDefault(itemId, new ArrayList<>());

                    List<SaholicPOItem> poItemAvailability = null;

                    if (poItemAvailabilityMap != null) {

                        poItemAvailability = poItemAvailabilityMap.get(itemId);

                    }

                    for (SaholicCISTable saholicCISTable : currentAvailability) {

                        saholicCISTable.setWarehouseName(

                                ProfitMandiConstants.WAREHOUSE_MAP.get(saholicCISTable.getWarehouseFrom()));

                    }

                    String poColor = "grey";

                    boolean active = false;

                    if (currentAvailability != null && currentAvailability.stream().collect(Collectors.summingInt(SaholicCISTable::getNetAvailability)) > 0) {

                        poColor = "green";

                        modelColorClass = "green";

                    } else if (poItemAvailability != null && poItemAvailability.stream().collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty)) > 0) {

                        if (currentAvailability != null && poItemAvailability.stream().collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty)) + currentAvailability.stream().collect(Collectors.summingInt(SaholicCISTable::getNetAvailability)) <= 0) {

                            poColor = "grey";

                        } else {

                            poColor = "yellow";

                            if (!modelColorClass.equals("green")) {

                                modelColorClass = poColor;

                            }

                        }

                    }

                }

                fofoCatalogResponse.setInStock(!modelColorClass.equals("grey"));

            }

            fofoCatalogResponses.add(fofoCatalogResponse);

        }

        return fofoCatalogResponses;

    }

    private FofoCatalogResponse toFofoCatalogResponse(JSONObject doc) {

        FofoCatalogResponse fofoCatalogResponse = new FofoCatalogResponse();

        fofoCatalogResponse.setCatalogId(doc.getInt("catalogId_i"));

        fofoCatalogResponse.setImageUrl(doc.getString("imageUrl_s"));

        fofoCatalogResponse.setTitle(doc.getString("title_s"));

        fofoCatalogResponse.setMop(doc.getFloat("mop_f"));

        fofoCatalogResponse.setDp(doc.getFloat("dp_f"));

        fofoCatalogResponse.setBrand(doc.getJSONArray("brand_ss").getString(0));

        return fofoCatalogResponse;

    }

    @RequestMapping(value = "/online-deals", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    @ApiOperation(value = "Get online deals")

    public ResponseEntity<?> getOnlineDeals(HttpServletRequest request, @RequestParam(value = "categoryId") String

            categoryId, @RequestParam(value = "offset") String offset, @RequestParam(value = "limit") String

                                                    limit, @RequestParam(value = "sort", required = false) String

                                                    sort, @RequestParam(value = "direction", required = false) String

                                                    direction, @RequestParam(value = "filterData", required = false) String filterData) throws Throwable {

        logger.info("Request " + request.getParameterMap());

        String response = null;

        int userId = (int) request.getAttribute("userId");

        String uri = "/deals/" + userId;

                Map<String, String> params = new HashMap<>();

        params.put("offset", offset);

        params.put("limit", limit);

        params.put("categoryId", categoryId);

        params.put("direction", direction);

        params.put("sort", sort);

        params.put("source", "online");

        params.put("filterData", filterData);

        /*

         * if (userInfo.getRoleNames().contains(RoleType.FOFO.toString())) {

         * params.put("tag_ids", getCommaSeparateTags(userId)); }

         */

        List<Object> responseObject = new ArrayList<>();

        try {

            response = restClient.get(SchemeType.HTTP, host, port, uri, params);

        } catch (HttpHostConnectException e) {

            throw new ProfitMandiBusinessException("", "", "Could not connect to host");

        }

        JsonArray result_json = Json.parse(response).asArray();

        for (JsonValue j : result_json) {

            // logger.info("res " + j.asArray());

            List<Object> innerObject = new ArrayList<>();

            for (JsonValue jsonObject : j.asArray()) {

                innerObject.add(toDealObject(jsonObject.asObject()));

            }

            if (innerObject.size() > 0) {

                responseObject.add(innerObject);

            }

        }

        return responseSender.ok(responseObject);

    }

    private Object toDealObject(JsonObject jsonObject) {

        if (jsonObject.get("dealObject") != null && jsonObject.get("dealObject").asInt() == 1) {

            return new Gson().fromJson(jsonObject.toString(), DealObjectResponse.class);

        }

        return new Gson().fromJson(jsonObject.toString(), DealsResponse.class);

    }

    @RequestMapping(value = ProfitMandiConstants.URL_BRANDS, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    @ApiOperation(value = "Get brand list and count for category")

    public ResponseEntity<?> getBrands(HttpServletRequest request, @RequestParam(value = "category_id") String

            category_id) throws ProfitMandiBusinessException {

        logger.info("Request " + request.getParameterMap());

        String response = null;

        // TODO: move to properties

        String uri = ProfitMandiConstants.URL_BRANDS;

                Map<String, String> params = new HashMap<>();

        params.put("category_id", category_id);

        List<DealBrands> dealBrandsResponse = null;

        try {

            response = restClient.get(SchemeType.HTTP, host, port, uri, params);

        } catch (HttpHostConnectException e) {

            throw new ProfitMandiBusinessException("", "", "Could not connect to host");

        }

        dealBrandsResponse = new Gson().fromJson(response, new TypeToken<List<DealBrands>>() {

        }.getType());

        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

        List<String> restrictedBrands = brandsService.restrictedBrands(userInfo.getRetailerId());

        dealBrandsResponse = dealBrandsResponse.stream().filter(x -> !restrictedBrands.contains(x.getBrand()))

                .collect(Collectors.toList());

        return responseSender.ok(dealBrandsResponse);

    }

    @RequestMapping(value = ProfitMandiConstants.URL_UNIT_DEAL, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    @ApiOperation(value = "Get unit deal object")

    public ResponseEntity<?> getUnitDeal(HttpServletRequest request, @PathVariable(value = "id") long id) throws

            ProfitMandiBusinessException {

        String response = null;

        // TODO: move to properties

        String uri = "getDealById/" + id;

        System.out.println("Unit deal " + uri);

                Map<String, String> params = new HashMap<>();

        DealsResponse dealsResponse = null;

        try {

            response = restClient.get(SchemeType.HTTP, host, port, uri, params);

        } catch (HttpHostConnectException e) {

            throw new ProfitMandiBusinessException("", "", "Could not connect to host");

        }

        JsonObject result_json = Json.parse(response).asObject();

        if (!result_json.isEmpty()) {

            dealsResponse = new Gson().fromJson(response, DealsResponse.class);

            Iterator<AvailabilityInfo> iter = dealsResponse.getAvailabilityInfo().iterator();

            while (iter.hasNext()) {

                AvailabilityInfo ai = iter.next();

                if (ai.getAvailability() <= 0)

                    iter.remove();

            }

        }

        return responseSender.ok(dealsResponse);

    }

    @RequestMapping(value = "/partnerdeals/{id}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    @ApiOperation(value = "Get unit deal object")

    public ResponseEntity<?> getUnitFocoDeal(HttpServletRequest request, @PathVariable(value = "id") long id) throws

            Exception {

        List<FofoCatalogResponse> dealResponse = new ArrayList<>();

        List<Integer> tagIds = Arrays.asList(4);

        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

        if (roleManagerService.isPartner(userInfo.getRoleIds())) {

            String categoryId = "(3 OR 6)";

            UserCart uc = userAccountRepository.getUserCart(userInfo.getUserId());

                        Map<String, String> params = new HashMap<>();

            List<String> mandatoryQ = new ArrayList<>();

            String catalogString = "catalog" + id;

            mandatoryQ.add(String.format("+(categoryId_i:%s) +(id:%s) +{!parent which=\"id:%s\"} tagId_i:(%s)", categoryId, catalogString, catalogString, StringUtils.join(tagIds, " ")));

            params.put("q", StringUtils.join(mandatoryQ, " "));

            params.put("fl", "*, [child parentFilter=id:catalog*]");

            params.put("sort", "rank_i asc, create_s desc");

            params.put("wt", "json");

            JSONArray docs = partnerSolrClient.selectDocs(params, userInfo.getRetailerId());

            dealResponse = getCatalogResponse(docs, userInfo.getRetailerId());

        } else {

            return responseSender.badRequest(

                    new ProfitMandiBusinessException("Retailer id", userInfo.getUserId(), "NOT_FOFO_RETAILER"));

        }

        if (dealResponse.isEmpty()) {

            return responseSender.badRequest(

                    new ProfitMandiBusinessException("catalogId", id, "DEAL_NOT_FOUND"));

        }

        hotDealEnrichmentService.enrich(dealResponse);

        return responseSender.ok(dealResponse.get(0));

    }

    @RequestMapping(value = "/suggestedPoDeals", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> suggestedPoDeals(HttpServletRequest request,@RequestBody Set<Integer>catalogIds) throws Exception {

        int userId = (int) request.getAttribute("userId");

        UserCart uc = userAccountRepository.getUserCart(userId);

        int fofoId = uc.getUserId();

        List<FofoCatalogResponse> dealResponse = new ArrayList<>();

        if (!catalogIds.isEmpty()) {

            dealResponse = webSolrService.dealResponse(catalogIds, fofoId);

        }

        return responseSender.ok(dealResponse);

    }

    @RequestMapping(value = "/fofo/brands", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getBrandsToDisplay(HttpServletRequest request,

                                                @RequestParam(required = false, defaultValue = "0") int categoryId) throws Exception {

        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

        logger.info("userInfo [{}]", userInfo);

        List<BrandCatalog> brandsDisplay = brandsService.getBrandsToDisplay(categoryId);

        //List<DBObject> brandsDisplay = mongoClient.getMongoBrands(userInfo.getRetailerId(), userInfo.getEmail(), categoryId);

        return new ResponseEntity<>(brandsDisplay, HttpStatus.OK);

    }

    @RequestMapping(value = "/fofo/brandCatalog", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getBrands(HttpServletRequest request,

                                       @RequestParam(required = false, defaultValue = "0") int categoryId) throws Exception {

        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

        logger.info("userInfo [{}]", userInfo);

        List<BrandCatalog> brandsDisplay = brandsService.getBrands(userInfo.getRetailerId(), userInfo.getEmail(), categoryId);

        List<String> restrictedBrands = brandsService.restrictedBrands(userInfo.getRetailerId());

        brandsDisplay = brandsDisplay.stream().filter(x -> !restrictedBrands.contains(x.getName()))

                .collect(Collectors.toList());

        return new ResponseEntity<>(brandsDisplay, HttpStatus.OK);

    }

    @RequestMapping(value = "/fofo/accessory/all-categories", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getSubCategoriesToDisplay(HttpServletRequest request) throws Exception {

        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

        logger.info("userInfo [{}]", userInfo);

        List<DBObject> subCategoriesDisplay = this.getSubCategoriesToDisplay();

        return new ResponseEntity<>(subCategoriesDisplay, HttpStatus.OK);

    }

    private List<DBObject> getSubCategoriesToDisplay() throws Exception {

        List<DBObject> subCategories = new ArrayList<>();

                Map<String, String> params = new HashMap<>();

        params.put("q", "categoryId_i:6");

        params.put("group", "true");

        params.put("group.field", "subCategoryId_i");

        params.put("wt", "json");

        params.put("rows", "50");

        params.put("fl", "subCategoryId_i");

        String response = null;

        try {

            response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);

        } catch (HttpHostConnectException e) {

            throw new ProfitMandiBusinessException("", "", "Could not connect to host");

        }

        JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("grouped");

        JSONArray groups = solrResponseJSONObj.getJSONObject("subCategoryId_i").getJSONArray("groups");

        List<Integer> categoryIds = new ArrayList<>();

        for (int i = 0; i < groups.length(); i++) {

            JSONObject groupObject = groups.getJSONObject(i);

            int subCategoryId = groupObject.getInt("groupValue");

            int quantity = groupObject.getJSONObject("doclist").getInt("numFound");

            categoryIds.add(subCategoryId);

        }

        List<Category> categories = categoryRepository.selectByIds(categoryIds);

        AtomicInteger i = new AtomicInteger(0);

        categories.forEach(x -> {

            DBObject dbObject = new BasicDBObject();

            dbObject.put("name", x.getLabel());

            dbObject.put("subCategoryId", x.getId());

            dbObject.put("rank", i.incrementAndGet());

            dbObject.put("categoryId", 6);

            dbObject.put("url", "https://images.smartdukaan.com/uploads/campaigns/" + x.getId() + ".png");

            subCategories.add(dbObject);

        });

        return subCategories;

    }

    @RequestMapping(value = "/fofo/categories", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getFofoCategories() {

        Map<Integer, Category> categoryMap = categoryRepository.selectAll();

        List<Map<String, Object>> result = new ArrayList<>();

        for (Category category : categoryMap.values()) {

            if (category.isStatus()) {

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

                cat.put("id", category.getId());

                cat.put("label", category.getLabel());

                cat.put("displayName", category.getDisplayName());

                cat.put("parentCategoryId", category.getParentCategoryId());

                cat.put("marginOnly", category.isMarginOnly());

                result.add(cat);

            }

        }

        return responseSender.ok(result);

    }

    @RequestMapping(value = "/banners/{bannerType}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getBanners(@PathVariable String bannerType) {

        return new ResponseEntity<>(mongoClient.getBannersByType(bannerType), HttpStatus.OK);

    }

    @RequestMapping(value = "/deals/subCategories", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getSubcategoriesToDisplay() {

        return new ResponseEntity<>(mongoClient.getSubcategoriesToDisplay(), HttpStatus.OK);

    }

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    @RequestMapping(value = "/deals/skus/{skus}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getDealsBySkus(@PathVariable String skus) throws ProfitMandiBusinessException {

        StringBuffer sb = new StringBuffer("/getDealsForNotification/");

        String uri = sb.append(skus).toString();

                String response;

        try {

            response = restClient.get(SchemeType.HTTP, host, port, uri, new HashMap<>());

        } catch (HttpHostConnectException e) {

            throw new ProfitMandiBusinessException("", "", "Could not connect to host");

        }

        JsonArray result_json = Json.parse(response).asArray();

        List<Object> responseObject = new ArrayList<>();

        for (JsonValue j : result_json) {

            // logger.info("res " + j.asArray());

            List<Object> innerObject = new ArrayList<>();

            for (JsonValue jsonObject : j.asArray()) {

                innerObject.add(toDealObject(jsonObject.asObject()));

            }

            if (innerObject.size() > 0) {

                responseObject.add(innerObject);

            }

        }

        return responseSender.ok(responseObject);

    }

    // Fans out the per-listing Solr HTTP calls only; every DB access stays on the request

    // thread because the Hibernate session is thread-bound. Pool size matches the

    // RestClient per-route connection limit.

    private static final ExecutorService SOLR_EXECUTOR = Executors.newFixedThreadPool(8, r -> {

        Thread t = new Thread(r, "partner-listing-solr");

        t.setDaemon(true);

        return t;

    });

    @RequestMapping(value = "/partner/listing", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    public ResponseEntity<?> getPartnersListing(HttpServletRequest request) throws Exception {

        List<WebListing> webListings = webListingRepository.selectAllWebListingByType(Optional.of(true), WebListingSource.partner);

        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");

        int fofoId = userInfo.getRetailerId();

        FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);

        // Build every listing's Solr query on the request thread; the brand exclusion is

        // partner-scoped, so resolve it once instead of per listing.

        String exclusionFq = SolrService.brandExclusionFq(brandsService.restrictedBrands(fofoId));

        List<ListingQuery> queries = new ArrayList<>();

        for (WebListing webListing : webListings) {

            ListingQuery query = buildListingQuery(webListing, fs.getWarehouseId(), 0, 20);

            if (query.params != null && exclusionFq != null) {

                query.params.put("fq", exclusionFq);

            }

            queries.add(query);

        }

        Map<Integer, CompletableFuture<JSONArray>> futures = new HashMap<>();

        for (int i = 0; i < queries.size(); i++) {

            Map<String, String> params = queries.get(i).params;

            if (params != null) {

                futures.put(i, CompletableFuture.supplyAsync(() -> {

                    try {

                        return partnerSolrClient.selectDocsRaw(params);

                    } catch (ProfitMandiBusinessException e) {

                        throw new CompletionException(e);

                    }

                }, SOLR_EXECUTOR));

            }

        }

        Map<Integer, JSONArray> docsByListing = new HashMap<>();

        Set<Integer> allCatalogIds = new LinkedHashSet<>();

        Set<Integer> allItemIds = new LinkedHashSet<>();

        for (Map.Entry<Integer, CompletableFuture<JSONArray>> entry : futures.entrySet()) {

            JSONArray docs;

            try {

                docs = entry.getValue().join();

            } catch (CompletionException e) {

                throw e.getCause() instanceof Exception ? (Exception) e.getCause() : e;

            }

            docsByListing.put(entry.getKey(), docs);

            allCatalogIds.addAll(extractCatalogIds(docs));

            allItemIds.addAll(extractItemIds(docs));

        }

        CatalogBatchData batch = allItemIds.isEmpty() ? null

                : buildCatalogBatchData(fofoId, fs.getWarehouseId(), new ArrayList<>(allCatalogIds), new ArrayList<>(allItemIds));

        for (int i = 0; i < queries.size(); i++) {

            ListingQuery query = queries.get(i);

            JSONArray docs = docsByListing.get(i);

            List<FofoCatalogResponse> dealResponse;

            if (docs == null || batch == null) {

                dealResponse = new ArrayList<>();

            } else {

                dealResponse = buildCatalogResponses(docs, fofoId, batch);

                if (query.webProducts != null && query.webListing.getUrl().equals("new-launches")) {

                    List<Integer> webProductsFinal = query.webProducts;

                    dealResponse = dealResponse.stream().sorted(Comparator.comparing(x -> webProductsFinal.indexOf(x.getCatalogId()))).collect(Collectors.toList());

                }

            }

            query.webListing.setFofoCatalogResponses(dealResponse);

        }

        return responseSender.ok(webListings);

    }

    private List<FofoCatalogResponse> getDealResponses(UserInfo userInfo, FofoStore fs, WebListing webListing, int offset, int limit) throws Exception {

        ListingQuery query = buildListingQuery(webListing, fs.getWarehouseId(), offset, limit);

        if (query.params == null) {

            return new ArrayList<>();

        }

        JSONArray docs = partnerSolrClient.selectDocs(query.params, userInfo.getRetailerId());

        List<FofoCatalogResponse> dealResponse = getCatalogResponse(docs, userInfo.getRetailerId());