118 lines
3.9 KiB
TypeScript
118 lines
3.9 KiB
TypeScript
import { getWebsiteApiBaseUrl } from '@/lib/config/apiBaseUrl';
|
|
import { Result } from '@/lib/contracts/Result';
|
|
import { DomainError, Service } from '@/lib/contracts/services/Service';
|
|
import { ApiError } from '@/lib/gateways/api/base/ApiError';
|
|
import { RacesApiClient } from '@/lib/gateways/api/races/RacesApiClient';
|
|
import { ConsoleErrorReporter } from '@/lib/infrastructure/logging/ConsoleErrorReporter';
|
|
import { ConsoleLogger } from '@/lib/infrastructure/logging/ConsoleLogger';
|
|
import type { ImportRaceResultsSummaryViewData } from '@/lib/view-data/ImportRaceResultsSummaryViewData';
|
|
import { ImportRaceResultsSummaryViewModel } from '@/lib/view-models/ImportRaceResultsSummaryViewModel';
|
|
import { RaceResultsDetailViewModel } from '@/lib/view-models/RaceResultsDetailViewModel';
|
|
import type { RaceWithSOFViewData } from '@/lib/view-data/RaceWithSOFViewData';
|
|
import { RaceWithSOFViewModel } from '@/lib/view-models/RaceWithSOFViewModel';
|
|
import { injectable, unmanaged } from 'inversify';
|
|
|
|
/**
|
|
* Race Results Service
|
|
*
|
|
* Orchestration service for race results operations.
|
|
* Returns raw API DTOs. No ViewModels or UX logic.
|
|
*/
|
|
@injectable()
|
|
export class RaceResultsService implements Service {
|
|
private apiClient: RacesApiClient;
|
|
|
|
constructor(@unmanaged() apiClient?: RacesApiClient) {
|
|
if (apiClient) {
|
|
this.apiClient = apiClient;
|
|
} else {
|
|
// Service creates its own dependencies
|
|
const baseUrl = getWebsiteApiBaseUrl();
|
|
const logger = new ConsoleLogger();
|
|
const errorReporter = new ConsoleErrorReporter();
|
|
|
|
this.apiClient = new RacesApiClient(baseUrl, errorReporter, logger);
|
|
}
|
|
}
|
|
|
|
async getResultsDetail(raceId: string, currentUserId?: string): Promise<any> {
|
|
const res = await this.getRaceResultsDetail(raceId);
|
|
if (res.isErr()) throw new Error((res as any).error.message);
|
|
const data = (res as any).value;
|
|
return new RaceResultsDetailViewModel({
|
|
...data,
|
|
currentUserId: currentUserId ?? '',
|
|
results: data.results || [],
|
|
});
|
|
}
|
|
|
|
async importResults(raceId: string, input: any): Promise<any> {
|
|
const res = await this.apiClient.importResults(raceId, input);
|
|
const viewData: ImportRaceResultsSummaryViewData = {
|
|
success: res.success,
|
|
raceId: res.raceId,
|
|
driversProcessed: res.driversProcessed,
|
|
resultsRecorded: res.resultsRecorded,
|
|
errors: res.errors || [],
|
|
};
|
|
return new ImportRaceResultsSummaryViewModel(viewData);
|
|
}
|
|
|
|
/**
|
|
* Get race results detail
|
|
* Returns results for a specific race
|
|
*/
|
|
async getRaceResultsDetail(raceId: string): Promise<Result<any, DomainError>> {
|
|
try {
|
|
const data = await this.apiClient.getResultsDetail(raceId);
|
|
return Result.ok(data);
|
|
} catch (error: unknown) {
|
|
if (error instanceof ApiError) {
|
|
return Result.err({
|
|
type: this.mapApiErrorType(error.type),
|
|
message: error.message
|
|
});
|
|
}
|
|
return Result.err({
|
|
type: 'unknown',
|
|
message: (error as Error).message || 'Failed to fetch race results'
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get race with strength of field
|
|
* Returns race data with SOF calculation
|
|
*/
|
|
async getWithSOF(raceId: string): Promise<any> {
|
|
try {
|
|
const data = await this.apiClient.getWithSOF(raceId);
|
|
const viewData: RaceWithSOFViewData = {
|
|
id: data.id,
|
|
track: data.track,
|
|
strengthOfField: data.strengthOfField ?? null,
|
|
};
|
|
return new RaceWithSOFViewModel(viewData);
|
|
} catch (error: unknown) {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
private mapApiErrorType(apiErrorType: string): DomainError['type'] {
|
|
switch (apiErrorType) {
|
|
case 'NOT_FOUND':
|
|
return 'notFound';
|
|
case 'AUTH_ERROR':
|
|
return 'unauthorized';
|
|
case 'VALIDATION_ERROR':
|
|
return 'validation';
|
|
case 'SERVER_ERROR':
|
|
return 'serverError';
|
|
case 'NETWORK_ERROR':
|
|
return 'networkError';
|
|
default:
|
|
return 'unknown';
|
|
}
|
|
}
|
|
}
|