169 lines
9.9 KiB
SQL
169 lines
9.9 KiB
SQL
/*
|
|
* -------------------------------------------------------
|
|
* Course Management Schema
|
|
* Phase 5: courses, sessions, categories, participants,
|
|
* instructors, locations, attendance
|
|
* -------------------------------------------------------
|
|
*/
|
|
|
|
create type public.enrollment_status as enum(
|
|
'enrolled', 'waitlisted', 'cancelled', 'completed'
|
|
);
|
|
|
|
-- Course categories (hierarchical)
|
|
create table if not exists public.course_categories (
|
|
id uuid primary key default gen_random_uuid(),
|
|
account_id uuid not null references public.accounts(id) on delete cascade,
|
|
parent_id uuid references public.course_categories(id) on delete set null,
|
|
name text not null,
|
|
description text,
|
|
sort_order integer not null default 0,
|
|
created_at timestamptz not null default now()
|
|
);
|
|
create index ix_course_categories_account on public.course_categories(account_id);
|
|
alter table public.course_categories enable row level security;
|
|
revoke all on public.course_categories from authenticated, service_role;
|
|
grant select, insert, update, delete on public.course_categories to authenticated;
|
|
grant all on public.course_categories to service_role;
|
|
create policy course_categories_select on public.course_categories for select to authenticated using (public.has_role_on_account(account_id));
|
|
create policy course_categories_mutate on public.course_categories for all to authenticated using (public.has_permission(auth.uid(), account_id, 'courses.write'::public.app_permissions));
|
|
|
|
-- Locations
|
|
create table if not exists public.course_locations (
|
|
id uuid primary key default gen_random_uuid(),
|
|
account_id uuid not null references public.accounts(id) on delete cascade,
|
|
name text not null,
|
|
address text,
|
|
room text,
|
|
capacity integer,
|
|
notes text,
|
|
created_at timestamptz not null default now()
|
|
);
|
|
create index ix_course_locations_account on public.course_locations(account_id);
|
|
alter table public.course_locations enable row level security;
|
|
revoke all on public.course_locations from authenticated, service_role;
|
|
grant select, insert, update, delete on public.course_locations to authenticated;
|
|
grant all on public.course_locations to service_role;
|
|
create policy course_locations_select on public.course_locations for select to authenticated using (public.has_role_on_account(account_id));
|
|
create policy course_locations_mutate on public.course_locations for all to authenticated using (public.has_permission(auth.uid(), account_id, 'courses.write'::public.app_permissions));
|
|
|
|
-- Instructors
|
|
create table if not exists public.course_instructors (
|
|
id uuid primary key default gen_random_uuid(),
|
|
account_id uuid not null references public.accounts(id) on delete cascade,
|
|
first_name text not null,
|
|
last_name text not null,
|
|
email text,
|
|
phone text,
|
|
qualifications text,
|
|
hourly_rate numeric(10,2),
|
|
notes text,
|
|
created_at timestamptz not null default now()
|
|
);
|
|
create index ix_course_instructors_account on public.course_instructors(account_id);
|
|
alter table public.course_instructors enable row level security;
|
|
revoke all on public.course_instructors from authenticated, service_role;
|
|
grant select, insert, update, delete on public.course_instructors to authenticated;
|
|
grant all on public.course_instructors to service_role;
|
|
create policy course_instructors_select on public.course_instructors for select to authenticated using (public.has_role_on_account(account_id));
|
|
create policy course_instructors_mutate on public.course_instructors for all to authenticated using (public.has_permission(auth.uid(), account_id, 'courses.write'::public.app_permissions));
|
|
|
|
-- Courses
|
|
create table if not exists public.courses (
|
|
id uuid primary key default gen_random_uuid(),
|
|
account_id uuid not null references public.accounts(id) on delete cascade,
|
|
course_number text,
|
|
name text not null,
|
|
description text,
|
|
category_id uuid references public.course_categories(id) on delete set null,
|
|
instructor_id uuid references public.course_instructors(id) on delete set null,
|
|
location_id uuid references public.course_locations(id) on delete set null,
|
|
start_date date,
|
|
end_date date,
|
|
fee numeric(10,2) not null default 0,
|
|
reduced_fee numeric(10,2),
|
|
capacity integer not null default 20,
|
|
min_participants integer default 5,
|
|
status text not null default 'planned' check (status in ('planned', 'open', 'running', 'completed', 'cancelled')),
|
|
registration_deadline date,
|
|
notes text,
|
|
custom_data jsonb not null default '{}'::jsonb,
|
|
created_at timestamptz not null default now(),
|
|
updated_at timestamptz not null default now()
|
|
);
|
|
create index ix_courses_account on public.courses(account_id);
|
|
create index ix_courses_status on public.courses(account_id, status);
|
|
create index ix_courses_dates on public.courses(account_id, start_date, end_date);
|
|
alter table public.courses enable row level security;
|
|
revoke all on public.courses from authenticated, service_role;
|
|
grant select, insert, update, delete on public.courses to authenticated;
|
|
grant all on public.courses to service_role;
|
|
create policy courses_select on public.courses for select to authenticated using (public.has_role_on_account(account_id));
|
|
create policy courses_insert on public.courses for insert to authenticated with check (public.has_permission(auth.uid(), account_id, 'courses.write'::public.app_permissions));
|
|
create policy courses_update on public.courses for update to authenticated using (public.has_permission(auth.uid(), account_id, 'courses.write'::public.app_permissions));
|
|
create policy courses_delete on public.courses for delete to authenticated using (public.has_permission(auth.uid(), account_id, 'courses.write'::public.app_permissions));
|
|
create trigger trg_courses_updated_at before update on public.courses for each row execute function public.update_account_settings_timestamp();
|
|
|
|
-- Course sessions (individual dates/times)
|
|
create table if not exists public.course_sessions (
|
|
id uuid primary key default gen_random_uuid(),
|
|
course_id uuid not null references public.courses(id) on delete cascade,
|
|
session_date date not null,
|
|
start_time time not null,
|
|
end_time time not null,
|
|
location_id uuid references public.course_locations(id) on delete set null,
|
|
notes text,
|
|
is_cancelled boolean not null default false,
|
|
created_at timestamptz not null default now()
|
|
);
|
|
create index ix_course_sessions_course on public.course_sessions(course_id);
|
|
create index ix_course_sessions_date on public.course_sessions(session_date);
|
|
alter table public.course_sessions enable row level security;
|
|
revoke all on public.course_sessions from authenticated, service_role;
|
|
grant select, insert, update, delete on public.course_sessions to authenticated;
|
|
grant all on public.course_sessions to service_role;
|
|
create policy course_sessions_select on public.course_sessions for select to authenticated using (exists (select 1 from public.courses c where c.id = course_sessions.course_id and public.has_role_on_account(c.account_id)));
|
|
create policy course_sessions_mutate on public.course_sessions for all to authenticated using (exists (select 1 from public.courses c where c.id = course_sessions.course_id and public.has_permission(auth.uid(), c.account_id, 'courses.write'::public.app_permissions)));
|
|
|
|
-- Course participants (enrollments)
|
|
create table if not exists public.course_participants (
|
|
id uuid primary key default gen_random_uuid(),
|
|
course_id uuid not null references public.courses(id) on delete cascade,
|
|
member_id uuid references public.members(id) on delete set null,
|
|
first_name text not null,
|
|
last_name text not null,
|
|
email text,
|
|
phone text,
|
|
status public.enrollment_status not null default 'enrolled',
|
|
enrolled_at timestamptz not null default now(),
|
|
cancelled_at timestamptz,
|
|
fee_paid numeric(10,2) default 0,
|
|
notes text,
|
|
unique(course_id, member_id)
|
|
);
|
|
create index ix_course_participants_course on public.course_participants(course_id);
|
|
create index ix_course_participants_member on public.course_participants(member_id);
|
|
alter table public.course_participants enable row level security;
|
|
revoke all on public.course_participants from authenticated, service_role;
|
|
grant select, insert, update, delete on public.course_participants to authenticated;
|
|
grant all on public.course_participants to service_role;
|
|
create policy course_participants_select on public.course_participants for select to authenticated using (exists (select 1 from public.courses c where c.id = course_participants.course_id and public.has_role_on_account(c.account_id)));
|
|
create policy course_participants_mutate on public.course_participants for all to authenticated using (exists (select 1 from public.courses c where c.id = course_participants.course_id and public.has_permission(auth.uid(), c.account_id, 'courses.write'::public.app_permissions)));
|
|
|
|
-- Attendance
|
|
create table if not exists public.course_attendance (
|
|
id uuid primary key default gen_random_uuid(),
|
|
session_id uuid not null references public.course_sessions(id) on delete cascade,
|
|
participant_id uuid not null references public.course_participants(id) on delete cascade,
|
|
present boolean not null default false,
|
|
notes text,
|
|
unique(session_id, participant_id)
|
|
);
|
|
create index ix_course_attendance_session on public.course_attendance(session_id);
|
|
alter table public.course_attendance enable row level security;
|
|
revoke all on public.course_attendance from authenticated, service_role;
|
|
grant select, insert, update, delete on public.course_attendance to authenticated;
|
|
grant all on public.course_attendance to service_role;
|
|
create policy course_attendance_select on public.course_attendance for select to authenticated using (exists (select 1 from public.course_sessions s join public.courses c on c.id = s.course_id where s.id = course_attendance.session_id and public.has_role_on_account(c.account_id)));
|
|
create policy course_attendance_mutate on public.course_attendance for all to authenticated using (exists (select 1 from public.course_sessions s join public.courses c on c.id = s.course_id where s.id = course_attendance.session_id and public.has_permission(auth.uid(), c.account_id, 'courses.write'::public.app_permissions)));
|