Add Offerings domain and studio-admin capabilities

Implements the offerings catalog (#1): private-lesson types and group
classes carrying pricing, billing mode (one_time/full_term), duration,
capacity, and term details. Adds the src/Offering/ domain (value object,
repository, REST endpoint, admin controller + template), the us_offerings
table, and an Offerings admin page.

Also lands the capability slice of #9: registers the us_studio_admin role
and the new capability strings (manage_instructors, manage_offerings,
manage_questions, manage_policies, manage_billing, view_all_payments,
view_own_payments, export_payments) so offering management gates correctly.

Tests: tests/Unit/Offering/ (value object + repository) and a studio-admin
case in RoleManagerTest. composer test, cs, and PHPStan level 6 all pass.

Refs #1 #9

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

tests/Unit/Auth/RoleManagerTest.php

@@ -47,6 +47,30 @@ class RoleManagerTest extends TestCase
         (new RoleManager())->createRoles();
     }
 
+    public function testCreateRolesAddsStudioAdminRoleWithCorrectCaps(): void
+    {
+        Functions\when('get_role')->alias(static function (string $role): ?object {
+            return $role === RoleManager::STUDIO_ADMIN ? null : new \stdClass();
+        });
+
+        Functions\expect('add_role')
+            ->once()
+            ->with(
+                RoleManager::STUDIO_ADMIN,
+                \Mockery::any(),
+                \Mockery::on(static function (array $caps): bool {
+                    return ($caps['read'] ?? false) === true
+                        && ($caps[RoleManager::CAP_MANAGE_INSTRUCTORS] ?? false) === true
+                        && ($caps[RoleManager::CAP_MANAGE_OFFERINGS] ?? false) === true
+                        && ($caps[RoleManager::CAP_MANAGE_POLICIES] ?? false) === true
+                        && ($caps[RoleManager::CAP_MANAGE_BILLING] ?? false) === true
+                        && ($caps[RoleManager::CAP_VIEW_ALL_PAYMENTS] ?? false) === true;
+                })
+            );
+
+        (new RoleManager())->createRoles();
+    }
+
     public function testCreateRolesAddsStudentRoleWithCorrectCaps(): void
     {
         Functions\when('get_role')->alias(static function (string $role): ?object {

tests/Unit/Offering/OfferingRepositoryTest.php

@@ -0,0 +1,182 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Tests\Unit\Offering;
+
+use Brain\Monkey\Functions;
+use Mockery;
+use Unsupervised\Schedular\Offering\Offering;
+use Unsupervised\Schedular\Offering\OfferingRepository;
+use Unsupervised\Schedular\Tests\Unit\TestCase;
+
+class OfferingRepositoryTest extends TestCase
+{
+    private \wpdb $db;
+    private OfferingRepository $repo;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->db         = Mockery::mock(\wpdb::class);
+        $this->db->prefix = 'wp_';
+        $this->repo       = new OfferingRepository($this->db);
+    }
+
+    public function testInsertCallsWpdbInsertAndReturnsId(): void
+    {
+        Functions\expect('current_time')->with('mysql')->andReturn('2026-04-01 12:00:00');
+
+        $this->db->shouldReceive('insert')
+            ->once()
+            ->with(
+                'wp_us_offerings',
+                Mockery::on(static function (array $data): bool {
+                    return $data['instructor_id'] === 5
+                        && $data['kind'] === Offering::KIND_PRIVATE_LESSON
+                        && $data['title'] === '30-min Piano'
+                        && $data['price_cents'] === 3500
+                        && $data['allow_weekly'] === 0
+                        && $data['is_active'] === 1
+                        && $data['created_at'] === '2026-04-01 12:00:00';
+                }),
+                Mockery::type('array')
+            );
+
+        $this->db->insert_id = 42;
+
+        $offering = new Offering(
+            instructorId:    5,
+            kind:            Offering::KIND_PRIVATE_LESSON,
+            title:           '30-min Piano',
+            priceCents:      3500,
+            durationMinutes: 30,
+        );
+
+        self::assertSame(42, $this->repo->insert($offering));
+    }
+
+    public function testUpdateReturnsTrueOnSuccess(): void
+    {
+        $this->db->shouldReceive('update')
+            ->once()
+            ->with(
+                'wp_us_offerings',
+                Mockery::on(static fn (array $data): bool => $data['title'] === 'Renamed' && $data['allow_weekly'] === 1),
+                ['id' => 7],
+                Mockery::type('array'),
+                ['%d']
+            )
+            ->andReturn(1);
+
+        $offering = new Offering(
+            instructorId: 5,
+            kind:         Offering::KIND_PRIVATE_LESSON,
+            title:        'Renamed',
+            allowWeekly:  true,
+            id:           7,
+        );
+
+        self::assertTrue($this->repo->update(7, $offering));
+    }
+
+    public function testUpdateReturnsFalseWhenWpdbReturnsFalse(): void
+    {
+        $this->db->shouldReceive('update')->once()->andReturn(false);
+
+        $offering = new Offering(5, Offering::KIND_GROUP_CLASS, 'Choir', id: 9);
+
+        self::assertFalse($this->repo->update(9, $offering));
+    }
+
+    public function testFindByIdReturnsNullWhenNotFound(): void
+    {
+        $this->db->shouldReceive('prepare')->once()->andReturn('SELECT ...');
+        $this->db->shouldReceive('get_row')->once()->andReturn(null);
+
+        self::assertNull($this->repo->findById(99));
+    }
+
+    public function testFindByIdReturnsOfferingWhenFound(): void
+    {
+        $this->db->shouldReceive('prepare')->andReturn('SELECT ...');
+        $this->db->shouldReceive('get_row')->andReturn($this->sampleRow());
+
+        $offering = $this->repo->findById(10);
+
+        self::assertInstanceOf(Offering::class, $offering);
+        self::assertSame(10, $offering->id);
+        self::assertSame(3, $offering->instructorId);
+    }
+
+    public function testFindAllWithNoFiltersUsesNoParams(): void
+    {
+        $this->db->shouldReceive('get_results')
+            ->once()
+            ->with(Mockery::pattern('/WHERE 1 = 1/'))
+            ->andReturn([$this->sampleRow()]);
+
+        $offerings = $this->repo->findAll();
+
+        self::assertCount(1, $offerings);
+        self::assertInstanceOf(Offering::class, $offerings[0]);
+    }
+
+    public function testFindAllActiveOnlyPreparesQuery(): void
+    {
+        $this->db->shouldReceive('prepare')
+            ->once()
+            ->with(Mockery::pattern('/is_active = %d/'), Mockery::on(static fn (array $p): bool => $p === [1]))
+            ->andReturn('SELECT ...');
+
+        $this->db->shouldReceive('get_results')->andReturn([]);
+
+        self::assertSame([], $this->repo->findAll(activeOnly: true));
+    }
+
+    public function testFindAllWithInstructorAndKindFilters(): void
+    {
+        $this->db->shouldReceive('prepare')
+            ->once()
+            ->with(
+                Mockery::pattern('/instructor_id = %d AND kind = %s/'),
+                Mockery::on(static fn (array $p): bool => $p === [3, Offering::KIND_GROUP_CLASS])
+            )
+            ->andReturn('SELECT ...');
+
+        $this->db->shouldReceive('get_results')->andReturn([]);
+
+        $this->repo->findAll(3, Offering::KIND_GROUP_CLASS);
+    }
+
+    public function testDeleteCallsWpdbDelete(): void
+    {
+        $this->db->shouldReceive('delete')
+            ->once()
+            ->with('wp_us_offerings', ['id' => 4], ['%d'])
+            ->andReturn(1);
+
+        self::assertTrue($this->repo->delete(4));
+    }
+
+    private function sampleRow(): object
+    {
+        return (object) [
+            'id'               => '10',
+            'instructor_id'    => '3',
+            'kind'             => Offering::KIND_PRIVATE_LESSON,
+            'title'            => '30-min Piano',
+            'description'      => null,
+            'duration_minutes' => '30',
+            'price_cents'      => '3500',
+            'currency'         => 'CAD',
+            'billing_mode'     => Offering::BILLING_ONE_TIME,
+            'allow_weekly'     => '0',
+            'capacity'         => null,
+            'term_start'       => null,
+            'term_end'         => null,
+            'schedule_note'    => null,
+            'is_active'        => '1',
+        ];
+    }
+}

tests/Unit/Offering/OfferingTest.php

@@ -0,0 +1,93 @@
+<?php
+declare(strict_types=1);
+
+namespace Unsupervised\Schedular\Tests\Unit\Offering;
+
+use Unsupervised\Schedular\Offering\Offering;
+use Unsupervised\Schedular\Tests\Unit\TestCase;
+
+class OfferingTest extends TestCase
+{
+    public function testConstructorAndProperties(): void
+    {
+        $offering = new Offering(
+            instructorId:    5,
+            kind:            Offering::KIND_PRIVATE_LESSON,
+            title:           '30-min Piano',
+            priceCents:      3500,
+            billingMode:     Offering::BILLING_ONE_TIME,
+            durationMinutes: 30,
+            id:              42,
+        );
+
+        self::assertSame(5, $offering->instructorId);
+        self::assertSame(Offering::KIND_PRIVATE_LESSON, $offering->kind);
+        self::assertSame('30-min Piano', $offering->title);
+        self::assertSame(3500, $offering->priceCents);
+        self::assertSame(30, $offering->durationMinutes);
+        self::assertSame(42, $offering->id);
+    }
+
+    public function testDefaults(): void
+    {
+        $offering = new Offering(1, Offering::KIND_GROUP_CLASS, 'Choir');
+
+        self::assertSame(0, $offering->priceCents);
+        self::assertSame('CAD', $offering->currency);
+        self::assertSame(Offering::BILLING_ONE_TIME, $offering->billingMode);
+        self::assertNull($offering->durationMinutes);
+        self::assertFalse($offering->allowWeekly);
+        self::assertNull($offering->capacity);
+        self::assertTrue($offering->isActive);
+        self::assertNull($offering->id);
+    }
+
+    public function testFromRowMapsCorrectlyAndCastsNullables(): void
+    {
+        $row = (object) [
+            'id'               => '7',
+            'instructor_id'    => '3',
+            'kind'             => Offering::KIND_GROUP_CLASS,
+            'title'            => 'Year Choir',
+            'description'      => 'Weekly choir',
+            'duration_minutes' => null,
+            'price_cents'      => '12000',
+            'currency'         => 'CAD',
+            'billing_mode'     => Offering::BILLING_FULL_TERM,
+            'allow_weekly'     => '0',
+            'capacity'         => '20',
+            'term_start'       => '2026-09-01',
+            'term_end'         => '2027-06-30',
+            'schedule_note'    => 'Tuesdays 4:00pm',
+            'is_active'        => '1',
+        ];
+
+        $offering = Offering::fromRow($row);
+
+        self::assertSame(7, $offering->id);
+        self::assertSame(3, $offering->instructorId);
+        self::assertNull($offering->durationMinutes);
+        self::assertSame(12000, $offering->priceCents);
+        self::assertSame(20, $offering->capacity);
+        self::assertSame(Offering::BILLING_FULL_TERM, $offering->billingMode);
+        self::assertTrue($offering->isActive);
+    }
+
+    public function testToArrayContainsExpectedKeys(): void
+    {
+        $offering = new Offering(1, Offering::KIND_PRIVATE_LESSON, 'Lesson', id: 10);
+        $arr      = $offering->toArray();
+
+        foreach (['id', 'instructor_id', 'kind', 'title', 'price_cents', 'billing_mode', 'is_active'] as $key) {
+            self::assertArrayHasKey($key, $arr);
+        }
+    }
+
+    public function testValidKindAndBillingConstants(): void
+    {
+        self::assertContains(Offering::KIND_PRIVATE_LESSON, Offering::VALID_KINDS);
+        self::assertContains(Offering::KIND_GROUP_CLASS, Offering::VALID_KINDS);
+        self::assertContains(Offering::BILLING_ONE_TIME, Offering::VALID_BILLING_MODES);
+        self::assertContains(Offering::BILLING_FULL_TERM, Offering::VALID_BILLING_MODES);
+    }
+}