Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.tag;

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

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

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

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

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

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

import com.spice.profitmandi.dao.enumuration.catalog.TagType;

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

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

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

import org.apache.commons.collections.CollectionUtils;

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

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

import org.springframework.cache.annotation.Cacheable;

import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

import java.util.*;

import java.util.stream.Collectors;

@Component

public class TagServiceImpl implements TagService {

	@Autowired

	private TagRepository tagRepository;

	@Autowired

	@Qualifier("catalogItemRepository")

	private ItemRepository itemRepository;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private RetailerTagRepository retailerTagRepository;

	@Autowired

	private VendorItemPricingRepository vendorItemPricingRepository;

	@Autowired

	private RetailerRepository retailerRepository;

	@Autowired

	private PinCodeTagRepository pinCodeTagRepository;

	@Override

	public void createTagListings(List<TagListingModel> tagListingModels) throws ProfitMandiBusinessException {

		if(tagListingModels.isEmpty()){

			throw new ProfitMandiBusinessException("tagListing", tagListingModels, "TGLSTNG_1001");

		}

		Set<Integer> tagIds = new HashSet<>();

		Set<Integer> itemIds = new HashSet<>();

		for(TagListingModel tagListingModel : tagListingModels){

			tagIds.add(tagListingModel.getTagId());

			itemIds.add(tagListingModel.getItemId());

		}

		List<Tag> tags = tagRepository.selectByIds(tagIds);

		if(tags.size() != tagIds.size()){

			Set<Integer> foundTagIds = new HashSet<>();

			for(Tag tag : tags){

				foundTagIds.add(tag.getId());

			}

			Collection<?> invalidTagIds = CollectionUtils.subtract(tagIds, foundTagIds);

			ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(ProfitMandiConstants.TAG_ID, invalidTagIds, "TG_1001");

			throw profitMandiBusinessException;

		}

		List<Item> items = itemRepository.selectByIds(itemIds);

		if(items.size() != itemIds.size()){

			Set<Integer> foundItemIds = new HashSet<>();

			for(Item item : items){

				foundItemIds.add(item.getId());

			}

			Collection<?> invalidItemIds = CollectionUtils.subtract(itemIds, foundItemIds);

			ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, invalidItemIds, "TG_1002");

			throw profitMandiBusinessException;

		}

