Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.pricing;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

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

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

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

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

import com.spice.profitmandi.dao.entity.dtr.GadgetCopsInsuranceCalc;

import com.spice.profitmandi.dao.entity.user.Address;

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.service.scheme.SchemeService;

import com.spice.profitmandi.service.tag.TagService;

import org.apache.commons.collections.CollectionUtils;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Component;

import java.util.*;

@Component

public class PricingServiceImpl implements PricingService{

	@Autowired

	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

	@Autowired

	private AddressRepository addressRepository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private SchemeService schemeService;

	@Autowired

	private TagService tagService;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private InsuranceProviderRepository insuranceProviderRepository;

	@Autowired

	private GadgetCopsInsuranceCalcRepository gadgetCopsInsuranceCalcRepository;

	@Autowired

	@Qualifier("fofoInventoryItemRepository")

	private InventoryItemRepository inventoryItemRepository;

	private static final Logger LOGGER = LogManager.getLogger(PricingServiceImpl.class);

	@Override

	public Map<Integer, Float> getPrices(Set<Integer> itemIds, int retailerId) {

		Map<Integer, Float> itemIdPrice = this.preparePriceDefaultValues(itemIds);

		List<TagListing> tagListings = this.getTagListing(itemIds, retailerId);

		for(TagListing tagListing : tagListings){

			if(itemIdPrice.get(tagListing.getItemId()) > tagListing.getSellingPrice()){

				itemIdPrice.put(tagListing.getItemId(), tagListing.getSellingPrice());

			}

		}

		return itemIdPrice;

	}

	private Map<Integer, Float> preparePriceDefaultValues(Set<Integer> itemIds){

		Map<Integer, Float> itemIdPrice = new HashMap<>(itemIds.size());

		for(int itemId : itemIds){

			itemIdPrice.put(itemId, Float.MAX_VALUE);

		}

		return itemIdPrice;

	}

	private Map<Integer, PriceModel> preparePriceModelDefaultValues(Set<Integer> itemIds){

		Map<Integer, PriceModel> itemIdPrice = new HashMap<>(itemIds.size());

		for(int itemId : itemIds){

			PriceModel priceModel = new PriceModel();

			priceModel.setPrice(Float.MAX_VALUE);

			itemIdPrice.put(itemId, priceModel);

		}

		return itemIdPrice;

	}

	@SuppressWarnings("unchecked")

	private List<TagListing> getTagListing(Set<Integer> itemIds, int retailerId){

		Map<Integer, TagListing> itemIdTagListing = new HashMap<>();

		List<TagListing> tagListings = new ArrayList<>();

		try {

			if(itemIds.isEmpty()) {

				return tagListings;

			}

			int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailerId);

			Address retailerAddress = addressRepository.selectById(addressId);

			Set<Integer> pinCodeTagIds = tagService.getFofoTagIdsByPinCode(retailerAddress.getPinCode());

			Set<Integer> pinNegativeTagIds = tagService.getPinCodeNegativeTagIds();

			Set<Integer> pinCodeIntersection = new HashSet<>(CollectionUtils.intersection(pinCodeTagIds, pinNegativeTagIds));

			Set<Integer> filterPinCodeTagIds = new HashSet<>(CollectionUtils.subtract(pinNegativeTagIds, pinCodeIntersection));

			Set<Integer> pinPositiveTagIds = tagService.getPinCodePositiveTagIds();

			filterPinCodeTagIds.addAll(pinPositiveTagIds);

			if(filterPinCodeTagIds.isEmpty()){

				return tagListings;

			}

			Set<Integer> retailerTagIds = tagService.getUserTagIdsByTagIds(filterPinCodeTagIds);

			Set<Integer> userNegativeTagIds = tagService.getUserNegativeTagIds();

			Set<Integer> userIntersection = new HashSet<>(CollectionUtils.intersection(retailerTagIds, userNegativeTagIds));

			Set<Integer> filterUserTagIds = new HashSet<>(CollectionUtils.subtract(userNegativeTagIds, userIntersection));

			Set<Integer> userPositiveTagIds = tagService.getUserPositiveTagIds();

			filterUserTagIds.addAll(userPositiveTagIds);

			if(filterUserTagIds.isEmpty()){

				return tagListings;

			}

			tagListings = tagListingRepository.selectByItemIdsAndTagIds(itemIds, filterUserTagIds);

			if(tagListings.isEmpty()){

				return tagListings;

			}

			for(TagListing tagListing : tagListings){

				if(!itemIdTagListing.containsKey(tagListing.getItemId()))

				{

					itemIdTagListing.put(tagListing.getItemId(), tagListing);

				}else{

					if(itemIdTagListing.get(tagListing.getItemId()).getSellingPrice() > tagListing.getSellingPrice()){

						itemIdTagListing.put(tagListing.getItemId(), tagListing);

					}

				}

			}

		} catch (ProfitMandiBusinessException e) {

			e.printStackTrace();

		}

