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

    InventoryService inventoryService;

    // 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 ComboMappedModelRepository comboMappedModelRepository;

    @Autowired

    private BrandsService brandsService;

    @Autowired

    private WebListingRepository webListingRepository;

    @Autowired

    private WebProductListingRepository webProductListingRepository;

    @Autowired

    private CatalogFavouriteRepository catalogFavouriteRepository;

    @Autowired

    PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

    @Autowired

    PartnerDealerRepository partnerDealerRepository;

    @Autowired

    BrandCommitRepository brandCommitRepository;

    @Autowired

    CatalogRepository catalogRepository;

    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());

        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");

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

        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 {

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

        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());

        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");

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

        return responseSender.ok(dealResponse);

    }

    @RequestMapping(value = "/suggestedPo/status", 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<?> 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);

        }

        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() + "");

        try {

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

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

            JSONArray docs = solrResponseJSONObj.getJSONArray("docs");

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

        } catch (HttpHostConnectException e) {

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

        }

    }

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

    @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) int subCategoryId, @RequestParam(value = "q", required = false) String queryTerm, @RequestParam(value = "hotDeal", required = false) boolean hotDeal, @RequestParam(value = "endPoint", required = false) String endPoint) throws Throwable {

        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);

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

            WebListing webListing = webListingRepository.selectByUrl(endPoint);

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

        } else {

            dealResponse = this.getCatalogResponse(

                    solrService.getSolrDocs(queryTerm, categoryId, offset, limit, sort, brand, subCategoryId, hotDeal), hotDeal, userInfo.getRetailerId());

        }

        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() + "");

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

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

        JSONArray docs = solrResponseJSONObj.getJSONArray("docs");

        int warehouseId = fofoStoreRepository.selectByRetailerId(fofoStore.getId()).getWarehouseId();

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

        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 = saholicCISTableRepository.selectByItemWarehouse(itemId, warehouseId);

                    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;

        RestClient rc = new RestClient();

        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 = rc.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;

        RestClient rc = new RestClient();

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

        params.put("category_id", category_id);

        List<DealBrands> dealBrandsResponse = null;

        try {

            response = rc.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());

        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);

        RestClient rc = new RestClient();

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

        DealsResponse dealsResponse = null;

        try {

            response = rc.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());

            RestClient rc = new RestClient();

            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");

            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, userInfo.getRetailerId());

        } else {

            return responseSender.badRequest(

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

        }

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

    }

    @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);

        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<>();

        RestClient rc = new RestClient();

        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 = 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("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 = "/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();

        RestClient rc = new RestClient();

        String response;

        try {

            response = rc.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);

    }

    @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");

        for (WebListing webListing : webListings) {

            webListing.setFofoCatalogResponses(getDealResponses(userInfo, webListing, 0, 20));

        }

        return responseSender.ok(webListings);

    }

    private List<FofoCatalogResponse> getDealResponses(UserInfo userInfo, WebListing webListing, int offset,

                                                       int limit) throws Exception {

        RestClient rc = new RestClient();

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

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

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

        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());

            webProducts = webProductListingRepository.selectAllByWebListingId(webListing.getId(), offset, limit).stream().filter(x -> x.getRank() > 0).map(x -> x.getEntityId()).collect(Collectors.toList());

            if (webProducts.size() == 0) {

                return new ArrayList<>();

            }

            mandatoryQ.add(String.format(

                    "+{!parent which=\"catalogId_i:(" + StringUtils.join(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");

        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");

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

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

            List<Integer> webProductsFinal = webProducts;

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

        }

        return dealResponse;

    }

    @Autowired

    private SaholicCISTableRepository saholicCISTableRepository;

    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"));

            fofoCatalogResponse.setSuperCatalogTitle(doc.getString("superCatalog_s"));

            fofoCatalogResponse.setSuperCatalogId(doc.getInt("superCatalog_i"));

            fofoCatalogResponse.setSuperCatalogVariants(doc.getString("superCatalogVariants_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);