WebSVN – SmartDukaan – Diff – /trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/RbmTargetServiceImpl.java

         // Get all RBM positions (L1 and L2)
         long start = System.currentTimeMillis();
         List<Position> allRbmPositions = positionRepository
                 .selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_RBM).stream()
-                .filter(x -> Arrays.asList(EscalationType.L1, EscalationType.L2).contains(x.getEscalationType()))
+                .filter(x -> Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3).contains(x.getEscalationType()))
                 .collect(Collectors.toList());
-        // Separate L1 and L2 auth IDs
+        // Separate L1, L2 and L3 auth IDs
         List<Integer> l1AuthIds = allRbmPositions.stream()
                 .filter(p -> EscalationType.L1.equals(p.getEscalationType()))
                 .map(Position::getAuthUserId).distinct().collect(Collectors.toList());
         List<Integer> l2AuthIds = allRbmPositions.stream()
                 .filter(p -> EscalationType.L2.equals(p.getEscalationType()))
                 .map(Position::getAuthUserId).distinct().collect(Collectors.toList());
+        List<Integer> l3AuthIds = allRbmPositions.stream()
+                .filter(p -> EscalationType.L3.equals(p.getEscalationType()))
+                .map(Position::getAuthUserId).distinct().collect(Collectors.toList());
         // Union of all auth IDs for batch fetching
         List<Integer> rbmPositionsAuthIds = allRbmPositions.stream()
                 .map(Position::getAuthUserId).distinct().collect(Collectors.toList());
-        LOGGER.info("RBM Call Target - RBM positions fetch: {}ms, L1: {}, L2: {}", System.currentTimeMillis() - start, l1AuthIds.size(), l2AuthIds.size());
+        LOGGER.info("RBM Call Target - RBM positions fetch: {}ms, L1: {}, L2: {}, L3: {}", System.currentTimeMillis() - start, l1AuthIds.size(), l2AuthIds.size(), l3AuthIds.size());
         start = System.currentTimeMillis();
         Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();
         LOGGER.info("RBM Call Target - StoreGuyMap fetch: {}ms", System.currentTimeMillis() - start);
         // Initialize L2 calling list map - will be populated after fetching remarks
         Map<Integer, List<Integer>> l2AuthIdToFofoIds = new HashMap<>();
         for (int l2AuthId : l2AuthIds) {
             l2AuthIdToFofoIds.put(l2AuthId, new ArrayList<>());
+        }
+        // Initialize L3 calling list map - will be populated after fetching remarks
+        Map<Integer, List<Integer>> l3AuthIdToFofoIds = new HashMap<>();
+        for (int l3AuthId : l3AuthIds) {
+            l3AuthIdToFofoIds.put(l3AuthId, new ArrayList<>());
+        }
         LOGGER.info("RBM Call Target - Total fofo IDs to process: {}", allFofoIds.size());
         // Get only needed fofo stores (OPTIMIZED - was fetching ALL stores before)
         start = System.currentTimeMillis();
         Map<Integer, FofoStore> fofoStoresMap = new HashMap<>();
+                }
+            }
+        }
         LOGGER.info("RBM Call Target - L2 calling lists populated from RBM_L2_ESCALATION remarks");
