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<>();
         }
        }




}