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

         long calledCount = calledFofoIds.size() + calledNumbersWithoutFofoId.size();
         return new long[]{calledCount, totalRecordingCalls, uniqueRecordingNumbers.size()};
+    }
+    // Same rule as computeUniqueTriedCount but restricted to fofoIds in the target set.
+    // Used to compute "TGT Calls" — how many of THIS RBM's Calling Target partners were
+    // actually engaged today. Off-target activity is silently excluded.
+    private long computeUniqueTriedCountForTargets(List<AgentCallLog> callLogs,
+                                                   Map<String, Integer> mobileToFofoIdMap,
+                                                   Set<Integer> targetFofoIds) {
+        if (callLogs == null || callLogs.isEmpty()) return 0L;
+        if (targetFofoIds == null || targetFofoIds.isEmpty()) return 0L;
+        Map<Integer, List<AgentCallLog>> byFofoId = new HashMap<>();
+        for (AgentCallLog log : callLogs) {
+            String num = log.getCustomerNumber();
+            if (num == null) continue;
+            String normalized = num.startsWith("+91") ? num.substring(3) : num;
+            Integer fofoId = mobileToFofoIdMap != null ? mobileToFofoIdMap.get(normalized) : null;
+            if (fofoId == null) continue;
+            if (!targetFofoIds.contains(fofoId)) continue; // off-target, skip
+            byFofoId.computeIfAbsent(fofoId, k -> new ArrayList<>()).add(log);
+        }
+        long count = 0L;
+        for (List<AgentCallLog> logs : byFofoId.values()) {
+            boolean hasNonMissed = false;
+            for (AgentCallLog l : logs) {
+                if (!isMissedCustomerStatus(l.getCustomerStatus())) {
+                    hasNonMissed = true;
+                    break;
+                }
+            }
+            if (hasNonMissed) count++;
+            else if (logs.size() >= 3) count++;
+        }
+        return count;
+    }
     // Matches "Missed", "MISSED", "No Answer", "NO_ANSWER", "no-answer" etc.
     // Kommuno currently emits "Missed" — kept liberal so we're covered if the tag changes.
     private static boolean isMissedCustomerStatus(String status) {
         if (status == null) return false;
         String s = status.trim().toLowerCase().replace('_', ' ').replace('-', ' ').replaceAll("\\s+", " ");
             List<AgentCallLog> l1Logs = callLogsByAuthId.get((long) rbmAuthId);
             long[] callStats = getCallStatsFromLogs(l1Logs, mobileToFofoIdMap);
             targetModel.setValueTargetAchieved(callStats[0]);
             targetModel.setTotalRecordingCalls(callStats[1]);
             targetModel.setUniqueRecordingCalls(callStats[2]);
-            targetModel.setTriedUniqueCalls(computeUniqueTriedCount(l1Logs));
+            targetModel.setTriedUniqueCalls(computeUniqueTriedCount(l1Logs, mobileToFofoIdMap));
+            targetModel.setTgtCalls(computeUniqueTriedCountForTargets(l1Logs, mobileToFofoIdMap, todayTargetPartners));
             // Keep todayRemarks for movedToFuture calculation
             List<PartnerCollectionRemark> todayRemarks = remarksByAuthId.getOrDefault(rbmAuthId, Collections.emptyList());
             // Moved to Future = Partners in Future Plan category who have a remark today
             List<Integer> l2FofoIdList = l2AuthIdToFofoIds.getOrDefault(l2AuthId, Collections.emptyList());
             // For L2, use unique fofoIds with RBM_L2_ESCALATION remark as target
             Set<Integer> l2TargetFofoIds = new HashSet<>(l2FofoIdList);
+            // Collected from the L1-merge branch below when the user is also L1. Used later
+            // for the TGT Calls scope: L2 escalation + L1 target buckets.
+            Set<Integer> l1MergedTargetPartners = new HashSet<>();
             RbmCallTargetModel l2Model = new RbmCallTargetModel();
             l2Model.setAuthId(l2AuthId);
             l2Model.setRbmName(authUser.getFullName() + " (L2)");
             l2Model.setL2Position(true);
             l2Model.setL2CallingList(l2TargetFofoIds.size());
                 l2Model.setRevival(revivalPartners.size());
                 long l1OwnTarget = planTodayPartners.size() + carryForwardPartners.size()
                         + zeroBillingPartners.size() + untouchedPartners.size();
+                // Feed the L1 target sets up to the outer scope so TGT Calls can include them.
+                l1MergedTargetPartners.addAll(planTodayPartners);
+                l1MergedTargetPartners.addAll(carryForwardPartners);
+                l1MergedTargetPartners.addAll(zeroBillingPartners);
+                l1MergedTargetPartners.addAll(untouchedPartners);
                 // Today Target = own L1 target + L2 escalation
                 l2Model.setTodayTargetOfCall(l2TargetFofoIds.size() + l1OwnTarget);
                 // Moved to Future from L1 partners
                 List<PartnerCollectionRemark> todayRemarks = remarksByAuthId.getOrDefault(l2AuthId, Collections.emptyList());
             List<AgentCallLog> l2Logs = callLogsByAuthId.get((long) l2AuthId);
             long[] l2CallStats = getCallStatsFromLogs(l2Logs, mobileToFofoIdMap);
             l2Model.setValueTargetAchieved(l2CallStats[0]);
             l2Model.setTotalRecordingCalls(l2CallStats[1]);
             l2Model.setUniqueRecordingCalls(l2CallStats[2]);
-            l2Model.setTriedUniqueCalls(computeUniqueTriedCount(l2Logs));
+            l2Model.setTriedUniqueCalls(computeUniqueTriedCount(l2Logs, mobileToFofoIdMap));
+            // TGT Calls scope: L2 escalation + (if user is also L1) the L1 target buckets.
+            Set<Integer> l2TgtSet = new HashSet<>(l2TargetFofoIds);
+            l2TgtSet.addAll(l1MergedTargetPartners);
+            l2Model.setTgtCalls(computeUniqueTriedCountForTargets(l2Logs, mobileToFofoIdMap, l2TgtSet));
             l2Model.setOutOfSequenceCount(outOfSequenceCountByAuthId.getOrDefault(l2AuthId, 0L));
             rbmCallTargetModels.add(l2Model);
+        }
             List<AgentCallLog> l3Logs = callLogsByAuthId.get((long) l3AuthId);
             long[] l3CallStats = getCallStatsFromLogs(l3Logs, mobileToFofoIdMap);
             l3Model.setValueTargetAchieved(l3CallStats[0]);
             l3Model.setTotalRecordingCalls(l3CallStats[1]);
             l3Model.setUniqueRecordingCalls(l3CallStats[2]);
