wip

apps/website/lib/presenters/LeagueAdminPresenter.ts

@@ -0,0 +1,292 @@
+import type { League } from '@gridpilot/racing/domain/entities/League';
+import type { Protest } from '@gridpilot/racing/domain/entities/Protest';
+import type { Race } from '@gridpilot/racing/domain/entities/Race';
+import type { DriverDTO } from '@gridpilot/racing/application/dto/DriverDTO';
+import type { LeagueConfigFormModel } from '@gridpilot/racing/application';
+import type { MembershipRole } from '@/lib/leagueMembership';
+import { EntityMappers } from '@gridpilot/racing/application/mappers/EntityMappers';
+import {
+  getLeagueMembershipRepository,
+  getDriverRepository,
+  getGetLeagueFullConfigUseCase,
+  getRaceRepository,
+  getProtestRepository,
+  getDriverStats,
+  getAllDriverRankings,
+} from '@/lib/di-container';
+
+export interface LeagueJoinRequestViewModel {
+  id: string;
+  leagueId: string;
+  driverId: string;
+  requestedAt: Date;
+  message?: string;
+  driver?: DriverDTO;
+}
+
+export interface ProtestDriverSummary {
+  [driverId: string]: DriverDTO;
+}
+
+export interface ProtestRaceSummary {
+  [raceId: string]: Race;
+}
+
+export interface LeagueOwnerSummaryViewModel {
+  driver: DriverDTO;
+  rating: number | null;
+  rank: number | null;
+}
+
+export interface LeagueAdminProtestsViewModel {
+  protests: Protest[];
+  racesById: ProtestRaceSummary;
+  driversById: ProtestDriverSummary;
+}
+
+export interface LeagueAdminConfigViewModel {
+  form: LeagueConfigFormModel | null;
+}
+
+export interface LeagueAdminPermissionsViewModel {
+  canRemoveMember: boolean;
+  canUpdateRoles: boolean;
+}
+
+export interface LeagueAdminViewModel {
+  joinRequests: LeagueJoinRequestViewModel[];
+  ownerSummary: LeagueOwnerSummaryViewModel | null;
+  config: LeagueAdminConfigViewModel;
+  protests: LeagueAdminProtestsViewModel;
+}
+
+/**
+ * Load join requests plus requester driver DTOs for a league.
+ */
+export async function loadLeagueJoinRequests(leagueId: string): Promise<LeagueJoinRequestViewModel[]> {
+  const membershipRepo = getLeagueMembershipRepository();
+  const requests = await membershipRepo.getJoinRequests(leagueId);
+
+  const driverRepo = getDriverRepository();
+  const uniqueDriverIds = Array.from(new Set(requests.map((r) => r.driverId)));
+  const driverEntities = await Promise.all(uniqueDriverIds.map((id) => driverRepo.findById(id)));
+  const driverDtos = driverEntities
+    .map((driver) => (driver ? EntityMappers.toDriverDTO(driver) : null))
+    .filter((dto): dto is DriverDTO => dto !== null);
+
+  const driversById: Record<string, DriverDTO> = {};
+  for (const dto of driverDtos) {
+    driversById[dto.id] = dto;
+  }
+
+  return requests.map((request) => ({
+    id: request.id,
+    leagueId: request.leagueId,
+    driverId: request.driverId,
+    requestedAt: request.requestedAt,
+    message: request.message,
+    driver: driversById[request.driverId],
+  }));
+}
+
+/**
+ * Approve a league join request and return updated join requests.
+ */
+export async function approveLeagueJoinRequest(
+  leagueId: string,
+  requestId: string
+): Promise<LeagueJoinRequestViewModel[]> {
+  const membershipRepo = getLeagueMembershipRepository();
+  const requests = await membershipRepo.getJoinRequests(leagueId);
+  const request = requests.find((r) => r.id === requestId);
+  if (!request) {
+    throw new Error('Join request not found');
+  }
+
+  await membershipRepo.saveMembership({
+    leagueId: request.leagueId,
+    driverId: request.driverId,
+    role: 'member',
+    status: 'active',
+    joinedAt: new Date(),
+  });
+  await membershipRepo.removeJoinRequest(requestId);
+
+  return loadLeagueJoinRequests(leagueId);
+}
+
+/**
+ * Reject a league join request (alpha: just remove).
+ */
+export async function rejectLeagueJoinRequest(
+  leagueId: string,
+  requestId: string
+): Promise<LeagueJoinRequestViewModel[]> {
+  const membershipRepo = getLeagueMembershipRepository();
+  await membershipRepo.removeJoinRequest(requestId);
+  return loadLeagueJoinRequests(leagueId);
+}
+
+/**
+ * Compute permissions for a performer on league membership actions.
+ */
+export async function getLeagueAdminPermissions(
+  leagueId: string,
+  performerDriverId: string
+): Promise<LeagueAdminPermissionsViewModel> {
+  const membershipRepo = getLeagueMembershipRepository();
+  const performer = await membershipRepo.getMembership(leagueId, performerDriverId);
+
+  const isOwner = performer?.role === 'owner';
+  const isAdmin = performer?.role === 'admin';
+
+  return {
+    canRemoveMember: Boolean(isOwner || isAdmin),
+    canUpdateRoles: Boolean(isOwner),
+  };
+}
+
+/**
+ * Remove a member from the league, enforcing simple role rules.
+ */
+export async function removeLeagueMember(
+  leagueId: string,
+  performerDriverId: string,
+  targetDriverId: string
+): Promise<void> {
+  const membershipRepo = getLeagueMembershipRepository();
+  const performer = await membershipRepo.getMembership(leagueId, performerDriverId);
+  if (!performer || (performer.role !== 'owner' && performer.role !== 'admin')) {
+    throw new Error('Only owners or admins can remove members');
+  }
+
+  const membership = await membershipRepo.getMembership(leagueId, targetDriverId);
+  if (!membership) {
+    throw new Error('Member not found');
+  }
+  if (membership.role === 'owner') {
+    throw new Error('Cannot remove the league owner');
+  }
+
+  await membershipRepo.removeMembership(leagueId, targetDriverId);
+}
+
+/**
+ * Update a member's role, enforcing simple owner-only rules.
+ */
+export async function updateLeagueMemberRole(
+  leagueId: string,
+  performerDriverId: string,
+  targetDriverId: string,
+  newRole: MembershipRole
+): Promise<void> {
+  const membershipRepo = getLeagueMembershipRepository();
+  const performer = await membershipRepo.getMembership(leagueId, performerDriverId);
+  if (!performer || performer.role !== 'owner') {
+    throw new Error('Only the league owner can update roles');
+  }
+
+  const membership = await membershipRepo.getMembership(leagueId, targetDriverId);
+  if (!membership) {
+    throw new Error('Member not found');
+  }
+  if (membership.role === 'owner') {
+    throw new Error('Cannot change the owner role');
+  }
+
+  await membershipRepo.saveMembership({
+    ...membership,
+    role: newRole,
+  });
+}
+
+/**
+ * Load owner summary (DTO + rating/rank) for a league.
+ */
+export async function loadLeagueOwnerSummary(league: League): Promise<LeagueOwnerSummaryViewModel | null> {
+  const driverRepo = getDriverRepository();
+  const entity = await driverRepo.findById(league.ownerId);
+  if (!entity) return null;
+
+  const ownerDriver = EntityMappers.toDriverDTO(entity);
+  const stats = getDriverStats(ownerDriver.id);
+  const allRankings = getAllDriverRankings();
+
+  let rating: number | null = stats?.rating ?? null;
+  let rank: number | null = null;
+
+  if (stats) {
+    if (typeof stats.overallRank === 'number' && stats.overallRank > 0) {
+      rank = stats.overallRank;
+    } else {
+      const indexInGlobal = allRankings.findIndex((stat) => stat.driverId === stats.driverId);
+      if (indexInGlobal !== -1) {
+        rank = indexInGlobal + 1;
+      }
+    }
+
+    if (rating === null) {
+      const globalEntry = allRankings.find((stat) => stat.driverId === stats.driverId);
+      if (globalEntry) {
+        rating = globalEntry.rating;
+      }
+    }
+  }
+
+  return {
+    driver: ownerDriver,
+    rating,
+    rank,
+  };
+}
+
+/**
+ * Load league full config form.
+ */
+export async function loadLeagueConfig(leagueId: string): Promise<LeagueAdminConfigViewModel> {
+  const useCase = getGetLeagueFullConfigUseCase();
+  const form = await useCase.execute({ leagueId });
+  return { form };
+}
+
+/**
+ * Load protests, related races and driver DTOs for a league.
+ */
+export async function loadLeagueProtests(leagueId: string): Promise<LeagueAdminProtestsViewModel> {
+  const raceRepo = getRaceRepository();
+  const protestRepo = getProtestRepository();
+  const driverRepo = getDriverRepository();
+
+  const leagueRaces = await raceRepo.findByLeagueId(leagueId);
+
+  const allProtests: Protest[] = [];
+  const racesById: Record<string, Race> = {};
+
+  for (const race of leagueRaces) {
+    racesById[race.id] = race;
+    const raceProtests = await protestRepo.findByRaceId(race.id);
+    allProtests.push(...raceProtests);
+  }
+
+  const driverIds = new Set<string>();
+  allProtests.forEach((p) => {
+    driverIds.add(p.protestingDriverId);
+    driverIds.add(p.accusedDriverId);
+  });
+
+  const driverEntities = await Promise.all(Array.from(driverIds).map((id) => driverRepo.findById(id)));
+  const driverDtos = driverEntities
+    .map((driver) => (driver ? EntityMappers.toDriverDTO(driver) : null))
+    .filter((dto): dto is DriverDTO => dto !== null);
+
+  const driversById: Record<string, DriverDTO> = {};
+  for (const dto of driverDtos) {
+    driversById[dto.id] = dto;
+  }
+
+  return {
+    protests: allProtests,
+    racesById,
+    driversById,
+  };
+}