WebSVN – SmartDukaan – Diff – /trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/ScheduledTasks.java

 import java.util.Map.Entry;
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.mapping;
 @Component
 @Transactional(rollbackFor = Throwable.class)
 public class ScheduledTasks {
     @Value("${oxigen.recharge.transaction.url}")
         rechargeProviders.stream().forEach(x -> x.setAmount(0));
         rechargeProviders.stream().forEach(x -> {
             Map<LocalDate, List<RechargeProviderCreditWalletHistory>> dateWiseProviderCreditsMap = allCreditHistory
                     .stream().filter(z -> z.getProviderId() == x.getId())
-                    .collect(Collectors.groupingBy(x1 -> x1.getReceiveTimestamp().toLocalDate()));
+                    .collect(groupingBy(x1 -> x1.getReceiveTimestamp().toLocalDate()));
             LOGGER.info("dateWiseProviderCreditsMap -{}", dateWiseProviderCreditsMap);
             LocalDate endDate = LocalDate.now().plusDays(1);
             float previousDayClosing = 0;
             LocalDate date = LocalDate.of(2018, 4, 6);
     // TemporaryMethod
     public void migrateInvoice() {
         List<FofoOrder> fofoOrders = fofoOrderRepository.selectFromSaleDate(LocalDateTime.now().minusDays(3));
         Map<Integer, List<FofoOrder>> partnerOrdersMap = new HashMap<>();
         partnerOrdersMap = fofoOrders.stream()
-                .collect(Collectors.groupingBy(FofoOrder::getFofoId, Collectors.toList()));
+                .collect(groupingBy(FofoOrder::getFofoId, Collectors.toList()));
         for (List<FofoOrder> orderList : partnerOrdersMap.values()) {
             int sequence = 0;
             String prefix = "";
             List<FofoOrder> sortedList = orderList.stream().sorted((x1, x2) -> x1.getId() - x2.getId())
                     .collect(Collectors.toList());
         LocalDateTime cashbackTime = LocalDateTime.now();
         int referenceId = (int) Timestamp.valueOf(cashbackTime).getTime() / 1000;
         List<RechargeTransaction> pendingTransactions = rechargeTransactionRepository
                 .getPendingCashBackRehargeTransactions();
         Map<Object, Double> totalRetailerCashbacks = pendingTransactions.stream().collect(
-                Collectors.groupingBy(x -> x.getRetailerId(), Collectors.summingDouble(x -> x.getCommission())));
+                groupingBy(x -> x.getRetailerId(), Collectors.summingDouble(x -> x.getCommission())));
         for (Map.Entry<Object, Double> totalRetailerCashback : totalRetailerCashbacks.entrySet()) {
             int retailerId = (Integer) totalRetailerCashback.getKey();
             float amount = totalRetailerCashback.getValue().floatValue();
             if (Math.round(amount) > 0) {
                 walletService.addAmountToWallet(retailerId, referenceId, WalletReferenceType.CASHBACK,
         Map<Integer, List<?>> partnerRowsMap = new HashMap<>();
         Map<Integer, FofoReportingModel> partnerIdSalesHeaderMap = this.getPartnerIdSalesHeaders();
         Map<Integer, Integer> shortDaysMap = partnerDailyInvestmentRepository
-                .selectAll(LocalDate.now().withDayOfMonth(1), LocalDate.now()).stream().collect(Collectors.groupingBy(
+                .selectAll(LocalDate.now().withDayOfMonth(1), LocalDate.now()).stream().collect(groupingBy(
                         x -> x.getFofoId(), Collectors.summingInt(x -> x.getShortPercentage() > 10 ? 1 : 0)));
         for (FofoStore fofoStore : fofoStores) {
             LOGGER.info("Fofo Store {},  {}", fofoStore.getId(), fofoStore.getCode());
             int fofoId = fofoStore.getId();
         List<EmployeeAttendance> employeeAttendances = employeeAttendanceRepository
                 .selectAllByDatesBetween(LocalDate.now().atStartOfDay(), LocalDateTime.now());
         Map<Integer, Optional<EmployeeAttendance>> employeeMorningAttendance = employeeAttendances.stream()
-                .collect(Collectors.groupingBy(EmployeeAttendance::getUserId,
+                .collect(groupingBy(EmployeeAttendance::getUserId,
                         Collectors.minBy(Comparator.comparing(EmployeeAttendance::getCreateTimestamp))));
         for (AuthUser authUser : authUsers) {
             User user = userMap.get(authUser.getEmailId());
             Optional<EmployeeAttendance> employeeAttendanceOptional = employeeMorningAttendance.get(user.getId());
             LOGGER.info("AuthUser - {}, employeeAttendanceOptional {}", authUser.getName(), employeeAttendanceOptional);
         List<User> users = dtrUserRepository.selectAllByEmailIds(new ArrayList<>(authUserEmailMap.keySet()));
         Map<String, User> userMap = users.stream().collect(Collectors.toMap(x -> x.getEmailId(), x -> x));
         Map<Integer, List<EmployeeAttendance>> employeeAttendancesMap = employeeAttendanceRepository
                 .selectAllByDatesBetween(LocalDate.now().atStartOfDay(), LocalDateTime.now()).stream()
-                .collect(Collectors.groupingBy(x -> x.getUserId()));
+                .collect(groupingBy(x -> x.getUserId()));
         for (AuthUser authUser : authUsers) {
             User user = userMap.get(authUser.getEmailId());
             String body = null;
             List<EmployeeAttendance> employeeAttendances = employeeAttendancesMap.get(user.getId());
                 walletReferenceTypes);
         double schemeAmountWalletTotal = history.stream().mapToDouble(x -> x.getAmount()).sum();
         if (Math.abs(netSchemeDisbursed - schemeAmountWalletTotal) > 10d) {
             LOGGER.info("Scheme Amount mismatched for Date {}", date);
-            Map<Integer, Double> inventoryItemSchemeIO = siosCreated.stream().collect(Collectors
-                    .groupingBy(x -> x.getInventoryItemId(), Collectors.summingDouble(SchemeInOut::getAmount)));
+            Map<Integer, Double> inventoryItemSchemeIO = siosCreated.stream().collect(groupingBy(x -> x.getInventoryItemId(), Collectors.summingDouble(SchemeInOut::getAmount)));
             Map<Integer, Double> userSchemeMap = inventoryItemRepository.selectByIds(inventoryItemSchemeIO.keySet())
-                    .stream().collect(Collectors.groupingBy(x -> x.getFofoId(),
+                    .stream().collect(groupingBy(x -> x.getFofoId(),
                             Collectors.summingDouble(x -> inventoryItemSchemeIO.get(x.getId()))));
-            Map<Integer, Double> inventoryItemSchemeIORefunded = siosRefunded.stream().collect(Collectors
-                    .groupingBy(x -> x.getInventoryItemId(), Collectors.summingDouble(SchemeInOut::getAmount)));
+            Map<Integer, Double> inventoryItemSchemeIORefunded = siosRefunded.stream().collect(groupingBy(x -> x.getInventoryItemId(), Collectors.summingDouble(SchemeInOut::getAmount)));
             Map<Integer, Double> userSchemeRefundedMap = inventoryItemRepository
                     .selectByIds(inventoryItemSchemeIORefunded.keySet()).stream()
-                    .collect(Collectors.groupingBy(x -> x.getFofoId(),
+                    .collect(groupingBy(x -> x.getFofoId(),
                             Collectors.summingDouble(x -> inventoryItemSchemeIORefunded.get(x.getId()))));
             Map<Integer, Double> finalUserSchemeAmountMap = new HashMap<>();
             for (Map.Entry<Integer, Double> schemeAmount : userSchemeRefundedMap.entrySet()) {
+            }
             Map<Integer, Integer> userWalletMap = userWalletRepository
                     .selectByRetailerIds(finalUserSchemeAmountMap.keySet()).stream()
                     .collect(Collectors.toMap(UserWallet::getUserId, UserWallet::getId));
-            Map<Integer, Double> walletAmountMap = history.stream().collect(Collectors.groupingBy(
+            Map<Integer, Double> walletAmountMap = history.stream().collect(groupingBy(
                     UserWalletHistory::getWalletId, Collectors.summingDouble((UserWalletHistory::getAmount))));
             for (Map.Entry<Integer, Double> userAmount : walletAmountMap.entrySet()) {
                 double diff = Math.abs(finalUserSchemeAmountMap.get(userAmount.getKey()) - userAmount.getValue());
                 if (diff > 5) {
                     LOGGER.info("Partner scheme mismatched for Userid {}", userWalletMap.get(userAmount.getKey()));
                         .filter(x -> schemeTypeMap.get(x.getSchemeId()).equals(SchemeType.OUT))
                         .collect(Collectors.toList());
                 LOGGER.info("Found {} duplicate schemeouts for Orderid {}", sios.size(), fofoOrder.getId());
                 UserWalletHistory uwh = new UserWalletHistory();
                 Map<Integer, List<SchemeInOut>> inventoryIdSouts = sios.stream()
-                        .collect(Collectors.groupingBy(SchemeInOut::getInventoryItemId, Collectors.toList()));
+                        .collect(groupingBy(SchemeInOut::getInventoryItemId, Collectors.toList()));
                 for (Map.Entry<Integer, List<SchemeInOut>> inventorySioEntry : inventoryIdSouts.entrySet()) {
                     List<SchemeInOut> outList = inventorySioEntry.getValue();
                     if (outList.size() > 1) {
+                    }
             model.setTotalQty(partnerOrderQtyMap.containsKey(fofoId) ? partnerOrderQtyMap.get(fofoId) : 0);
             model.setPast3daysSale(
                     spPartner3DaysOrderValMap.containsKey(fofoId) ? spPartner3DaysOrderValMap.get(fofoId) : 0);
             model.setFofoId(fofoId);
             model.setCode(fofoStoreMap.get(fofoId).getCode());
+            model.setActivationType(fofoStoreMap.get(fofoId).getActivationType());
             saleTargetReportModelMap.put(fofoId, model);
+        }
         Map<Integer, FofoReportingModel> partnerSalesHeadersMap = this.getPartnerIdSalesHeaders();
         for (Integer fofoId : fofoIds) {
         private double totalSale;
         private long totalQty;
         private double past3daysSale;
         private int fofoId;
         private String code;
+        private ActivationType activationType;
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            SaleTargetReportModel that = (SaleTargetReportModel) o;
+            return Double.compare(that.totalSale, totalSale) == 0 && totalQty == that.totalQty && Double.compare(that.past3daysSale, past3daysSale) == 0 && fofoId == that.fofoId && Double.compare(that.secondary, secondary) == 0 && Double.compare(that.smartphoneSale, smartphoneSale) == 0 && smartphoneQty == that.smartphoneQty && Double.compare(that.insuranceSale, insuranceSale) == 0 && insruanceQty == that.insruanceQty && Objects.equals(code, that.code) && activationType == that.activationType;
+        }
+        @Override
+        public int hashCode() {
+            return Objects.hash(totalSale, totalQty, past3daysSale, fofoId, code, activationType, secondary, smartphoneSale, smartphoneQty, insuranceSale, insruanceQty);
+        }
+        public ActivationType getActivationType() {
+            return activationType;
+        }
+        public void setActivationType(ActivationType activationType) {
+            this.activationType = activationType;
+        }
         public double getSecondary() {
             return secondary;
+        }
                     ", insuranceSale=" + insuranceSale +
                     ", insruanceQty=" + insruanceQty +
                     '}';
+        }
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            SaleTargetReportModel that = (SaleTargetReportModel) o;
-            return Double.compare(that.totalSale, totalSale) == 0 && totalQty == that.totalQty && Double.compare(that.past3daysSale, past3daysSale) == 0 && fofoId == that.fofoId && Double.compare(that.secondary, secondary) == 0 && Double.compare(that.smartphoneSale, smartphoneSale) == 0 && smartphoneQty == that.smartphoneQty && Double.compare(that.insuranceSale, insuranceSale) == 0 && insruanceQty == that.insruanceQty && Objects.equals(code, that.code);
-        }
-        @Override
-        public int hashCode() {
-            return Objects.hash(totalSale, totalQty, past3daysSale, fofoId, code, secondary, smartphoneSale, smartphoneQty, insuranceSale, insruanceQty);
-        }
         public String getCode() {
             return code;
+        }
         public void setCode(String code) {
 			if (!fofoIds.isEmpty()) {
 				List<FofoStore> stores = fofoStoreRepository
 						.selectActivePartnersByRetailerIds(new ArrayList<>(fofoIds));
-                Map<String, List<Integer>> stateMap = stores.stream().collect(Collectors.groupingBy(
+                Map<String, List<Integer>> stateMap = stores.stream().collect(groupingBy(
-                        x -> x.getCode().substring(0, 2), Collectors.mapping(x -> x.getId(), Collectors.toList())));
+                        x -> x.getCode().substring(0, 2), mapping(x -> x.getId(), Collectors.toList())));
                 List<List<Serializable>> stateWiseSales = new ArrayList<>();
                 for (Map.Entry<String, List<Integer>> stateMapEntry : stateMap.entrySet()) {
                     long totalQty = stateMapEntry.getValue().stream()
                             .collect(Collectors.summingLong(x -> saleTargetReportModelMap.get(x).getTotalQty()));
                     double totalSale = stateMapEntry.getValue().stream()
                         .sorted(Comparator.comparing(SaleTargetReportModel::getCode).thenComparing(SaleTargetReportModel::getSecondary))
                         .map(SaleTargetReportModel::getFofoId).collect(Collectors.toList());
                 String subject = String.format("Sale till %s", String.format(timeString, now.format(timeFormatter)));
-                List<String> headers = Arrays.asList("Store Id", "Store Code", "Store Name", "BDM Name", "Regional Manager", "Territory Manager",
+                List<String> headers = Arrays.asList("Store Id", "Store Code", "Store Name", "Activation Type", "BDM Name", "Regional Manager", "Territory Manager",
                         "Secondary(4 days)", "Sale", "Smartphone Value", "Smartphone Qty");
                 List<List<?>> rows = new ArrayList<>();
                 for (Integer fofoId : sortedSaleTargetReport) {
-                    FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
                     FofoReportingModel fofoReportingModel = partnerSalesHeadersMap.get(fofoId);
-                    rows.add(Arrays.asList(fofoId, fofoReportingModel.getCode(), fofoReportingModel.getBusinessName(),
+                    rows.add(Arrays.asList(fofoId, fofoReportingModel.getCode(), fofoReportingModel.getBusinessName(), saleTargetReportModelMap.get(fofoId).getActivationType(),
                             fofoReportingModel.getBusinessManager(), fofoReportingModel.getRegionalManager(), fofoReportingModel.getTerritoryManager(),
                             saleTargetReportModelMap.get(fofoId).getSecondary(), saleTargetReportModelMap.get(fofoId).getTotalSale(),
                             saleTargetReportModelMap.get(fofoId).getSmartphoneSale(), saleTargetReportModelMap.get(fofoId).getSmartphoneQty()
                     ));
+                    //Now try to populate html rows
-                    if (!fofoStore.getActivationType().equals(ActivationType.ACTIVE)) {
+                    if (!saleTargetReportModelMap.get(fofoId).getActivationType().equals(ActivationType.ACTIVE)) {
                         continue;
+                    }
                     if (saleTargetReportModelMap.get(fofoId).getSecondary() == 0) {
                         sb.append("<tr style='background-color:#D21F3C;color:white'>");
                     } else {
             Map<Integer, Integer> currentInventorySnapshot = currentInventorySnapshotRepository.selectByFofoId(fofoId)
                     .stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
             if (!currentInventorySnapshot.isEmpty()) {
                 catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
-                        .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
+                        .collect(groupingBy(x -> x.getCatalogItemId(),
                                 Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
+            }
             Map<Integer, Integer> grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoId).stream()
-                    .collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
+                    .collect(groupingBy(x -> x.getLineItem().getItemId(),
                             Collectors.summingInt(x -> x.getLineItem().getQuantity())));
             if (!grnPendingOrders.isEmpty()) {
                 grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
-                        .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
+                        .collect(groupingBy(x -> x.getCatalogItemId(),
                                 Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
+            }
             Map<Integer, Integer> processingOrder = orderRepository.selectOrders(fofoId, orderStatusList).stream()
-                    .collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
+                    .collect(groupingBy(x -> x.getLineItem().getItemId(),
                             Collectors.summingInt(x -> x.getLineItem().getQuantity())));
             if (!processingOrder.isEmpty()) {
                 processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
-                        .collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
+                        .collect(groupingBy(x -> x.getCatalogItemId(),
                                 Collectors.summingInt(x -> processingOrder.get(x.getId()))));
+            }
             List<String> brands = mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))
             if (regionIds.size() == 0) {
                 LOGGER.info("No region found for partner {}", fofoId);
                 continue;
+            }
             Map<Integer, Optional<Integer>> focusedCatalogIdAndQtyMap = focusedModelRepository
-                    .selectAllByRegionIds(regionIds).stream().collect(Collectors.groupingBy(FocusedModel::getCatalogId,
+                    .selectAllByRegionIds(regionIds).stream().collect(groupingBy(FocusedModel::getCatalogId,
-                            Collectors.mapping(FocusedModel::getObsMinimumQty, Collectors.maxBy(Integer::compareTo))));
+                            mapping(FocusedModel::getObsMinimumQty, Collectors.maxBy(Integer::compareTo))));
             LOGGER.info("focusedCatalogIdAndQtyMap" + focusedCatalogIdAndQtyMap);
             for (Map.Entry<Integer, Optional<Integer>> entry : focusedCatalogIdAndQtyMap.entrySet()) {
                 int minQty = entry.getValue().get();
                  */
                 if (inventoryItem.getLastScanType().equals(ScanType.SALE)
                         || inventoryItem.getLastScanType().equals(ScanType.SALE_RET)) {
                     Map<String, Double> map = schemeInOuts.stream()
                             .collect(
-                                    Collectors.groupingBy(
+                                    groupingBy(
                                             x -> DateTimeFormatter.ofPattern("yyyyMMddHH")
                                                     .format(x.getCreateTimestamp()) + "- " + x.getSchemeId(),
                                             Collectors.summingDouble(x -> x.getAmount())));
                     for (Map.Entry<String, Double> entry : map.entrySet()) {
                         LOGGER.info("{} = {}", entry.getKey(), entry.getValue());
             for (Loan loan : loans) {
                 List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(loan.getId());
-                Map<LoanReferenceType, Double> loanStatusAmount = loanStatements.stream().collect(Collectors.groupingBy(
+                Map<LoanReferenceType, Double> loanStatusAmount = loanStatements.stream().collect(groupingBy(
                         x -> x.getLoanReferenceType(), Collectors.summingDouble(x -> x.getAmount().doubleValue())));
                 if (loan.getFreeDays() > 0) {
                     LocalDateTime freeDaysLimitDate = loan.getCreatedOn().plusDays(loan.getFreeDays() - 1);
                     List<LoanStatement> loanStatements = loanStatementRepository.selectByLoanId(loan.getId());
                     LOGGER.info("loanStatements {}", loanStatements);
                     Map<LoanReferenceType, Double> loanStatusAmount = loanStatements.stream()
-                            .collect(Collectors.groupingBy(x -> x.getLoanReferenceType(),
+                            .collect(groupingBy(x -> x.getLoanReferenceType(),
                                     Collectors.summingDouble(x -> FormattingUtils.serialize(x.getAmount()))));
                     LOGGER.info("loanStatusAmount {}", loanStatusAmount);
                     Double interestAmount = loanStatusAmount.get(LoanReferenceType.INTEREST);
             LOGGER.info("allOrders {}", allOrders);
             if (!allOrders.isEmpty()) {
                 Map<Integer, List<Order>> transactionOrdersMap = allOrders.stream()
-                        .collect(Collectors.groupingBy(Order::getTransactionId, Collectors.toList()));
+                        .collect(groupingBy(Order::getTransactionId, Collectors.toList()));
                 LinkedHashMap<Integer, List<Order>> sortedTransactionOrdersMap = new LinkedHashMap<>();
                 transactionOrdersMap.entrySet().stream().sorted(Map.Entry.comparingByKey())
                         .forEachOrdered(x -> sortedTransactionOrdersMap.put(x.getKey(), x.getValue()));
                 LOGGER.info("sortedTransactionOrdersMap {}", sortedTransactionOrdersMap);
                 remarks);
         if (!hygieneData.isEmpty()) {
             Map<Integer, List<HygieneData>> partnerHygieneDataMap = hygieneData.stream()
-                    .collect(Collectors.groupingBy(x -> x.getFofoId()));
+                    .collect(groupingBy(x -> x.getFofoId()));
             for (Entry<Integer, List<HygieneData>> partnerHygieneDataMapEntry : partnerHygieneDataMap.entrySet()) {
                 CustomRetailer customRetailer = retailerService.getFofoRetailer(partnerHygieneDataMapEntry.getKey());
         Map<Integer, List<HygieneData>> partnerHygieneDataRecentMonth = null;
         if (!hygieneDataLastThreeMonth.isEmpty()) {
             partnerHygieneLastThreeMonthMap = hygieneDataLastThreeMonth.stream()
-                    .collect(Collectors.groupingBy(x -> x.getFofoId()));
+                    .collect(groupingBy(x -> x.getFofoId()));
+        }
         if (!hygieneDataRecentMonth.isEmpty()) {
             partnerHygieneDataRecentMonth = hygieneDataRecentMonth.stream()
-                    .collect(Collectors.groupingBy(x -> x.getFofoId()));
+                    .collect(groupingBy(x -> x.getFofoId()));
+        }
         for (Entry<String, Set<Integer>> storeGuyEntry : storeGuyMap.entrySet()) {
             String email = storeGuyEntry.getKey();
                 if (!partnerHygieneLastThreeMonthMap.isEmpty()) {
                     List<HygieneData> hygienes = partnerHygieneLastThreeMonthMap.get(fofoId);
                     if (hygienes != null) {
                         Map<YearMonth, List<HygieneData>> yearMonthData = hygienes.stream()
-                                .collect(Collectors.groupingBy(x -> YearMonth.from(x.getDisposedTimestamp())));
+                                .collect(groupingBy(x -> YearMonth.from(x.getDisposedTimestamp())));
                         partnerYearMonthData.put(fofoId, yearMonthData);
+                    }
                     List<HygieneData> dateWiseHygienes = partnerHygieneDataRecentMonth.get(fofoId);
                     if (dateWiseHygienes != null) {
                         Map<LocalDate, List<HygieneData>> dateWiseData = hygienes.stream()
-                                .collect(Collectors.groupingBy(x -> (x.getDisposedTimestamp()).toLocalDate()));
+                                .collect(groupingBy(x -> (x.getDisposedTimestamp()).toLocalDate()));
                         partnerDateWiseData.put(fofoId, dateWiseData);
+                    }

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/ScheduledTasks.java – Rev 31722 → 31724