Subversion Repositories SmartDukaan

package com.spice.profitmandi.common.solr;

import com.spice.profitmandi.common.enumuration.SchemeType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.web.client.RestClient;
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.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Service("solrServiceCommon")
public class SolrService {

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

        @Value("${new.solr.url}")
        private String solrUrl;

        @Autowired
        private RestClient restClient;

        public String getContent(String queryTerm, List<Integer> categoryIds, List<String> brands, int limit,
                        boolean activeOnly) throws Exception {

                JSONArray docs = this.getContentDocs(queryTerm, categoryIds, brands, limit, activeOnly);
                return docs.toString();
        }

        public JSONArray getContentDocs(String queryTerm, List<Integer> categoryIds, List<String> brands, int limit,
                        boolean activeOnly) throws Exception {
                Map<String, String> params = new HashMap<>();
                List<String> mandatoryQ = new ArrayList<>();
                if (queryTerm != null && !queryTerm.equals("null")) {
                        mandatoryQ.add(String.format("+(%s)", "*" + queryTerm + "*"));
                } else {
                        queryTerm = null;
                }
                params.put("q", StringUtils.join(mandatoryQ, " "));
                if (categoryIds != null && categoryIds.size() > 0) {
                        params.put("q", params.get("q") + " +filter(categoryId_i:(" + StringUtils.join(categoryIds, " ") + "))");
                }
                if (brands.size() > 0) {
                        brands = brands.stream().map(x -> x.replaceAll(" ", "\\\\ ")).collect(Collectors.toList());
                        params.put("q", params.get("q") + " AND brand_ss:(" + StringUtils.join(brands, " ") + ")");
                }
                if (activeOnly) {
                        params.put("q", params.get("q") + " AND active_b:true");
                }
                params.put("fl", "*");
                if (queryTerm == null) {
                        params.put("sort", "create_s desc");
                }
                params.put("start", String.valueOf(0));
                if (limit == 0) {
                        params.put("fl", "catalogId_i, title_s, active_b");
                        params.put("rows", String.valueOf(5000));
                } else {
                        params.put("rows", String.valueOf(limit));
                }
                params.put("wt", "json");
                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("response");
                JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
                return docs;
        }

        /**
         * Same query as {@link #getContentDocs} but also surfaces Solr's
         * <code>response.numFound</code> so callers can show "showing X of Y" totals.
         * Returns a small wrapper with the docs array (still capped by {@code limit})
         * and the unlimited match total.
         */
        public ContentSearchResult getContentWithTotal(String queryTerm, List<Integer> categoryIds, List<String> brands,
                        int limit, boolean activeOnly) throws Exception {
                Map<String, String> params = new HashMap<>();
                List<String> mandatoryQ = new ArrayList<>();
                if (queryTerm != null && !queryTerm.equals("null")) {
                        mandatoryQ.add(String.format("+(%s)", "*" + queryTerm + "*"));
                } else {
                        queryTerm = null;
                }
                params.put("q", StringUtils.join(mandatoryQ, " "));
                if (categoryIds != null && categoryIds.size() > 0) {
                        params.put("q", params.get("q") + " +filter(categoryId_i:(" + StringUtils.join(categoryIds, " ") + "))");
                }
                if (brands.size() > 0) {
                        brands = brands.stream().map(x -> x.replaceAll(" ", "\\\\ ")).collect(Collectors.toList());
                        params.put("q", params.get("q") + " AND brand_ss:(" + StringUtils.join(brands, " ") + ")");
                }
                if (activeOnly) {
                        params.put("q", params.get("q") + " AND active_b:true");
                }
                params.put("fl", "*");
                if (queryTerm == null) {
                        params.put("sort", "create_s desc");
                }
                params.put("start", String.valueOf(0));
                if (limit == 0) {
                        params.put("fl", "catalogId_i, title_s");
                        params.put("rows", String.valueOf(5000));
                } else {
                        params.put("rows", String.valueOf(limit));
                }
                params.put("wt", "json");
                String response;
                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("response");
                JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
                long numFound = solrResponseJSONObj.optLong("numFound", docs.length());
                return new ContentSearchResult(docs, numFound);
        }

        /** Wrapper for {@link #getContentWithTotal}. */
        public static class ContentSearchResult {
                private final JSONArray docs;
                private final long totalCount;

                public ContentSearchResult(JSONArray docs, long totalCount) {
                        this.docs = docs;
                        this.totalCount = totalCount;
                }

                public JSONArray getDocs() { return docs; }
                public long getTotalCount() { return totalCount; }
        }

        public Map<Integer, JSONObject> getContentByCatalogIds(List<Integer> catalogIds) throws Exception {
                Map<Integer, JSONObject> documentMap = new HashMap<>();
                Map<String, String> params = new HashMap<>();
                params.put("q", "catalogId_i:" + StringUtils.join(catalogIds, " "));
                params.put("fl", "*");
                params.put("start", String.valueOf(0));
                params.put("rows", String.valueOf(100));
                params.put("wt", "json");
                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("response");
                JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
                for (int i = 0; i < docs.length(); i++) {
                        JSONObject doc = docs.getJSONObject(i);
                        documentMap.put(doc.getInt("catalogId_i"), doc);
                }
                return documentMap;
        }

