WebSVN – SmartDukaan – Diff – /trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/LmsLeadController.java

         model.addAttribute("stageIndex", happyPathIndex(effectiveStage));
         model.addAttribute("terminal", isTerminal(effectiveStage));
         model.addAttribute("stages", LeadStage.HAPPY_PATH);
         model.addAttribute("dispositions", LeadDisposition.values());
         model.addAttribute("slaState", lmsAssignmentService.slaState(lead));
+        model.addAttribute("businessValue", lakhLabel(lead.getPotential()));
+        model.addAttribute("businessValueInput", lakhInput(lead.getPotential()));
         model.addAttribute("dateTimeFormatter", RECORD_FORMAT);
         // Region picker in the edit modal — the same list the Create-Lead form offers.
         model.addAttribute("regions", regionRepository.selectAll());
+        }
         AuthUser actor = currentUser(request);
         applyStage(lead, target);
         leadRepository.persist(lead);
+        appendTrail(leadId, actor,
-        appendTrail(leadId, actor, "Stage " + pretty(current) + " → " + pretty(target) + ": " + comment.trim(), null, null);
+                latin1Safe("Stage " + pretty(current) + " -> " + pretty(target) + ": " + comment.trim()),
+                null, null);
         LOGGER.info("LMS stage advanced: lead {} {} -> {} by {}", leadId, current, target,
                 actor != null ? actor.getId() : 0);
         return responseSender.ok(stateOf(lead));
+    }
         AuthUser actor = currentUser(request);
         LeadStage before = lead.getEffectiveStage();
         LeadCall call = resolveCall(body, lead, actor);
+        String subReason = latin1Safe(trimToNull(body.subReason));
+        if (subReason != null && subReason.length() > 64) {
+            return responseSender.badRequest("Sub-reason is too long - keep it to 64 characters");
+        }
         lead.setDisposition(disposition);
