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

view models

Browse Source
This commit is contained in:
Marc Mintel
2025-12-18 01:20:23 +01:00
parent 7c449af311
commit cc2553876a
216 changed files with 485 additions and 10179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

228
apps/website/lib/services/leagues/LeagueMembershipService.test.ts
View File

@@ -1,228 +0,0 @@
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { LeagueMembershipService } from './LeagueMembershipService';
import type { LeaguesApiClient } from '../../api/leagues/LeaguesApiClient';
import type { LeagueMembersPresenter } from '../../presenters/LeagueMembersPresenter';
import type { LeagueMembershipsDto } from '../../dtos';
import type { LeagueMemberViewModel } from '../../view-models';
describe('LeagueMembershipService', () => {
let service: LeagueMembershipService;
let mockApiClient: LeaguesApiClient;
let mockLeagueMembersPresenter: LeagueMembersPresenter;
beforeEach(() => {
mockApiClient = {
getMemberships: vi.fn(),
removeMember: vi.fn(),
} as unknown as LeaguesApiClient;
mockLeagueMembersPresenter = {
present: vi.fn(),
} as unknown as LeagueMembersPresenter;
service = new LeagueMembershipService(
mockApiClient,
mockLeagueMembersPresenter
);
});
describe('constructor', () => {
it('should create instance with injected dependencies', () => {
expect(service).toBeInstanceOf(LeagueMembershipService);
});
});
describe('getLeagueMemberships', () => {
it('should fetch league memberships from API and transform via presenter', async () => {
// Arrange
const leagueId = 'league-123';
const currentUserId = 'user-456';
const mockDto: LeagueMembershipsDto = {
members: [
{
driverId: 'driver-1',
role: 'owner',
joinedAt: '2024-01-01',
},
{
driverId: 'driver-2',
role: 'member',
joinedAt: '2024-01-02',
},
],
};
const mockViewModels: LeagueMemberViewModel[] = [
{
driverId: 'driver-1',
role: 'owner',
joinedAt: '2024-01-01',
} as LeagueMemberViewModel,
{
driverId: 'driver-2',
role: 'member',
joinedAt: '2024-01-02',
} as LeagueMemberViewModel,
];
vi.mocked(mockApiClient.getMemberships).mockResolvedValue(mockDto);
vi.mocked(mockLeagueMembersPresenter.present).mockReturnValue(mockViewModels);
// Act
const result = await service.getLeagueMemberships(leagueId, currentUserId);
// Assert
expect(mockApiClient.getMemberships).toHaveBeenCalledWith(leagueId);
expect(mockLeagueMembersPresenter.present).toHaveBeenCalledWith(mockDto, currentUserId);
expect(result).toEqual(mockViewModels);
});
it('should handle empty memberships list', async () => {
// Arrange
const leagueId = 'league-123';
const currentUserId = 'user-456';
const mockDto: LeagueMembershipsDto = {
members: [],
};
const mockViewModels: LeagueMemberViewModel[] = [];
vi.mocked(mockApiClient.getMemberships).mockResolvedValue(mockDto);
vi.mocked(mockLeagueMembersPresenter.present).mockReturnValue(mockViewModels);
// Act
const result = await service.getLeagueMemberships(leagueId, currentUserId);
// Assert
expect(mockApiClient.getMemberships).toHaveBeenCalledWith(leagueId);
expect(mockLeagueMembersPresenter.present).toHaveBeenCalledWith(mockDto, currentUserId);
expect(result).toEqual([]);
});
it('should propagate errors from API client', async () => {
// Arrange
const leagueId = 'league-123';
const currentUserId = 'user-456';
const error = new Error('Failed to fetch memberships');
vi.mocked(mockApiClient.getMemberships).mockRejectedValue(error);
// Act & Assert
await expect(service.getLeagueMemberships(leagueId, currentUserId)).rejects.toThrow('Failed to fetch memberships');
expect(mockApiClient.getMemberships).toHaveBeenCalledWith(leagueId);
expect(mockLeagueMembersPresenter.present).not.toHaveBeenCalled();
});
it('should pass correct currentUserId to presenter', async () => {
// Arrange
const leagueId = 'league-123';
const currentUserId = 'current-user-789';
const mockDto: LeagueMembershipsDto = {
members: [
{
driverId: 'driver-1',
role: 'member',
joinedAt: '2024-01-01',
},
],
};
const mockViewModels: LeagueMemberViewModel[] = [
{
driverId: 'driver-1',
role: 'member',
joinedAt: '2024-01-01',
} as LeagueMemberViewModel,
];
vi.mocked(mockApiClient.getMemberships).mockResolvedValue(mockDto);
vi.mocked(mockLeagueMembersPresenter.present).mockReturnValue(mockViewModels);
// Act
await service.getLeagueMemberships(leagueId, currentUserId);
// Assert
expect(mockLeagueMembersPresenter.present).toHaveBeenCalledWith(mockDto, currentUserId);
});
});
describe('removeMember', () => {
it('should remove a member from league', async () => {
// Arrange
const leagueId = 'league-123';
const performerDriverId = 'driver-admin';
const targetDriverId = 'driver-remove';
const mockOutput = { success: true };
vi.mocked(mockApiClient.removeMember).mockResolvedValue(mockOutput);
// Act
const result = await service.removeMember(leagueId, performerDriverId, targetDriverId);
// Assert
expect(mockApiClient.removeMember).toHaveBeenCalledWith(leagueId, performerDriverId, targetDriverId);
expect(result).toEqual(mockOutput);
});
it('should handle removal failure', async () => {
// Arrange
const leagueId = 'league-123';
const performerDriverId = 'driver-admin';
const targetDriverId = 'driver-remove';
const mockOutput = { success: false };
vi.mocked(mockApiClient.removeMember).mockResolvedValue(mockOutput);
// Act
const result = await service.removeMember(leagueId, performerDriverId, targetDriverId);
// Assert
expect(mockApiClient.removeMember).toHaveBeenCalledWith(leagueId, performerDriverId, targetDriverId);
expect(result).toEqual(mockOutput);
expect(result.success).toBe(false);
});
it('should propagate errors from API client', async () => {
// Arrange
const leagueId = 'league-123';
const performerDriverId = 'driver-admin';
const targetDriverId = 'driver-remove';
const error = new Error('Failed to remove member');
vi.mocked(mockApiClient.removeMember).mockRejectedValue(error);
// Act & Assert
await expect(service.removeMember(leagueId, performerDriverId, targetDriverId)).rejects.toThrow('Failed to remove member');
expect(mockApiClient.removeMember).toHaveBeenCalledWith(leagueId, performerDriverId, targetDriverId);
});
it('should handle unauthorized removal attempt', async () => {
// Arrange
const leagueId = 'league-123';
const performerDriverId = 'non-admin-driver';
const targetDriverId = 'driver-remove';
const error = new Error('Unauthorized');
vi.mocked(mockApiClient.removeMember).mockRejectedValue(error);
// Act & Assert
await expect(service.removeMember(leagueId, performerDriverId, targetDriverId)).rejects.toThrow('Unauthorized');
expect(mockApiClient.removeMember).toHaveBeenCalledWith(leagueId, performerDriverId, targetDriverId);
});
it('should handle removing non-existent member', async () => {
// Arrange
const leagueId = 'league-123';
const performerDriverId = 'driver-admin';
const targetDriverId = 'non-existent-driver';
const error = new Error('Member not found');
vi.mocked(mockApiClient.removeMember).mockRejectedValue(error);
// Act & Assert
await expect(service.removeMember(leagueId, performerDriverId, targetDriverId)).rejects.toThrow('Member not found');
expect(mockApiClient.removeMember).toHaveBeenCalledWith(leagueId, performerDriverId, targetDriverId);
});
});
});

