mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor driver module (wip)

Browse Source
This commit is contained in:
Marc Mintel
2025-12-22 10:24:40 +01:00
parent e7dbec4a85
commit 9da528d5bd
108 changed files with 842 additions and 947 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
apps/api/src/domain/team/TeamService.ts
View File

@@ -12,14 +12,18 @@ import { GetTeamMembershipOutputDTO } from './dtos/GetTeamMembershipOutputDTO';
// Core imports
import type { Logger } from '@core/shared/application/Logger';
import type { ITeamRepository } from '@core/racing/domain/repositories/ITeamRepository';
import type { ITeamMembershipRepository } from '@core/racing/domain/repositories/ITeamMembershipRepository';
import type { IDriverRepository } from '@core/racing/domain/repositories/IDriverRepository';
import type { IImageServicePort } from '@core/racing/application/ports/IImageServicePort';
// Use cases
import { GetAllTeamsUseCase } from '@core/racing/application/use-cases/GetAllTeamsUseCase';
import { GetTeamDetailsUseCase } from '@core/racing/application/use-cases/GetTeamDetailsUseCase';
import { GetTeamMembersUseCase } from '@core/racing/application/use-cases/GetTeamMembersUseCase';
import { GetTeamJoinRequestsUseCase } from '@core/racing/application/use-cases/GetTeamJoinRequestsUseCase';
import { CreateTeamUseCase } from '@core/racing/application/use-cases/CreateTeamUseCase';
import { UpdateTeamUseCase } from '@core/racing/application/use-cases/UpdateTeamUseCase';
import { CreateTeamUseCase, CreateTeamInput } from '@core/racing/application/use-cases/CreateTeamUseCase';
import { UpdateTeamUseCase, UpdateTeamInput } from '@core/racing/application/use-cases/UpdateTeamUseCase';
import { GetDriverTeamUseCase } from '@core/racing/application/use-cases/GetDriverTeamUseCase';
import { GetTeamMembershipUseCase } from '@core/racing/application/use-cases/GetTeamMembershipUseCase';
@@ -34,97 +38,90 @@ import { CreateTeamPresenter } from './presenters/CreateTeamPresenter';
import { UpdateTeamPresenter } from './presenters/UpdateTeamPresenter';
// Tokens
import { LOGGER_TOKEN } from './TeamProviders';
import { TEAM_REPOSITORY_TOKEN, TEAM_MEMBERSHIP_REPOSITORY_TOKEN, DRIVER_REPOSITORY_TOKEN, IMAGE_SERVICE_TOKEN, LOGGER_TOKEN } from './TeamProviders';
@Injectable()
export class TeamService {
constructor(
private readonly getAllTeamsUseCase: GetAllTeamsUseCase,
private readonly getTeamDetailsUseCase: GetTeamDetailsUseCase,
private readonly getTeamMembersUseCase: GetTeamMembersUseCase,
private readonly getTeamJoinRequestsUseCase: GetTeamJoinRequestsUseCase,
private readonly createTeamUseCase: CreateTeamUseCase,
private readonly updateTeamUseCase: UpdateTeamUseCase,
private readonly getDriverTeamUseCase: GetDriverTeamUseCase,
private readonly getTeamMembershipUseCase: GetTeamMembershipUseCase,
@Inject(TEAM_REPOSITORY_TOKEN) private readonly teamRepository: ITeamRepository,
@Inject(TEAM_MEMBERSHIP_REPOSITORY_TOKEN) private readonly membershipRepository: ITeamMembershipRepository,
@Inject(DRIVER_REPOSITORY_TOKEN) private readonly driverRepository: IDriverRepository,
@Inject(IMAGE_SERVICE_TOKEN) private readonly imageService: IImageServicePort,
@Inject(LOGGER_TOKEN) private readonly logger: Logger,
) {}
async getAll(): Promise<any> { // TODO: type
async getAll(): Promise<GetAllTeamsOutputDTO> {
this.logger.debug('[TeamService] Fetching all teams.');
const result = await this.getAllTeamsUseCase.execute();
const presenter = new AllTeamsPresenter();
const useCase = new GetAllTeamsUseCase(this.teamRepository, this.membershipRepository, this.logger, presenter);
const result = await useCase.execute();
if (result.isErr()) {
this.logger.error('Error fetching all teams', result.error);
await presenter.present({ teams: [], totalCount: 0 });
return presenter.responseModel;
this.logger.error('Error fetching all teams', result.error?.details?.message || 'Unknown error');
return { teams: [], totalCount: 0 };
}
await presenter.present(result.value);
return presenter.responseModel;
}
async getDetails(teamId: string, userId?: string): Promise<TeamDetailsPresenter> {
async getDetails(teamId: string, userId?: string): Promise<GetTeamDetailsOutputDTO | null> {
this.logger.debug(`[TeamService] Fetching team details for teamId: ${teamId}, userId: ${userId}`);
const presenter = new TeamDetailsPresenter();
const result = await this.getTeamDetailsUseCase.execute({ teamId, driverId: userId || '' });
const useCase = new GetTeamDetailsUseCase(this.teamRepository, this.membershipRepository, presenter);
const result = await useCase.execute({ teamId, driverId: userId || '' });
if (result.isErr()) {
this.logger.error(`Error fetching team details for teamId: ${teamId}`, result.error);
return presenter;
this.logger.error(`Error fetching team details for teamId: ${teamId}: ${result.error?.details?.message || 'Unknown error'}`);
return null;
}
await presenter.present(result.value);
return presenter;
return presenter.getResponseModel();
}
async getMembers(teamId: string): Promise<TeamMembersPresenter> {
async getMembers(teamId: string): Promise<GetTeamMembersOutputDTO> {
this.logger.debug(`[TeamService] Fetching team members for teamId: ${teamId}`);
const presenter = new TeamMembersPresenter();
const result = await this.getTeamMembersUseCase.execute({ teamId });
const useCase = new GetTeamMembersUseCase(this.membershipRepository, this.driverRepository, this.imageService, this.logger, presenter);
const result = await useCase.execute({ teamId });
if (result.isErr()) {
this.logger.error(`Error fetching team members for teamId: ${teamId}`, result.error);
await presenter.present({
this.logger.error(`Error fetching team members for teamId: ${teamId}: ${result.error?.details?.message || 'Unknown error'}`);
return {
members: [],
totalCount: 0,
ownerCount: 0,
managerCount: 0,
memberCount: 0,
} as unknown as any);
return presenter;
};
}
await presenter.present(result.value);
return presenter;
return presenter.getResponseModel()!;
}
async getJoinRequests(teamId: string): Promise<TeamJoinRequestsPresenter> {
async getJoinRequests(teamId: string): Promise<GetTeamJoinRequestsOutputDTO> {
this.logger.debug(`[TeamService] Fetching team join requests for teamId: ${teamId}`);
const presenter = new TeamJoinRequestsPresenter();
const result = await this.getTeamJoinRequestsUseCase.execute({ teamId });
const useCase = new GetTeamJoinRequestsUseCase(this.membershipRepository, this.driverRepository, this.teamRepository, presenter);
const result = await useCase.execute({ teamId });
if (result.isErr()) {
this.logger.error(`Error fetching team join requests for teamId: ${teamId}`, result.error);
await presenter.present({
this.logger.error(new Error(`Error fetching team join requests for teamId: ${teamId}: ${result.error?.details?.message || 'Unknown error'}`));
return {
requests: [],
pendingCount: 0,
totalCount: 0,
} as unknown as any);
return presenter;
};
}
await presenter.present(result.value);
return presenter;
return presenter.getResponseModel()!;
}
async create(input: CreateTeamInputDTO, userId?: string): Promise<CreateTeamPresenter> {
async create(input: CreateTeamInputDTO, userId?: string): Promise<CreateTeamOutputDTO> {
this.logger.debug('[TeamService] Creating team', { input, userId });
const presenter = new CreateTeamPresenter();
const command = {
const command: CreateTeamInput = {
name: input.name,
tag: input.tag,
description: input.description ?? '',
@@ -132,68 +129,66 @@ export class TeamService {
leagues: [],
};
const result = await this.createTeamUseCase.execute(command as any);
const useCase = new CreateTeamUseCase(this.teamRepository, this.membershipRepository, this.logger, presenter);
const result = await useCase.execute(command);
if (result.isErr()) {
this.logger.error('Error creating team', result.error);
presenter.presentError();
return presenter;
this.logger.error(`Error creating team: ${result.error?.details?.message || 'Unknown error'}`);
return { id: '', success: false };
}
presenter.presentSuccess(result.value);
return presenter;
return presenter.responseModel;
}
async update(teamId: string, input: UpdateTeamInputDTO, userId?: string): Promise<UpdateTeamPresenter> {
async update(teamId: string, input: UpdateTeamInputDTO, userId?: string): Promise<UpdateTeamOutputDTO> {
this.logger.debug(`[TeamService] Updating team ${teamId}`, { input, userId });
const presenter = new UpdateTeamPresenter();
const command = {
const command: UpdateTeamInput = {
teamId,
updates: {
name: input.name,
tag: input.tag,
description: input.description,
...(input.name !== undefined && { name: input.name }),
...(input.tag !== undefined && { tag: input.tag }),
...(input.description !== undefined && { description: input.description }),
},
updatedBy: userId || '',
};
const result = await this.updateTeamUseCase.execute(command as any);
const useCase = new UpdateTeamUseCase(this.teamRepository, this.membershipRepository, presenter);
const result = await useCase.execute(command);
if (result.isErr()) {
this.logger.error(`Error updating team ${teamId}`, result.error);
presenter.presentError();
return presenter;
this.logger.error(`Error updating team ${teamId}: ${result.error?.details?.message || 'Unknown error'}`);
return { success: false };
}
presenter.presentSuccess();
return presenter;
return presenter.responseModel;
}
async getDriverTeam(driverId: string): Promise<DriverTeamPresenter> {
async getDriverTeam(driverId: string): Promise<GetDriverTeamOutputDTO | null> {
this.logger.debug(`[TeamService] Fetching driver team for driverId: ${driverId}`);
const presenter = new DriverTeamPresenter();
const result = await this.getDriverTeamUseCase.execute({ driverId });
const useCase = new GetDriverTeamUseCase(this.teamRepository, this.membershipRepository, this.logger, presenter);
const result = await useCase.execute({ driverId });
if (result.isErr()) {
this.logger.error(`Error fetching driver team for driverId: ${driverId}`, result.error);
return presenter;
this.logger.error(`Error fetching driver team for driverId: ${driverId}: ${result.error?.details?.message || 'Unknown error'}`);
return null;
}
await presenter.present(result.value);
return presenter;
return presenter.getResponseModel();
}
async getMembership(teamId: string, driverId: string): Promise<TeamMembershipPresenter> {
async getMembership(teamId: string, driverId: string): Promise<GetTeamMembershipOutputDTO | null> {
this.logger.debug(`[TeamService] Fetching team membership for teamId: ${teamId}, driverId: ${driverId}`);
const presenter = new TeamMembershipPresenter();
const result = await this.getTeamMembershipUseCase.execute({ teamId, driverId });
const useCase = new GetTeamMembershipUseCase(this.membershipRepository, this.logger, presenter);
const result = await useCase.execute({ teamId, driverId });
if (result.isErr()) {
this.logger.error(`Error fetching team membership for teamId: ${teamId}, driverId: ${driverId}`, result.error);
return presenter;
this.logger.error(`Error fetching team membership for teamId: ${teamId}, driverId: ${driverId}: ${result.error?.details?.message || 'Unknown error'}`);
return null;
}
presenter.present(result.value as any);
return presenter;
return presenter.responseModel;
}
}