-        lead.setDispositionSubReason(trimToNull(body.subReason));
+        lead.setDispositionSubReason(subReason);
         // Interim manual path — drops out when the dialer starts filling recordings from the webhook.
         if (body.recordingUrl != null && !body.recordingUrl.trim().isEmpty()) {
             lead.setRecordingUrl(body.recordingUrl.trim());
+        }
         // Reaching the retailer IS the first contact — stamp once, never move it. NOT_REACHABLE (nobody
         leadRepository.persist(lead);
         CommunicationType type = "MEETING".equalsIgnoreCase(body.followUpType)
                 ? CommunicationType.VISIT : CommunicationType.TELEPHONIC;
         LeadActivity activity = appendTrail(body.leadId, actor,
-                dispositionRemark(disposition, before, lead, body), type, scheduled,
+                latin1Safe(dispositionRemark(disposition, before, lead, body)), type, scheduled,
                 call != null ? call.getId() : null);
         // Bind both ways: the trail entry knows its call (for duration + a recording link), and the
         // call knows the disposition it produced (so an unactioned call is findable).
         if (call != null) {
         LeadDnd dnd = new LeadDnd();
         dnd.setMobile(lead.getLeadMobile());
         dnd.setLeadId(lead.getId());
         dnd.setAuthId(actor != null ? actor.getId() : null);
         dnd.setSource("DISPOSITION");
-        dnd.setReason(trimToNull(body.note) != null
+        dnd.setReason(latin1Safe(trimToNull(body.note) != null
-                ? trimToNull(body.note) : "Retailer asked not to be contacted");
+                ? trimToNull(body.note) : "Retailer asked not to be contacted"));
         leadDndRepository.block(dnd);
         LOGGER.info("LMS DND block on lead {} by {}", lead.getId(), actor != null ? actor.getId() : 0);
+    }
     /**
         AuthUser me = currentUser(request);
         if (me == null) {
             return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
+        }
-        String name = trimToNull(body.retailerName);
+        String name = latin1Safe(trimToNull(body.retailerName));
         if (name == null) {
             return responseSender.badRequest("Retailer name is required");
+        }
+        // These columns are narrow (city and state are varchar(30)) and the server runs
+        // STRICT_TRANS_TABLES, so an over-long value is a 500 at flush rather than a rejected field.
+        // Check here and name the field, so the agent can shorten it instead of losing the edit.
+        String tooLong = firstTooLong(
+                "Retailer name", name, 128,
+                "Business name", body.businessName, 100,
+                "Address", body.address, 128,
+                "City", body.city, 30,
+                "State", body.state, 30);
+        if (tooLong != null) {
+            return responseSender.badRequest(tooLong);
+        }
         String mobile = digitsOnly(body.mobile);
         if (mobile == null || mobile.length() < 10) {
             return responseSender.badRequest("A valid 10-digit contact number is required");
+        }
         mobile = mobile.substring(mobile.length() - 10);
         List<String> entries = new ArrayList<>();
         String beforeName = joinName(lead.getFirstName(), lead.getLastName());
         if (!name.equals(beforeName)) {
             int space = name.lastIndexOf(' ');
+            // Both halves are varchar(64); a long single-token name would otherwise fail at flush.
+            if ((space > 0 ? name.substring(0, space) : name).length() > 64
+                    || (space > 0 ? name.substring(space + 1) : "").length() > 64) {
+                return responseSender.badRequest(
+                        "Retailer name is too long - keep each part to 64 characters");
+            }
             lead.setFirstName(space > 0 ? name.substring(0, space) : name);
             // user.lead.last_name is NOT NULL — a single-word name keeps an empty surname, not null.
             lead.setLastName(space > 0 ? name.substring(space + 1) : "");
             entries.add(fieldChange("Retailer", beforeName, name));
+        }
         if (mobileChanged) {
             entries.add(fieldChange("Contact", lead.getLeadMobile(), mobile));
             lead.setLeadMobile(mobile);
+        }
-        String outlet = trimToNull(body.businessName);
+        String outlet = latin1Safe(trimToNull(body.businessName));
         if (!same(lead.getOutLetName(), outlet)) {
             entries.add(fieldChange("Business", lead.getOutLetName(), outlet));
             lead.setOutLetName(outlet == null ? "" : outlet);
+        }
         // address / city / state are NOT NULL — blanked fields are written empty, never null.
-        String address = trimToEmpty(body.address);
+        String address = latin1Safe(trimToEmpty(body.address));
-        String city = trimToEmpty(body.city);
+        String city = latin1Safe(trimToEmpty(body.city));
-        String state = trimToEmpty(body.state);
+        String state = latin1Safe(trimToEmpty(body.state));
         String beforeLocation = locationOf(lead.getAddress(), lead.getCity(), lead.getState());
         String afterLocation = locationOf(address, city, state);
         if (!beforeLocation.equals(afterLocation)) {
             lead.setAddress(address);
             lead.setCity(city);
             StringBuilder move = new StringBuilder(fieldChange("Region", beforeRegion, a.regionCode));
             if (a.bm != null) {
                 move.append(" · owner re-resolved to ").append(a.bm.getFullName());
                 if (!stillAutoAssigned) {
-                    move.append(" (working owner left unchanged — the lead is mapped to a named user)");
+                    move.append(" (working owner left unchanged - the lead is mapped to a named user)");
+                }
             } else {
                 move.append(" · no active BM/RSM for that region, moved to the HOLD queue");
+            }
             entries.add(move.toString());
+        }
         lead.setUpdatedTimestamp(LocalDateTime.now());
         leadRepository.persist(lead);
         for (String entry : entries) {
-            trail(lead.getId(), me.getId(), entry);
+            trail(lead.getId(), me.getId(), latin1Safe(entry));
+        }
         LOGGER.info("LMS lead {} edited by auth {} — {}", lead.getId(), me.getId(), entries);
         Map<String, Object> out = new LinkedHashMap<>();
         out.put("ok", true);
         public String state;
         public Integer regionId;
         public Double potential;
+    }
+    /**
+     * Trail line for one edited field.
+     *
+     * <p>ASCII only, deliberately. {@code user.lead_activity.remark} is latin1_swedish_ci, so an
+     * arrow or an em dash makes the INSERT fail with "Incorrect string value" — and because the
-    /** Trail line for one edited field. Blank before/after read as an em dash, not as nothing. */
+     * failure surfaces at flush rather than at the write, it arrives as an unrelated-looking
+     * "null id in LeadActivity entry" 500.
+     */
     private String fieldChange(String label, String before, String after) {
-        return label + " " + orDash(before) + " → " + orDash(after);
+        return label + " " + orDash(before) + " -> " + orDash(after);
+    }
     private String orDash(String s) {
-        return (s == null || s.trim().isEmpty()) ? "—" : s.trim();
+        return (s == null || s.trim().isEmpty()) ? "(not set)" : s.trim();
+    }
+    /**
+     * First over-long field, as a message naming it and its limit; null when all fit.
+     *
+     * <p>Args come in (label, value, max) triples. Retailer name is checked against 128 because it
+     * is split across first_name and last_name, which are varchar(64) each.
+     */
+    private String firstTooLong(Object... fields) {
+        for (int i = 0; i + 2 < fields.length; i += 3) {
+            String label = (String) fields[i];
+            String value = (String) fields[i + 1];
+            int max = (Integer) fields[i + 2];
+            if (value != null && value.trim().length() > max) {
+                return label + " is too long - keep it to " + max + " characters (currently "
+                        + value.trim().length() + ")";
+            }
+        }
+        return null;
+    }
+    /**
+     * Make caller-supplied text safe for the latin1 columns this controller writes.
+     *
+     * <p>Every text column here — {@code lead_activity.remark}, {@code lead.disposition_sub_reason},
+     * the address fields — is latin1_swedish_ci. Fixing our own literals was only half the job: an
+     * agent pastes a note from WhatsApp or Word and it arrives full of smart quotes, en dashes and
+     * ellipses, none of which exist in latin1. That INSERT fails, and because the failure surfaces
+     * at flush it reads as "null id in LeadActivity entry" rather than as a bad character.
+     *
+     * <p>The common typographic characters are transliterated rather than dropped, because losing an
+     * apostrophe out of "retailer's shop" is silent damage. Anything else outside latin1 (emoji,
+     * Devanagari) becomes '?' — visible, so it is obvious the text was not stored verbatim.
+     */
+    private String latin1Safe(String s) {
+        if (s == null || s.isEmpty()) {
+            return s;
+        }
+        StringBuilder out = new StringBuilder(s.length());
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            switch (c) {
+                case '\u2018': case '\u2019': case '\u201B': out.append('\''); break;   // ' ' ‛
+                case '\u201C': case '\u201D': case '\u201E': out.append('"'); break;    // " " „
+                case '\u2013': case '\u2014': case '\u2212': out.append('-'); break;    // – — −
+                case '\u2026': out.append("..."); break;                                // …
+                case '\u2192': out.append("->"); break;                                 // →
+                case '\u20B9': out.append("Rs"); break;                                 // ₹
+                case '\u00A0': out.append(' '); break;                                  // nbsp
+                default:
+                    out.append(c <= 0xFF ? c : '?');
+            }
+        }
+        return out.toString();
+    }
     private boolean same(String a, String b) {
         return orDash(a).equals(orDash(b));
+    }
+        }
         return sb.toString();
