131 lines
4.3 KiB
TypeScript
131 lines
4.3 KiB
TypeScript
/**
|
|
* Get Dashboard Use Case
|
|
*
|
|
* Orchestrates the retrieval of dashboard data for a driver.
|
|
* Aggregates data from multiple repositories and returns a unified dashboard view.
|
|
*/
|
|
|
|
import { DashboardRepository } from '../ports/DashboardRepository';
|
|
import { DashboardQuery } from '../ports/DashboardQuery';
|
|
import { DashboardDTO } from '../dto/DashboardDTO';
|
|
import { DashboardEventPublisher } from '../ports/DashboardEventPublisher';
|
|
import { DriverNotFoundError } from '../../domain/errors/DriverNotFoundError';
|
|
import { ValidationError } from '../../../shared/errors/ValidationError';
|
|
|
|
export interface GetDashboardUseCasePorts {
|
|
driverRepository: DashboardRepository;
|
|
raceRepository: DashboardRepository;
|
|
leagueRepository: DashboardRepository;
|
|
activityRepository: DashboardRepository;
|
|
eventPublisher: DashboardEventPublisher;
|
|
}
|
|
|
|
export class GetDashboardUseCase {
|
|
constructor(private readonly ports: GetDashboardUseCasePorts) {}
|
|
|
|
async execute(query: DashboardQuery): Promise<DashboardDTO> {
|
|
// Validate input
|
|
this.validateQuery(query);
|
|
|
|
// Find driver
|
|
const driver = await this.ports.driverRepository.findDriverById(query.driverId);
|
|
if (!driver) {
|
|
throw new DriverNotFoundError(query.driverId);
|
|
}
|
|
|
|
// Fetch all data in parallel
|
|
const [upcomingRaces, leagueStandings, recentActivity] = await Promise.all([
|
|
this.ports.raceRepository.getUpcomingRaces(query.driverId),
|
|
this.ports.leagueRepository.getLeagueStandings(query.driverId),
|
|
this.ports.activityRepository.getRecentActivity(query.driverId),
|
|
]);
|
|
|
|
// Limit upcoming races to 3
|
|
const limitedRaces = upcomingRaces
|
|
.sort((a, b) => a.scheduledDate.getTime() - b.scheduledDate.getTime())
|
|
.slice(0, 3);
|
|
|
|
// Sort recent activity by timestamp (newest first)
|
|
const sortedActivity = recentActivity
|
|
.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
|
|
|
|
// Transform to DTO
|
|
const driverDto: DashboardDTO['driver'] = {
|
|
id: driver.id,
|
|
name: driver.name,
|
|
};
|
|
if (driver.avatar) {
|
|
driverDto.avatar = driver.avatar;
|
|
}
|
|
|
|
const result: DashboardDTO = {
|
|
driver: driverDto,
|
|
statistics: {
|
|
rating: driver.rating,
|
|
rank: driver.rank,
|
|
starts: driver.starts,
|
|
wins: driver.wins,
|
|
podiums: driver.podiums,
|
|
leagues: driver.leagues,
|
|
},
|
|
upcomingRaces: limitedRaces.map(race => ({
|
|
trackName: race.trackName,
|
|
carType: race.carType,
|
|
scheduledDate: race.scheduledDate.toISOString(),
|
|
timeUntilRace: race.timeUntilRace || this.calculateTimeUntilRace(race.scheduledDate),
|
|
})),
|
|
championshipStandings: leagueStandings.map(standing => ({
|
|
leagueName: standing.leagueName,
|
|
position: standing.position,
|
|
points: standing.points,
|
|
totalDrivers: standing.totalDrivers,
|
|
})),
|
|
recentActivity: sortedActivity.map(activity => ({
|
|
type: activity.type,
|
|
description: activity.description,
|
|
timestamp: activity.timestamp.toISOString(),
|
|
status: activity.status,
|
|
})),
|
|
};
|
|
|
|
// Publish event
|
|
await this.ports.eventPublisher.publishDashboardAccessed({
|
|
type: 'dashboard_accessed',
|
|
driverId: query.driverId,
|
|
timestamp: new Date(),
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
private validateQuery(query: DashboardQuery): void {
|
|
if (!query.driverId || typeof query.driverId !== 'string') {
|
|
throw new ValidationError('Driver ID must be a valid string');
|
|
}
|
|
if (query.driverId.trim().length === 0) {
|
|
throw new ValidationError('Driver ID cannot be empty');
|
|
}
|
|
}
|
|
|
|
private calculateTimeUntilRace(scheduledDate: Date): string {
|
|
const now = new Date();
|
|
const diff = scheduledDate.getTime() - now.getTime();
|
|
|
|
if (diff <= 0) {
|
|
return 'Race started';
|
|
}
|
|
|
|
const days = Math.floor(diff / (1000 * 60 * 60 * 24));
|
|
const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
|
|
const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
|
|
|
|
if (days > 0) {
|
|
return `${days} day${days > 1 ? 's' : ''} ${hours} hour${hours > 1 ? 's' : ''}`;
|
|
}
|
|
if (hours > 0) {
|
|
return `${hours} hour${hours > 1 ? 's' : ''} ${minutes} minute${minutes > 1 ? 's' : ''}`;
|
|
}
|
|
return `${minutes} minute${minutes > 1 ? 's' : ''}`;
|
|
}
|
|
}
|