Equitask

Equitask is a full-stack web app for university group assignments that prioritizes fair workload distribution, task effort voting, availability-aware assignment, accountability, and team analytics.

The app now uses Supabase authentication for normal access. Earlier demo-login entry points have been removed, so users sign up or sign in with a real Supabase-backed account.

Project Overview

Equitask solves group-project imbalance by making effort estimation and assignment transparent:

• Story point voting happens before assignment
• Official effort is based on team average votes
• Workload fairness is continuously measured
• Overload and overdue risk are surfaced early
• Analytics shows contribution and progress trends

Key Features

• Landing page with product positioning and CTA flow
• Supabase sign-up and sign-in (email/password)
• Team Hub for creating teams, joining by team code, and switching active team
• Dashboard with summary cards, fairness score, activity feed, notifications, progress chart, and member cards
• Scrum board with status updates, assignment updates, and task creation panel
• Task detail page with voting, comments, assignment recommendations, and activity log
• Dedicated voting center for planning-poker style estimation
• Member profile page with timetable-style weekly availability
• Analytics page with Recharts visualizations
• Settings page for session and account visibility

Tech Stack

• Next.js (App Router)
• TypeScript
• Tailwind CSS
• Next.js server routes (/api/...) for backend logic
• Recharts for analytics
• Supabase integration via service/provider layer
• Vercel-compatible structure (no custom server)

Local Development

1. Install dependencies:

npm install

2. Start development server:

npm run dev

3. Open:

http://localhost:3000

Supabase Auth Required

The public demo login flow has been removed. To use the workspace, configure Supabase and sign in through the normal email/password flow.

The codebase still contains seeded data and a provider abstraction for development history and safe fallback testing, but the website no longer exposes a demo login button, settings switch, sidebar switch, or any demo workspace controls in the UI.

Environment Variables You Must Add Manually

Do not hardcode credentials. Add these yourself in local/Vercel:

• NEXT_PUBLIC_SUPABASE_URL
• NEXT_PUBLIC_SUPABASE_ANON_KEY

No filled .env file is generated by this project.

Supabase Setup

1. Create a Supabase Project

Create a project in Supabase and wait for it to initialize.

2. Enable Email/Password Auth

In Supabase Dashboard:

• Go to Authentication -> Providers
• Enable Email
• Enable Email + Password sign-in
• Optional: disable email confirmation for faster dev testing

3. Add Environment Variables

Add these to your local environment and Vercel project settings:

• NEXT_PUBLIC_SUPABASE_URL
• NEXT_PUBLIC_SUPABASE_ANON_KEY

4. Run SQL in Supabase

• Go to Supabase Dashboard -> SQL Editor
• Create a new query
• Paste the full SQL from the section SQL to Run in Supabase
• Run it

5. Start App and Test Auth

• Start app: npm run dev
• Open /sign-up and create an account
• During sign-up, either create a new team or join with a team code
• Then sign in at /sign-in
• If the user has a team membership, login redirects to /dashboard
• If no team membership exists, login redirects to /teams (Team Hub)
• Workspace, board, voting, and analytics all load from the active team in session

6. Supabase Session Behaviour

• Supabase mode is used when env vars are configured and the user signs in through the Supabase form.
• Team context is saved in session (teamId) so users return to their team workspace directly.
• Demo login and demo switching are no longer exposed in the website.

SQL to Run in Supabase

Paste this entire SQL block into Supabase SQL Editor:

-- Extensions
create extension if not exists pgcrypto;

-- Helper function for updated_at
create or replace function public.set_tasks_updated_at()
returns trigger
language plpgsql
as $$
begin
  new.updated_at = now();
  return new;
end;
$$;

-- Profiles
create table if not exists public.profiles (
  id text primary key,
  name text not null,
  role text not null default 'Student collaborator',
  bio text not null default '',
  preferred_working_style text not null default '',
  availability jsonb not null default '[]'::jsonb,
  reliability_score int not null default 80,
  avatar_color text not null default '#2f6b4f',
  created_at timestamptz not null default now()
);

