Subversion Repositories SmartDukaan

import com.spice.profitmandi.dao.entity.cs.Position;

import com.spice.profitmandi.dao.entity.cs.Region;

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

import com.spice.profitmandi.dao.repository.cs.PositionRepository;

import com.spice.profitmandi.dao.entity.user.LeadCallAnswer;

import com.spice.profitmandi.dao.entity.user.LeadCallQuestion;

import com.spice.profitmandi.dao.repository.dtr.LeadCallChecklistRepository;

import java.util.Arrays;

    private LeadCallChecklistRepository leadCallChecklistRepository;

    @Autowired

    private PositionRepository positionRepository;

    @Autowired

     * First-call checklist for a lead (SOP §9 Path A step 2).

     *

     * <p>Returns the active question set, any answers already recorded, and — the part the caller

     * cannot work out for itself — whether this is actually the lead's FIRST connected call.

     *

     * <p>"First" means no earlier <em>answered</em> call. A string of unanswered dials does not make

     * the next one a second call: as far as the retailer is concerned nobody has spoken to them yet,

     * and that is exactly when the checklist is worth asking.

     */

    @RequestMapping(value = "/lms/checklist", method = RequestMethod.GET)

    @ResponseBody

    public ResponseEntity<?> checklist(@RequestParam(name = "leadId") int leadId,

                                       @RequestParam(name = "leadCallId", required = false) Integer leadCallId) {

        Lead lead = leadRepository.selectById(leadId);

        if (lead == null) {

            return responseSender.notFound("Lead not found");

        }

        // Only the questions that belong at the lead's CURRENT stage. A question tagged

        // NEW|ASSIGNED is a first-call question by construction; one tagged VISITED is not, and

        // showing the whole bank on every call is how a checklist becomes something people skip.

        String stage = lead.getEffectiveStage() == null ? null : lead.getEffectiveStage().name();

        List<LeadCallAnswer> answers = leadCallChecklistRepository.selectAnswersByLeadId(leadId);

        Map<Integer, LeadCallAnswer> byQuestion = new HashMap<>();

        for (LeadCallAnswer a : answers) {

            byQuestion.put(a.getQuestionId(), a);

        }

        List<Map<String, Object>> out = new ArrayList<>();

        int availablePoints = 0;

        for (LeadCallQuestion q : leadCallChecklistRepository.selectActiveQuestions()) {

            if (!q.appliesTo(stage)) {

                continue;

            }

            LeadCallAnswer a = byQuestion.get(q.getId());

            Map<String, Object> m = new LinkedHashMap<>();

            m.put("id", q.getId());

            m.put("prompt", q.getPrompt());

            m.put("answerType", q.getAnswerType());

            m.put("choices", q.getChoices() == null || q.getChoices().trim().isEmpty()

                    ? new ArrayList<String>() : Arrays.asList(q.getChoices().split("\\|")));

            m.put("required", q.isRequired());

            m.put("points", q.getPoints());

            m.put("answer", a == null ? null : a.getAnswer());

            out.add(m);

            availablePoints += q.getPoints();

        }

        // Score is over EVERY answer the lead has, not just the ones showing now — a lead that

        // answered the early questions keeps those points when it moves on to a later stage.

        int score = 0;

        for (LeadCallAnswer a : answers) {

            score += a.getPointsAwarded();

        }

        Map<String, Object> res = new LinkedHashMap<>();

        res.put("leadId", leadId);

        res.put("stage", stage);

        res.put("questions", out);

        res.put("answered", !answers.isEmpty());

        res.put("score", score);

        res.put("availablePoints", availablePoints);

        res.put("firstCall", !leadCallChecklistRepository.hasEarlierConnectedCall(leadId, leadCallId));

        // Worth showing on the panel: the checklist is about this retailer, not a generic form.

        res.put("retailer", joinName(lead.getFirstName(), lead.getLastName()));

        return responseSender.ok(res);

    }

    /** Record (or correct) the checklist answers for a lead. */

    @RequestMapping(value = "/lms/checklist", method = RequestMethod.POST,

            consumes = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    public ResponseEntity<?> saveChecklist(HttpServletRequest request, @RequestBody ChecklistRequest body) {

        if (body == null || body.leadId <= 0) {

            return responseSender.badRequest("Nothing to save");

        }

        Lead lead = leadRepository.selectById(body.leadId);

        if (lead == null) {

            return responseSender.notFound("Lead not found");

        }

        AuthUser me = currentUser(request);

        if (me == null) {

            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();

        }

        Map<Integer, LeadCallQuestion> active = new HashMap<>();

        for (LeadCallQuestion q : leadCallChecklistRepository.selectActiveQuestions()) {

            active.put(q.getId(), q);

        }

        int saved = 0;

        int points = 0;

        List<String> summary = new ArrayList<>();

        if (body.answers != null) {

            for (ChecklistAnswer a : body.answers) {

                LeadCallQuestion q = active.get(a.questionId);

                // Ignore anything that is not a live question rather than storing an answer to

                // something the screen never asked.

                if (q == null) {

                    continue;

                }

                String value = trimToNull(a.answer);

                if (value == null) {

                    continue;

                }

                if (value.length() > 1000) {

                    value = value.substring(0, 1000);

                }

                LeadCallAnswer row = new LeadCallAnswer();

                row.setLeadId(body.leadId);

                row.setLeadCallId(body.leadCallId);

                row.setQuestionId(q.getId());

                row.setAuthId(me.getId());

                row.setAnswer(value);

                // Snapshot the points as priced today, so re-pricing the question later does not

                // retroactively change what this lead scored.

                row.setPointsAwarded(q.getPoints());

                leadCallChecklistRepository.saveAnswer(row);

                saved++;

                points += q.getPoints();

                summary.add(q.getPrompt() + ": " + value);

            }

        }

        if (saved > 0) {

            // The trail is where the lead's story lives; a checklist that only existed in its own

            // table would be invisible to anyone reading the record.

            trail(body.leadId, me.getId(), latin1Safe("Checklist recorded (" + saved + " answer"

                    + (saved == 1 ? "" : "s") + ", " + points + " pts) - " + String.join(" \u00b7 ", summary)));

        }

        Map<String, Object> res = new LinkedHashMap<>();

        res.put("ok", true);

        res.put("saved", saved);

        res.put("points", points);

        LOGGER.info("Checklist saved for lead {} ({} answers) by auth {}", body.leadId, saved, me.getId());

        return responseSender.ok(res);

    }

    // ---- Assignment -------------------------------------------------------------------------

    /** Sales category in {@code cs.position} — the same one auto-assignment resolves owners from. */

    private static final int SALES_CATEGORY = com.spice.profitmandi.common.model.ProfitMandiConstants.TICKET_CATEGORY_SALES;

    /** Tiers a lead can be assigned to. L6+ exist but are not lead owners. */

    private static final List<EscalationType> SALES_TIERS = Arrays.asList(

            EscalationType.L1, EscalationType.L2, EscalationType.L3, EscalationType.L4, EscalationType.L5);

    /**

     * Sales people a lead can be assigned to, grouped by escalation tier (L1–L5).

     *

     * <p>Read from {@code cs.position}, the same source auto-assignment resolves owners from, so the

     * manual list and the engine can never disagree about who is a sales owner.

     *

     * <p>{@code regionId} does not filter the list — it marks who covers that region, so an agent can

     * see the right owner first without being prevented from picking someone else. A lead in a

     * region with no active owner still has to go to somebody.

     */

    @RequestMapping(value = "/lms/salespeople", method = RequestMethod.GET)

    @ResponseBody

    public ResponseEntity<?> salespeople(@RequestParam(name = "regionId", required = false) Integer regionId) {

        List<Position> positions = positionRepository.selectPositionByCategoryId(SALES_CATEGORY);

        if (positions == null) {

            positions = new ArrayList<>();

        }

        Set<Integer> ids = new HashSet<>();

        for (Position p : positions) {

            if (SALES_TIERS.contains(p.getEscalationType())) {

                ids.add(p.getAuthUserId());

            }

        }

        Map<Integer, AuthUser> users = new HashMap<>();

        if (!ids.isEmpty()) {

            for (AuthUser u : authRepository.selectByIds(new ArrayList<>(ids))) {

                users.put(u.getId(), u);

            }

        }

        // One row per person per tier: somebody can hold an L4 in one region and an L5 in another,

        // and collapsing that would hide which hat they are being picked under.

        Map<String, Map<String, Object>> byKey = new LinkedHashMap<>();

        for (Position p : positions) {

            if (!SALES_TIERS.contains(p.getEscalationType())) {

                continue;

            }

            AuthUser u = users.get(p.getAuthUserId());

            if (u == null || !Boolean.TRUE.equals(u.isActive())) {

                continue;                       // never offer a departed colleague as an owner

            }

            String key = p.getAuthUserId() + ":" + p.getEscalationType().name();

            Map<String, Object> m = byKey.get(key);

            if (m == null) {

                m = new LinkedHashMap<>();

                m.put("authId", u.getId());

                m.put("name", u.getFullName());

                m.put("email", u.getEmailId());

                m.put("tier", p.getEscalationType().name());

                m.put("regions", new ArrayList<String>());

                m.put("coversRegion", false);

                byKey.put(key, m);

            }

            Region r = p.getRegionId() > 0 ? regionRepository.selectById(p.getRegionId()) : null;

            if (r != null) {

                @SuppressWarnings("unchecked")

                List<String> regions = (List<String>) m.get("regions");

                String code = r.getRegionCode() != null ? r.getRegionCode() : r.getName();

                if (code != null && !regions.contains(code)) {

                    regions.add(code);

                }

                if (regionId != null && regionId > 0 && r.getId() == regionId) {

                    m.put("coversRegion", true);

                }

            }

        }

        Map<String, Object> res = new LinkedHashMap<>();

        res.put("people", new ArrayList<>(byKey.values()));

        List<String> tiers = new ArrayList<>();

        for (EscalationType t : SALES_TIERS) {

            tiers.add(t.name());

        }

        res.put("tiers", tiers);

        return responseSender.ok(res);

    }

    /**

     * Assign a lead to a sales person.

     *

     * <p>Sets the working owner ({@code assign_to}) only. The auto-resolved {@code owner_bm_id} is

     * left alone: it records which BM the region routed to, and overwriting it on a manual hand-off

     * would erase the routing decision the SLA and the HOLD queue are measured against.

     */

    @RequestMapping(value = "/lms/assignLead", method = RequestMethod.POST)

    @ResponseBody

    public ResponseEntity<?> assignLead(HttpServletRequest request,

                                        @RequestParam(name = "leadId") int leadId,

                                        @RequestParam(name = "authId") int authId) {

        Lead lead = leadRepository.selectById(leadId);

        if (lead == null) {

            return responseSender.notFound("Lead not found");

        }

        AuthUser me = currentUser(request);

        if (me == null) {

            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();

        }

        AuthUser owner = authRepository.selectById(authId);

        if (owner == null || !Boolean.TRUE.equals(owner.isActive())) {

            return responseSender.badRequest("That person is not an active user");

        }

        // Must hold a sales position — otherwise any auth id could be made a lead owner, and the

        // pipeline would show owners the assignment engine has never heard of.

        EscalationType tier = null;

        List<Position> held = positionRepository.selectPositionByAuthId(authId);

        if (held != null) {

            for (Position p : held) {

                if (p.getCategoryId() == SALES_CATEGORY && SALES_TIERS.contains(p.getEscalationType())) {

                    tier = p.getEscalationType();

                    break;

                }

            }

        }

        if (tier == null) {

            return responseSender.badRequest(owner.getFullName() + " does not hold a sales position (L1-L5)");

        }

        AuthUser previous = lead.getAssignTo() > 0 ? authRepository.selectById(lead.getAssignTo()) : null;

        if (previous != null && previous.getId() == authId) {

            return responseSender.badRequest("Already assigned to " + owner.getFullName());

        }

        lead.setAssignTo(authId);

        // A lead sitting in HOLD because its region had no owner now has one.

        if ("HOLD".equalsIgnoreCase(lead.getAssignmentStatus())) {

            lead.setAssignmentStatus("ASSIGNED");

        }

        lead.setUpdatedTimestamp(LocalDateTime.now());

        leadRepository.persist(lead);

        trail(leadId, me.getId(), latin1Safe("Assigned to " + owner.getFullName() + " (" + tier.name() + ")"

                + (previous != null ? " from " + previous.getFullName() : "")));

        LOGGER.info("Lead {} assigned to auth {} ({}) by auth {}", leadId, authId, tier, me.getId());

        Map<String, Object> res = new LinkedHashMap<>();

        res.put("ok", true);

        res.put("leadId", leadId);

        res.put("owner", owner.getFullName());

        res.put("tier", tier.name());

        return responseSender.ok(res);

    }

    // ---- Checklist question management (CRUD) -----------------------------------------------

    /** Every question, active and inactive, for the management screen. */

    @RequestMapping(value = "/lms/checklist/questions", method = RequestMethod.GET)

    @ResponseBody

    public ResponseEntity<?> listQuestions() {

        List<Map<String, Object>> out = new ArrayList<>();

        for (LeadCallQuestion q : leadCallChecklistRepository.selectAllQuestions()) {

            out.add(questionJson(q));

        }

        Map<String, Object> res = new LinkedHashMap<>();

        res.put("questions", out);

        // The screen builds its stage picker from this rather than hardcoding the ladder, so a new

        // LeadStage shows up without a front-end change.

        List<String> stages = new ArrayList<>();

        for (LeadStage st : LeadStage.HAPPY_PATH) {

            stages.add(st.name());

        }

        res.put("stages", stages);

        res.put("answerTypes", Arrays.asList("TEXT", "NUMBER", "YESNO", "CHOICE"));

        return responseSender.ok(res);

    }

    /** Create or update a question. An id of 0 creates. */

    @RequestMapping(value = "/lms/checklist/questions/save", method = RequestMethod.POST,

            consumes = MediaType.APPLICATION_JSON_VALUE)

    @ResponseBody

    public ResponseEntity<?> saveQuestion(HttpServletRequest request, @RequestBody QuestionRequest body) {

        if (body == null) {

            return responseSender.badRequest("Nothing to save");

        }

        AuthUser me = currentUser(request);

        if (me == null) {

            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();

        }

        String prompt = trimToNull(body.prompt);

        if (prompt == null) {

            return responseSender.badRequest("The question text is required");

        }

        if (prompt.length() > 500) {

            return responseSender.badRequest("Keep the question under 500 characters");

        }

        String type = trimToNull(body.answerType) == null ? "TEXT" : body.answerType.trim().toUpperCase();

        if (!Arrays.asList("TEXT", "NUMBER", "YESNO", "CHOICE").contains(type)) {

            return responseSender.badRequest("Unknown answer type: " + type);

        }

        String choices = trimToNull(body.choices);

        if ("CHOICE".equals(type) && choices == null) {

            return responseSender.badRequest("A choice question needs at least one option");

        }

        if (body.points != null && body.points < 0) {

            return responseSender.badRequest("Points cannot be negative");

        }

        // Reject unknown stage names rather than storing a filter that silently matches nothing.

        String stages = trimToNull(body.stages);

        if (stages != null) {

            for (String st : stages.split("\\|")) {

                if (st.trim().isEmpty()) {

                    continue;

                }

                try {

                    LeadStage.valueOf(st.trim().toUpperCase());

                } catch (IllegalArgumentException e) {

                    return responseSender.badRequest("Unknown stage: " + st.trim());

                }

            }

        }

        LeadCallQuestion q;

        boolean creating = body.id <= 0;

        if (creating) {

            q = new LeadCallQuestion();

        } else {

            q = leadCallChecklistRepository.selectQuestionById(body.id);

            if (q == null) {

                return responseSender.notFound("Question not found");

            }

        }

        q.setPrompt(latin1Safe(prompt));

        q.setAnswerType(type);

        q.setChoices("CHOICE".equals(type) ? latin1Safe(choices) : null);

        q.setRequired(Boolean.TRUE.equals(body.required));

        q.setActive(body.active == null || Boolean.TRUE.equals(body.active));

        q.setPoints(body.points == null ? 0 : body.points);

        q.setStages(stages == null ? null : stages.toUpperCase());

        q.setSortOrder(body.sortOrder == null ? 0 : body.sortOrder);

        leadCallChecklistRepository.saveQuestion(q);

        LOGGER.info("Checklist question {} by auth {}: {}", creating ? "created" : "updated", me.getId(), q.getPrompt());

        Map<String, Object> res = new LinkedHashMap<>();

        res.put("ok", true);

        res.put("id", q.getId());

        res.put("created", creating);

        return responseSender.ok(res);

    }

    /**

     * Delete a question — but only one nobody has answered.

     *

     * <p>A question with answers is retired by clearing {@code active}, never deleted: the answers

     * reference it, and removing it would leave a lead's recorded history pointing at nothing.

     */

    @RequestMapping(value = "/lms/checklist/questions/delete", method = RequestMethod.POST)

    @ResponseBody

    public ResponseEntity<?> deleteQuestion(HttpServletRequest request,

                                            @RequestParam(name = "id") int id) {

        AuthUser me = currentUser(request);

        if (me == null) {

            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();

        }

        LeadCallQuestion q = leadCallChecklistRepository.selectQuestionById(id);

        if (q == null) {

            return responseSender.notFound("Question not found");

        }

        long answers = leadCallChecklistRepository.countAnswersForQuestion(id);

        if (answers > 0) {

            return responseSender.badRequest("This question has " + answers + " recorded answer"

                    + (answers == 1 ? "" : "s") + " - switch it off instead of deleting it, so the "

                    + "answers keep their question");

        }

        leadCallChecklistRepository.deleteQuestion(q);

        LOGGER.info("Checklist question {} deleted by auth {}", id, me.getId());

        Map<String, Object> res = new LinkedHashMap<>();

        res.put("ok", true);

        return responseSender.ok(res);

    }

    private Map<String, Object> questionJson(LeadCallQuestion q) {

        Map<String, Object> m = new LinkedHashMap<>();

        m.put("id", q.getId());

        m.put("sortOrder", q.getSortOrder());

        m.put("prompt", q.getPrompt());

        m.put("answerType", q.getAnswerType());

        m.put("choices", q.getChoices());

        m.put("required", q.isRequired());

        m.put("active", q.isActive());

        m.put("points", q.getPoints());

        m.put("stages", q.getStages());

        m.put("answerCount", leadCallChecklistRepository.countAnswersForQuestion(q.getId()));

        return m;

    }

    /** Payload for {@link #saveQuestion}. */

    public static class QuestionRequest {

        public int id;

        public String prompt;

        public String answerType;

        public String choices;

        public Boolean required;

        public Boolean active;

        public Integer points;

        public String stages;

        public Integer sortOrder;

    }

    /** Payload for {@link #saveChecklist}. */

    public static class ChecklistRequest {

        public int leadId;

        public Integer leadCallId;

        public List<ChecklistAnswer> answers;

    }

    /** One answer in that payload. */

    public static class ChecklistAnswer {

        public int questionId;

        public String answer;

    }

    /**