Add group-class scheduling, instructor assignment, and details/invite management

Group classes now carry a specific class time (alongside date and duration)
and an assigned instructor:

- Schema: add `class_time` (TIME) to `us_offerings`; `Offering` gains
  `normalizeTime`/`sessionWindows`. (Rides the pending 1.0.0->1.1.0 dbDelta
  upgrade, so no version bump.)
- Offering form: class-time field, plus a studio-admin instructor picker
  (plain instructors always own their own classes).
- `ClassSlotReconciler`: assigning an instructor clears their open booking
  slots overlapping each session and flags already-booked lessons that clash
  (a booked lesson is never deleted). Uses new
  `AvailabilityRepository::findOverlapping`.
- Front end: `GET /offerings` exposes `instructor_name`; the enrolment page
  shows who teaches each class and when it meets.

Back-office group-class views redesigned:

- Instructor **My Group Classes** and studio-admin **Group Classes** are now
  per-class summaries with enrolment counts, not flat student lists.
- Each links through (`?class_id=<id>`) to a per-class **details page**
  (schedule panel, roster with payment status, and — for invite-only classes
  — the add/make-available/invite-by-email controls). Invite-only membership
  is managed entirely from this page.
- Invite actions are allowed for the class's owning instructor or any
  `view_all_lessons` studio admin, so an owner-operator (studio admin who also
  teaches) can reach every class's roster and invites from the Group Classes
  page.

Tests: composer test (508), composer lint, composer cs all pass.

Co-Authored-By: Claude Opus 4.8 <[email protected]>

tests/Unit/Offering/ClassSlotReconcilerTest.php

@@ -0,0 +1,122 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Tests\Unit\Offering;
+
+use Mockery;
+use Unsupervised\Schedular\Availability\AvailabilityRepository;
+use Unsupervised\Schedular\Availability\AvailabilitySlot;
+use Unsupervised\Schedular\Offering\ClassSlotReconciler;
+use Unsupervised\Schedular\Offering\Offering;
+use Unsupervised\Schedular\Tests\Unit\TestCase;
+
+class ClassSlotReconcilerTest extends TestCase
+{
+    private AvailabilityRepository&Mockery\MockInterface $availability;
+    private ClassSlotReconciler $reconciler;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->availability = Mockery::mock(AvailabilityRepository::class);
+        $this->reconciler   = new ClassSlotReconciler($this->availability);
+    }
+
+    private function groupClass(?string $termEnd = null): Offering
+    {
+        return new Offering(
+            instructorId:    3,
+            kind:            Offering::KIND_GROUP_CLASS,
+            title:           'Choir',
+            durationMinutes: 60,
+            termStart:       '2026-09-08',
+            termEnd:         $termEnd ?? '2026-09-08',
+            classTime:       '16:00:00',
+            id:              8,
+        );
+    }
+
+    public function testRemovesOpenSlotsOverlappingASession(): void
+    {
+        $open = new AvailabilitySlot(3, '2026-09-08 16:00:00', '2026-09-08 17:00:00', 60, id: 12);
+
+        $this->availability->shouldReceive('findOverlapping')
+            ->once()->with(3, '2026-09-08 16:00:00', '2026-09-08 17:00:00')
+            ->andReturn([$open]);
+        $this->availability->shouldReceive('delete')->once()->with(12)->andReturn(true);
+
+        $result = $this->reconciler->reconcile($this->groupClass());
+
+        self::assertSame(1, $result['removed']);
+        self::assertSame([], $result['conflicts']);
+    }
+
+    public function testReportsBookedSlotAsConflictWithoutDeleting(): void
+    {
+        $booked = new AvailabilitySlot(3, '2026-09-08 16:00:00', '2026-09-08 17:00:00', 60, isBooked: true, id: 12);
+
+        $this->availability->shouldReceive('findOverlapping')->once()->andReturn([$booked]);
+        // A booked lesson is never deleted.
+        $this->availability->shouldReceive('delete')->never();
+
+        $result = $this->reconciler->reconcile($this->groupClass());
+
+        self::assertSame(0, $result['removed']);
+        self::assertSame(['2026-09-08 16:00:00'], $result['conflicts']);
+    }
+
+    public function testWeeklyClassReconcilesEverySession(): void
+    {
+        // Three weekly sessions from Sep 8 to Sep 22.
+        $this->availability->shouldReceive('findOverlapping')
+            ->once()->with(3, '2026-09-08 16:00:00', '2026-09-08 17:00:00')->andReturn([]);
+        $this->availability->shouldReceive('findOverlapping')
+            ->once()->with(3, '2026-09-15 16:00:00', '2026-09-15 17:00:00')->andReturn([]);
+        $this->availability->shouldReceive('findOverlapping')
+            ->once()->with(3, '2026-09-22 16:00:00', '2026-09-22 17:00:00')->andReturn([]);
+
+        $result = $this->reconciler->reconcile($this->groupClass('2026-09-22'));
+
+        self::assertSame(0, $result['removed']);
+    }
+
+    public function testUnscheduledClassIsSkipped(): void
+    {
+        // No class time set — nothing to reconcile.
+        $offering = new Offering(
+            instructorId:    3,
+            kind:            Offering::KIND_GROUP_CLASS,
+            title:           'Choir',
+            durationMinutes: 60,
+            termStart:       '2026-09-08',
+            id:              8,
+        );
+
+        $this->availability->shouldReceive('findOverlapping')->never();
+
+        $result = $this->reconciler->reconcile($offering);
+
+        self::assertSame(['removed' => 0, 'conflicts' => []], $result);
+    }
+
+    public function testPrivateLessonOfferingIsSkipped(): void
+    {
+        $offering = new Offering(
+            instructorId:    3,
+            kind:            Offering::KIND_PRIVATE_LESSON,
+            title:           '30 min',
+            durationMinutes: 30,
+            termStart:       '2026-09-08',
+            termEnd:         '2026-09-08',
+            classTime:       '16:00:00',
+            id:              8,
+        );
+
+        $this->availability->shouldReceive('findOverlapping')->never();
+
+        $result = $this->reconciler->reconcile($offering);
+
+        self::assertSame(['removed' => 0, 'conflicts' => []], $result);
+    }
+}

