WebSVN – SmartDukaan – Diff – //trunk/profitmandi-web/src/main/java/com/spice/profitmandi/web/controller/DealsController.java

 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)
+            }
+        }
         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
-        // Pre-fetch FofoStore once (instead of N times inside getDealResponses)
+        // partner-scoped, so resolve it once instead of per listing.
-        FofoStore fs = fofoStoreRepository.selectByRetailerId(userInfo.getRetailerId());
+        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, false, 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());
+                }
+            }
-            webListing.setFofoCatalogResponses(getDealResponses(userInfo, fs, webListing, 0, 20));
+            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, false, userInfo.getRetailerId());
+        if (query.webProducts != null && webListing.getUrl().equals("new-launches")) {
+            List<Integer> webProductsFinal = query.webProducts;
+            dealResponse = dealResponse.stream().sorted(Comparator.comparing(x -> webProductsFinal.indexOf(x.getCatalogId()))).collect(Collectors.toList());
+        }
+        return dealResponse;
+    }
+    /** Solr query for one web listing; params is null when a curated listing has no ranked products. */
+    private static class ListingQuery {
+        WebListing webListing;
+        Map<String, String> params;
+        List<Integer> webProducts;
+    }
+    private ListingQuery buildListingQuery(WebListing webListing, int warehouseId, int offset, int limit) {
+        ListingQuery query = new ListingQuery();
+        query.webListing = webListing;
         Map<String, String> params = new HashMap<>();
         List<String> mandatoryQ = new ArrayList<>();
+        params.put("sort", "w" + warehouseId + "_i desc");
-        params.put("sort", "w" + fs.getWarehouseId() + "_i desc");
-        List<Integer> webProducts = null;
         if (webListing.getType().equals(WebListingType.solr)) {
-            logger.info("solrtype {}", webListing.getSolrQuery());
             mandatoryQ.add(String.format("+{!parent which=\"" + webListing.getSolrQuery() + "\"} AND active_b:true AND show_default_b:true"));
         } else {
-            logger.info("solrtype2 {}", webListing.getSolrQuery());
+            query.webProducts = webProductListingRepository.selectAllByWebListingId(webListing.getId(), offset, limit).stream().filter(x -> x.getRank() > 0).map(x -> x.getEntityId()).collect(Collectors.toList());
-            webProducts = webProductListingRepository.selectAllByWebListingId(webListing.getId(), offset, limit).stream().filter(x -> x.getRank() > 0).map(x -> x.getEntityId()).collect(Collectors.toList());
-            if (webProducts.size() == 0) {
+            if (query.webProducts.size() == 0) {
-                return new ArrayList<>();
+                return query;
+            }
             mandatoryQ.add(String.format(
-                    "+{!parent which=\"catalogId_i:(" + StringUtils.join(webProducts, " ") + ")\"} AND active_b:true AND show_default_b:true"));
+                    "+{!parent which=\"catalogId_i:(" + StringUtils.join(query.webProducts, " ") + ")\"} 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("start", String.valueOf(offset));
         params.put("rows", String.valueOf(limit));
         params.put("wt", "json");
-        JSONArray docs = partnerSolrClient.selectDocs(params, userInfo.getRetailerId());
-        List<FofoCatalogResponse> dealResponse = getCatalogResponse(docs, false, userInfo.getRetailerId());
-        if (webProducts != null && webListing.getUrl().equals("new-launches")) {
-            List<Integer> webProductsFinal = webProducts;
+        query.params = params;
-            dealResponse = dealResponse.stream().sorted(Comparator.comparing(x -> webProductsFinal.indexOf(x.getCatalogId()))).collect(Collectors.toList());
-        }
-        return dealResponse;
+        return query;
+    }
     @Autowired
     private SaholicCISTableRepository saholicCISTableRepository;
     private List<FofoCatalogResponse> getCatalogResponse(JSONArray docs, boolean hotDeal, int fofoId) throws Exception {
+        List<Integer> itemIds = extractItemIds(docs);
+        if (itemIds.isEmpty()) {
+            return new ArrayList<>();
+        }
+        int warehouseId = fofoStoreRepository.selectByRetailerId(fofoId).getWarehouseId();
+        CatalogBatchData batch = buildCatalogBatchData(fofoId, warehouseId, extractCatalogIds(docs), itemIds);
-        List<FofoCatalogResponse> dealResponse = new ArrayList<>();
+        return buildCatalogResponses(docs, hotDeal, fofoId, batch);
+    }
-        List<Integer> tagIds = Arrays.asList(4);
+    private List<Integer> extractItemIds(JSONArray docs) {
         List<Integer> itemIds = new ArrayList<>();
-        Map<Integer, Integer> partnerStockAvailabilityMap = null;
-        if (docs.length() > 0) {
-            for (int i = 0; i < docs.length(); i++) {
+        for (int i = 0; i < docs.length(); i++) {
-                JSONObject doc = docs.getJSONObject(i);
+            JSONObject doc = docs.getJSONObject(i);
-                if (doc.has("_childDocuments_")) {
+            if (doc.has("_childDocuments_")) {
-                    for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {
+                for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {
-                        JSONObject childItem = doc.getJSONArray("_childDocuments_").getJSONObject(j);
+                    itemIds.add(doc.getJSONArray("_childDocuments_").getJSONObject(j).getInt("itemId_i"));
-                        int itemId = childItem.getInt("itemId_i");
-                        itemIds.add(itemId);
-                    }
+                }
+            }
+        }
-        if (itemIds.isEmpty()) {
-            return dealResponse;
+        return itemIds;
-        }
+    }
-        // get warehouse Id
-        int warehouseId = fofoStoreRepository.selectByRetailerId(fofoId).getWarehouseId();
+    private List<Integer> extractCatalogIds(JSONArray docs) {
-        Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = saholicInventoryService.getSaholicPOItems().get(warehouseId);
         List<Integer> catalogIds = new ArrayList<>();
         for (int i = 0; i < docs.length(); i++) {
-            JSONObject doc = docs.getJSONObject(i);
-            catalogIds.add(doc.getInt("catalogId_i"));
+            catalogIds.add(docs.getJSONObject(i).getInt("catalogId_i"));
+        }
+        return catalogIds;
+    }
+    /** Partner-level data shared by every catalog response built in one request. */
+    private static class CatalogBatchData {
+        int warehouseId;
+        Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap;
+        Map<Integer, Integer> partnerStockAvailabilityMap;
+        Set<Integer> favouriteCatalogIds;
-        List<CreateOfferRequest> allSchemOffers = null;
+        Map<Integer, List<WebOffer>> webOffersMap;
+        Map<Integer, List<ComboModel>> comboModelsByCatalogId;
-        Map<Integer, PriceCircularItemModelNew> priceCircularItemModelMap = new HashMap<>();
+        Map<Integer, PriceCircularItemModelNew> priceCircularItemModelMap;
+        Map<Integer, List<CreateOfferRequest>> schemeOffersByCatalogId;
+        Map<Integer, List<SaholicCISTable>> cisDataByItemId;
+        Map<Integer, Item> itemMap;
+        Map<Integer, Float> cashbackMap;
+    }
+    private CatalogBatchData buildCatalogBatchData(int fofoId, int warehouseId, List<Integer> catalogIds, List<Integer> itemIds) throws Exception {
+        CatalogBatchData batch = new CatalogBatchData();
+        batch.warehouseId = warehouseId;
+        batch.poItemAvailabilityMap = saholicInventoryService.getSaholicPOItems().get(warehouseId);
+        batch.priceCircularItemModelMap = new HashMap<>();
+        batch.schemeOffersByCatalogId = new HashMap<>();
         if (catalogIds.size() > 0) {
             PriceCircularModel priceCircularModel = priceCircularService.getPriceCircularByOffer(fofoId, catalogIds, LocalDate.now());
-            allSchemOffers = priceCircularModel.getOffers();
+            List<CreateOfferRequest> allSchemOffers = priceCircularModel.getOffers();
             List<PriceCircularItemModelNew> priceCircularItemModelNews = priceCircularModel.getPriceCircularItemModelNews();
             if (priceCircularItemModelNews != null) {
-                priceCircularItemModelMap = priceCircularItemModelNews.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
+                batch.priceCircularItemModelMap = priceCircularItemModelNews.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
+            }
+            // Filter null slab payouts and align the surviving ones with the offer list exactly
+            // once per catalog. The models are shared when a catalog appears in more than one
+            // listing, and the iterator.remove() below breaks the index alignment on a second pass.
+            for (PriceCircularItemModelNew model : batch.priceCircularItemModelMap.values()) {
+                if (model.getSlabPayouts() == null) {
+                    continue;
+                }
+                List<CreateOfferRequest> schemeOffers = new ArrayList<>();
+                Iterator<Map<Integer, AmountModel>> iterator = model.getSlabPayouts().iterator();
+                int iteratorCount = 0;
+                while (iterator.hasNext()) {
+                    Map<Integer, AmountModel> slabPayoutMap = iterator.next();
+                    if (slabPayoutMap != null) {
+                        schemeOffers.add(allSchemOffers.get(iteratorCount));
+                    } else {
+                        iterator.remove();
+                    }
+                    iteratorCount++;
+                }
+                batch.schemeOffersByCatalogId.put(model.getCatalogId(), schemeOffers);
+            }
+        }
-        /*List<CatalogFavourite> catalogFavourites = catalogFavouriteRepository.selectBypartnerId(fofoId);
-        List<Integer> catalogFavouriteIds = new ArrayList<>();
-        if (!catalogFavourites.isEmpty()) {
-            catalogFavouriteIds = catalogFavourites.stream().map(x -> x.getCatalogId()).collect(Collectors.toList());
-        }
-        if (!catalogFavourites.isEmpty()) {
-            catalogFavourites.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
-        }*/
         if (fofoId > 0) {
-            partnerStockAvailabilityMap = currentInventorySnapshotRepository.selectItemsStock(fofoId).stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
+            batch.partnerStockAvailabilityMap = currentInventorySnapshotRepository.selectItemsStock(fofoId).stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
-            logger.info("partnerStockAvailabilityMap: {}",partnerStockAvailabilityMap);
+        }
-        List<CatalogFavourite> catalogFavouriteList = catalogFavouriteRepository.selectBypartnerId(fofoId);
+        batch.favouriteCatalogIds = catalogFavouriteRepository.selectBypartnerId(fofoId).stream()
-        Set<Integer> favouriteCatalogIds = catalogFavouriteList.stream()
                 .map(CatalogFavourite::getCatalogId)
                 .collect(Collectors.toSet());
-        // Pre-fetch CIS data for all items (batch query instead of N+1)
-        Map<Integer, List<SaholicCISTable>> cisDataByItemId = saholicCISTableRepository
+        batch.cisDataByItemId = saholicCISTableRepository
                 .selectByItemWarehouse(itemIds, warehouseId).stream()
                 .collect(Collectors.groupingBy(SaholicCISTable::getItemId));
-        // Pre-fetch all Items (batch query instead of N+1)
-        Map<Integer, Item> itemMap = itemRepository.selectByIds(new HashSet<>(itemIds)).stream()
+        batch.itemMap = itemRepository.selectByIds(new HashSet<>(itemIds)).stream()
                 .collect(Collectors.toMap(Item::getId, x -> x));
-        // Pre-fetch cashback data for all catalogs (batch query instead of N+1)
-        Map<Integer, Float> cashbackMap = schemeService.getCatalogSchemeCashBack(fofoId, catalogIds);
+        batch.cashbackMap = schemeService.getCatalogSchemeCashBack(fofoId, catalogIds);
-        // Pre-fetch web offers (call once instead of inside loop)
-        Map<Integer, List<WebOffer>> webOffersMap = webOfferRepository.selectAllActiveOffers();
+        batch.webOffersMap = webOfferRepository.selectAllActiveOffers();
-        // Pre-fetch combo models (call once instead of inside loop)
-        Map<Integer, List<ComboModel>> comboModelsByCatalogId = comboModelRepository.selectByWarehouseId(warehouseId)
+        batch.comboModelsByCatalogId = comboModelRepository.selectByWarehouseId(warehouseId)
                 .stream().collect(Collectors.groupingBy(ComboModel::getCatalogId));
+        return batch;
+    }
+    private List<FofoCatalogResponse> buildCatalogResponses(JSONArray docs, boolean hotDeal, int fofoId, CatalogBatchData batch) throws Exception {
+        List<FofoCatalogResponse> dealResponse = new ArrayList<>();
+        int warehouseId = batch.warehouseId;
+        Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = batch.poItemAvailabilityMap;
+        Map<Integer, Integer> partnerStockAvailabilityMap = batch.partnerStockAvailabilityMap;
+        Set<Integer> favouriteCatalogIds = batch.favouriteCatalogIds;
+        Map<Integer, List<WebOffer>> webOffersMap = batch.webOffersMap;
+        Map<Integer, List<ComboModel>> comboModelsByCatalogId = batch.comboModelsByCatalogId;
+        Map<Integer, PriceCircularItemModelNew> priceCircularItemModelMap = batch.priceCircularItemModelMap;
+        Map<Integer, List<SaholicCISTable>> cisDataByItemId = batch.cisDataByItemId;
+        Map<Integer, Item> itemMap = batch.itemMap;
+        Map<Integer, Float> cashbackMap = batch.cashbackMap;
         for (int i = 0; i < docs.length(); i++) {
             Map<Integer, FofoAvailabilityInfo> fofoAvailabilityInfoMap = new HashMap<>();
             JSONObject doc = docs.getJSONObject(i);
             FofoCatalogResponse fofoCatalogResponse = new FofoCatalogResponse();
                 fofoCatalogResponse.setFeature(null);
                 logger.info("Could not find Feature_s for {}", fofoCatalogResponse.getCatalogId());
+            }
             fofoCatalogResponse.setBrand(doc.getJSONArray("brand_ss").getString(0));
-            logger.info("labelss {}", doc.has("label_ss"));
             if (doc.has("label_ss")) {
-                logger.info("label {}", doc.getJSONArray("label_ss"));
                 JSONArray arr = doc.getJSONArray("label_ss");
                 Set<String> labels = new HashSet<String>();
                 for (int j = 0; j < arr.length(); j++) {
                     labels.add(arr.getString(j));
+                }
             if (fofoAvailabilityInfoMap.values().size() > 0) {
                 List<FofoAvailabilityInfo> availabilityList = fofoAvailabilityInfoMap.values().stream().sorted(Comparator.comparing(FofoAvailabilityInfo::getAvailability).reversed()).collect(Collectors.toList());
                 fofoCatalogResponse.setItems(availabilityList);
                 if (priceCircularItemModelMap.containsKey(fofoCatalogResponse.getCatalogId())) {
                     PriceCircularItemModelNew priceCircularItemModel = priceCircularItemModelMap.get(fofoCatalogResponse.getCatalogId());
-                    if (priceCircularItemModel.getSlabPayouts() != null) {
-                        List<CreateOfferRequest> schemeOffers = new ArrayList<>();
+                    List<CreateOfferRequest> schemeOffers = batch.schemeOffersByCatalogId.get(fofoCatalogResponse.getCatalogId());
-                        List<Map<Integer, AmountModel>> slabPayouts = priceCircularItemModel.getSlabPayouts();
-                        Iterator<Map<Integer, AmountModel>> iterator = slabPayouts.iterator();
-                        int iteratorCount = 0;
-                        while (iterator.hasNext()) {
-                            Map<Integer, AmountModel> slabPayoutMap = iterator.next();
-                            if (slabPayoutMap != null) {
+                    if (schemeOffers != null) {
-                                schemeOffers.add(allSchemOffers.get(iteratorCount));
-                            } else {
-                                iterator.remove();
-                            }
-                            iteratorCount++;
-                        }
                         fofoCatalogResponse.setSchemeOffers(schemeOffers);
+                    }
                     fofoCatalogResponse.setPriceCircularItemModel(priceCircularItemModel);
+                }
                 dealResponse.add(fofoCatalogResponse);

Subversion Repositories SmartDukaan

(root)//trunk/profitmandi-web/src/main/java/com/spice/profitmandi/web/controller/DealsController.java – Rev 37247 → 37250