Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.services;


import java.io.IOException;

import java.io.InputStream;
import java.net.URISyntaxException;
import java.net.URL;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

import com.spice.profitmandi.common.enumuration.SchemeType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.common.web.client.RestClient;
import com.spice.profitmandi.dao.entity.catalog.ComboModel;
import com.spice.profitmandi.dao.entity.catalog.Item;
import com.spice.profitmandi.dao.entity.dtr.WebOffer;
import com.spice.profitmandi.dao.entity.inventory.SaholicCISTable;
import com.spice.profitmandi.dao.entity.inventory.SaholicPOItem;
import com.spice.profitmandi.dao.model.AmountModel;
import com.spice.profitmandi.dao.model.CreateOfferRequest;
import com.spice.profitmandi.dao.repository.catalog.ComboModelRepository;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.dtr.WebOfferRepository;
import com.spice.profitmandi.dao.repository.inventory.SaholicCISTableRepository;
import com.spice.profitmandi.service.inventory.FofoAvailabilityInfo;
import com.spice.profitmandi.service.inventory.FofoCatalogResponse;
import com.spice.profitmandi.service.inventory.SaholicInventoryService;
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.scheme.SchemeService;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.conn.HttpHostConnectException;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
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.Component;


@Component("solrService")
public class SolrService{
        
        private static final Logger logger=LogManager.getLogger(SolrService.class);
        
        @Value("${solr.url}")
        private String SOLR_URL;

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

        @Autowired
        private FofoStoreRepository fofoStoreRepository;

        @Autowired
        private PriceCircularService priceCircularService;

        @Autowired
        private SaholicInventoryService saholicInventoryService;

        @Autowired
        private WebOfferRepository webOfferRepository;

        @Autowired
        private ComboModelRepository comboModelRepository;

        @Autowired
        private SchemeService schemeService;

        @Autowired
        private ItemRepository itemRepository;

        @Autowired
        private SaholicCISTableRepository saholicCISTableRepository;

        private static final String limit ="20";
        private static final String groupLimit = "10";
        private static final String autoSuggestField = "title,subCategoryId,category_id,category,subCategory,score";
        private static final String searchResultsField = "title,skuBundleId,id,thumbnail,ids";
        private static final String outputFormat = "json";
        
        
        
        public String getSuggestions(String search_text) throws URISyntaxException, IOException{

                URIBuilder autoSuggestUrl = new URIBuilder(SOLR_URL);
                autoSuggestUrl.addParameter("fl", autoSuggestField);                  //Fields to choose
                autoSuggestUrl.addParameter("wt", outputFormat);                                          //Output format
                autoSuggestUrl.addParameter("group", "true");                             //group data
                autoSuggestUrl.addParameter("group.query", "category_id:3");  //group by category
                autoSuggestUrl.addParameter("group.query", "category_id:5");  //group by category
                autoSuggestUrl.addParameter("group.field", "subCategoryId");  //group by subCategory
                autoSuggestUrl.addParameter("group.limit", groupLimit);
                autoSuggestUrl.addParameter("q", "suggest:("+search_text+")");
                URL url = autoSuggestUrl.build().toURL();
                logger.info("Auto Suggest Solr");
                InputStream is = url.openStream();
                String jsonString;
                try{
                        jsonString = IOUtils.toString(is, "UTF-8");
                }
                finally{
                        is.close();
                }
                return jsonString; 
        }
        
        public String getSearchResults(String search_text, int offset) throws URISyntaxException, IOException{
                
                URIBuilder generalSearchUrl = new URIBuilder(SOLR_URL);
                generalSearchUrl.addParameter("q", search_text);
                generalSearchUrl.addParameter("fl", searchResultsField);                  //Fields to choose
                generalSearchUrl.addParameter("wt", outputFormat);                                        //Output format
                generalSearchUrl.addParameter("rows", limit);                                     //limit
                generalSearchUrl.setParameter("start", String.valueOf(offset));
                URL url = generalSearchUrl.build().toURL();
                InputStream is = url.openStream();
                String jsonString;
                try{
                        jsonString = IOUtils.toString(is, "UTF-8");
                }
                finally{
                        is.close();
                }
                return jsonString; 
        }