13
apps/website/lib/services/leagues/LeagueMembershipService.ts
View File

@@ -1,25 +1,24 @@
import type { LeaguesApiClient } from '../../api/leagues/LeaguesApiClient';
import type { LeagueMemberViewModel } from '../../view-models';
import type { LeagueMembersPresenter } from '../../presenters/LeagueMembersPresenter';
import { LeagueMemberViewModel } from '../../view-models';
import type { LeagueMemberDTO } from '../../types/generated';
/**
* League Membership Service
*
* Orchestrates league membership operations by coordinating API calls and presentation logic.
* Orchestrates league membership operations by coordinating API calls and view model creation.
* All dependencies are injected via constructor.
*/
export class LeagueMembershipService {
constructor(
private readonly apiClient: LeaguesApiClient,
private readonly leagueMembersPresenter: LeagueMembersPresenter
private readonly apiClient: LeaguesApiClient
) {}
/**
* Get league memberships with presentation transformation
* Get league memberships with view model transformation
*/
async getLeagueMemberships(leagueId: string, currentUserId: string): Promise<LeagueMemberViewModel[]> {
const dto = await this.apiClient.getMemberships(leagueId);
return this.leagueMembersPresenter.present(dto, currentUserId);
return dto.members.map((member: LeagueMemberDTO) => new LeagueMemberViewModel(member, currentUserId));
}
/**

448
apps/website/lib/services/leagues/LeagueService.test.ts
View File

@@ -1,448 +0,0 @@
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { LeagueService } from './LeagueService';
import type { LeaguesApiClient } from '../../api/leagues/LeaguesApiClient';
import type { LeagueSummaryPresenter } from '../../presenters/LeagueSummaryPresenter';
import type { LeagueStandingsPresenter } from '../../presenters/LeagueStandingsPresenter';
import type {
AllLeaguesWithCapacityDto,
LeagueStandingsDto,
LeagueStatsDto,
LeagueScheduleDto,
LeagueMembershipsDto,
CreateLeagueInputDto,
CreateLeagueOutputDto,
} from '../../dtos';
import type { LeagueSummaryViewModel, LeagueStandingsViewModel } from '../../view-models';
describe('LeagueService', () => {
let service: LeagueService;
let mockApiClient: LeaguesApiClient;
let mockLeagueSummaryPresenter: LeagueSummaryPresenter;
let mockLeagueStandingsPresenter: LeagueStandingsPresenter;
beforeEach(() => {
mockApiClient = {
getAllWithCapacity: vi.fn(),
getTotal: vi.fn(),
getStandings: vi.fn(),
getSchedule: vi.fn(),
getMemberships: vi.fn(),
create: vi.fn(),
removeMember: vi.fn(),
} as unknown as LeaguesApiClient;
mockLeagueSummaryPresenter = {
present: vi.fn(),
} as unknown as LeagueSummaryPresenter;
mockLeagueStandingsPresenter = {
present: vi.fn(),
} as unknown as LeagueStandingsPresenter;
service = new LeagueService(
mockApiClient,
mockLeagueSummaryPresenter,
mockLeagueStandingsPresenter
);
});
describe('constructor', () => {
it('should create instance with injected dependencies', () => {
expect(service).toBeInstanceOf(LeagueService);
});
});
describe('getAllLeagues', () => {
it('should fetch all leagues from API and transform via presenter', async () => {
// Arrange
const mockDto: AllLeaguesWithCapacityDto = {
leagues: [
{
id: 'league-1',
name: 'Championship League',
description: 'Top tier racing',
memberCount: 10,
maxMembers: 20,
isPublic: true,
ownerId: 'owner-1',
},
{
id: 'league-2',
name: 'Rookie League',
description: 'Entry level racing',
memberCount: 5,
maxMembers: 15,
isPublic: true,
ownerId: 'owner-2',
},
],
};
const mockViewModels: LeagueSummaryViewModel[] = [
{
id: 'league-1',
name: 'Championship League',
description: 'Top tier racing',
memberCount: 10,
maxMembers: 20,
isPublic: true,
ownerId: 'owner-1',
} as LeagueSummaryViewModel,
{
id: 'league-2',
name: 'Rookie League',
description: 'Entry level racing',
memberCount: 5,
maxMembers: 15,
isPublic: true,
ownerId: 'owner-2',
} as LeagueSummaryViewModel,
];
vi.mocked(mockApiClient.getAllWithCapacity).mockResolvedValue(mockDto);
vi.mocked(mockLeagueSummaryPresenter.present).mockReturnValue(mockViewModels);
// Act
const result = await service.getAllLeagues();
// Assert
expect(mockApiClient.getAllWithCapacity).toHaveBeenCalled();
expect(mockLeagueSummaryPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual(mockViewModels);
});
it('should handle empty leagues list', async () => {
// Arrange
const mockDto: AllLeaguesWithCapacityDto = {
leagues: [],
};
const mockViewModels: LeagueSummaryViewModel[] = [];
vi.mocked(mockApiClient.getAllWithCapacity).mockResolvedValue(mockDto);
vi.mocked(mockLeagueSummaryPresenter.present).mockReturnValue(mockViewModels);
// Act
const result = await service.getAllLeagues();
// Assert
expect(mockApiClient.getAllWithCapacity).toHaveBeenCalled();
expect(mockLeagueSummaryPresenter.present).toHaveBeenCalledWith(mockDto);
expect(result).toEqual([]);
});
it('should propagate errors from API client', async () => {
// Arrange
const error = new Error('Failed to fetch leagues');
vi.mocked(mockApiClient.getAllWithCapacity).mockRejectedValue(error);
// Act & Assert
await expect(service.getAllLeagues()).rejects.toThrow('Failed to fetch leagues');
expect(mockApiClient.getAllWithCapacity).toHaveBeenCalled();
expect(mockLeagueSummaryPresenter.present).not.toHaveBeenCalled();
});
});
describe('getLeagueStandings', () => {
it('should fetch league standings and transform via presenter', async () => {
// Arrange
const leagueId = 'league-123';
const currentUserId = 'user-456';
const mockDto: LeagueStandingsDto = {
standings: [
{
position: 1,
driverId: 'driver-1',
points: 100,
},
{
position: 2,
driverId: 'driver-2',
points: 85,
},
],
drivers: [],
memberships: [],
};
const mockViewModel: LeagueStandingsViewModel = {
standings: [
{
position: 1,
driverId: 'driver-1',
points: 100,
},
{
position: 2,
driverId: 'driver-2',
points: 85,
},
],
drivers: [],
memberships: [],
} as LeagueStandingsViewModel;
vi.mocked(mockApiClient.getStandings).mockResolvedValue(mockDto);
vi.mocked(mockLeagueStandingsPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.getLeagueStandings(leagueId, currentUserId);
// Assert
expect(mockApiClient.getStandings).toHaveBeenCalledWith(leagueId);
expect(mockLeagueStandingsPresenter.present).toHaveBeenCalledWith(
expect.objectContaining(mockDto),
currentUserId
);
expect(result).toEqual(mockViewModel);
});
it('should handle empty standings', async () => {
// Arrange
const leagueId = 'league-123';
const currentUserId = 'user-456';
const mockDto: LeagueStandingsDto = {
standings: [],
drivers: [],
memberships: [],
};
const mockViewModel: LeagueStandingsViewModel = {
standings: [],
drivers: [],
memberships: [],
} as LeagueStandingsViewModel;
vi.mocked(mockApiClient.getStandings).mockResolvedValue(mockDto);
vi.mocked(mockLeagueStandingsPresenter.present).mockReturnValue(mockViewModel);
// Act
const result = await service.getLeagueStandings(leagueId, currentUserId);
// Assert
expect(mockApiClient.getStandings).toHaveBeenCalledWith(leagueId);
expect(mockLeagueStandingsPresenter.present).toHaveBeenCalled();
expect(result).toEqual(mockViewModel);
});
it('should propagate errors from API client', async () => {
// Arrange
const leagueId = 'league-123';
const currentUserId = 'user-456';
const error = new Error('Failed to fetch standings');
vi.mocked(mockApiClient.getStandings).mockRejectedValue(error);
// Act & Assert
await expect(service.getLeagueStandings(leagueId, currentUserId)).rejects.toThrow('Failed to fetch standings');
expect(mockApiClient.getStandings).toHaveBeenCalledWith(leagueId);
expect(mockLeagueStandingsPresenter.present).not.toHaveBeenCalled();
});
});
describe('getLeagueStats', () => {
it('should fetch league statistics', async () => {
// Arrange
const mockStats: LeagueStatsDto = {
totalLeagues: 42,
};
vi.mocked(mockApiClient.getTotal).mockResolvedValue(mockStats);
// Act
const result = await service.getLeagueStats();
// Assert
expect(mockApiClient.getTotal).toHaveBeenCalled();
expect(result).toEqual(mockStats);
});
it('should propagate errors from API client', async () => {
// Arrange
const error = new Error('Failed to fetch stats');
vi.mocked(mockApiClient.getTotal).mockRejectedValue(error);
// Act & Assert
await expect(service.getLeagueStats()).rejects.toThrow('Failed to fetch stats');
expect(mockApiClient.getTotal).toHaveBeenCalled();
});
});
describe('getLeagueSchedule', () => {
it('should fetch league schedule', async () => {
// Arrange
const leagueId = 'league-123';
const mockSchedule: LeagueScheduleDto = {
races: [
{
id: 'race-1',
name: 'Race 1',
date: '2024-01-01',
},
{
id: 'race-2',
name: 'Race 2',
date: '2024-01-08',
},
],
};
vi.mocked(mockApiClient.getSchedule).mockResolvedValue(mockSchedule);
// Act
const result = await service.getLeagueSchedule(leagueId);
// Assert
expect(mockApiClient.getSchedule).toHaveBeenCalledWith(leagueId);
expect(result).toEqual(mockSchedule);
});
it('should propagate errors from API client', async () => {
// Arrange
const leagueId = 'league-123';
const error = new Error('Failed to fetch schedule');
vi.mocked(mockApiClient.getSchedule).mockRejectedValue(error);
// Act & Assert
await expect(service.getLeagueSchedule(leagueId)).rejects.toThrow('Failed to fetch schedule');
expect(mockApiClient.getSchedule).toHaveBeenCalledWith(leagueId);
});
});
describe('getLeagueMemberships', () => {
it('should fetch league memberships', async () => {
// Arrange
const leagueId = 'league-123';
const mockMemberships: LeagueMembershipsDto = {
memberships: [
{
driverId: 'driver-1',
role: 'admin',
joinedAt: '2024-01-01',
},
{
driverId: 'driver-2',
role: 'member',
joinedAt: '2024-01-02',
},
],
};
vi.mocked(mockApiClient.getMemberships).mockResolvedValue(mockMemberships);
// Act
const result = await service.getLeagueMemberships(leagueId);
// Assert
expect(mockApiClient.getMemberships).toHaveBeenCalledWith(leagueId);
expect(result).toEqual(mockMemberships);
});
it('should propagate errors from API client', async () => {
// Arrange
const leagueId = 'league-123';
const error = new Error('Failed to fetch memberships');
vi.mocked(mockApiClient.getMemberships).mockRejectedValue(error);
// Act & Assert
await expect(service.getLeagueMemberships(leagueId)).rejects.toThrow('Failed to fetch memberships');
expect(mockApiClient.getMemberships).toHaveBeenCalledWith(leagueId);
});
});
describe('createLeague', () => {
it('should create a new league', async () => {
// Arrange
const input: CreateLeagueInputDto = {
name: 'New League',
description: 'A brand new league',
maxMembers: 25,
isPublic: true,
};
const mockOutput: CreateLeagueOutputDto = {
id: 'league-new',
name: 'New League',
success: true,
};
vi.mocked(mockApiClient.create).mockResolvedValue(mockOutput);
// Act
const result = await service.createLeague(input);
// Assert
expect(mockApiClient.create).toHaveBeenCalledWith(input);
expect(result).toEqual(mockOutput);
});
it('should propagate errors from API client', async () => {
// Arrange
const input: CreateLeagueInputDto = {
name: 'New League',
description: 'A brand new league',
maxMembers: 25,
isPublic: true,
};
const error = new Error('Failed to create league');
vi.mocked(mockApiClient.create).mockRejectedValue(error);
// Act & Assert
await expect(service.createLeague(input)).rejects.toThrow('Failed to create league');
expect(mockApiClient.create).toHaveBeenCalledWith(input);
});
});
describe('removeMember', () => {
it('should remove a member from league', async () => {
// Arrange
const leagueId = 'league-123';
const performerDriverId = 'driver-admin';
const targetDriverId = 'driver-remove';
const mockOutput = { success: true };
vi.mocked(mockApiClient.removeMember).mockResolvedValue(mockOutput);
// Act
const result = await service.removeMember(leagueId, performerDriverId, targetDriverId);
// Assert
expect(mockApiClient.removeMember).toHaveBeenCalledWith(leagueId, performerDriverId, targetDriverId);
expect(result).toEqual(mockOutput);
});
it('should handle removal failure', async () => {
// Arrange
const leagueId = 'league-123';
const performerDriverId = 'driver-admin';
const targetDriverId = 'driver-remove';
const mockOutput = { success: false };
vi.mocked(mockApiClient.removeMember).mockResolvedValue(mockOutput);
// Act
const result = await service.removeMember(leagueId, performerDriverId, targetDriverId);
// Assert
expect(mockApiClient.removeMember).toHaveBeenCalledWith(leagueId, performerDriverId, targetDriverId);
expect(result).toEqual(mockOutput);
expect(result.success).toBe(false);
});
it('should propagate errors from API client', async () => {
// Arrange
const leagueId = 'league-123';
const performerDriverId = 'driver-admin';
const targetDriverId = 'driver-remove';
const error = new Error('Failed to remove member');
vi.mocked(mockApiClient.removeMember).mockRejectedValue(error);
// Act & Assert
await expect(service.removeMember(leagueId, performerDriverId, targetDriverId)).rejects.toThrow('Failed to remove member');
expect(mockApiClient.removeMember).toHaveBeenCalledWith(leagueId, performerDriverId, targetDriverId);
});
});
});

27
apps/website/lib/services/leagues/LeagueService.ts
View File

@@ -1,32 +1,33 @@
import type { LeaguesApiClient } from '../../api/leagues/LeaguesApiClient';
import type { LeagueSummaryPresenter } from '../../presenters/LeagueSummaryPresenter';
import type { LeagueStandingsPresenter } from '../../presenters/LeagueStandingsPresenter';
import type { LeagueSummaryViewModel, LeagueStandingsViewModel } from '../../view-models';
import type { CreateLeagueInputDto, CreateLeagueOutputDto, LeagueStatsDto, LeagueScheduleDto, LeagueMembershipsDto } from '../../dtos';
import { LeagueSummaryViewModel, LeagueStandingsViewModel } from '../../view-models';
import type { CreateLeagueInputDTO, CreateLeagueOutputDTO, LeagueWithCapacityDTO } from '../../types/generated';
// TODO: Move these types to apps/website/lib/types/generated when available
type LeagueStatsDto = { totalLeagues: number };
type LeagueScheduleDto = { races: Array<unknown> };
type LeagueMembershipsDto = { memberships: Array<unknown> };
/**
* League Service
*
* Orchestrates league operations by coordinating API calls and presentation logic.
* Orchestrates league operations by coordinating API calls and view model creation.
* All dependencies are injected via constructor.
*/
export class LeagueService {
constructor(
private readonly apiClient: LeaguesApiClient,
private readonly leagueSummaryPresenter: LeagueSummaryPresenter,
private readonly leagueStandingsPresenter: LeagueStandingsPresenter
private readonly apiClient: LeaguesApiClient
) {}
/**
* Get all leagues with presentation transformation
* Get all leagues with view model transformation
*/
async getAllLeagues(): Promise<LeagueSummaryViewModel[]> {
const dto = await this.apiClient.getAllWithCapacity();
return this.leagueSummaryPresenter.present(dto);
return dto.leagues.map((league: LeagueWithCapacityDTO) => new LeagueSummaryViewModel(league));
}
/**
* Get league standings with presentation transformation
* Get league standings with view model transformation
*/
async getLeagueStandings(leagueId: string, currentUserId: string): Promise<LeagueStandingsViewModel> {
const dto = await this.apiClient.getStandings(leagueId);
@@ -36,7 +37,7 @@ export class LeagueService {
drivers: [], // TODO: fetch drivers
memberships: [], // TODO: fetch memberships
};
return this.leagueStandingsPresenter.present(dtoWithExtras, currentUserId);
return new LeagueStandingsViewModel(dtoWithExtras, currentUserId);
}
/**
@@ -63,7 +64,7 @@ export class LeagueService {
/**
* Create a new league
*/
async createLeague(input: CreateLeagueInputDto): Promise<CreateLeagueOutputDto> {
async createLeague(input: CreateLeagueInputDTO): Promise<CreateLeagueOutputDTO> {
return await this.apiClient.create(input);
}