Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class DealsController {

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

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

	private String host;

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

	private String solrUrl;

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

	private int port;

	@Autowired

	RestClient restClient;

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

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

	private String[] ccGadgetCopInvoiceTo;

	@Autowired

	private PricingService pricingService;

	@Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@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 ResponseSender<?> responseSender;

	@Autowired

	private CategoryRepository repository;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private ItemAvailabilityCacheRepository itemAvailabilityCacheRepository;

	@Autowired

	private RoleManager roleManagerService;

	@Autowired

	private SuggestedPoDetailRepository monthlyPoDetailRepository;

	@Autowired

	private SuggestedPoRepository suggestedPoRepository;

	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 = monthlyPoDetailRepository.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");

		return responseSender.ok(true);

	}

	private String getCommaSeparateTags(int userId) {

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

	}

	@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") String offset, @RequestParam(value = "limit") String 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) throws Throwable {

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

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

		dealResponse = this.getCatalogResponse(this.getSolrDocs(userInfo.getRetailerId(), queryTerm, categoryId, offset,

				limit, sort, brand, subCategoryId, hotDeal), hotDeal, 0);

		return responseSender.ok(dealResponse);

	}

	private JSONArray getSolrDocs(int fofoId, String queryTerm, String categoryId, String offset, String limit,

			String sort, String brand, int subCategoryId, boolean hotDeal) throws Throwable {

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

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

		parentFilter.add("categoryId_i:" + categoryId);

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

		}

		if (hotDeal) {

			childFilter.add("hot_deal_b:true");

		} else {

			childFilter.add("active_b:true");

		}

		if (subCategoryId != 0) {

			parentFilter.add("subCategoryId_i:" + subCategoryId);

		}

		if (StringUtils.isNotBlank(brand)) {

			parentFilter.add("brand_ss:" + brand);

		}

		String parentFilterString = "\"" + String.join(" AND ", parentFilter) + "\"";

		String childFilterString = String.join(" AND ", childFilter);

		logger.info(parentFilterString);

		params.put("q", String.format("%s{!parent which=%s}%s", queryTerm, parentFilterString, childFilterString));

		params.put("fl", String.format("*, [child parentFilter=id:catalog* childFilter=%s]",

				"\"" + childFilterString + "\""));

		if (queryTerm == "") {

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

		}

		params.put("start", String.valueOf(offset));

		params.put("rows", String.valueOf(limit));

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

		String response = null;

		try {

			response = restClient.get(SchemeType.HTTP, "50.116.10.120", 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;

	}

	@ApiImplicitParams({

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

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

	public ResponseEntity<?> partnerStock(HttpServletRequest request,

			@RequestParam(value = "categoryId", required = false, defaultValue = "3") String categoryId,

			@RequestParam(value = "offset") String offset, @RequestParam(value = "limit") String 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 = " ", required = false, defaultValue = "true") boolean partnerStockOnly)

			throws Throwable {

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

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

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

		dealResponse = this.getCatalogResponse(this.getSolrDocs(uc.getUserId(), queryTerm, categoryId, offset, limit,

				sort, brand, subCategoryId, false), false, userInfo.getRetailerId());

		return responseSender.ok(dealResponse);

	}

	@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 ProfitMandiBusinessException {

		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, "50.116.10.120", 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<DBObject> brandsDisplay = mongoClient.getMongoBrands(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, "50.116.10.120", 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);

	}

	private List<FofoCatalogResponse> getCatalogResponse(JSONArray docs, boolean hotDeal, int fofoId)

			throws ProfitMandiBusinessException {

		Map<Integer, Integer> ourItemAvailabilityMap = null;

		Map<Integer, Integer> partnerStockAvailabilityMap = null;

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

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

		if (docs.length() > 0) {

			HashSet<Integer> itemsSet = new HashSet<>();

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

						itemsSet.add(itemId);

					}

				}

			}

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

				return dealResponse;

			}

			if (hotDeal) {

				ourItemAvailabilityMap = saholicInventoryService.getTotalAvailabilityByItemIds(new ArrayList<>(itemsSet));

			} else if (fofoId > 0) {

				partnerStockAvailabilityMap = currentInventorySnapshotRepository.selectItemsStock().stream()

						.collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));

				ourItemAvailabilityMap = saholicInventoryService.getTotalAvailabilityByItemIds(new ArrayList<>(itemsSet));

			}

		}

		List<FofoAvailabilityInfo> fdis = new ArrayList<>();

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

			Map<Integer, FofoAvailabilityInfo> fofoAvailabilityInfoMap = new HashMap<>();

			JSONObject doc = docs.getJSONObject(i);

			FofoCatalogResponse ffdr = new FofoCatalogResponse();

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

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

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

			try {

				ffdr.setFeature(doc.getString("feature_s"));

			} catch (Exception e) {

				ffdr.setFeature(null);

				logger.info("Could not find Feature_s for {}", ffdr.getCatalogId());

			}

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

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

					float sellingPrice = (float) childItem.getDouble("sellingPrice_f");

					if (fofoAvailabilityInfoMap.containsKey(itemId)) {

						if (fofoAvailabilityInfoMap.get(itemId).getSellingPrice() > sellingPrice) {

							fofoAvailabilityInfoMap.get(itemId).setSellingPrice(sellingPrice);

							fofoAvailabilityInfoMap.get(itemId).setMop((float) childItem.getDouble("mop_f"));

						}

					} else {

						FofoAvailabilityInfo fdi = new FofoAvailabilityInfo();

						fdi.setSellingPrice(sellingPrice);

						fdi.setActive(childItem.getBoolean("active_b"));

						fdi.setMrp(childItem.getDouble("mrp_f"));

						fdi.setMop((float) childItem.getDouble("mop_f"));

						fdi.setColor(childItem.has("color_s") ? childItem.getString("color_s") : "");

						fdi.setTagId(childItem.getInt("tagId_i"));

						fdi.setItem_id(itemId);

						Float cashBack = schemeService.getItemSchemeCashBack().get(itemId);

						cashBack = cashBack == null ? 0 : cashBack;

						fdi.setCashback(cashBack);

						if (hotDeal) {

							try {

								int totalAvailability = ourItemAvailabilityMap.get(itemId);

								if (totalAvailability <= 0) {

									continue;

								}

								fdi.setAvailability(ourItemAvailabilityMap.get(itemId));

							} catch (Exception e) {

								continue;

							}

						} else if (fofoId == 0) {

							// For accessories item availability should at be ordered for Rs.1000

							fdi.setAvailability(100);

							Item item = itemRepository.selectById(itemId);

							// In case its tampered glass moq should be 5

							if (item.getCategoryId() == 10020) {

								fdi.setMinBuyQuantity(5);

							} else {

								fdi.setMinBuyQuantity(1);

							}

						} else {

							int ourStockAvailability = ourItemAvailabilityMap.get(itemId) == null ? 0 : ourItemAvailabilityMap.get(itemId);

							int partnerAvailability = partnerStockAvailabilityMap.get(itemId) == null ? 0 : partnerStockAvailabilityMap.get(itemId);

							fdi.setAvailability(ourStockAvailability + partnerAvailability);

						}

						fdi.setQuantityStep(1);

						fdi.setMaxQuantity(Math.min(fdi.getAvailability(), 100));

						fofoAvailabilityInfoMap.put(itemId, fdi);

					}

				}

			}

			if (fofoAvailabilityInfoMap.values().size() > 0) {

				ffdr.setItems(new ArrayList<FofoAvailabilityInfo>(fofoAvailabilityInfoMap.values()));

				dealResponse.add(ffdr);

			}

		}

		return dealResponse;

	}

	private List<FofoCatalogResponse> getCatalogSingleSkuResponse(JSONArray docs, Map<Integer, Integer> itemFilter,

			boolean hotDeal) throws ProfitMandiBusinessException {

		Map<Integer, TagListing> itemTagListingMap = null;

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

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

		itemTagListingMap = tagListingRepository.selectByItemIdsAndTagIds(itemFilter.keySet(), new HashSet<>(tagIds))

				.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x));

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

			Map<Integer, FofoAvailabilityInfo> fofoAvailabilityInfoMap = new HashMap<>();

			JSONObject doc = docs.getJSONObject(i);

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

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

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

				TagListing tl = itemTagListingMap.get(itemId);

				if (tl == null) {

					continue;

				}

				if (hotDeal) {

					if (!tl.isHotDeals()) {

						continue;

					}

				}

				float sellingPrice = (float) childItem.getDouble("sellingPrice_f");

				if (fofoAvailabilityInfoMap.containsKey(itemId)) {

					if (fofoAvailabilityInfoMap.get(itemId).getSellingPrice() > sellingPrice) {

						fofoAvailabilityInfoMap.get(itemId).setSellingPrice(sellingPrice);

						fofoAvailabilityInfoMap.get(itemId).setMop((float) childItem.getDouble("mop_f"));

					}

				} else {

					FofoAvailabilityInfo fdi = new FofoAvailabilityInfo();

					fdi.setSellingPrice((float) childItem.getDouble("sellingPrice_f"));

					fdi.setMop((float) childItem.getDouble("mop_f"));

					fdi.setMop((float) tl.getMrp());

					fdi.setColor(childItem.has("color_s") ? childItem.getString("color_s") : "");

					fdi.setTagId(childItem.getInt("tagId_i"));

					fdi.setItem_id(itemId);

					Item item = itemRepository.selectById(itemId);

					// In case its tampered glass moq should be 5

					if (item.getCategoryId() == 10020) {

						fdi.setMinBuyQuantity(10);

					} else {

						fdi.setMinBuyQuantity(1);

					}

					fdi.setAvailability(itemFilter.get(itemId));

					fdi.setQuantityStep(1);

					fdi.setMaxQuantity(Math.min(fdi.getAvailability(), 100));

					fofoAvailabilityInfoMap.put(itemId, fdi);

				}

			}

			if (fofoAvailabilityInfoMap.values().size() > 0) {

				for (FofoAvailabilityInfo fofoAvailabilityInfo : fofoAvailabilityInfoMap.values()) {

					FofoCatalogResponse ffdr = new FofoCatalogResponse();

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

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

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

					try {

						ffdr.setFeature(doc.getString("feature_s"));

					} catch (Exception e) {

						ffdr.setFeature(null);

						logger.info("Could not find Feature_s for {}", ffdr.getCatalogId());

					}

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

					ffdr.setItems(Arrays.asList(fofoAvailabilityInfo));

					dealResponse.add(ffdr);

				}

			}

		}

		return dealResponse;

	}

}