        // This method is the used to pull docs based on search and shall be used
        // interchangably for both the things
        public static String brandExclusionFq(List<String> excludeBrands) {
                if (excludeBrands == null || excludeBrands.isEmpty()) {
                        return null;
                }
                return "-brand_ss:(" + excludeBrands.stream().map(x -> "\"" + x + "\"").collect(Collectors.joining(" OR "))
                                + ")";
        }

        /**
         * Category facet over the hot-deal models: which categoryId_i values are present (and
         * how many models each) among the docs the hot-deal listing can show. Drives the
         * page's category filter chips.
         */
        public Map<Integer, Integer> getHotDealCategoryFacet(List<Integer> hotDealCatalogIds) throws Exception {
                Map<Integer, Integer> counts = new LinkedHashMap<>();
                for (Map.Entry<String, Integer> bucket
                                : hotDealFacet(hotDealCatalogIds, "categoryId_i", null).entrySet()) {
                        counts.put(Integer.parseInt(bucket.getKey()), bucket.getValue());
                }
                return counts;
        }

        /**
         * Brand facet over the hot-deal models, driving the page's brand chips.
         *
         * <p>Facets on oem_brand_s, NOT brand_ss. Every hot-deal doc reads "Hot Deal" in
         * brand_ss - that is the whole point of the brand - so faceting there would yield a
         * single useless bucket. oem_brand_s carries the brand the SKU had before the move
         * (Samsung, OnePlus, ...), which is what a partner actually wants to narrow by. It is
         * surfaced to partners as plain "Brand"; "OEM" is internal vocabulary.
         */
        /**
         * @param categoryId when set, counts only models in that category, so the chips match
         *                   the tab the partner is standing on. Without it the row is global:
         *                   the LED TVs tab would offer Samsung and Vivo chips even though
         *                   neither has a hot-deal TV, and tapping one returns nothing.
         */
        public Map<String, Integer> getHotDealBrandFacet(List<Integer> hotDealCatalogIds, Integer categoryId)
                        throws Exception {
                return hotDealFacet(hotDealCatalogIds, "oem_brand_s", categoryId);
        }

        /**
         * One facet query over the hot-deal doc set, keyed by raw bucket value. Shared by the
         * category and brand facets, which differ only in the field they count and whether
         * they narrow to a category.
         */
        private Map<String, Integer> hotDealFacet(List<Integer> hotDealCatalogIds, String facetField,
                        Integer categoryId) throws Exception {
                Map<String, Integer> counts = new LinkedHashMap<>();
                if (hotDealCatalogIds == null || hotDealCatalogIds.isEmpty()) {
                        return counts;
                }
                String idClause = hotDealCatalogIds.stream().map(x -> "catalog" + x)
                                .collect(Collectors.joining(" OR "));
                // categoryId_i lives on the parent (catalog) doc, same as the id clause, so it
                // narrows the facet without needing a child-document join.
                String categoryClause = categoryId == null || categoryId <= 0
                                ? "" : " +categoryId_i:" + categoryId;
                Map<String, String> params = new HashMap<>();
                params.put("q", "+id:(" + idClause + ") +show_default_b:true +eol_no_stock_b:false"
                                + categoryClause);
                params.put("rows", "0");
                params.put("facet", "true");
                params.put("facet.field", facetField);
                params.put("facet.mincount", "1");
                params.put("wt", "json");
                String response = restClient.get(SchemeType.HTTP, solrUrl, 8984, "solr/demo/select", params);
                JSONArray buckets = new JSONObject(response).getJSONObject("facet_counts")
                                .getJSONObject("facet_fields").getJSONArray(facetField);
                for (int i = 0; i + 1 < buckets.length(); i += 2) {
                        counts.put(buckets.getString(i), buckets.getInt(i + 1));
                }
                return counts;
        }

        public JSONArray getSolrDocs(String queryTerm, String categoryId, int offset, int limit, String sort,
                        String brand, int subCategoryId, boolean hotDeal, boolean group, boolean eol_filter) throws Throwable {
                return this.getSolrDocs(queryTerm, categoryId, offset, limit, sort, brand, subCategoryId, hotDeal, group,
                                eol_filter, null);
        }

        public JSONArray getSolrDocs(String queryTerm, String categoryId, int offset, int limit, String sort,
                        String brand, int subCategoryId, boolean hotDeal, boolean group, boolean eol_filter,
                        List<String> excludeBrands) throws Throwable {
                return getSolrDocs(queryTerm, categoryId, offset, limit, sort, brand, subCategoryId, hotDeal, group,
                                eol_filter, excludeBrands, null);
        }

