Split availability windows into bookable lesson-length slots with weekly calendar views

Availability windows were stored and served as a single bookable row, so a
9:00 AM-4:00 PM window showed to students as one giant slot and booking it
consumed the whole day; past and multi-day windows also leaked into the
booking page as nonsense entries.

- Split windows into consecutive lesson-length slots on save (REST and admin
  form); each chunk is independently bookable and weekly recurrence creates a
  series per chunk so "reserve this time weekly" holds the same hour each week
- Reject windows spanning multiple days or shorter than the lesson length
  (400 invalid_window)
- Never return slots whose start has passed from GET /availability
- Migrate pre-split rows: Plugin::boot re-runs the Installer on version change
  and AvailabilityRepository::splitOversizedWindows() rewrites unbooked
  same-day oversized windows in place
- Display all times in 12-hour AM/PM form (booking page, wp-admin lists,
  editor previews)
- Add a List | Week view toggle to the student booking page and the
  instructor availability page, with previous/next-week navigation honouring
  the site's start_of_week option (new WeekCalendar helper)

Co-Authored-By: Claude Fable 5 <[email protected]>

src/Availability/AvailabilityController.php

@@ -29,6 +29,18 @@ class AvailabilityController {
 		$slots           = $this->repository->findByInstructor( $instructorId );
 		$offeringChoices = $this->offerings->findAll( $instructorId, Offering::KIND_PRIVATE_LESSON, true );
 
+		// View-state query params only (which view, which week) — nothing is
+		// mutated from them, so no nonce applies.
+		// phpcs:disable WordPress.Security.NonceVerification.Recommended
+		$view          = 'week' === sanitize_key( Val::string( wp_unslash( $_GET['usc_view'] ?? '' ) ) ) ? 'week' : 'list';
+		$requestedWeek = sanitize_text_field( Val::string( wp_unslash( $_GET['usc_week'] ?? '' ) ) );
+		// phpcs:enable WordPress.Security.NonceVerification.Recommended
+
+		$weekStart = WeekCalendar::weekStart( $requestedWeek, Val::int( get_option( 'start_of_week', 1 ) ), current_time( 'Y-m-d' ) );
+		$weekDays  = WeekCalendar::days( $weekStart, $slots );
+		$prevWeek  = ( new \DateTimeImmutable( $weekStart ) )->modify( '-7 days' )->format( 'Y-m-d' );
+		$nextWeek  = ( new \DateTimeImmutable( $weekStart ) )->modify( '+7 days' )->format( 'Y-m-d' );
+
 		include USC_PLUGIN_DIR . 'templates/admin/availability.php';
 	}
 
