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

+        }
         if (ticket.getSubCategoryId() != ticketSubCategory.getId()) {
             ticket.setSubCategoryId(ticketSubCategory.getId());
             List<Integer> oldAssignedAuthUserIds = oldTicketAssignedList.stream().map(x -> x.getAssineeId()).collect(Collectors.toList());
-            List<String> oldAssignedEmailIds = authRepository.selectAllAuthUserByIds(oldAssignedAuthUserIds).stream().map(x -> x.getEmailId()).collect(Collectors.toList());
+            List<String> oldAssignedEmailIds = authRepository.selectByIds(oldAssignedAuthUserIds).stream().map(x -> x.getEmailId()).collect(Collectors.toList());
             String mailTo = oldAssignedEmailIds.remove(0);
             String message = String.format(CATEGORY_CHANGED_TICKET, ticket.getId(), storeName, ticketSubCategory.getTicketCategory().getName() + " - " + ticketSubCategory.getName());
             try {
                 Utils.sendMailWithAttachments(mailSender, mailTo, oldAssignedEmailIds.toArray(new String[0]), "Ticket Category/Subcategory Changed", message, null);
             } catch (Exception e) {
         List<Position> positionAssignee = positions.stream().filter(x -> x.isTicketAssignee() && partnerPositionsIds.contains(x.getId())).collect(Collectors.toList());
         LOGGER.info("User List List {}", positions.stream().map(x -> x.getAuthUserId()).collect(Collectors.toList()));
         LOGGER.info("positionAssignee List {}", positionAssignee);
         if (positionAssignee.size() > 0) {
-            List<AuthUser> authUsers = authRepository.selectAllAuthUserByIds(
+            List<AuthUser> authUsers = authRepository.selectByIds(
                     positionAssignee.stream().map(x -> x.getAuthUserId()).collect(Collectors.toList()));
             authUsers = authUsers.stream().filter(x -> x.isActive()).collect(Collectors.toList());
             LOGGER.info("Auth User List {}", authUsers);
             if (authUsers.size() > 0) {
                 authUserId = authUsers.get(0).getId();
         List<Position> positionAssignee = positions.stream().filter(x -> partnerPositionsIds.contains(x.getId())).collect(Collectors.toList());
         LOGGER.info("User List List {}", positions.stream().map(x -> x.getAuthUserId()).collect(Collectors.toList()));
         LOGGER.info("positionAssignee List {}", positionAssignee);
         if (positionAssignee.size() > 0) {
-            List<AuthUser> authUsers = authRepository.selectAllAuthUserByIds(
+            List<AuthUser> authUsers = authRepository.selectByIds(
                     positionAssignee.stream().map(x -> x.getAuthUserId()).collect(Collectors.toList()));
             authUsers = authUsers.stream().filter(x -> x.isActive()).collect(Collectors.toList());
             LOGGER.info("Auth User List {}", authUsers);
             if (authUsers.size() > 0) {
                 authUserId = authUsers.get(0).getId();
         List<Integer> partnerPositionIds = partnerPositionRepository.selectByRegionIdAndPartnerId(regionIds, Arrays.asList(fofoId, 0)).stream().map(x -> x.getPositionId()).collect(Collectors.toList());
         LOGGER.info("partnerPositionIds" + partnerPositionIds);
-        List<Position> positions = positionRepository.selectAll(partnerPositionIds);
+        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()) {
             for (Position partnerPostionId : positions) {
         if (tickets.size() == 0) {
             return new HashMap<>();
+        }
         List<TicketAssigned> ticketAssignedList = ticketAssignedRepository.selectByTicketIds(tickets.stream().map(x -> x.getId()).collect(Collectors.toList()));
         List<Integer> authUserIds = ticketAssignedList.stream().map(x -> x.getAssineeId()).distinct().collect(Collectors.toList());
-        Map<Integer, AuthUser> authUserMap = authRepository.selectAllAuthUserByIds(authUserIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
+        Map<Integer, AuthUser> authUserMap = authRepository.selectByIds(authUserIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
         return ticketAssignedList.stream().collect(Collectors.groupingBy(x -> x.getTicketId(), Collectors.mapping(x -> authUserMap.get(x.getAssineeId()), Collectors.toList())));
+    }
     @Override
     public Map<EscalationType, AuthUser> getAuthUserAndEsclationByPartnerId(int fofoId) throws ProfitMandiBusinessException {
         return authuserEsclationTypeMap;
+    }
     @Override
+    public Map<Integer, Map<EscalationType, AuthUser>> getAuthUserAndEsclationByPartnerIds(Set<Integer> fofoIds) throws ProfitMandiBusinessException {
+        Map<Integer, Map<EscalationType, AuthUser>> result = new HashMap<>();
+        if (fofoIds == null || fofoIds.isEmpty()) {
+            return result;
+        }
+        // Initialize result map
+        for (Integer fofoId : fofoIds) {
+            result.put(fofoId, new HashMap<>());
+        }
+        // Batch fetch all partner regions
+        List<Integer> fofoIdListWithZero = new ArrayList<>(fofoIds);
+        fofoIdListWithZero.add(0);
+        List<PartnerRegion> allPartnerRegions = partnerRegionRepository.selectByfofoIds(fofoIdListWithZero);
+        // Build fofoId -> regionIds map
+        Map<Integer, Set<Integer>> fofoRegionMap = new HashMap<>();
+        for (Integer fofoId : fofoIds) {
+            fofoRegionMap.put(fofoId, new HashSet<>());
+            fofoRegionMap.get(fofoId).add(ALL_PARTNERS_REGION);
+        }
+        for (PartnerRegion pr : allPartnerRegions) {
+            int prFofoId = pr.getFofoId();
+            if (prFofoId == 0) {
+                for (Integer fid : fofoIds) {
+                    fofoRegionMap.get(fid).add(pr.getRegionId());
+                }
+            } else if (fofoIds.contains(prFofoId)) {
+                fofoRegionMap.get(prFofoId).add(pr.getRegionId());
+            }
+        }
+        // Collect all region IDs
+        Set<Integer> allRegionIds = fofoRegionMap.values().stream()
+                .flatMap(Set::stream).collect(Collectors.toSet());
+        // Batch fetch all partner positions
+        List<PartnerPosition> allPartnerPositions = partnerPositionRepository.selectByRegionIdAndPartnerId(
+                new ArrayList<>(allRegionIds), fofoIdListWithZero);
+        // Collect all position IDs
+        Set<Integer> allPositionIds = allPartnerPositions.stream()
+                .map(PartnerPosition::getPositionId).collect(Collectors.toSet());
+        // Batch fetch all positions for SALES category
+        List<Position> salesPositions = positionRepository.selectPositionbyCategoryIdAndEscalationType(
+                ProfitMandiConstants.TICKET_CATEGORY_SALES, null);
+        Map<Integer, Position> positionMap = salesPositions.stream()
+                .filter(p -> allPositionIds.contains(p.getId()))
+                .collect(Collectors.toMap(Position::getId, p -> p, (a, b) -> a));
+        // Collect all auth user IDs and batch fetch
+        Set<Integer> authUserIds = positionMap.values().stream()
+                .map(Position::getAuthUserId).collect(Collectors.toSet());
+        Map<Integer, AuthUser> authUserMap = authRepository.selectByIds(new ArrayList<>(authUserIds))
+                .stream().collect(Collectors.toMap(AuthUser::getId, au -> au, (a, b) -> a));
+        // For each fofoId, find matching positions and build result
+        for (Integer fofoId : fofoIds) {
+            Set<Integer> regionIds = fofoRegionMap.get(fofoId);
+            Map<EscalationType, AuthUser> escalationMap = result.get(fofoId);
+            for (PartnerPosition pp : allPartnerPositions) {
+                if (regionIds.contains(pp.getRegionId()) &&
+                    (pp.getFofoId() == 0 || pp.getFofoId() == fofoId)) {
+                    Position position = positionMap.get(pp.getPositionId());
+                    if (position != null) {
+                        AuthUser authUser = authUserMap.get(position.getAuthUserId());
+                        if (authUser != null) {
+                            escalationMap.put(position.getEscalationType(), authUser);
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    @Override
     public List<AuthUser> getAuthUserIdByPartnerId(int fofoId) throws ProfitMandiBusinessException {
         return this.getAuthUserIdByPartnerId(fofoId, EscalationType.escalations.toArray(new EscalationType[0]));
+    }
     @Override
         //LOGGER.info("partnerPositionIds" + partnerPositionIds);
         List<Integer> allowedTicketCategoryIds = Arrays.asList(ProfitMandiConstants.TICKET_CATEGORY_SALES, ProfitMandiConstants.TICKET_CATEGORY_RBM,ProfitMandiConstants.TICKET_CATEGORY_ABM);
-        List<Position> escalationBasedPositions = positionRepository.selectAll(partnerPositionIds).stream().filter(x -> allowedTicketCategoryIds.contains(x.getCategoryId()) &&
+        List<Position> escalationBasedPositions = positionRepository.selectByIds(partnerPositionIds).stream().filter(x -> allowedTicketCategoryIds.contains(x.getCategoryId()) &&
                 Arrays.stream(escalationTypes)
                         .anyMatch(y -> y.equals(x.getEscalationType()))).collect(Collectors.toList());
         List<Integer> authUserIds = escalationBasedPositions.stream().map(x -> x.getAuthUserId()).collect(Collectors.toList());
-        return authRepository.selectAllAuthUserByIds(authUserIds);
+        return authRepository.selectByIds(authUserIds);
+    }
     @Override
     public List<AuthUser> getAuthUserIds(int categoryId, List<EscalationType> escalationType) {
         List<Integer> authIds = positions.stream().map(x -> x.getAuthUserId()).distinct().collect(Collectors.toList());
         //LOGGER.info("authIds" + authIds);
         List<AuthUser> authUsers = null;
         if (authIds.size() > 0) {
-            authUsers = authRepository.selectAllAuthUserByIds(authIds);
+            authUsers = authRepository.selectByIds(authIds);
         } else {
             authUsers = new ArrayList<>();
+        }
         LOGGER.info("authUsers" + authUsers);
         List<Integer> authIds = positions.stream().map(x -> x.getAuthUserId()).distinct().collect(Collectors.toList());
         LOGGER.info("authIds" + authIds);
         List<AuthUser> authUsers = new ArrayList<>();
         if (!authIds.isEmpty()) {
-            authUsers = authRepository.selectAllAuthUserByIds(authIds);
+            authUsers = authRepository.selectByIds(authIds);
+        }
         LOGGER.info("authUsers" + authUsers);
         return authUsers;
+    }
         List<Position> positions = positionRepository.selectPositionByCategoryId(categoryId);
         List<Integer> authIds = positions.stream().map(x -> x.getAuthUserId()).distinct().collect(Collectors.toList());
         LOGGER.info("authIds" + authIds);
-        List<AuthUser> authUsers = authRepository.selectAllAuthUserByIds(authIds).stream().filter(x -> x.getActive()).collect(Collectors.toList());
+        List<AuthUser> authUsers = authRepository.selectByIds(authIds).stream().filter(x -> x.getActive()).collect(Collectors.toList());
         LOGGER.info("authUsers" + authUsers);
         return authUsers;
+    }
+        }
         return subCategoryIdAndCategoryMap;
+    }
+    @Override
+    public Map<Integer, Map<String, Integer>> getBmAsmRbmAuthUserIdsByFofoIds(Set<Integer> fofoIds) throws ProfitMandiBusinessException {
+        Map<Integer, Map<String, Integer>> result = new HashMap<>();
+        if (fofoIds == null || fofoIds.isEmpty()) {
+            return result;
+        }
+        // Initialize result map with empty values for each fofoId
+        for (Integer fofoId : fofoIds) {
+            Map<String, Integer> roleMap = new HashMap<>();
+            roleMap.put("BM", 0);
+            roleMap.put("ASM", 0);
+            roleMap.put("RBM", 0);
+            result.put(fofoId, roleMap);
+        }
+        // Fetch positions by category + escalation type (same for all fofoIds)
+        List<Position> bmPositions = positionRepository.selectPositionbyCategoryIdAndEscalationType(
+                ProfitMandiConstants.TICKET_CATEGORY_SALES, EscalationType.L2);
+        List<Position> asmPositions = positionRepository.selectPositionbyCategoryIdAndEscalationType(
+                ProfitMandiConstants.TICKET_CATEGORY_SALES, EscalationType.L1);
+        List<Position> rbmPositions = positionRepository.selectPositionbyCategoryIdAndEscalationType(
+                ProfitMandiConstants.TICKET_CATEGORY_RBM, EscalationType.L1);
+        // Batch fetch all partner regions for all fofoIds
+        List<Integer> fofoIdList = new ArrayList<>(fofoIds);
+        fofoIdList.add(0); // Include global entries
+        List<PartnerRegion> allPartnerRegions = partnerRegionRepository.selectByfofoIds(fofoIdList);
+        // Build fofoId -> regionIds map
+        Map<Integer, Set<Integer>> fofoRegionMap = new HashMap<>();
+        for (Integer fofoId : fofoIds) {
+            fofoRegionMap.put(fofoId, new HashSet<>());
+            fofoRegionMap.get(fofoId).add(ALL_PARTNERS_REGION); // Add all partners region
+        }
+        for (PartnerRegion pr : allPartnerRegions) {
+            int fofoId = pr.getFofoId();
+            if (fofoId == 0) {
+                // Global entry applies to all fofoIds
+                for (Integer fid : fofoIds) {
+                    fofoRegionMap.get(fid).add(pr.getRegionId());
+                }
+            } else if (fofoIds.contains(fofoId)) {
+                fofoRegionMap.get(fofoId).add(pr.getRegionId());
+            }
+        }
+        // Collect all unique region IDs and position IDs for batch query
+        Set<Integer> allRegionIds = fofoRegionMap.values().stream()
+                .flatMap(Set::stream).collect(Collectors.toSet());
+        Set<Integer> allPositionIds = new HashSet<>();
+        bmPositions.forEach(p -> allPositionIds.add(p.getId()));
+        asmPositions.forEach(p -> allPositionIds.add(p.getId()));
+        rbmPositions.forEach(p -> allPositionIds.add(p.getId()));
+        // Batch fetch all partner positions
+        List<PartnerPosition> allPartnerPositions = partnerPositionRepository.selectByRegionIdAndPostionId(
+                new ArrayList<>(allRegionIds), new ArrayList<>(allPositionIds));
+        // Build positionId -> set of (regionId, partnerId) for matching
+        Map<Integer, List<PartnerPosition>> positionIdToPartnerPositions = allPartnerPositions.stream()
+                .collect(Collectors.groupingBy(PartnerPosition::getPositionId));
+        // Collect all auth user IDs we need
+        Set<Integer> allAuthUserIds = new HashSet<>();
+        bmPositions.forEach(p -> allAuthUserIds.add(p.getAuthUserId()));
+        asmPositions.forEach(p -> allAuthUserIds.add(p.getAuthUserId()));
+        rbmPositions.forEach(p -> allAuthUserIds.add(p.getAuthUserId()));
+        // Batch fetch all auth users
+        Map<Integer, AuthUser> authUserMap = authRepository.selectByIds(new ArrayList<>(allAuthUserIds))
+                .stream().filter(AuthUser::isActive)
+                .collect(Collectors.toMap(AuthUser::getId, au -> au, (a, b) -> a));
+        // Build position ID sets for fast lookup
+        Set<Integer> bmPositionIds = bmPositions.stream().map(Position::getId).collect(Collectors.toSet());
+        Set<Integer> asmPositionIds = asmPositions.stream().map(Position::getId).collect(Collectors.toSet());
+        Set<Integer> rbmPositionIds = rbmPositions.stream().map(Position::getId).collect(Collectors.toSet());
+        // Map position ID to auth user ID
+        Map<Integer, Integer> positionToAuthUser = new HashMap<>();
+        bmPositions.forEach(p -> positionToAuthUser.put(p.getId(), p.getAuthUserId()));
+        asmPositions.forEach(p -> positionToAuthUser.put(p.getId(), p.getAuthUserId()));
+        rbmPositions.forEach(p -> positionToAuthUser.put(p.getId(), p.getAuthUserId()));
+        // For each fofoId, find matching positions
+        for (Integer fofoId : fofoIds) {
+            Set<Integer> regionIds = fofoRegionMap.get(fofoId);
+            // Find position IDs that match this fofoId's regions (partnerId = 0 or fofoId)
+            Set<Integer> matchingPositionIds = new HashSet<>();
+            for (PartnerPosition pp : allPartnerPositions) {
+                if (regionIds.contains(pp.getRegionId()) &&
+                    (pp.getFofoId() == 0 || pp.getFofoId() == fofoId)) {
+                    matchingPositionIds.add(pp.getPositionId());
+                }
+            }
+            // Find first active auth user for each role
+            Map<String, Integer> roleMap = result.get(fofoId);
+            for (Integer positionId : matchingPositionIds) {
+                Integer authUserId = positionToAuthUser.get(positionId);
+                if (authUserId != null && authUserMap.containsKey(authUserId)) {
+                    if (bmPositionIds.contains(positionId) && roleMap.get("BM") == 0) {
+                        roleMap.put("BM", authUserId);
+                    } else if (asmPositionIds.contains(positionId) && roleMap.get("ASM") == 0) {
+                        roleMap.put("ASM", authUserId);
+                    } else if (rbmPositionIds.contains(positionId) && roleMap.get("RBM") == 0) {
+                        roleMap.put("RBM", authUserId);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

Subversion Repositories SmartDukaan

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