141 lines
4.0 KiB
TypeScript
141 lines
4.0 KiB
TypeScript
import { BaseApiService } from "./base-api.service";
|
|
import { Library, LibraryResponse } from "@/types/library";
|
|
import { Series } from "@/types/series";
|
|
import { serverCacheService } from "./server-cache.service";
|
|
|
|
export class LibraryService extends BaseApiService {
|
|
static async getLibraries(): Promise<Library[]> {
|
|
try {
|
|
return this.fetchWithCache<Library[]>(
|
|
"libraries",
|
|
async () => this.fetchFromApi<Library[]>({ path: "libraries" }),
|
|
"LIBRARIES"
|
|
);
|
|
} catch (error) {
|
|
return this.handleError(error, "Impossible de récupérer les bibliothèques");
|
|
}
|
|
}
|
|
|
|
static async getLibrary(libraryId: string): Promise<Library> {
|
|
const libraries = await this.getLibraries();
|
|
const library = libraries.find((library) => library.id === libraryId);
|
|
if (!library) {
|
|
throw new Error(`Bibliothèque ${libraryId} non trouvée`);
|
|
}
|
|
return library;
|
|
}
|
|
|
|
static async getAllLibrarySeries(libraryId: string): Promise<Series[]> {
|
|
try {
|
|
const headers = { "Content-Type": "application/json" };
|
|
|
|
const searchBody = {
|
|
condition: {
|
|
libraryId: {
|
|
operator: "is",
|
|
value: libraryId,
|
|
},
|
|
},
|
|
};
|
|
|
|
const cacheKey = `library-${libraryId}-all-series`;
|
|
const response = await this.fetchWithCache<LibraryResponse<Series>>(
|
|
cacheKey,
|
|
async () =>
|
|
this.fetchFromApi<LibraryResponse<Series>>(
|
|
{
|
|
path: "series/list",
|
|
params: {
|
|
size: "1000", // On récupère un maximum de livres
|
|
},
|
|
},
|
|
headers,
|
|
{
|
|
method: "POST",
|
|
body: JSON.stringify(searchBody),
|
|
}
|
|
),
|
|
"SERIES"
|
|
);
|
|
|
|
return response.content;
|
|
} catch (error) {
|
|
return this.handleError(error, "Impossible de récupérer toutes les séries");
|
|
}
|
|
}
|
|
|
|
static async getLibrarySeries(
|
|
libraryId: string,
|
|
page: number = 0,
|
|
size: number = 20,
|
|
unreadOnly: boolean = false,
|
|
search?: string
|
|
): Promise<LibraryResponse<Series>> {
|
|
try {
|
|
// Récupérer toutes les séries depuis le cache
|
|
const allSeries = await this.getAllLibrarySeries(libraryId);
|
|
// Filtrer les séries
|
|
let filteredSeries = allSeries;
|
|
|
|
if (unreadOnly) {
|
|
filteredSeries = filteredSeries.filter(
|
|
(series) => series.booksReadCount < series.booksCount
|
|
);
|
|
}
|
|
|
|
if (search) {
|
|
const searchLower = search.toLowerCase();
|
|
filteredSeries = filteredSeries.filter((series) =>
|
|
series.metadata.title.toLowerCase().includes(searchLower)
|
|
);
|
|
}
|
|
|
|
// Trier les séries
|
|
filteredSeries.sort((a, b) => a.metadata.titleSort.localeCompare(b.metadata.titleSort));
|
|
|
|
// Calculer la pagination
|
|
const totalElements = filteredSeries.length;
|
|
const totalPages = Math.ceil(totalElements / size);
|
|
const startIndex = page * size;
|
|
const endIndex = Math.min(startIndex + size, totalElements);
|
|
const paginatedSeries = filteredSeries.slice(startIndex, endIndex);
|
|
|
|
// Construire la réponse
|
|
return {
|
|
content: paginatedSeries,
|
|
empty: paginatedSeries.length === 0,
|
|
first: page === 0,
|
|
last: page >= totalPages - 1,
|
|
number: page,
|
|
numberOfElements: paginatedSeries.length,
|
|
pageable: {
|
|
offset: startIndex,
|
|
pageNumber: page,
|
|
pageSize: size,
|
|
paged: true,
|
|
sort: {
|
|
empty: false,
|
|
sorted: true,
|
|
unsorted: false,
|
|
},
|
|
unpaged: false,
|
|
},
|
|
size,
|
|
sort: {
|
|
empty: false,
|
|
sorted: true,
|
|
unsorted: false,
|
|
},
|
|
totalElements,
|
|
totalPages,
|
|
};
|
|
} catch (error) {
|
|
return this.handleError(error, "Impossible de récupérer les séries");
|
|
}
|
|
}
|
|
|
|
static async clearLibrarySeriesCache(libraryId: string) {
|
|
serverCacheService.deleteAll(`library-${libraryId}-series`);
|
|
}
|
|
}
|