WebSVN – SmartDukaan – Diff – /trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/dao/repository/cs/CsServiceImpl.java

+        }
+    }
     @Override
     public Map<Integer, AuthUser> getAuthUserIdAndAuthUserMap(List<TicketAssigned> ticketAssigneds) {
+        if (ticketAssigneds == null || ticketAssigneds.isEmpty()) {
+            return new HashMap<>();
+        }
+        // OPTIMIZED: Batch fetch all AuthUsers instead of N+1 queries
+        List<Integer> assigneeIds = ticketAssigneds.stream()
+                .map(TicketAssigned::getAssineeId)
+                .distinct()
+                .collect(Collectors.toList());
-        Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
+        Map<Integer, AuthUser> authUserById = authRepository.selectByIds(assigneeIds).stream()
+                .collect(Collectors.toMap(AuthUser::getId, au -> au, (a, b) -> a));
+        Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
         for (TicketAssigned ticketAssigned : ticketAssigneds) {
-            AuthUser authUser = authRepository.selectById(ticketAssigned.getAssineeId());
-            authUserIdAndAuthUserMap.put(ticketAssigned.getTicketId(), authUser);
+            authUserIdAndAuthUserMap.put(ticketAssigned.getTicketId(), authUserById.get(ticketAssigned.getAssineeId()));
+        }
         return authUserIdAndAuthUserMap;
+    }
     @Override
     public Map<Integer, AuthUser> getTicketIdAndAuthUserMapUsingTickets(List<Ticket> tickets) {
+        if (tickets == null || tickets.isEmpty()) {
+            return new HashMap<>();
+        }
+        // OPTIMIZED: Batch fetch all AuthUsers instead of N+1 queries
+        List<Integer> authUserIds = tickets.stream()
+                .map(Ticket::getL1AuthUser)
+                .filter(id -> id != null && id > 0)
+                .distinct()
+                .collect(Collectors.toList());
-        Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
+        Map<Integer, AuthUser> authUserById = authRepository.selectByIds(authUserIds).stream()
+                .collect(Collectors.toMap(AuthUser::getId, au -> au, (a, b) -> a));
+        Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
         for (Ticket ticket : tickets) {
-            AuthUser authUser = authRepository.selectById(ticket.getL1AuthUser());
-            authUserIdAndAuthUserMap.put(ticket.getId(), authUser);
+            authUserIdAndAuthUserMap.put(ticket.getId(), authUserById.get(ticket.getL1AuthUser()));
+        }
         return authUserIdAndAuthUserMap;
+    }
     @Override
         return new ArrayList<>(ticketSubCategories.stream().map(x -> x.getTicketCategory()).collect(Collectors.toSet()));
