feat: introduce Teams & OKRs feature with models, types, and UI components for team management and objective tracking

src/app/api/okrs/[id]/key-results/[krId]/route.ts

@@ -0,0 +1,59 @@
+import { NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { updateKeyResult } from '@/services/okrs';
+import { getOKR } from '@/services/okrs';
+import { isTeamMember, isTeamAdmin } from '@/services/teams';
+
+export async function PATCH(
+  request: Request,
+  { params }: { params: Promise<{ id: string; krId: string }> }
+) {
+  try {
+    const { id, krId } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Get OKR to check permissions
+    const okr = await getOKR(id);
+    if (!okr) {
+      return NextResponse.json({ error: 'OKR non trouvé' }, { status: 404 });
+    }
+
+    // Check if user is a member of the team
+    const isMember = await isTeamMember(okr.teamMember.team.id, session.user.id);
+    if (!isMember) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    // Check if user is admin or the concerned member
+    const isAdmin = await isTeamAdmin(okr.teamMember.team.id, session.user.id);
+    const isConcernedMember = okr.teamMember.userId === session.user.id;
+
+    if (!isAdmin && !isConcernedMember) {
+      return NextResponse.json(
+        { error: 'Seuls les administrateurs et le membre concerné peuvent mettre à jour les Key Results' },
+        { status: 403 }
+      );
+    }
+
+    const body = await request.json();
+    const { currentValue, notes } = body;
+
+    if (currentValue === undefined) {
+      return NextResponse.json({ error: 'Valeur actuelle requise' }, { status: 400 });
+    }
+
+    const updated = await updateKeyResult(krId, Number(currentValue), notes || null);
+
+    return NextResponse.json(updated);
+  } catch (error: any) {
+    console.error('Error updating key result:', error);
+    return NextResponse.json(
+      { error: error.message || 'Erreur lors de la mise à jour du Key Result' },
+      { status: 500 }
+    );
+  }
+}

src/app/api/okrs/[id]/route.ts

@@ -0,0 +1,111 @@
+import { NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { getOKR, updateOKR, deleteOKR } from '@/services/okrs';
+import { isTeamMember, isTeamAdmin } from '@/services/teams';
+import type { UpdateOKRInput } from '@/lib/types';
+
+export async function GET(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    const okr = await getOKR(id);
+
+    if (!okr) {
+      return NextResponse.json({ error: 'OKR non trouvé' }, { status: 404 });
+    }
+
+    // Check if user is a member of the team
+    const isMember = await isTeamMember(okr.teamMember.team.id, session.user.id);
+    if (!isMember) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json(okr);
+  } catch (error) {
+    console.error('Error fetching OKR:', error);
+    return NextResponse.json(
+      { error: 'Erreur lors de la récupération de l\'OKR' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PATCH(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    const okr = await getOKR(id);
+    if (!okr) {
+      return NextResponse.json({ error: 'OKR non trouvé' }, { status: 404 });
+    }
+
+    // Check if user is admin of the team
+    const isAdmin = await isTeamAdmin(okr.teamMember.team.id, session.user.id);
+    if (!isAdmin) {
+      return NextResponse.json({ error: 'Seuls les administrateurs peuvent modifier les OKRs' }, { status: 403 });
+    }
+
+    const body: UpdateOKRInput & { startDate?: string; endDate?: string } = await request.json();
+    
+    // Convert date strings to Date objects if provided
+    const updateData: UpdateOKRInput = { ...body };
+    if (body.startDate) {
+      updateData.startDate = new Date(body.startDate);
+    }
+    if (body.endDate) {
+      updateData.endDate = new Date(body.endDate);
+    }
+
+    const updated = await updateOKR(id, updateData);
+
+    return NextResponse.json(updated);
+  } catch (error: any) {
+    console.error('Error updating OKR:', error);
+    return NextResponse.json(
+      { error: error.message || 'Erreur lors de la mise à jour de l\'OKR' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    const okr = await getOKR(id);
+    if (!okr) {
+      return NextResponse.json({ error: 'OKR non trouvé' }, { status: 404 });
+    }
+
+    // Check if user is admin of the team
+    const isAdmin = await isTeamAdmin(okr.teamMember.team.id, session.user.id);
+    if (!isAdmin) {
+      return NextResponse.json({ error: 'Seuls les administrateurs peuvent supprimer les OKRs' }, { status: 403 });
+    }
+
+    await deleteOKR(id);
+
+    return NextResponse.json({ success: true });
+  } catch (error: any) {
+    console.error('Error deleting OKR:', error);
+    return NextResponse.json(
+      { error: error.message || 'Erreur lors de la suppression de l\'OKR' },
+      { status: 500 }
+    );
+  }
+}

src/app/api/okrs/route.ts

@@ -0,0 +1,74 @@
+import { NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { createOKR } from '@/services/okrs';
+import { getTeamMemberById, isTeamAdmin } from '@/services/teams';
+import type { CreateOKRInput, CreateKeyResultInput } from '@/lib/types';
+
+export async function POST(request: Request) {
+  try {
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    const body = await request.json();
+    const { teamMemberId, objective, description, period, startDate, endDate, keyResults } =
+      body as CreateOKRInput & {
+        startDate: string | Date;
+        endDate: string | Date;
+      };
+
+    if (!teamMemberId || !objective || !period || !startDate || !endDate || !keyResults) {
+      return NextResponse.json({ error: 'Champs requis manquants' }, { status: 400 });
+    }
+
+    // Get team member to check permissions
+    const teamMember = await getTeamMemberById(teamMemberId);
+    if (!teamMember) {
+      return NextResponse.json({ error: "Membre de l'équipe non trouvé" }, { status: 404 });
+    }
+
+    // Check if user is admin of the team
+    const isAdmin = await isTeamAdmin(teamMember.team.id, session.user.id);
+    if (!isAdmin) {
+      return NextResponse.json(
+        { error: 'Seuls les administrateurs peuvent créer des OKRs' },
+        { status: 403 }
+      );
+    }
+
+    // Convert dates to Date objects if they are strings
+    const startDateObj = startDate instanceof Date ? startDate : new Date(startDate);
+    const endDateObj = endDate instanceof Date ? endDate : new Date(endDate);
+
+    // Validate dates
+    if (isNaN(startDateObj.getTime()) || isNaN(endDateObj.getTime())) {
+      return NextResponse.json({ error: 'Dates invalides' }, { status: 400 });
+    }
+
+    // Ensure all key results have a unit and order
+    const keyResultsWithUnit = keyResults.map((kr: CreateKeyResultInput, index: number) => ({
+      ...kr,
+      unit: kr.unit || '%',
+      order: kr.order !== undefined ? kr.order : index,
+    }));
+
+    const okr = await createOKR(
+      teamMemberId,
+      objective,
+      description || null,
+      period,
+      startDateObj,
+      endDateObj,
+      keyResultsWithUnit
+    );
+
+    return NextResponse.json(okr, { status: 201 });
+  } catch (error) {
+    console.error('Error creating OKR:', error);
+    const errorMessage =
+      error instanceof Error ? error.message : "Erreur lors de la création de l'OKR";
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}

src/app/api/teams/[id]/members/route.ts

@@ -0,0 +1,107 @@
+import { NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { addTeamMember, removeTeamMember, updateMemberRole, isTeamAdmin } from '@/services/teams';
+import type { AddTeamMemberInput, UpdateMemberRoleInput } from '@/lib/types';
+
+export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Check if user is admin
+    const isAdmin = await isTeamAdmin(id, session.user.id);
+    if (!isAdmin) {
+      return NextResponse.json({ error: 'Seuls les administrateurs peuvent ajouter des membres' }, { status: 403 });
+    }
+
+    const body: AddTeamMemberInput = await request.json();
+    const { userId, role } = body;
+
+    if (!userId) {
+      return NextResponse.json({ error: 'ID utilisateur requis' }, { status: 400 });
+    }
+
+    const member = await addTeamMember(id, userId, role || 'MEMBER');
+
+    return NextResponse.json(member, { status: 201 });
+  } catch (error: any) {
+    console.error('Error adding team member:', error);
+    return NextResponse.json(
+      { error: error.message || 'Erreur lors de l\'ajout du membre' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PATCH(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Check if user is admin
+    const isAdmin = await isTeamAdmin(id, session.user.id);
+    if (!isAdmin) {
+      return NextResponse.json({ error: 'Seuls les administrateurs peuvent modifier les rôles' }, { status: 403 });
+    }
+
+    const body: UpdateMemberRoleInput & { userId: string } = await request.json();
+    const { userId, role } = body;
+
+    if (!userId || !role) {
+      return NextResponse.json({ error: 'ID utilisateur et rôle requis' }, { status: 400 });
+    }
+
+    const member = await updateMemberRole(id, userId, role);
+
+    return NextResponse.json(member);
+  } catch (error) {
+    console.error('Error updating member role:', error);
+    return NextResponse.json(
+      { error: 'Erreur lors de la mise à jour du rôle' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Check if user is admin
+    const isAdmin = await isTeamAdmin(id, session.user.id);
+    if (!isAdmin) {
+      return NextResponse.json({ error: 'Seuls les administrateurs peuvent retirer des membres' }, { status: 403 });
+    }
+
+    const { searchParams } = new URL(request.url);
+    const userId = searchParams.get('userId');
+
+    if (!userId) {
+      return NextResponse.json({ error: 'ID utilisateur requis' }, { status: 400 });
+    }
+
+    await removeTeamMember(id, userId);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error('Error removing team member:', error);
+    return NextResponse.json(
+      { error: 'Erreur lors de la suppression du membre' },
+      { status: 500 }
+    );
+  }
+}
+

src/app/api/teams/[id]/route.ts

@@ -0,0 +1,91 @@
+import { NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { getTeam, updateTeam, deleteTeam, isTeamAdmin, isTeamMember } from '@/services/teams';
+import type { UpdateTeamInput } from '@/lib/types';
+
+export async function GET(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    const team = await getTeam(id);
+
+    if (!team) {
+      return NextResponse.json({ error: 'Équipe non trouvée' }, { status: 404 });
+    }
+
+    // Check if user is a member
+    const isMember = await isTeamMember(id, session.user.id);
+    if (!isMember) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    return NextResponse.json(team);
+  } catch (error) {
+    console.error('Error fetching team:', error);
+    return NextResponse.json(
+      { error: 'Erreur lors de la récupération de l\'équipe' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PATCH(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Check if user is admin
+    const isAdmin = await isTeamAdmin(id, session.user.id);
+    if (!isAdmin) {
+      return NextResponse.json({ error: 'Seuls les administrateurs peuvent modifier l\'équipe' }, { status: 403 });
+    }
+
+    const body: UpdateTeamInput = await request.json();
+    const team = await updateTeam(id, body);
+
+    return NextResponse.json(team);
+  } catch (error) {
+    console.error('Error updating team:', error);
+    return NextResponse.json(
+      { error: 'Erreur lors de la mise à jour de l\'équipe' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: Request, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    // Check if user is admin
+    const isAdmin = await isTeamAdmin(id, session.user.id);
+    if (!isAdmin) {
+      return NextResponse.json({ error: 'Seuls les administrateurs peuvent supprimer l\'équipe' }, { status: 403 });
+    }
+
+    await deleteTeam(id);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error('Error deleting team:', error);
+    return NextResponse.json(
+      { error: 'Erreur lors de la suppression de l\'équipe' },
+      { status: 500 }
+    );
+  }
+}
+

src/app/api/teams/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { getUserTeams, createTeam } from '@/services/teams';
+import type { CreateTeamInput } from '@/lib/types';
+
+export async function GET() {
+  try {
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    const teams = await getUserTeams(session.user.id);
+
+    return NextResponse.json(teams);
+  } catch (error) {
+    console.error('Error fetching teams:', error);
+    return NextResponse.json(
+      { error: 'Erreur lors de la récupération des équipes' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    const body: CreateTeamInput = await request.json();
+    const { name, description } = body;
+
+    if (!name) {
+      return NextResponse.json({ error: 'Le nom de l\'équipe est requis' }, { status: 400 });
+    }
+
+    const team = await createTeam(name, description || null, session.user.id);
+
+    return NextResponse.json(team, { status: 201 });
+  } catch (error) {
+    console.error('Error creating team:', error);
+    return NextResponse.json(
+      { error: 'Erreur lors de la création de l\'équipe' },
+      { status: 500 }
+    );
+  }
+}
+

src/app/api/users/route.ts

@@ -0,0 +1,33 @@
+import { NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/services/database';
+
+export async function GET() {
+  try {
+    const session = await auth();
+
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    const users = await prisma.user.findMany({
+      select: {
+        id: true,
+        email: true,
+        name: true,
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+
+    return NextResponse.json(users);
+  } catch (error) {
+    console.error('Error fetching users:', error);
+    return NextResponse.json(
+      { error: 'Erreur lors de la récupération des utilisateurs' },
+      { status: 500 }
+    );
+  }
+}
+