Subversion Repositories SmartDukaan

	// ==================== ASSIGN LEADS ONTO BEATS ====================

	// A rep's assigned leads can be routed onto a beat from two surfaces:

	//   • Route Planner "Assigned Leads" list → single lead, calendar-chip picks beat+date

	//   • Day View "Add Lead" modal           → bulk write onto a known beat+date

	// Both converge on the same dated, APPROVED lead_route write (writeLeadRoute),

	// mirroring VisitRequestController.approveSchedule and deferredAssignToBeat's

	// lead branch. Nothing downstream changes — getBeatVisits and the

	// /visit-approvals/beat-route feed already render lead_route rows for the run.

	// Active/open lead colours a manager can still route (matches getOpenLead's

	// All → yellow+green expansion). Red/other are dropped as not-worth-visiting.

	private static final Set<String> ROUTABLE_LEAD_COLORS =

			new HashSet<>(Arrays.asList("yellow", "green"));

	// Can the caller see the selected user's leads? Super-admin sees everyone;

	// otherwise the user must be the caller or in their downline.

	private boolean canViewUserLeads(AuthUser me, int authUserId) {

		if (me == null) return false;

		if (isSuperAdmin(me)) return true;

		if (me.getId() == authUserId) return true;

		return new HashSet<>(authService.getAllReportees(me.getId())).contains(authUserId);

	}

	// GET /beatPlan/assignedLeads?authUserId=&beatId=&date=

	// Lists the selected user's active/open leads (pending + follow-up, yellow/green).

	// When beatId+date are supplied (Day View), each lead is tagged alreadyOnBeat if

	// it already has a non-cancelled lead_route on that beat+date.

	@GetMapping(value = "/beatPlan/assignedLeads")

	public ResponseEntity<?> assignedLeads(

			HttpServletRequest request,

			@RequestParam int authUserId,

			@RequestParam(required = false) Integer beatId,

			@RequestParam(required = false) String date) throws ProfitMandiBusinessException {

		AuthUser me = currentUser(request);

		if (me == null) return responseSender.unauthorized("Not logged in");

		if (!canViewUserLeads(me, authUserId)) {

			// Not visible to this manager → empty (mirrors VisitRequestController.list).

			return responseSender.ok(Collections.singletonMap("rows", new ArrayList<>()));

		}

		// Active/open only — pending + follow-up.

		List<Lead> leads = new ArrayList<>();

		leads.addAll(leadRepository.selectByAssignAuthIdAndStatus(

				authUserId, com.spice.profitmandi.dao.enumuration.dtr.LeadStatus.pending));

		leads.addAll(leadRepository.selectByAssignAuthIdAndStatus(

				authUserId, com.spice.profitmandi.dao.enumuration.dtr.LeadStatus.followUp));

		// Leads already on this beat+date (Day View only), to flag dupes in the picker.

		LocalDate onDate = (date != null && !date.isEmpty()) ? LocalDate.parse(date) : null;

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

		if (beatId != null && onDate != null) {

			for (LeadRoute lr : leadRouteRepository.selectByBeatId(beatId)) {

				if (onDate.equals(lr.getScheduleDate()) && !"CANCELLED".equals(lr.getStatus())) {

					alreadyOnBeat.add(lr.getLeadId());

				}

			}

		}

		// Colour-filter + dedupe, then batch-resolve approved geo (avoids N+1).

		List<Lead> routable = new ArrayList<>();

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

		for (Lead lead : leads) {

			if (!seen.add(lead.getId())) continue;

			String color = lead.getColor() != null ? lead.getColor().toLowerCase() : "";

			if (!ROUTABLE_LEAD_COLORS.contains(color)) continue;

			routable.add(lead);

		}

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

		if (!routable.isEmpty()) {

			List<Integer> ids = routable.stream().map(Lead::getId).collect(Collectors.toList());

			for (com.spice.profitmandi.dao.entity.user.LeadLiveLocation loc :

					leadLiveLocationRepositoryAuto.selectByLeadIds(ids)) {

				if (loc.getStatus() != null && "APPROVED".equals(loc.getStatus().name())) {

					withGeo.add(loc.getLeadId());

				}

			}

		}

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

		for (Lead lead : routable) {

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

			m.put("leadId", lead.getId());

			String name = ((lead.getFirstName() != null ? lead.getFirstName() : "") + " "

					+ (lead.getLastName() != null ? lead.getLastName() : "")).trim();

			m.put("leadName", name.isEmpty() ? ("Lead #" + lead.getId()) : name);

			m.put("outletName", lead.getOutLetName());

			m.put("mobile", lead.getLeadMobile());

			m.put("city", lead.getCity());

			m.put("state", lead.getState());

			m.put("stage", lead.getEffectiveStage() != null ? lead.getEffectiveStage().name() : "");

			m.put("color", lead.getColor());

			m.put("hasGeo", withGeo.contains(lead.getId()));

			m.put("alreadyOnBeat", alreadyOnBeat.contains(lead.getId()));

			rows.add(m);

		}

		return responseSender.ok(Collections.singletonMap("rows", rows));

	}

	// Shared, idempotent lead_route write. Returns true when a new row is created,

	// false when the lead is already on that (beat, date). Best-effort nudges the

	// lead forward to BEAT_PLANNED. Callers are responsible for the beat-runs-on-date

	// and future-date guards. Mirrors deferredAssignToBeat's lead branch.

	private boolean writeLeadRoute(int beatId, int leadId, LocalDate date, int approverAuthId) {

		boolean exists = leadRouteRepository.selectByBeatId(beatId).stream()

				.anyMatch(lr -> lr.getLeadId() == leadId

						&& date.equals(lr.getScheduleDate())

						&& !"CANCELLED".equals(lr.getStatus()));

		if (exists) return false;

		LocalDateTime now = LocalDateTime.now();

		LeadRoute lr = new LeadRoute();

		lr.setBeatId(beatId);

		lr.setLeadId(leadId);

		lr.setScheduleDate(date);

		lr.setSequenceOrder(9999); // append; planner can reorder

		lr.setStatus("APPROVED");

		lr.setApprovedBy(approverAuthId);

		lr.setApprovedTimestamp(now);

		lr.setCreatedTimestamp(now);

		lr.setUpdatedTimestamp(now);

		leadRouteRepository.persist(lr);

		advanceLeadToBeatPlanned(leadId);

		return true;

	}

	// Best-effort: move a lead forward to BEAT_PLANNED when it's still in an earlier

	// happy-path stage. Never regresses a VISITED+ lead and never aborts the caller's

	// write on failure (the legacy status is kept in sync via toLegacyStatus()).

	private void advanceLeadToBeatPlanned(int leadId) {

		try {

			Lead lead = leadRepository.selectById(leadId);

			if (lead == null) return;

			com.spice.profitmandi.dao.enumuration.dtr.LeadStage cur = lead.getEffectiveStage();

			boolean beforeBeatPlanned =

					cur == com.spice.profitmandi.dao.enumuration.dtr.LeadStage.NEW

							|| cur == com.spice.profitmandi.dao.enumuration.dtr.LeadStage.ASSIGNED

							|| cur == com.spice.profitmandi.dao.enumuration.dtr.LeadStage.CONTACTED

							|| cur == com.spice.profitmandi.dao.enumuration.dtr.LeadStage.QUALIFIED;

			if (!beforeBeatPlanned) return;

			com.spice.profitmandi.dao.enumuration.dtr.LeadStage target =

					com.spice.profitmandi.dao.enumuration.dtr.LeadStage.BEAT_PLANNED;

			lead.setStage(target);

			lead.setStatus(target.toLegacyStatus());

			lead.setUpdatedTimestamp(LocalDateTime.now());

			leadRepository.persist(lead);

		} catch (Exception e) {

			LOGGER.warn("Could not advance lead {} to BEAT_PLANNED", leadId, e);

		}

	}

	// Confirm a beat actually runs on the given date.

	private boolean beatRunsOnDate(int beatId, LocalDate date) {

		return beatScheduleRepository.selectByBeatId(beatId).stream()

				.anyMatch(s -> date.equals(s.getStartDate()));

	}

	// POST /beatPlan/lead/scheduleOnBeat  {leadId, beatId, date}

	// Single-lead write for the Route Planner calendar-chip handoff. Strictly-future

	// date only (matches the visit-request / deferred chip flow).

	@PostMapping(value = "/beatPlan/lead/scheduleOnBeat")

	public ResponseEntity<?> leadScheduleOnBeat(

			HttpServletRequest request,

			@org.springframework.web.bind.annotation.RequestBody Map<String, Object> body) throws Exception {

		AuthUser me = currentUser(request);

		if (me == null) return responseSender.unauthorized("Not logged in");

		if (!canEditBeat(me)) return responseSender.badRequest("Scheduling a lead is restricted to L2 and above.");

		Integer beatId = body.get("beatId") != null ? ((Number) body.get("beatId")).intValue() : null;

		Integer leadId = body.get("leadId") != null ? ((Number) body.get("leadId")).intValue() : null;

		String dateStr = (String) body.get("date");

		if (beatId == null || leadId == null || dateStr == null)

			return responseSender.badRequest("leadId, beatId and date are required");

		LocalDate date;

		try {

			date = LocalDate.parse(dateStr);

		} catch (Exception e) {

			return responseSender.badRequest("Invalid date (yyyy-MM-dd)");

		}

		if (!date.isAfter(LocalDate.now()))

			return responseSender.badRequest("Pick a future date — today is already in progress.");

		Beat beat = beatRepository.selectById(beatId);

		if (beat == null) return responseSender.badRequest("Beat not found");

		if (!beatRunsOnDate(beatId, date))

			return responseSender.badRequest("That beat is not scheduled on " + dateStr);

		if (leadRepository.selectById(leadId) == null)

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

		boolean created = writeLeadRoute(beatId, leadId, date, me.getId());

		Map<String, Object> ok = new HashMap<>();

		ok.put("status", true);

		ok.put("created", created);

		ok.put("beatId", beatId);

		ok.put("scheduleDate", date.toString());

		ok.put("message", created

				? "Lead added to beat '" + beat.getName() + "' on " + dateStr

				: "Lead is already on that beat for " + dateStr);

		return responseSender.ok(ok);

	}

	// POST /beatPlan/leadsForBeat/submit  {beatId, date, leadIds:[...]}

	// Bulk write for the Day View "Add Lead" modal onto a known beat+date. Allows

	// today or a future date (the row's scheduled run may be today).

	@PostMapping(value = "/beatPlan/leadsForBeat/submit")

	public ResponseEntity<?> leadsForBeatSubmit(

			HttpServletRequest request,

			@org.springframework.web.bind.annotation.RequestBody Map<String, Object> body) throws Exception {

		AuthUser me = currentUser(request);

		if (me == null) return responseSender.unauthorized("Not logged in");

		if (!canEditBeat(me)) return responseSender.badRequest("Adding a lead is restricted to L2 and above.");

		Integer beatId = body.get("beatId") != null ? ((Number) body.get("beatId")).intValue() : null;

		String dateStr = (String) body.get("date");

		List<?> leadIdsRaw = (List<?>) body.get("leadIds");

		if (beatId == null || dateStr == null || leadIdsRaw == null || leadIdsRaw.isEmpty())

			return responseSender.badRequest("beatId, date and leadIds are required");

		LocalDate date;

		try {

			date = LocalDate.parse(dateStr);

		} catch (Exception e) {

			return responseSender.badRequest("Invalid date (yyyy-MM-dd)");

		}

		if (date.isBefore(LocalDate.now()))

			return responseSender.badRequest("Pick today or a future date.");

		Beat beat = beatRepository.selectById(beatId);

		if (beat == null) return responseSender.badRequest("Beat not found");

		if (!beatRunsOnDate(beatId, date))

			return responseSender.badRequest("That beat is not scheduled on " + dateStr);

		int added = 0, skipped = 0;

		for (Object idRaw : leadIdsRaw) {

			int leadId = ((Number) idRaw).intValue();

			if (leadRepository.selectById(leadId) == null) {

				skipped++;

				continue;

			}

			if (writeLeadRoute(beatId, leadId, date, me.getId())) added++;

			else skipped++;

		}

		Map<String, Object> ok = new HashMap<>();

		ok.put("status", true);

		ok.put("added", added);

		ok.put("skipped", skipped);

		ok.put("message", added + " lead(s) added to '" + beat.getName() + "' on " + dateStr

				+ (skipped > 0 ? " (" + skipped + " already present or invalid)" : ""));

		return responseSender.ok(ok);

	}

	// POST /beatPlan/lead/createBeatAndSchedule  {authUserId, leadId, date, beatName?}

	// The "+ New beat" action — a 1-day beat with this lead as the only Day-1 stop,

	// for a rep who has no beat to land on. Mirrors VisitRequestController.createBeatAndSchedule.

	@PostMapping(value = "/beatPlan/lead/createBeatAndSchedule")

	public ResponseEntity<?> leadCreateBeatAndSchedule(

			HttpServletRequest request,

			@org.springframework.web.bind.annotation.RequestBody Map<String, Object> body) throws Exception {

		AuthUser me = currentUser(request);

		if (me == null) return responseSender.unauthorized("Not logged in");

		if (!canEditBeat(me)) return responseSender.badRequest("Creating a beat is restricted to L2 and above.");

		Integer authUserId = body.get("authUserId") != null ? ((Number) body.get("authUserId")).intValue() : null;

		Integer leadId = body.get("leadId") != null ? ((Number) body.get("leadId")).intValue() : null;

		String dateStr = (String) body.get("date");

		if (authUserId == null || leadId == null || dateStr == null)

			return responseSender.badRequest("authUserId, leadId and date are required");

		LocalDate date;

		try {

			date = LocalDate.parse(dateStr);

		} catch (Exception e) {

			return responseSender.badRequest("Invalid date (yyyy-MM-dd)");

		}

		if (!date.isAfter(LocalDate.now()))

			return responseSender.badRequest("Pick a future date — today is already in progress.");

		Lead lead = leadRepository.selectById(leadId);

		if (lead == null) return responseSender.badRequest("Lead not found");

		// One-beat-per-day guard for the rep.

		for (Beat existing : beatRepository.selectActiveByAuthUserId(authUserId)) {

			for (BeatSchedule s : beatScheduleRepository.selectByBeatId(existing.getId())) {

				if (date.equals(s.getStartDate())) {

					return responseSender.badRequest("This user already has '"

							+ (existing.getName() != null ? existing.getName() : "Beat #" + existing.getId())

							+ "' scheduled on " + date + " — use Schedule on a beat instead.");

				}

			}

		}

		String leadLabel = ((lead.getFirstName() != null ? lead.getFirstName() : "") + " "

				+ (lead.getLastName() != null ? lead.getLastName() : "")).trim();

		if (leadLabel.isEmpty()) leadLabel = "Lead #" + leadId;

		Object nameRaw = body.get("beatName");

		String beatName = (nameRaw != null && !nameRaw.toString().trim().isEmpty())

				? nameRaw.toString().trim()

				: ("Lead - " + leadLabel + " - " + date);

		if (beatName.length() > 100) beatName = beatName.substring(0, 100);

		LocalDateTime now = LocalDateTime.now();

		Beat beat = new Beat();

		beat.setName(beatName);

		beat.setAuthUserId(authUserId);

		beat.setBeatColor(BEAT_COLORS[Math.abs(beatName.hashCode()) % BEAT_COLORS.length]);

		beat.setTotalDays(1);

		beat.setActive(true);

		beat.setCreatedBy(me.getId());

		beat.setCreatedTimestamp(now);

		beatRepository.persist(beat);

		BeatSchedule sched = new BeatSchedule();

		sched.setBeatId(beat.getId());

		sched.setStartDate(date);

		sched.setEndDate(date);

		sched.setDayNumber(1);

		sched.setEndAction("HOME");

		sched.setCreatedTimestamp(now);

		beatScheduleRepository.persist(sched);

		writeLeadRoute(beat.getId(), leadId, date, me.getId());

		Map<String, Object> ok = new HashMap<>();

		ok.put("status", true);

		ok.put("beatId", beat.getId());

		ok.put("beatName", beatName);

		ok.put("scheduleDate", date.toString());

		ok.put("message", "Beat '" + beatName + "' created on " + dateStr);

		return responseSender.ok(ok);

	}