Subversion Repositories SmartDukaan

Rev

Rev 34454 | Rev 34472 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 34454 Rev 34456
Line 1998... Line 1998...
1998 
        Map<Integer, Integer> currentInventorySnapshot = currentInventorySnapshotRepository.selectByFofoId(fofoId)
 1998 
        Map<Integer, Integer> currentInventorySnapshot = currentInventorySnapshotRepository.selectByFofoId(fofoId)
1999 
                .stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
 1999 
                .stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
2000 
 
 2000 
 
2001 
 
 2001 
 
2002 
        if (!currentInventorySnapshot.isEmpty()) {
 2002 
        if (!currentInventorySnapshot.isEmpty()) {
2003 
           /* as of now its commented showed all brand data
 - 
 
2004 
            if (!brand.equals("undefined") && !brand.equals("accessories") && !brand.equals("TV")) {
 - 
 
2005 
                catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
 - 
 
2006 
                        .filter(x -> x.getBrand().equals(brand))
 - 
 
2007 
                        .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
 - 
 
2008 
                                Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
 - 
 
2009 
 
 - 
 
2010 
            } else {
 - 
 
2011 
                catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
 - 
 
2012 
                        .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
 - 
 
2013 
                                Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
 - 
 
2014 
            }*/
 - 
 
2015 
            catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
 2003 
            catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
2016 
                    .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
 2004 
                    .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
2017 
                            Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
 2005 
                            Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
2018 
            inStocks.addAll(getBrandItemwiseDescription(brand, catalogIdAndQtyMap));
 2006 
            inStocks.addAll(getBrandItemwiseDescription(brand, catalogIdAndQtyMap));
2019 
            inStocksDescriptionModelMap = inStocks.stream().collect(Collectors.toMap(x -> x.getItemDescription(), x -> x));
 2007 
            inStocksDescriptionModelMap = inStocks.stream().collect(Collectors.toMap(x -> x.getItemDescription(), x -> x));
Line 2021... Line 2009...
2021 
 
 2009 
 
2022 
        Map<Integer, Integer> grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoId).stream()
 2010 
        Map<Integer, Integer> grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoId).stream()
2023 
                .collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
 2011 
                .collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
2024 
                        Collectors.summingInt(x -> x.getLineItem().getQuantity())));
 2012 
                        Collectors.summingInt(x -> x.getLineItem().getQuantity())));
2025 
        if (!grnPendingOrders.isEmpty()) {
 2013 
        if (!grnPendingOrders.isEmpty()) {
2026 
 
 - 
 
2027 
           /* if (!brand.equals("undefined") && !brand.equals("accessories") && !brand.equals("TV")) {
 - 
 
2028 
                grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
 - 
 
2029 
                        .filter(x -> x.getBrand().equals(brand))
 - 
 
2030 
                        .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
 - 
 
2031 
                                Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
 - 
 
2032 
 
 - 
 
2033 
            } else {
 - 
 
2034 
                grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
 - 
 
2035 
                        .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
 - 
 
2036 
                                Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
 - 
 
2037 
            }*/
 - 
 
2038 
            grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
 2014 
            grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
2039 
                    .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
 2015 
                    .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
2040 
                            Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
 2016 
                            Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
2041 
            grnPendings.addAll(getBrandItemwiseDescription(brand, grnPendingOrdersMap));
 2017 
            grnPendings.addAll(getBrandItemwiseDescription(brand, grnPendingOrdersMap));
2042 
            grnPendingsDescriptionModelMap = grnPendings.stream().collect(Collectors.toMap(x -> x.getItemDescription(), x -> x));
 2018 
            grnPendingsDescriptionModelMap = grnPendings.stream().collect(Collectors.toMap(x -> x.getItemDescription(), x -> x));
Line 2045... Line 2021...
2045 
 
 2021 
 
2046 
        Map<Integer, Integer> processingOrder = orderRepository.selectOrders(fofoId, orderStatusList).stream()
 2022 
        Map<Integer, Integer> processingOrder = orderRepository.selectOrders(fofoId, orderStatusList).stream()
2047 
                .collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
 2023 
                .collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
2048 
                        Collectors.summingInt(x -> x.getLineItem().getQuantity())));
 2024 
                        Collectors.summingInt(x -> x.getLineItem().getQuantity())));
2049 
        if (!processingOrder.isEmpty()) {
 2025 
        if (!processingOrder.isEmpty()) {
2050 
           /* if (!brand.equals("undefined") && !brand.equals("accessories") && !brand.equals("TV")) {
 - 
 
2051 
                processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
 - 
 
2052 
                        .filter(x -> x.getBrand().equals(brand)).collect(Collectors.groupingBy(
 - 
 
2053 
                                x -> x.getCatalogItemId(), Collectors.summingInt(x -> processingOrder.get(x.getId()))));
 - 
 
2054 
 
 - 
 
2055 
            } else {
 - 
 
2056 
                processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
 - 
 
2057 
                        .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
 - 
 
2058 
                                Collectors.summingInt(x -> processingOrder.get(x.getId()))));
 - 
 
2059 
            }*/
 - 
 
2060 
            processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
 2026 
            processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
2061 
                    .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
 2027 
                    .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
2062 
                            Collectors.summingInt(x -> processingOrder.get(x.getId()))));
 2028 
                            Collectors.summingInt(x -> processingOrder.get(x.getId()))));
2063 
            pendingIndents.addAll(getBrandItemwiseDescription(brand, processingOrderMap));
 2029 
            pendingIndents.addAll(getBrandItemwiseDescription(brand, processingOrderMap));
2064 
            pendingIndentsDescriptionModelMap = pendingIndents.stream().collect(Collectors.toMap(x -> x.getItemDescription(), x -> x));
 2030 
            pendingIndentsDescriptionModelMap = pendingIndents.stream().collect(Collectors.toMap(x -> x.getItemDescription(), x -> x));
Line 2070... Line 2036...
2070 
        LOGGER.info("regionIds" + regionIds);
 2036 
        LOGGER.info("regionIds" + regionIds);
2071 
        if (regionIds.size() == 0) {
 2037 
        if (regionIds.size() == 0) {
2072 
            LOGGER.info("No region found for partner {}", fofoId);
 2038 
            LOGGER.info("No region found for partner {}", fofoId);
2073 
 
 2039 
 
2074 
        }
 2040 
        }
- 
 
 2041 
 
- 
 
 2042 
//        this code is using for focusedModel()
2075 
        Map<Integer, Optional<Integer>> focusedCatalogIdAndQtyMap = focusedModelRepository
 2043 
        Map<Integer, Optional<Integer>> focusedCatalogIdAndQtyMap = focusedModelRepository
2076 
                .selectAllByRegionIds(regionIds).stream().collect(Collectors.groupingBy(FocusedModel::getCatalogId,
 2044 
                .selectAllByRegionIds(regionIds).stream().collect(Collectors.groupingBy(FocusedModel::getCatalogId,
2077 
                        Collectors.mapping(FocusedModel::getObsMinimumQty, Collectors.maxBy(Integer::compareTo))));
 2045 
                        Collectors.mapping(FocusedModel::getObsMinimumQty, Collectors.maxBy(Integer::compareTo))));
2078 
 
 2046 
 
2079 
        for (Map.Entry<Integer, Optional<Integer>> entry : focusedCatalogIdAndQtyMap.entrySet()) {
 2047 
        for (Map.Entry<Integer, Optional<Integer>> entry : focusedCatalogIdAndQtyMap.entrySet()) {