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

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

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

import com.spice.profitmandi.dao.entity.inventory.SaholicCISTable;

import com.spice.profitmandi.dao.entity.inventory.SaholicPOItem;

import com.spice.profitmandi.dao.enumuration.dtr.WebListingType;

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

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

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

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

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

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

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.service.authentication.RoleManager;

import com.spice.profitmandi.service.catalog.BrandsService;

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

import com.spice.profitmandi.service.pricecircular.PriceCircularItemModel;

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

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

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

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

import javax.servlet.http.HttpServletRequest;

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

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

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

	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,

			@RequestParam(value = "endPoint", required = false) String endPoint) throws Throwable {

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

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

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

		sort = "w" + fs.getWarehouseId() + "_i desc";

		logger.info("endPoint {}", endPoint);

		if (StringUtils.isEmpty(endPoint)) {

			dealResponse = this.getCatalogResponse(

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

					hotDeal, userInfo.getRetailerId());

		} else {

			WebListing webListing = webListingRepository.selectByUrl(endPoint);

			dealResponse = this.getDealResponses(userInfo, webListing);

		}

		logger.info("log me");

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

	}

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

				WebListingType.partner);

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

		for (WebListing webListing : webListings) {

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

		}

		return responseSender.ok(webListings);

	}

	private List<FofoCatalogResponse> getDealResponses(UserInfo userInfo, WebListing webListing) throws Exception {

		List<Integer> webProducts = webProductListingRepository.selectAllByWebListingId(webListing.getId()).stream()

				.filter(x -> x.getRank() > 0).map(x -> x.getEntityId()).collect(Collectors.toList());

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

			return new ArrayList<>();

		}

		RestClient rc = new RestClient();

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

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

		mandatoryQ.add(String.format(

				"+{!parent which=\"catalogId_i:" + StringUtils.join(webProducts, " ") + "\"} tagId_i:(%s)",

				StringUtils.join(TAG_IDS, " ")));

		params.put("q", StringUtils.join(mandatoryQ, " "));

		params.put("fl", "*, [child parentFilter=id:catalog*]");

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

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

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

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

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

		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, PriceCircularItemModel> priceCircularItemModelMap = new HashMap<>();

		if (catalogIds.size() > 0) {

			PriceCircularModel priceCircularModel = priceCircularService.getPriceCircularByOffer(fofoId, catalogIds);

			allSchemOffers = priceCircularModel.getOffers();

			List<PriceCircularItemModel> priceCircularItemModels = priceCircularModel.getPriceCircularItemModels();

			if (priceCircularItemModels != null) {

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

			List<WebOffer> webOffers = webOfferRepository.selectAllActiveOffers()

					.get(fofoCatalogResponse.getCatalogId());

			logger.info("webOffers {}", webOffers);

			if (webOffers != null && webOffers.size() > 0) {

				fofoCatalogResponse.setWebOffers(webOffers);

			}

			List<ComboModel> comboModels = comboModelRepository.selectByWarehouseId(warehouseId).stream()

					.filter(x -> x.getCatalogId() == fofoCatalogResponse.getCatalogId()).collect(Collectors.toList());

			for (ComboModel comboModel : comboModels) {

				List<ComboMappedModel> mappedModels = comboMappedModelRepository.selectByComboId(comboModel.getId());

				comboModel.setComboMappedModels(mappedModels);

			}

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

			if (doc.has("_childDocuments_")) {

				String modelColorClass = "grey";

				FofoAvailabilityInfo fdiAnyColour = null;

				// Iterating itemIds

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

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

						}

						fdi.setNlc(priceCircularItemModel == null ? 0 : priceCircularItemModel.getNetPrice());

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

						Float cashBack = schemeService.getCatalogSchemeCashBack()

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

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

						fofoAvailabilityInfoMap.put(itemId, fdi);

					}

				}

				if (fdiAnyColour != null) {

					fdiAnyColour.setColorClass(modelColorClass);

				}

			}

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

					PriceCircularItemModel priceCircularItemModel = priceCircularItemModelMap

							.get(fofoCatalogResponse.getCatalogId());

					if (priceCircularItemModel.getSlabPayouts() != null) {

						List<CreateOfferRequest> schemeOffers = new ArrayList<>();

						List<Map<Integer, Long>> slabPayouts = priceCircularItemModel.getSlabPayouts();

						Iterator<Map<Integer, Long>> iterator = slabPayouts.iterator();

						int iteratorCount = 0;

						while (iterator.hasNext()) {

							Map<Integer, Long> 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;

	}

	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;

	}

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

	public ResponseEntity<?> getBanners(@RequestParam int catalogId, @RequestParam int warehouseId) {

		List<ComboModel> comboModels = comboModelRepository.selectByCatalogIdAndWarehouseId(catalogId, warehouseId);

		return responseSender.ok(comboModels);

	}

}