-- Teams
create table if not exists public.teams (
  id text primary key default ('team-' || gen_random_uuid()::text),
  name text not null,
  project_name text not null,
  created_by text not null references public.profiles(id) on delete restrict,
  created_at timestamptz not null default now()
);

-- Team membership
create table if not exists public.team_members (
  team_id text not null references public.teams(id) on delete cascade,
  profile_id text not null references public.profiles(id) on delete cascade,
  member_role text not null default 'member',
  joined_at timestamptz not null default now(),
  primary key (team_id, profile_id)
);

-- Membership helper for RLS
create or replace function public.is_member_of_team(target_team_id text)
returns boolean
language sql
stable
security definer
set search_path = public
as $$
  select exists (
    select 1
    from public.team_members tm
    where tm.team_id = target_team_id
      and tm.profile_id = auth.uid()::text
  );
$$;

revoke all on function public.is_member_of_team(text) from public;
grant execute on function public.is_member_of_team(text) to authenticated;

-- Tasks
create table if not exists public.tasks (
  id text primary key default ('task-' || gen_random_uuid()::text),
  team_id text not null references public.teams(id) on delete cascade,
  title text not null,
  description text not null default '',
  status text not null check (status in ('backlog', 'todo', 'in_progress', 'review', 'done')),
  priority text not null check (priority in ('low', 'medium', 'high', 'critical')),
  tags text[] not null default '{}',
  due_date date not null,
  assignee_id text references public.profiles(id) on delete set null,
  voting_required boolean not null default true,
  voting_closed boolean not null default false,
  official_story_points numeric(6,2),
  created_by text not null references public.profiles(id) on delete restrict,
  created_at timestamptz not null default now(),
  updated_at timestamptz not null default now()
);

-- Votes
create table if not exists public.task_votes (
  id text primary key default ('vote-' || gen_random_uuid()::text),
  task_id text not null references public.tasks(id) on delete cascade,
  member_id text not null references public.profiles(id) on delete cascade,
  vote_value int not null check (vote_value in (1, 2, 3, 5, 8, 13)),
  created_at timestamptz not null default now(),
  unique (task_id, member_id)
);

-- Comments
create table if not exists public.comments (
  id text primary key default ('comment-' || gen_random_uuid()::text),
  task_id text not null references public.tasks(id) on delete cascade,
  member_id text not null references public.profiles(id) on delete cascade,
  body text not null,
  created_at timestamptz not null default now()
);

-- Notifications
create table if not exists public.notifications (
  id text primary key default ('notif-' || gen_random_uuid()::text),
  team_id text not null references public.teams(id) on delete cascade,
  type text not null check (type in ('vote_needed', 'task_overdue', 'task_assigned', 'member_overloaded', 'vote_disagreement', 'deadline_approaching')),
  message text not null,
  task_id text references public.tasks(id) on delete set null,
  member_id text references public.profiles(id) on delete set null,
  is_read boolean not null default false,
  severity text not null check (severity in ('info', 'warning', 'critical')),
  created_at timestamptz not null default now()
);

-- Indexes
create index if not exists idx_team_members_profile on public.team_members(profile_id);
create index if not exists idx_tasks_team_status on public.tasks(team_id, status);
create index if not exists idx_tasks_assignee on public.tasks(assignee_id);
create index if not exists idx_tasks_due_date on public.tasks(due_date);
create index if not exists idx_votes_task on public.task_votes(task_id);
create index if not exists idx_comments_task on public.comments(task_id);
create index if not exists idx_notifications_team_created on public.notifications(team_id, created_at desc);

-- Trigger
drop trigger if exists trg_tasks_updated_at on public.tasks;
create trigger trg_tasks_updated_at
before update on public.tasks
for each row
execute function public.set_tasks_updated_at();

-- RLS
alter table public.profiles enable row level security;
alter table public.teams enable row level security;
alter table public.team_members enable row level security;
alter table public.tasks enable row level security;
alter table public.task_votes enable row level security;
alter table public.comments enable row level security;
alter table public.notifications enable row level security;

