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

 import com.spice.profitmandi.common.model.CustomRetailer;
 import com.spice.profitmandi.common.web.util.ResponseSender;
 import com.spice.profitmandi.dao.entity.auth.AuthUser;
 import com.spice.profitmandi.dao.entity.fofo.FofoStore;
 import com.spice.profitmandi.dao.entity.logistics.PublicHolidays;
-import com.spice.profitmandi.dao.entity.user.AuthUserLocation;
-import com.spice.profitmandi.dao.entity.user.BeatPlan;
+import com.spice.profitmandi.dao.entity.user.*;
-import com.spice.profitmandi.dao.entity.user.BeatPlanDay;
 import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
 import com.spice.profitmandi.dao.repository.auth.AuthRepository;
 import com.spice.profitmandi.dao.repository.cs.CsService;
 import com.spice.profitmandi.dao.repository.dtr.*;
 import com.spice.profitmandi.dao.repository.logistics.PublicHolidaysRepository;
 	@Autowired
 	private FofoStoreRepository fofoStoreRepository;
 	@Autowired
 	private RetailerService retailerService;
 	@Autowired
-	private BeatPlanRepository beatPlanRepository;
+	private BeatRepository beatRepository;
 	@Autowired
-	private BeatPlanDayRepository beatPlanDayRepository;
+	private BeatRouteRepository beatRouteRepository;
+	@Autowired
+	private BeatScheduleRepository beatScheduleRepository;
+	@Autowired
+	private LeadRouteRepository leadRouteRepository;
 	@Autowired
 	private AuthUserLocationRepository authUserLocationRepository;
 	@Autowired
 	private LeadRepository leadRepository;
 	@Autowired
 	@GetMapping(value = "/beatPlan/getAuthUsers")
 	public ResponseEntity<?> getAuthUsers(
 			@RequestParam int categoryId,
 			@RequestParam EscalationType escalationType) {
 		List<AuthUser> authUsers = csService.getAuthUserByCategoryId(categoryId, escalationType);
 		List<Map<String, Object>> result = authUsers.stream()
 				.filter(au -> au.getActive())
 				.map(au -> {
 					Map<String, Object> map = new HashMap<>();
 					map.put("id", au.getId());
 					map.put("name", au.getFirstName() + " " + au.getLastName());
 					return map;
 				})
 				.collect(Collectors.toList());
 		return responseSender.ok(result);
+	}
+	// Returns visits for a beat.
+	// - Partner stops (beat_route) belong to the beat template — always returned.
+	// - Lead stops (lead_route) belong to a specific run — returned ONLY when planDate
+	//   is given and matches the lead's schedule_date. (No planDate = template view.)
 	@GetMapping(value = "/beatPlan/getBeatVisits")
