d9bf089e32
- Add JSDoc comments for better maintainability and code clarity in `BookRepo` methods. - Streamline query definitions using variables to improve readability. - Consolidate error handling logic across all methods. - Ensure multilingual support in error messages for consistent user feedback. - Remove redundant error branches and simplify unknown error processing.
571 lines
30 KiB
TypeScript
571 lines
30 KiB
TypeScript
import { Database, QueryResult, RunResult, SQLiteValue } from 'node-sqlite3-wasm';
|
|
import System from "../System.js";
|
|
|
|
export interface BookCharactersTable extends Record<string, SQLiteValue> {
|
|
character_id: string;
|
|
book_id: string;
|
|
user_id: string;
|
|
first_name: string;
|
|
last_name: string | null;
|
|
category: string;
|
|
title: string | null;
|
|
image: string | null;
|
|
role: string | null;
|
|
biography: string | null;
|
|
history: string | null;
|
|
last_update: number;
|
|
}
|
|
|
|
export interface SyncedCharacterResult extends Record<string, SQLiteValue> {
|
|
character_id: string;
|
|
book_id: string;
|
|
first_name: string;
|
|
last_update: number;
|
|
}
|
|
|
|
export interface SyncedCharacterAttributeResult extends Record<string, SQLiteValue> {
|
|
attr_id: string;
|
|
character_id: string;
|
|
attribute_name: string;
|
|
last_update: number;
|
|
}
|
|
|
|
export interface BookCharactersAttributesTable extends Record<string, SQLiteValue> {
|
|
attr_id: string;
|
|
character_id: string;
|
|
user_id: string;
|
|
attribute_name: string;
|
|
attribute_value: string;
|
|
last_update: number;
|
|
}
|
|
|
|
export interface CharacterResult extends Record<string, SQLiteValue> {
|
|
character_id: string;
|
|
first_name: string;
|
|
last_name: string;
|
|
title: string;
|
|
category: string;
|
|
image: string;
|
|
role: string;
|
|
biography: string;
|
|
history: string;
|
|
}
|
|
|
|
export interface AttributeResult extends Record<string, SQLiteValue> {
|
|
attr_id: string;
|
|
attribute_name: string;
|
|
attribute_value: string;
|
|
}
|
|
|
|
export interface CompleteCharacterResult extends Record<string, SQLiteValue> {
|
|
character_id: string;
|
|
first_name: string;
|
|
last_name: string;
|
|
category: string;
|
|
title: string;
|
|
role: string;
|
|
biography: string;
|
|
history: string;
|
|
attribute_name: string;
|
|
attribute_value: string;
|
|
}
|
|
|
|
export default class CharacterRepo {
|
|
/**
|
|
* Fetches all characters for a specific book and user.
|
|
* @param userId - The unique identifier of the user
|
|
* @param bookId - The unique identifier of the book
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns An array of character results
|
|
*/
|
|
public static fetchCharacters(userId: string, bookId: string, lang: 'fr' | 'en' = 'fr'): CharacterResult[] {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'SELECT character_id, first_name, last_name, title, category, image, role, biography, history FROM book_characters WHERE book_id=? AND user_id=?';
|
|
const params: SQLiteValue[] = [bookId, userId];
|
|
const characters: CharacterResult[] = db.all(query, params) as CharacterResult[];
|
|
return characters;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de récupérer les personnages.` : `Unable to retrieve characters.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds a new character to the database.
|
|
* @param userId - The unique identifier of the user
|
|
* @param characterId - The unique identifier for the new character
|
|
* @param encryptedName - The encrypted first name of the character
|
|
* @param encryptedLastName - The encrypted last name of the character
|
|
* @param encryptedTitle - The encrypted title of the character
|
|
* @param encryptedCategory - The encrypted category of the character
|
|
* @param encryptedImage - The encrypted image path of the character
|
|
* @param encryptedRole - The encrypted role of the character
|
|
* @param encryptedBiography - The encrypted biography of the character
|
|
* @param encryptedHistory - The encrypted history of the character
|
|
* @param bookId - The unique identifier of the book
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns The character ID if successful
|
|
*/
|
|
public static addNewCharacter(userId: string, characterId: string, encryptedName: string, encryptedLastName: string, encryptedTitle: string, encryptedCategory: string, encryptedImage: string, encryptedRole: string, encryptedBiography: string, encryptedHistory: string, bookId: string, lang: 'fr' | 'en' = 'fr'): string {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'INSERT INTO `book_characters` (character_id, book_id, user_id, first_name, last_name, category, title, image, role, biography, history, last_update) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)';
|
|
const params: SQLiteValue[] = [characterId, bookId, userId, encryptedName, encryptedLastName, encryptedCategory, encryptedTitle, encryptedImage, encryptedRole, encryptedBiography, encryptedHistory, System.timeStampInSeconds()];
|
|
const insertResult: RunResult = db.run(query, params);
|
|
if (!insertResult || insertResult.changes === 0) {
|
|
throw new Error(lang === 'fr' ? `Une erreur s'est produite lors de l'ajout du personnage.` : `Error adding character.`);
|
|
}
|
|
return characterId;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible d'ajouter le personnage.` : `Unable to add character.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Inserts a new attribute for a character.
|
|
* @param attributeId - The unique identifier for the new attribute
|
|
* @param characterId - The unique identifier of the character
|
|
* @param userId - The unique identifier of the user
|
|
* @param type - The attribute name/type
|
|
* @param name - The attribute value
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns The attribute ID if successful
|
|
*/
|
|
static insertAttribute(attributeId: string, characterId: string, userId: string, type: string, name: string, lang: 'fr' | 'en' = 'fr'): string {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'INSERT INTO `book_characters_attributes` (attr_id, character_id, user_id, attribute_name, attribute_value, last_update) VALUES (?,?,?,?,?,?)';
|
|
const params: SQLiteValue[] = [attributeId, characterId, userId, type, name, System.timeStampInSeconds()];
|
|
const insertResult: RunResult = db.run(query, params);
|
|
if (!insertResult || insertResult.changes === 0) {
|
|
throw new Error(lang === 'fr' ? `Une erreur s'est produite lors de l'ajout de l'attribut.` : `Error adding attribute.`);
|
|
}
|
|
return attributeId;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible d'ajouter l'attribut.` : `Unable to add attribute.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates an existing character's information.
|
|
* @param userId - The unique identifier of the user
|
|
* @param id - The unique identifier of the character to update
|
|
* @param encryptedName - The encrypted first name of the character
|
|
* @param encryptedLastName - The encrypted last name of the character
|
|
* @param encryptedTitle - The encrypted title of the character
|
|
* @param encryptedCategory - The encrypted category of the character
|
|
* @param encryptedImage - The encrypted image path of the character
|
|
* @param encryptedRole - The encrypted role of the character
|
|
* @param encryptedBiography - The encrypted biography of the character
|
|
* @param encryptedHistory - The encrypted history of the character
|
|
* @param lastUpdate - The timestamp of the last update
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns True if the update was successful, false otherwise
|
|
*/
|
|
static updateCharacter(userId: string, id: string, encryptedName: string, encryptedLastName: string, encryptedTitle: string, encryptedCategory: string, encryptedImage: string, encryptedRole: string, encryptedBiography: string, encryptedHistory: string, lastUpdate: number, lang: 'fr' | 'en' = 'fr'): boolean {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'UPDATE `book_characters` SET `first_name`=?,`last_name`=?,`title`=?,`category`=?,`image`=?,`role`=?,`biography`=?,`history`=?,`last_update`=? WHERE `character_id`=? AND `user_id`=?';
|
|
const params: SQLiteValue[] = [encryptedName, encryptedLastName, encryptedTitle, encryptedCategory, encryptedImage, encryptedRole, encryptedBiography, encryptedHistory, lastUpdate, id, userId];
|
|
const updateResult: RunResult = db.run(query, params);
|
|
return updateResult.changes > 0;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de mettre à jour le personnage.` : `Unable to update character.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deletes a character attribute from the database.
|
|
* @param userId - The unique identifier of the user
|
|
* @param attributeId - The unique identifier of the attribute to delete
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns True if the deletion was successful, false otherwise
|
|
*/
|
|
static deleteAttribute(userId: string, attributeId: string, lang: 'fr' | 'en' = 'fr'): boolean {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'DELETE FROM `book_characters_attributes` WHERE `attr_id`=? AND `user_id`=?';
|
|
const params: SQLiteValue[] = [attributeId, userId];
|
|
const deleteResult: RunResult = db.run(query, params);
|
|
return deleteResult.changes > 0;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de supprimer l'attribut.` : `Unable to delete attribute.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches all attributes for a specific character.
|
|
* @param characterId - The unique identifier of the character
|
|
* @param userId - The unique identifier of the user
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns An array of attribute results
|
|
*/
|
|
static fetchAttributes(characterId: string, userId: string, lang: 'fr' | 'en' = 'fr'): AttributeResult[] {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'SELECT attr_id, attribute_name, attribute_value FROM book_characters_attributes WHERE character_id=? AND user_id=?';
|
|
const params: SQLiteValue[] = [characterId, userId];
|
|
const attributes: AttributeResult[] = db.all(query, params) as AttributeResult[];
|
|
return attributes;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de récupérer les attributs.` : `Unable to retrieve attributes.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches complete character information including attributes, optionally filtered by character IDs.
|
|
* @param userId - The unique identifier of the user
|
|
* @param bookId - The unique identifier of the book
|
|
* @param tags - An optional array of character IDs to filter by
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns An array of complete character results with attributes
|
|
*/
|
|
static fetchCompleteCharacters(userId: string, bookId: string, tags: string[], lang: 'fr' | 'en' = 'fr'): CompleteCharacterResult[] {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
let query: string = 'SELECT charac.character_id, first_name, last_name, category, title, role, biography, history, attribute_name, attribute_value FROM book_characters AS charac LEFT JOIN book_characters_attributes AS attr ON charac.character_id=attr.character_id WHERE charac.user_id=? AND charac.book_id=?';
|
|
let params: SQLiteValue[] = [userId, bookId];
|
|
if (tags && tags.length > 0) {
|
|
const placeholders: string = tags.map((): string => '?').join(',');
|
|
query += ` AND charac.character_id IN (${placeholders})`;
|
|
params.push(...tags);
|
|
}
|
|
const characters: CompleteCharacterResult[] = db.all(query, params) as CompleteCharacterResult[];
|
|
if (characters.length === 0) {
|
|
throw new Error(lang === 'fr' ? `Aucun personnage complet trouvé.` : `No complete characters found.`);
|
|
}
|
|
return characters;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de récupérer les personnages complets.` : `Unable to retrieve complete characters.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates an existing character attribute.
|
|
* @param userId - The unique identifier of the user
|
|
* @param characterAttributeId - The unique identifier of the attribute to update
|
|
* @param attributeName - The new attribute name
|
|
* @param attributeValue - The new attribute value
|
|
* @param lastUpdate - The timestamp of the last update
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns True if the update was successful, false otherwise
|
|
*/
|
|
static updateCharacterAttribute(userId: string, characterAttributeId: string, attributeName: string, attributeValue: string, lastUpdate: number, lang: "fr" | "en"): boolean {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'UPDATE `book_characters_attributes` SET `attribute_name`=?,`attribute_value`=?, last_update=FROM_UNIXTIME(?) WHERE `attr_id`=UUID_TO_BIN(?) AND `user_id`=UUID_TO_BIN(?)';
|
|
const params: SQLiteValue[] = [attributeName, attributeValue, lastUpdate, characterAttributeId, userId];
|
|
const updateResult: RunResult = db.run(query, params);
|
|
return updateResult.changes > 0;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de mettre à jour l'attribut du personnage.` : `Unable to update character attribute.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if a character exists in the database.
|
|
* @param userId - The unique identifier of the user
|
|
* @param characterId - The unique identifier of the character to check
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns True if the character exists, false otherwise
|
|
*/
|
|
static isCharacterExist(userId: string, characterId: string, lang: "fr" | "en"): boolean {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'SELECT 1 FROM `book_characters` WHERE `character_id`=? AND `user_id`=?';
|
|
const params: SQLiteValue[] = [characterId, userId];
|
|
const character: QueryResult | null = db.get(query, params) || null;
|
|
return character !== null;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de vérifier l'existence du personnage.` : `Unable to check character existence.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if a character attribute exists in the database.
|
|
* @param userId - The unique identifier of the user
|
|
* @param characterAttributeId - The unique identifier of the attribute to check
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns True if the attribute exists, false otherwise
|
|
*/
|
|
static isCharacterAttributeExist(userId: string, characterAttributeId: string, lang: "fr" | "en"): boolean {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'SELECT 1 FROM `book_characters_attributes` WHERE `attr_id`=? AND `user_id`=?';
|
|
const params: SQLiteValue[] = [characterAttributeId, userId];
|
|
const attribute: QueryResult | null = db.get(query, params) || null;
|
|
return attribute !== null;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de vérifier l'existence de l'attribut du personnage.` : `Unable to check character attribute existence.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches all characters for a specific book asynchronously.
|
|
* @param userId - The unique identifier of the user
|
|
* @param bookId - The unique identifier of the book
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns A promise resolving to an array of book characters
|
|
*/
|
|
static async fetchBookCharacters(userId: string, bookId: string, lang: 'fr' | 'en'): Promise<BookCharactersTable[]> {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'SELECT character_id, book_id, user_id, first_name, last_name, category, title, image, role, biography, history, last_update FROM book_characters WHERE user_id=? AND book_id=?';
|
|
const params: SQLiteValue[] = [userId, bookId];
|
|
const characters: BookCharactersTable[] = db.all(query, params) as BookCharactersTable[];
|
|
return characters;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de récupérer les personnages.` : `Unable to retrieve characters.`);
|
|
} else {
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches all attributes for a specific character asynchronously.
|
|
* @param userId - The unique identifier of the user
|
|
* @param characterId - The unique identifier of the character
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns A promise resolving to an array of character attributes
|
|
*/
|
|
static async fetchBookCharactersAttributes(userId: string, characterId: string, lang: 'fr' | 'en'): Promise<BookCharactersAttributesTable[]> {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'SELECT attr_id, character_id, user_id, attribute_name, attribute_value, last_update FROM book_characters_attributes WHERE user_id=? AND character_id=?';
|
|
const params: SQLiteValue[] = [userId, characterId];
|
|
const attributes: BookCharactersAttributesTable[] = db.all(query, params) as BookCharactersAttributesTable[];
|
|
return attributes;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de récupérer les attributs des personnages.` : `Unable to retrieve character attributes.`);
|
|
} else {
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches all synced characters for a user.
|
|
* @param userId - The unique identifier of the user
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns An array of synced character results
|
|
*/
|
|
static fetchSyncedCharacters(userId: string, lang: 'fr' | 'en'): SyncedCharacterResult[] {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'SELECT character_id, book_id, first_name, last_update FROM book_characters WHERE user_id = ?';
|
|
const params: SQLiteValue[] = [userId];
|
|
const syncedCharacters: SyncedCharacterResult[] = db.all(query, params) as SyncedCharacterResult[];
|
|
return syncedCharacters;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de récupérer les personnages synchronisés.` : `Unable to retrieve synced characters.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches all synced character attributes for a user.
|
|
* @param userId - The unique identifier of the user
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns An array of synced character attribute results
|
|
*/
|
|
static fetchSyncedCharacterAttributes(userId: string, lang: 'fr' | 'en'): SyncedCharacterAttributeResult[] {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = 'SELECT attr_id, character_id, attribute_name, last_update FROM book_characters_attributes WHERE user_id = ?';
|
|
const params: SQLiteValue[] = [userId];
|
|
const syncedAttributes: SyncedCharacterAttributeResult[] = db.all(query, params) as SyncedCharacterAttributeResult[];
|
|
return syncedAttributes;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible de récupérer les attributs des personnages synchronisés.` : `Unable to retrieve synced character attributes.`);
|
|
} else {
|
|
console.error("An unknown error occurred.");
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Inserts a synced character into the database.
|
|
* @param characterId - The unique identifier of the character
|
|
* @param bookId - The unique identifier of the book
|
|
* @param userId - The unique identifier of the user
|
|
* @param firstName - The first name of the character
|
|
* @param lastName - The last name of the character (nullable)
|
|
* @param category - The category of the character
|
|
* @param title - The title of the character (nullable)
|
|
* @param image - The image path of the character (nullable)
|
|
* @param role - The role of the character (nullable)
|
|
* @param biography - The biography of the character (nullable)
|
|
* @param history - The history of the character (nullable)
|
|
* @param lastUpdate - The timestamp of the last update
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns True if the insertion was successful, false otherwise
|
|
*/
|
|
static insertSyncCharacter(characterId: string, bookId: string, userId: string, firstName: string, lastName: string | null, category: string, title: string | null, image: string | null, role: string | null, biography: string | null, history: string | null, lastUpdate: number, lang: 'fr' | 'en'): boolean {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = `INSERT INTO book_characters (character_id, book_id, user_id, first_name, last_name, category, title, image, role, biography, history, last_update)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
|
|
const params: SQLiteValue[] = [characterId, bookId, userId, firstName, lastName, category, title, image, role, biography, history, lastUpdate];
|
|
const insertResult: RunResult = db.run(query, params);
|
|
return insertResult.changes > 0;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible d'insérer le personnage.` : `Unable to insert character.`);
|
|
} else {
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Inserts a synced character attribute into the database.
|
|
* @param attrId - The unique identifier of the attribute
|
|
* @param characterId - The unique identifier of the character
|
|
* @param userId - The unique identifier of the user
|
|
* @param attributeName - The name of the attribute
|
|
* @param attributeValue - The value of the attribute
|
|
* @param lastUpdate - The timestamp of the last update
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns True if the insertion was successful, false otherwise
|
|
*/
|
|
static insertSyncCharacterAttribute(attrId: string, characterId: string, userId: string, attributeName: string, attributeValue: string, lastUpdate: number, lang: 'fr' | 'en'): boolean {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = `INSERT INTO book_characters_attributes (attr_id, character_id, user_id, attribute_name, attribute_value, last_update)
|
|
VALUES (?, ?, ?, ?, ?, ?)`;
|
|
const params: SQLiteValue[] = [attrId, characterId, userId, attributeName, attributeValue, lastUpdate];
|
|
const insertResult: RunResult = db.run(query, params);
|
|
return insertResult.changes > 0;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
console.error(`DB Error: ${error.message}`);
|
|
throw new Error(lang === 'fr' ? `Impossible d'insérer l'attribut du personnage.` : `Unable to insert character attribute.`);
|
|
} else {
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches a complete character by its ID.
|
|
* @param id - The unique identifier of the character
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns A promise resolving to an array of book characters (typically one)
|
|
*/
|
|
static async fetchCompleteCharacterById(id: string, lang: "fr" | "en"): Promise<BookCharactersTable[]> {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = `SELECT character_id, book_id, user_id, first_name, last_name, category, title, image, role, biography, history, last_update
|
|
FROM book_characters
|
|
WHERE character_id = ?`;
|
|
const params: SQLiteValue[] = [id];
|
|
const character: BookCharactersTable[] = db.all(query, params) as BookCharactersTable[];
|
|
return character;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
throw new Error(lang === 'fr' ? `Impossible de récupérer le personnage complet.` : `Unable to retrieve complete character.`);
|
|
} else {
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches a complete character attribute by its ID.
|
|
* @param id - The unique identifier of the attribute
|
|
* @param lang - The language for error messages ('fr' or 'en')
|
|
* @returns A promise resolving to an array of character attributes (typically one)
|
|
*/
|
|
static async fetchCompleteCharacterAttributeById(id: string, lang: "fr" | "en"): Promise<BookCharactersAttributesTable[]> {
|
|
try {
|
|
const db: Database = System.getDb();
|
|
const query: string = `SELECT attr_id, character_id, user_id, attribute_name, attribute_value, last_update
|
|
FROM book_characters_attributes
|
|
WHERE attr_id = ?`;
|
|
const params: SQLiteValue[] = [id];
|
|
const attribute: BookCharactersAttributesTable[] = db.all(query, params) as BookCharactersAttributesTable[];
|
|
return attribute;
|
|
} catch (error: unknown) {
|
|
if (error instanceof Error) {
|
|
throw new Error(lang === 'fr' ? `Impossible de récupérer l'attribut de personnage complet.` : `Unable to retrieve complete character attribute.`);
|
|
} else {
|
|
throw new Error(lang === 'fr' ? "Une erreur inconnue s'est produite." : "An unknown error occurred.");
|
|
}
|
|
}
|
|
}
|
|
}
|