Subversion Repositories SmartDukaan

		// One-beat-per-day guard: reject if any of the requested dates already

		// has a beat scheduled for this user.

		if (dates != null) {

			List<LocalDate> candidateDates = new ArrayList<>();

			for (String dStr : dates) {

				if (dStr != null && !dStr.isEmpty()) {

					try {

						candidateDates.add(LocalDate.parse(dStr, DateTimeFormatter.ISO_DATE));

					} catch (Exception ignored) {

					}

				}

			}

			Map<String, Object> conflict = findScheduleConflict(authUserId, candidateDates, 0);

			if (conflict != null) return responseSender.badRequest(scheduleConflictMessage(conflict));

		}

		// =====================================================================

		// All-or-nothing import: validate every group first; only persist if

		// so the user can fix and re-upload without partial creations.

		// =====================================================================

		List<ValidatedBulkBeat> ready = new ArrayList<>();

		// ----- Phase 1: validate every group, collect ALL errors -----

			String beatName = g.beatName;

			int authUserId;

			LocalDate startDate;

			try {

				startDate = (g.startDate == null || g.startDate.isEmpty())

			} catch (Exception e) {

				errorMessages.add("Beat '" + beatName + "': invalid start_date '" + g.startDate + "'.");

				continue;

			}

						continue;

					scheduleDates.add(d);

					d = d.plusDays(1);

			}

			if (!badCodes.isEmpty()) {

				errorMessages.add("Beat '" + beatName + "': unknown partner code(s) — " + String.join(", ", badCodes) + ".");

				continue;

			}

			ready.add(new ValidatedBulkBeat(g, authUserId, sortedDays, scheduleDates));

		}

		// Intra-file conflict: two beats in the same upload requesting the same

		// user + date. Caught here so the user fixes the file before re-uploading.

		Set<String> seenUserDates = new HashSet<>();

		for (ValidatedBulkBeat v : ready) {

			for (LocalDate sd : v.scheduleDates) {

				String key = v.authUserId + "|" + sd;

				if (!seenUserDates.add(key)) {

					errorMessages.add("Beat '" + v.g.beatName + "': date " + sd + " is also claimed by another beat in this file for the same user.");

					break;

				}

			}

		}

		// All-or-nothing: any error → return without persisting anything.

		if (!errorMessages.isEmpty()) {

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

			response.put("status", false);

			response.put("beatsCreated", 0);

			response.put("errors", errorMessages.size());

			response.put("errorMessages", errorMessages);

			response.put("message", "No beats created. Fix the issues below and re-upload the file.");

			return responseSender.ok(response);

		}

		// ----- Phase 2: persist (only reached when every row was clean) -----

		int beatsCreated = 0;

		for (ValidatedBulkBeat v : ready) {

			BulkBeatGroup g = v.g;

			String beatName = g.beatName;

			int authUserId = v.authUserId;

			List<Integer> sortedDays = v.sortedDays;

			List<LocalDate> scheduleDates = v.scheduleDates;

			String beatColor = BEAT_COLORS[Math.abs(beatName.hashCode()) % BEAT_COLORS.length];

			AuthUserLocation homeLoc = authUserLocationRepository.selectDefaultByAuthUserIdAndType(authUserId, "BASE");

			Beat beat = new Beat();

			beat.setName(beatName);

			beat.setAuthUserId(authUserId);

			beat.setBeatColor(beatColor);

			beat.setTotalDays(sortedDays.size());

			beat.setStartLocationName(homeLoc != null ? homeLoc.getLocationName() : "Home");

			beat.setStartLatitude(homeLoc != null ? homeLoc.getLatitude() : null);

			beat.setStartLongitude(homeLoc != null ? homeLoc.getLongitude() : null);

			beat.setActive(true);

			beat.setCreatedBy(currentUser.getId());

			beat.setCreatedTimestamp(LocalDateTime.now());

			beatRepository.persist(beat);

			LocalDate bulkEndDate = scheduleDates.isEmpty() ? null : scheduleDates.get(scheduleDates.size() - 1);

			for (int dayIdx = 0; dayIdx < sortedDays.size(); dayIdx++) {

				int dayNumber = sortedDays.get(dayIdx);

				LocalDate planDate = (dayIdx < scheduleDates.size()) ? scheduleDates.get(dayIdx) : null;

				BeatSchedule schedule = new BeatSchedule();

				schedule.setBeatId(beat.getId());

				schedule.setStartDate(planDate != null ? planDate : LocalDate.of(9999, 12, 31));

				schedule.setEndDate(bulkEndDate);

				schedule.setDayNumber(dayNumber);

				schedule.setEndAction(dayIdx == sortedDays.size() - 1 ? "HOME" : "DAYBREAK");

				schedule.setCreatedTimestamp(LocalDateTime.now());

				beatScheduleRepository.persist(schedule);

				List<BulkPartner> partners = g.dayToPartners.get(dayNumber);

				partners.sort((a, b) -> {

					if (a.seq >= 0 && b.seq >= 0) return Integer.compare(a.seq, b.seq);

					if (a.seq >= 0) return -1;

					if (b.seq >= 0) return 1;

					return Integer.compare(a.rowNum, b.rowNum);

				});

				int autoSeq = 0;

				for (BulkPartner p : partners) {

					Integer fofoId = codeToId.get(p.code);

					// Codes were validated in Phase 1, this is just a safety net.

					if (fofoId == null) continue;

					BeatRoute route = new BeatRoute();

					route.setBeatId(beat.getId());

					route.setFofoId(fofoId);

					route.setSequenceOrder(p.seq >= 0 ? p.seq : autoSeq);

					route.setDayNumber(dayNumber);

					route.setActive(true);

					beatRouteRepository.persist(route);

					autoSeq++;

				}

			}

			beatsCreated++;

		response.put("message", beatsCreated + " beat(s) created.");

		return responseSender.ok(response);

	}

	// Move a beat from one date to another — used by calendar drag-and-drop.

	// Behaviour: if the target date already has ANOTHER beat scheduled (for the

	// same sales user), the two schedules swap — the other beat slides onto

	// the source date. If the target date is empty, the source date becomes empty.

	@PostMapping(value = "/beatPlan/moveScheduleDate")

	public ResponseEntity<?> moveScheduleDate(

			@RequestParam String planGroupId,

			@RequestParam String fromDate,

			@RequestParam String toDate) {

		int beatId = Integer.parseInt(planGroupId);

		LocalDate from = LocalDate.parse(fromDate);

		LocalDate to = LocalDate.parse(toDate);

		if (from.equals(to)) {

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

			ok.put("status", true);

			ok.put("message", "Same date — no change");

			return responseSender.ok(ok);

		}

		// Today is the live/running slot — a beat already running today can't be

		// bumped, and a future beat can't be moved onto today.

		LocalDate today = LocalDate.now();

		if (to.equals(today) || from.equals(today) || from.isBefore(today) || to.isBefore(today)) {

			return responseSender.badRequest("Cannot move to or from today / a past date — today's beat is live. Use future dates only.");

		}

		Beat beat = beatRepository.selectById(beatId);

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

		List<BeatSchedule> schedules = beatScheduleRepository.selectByBeatId(beatId);

		// Reject if THIS beat already has a different schedule row on the target date

		// (it would create two schedule rows of the same beat on one day).

		boolean selfConflict = schedules.stream()

				.anyMatch(s -> s.getStartDate() != null && s.getStartDate().equals(to));

		if (selfConflict) return responseSender.badRequest("Beat is already scheduled on " + toDate);

		BeatSchedule match = schedules.stream()

				.filter(s -> s.getStartDate() != null && s.getStartDate().equals(from))

				.findFirst().orElse(null);

		if (match == null) return responseSender.badRequest("No schedule found for " + fromDate);

		// Look for ANY OTHER beat (same sales user) whose schedule sits on the target

		// date — if found we'll swap it onto the source date.

		BeatSchedule otherSchedule = null;

		List<BeatSchedule> otherSchedules = null;

		Beat otherBeat = null;

		for (Beat ub : beatRepository.selectActiveByAuthUserId(beat.getAuthUserId())) {

			if (ub.getId() == beatId) continue;

			List<BeatSchedule> ubSchedules = beatScheduleRepository.selectByBeatId(ub.getId());

			BeatSchedule hit = ubSchedules.stream()

					.filter(s -> s.getStartDate() != null && s.getStartDate().equals(to))

					.findFirst().orElse(null);

			if (hit != null) {

				otherSchedule = hit;

				otherSchedules = ubSchedules;

				otherBeat = ub;

				break;

			}

		}

		// Move the dragged beat onto the target date.

		match.setStartDate(to);

		// If another beat occupied the target, slide it onto the source date (swap).

		if (otherSchedule != null) {

			otherSchedule.setStartDate(from);

		}

		// Recompute endDate as the max across each affected beat's schedules so

		// the [startDate, endDate] envelope stays consistent.

		recomputeEndDate(schedules);

		if (otherSchedules != null) {

			recomputeEndDate(otherSchedules);

		}

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

		response.put("status", true);

		response.put("message", otherBeat != null

				? "Swapped with \"" + (otherBeat.getName() != null ? otherBeat.getName() : "beat") + "\" on " + toDate

				: "Moved from " + fromDate + " to " + toDate);

		response.put("swapped", otherBeat != null);

			}

		}

	}

	/**

	 * Per-user one-beat-per-day guard. Walks every active beat the sales user

	 * already has and looks for a schedule row on any of the candidate dates.

	 * Returns null if the candidate dates are clear, otherwise a {date,beatName}

	 * map describing the first collision so the caller can surface a clean error.

	 * Pass `excludeBeatId` so callers that are re-scheduling an existing beat

	 * don't trip on their own pre-existing schedule rows; pass 0 for new beats.

	 */

	private Map<String, Object> findScheduleConflict(int authUserId, java.util.Collection<LocalDate> candidates, int excludeBeatId) {

		if (candidates == null || candidates.isEmpty()) return null;

		Set<LocalDate> ds = new HashSet<>();

		for (LocalDate d : candidates) {

			if (d != null && d.getYear() != 9999) ds.add(d);

		}

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

			if (ub.getId() == excludeBeatId) continue;

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

				if (s.getStartDate() != null && ds.contains(s.getStartDate())) {

				}

			}

		return null;

	}

	private String scheduleConflictMessage(Map<String, Object> conflict) {

	}

	@PostMapping(value = "/beatPlan/scheduleOnCalendar")

	public ResponseEntity<?> scheduleOnCalendar(

			HttpServletRequest request,

			@RequestParam String planGroupId,

			@RequestParam String dates,

			@RequestParam(required = false) String beatName,

			try {

		Map<String, Object> conflict = findScheduleConflict(beat.getAuthUserId(), requested, beatId);

		if (conflict != null) return responseSender.badRequest(scheduleConflictMessage(conflict));

		// Delete old schedules and create new

		beatScheduleRepository.deleteByBeatId(beatId);

		LocalDate schEndDate = dateList.isEmpty() ? null : LocalDate.parse(dateList.get(dateList.size() - 1));

		for (int i = 0; i < dateList.size() && i < beat.getTotalDays(); i++) {

            int dayNumber = i + 1;

            String endAction = (i == dateList.size() - 1) ? "HOME" : "DAYBREAK";

			BeatSchedule schedule = new BeatSchedule();

			schedule.setBeatId(beatId);

			schedule.setStartDate(LocalDate.parse(dateList.get(i)));

			schedule.setEndDate(schEndDate);

            schedule.setDayNumber(dayNumber);

            schedule.setEndAction(endAction);

            // Fill total_distance_km / total_time_mins from beat_route so the new

            // schedule row isn't NULL (this was the bug — these were left unset).

            double[] totals = computeDayTotals(beatId, dayNumber, endAction);

            schedule.setTotalDistanceKm(totals[0]);

            schedule.setTotalTimeMins((int) totals[1]);

			schedule.setCreatedTimestamp(LocalDateTime.now());

			beatScheduleRepository.persist(schedule);

		}

		// One-beat-per-day guard: reject if any of the new dates already has

		// another beat scheduled for this user (excluding this beat itself).

		List<LocalDate> repeatDates = new ArrayList<>();

		for (String s : dateList) {

			try {

				repeatDates.add(LocalDate.parse(s));

			} catch (Exception ignored) {

			}

		}

		Map<String, Object> repeatConflict = findScheduleConflict(beat.getAuthUserId(), repeatDates, beatId);

		if (repeatConflict != null) return responseSender.badRequest(scheduleConflictMessage(repeatConflict));

	private static class ValidatedBulkBeat {

		final BulkBeatGroup g;

		final int authUserId;

		final List<Integer> sortedDays;

		final List<LocalDate> scheduleDates;

		ValidatedBulkBeat(BulkBeatGroup g, int authUserId, List<Integer> sortedDays, List<LocalDate> scheduleDates) {

			this.g = g;

			this.authUserId = authUserId;

			this.sortedDays = sortedDays;

			this.scheduleDates = scheduleDates;

		}

	}