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.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.inventory.ItemAvailabilityCache;

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.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.pricing.PricingService;

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("${python.api.port}")

	private int port;

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

	List<String> filterableParams = Arrays.asList("brand");

	@RequestMapping(value = ProfitMandiConstants.URL_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 deals")

	public ResponseEntity<?> getDeals(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 ProfitMandiBusinessException {

		logger.info("Request " + request.getParameterMap());

		String response = null;

		int userId = (int) request.getAttribute("userId");

		// If pincode belongs to Specific warehouse marked

		// availability should be fetched for that warehouse only

		// show only skus belonging to that specific

		// else use normal flow

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

		// TODO: move to properties

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

		params.put("source", "deals");

		if (roleManagerService.isPartner(userInfo.getRoleIds())) {

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

	}

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

		RestClient rc = new RestClient();

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

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

		mandatoryQ.add(String.format("+{!parent which=\"id:catalog*\"} itemId_i:(%s)", StringUtils.join(itemIdsQtyMap.keySet(), " ")));

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

		dealResponse = dealResponse.stream()

				//.filter(x->itemIdsQtyMap.keySet().contains((int)(x.getItems().get(0).getItem_id())))

				.map(x->{

					FofoAvailabilityInfo fai = x.getItems().get(0);

					fai.setAvailability(itemIdsQtyMap.get((int)fai.getItem_id()));

					return x;

				}).collect(Collectors.toList());

		Bucket bucket = itemBucketService.getBuckets(Optional.of(true)).get(0);

		bucket.setFofoCatalogResponses(dealResponse);

		return responseSender.ok(bucket);

	}

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

		if (roleManagerService.isPartner(userInfo.getRoleIds())) {

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

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

			RestClient rc = new RestClient();

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

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

			if (queryTerm != null && !queryTerm.equals("null")) {

				mandatoryQ.add(String.format("+(%s)", queryTerm));

			} else {

				queryTerm = null;

			}

			if (subCategoryId != 0) {

				mandatoryQ

						.add(String.format("+(subCategoryId_i:%s) +{!parent which=\"subCategoryId_i:%s\"} tagId_i:(%s)",

								subCategoryId, subCategoryId, StringUtils.join(tagIds, " ")));

			} else if (hotDeal) {

				mandatoryQ.add(String.format("+{!parent which=\"hot_deals_b=true\"} tagId_i:(%s)",

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

			} else if (StringUtils.isNotBlank(brand)) {

				mandatoryQ.add(

						String.format("+(categoryId_i:%s) +(brand_ss:%s) +{!parent which=\"brand_ss:%s\"} tagId_i:(%s)",

								categoryId, brand, brand, StringUtils.join(tagIds, " ")));

			} else {

				mandatoryQ.add(

						String.format("+{!parent which=\"id:catalog*\"} tagId_i:(%s)", StringUtils.join(tagIds, " ")));

			}

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

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

			if (queryTerm == null) {

				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 = rc.get(SchemeType.HTTP, "dtr", 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, hotDeal);

			if (Mongo.PARTNER_BLoCKED_BRANDS.containsKey(userInfo.getEmail())) {

				dealResponse.stream()

						.filter(x -> Mongo.PARTNER_BLoCKED_BRANDS.get(userInfo.getEmail()).contains(x.getBrand()));

			}

		} else {

			return responseSender.badRequest(

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

		}

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

		} 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> subCateogriesDisplay = this.getSubCategoriesToDisplay();

		return new ResponseEntity<>(subCateogriesDisplay, 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, "dtr", 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", "http://api.profittill.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)

			throws ProfitMandiBusinessException {

		Map<Integer, TagListing> itemTagListingMap = 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);

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

				}

			}

			itemTagListingMap = tagListingRepository.selectByItemIdsAndTagIds(itemsSet, 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);

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

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

					}

					if (hotDeal || !tl.isActive()) {

						int totalAvailability = 0; // Using item availability

													// cache for now but can be

													// changed to

													// use caching later.

						try {

							ItemAvailabilityCache iac = itemAvailabilityCacheRepository.selectByItemId(itemId);

							totalAvailability = iac.getTotalAvailability();

							fdi.setAvailability(totalAvailability);

						} catch (Exception e) {

							continue;

						}

						if (totalAvailability <= 0) {

							continue;

						}

					} else {

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

						fdi.setAvailability(100);

					}

					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, boolean hotDeal)

			throws ProfitMandiBusinessException {

		Map<Integer, TagListing> itemTagListingMap = 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);

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

				}

			}

			itemTagListingMap = tagListingRepository.selectByItemIdsAndTagIds(itemsSet, 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 (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.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);

					}

					if (hotDeal || !tl.isActive()) {

						int totalAvailability = 0; // Using item availability

						// cache for now but can be

						// changed to

						// use caching later.

						try {

							ItemAvailabilityCache iac = itemAvailabilityCacheRepository.selectByItemId(itemId);

							totalAvailability = iac.getTotalAvailability();

							fdi.setAvailability(totalAvailability);

						} catch (Exception e) {

							continue;

						}

						if (totalAvailability <= 0) {

							continue;

						}

					} else {

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

						fdi.setAvailability(100);

					}

					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;

	}

}