natgitadm/ERitors-Scribe-Desktop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate from window.electron to tauri IPC functions across components

Browse Source 
- Replaced `window.electron.invoke` calls with equivalent `tauri` function calls for all IPC interactions.
- Removed `electron.d.ts` TypeScript definitions as they are no longer needed.
- Updated related logic for offline/online state synchronization.
- Added `types.rs` and `shared/mod.rs` modules to support Tauri IPC integration with Rust enums and shared logic.
- Refactored IPC request queues to use updated handler names for consistency with Tauri.
This commit is contained in:
natreex
2026-03-21 09:34:13 -04:00
parent 1a15692e40
commit ee4438834c
144 changed files with 21258 additions and 876 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
hooks/settings/useCharacters.ts
View File

@@ -2,6 +2,7 @@
import {useCallback, useContext, useEffect, useState} from 'react';
import {Attribute, CharacterListResponse, CharacterProps} from '@/lib/models/Character';
import {SeriesCharacterProps} from '@/lib/models/Series';
import * as tauri from '@/lib/tauri';
import {SessionContext} from '@/context/SessionContext';
import {BookContext} from '@/context/BookContext';
import {AlertContext} from '@/context/AlertContext';
@@ -147,10 +148,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let response: SeriesCharacterProps[];
// Dual logic: offline ou livre local → IPC, sinon serveur
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<SeriesCharacterProps[]>(
'db:series:character:list',
{seriesId: bookSeriesId}
);
response = await tauri.getSeriesCharacterList(bookSeriesId);
} else {
response = await System.authGetQueryToServer<SeriesCharacterProps[]>(
'series/character/list',
@@ -176,10 +174,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
// Series mode - dual logic
let response: SeriesCharacterProps[];
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<SeriesCharacterProps[]>(
'db:series:character:list',
{seriesId: entityId}
);
response = await tauri.getSeriesCharacterList(entityId);
} else {
response = await System.authGetQueryToServer<SeriesCharacterProps[]>(
'series/character/list',
@@ -231,11 +226,11 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
// Pattern B: GET dans contexte livre
let response: CharacterListResponse;
if (isCurrentlyOffline()) {
// Offline → IPC
response = await window.electron.invoke<CharacterListResponse>('db:character:list', {bookid: entityId});
// Offline → Tauri
response = await tauri.getCharacterList(entityId, true) as CharacterListResponse;
} else if (book?.localBook) {
// Online mais livre local → IPC
response = await window.electron.invoke<CharacterListResponse>('db:character:list', {bookid: entityId});
// Online mais livre local → Tauri
response = await tauri.getCharacterList(entityId, true) as CharacterListResponse;
} else {
// Online + livre serveur → Server
response = await System.authGetQueryToServer<CharacterListResponse>(
@@ -306,15 +301,15 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let response: boolean;
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
response = await window.electron.invoke<boolean>('db:book:tool:update', requestData);
// Offline OU livre local → Tauri
response = await tauri.updateBookToolSetting(requestData.bookId, requestData.toolName, requestData.enabled);
} else {
// Online + livre serveur → Server
response = await System.authPatchToServer<boolean>('book/tool-setting', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (book?.bookId && localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === book.bookId)) {
addToQueue('db:book:tool:update', requestData);
addToQueue('update_book_tool_setting', {data: requestData});
}
}
@@ -385,7 +380,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
}
};
if (isCurrentlyOffline() || localSeries) {
characterId = await window.electron.invoke<string>('db:series:character:add', seriesCharacterData);
characterId = await tauri.addSeriesCharacter(seriesCharacterData);
} else {
characterId = await System.authPostToServer<string>(
'series/character/add',
@@ -394,7 +389,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
lang
);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:add', {...seriesCharacterData, id: characterId});
addToQueue('add_series_character', {data: {...seriesCharacterData, id: characterId}});
}
}
} else {
@@ -405,15 +400,15 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
};
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
characterId = await window.electron.invoke<string>('db:character:create', requestData);
// Offline OU livre local → Tauri
characterId = await tauri.createCharacter(requestData.character, requestData.bookId, requestData.id);
} else {
// Online + livre serveur → Server
characterId = await System.authPostToServer<string>('character/add', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:create', {...requestData, id: characterId});
addToQueue('create_character', {data: {...requestData, id: characterId}});
}
}
}
@@ -470,11 +465,11 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
}
};
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<boolean>('db:series:character:update', updateData);
response = await tauri.updateSeriesCharacter(updateData);
} else {
response = await System.authPatchToServer<boolean>('series/character/update', updateData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:update', updateData);
addToQueue('update_series_character', {data: updateData});
}
}
} else {
@@ -484,15 +479,15 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
};
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
response = await window.electron.invoke<boolean>('db:character:update', requestData);
// Offline OU livre local → Tauri
response = await tauri.updateCharacter(requestData.character);
} else {
// Online + livre serveur → Server
response = await System.authPostToServer<boolean>('character/update', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:update', requestData);
addToQueue('update_character', {data: requestData});
}
}
}
@@ -529,26 +524,26 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
// Series mode - dual logic
const requestData = {characterId, deletedAt};
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<boolean>('db:series:character:delete', requestData);
response = await tauri.deleteSeriesCharacter(requestData.characterId, requestData.deletedAt);
} else {
response = await System.authDeleteToServer<boolean>('series/character/delete', requestData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:delete', requestData);
addToQueue('delete_series_character', {data: requestData});
}
}
} else {
// Pattern A: mutations
const requestData = {characterId, bookId: entityId, deletedAt};
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
response = await window.electron.invoke<boolean>('db:character:delete', requestData);
// Offline OU livre local → Tauri
response = await tauri.deleteCharacter(requestData.characterId, requestData.bookId, requestData.deletedAt);
} else {
// Online + livre serveur → Server
response = await System.authDeleteToServer<boolean>('character/delete', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:delete', requestData);
addToQueue('delete_character', {data: requestData});
}
}
}
@@ -595,25 +590,25 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
if (isSeriesMode) {
// Series mode - dual logic
if (isCurrentlyOffline() || localSeries) {
attributeId = await window.electron.invoke<string>('db:series:character:attribute:add', requestData);
attributeId = await tauri.addSeriesCharacterAttribute(requestData);
} else {
attributeId = await System.authPostToServer<string>('series/character/attribute/add', requestData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:attribute:add', {...requestData, id: attributeId});
addToQueue('add_series_character_attribute', {data: {...requestData, id: attributeId}});
}
}
} else {
// Pattern A: mutations
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
attributeId = await window.electron.invoke<string>('db:character:attribute:add', requestData);
// Offline OU livre local → Tauri
attributeId = await tauri.addCharacterAttribute(requestData.characterId, requestData.type, requestData.name, requestData.id);
} else {
// Online + livre serveur → Server
attributeId = await System.authPostToServer<string>('character/attribute/add', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:attribute:add', {...requestData, id: attributeId});
addToQueue('add_character_attribute', {data: {...requestData, id: attributeId}});
}
}
}
@@ -658,26 +653,26 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
// Series mode - dual logic
const requestData = {attributeId: attrId, deletedAt};
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<boolean>('db:series:character:attribute:delete', requestData);
response = await tauri.deleteSeriesCharacterAttribute(requestData.attributeId, requestData.deletedAt);
} else {
response = await System.authDeleteToServer<boolean>('series/character/attribute/delete', requestData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:attribute:delete', requestData);
addToQueue('delete_series_character_attribute', {data: requestData});
}
}
} else {
// Pattern A: mutations
const requestData = {attributeId: attrId, bookId: entityId, deletedAt};
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
response = await window.electron.invoke<boolean>('db:character:attribute:delete', requestData);
// Offline OU livre local → Tauri
response = await tauri.deleteCharacterAttribute(requestData.attributeId, requestData.bookId, requestData.deletedAt);
} else {
// Online + livre serveur → Server
response = await System.authDeleteToServer<boolean>('character/attribute/delete', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:attribute:delete', requestData);
addToQueue('delete_character_attribute', {data: requestData});
}
}
}
@@ -734,8 +729,8 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let seriesCharacterId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
seriesCharacterId = await window.electron.invoke<string>('db:series:character:add', seriesCharacterData);
// Mode offline ou livre local → Tauri
seriesCharacterId = await tauri.addSeriesCharacter(seriesCharacterData);
} else {
// Mode online → Serveur
seriesCharacterId = await System.authPostToServer<string>(
@@ -746,7 +741,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
);
// Si la série a une copie locale → addToQueue
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === bookSeriesId)) {
addToQueue('db:series:character:add', {...seriesCharacterData, id: seriesCharacterId});
addToQueue('add_series_character', {data: {...seriesCharacterData, id: seriesCharacterId}});
}
}
@@ -760,14 +755,14 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let updateResponse: boolean;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
updateResponse = await window.electron.invoke<boolean>('db:character:update', updateData);
// Mode offline ou livre local → Tauri
updateResponse = await tauri.updateCharacter(updateData.character);
} else {
// Mode online → Serveur
updateResponse = await System.authPostToServer<boolean>('character/update', updateData, userToken, lang);
// Si le livre a une copie locale → addToQueue
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:update', updateData);
addToQueue('update_character', {data: updateData});
}
}
@@ -869,14 +864,14 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let characterId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
characterId = await window.electron.invoke<string>('db:character:create', requestData);
// Mode offline ou livre local → Tauri
characterId = await tauri.createCharacter(requestData.character, requestData.bookId, requestData.id);
} else {
// Mode online → Serveur
characterId = await System.authPostToServer<string>('character/add', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:create', {...requestData, id: characterId});
addToQueue('create_character', {data: {...requestData, id: characterId}});
}
}