        public JSONArray getSolrDocs(String queryTerm, String categoryId, int offset, int limit, String sort,
                        String brand, int subCategoryId, boolean hotDeal, boolean group, boolean eol_filter,
                        List<String> excludeBrands, List<Integer> hotDealCatalogIds) throws Throwable {
                List<String> parentFilter = new ArrayList<>();
                // Hot-deal listings are cross-category by default (the curated catalogId filter
                // is the scope); categoryId is applied there only when the caller explicitly
                // passes one (the page's category filter chips)
                if (hotDealCatalogIds == null || hotDealCatalogIds.isEmpty()
                                || (categoryId != null && !categoryId.trim().isEmpty())) {
                        parentFilter.add("categoryId_i:" + categoryId);
                }
                parentFilter.add("show_default_b:true");
                List<String> childFilter = new ArrayList<>();
                childFilter.add("itemId_i:*");

                Map<String, String> params = new HashMap<>();
                if (queryTerm == null || queryTerm.equals("null")) {
                        queryTerm = "";
                } else {
                        queryTerm = "(" + queryTerm + ")";
                }
                // True when this query is scoped to hot deals by EITHER route below. The brand
                // filter keys off this rather than the hotDeal flag alone, because the caller that
                // resolves the catalog ids itself passes hotDeal = false - and that listing still
                // needs its brand chips routed to oem_brand_s.
                boolean hotDealScoped = hotDeal || (hotDealCatalogIds != null && !hotDealCatalogIds.isEmpty());

                if (hotDealCatalogIds != null && !hotDealCatalogIds.isEmpty()) {
                        // Caller already resolved the hot-deal set from the brand: restrict parents to
                        // those models; items stay the normal active set
                        String idClause = hotDealCatalogIds.stream().map(x -> "catalog" + x)
                                        .collect(java.util.stream.Collectors.joining(" OR "));
                        parentFilter.add("id:(" + idClause + ")");
                        childFilter.add("active_b:true");
                } else if (hotDeal) {
                        // hot_deal_b is derived from the SKU's brand at index time (FofoSolr)
                        childFilter.add("hot_deal_b:true");
                } else {
                        childFilter.add("active_b:true");
                }
                if (subCategoryId != 0) {
                        parentFilter.add("subCategoryId_i:" + subCategoryId);
                }

                if(eol_filter){
                        parentFilter.add("eol_no_stock_b:false");
                }
                if (StringUtils.isNotBlank(brand)) {
                        // Inside the hot-deal listing the brand chips carry the ORIGINAL brand, which
                        // lives in oem_brand_s - every one of those docs reads "Hot Deal" in brand_ss,
                        // so filtering there would match nothing.
                        String brandField = hotDealScoped ? "oem_brand_s" : "brand_ss";
                        parentFilter.add(brandField + ":" + "\\\"" + brand + "\\\"");
                }
                if (queryTerm == "") {
                        params.put("sort", (sort == "" ? "" : sort + ", ") + "create_s desc");
                } else {
                        parentFilter.addAll(Arrays.asList(queryTerm.split(" ")));
                }
                String parentFilterString = "\"" + String.join(" AND ", parentFilter) + "\"";
                String childFilterString = String.join(" AND ", childFilter);
                params.put("q", String.format("{!parent which=%s}%s", parentFilterString, childFilterString));
                params.put("fl",
                                String.format("*, [child parentFilter=id:catalog* childFilter=%s]", "\"" + childFilterString + "\""));
                params.put("start", String.valueOf(offset));
                params.put("rows", String.valueOf(limit));
                params.put("wt", "json");

                String exclusionFq = brandExclusionFq(excludeBrands);
                if (exclusionFq != null) {
                        params.put("fq", exclusionFq);
                }

                String groupByField = null;

                if (group) {
                        groupByField = "superCatalog_s";
                        params.put("group", String.valueOf(group));
                        params.put("group.field", groupByField);
                        params.put("group.limit", "1");
                        if (!sort.isEmpty()) {
                                params.put("group.sort", sort);
                        }
                }
logger.info("groupByField {}", groupByField);
                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("response");
                JSONArray docs = solrResponseJSONObj.getJSONArray("docs");*/

                JSONObject solrResponseJSONObj = new JSONObject(response);
                JSONArray docs;

                if (group) {
                        logger.info("Reached in if condition {}",groupByField);
                        JSONObject grouped = solrResponseJSONObj.getJSONObject("grouped");
                        JSONArray groups = grouped.getJSONObject(groupByField).getJSONArray("groups");

                        docs = new JSONArray();
                        for (int i = 0; i < groups.length(); i++) {
                                JSONObject groupObj = groups.getJSONObject(i);
                                JSONArray groupDocs = groupObj.getJSONObject("doclist").getJSONArray("docs");
                                for (int j = 0; j < groupDocs.length(); j++) {
                                        docs.put(groupDocs.getJSONObject(j));
                                }
                        }
                } else {
                        logger.info("Reached in else condition {}",groupByField);
                        docs = solrResponseJSONObj.getJSONObject("response").getJSONArray("docs");
                }

                logger.info("Reached at end {}",docs);

                return docs;
        }

}