-- Profiles policies (intentionally permissive for team-seeding workflow)
drop policy if exists profiles_select_authenticated on public.profiles;
create policy profiles_select_authenticated
on public.profiles
for select
using (auth.role() = 'authenticated');

drop policy if exists profiles_insert_authenticated on public.profiles;
create policy profiles_insert_authenticated
on public.profiles
for insert
with check (auth.role() = 'authenticated');

drop policy if exists profiles_update_authenticated on public.profiles;
create policy profiles_update_authenticated
on public.profiles
for update
using (auth.role() = 'authenticated')
with check (auth.role() = 'authenticated');

-- Teams policies
drop policy if exists teams_select_member on public.teams;
create policy teams_select_member
on public.teams
for select
using (public.is_member_of_team(id) or created_by = auth.uid()::text);

drop policy if exists teams_insert_owner on public.teams;
create policy teams_insert_owner
on public.teams
for insert
with check (created_by = auth.uid()::text);

drop policy if exists teams_update_member on public.teams;
create policy teams_update_member
on public.teams
for update
using (public.is_member_of_team(id))
with check (public.is_member_of_team(id));

-- Team member policies
drop policy if exists team_members_select_member on public.team_members;
create policy team_members_select_member
on public.team_members
for select
using (
  profile_id = auth.uid()::text
  or exists (
    select 1
    from public.teams t
    where t.id = team_id
      and t.created_by = auth.uid()::text
  )
);

drop policy if exists team_members_insert_member on public.team_members;
create policy team_members_insert_member
on public.team_members
for insert
with check (
  profile_id = auth.uid()::text
  or exists (
    select 1
    from public.teams t
    where t.id = team_id
      and t.created_by = auth.uid()::text
  )
);

drop policy if exists team_members_update_member on public.team_members;
create policy team_members_update_member
on public.team_members
for update
using (
  exists (
    select 1
    from public.teams t
    where t.id = team_id
      and t.created_by = auth.uid()::text
  )
)
with check (
  exists (
    select 1
    from public.teams t
    where t.id = team_id
      and t.created_by = auth.uid()::text
  )
);

-- Tasks policies
drop policy if exists tasks_select_member on public.tasks;
create policy tasks_select_member
on public.tasks
for select
using (public.is_member_of_team(team_id));

drop policy if exists tasks_insert_member on public.tasks;
create policy tasks_insert_member
on public.tasks
for insert
with check (public.is_member_of_team(team_id));

drop policy if exists tasks_update_member on public.tasks;
create policy tasks_update_member
on public.tasks
for update
using (public.is_member_of_team(team_id))
with check (public.is_member_of_team(team_id));

drop policy if exists tasks_delete_member on public.tasks;
create policy tasks_delete_member
on public.tasks
for delete
using (public.is_member_of_team(team_id));

-- Votes policies
drop policy if exists votes_select_member on public.task_votes;
create policy votes_select_member
on public.task_votes
for select
using (
  exists (
    select 1
    from public.tasks t
    where t.id = task_id
      and public.is_member_of_team(t.team_id)
  )
);

drop policy if exists votes_insert_member on public.task_votes;
create policy votes_insert_member
on public.task_votes
for insert
with check (
  exists (
    select 1
    from public.tasks t
    where t.id = task_id
      and public.is_member_of_team(t.team_id)
  )
);

drop policy if exists votes_update_member on public.task_votes;
create policy votes_update_member
on public.task_votes
for update
using (
  exists (
    select 1
    from public.tasks t
    where t.id = task_id
      and public.is_member_of_team(t.team_id)
  )
)
with check (
  exists (
    select 1
    from public.tasks t
    where t.id = task_id
      and public.is_member_of_team(t.team_id)
  )
);

-- Comments policies
drop policy if exists comments_select_member on public.comments;
create policy comments_select_member
on public.comments
for select
using (
  exists (
    select 1
    from public.tasks t
    where t.id = task_id
      and public.is_member_of_team(t.team_id)
  )
);

drop policy if exists comments_insert_member on public.comments;
create policy comments_insert_member
on public.comments
for insert
with check (
  exists (
    select 1
    from public.tasks t
    where t.id = task_id
      and public.is_member_of_team(t.team_id)
  )
);