101
hooks/settings/useLocations.ts
View File

@@ -15,6 +15,7 @@ import {SyncedBook} from '@/lib/models/SyncedBook';
import {SeriesContext, SeriesContextProps} from '@/context/SeriesContext';
import {SeriesSyncContext, SeriesSyncContextProps} from '@/context/SeriesSyncContext';
import {SyncedSeries} from '@/lib/models/SyncedSeries';
import * as tauri from '@/lib/tauri';
export interface SubElement {
id: string;
@@ -142,10 +143,7 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
let response: SeriesLocationItem[];
// Dual logic: offline ou livre local → IPC, sinon serveur
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<SeriesLocationItem[]>(
'db:series:location:list',
{seriesId: bookSeriesId}
);
response = await tauri.getSeriesLocationList(bookSeriesId);
} else {
response = await System.authGetQueryToServer<SeriesLocationItem[]>(
'series/location/list',
@@ -171,10 +169,7 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
// Series mode - dual logic
let response: SeriesLocationItem[];
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<SeriesLocationItem[]>(
'db:series:location:list',
{seriesId: entityId}
);
response = await tauri.getSeriesLocationList(entityId);
} else {
response = await System.authGetQueryToServer<SeriesLocationItem[]>(
'series/location/list',
@@ -209,9 +204,9 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
} else {
let response: LocationListResponse;
if (isCurrentlyOffline()) {
response = await window.electron.invoke<LocationListResponse>('db:location:all', {bookid: entityId});
response = await tauri.getAllLocations(entityId, true) as unknown as LocationListResponse;
} else if (book?.localBook) {
response = await window.electron.invoke<LocationListResponse>('db:location:all', {bookid: entityId});
response = await tauri.getAllLocations(entityId, true) as unknown as LocationListResponse;
} else {
response = await System.authGetQueryToServer<LocationListResponse>(
'location/all',
@@ -257,12 +252,12 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
};
let response: boolean;
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<boolean>('db:book:tool:update', requestData);
response = await tauri.updateBookToolSetting(requestData.bookId!, requestData.toolName, requestData.enabled);
} else {
response = await System.authPatchToServer<boolean>('book/tool-setting', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === book?.bookId)) {
addToQueue('db:book:tool:update', requestData);
addToQueue('update_book_tool_setting', {data: requestData});
}
}
if (response && setBook && book) {
@@ -300,7 +295,7 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
name: newSectionName,
};
if (isCurrentlyOffline() || localSeries) {
sectionId = await window.electron.invoke<string>('db:series:location:section:add', addData);
sectionId = await tauri.addSeriesLocationSection(addData);
} else {
sectionId = await System.authPostToServer<string>(
'series/location/section/add',
@@ -309,7 +304,7 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
lang
);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:location:section:add', {...addData, id: sectionId});
addToQueue('add_series_location_section', {data: {...addData, id: sectionId}});
}
}
if (!sectionId) {
@@ -322,12 +317,12 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
locationName: newSectionName,
};
if (isCurrentlyOffline() || book?.localBook) {
sectionId = await window.electron.invoke<string>('db:location:section:add', requestData);
sectionId = await tauri.addLocationSection(requestData.locationName, requestData.bookId, undefined, undefined);
} else {
sectionId = await System.authPostToServer<string>('location/section/add', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:section:add', {...requestData, id: sectionId});
addToQueue('add_location_section', {data: {...requestData, id: sectionId}});
}
}
if (!sectionId) {
@@ -371,7 +366,7 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
name: newElementNames[sectionId],
};
if (isCurrentlyOffline() || localSeries) {
elementId = await window.electron.invoke<string>('db:series:location:element:add', addData);
elementId = await tauri.addSeriesLocationElement(addData);
} else {
elementId = await System.authPostToServer<string>(
'series/location/element/add',
@@ -380,7 +375,7 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
lang
);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:location:element:add', {...addData, id: elementId});
addToQueue('add_series_location_element', {data: {...addData, id: elementId}});
}
}
if (!elementId) {
@@ -394,12 +389,12 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
elementName: newElementNames[sectionId],
};
if (isCurrentlyOffline() || book?.localBook) {
elementId = await window.electron.invoke<string>('db:location:element:add', requestData);
elementId = await tauri.addLocationElement(requestData.locationId, requestData.elementName, undefined);
} else {
elementId = await System.authPostToServer<string>('location/element/add', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:element:add', {...requestData, id: elementId});
addToQueue('add_location_element', {data: {...requestData, id: elementId}});
}
}
if (!elementId) {
@@ -453,7 +448,7 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
name: newSubElementNames[elementIndex],
};
if (isCurrentlyOffline() || localSeries) {
subElementId = await window.electron.invoke<string>('db:series:location:subelement:add', addData);
subElementId = await tauri.addSeriesLocationSubElement(addData);
} else {
subElementId = await System.authPostToServer<string>(
'series/location/sub-element/add',
@@ -462,7 +457,7 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
lang
);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:location:subelement:add', {...addData, id: subElementId});
addToQueue('add_series_location_sub_element', {data: {...addData, id: subElementId}});
}
}
if (!subElementId) {
@@ -475,12 +470,12 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
subElementName: newSubElementNames[elementIndex],
};
if (isCurrentlyOffline() || book?.localBook) {
subElementId = await window.electron.invoke<string>('db:location:subelement:add', requestData);
subElementId = await tauri.addLocationSubElement(requestData.elementId, requestData.subElementName, undefined);
} else {
subElementId = await System.authPostToServer<string>('location/sub-element/add', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:subelement:add', {...requestData, id: subElementId});
addToQueue('add_location_sub_element', {data: {...requestData, id: subElementId}});
}
}
if (!subElementId) {
@@ -519,11 +514,11 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
// Series mode - dual logic
const deleteData = {locationId: sectionId, deletedAt};
if (isCurrentlyOffline() || localSeries) {
success = await window.electron.invoke<boolean>('db:series:location:delete', deleteData);
success = await tauri.deleteSeriesLocation(deleteData.locationId, deleteData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('series/location/delete', deleteData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:location:delete', deleteData);
addToQueue('delete_series_location', {data: deleteData});
}
}
} else {
@@ -531,12 +526,12 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
locationId: sectionId, bookId: entityId, deletedAt,
};
if (isCurrentlyOffline() || book?.localBook) {
success = await window.electron.invoke<boolean>('db:location:delete', requestData);
success = await tauri.deleteLocationSection(requestData.locationId, requestData.bookId, requestData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('location/delete', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:delete', requestData);
addToQueue('delete_location_section', {data: requestData});
}
}
}
@@ -569,11 +564,11 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
// Series mode - dual logic
const deleteData = {elementId, deletedAt};
if (isCurrentlyOffline() || localSeries) {
success = await window.electron.invoke<boolean>('db:series:location:element:delete', deleteData);
success = await tauri.deleteSeriesLocationElement(deleteData.elementId!, deleteData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('series/location/element/delete', deleteData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:location:element:delete', deleteData);
addToQueue('delete_series_location_element', {data: deleteData});
}
}
} else {
@@ -581,12 +576,12 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
elementId, bookId: entityId, deletedAt,
};
if (isCurrentlyOffline() || book?.localBook) {
success = await window.electron.invoke<boolean>('db:location:element:delete', requestData);
success = await tauri.deleteLocationElement(requestData.elementId!, requestData.bookId, requestData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('location/element/delete', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:element:delete', requestData);
addToQueue('delete_location_element', {data: requestData});
}
}
}
@@ -622,11 +617,11 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
// Series mode - dual logic
const deleteData = {subElementId, deletedAt};
if (isCurrentlyOffline() || localSeries) {
success = await window.electron.invoke<boolean>('db:series:location:subelement:delete', deleteData);
success = await tauri.deleteSeriesLocationSubElement(deleteData.subElementId!, deleteData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('series/location/sub-element/delete', deleteData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:location:subelement:delete', deleteData);
addToQueue('delete_series_location_sub_element', {data: deleteData});
}
}
} else {
@@ -634,12 +629,12 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
subElementId, bookId: entityId, deletedAt,
};
if (isCurrentlyOffline() || book?.localBook) {
success = await window.electron.invoke<boolean>('db:location:subelement:delete', requestData);
success = await tauri.deleteLocationSubElement(requestData.subElementId!, requestData.bookId, requestData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('location/sub-element/delete', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:subelement:delete', requestData);
addToQueue('delete_location_sub_element', {data: requestData});
}
}
}
@@ -694,12 +689,12 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
};
let response: boolean;
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<boolean>('db:location:update', requestData);
response = await tauri.updateLocations(requestData.locations);
} else {
response = await System.authPostToServer<boolean>('location/update', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:update', requestData);
addToQueue('update_locations', {data: requestData});
}
}
if (!response) {
@@ -729,14 +724,14 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
let seriesLocationId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
seriesLocationId = await window.electron.invoke<string>('db:series:location:section:add', seriesLocationData);
// Mode offline ou livre local → Tauri
seriesLocationId = await tauri.addSeriesLocationSection(seriesLocationData);
} else {
// Mode online → Serveur
seriesLocationId = await System.authPostToServer<string>('series/location/section/add', seriesLocationData, userToken, lang);
// Si la série a une copie locale → addToQueue avec l'ID du serveur
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === bookSeriesId)) {
addToQueue('db:series:location:section:add', {...seriesLocationData, id: seriesLocationId});
addToQueue('add_series_location_section', {data: {...seriesLocationData, id: seriesLocationId}});
}
}
@@ -749,14 +744,14 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
let updateResponse: boolean;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
updateResponse = await window.electron.invoke<boolean>('db:location:section:update', updateData);
// Mode offline ou livre local → Tauri
updateResponse = await tauri.updateLocationSectionWithSeriesLink(updateData.sectionId, updateData.sectionName, updateData.seriesLocationId);
} else {
// Mode online → Serveur
updateResponse = await System.authPostToServer<boolean>('location/section/update', updateData, userToken, lang);
// Si le livre a une copie locale → addToQueue
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:section:update', updateData);
addToQueue('update_location_section_with_series_link', {data: updateData});
}
}
@@ -799,14 +794,14 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
let sectionId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
sectionId = await window.electron.invoke<string>('db:location:section:add', sectionData);
// Mode offline ou livre local → Tauri
sectionId = await tauri.addLocationSection(sectionData.locationName, sectionData.bookId, undefined, sectionData.seriesLocationId);
} else {
// Mode online → Serveur
sectionId = await System.authPostToServer<string>('location/section/add', sectionData, userToken, lang);
// Si le livre a une copie locale → addToQueue avec l'ID du serveur
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:section:add', {...sectionData, id: sectionId});
addToQueue('add_location_section', {data: {...sectionData, id: sectionId}});
}
}
@@ -826,14 +821,14 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
let elementId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
elementId = await window.electron.invoke<string>('db:location:element:add', elementData);
// Mode offline ou livre local → Tauri
elementId = await tauri.addLocationElement(elementData.locationId, elementData.elementName, undefined);
} else {
// Mode online → Serveur
elementId = await System.authPostToServer<string>('location/element/add', elementData, userToken, lang);
// Si le livre a une copie locale → addToQueue avec l'ID du serveur
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:element:add', {...elementData, id: elementId});
addToQueue('add_location_element', {data: {...elementData, id: elementId}});
}
}
@@ -849,14 +844,14 @@ export function useLocations(config: UseLocationsConfig): UseLocationsReturn {
let subElementId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
subElementId = await window.electron.invoke<string>('db:location:subelement:add', subElementData);
// Mode offline ou livre local → Tauri
subElementId = await tauri.addLocationSubElement(subElementData.elementId, subElementData.subElementName, undefined);
} else {
// Mode online → Serveur
subElementId = await System.authPostToServer<string>('location/sub-element/add', subElementData, userToken, lang);
// Si le livre a une copie locale → addToQueue avec l'ID du serveur
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:location:subelement:add', {...subElementData, id: subElementId});
addToQueue('add_location_sub_element', {data: {...subElementData, id: subElementId}});
}
}

