Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.cart;

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.model.WarehouseItemQtyModel;

import com.spice.profitmandi.service.inventory.SaholicInventoryService;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

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

import org.springframework.stereotype.Component;

import javax.persistence.TypedQuery;

import java.time.LocalDateTime;

import java.util.*;

import java.util.stream.Collectors;

@Component

public class SmartCartServiceImpl implements SmartCartService {

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

    private static final Logger logger = LogManager.getLogger(SmartCartServiceImpl.class);

    @Autowired

    SessionFactory sessionFactory;

    @Autowired

    ItemRepository itemRepository;

    @Autowired

    CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    @Autowired

    FofoOpeningStockRepository fofoOpeningStockRepository;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private SaholicInventoryService saholicInventoryService;

    @Override

    public List<SoldFocusedItemPartnerWiseModel> getAllSoldFocusModelByPartner(int fofoId, LocalDateTime orderDate){

        Session session = sessionFactory.getCurrentSession();

        final TypedQuery<SoldFocusedItemPartnerWiseModel> typedQuerySimilar = session.createNamedQuery("Focused.soldFocusItemByPartner", SoldFocusedItemPartnerWiseModel.class);

        typedQuerySimilar.setParameter("fofoId", fofoId);

        typedQuerySimilar.setParameter("orderDate", orderDate);

        return typedQuerySimilar.getResultList();

    }

    @Override

    public List<SoldAllCatalogitemQtyByPartnerModel> getAllSoldCatalogItemByPartner(int fofoId, LocalDateTime startOfday, LocalDateTime endOfDay){

        Session session = sessionFactory.getCurrentSession();

        final TypedQuery<SoldAllCatalogitemQtyByPartnerModel> typedQuerySimilar = session.createNamedQuery("FofoOrder.soldAllItemByToday", SoldAllCatalogitemQtyByPartnerModel.class);

        typedQuerySimilar.setParameter("fofoId", fofoId);

        typedQuerySimilar.setParameter("startOfDay", startOfday);

        typedQuerySimilar.setParameter("endOfDay", endOfDay);

        return typedQuerySimilar.getResultList();

    }

    @Override

    public List<PoAndGrnPendingPartnerStockModel> getAllGrnPendingAndPoPartnerStock(int fofoId){

        Session session = sessionFactory.getCurrentSession();

        final TypedQuery<PoAndGrnPendingPartnerStockModel> typedQuerySimilar = session.createNamedQuery("Order.partnerStockPoAndGrnPending", PoAndGrnPendingPartnerStockModel.class);

        typedQuerySimilar.setParameter("fofoId", fofoId);

        return typedQuerySimilar.getResultList();

    }

    @Override

    public void addOpeningStock(int itemId, int fofoId, int quantity) throws ProfitMandiBusinessException{

        int catalogId = itemRepository.selectById(itemId).getCatalogItemId();

        FofoOpeningStock fofoOpeningStock = fofoOpeningStockRepository.findByFofoIdAndCatalogId(fofoId,catalogId);

        if(fofoOpeningStock !=null){

            int updatedQty = fofoOpeningStock.getCurrentQty() + quantity;

            fofoOpeningStock.setCurrentQty(updatedQty);

        }

    }

    @Override

    public void minusOpeningStock(int itemId, int fofoId, int quantity) throws ProfitMandiBusinessException{

        int catalogId = itemRepository.selectById(itemId).getCatalogItemId();

        FofoOpeningStock fofoOpeningStock = fofoOpeningStockRepository.findByFofoIdAndCatalogId(fofoId,catalogId);

        if(fofoOpeningStock !=null){

            int updatedQty = fofoOpeningStock.getCurrentQty() - quantity;

            fofoOpeningStock.setCurrentQty(updatedQty);

        }

    }

    @Override

    public Set<Integer> getAllItemIdsForSmartCartOfPartner(int fofoId) throws ProfitMandiBusinessException {

        List<FofoOpeningStock> fofoOpeningStocks = fofoOpeningStockRepository.selectAllByFofoId(fofoId);

        List<FofoOpeningStock> filteredFofoOpeningStocks = fofoOpeningStocks.stream()

                .filter(stock -> stock.getCurrentQty() < stock.getOpeningQty())

                .collect(Collectors.toList());

        logger.info("filteredFofoOpeningStocks {}",filteredFofoOpeningStocks);

        if(filteredFofoOpeningStocks.size() > 0) {

            Set<Integer> filteredCatalogIds = filteredFofoOpeningStocks.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());

            List<Item> soldItems = itemRepository.selectAllByCatalogIds(filteredCatalogIds);

            List<Integer> soldItemIds = soldItems.stream().map(x -> x.getId()).collect(Collectors.toList());

//        now logic start for check our (smart dukaan) stock item

            FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

            Map<Integer, List<WarehouseItemQtyModel>> itemQtyMap = saholicInventoryService.getSaholicStock(fofoStore.getWarehouseId(), soldItemIds);

            // Collect items where availability is greater than 0

            Set<Integer> saholicStockItemIds = itemQtyMap.entrySet().stream()

                    .filter(entry -> entry.getValue().stream().anyMatch(x -> x.getNetAvailability() > 0))

                    .map(Map.Entry::getKey)

                    .collect(Collectors.toSet());

            if (saholicStockItemIds.size() > 0) {

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

                Set<Integer> saholictStockCatalogIds = items.stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet());

                return saholictStockCatalogIds;

            } else {

                return new HashSet<>();

            }

          } else {

            return new HashSet<>();

         }

        }

}