		return tagListings;

	}

	@Autowired

	PartnerTypeChangeService partnerTypeChangeService;

	public static final List<Integer> mopVoilatedRetailerIds = Arrays.asList();

	@Override

	public List<Integer> getMopVoilatedRetailerIds() {

		return mopVoilatedRetailerIds;

	}

	@Override

    public Map<Integer, PriceModel> getMopPrices(Set<Integer> itemIds, int retailerId) throws ProfitMandiBusinessException {

		//Set Price with max value

		Map<Integer, PriceModel> itemPriceMap = this.preparePriceModelDefaultValues(itemIds);

		List<TagListing> tagListings = this.getTagListing(itemIds, retailerId);

		for(TagListing tagListing : tagListings){

			Item item = null;

			try {

				item = itemRepository.selectById(tagListing.getItemId());

			} catch (Exception e) {

				LOGGER.info("Could not find item {}", tagListing.getItemId());

				continue;

			}

			PriceModel priceModel = itemPriceMap.get(tagListing.getItemId());

			//In case of hot deal mop is set to retailer buying price

			priceModel.setPurchasePrice(tagListing.getSellingPrice());

			priceModel.setMrp(tagListing.getMrp());

			if(tagListing.isHotDeals()) {

				priceModel.setMop(true);

				priceModel.setPrice(tagListing.getSellingPrice());

			} else if (itemPriceMap.get(tagListing.getItemId()).getPrice() > tagListing.getMop()) {

				priceModel.setPrice(tagListing.getMop());

				priceModel.setMop(true);

				Map<Integer, Float> catalogSchemeCashBack =  schemeService.getCatalogSchemeCashBack(retailerId, Arrays.asList(item.getCatalogItemId()));

				if(catalogSchemeCashBack.get(item.getCatalogItemId()) != null && catalogSchemeCashBack.get(item.getCatalogItemId()) > 0) {

					priceModel.setMaxDiscountAmount(catalogSchemeCashBack.get(item.getCatalogItemId()));

				}

			} else if (item.getHsnCode().equals("85171400")) {

				priceModel.setMop(false);

				priceModel.setPrice(tagListing.getSellingPrice());

			}

            if (mopVoilatedRetailerIds.contains(retailerId) || "almost new".equals(item.getBrand().toLowerCase())) {

				priceModel.setMop(false);

			}

		}

		return itemPriceMap;

	}

	@Override

	public Map<Float, GadgetCopsInsuranceCalc> getInsurancePrices(Set<Float> prices, String providerName) throws ProfitMandiBusinessException{

		insuranceProviderRepository.selectByName(providerName);

		Map<Float, GadgetCopsInsuranceCalc> pricesMap = new HashMap<>();

		if(ProfitMandiConstants.GADGET_COPS.equals(providerName)){

			List<GadgetCopsInsuranceCalc> gadgetCopsInsuranceCalcs = gadgetCopsInsuranceCalcRepository.selectAll();

			for(GadgetCopsInsuranceCalc gadgetCopsInsuranceCalc : gadgetCopsInsuranceCalcs){

				for(float price : prices){

					if(gadgetCopsInsuranceCalc.getPriceRangeMin()<= price && gadgetCopsInsuranceCalc.getPriceRangeMax() >= price){

						pricesMap.put(price, gadgetCopsInsuranceCalc);

					}

				}

			}

		}else{

			throw new ProfitMandiBusinessException(ProfitMandiConstants.PROVIDER_NAME, providerName, "INSRNC_PRVDR_1000");

		}

		return pricesMap;

	}

	@Override

    public Map<Integer, PriceModel> getPurchasePriceMopPriceNotFound(Set<Integer> itemIds, int retailerId) throws ProfitMandiBusinessException {

		return this.getMopPrices(itemIds, retailerId);

	}

	//Currently it only handles fofos

	@SuppressWarnings("unchecked")

    public List<Integer> getTagsIdsByRetailerId(int retailerId) throws ProfitMandiBusinessException {

		Set<Integer> pinCodeTagIds = tagService.getFofoTagIdsByPinCode("110001");

		Set<Integer> pinNegativeTagIds = tagService.getPinCodeNegativeTagIds();

		Set<Integer> pinCodeIntersection = new HashSet<>(CollectionUtils.intersection(pinCodeTagIds, pinNegativeTagIds));

		Set<Integer> validTagIds = new HashSet<>(CollectionUtils.subtract(pinNegativeTagIds, pinCodeIntersection));

		Set<Integer> pinPositiveTagIds = tagService.getPinCodePositiveTagIds();

		validTagIds.addAll(CollectionUtils.intersection(pinPositiveTagIds, pinCodeTagIds));

		if(validTagIds.isEmpty()){

			return new ArrayList<>(validTagIds);

		}

		Set<Integer> retailerTagIds = tagService.getUserTagIdsByTagIds(validTagIds);

		Set<Integer> userNegativeTagIds = tagService.getUserNegativeTagIds();

		Set<Integer> userIntersection = new HashSet<>(CollectionUtils.intersection(retailerTagIds, userNegativeTagIds));

		validTagIds = new HashSet<>(CollectionUtils.subtract(userNegativeTagIds, userIntersection));

		Set<Integer> userPositiveTagIds = tagService.getUserPositiveTagIds();

		validTagIds.addAll(CollectionUtils.intersection(userPositiveTagIds, retailerTagIds));

		return new ArrayList<>(validTagIds);

	}

}