Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.cart;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

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

import com.spice.profitmandi.common.util.FormattingUtils;

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.entity.user.Cart;

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

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

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

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

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

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

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

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

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

public class CartServiceImpl implements CartService {

	private static final Set<Integer> tagIds = new HashSet<>(Arrays.asList(4));

	@Autowired

	CartRepository cartRepository;

	@Autowired

	CartItemRepository cartItemRepository;

	@Autowired

	FofoStoreRepository fofoStoreRepository;

	@Autowired

	TagListingRepository tagListingRepository;

	@Autowired

	UserRepository saholicUserRepository;

	@Autowired

	ItemRepository itemRepository;

	@Autowired

	CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Override

	public CartModel addToCart(int cartId, int itemId, int quantity, float sellingPrice) {

		CartItem cartItem = cartItemRepository.selectByCartItem(cartId, itemId);

		if (cartItem == null) {

			this.createCartItem(cartId, itemId, quantity, sellingPrice);

		} else {

			cartItem.setQuantity(quantity);

			cartItem.setActualPrice(sellingPrice);

		}

		return null;

	}

	private void createCartItem(int cartId, int itemId, int quantity, float sellingPrice) {

		CartItem cartItem = new CartItem();

		cartItem.setActualPrice(sellingPrice);

		cartItem.setCartId(cartId);

		cartItem.setQuantity(quantity);

		// TODO: Estmiate Logic

		cartItem.setEstimate(2);

		cartItemRepository.persist(cartItem);

	}

	@Override

	public CartModel removeFromCart(int cartId, int itemId) {

		CartItem cartItem = cartItemRepository.selectByCartItem(cartId, itemId);

		if (cartItem != null) {

			cartItemRepository.delete(cartItem);

		}

		return this.validateCart(cartId);

	}

	@Override

	public void clearCart(int cartId) {

		List<CartItem> cartItems = cartItemRepository.selectAllByCartId(cartId);

		cartItems.stream().forEach(cartItem -> cartItemRepository.delete(cartItem));

	}

	@Override

	public CartModel getCart(int cartId) {

		// TODO Auto-generated method stub

		return null;

	}

	private CartModel validateCart(int cartId) {

		CartModel cartModel = null;

		try {

			Cart cart = cartRepository.selectById(cartId);

			User user = saholicUserRepository.selectByCartId(cartId);

			List<CartItem> cartItems = cartItemRepository.selectAllByCartId(cartId);

			cartModel = new CartModel();

			List<CartItemModel> cartItemModels = new ArrayList<>();

			Set<Integer> itemIds = cartItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());

			boolean isFofo = true;

			Map<Integer, Item> itemsMap = itemRepository.selectByIds(itemIds).stream()

					.collect(Collectors.toMap(x -> x.getId(), x -> x));

			Map<Integer, Float> priceMap = this.getPriceMap(user, itemIds);

			Map<Integer, Integer> availabilityMap = this.getAvailabilityMap(user, itemIds);

			for (CartItem cartItem : cartItems) {

				try {

					CartItemModel cartItemModel = new CartItemModel();

					cartItemModel.setItemId(cartItem.getItemId());

					Item item = itemsMap.get(cartItem.getItemId());

					cartItemModel.setTitle(item.getItemDescription());

					float currentSellingPrice = priceMap.get(cartItem.getItemId());

					if (currentSellingPrice != cartItem.getActualPrice()) {

						CartItemMessage cartItemMessage = new CartItemMessage();

						int diffPrice = (int) (currentSellingPrice - cartItem.getActualPrice());

						String diff = currentSellingPrice - cartItem.getActualPrice() > 0 ? "increased" : "decreased";

						cartItem.setActualPrice(cartItem.getActualPrice());

						cartItemMessage.setMessageText("Pricing have been " + diff + "by Rs."

								+ FormattingUtils.formatDecimalTwoDigits(Math.abs(diffPrice)));

						cartItemMessage.setType("info");

					}

					cartItemModel.setSellingPrice(cartItem.getActualPrice());

					// Check stock availability and check if stock is active

				} catch (Exception e) {

				}

			}

		} catch (Exception e) {

			e.printStackTrace();

		}

		return cartModel;

	}

	// As of now it only works for Fofo Partners need to be refactored later

	private Map<Integer, Integer> getAvailabilityMap(User user, Set<Integer> itemIds) {

		Map<Integer, Integer> itemAvailabilityMap = new HashMap<>();

		List<TagListing> tags = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds);

		tags.stream().forEach(tagListing -> {

			if (!tagListing.isActive() || tagListing.isHotDeals()) {

				// show actual values here

			} else {

				itemAvailabilityMap.put(tagListing.getItemId(), 100);

			}

		});

		return itemAvailabilityMap;

	}

	// As of now it only works for Fofo Partners need to be refactored later

	private Map<Integer, Integer> getMinBuyQtyMap(User user, Set<Integer> itemIds) {

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

		return items.stream().collect(Collectors.toMap(x -> x.getId(), x -> x.getCategoryId() == 10020 ? 1 : 10));

	}

	// As of now it only works for Fofo Partners need to be refactored later

	private Map<Integer, Float> getPriceMap(User user, Set<Integer> itemIds) {

		List<TagListing> tags = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds);

		return tags.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getSellingPrice()));

	}

}