WebSVN – SmartDukaan – Diff – //trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/PartnerLimitHelper.java

 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.time.LocalDateTime;
 import java.util.*;
 import java.util.stream.Collectors;
 @Service
     /**
      * Read-only: calculates limits for all partners, returns only those that changed.
      */
     @Transactional(readOnly = true)
     public List<PartnerLimitUpdateData> calculateChangedPartnerLimits() throws ProfitMandiBusinessException {
+        return calculateChangedPartnerLimits(null);
+    }
+    /**
+     * Read-only: calculates limits and returns only those that changed.
+     *
+     * @param restrictTo when non-null, only these partners are considered. The 2-minute investment
+     * sweep passes the partners whose {@code base_value} moved — measured at 3 on average, peak 18 —
+     * so the limit stops rescanning all ~980 partners to find the handful that can possibly differ.
+     */
+    @Transactional(readOnly = true)
+    public List<PartnerLimitUpdateData> calculateChangedPartnerLimits(Collection<Integer> restrictTo)
+            throws ProfitMandiBusinessException {
         List<PartnerLimitUpdateData> changedPartners = new ArrayList<>();
         Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(true);
         Map<Integer, BigDecimal> fofoSidbiLimitMap = sidbiService.getSuggestedLimitMap();
         Map<Integer, SDCreditRequirement> sdCreditRequirementMap = sdCreditRequirementRepository.selectAll()
         Map<Integer, CreditAccount> creditAccountMap = creditAccountRepository
                 .selectAllByGateways(Arrays.asList(Gateway.SIDBI, Gateway.SDDIRECT))
                 .stream().filter(x -> x.isActive()).collect(Collectors.toMap(x -> x.getFofoId(), x -> x));
         Map<Integer, BulkCreditSummary> bulkSummaryMap = sdCreditService.getCreditSummaryBulk();
-        List<Integer> sortedFofoIds = customRetailerMap.keySet().stream().sorted().collect(Collectors.toList());
+        List<Integer> sortedFofoIds = customRetailerMap.keySet().stream()
+                .filter(id -> restrictTo == null || restrictTo.contains(id))
+                .sorted().collect(Collectors.toList());
+        // One grouped query instead of one per partner. getCurrentRisk only consults this when the
+        // partner has no risk_timestamp (418 of 980 have one, so those reads were discarded), and
+        // the per-partner form was ~4.7ms x 980 -- most of this job's runtime.
+        Map<Integer, LocalDateTime> firstBillingDateMap = transactionRepository.getFirstBillingDates(sortedFofoIds);
         for (int fofoId : sortedFofoIds) {
             // Per-partner isolation: one partner's bad data (null limit/util in the
             // compareTo, a getFirstBillingDate/getCurrentRisk failure, etc.) must not
             // abort the whole read phase and silently update zero partners. Mirrors the
                             suggestedAmount.subtract(utilizationAmount),
                             CreditRisk.HIGH_RISK, true));
                     continue;
+                }
-                LocalDateTime firstBillingDate = transactionRepository.getFirstBillingDate(fofoId);
+                LocalDateTime firstBillingDate = firstBillingDateMap.get(fofoId);
                 CreditRisk newRisk = sdCreditService.getCurrentRisk(existing, firstBillingDate);
                 BigDecimal currentLimit = existing.isHardLimit() ? existing.getLimit() : existing.getSuggestedLimit();
                 BigDecimal newLimit = existing.isHardLimit() ? existing.getLimit() : suggestedAmount;
                 BigDecimal newAvailable = newLimit.subtract(utilizationAmount);
-                // Compare: only include if something actually changed
+                // Compare: only include if something actually changed. Both sides are rounded to
+                // paise first — without that, double noise below half a paisa made ~90% of these
+                // "changes" phantom, rewriting sd_credit_requirement and dtr.credit_account (and
+                // churning the SIDBI mirror) ~14,000 times a day for identical values, and leaving
+                // update_timestamp useless as a signal of when a limit really moved.
-                boolean limitChanged = suggestedAmount.compareTo(existing.getSuggestedLimit()) != 0;
+                boolean limitChanged = scaleMoney(suggestedAmount).compareTo(scaleMoney(existing.getSuggestedLimit())) != 0;
-                boolean utilizationChanged = utilizationAmount.compareTo(existing.getUtilizedAmount()) != 0;
+                boolean utilizationChanged = scaleMoney(utilizationAmount).compareTo(scaleMoney(existing.getUtilizedAmount())) != 0;
                 boolean riskChanged = !newRisk.equals(existing.getRisk());
                 if (limitChanged || utilizationChanged || riskChanged) {
                     LOGGER.info("fofoId={} changed: limit {}→{}, util {}→{}, risk {}→{}, agedAppleStock={}",
                             fofoId,
+            }
         } else if (creditAccount.getGateway().equals(Gateway.SIDBI) && sidbiLimit != null) {
             suggestedAmount = getSuggestedLimit(getCreditableInvestment(partnerDailyInvestment) - utilization);
             suggestedAmount = suggestedAmount.max(sidbiLimit);
+        }
-        return suggestedAmount;
+        return scaleMoney(suggestedAmount);
+    }
+    /**
+     * Rounds to paise before the value is compared or stored.
+     *
+     * <p>The limit comes out of a double multiply, so it carries binary noise the stored
+     * DECIMAL(12,4) cannot — 65123.7400 round-trips and comes back as 65123.740000000005, which
+     * {@code BigDecimal.compareTo} reports as a change. Measured on a production run, 208 of 230
+     * "changed" partners differed by less than half a paisa; real changes were never smaller than a
+     * rupee, so rounding here sits in a clean gap and cannot suppress one.
+     */
+    private static BigDecimal scaleMoney(BigDecimal value) {
+        return (value == null ? BigDecimal.ZERO : value).setScale(2, RoundingMode.HALF_UP);
+    }
     /**
      * Investment that counts toward a suggested limit: total investment less the value of Apple
      * handsets the partner has held beyond {@link ProfitMandiConstants#AGED_STOCK_APPLE_DAYS} days

Subversion Repositories SmartDukaan

(root)//trunk/profitmandi-cron/src/main/java/com/smartdukaan/cron/scheduled/PartnerLimitHelper.java – Rev 37465 → 37589