+        // Populate L3 calling list based on partners whose latest remark is RBM_L3_ESCALATION
+        // Find the L1 who originally has the partner, then traverse: L1 -> L2 (manager) -> L3 (manager's manager)
+        for (Map.Entry<Integer, PartnerCollectionRemark> entry : allPartnerCollectionRemarks.entrySet()) {
+            Integer fofoId = entry.getKey();
+            PartnerCollectionRemark remark = entry.getValue();
+            if (CollectionRemark.RBM_L3_ESCALATION.equals(remark.getRemark())) {
+                // Find which L1 RBM originally has this partner assigned
+                for (int l1AuthId : l1AuthIds) {
+                    List<Integer> l1FofoIds = rbmToFofoIdsMap.getOrDefault(l1AuthId, Collections.emptyList());
+                    if (l1FofoIds.contains(fofoId)) {
+                        // Get L1's manager (L2)
+                        AuthUser l1User = authUserMap.get(l1AuthId);
+                        if (l1User != null) {
+                            int l2ManagerId = l1User.getManagerId();
+                            AuthUser l2User = authUserMap.get(l2ManagerId);
+                            // Get L2's manager (L3)
+                            if (l2User != null && l3AuthIdToFofoIds.containsKey(l2User.getManagerId())) {
+                                int l3ManagerId = l2User.getManagerId();
+                                l3AuthIdToFofoIds.get(l3ManagerId).add(fofoId);
+                                LOGGER.debug("L3 Calling List: fofoId={} -> L1={} -> L2={} -> L3={}",
+                                        fofoId, l1AuthId, l2ManagerId, l3ManagerId);
+                            }
+                        }
+                        break; // Found the L1 for this fofoId
+                    }
+                }
+            }
+        }
+        LOGGER.info("RBM Call Target - L3 calling lists populated from RBM_L3_ESCALATION remarks");
         // Batch fetch collection RANK map for all fofoIds (OPTIMIZED - only fetches rank, not full model)
         start = System.currentTimeMillis();
         Map<Integer, Integer> allCollectionRankMap = new HashMap<>();
         if (!allFofoIds.isEmpty()) {
             try {
             l2Model.setOutOfSequenceCount(outOfSequenceCountByAuthId.getOrDefault(l2AuthId, 0L));
             rbmCallTargetModels.add(l2Model);
+        }
+        // Process L3 RBMs (escalated ticket logic with categorization)
+        for (int l3AuthId : l3AuthIds) {
+            AuthUser authUser = authUserMap.get(l3AuthId);
+            if (authUser == null) {
+                continue;
+            }
+            List<Integer> l3FofoIdList = l3AuthIdToFofoIds.getOrDefault(l3AuthId, Collections.emptyList());
+            // For L3, use unique fofoIds with RBM_L3_ESCALATION remark as target
+            Set<Integer> l3TargetFofoIds = new HashSet<>(l3FofoIdList);
+            RbmCallTargetModel l3Model = new RbmCallTargetModel();
+            l3Model.setAuthId(l3AuthId);
+            l3Model.setRbmName(authUser.getFullName() + " (L3)");
+            l3Model.setL3Position(true);
+            l3Model.setL3CallingList(l3TargetFofoIds.size());
+            // Partner count = total assigned partners (same as L2 source)
+            List<Integer> l3AssignedFofoIds = rbmToFofoIdsMap.getOrDefault(l3AuthId, Collections.emptyList());
+            l3Model.setPartnerCount(l3AssignedFofoIds.size());
+            // L3 Target = partners with RBM_L3_ESCALATION as latest remark
+            l3Model.setTodayTargetOfCall(l3TargetFofoIds.size());
+            // Value Achieved = All distinct partners called today (from call logs)
+            long l3ValueAchieved = getCalledCountFromCallLogs(l3AuthId);
+            l3Model.setValueTargetAchieved(l3ValueAchieved);
+            l3Model.setOutOfSequenceCount(outOfSequenceCountByAuthId.getOrDefault(l3AuthId, 0L));
+            rbmCallTargetModels.add(l3Model);
+        }
-        // Group L1 under their L2 manager using authUser.managerId
+        // Group L1 under their L2 manager, and L2 under their L3 manager using authUser.managerId
+        Map<Integer, RbmCallTargetModel> l3ModelsByAuthId = new HashMap<>();
         Map<Integer, RbmCallTargetModel> l2ModelsByAuthId = new HashMap<>();
         Map<Integer, RbmCallTargetModel> l1ModelsByAuthId = new HashMap<>();
         for (RbmCallTargetModel m : rbmCallTargetModels) {
-            if (m.isL2Position()) {
+            if (m.isL3Position()) {
+                l3ModelsByAuthId.put(m.getAuthId(), m);
+            } else if (m.isL2Position()) {
                 l2ModelsByAuthId.put(m.getAuthId(), m);
             } else {
                 l1ModelsByAuthId.put(m.getAuthId(), m);
+            }
+        }
+        // Build L3 -> L2 team map using managerId from AuthUser
+        Map<Integer, List<RbmCallTargetModel>> l3TeamMap = new LinkedHashMap<>();
+        for (RbmCallTargetModel l3Model : l3ModelsByAuthId.values()) {
+            l3TeamMap.put(l3Model.getAuthId(), new ArrayList<>());
+        }
+        Set<Integer> addedL2AuthIds = new HashSet<>();
+        for (RbmCallTargetModel l2Model : l2ModelsByAuthId.values()) {
+            AuthUser l2User = authUserMap.get(l2Model.getAuthId());
+            if (l2User != null && l3TeamMap.containsKey(l2User.getManagerId())) {
+                l3TeamMap.get(l2User.getManagerId()).add(l2Model);
+                addedL2AuthIds.add(l2Model.getAuthId());
+            }
+        }
         // Build L2 -> L1 team map using managerId from AuthUser
         Map<Integer, List<RbmCallTargetModel>> l2TeamMap = new LinkedHashMap<>();
         for (RbmCallTargetModel l2Model : l2ModelsByAuthId.values()) {
             l2TeamMap.put(l2Model.getAuthId(), new ArrayList<>());
+        }
                 l2TeamMap.get(l1User.getManagerId()).add(l1Model);
                 addedL1AuthIds.add(l1Model.getAuthId());
+            }
+        }
-        // Build sorted result: L2 row, then its L1 team (sorted by name)
+        // Build sorted result: L3 row, then its L2 team with their L1 teams (sorted by name)
         List<RbmCallTargetModel> sortedModels = new ArrayList<>();
+        // First add L3 with their L2 teams
-        List<RbmCallTargetModel> l2Sorted = new ArrayList<>(l2ModelsByAuthId.values());
+        List<RbmCallTargetModel> l3Sorted = new ArrayList<>(l3ModelsByAuthId.values());
-        l2Sorted.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
+        l3Sorted.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
+        for (RbmCallTargetModel l3Model : l3Sorted) {
+            sortedModels.add(l3Model);
+            List<RbmCallTargetModel> l2Team = l3TeamMap.getOrDefault(l3Model.getAuthId(), Collections.emptyList());
+            l2Team.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
+            for (RbmCallTargetModel l2Model : l2Team) {
+                sortedModels.add(l2Model);
+                List<RbmCallTargetModel> l1Team = l2TeamMap.getOrDefault(l2Model.getAuthId(), Collections.emptyList());
+                l1Team.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
+                sortedModels.addAll(l1Team);
+            }
+        }
+        // Add L2s not mapped to any L3 with their L1 teams
+        List<RbmCallTargetModel> unmappedL2 = new ArrayList<>();
+        for (RbmCallTargetModel l2Model : l2ModelsByAuthId.values()) {
+            if (!addedL2AuthIds.contains(l2Model.getAuthId())) {
+                unmappedL2.add(l2Model);
+            }
+        }
+        unmappedL2.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
-        for (RbmCallTargetModel l2Model : l2Sorted) {
+        for (RbmCallTargetModel l2Model : unmappedL2) {
             sortedModels.add(l2Model);
             List<RbmCallTargetModel> team = l2TeamMap.getOrDefault(l2Model.getAuthId(), Collections.emptyList());
             team.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
             sortedModels.addAll(team);
+        }

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/RbmTargetServiceImpl.java – Rev 36181 → 36210