+    }
     @Override
     public Map<Integer, AuthUser> getAuthUserIdAndAuthUserMapUsingPositions(List<Position> positions) {
-        Map<Integer, AuthUser> authUserIdAndAuthUserMap = new HashMap<>();
-        for (Position position : positions) {
+        if (positions == null || positions.isEmpty()) {
-            AuthUser authUser = authRepository.selectById(position.getAuthUserId());
-            authUserIdAndAuthUserMap.put(position.getAuthUserId(), authUser);
+            return new HashMap<>();
+        }
+        // OPTIMIZED: Batch fetch all AuthUsers instead of N+1 queries
-        return authUserIdAndAuthUserMap;
+        List<Integer> authUserIds = positions.stream()
+                .map(Position::getAuthUserId)
+                .filter(id -> id != null && id > 0)
+                .distinct()
+                .collect(Collectors.toList());
+        return authRepository.selectByIds(authUserIds).stream()
+                .collect(Collectors.toMap(AuthUser::getId, au -> au, (a, b) -> a));
+    }
     @Override
     public Map<Integer, TicketCategory> getCategoryIdAndCategoryUsingPositions(List<Position> positions) {
-        Map<Integer, TicketCategory> categoryIdAndCategoryMap = new HashMap<>();
-        for (Position position : positions) {
+        if (positions == null || positions.isEmpty()) {
-            TicketCategory ticketCategory = ticketCategoryRepository.selectById(position.getCategoryId());
-            categoryIdAndCategoryMap.put(position.getCategoryId(), ticketCategory);
+            return new HashMap<>();
+        }
+        // OPTIMIZED: Batch fetch all categories instead of N+1 queries
+        List<Integer> categoryIds = positions.stream()
-        return categoryIdAndCategoryMap;
+                .map(Position::getCategoryId)
+                .filter(id -> id != null && id > 0)
+                .distinct()
+                .collect(Collectors.toList());
+        return ticketCategoryRepository.selectAll(categoryIds).stream()
+                .collect(Collectors.toMap(TicketCategory::getId, tc -> tc, (a, b) -> a));
+    }
     @Override
     public Map<Integer, Region> getRegionIdAndRegionMap(List<Position> positions) {
-        Map<Integer, Region> regionIdAndRegionMap = new HashMap<>();
-        for (Position position : positions) {
+        if (positions == null || positions.isEmpty()) {
-            Region region = regionRepository.selectById(position.getRegionId());
-            regionIdAndRegionMap.put(position.getRegionId(), region);
+            return new HashMap<>();
+        }
+        // OPTIMIZED: Batch fetch all regions instead of N+1 queries
-        return regionIdAndRegionMap;
+        Set<Integer> regionIds = positions.stream()
+                .map(Position::getRegionId)
+                .filter(id -> id != null && id > 0)
+                .collect(Collectors.toSet());
+        return regionRepository.selectAll().stream()
+                .filter(r -> regionIds.contains(r.getId()))
+                .collect(Collectors.toMap(Region::getId, r -> r, (a, b) -> a));
+    }
     private void sendAssignedTicketMail(AuthUser authUserTo, List<AuthUser> authUsersCc, Ticket ticket, boolean isEscalated, List<Activity> activities) throws ProfitMandiBusinessException {
         try {
             String[] ccTo = authUsersCc.stream().filter(x -> x != null).map(x -> x.getEmailId()).toArray(String[]::new);
+        }
         List<Position> categoryPositions = positionRepository.selectPositionByCategoryIds(categoryIds);
         Map<Integer, Position> positionsMap = categoryPositions.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
+        // OPTIMIZED: Batch fetch all AuthUsers instead of N+1 queries
+        List<Integer> authUserIds = categoryPositions.stream()
+                .map(Position::getAuthUserId)
+                .filter(id -> id != null && id > 0)
+                .distinct()
+                .collect(Collectors.toList());
+        Map<Integer, AuthUser> authUserMap = authRepository.selectByIds(authUserIds).stream()
+                .collect(Collectors.toMap(AuthUser::getId, au -> au, (a, b) -> a));
         Map<Integer, List<CustomRetailer>> positonPartnerMap = this.getPositionCustomRetailerMap(categoryPositions);
         for (Map.Entry<Integer, List<CustomRetailer>> positionPartnerEntry : positonPartnerMap.entrySet()) {
             int authUserId = positionsMap.get(positionPartnerEntry.getKey()).getAuthUserId();
             Set<Integer> partnerIds = positionPartnerEntry.getValue().stream().filter(x -> activeFofoIds.contains(x.getPartnerId())).map(x -> x.getPartnerId()).collect(Collectors.toSet());
-            AuthUser authUser = authRepository.selectById(authUserId);
+            AuthUser authUser = authUserMap.get(authUserId);
-            if (authUser.isActive()) {
+            if (authUser != null && authUser.isActive()) {
                 if (!authUserPartnerMap.containsKey(authUser.getEmailId())) {
                     authUserPartnerMap.put(authUser.getEmailId(), partnerIds);
                 } else {
                     authUserPartnerMap.get(authUser.getEmailId()).addAll(partnerIds);
+                }
         Map<Integer, List<Integer>> authUserpartnerIdMap = new HashMap<>();
         List<Position> authPositions = positionRepository.selectPositionbyCategoryIdAndAuthId(categoryId, authId);
+        // OPTIMIZED: Batch fetch all PartnerPositions instead of N+1 queries
-        List<PartnerPosition> partnerPositions = authPositions.stream()
+        List<Integer> positionIds = authPositions.stream()
-                .flatMap(authPosition -> partnerPositionRepository.selectByPositionId(authPosition.getId()).stream())
+                .map(Position::getId)
                 .collect(Collectors.toList());
+        List<PartnerPosition> partnerPositions = partnerPositionRepository.selectByPositionIds(positionIds);
         if (partnerPositions.stream().anyMatch(partnerPosition -> partnerPosition.getFofoId() == 0)) {
             List<FofoStore> activeFofoStores = fofoStoreRepository.selectActiveStores();
             List<Integer> fofoStoreIds = activeFofoStores.stream()
         List<Position> positions = positionRepository.selectByIds(partnerPositionIds);
         positions = positions.stream().filter(x -> (x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_SALES || x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_RBM || x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_ABM)).collect(Collectors.toList());
         if (!positions.isEmpty()) {
+            // OPTIMIZED: Batch fetch all AuthUsers instead of N+1 queries
-            for (Position partnerPostionId : positions) {
+            List<Integer> authUserIds = positions.stream()
+                    .map(Position::getAuthUserId)
+                    .filter(id -> id != null && id > 0)
+                    .distinct()
+                    .collect(Collectors.toList());
+            Map<Integer, AuthUser> authUserMap = authRepository.selectByIds(authUserIds).stream()
+                    .collect(Collectors.toMap(AuthUser::getId, au -> au, (a, b) -> a));
+            for (Position partnerPostionId : positions) {
-                AuthUser authUser = authRepository.selectById(partnerPostionId.getAuthUserId());
+                AuthUser authUser = authUserMap.get(partnerPostionId.getAuthUserId());
                 LOGGER.info("authUser" + authUser);
+                if (authUser != null) {
-                emails.add(authUser.getEmailId());
+                    emails.add(authUser.getEmailId());
+                }
+            }
+        }
         return emails;
+    }
         //LOGGER.info("fofoIds" + fofoIds);
         List<Integer> partnerPositionIds = partnerPositionRepository.selectByRegionIdAndPartnerId(regionIds, fofoIds).stream().map(x -> x.getPositionId()).collect(Collectors.toList());
         //LOGGER.info("partnerPositionIds" + partnerPositionIds);
+        // OPTIMIZED: Batch fetch all positions instead of N+1 queries
-        for (Integer partnerPostionId : partnerPositionIds) {
+        List<Position> positions = positionRepository.selectByIds(partnerPositionIds).stream()
-            Position position = positionRepository.selectByIdAndCategoryId(partnerPostionId, ProfitMandiConstants.TICKET_CATEGORY_SALES);
+                .filter(p -> p.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_SALES)
-            //LOGGER.info("position" + position);
+                .collect(Collectors.toList());
-            if (position != null) {
+        if (!positions.isEmpty()) {
+            // OPTIMIZED: Batch fetch all AuthUsers instead of N+1 queries
+            List<Integer> authUserIds = positions.stream()
+                    .map(Position::getAuthUserId)
+                    .filter(id -> id != null && id > 0)
+                    .distinct()
+                    .collect(Collectors.toList());
+            Map<Integer, AuthUser> authUserMap = authRepository.selectByIds(authUserIds).stream()
+                    .collect(Collectors.toMap(AuthUser::getId, au -> au, (a, b) -> a));
+            for (Position position : positions) {
-                AuthUser authUser = authRepository.selectById(position.getAuthUserId());
+                AuthUser authUser = authUserMap.get(position.getAuthUserId());
                 //LOGGER.info("authUser" + authUser);
+                if (authUser != null) {
-                emailEsclationTypeMap.put(position.getEscalationType(), authUser.getEmailId());
+                    emailEsclationTypeMap.put(position.getEscalationType(), authUser.getEmailId());
+                }
+            }
+        }
         //LOGGER.info("emailEsclationTypeMap" + emailEsclationTypeMap);
         List<Position> categoryPositions = positionRepository.selectAllPosition();
         Map<Integer, Position> positionsMap = categoryPositions.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
+        // OPTIMIZED: Batch fetch all AuthUsers instead of N+1 queries
+        List<Integer> authUserIds = categoryPositions.stream()
+                .map(Position::getAuthUserId)
+                .filter(id -> id != null && id > 0)
+                .distinct()
+                .collect(Collectors.toList());
+        Map<Integer, AuthUser> authUserMap = authRepository.selectByIds(authUserIds).stream()
+                .collect(Collectors.toMap(AuthUser::getId, au -> au, (a, b) -> a));
         Map<Integer, List<CustomRetailer>> positonPartnerMap = this.getPositionCustomRetailerMap(categoryPositions);
         for (Map.Entry<Integer, List<CustomRetailer>> positionPartnerEntry : positonPartnerMap.entrySet()) {
             int authUserId = positionsMap.get(positionPartnerEntry.getKey()).getAuthUserId();
             List<Integer> partnerIds = positionPartnerEntry.getValue().stream().filter(x -> activeFofoIds.contains(x.getPartnerId())).map(x -> x.getPartnerId()).collect(Collectors.toList());
-            AuthUser authUser = authRepository.selectById(authUserId);
+            AuthUser authUser = authUserMap.get(authUserId);
             if (authUser != null && authUser.isActive()) {
                 if (!storeGuyMap.containsKey(authUserId)) {
                     storeGuyMap.put(authUserId, partnerIds);
                 } else {
                     storeGuyMap.get(authUserId).addAll(partnerIds);

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/dao/repository/cs/CsServiceImpl.java – Rev 35443 → 35454