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

             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));
-            // Keep todayRemarks for movedToFuture calculation
+            // Keep todayRemarks for movedToFuture calculation AND for Tried calculation
             List<PartnerCollectionRemark> todayRemarks = remarksByAuthId.getOrDefault(rbmAuthId, Collections.emptyList());
+            targetModel.setTriedUniqueCalls(computeUniqueTriedCount(l1Logs, mobileToFofoIdMap, todayRemarks));
             // Moved to Future = Partners in Future Plan category who have a remark today
             // These are partners who were contacted today but moved to a future date
             Set<Integer> todayRemarkedFofoIds = todayRemarks.stream()
                     .map(PartnerCollectionRemark::getFofoId)
             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,
+                    remarksByAuthId.getOrDefault(l2AuthId, Collections.emptyList())));
             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,
+                    remarksByAuthId.getOrDefault(l3AuthId, Collections.emptyList())));
             l3Model.setOutOfSequenceCount(outOfSequenceCountByAuthId.getOrDefault(l3AuthId, 0L));
             rbmCallTargetModels.add(l3Model);
+        }
         LOGGER.info("RBM Call Target - TOTAL TIME: {}ms, RBM count: {}", System.currentTimeMillis() - methodStart, sortedModels.size());
         return sortedModels;
+    }
     /**
-     * Rule: count each distinct customer number this RBM attempted today, EXCEPT
+     * Rule: count each distinct customer number this RBM attempted today, based on
+     * post-call REMARKS (PartnerCollectionRemark), not the vendor callStatus:
-     * numbers whose every log entry has callStatus "No Answer" — those count only
+     *   - If the RBM logged ANY remark other than NO_ANSWER for this partner today
-     * if there were 3 or more attempts (persistence credit). Recording presence is
+     *     → count as 1 (customer was reached / tagged with a real outcome).
+     *   - Else if the RBM has NO remark row at all for this partner today → count
-     * not required. null/empty callStatus is treated as "not no-answer" (favours
+     *     as 1 (treat missing remark as "not tagged no-answer" — matches the "-"
-     * counting when the vendor didn't classify the outcome).
+     *     rows shown in the Called Partners modal which count as tried).
+     *   - Else (every remark is NO_ANSWER) → count only if attempts >= 3
+     *     (persistence credit).
+     * Unknown numbers (no fofoId mapping) always count as 1 — no remark to check.
      */
-    private long computeUniqueTriedCount(List<AgentCallLog> callLogs) {
+    private long computeUniqueTriedCount(List<AgentCallLog> callLogs,
+                                         Map<String, Integer> mobileToFofoIdMap,
+                                         List<PartnerCollectionRemark> rbmRemarksToday) {
         if (callLogs == null || callLogs.isEmpty()) return 0L;
+        // Build fofoId -> remarks (only the current RBM's remarks today are in scope).
+        Map<Integer, List<PartnerCollectionRemark>> remarksByFofoId = new HashMap<>();
+        if (rbmRemarksToday != null) {
+            for (PartnerCollectionRemark r : rbmRemarksToday) {
+                remarksByFofoId.computeIfAbsent(r.getFofoId(), k -> new ArrayList<>()).add(r);
+            }
+        }
+        // Attempts (call count) per fofoId, or per raw number if unresolved.
-        Map<String, List<AgentCallLog>> byNumber = new HashMap<>();
+        Map<Integer, Integer> attemptsByFofo = new HashMap<>();
+        Set<String> unresolvedNumbers = new HashSet<>();
         for (AgentCallLog log : callLogs) {
             String num = log.getCustomerNumber();
             if (num == null) continue;
             String normalized = num.startsWith("+91") ? num.substring(3) : num;
-            byNumber.computeIfAbsent(normalized, k -> new ArrayList<>()).add(log);
+            Integer fofoId = mobileToFofoIdMap != null ? mobileToFofoIdMap.get(normalized) : null;
+            if (fofoId != null) {
+                attemptsByFofo.merge(fofoId, 1, Integer::sum);
+            } else {
+                unresolvedNumbers.add(normalized);
+            }
+        }
         long count = 0L;
-        for (List<AgentCallLog> logs : byNumber.values()) {
+        for (Map.Entry<Integer, Integer> e : attemptsByFofo.entrySet()) {
+            int fofoId = e.getKey();
+            int attempts = e.getValue();
+            List<PartnerCollectionRemark> remarks = remarksByFofoId.getOrDefault(fofoId, Collections.emptyList());
+            if (remarks.isEmpty()) {
+                // No remark logged today for this fofoId — counts.
+                count++;
+                continue;
+            }
             boolean hasNonNoAnswer = false;
-            for (AgentCallLog l : logs) {
+            for (PartnerCollectionRemark r : remarks) {
-                if (!isNoAnswerStatus(l.getCallStatus())) {
+                if (r.getRemark() != CollectionRemark.NO_ANSWER) {
                     hasNonNoAnswer = true;
                     break;
+                }
+            }
             if (hasNonNoAnswer) count++;
-            else if (logs.size() >= 3) count++;
+            else if (attempts >= 3) count++;
+        }
+        // Unresolved numbers — count each as 1.
+        count += unresolvedNumbers.size();
         return count;
+    }
     /**
      * Returns call stats: [0] = called count, [1] = total recording calls, [2] = unique recording calls

Subversion Repositories SmartDukaan

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