-	public ResponseEntity<?> getBeatVisits(@RequestParam String planGroupId) {
+	public ResponseEntity<?> getBeatVisits(
+			@RequestParam String planGroupId,
+			@RequestParam(required = false) String planDate) {
+		int beatId;
+		try {
+			beatId = Integer.parseInt(planGroupId);
+		} catch (NumberFormatException e) {
+			return responseSender.ok(new ArrayList<>());
+		}
-		List<BeatPlan> visits = beatPlanRepository.selectByPlanGroupId(planGroupId);
+		List<BeatRoute> routes = beatRouteRepository.selectByBeatId(beatId);
-		List<Map<String, Object>> result = visits.stream().map(v -> {
+		List<Map<String, Object>> result = new ArrayList<>();
+		// Partner stops — always (they belong to the beat template)
+		for (BeatRoute r : routes) {
 			Map<String, Object> map = new HashMap<>();
-			map.put("fofoId", v.getFofoId());
+			map.put("fofoId", r.getFofoId());
-			map.put("dayNumber", v.getDayNumber());
+			map.put("dayNumber", r.getDayNumber());
-			map.put("sequenceOrder", v.getSequenceOrder());
+			map.put("sequenceOrder", r.getSequenceOrder());
-			map.put("visitType", v.getVisitType());
+			map.put("visitType", "partner");
-			return map;
+			result.add(map);
+		}
+		// Lead stops — only for the requested run date
+		if (planDate != null && !planDate.isEmpty()) {
+			LocalDate date = LocalDate.parse(planDate);
+			List<LeadRoute> leads = leadRouteRepository.selectByBeatId(beatId);
+			for (LeadRoute lr : leads) {
+				if ("APPROVED".equals(lr.getStatus())
+						&& lr.getScheduleDate() != null
+						&& lr.getScheduleDate().equals(date)) {
+					Map<String, Object> map = new HashMap<>();
-		}).collect(Collectors.toList());
+					map.put("fofoId", lr.getLeadId());
+					map.put("dayNumber", 1);
+					map.put("sequenceOrder", lr.getSequenceOrder() != null ? lr.getSequenceOrder() : 999);
+					map.put("visitType", "lead");
+					result.add(map);
+				}
+			}
+		}
+		// Sort by dayNumber then sequenceOrder
+		result.sort((a, b) -> {
+			int cmp = Integer.compare((int) a.get("dayNumber"), (int) b.get("dayNumber"));
+			return cmp != 0 ? cmp : Integer.compare((int) a.get("sequenceOrder"), (int) b.get("sequenceOrder"));
+		});
 		return responseSender.ok(result);
+	}
 	@GetMapping(value = "/beatPlan/getBaseLocation")
 	public ResponseEntity<?> getBaseLocation(@RequestParam int authUserId) {
 			@RequestParam int authUserId,
 			@RequestParam String locationName,
 			@RequestParam String latitude,
 			@RequestParam String longitude,
 			@RequestParam(required = false) String address) {
 		AuthUserLocation loc = new AuthUserLocation();
 		loc.setAuthUserId(authUserId);
 		loc.setLocationType("BASE");
 		loc.setLocationName(locationName);
 		loc.setLatitude(latitude);
 			@RequestParam(required = false) String startLng) throws ProfitMandiBusinessException {
 		Map<Integer, List<Integer>> pp = csService.getAuthUserIdPartnerIdMapping();
 		List<Integer> fofoIds = pp.get(authUserId);
-		if (fofoIds.isEmpty()) {
+		if (fofoIds == null || fofoIds.isEmpty()) {
 			Map<String, Object> empty = new HashMap<>();
 			empty.put("partners", new ArrayList<>());
 			return responseSender.ok(empty);
+		}
 		List<FofoStore> fofoStores = fofoStoreRepository.selectByRetailerIds(fofoIds);
 		Map<Integer, CustomRetailer> retailerMap = retailerService.getFofoRetailers(fofoIds);
-		// Build partner data list with addresses
 		List<Map<String, Object>> partners = new ArrayList<>();
 		List<String> addressesToGeocode = new ArrayList<>();
-		List<FofoStore> activeStores = new ArrayList<>();
 		for (FofoStore store : fofoStores) {
 			if (!store.isActive() || store.isClosed()) continue;
-			activeStores.add(store);
 			CustomRetailer retailer = retailerMap.get(store.getId());
 			Map<String, Object> partnerData = new HashMap<>();
 			partnerData.put("fofoId", store.getId());
 			partnerData.put("code", store.getCode());
 			partnerData.put("outletName", store.getOutletName());
 			partnerData.put("type", "partner");
-			String displayAddress = null;
 			String geoAddress = null;
 			if (retailer != null) {
 				partnerData.put("businessName", retailer.getBusinessName());
 				if (retailer.getAddress() != null) {
-					displayAddress = retailer.getAddress().getAddressString();
+					partnerData.put("address", retailer.getAddress().getAddressString());
-					partnerData.put("address", displayAddress);
-					// Build clean address for geocoding: city, state, pincode, India
 					geoAddress = com.spice.profitmandi.service.GeocodingService.buildGeoAddress(
 							retailer.getAddress().getLine1(),
 							retailer.getAddress().getCity(),
 							retailer.getAddress().getState(),
 							retailer.getAddress().getPinCode());
+				}
+			}
 			addressesToGeocode.add(geoAddress);
 			partners.add(partnerData);
+		}
-		// Geocode all addresses in parallel (cached eternally in Redis, so only first call hits Google)
+		// Geocode in parallel
 		java.util.concurrent.ExecutorService executor = java.util.concurrent.Executors.newFixedThreadPool(
-				Math.min(10, partners.size()));
+				Math.min(10, Math.max(1, partners.size())));
 		List<java.util.concurrent.Future<double[]>> futures = new ArrayList<>();
 		for (String addr : addressesToGeocode) {
 			futures.add(executor.submit(() -> {
 				if (addr != null && !addr.isEmpty()) {
 					try {
 						return geocodingService.geocodeAddress(addr);
+					}
+				}
 				return null;
 			}));
+		}
-		// Collect results
 		for (int i = 0; i < partners.size(); i++) {
-			Map<String, Object> partnerData = partners.get(i);
-			String lat = null, lng = null;
 			try {
 				double[] coords = futures.get(i).get(10, java.util.concurrent.TimeUnit.SECONDS);
 				if (coords != null) {
-					lat = String.valueOf(coords[0]);
+					partners.get(i).put("latitude", String.valueOf(coords[0]));
-					lng = String.valueOf(coords[1]);
+					partners.get(i).put("longitude", String.valueOf(coords[1]));
+				}
 			} catch (Exception e) {
-				LOGGER.warn("Geocoding timeout/error for partner {}", partnerData.get("code"));
+				LOGGER.warn("Geocoding timeout/error for partner {}", partners.get(i).get("code"));
+			}
-			partnerData.put("latitude", lat);
-			partnerData.put("longitude", lng);
+		}
 		executor.shutdown();
-		// Sort by nearest neighbor from start location if provided, otherwise from first partner
 		if (startLat != null && startLng != null && !startLat.isEmpty() && !startLng.isEmpty()) {
 			partners = sortByNearestNeighborFromStart(partners, Double.parseDouble(startLat), Double.parseDouble(startLng));
 		} else {
 			partners = sortByNearestNeighbor(partners);
+		}
 		Map<String, Object> plan = gson.fromJson(planData, type);
 		List<Map<String, Object>> days = (List<Map<String, Object>>) plan.get("days");
 		List<String> dates = (List<String>) plan.get("dates");
-		// Build visit fingerprint to detect duplicates
-		List<Integer> newVisitIds = new ArrayList<>();
-		for (Map<String, Object> day : days) {
-			List<Map<String, Object>> visits = (List<Map<String, Object>>) day.get("visits");
+		String beatName = (plan.get("beatName") != null ? (String) plan.get("beatName") : "Beat").trim();
-			if (visits != null) {
-				for (Map<String, Object> v : visits) {
-					newVisitIds.add(((Number) v.get("id")).intValue());
-				}
-			}
-		}
-		Collections.sort(newVisitIds);
-		// Check existing beats for this auth user
+		// Duplicate check — same name + same authUserId = duplicate
-		List<BeatPlanDay> existingBeatDays = beatPlanDayRepository.selectByAuthUserIdAndDateRange(
+		List<Beat> existingBeats = beatRepository.selectByAuthUserId(authUserId);
-				authUserId, LocalDate.of(2000, 1, 1), LocalDate.of(2099, 12, 31));
-		Set<String> existingGroups = existingBeatDays.stream()
-				.map(BeatPlanDay::getPlanGroupId).filter(g -> g != null).collect(Collectors.toSet());
-		for (String existingGroup : existingGroups) {
+		for (Beat existing : existingBeats) {
-			List<BeatPlan> existingVisits = beatPlanRepository.selectByPlanGroupId(existingGroup);
+			if (existing.getName() != null && beatName.equalsIgnoreCase(existing.getName().trim())) {
-			List<Integer> existingIds = existingVisits.stream()
-					.map(BeatPlan::getFofoId).sorted().collect(Collectors.toList());
+				LOGGER.info("Duplicate beat blocked: name='{}' authUserId={} existingId={}", beatName, authUserId, existing.getId());
-			if (existingIds.equals(newVisitIds)) {
-				// Duplicate found — return existing planGroupId
 				Map<String, Object> response = new HashMap<>();
 				response.put("status", true);
-				response.put("planGroupId", existingGroup);
+				response.put("planGroupId", String.valueOf(existing.getId()));
 				response.put("duplicate", true);
-				response.put("message", "Beat already exists with same visits");
+				response.put("message", "Beat '" + beatName + "' already exists");
 				return responseSender.ok(response);
+			}
+		}
+		String beatColor = BEAT_COLORS[Math.abs(beatName.hashCode()) % BEAT_COLORS.length];
+		int totalDays = days.size();
+		// Create Beat master
+		Beat beat = new Beat();
+		beat.setName(beatName);
+		beat.setAuthUserId(authUserId);
+		beat.setBeatColor(beatColor);
+		beat.setTotalDays(totalDays);
+		beat.setActive(true);
+		beat.setCreatedBy(currentUser.getId());
+		beat.setCreatedTimestamp(LocalDateTime.now());
+		// Set start location from first day
+		if (!days.isEmpty()) {
-		String planGroupId = UUID.randomUUID().toString();
+			Map<String, Object> firstDay = days.get(0);
-		String beatName = plan.get("beatName") != null ? (String) plan.get("beatName") : "Beat";
+			beat.setStartLocationName((String) firstDay.get("startLocationName"));
+			beat.setStartLatitude((String) firstDay.get("startLatitude"));
+			beat.setStartLongitude((String) firstDay.get("startLongitude"));
+		}
+		beatRepository.persist(beat);
+		// End date of the whole beat = last scheduled day's date
+		LocalDate beatEndDate = null;
+		if (dates != null) {
+			for (int d = dates.size() - 1; d >= 0; d--) {
+				if (dates.get(d) != null) {
-		String beatColor = BEAT_COLORS[Math.abs(planGroupId.hashCode()) % BEAT_COLORS.length];
+					beatEndDate = LocalDate.parse(dates.get(d), DateTimeFormatter.ISO_DATE);
+					break;
+				}
+			}
+		}
+		// Create routes and schedules for each day
 		for (int d = 0; d < days.size(); d++) {
 			Map<String, Object> day = days.get(d);
 			int dayNumber = d + 1;
 			LocalDate planDate = (dates != null && d < dates.size() && dates.get(d) != null)
-					? LocalDate.parse(dates.get(d), DateTimeFormatter.ISO_DATE)
+					? LocalDate.parse(dates.get(d), DateTimeFormatter.ISO_DATE) : null;
-					: null;
-			// Save day-level info
-			BeatPlanDay bpDay = new BeatPlanDay();
+			// Auto-determine end action: last day = HOME, others = DAYBREAK
-			bpDay.setPlanGroupId(planGroupId);
+			String endAction = (String) day.get("endAction");
-			bpDay.setAuthUserId(authUserId);
+			if (endAction == null || endAction.isEmpty()) {
-			bpDay.setDayNumber(dayNumber);
+				endAction = (dayNumber == totalDays) ? "HOME" : "DAYBREAK";
+			}
-			bpDay.setPlanDate(planDate);
+			// Always create schedule (even if planDate is null — unscheduled beat)
-			bpDay.setBeatName(beatName);
+			BeatSchedule schedule = new BeatSchedule();
-			bpDay.setBeatColor(beatColor);
+			schedule.setBeatId(beat.getId());
-			bpDay.setStartLocationName((String) day.get("startLocationName"));
+			schedule.setStartDate(planDate != null ? planDate : LocalDate.of(9999, 12, 31)); // placeholder for unscheduled
-			bpDay.setStartLatitude((String) day.get("startLatitude"));
+			schedule.setEndDate(beatEndDate);
-			bpDay.setStartLongitude((String) day.get("startLongitude"));
+			schedule.setDayNumber(dayNumber);
-			bpDay.setEndAction((String) day.get("endAction"));
+			schedule.setEndAction(endAction);
-			bpDay.setStayLocationName((String) day.get("stayLocationName"));
+			schedule.setStayLocationName((String) day.get("stayLocationName"));
-			bpDay.setStayLatitude((String) day.get("stayLatitude"));
+			schedule.setStayLatitude((String) day.get("stayLatitude"));
-			bpDay.setStayLongitude((String) day.get("stayLongitude"));
+			schedule.setStayLongitude((String) day.get("stayLongitude"));
-			if (day.get("totalDistanceKm") != null) {
+			if (day.get("totalDistanceKm") != null)
-				bpDay.setTotalDistanceKm(((Number) day.get("totalDistanceKm")).doubleValue());
+				schedule.setTotalDistanceKm(((Number) day.get("totalDistanceKm")).doubleValue());
-			}
-			if (day.get("totalTimeMins") != null) {
+			if (day.get("totalTimeMins") != null)
-				bpDay.setTotalTimeMins(((Number) day.get("totalTimeMins")).intValue());
+				schedule.setTotalTimeMins(((Number) day.get("totalTimeMins")).intValue());
-			}
-			bpDay.setCreatedBy(currentUser.getId());
-			bpDay.setCreatedTimestamp(LocalDateTime.now());
+			schedule.setCreatedTimestamp(LocalDateTime.now());
-			bpDay.setActive(true);
-			beatPlanDayRepository.persist(bpDay);
+			beatScheduleRepository.persist(schedule);
-			// Save visits for this day
+			// Routes (stops)
 			List<Map<String, Object>> visits = (List<Map<String, Object>>) day.get("visits");
 			if (visits != null) {
 				for (int i = 0; i < visits.size(); i++) {
 					Map<String, Object> visit = visits.get(i);
-					BeatPlan bp = new BeatPlan();
+					BeatRoute route = new BeatRoute();
-					bp.setAuthUserId(authUserId);
+					route.setBeatId(beat.getId());
-					bp.setFofoId(((Number) visit.get("id")).intValue());
+					route.setFofoId(((Number) visit.get("id")).intValue());
-					bp.setVisitType((String) visit.get("type"));
-					bp.setDayNumber(dayNumber);
-					bp.setPlanGroupId(planGroupId);
-					bp.setPlanDate(planDate);
-					bp.setSequenceOrder(i);
+					route.setSequenceOrder(i);
-					bp.setCreatedBy(currentUser.getId());
+					route.setDayNumber(dayNumber);
-					bp.setCreatedTimestamp(LocalDateTime.now());
-					bp.setUpdatedTimestamp(LocalDateTime.now());
-					bp.setActive(true);
+					route.setActive(true);
-					beatPlanRepository.persist(bp);
+					beatRouteRepository.persist(route);
+				}
+			}
+		}
 		Map<String, Object> response = new HashMap<>();
 		response.put("status", true);
-		response.put("planGroupId", planGroupId);
+		response.put("planGroupId", String.valueOf(beat.getId()));
 		response.put("message", "Beat plan submitted successfully");
 		return responseSender.ok(response);
+	}
 	// ============ BULK UPLOAD ============
 		csv += "Agra Circuit,145,2026-06-05,1,\"UPAGR101,UPAGR102\"\n";
 		org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
 		headers.add("Content-Disposition", "attachment; filename=beat_plan_template.csv");
 		headers.add("Content-Type", "text/csv");
 		return new ResponseEntity<>(csv, headers, org.springframework.http.HttpStatus.OK);
+	}
 	@PostMapping(value = "/beatPlan/bulkUploadProcess")
 	public ResponseEntity<?> bulkUploadProcess(
 		AuthUser currentUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
 		java.io.Reader reader = new java.io.InputStreamReader(file.getInputStream());
 		org.apache.commons.csv.CSVParser parser = new org.apache.commons.csv.CSVParser(reader,
 				org.apache.commons.csv.CSVFormat.DEFAULT.withFirstRecordAsHeader().withTrim());
-		// Each row = one day: beat_name, auth_user_id, start_date (only on day 1), day_number, partner_codes
-		// First pass: collect all records, normalize beat_name
 		List<org.apache.commons.csv.CSVRecord> allRecords = parser.getRecords();
 		parser.close();
-		// Track last beat_name per auth_user_id for blank name rows
 		Map<String, String> lastBeatNameByUser = new HashMap<>();
 		Map<String, List<org.apache.commons.csv.CSVRecord>> beatGroups = new LinkedHashMap<>();
-		// Also store resolved beat names since CSVRecord is immutable
 		Map<Long, String> resolvedBeatNames = new HashMap<>();
 		for (org.apache.commons.csv.CSVRecord record : allRecords) {
 			String authId = record.get("auth_user_id").trim();
-			String rawName = record.get("beat_name").trim();
+			String rawName = record.get("beat_name").trim().replaceAll("\\s+", " ");
-			// Normalize: collapse multiple spaces, trim
-			String beatName = rawName.replaceAll("\\s+", " ").trim();
-			// If blank, use last beat_name for this auth_user_id
-			if (beatName.isEmpty()) {
-				beatName = lastBeatNameByUser.getOrDefault(authId, "Beat");
+			if (rawName.isEmpty()) rawName = lastBeatNameByUser.getOrDefault(authId, "Beat");
-			} else {
-				lastBeatNameByUser.put(authId, beatName);
+			else lastBeatNameByUser.put(authId, rawName);
-			}
-			resolvedBeatNames.put(record.getRecordNumber(), beatName);
+			resolvedBeatNames.put(record.getRecordNumber(), rawName);
-			String key = beatName + "|" + authId;
-			beatGroups.computeIfAbsent(key, k -> new ArrayList<>()).add(record);
+			beatGroups.computeIfAbsent(rawName + "|" + authId, k -> new ArrayList<>()).add(record);
+		}
-		// Build FofoStore code → id lookup
 		List<FofoStore> allStores = fofoStoreRepository.selectAll();
 		Map<String, Integer> codeToId = new HashMap<>();
-		for (FofoStore store : allStores) {
-			codeToId.put(store.getCode(), store.getId());
+		for (FofoStore store : allStores) codeToId.put(store.getCode(), store.getId());
-		}
-		// Load holidays for validation
 		LocalDate holidayStart = LocalDate.now();
-		LocalDate holidayEnd = holidayStart.plusMonths(6);
-		List<PublicHolidays> holidays = publicHolidaysRepository.selectAllBetweenDates(holidayStart, holidayEnd);
+		List<PublicHolidays> holidays = publicHolidaysRepository.selectAllBetweenDates(holidayStart, holidayStart.plusMonths(6));
 		Set<LocalDate> holidayDates = holidays.stream().map(PublicHolidays::getDate).collect(Collectors.toSet());
-		int beatsCreated = 0;
+		int beatsCreated = 0, errors = 0;
-		int errors = 0;
 		List<String> errorMessages = new ArrayList<>();
 		for (Map.Entry<String, List<org.apache.commons.csv.CSVRecord>> entry : beatGroups.entrySet()) {
 			try {
 				String[] keyParts = entry.getKey().split("\\|");
 				String beatName = keyParts[0];
 				int authUserId = Integer.parseInt(keyParts[1]);
 				List<org.apache.commons.csv.CSVRecord> rows = entry.getValue();
-				// Sort rows by day_number
 				rows.sort((a, b) -> Integer.parseInt(a.get("day_number").trim()) - Integer.parseInt(b.get("day_number").trim()));
-				// Get start_date from first row
 				String startDateStr = rows.get(0).get("start_date").trim();
-				LocalDate startDate = null;
-				if (!startDateStr.isEmpty()) {
-					startDate = LocalDate.parse(startDateStr, DateTimeFormatter.ISO_DATE);
+				LocalDate startDate = startDateStr.isEmpty() ? null : LocalDate.parse(startDateStr, DateTimeFormatter.ISO_DATE);
-				}
-				// Validate start date
 				if (startDate != null && startDate.isBefore(LocalDate.now())) {
-					errorMessages.add("Beat '" + beatName + "': start_date " + startDate + " is in the past. Skipped.");
+					errorMessages.add("Beat '" + beatName + "': start_date in past. Skipped.");
 					errors++;
 					continue;
+				}
-				// Auto-calculate dates for each day, skipping Sundays and holidays
-				int totalDays = rows.size();
 				List<LocalDate> scheduleDates = new ArrayList<>();
 				if (startDate != null) {
 					LocalDate d = startDate;
-					while (scheduleDates.size() < totalDays) {
+					while (scheduleDates.size() < rows.size()) {
-						boolean isSunday = d.getDayOfWeek() == DayOfWeek.SUNDAY;
-						boolean isHoliday = holidayDates.contains(d);
+						if (holidayDates.contains(d)) {
-						if (isHoliday) {
+							d = d.plusDays(1);
-							// Always skip holidays
+							continue;
-							errorMessages.add("Beat '" + beatName + "': skipping " + d + " (Holiday)");
-						} else if (isSunday && !includeSundays) {
-							// Skip Sunday only if not including Sundays
-							errorMessages.add("Beat '" + beatName + "': skipping " + d + " (Sunday)");
-						} else {
+						}
-							scheduleDates.add(d);
+						if (d.getDayOfWeek() == DayOfWeek.SUNDAY && !includeSundays) {
-							if (isSunday) {
+							d = d.plusDays(1);
-								errorMessages.add("Beat '" + beatName + "': including Sunday " + d);
-							}
+							continue;
+						}
+						scheduleDates.add(d);
 						d = d.plusDays(1);
+					}
+				}
+				// Duplicate check — skip if a beat with same name already exists for this user
-				String planGroupId = UUID.randomUUID().toString();
+				boolean isDuplicate = beatRepository.selectByAuthUserId(authUserId).stream()
-				String beatColor = BEAT_COLORS[Math.abs(planGroupId.hashCode()) % BEAT_COLORS.length];
+						.anyMatch(b -> b.getName() != null && beatName.equalsIgnoreCase(b.getName().trim()));
+				if (isDuplicate) {
+					errorMessages.add("Beat '" + beatName + "' already exists for user " + authUserId + ". Skipped.");
+					errors++;
+					continue;
+				}
-				// Get home location for this auth user
+				String beatColor = BEAT_COLORS[Math.abs(beatName.hashCode()) % BEAT_COLORS.length];
 				AuthUserLocation homeLoc = authUserLocationRepository.selectLatestByAuthUserIdAndType(authUserId, "BASE");
-				String homeName = homeLoc != null ? homeLoc.getLocationName() : "Home";
-				String homeLat = homeLoc != null ? homeLoc.getLatitude() : null;
-				String homeLng = homeLoc != null ? homeLoc.getLongitude() : null;
+				// Create Beat master
+				Beat beat = new Beat();
+				beat.setName(beatName);
+				beat.setAuthUserId(authUserId);
+				beat.setBeatColor(beatColor);
-				int totalRows = rows.size();
+				beat.setTotalDays(rows.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);
-				for (int rowIdx = 0; rowIdx < totalRows; rowIdx++) {
+				for (int rowIdx = 0; rowIdx < rows.size(); rowIdx++) {
 					org.apache.commons.csv.CSVRecord row = rows.get(rowIdx);
 					int dayNumber = Integer.parseInt(row.get("day_number").trim());
-					boolean isFirstDay = (rowIdx == 0);
-					boolean isLastDay = (rowIdx == totalRows - 1);
 					LocalDate planDate = (rowIdx < scheduleDates.size()) ? scheduleDates.get(rowIdx) : null;
+					LocalDate bulkEndDate = scheduleDates.isEmpty() ? null : scheduleDates.get(scheduleDates.size() - 1);
-					// Save BeatPlanDay
+					// Always create schedule — placeholder date (9999-12-31) when unscheduled
-					BeatPlanDay bpDay = new BeatPlanDay();
+					BeatSchedule schedule = new BeatSchedule();
-					bpDay.setPlanGroupId(planGroupId);
-					bpDay.setAuthUserId(authUserId);
+					schedule.setBeatId(beat.getId());
-					bpDay.setDayNumber(dayNumber);
+					schedule.setStartDate(planDate != null ? planDate : LocalDate.of(9999, 12, 31));
-					bpDay.setPlanDate(planDate);
+					schedule.setEndDate(bulkEndDate);
-					bpDay.setBeatName(beatName);
+					schedule.setDayNumber(dayNumber);
-					bpDay.setBeatColor(beatColor);
-					// Start location: Day 1 starts from home, other days start from home too (each day starts fresh)
-					bpDay.setStartLocationName(homeName);
-					bpDay.setStartLatitude(homeLat);
-					bpDay.setStartLongitude(homeLng);
-					// End action: last day = HOME (return home), other days = DAYBREAK
+					schedule.setEndAction(rowIdx == rows.size() - 1 ? "HOME" : "DAYBREAK");
-					if (isLastDay) {
-						bpDay.setEndAction("HOME");
-					} else {
-						bpDay.setEndAction("DAYBREAK");
-					}
-					bpDay.setCreatedBy(currentUser.getId());
-					bpDay.setCreatedTimestamp(LocalDateTime.now());
+					schedule.setCreatedTimestamp(LocalDateTime.now());
-					bpDay.setActive(true);
-					beatPlanDayRepository.persist(bpDay);
+					beatScheduleRepository.persist(schedule);
-					// Parse comma-separated partner codes
-					String partnerCodesStr = row.get("partner_codes").trim();
-					String[] partnerCodes = partnerCodesStr.split(",");
+					String[] partnerCodes = row.get("partner_codes").trim().split(",");
 					for (int i = 0; i < partnerCodes.length; i++) {
-						String partnerCode = partnerCodes[i].trim();
+						String code = partnerCodes[i].trim();
-						if (partnerCode.isEmpty()) continue;
+						if (code.isEmpty()) continue;
-						Integer fofoId = codeToId.get(partnerCode);
+						Integer fofoId = codeToId.get(code);
 						if (fofoId == null) {
-							errorMessages.add("Partner code not found: " + partnerCode + " in beat '" + beatName + "'");
+							errorMessages.add("Code not found: " + code);
 							errors++;
 							continue;
+						}
-						BeatPlan bp = new BeatPlan();
+						BeatRoute route = new BeatRoute();
-						bp.setAuthUserId(authUserId);
+						route.setBeatId(beat.getId());
-						bp.setFofoId(fofoId);
+						route.setFofoId(fofoId);
-						bp.setVisitType("partner");
+						route.setSequenceOrder(i);
-						bp.setDayNumber(dayNumber);
+						route.setDayNumber(dayNumber);
-						bp.setPlanGroupId(planGroupId);
-						bp.setPlanDate(planDate);
-						bp.setSequenceOrder(i);
-						bp.setCreatedBy(currentUser.getId());
-						bp.setCreatedTimestamp(LocalDateTime.now());
-						bp.setUpdatedTimestamp(LocalDateTime.now());
-						bp.setActive(true);
+						route.setActive(true);
-						beatPlanRepository.persist(bp);
+						beatRouteRepository.persist(route);
+					}
+				}
 				beatsCreated++;
-				// Log scheduled dates
-				if (!scheduleDates.isEmpty()) {
-					errorMessages.add("Beat '" + beatName + "' for user " + authUserId + " scheduled on: " +
-							scheduleDates.stream().map(LocalDate::toString).collect(Collectors.joining(", ")));
-				}
 			} catch (Exception e) {
 				errors++;
-				errorMessages.add("Error processing beat: " + entry.getKey() + " - " + e.getMessage());
+				errorMessages.add("Error: " + entry.getKey() + " - " + e.getMessage());
-				LOGGER.error("Bulk upload error for {}: {}", entry.getKey(), e.getMessage());
+			}
+		}
 		Map<String, Object> response = new HashMap<>();
 		response.put("status", true);
 		response.put("errors", errors);
 		response.put("errorMessages", errorMessages);
 		return responseSender.ok(response);
+	}
-	// ============ CALENDAR ENDPOINTS ============
+	// ============ CALENDAR ============
 	@PostMapping(value = "/beatPlan/delete")
 	public ResponseEntity<?> deleteBeat(@RequestParam String planGroupId) {
+		int beatId = Integer.parseInt(planGroupId);
-		beatPlanDayRepository.deleteByPlanGroupId(planGroupId);
+		beatRouteRepository.deleteByBeatId(beatId);
-		beatPlanRepository.deleteByPlanGroupId(planGroupId);
+		beatScheduleRepository.deleteByBeatId(beatId);
+		Beat beat = beatRepository.selectById(beatId);
+		if (beat != null) {
+			beat.setActive(false);
+		}
 		Map<String, Object> response = new HashMap<>();
 		response.put("status", true);
 		response.put("message", "Beat deleted");
 		return responseSender.ok(response);
 		YearMonth ym = YearMonth.parse(month);
 		LocalDate startDate = ym.atDay(1);
 		LocalDate endDate = ym.atEndOfMonth();
-		// Get holidays
 		List<PublicHolidays> holidays = publicHolidaysRepository.selectAllBetweenDates(startDate, endDate);
 		List<Map<String, String>> holidayList = holidays.stream().map(h -> {
 			Map<String, String> m = new HashMap<>();
 			m.put("date", h.getDate().toString());
 			m.put("occasion", h.getOccasion());
 			return m;
 		}).collect(Collectors.toList());
-		// Get ALL active beats for this auth user (not just this month)
-		List<BeatPlanDay> allBeatDays = beatPlanDayRepository.selectByAuthUserIdAndDateRange(
+		List<Beat> allBeats = beatRepository.selectActiveByAuthUserId(authUserId);
-				authUserId, LocalDate.of(2000, 1, 1), LocalDate.of(2099, 12, 31));
-		// Group by planGroupId
-		Map<String, List<BeatPlanDay>> grouped = allBeatDays.stream()
-				.filter(d -> d.getPlanGroupId() != null)
-				.collect(Collectors.groupingBy(BeatPlanDay::getPlanGroupId));
 		LocalDate today = LocalDate.now();
 		List<Map<String, Object>> scheduledBeats = new ArrayList<>();
-		for (Map.Entry<String, List<BeatPlanDay>> entry : grouped.entrySet()) {
+		for (Beat beat : allBeats) {
-			List<BeatPlanDay> days = entry.getValue();
+			List<BeatSchedule> schedules = beatScheduleRepository.selectByBeatId(beat.getId());
-			BeatPlanDay first = days.get(0);
+			List<BeatRoute> routes = beatRouteRepository.selectByBeatId(beat.getId());
-			// Determine status
-			boolean allNullDates = days.stream().allMatch(d -> d.getPlanDate() == null);
+			boolean allNullDates = schedules.isEmpty() || schedules.stream().allMatch(s -> s.getStartDate().getYear() == 9999);
-			boolean hasToday = days.stream().anyMatch(d -> d.getPlanDate() != null && d.getPlanDate().equals(today));
+			boolean hasToday = !allNullDates && schedules.stream().anyMatch(s -> s.getStartDate().equals(today));
-			boolean allPast = !allNullDates && days.stream().filter(d -> d.getPlanDate() != null).allMatch(d -> d.getPlanDate().isBefore(today));
+			boolean allPast = !allNullDates && schedules.stream().filter(s -> s.getStartDate().getYear() != 9999).allMatch(s -> s.getStartDate().isBefore(today));
-			boolean allFuture = !allNullDates && days.stream().filter(d -> d.getPlanDate() != null).allMatch(d -> d.getPlanDate().isAfter(today));
+			boolean allFuture = !allNullDates && schedules.stream().filter(s -> s.getStartDate().getYear() != 9999).allMatch(s -> s.getStartDate().isAfter(today));
 			String status;
 			if (allNullDates) status = "unscheduled";
 			else if (hasToday) status = "running";
 			else if (allPast) status = "completed";
-			else if (allFuture) status = "scheduled";
+			else status = "scheduled";
-			else status = "scheduled"; // mixed past/future
-			// Get visit counts per day
-			Map<String, Object> beat = new HashMap<>();
+			Map<String, Object> beatInfo = new HashMap<>();
-			beat.put("planGroupId", entry.getKey());
+			beatInfo.put("planGroupId", String.valueOf(beat.getId()));
-			beat.put("beatName", first.getBeatName() != null ? first.getBeatName() : "Beat");
+			beatInfo.put("beatName", beat.getName() != null ? beat.getName() : "Beat");
-			beat.put("beatColor", first.getBeatColor() != null ? first.getBeatColor() : "#3498DB");
+			beatInfo.put("beatColor", beat.getBeatColor() != null ? beat.getBeatColor() : "#3498DB");
-			beat.put("status", status);
+			beatInfo.put("status", status);
 			List<Map<String, Object>> dayInfoList = new ArrayList<>();
-			for (BeatPlanDay d : days) {
+			for (BeatSchedule s : schedules) {
 				Map<String, Object> dayInfo = new HashMap<>();
-				dayInfo.put("dayNumber", d.getDayNumber());
+				dayInfo.put("dayNumber", s.getDayNumber());
+				boolean isUnscheduled = s.getStartDate().getYear() == 9999;
-				dayInfo.put("planDate", d.getPlanDate() != null ? d.getPlanDate().toString() : null);
+				dayInfo.put("planDate", isUnscheduled ? null : s.getStartDate().toString());
-				dayInfo.put("totalKm", d.getTotalDistanceKm());
+				dayInfo.put("totalKm", s.getTotalDistanceKm());
-				dayInfo.put("totalMins", d.getTotalTimeMins());
+				dayInfo.put("totalMins", s.getTotalTimeMins());
-				// Count visits for this day
-				List<BeatPlan> visits = beatPlanRepository.selectByPlanGroupId(entry.getKey()).stream()
-						.filter(bp -> bp.getDayNumber() == d.getDayNumber())
+				long visitCount = routes.stream().filter(r -> r.getDayNumber() == s.getDayNumber()).count();
-						.collect(Collectors.toList());
-				dayInfo.put("visitCount", visits.size());
+				dayInfo.put("visitCount", (int) visitCount);
 				dayInfoList.add(dayInfo);
+			}
+			if (schedules.isEmpty()) {
+				// No schedule at all — show from routes
+				Map<Integer, Long> dayCounts = routes.stream()
+						.collect(Collectors.groupingBy(BeatRoute::getDayNumber, Collectors.counting()));
+				for (int d = 1; d <= beat.getTotalDays(); d++) {
+					Map<String, Object> dayInfo = new HashMap<>();
+					dayInfo.put("dayNumber", d);
+					dayInfo.put("planDate", null);
+					dayInfo.put("totalKm", null);
+					dayInfo.put("totalMins", null);
+					dayInfo.put("visitCount", dayCounts.getOrDefault(d, 0L).intValue());
+					dayInfoList.add(dayInfo);
+				}
+			}
-			beat.put("days", dayInfoList);
+			beatInfo.put("days", dayInfoList);
-			scheduledBeats.add(beat);
+			scheduledBeats.add(beatInfo);
+		}
-		// Build blocked dates (Sundays + holidays)
 		Set<String> blockedDates = new HashSet<>();
 		for (LocalDate d = startDate; !d.isAfter(endDate); d = d.plusDays(1)) {
-			if (d.getDayOfWeek() == DayOfWeek.SUNDAY) {
+			if (d.getDayOfWeek() == DayOfWeek.SUNDAY) blockedDates.add(d.toString());
-				blockedDates.add(d.toString());
-			}
-		}
-		for (PublicHolidays h : holidays) {
-			blockedDates.add(h.getDate().toString());
+		}
+		for (PublicHolidays h : holidays) blockedDates.add(h.getDate().toString());
 		Map<String, Object> response = new HashMap<>();
 		response.put("holidays", holidayList);
 		response.put("scheduledBeats", scheduledBeats);
 		response.put("blockedDates", blockedDates);
 		return responseSender.ok(response);
+	}
 	@PostMapping(value = "/beatPlan/scheduleOnCalendar")
 	public ResponseEntity<?> scheduleOnCalendar(
 			@RequestParam String planGroupId,
 			@RequestParam String dates,
 			@RequestParam(required = false) String beatName,
 			@RequestParam(required = false) String beatColor) throws Exception {
+		int beatId = Integer.parseInt(planGroupId);
 		Gson gson = new Gson();
 		List<String> dateList = gson.fromJson(dates, new TypeToken<List<String>>() {
 		}.getType());
-		List<BeatPlanDay> beatDays = beatPlanDayRepository.selectByPlanGroupId(planGroupId);
+		Beat beat = beatRepository.selectById(beatId);
-		if (beatDays.isEmpty()) {
-			return responseSender.badRequest("No beat found for this plan group");
+		if (beat == null) return responseSender.badRequest("Beat not found");
-		}
-		// Check running beat — can't reschedule
+		if (beatName != null) beat.setName(beatName);
-		LocalDate today = LocalDate.now();
-		boolean isRunning = beatDays.stream().anyMatch(d -> d.getPlanDate() != null && d.getPlanDate().equals(today));
-		if (isRunning) {
-			return responseSender.badRequest("Cannot reschedule a running beat");
+		if (beatColor != null && !beatColor.isEmpty()) beat.setBeatColor(beatColor);
-		}
-		// Auto-assign color if not provided
+		// Delete old schedules and create new
-		if (beatColor == null || beatColor.isEmpty()) {
-			beatColor = BEAT_COLORS[Math.abs(planGroupId.hashCode()) % BEAT_COLORS.length];
-		}
-		// Update dates on beat_plan_day
+		beatScheduleRepository.deleteByBeatId(beatId);
-		beatDays.sort(Comparator.comparingInt(BeatPlanDay::getDayNumber));
+		LocalDate schEndDate = dateList.isEmpty() ? null : LocalDate.parse(dateList.get(dateList.size() - 1));
-		for (int i = 0; i < beatDays.size() && i < dateList.size(); i++) {
+		for (int i = 0; i < dateList.size() && i < beat.getTotalDays(); i++) {
-			BeatPlanDay day = beatDays.get(i);
+			BeatSchedule schedule = new BeatSchedule();
-			day.setPlanDate(LocalDate.parse(dateList.get(i)));
-			if (beatName != null) day.setBeatName(beatName);
-			day.setBeatColor(beatColor);
+			schedule.setBeatId(beatId);
-			beatPlanDayRepository.persist(day);
+			schedule.setStartDate(LocalDate.parse(dateList.get(i)));
-		}
-		// Update dates on beat_plan records too
+			schedule.setEndDate(schEndDate);
-		List<BeatPlan> beatPlans = beatPlanRepository.selectByPlanGroupId(planGroupId);
-		for (BeatPlan bp : beatPlans) {
+			schedule.setDayNumber(i + 1);
-			for (int i = 0; i < beatDays.size() && i < dateList.size(); i++) {
+			schedule.setEndAction(i == dateList.size() - 1 ? "HOME" : "DAYBREAK");
-				if (bp.getDayNumber() == beatDays.get(i).getDayNumber()) {
-					bp.setPlanDate(LocalDate.parse(dateList.get(i)));
+			schedule.setCreatedTimestamp(LocalDateTime.now());
-					beatPlanRepository.persist(bp);
+			beatScheduleRepository.persist(schedule);
-				}
-			}
+		}
 		Map<String, Object> response = new HashMap<>();
 		response.put("status", true);
 		response.put("message", "Beat scheduled successfully");
 		return responseSender.ok(response);
+	}
+	// Drag-drop scheduling — adds schedule dates to the EXISTING beat (no new beat created)
 	@PostMapping(value = "/beatPlan/repeatBeat")
 	public ResponseEntity<?> repeatBeat(
 			HttpServletRequest request,
 			@RequestParam String sourcePlanGroupId,
 			@RequestParam int authUserId,
 			@RequestParam String dates) throws Exception {
-		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		int beatId = Integer.parseInt(sourcePlanGroupId);
-		AuthUser currentUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());
 		Gson gson = new Gson();
 		List<String> dateList = gson.fromJson(dates, new TypeToken<List<String>>() {
 		}.getType());
-		// Get source beat days and visits
-		List<BeatPlanDay> sourceDays = beatPlanDayRepository.selectByPlanGroupId(sourcePlanGroupId);
-		List<BeatPlan> sourceVisits = beatPlanRepository.selectByPlanGroupId(sourcePlanGroupId);
+		Beat beat = beatRepository.selectById(beatId);
-		if (sourceDays.isEmpty()) {
-			return responseSender.badRequest("Source beat not found");
+		if (beat == null) return responseSender.badRequest("Beat not found");
-		}
-		String newPlanGroupId = UUID.randomUUID().toString();
-		String beatName = sourceDays.get(0).getBeatName();
+		// Remove placeholder (unscheduled) schedule rows
-		String beatColor = sourceDays.get(0).getBeatColor();
+		List<BeatSchedule> existing = beatScheduleRepository.selectByBeatId(beatId);
-		// Copy days with new dates
-		sourceDays.sort(Comparator.comparingInt(BeatPlanDay::getDayNumber));
-		for (int i = 0; i < sourceDays.size() && i < dateList.size(); i++) {
-			BeatPlanDay src = sourceDays.get(i);
-			BeatPlanDay newDay = new BeatPlanDay();
+		for (BeatSchedule s : existing) {
-			newDay.setPlanGroupId(newPlanGroupId);
-			newDay.setAuthUserId(authUserId);
-			newDay.setDayNumber(src.getDayNumber());
-			newDay.setPlanDate(LocalDate.parse(dateList.get(i)));
-			newDay.setBeatName(beatName);
-			newDay.setBeatColor(beatColor);
-			newDay.setStartLocationName(src.getStartLocationName());
-			newDay.setStartLatitude(src.getStartLatitude());
+			if (s.getStartDate() != null && s.getStartDate().getYear() == 9999) {
-			newDay.setStartLongitude(src.getStartLongitude());
-			newDay.setEndAction(src.getEndAction());
-			newDay.setStayLocationName(src.getStayLocationName());
-			newDay.setStayLatitude(src.getStayLatitude());
-			newDay.setStayLongitude(src.getStayLongitude());
-			newDay.setTotalDistanceKm(src.getTotalDistanceKm());
-			newDay.setTotalTimeMins(src.getTotalTimeMins());
-			newDay.setCreatedBy(currentUser.getId());
-			newDay.setCreatedTimestamp(LocalDateTime.now());
-			newDay.setActive(true);
-			beatPlanDayRepository.persist(newDay);
+				beatScheduleRepository.delete(s);
-		}
-		// Copy visits with new plan group and dates
-		for (BeatPlan srcVisit : sourceVisits) {
-			BeatPlan newVisit = new BeatPlan();
-			newVisit.setAuthUserId(authUserId);
-			newVisit.setFofoId(srcVisit.getFofoId());
-			newVisit.setVisitType(srcVisit.getVisitType());
-			newVisit.setDayNumber(srcVisit.getDayNumber());
-			newVisit.setPlanGroupId(newPlanGroupId);
-			newVisit.setSequenceOrder(srcVisit.getSequenceOrder());
-			newVisit.setCreatedBy(currentUser.getId());
-			newVisit.setCreatedTimestamp(LocalDateTime.now());
-			newVisit.setUpdatedTimestamp(LocalDateTime.now());
-			newVisit.setActive(true);
-			// Set date from new dateList
-			int dayIdx = srcVisit.getDayNumber() - 1;
-			if (dayIdx >= 0 && dayIdx < dateList.size()) {
-				newVisit.setPlanDate(LocalDate.parse(dateList.get(dayIdx)));
+			}
+		}
+		// Add new real-date schedule rows for the existing beat
+		LocalDate repeatEndDate = dateList.isEmpty() ? null : LocalDate.parse(dateList.get(dateList.size() - 1));
+		for (int i = 0; i < dateList.size(); i++) {
+			BeatSchedule schedule = new BeatSchedule();
+			schedule.setBeatId(beatId);
+			schedule.setStartDate(LocalDate.parse(dateList.get(i)));
+			schedule.setEndDate(repeatEndDate);
+			schedule.setDayNumber(i + 1);
+			schedule.setEndAction(i == dateList.size() - 1 ? "HOME" : "DAYBREAK");
+			schedule.setCreatedTimestamp(LocalDateTime.now());
-			beatPlanRepository.persist(newVisit);
+			beatScheduleRepository.persist(schedule);
+		}
 		Map<String, Object> response = new HashMap<>();
 		response.put("status", true);
-		response.put("planGroupId", newPlanGroupId);
+		response.put("planGroupId", String.valueOf(beatId));
-		response.put("message", "Beat repeated successfully");
+		response.put("message", "Beat scheduled successfully");
 		return responseSender.ok(response);
+	}
 	@GetMapping(value = "/beatPlan/availableSlots")
 	public ResponseEntity<?> getAvailableSlots(
 		YearMonth ym = YearMonth.parse(month);
 		LocalDate startDate = ym.atDay(1);
 		LocalDate endDate = ym.atEndOfMonth();
 		LocalDate today = LocalDate.now();
-		// Blocked: Sundays + holidays + already scheduled dates
 		Set<LocalDate> blocked = new HashSet<>();
 		for (LocalDate d = startDate; !d.isAfter(endDate); d = d.plusDays(1)) {
 			if (d.getDayOfWeek() == DayOfWeek.SUNDAY) blocked.add(d);
-			if (!d.isAfter(today)) blocked.add(d); // past dates blocked
+			if (!d.isAfter(today)) blocked.add(d);
+		}
 		List<PublicHolidays> holidays = publicHolidaysRepository.selectAllBetweenDates(startDate, endDate);
 		for (PublicHolidays h : holidays) blocked.add(h.getDate());
+		// Get all scheduled dates for this user
-		List<BeatPlanDay> existingBeats = beatPlanDayRepository.selectByAuthUserIdAndDateRange(authUserId, startDate, endDate);
+		List<Beat> userBeats = beatRepository.selectActiveByAuthUserId(authUserId);
-		for (BeatPlanDay bd : existingBeats) {
+		for (Beat b : userBeats) {
+			List<BeatSchedule> schedules = beatScheduleRepository.selectByBeatId(b.getId());
-			if (bd.getPlanDate() != null) blocked.add(bd.getPlanDate());
+			for (BeatSchedule s : schedules) blocked.add(s.getStartDate());
+		}
-		// Find earliest available slots
 		List<String> available = new ArrayList<>();
 		for (LocalDate d = startDate.isAfter(today) ? startDate : today.plusDays(1);
 			 !d.isAfter(endDate) && available.size() < daysNeeded;
 			 d = d.plusDays(1)) {
-			if (!blocked.contains(d)) {
-				available.add(d.toString());
+			if (!blocked.contains(d)) available.add(d.toString());
-			}
+		}
 		Map<String, Object> response = new HashMap<>();
 		response.put("suggestedDates", available);
 		response.put("totalAvailable", available.size());
 	// --- Sorting helpers ---
 	private List<Map<String, Object>> sortByNearestNeighborFromStart(
 			List<Map<String, Object>> partners, double startLat, double startLng) {
 		List<Map<String, Object>> withCoords = new ArrayList<>();
 		List<Map<String, Object>> withoutCoords = new ArrayList<>();
 		for (Map<String, Object> p : partners) {
-			if (hasValidCoords(p)) {
+			if (hasValidCoords(p)) withCoords.add(p);
-				withCoords.add(p);
-			} else {
-				withoutCoords.add(p);
+			else withoutCoords.add(p);
-			}
+		}
 		List<Map<String, Object>> sorted = new ArrayList<>();
-		double currentLat = startLat;
-		double currentLng = startLng;
+		double currentLat = startLat, currentLng = startLng;
 		while (!withCoords.isEmpty()) {
 			int nearestIdx = 0;
 			double nearestDist = Double.MAX_VALUE;
 			for (int i = 0; i < withCoords.size(); i++) {
-				double lat = Double.parseDouble(withCoords.get(i).get("latitude").toString());
+				double dist = haversine(currentLat, currentLng,
-				double lng = Double.parseDouble(withCoords.get(i).get("longitude").toString());
+						Double.parseDouble(withCoords.get(i).get("latitude").toString()),
-				double dist = haversine(currentLat, currentLng, lat, lng);
+						Double.parseDouble(withCoords.get(i).get("longitude").toString()));
 				if (dist < nearestDist) {
 					nearestDist = dist;
 					nearestIdx = i;
+				}
+			}
 			Map<String, Object> nearest = withCoords.remove(nearestIdx);
 			sorted.add(nearest);
 			currentLat = Double.parseDouble(nearest.get("latitude").toString());
 			currentLng = Double.parseDouble(nearest.get("longitude").toString());
+		}
 		sorted.addAll(withoutCoords);
 		return sorted;
+	}
 	private List<Map<String, Object>> sortByNearestNeighbor(List<Map<String, Object>> partners) {
 		List<Map<String, Object>> withCoords = new ArrayList<>();
 		List<Map<String, Object>> withoutCoords = new ArrayList<>();
 		for (Map<String, Object> p : partners) {
-			if (hasValidCoords(p)) {
+			if (hasValidCoords(p)) withCoords.add(p);
-				withCoords.add(p);
-			} else {
-				withoutCoords.add(p);
+			else withoutCoords.add(p);
-			}
+		}
 		List<Map<String, Object>> sorted = new ArrayList<>();
 		if (!withCoords.isEmpty()) {
 			sorted.add(withCoords.remove(0));
 			while (!withCoords.isEmpty()) {
 				Map<String, Object> last = sorted.get(sorted.size() - 1);
 				double lastLat = Double.parseDouble(last.get("latitude").toString());
 				double lastLng = Double.parseDouble(last.get("longitude").toString());
 				int nearestIdx = 0;
 				double nearestDist = Double.MAX_VALUE;
 				for (int i = 0; i < withCoords.size(); i++) {
-					double lat = Double.parseDouble(withCoords.get(i).get("latitude").toString());
+					double dist = haversine(lastLat, lastLng,
-					double lng = Double.parseDouble(withCoords.get(i).get("longitude").toString());
+							Double.parseDouble(withCoords.get(i).get("latitude").toString()),
-					double dist = haversine(lastLat, lastLng, lat, lng);
+							Double.parseDouble(withCoords.get(i).get("longitude").toString()));
 					if (dist < nearestDist) {
 						nearestDist = dist;
 						nearestIdx = i;
+					}
+				}
+	}
 	private boolean hasValidCoords(Map<String, Object> p) {
 		Object lat = p.get("latitude");
 		Object lng = p.get("longitude");
-		return lat != null && lng != null
-				&& !lat.toString().isEmpty() && !lng.toString().isEmpty();
+		return lat != null && lng != null && !lat.toString().isEmpty() && !lng.toString().isEmpty();
+	}
 	private double haversine(double lat1, double lng1, double lat2, double lng2) {
 		double R = 6371;
 		double dLat = Math.toRadians(lat2 - lat1);

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/BeatPlanController.java – Rev 36632 → 36644