-            l3Model.setTriedUniqueCalls(computeUniqueTriedCount(l3Logs));
+            l3Model.setTriedUniqueCalls(computeUniqueTriedCount(l3Logs, mobileToFofoIdMap));
+            // L3 TGT Calls scope: L3 escalation partners.
+            l3Model.setTgtCalls(computeUniqueTriedCountForTargets(l3Logs, mobileToFofoIdMap, l3TargetFofoIds));
             l3Model.setOutOfSequenceCount(outOfSequenceCountByAuthId.getOrDefault(l3AuthId, 0L));
             rbmCallTargetModels.add(l3Model);
+        }
      *   - Else (every call to this number was Missed) → count only if attempts >= 3
      *     (persistence credit).
      * null/empty customerStatus is treated as "not Missed" (favours counting when
      * the vendor didn't classify the outcome).
      */
-    private long computeUniqueTriedCount(List<AgentCallLog> callLogs) {
+    private long computeUniqueTriedCount(List<AgentCallLog> callLogs,
+                                         Map<String, Integer> mobileToFofoIdMap) {
         if (callLogs == null || callLogs.isEmpty()) return 0L;
+        // Group by fofoId (not raw number) — numbers that don't resolve to a partner via
+        // retailer_contact/address are skipped. Once a number gets added to retailer_contact
+        // it'll automatically resolve and start counting on the next page load.
-        Map<String, List<AgentCallLog>> byNumber = new HashMap<>();
+        Map<Integer, List<AgentCallLog>> byFofoId = new HashMap<>();
         for (AgentCallLog log : callLogs) {
             String num = log.getCustomerNumber();
             if (num == null) continue;
             String normalized = num.startsWith("+91") ? num.substring(3) : num;
+            Integer fofoId = mobileToFofoIdMap != null ? mobileToFofoIdMap.get(normalized) : null;
+            if (fofoId == null) continue; // unknown number — excluded from Tried
-            byNumber.computeIfAbsent(normalized, k -> new ArrayList<>()).add(log);
+            byFofoId.computeIfAbsent(fofoId, k -> new ArrayList<>()).add(log);
+        }
         long count = 0L;
-        for (List<AgentCallLog> logs : byNumber.values()) {
+        for (List<AgentCallLog> logs : byFofoId.values()) {
             boolean hasNonMissed = false;
             for (AgentCallLog l : logs) {
                 if (!isMissedCustomerStatus(l.getCustomerStatus())) {
                     hasNonMissed = true;
                     break;

Subversion Repositories SmartDukaan

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