tests/Unit/Offering/OfferingControllerTest.php

@@ -5,6 +5,7 @@ namespace Unsupervised\Schedular\Tests\Unit\Offering;
 
 use Brain\Monkey\Functions;
 use Mockery;
+use Unsupervised\Schedular\Offering\ClassSlotReconciler;
 use Unsupervised\Schedular\Offering\Offering;
 use Unsupervised\Schedular\Offering\OfferingController;
 use Unsupervised\Schedular\Offering\OfferingRepository;
@@ -13,6 +14,7 @@ use Unsupervised\Schedular\Tests\Unit\TestCase;
 class OfferingControllerTest extends TestCase
 {
     private OfferingRepository&Mockery\MockInterface $repository;
+    private ClassSlotReconciler&Mockery\MockInterface $reconciler;
     private OfferingController $controller;
 
     protected function setUp(): void
@@ -20,13 +22,16 @@ class OfferingControllerTest extends TestCase
         parent::setUp();
 
         $this->repository = Mockery::mock(OfferingRepository::class);
-        $this->controller = new OfferingController($this->repository);
+        $this->reconciler = Mockery::mock(ClassSlotReconciler::class);
+        $this->reconciler->shouldReceive('reconcile')->andReturn(['removed' => 0, 'conflicts' => []])->byDefault();
+        $this->controller = new OfferingController($this->repository, $this->reconciler);
 
         $_POST = [];
         $_GET  = [];
 
         Functions\when('current_user_can')->justReturn(true);
         Functions\when('get_current_user_id')->justReturn(3);
+        Functions\when('get_users')->justReturn([]);
         Functions\when('check_admin_referer')->justReturn(true);
         Functions\when('admin_url')->justReturn('admin.php?page=us-offerings');
         Functions\when('add_query_arg')->alias(
@@ -70,6 +75,90 @@ class OfferingControllerTest extends TestCase
         $this->render();
     }
 
+    public function testAddGroupClassStoresClassTimeAndReconcilesSlots(): void
+    {
+        $_POST = [
+            'usc_action'  => 'add',
+            'title'       => 'Ballet Beginners',
+            'kind'        => Offering::KIND_GROUP_CLASS,
+            'term_start'  => '2026-09-08',
+            'class_time'  => '16:30',
+            'duration_minutes' => '60',
+        ];
+
+        $this->repository->shouldReceive('insert')->once()->with(Mockery::on(
+            static fn (Offering $o) => '16:30:00' === $o->classTime
+        ))->andReturn(1);
+        $this->repository->shouldReceive('findAll')->andReturn([]);
+
+        // A scheduled class is reconciled against the instructor's availability,
+        // and the resulting notice is surfaced to the admin.
+        $this->reconciler->shouldReceive('reconcile')->once()->with(Mockery::on(
+            static fn (Offering $o) => '16:30:00' === $o->classTime
+        ))->andReturn(['removed' => 2, 'conflicts' => []]);
+
+        $html = $this->render();
+
+        self::assertStringContainsString('2 open booking slots were removed', $html);
+    }
+
+    public function testGarbageClassTimeIsRejected(): void
+    {
+        $_POST = [
+            'usc_action' => 'add',
+            'title'      => 'Choir',
+            'kind'       => Offering::KIND_GROUP_CLASS,
+            'class_time' => 'not-a-time',
+        ];
+
+        $this->repository->shouldReceive('insert')->once()->with(Mockery::on(
+            static fn (Offering $o) => null === $o->classTime
+        ))->andReturn(1);
+        $this->repository->shouldReceive('findAll')->andReturn([]);
+
+        $this->render();
+    }
+
+    public function testStudioAdminAssignsClassToChosenInstructor(): void
+    {
+        $_POST = [
+            'usc_action'          => 'add',
+            'title'               => 'Choir',
+            'kind'                => Offering::KIND_GROUP_CLASS,
+            'class_instructor_id' => '7',
+        ];
+
+        $this->repository->shouldReceive('insert')->once()->with(Mockery::on(
+            static fn (Offering $o) => 7 === $o->instructorId
+        ))->andReturn(1);
+        $this->repository->shouldReceive('findAll')->andReturn([]);
+
+        $this->render();
+    }
+
+    public function testInstructorCannotReassignClassToAnotherInstructor(): void
+    {
+        // A plain instructor (no manage_instructors) — the posted instructor id
+        // must be ignored so the class stays theirs.
+        Functions\when('current_user_can')->alias(
+            static fn (string $cap) => 'manage_instructors' !== $cap
+        );
+
+        $_POST = [
+            'usc_action'          => 'add',
+            'title'               => 'Choir',
+            'kind'                => Offering::KIND_GROUP_CLASS,
+            'class_instructor_id' => '7',
+        ];
+
+        $this->repository->shouldReceive('insert')->once()->with(Mockery::on(
+            static fn (Offering $o) => 3 === $o->instructorId
+        ))->andReturn(1);
+        $this->repository->shouldReceive('findAll')->andReturn([]);
+
+        $this->render();
+    }
+
     public function testAddInviteOnlyGroupClassStoresInviteOnlyAccess(): void
     {
         $_POST = [

tests/Unit/Offering/OfferingEndpointTest.php

@@ -22,6 +22,7 @@ class OfferingEndpointTest extends TestCase
         parent::setUp();
 
         Functions\when('get_current_user_id')->justReturn(5);
+        Functions\when('get_userdata')->justReturn((object) ['display_name' => 'Ada Lovelace']);
 
         $this->repository = Mockery::mock(OfferingRepository::class);
         $this->access     = Mockery::mock(GroupAccessRepository::class);
@@ -88,6 +89,20 @@ class OfferingEndpointTest extends TestCase
         self::assertSame([], $data);
     }
 
+    public function testIndexIncludesInstructorNameForEachOffering(): void
+    {
+        $instructor = Mockery::mock(\WP_User::class);
+        $instructor->display_name = 'Ada Lovelace';
+        Functions\when('get_userdata')->justReturn($instructor);
+
+        $this->repository->shouldReceive('findAll')->andReturn([$this->group(1, Offering::ACCESS_PUBLIC)]);
+        $this->access->shouldReceive('findGrantedOfferingIds')->with(5)->andReturn([]);
+
+        $data = $this->endpoint->index(new \WP_REST_Request())->get_data();
+
+        self::assertSame('Ada Lovelace', $data[0]['instructor_name']);
+    }
+
     public function testIndexOmitsEtransferEmailFromPublicListing(): void
     {
         $this->repository->shouldReceive('findAll')->andReturn([

tests/Unit/Offering/OfferingTest.php

@@ -52,6 +52,82 @@ class OfferingTest extends TestCase
         self::assertSame('2026-09-08', Offering::weeklyTermEnd('2026-09-08', 0));
     }
 
+    public function testNormalizeTimeAcceptsHtmlTimeInput(): void
+    {
+        self::assertSame('16:30:00', Offering::normalizeTime('16:30'));
+        self::assertSame('09:00:00', Offering::normalizeTime('09:00:00'));
+    }
+
+    public function testNormalizeTimeRejectsGarbage(): void
+    {
+        self::assertNull(Offering::normalizeTime(''));
+        self::assertNull(Offering::normalizeTime('25:00'));
+        self::assertNull(Offering::normalizeTime('not-a-time'));
+    }
+
+    public function testSessionWindowsForOneOffClass(): void
+    {
+        $offering = new Offering(
+            instructorId: 3,
+            kind: Offering::KIND_GROUP_CLASS,
+            title: 'Recital',
+            durationMinutes: 90,
+            termStart: '2026-09-08',
+            termEnd: '2026-09-08',
+            classTime: '16:00:00',
+        );
+
+        self::assertSame(
+            [['start' => '2026-09-08 16:00:00', 'end' => '2026-09-08 17:30:00']],
+            $offering->sessionWindows()
+        );
+    }
+
+    public function testSessionWindowsWalksWeeklyTerm(): void
+    {
+        $offering = new Offering(
+            instructorId: 3,
+            kind: Offering::KIND_GROUP_CLASS,
+            title: 'Choir',
+            durationMinutes: 60,
+            termStart: '2026-09-08',
+            termEnd: '2026-09-22',
+            classTime: '16:00:00',
+        );
+
+        $windows = $offering->sessionWindows();
+
+        self::assertCount(3, $windows);
+        self::assertSame('2026-09-08 16:00:00', $windows[0]['start']);
+        self::assertSame('2026-09-22 16:00:00', $windows[2]['start']);
+        self::assertSame('2026-09-22 17:00:00', $windows[2]['end']);
+    }
+
+    public function testSessionWindowsEmptyWhenScheduleIncomplete(): void
+    {
+        // No class time.
+        $noTime = new Offering(
+            instructorId: 3,
+            kind: Offering::KIND_GROUP_CLASS,
+            title: 'Choir',
+            durationMinutes: 60,
+            termStart: '2026-09-08',
+            termEnd: '2026-09-08',
+        );
+        self::assertSame([], $noTime->sessionWindows());
+
+        // No duration.
+        $noDuration = new Offering(
+            instructorId: 3,
+            kind: Offering::KIND_GROUP_CLASS,
+            title: 'Choir',
+            termStart: '2026-09-08',
+            termEnd: '2026-09-08',
+            classTime: '16:00:00',
+        );
+        self::assertSame([], $noDuration->sessionWindows());
+    }
+
     public function testDefaults(): void
     {
         $offering = new Offering(1, Offering::KIND_GROUP_CLASS, 'Choir');