		for(TagListingModel tagListingModel : tagListingModels){

			this.createTagListing(tagListingModel.getTagId(), tagListingModel.getItemId(), tagListingModel.getSellingPrice(), tagListingModel.getMop(), 

					tagListingModel.getSupportPrice(), tagListingModel.getMaxDiscountPrice(), tagListingModel.getStartDate());

		}

	}

	@Override

	public void createTagListing(int tagId, int itemId, float sellingPrice, float mop, float priceSupport, float maxDiscount, LocalDateTime startDate) {

		List<TagListing> tatListingList = tagListingRepository.selectByItemIdsAndTagIds(new HashSet<Integer>(Arrays.asList(itemId)), new HashSet<Integer>(Arrays.asList(tagId)));

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

			TagListing tagListing = new TagListing();

			tagListing.setActive(true);

			tagListing.setCreatedBy(1);

			tagListing.setItemId(itemId);

			tagListing.setSupportPrice(priceSupport);

			tagListing.setSellingPrice(sellingPrice);

			tagListing.setMop(mop);

			tagListing.setStartDate(startDate);

			tagListing.setTagId(tagId);

			tagListing.setMaxDiscountPrice(maxDiscount);

			tagListingRepository.persist(tagListing);

		} else {

			TagListing tl = tatListingList.get(0);

			tl.setSellingPrice(sellingPrice);

			tl.setMop(mop);

			tl.setSupportPrice(priceSupport);

			tl.setMaxDiscountPrice(maxDiscount);

			tagListingRepository.persist(tl);

		}

	}

	@Override

	public List<Retailer> getRetailersByTagId(int tagId) {

		List<RetailerTag> retailerTags = retailerTagRepository.selectByTagId(tagId);

		if(retailerTags.isEmpty()){

			return new ArrayList<>();

		}

		List<Integer> retailerIds = new ArrayList<>();

		for(RetailerTag retailerTag : retailerTags){

			retailerIds.add(retailerTag.getRetailerId());

		}

		return retailerRepository.selectByIds(retailerIds);

	}

	@Override

    public List<Tag> getTagsByPinCode(String pinCode) throws ProfitMandiBusinessException {

		Set<Integer> tagIds = this.getTagIdsByPinCode(pinCode);

		if(tagIds.isEmpty()){

			return new ArrayList<>();

		}

		return tagRepository.selectByIds(tagIds);

	}

	@Override

	public Set<Integer> getTagIdsByPinCode(String pinCode){

		List<PinCodeTag> pinCodeTags = pinCodeTagRepository.selectByPinCode(pinCode);

		Set<Integer> tagIds = new HashSet<>();

		for(PinCodeTag pinCodeTag : pinCodeTags){

			tagIds.add(pinCodeTag.getTagId());

		}

		return tagIds;

	}

	@Cacheable(value = "pinCodeByTagId", cacheManager = "timeoutCacheManager")

	@Override

	public Set<String> getPinCodesByTagId(int tagId) {

		List<PinCodeTag> pinCodeTags = pinCodeTagRepository.selectByTagId(tagId);

		Set<String> pinCodes = new HashSet<>();

		for(PinCodeTag pinCodeTag : pinCodeTags){

			pinCodes.add(pinCodeTag.getPinCode());

		}

		return pinCodes;

	}

	@Override

    public List<Tag> getTagsByRetailerId(int retailerId) throws ProfitMandiBusinessException {

		List<RetailerTag> retailerTags = retailerTagRepository.selectByRetailerId(retailerId);

		if(!retailerTags.isEmpty()){

			return new ArrayList<>();

		}

		Set<Integer> tagIds = new HashSet<>();

		for(RetailerTag retailerTag : retailerTags){

			tagIds.add(retailerTag.getTagId());

		}

		return tagRepository.selectByIds(tagIds);

	}

	@Override

    public Set<Integer> getFofoTagIdsByPinCode(String pinCode) throws ProfitMandiBusinessException {

		List<Tag> pinCodeTags = this.getTagsByPinCode(pinCode);

		Set<Integer> pinCodeTagIds = new HashSet<>();

		for(Tag tag : pinCodeTags){

			if(tag.getType() == TagType.FOFO){

				pinCodeTagIds.add(tag.getId());

			}

		}

		return pinCodeTagIds;

	}

	private Map<Integer, Map<String, Object>> createTagsMap(List<Tag> tags){

		Map<Integer, Map<String, Object>> tagsMap = new HashMap<>();

		for(Tag tag: tags){

			if(!tagsMap.containsKey(tag.getId())){

				Map<String, Object> tagMap = new HashMap<>();

				tagMap.put(ProfitMandiConstants.LABEL, tag.getLabel());

				tagMap.put(ProfitMandiConstants.CREATED_BY, tag.getCreatedBy());

				tagMap.put(ProfitMandiConstants.CREATE_TIMESTAMP, tag.getCreateTimestamp());

				tagMap.put(ProfitMandiConstants.DESCRIPTION, tag.getDescription());

				tagMap.put(ProfitMandiConstants.TYPE, tag.getType());

				tagMap.put(ProfitMandiConstants.UPDATE_TIMESTAMP, tag.getUpdateTimestamp());

				tagsMap.put(tag.getId(), tagMap);

			}

		}

		return tagsMap;

	}

	private Map<Integer, Map<String, Object>> createItemsMap(List<Item> items){

		Map<Integer, Map<String, Object>> itemsMap = new HashMap<>();

		for(Item item: items){

			if(!itemsMap.containsKey(item.getId())){

				Map<String, Object> itemMap = new HashMap<>();

				itemMap.put(ProfitMandiConstants.BRAND, item.getBrand());

				itemMap.put(ProfitMandiConstants.MODEL_NAME, item.getModelName());

				itemMap.put(ProfitMandiConstants.MODEL_NUMBER, item.getModelNumber());

				itemMap.put(ProfitMandiConstants.COLOR, item.getColor());

				itemsMap.put(item.getId(), itemMap);

			}

		}

		return itemsMap;

	}

	@Override

    public List<Map<String, Object>> getTagListingDetail(int tagId) throws ProfitMandiBusinessException {

		List<TagListing> tagListings = tagListingRepository.selectByTagId(tagId);

		List<Map<String, Object>> tagListingsList = new ArrayList<>();

		if(tagListings.isEmpty()){

			return new ArrayList<>();

		}

		Set<Integer> tagIds = new HashSet<>();

		Set<Integer> itemIds = new HashSet<>();

		for(TagListing tagListing : tagListings){

			tagIds.add(tagListing.getTagId());

			itemIds.add(tagListing.getItemId());

		}

		List<Tag> tags = tagRepository.selectByIds(tagIds);

		Map<Integer, List<VendorItemPricing>> itemVipsMap = vendorItemPricingRepository.selectAll(new ArrayList<>(itemIds)).stream().collect(

				Collectors.groupingBy(x->x.getItemId(), Collectors.toList()));

		Map<Integer, Map<String, Object>> tagsMap = this.createTagsMap(tags);

		for(TagListing tagListing : tagListings){

			Map<String, Object> tagListingMap = new HashMap<>();

			tagListingMap.put(ProfitMandiConstants.CREATED_BY, tagListing.getCreatedBy());

			tagListingMap.put(ProfitMandiConstants.CREATE_TIMESTAMP, tagListing.getCreatedTimestamp());

			if(itemVipsMap.get(tagListing.getItemId())!=null) {

				tagListingMap.put("TP", itemVipsMap.get(tagListing.getItemId()).get(0).getTp());

			} else {

				tagListingMap.put("TP", null);

			}

			tagListingMap.put(ProfitMandiConstants.SELLING_PRICE, tagListing.getSellingPrice());

			tagListingMap.put(ProfitMandiConstants.MOP, tagListing.getMop());

			tagListingMap.put(ProfitMandiConstants.START_DATE, tagListing.getStartDate());

			tagListingMap.put(ProfitMandiConstants.SUPPORT_PRICE, tagListing.getSupportPrice());

			tagListingMap.put(ProfitMandiConstants.MAX_DISCOUNT, tagListing.getMaxDiscountPrice());

			tagListingMap.put(ProfitMandiConstants.ITEM_ID, tagListing.getItemId());

			tagListingMap.put(ProfitMandiConstants.TAG_ID, tagListing.getTagId());

			tagListingMap.put(ProfitMandiConstants.TAG, tagsMap.get(tagListing.getTagId()));

			tagListingMap.put(ProfitMandiConstants.ACTIVE, String.valueOf(tagListing.isActive()));

			tagListingsList.add(tagListingMap);

		}

		return tagListingsList;

	}

	private Set<Integer> toTagIds(List<Tag> tags){

		if(tags.isEmpty()){

			return new HashSet<>();

		}

		Set<Integer> tagIds = new HashSet<>();

		for(Tag tag : tags){

			tagIds.add(tag.getId());

		}

		return tagIds;

	}

	@Cacheable(value = "pinCodeNegativesTagIds", cacheManager = "timeoutCacheManager")

	@Override

	public Set<Integer> getPinCodeNegativeTagIds() {

		List<Tag> tags = tagRepository.selectAllByPinAll(true);

		return this.toTagIds(tags);

	}

	@Cacheable(value = "pinCodePositiveTagIds", cacheManager = "timeoutCacheManager")

	@Override

	public Set<Integer> getPinCodePositiveTagIds() {

		List<Tag> tags = tagRepository.selectAllByPinAll(false);

		return this.toTagIds(tags);

	}

	@Cacheable(value = "userNegativesTagIds", cacheManager = "timeoutCacheManager")

	@Override

	public Set<Integer> getUserNegativeTagIds() {

		List<Tag> tags = tagRepository.selectAllByUserAll(true);

		return this.toTagIds(tags);

	}

	@Cacheable(value = "userPositiveTagIds", cacheManager = "timeoutCacheManager")

	@Override

	public Set<Integer> getUserPositiveTagIds() {

		List<Tag> tags = tagRepository.selectAllByUserAll(false);

		return this.toTagIds(tags);

	}

	@Override

    public Set<Integer> getUserTagIdsByTagIds(Set<Integer> tagIds) throws ProfitMandiBusinessException {

		List<RetailerTag> retailerTags = retailerTagRepository.selectByTagIds(tagIds);

		Set<Integer> retailerTagIds = new HashSet<>();

		if(retailerTags.isEmpty()){

			return retailerTagIds;

		}

		for(RetailerTag retailerTag : retailerTags){

			retailerTagIds.add(retailerTag.getTagId());

		}

		return retailerTagIds;

	}

}