Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.StringUtils;

import org.json.JSONArray;

import org.json.JSONObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

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

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

import com.spice.profitmandi.service.pricing.PricingService;

import com.spice.profitmandi.web.res.AvailabilityInfo;

import com.spice.profitmandi.web.res.DealBrands;

import com.spice.profitmandi.web.res.DealObjectResponse;

import com.spice.profitmandi.web.res.DealsResponse;

import com.spice.profitmandi.web.res.FofoAvailabilityInfo;

import com.spice.profitmandi.web.res.FofoCatalogResponse;

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 = LoggerFactory.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("${fofo.warehouseIds}")

	private int[] warehouseIds; 

	@Autowired

	private PricingService pricingService;

	@Autowired

	private Mongo mongoClient;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Autowired

	private ItemAvailabilityCacheRepository itemAvailabilityCacheRepository;

	@Autowired

	private ResponseSender<?> responseSender;

	@Autowired

	private InventoryService inventoryService;

	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(SchemeType.HTTP, host, port);

		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 (userInfo.getRoleNames().contains(RoleType.FOFO.toString())) {

			params.put("tag_ids", getCommaSeparateTags(userId));

		}

		List<Object> responseObject = new ArrayList<>();

		response = rc.get(uri, params);

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

			}

		}

		final ProfitMandiResponse<?> profitMandiResponse = new ProfitMandiResponse<>(LocalDateTime.now(),

				request.getRequestURL().toString(), HttpStatus.OK.toString(), HttpStatus.OK, ResponseStatus.SUCCESS,

				responseObject);

		return new ResponseEntity<>(profitMandiResponse, HttpStatus.OK);

	}

	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") 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) throws Throwable {

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

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

		if (userInfo.getRoleNames().contains(RoleType.FOFO.toString())) {

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

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

			RestClient rc  = new RestClient(SchemeType.HTTP, "dtr", 8984);

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

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

			if(brand != null) {

				mandatoryQ.add(String.format("+{!parent which=\"brand_s=%s\"} tagId_i:(%s)", 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*]");

			params.put("sort", "rank_i asc");

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

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

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

			logger.info(rc.getUrl());

			String response  =rc.get("solr/demo/select", params);

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

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

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

				ffdr.setBrand(doc.getString("brand_s"));

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

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

							} catch (Exception e) {}

							if(totalAvailability <= 0){

								continue;

							}

							fdi.setAvailability(totalAvailability);

							fdi.setQuantityStep(1);

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

				}

			}

		} 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(SchemeType.HTTP, host, port);

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

		response = rc.get(uri, params);

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

			}

		}

		final ProfitMandiResponse<?> profitMandiResponse = new ProfitMandiResponse<>(LocalDateTime.now(),

				request.getRequestURL().toString(), HttpStatus.OK.toString(), HttpStatus.OK, ResponseStatus.SUCCESS,

				responseObject);

		return new ResponseEntity<>(profitMandiResponse, HttpStatus.OK);

	}

	/*

	 * @RequestMapping(value = "/direct-deals",

	 * method=RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)

	 * 

	 * @ApiImplicitParams({

	 * 

	 * @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required =

	 * true, dataType = "string", paramType = "header") }) public

	 * ResponseEntity<?> getDirectDeals(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 ){

	 * 

	 * return new ResponseEntity<>(profitMandiResponse,HttpStatus.OK); }

	 */

	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(SchemeType.HTTP, host, port);

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

		params.put("category_id", category_id);

		List<DealBrands> dealBrandsResponse = null;

		response = rc.get(uri, params);

		dealBrandsResponse = new Gson().fromJson(response, new TypeToken<List<DealBrands>>() {

		}.getType());

		final ProfitMandiResponse<?> profitMandiResponse = new ProfitMandiResponse<>(LocalDateTime.now(),

				request.getRequestURL().toString(), HttpStatus.OK.toString(), HttpStatus.OK, ResponseStatus.SUCCESS,

				dealBrandsResponse);

		return new ResponseEntity<>(profitMandiResponse, HttpStatus.OK);

	}

	@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(SchemeType.HTTP, host, port);

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

		DealsResponse dealsResponse = null;

		response = rc.get(uri, params);

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

			}

		}

		/*final ProfitMandiResponse<?> profitMandiResponse = new ProfitMandiResponse<>(LocalDateTime.now(),

				request.getRequestURL().toString(), HttpStatus.OK.toString(), HttpStatus.OK, ResponseStatus.SUCCESS,

				dealsResponse);*/

		return responseSender.ok(dealsResponse);

	}

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

	public ResponseEntity<?> getBrandsToDisplay() {

		return new ResponseEntity<>(mongoClient.getBrandsToDisplay(), HttpStatus.OK);

	}

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

	}

	@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(SchemeType.HTTP, host, port);

		String response = rc.get(uri, new HashMap<>());

		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 = "/deals/pincode/{pincode}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

	public ResponseEntity<?> getDealsByPinCode (@PathVariable String pincode, 

			@RequestParam(value = "offset") String offset, @RequestParam(value = "limit") String limit) throws ProfitMandiBusinessException{

			return responseSender.ok("");

	}*/

}