@@ -58,14 +70,16 @@ class AvailabilityController {
 		$startDt = AvailabilitySlot::normalizeDateTime( sanitize_text_field( Val::string( wp_unslash( $_POST['start_dt'] ?? '' ) ) ) );
 		$endDt   = AvailabilitySlot::normalizeDateTime( sanitize_text_field( Val::string( wp_unslash( $_POST['end_dt'] ?? '' ) ) ) );
 
-		if ( null === $startDt || null === $endDt || $endDt <= $startDt ) {
+		// A window must start and end on the same day (weekly repeat covers longer
+		// ranges) and fit at least one lesson; it is stored as lesson-length slots.
+		if ( null === $startDt || null === $endDt || $endDt <= $startDt || substr( $startDt, 0, 10 ) !== substr( $endDt, 0, 10 ) ) {
 			return;
 		}
 
 		$offeringId = absint( Val::int( $_POST['offering_id'] ?? 0 ) );
 		$duration   = absint( Val::int( $_POST['duration_minutes'] ?? 0 ) );
 
-		$slot = new AvailabilitySlot(
+		$window = new AvailabilitySlot(
 			instructorId:    $instructorId,
 			startDt:         $startDt,
 			endDt:           $endDt,
@@ -73,12 +87,10 @@ class AvailabilityController {
 			offeringId:      $offeringId > 0 ? $offeringId : null,
 		);
 
-		if ( 'weekly' === sanitize_key( Val::string( wp_unslash( $_POST['recurrence'] ?? 'single' ) ) ) ) {
-			$this->repository->createWeeklySeries( $slot, absint( Val::int( $_POST['weeks'] ?? 1 ) ) );
-			return;
-		}
+		$recurrence = sanitize_key( Val::string( wp_unslash( $_POST['recurrence'] ?? 'single' ) ) );
+		$weeks      = absint( Val::int( $_POST['weeks'] ?? 1 ) );
 
-		$this->repository->insert( $slot );
+		$this->repository->createFromWindow( $window, 'weekly' === $recurrence, $weeks );
 		// phpcs:enable WordPress.Security.NonceVerification.Missing
 	}
 }

src/Availability/AvailabilityEndpoint.php

@@ -133,7 +133,11 @@ class AvailabilityEndpoint {
 			return new \WP_Error( 'invalid_datetime', __( 'Provide a valid start and end, with the end after the start.', 'unsupervised-schedular' ), [ 'status' => 400 ] );
 		}
 
-		$slot = new AvailabilitySlot(
+		if ( substr( $startDt, 0, 10 ) !== substr( $endDt, 0, 10 ) ) {
+			return new \WP_Error( 'invalid_window', __( 'Availability must start and end on the same day. Use the weekly repeat to cover multiple weeks.', 'unsupervised-schedular' ), [ 'status' => 400 ] );
+		}
+
+		$window = new AvailabilitySlot(
 			instructorId:    $instructorId,
 			startDt:         $startDt,
 			endDt:           $endDt,
@@ -141,15 +145,17 @@ class AvailabilityEndpoint {
 			offeringId:      $offeringId > 0 ? $offeringId : null,
 		);
 
-		if ( 'weekly' === $request->get_param( 'recurrence' ) ) {
-			$ids = $this->repository->createWeeklySeries( $slot, absint( Val::int( $request->get_param( 'weeks' ) ) ) );
-
-			return new \WP_REST_Response( [ 'ids' => $ids ], 201 );
+		if ( [] === $window->splitByDuration() ) {
+			return new \WP_Error( 'invalid_window', __( 'The availability window is shorter than the lesson length.', 'unsupervised-schedular' ), [ 'status' => 400 ] );
 		}
 
-		$id = $this->repository->insert( $slot );
+		$ids = $this->repository->createFromWindow(
+			$window,
+			'weekly' === $request->get_param( 'recurrence' ),
+			absint( Val::int( $request->get_param( 'weeks' ) ) )
+		);
 
-		return new \WP_REST_Response( [ 'id' => $id ], 201 );
+		return new \WP_REST_Response( [ 'ids' => $ids ], 201 );
 	}
 
 	public function delete( \WP_REST_Request $request ): \WP_REST_Response|\WP_Error {

src/Availability/AvailabilityRepository.php

@@ -30,6 +30,26 @@ class AvailabilityRepository {
 		return $this->db->insert_id;
 	}
 
+	/**
+	 * Persist an availability window as individually bookable lesson-length slots.
+	 * The window is split into consecutive `duration_minutes` chunks; each chunk
+	 * becomes its own row (and, when weekly, its own weekly series) so students can
+	 * book any open lesson-length block within the window.
+	 *
+	 * @return list<int> Inserted slot IDs.
+	 */
+	public function createFromWindow( AvailabilitySlot $window, bool $weekly = false, int $weeks = 1 ): array {
+		$ids = [];
+
+		foreach ( $window->splitByDuration() as $slot ) {
+			$ids = $weekly
+				? array_merge( $ids, $this->createWeeklySeries( $slot, $weeks ) )
+				: [ ...$ids, $this->insert( $slot ) ];
+		}
+
+		return $ids;
+	}
+
 	/**
 	 * Create a weekly-recurring series from a template slot. Each occurrence is a
 	 * separate row one week apart, all sharing a `recurrence_group` (the id of the
@@ -87,8 +107,10 @@ class AvailabilityRepository {
 	 * @return list<AvailabilitySlot>
 	 */
 	public function findAvailable( int $instructorId = 0, int $offeringId = 0, int $durationMinutes = 0, string $from = '', string $to = '' ): array {
-		$where  = [ 'is_booked = 0' ];
-		$params = [];
+		// A slot whose start has passed can no longer be booked, so it is never
+		// "available" regardless of the requested range.
+		$where  = [ 'is_booked = 0', 'start_dt >= %s' ];
+		$params = [ current_time( 'mysql' ) ];
 
 		if ( $instructorId > 0 ) {
 			$where[]  = 'instructor_id = %d';
@@ -189,6 +211,47 @@ class AvailabilityRepository {
 		return 1 === $updated;
 	}
 
+	/**
+	 * One-time upgrade for rows created before windows were split on save: a
+	 * window stored as a single row (e.g. 09:00–16:00 with 60-minute lessons)
+	 * showed to students as one giant slot. Rewrites every unbooked same-day
+	 * window longer than its lesson length as lesson-length rows: the original
+	 * row is trimmed to the first chunk (keeping its id and any recurrence
+	 * group), and the remaining chunks are inserted as one-off rows.
+	 */
+	public function splitOversizedWindows(): void {
+		$rows = $this->db->get_results(
+			$this->db->prepare(
+				'SELECT * FROM %i
+                 WHERE is_booked = 0
+                   AND DATE(start_dt) = DATE(end_dt)
+                   AND TIMESTAMPDIFF(MINUTE, start_dt, end_dt) > duration_minutes',
+				$this->table
+			)
+		);
+
+		foreach ( $rows ?? [] as $row ) {
+			$window = AvailabilitySlot::fromRow( $row );
+			$chunks = $window->splitByDuration();
+
+			if ( [] === $chunks ) {
+				continue;
+			}
+
+			$this->db->update(
+				$this->table,
+				[ 'end_dt' => $chunks[0]->endDt ],
+				[ 'id' => $window->id ],
+				[ '%s' ],
+				[ '%d' ]
+			);
+
+			foreach ( array_slice( $chunks, 1 ) as $chunk ) {
+				$this->insert( $chunk );
+			}
+		}
+	}
+
 	/**
 	 * Delete an unbooked slot. Returns false if the slot is already booked.
 	 */

src/Availability/AvailabilitySlot.php

@@ -37,6 +37,42 @@ class AvailabilitySlot {
 		return null;
 	}
 
+	/**
+	 * Split this window into consecutive lesson-length slots: 09:00–16:00 with
+	 * 60-minute lessons yields seven bookable slots. A trailing remainder shorter
+	 * than the lesson length is dropped, and an empty list is returned when the
+	 * window cannot fit a single lesson.
+	 *
+	 * @return list<self>
+	 */
+	public function splitByDuration(): array {
+		if ( $this->durationMinutes <= 0 ) {
+			return [];
+		}
+
+		$end  = new \DateTimeImmutable( $this->endDt );
+		$step = new \DateInterval( 'PT' . $this->durationMinutes . 'M' );
+
+		$cursor   = new \DateTimeImmutable( $this->startDt );
+		$chunkEnd = $cursor->add( $step );
+
+		$slots = [];
+		while ( $chunkEnd <= $end ) {
+			$slots[] = new self(
+				instructorId:    $this->instructorId,
+				startDt:         $cursor->format( 'Y-m-d H:i:s' ),
+				endDt:           $chunkEnd->format( 'Y-m-d H:i:s' ),
+				durationMinutes: $this->durationMinutes,
+				offeringId:      $this->offeringId,
+			);
+
+			$cursor   = $chunkEnd;
+			$chunkEnd = $cursor->add( $step );
+		}
+
+		return $slots;
+	}
+
 	public static function fromRow( \stdClass $row ): self {
 		return new self(
 			instructorId:    Val::int( $row->instructor_id ),

src/Availability/WeekCalendar.php

@@ -0,0 +1,57 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Availability;
+
+/**
+ * Pure helpers for the weekly calendar views: resolving which week to show and
+ * bucketing slots into that week's seven days.
+ */
+class WeekCalendar {
+
+	/**
+	 * Resolve a requested week anchor to the date of the first day of its week.
+	 * `$requested` may be any date (`Y-m-d`) inside the wanted week; anything
+	 * unparseable falls back to `$today`. `$startOfWeek` follows WordPress's
+	 * `start_of_week` option (0 = Sunday … 6 = Saturday).
+	 */
+	public static function weekStart( string $requested, int $startOfWeek, string $today ): string {
+		$anchor = self::parseDay( $requested ) ?? self::parseDay( $today ) ?? new \DateTimeImmutable( 'today' );
+		$shift  = ( (int) $anchor->format( 'w' ) - $startOfWeek + 7 ) % 7;
+
+		return $anchor->modify( '-' . $shift . ' days' )->format( 'Y-m-d' );
+	}
+
+	/**
+	 * Bucket slots into the seven days of the week starting at `$weekStart`
+	 * (`Y-m-d`). Every day is present, empty or not, in calendar order.
+	 *
+	 * @param list<AvailabilitySlot> $slots
+	 * @return list<array{date: string, slots: list<AvailabilitySlot>}>
+	 */
+	public static function days( string $weekStart, array $slots ): array {
+		$start = self::parseDay( $weekStart ) ?? new \DateTimeImmutable( 'today' );
+
+		$byDay = [];
+		foreach ( $slots as $slot ) {
+			$byDay[ substr( $slot->startDt, 0, 10 ) ][] = $slot;
+		}
+
+		$days = [];
+		for ( $i = 0; $i < 7; $i++ ) {
+			$date   = $start->modify( '+' . $i . ' days' )->format( 'Y-m-d' );
+			$days[] = [
+				'date'  => $date,
+				'slots' => $byDay[ $date ] ?? [],
+			];
+		}
+
+		return $days;
+	}
+
+	private static function parseDay( string $value ): ?\DateTimeImmutable {
+		$day = \DateTimeImmutable::createFromFormat( '!Y-m-d', $value );
+
+		return false !== $day && $day->format( 'Y-m-d' ) === $value ? $day : null;
+	}
+}