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

     RetailerContactRepository retailerContactRepository;
     @Autowired
     AddressRepository addressRepository;
+    @Autowired
+    com.spice.profitmandi.dao.repository.cs.PartnerPositionRepository partnerPositionRepository;
     @Override
     public List<RbmCallTargetModel> getRbmCallTargetModels() throws Exception {
         long methodStart = System.currentTimeMillis();
         List<RbmCallTargetModel> rbmCallTargetModels = new ArrayList<>();
         Map<Integer, Long> outOfSequenceCountByAuthId = outOfSequenceLogs.stream()
                 .collect(Collectors.groupingBy(RbmCallSequenceLog::getAuthId,
                         Collectors.mapping(RbmCallSequenceLog::getFofoId, Collectors.collectingAndThen(Collectors.toSet(), s -> (long) s.size()))));
         LOGGER.info("RBM Call Target - Out of Sequence fetch: {}ms", System.currentTimeMillis() - start);
+        // Identify users who are both L1 and L2 — they will be shown only as L2
-        // Process L1 RBMs (existing logic)
+        Set<Integer> l2AuthIdSet = new HashSet<>(l2AuthIds);
+        // Process L1 RBMs (skip users who are also L2 — their data will be merged into L2 model)
         for (int rbmAuthId : l1AuthIds) {
+            if (l2AuthIdSet.contains(rbmAuthId)) {
+                continue; // Will be handled in L2 processing with merged L1 data
+            }
             AuthUser authUser = authUserMap.get(rbmAuthId);
             if (authUser == null || !storeGuyMap.containsKey(authUser.getEmailId())) {
                 continue;
+            }
             rbmCallTargetModels.add(targetModel);
+        }
         // Process L2 RBMs (escalated ticket logic with categorization)
+        // For users who are both L1 and L2, merge their L1 calling target into L2 model
         for (int l2AuthId : l2AuthIds) {
             AuthUser authUser = authUserMap.get(l2AuthId);
             if (authUser == null) {
                 continue;
+            }
             l2Model.setL2CallingList(l2TargetFofoIds.size());
             // Partner count = total assigned partners (same as L1 source)
             List<Integer> l2AssignedFofoIds = rbmToFofoIdsMap.getOrDefault(l2AuthId, Collections.emptyList());
             l2Model.setPartnerCount(l2AssignedFofoIds.size());
+            // Calculate L1 own target if user is also L1
+            long l1OwnTarget = 0;
+            if (l1AuthIds.contains(l2AuthId) && storeGuyMap.containsKey(authUser.getEmailId())) {
+                List<Integer> fofoIdList = rbmToFofoIdsMap.getOrDefault(l2AuthId, Collections.emptyList());
+                List<Position> positions = positionsByAuthId.getOrDefault(l2AuthId, Collections.emptyList());
+                boolean isRBMAndL1 = positions.stream()
+                        .anyMatch(position ->
+                                ProfitMandiConstants.TICKET_CATEGORY_RBM == position.getCategoryId()
+                                        && EscalationType.L1.equals(position.getEscalationType()));
+                List<Integer> l1FofoIds = new ArrayList<>(fofoIdList);
+                if (isRBMAndL1) {
+                    Map<Integer, PartnerCollectionRemark> partnerCollectionRemarks = new HashMap<>();
+                    for (Integer fofoId : fofoIdList) {
+                        if (allPartnerCollectionRemarks.containsKey(fofoId)) {
+                            partnerCollectionRemarks.put(fofoId, allPartnerCollectionRemarks.get(fofoId));
+                        }
+                    }
+                    l1FofoIds = partnerCollectionRemarks.entrySet().stream()
+                            .filter(entry -> {
+                                PartnerCollectionRemark pcrMap = entry.getValue();
+                                return !(CollectionRemark.RBM_L2_ESCALATION.equals(pcrMap.getRemark())
+                                        || CollectionRemark.SALES_ESCALATION.equals(pcrMap.getRemark()));
+                            })
+                            .map(Map.Entry::getKey)
+                            .collect(Collectors.toList());
+                }
+                Map<Integer, FofoStore> finalFofoStoresMap2 = fofoStoresMap;
+                List<Integer> validL1FofoIds = l1FofoIds.stream()
+                        .filter(fofoId -> {
+                            FofoStore store = finalFofoStoresMap2.get(fofoId);
+                            if (store == null || store.isInternal()) return false;
+                            return ActivationType.ACTIVE.equals(store.getActivationType())
+                                    || ActivationType.REVIVAL.equals(store.getActivationType());
+                        })
+                        .collect(Collectors.toList());
+                // Count L1 own target (PlanToday + CarryForward + ZeroBilling + Untouched)
+                for (Integer fofoId : validL1FofoIds) {
+                    int rank = allCollectionRankMap.getOrDefault(fofoId, 5);
+                    boolean hasZeroBilling = !allMtdBilledFofoIds.contains(fofoId);
+                    if (rank == 1 || rank == 2 || hasZeroBilling || rank == 3) {
+                        l1OwnTarget++;
+                    }
+                }
+            }
-            // L2 Target = partners with RBM_L2_ESCALATION as latest remark
+            // L2 Target = L2 escalation partners + own L1 target (if also L1)
-            l2Model.setTodayTargetOfCall(l2TargetFofoIds.size());
+            l2Model.setTodayTargetOfCall(l2TargetFofoIds.size() + l1OwnTarget);
             // Value Achieved = All distinct partners called today (from call logs)
             long l2ValueAchieved = getCalledCountFromCallLogs(l2AuthId);
             l2Model.setValueTargetAchieved(l2ValueAchieved);
             l3Model.setOutOfSequenceCount(outOfSequenceCountByAuthId.getOrDefault(l3AuthId, 0L));
             rbmCallTargetModels.add(l3Model);
+        }
-        // Group L1 under their L2 manager, and L2 under their L3 manager using authUser.managerId
+        // Group models by escalation level
         Map<Integer, RbmCallTargetModel> l3ModelsByAuthId = new HashMap<>();
         Map<Integer, RbmCallTargetModel> l2ModelsByAuthId = new HashMap<>();
         Map<Integer, RbmCallTargetModel> l1ModelsByAuthId = new HashMap<>();
         for (RbmCallTargetModel m : rbmCallTargetModels) {
             if (m.isL3Position()) {
             } else {
                 l1ModelsByAuthId.put(m.getAuthId(), m);
+            }
+        }
+        // Build partner-based hierarchy using partner_position table
+        // Map positionId -> Position for quick lookup
+        Map<Integer, Position> positionByIdMap = allRbmPositions.stream()
+                .collect(Collectors.toMap(Position::getId, p -> p, (a, b) -> a));
+        // Get all RBM position IDs and fetch their partner assignments
+        List<Integer> allRbmPositionIds = allRbmPositions.stream()
+                .map(Position::getId).collect(Collectors.toList());
+        List<com.spice.profitmandi.dao.entity.cs.PartnerPosition> allPartnerPositions =
+                partnerPositionRepository.selectByPositionIds(allRbmPositionIds);
+        // Build partnerId -> map of escalationType -> Set<authUserIds>
+        // This tells us for each partner, who is their L1, L2, L3
+        Map<Integer, Map<EscalationType, Set<Integer>>> partnerToAuthByLevel = new HashMap<>();
+        for (com.spice.profitmandi.dao.entity.cs.PartnerPosition pp : allPartnerPositions) {
+            Position pos = positionByIdMap.get(pp.getPositionId());
+            if (pos != null && pos.getEscalationType() != null) {
+                partnerToAuthByLevel
+                        .computeIfAbsent(pp.getFofoId(), k -> new HashMap<>())
+                        .computeIfAbsent(pos.getEscalationType(), k -> new HashSet<>())
+                        .add(pos.getAuthUserId());
+            }
+        }
+        // Build L2 -> L1 team map based on shared partners
+        // If an L1 and L2 share partners (L1 at L1 level, L2 at L2 level), that L1 belongs under that L2
+        Map<Integer, List<RbmCallTargetModel>> l2TeamMap = new LinkedHashMap<>();
+        for (RbmCallTargetModel l2Model : l2ModelsByAuthId.values()) {
+            l2TeamMap.put(l2Model.getAuthId(), new ArrayList<>());
+        }
-        // Build L3 -> L2 team map using managerId from AuthUser
+        // Build L3 -> L2 team map based on shared partners
         Map<Integer, List<RbmCallTargetModel>> l3TeamMap = new LinkedHashMap<>();
         for (RbmCallTargetModel l3Model : l3ModelsByAuthId.values()) {
             l3TeamMap.put(l3Model.getAuthId(), new ArrayList<>());
+        }
+        // For each L1, find which L2 shares the most partners -> that's their L2
+        Set<Integer> addedL1AuthIds = new HashSet<>();
+        for (RbmCallTargetModel l1Model : l1ModelsByAuthId.values()) {
+            Map<Integer, Integer> l2SharedCount = new HashMap<>(); // l2AuthId -> shared partner count
+            for (Map.Entry<Integer, Map<EscalationType, Set<Integer>>> entry : partnerToAuthByLevel.entrySet()) {
+                Map<EscalationType, Set<Integer>> levelMap = entry.getValue();
+                Set<Integer> l1IdsForPartner = levelMap.getOrDefault(EscalationType.L1, Collections.emptySet());
+                Set<Integer> l2AuthIdsForPartner = levelMap.getOrDefault(EscalationType.L2, Collections.emptySet());
+                if (l1IdsForPartner.contains(l1Model.getAuthId())) {
+                    for (int l2Id : l2AuthIdsForPartner) {
+                        if (l2ModelsByAuthId.containsKey(l2Id) && l2Id != l1Model.getAuthId()) {
+                            l2SharedCount.merge(l2Id, 1, Integer::sum);
+                        }
+                    }
+                }
+            }
+            // Assign L1 to the L2 with most shared partners
+            if (!l2SharedCount.isEmpty()) {
+                int bestL2 = l2SharedCount.entrySet().stream()
+                        .max(Map.Entry.comparingByValue()).get().getKey();
+                l2TeamMap.get(bestL2).add(l1Model);
+                addedL1AuthIds.add(l1Model.getAuthId());
+            }
+        }
+        // For each L2, find which L3 shares the most partners -> that's their L3
         Set<Integer> addedL2AuthIds = new HashSet<>();
         for (RbmCallTargetModel l2Model : l2ModelsByAuthId.values()) {
+            Map<Integer, Integer> l3SharedCount = new HashMap<>();
+            for (Map.Entry<Integer, Map<EscalationType, Set<Integer>>> entry : partnerToAuthByLevel.entrySet()) {
+                Map<EscalationType, Set<Integer>> levelMap = entry.getValue();
+                Set<Integer> l2AuthIdsForPartner = levelMap.getOrDefault(EscalationType.L2, Collections.emptySet());
+                Set<Integer> l3AuthIdsForPartner = levelMap.getOrDefault(EscalationType.L3, Collections.emptySet());
-            AuthUser l2User = authUserMap.get(l2Model.getAuthId());
+                if (l2AuthIdsForPartner.contains(l2Model.getAuthId())) {
+                    for (int l3Id : l3AuthIdsForPartner) {
-            if (l2User != null && l3TeamMap.containsKey(l2User.getManagerId())) {
+                        if (l3ModelsByAuthId.containsKey(l3Id)) {
+                            l3SharedCount.merge(l3Id, 1, Integer::sum);
+                        }
+                    }
+                }
+            }
+            if (!l3SharedCount.isEmpty()) {
+                int bestL3 = l3SharedCount.entrySet().stream()
+                        .max(Map.Entry.comparingByValue()).get().getKey();
-                l3TeamMap.get(l2User.getManagerId()).add(l2Model);
+                l3TeamMap.get(bestL3).add(l2Model);
                 addedL2AuthIds.add(l2Model.getAuthId());
+            }
+        }
-        // Build L2 -> L1 team map using managerId from AuthUser
+        // For L1s not mapped to any L2, check if they map directly to an L3 via shared partners
-        Map<Integer, List<RbmCallTargetModel>> l2TeamMap = new LinkedHashMap<>();
+        Map<Integer, List<RbmCallTargetModel>> l3DirectL1Map = new LinkedHashMap<>();
-        for (RbmCallTargetModel l2Model : l2ModelsByAuthId.values()) {
+        for (RbmCallTargetModel l3Model : l3ModelsByAuthId.values()) {
-            l2TeamMap.put(l2Model.getAuthId(), new ArrayList<>());
+            l3DirectL1Map.put(l3Model.getAuthId(), new ArrayList<>());
+        }
-        Set<Integer> addedL1AuthIds = new HashSet<>();
         for (RbmCallTargetModel l1Model : l1ModelsByAuthId.values()) {
-            AuthUser l1User = authUserMap.get(l1Model.getAuthId());
+            if (addedL1AuthIds.contains(l1Model.getAuthId())) continue;
+            Map<Integer, Integer> l3SharedCount = new HashMap<>();
+            for (Map.Entry<Integer, Map<EscalationType, Set<Integer>>> entry : partnerToAuthByLevel.entrySet()) {
+                Map<EscalationType, Set<Integer>> levelMap = entry.getValue();
+                Set<Integer> l1IdsForPartner = levelMap.getOrDefault(EscalationType.L1, Collections.emptySet());
+                Set<Integer> l3AuthIdsForPartner = levelMap.getOrDefault(EscalationType.L3, Collections.emptySet());
-            if (l1User != null && l2TeamMap.containsKey(l1User.getManagerId())) {
+                if (l1IdsForPartner.contains(l1Model.getAuthId())) {
+                    for (int l3Id : l3AuthIdsForPartner) {
+                        if (l3ModelsByAuthId.containsKey(l3Id)) {
+                            l3SharedCount.merge(l3Id, 1, Integer::sum);
+                        }
+                    }
+                }
+            }
+            if (!l3SharedCount.isEmpty()) {
+                int bestL3 = l3SharedCount.entrySet().stream()
+                        .max(Map.Entry.comparingByValue()).get().getKey();
-                l2TeamMap.get(l1User.getManagerId()).add(l1Model);
+                l3DirectL1Map.get(bestL3).add(l1Model);
                 addedL1AuthIds.add(l1Model.getAuthId());
+            }
+        }
-        // Build sorted result: L3 row, then its L2 team with their L1 teams (sorted by name)
+        // Build sorted result: L3 -> L2 -> L1 (with direct L1s under L3 if no L2)
         List<RbmCallTargetModel> sortedModels = new ArrayList<>();
-        // First add L3 with their L2 teams
         List<RbmCallTargetModel> l3Sorted = new ArrayList<>(l3ModelsByAuthId.values());
         l3Sorted.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
         for (RbmCallTargetModel l3Model : l3Sorted) {
             sortedModels.add(l3Model);
                 sortedModels.add(l2Model);
                 List<RbmCallTargetModel> l1Team = l2TeamMap.getOrDefault(l2Model.getAuthId(), Collections.emptyList());
                 l1Team.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
                 sortedModels.addAll(l1Team);
+            }
+            // Add L1s that report directly to this L3 (no L2 in between)
+            List<RbmCallTargetModel> directL1Team = l3DirectL1Map.getOrDefault(l3Model.getAuthId(), Collections.emptyList());
+            directL1Team.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
+            sortedModels.addAll(directL1Team);
+        }
-        // Add L2s not mapped to any L3 with their L1 teams
+        // Add L2s not mapped to any L3
         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 : unmappedL2) {
             sortedModels.add(l2Model);
             List<RbmCallTargetModel> team = l2TeamMap.getOrDefault(l2Model.getAuthId(), Collections.emptyList());
             team.sort(Comparator.comparing(RbmCallTargetModel::getRbmName));
             sortedModels.addAll(team);
+        }
-        // Add any L1 RBMs not mapped to any L2 (sorted by name)
+        // Add any L1s not mapped to any L2 or L3
         List<RbmCallTargetModel> unmappedL1 = new ArrayList<>();
         for (RbmCallTargetModel m : l1ModelsByAuthId.values()) {
             if (!addedL1AuthIds.contains(m.getAuthId())) {
                 unmappedL1.add(m);
+            }

Subversion Repositories SmartDukaan

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