109
hooks/settings/useSpells.ts
View File

@@ -23,6 +23,7 @@ import {SyncedBook} from '@/lib/models/SyncedBook';
import {SeriesContext, SeriesContextProps} from '@/context/SeriesContext';
import {SeriesSyncContext, SeriesSyncContextProps} from '@/context/SeriesSyncContext';
import {SyncedSeries} from '@/lib/models/SyncedSeries';
import * as tauri from '@/lib/tauri';
export interface UseSpellsConfig {
entityType: 'book' | 'series';
@@ -113,10 +114,7 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
let response: SeriesSpellListResponse;
// Dual logic: offline ou livre local → IPC, sinon serveur
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<SeriesSpellListResponse>(
'db:series:spell:list',
{seriesId: bookSeriesId}
);
response = await tauri.getSeriesSpellList(bookSeriesId) as SeriesSpellListResponse;
} else {
response = await System.authGetQueryToServer<SeriesSpellListResponse>(
'series/spell/list',
@@ -142,10 +140,7 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
// Series mode - dual logic
let response: SeriesSpellListResponse;
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<SeriesSpellListResponse>(
'db:series:spell:list',
{seriesId: entityId}
);
response = await tauri.getSeriesSpellList(entityId) as SeriesSpellListResponse;
} else {
response = await System.authGetQueryToServer<SeriesSpellListResponse>(
'series/spell/list',
@@ -174,9 +169,9 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
} else {
let response: SpellListResponse;
if (isCurrentlyOffline()) {
response = await window.electron.invoke<SpellListResponse>('db:spell:list', {bookid: entityId});
response = await tauri.getSpellList(entityId, true) as SpellListResponse;
} else if (book?.localBook) {
response = await window.electron.invoke<SpellListResponse>('db:spell:list', {bookid: entityId});
response = await tauri.getSpellList(entityId, true) as SpellListResponse;
} else {
response = await System.authGetQueryToServer<SpellListResponse>(
'spell/list',
@@ -242,10 +237,7 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
// Series mode - dual logic
let response: SeriesSpellDetailResponse;
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<SeriesSpellDetailResponse>(
'db:series:spell:detail',
{spellId: spell.id}
);
response = await tauri.getSeriesSpellDetail(spell.id) as SeriesSpellDetailResponse;
} else {
response = await System.authGetQueryToServer<SeriesSpellDetailResponse>(
'series/spell/detail',
@@ -270,9 +262,9 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
} else {
let response: SpellProps;
if (isCurrentlyOffline()) {
response = await window.electron.invoke<SpellProps>('db:spell:detail', {spellid: spell.id});
response = await tauri.getSpellDetail(spell.id) as SpellProps;
} else if (book?.localBook) {
response = await window.electron.invoke<SpellProps>('db:spell:detail', {spellid: spell.id});
response = await tauri.getSpellDetail(spell.id) as SpellProps;
} else {
response = await System.authGetQueryToServer<SpellProps>(
'spell/detail',
@@ -298,10 +290,7 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
if (response.seriesSpellId) {
let seriesSpellResponse: SeriesSpellDetailResponse;
if (isCurrentlyOffline() || book?.localBook) {
seriesSpellResponse = await window.electron.invoke<SeriesSpellDetailResponse>(
'db:series:spell:detail',
{spellId: response.seriesSpellId}
);
seriesSpellResponse = await tauri.getSeriesSpellDetail(response.seriesSpellId) as SeriesSpellDetailResponse;
} else {
seriesSpellResponse = await System.authGetQueryToServer<SeriesSpellDetailResponse>(
'series/spell/detail',
@@ -353,11 +342,11 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
};
let response: boolean;
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<boolean>('db:book:tool:update', requestData);
response = await tauri.updateBookToolSetting(requestData.bookId, requestData.toolName, requestData.enabled);
} else {
response = await System.authPatchToServer<boolean>('book/tool-setting', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === book?.bookId)) {
addToQueue('db:book:tool:update', requestData);
addToQueue('update_book_tool_setting', {data: requestData});
}
}
if (response && setBook && book) {
@@ -410,11 +399,11 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
notes: spell.notes,
};
if (isCurrentlyOffline() || localSeries) {
newSpellId = await window.electron.invoke<string>('db:series:spell:add', data);
newSpellId = await tauri.addSeriesSpell(data);
} else {
newSpellId = await System.authPostToServer<string>('series/spell/add', data, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:spell:add', {...data, id: newSpellId});
addToQueue('add_series_spell', {data: {...data, id: newSpellId}});
}
}
} else {
@@ -432,11 +421,11 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
}
};
if (isCurrentlyOffline() || book?.localBook) {
newSpellId = await window.electron.invoke<string>('db:spell:create', data);
newSpellId = await tauri.createSpell(data.bookId, data.spell);
} else {
newSpellId = await System.authPostToServer<string>('spell/add', data, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:spell:create', {...data, id: newSpellId});
addToQueue('create_spell', {data: {...data, id: newSpellId}});
}
}
}
@@ -492,20 +481,20 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
if (isSeriesMode) {
// Series mode - dual logic
if (isCurrentlyOffline() || localSeries) {
success = await window.electron.invoke<boolean>('db:series:spell:update', data);
success = await tauri.updateSeriesSpell(data);
} else {
success = await System.authPutToServer<boolean>('series/spell/update', data, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:spell:update', data);
addToQueue('update_series_spell', {data});
}
}
} else {
if (isCurrentlyOffline() || book?.localBook) {
success = await window.electron.invoke<boolean>('db:spell:update', data);
success = await tauri.updateSpell(data.id, data);
} else {
success = await System.authPutToServer<boolean>('spell/update', data, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:spell:update', data);
addToQueue('update_spell', {data});
}
}
}
@@ -549,21 +538,21 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
// Series mode - dual logic
const requestData = {spellId, deletedAt};
if (isCurrentlyOffline() || localSeries) {
success = await window.electron.invoke<boolean>('db:series:spell:delete', requestData);
success = await tauri.deleteSeriesSpell(requestData.spellId, requestData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('series/spell/delete', requestData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:spell:delete', requestData);
addToQueue('delete_series_spell', {data: requestData});
}
}
} else {
const requestData = {spellId, bookId: entityId, deletedAt};
if (isCurrentlyOffline() || book?.localBook) {
success = await window.electron.invoke<boolean>('db:spell:delete', requestData);
success = await tauri.deleteSpell(requestData.spellId, requestData.bookId, requestData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('spell/delete', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:spell:delete', requestData);
addToQueue('delete_spell', {data: requestData});
}
}
}
@@ -605,7 +594,7 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
let seriesSpellId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
seriesSpellId = await window.electron.invoke<string>('db:series:spell:add', seriesSpellData);
seriesSpellId = await tauri.addSeriesSpell(seriesSpellData);
} else {
// Mode online → Serveur
seriesSpellId = await System.authPostToServer<string>(
@@ -616,7 +605,7 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
);
// Si la série a une copie locale → addToQueue
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === bookSeriesId)) {
addToQueue('db:series:spell:add', {...seriesSpellData, id: seriesSpellId});
addToQueue('add_series_spell', {data: {...seriesSpellData, id: seriesSpellId}});
}
}
@@ -636,14 +625,14 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
let updateSuccess: boolean;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
updateSuccess = await window.electron.invoke<boolean>('db:spell:update', updateData);
// Mode offline ou livre local → Tauri
updateSuccess = await tauri.updateSpell(updateData.id, updateData);
} else {
// Mode online → Serveur
updateSuccess = await System.authPutToServer<boolean>('spell/update', updateData, userToken, lang);
// Si le livre a une copie locale → addToQueue
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:spell:update', updateData);
addToQueue('update_spell', {data: updateData});
}
}
@@ -680,11 +669,8 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
// 1. Récupérer les détails du sort de la série
let seriesSpellDetail: SeriesSpellDetailResponse;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline → IPC pour récupérer les détails du sort de la série locale
seriesSpellDetail = await window.electron.invoke<SeriesSpellDetailResponse>(
'db:series:spell:detail',
{spellId: seriesSpellId}
);
// Mode offline → Tauri pour récupérer les détails du sort de la série locale
seriesSpellDetail = await tauri.getSeriesSpellDetail(seriesSpellId) as SeriesSpellDetailResponse;
} else {
// Mode online → Serveur
seriesSpellDetail = await System.authGetQueryToServer<SeriesSpellDetailResponse>(
@@ -715,14 +701,14 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
let createdSpellId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
createdSpellId = await window.electron.invoke<string>('db:spell:create', spellData);
// Mode offline ou livre local → Tauri
createdSpellId = await tauri.createSpell(spellData.bookId, spellData.spell);
} else {
// Mode online → Serveur
createdSpellId = await System.authPostToServer<string>('spell/add', spellData, userToken, lang);
// Si le livre a une copie locale → addToQueue
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:spell:create', {...spellData, id: createdSpellId});
addToQueue('create_spell', {data: {...spellData, id: createdSpellId}});
}
}
@@ -758,7 +744,7 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
};
let tagId: string;
if (isCurrentlyOffline() || localSeries) {
tagId = await window.electron.invoke<string>('db:series:spell:tag:add', addData);
tagId = await tauri.addSeriesSpellTag(addData);
} else {
tagId = await System.authPostToServer<string>(
'series/spell/tag/add',
@@ -767,7 +753,7 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
lang
);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:spell:tag:add', {...addData, id: tagId});
addToQueue('add_series_spell_tag', {data: {...addData, id: tagId}});
}
}
if (tagId) {
@@ -786,11 +772,11 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
};
let newTag: SpellTagProps;
if (isCurrentlyOffline() || book?.localBook) {
newTag = await window.electron.invoke<SpellTagProps>('db:spell:tag:create', requestData);
newTag = await tauri.createSpellTag(requestData.bookId, requestData.name, requestData.color) as SpellTagProps;
} else {
newTag = await System.authPostToServer<SpellTagProps>('spell/tag/add', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:spell:tag:create', {...requestData, id: newTag?.id});
addToQueue('create_spell_tag', {data: {...requestData, id: newTag?.id}});
}
}
if (newTag && newTag.id) {
@@ -816,20 +802,20 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
if (isSeriesMode) {
// Series mode - dual logic
if (isCurrentlyOffline() || localSeries) {
success = await window.electron.invoke<boolean>('db:series:spell:tag:update', requestData);
success = await tauri.updateSeriesSpellTag(requestData);
} else {
success = await System.authPutToServer<boolean>('series/spell/tag/update', requestData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:spell:tag:update', requestData);
addToQueue('update_series_spell_tag', {data: requestData});
}
}
} else {
if (isCurrentlyOffline() || book?.localBook) {
success = await window.electron.invoke<boolean>('db:spell:tag:update', requestData);
success = await tauri.updateSpellTag(requestData.tagId, requestData.name, requestData.color);
} else {
success = await System.authPutToServer<boolean>('spell/tag/update', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:spell:tag:update', requestData);
addToQueue('update_spell_tag', {data: requestData});
}
}
}
@@ -859,21 +845,21 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
// Series mode - dual logic
const deleteData = {tagId, deletedAt};
if (isCurrentlyOffline() || localSeries) {
success = await window.electron.invoke<boolean>('db:series:spell:tag:delete', deleteData);
success = await tauri.deleteSeriesSpellTag(deleteData.tagId, deleteData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('series/spell/tag/delete', deleteData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:spell:tag:delete', deleteData);
addToQueue('delete_series_spell_tag', {data: deleteData});
}
}
} else {
const requestData = {tagId, bookId: entityId, deletedAt};
if (isCurrentlyOffline() || book?.localBook) {
success = await window.electron.invoke<boolean>('db:spell:tag:delete', requestData);
success = await tauri.deleteSpellTag(requestData.tagId, requestData.bookId, requestData.deletedAt);
} else {
success = await System.authDeleteToServer<boolean>('spell/tag/delete', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:spell:tag:delete', requestData);
addToQueue('delete_spell_tag', {data: requestData});
}
}
}
@@ -898,10 +884,7 @@ export function useSpells(config: UseSpellsConfig): UseSpellsReturn {
if (selectedSpell?.seriesSpellId) {
let seriesSpellResponse: SeriesSpellDetailResponse;
if (isCurrentlyOffline() || (isSeriesMode ? localSeries : book?.localBook)) {
seriesSpellResponse = await window.electron.invoke<SeriesSpellDetailResponse>(
'db:series:spell:detail',
{spellId: selectedSpell.seriesSpellId}
);
seriesSpellResponse = await tauri.getSeriesSpellDetail(selectedSpell.seriesSpellId) as SeriesSpellDetailResponse;
} else {
seriesSpellResponse = await System.authGetQueryToServer<SeriesSpellDetailResponse>(
'series/spell/detail',

53
hooks/settings/useWorlds.ts
View File

@@ -17,6 +17,7 @@ import System from '@/lib/models/System';
import {useTranslations} from 'next-intl';
import {SelectBoxProps} from '@/shared/interface';
import {ViewMode} from '@/shared/interface';
import * as tauri from '@/lib/tauri';
const initialWorldState: WorldProps = {
id: '',
@@ -135,10 +136,7 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
let response: SeriesWorldProps[];
// Dual logic: offline ou livre local → IPC, sinon serveur
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<SeriesWorldProps[]>(
'db:series:world:list',
{seriesId: bookSeriesId}
);
response = await tauri.getSeriesWorldList(bookSeriesId);
} else {
response = await System.authGetQueryToServer<SeriesWorldProps[]>(
'series/world/list',
@@ -164,10 +162,7 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
// Series mode - dual logic
let response: SeriesWorldProps[];
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<SeriesWorldProps[]>(
'db:series:world:list',
{seriesId: entityId}
);
response = await tauri.getSeriesWorldList(entityId);
} else {
response = await System.authGetQueryToServer<SeriesWorldProps[]>(
'series/world/list',
@@ -212,9 +207,9 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
} else {
let response: WorldListResponse;
if (isCurrentlyOffline()) {
response = await window.electron.invoke<WorldListResponse>('db:book:worlds:get', {bookid: entityId});
response = await tauri.getWorlds(entityId, true) as unknown as WorldListResponse;
} else if (book?.localBook) {
response = await window.electron.invoke<WorldListResponse>('db:book:worlds:get', {bookid: entityId});
response = await tauri.getWorlds(entityId, true) as unknown as WorldListResponse;
} else {
response = await System.authGetQueryToServer<WorldListResponse>(
'book/worlds',
@@ -293,11 +288,11 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
};
let response: boolean;
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<boolean>('db:book:tool:update', requestData);
response = await tauri.updateBookToolSetting(requestData.bookId, requestData.toolName, requestData.enabled);
} else {
response = await System.authPatchToServer<boolean>('book/tool-setting', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === book?.bookId)) {
addToQueue('db:book:tool:update', requestData);
addToQueue('update_book_tool_setting', {data: requestData});
}
}
if (response && setBook && book) {
@@ -333,7 +328,7 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
name: newWorldName,
};
if (isCurrentlyOffline() || localSeries) {
newWorldId = await window.electron.invoke<string>('db:series:world:add', addData);
newWorldId = await tauri.addSeriesWorld(addData);
} else {
newWorldId = await System.authPostToServer<string>(
'series/world/add',
@@ -342,7 +337,7 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
lang
);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:world:add', {...addData, id: newWorldId});
addToQueue('add_series_world', {data: {...addData, id: newWorldId}});
}
}
if (!newWorldId) {
@@ -355,11 +350,11 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
bookId: entityId,
};
if (isCurrentlyOffline() || book?.localBook) {
newWorldId = await window.electron.invoke<string>('db:book:world:add', requestData);
newWorldId = await tauri.addWorld(requestData.bookId || entityId, requestData.worldName, requestData.id, requestData.seriesWorldId);
} else {
newWorldId = await System.authPostToServer<string>('book/world/add', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:book:world:add', {...requestData, id: newWorldId});
addToQueue('add_world', {data: {...requestData, id: newWorldId}});
}
}
if (!newWorldId) {
@@ -410,11 +405,11 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
};
let response: boolean;
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<boolean>('db:series:world:update', updateData);
response = await tauri.updateSeriesWorld(updateData);
} else {
response = await System.authPatchToServer<boolean>('series/world/update', updateData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:world:update', updateData);
addToQueue('update_series_world', {data: updateData});
}
}
if (!response) {
@@ -428,11 +423,11 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
};
let response: boolean;
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<boolean>('db:book:world:update', requestData);
response = await tauri.updateWorld(requestData.world || requestData);
} else {
response = await System.authPatchToServer<boolean>('book/world/update', requestData, userToken, lang);
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:book:world:update', requestData);
addToQueue('update_world', {data: requestData});
}
}
if (!response) {
@@ -469,8 +464,8 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
let seriesWorldId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
seriesWorldId = await window.electron.invoke<string>('db:series:world:add', seriesWorldData);
// Mode offline ou livre local → Tauri
seriesWorldId = await tauri.addSeriesWorld(seriesWorldData);
} else {
// Mode online → Serveur
seriesWorldId = await System.authPostToServer<string>('series/world/add', {
@@ -486,7 +481,7 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
}, userToken, lang);
// Si la série a une copie locale → addToQueue
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === bookSeriesId)) {
addToQueue('db:series:world:add', {...seriesWorldData, id: seriesWorldId});
addToQueue('add_series_world', {data: {...seriesWorldData, id: seriesWorldId}});
}
}
@@ -501,14 +496,14 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
let updateResponse: boolean;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
updateResponse = await window.electron.invoke<boolean>('db:book:world:update', updateData);
// Mode offline ou livre local → Tauri
updateResponse = await tauri.updateWorld(updateData.world || updateData);
} else {
// Mode online → Serveur
updateResponse = await System.authPostToServer<boolean>('book/world/update', updateData, userToken, lang);
// Si le livre a une copie locale → addToQueue
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:book:world:update', updateData);
addToQueue('update_world', {data: updateData});
}
}
@@ -567,14 +562,14 @@ export function useWorlds(config: UseWorldsConfig): UseWorldsReturn {
let worldId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
worldId = await window.electron.invoke<string>('db:book:world:add', requestData);
// Mode offline ou livre local → Tauri
worldId = await tauri.addWorld(requestData.bookId || entityId, requestData.worldName, requestData.id, requestData.seriesWorldId);
} else {
// Mode online → Serveur
worldId = await System.authPostToServer<string>('book/world/add', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:book:world:add', {...requestData, id: worldId});
addToQueue('add_world', {data: {...requestData, id: worldId}});
}
}