        public List<FofoCatalogResponse> dealResponse (Set<Integer> catalogIds, int fofoId) throws Exception {
                List<FofoCatalogResponse> dealResponse = new ArrayList<>();
                RestClient rc = new RestClient();
                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");
                String response = null;
                try {
                        response = rc.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");
                dealResponse = getCatalogResponse(docs, false, fofoId);

                return dealResponse;

        }


        private List<FofoCatalogResponse> getCatalogResponse(JSONArray docs, boolean hotDeal, int fofoId) throws
                        Exception {
                List<FofoCatalogResponse> dealResponse = new ArrayList<>();
                List<Integer> tagIds = Arrays.asList(4);
                List<Integer> itemIds = new ArrayList<>();
                if (docs.length() > 0) {
                        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++) {
                                                JSONObject childItem = doc.getJSONArray("_childDocuments_").getJSONObject(j);
                                                int itemId = childItem.getInt("itemId_i");
                                                itemIds.add(itemId);
                                        }
                                }
                        }
                        if (itemIds.size() == 0) {
                                return dealResponse;
                        }
                }
                // get warehouse Id
                int warehouseId = fofoStoreRepository.selectByRetailerId(fofoId).getWarehouseId();
                Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = saholicInventoryService.getSaholicPOItems().get(warehouseId);
                List<Integer> catalogIds = new ArrayList<>();
                for (int i = 0; i < docs.length(); i++) {
                        Map<Integer, FofoAvailabilityInfo> fofoAvailabilityInfoMap = new HashMap<>();
                        JSONObject doc = docs.getJSONObject(i);
                        catalogIds.add(doc.getInt("catalogId_i"));
                }
                List<CreateOfferRequest> allSchemOffers = null;
                Map<Integer, PriceCircularItemModelNew> priceCircularItemModelMap = new HashMap<>();
                if (catalogIds.size() > 0) {
                        PriceCircularModel priceCircularModel = priceCircularService.getPriceCircularByOffer(fofoId, catalogIds, LocalDate.now());
                        allSchemOffers = priceCircularModel.getOffers();

                        List<PriceCircularItemModelNew> priceCircularItemModelNews = priceCircularModel.getPriceCircularItemModelNews();
                        if (priceCircularItemModelNews != null) {
                                priceCircularItemModelMap = priceCircularItemModelNews.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
                        }
                }

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

                for (int i = 0; i < docs.length(); i++) {
                        Map<Integer, FofoAvailabilityInfo> fofoAvailabilityInfoMap = new HashMap<>();
                        JSONObject doc = docs.getJSONObject(i);
                        FofoCatalogResponse fofoCatalogResponse = new FofoCatalogResponse();
                        fofoCatalogResponse.setCatalogId(doc.getInt("catalogId_i"));
                        fofoCatalogResponse.setImageUrl(doc.getString("imageUrl_s"));
                        fofoCatalogResponse.setTitle(doc.getString("title_s"));

            /*if (catalogFavouriteIds.contains(fofoCatalogResponse.getCatalogId())) {
                fofoCatalogResponse.setFavourite(true);
            }*/

                        List<WebOffer> webOffers = webOfferRepository.selectAllActiveOffers().get(fofoCatalogResponse.getCatalogId());

                        //logger.info("webOffers {}", webOffers);
                        if (webOffers != null && webOffers.size() > 0) {
                                fofoCatalogResponse.setWebOffers(webOffers);
                                fofoCatalogResponse.setOffers(webOffers.stream().map(x -> x.getTitle()).collect(Collectors.toList()));

                        }

                        List<ComboModel> comboModels = comboModelRepository.selectByWarehouseId(warehouseId).stream().filter(x -> x.getCatalogId() == fofoCatalogResponse.getCatalogId()).collect(Collectors.toList());

                        //logger.info("comboModels {}", comboModels);

                        if (comboModels != null && comboModels.size() > 0) {
                                fofoCatalogResponse.setComboModels(comboModels);
                        }

                        try {
                                fofoCatalogResponse.setFeature(doc.getString("feature_s"));
                        } catch (Exception e) {
                                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));
                                }

                                fofoCatalogResponse.setLabels(new ArrayList<>(labels));

                        }
                        if (doc.has("similarModels_ii")) {
                                JSONArray similarModelsArray = doc.getJSONArray("similarModels_ii");
                                List<Integer> similarCatalogIds = new ArrayList<>();
                                for (int j = 0; j < similarModelsArray.length(); j++) {
                                        similarCatalogIds.add(similarModelsArray.getInt(j));
                                }
                                fofoCatalogResponse.setSimilarModelIds(similarCatalogIds);
                        }

                        if (doc.has("_childDocuments_")) {
                                String modelColorClass = "grey";
                                FofoAvailabilityInfo fdiAnyColour = null;
                                // Iterating itemIds
                                for (int j = 0; j < doc.getJSONArray("_childDocuments_").length(); j++) {
                                        PriceCircularItemModelNew priceCircularItemModel = priceCircularItemModelMap.get(fofoCatalogResponse.getCatalogId());
                                        JSONObject childItem = doc.getJSONArray("_childDocuments_").getJSONObject(j);
                                        int itemId = childItem.getInt("itemId_i");
                                        float sellingPrice = (float) childItem.getDouble("sellingPrice_f");
                                        if (!fofoAvailabilityInfoMap.containsKey(itemId)) {
                                                FofoAvailabilityInfo fdi = new FofoAvailabilityInfo();
                                                List<SaholicCISTable> currentAvailability = saholicCISTableRepository.selectByItemWarehouse(itemId, warehouseId);
                                                List<SaholicPOItem> poItemAvailability = null;
                                                if (poItemAvailabilityMap != null) {
                                                        poItemAvailability = poItemAvailabilityMap.get(itemId);
                                                }

                                                if (priceCircularItemModel != null) {
                                                        fdi.setNlc((float) priceCircularItemModel.getNetNlc());
                                                }

                                                for (SaholicCISTable saholicCISTable : currentAvailability) {
                                                        saholicCISTable.setWarehouseName(
                                                                        ProfitMandiConstants.WAREHOUSE_MAP.get(saholicCISTable.getWarehouseFrom()));
                                                }

                                                Map<Integer, SaholicCISTable> map = currentAvailability.stream().collect(Collectors.toMap(SaholicCISTable::getWarehouseFrom, x -> x));
                                                if (poItemAvailability != null) {
                                                        for (SaholicPOItem saholicPOItem : poItemAvailability) {
                                                                if (map.containsKey(saholicPOItem.getWarehouseFrom())) {
                                                                        map.get(saholicPOItem.getWarehouseFrom()).setPopendingQty(saholicPOItem.getUnfulfilledQty());
                                                                } else {
                                                                        SaholicCISTable saholicCISTable = new SaholicCISTable();
                                                                        saholicCISTable.setAvailability(0);
                                                                        saholicCISTable.setReserved(0);
                                                                        saholicCISTable.setItemId(itemId);
                                                                        saholicCISTable.setWarehouseId(warehouseId);
                                                                        saholicCISTable.setPopendingQty(saholicPOItem.getUnfulfilledQty());
                                                                        saholicCISTable.setWarehouseFrom(saholicPOItem.getWarehouseFrom());
                                                                        saholicCISTable.setWarehouseName(
                                                                                        ProfitMandiConstants.WAREHOUSE_MAP.get(saholicPOItem.getWarehouseFrom()));
                                                                        map.put(saholicPOItem.getWarehouseFrom(), saholicCISTable);
                                                                }
                                                        }
                                                }
                                                fdi.setSaholicCISTableList(new ArrayList<>(map.values()));
                                                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 != "green") {
                                                                        modelColorClass = poColor;
                                                                }
                                                        }
                                                }
                                                fdi.setColorClass(poColor);
                                                fdi.setSellingPrice(sellingPrice);
                                                fdi.setActive(active);
                                                fdi.setMrp(childItem.getDouble("mrp_f"));
                                                fdi.setMop((float) childItem.getDouble("mop_f"));
                                                fdi.setColor(childItem.has("color_s") ? childItem.getString("color_s") : "");
                                                if (fdi.getColor().equalsIgnoreCase("any colour")) {
                                                        fdiAnyColour = fdi;
                                                }
                                                fdi.setTagId(childItem.getInt("tagId_i"));
                                                fdi.setItem_id(itemId);
                                                fdi.setCatalog_id(doc.getInt("catalogId_i"));
                                                Float cashBack = schemeService.getCatalogSchemeCashBack(fofoId, Arrays.asList(fofoCatalogResponse.getCatalogId())).get(fofoCatalogResponse.getCatalogId());
                                                cashBack = cashBack == null ? 0 : cashBack;
                                                fdi.setCashback(cashBack);
                                                fdi.setMinBuyQuantity(1);
                                                if (hotDeal) {
                                                        if (currentAvailability != null) {
                                                                fdi.setAvailability(currentAvailability.stream().collect(Collectors.summingInt(SaholicCISTable::getNetAvailability)));
                                                        } else {
                                                                fdi.setAvailability(0);
                                                        }
                                                } else {
                                                        // Lets consider that its out of stock
                                                        fdi.setAvailability(400);
                                                        Item item = null;
                                                        try {
                                                                item = itemRepository.selectById(itemId);
                                                        } catch (Exception e) {
                                                                e.printStackTrace();
                                                                continue;
                                                        }
                                                        // In case its tampered glass moq should be
                                                        if (item.getCategoryId() == 10020) {
                                                                fdi.setMinBuyQuantity(5);
                                                        }
                                                }
                                                fdi.setQuantityStep(1);
                                                fdi.setMaxQuantity(Math.min(fdi.getAvailability(), 400));
                                                fofoAvailabilityInfoMap.put(itemId, fdi);
                                        }
                                }
                                if (fdiAnyColour != null) {
                                        fdiAnyColour.setColorClass(modelColorClass);
                                }
                                fofoCatalogResponse.setInStock(!modelColorClass.equals("grey"));
                        }
                        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<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) {
                                                                schemeOffers.add(allSchemOffers.get(iteratorCount));
                                                        } else {
                                                                iterator.remove();
                                                        }
                                                        iteratorCount++;
                                                }
                                                fofoCatalogResponse.setSchemeOffers(schemeOffers);
                                        }
                                        fofoCatalogResponse.setPriceCircularItemModel(priceCircularItemModel);
                                }
                                dealResponse.add(fofoCatalogResponse);
                        }
                }
                return dealResponse;

        }

}