Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.catalog;

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

import com.spice.profitmandi.common.web.client.RestClient;

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

import com.spice.profitmandi.dao.entity.fofo.FofoStore;

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

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

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

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

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

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.stereotype.Component;

import java.util.*;

import java.util.stream.Collectors;

@Component

public class ComboServiceImpl implements ComboService {

    @Autowired

    CartLineRepository cartLineRepository;

    @Autowired

    ItemRepository itemRepository;

    @Autowired

    CatalogRepository catalogRepository;

    @Autowired

    UserRepository userRepository;

    @Autowired

    FofoStoreRepository fofoStoreRepository;

    @Autowired

    ComboModelRepository comboModelRepository;

    @Autowired

    ComboOptionRepository comboOptionRepository;

    @Autowired

    ComboMappedModelRepository comboMappedModelRepository;

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

    @Override

    public boolean validateCombo(UserCart userCart) throws ProfitMandiBusinessException {

        Map<Integer, Integer> itemQtyMap = cartLineRepository.selectAllByCart(userCart.getCartId()).stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getQuantity()));

        LOGGER.info("itemQtyMap - {}", itemQtyMap);

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

        Set<Integer> focModelSet = items.stream().filter(x -> x.getBrand().equals("FOC")).map(x -> x.getCatalogItemId()).collect(Collectors.toSet());

        Map<Integer, Integer> catalogIdCartQtyMap = items.stream().collect(Collectors.groupingBy(x -> x.getCatalogItemId(), Collectors.summingInt(x -> itemQtyMap.get(x.getId()))));

        FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(userCart.getUserId());

        List<ComboModel> comboModelList = comboModelRepository.selectByCatalogIdsAndWarehouseId(new ArrayList<>(catalogIdCartQtyMap.keySet()), fofoStore.getWarehouseId());

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

            return false;

        }

        Map<Integer, List<ComboModel>> comboMap = comboModelList.stream().collect(Collectors.groupingBy(x -> x.getCatalogId()));

        for (Map.Entry<Integer, List<ComboModel>> comboEntry : comboMap.entrySet()) {

            int catalogId = comboEntry.getKey();

            List<ComboModel> comboModels = comboEntry.getValue();

            ComboModel filteredModel = comboModels.stream().filter(x -> x.getQty() == catalogIdCartQtyMap.get(catalogId)).findAny().orElse(null);

            if (filteredModel == null) {

                throw new ProfitMandiBusinessException("Combo Quantity mismatched", "Combo Quantity mismatched", "Combo Quantity mismatched");

            }

            List<ComboOption> comboOptions = comboOptionRepository.selectByComboId(filteredModel.getId());

            List<ComboMappedModel> comboMappedModels = comboMappedModelRepository.selectByComboOptionId(comboOptions.get(0).getId());

            for (ComboMappedModel comboMappedModel : comboMappedModels) {

                int secondaryCatalogId = comboMappedModel.getComboCatalogId();

                int requiredQty = comboMappedModel.getComboQty();

                LOGGER.info("catalogIdCartQtyMap.get(secondaryCatalogId) - {}", catalogIdCartQtyMap.get(secondaryCatalogId));

                if (!catalogIdCartQtyMap.containsKey(secondaryCatalogId) || requiredQty > catalogIdCartQtyMap.get(secondaryCatalogId)) {

                    Catalog catalog = catalogRepository.selectCatalogById(catalogId);

                    throw new ProfitMandiBusinessException("Missing required Qty for Combo", "", "Missing required qty for Combo - " + catalog.getDescription());

                } else {

                    catalogIdCartQtyMap.put(secondaryCatalogId, catalogIdCartQtyMap.get(secondaryCatalogId) - requiredQty);

                }

            }

        }

        for (int focModel : focModelSet) {

            int qtyLeft = catalogIdCartQtyMap.get(focModel);

            if (qtyLeft != 0) {

                throw new ProfitMandiBusinessException("FOC items cant be billed above Combo Qty", "FOC", "FOC items cant be billed above Combo Qty");

            }

        }

        return true;

    }

}