Refactor character, chapter, and story components to support offline mode

- Add `OfflineContext` and `BookContext` to components for offline state management.
- Introduce conditional logic to toggle between server API requests and offline IPC handlers for CRUD operations.
- Refine `TextEditor`, `DraftCompanion`, and other components to disable actions or features unavailable in offline mode.
- Improve error handling and user feedback in both online and offline scenarios.

app/page.tsx

@@ -475,7 +475,15 @@ function ScribeContent() {
                     }
                     response = await window.electron.invoke('db:chapter:last', currentBook?.bookId)
                 } else {
-                    response = await System.authGetQueryToServer<ChapterProps | null>(`chapter/last-chapter`, session.accessToken, locale, {bookid: currentBook?.bookId});
+                    if (currentBook?.localBook) {
+                        if (!offlineMode.isDatabaseInitialized) {
+                            setCurrentChapter(undefined);
+                            return;
+                        }
+                        response = await window.electron.invoke('db:chapter:last', currentBook?.bookId)
+                    } else {
+                        response = await System.authGetQueryToServer<ChapterProps | null>(`chapter/last-chapter`, session.accessToken, locale, {bookid: currentBook?.bookId});
+                    }
                 }
                 if (response) {
                     setCurrentChapter(response)

components/book/settings/BasicInformationSetting.tsx

@@ -127,14 +127,25 @@ function BasicInformationSetting(props: any, ref: any) {
                     bookId: bookId
                 });
             } else {
-                response = await System.authPostToServer<boolean>('book/basic-information', {
+                if (book?.localBook) {
-                    title: title,
+                    response = await window.electron.invoke<boolean>('db:book:updateBasicInformation', {
-                    subTitle: subTitle,
+                        title: title,
-                    summary: summary,
+                        subTitle: subTitle,
-                    publicationDate: publicationDate,
+                        summary: summary,
-                    wordCount: wordCount,
+                        publicationDate: publicationDate,
-                    bookId: bookId
+                        wordCount: wordCount,
-                }, userToken, lang);
+                        bookId: bookId
+                    });
+                } else {
+                    response = await System.authPostToServer<boolean>('book/basic-information', {
+                        title: title,
+                        subTitle: subTitle,
+                        summary: summary,
+                        publicationDate: publicationDate,
+                        wordCount: wordCount,
+                        bookId: bookId
+                    }, userToken, lang);
+                }
             }
             if (!response) {
                 errorMessage(t('basicInformationSetting.error.update'));

components/book/settings/DeleteBook.tsx

@@ -8,6 +8,7 @@ import {LangContext, LangContextProps} from "@/context/LangContext";
 import {AlertContext, AlertContextProps} from "@/context/AlertContext";
 import AlertBox from "@/components/AlertBox";
 import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
+import {BookContext} from "@/context/BookContext";
 
 interface DeleteBookProps {
     bookId: string;
@@ -17,6 +18,7 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
     const {session, setSession} = useContext(SessionContext);
     const {lang} = useContext<LangContextProps>(LangContext)
     const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
+    const {book} = useContext(BookContext);
     const [showConfirmBox, setShowConfirmBox] = useState<boolean>(false);
     const {errorMessage} = useContext<AlertContextProps>(AlertContext)
     
@@ -32,14 +34,20 @@ export default function DeleteBook({bookId}: DeleteBookProps) {
                     id: bookId,
                 });
             } else {
-                response = await System.authDeleteToServer<boolean>(
+                if (book?.localBook) {
-                    `book/delete`,
+                    response = await window.electron.invoke<boolean>('db:book:delete', {
-                    {
                         id: bookId,
-                    },
+                    });
-                    session.accessToken,
+                } else {
-                    lang
+                    response = await System.authDeleteToServer<boolean>(
-                );
+                        `book/delete`,
+                        {
+                            id: bookId,
+                        },
+                        session.accessToken,
+                        lang
+                    );
+                }
             }
             if (response) {
                 setShowConfirmBox(false);

components/book/settings/characters/CharacterComponent.tsx

@@ -70,9 +70,13 @@ export function CharacterComponent(props: any, ref: any) {
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<CharacterProps[]>('db:character:list', {bookid: book?.bookId});
             } else {
-                response = await System.authGetQueryToServer<CharacterProps[]>(`character/list`, session.accessToken, lang, {
+                if (book?.localBook) {
-                    bookid: book?.bookId,
+                    response = await window.electron.invoke<CharacterProps[]>('db:character:list', {bookid: book?.bookId});
-                });
+                } else {
+                    response = await System.authGetQueryToServer<CharacterProps[]>(`character/list`, session.accessToken, lang, {
+                        bookid: book?.bookId,
+                    });
+                }
             }
             if (response) {
                 setCharacters(response);
@@ -122,10 +126,17 @@ export function CharacterComponent(props: any, ref: any) {
                     character: updatedCharacter,
                 });
             } else {
-                characterId = await System.authPostToServer<string>(`character/add`, {
+                if (book?.localBook) {
-                    bookId: book?.bookId,
+                    characterId = await window.electron.invoke<string>('db:character:create', {
-                    character: updatedCharacter,
+                        bookId: book?.bookId,
-                }, session.accessToken, lang);
+                        character: updatedCharacter,
+                    });
+                } else {
+                    characterId = await System.authPostToServer<string>(`character/add`, {
+                        bookId: book?.bookId,
+                        character: updatedCharacter,
+                    }, session.accessToken, lang);
+                }
             }
             if (!characterId) {
                 errorMessage(t("characterComponent.errorAddCharacter"));
@@ -151,9 +162,15 @@ export function CharacterComponent(props: any, ref: any) {
                     character: updatedCharacter,
                 });
             } else {
-                response = await System.authPostToServer<boolean>(`character/update`, {
+                if (book?.localBook) {
-                    character: updatedCharacter,
+                    response = await window.electron.invoke<boolean>('db:character:update', {
-                }, session.accessToken, lang);
+                        character: updatedCharacter,
+                    });
+                } else {
+                    response = await System.authPostToServer<boolean>(`character/update`, {
+                        character: updatedCharacter,
+                    }, session.accessToken, lang);
+                }
             }
             if (!response) {
                 errorMessage(t("characterComponent.errorUpdateCharacter"));
@@ -205,11 +222,19 @@ export function CharacterComponent(props: any, ref: any) {
                             name: value.name,
                         });
                     } else {
-                        attributeId = await System.authPostToServer<string>(`character/attribute/add`, {
+                        if (book?.localBook) {
-                            characterId: selectedCharacter.id,
+                            attributeId = await window.electron.invoke<string>('db:character:attribute:add', {
-                            type: section,
+                                characterId: selectedCharacter.id,
-                            name: value.name,
+                                type: section,
-                        }, session.accessToken, lang);
+                                name: value.name,
+                            });
+                        } else {
+                            attributeId = await System.authPostToServer<string>(`character/attribute/add`, {
+                                characterId: selectedCharacter.id,
+                                type: section,
+                                name: value.name,
+                            }, session.accessToken, lang);
+                        }
                     }
                     if (!attributeId) {
                         errorMessage(t("characterComponent.errorAddAttribute"));
@@ -251,9 +276,15 @@ export function CharacterComponent(props: any, ref: any) {
                             attributeId: attrId,
                         });
                     } else {
-                        response = await System.authDeleteToServer<boolean>(`character/attribute/delete`, {
+                        if (book?.localBook) {
-                            attributeId: attrId,
+                            response = await window.electron.invoke<boolean>('db:character:attribute:delete', {
-                        }, session.accessToken, lang);
+                                attributeId: attrId,
+                            });
+                        } else {
+                            response = await System.authDeleteToServer<boolean>(`character/attribute/delete`, {
+                                attributeId: attrId,
+                            }, session.accessToken, lang);
+                        }
                     }
                     if (!response) {
                         errorMessage(t("characterComponent.errorRemoveAttribute"));

components/book/settings/characters/CharacterDetail.tsx

@@ -30,6 +30,7 @@ import CharacterSectionElement from "@/components/book/settings/characters/Chara
 import {useTranslations} from "next-intl";
 import {LangContext} from "@/context/LangContext";
 import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
+import {BookContext} from "@/context/BookContext";
 
 interface CharacterDetailProps {
     selectedCharacter: CharacterProps | null;
@@ -57,6 +58,7 @@ export default function CharacterDetail(
     const t = useTranslations();
     const {lang} = useContext(LangContext);
     const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
+    const {book} = useContext(BookContext);
     const {session} = useContext(SessionContext);
     const {errorMessage} = useContext(AlertContext);
     
@@ -74,9 +76,15 @@ export default function CharacterDetail(
                     characterId: selectedCharacter?.id,
                 });
             } else {
-                response = await System.authGetQueryToServer<CharacterAttribute>(`character/attribute`, session.accessToken, lang, {
+                if (book?.localBook) {
-                    characterId: selectedCharacter?.id,
+                    response = await window.electron.invoke<CharacterAttribute>('db:character:attributes', {
-                });
+                        characterId: selectedCharacter?.id,
+                    });
+                } else {
+                    response = await System.authGetQueryToServer<CharacterAttribute>(`character/attribute`, session.accessToken, lang, {
+                        characterId: selectedCharacter?.id,
+                    });
+                }
             }
             if (response) {
                 setSelectedCharacter({

components/book/settings/guide-line/GuideLineSetting.tsx

@@ -81,7 +81,11 @@ function GuideLineSetting(props: any, ref: any) {
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<GuideLineAI>('db:book:guideline:ai:get', {id: bookId});
             } else {
-                response = await System.authGetQueryToServer<GuideLineAI>(`book/ai/guideline`, userToken, lang, {id: bookId});
+                if (book?.localBook) {
+                    response = await window.electron.invoke<GuideLineAI>('db:book:guideline:ai:get', {id: bookId});
+                } else {
+                    response = await System.authGetQueryToServer<GuideLineAI>(`book/ai/guideline`, userToken, lang, {id: bookId});
+                }
             }
             if (response) {
                 setPlotSummary(response.globalResume);
@@ -107,12 +111,16 @@ function GuideLineSetting(props: any, ref: any) {
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<GuideLine>('db:book:guideline:get', {id: bookId});
             } else {
-                response = await System.authGetQueryToServer<GuideLine>(
+                if (book?.localBook) {
-                    `book/guide-line`,
+                    response = await window.electron.invoke<GuideLine>('db:book:guideline:get', {id: bookId});
-                    userToken,
+                } else {
-                    lang,
+                    response = await System.authGetQueryToServer<GuideLine>(
-                    {id: bookId},
+                        `book/guide-line`,
-                );
+                        userToken,
+                        lang,
+                        {id: bookId},
+                    );
+                }
             }
             if (response) {
                 setTone(response.tone);
@@ -154,12 +162,16 @@ function GuideLineSetting(props: any, ref: any) {
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<boolean>('db:book:guideline:update', guidelineData);
             } else {
-                response = await System.authPostToServer<boolean>(
+                if (book?.localBook) {
-                    'book/guide-line',
+                    response = await window.electron.invoke<boolean>('db:book:guideline:update', guidelineData);
-                    guidelineData,
+                } else {
-                    userToken,
+                    response = await System.authPostToServer<boolean>(
-                    lang,
+                        'book/guide-line',
-                );
+                        guidelineData,
+                        userToken,
+                        lang,
+                    );
+                }
             }
             if (!response) {
                 errorMessage(t("guideLineSetting.saveError"));
@@ -177,9 +189,9 @@ function GuideLineSetting(props: any, ref: any) {
     
     async function saveQuillSense(): Promise<void> {
         try {
-            const response: boolean = await System.authPostToServer<boolean>(
+            let response: boolean;
-                'quillsense/book/guide-line',
+            if (isCurrentlyOffline()) {
-                {
+                response = await window.electron.invoke<boolean>('db:book:guideline:ai:update', {
                     bookId: bookId,
                     plotSummary: plotSummary,
                     verbTense: verbTense,
@@ -188,10 +200,37 @@ function GuideLineSetting(props: any, ref: any) {
                     toneAtmosphere: toneAtmosphere,
                     language: language,
                     themes: themes,
-                },
+                });
-                userToken,
+            } else {
-                lang,
+                if (book?.localBook) {
-            );
+                    response = await window.electron.invoke<boolean>('db:book:guideline:ai:update', {
+                        bookId: bookId,
+                        plotSummary: plotSummary,
+                        verbTense: verbTense,
+                        narrativeType: narrativeType,
+                        dialogueType: dialogueType,
+                        toneAtmosphere: toneAtmosphere,
+                        language: language,
+                        themes: themes,
+                    });
+                } else {
+                    response = await System.authPostToServer<boolean>(
+                        'quillsense/book/guide-line',
+                        {
+                            bookId: bookId,
+                            plotSummary: plotSummary,
+                            verbTense: verbTense,
+                            narrativeType: narrativeType,
+                            dialogueType: dialogueType,
+                            toneAtmosphere: toneAtmosphere,
+                            language: language,
+                            themes: themes,
+                        },
+                        userToken,
+                        lang,
+                    );
+                }
+            }
             if (response) {
                 successMessage(t("guideLineSetting.saveSuccess"));
             } else {

components/book/settings/locations/LocationComponent.tsx

@@ -64,9 +64,13 @@ export function LocationComponent(props: any, ref: any) {
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<LocationProps[]>('db:location:all', {bookid: bookId});
             } else {
-                response = await System.authGetQueryToServer<LocationProps[]>(`location/all`, token, lang, {
+                if (book?.localBook) {
-                    bookid: bookId,
+                    response = await window.electron.invoke<LocationProps[]>('db:location:all', {bookid: bookId});
-                });
+                } else {
+                    response = await System.authGetQueryToServer<LocationProps[]>(`location/all`, token, lang, {
+                        bookid: bookId,
+                    });
+                }
             }
             if (response && response.length > 0) {
                 setSections(response);
@@ -93,10 +97,17 @@ export function LocationComponent(props: any, ref: any) {
                     locationName: newSectionName,
                 });
             } else {
-                sectionId = await System.authPostToServer<string>(`location/section/add`, {
+                if (book?.localBook) {
-                    bookId: bookId,
+                    sectionId = await window.electron.invoke<string>('db:location:section:add', {
-                    locationName: newSectionName,
+                        bookId: bookId,
-                }, token, lang);
+                        locationName: newSectionName,
+                    });
+                } else {
+                    sectionId = await System.authPostToServer<string>(`location/section/add`, {
+                        bookId: bookId,
+                        locationName: newSectionName,
+                    }, token, lang);
+                }
             }
             if (!sectionId) {
                 errorMessage(t('locationComponent.errorUnknownAddSection'));
@@ -132,12 +143,20 @@ export function LocationComponent(props: any, ref: any) {
                     elementName: newElementNames[sectionId],
                 });
             } else {
-                elementId = await System.authPostToServer<string>(`location/element/add`, {
+                if (book?.localBook) {
+                    elementId = await window.electron.invoke<string>('db:location:element:add', {
                         bookId: bookId,
                         locationId: sectionId,
                         elementName: newElementNames[sectionId],
-                    },
+                    });
-                    token, lang);
+                } else {
+                    elementId = await System.authPostToServer<string>(`location/element/add`, {
+                            bookId: bookId,
+                            locationId: sectionId,
+                            elementName: newElementNames[sectionId],
+                        },
+                        token, lang);
+                }
             }
             if (!elementId) {
                 errorMessage(t('locationComponent.errorUnknownAddElement'));
@@ -198,10 +217,17 @@ export function LocationComponent(props: any, ref: any) {
                     subElementName: newSubElementNames[elementIndex],
                 });
             } else {
-                subElementId = await System.authPostToServer<string>(`location/sub-element/add`, {
+                if (book?.localBook) {
-                    elementId: sections[sectionIndex].elements[elementIndex].id,
+                    subElementId = await window.electron.invoke<string>('db:location:subelement:add', {
-                    subElementName: newSubElementNames[elementIndex],
+                        elementId: sections[sectionIndex].elements[elementIndex].id,
-                }, token, lang);
+                        subElementName: newSubElementNames[elementIndex],
+                    });
+                } else {
+                    subElementId = await System.authPostToServer<string>(`location/sub-element/add`, {
+                        elementId: sections[sectionIndex].elements[elementIndex].id,
+                        subElementName: newSubElementNames[elementIndex],
+                    }, token, lang);
+                }
             }
             if (!subElementId) {
                 errorMessage(t('locationComponent.errorUnknownAddSubElement'));
@@ -254,9 +280,15 @@ export function LocationComponent(props: any, ref: any) {
                     elementId: elementId,
                 });
             } else {
-                response = await System.authDeleteToServer<boolean>(`location/element/delete`, {
+                if (book?.localBook) {
-                    elementId: elementId,
+                    response = await window.electron.invoke<boolean>('db:location:element:delete', {
-                }, token, lang);
+                        elementId: elementId,
+                    });
+                } else {
+                    response = await System.authDeleteToServer<boolean>(`location/element/delete`, {
+                        elementId: elementId,
+                    }, token, lang);
+                }
             }
             if (!response) {
                 errorMessage(t('locationComponent.errorUnknownDeleteElement'));
@@ -288,9 +320,15 @@ export function LocationComponent(props: any, ref: any) {
                     subElementId: subElementId,
                 });
             } else {
-                response = await System.authDeleteToServer<boolean>(`location/sub-element/delete`, {
+                if (book?.localBook) {
-                    subElementId: subElementId,
+                    response = await window.electron.invoke<boolean>('db:location:subelement:delete', {
-                }, token, lang);
+                        subElementId: subElementId,
+                    });
+                } else {
+                    response = await System.authDeleteToServer<boolean>(`location/sub-element/delete`, {
+                        subElementId: subElementId,
+                    }, token, lang);
+                }
             }
             if (!response) {
                 errorMessage(t('locationComponent.errorUnknownDeleteSubElement'));
@@ -317,9 +355,15 @@ export function LocationComponent(props: any, ref: any) {
                     locationId: sectionId,
                 });
             } else {
-                response = await System.authDeleteToServer<boolean>(`location/delete`, {
+                if (book?.localBook) {
-                    locationId: sectionId,
+                    response = await window.electron.invoke<boolean>('db:location:delete', {
-                }, token, lang);
+                        locationId: sectionId,
+                    });
+                } else {
+                    response = await System.authDeleteToServer<boolean>(`location/delete`, {
+                        locationId: sectionId,
+                    }, token, lang);
+                }
             }
             if (!response) {
                 errorMessage(t('locationComponent.errorUnknownDeleteSection'));
@@ -344,9 +388,15 @@ export function LocationComponent(props: any, ref: any) {
                     locations: sections,
                 });
             } else {
-                response = await System.authPostToServer<boolean>(`location/update`, {
+                if (book?.localBook) {
-                    locations: sections,
+                    response = await window.electron.invoke<boolean>('db:location:update', {
-                }, token, lang);
+                        locations: sections,
+                    });
+                } else {
+                    response = await System.authPostToServer<boolean>(`location/update`, {
+                        locations: sections,
+                    }, token, lang);
+                }
             }
             if (!response) {
                 errorMessage(t('locationComponent.errorUnknownSave'));

components/book/settings/story/Act.tsx

@@ -80,10 +80,17 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                     name: newIncidentTitle,
                 });
             } else {
-                incidentId = await System.authPostToServer<string>('book/incident/new', {
+                if (book?.localBook) {
-                    bookId,
+                    incidentId = await window.electron.invoke<string>('db:book:incident:add', {
-                    name: newIncidentTitle,
+                        bookId,
-                }, token, lang);
+                        name: newIncidentTitle,
+                    });
+                } else {
+                    incidentId = await System.authPostToServer<string>('book/incident/new', {
+                        bookId,
+                        name: newIncidentTitle,
+                    }, token, lang);
+                }
             }
             if (!incidentId) {
                 errorMessage(t('errorAddIncident'));
@@ -125,10 +132,17 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                     incidentId,
                 });
             } else {
-                response = await System.authDeleteToServer<boolean>('book/incident/remove', {
+                if (book?.localBook) {
-                    bookId,
+                    response = await window.electron.invoke<boolean>('db:book:incident:remove', {
-                    incidentId,
+                        bookId,
-                }, token, lang);
+                        incidentId,
+                    });
+                } else {
+                    response = await System.authDeleteToServer<boolean>('book/incident/remove', {
+                        bookId,
+                        incidentId,
+                    }, token, lang);
+                }
             }
             if (!response) {
                 errorMessage(t('errorDeleteIncident'));
@@ -166,11 +180,19 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                     incidentId: selectedIncidentId,
                 });
             } else {
-                plotId = await System.authPostToServer<string>('book/plot/new', {
+                if (book?.localBook) {
-                    bookId,
+                    plotId = await window.electron.invoke<string>('db:book:plot:add', {
-                    name: newPlotPointTitle,
+                        bookId,
-                    incidentId: selectedIncidentId,
+                        name: newPlotPointTitle,
-                }, token, lang);
+                        incidentId: selectedIncidentId,
+                    });
+                } else {
+                    plotId = await System.authPostToServer<string>('book/plot/new', {
+                        bookId,
+                        name: newPlotPointTitle,
+                        incidentId: selectedIncidentId,
+                    }, token, lang);
+                }
             }
             if (!plotId) {
                 errorMessage(t('errorAddPlotPoint'));
@@ -212,9 +234,15 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                     plotId: plotPointId,
                 });
             } else {
-                response = await System.authDeleteToServer<boolean>('book/plot/remove', {
+                if (book?.localBook) {
-                    plotId: plotPointId,
+                    response = await window.electron.invoke<boolean>('db:book:plot:remove', {
-                }, token, lang);
+                        plotId: plotPointId,
+                    });
+                } else {
+                    response = await System.authDeleteToServer<boolean>('book/plot/remove', {
+                        plotId: plotPointId,
+                    }, token, lang);
+                }
             }
             if (!response) {
                 errorMessage(t('errorDeletePlotPoint'));
@@ -264,7 +292,11 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
             if (isCurrentlyOffline()) {
                 linkId = await window.electron.invoke<string>('db:chapter:information:add', linkData);
             } else {
-                linkId = await System.authPostToServer<string>('chapter/resume/add', linkData, token, lang);
+                if (book?.localBook) {
+                    linkId = await window.electron.invoke<string>('db:chapter:information:add', linkData);
+                } else {
+                    linkId = await System.authPostToServer<string>('chapter/resume/add', linkData, token, lang);
+                }
             }
             if (!linkId) {
                 errorMessage(t('errorLinkChapter'));
@@ -346,9 +378,15 @@ export default function Act({acts, setActs, mainChapters}: ActProps) {
                     chapterInfoId,
                 });
             } else {
-                response = await System.authDeleteToServer<boolean>('chapter/resume/remove', {
+                if (book?.localBook) {
-                    chapterInfoId,
+                    response = await window.electron.invoke<boolean>('db:chapter:information:remove', {
-                }, token, lang);
+                        chapterInfoId,
+                    });
+                } else {
+                    response = await System.authDeleteToServer<boolean>('chapter/resume/remove', {
+                        chapterInfoId,
+                    }, token, lang);
+                }
             }
             if (!response) {
                 errorMessage(t('errorUnlinkChapter'));

components/book/settings/story/Issue.tsx

@@ -42,10 +42,17 @@ export default function Issues({issues, setIssues}: IssuesProps) {
                     name: newIssueName,
                 });
             } else {
-                issueId = await System.authPostToServer<string>('book/issue/add', {
+                if (book?.localBook) {
-                    bookId,
+                    issueId = await window.electron.invoke<string>('db:book:issue:add', {
-                    name: newIssueName,
+                        bookId,
-                }, token, lang);
+                        name: newIssueName,
+                    });
+                } else {
+                    issueId = await System.authPostToServer<string>('book/issue/add', {
+                        bookId,
+                        name: newIssueName,
+                    }, token, lang);
+                }
             }
             if (!issueId) {
                 errorMessage(t("issues.errorAdd"));
@@ -81,15 +88,22 @@ export default function Issues({issues, setIssues}: IssuesProps) {
                     issueId,
                 });
             } else {
-                response = await System.authDeleteToServer<boolean>(
+                if (book?.localBook) {
-                    'book/issue/remove',
+                    response = await window.electron.invoke<boolean>('db:book:issue:remove', {
-                    {
                         bookId,
                         issueId,
-                    },
+                    });
-                    token,
+                } else {
-                    lang
+                    response = await System.authDeleteToServer<boolean>(
-                );
+                        'book/issue/remove',
+                        {
+                            bookId,
+                            issueId,
+                        },
+                        token,
+                        lang
+                    );
+                }
             }
             if (response) {
                 const updatedIssues: Issue[] = issues.filter((issue: Issue): boolean => issue.id !== issueId,);

components/book/settings/story/MainChapter.tsx

@@ -88,7 +88,11 @@ export default function MainChapter({chapters, setChapters}: MainChapterProps) {
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<boolean>('db:chapter:remove', deleteData);
             } else {
-                response = await System.authDeleteToServer<boolean>('chapter/remove', deleteData, token, lang);
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:chapter:remove', deleteData);
+                } else {
+                    response = await System.authDeleteToServer<boolean>('chapter/remove', deleteData, token, lang);
+                }
             }
             if (!response) {
                 errorMessage(t("mainChapter.errorDelete"));
@@ -120,7 +124,11 @@ export default function MainChapter({chapters, setChapters}: MainChapterProps) {
             if (isCurrentlyOffline()) {
                 responseId = await window.electron.invoke<string>('db:chapter:add', chapterData);
             } else {
-                responseId = await System.authPostToServer<string>('chapter/add', chapterData, token);
+                if (book?.localBook) {
+                    responseId = await window.electron.invoke<string>('db:chapter:add', chapterData);
+                } else {
+                    responseId = await System.authPostToServer<string>('chapter/add', chapterData, token);
+                }
             }
             if (!responseId) {
                 errorMessage(t("mainChapter.errorAdd"));

components/book/settings/story/StorySetting.tsx

@@ -74,9 +74,13 @@ export function Story(props: any, ref: any) {
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<StoryFetchData>('db:book:story:get', {bookid: bookId});
             } else {
-                response = await System.authGetQueryToServer<StoryFetchData>(`book/story`, userToken, lang, {
+                if (book?.localBook) {
-                    bookid: bookId,
+                    response = await window.electron.invoke<StoryFetchData>('db:book:story:get', {bookid: bookId});
-                });
+                } else {
+                    response = await System.authGetQueryToServer<StoryFetchData>(`book/story`, userToken, lang, {
+                        bookid: bookId,
+                    });
+                }
             }
             if (response) {
                 setActs(response.acts);
@@ -136,7 +140,11 @@ export function Story(props: any, ref: any) {
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<boolean>('db:book:story:update', storyData);
             } else {
-                response = await System.authPostToServer<boolean>('book/story', storyData, userToken, lang);
+                if (book?.localBook) {
+                    response = await window.electron.invoke<boolean>('db:book:story:update', storyData);
+                } else {
+                    response = await System.authPostToServer<boolean>('book/story', storyData, userToken, lang);
+                }
             }
             if (!response) {
                 errorMessage(t("story.errorSave"))

components/book/settings/world/WorldElement.tsx

@@ -12,6 +12,7 @@ import InputField from "@/components/form/InputField";
 import {useTranslations} from "next-intl";
 import {LangContext, LangContextProps} from "@/context/LangContext";
 import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
+import {BookContext} from "@/context/BookContext";
 
 interface WorldElementInputProps {
     sectionLabel: string;
@@ -22,6 +23,7 @@ export default function WorldElementComponent({sectionLabel, sectionType}: World
     const t = useTranslations();
     const {lang} = useContext<LangContextProps>(LangContext);
     const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
+    const {book} = useContext(BookContext);
     const {worlds, setWorlds, selectedWorldIndex} = useContext(WorldContext);
     const {errorMessage, successMessage} = useContext(AlertContext);
     const {session} = useContext(SessionContext);
@@ -40,9 +42,15 @@ export default function WorldElementComponent({sectionLabel, sectionType}: World
                     elementId: elementId,
                 });
             } else {
-                response = await System.authDeleteToServer<boolean>('book/world/element/delete', {
+                if (book?.localBook) {
-                    elementId: elementId,
+                    response = await window.electron.invoke<boolean>('db:book:world:element:remove', {
-                }, session.accessToken, lang);
+                        elementId: elementId,
+                    });
+                } else {
+                    response = await System.authDeleteToServer<boolean>('book/world/element/delete', {
+                        elementId: elementId,
+                    }, session.accessToken, lang);
+                }
             }
             if (!response) {
                 errorMessage(t("worldSetting.unknownError"))
@@ -76,11 +84,19 @@ export default function WorldElementComponent({sectionLabel, sectionType}: World
                     elementName: newElementName,
                 });
             } else {
-                elementId = await System.authPostToServer('book/world/element/add', {
+                if (book?.localBook) {
-                    elementType: section,
+                    elementId = await window.electron.invoke<string>('db:book:world:element:add', {
-                    worldId: worlds[selectedWorldIndex].id,
+                        elementType: section,
-                    elementName: newElementName,
+                        worldId: worlds[selectedWorldIndex].id,
-                }, session.accessToken, lang);
+                        elementName: newElementName,
+                    });
+                } else {
+                    elementId = await System.authPostToServer('book/world/element/add', {
+                        elementType: section,
+                        worldId: worlds[selectedWorldIndex].id,
+                        elementName: newElementName,
+                    }, session.accessToken, lang);
+                }
             }
             if (!elementId) {
                 errorMessage(t("worldSetting.unknownError"))

components/book/settings/world/WorldSetting.tsx

@@ -55,9 +55,13 @@ export function WorldSetting(props: any, ref: any) {
             if (isCurrentlyOffline()) {
                 response = await window.electron.invoke<WorldProps[]>('db:book:worlds:get', {bookid: bookId});
             } else {
-                response = await System.authGetQueryToServer<WorldProps[]>(`book/worlds`, session.accessToken, lang, {
+                if (book?.localBook) {
-                    bookid: bookId,
+                    response = await window.electron.invoke<WorldProps[]>('db:book:worlds:get', {bookid: bookId});
-                });
+                } else {
+                    response = await System.authGetQueryToServer<WorldProps[]>(`book/worlds`, session.accessToken, lang, {
+                        bookid: bookId,
+                    });
+                }
             }
             if (response) {
                 setWorlds(response);
@@ -91,10 +95,17 @@ export function WorldSetting(props: any, ref: any) {
                     bookId: bookId,
                 });
             } else {
-                worldId = await System.authPostToServer<string>('book/world/add', {
+                if (book?.localBook) {
-                    worldName: newWorldName,
+                    worldId = await window.electron.invoke<string>('db:book:world:add', {
-                    bookId: bookId,
+                        worldName: newWorldName,
-                }, session.accessToken, lang);
+                        bookId: bookId,
+                    });
+                } else {
+                    worldId = await System.authPostToServer<string>('book/world/add', {
+                        worldName: newWorldName,
+                        bookId: bookId,
+                    }, session.accessToken, lang);
+                }
             }
             if (!worldId) {
                 errorMessage(t("worldSetting.addWorldError"));
@@ -147,10 +158,17 @@ export function WorldSetting(props: any, ref: any) {
                     bookId: bookId,
                 });
             } else {
-                response = await System.authPutToServer<boolean>('book/world/update', {
+                if (book?.localBook) {
-                    world: worlds[selectedWorldIndex],
+                    response = await window.electron.invoke<boolean>('db:book:world:update', {
-                    bookId: bookId,
+                        world: worlds[selectedWorldIndex],
-                }, session.accessToken, lang);
+                        bookId: bookId,
+                    });
+                } else {
+                    response = await System.authPutToServer<boolean>('book/world/update', {
+                        world: worlds[selectedWorldIndex],
+                        bookId: bookId,
+                    }, session.accessToken, lang);
+                }
             }
             if (!response) {
                 errorMessage(t("worldSetting.updateWorldError"));

components/editor/DraftCompanion.tsx

@@ -32,6 +32,7 @@ import {LangContext, LangContextProps} from "@/context/LangContext";
 import {BookTags} from "@/lib/models/Book";
 import {AIUsageContext, AIUsageContextProps} from "@/context/AIUsageContext";
 import {configs} from "@/lib/configs";
+import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
 
 interface CompanionContent {
     version: number;
@@ -43,6 +44,7 @@ export default function DraftCompanion() {
     const t = useTranslations();
     const {setTotalPrice, setTotalCredits} = useContext<AIUsageContextProps>(AIUsageContext)
     const {lang} = useContext<LangContextProps>(LangContext)
+    const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
 
     const mainEditor: Editor | null = useEditor({
         extensions: [
@@ -95,7 +97,7 @@ export default function DraftCompanion() {
     
     const isGPTEnabled: boolean = QuillSense.isOpenAIEnabled(session);
     const isSubTierTree: boolean = QuillSense.getSubLevel(session) === 3;
-    const hasAccess: boolean = isGPTEnabled || isSubTierTree;
+    const hasAccess: boolean = (isGPTEnabled || isSubTierTree) && !isCurrentlyOffline() && !book?.localBook;
     
     useEffect((): void => {
         getDraftContent().then();
@@ -106,11 +108,28 @@ export default function DraftCompanion() {
     
     async function getDraftContent(): Promise<void> {
         try {
-            const response: CompanionContent = await System.authGetQueryToServer<CompanionContent>(`chapter/content/companion`, session.accessToken, lang, {
+            let response: CompanionContent | null;
-                bookid: book?.bookId,
+            if (isCurrentlyOffline()) {
-                chapterid: chapter?.chapterId,
+                response = await window.electron.invoke<CompanionContent>('db:chapter:content:companion', {
-                version: chapter?.chapterContent.version,
+                    bookid: book?.bookId,
-            });
+                    chapterid: chapter?.chapterId,
+                    version: chapter?.chapterContent.version,
+                });
+            } else {
+                if (book?.localBook) {
+                    response = await window.electron.invoke<CompanionContent>('db:chapter:content:companion', {
+                        bookid: book?.bookId,
+                        chapterid: chapter?.chapterId,
+                        version: chapter?.chapterContent.version,
+                    });
+                } else {
+                    response = await System.authGetQueryToServer<CompanionContent>(`chapter/content/companion`, session.accessToken, lang, {
+                        bookid: book?.bookId,
+                        chapterid: chapter?.chapterId,
+                        version: chapter?.chapterContent.version,
+                    });
+                }
+            }
             if (response && mainEditor) {
                 mainEditor.commands.setContent(JSON.parse(response.content));
                 setDraftVersion(response.version);
@@ -145,9 +164,18 @@ export default function DraftCompanion() {
     
     async function fetchTags(): Promise<void> {
         try {
-            const responseTags: BookTags = await System.authGetQueryToServer<BookTags>(`book/tags`, session.accessToken, lang, {
+            let responseTags: BookTags | null;
-                bookId: book?.bookId
+            if (isCurrentlyOffline()) {
-            });
+                responseTags = await window.electron.invoke<BookTags>('db:book:tags', book?.bookId);
+            } else {
+                if (book?.localBook) {
+                    responseTags = await window.electron.invoke<BookTags>('db:book:tags', book?.bookId);
+                } else {
+                    responseTags = await System.authGetQueryToServer<BookTags>(`book/tags`, session.accessToken, lang, {
+                        bookId: book?.bookId
+                    });
+                }
+            }
             if (responseTags) {
                 setCharacters(responseTags.characters);
                 setLocations(responseTags.locations);

components/editor/TextEditor.tsx

@@ -22,6 +22,7 @@ import {ChapterContext} from '@/context/ChapterContext';
 import System from '@/lib/models/System';
 import {AlertContext} from '@/context/AlertContext';
 import {SessionContext} from "@/context/SessionContext";
+import {BookContext} from '@/context/BookContext';
 import DraftCompanion from "@/components/editor/DraftCompanion";
 import GhostWriter from "@/components/ghostwriter/GhostWriter";
 import SubmitButtonWLoading from "@/components/form/SubmitButtonWLoading";
@@ -135,6 +136,7 @@ export default function TextEditor() {
     const {lang} = useContext<LangContextProps>(LangContext)
     const {editor} = useContext(EditorContext);
     const {chapter} = useContext(ChapterContext);
+    const {book} = useContext(BookContext);
     const {errorMessage, successMessage} = useContext(AlertContext);
     const {session} = useContext(SessionContext);
     const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
@@ -294,13 +296,23 @@ export default function TextEditor() {
                     currentTime: mainTimer
                 })
             } else {
-                response = await System.authPostToServer<boolean>(`chapter/content`, {
+                if (book?.localBook) {
-                    chapterId,
+                    response = await window.electron.invoke<boolean>('db:chapter:content:save',{
-                    version,
+                        chapterId,
-                    content,
+                        version,
-                    totalWordCount: editor.getText().length,
+                        content,
-                    currentTime: mainTimer
+                        totalWordCount: editor.getText().length,
-                }, session?.accessToken, lang);
+                        currentTime: mainTimer
+                    })
+                } else {
+                    response = await System.authPostToServer<boolean>(`chapter/content`, {
+                        chapterId,
+                        version,
+                        content,
+                        totalWordCount: editor.getText().length,
+                        currentTime: mainTimer
+                    }, session?.accessToken, lang);
+                }
             }
             if (!response) {
                 errorMessage(t('editor.error.savedFailed'));
@@ -467,7 +479,7 @@ export default function TextEditor() {
                         onClick={handleShowUserSettings}
                         icon={faCog}
                     />
-                    {chapter?.chapterContent.version === 2 && !isCurrentlyOffline() && (
+                    {chapter?.chapterContent.version === 2 && !isCurrentlyOffline() && !book?.localBook && (
                         <CollapsableButton
                             showCollapsable={showGhostWriter}
                             text={t("textEditor.ghostWriter")}

components/rightbar/ComposerRightBar.tsx

@@ -171,7 +171,7 @@ export default function ComposerRightBar() {
             <div className="bg-tertiary border-l border-secondary/50 p-3 flex flex-col space-y-3 shadow-xl">
                 {book ? editorComponents
                     .filter((component: PanelComponent):boolean => {
-                        return !(isCurrentlyOffline() && component.id === 1);
+                        return !((isCurrentlyOffline() || book?.localBook) && component.id === 1);
                     })
                     .map((component: PanelComponent) => (
                     <button