24
hooks/useSyncBooks.ts
View File

@@ -8,6 +8,7 @@ import {BooksSyncContext} from '@/context/BooksSyncContext';
import {CompleteBook} from '@/lib/models/Book';
import {BookSyncCompare, SyncedBook} from '@/lib/models/SyncedBook';
import {useTranslations} from 'next-intl';
import * as tauri from '@/lib/tauri';
interface RemovedItemRecord {
removal_id: string;
@@ -46,7 +47,7 @@ export default function useSyncBooks() {
if (isCurrentlyOffline()) return false;
try {
const bookToSync: CompleteBook = await window.electron.invoke<CompleteBook>('db:book:uploadToServer', bookId);
const bookToSync: CompleteBook = await tauri.uploadBookToServer(bookId) as CompleteBook;
if (!bookToSync) {
errorMessage(t('bookCard.uploadError'));
return false;
@@ -86,7 +87,7 @@ export default function useSyncBooks() {
errorMessage(t('bookCard.downloadError'));
return false;
}
const syncStatus: boolean = await window.electron.invoke<boolean>('db:book:syncSave', response);
const syncStatus: boolean = await tauri.syncSaveBook(response);
if (!syncStatus) {
errorMessage(t('bookCard.downloadError'));
return false;
@@ -126,7 +127,7 @@ export default function useSyncBooks() {
errorMessage(t('bookCard.syncFromServerError'));
return false;
}
const syncStatus: boolean = await window.electron.invoke<boolean>('db:book:sync:toClient', response);
const syncStatus: boolean = await tauri.syncBookToClient(response);
if (!syncStatus) {
errorMessage(t('bookCard.syncFromServerError'));
return false;
@@ -154,7 +155,7 @@ export default function useSyncBooks() {
errorMessage(t('bookCard.syncToServerError'));
return false;
}
const bookToSync: CompleteBook = await window.electron.invoke<CompleteBook>('db:book:sync:toServer', bookToFetch);
const bookToSync: CompleteBook = await tauri.syncBookToServer(bookToFetch) as CompleteBook;
if (!bookToSync) {
errorMessage(t('bookCard.syncToServerError'));
return false;
@@ -199,19 +200,13 @@ export default function useSyncBooks() {
if (!isCurrentlyOffline()) {
if (offlineMode.isDatabaseInitialized) {
localBooksResponse = await window.electron.invoke<SyncedBook[]>('db:books:synced');
localBooksResponse = await tauri.getSyncedBooks() as SyncedBook[];
// Get lastOnlineTimestamp from localStorage (or 0 if not set)
const lastOnlineStr: string | null = localStorage.getItem('lastOnlineTimestamp');
const lastOnlineTimestamp: number = lastOnlineStr ? parseInt(lastOnlineStr, 10) : 0;
// Get local tombstones since lastOnlineTimestamp via IPC
const localTombstones: RemovedItemRecord[] = await window.electron.invoke<RemovedItemRecord[]>(
'db:tombstones:since',
lastOnlineTimestamp
);
const localTombstones: RemovedItemRecord[] = await tauri.getTombstonesSince(lastOnlineTimestamp) as RemovedItemRecord[];
// Call server with POST and tombstones
const serverResponse: SyncedBooksResponse = await System.authPostToServer<SyncedBooksResponse>(
'books/synced',
{ lastOnlineTimestamp, tombstones: localTombstones },
@@ -221,8 +216,7 @@ export default function useSyncBooks() {
serverBooksResponse = serverResponse.books;
// Apply server tombstones locally via IPC
await window.electron.invoke<void>('db:tombstones:apply:books', serverResponse.tombstones);
await tauri.applyBookTombstones(serverResponse.tombstones as tauri.TombstoneRecord[]);
} else {
// No local DB but online - just get server books without tombstones
const serverResponse: SyncedBooksResponse = await System.authPostToServer<SyncedBooksResponse>(
@@ -235,7 +229,7 @@ export default function useSyncBooks() {
}
} else {
if (offlineMode.isDatabaseInitialized) {
localBooksResponse = await window.electron.invoke<SyncedBook[]>('db:books:synced');
localBooksResponse = await tauri.getSyncedBooks() as SyncedBook[];
}
}

27
hooks/useSyncSeries.ts
View File

@@ -7,6 +7,7 @@ import OfflineContext from '@/context/OfflineContext';
import { SeriesSyncContext } from '@/context/SeriesSyncContext';
import { SeriesSyncCompare, SyncedSeries } from '@/lib/models/SyncedSeries';
import { useTranslations } from 'next-intl';
import * as tauri from '@/lib/tauri';
interface RemovedItemRecord {
removal_id: string;
@@ -72,7 +73,7 @@ export default function useSyncSeries() {
if (isCurrentlyOffline()) return false;
try {
const seriesToSync: CompleteSeries = await window.electron.invoke<CompleteSeries>('db:series:uploadToServer', seriesId);
const seriesToSync: CompleteSeries = await tauri.uploadSeriesToServer(seriesId) as CompleteSeries;
if (!seriesToSync) {
errorMessage(t('seriesCard.uploadError'));
return false;
@@ -130,7 +131,7 @@ export default function useSyncSeries() {
return false;
}
const syncStatus: boolean = await window.electron.invoke<boolean>('db:series:syncSave', response);
const syncStatus: boolean = await tauri.syncSaveSeries(response);
if (!syncStatus) {
errorMessage(t('seriesCard.downloadError'));
return false;
@@ -188,7 +189,7 @@ export default function useSyncSeries() {
return false;
}
const syncStatus: boolean = await window.electron.invoke<boolean>('db:series:sync:toClient', response);
const syncStatus: boolean = await tauri.syncSeriesToClient(response);
if (!syncStatus) {
errorMessage(t('seriesCard.syncFromServerError'));
return false;
@@ -230,10 +231,7 @@ export default function useSyncSeries() {
return true;
}
const seriesToSync: CompleteSeries = await window.electron.invoke<CompleteSeries>(
'db:series:sync:toServer',
seriesToFetch
);
const seriesToSync: CompleteSeries = await tauri.syncSeriesToServer(seriesToFetch) as CompleteSeries;
if (!seriesToSync) {
errorMessage(t('seriesCard.syncToServerError'));
return false;
@@ -288,19 +286,13 @@ export default function useSyncSeries() {
if (!isCurrentlyOffline()) {
if (offlineMode.isDatabaseInitialized) {
localSeriesResponse = await window.electron.invoke<SyncedSeries[]>('db:series:synced');
localSeriesResponse = await tauri.getSyncedSeries() as SyncedSeries[];
// Get lastOnlineTimestamp from localStorage (or 0 if not set)
const lastOnlineStr: string | null = localStorage.getItem('lastOnlineTimestamp');
const lastOnlineTimestamp: number = lastOnlineStr ? parseInt(lastOnlineStr, 10) : 0;
// Get local tombstones since lastOnlineTimestamp via IPC
const localTombstones: RemovedItemRecord[] = await window.electron.invoke<RemovedItemRecord[]>(
'db:tombstones:since',
lastOnlineTimestamp
);
const localTombstones: RemovedItemRecord[] = await tauri.getTombstonesSince(lastOnlineTimestamp) as RemovedItemRecord[];
// Call server with POST and tombstones
const serverResponse: SyncedSeriesResponse = await System.authPostToServer<SyncedSeriesResponse>(
'series/synced',
{ lastOnlineTimestamp, tombstones: localTombstones },
@@ -310,8 +302,7 @@ export default function useSyncSeries() {
serverSeriesResponse = serverResponse.series;
// Apply server tombstones locally via IPC
await window.electron.invoke<void>('db:tombstones:apply:series', serverResponse.tombstones);
await tauri.applySeriesTombstones(serverResponse.tombstones as tauri.TombstoneRecord[]);
} else {
// No local DB but online - just get server series without tombstones
const serverResponse: SyncedSeriesResponse = await System.authPostToServer<SyncedSeriesResponse>(
@@ -324,7 +315,7 @@ export default function useSyncSeries() {
}
} else {
if (offlineMode.isDatabaseInitialized) {
localSeriesResponse = await window.electron.invoke<SyncedSeries[]>('db:series:synced');
localSeriesResponse = await tauri.getSyncedSeries() as SyncedSeries[];
}
}