+    }
     private String money(double value) {
+        String label = lakhLabel(value);
-        return "₹" + String.format("%.0f", value) + "/mo";
+        return label == null ? "(not set)" : label + "/mo";
+    }
     /**
      * Region &rarr; owning BM/RSM, resolved live from {@code cs.position}. Drives the Create-Lead
      * assignment preview and the dashboard's routing table; {@code HOLD} means the region has no
                 sb.append(", retry ").append(body.retrySchedule.trim());
+            }
+        }
         LeadStage after = lead.getEffectiveStage();
         if (after != before) {
-            sb.append(" · stage ").append(pretty(before)).append(" → ").append(pretty(after));
+            sb.append(" · stage ").append(pretty(before)).append(" -> ").append(pretty(after));
+        }
         if (body.note != null && !body.note.trim().isEmpty()) {
-            sb.append(" — ").append(body.note.trim());
+            sb.append(" - ").append(body.note.trim());
+        }
         return sb.toString();
+    }
     /** What the caller needs to refresh its row without re-reading the whole record. */
     private boolean isTerminal(LeadStage stage) {
         return stage == LeadStage.NOT_INTERESTED || stage == LeadStage.DROPPED;
+    }
     private String pretty(LeadStage stage) {
-        return stage == null ? "—" : pretty(stage.name());
+        return stage == null ? "-" : pretty(stage.name());
+    }
     private String pretty(String enumName) {
         return enumName.replace('_', ' ');
+    }
     @ResponseBody
     public ResponseEntity<?> createLead(HttpServletRequest request, @RequestBody CreateLeadRequest body) {
         if (body == null) {
             return responseSender.badRequest("Nothing to create");
+        }
-        String name = body.firstName == null ? "" : body.firstName.trim();
+        String name = latin1Safe(body.firstName == null ? "" : body.firstName.trim());
         if (name.isEmpty()) {
             return responseSender.badRequest("Retailer name is required");
+        }
         String mobile = body.mobile == null ? "" : body.mobile.replaceAll("\\D", "");
         if (mobile.length() < 10) {
         // address / city / state are NOT NULL but are no longer asked for: the geo link supplies the
         // real location. Coalesced rather than left to fail the insert.
         lead.setAddress("");
         lead.setCity("");
         lead.setState("");
-        lead.setSource(body.source == null || body.source.trim().isEmpty() ? "LMS Dashboard" : body.source.trim());
+        lead.setSource(latin1Safe(body.source == null || body.source.trim().isEmpty()
+                ? "LMS Dashboard" : body.source.trim()));
         lead.setCreatedTimestamp(LocalDateTime.now());
         lead.setUpdatedTimestamp(LocalDateTime.now());
         lead.setCreatedBy(me.getFirstName() + " " + me.getLastName());
         lead.setAuthId(me.getId());
         // The record screen reads the business name off user.lead.outlet_name. Until now it was only
         // written to lead_detail below — a call that throws for every lead created here, because the
         // legacy detail path demands store photos this form deliberately does not collect — so the
         // name the agent typed was silently dropped and the Business row rendered blank.
-        lead.setOutLetName(body.outletName == null ? "" : body.outletName.trim());
+        lead.setOutLetName(latin1Safe(body.outletName == null ? "" : body.outletName.trim()));
         lead.setRegionId(body.regionId);
         if (body.potential != null && body.potential > 0) {
             lead.setPotential(body.potential);
+        }
         // Path B is a field encounter, so the creator owns it; Path A goes to the region's BM.
+                }
                 created.append(bv.brand.trim()).append(' ').append(bv.value.longValue());
                 first = false;
+            }
+        }
-        trail(lead.getId(), me.getId(), created.toString()
+        trail(lead.getId(), me.getId(), latin1Safe(created.toString()
                 + (assignment != null && "HOLD".equals(assignment.assignmentStatus)
-                   ? " — region has no active BM/RSM, parked in the HOLD queue" : ""));
+                   ? " - region has no active BM/RSM, parked in the HOLD queue" : "")));
         // Auto-generate the geo capture link so the agent can send it during the same call.
         String geoLink = buildGeoCaptureLink(lead.getId());
         if (geoLink != null) {
             trail(lead.getId(), me.getId(), "Geolocation link generated for lead");
         LOGGER.info("LMS lead {} created ({}) by auth {} — region {} status {}",
                 lead.getId(), lead.getLmsCode(), me.getId(), lead.getRegionCode(), lead.getAssignmentStatus());
         return responseSender.ok(out);
+    }
+    /**
+     * Business value on the lakh scale.
+     *
+     * <p>Two conventions live in {@code user.lead.potential}: the forms capture LAKHS (rows hold
+     * 1&ndash;99) but about 1,355 older rows were entered in RUPEES (1,000 upwards). No row sits
+     * between 100 and 999, so that gap is a safe separator — anything from {@value #LAKH_CUTOFF} up
-    /** Append a trail entry. Never fatal — a lost note must not fail the lead. */
+     * is read as rupees and brought onto the lakh scale. Read-side only: no stored value is
-    private void trail(int leadId, int authId, String remark) {
+     * rewritten, so a row keeps whatever it holds until someone edits it.
-        try {
+     */
+    private static final double LAKH_CUTOFF = 1000d;
+    private double toLakh(double v) {
-            LeadActivity activity = new LeadActivity();
+        return v >= LAKH_CUTOFF ? v / 100000d : v;
+    }
+    /** "12L" / "5.2L" / "0.01L" — a sub-lakh value needs two decimals or it prints as 0L. */
+    private String lakhLabel(double potential) {
-            activity.setLeadId(leadId);
+        if (potential <= 0) {
-            activity.setAuthId(authId);
+            return null;
+        }
-            activity.setRemark(remark);
+        double l = toLakh(potential);
-            activity.setCreatedTimestamp(LocalDateTime.now());
+        String n = (l < 1) ? trimZeros(String.format("%.2f", l)) : trimZeros(String.format("%.1f", l));
+        return n + "L";
+    }
+    /** The same number, unsuffixed, for the edit form — so saving cannot re-store rupees. */
-            leadActivityRepository.persist(activity);
+    private String lakhInput(double potential) {
-        } catch (Exception e) {
+        if (potential <= 0) {
-            LOGGER.warn("Could not write the trail entry for lead {}", leadId, e);
+            return "";
+        }
+        double l = toLakh(potential);
+        return (l < 1) ? trimZeros(String.format("%.2f", l)) : trimZeros(String.format("%.1f", l));
+    }
+    private String trimZeros(String s) {
+        return s.contains(".") ? s.replaceAll("0+$", "").replaceAll("\\.$", "") : s;
+    }
+    /**
+     * Append a trail entry.
+     *
+     * <p>Deliberately NOT caught. It used to swallow the exception on the grounds that "a lost note
+     * must not fail the lead", but inside a {@code @Transactional} method that is worse than
+     * useless: the failed entity stays in the Hibernate session with a null id, the request carries
+     * on, and the commit-time flush dies with "null id in LeadActivity entry" — an error that names
+     * neither the lead nor the real cause. An edit that cannot be recorded should fail loudly and
+     * roll back; SOP §6 wants the trail append-only, and a change with no trail entry is worse than
+     * a change that did not happen.
+     */
+    private void trail(int leadId, int authId, String remark) {
+        LeadActivity activity = new LeadActivity();
+        activity.setLeadId(leadId);
+        activity.setAuthId(authId);
+        activity.setRemark(remark);
+        activity.setCreatedTimestamp(LocalDateTime.now());
+        leadActivityRepository.persist(activity);
+    }
     /**
      * {base}/lead-geo/{leadId} — the same URL the Leads screen's Generate Link button produces.
      * Null when the base URL is unconfigured, which must not stop a lead being created.

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/LmsLeadController.java – Rev 37651 → 37692