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.CurrentInventorySnapshot;

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

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

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

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.ActivatedImeiRepository;

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

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

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

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.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

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

    InventoryItemRepository inventoryItemRepository;

    @Autowired

    CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    @Autowired

    FofoOpeningStockRepository fofoOpeningStockRepository;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private SaholicInventoryService saholicInventoryService;

    @Autowired

    private ActivatedImeiRepository activatedImeiRepository;

    @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);

        } else {

            FofoOpeningStock newOpeningStock = new FofoOpeningStock();

            newOpeningStock.setFofoId(fofoId);

            newOpeningStock.setCatalogId(catalogId);

            newOpeningStock.setOpeningDate(LocalDate.now());

            newOpeningStock.setOpeningQty(quantity);

            newOpeningStock.setCurrentQty(quantity);

            fofoOpeningStockRepository.persist(newOpeningStock);

        }

    }

    @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 = Math.max(fofoOpeningStock.getCurrentQty() - quantity, 0);

            fofoOpeningStock.setCurrentQty(updatedQty);

        }

    }

    @Override

    public void minusOpeningStockBatch(Map<Integer, Integer> itemIdQuantityMap, int fofoId) throws ProfitMandiBusinessException {

        if (itemIdQuantityMap == null || itemIdQuantityMap.isEmpty()) {

            return;

        }

        // Batch fetch all items - 1 DB call instead of N

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

        // Build itemId -> catalogId map

        Map<Integer, Integer> itemToCatalogMap = items.stream()

                .collect(Collectors.toMap(Item::getId, Item::getCatalogItemId));

        // Get unique catalogIds and build catalogId -> quantity map

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

        for (Map.Entry<Integer, Integer> entry : itemIdQuantityMap.entrySet()) {

            Integer catalogId = itemToCatalogMap.get(entry.getKey());

            if (catalogId != null) {

                catalogQuantityMap.merge(catalogId, entry.getValue(), Integer::sum);

            }

        }

        // Batch fetch all FofoOpeningStock records - 1 DB call instead of N

        List<FofoOpeningStock> openingStocks = fofoOpeningStockRepository.findByFofoIdAndCatalogIds(

                fofoId, catalogQuantityMap.keySet());

        // Update each opening stock

        for (FofoOpeningStock openingStock : openingStocks) {

            Integer quantityToSubtract = catalogQuantityMap.get(openingStock.getCatalogId());

            if (quantityToSubtract != null) {

                openingStock.setCurrentQty(Math.max(openingStock.getCurrentQty() - quantityToSubtract, 0));

            }

        }

    }

    @Override

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

        LocalDateTime todayDate = LocalDate.now().atStartOfDay();

        LocalDateTime fortyFiveAgoDate = todayDate.minusDays(45).with(LocalTime.MAX);

        List<SoldAllCatalogitemQtyByPartnerModel> soldAllCatalogitemQtyByPartnerModels = this.getAllSoldCatalogItemByPartner(fofoId,fortyFiveAgoDate,todayDate);

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

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

            return new HashSet<>();

        }

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

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

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

        List<CurrentInventorySnapshot> currentInventorySnapshots =  currentInventorySnapshotRepository.selectByFofoItemIds(fofoId,soldItemIds);

        Set<Integer> instockItemIds = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0).map(x->x.getItemId()).collect(Collectors.toSet());

        if(instockItemIds.size() > 0) {

                Set<Integer> filteredCatalogIds = itemRepository.selectByIds(instockItemIds).stream().map(x->x.getCatalogItemId()).collect(Collectors.toSet());

//            this logis has been stop as of now we are not checking that sold catalog is avaialable or not in our stock

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

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

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

            }*/

            return  filteredCatalogIds;

          } else {

            return new HashSet<>();

         }

        }

    @Override

    public Map<Integer, Map<Integer, Integer>> activatedButNotBilledCatalogQtyMap() throws ProfitMandiBusinessException {

        List<FofoStore> fofoStores = fofoStoreRepository.selectAll();

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

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

        for (Integer fofoId : fofoIds) {

            List<InventoryItem> inventoryItems = inventoryItemRepository.selectByActivatedNotSold(fofoId);

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

            for (InventoryItem inventoryitem : inventoryItems) {

                Item item = itemRepository.selectById(inventoryitem.getItemId());

                Integer catalogId = item.getCatalogItemId(); // Assuming this exists

                catalogIdQtyMap.put(catalogId, catalogIdQtyMap.getOrDefault(catalogId, 0) + 1);

            }

            fofoCatalogQtyMap.put(fofoId, catalogIdQtyMap);

        }

        //System.out.println("fofoCatalogQtyMap {}" + fofoCatalogQtyMap);

        return fofoCatalogQtyMap;

    }

}