-- Notifications policies
drop policy if exists notifications_select_member on public.notifications;
create policy notifications_select_member
on public.notifications
for select
using (public.is_member_of_team(team_id));

drop policy if exists notifications_insert_member on public.notifications;
create policy notifications_insert_member
on public.notifications
for insert
with check (public.is_member_of_team(team_id));

drop policy if exists notifications_update_member on public.notifications;
create policy notifications_update_member
on public.notifications
for update
using (public.is_member_of_team(team_id))
with check (public.is_member_of_team(team_id));

Storage Bucket Requirement

No storage bucket is required for the current app features.

How to Test Sign Up and Sign In After Supabase Setup

1. Confirm env vars are set and app restarted.
2. Open /sign-up and create a user.
3. At sign-up, choose:
   • create a new team, or
   • join with a team code (team-... id shared by teammate).
4. Open /sign-in and authenticate.
5. Verify:
   • members with a team go to /dashboard
   • users without a membership go to /teams.
6. In /board, create a new task with title/description/due date.
7. Vote on the task in /voting or task detail, then assign after voting closes.
8. Refresh and confirm persisted state remains.

App Structure

src/
  app/
    (auth)/
    (workspace)/
    teams/
    api/
      teams/
  components/
    teams/
  data/
    providers/
    seed/
  lib/
  services/
  types/

Seeded Data Provider

• The repository still includes seeded data and demoProvider for development history and provider abstraction.
• Public demo login has been removed from the website.
• Workspace access now requires a Supabase-backed session.

Supabase Mode Architecture

• Session mode: supabase
• Session stores active team context (teamId, team/project metadata)
• Data source: Supabase provider (supabaseProvider)
• Auth: Supabase email/password through API routes
• Team Hub supports create/join/switch workflows
• Workspace reads/writes through provider abstraction

Data Abstraction and Service Layer

The app uses:

• Provider layer:
  • demoProvider
  • supabaseProvider
• Service layer:
  • authService
  • taskService
  • voteService
  • memberService
  • analyticsService
  • fairnessService
  • notificationService
  • teamService
  • workspaceService

This avoids business-logic duplication. The live website now uses Supabase-backed data for normal user access.

Fairness Score Logic

Fairness score (0-100) is calculated from:

• Balance of assigned story points
• Balance of completed story points
• Overdue task penalty
• Voting compliance before assignment
• Overload penalty when one member carries too much active effort

The score and breakdown are visible in dashboard and analytics.

Voting Logic

• Team members vote using 1, 2, 3, 5, 8, 13
• Votes are stored per task/member
• Average vote is computed
• When all members vote, task voting closes and average becomes official story points
• Disagreement range (max - min) is surfaced
• Strong disagreement warnings appear when range is high

Deploy to Vercel

1. Push repository to GitHub (you handle Git operations).
2. Import project in Vercel.
3. Add environment variables:
   • NEXT_PUBLIC_SUPABASE_URL
   • NEXT_PUBLIC_SUPABASE_ANON_KEY
4. Deploy.

No custom Node server is required; app uses standard Next.js conventions.

Troubleshooting

Supabase sign-in fails with invalid login

• Verify email/password provider is enabled.
• If email confirmation is enabled, confirm user email first.

App redirects back to sign-in

• Ensure env vars are set and app restarted.
• Use /sign-in or /sign-up to create a Supabase session.
• Old browser cookies from the removed demo flow should be replaced by signing in again.

SQL errors on policy creation

• Run SQL in order as provided.
• Ensure tables/functions exist before policies.

Empty analytics in Supabase mode

• Create/sign in user first.
• Ensure user has joined or created a team (/teams).
• Create tasks in /board and submit votes so charts have dataset to render.

401 responses from API routes

• Session cookie may be missing/expired.
• Sign in again via /sign-in.

Redirected to /teams after sign-in

• The authenticated user has no row in team_members.
• Create a team in Team Hub or join using a valid team code.
• Team code is the teams.id value (format starts with team-).