add: markdown deletion

improve: template

.gitignore

@@ -1 +1,2 @@
-summerizer.py
+summerizer.py
+node_modules

BuildConfig.sh

@@ -5,7 +5,7 @@ FRONTEND_HOST="${FRONTEND_HOST:-http://localhost:80}"
 KC_CLIENT_ID="${KC_CLIENT_ID:-labdev}"
 KC_HOST="${KC_HOST:-https://login.hangman-lab.top}"
 KC_REALM="${KC_REALM:-Hangman-Lab}"
-
+DEBUG="${DEBUG:false}"
 rm -f /usr/share/nginx/html/config.js
 
 
@@ -24,7 +24,8 @@ cat <<EOL > /usr/share/nginx/html/config.json
         "scope": "openid profile email roles",
         "popup_redirect_uri": "${FRONTEND_HOST}/popup_callback",
         "silent_redirect_uri": "${FRONTEND_HOST}/silent_callback"
-    }
+    },
+    "DEBUG": ${DEBUG}
 }
 EOL
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:18-alpine AS build-stage
+FROM node:20-alpine AS build-stage
 WORKDIR /app
 
 

README.md

@@ -113,18 +113,15 @@ The application will be accessible at `http://localhost:3000` by default.
 ## Docker Deployment
 
 ### Image
-Pull the latest Docker image from the repository:
+Pull the latest Docker image from the registry:
 ```bash
-docker pull git.hangman-lab.top/hzhang/hangman-lab-frontend:latest
-```
-### Building the docker Image
-```bash
-docker build -t hangman-lab-frontend:latest .
+docker pull git.hangman-lab.top/hzhang/hangmanlab-frontend:latest
 ```
+
 ### Running the Docker Container
 Ensure your backend service (e.g., running at http://localhost:5000) is up and accessible. Then, run the Docker container:
 ```bash
-docker run -d -p 80:80 --name hangman-lab-frontend hangman-lab-frontend:latest
+docker run -d -p 80:80 --name hangmanlab-frontend hangmanlab-frontend:latest
 ```
 
 #### Note:

jest.config.js

@@ -0,0 +1,15 @@
+module.exports = {
+    testEnvironment: "jsdom",
+    setupFilesAfterEnv: ["@testing-library/jest-dom", "<rootDir>/jest.setup.js"],
+    moduleNameMapper: {
+        "\\.(css|less|scss|sass)$": "identity-obj-proxy",
+    },
+    transform: {
+        "^.+\\.[t|j]sx?$": "babel-jest",
+    },
+    transformIgnorePatterns: [
+        'node_modules/(?!(@thi.ng)/)',
+        "node_modules/(?!node-fetch|katex|react-markdown|remark-math|rehype-katex|rehype-raw)"
+    ],
+
+};

jest.setup.js

@@ -0,0 +1,6 @@
+const { TextEncoder, TextDecoder } = require("util");
+global.TextEncoder = TextEncoder;
+global.TextDecoder = TextDecoder;
+const fetch = (...args) =>
+    import("node-fetch").then(({ default: fetch }) => fetch(...args));
+global.fetch = fetch;

package.json

@@ -12,27 +12,47 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@reduxjs/toolkit": "^2.7.0",
+    "@tanstack/react-query": "^5.75.5",
+    "@tanstack/react-query-devtools": "^5.75.5",
+    "assert": "^2.1.0",
+    "axios": "^1.7.9",
     "bulma": "^1.0.2",
     "katex": "^0.16.11",
     "oidc-client-ts": "^3.1.0",
+    "path-browserify": "^1.0.1",
+    "prismjs": "^1.30.0",
+    "process": "^0.11.10",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-markdown": "^9.0.1",
-    "react-query": "^3.39.3",
+    "react-redux": "^9.2.0",
     "react-router-dom": "^7.0.1",
     "react-syntax-highlighter": "^15.6.1",
+    "redux": "^5.0.1",
     "rehype-katex": "^7.0.1",
     "rehype-raw": "^7.0.0",
-    "remark-math": "^6.0.0"
+    "remark-gfm": "^4.0.0",
+    "remark-math": "^6.0.0",
+    "util": "^0.12.5"
   },
   "devDependencies": {
     "@babel/core": "^7.26.0",
     "@babel/preset-env": "^7.26.0",
-    "@babel/preset-react": "^7.25.9",
+    "@babel/preset-react": "^7.26.3",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.1.0",
+    "@testing-library/user-event": "^14.5.2",
+    "axios-mock-adapter": "^2.1.0",
+    "babel-jest": "^29.7.0",
     "babel-loader": "^9.2.1",
     "css-loader": "^7.1.2",
     "dotenv-webpack": "^8.1.0",
     "html-webpack-plugin": "^5.6.3",
+    "identity-obj-proxy": "^3.0.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "node-fetch": "^3.3.2",
     "sass": "^1.81.0",
     "sass-loader": "^16.0.3",
     "style-loader": "^4.0.0",

public/index.html

@@ -4,6 +4,7 @@
         <meta charset="UTF-8">
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
         <title>Hangman Lab</title>
+        <link rel="icon" type="image/png" href="./icons/logo.png">
 
     </head>
     <body>

src/App.css

@@ -14,4 +14,8 @@
     flex: 1;
     padding: 1rem 1rem 100px 1rem;
     overflow-y: auto;
+}
+
+:root {
+    overflow: hidden;
 }

src/App.js

@@ -1,38 +1,56 @@
 import React from "react";
-import { BrowserRouter as Router, Route, Routes } from "react-router-dom";
+import {BrowserRouter as Router, Navigate, Route, Routes} from "react-router-dom";
+import { Provider } from 'react-redux';
+import { store } from './store';
 import MainNavigation from "./components/Navigations/MainNavigation";
 import SideNavigation from "./components/Navigations/SideNavigation";
 import MarkdownContent from "./components/Markdowns/MarkdownContent";
 import MarkdownEditor from "./components/Markdowns/MarkdownEditor";
+import StandaloneMarkdownPage from "./components/Markdowns/StandaloneMarkdownPage";
 import "./App.css";
 import Callback from "./components/KeycloakCallbacks/Callback";
 import Footer from "./components/Footer";
 import PopupCallback from "./components/KeycloakCallbacks/PopupCallback";
 import SilentCallback from "./components/KeycloakCallbacks/SilentCallback";
+import MarkdownTemplateEditor from "./components/MarkdownTemplate/MarkdownTemplateEditor";
 
 const App = () => {
+
     return (
-        <Router>
-            <div className="app-container">
-                <MainNavigation />
-                <div className="content-container">
-                    <SideNavigation />
-                    <main className="main-content">
-                        <Routes>
-                            <Route path="/" element={<h1>Welcome to My React Project</h1>} />
-                            <Route path="/markdown/:id" element={<MarkdownContent />} />
-                            <Route path="/callback" element={<Callback />} />
-                            <Route path="/test" element={<h1>TEST</h1>}></Route>
-                            <Route path="/markdown/create" element={<MarkdownEditor />} />
-                            <Route path="/markdown/edit/:id" element={<MarkdownEditor />} />
-                            <Route path="/popup_callback" element={<PopupCallback />} />
-                            <Route path="silent_callback" element={<SilentCallback />} />
-                        </Routes>
-                    </main>
-                </div>
-            </div>
-            <Footer />
-        </Router>
+        <Provider store={store}>
+            <Router>
+                <Routes>
+                    <Route path="/pg/*" element={<StandaloneMarkdownPage />} />
+                    <Route path="*" element={
+                        <div className="app-container">
+                            <MainNavigation />
+                            <div className="content-container">
+                                <SideNavigation />
+                                <main className="main-content">
+                                    <Routes>
+                                        <Route
+                                            path="/"
+                                            element={<Navigate to = "/markdown/1"/>}
+                                        />
+                                        <Route path="/testx" element={<h2>test2</h2>}/>
+                                        <Route path="/markdown/:strId" element={<MarkdownContent />} />
+                                        <Route path="/callback" element={<Callback />} />
+                                        <Route path="/test" element={<h1>TEST</h1>}></Route>
+                                        <Route path="/markdown/create" element={<MarkdownEditor />} />
+                                        <Route path="/markdown/edit/:strId" element={<MarkdownEditor />} />
+                                        <Route path="/popup_callback" element={<PopupCallback />} />
+                                        <Route path="/silent_callback" element={<SilentCallback />} />
+                                        <Route path="/template/create" element={<MarkdownTemplateEditor />} />
+                                        <Route path="/template/edit/:strId" element={<MarkdownTemplateEditor />} />
+                                    </Routes>
+                                </main>
+                            </div>
+                        </div>
+                    } />
+                </Routes>
+                <Footer />
+            </Router>
+        </Provider>
     );
 };
 

src/AuthProvider.js

@@ -1,4 +1,3 @@
-// src/AuthProvider.js
 import React, { createContext, useContext, useEffect, useMemo, useState } from "react";
 import { UserManager } from "oidc-client-ts";
 import { ConfigContext } from "./ConfigProvider";

src/ConfigProvider.js

@@ -33,7 +33,6 @@ const ConfigProvider = ({ children }) => {
                 return res.json();
             })
             .then((data) => {
-                console.log(data);
                 setConfig(data);
                 setIsLoading(false);
             })

src/components/Debug/ControlledReactQueryDevtools.js

@@ -0,0 +1,14 @@
+import React from "react";
+import {useConfig} from "../../ConfigProvider";
+import {ReactQueryDevtools} from "@tanstack/react-query-devtools";
+
+export const ControlledReactQueryDevtools = () => {
+    const config = useConfig();
+    if(config.DEBUG)
+        return (<ReactQueryDevtools />);
+
+    return (<></>);
+
+};
+
+export default ControlledReactQueryDevtools;

src/components/Footer.css

@@ -33,14 +33,22 @@
 .footer-content {
     margin-bottom: auto;
     text-align: center;
+    width: 100%;
+}
+
+.footer-content a {
+    color: #fff;
+    font-size: 1.2rem;
+    text-decoration: underline;
 }
 
 .footer-icons {
     display: flex;
     flex-direction: column;
     gap: 1rem;
-    align-items: flex-end;
-    margin-right: 1rem;
+    align-items: flex-start;
+    margin-left: 1rem;
+    width: 100%;
 }
 
 .footer-icon {

src/components/Footer.js

@@ -25,7 +25,15 @@ const Footer = () => {
                 {isExpanded ? "↓" : "↑"}
             </button>
             <div className={`footer-content`}>
-                <p>&copy; {new Date().getFullYear()} Hangman Lab. All rights reserved.</p>
+                <p>&copy; {new Date().getFullYear()} Hangman Lab. {!isVisible && (<span>
+                        &nbsp;&nbsp;&nbsp;&nbsp;
+                        <a href="mailto:hzhang@hangman-lab.top">email</a>
+                        &nbsp;&nbsp;&nbsp;&nbsp;
+                        <a href="https://git.hangman-lab.top/hzhang/HangmanLab">git</a>
+                        &nbsp;&nbsp;&nbsp;&nbsp;
+                        &nbsp;&nbsp;&nbsp;&nbsp;
+                    </span>
+                    )}</p>
                 {
                     isVisible && (
                         <div
@@ -52,10 +60,10 @@ const Footer = () => {
                                 >
                                     <img
                                         src="/icons/git.png"
-                                        alt="GitHub"
+                                        alt="Git"
                                         className="footer-icon"
                                     />
-                                    GitHub
+                                    Git
                                 </a>
                                 <a href="mailto:hzhang@hangman-lab.top">
                                     <img
@@ -70,7 +78,6 @@ const Footer = () => {
                     )
                 }
             </div>
-
         </footer>
     );
 };

src/components/MarkdownTemplate/EnumsEditor.js

@@ -0,0 +1,65 @@
+import React, { useState } from "react";
+
+const EnumsEditor = ({ enums, onChange }) => {
+    const [_enums, setEnums] = useState(enums || []);
+
+    return (
+        <div className="box">
+            <ul>
+                {_enums.map((item, index) => (
+                    <li key={index} className="field has-addons" style={{ marginBottom: "0.5rem" }}>
+                        <div className="control is-expanded">
+                            <input
+                                className="input is-small"
+                                type="text"
+                                value={item}
+                                onChange={(e) => {
+                                    const updated = [..._enums];
+                                    updated[index] = e.target.value;
+                                    setEnums(updated);
+                                    onChange(updated);
+                                }}
+                            />
+                        </div>
+                        <div className="control">
+                            <button
+                                className="button is-small is-danger"
+                                type="button"
+                                onClick={() => {
+                                    const updated = [..._enums];
+                                    updated.splice(index, 1);
+                                    setEnums(updated);
+                                    onChange(updated);
+                                }}
+                            >
+                                <span className="icon is-small">
+                                    <i className="fas fa-times" />
+                                </span>
+                            </button>
+                        </div>
+                    </li>
+                ))}
+            </ul>
+            <div className="field">
+                <div className="control">
+                    <button
+                        className="button is-small is-primary"
+                        type="button"
+                        onClick={() => {
+                            const updated = [..._enums, ""];
+                            setEnums(updated);
+                            onChange(updated);
+                        }}
+                    >
+                        <span className="icon is-small">
+                          <i className="fas fa-plus" />
+                        </span>
+                        <span>Add Enum</span>
+                    </button>
+                </div>
+            </div>
+        </div>
+    );
+};
+
+export default EnumsEditor;

src/components/MarkdownTemplate/LayoutEditor.js

@@ -0,0 +1,18 @@
+import React, {useEffect, useState} from 'react';
+const LayoutEditor = ({layout, onChange}) => {
+    const [_layout, setLayout] = useState(layout || "");
+    useEffect(() => {setLayout(layout)}, [layout]);
+    return (
+        <textarea
+            className="textarea"
+            style={{ height: "60vh" }}
+            value={_layout}
+            onChange={(e) => {
+                setLayout(e.target.value);
+                onChange(e.target.value);
+            }}
+        />
+    );
+};
+
+export default LayoutEditor;

src/components/MarkdownTemplate/MarkdownTemplateEditor.js

@@ -0,0 +1,99 @@
+import React, {useContext, useEffect, useState} from "react";
+import { AuthContext } from "../../AuthProvider";
+import { useNavigate, useParams } from "react-router-dom";
+import { useMarkdownTemplate, useSaveMarkdownTemplate } from "../../utils/queries/markdown-template-queries";
+import LayoutEditor from "./LayoutEditor";
+import ParametersManager from "./ParametersManager";
+import "bulma/css/bulma.min.css";
+
+const MarkdownTemplateEditor = () => {
+
+
+    const navigate = useNavigate();
+    const { strId } = useParams();
+    const id = Number(strId);
+    const { data: template, isFetching: templateIsFetching } = useMarkdownTemplate(id);
+    const saveMarkdownTemplate = useSaveMarkdownTemplate();
+
+    const [title, setTitle] = useState(template?.id || "");
+    const [parameters, setParameters] = useState(template?.parameters || []);
+    const [layout, setLayout] = useState(template?.layout || "");
+    const { roles } = useContext(AuthContext);
+
+    useEffect(() => {
+        setTitle(template?.title || "");
+        setParameters(template?.parameters || []);
+        setLayout(template?.layout || "");
+    }, [template]);
+
+    if (templateIsFetching) {
+        return <p>Loading...</p>;
+    }
+
+    if (!roles.includes("admin") || roles.includes("creator"))
+        return <div className="notification is-danger">Permission Denied</div>;
+    const handleSave = () => {
+        saveMarkdownTemplate.mutate(
+            { id, data: { title, parameters, layout } },
+            {
+                onSuccess: () => {
+                    navigate("/");
+                },
+                onError: () => {
+                    alert("Error saving template.");
+                }
+            }
+        );
+    };
+
+    return (
+        <section className="section">
+            <div className="container">
+                <h2 className="title is-4">Markdown Template Editor</h2>
+                <div className="field">
+                    <label className="label">Title:</label>
+                    <div className="control">
+                        <input
+                            className="input"
+                            type="text"
+                            placeholder="Enter template title"
+                            value={title}
+                            onChange={(e) => setTitle(e.target.value)}
+                        />
+                    </div>
+                </div>
+                <div className="columns is-variable is-8">
+                    <div className="column">
+                        <h3 className="title is-5">Layout</h3>
+
+                        <div className="box">
+                            <LayoutEditor
+                                layout={layout}
+                                parameters={parameters}
+                                onChange={(newLayout) => setLayout(newLayout)}
+                            />
+                        </div>
+
+                    </div>
+                    <div className="column">
+                        <h3 className="title is-5">Parameters</h3>
+                        <ParametersManager
+                            parameters={parameters}
+                            onChange={(newParameters) => setParameters(newParameters)}
+                        />
+
+                    </div>
+                </div>
+                <div className="field is-grouped">
+                    <div className="control">
+                        <button className="button is-primary" onClick={handleSave}>
+                            Save Template
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </section>
+    );
+};
+
+export default MarkdownTemplateEditor;

src/components/MarkdownTemplate/ParametersManager.js

@@ -0,0 +1,121 @@
+import React, {useEffect, useState} from "react";
+import TypeEditor from "./TypeEditor";
+
+const ParametersManager = ({ parameters, onChange }) => {
+    const [_parameters, setParameters] = useState(parameters || []);
+    const [expandedStates, setExpandedStates] = useState({});
+
+    const handleAdd = () => {
+        const updated = [
+            ..._parameters,
+            {
+                name: "",
+                type: { 
+                    base_type: "string",
+                    definition: {}
+                }
+            }
+        ];
+        setParameters(updated);
+        onChange(updated);
+    };
+
+    const handleTypeChange = (index, newType) => {
+        const updated = [..._parameters];
+        if (newType.base_type === "list" && !newType.extend_type) {
+            newType.extend_type = {
+                base_type: "string",
+                definition: {}
+            };
+        }
+        updated[index].type = newType;
+        setParameters(updated);
+        onChange(updated);
+    };
+
+    useEffect(() => {
+        setParameters(parameters);
+    }, [parameters]);
+
+    const handleNameChange = (index, newName) => {
+        const updated = [..._parameters];
+        updated[index].name = newName;
+        setParameters(updated);
+        onChange(updated);
+    };
+
+    const handleDelete = (index) => {
+        const updated = [..._parameters];
+        updated.splice(index, 1);
+        setParameters(updated);
+        onChange(updated);
+    };
+
+    const toggleExpand = (index) => {
+        setExpandedStates(prev => ({
+            ...prev,
+            [index]: !prev[index]
+        }));
+    };
+
+    return (
+        <div className="box">
+            <div className="field">
+                <div className="control">
+                    <button className="button is-primary" onClick={handleAdd}>
+                        Add Parameter
+                    </button>
+                </div>
+            </div>
+            <div style={{ maxHeight: "50vh", overflowY: "auto" }}>
+                {_parameters.map((param, index) => (
+                    <div key={index} className="box" style={{ marginBottom: "0.5rem" }}>
+                        <div className="field is-grouped is-align-items-end">
+                            <div className="control">
+                                <label className="label">Name:</label>
+                            </div>
+                            <div className="control is-expanded">
+                                <input
+                                    type="text"
+                                    className="input"
+                                    value={param.name}
+                                    onChange={(e) => handleNameChange(index, e.target.value)}
+                                    placeholder="Parameter name"
+                                />
+                            </div>
+                            <div className="control">
+                                <button
+                                    className="button is-danger"
+                                    onClick={() => handleDelete(index)}
+                                >
+                                    Delete
+                                </button>
+                            </div>
+                        </div>
+                        <div className="field">
+                            <div className="is-flex is-justify-content-space-between is-align-items-center mb-1">
+                                <label className="label mb-0">Type:</label>
+                                <button 
+                                    className="button is-small"
+                                    onClick={() => toggleExpand(index)}
+                                >
+                                    {expandedStates[index] ? "-" : "+"}
+                                </button>
+                            </div>
+                            {expandedStates[index] && (
+                                <div className="control">
+                                    <TypeEditor
+                                        type={param.type}
+                                        onChange={(newType) => handleTypeChange(index, newType)}
+                                    />
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                ))}
+            </div>
+        </div>
+    );
+};
+
+export default ParametersManager;

src/components/MarkdownTemplate/TemplateSelector.js

@@ -0,0 +1,61 @@
+import React, { useEffect, useState } from "react";
+import { useMarkdownTemplates } from "../../utils/queries/markdown-template-queries";
+
+const TemplateSelector = ({ template, onChange, onCreate }) => {
+    const { data: templates, isFetching: templatesAreFetching } = useMarkdownTemplates();
+    const [_template, setTemplate] = useState(
+        templates?.find((t) => t.id === template?.id) || {
+            title: "",
+            parameters: [],
+            layout: "",
+        }
+    );
+
+    useEffect(() => {
+        setTemplate(
+            templates?.find((t) => t.id === template?.id) || {
+                title: "",
+                parameters: [],
+                layout: "",
+            }
+        );
+    }, [template, templates]);
+
+    if (templatesAreFetching) {
+        return <p>Loading...</p>;
+    }
+
+    return (
+        <div className="field">
+            <label className="label">Select Template</label>
+            <div className="control">
+                <div className="select is-fullwidth is-primary">
+                    <select
+                        value={template?.id || ""}
+                        onChange={(e) => {
+                            const id = parseInt(e.target.value, 10);
+                            const selectedTemplate = templates.find((t) => t.id === id) || {
+                                title: "",
+                                parameters: [],
+                                layout: "",
+                            };
+                            onChange(selectedTemplate);
+                            if (onCreate) {
+                                onCreate(selectedTemplate);
+                            }
+                        }}
+                    >
+                        <option value="">(None)</option>
+                        {templates.map((tmpl) => (
+                            <option key={tmpl.id} value={tmpl.id}>
+                                {tmpl.title}
+                            </option>
+                        ))}
+                    </select>
+                </div>
+            </div>
+        </div>
+    );
+};
+
+export default TemplateSelector;

src/components/MarkdownTemplate/TypeEditor.js

@@ -0,0 +1,121 @@
+import React from 'react';
+import EnumsEditor from './EnumsEditor';
+import TemplateSelector from './TemplateSelector';
+
+const TypeEditor = ({ type, onChange }) => {
+    const [_type, setType] = React.useState(type || {});
+
+    const updateType = (updated) => {
+        setType(updated);
+        onChange(updated);
+    };
+
+    const renderExtraFields = () => {
+        switch (_type.base_type) {
+            case 'enum':
+                return (
+                    <div className="field">
+                        <label className="label">Enums</label>
+                        <div className="control">
+                            <EnumsEditor
+                                enums={_type.definition.enums}
+                                onChange={(newEnums) => {
+                                    updateType({
+                                        ..._type,
+                                        definition: { ..._type.definition, enums: newEnums },
+                                    });
+                                }}
+                            />
+                        </div>
+                    </div>
+                );
+
+            case 'list':
+                return (
+                    <div className="box">
+                        <div className="field">
+                            <label className="label">Extend Type</label>
+                            <div className="control">
+                                <TypeEditor
+                                    type={_type.extend_type}
+                                    onChange={(extendType) => {
+                                        updateType({ ..._type, extend_type: extendType });
+                                    }}
+                                />
+                            </div>
+                        </div>
+
+                        <div className="field">
+                            <label className="label">Iter Layout</label>
+                            <div className="control">
+                                <textarea
+                                    className="textarea"
+                                    value={_type.definition.iter_layout || ''}
+                                    onChange={(e) => {
+                                        updateType({
+                                            ..._type,
+                                            definition: {
+                                                ..._type.definition,
+                                                iter_layout: e.target.value,
+                                            },
+                                        });
+                                    }}
+                                />
+                            </div>
+                        </div>
+                    </div>
+                );
+
+            case 'template':
+                return (
+                    <div className="field">
+                        <div className="control">
+                            <TemplateSelector
+                                template={_type.definition.template}
+                                onChange={(newTemplate) => {
+                                    updateType({
+                                        ..._type,
+                                        definition: {
+                                            ..._type.definition,
+                                            template: newTemplate,
+                                        },
+                                    });
+                                }}
+                            />
+                        </div>
+                    </div>
+                );
+
+            default:
+                return null;
+        }
+    };
+
+    return (
+        <div className="box">
+            <div className="field">
+                {/*<label className="label">Type</label>*/}
+                <div className="control">
+                    <div className="select is-fullwidth">
+                        <select
+                            value={_type.base_type || ''}
+                            onChange={(e) => {
+                                const updated = { base_type: e.target.value, definition: {} };
+                                updateType(updated);
+                            }}
+                        >
+                            <option value="string">string</option>
+                            <option value="markdown">markdown</option>
+                            <option value="enum">enum</option>
+                            <option value="list">list</option>
+                            <option value="template">template</option>
+                        </select>
+                    </div>
+                </div>
+            </div>
+            {renderExtraFields()}
+        </div>
+    );
+};
+
+export default TypeEditor;

src/components/Markdowns/MarkdownContent.js

@@ -4,15 +4,23 @@ import "katex/dist/katex.min.css";
 import "./MarkdownContent.css";
 import MarkdownView from "./MarkdownView";
 import PermissionGuard from "../PermissionGuard";
-import {useMarkdown} from "../../utils/markdown-queries";
-import {usePath} from "../../utils/path-queries";
+import {useMarkdown} from "../../utils/queries/markdown-queries";
+import {usePath} from "../../utils/queries/path-queries";
+import {useMarkdownSetting} from "../../utils/queries/markdown-setting-queries";
+import {useMarkdownTemplate} from "../../utils/queries/markdown-template-queries";
+import {useMarkdownTemplateSetting} from "../../utils/queries/markdown-template-setting-queries";
+import MarkdownSettingModal from "../Modals/MarkdownSettingModal";
 
 const MarkdownContent = () => {
-    const { id } = useParams();
+    const { strId } = useParams();
+    const id = Number(strId);
     const [indexTitle, setIndexTitle] = useState(null);
+    const [isSettingModalOpen, setSettingModalOpen] = useState(false);
     const {data: markdown, isLoading, error} = useMarkdown(id);
     const {data: path, isFetching: isPathFetching} = usePath(markdown?.path_id);
-
+    const {data: setting, isFetching: isSettingFetching} = useMarkdownSetting(markdown?.setting_id);
+    const {data: templateSetting, isFetching: isTemplateSettingFetching} = useMarkdownTemplateSetting(setting?.template_setting_id);
+    const {data: template, isFetching: isTemplateFetching} = useMarkdownTemplate(templateSetting?.template_id);
 
     useEffect(() => {
         if(markdown && markdown.title === "index" && path){
@@ -21,28 +29,53 @@ const MarkdownContent = () => {
     }, [markdown, path]);
 
 
-    if (isLoading || isPathFetching) {
+    const notReady = isLoading || isPathFetching || isSettingFetching || isTemplateSettingFetching || isTemplateFetching;
+
+    if (notReady) {
         return <div>Loading...</div>;
     }
 
     if (error) {
         return <div>Error: {error.message || "Failed to load content"}</div>;
     }
+    if (markdown.isMessage) {
+
+        return (
+            <div className="markdown-content-container">
+                <div className="notification is-info">
+                    <h4 className="title is-4">{markdown.title}</h4>
+                    <p>{markdown.content}</p>
+                </div>
+            </div>
+        );
+    }
 
     return (
         <div className="markdown-content-container">
-            <div className="field has-addons markdown-content-container-header">
-                <h1 className="title control">{markdown.title === "index" ? indexTitle : markdown.title}</h1>
+            <div className="is-flex is-justify-content-space-between is-align-items-center markdown-content-container-header">
+                <h1 className="title">{markdown.title === "index" ? indexTitle : markdown.title}</h1>
                 <PermissionGuard rolesRequired={['admin']}>
-                    <Link to={`/markdown/edit/${id}`} className="control button is-primary is-light">
-                        Edit
-                    </Link>
+                    <div className="field has-addons">
+                        <button
+                            className="control button is-info is-light"
+                            onClick={() => setSettingModalOpen(true)}
+                        >
+                            Settings
+                        </button>
+                        <Link to={`/markdown/edit/${id}`} className="control button is-primary is-light">
+                            Edit
+                        </Link>
+                    </div>
                 </PermissionGuard>
             </div>
-
-            <MarkdownView content={markdown.content}/>
+            <MarkdownView content={JSON.parse(markdown.content)} template={template}/>
+            <MarkdownSettingModal 
+                isOpen={isSettingModalOpen}
+                markdown={markdown}
+                onClose={() => setSettingModalOpen(false)}
+            />
         </div>
     );
 };
 
-export default MarkdownContent;
+export default MarkdownContent;

src/components/Markdowns/MarkdownEditor.css

@@ -1,6 +1,6 @@
 
 .markdown-editor-container {
-    max-width: 800px;
+    max-width: 90vw;
     margin: 0 auto;
     padding: 20px;
     background-color: #f8f9fa;
@@ -92,4 +92,19 @@ pre {
     padding: 10px;
     border-radius: 6px;
     overflow-x: auto;
-}
+}
+.raw-editor {
+    font-family: monospace;
+    white-space: pre;
+    tab-size: 2;
+}
+
+.editor-toggle-button {
+    margin-left: 10px;
+}
+
+.json-error {
+    color: red;
+    margin-top: 5px;
+    font-size: 0.9em;
+}

src/components/Markdowns/MarkdownEditor.js

@@ -5,61 +5,206 @@ import "katex/dist/katex.min.css";
 import "./MarkdownEditor.css";
 import PathManager from "../PathManager";
 import MarkdownView from "./MarkdownView";
-import { useMarkdown, useSaveMarkdown } from "../../utils/markdown-queries";
+import { useMarkdown, useSaveMarkdown } from "../../utils/queries/markdown-queries";
+import {useMarkdownSetting, useUpdateMarkdownSetting} from "../../utils/queries/markdown-setting-queries";
+import {useMarkdownTemplate, useMarkdownTemplates} from "../../utils/queries/markdown-template-queries";
+import TemplatedEditor from "./TemplatedEditor";
+import {useMarkdownTemplateSetting, useUpdateMarkdownTemplateSetting, useCreateMarkdownTemplateSetting} from "../../utils/queries/markdown-template-setting-queries";
+import TemplateSelector from "../MarkdownTemplate/TemplateSelector";
+import {useCreateMarkdownSetting} from "../../utils/queries/markdown-setting-queries";
 
 const MarkdownEditor = () => {
     const { roles } = useContext(AuthContext);
     const navigate = useNavigate();
-    const { id } = useParams();
+    const { strId } = useParams();
+    const id = Number(strId);
     const [title, setTitle] = useState("");
-    const [content, setContent] = useState("");
+    const [content, setContent] = useState({});
+    const [shortcut, setShortcut] = useState("");
     const [pathId, setPathId] = useState(1);
-    const {data: markdown, isLoading, error} = useMarkdown(id);
+    const [isRawMode, setIsRawMode] = useState(false);
+    const [rawContent, setRawContent] = useState("");
+    const [jsonError, setJsonError] = useState("");
+    const [selectedTemplate, setSelectedTemplate] = useState(null);
+    const {data: markdown, isFetching: isMarkdownFetching, error} = useMarkdown(id);
     const saveMarkdown = useSaveMarkdown();
+    const {data: setting, isFetching: isSettingFetching} = useMarkdownSetting(markdown?.setting_id);
+    const {data: templateSetting, isFetching: isTemplateSettingFetching} = useMarkdownTemplateSetting(setting?.template_setting_id);
+    const {data: template, isFetching: isTemplateFetching} = useMarkdownTemplate(templateSetting?.template_id);
+    const updateTemplateSetting = useUpdateMarkdownTemplateSetting();
+    const createTemplateSetting = useCreateMarkdownTemplateSetting();
+    const updateSetting = useUpdateMarkdownSetting();
+    const {data: templates, isFetching: templatesAreFetching} = useMarkdownTemplates();
+    const createMarkdownSetting = useCreateMarkdownSetting();
 
-
+    const notReady = isMarkdownFetching || isTemplateFetching || isSettingFetching || isTemplateSettingFetching || templatesAreFetching;
 
     useEffect(() => {
-        if(markdown){
+        if (markdown) {
             setTitle(markdown.title);
-            setContent(markdown.content);
-            setPathId(markdown.path_id);
+            if (markdown.isMessage) {
+                navigate("/");
+                alert(markdown.content || "Cannot edit this markdown");
+                return;
+            }
+            try {
+                const parsedContent = JSON.parse(markdown.content);
+                setContent(parsedContent);
+                setRawContent(JSON.stringify(parsedContent, null, 2));
+                setShortcut(markdown.shortcut);
+                setPathId(markdown.path_id);
+            } catch (e) {
+                console.error("Error parsing markdown content:", e);
+                alert("Error parsing markdown content");
+                navigate("/");
+            }
         }
-    }, [markdown]);
+    }, [markdown, navigate]);
+
+    useEffect(() => {
+        if (template) {
+            setSelectedTemplate(template);
+        }
+    }, [template]);
 
     const handleSave = () => {
-        saveMarkdown.mutate(
-            {id, data: {title, content, path_id: pathId}},
-            {
-                onSuccess: () => {
-                    navigate("/");
-                },
-                onError: () => {
-                    alert("Error saving markdown file");
+        if (isRawMode && jsonError) {
+            alert("Please fix the JSON errors before saving");
+            return;
+        }
+
+        const saveData = {
+            title,
+            content: JSON.stringify(content),
+            path_id: pathId,
+            shortcut
+        };
+        console.log("markdown", markdown);
+        console.log(markdown?.id ? "update" : "create",)
+        if (!markdown?.id) {
+            saveMarkdown.mutate(
+                {data: saveData},
+                {
+                    onSuccess: (newMarkdown) => {
+                        createMarkdownSetting.mutate({}, {
+                            onSuccess: (settingRes) => {
+                                saveMarkdown.mutate({
+                                    id: newMarkdown.id,
+                                    data: {
+                                        setting_id: settingRes.id
+                                    }
+                                }, {
+                                    onSuccess: () => {
+                                        if (selectedTemplate?.id) {
+                                            createTemplateSetting.mutate({
+                                                template_id: selectedTemplate.id
+                                            }, {
+                                                onSuccess: (templateSettingRes) => {
+                                                    updateSetting.mutate({
+                                                        id: settingRes.id,
+                                                        data: {
+                                                            template_setting_id: templateSettingRes.id
+                                                        }
+                                                    }, {
+                                                        onSuccess: () => {
+                                                            navigate("/");
+                                                        }
+                                                    });
+                                                }
+                                            });
+                                        } else {
+                                            navigate("/");
+                                        }
+                                    }
+                                });
+                            }
+                        });
+                    },
+                    onError: () => {
+                        alert("Error saving markdown file");
+                    }
                 }
-            });
+            );
+        } else {
+            console.log("try update");
+            saveMarkdown.mutate(
+                {id, data: saveData},
+                {
+                    onSuccess: () => {
+                        navigate("/markdown/" + id);
+                    },
+                    onError: () => {
+                        alert("Error saving markdown file");
+                    }
+                }
+            );
+        }
     };
 
+    const toggleEditMode = () => {
+        if (isRawMode) {
+            try {
+                const parsed = JSON.parse(rawContent);
+                setContent(parsed);
+                setJsonError("");
+                setIsRawMode(false);
+            } catch (e) {
+                setJsonError("Invalid JSON: " + e.message);
+                return;
+            }
+        } else {
+            setRawContent(JSON.stringify(content, null, 2));
+            setIsRawMode(true);
+        }
+    };
+
+    const handleRawContentChange = (e) => {
+        const newRawContent = e.target.value;
+        setRawContent(newRawContent);
+        try {
+            const parsed = JSON.parse(newRawContent);
+            setContent(parsed);
+            setJsonError("");
+        } catch (e) {
+            setJsonError("Invalid JSON: " + e.message);
+        }
+    };
+
+    const handleTemplateChange = (newTemplate) => {
+        setSelectedTemplate(newTemplate);
+        if (templateSetting) {
+            updateTemplateSetting.mutate({
+                id: templateSetting.id,
+                data: {
+                    template_id: newTemplate.id
+                }
+            });
+        }
+    };
 
     const hasPermission = roles.includes("admin") || roles.includes("creator");
-    if (!hasPermission) {
+    if (!hasPermission)
         return <div className="notification is-danger">Permission Denied</div>;
-    }
 
-    if(isLoading)
+    if(notReady) {
+        console.log("=============");
+        console.log("isMarkdownFetching", isMarkdownFetching );
+        console.log("isTemplateFetching", isTemplateFetching );
+        console.log("isSettingFetching", isSettingFetching );
+        console.log("isTemplateSettingFetching", isTemplateSettingFetching);
+        console.log( "TemplatesAreFetching", templatesAreFetching);
+        console.log("----------------");
         return <p>Loading...</p>;
+    }
 
     if(error)
         return <p>{error.message || "Failed to load markdown"}</p>;
-
     return (
         <div className="container mt-5 markdown-editor-container">
             <h2 className="title is-4">{id ? "Edit Markdown" : "Create Markdown"}</h2>
             <div className="columns">
-                {/* Editor Column */}
                 <div className="column is-half">
                     <form>
-                        {/* Title Field */}
                         <div className="field">
                             <label className="label">Title</label>
                             <div className="control">
@@ -73,7 +218,18 @@ const MarkdownEditor = () => {
                             </div>
                         </div>
 
-                        {/* PathManager Field */}
+                        <div className="field">
+                            <label className="label">Shortcut</label>
+                            <div className="control">
+                                <input
+                                    className="input"
+                                    type="text"
+                                    placeholder="Enter shortcut"
+                                    value={shortcut}
+                                    onChange={(e) => setShortcut(e.target.value)}
+                                />
+                            </div>
+                        </div>
                         <div className="field">
                             <label className="label">Path</label>
                             <PathManager
@@ -82,21 +238,56 @@ const MarkdownEditor = () => {
                             />
                         </div>
 
-                        {/* Content Field */}
                         <div className="field">
-                            <label className="label">Content</label>
                             <div className="control">
-                                <textarea
-                                    style={{ height: "70vh" }}
-                                    className="textarea"
-                                    placeholder="Enter Markdown content"
-                                    value={content}
-                                    onChange={(e) => setContent(e.target.value)}
-                                ></textarea>
+                                <TemplateSelector
+                                    template={selectedTemplate || template}
+                                    onChange={handleTemplateChange}
+                                />
+                            </div>
+                        </div>
+
+                        <div className="field">
+                            <div className="is-flex is-justify-content-space-between is-align-items-center mb-2">
+                                <label className="label mb-0">Content</label>
+                                <button
+                                    type="button"
+                                    className={`button is-small editor-toggle-button ${isRawMode ? 'is-info' : 'is-light'}`}
+                                    onClick={toggleEditMode}
+                                >
+                                    {isRawMode ? 'Switch to Template Editor' : 'Switch to Raw Editor'}
+                                </button>
+                            </div>
+                            <div className="control">
+                                {isRawMode ? (
+                                    <div>
+                                        <p className="help mb-2">
+                                            Edit the JSON directly. Make sure it's valid JSON before saving.
+                                        </p>
+                                        <textarea
+                                            className={`textarea raw-editor ${jsonError ? 'is-danger' : ''}`}
+                                            style={{height: "70vh"}}
+                                            value={rawContent}
+                                            onChange={handleRawContentChange}
+                                            placeholder="Enter JSON content here"
+                                        />
+                                        {jsonError && (
+                                            <p className="help is-danger json-error">{jsonError}</p>
+                                        )}
+                                    </div>
+                                ) : (
+                                    <TemplatedEditor
+                                        style={{height: "40vh"}}
+                                        content={content}
+                                        template={!markdown?.id ? selectedTemplate : template}
+                                        onContentChanged={(k, v) => setContent(
+                                            prev => ({...prev, [k]: v})
+                                        )}
+                                    />
+                                )}
                             </div>
                         </div>
 
-                        {/* Save Button */}
                         <div className="field">
                             <div className="control">
                                 <button
@@ -112,14 +303,17 @@ const MarkdownEditor = () => {
                     </form>
                 </div>
 
-                {/* Preview Column */}
                 <div className="column is-half">
                     <h3 className="subtitle is-5">Preview</h3>
-                    <MarkdownView content={content} height='70vh'/>
+                    <MarkdownView 
+                        content={content} 
+                        template={!markdown?.id ? selectedTemplate : template} 
+                        height='70vh'
+                    />
                 </div>
             </div>
         </div>
     );
 };
 
-export default MarkdownEditor;
+export default MarkdownEditor;

src/components/Markdowns/MarkdownView.css

@@ -46,4 +46,67 @@ pre {
 
 .markdown-preview li {
     margin-bottom: 0.5rem;
-}
+}
+
+.markdown-preview h1 {
+    font-size: 2em;
+    font-weight: bold;
+    margin-bottom: 0.5rem;
+    color: #333;
+}
+
+.markdown-preview h2 {
+
+    font-size: 1.75em;
+    font-weight: bold;
+    margin-bottom: 0.5rem;
+    color: #444;
+}
+
+.markdown-preview h3 {
+    font-size: 1.5em;
+    font-weight: bold;
+    margin-bottom: 0.5rem;
+    color: #555;
+}
+
+
+.markdown-preview h4 {
+    font-size: 1.25em;
+    font-weight: bold;
+    margin-bottom: 0.5rem;
+    color: #666;
+}
+
+.markdown-preview h5 {
+    font-size: 1.1em;
+    font-weight: bold;
+    margin-bottom: 0.5rem;
+    color: #777;
+}
+
+
+.markdown-preview h6 {
+    font-size: 1em;
+    font-weight: bold;
+    margin-bottom: 0.5rem;
+    color: #888;
+}
+
+.markdown-preview table {
+    width: 100%;
+    border-collapse: collapse;
+    border: 1px solid #ddd;
+}
+
+.markdown-preview th,
+.markdown-preview td {
+    border: 1px solid #ddd;
+    padding: 8px;
+    text-align: left;
+}
+
+.markdown-preview th {
+    background-color: #f4f4f4;
+    font-weight: bold;
+}

src/components/Markdowns/MarkdownView.js

@@ -3,17 +3,77 @@ import ReactMarkdown from "react-markdown";
 import remarkMath from "remark-math";
 import rehypeKatex from "rehype-katex";
 import rehypeRaw from "rehype-raw";
+import remarkGfm from "remark-gfm";
 import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
 import { okaidia } from "react-syntax-highlighter/dist/esm/styles/prism";
 import "katex/dist/katex.min.css";
 import "./MarkdownView.css";
+import {useLinks} from "../../utils/queries/markdown-queries";
+
+const Translate = ({variable, value}) => {
+    if (variable.type.base_type === "markdown" || variable.type.base_type === "string" || variable.type.base_type === "enum") {
+        return value;
+    }
+    if(variable.type.base_type === "list"){
+        if (!variable.type.extend_type)
+            return [];
+
+        return (value || []).map((item, index) => Translate({
+            variable: {name: index, type: variable.type.extend_type},
+            value: item,
+        })).map((item) => variable.type.definition.iter_layout.replaceAll('<item/>', item)).join("");
+    }
+    if(variable.type.base_type === "template"){
+        return ParseTemplate({
+            template: variable.type.definition.template,
+            variables: value
+        });
+    }
+};
+
+
+const ParseTemplate = ({template, variables}) => {
+    if(!template || !Array.isArray(template.parameters)) return '';
+    const vars = variables || {};
+    let res = template.layout ?? '';
+    for (const parameter of template.parameters) {
+        res = res.replaceAll(`<${parameter.name}/>`, Translate({
+            variable: parameter,
+            value: vars[parameter.name]
+        }));
+    }
+    return res;
+};
+
+
+const MarkdownView = ({ content, template, height="auto" }) => {
+    const {data: links, isLoading} = useLinks();
+
+    if (isLoading)
+        return (<p>Loading...</p>);
+    const linkDefinitions = "\n<!-- Definitions -->\n" + links.join("\n");
+    const _template = template || {
+        parameters: [
+            {
+                name: "markdown",
+                type: {
+                    base_type: "markdown",
+                    definition: {}
+                }
+            }
+        ],
+        layout: "<markdown/>",
+        title: "default"
+    };
 
-const MarkdownView = ({ content, height="auto" }) => {
     return (
         <div className="markdown-preview" style={{height}}>
             <ReactMarkdown
-                children={content}
-                remarkPlugins={[remarkMath]}
+                children={ParseTemplate({
+                    template: _template,
+                    variables: content
+                }) + "\n" + linkDefinitions}
+                remarkPlugins={[remarkMath, remarkGfm]}
                 rehypePlugins={[rehypeKatex, rehypeRaw]}
                 components={{
                     code({ node, inline, className, children, ...props }) {

src/components/Markdowns/StandaloneMarkdownPage.js

@@ -0,0 +1,100 @@
+import React, { useEffect, useState } from "react";
+import { useLocation } from "react-router-dom";
+import "katex/dist/katex.min.css";
+import "./MarkdownContent.css";
+import MarkdownView from "./MarkdownView";
+import { useMarkdown } from "../../utils/queries/markdown-queries";
+import { useMarkdownSetting } from "../../utils/queries/markdown-setting-queries";
+import { useMarkdownTemplate } from "../../utils/queries/markdown-template-queries";
+import { useMarkdownTemplateSetting } from "../../utils/queries/markdown-template-setting-queries";
+import { useTree } from "../../utils/queries/tree-queries";
+import { getMarkdownIdByPath } from "../../utils/pathUtils";
+
+const StandaloneMarkdownPage = () => {
+    const location = useLocation();
+    const [indexTitle, setIndexTitle] = useState(null);
+    const [markdownId, setMarkdownId] = useState(null);
+    
+    // Extract path from /pg/project/index -> project/index
+    const pathString = location.pathname.replace(/^\/pg\//, '');
+    
+    const { data: tree, isLoading: isTreeLoading } = useTree();
+    const { data: markdown, isLoading: isMarkdownLoading, error } = useMarkdown(markdownId);
+    const { data: setting, isFetching: isSettingFetching } = useMarkdownSetting(markdown?.setting_id);
+    const { data: templateSetting, isFetching: isTemplateSettingFetching } = useMarkdownTemplateSetting(setting?.template_setting_id);
+    const { data: template, isFetching: isTemplateFetching } = useMarkdownTemplate(templateSetting?.template_id);
+
+    // Resolve markdown ID from path using tree
+    useEffect(() => {
+        if (tree && pathString) {
+            const resolvedId = getMarkdownIdByPath(tree, pathString);
+            setMarkdownId(resolvedId);
+        }
+    }, [tree, pathString]);
+
+    useEffect(() => {
+        if (markdown && markdown.title === "index" && pathString) {
+            const pathParts = pathString.split('/').filter(part => part.length > 0);
+            
+            if (pathParts.length === 0) {
+                // Root index: /pg/ or /pg
+                setIndexTitle("Home");
+            } else {
+                // Directory index: /pg/Projects or /pg/Projects/project1
+                // Use the last directory name as title
+                const directoryName = pathParts[pathParts.length - 1];
+                setIndexTitle(directoryName);
+            }
+        }
+    }, [markdown, pathString]);
+
+    const notReady = isTreeLoading || isMarkdownLoading || isSettingFetching || isTemplateSettingFetching || isTemplateFetching;
+
+    if (notReady) {
+        return (
+            <div style={{ padding: "2rem", textAlign: "center" }}>
+                <div>Loading...</div>
+            </div>
+        );
+    }
+
+    if (error) {
+        return (
+            <div style={{ padding: "2rem", textAlign: "center" }}>
+                <div>Error: {error.message || "Failed to load content"}</div>
+            </div>
+        );
+    }
+
+    if (!notReady && !markdownId) {
+        return (
+            <div style={{ padding: "2rem", textAlign: "center" }}>
+                <div>Markdown not found for path: {pathString}</div>
+            </div>
+        );
+    }
+
+    if (markdown?.isMessage) {
+        return (
+            <div style={{ padding: "2rem" }}>
+                <div className="notification is-info">
+                    <h4 className="title is-4">{markdown.title}</h4>
+                    <p>{markdown.content}</p>
+                </div>
+            </div>
+        );
+    }
+
+    return (
+        <div style={{ padding: "2rem", maxWidth: "100%", margin: "0 auto" }}>
+            <div style={{ marginBottom: "2rem" }}>
+                <h1 className="title">{markdown?.title === "index" ? indexTitle : markdown?.title}</h1>
+            </div>
+            {markdown && (
+                <MarkdownView content={JSON.parse(markdown.content)} template={template} />
+            )}
+        </div>
+    );
+};
+
+export default StandaloneMarkdownPage;

src/components/Markdowns/TemplatedEditor.js

@@ -0,0 +1,189 @@
+import React, {useState} from "react";
+import {useMarkdownTemplate} from "../../utils/queries/markdown-template-queries";
+
+const TemplatedEditorComponent = ({ variable, value, namespace, onContentChanged }) => {
+    console.log("variable", variable);
+    const __namespace = `${variable.name}(${variable.type.base_type})`;
+
+    const renderField = () => {
+        switch (variable.type.base_type) {
+            case "string":
+                return (
+                    <div className="box has-background-danger-soft">
+                        <label className="label">{__namespace}</label>
+                        <div className="control">
+                            <input
+                                type="text"
+                                className="input"
+                                value={value ?? ""}
+                                onChange={(e) => onContentChanged(variable.name, e.target.value)}
+                            />
+                        </div>
+                    </div>
+                );
+
+            case "markdown":
+                return (
+                    <div className="box has-background-primary-soft">
+                        <label className="label">{__namespace}</label>
+                        <div className="control">
+                            <textarea
+                                style={{maxHeight: "10vh"}}
+                                className="textarea"
+                                value={value}
+                                onChange={(e) => onContentChanged(variable.name, e.target.value)}
+                            />
+                        </div>
+                    </div>
+                );
+
+            case "enum":
+                return (
+                    <div className="box has-background-info-soft">
+                        <label className="label">{__namespace}</label>
+                        <div className="control">
+                            <div className="select is-fullwidth">
+                                <select
+                                    value={value}
+                                    onChange={(e) => onContentChanged(variable.name, e.target.value)}
+                                >
+                                    {variable.type.definition.enums.map((item) => (
+                                        <option key={item} value={item}>{item}</option>
+                                    ))}
+                                </select>
+                            </div>
+                        </div>
+                    </div>
+                );
+
+            case "list": {
+                const [cache, setCache] = useState(value || []);
+                const defaultValue = variable.type.definition.default;
+
+                const addItem = () => {
+                    const newCache = [...cache, defaultValue];
+                    setCache(newCache);
+                    onContentChanged(variable.name, newCache);
+                };
+
+                const removeItem = (index) => {
+                    const newCache = cache.filter((_, i) => i !== index);
+                    setCache(newCache);
+                    onContentChanged(variable.name, newCache);
+                };
+
+                const onItemChange = (index, val) => {
+                    const newCache = [...cache];
+                    newCache[index] = val;
+                    setCache(newCache);
+                    onContentChanged(variable.name, newCache);
+                };
+
+                return (
+                    <div className="box has-background-white-soft">
+                        <label className="label">{__namespace}</label>
+                        {cache.map((item, idx) => (
+                            <div className="field is-grouped" key={idx}>
+                                <div className="control is-expanded">
+                                    <TemplatedEditorComponent
+                                        variable={{ name: idx, type: variable.type.extend_type }}
+                                        value={item}
+                                        namespace={__namespace}
+                                        onContentChanged={(subKey, subVal) => onItemChange(idx, subVal)}
+                                    />
+                                </div>
+                                <div className="control">
+                                    <button
+                                        className="button is-danger"
+                                        type="button"
+                                        onClick={() => removeItem(idx)}
+                                    >
+                                        DELETE
+                                    </button>
+                                </div>
+                            </div>
+                        ))}
+                        <div className="field">
+                            <div className="control">
+                                <button
+                                    className="button is-warning"
+                                    type="button"
+                                    onClick={addItem}
+                                >
+                                    ADD
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                );
+            }
+
+            case "template": {
+                const { data: _template, isFetching: loading } = useMarkdownTemplate(variable.type.definition.template.id);
+                if (loading) return <p>Loading...</p>;
+                const _parameters = _template.parameters;
+
+                const handleSubChange = (key, val) => {
+                    const updated = { ...(value || {}), [key]: val };
+                    onContentChanged(variable.name, updated);
+                };
+
+                return (
+                    <div className="box has-background-grey-light">
+                        <label className="label">{__namespace}</label>
+                        {_parameters.map((param, i) => (
+                            <div className="field" key={i}>
+                                <TemplatedEditorComponent
+                                    variable={param}
+                                    value={(value || {})[param.name]}
+                                    namespace={__namespace}
+                                    onContentChanged={handleSubChange}
+                                />
+                            </div>
+                        ))}
+                    </div>
+                );
+            }
+
+            default:
+                return null;
+        }
+    };
+
+    return <>{renderField()}</>;
+};
+
+const TemplatedEditor = ({ content, template, onContentChanged, style }) => {
+    const tpl = template || {
+        parameters: [{ name: "markdown", type: { base_type: "markdown", definition: {} } }],
+        layout: "<markdown/>",
+        title: "default",
+    };
+
+    return (
+        <div className="box" style={{
+            ...style,
+            display: "flex",
+            flexDirection: "column",
+            overflow: "hidden"
+        }}>
+            <div style={{
+                flex: 1,
+                overflowY: "auto",
+                padding: "1rem"
+            }}>
+                {tpl.parameters.map((variable, idx) => (
+                    <TemplatedEditorComponent
+                        key={idx}
+                        variable={variable}
+                        value={content[variable.name]}
+                        namespace={tpl.title}
+                        onContentChanged={onContentChanged}
+                    />
+                ))}
+            </div>
+        </div>
+    );
+};
+
+export default TemplatedEditor;

src/components/Modals/ApiKeyCreationModal.js

@@ -0,0 +1,164 @@
+import React, { useState } from 'react';
+import { useCreateApiKey } from '../../utils/queries/apikey-queries';
+
+const AVAILABLE_ROLES = ['guest', 'creator', 'admin'];
+
+const ApiKeyCreationModal = ({ isOpen, onClose }) => {
+    const [name, setName] = useState('');
+    const [roles, setRoles] = useState(['guest']);
+    const [generatedKey, setGeneratedKey] = useState(null);
+    const createApiKeyMutation = useCreateApiKey();
+
+    const handleAddRole = () => {
+        const availableRoles = AVAILABLE_ROLES.filter(role => !roles.includes(role));
+        if (availableRoles.length > 0) {
+            setRoles([...roles, availableRoles[0]]);
+        }
+    };
+
+    const handleRoleChange = (index, value) => {
+        if (roles.includes(value) && roles.findIndex(r => r === value) !== index) {
+            return;
+        }
+        const newRoles = [...roles];
+        newRoles[index] = value;
+        setRoles(newRoles);
+    };
+
+    const handleRemoveRole = (index) => {
+        const newRoles = roles.filter((_, i) => i !== index);
+        setRoles(newRoles);
+    };
+
+    const handleGenerate = async () => {
+        if (!name.trim()) {
+            alert('API key name is required');
+            return;
+        }
+        try {
+            const result = await createApiKeyMutation.mutateAsync({
+                name: name.trim(),
+                roles: roles
+            });
+            setGeneratedKey(result);
+        } catch (error) {
+            console.error('failed to create api key', error);
+            alert('failed to create api key');
+        }
+    };
+
+    const handleCopy = () => {
+        navigator.clipboard.writeText(generatedKey)
+            .then(() => alert('API key copied to clipboard'))
+            .catch(err => console.error('failed to copy api key:', err));
+    };
+
+    const getRemainingRoles = (currentIndex) => {
+        return AVAILABLE_ROLES.filter(role => 
+            !roles.find((r, i) => r === role && i !== currentIndex)
+        );
+    };
+
+    if (!isOpen) return null;
+
+    return (
+        <div className="modal is-active">
+            <div className="modal-background" onClick={onClose}></div>
+            <div className="modal-card">
+                <header className="modal-card-head">
+                    <p className="modal-card-title">Create API Key</p>
+                    <button className="delete" aria-label="close" onClick={onClose}></button>
+                </header>
+                <section className="modal-card-body">
+                    {!generatedKey ? (
+                        <div>
+                            <div className="field">
+                                <label className="label">Name</label>
+                                <div className="control">
+                                    <input
+                                        className="input"
+                                        type="text"
+                                        placeholder="API key name"
+                                        value={name}
+                                        onChange={(e) => setName(e.target.value)}
+                                    />
+                                </div>
+                            </div>
+                            <div className="field">
+                                <label className="label">Roles</label>
+                                {roles.map((role, index) => (
+                                    <div key={index} className="field has-addons">
+                                        <div className="control">
+                                            <div className="select">
+                                                <select
+                                                    value={role}
+                                                    onChange={(e) => handleRoleChange(index, e.target.value)}
+                                                >
+                                                    {getRemainingRoles(index).map(availableRole => (
+                                                        <option key={availableRole} value={availableRole}>
+                                                            {availableRole}
+                                                        </option>
+                                                    ))}
+                                                </select>
+                                            </div>
+                                        </div>
+                                        <div className="control">
+                                            <button
+                                                className="button is-danger"
+                                                onClick={() => handleRemoveRole(index)}
+                                                disabled={roles.length === 1}
+                                            >
+                                                Delete
+                                            </button>
+                                        </div>
+                                    </div>
+                                ))}
+                                <button 
+                                    className="button is-info mt-2" 
+                                    onClick={handleAddRole}
+                                    disabled={roles.length === AVAILABLE_ROLES.length}
+                                >
+                                    Add Role
+                                </button>
+                            </div>
+                        </div>
+                    ) : (
+                        <div>
+                            <div className="notification is-warning">
+                                Please copy your API key immediately! It will only be displayed once!
+                            </div>
+                            <div className="field">
+                                <label className="label">Your API Key:</label>
+                                <div className="control">
+                                    <input
+                                        className="input"
+                                        type="text"
+                                        value={generatedKey.key}
+                                        readOnly
+                                    />
+                                </div>
+                            </div>
+                            <button className="button is-info" onClick={handleCopy}>
+                                Copy
+                            </button>
+                        </div>
+                    )}
+                </section>
+                <footer className="modal-card-foot">
+                    {!generatedKey && (
+                        <button
+                            className="button is-primary"
+                            onClick={handleGenerate}
+                            disabled={createApiKeyMutation.isLoading || !name.trim()}
+                        >
+                            Generate
+                        </button>
+                    )}
+                    <button className="button" onClick={onClose}>Close</button>
+                </footer>
+            </div>
+        </div>
+    );
+};
+
+export default ApiKeyCreationModal; 

src/components/Modals/ApiKeyRevokeModal.js

@@ -0,0 +1,63 @@
+import React, { useState } from 'react';
+import { useRevokeApiKey } from '../../utils/queries/apikey-queries';
+
+const ApiKeyRevokeModal = ({ isOpen, onClose }) => {
+    const [apiKey, setApiKey] = useState('');
+    const revokeApiKeyMutation = useRevokeApiKey();
+
+    const handleRevoke = async () => {
+        if (!apiKey.trim()) {
+            alert('Please enter an API key');
+            return;
+        }
+
+        try {
+            await revokeApiKeyMutation.mutateAsync(apiKey);
+            alert('API key revoked successfully');
+            onClose();
+        } catch (error) {
+            console.error('Failed to revoke API key:', error);
+            alert('Failed to revoke API key');
+        }
+    };
+
+    if (!isOpen) return null;
+
+    return (
+        <div className="modal is-active">
+            <div className="modal-background" onClick={onClose}></div>
+            <div className="modal-card">
+                <header className="modal-card-head">
+                    <p className="modal-card-title">Revoke API Key</p>
+                    <button className="delete" aria-label="close" onClick={onClose}></button>
+                </header>
+                <section className="modal-card-body">
+                    <div className="field">
+                        <label className="label">API Key</label>
+                        <div className="control">
+                            <input
+                                className="input"
+                                type="text"
+                                placeholder="Enter API key to revoke"
+                                value={apiKey}
+                                onChange={(e) => setApiKey(e.target.value)}
+                            />
+                        </div>
+                    </div>
+                </section>
+                <footer className="modal-card-foot">
+                    <button
+                        className="button is-danger"
+                        onClick={handleRevoke}
+                        disabled={revokeApiKeyMutation.isLoading}
+                    >
+                        Revoke
+                    </button>
+                    <button className="button" onClick={onClose}>Cancel</button>
+                </footer>
+            </div>
+        </div>
+    );
+};
+
+export default ApiKeyRevokeModal; 

src/components/Modals/JsonSchemaModal.js

@@ -0,0 +1,42 @@
+import React from 'react';
+
+const JsonSchemaModal = ({ isActive, onClose, schema }) => {
+    const handleCopy = () => {
+        navigator.clipboard.writeText(JSON.stringify(schema, null, 2));
+    };
+
+    return (
+        <div className={`modal ${isActive ? 'is-active' : ''}`}>
+            <div className="modal-background" onClick={onClose}></div>
+            <div className="modal-card">
+                <header className="modal-card-head">
+                    <p className="modal-card-title">JSON Schema</p>
+                    <button className="delete" aria-label="close" onClick={onClose}></button>
+                </header>
+                <section className="modal-card-body">
+                    <div className="field">
+                        <div className="control">
+                            <textarea
+                                className="textarea"
+                                value={JSON.stringify(schema, null, 2)}
+                                readOnly
+                                style={{ height: "50vh" }}
+                            />
+                        </div>
+                    </div>
+                </section>
+                <footer className="modal-card-foot">
+                    <button className="button is-primary" onClick={handleCopy}>
+                        <span className="icon">
+                            <i className="fas fa-copy"></i>
+                        </span>
+                        <span>copy</span>
+                    </button>
+                    <button className="button" onClick={onClose}>close</button>
+                </footer>
+            </div>
+        </div>
+    );
+};
+
+export default JsonSchemaModal; 

src/components/Modals/MarkdownSettingModal.js

@@ -0,0 +1,86 @@
+import {useCreateMarkdownSetting, useMarkdownSetting} from "../../utils/queries/markdown-setting-queries";
+import {useSaveMarkdown} from "../../utils/queries/markdown-queries";
+import React, {useState} from "react";
+import MarkdownTemplateSettingPanel from "../Settings/MarkdownSettings/MarkdownTemplateSettingPanel";
+import MarkdownPermissionSettingPanel from "../Settings/MarkdownSettings/MarkdownPermissionSettingPanel";
+
+const MarkdownSettingModal = ({isOpen, markdown, onClose}) => {
+    const {data: markdownSetting, isFetching: markdownSettingIsFetching} = useMarkdownSetting(markdown?.setting_id || 0);
+    const createMarkdownSetting = useCreateMarkdownSetting();
+    const updateMarkdown = useSaveMarkdown();
+
+    const [activeTab, setActiveTab] = useState("template");
+
+    const handleCreateMarkdownSetting = () => {
+        createMarkdownSetting.mutate({}, {
+            onSuccess: (res) => {
+                updateMarkdown.mutate({
+                    id: markdown.id,
+                    data: {
+                        setting_id: res.id
+                    }
+                });
+            }
+        });
+    };
+
+    if(markdownSettingIsFetching)
+        return(<p>Loading...</p>);
+
+    return (
+        <div className={`modal ${isOpen ? "is-active" : ""}`}>
+            <div className="modal-background" onClick={onClose} />
+            <div className="modal-card" style={{width: "60vw"}}>
+                <header className="modal-card-head">
+                    <p className="modal-card-title">Markdown Settings</p>
+                    <button
+                        className="delete"
+                        type="button"
+                        aria-label="close"
+                        onClick={onClose}
+                    />
+                </header>
+                {
+                    markdownSetting ?  (
+                        <section className="modal-card-body">
+                            <div className="tabs">
+                                <ul>
+                                    <li className={activeTab==="template" ? "is-active" : ""}>
+                                        <a onClick={() => setActiveTab("template")}>Template</a>
+                                    </li>
+                                    <li className={activeTab==="permission" ? "is-active" : ""}>
+                                        <a onClick={() => setActiveTab("permission")}>Permission</a>
+                                    </li>
+                                </ul>
+                            </div>
+                            {activeTab === "template" && (
+                                <MarkdownTemplateSettingPanel
+                                    markdownSetting={markdownSetting}
+                                    onClose={onClose}
+                                />
+                            )}
+                            {activeTab === "permission" && (
+                                <MarkdownPermissionSettingPanel
+                                    markdownSetting={markdownSetting}
+                                    onClose={onClose}
+                                />
+                            )}
+                        </section>
+                    ) : (
+                        <section className="modal-card-body">
+                            <button
+                                className="button is-primary"
+                                type="button"
+                                onClick={handleCreateMarkdownSetting}
+                            >
+                                Create Markdown Setting
+                            </button>
+                        </section>
+                    )
+                }
+            </div>
+        </div>
+    );
+
+};
+export default MarkdownSettingModal;

src/components/Modals/PathSettingModal.js

@@ -0,0 +1,77 @@
+import {useUpdatePath} from "../../utils/queries/path-queries";
+import {useCreatePathSetting, usePathSetting} from "../../utils/queries/path-setting-queries";
+import WebhookSettingPanel from "../Settings/PathSettings/WebhookSettingPanel";
+import React, {useState} from "react";
+const PathSettingModal = ({ isOpen, path, onClose }) => {
+    const settingId = path?.setting_id || 0;
+    const {data: pathSetting, isLoading: isPathSettingLoading} = usePathSetting(settingId);
+    const createPathSetting = useCreatePathSetting();
+    const updatePath = useUpdatePath();
+
+    const [activeTab, setActiveTab] = useState("webhook");
+    const handleCreatePathSetting = () => {
+        createPathSetting.mutate({}, {
+            onSuccess: (res) => {
+                updatePath.mutate({id: path.id, data: {setting_id: res.id}});
+            }
+        });
+    };
+
+
+    if(settingId && isPathSettingLoading)
+        return (<p>Loading...</p>);
+
+    return (
+        <div className={`modal ${isOpen ? "is-active" : ""}`}>
+            <div className="modal-background" onClick={onClose} />
+            <div className="modal-card" style={{width: "60vw"}}>
+                <header className="modal-card-head">
+                    <p className="modal-card-title">Path Settings</p>
+                    <button
+                        type="button"
+                        className="delete"
+                        aria-label="close"
+                        onClick={onClose}
+                    />
+                </header>
+                {!pathSetting ? (
+                    <section className="modal-card-body">
+                        <button
+                            type="button"
+                            className="button is-primary"
+                            onClick={handleCreatePathSetting}
+                        >
+                            Create Path Setting
+                        </button>
+                    </section>
+                ) : (
+                    <section className="modal-card-body">
+                        <div className="tabs">
+                            <ul>
+                                <li className={activeTab === "webhook" ? "is-active" : ""}>
+                                    <a onClick={() => setActiveTab("webhook")}>Webhook</a>
+                                </li>
+                                <li className={activeTab === "template" ? "is-active" : ""}>
+                                    <a onClick={() => setActiveTab("template")}>Template</a>
+                                </li>
+                            </ul>
+                        </div>
+                        {activeTab === "webhook" && (
+                            <WebhookSettingPanel
+                                pathSetting={pathSetting}
+                                onClose={onClose}
+                            />
+                        )}
+                        {activeTab === "template" && (
+                            <div></div>
+                        )}
+                    </section>
+                )}
+
+            </div>
+        </div>
+    );
+
+};
+
+export default PathSettingModal;

src/components/Navigations/MainNavigation.css

@@ -1,10 +1,13 @@
-/*src/components/MainNavigation.css*/
 .main-navigation {
     background-color: #333;
     color: white;
     padding: 1rem;
 }
 
+.dropdown-option {
+    margin-top: 0.2rem;
+}
+
 .main-navigation .navbar {
     background-color: #333 !important;
 }
@@ -19,6 +22,10 @@
     color: #f5f5f5 !important;
 }
 
+.navbar-end .navbar-item {
+    margin-right: 1rem;
+}
+
 .main-navigation .button {
     margin-left: 0.5rem;
 }
@@ -54,4 +61,4 @@
 .main-navigation .navbar-item:not(:last-child) {
     border-right: 1px solid #555;
     padding-right: 1rem;
-}
+}

src/components/Navigations/MainNavigation.js

@@ -1,86 +1,216 @@
-import React, { useContext } from "react";
+import React, {useContext, useState} from "react";
 import { Link } from "react-router-dom";
 import { AuthContext } from "../../AuthProvider";
 import "bulma/css/bulma.min.css";
+import {useConfig} from "../../ConfigProvider";
+import "./MainNavigation.css";
+import ApiKeyCreationModal from "../Modals/ApiKeyCreationModal";
+import ApiKeyRevokeModal from "../Modals/ApiKeyRevokeModal";
 
 const MainNavigation = () => {
     const { user, login, logout } = useContext(AuthContext);
+    const config = useConfig();
+    const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+    const [isApiKeyModalOpen, setIsApiKeyModalOpen] = useState(false);
+    const [isRevokeModalOpen, setIsRevokeModalOpen] = useState(false);
+
+    if (config===undefined) {
+        return <div>Loading ...</div>;
+    }
+
+    const handleLoadBackup = async () => {
+        try{
+            const input = document.createElement("input");
+            input.type = "file";
+            input.accept=".zip";
+            input.onchange = async (event) => {
+                const file = event.target.files[0];
+                if(!file)
+                    return;
+                const formData = new FormData();
+                formData.append("file", file);
+                try{
+                    const response = await fetch(
+                        `${config.BACKEND_HOST}/api/backup/load`, {
+                            method: "POST",
+                            headers: {
+                                Authorization: `Bearer ${localStorage.getItem("accessToken")}`,
+                            },
+                            body: formData
+                        }
+                    );
+                    if(response.ok){
+                        const result = await response.json();
+                        alert("Backup loaded");
+                    } else {
+                        const error = await response.json();
+                        alert(`failed to load ${error.error}`);
+                    }
+                } catch (error) {
+                    console.error(error);
+                    alert("error when loading backup");
+                }
+            };
+            input.click();
+        } catch (error) {
+            console.error(error);
+            alert(`Unexpected error`);
+        }
+    }
+    const handleGetBackup = async () => {
+        try{
+            const response = await fetch(
+                `${config.BACKEND_HOST}/api/backup/`, {
+                    method: "GET",
+                    headers: {
+                        Authorization: `Bearer ${localStorage.getItem("accessToken")}`,
+                    }
+                }
+            );
+            if(response.ok){
+                const blob = await response.blob();
+                const url = window.URL.createObjectURL(blob);
+                const a = document.createElement("a");
+                const contentDisposition = response.headers.get("Content-Disposition");
+                let filename = "backup.zip";
+                if (contentDisposition) {
+                    const match = contentDisposition.match(/filename="?([^"]+)"?/);
+                    if (match && match[1]) {
+                        filename = match[1];
+                    }
+                }
+                a.href = url;
+                a.download = filename;
+                a.click();
+                window.URL.revokeObjectURL(url);
+            }else{
+                alert("Failed to get backup");
+            }
+        } catch(err){
+            console.log(err);
+            alert("An error occurred while retrieving backup");
+        }
+    };
 
     return (
-        <nav className="navbar is-dark" role="navigation" aria-label="main navigation">
-            <div className="navbar-brand">
-                <Link className="navbar-item" to="/">
-                    Home
-                </Link>
-                <a
-                    role="button"
-                    className="navbar-burger"
-                    aria-label="menu"
-                    aria-expanded="false"
-                    data-target="navbarBasicExample"
-                    onClick={(e) => {
-                        e.currentTarget.classList.toggle("is-active");
-                        document
-                            .getElementById("navbarBasicExample")
-                            .classList.toggle("is-active");
-                    }}
-                >
-                    <span aria-hidden="true"></span>
-                    <span aria-hidden="true"></span>
-                    <span aria-hidden="true"></span>
-                </a>
-            </div>
-
-            <div id="navbarBasicExample" className="navbar-menu">
-                <div className="navbar-start">
+        <>
+            <nav className="navbar is-dark" role="navigation" aria-label="main navigation">
+                <div className="navbar-brand">
+                    <Link className="navbar-item" to="/">
+                        <img src="/icons/logo.png" alt="Logo" style={{ height: "40px", marginRight: "10px" }} />
+                        Home
+                    </Link>
                     <a
-                        href="https://mail.hangman-lab.top"
-                        className="navbar-item"
-                        target="_blank"
-                        rel="noopener noreferrer"
+                        role="button"
+                        className="navbar-burger"
+                        aria-label="menu"
+                        aria-expanded="false"
+                        data-target="navbarBasicExample"
+                        onClick={(e) => {
+                            e.currentTarget.classList.toggle("is-active");
+                            document
+                                .getElementById("navbarBasicExample")
+                                .classList.toggle("is-active");
+                        }}
                     >
-                        MailBox
-                    </a>
-                    <a
-                        href="https://git.hangman-lab.top"
-                        className="navbar-item"
-                        target="_blank"
-                        rel="noopener noreferrer"
-                    >
-                        Git
+                        <span aria-hidden="true"></span>
+                        <span aria-hidden="true"></span>
+                        <span aria-hidden="true"></span>
                     </a>
                 </div>
 
-                <div className="navbar-end">
-                    {user && user.profile ? (
-                        <div className="navbar-item">
-                            <div className="buttons">
-                                <span className="button is-primary is-light">
-                                    {user.profile.name}
-                                </span>
+                <div id="navbarBasicExample" className="navbar-menu">
+                    <div className="navbar-start">
+                        <a
+                            href="https://mail.hangman-lab.top"
+                            className="navbar-item"
+                            target="_blank"
+                            rel="noopener noreferrer"
+                        >
+                            MailBox
+                        </a>
+                        <a
+                            href="https://git.hangman-lab.top"
+                            className="navbar-item"
+                            target="_blank"
+                            rel="noopener noreferrer"
+                        >
+                            Git
+                        </a>
+                    </div>
+
+                    <div className="navbar-end">
+                        {user && user.profile ? (
+                            <div className="navbar-item has-dropdown is-hoverable">
+                                <div className="buttons">
+                                    <span
+                                        className="button is-primary is-light"
+                                        onClick={() => setIsDropdownOpen(!isDropdownOpen)}
+                                    >
+                                        {user.profile.name}
+                                    </span>
+                                    <div className={`navbar-dropdown ${isDropdownOpen ? "is-active" : ""}`}>
+                                        <button
+                                            className="button is-primary dropdown-option"
+                                            onClick={handleGetBackup}
+                                            type="button"
+                                        >
+                                            Get Backup
+                                        </button>
+                                        <button
+                                            className="button is-primary dropdown-option"
+                                            onClick={handleLoadBackup}
+                                            type="button"
+                                        >
+                                            Load Backup
+                                        </button>
+                                        <button
+                                            className="button is-info dropdown-option"
+                                            onClick={() => setIsApiKeyModalOpen(true)}
+                                            type="button"
+                                        >
+                                            Create API Key
+                                        </button>
+                                        <button
+                                            className="button is-warning dropdown-option"
+                                            onClick={() => setIsRevokeModalOpen(true)}
+                                            type="button"
+                                        >
+                                            Revoke API Key
+                                        </button>
+                                        <button
+                                            className="button is-danger dropdown-option"
+                                            onClick={logout}
+                                            type="button"
+                                        >
+                                            Logout
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+                        ) : (
+                            <div className="navbar-item">
                                 <button
-                                    className="button is-danger"
-                                    onClick={logout}
+                                    className="button is-primary"
+                                    onClick={login}
                                     type="button"
                                 >
-                                    Logout
+                                    Login
                                 </button>
                             </div>
-                        </div>
-                    ) : (
-                        <div className="navbar-item">
-                            <button
-                                className="button is-primary"
-                                onClick={login}
-                                type="button"
-                            >
-                                Login
-                            </button>
-                        </div>
-                    )}
+                        )}
+                    </div>
                 </div>
-            </div>
-        </nav>
+            </nav>
+            <ApiKeyCreationModal
+                isOpen={isApiKeyModalOpen}
+                onClose={() => setIsApiKeyModalOpen(false)}
+            />
+            <ApiKeyRevokeModal
+                isOpen={isRevokeModalOpen}
+                onClose={() => setIsRevokeModalOpen(false)}
+            />
+        </>
     );
 };
 

src/components/Navigations/MarkdownNode.js

@@ -0,0 +1,91 @@
+import {Link, useNavigate} from "react-router-dom";
+import PermissionGuard from "../PermissionGuard";
+import React, {useState} from "react";
+import MarkdownSettingModal from "../Modals/MarkdownSettingModal";
+import {useDeleteMarkdown} from "../../utils/queries/markdown-queries";
+import {useDeleteMarkdownSetting} from "../../utils/queries/markdown-setting-queries";
+const MarkdownNode = ({markdown, handleMoveMarkdown}) => {
+    const [isMarkdownSettingModalOpen, setIsMarkdownSettingModalOpen] = useState(false);
+    const navigate = useNavigate();
+    const deleteMarkdown = useDeleteMarkdown();
+    const deleteMarkdownSetting = useDeleteMarkdownSetting();
+    
+    const handleDeleteMarkdown = async () => {
+        if (!window.confirm(`delete markdown "${markdown.title}" ? this action cannot be undone.`)) {
+            return;
+        }
+        
+        try {
+            await deleteMarkdown.mutateAsync(markdown.id);
+
+            if (window.location.pathname === `/markdown/${markdown.id}`) {
+                navigate('/');
+            }
+        } catch (error) {
+            alert('failed: ' + (error.message || 'unknown error'));
+        }
+    };
+    return (
+        <li key={markdown.id}>
+            <div className="is-clickable field has-addons">
+                <span className="markdown-name has-text-weight-bold control">
+                    <Link to={`/markdown/${markdown.id}`} className="is-link markdown-node">
+                        {markdown.title}
+                    </Link>
+                </span>
+                <PermissionGuard rolesRequired={['admin']}>
+                    <p className="control">
+                        <button
+                            className="button is-small is-success"
+                            onClick={() => setIsMarkdownSettingModalOpen(true)}
+                            type="button"
+                        >
+                            <span className="icon">
+                                <i className="fas fa-cog"/>
+                            </span>
+                        </button>
+                    </p>
+                    <p className="control">
+                        <button
+                            className="button is-small is-danger"
+                            onClick={handleDeleteMarkdown}
+                            type="button"
+                            disabled={deleteMarkdown.isLoading || deleteMarkdownSetting.isLoading}
+                        >
+                            <span className="icon">
+                                <i className="fas fa-trash"/>
+                            </span>
+                        </button>
+                    </p>
+                    <div
+                        className="control is-flex is-flex-direction-column is-align-items-center"
+                        style={{marginLeft: "0.5rem"}}
+                    >
+                        <button
+                            className="button is-small mb-1 move-forward"
+                            style={{height: "1rem", padding: "0.25rem"}}
+                            onClick={() => handleMoveMarkdown(markdown, "forward")}
+                            type="button"
+                        >
+                        </button>
+                        <button
+                            className="button is-small mb-1 move-backward"
+                            style={{height: "1rem", padding: "0.25rem"}}
+                            onClick={() => handleMoveMarkdown(markdown, "backward")}
+                            type="button"
+                        >
+                        </button>
+                    </div>
+                    <MarkdownSettingModal
+                        isOpen={isMarkdownSettingModalOpen}
+                        markdown={markdown}
+                        onClose={() => setIsMarkdownSettingModalOpen(false)}
+                    />
+                </PermissionGuard>
+            </div>
+
+        </li>
+    );
+}
+
+export default MarkdownNode;

src/components/Navigations/PathNode.css

@@ -8,6 +8,18 @@
     margin-left: 1rem;
 }
 
+.path-toggle {
+    background-color: #e4a4d8;
+    width: 1.5rem;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    border-radius: 1rem;
+    font-size: 1rem;
+    color: #ffffff;
+}
+
 .path-node > .has-text-weight-bold {
     display: inline-flex;
     align-items: center;
@@ -46,4 +58,24 @@
     justify-content: space-between;
     align-items: center;
     width: 100%;
-}
+}
+
+
+.move-forward {
+    background-color: #c0fff0 !important;
+    border-color: #c0fbc0 !important;
+    color: #b0ffa0 !important;
+}
+.move-forward:hover {
+    background-color: #a0ffa0;
+    border-color: #0afb0c;
+}
+.move-backward {
+    background-color: #a0a0ff !important;
+    border-color: #c0c0ff !important;
+    color: #0af0fc !important;
+}
+.move-backward:hover {
+    background-color: #a4a4f0;
+    border-color: #facaff;
+}

src/components/Navigations/PathNode.js

@@ -1,31 +1,45 @@
 import React, {useState} from "react";
+import { useSelector, useDispatch } from 'react-redux';
+import { toggleNodeExpansion } from '../../store/navigationSlice';
 import { Link } from "react-router-dom";
 import PermissionGuard from "../PermissionGuard";
 import "./PathNode.css";
-import {useDeletePath, usePaths, useUpdatePath} from "../../utils/path-queries";
-import {useIndexMarkdown, useMarkdownsByPath} from "../../utils/markdown-queries";
+import {useDeletePath, useMovePath, useUpdatePath} from "../../utils/queries/path-queries";
+import {useIndexMarkdown, useMoveMarkdown} from "../../utils/queries/markdown-queries";
+import MarkdownNode from "./MarkdownNode";
+import PathSettingModal from "../Modals/PathSettingModal";
 
 const PathNode = ({ path, isRoot = false }) => {
-    const [isExpanded, setIsExpanded] = useState(isRoot);
+    const [isPathSettingModalOpen, setIsPathSettingModalOpen] = useState(false);
     const [isEditing, setIsEditing] = useState(false);
-    const [newName, setNewName] = useState(path.name);
+    const [newName, setNewName] = useState(path.name || "");
+
+    const expandedNodes = useSelector(state => state.navigation.expandedNodes);
+    const dispatch = useDispatch();
+    const isExpanded = isRoot || expandedNodes[path.id];
 
-    const { data: childPaths, isLoading: isChildLoading, error: childError } = usePaths(path.id);
-    const { data: markdowns, isLoading: isMarkdownLoading, error: markdownError } = useMarkdownsByPath(path.id);
     const deletePath = useDeletePath();
     const updatePath = useUpdatePath();
 
-    const {data: indexMarkdown, isLoading: isIndexLoading, error: indexMarkdownError} = useIndexMarkdown(path.id);
+    const {data: indexMarkdown} = useIndexMarkdown(path.id);
 
+    const movePath = useMovePath();
+    const moveMarkdown = useMoveMarkdown();
+
+
+    const expand = () => {
+        if (!isExpanded) {
+            dispatch(toggleNodeExpansion(path.id));
+        }
+    };
 
     const toggleExpand = () => {
-        setIsExpanded(!isExpanded);
+        dispatch(toggleNodeExpansion(path.id));
     };
 
     const handleSave = () => {
-        console.log(`handleSave  ${path.id}`);
         updatePath.mutate({id: path.id, data: {name: newName}}, {
-            onsuccess: () => setIsEditing(false),
+            onSuccess: () => setIsEditing(false),
             onError: err => alert("failed to update this path"),
         })
     };
@@ -40,35 +54,77 @@ const PathNode = ({ path, isRoot = false }) => {
         setIsEditing(true);
     };
 
+    const handleMovePath = (pth, direction) => {
+        movePath.mutate({path: pth, direction: direction}, {
+            onError: () => alert("failed to move this path"),
+        });
+    };
+
+    const handleMoveMarkdown = (md, direction) => {
+        moveMarkdown.mutate({markdown: md, direction: direction}, {
+            onError: () => alert("failed to move this markdown"),
+        })
+    };
+
+    const childPaths = path.children.filter(x => x.type==="path");
+    const sortedPaths = childPaths
+        ? childPaths.slice().sort((a, b) => a.order.localeCompare(b.order))
+        : [];
+
+    const markdowns = path.children.filter(x => x.type==="markdown");
+    const sortedMarkdowns = markdowns
+        ? markdowns.filter(md => md.title !== "index").sort((a, b) => a.order.localeCompare(b.order))
+        : [];
 
 
-    if(childError || markdownError){
-        return <li>Error...</li>;
-    }
-
-
+    if(isRoot)
+        return (
+            <ul className="menu-list">
+                {sortedPaths.map((path) => (
+                    <PathNode
+                        key={path.id}
+                        path={path}
+                        isRoot={false}
+                        onSave={handleSave}
+                        onDelete={handleDelete}
+                    />
+                ))}
+                {sortedMarkdowns.filter(md => md.title !== "index").map((markdown) => (
+                    <MarkdownNode
+                        markdown={markdown}
+                        handleMoveMarkdown={handleMoveMarkdown}
+                        key={markdown.id}
+                    />
+                ))}
+            </ul>
+        );
     return (
-        <li>
-            <div className="path-node-header is-clickable field has-addons" onClick={isRoot ? undefined : toggleExpand}>
+        <li key={path.id}>
+            <div className="path-node-header field has-addons">
+                <span className="control has-text-weight-bold path-toggle" onClick={isRoot ? undefined : toggleExpand}>
+                        {isExpanded ? "-" : "+"}
+                </span>
                 {isEditing ? (
-
-                        <div className = "control has-icons-left">
-                            <input
-                                className="input is-small path-edit-input"
-                                value={newName}
-                                onChange={(e) => setNewName(e.target.value)}
-                            />
-                        </div>
+                    <div className="control has-icons-left">
+                        <input
+                            className="input is-small path-edit-input"
+                            value={newName}
+                            onChange={(e) => setNewName(e.target.value)}
+                        />
+                    </div>
 
                 ) : (
-                    <span className="path-name has-text-weight-bold control">
+                    <span
+                        className="path-name has-text-weight-bold control"
+                        onClick={isRoot ? undefined : expand}
+                    >
                         {
                             indexMarkdown ? (
-                                <Link to={`/markdown/${indexMarkdown.id}`} className="is-link">
+                                <Link to={`/markdown/${indexMarkdown.id}`} className="is-link index-path-node">
                                     {path.name}
                                 </Link>
                             ) : (
-                                <a className="is-link">{path.name}</a>
+                                <a className="is-link path-node">{path.name}</a>
                             )
                         }
 
@@ -77,6 +133,19 @@ const PathNode = ({ path, isRoot = false }) => {
 
                 <PermissionGuard rolesRequired={["admin"]}>
                     <div className="field has-addons actions control is-justify-content-flex-end">
+                        <p className="control">
+                            <button
+                                className="button is-small is-success"
+                                onClick={() => {
+                                    setIsPathSettingModalOpen(true);
+                                }}
+                                type="button"
+                            >
+                                    <span className="icon">
+                                        <i className="fas fa-cog"/>
+                                    </span>
+                            </button>
+                        </p>
                         {isEditing ? (
                             <p className="control">
                                 <button
@@ -112,26 +181,49 @@ const PathNode = ({ path, isRoot = false }) => {
                                 </span>
                             </button>
                         </p>
+                        <div
+                            className="control is-flex is-flex-direction-column is-align-items-center"
+                            style={{marginLeft: "0.5rem"}}
+                        >
+                            <button
+                                className="button is-small mb-1 move-forward"
+                                style={{height: "1rem", padding: "0.25rem"}}
+                                onClick={() => handleMovePath(path, "forward")}
+                                type="button"
+                            >
+                            </button>
+                            <button
+                                className="button is-small mb-1 move-backward"
+                                style={{height: "1rem", padding: "0.25rem"}}
+                                onClick={() => handleMovePath(path, "backward")}
+                                type="button"
+                            >
+                            </button>
+                        </div>
                     </div>
+                    <PathSettingModal
+                        isOpen={isPathSettingModalOpen}
+                        path={path}
+                        onClose={() => setIsPathSettingModalOpen(false)}
+                    />
                 </PermissionGuard>
             </div>
 
             {isExpanded && (
                 <ul>
-                    { isChildLoading && <p>Loading...</p>}
-                    { childPaths.map((child) => (
+                    {sortedPaths.map((child) => (
                         <PathNode
                             key={child.id}
                             path={child}
                         />
                     ))}
 
-                    { markdowns.filter(md => md.title !== "index").map((markdown) => (
-                        <li key={markdown.id}>
-                            <Link to={`/markdown/${markdown.id}`} className="is-link">
-                                {markdown.title}
-                            </Link>
-                        </li>
+                    {sortedMarkdowns.filter(md => md.title !== "index").map((markdown) => (
+                        <MarkdownNode
+                            markdown={markdown}
+                            handleMoveMarkdown={handleMoveMarkdown}
+                            key={markdown.id}
+                        />
                     ))}
                 </ul>
             )}

src/components/Navigations/SideNavigation.css

@@ -3,8 +3,9 @@
     border-radius: 8px;
     padding: 1rem;
     background-color: #f9f9f9;
-    height: 100%;
-    overflow-y: auto;
+    height: 90vh;
+    overflow-y: hidden;
+    min-width: 15vw;
 }
 
 .menu-label {
@@ -15,6 +16,8 @@
 
 .menu-list {
     margin-left: 0;
+    height: 100%;
+    overflow-y: auto;
 }
 
 .menu-list-item {
@@ -46,3 +49,34 @@
 .is-clickable:hover {
     color: #2759a7;
 }
+
+.index-path-node {
+    background-color: #cceeee !important;
+}
+.path-node {
+    background-color: #ccffec !important;
+}
+.markdown-node {
+    background-color: #fffbe6 !important;
+}
+
+
+
+.tabs ul {
+    display: flex;
+    margin-bottom: 0;
+    padding-left: 0;
+}
+
+.tabs li {
+    flex: 1;
+    list-style: none;
+}
+
+.side-nav {
+    min-width: 15vw;
+    border-right: 1px solid #ddd;
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+}

src/components/Navigations/SideNavigation.js

@@ -1,62 +1,53 @@
-import PermissionGuard from "../PermissionGuard";
-import PathNode from "./PathNode";
+import React, { useContext, useEffect } from 'react';
+import { useSelector, useDispatch } from 'react-redux';
+import { setSelectedTab } from '../../store/navigationSlice';
 import "./SideNavigation.css";
-import {useDeletePath, usePaths, useUpdatePath} from "../../utils/path-queries";
-import React from 'react';
+import TreeTab from "./SideTabs/TreeTab";
+import TemplateTab from "./SideTabs/TemplateTab";
+import { AuthContext } from "../../AuthProvider";
 
 const SideNavigation = () => {
-    const {data: paths, isLoading, error } = usePaths(1);
-    const deletePath = useDeletePath();
-    const updatePath = useUpdatePath();
+    const { roles } = useContext(AuthContext);
+    const selectedTab = useSelector(state => state.navigation.selectedTab);
+    const dispatch = useDispatch();
 
-    const handleDelete = (id) => {
-        if (window.confirm("Are you sure you want to delete this path?")){
-            deletePath.mutate(id, {
-                onError: (err) => {
-                    alert("Failed to delete path");
-                },
-            });
+    const allTabs = [
+        { id: "tree", label: "Tree", component: <TreeTab /> },
+        { id: "templates", label: "Templates", component: <TemplateTab /> },
+    ];
+
+    const visibleTabs = roles.includes("admin")
+        ? allTabs
+        : allTabs.filter(tab => tab.id === "tree");
+
+    useEffect(() => {
+        if (!visibleTabs.find(tab => tab.id === selectedTab)) {
+            dispatch(setSelectedTab(visibleTabs[0]?.id || ""));
         }
-    };
+    }, [visibleTabs, selectedTab, dispatch]);
 
-    const handleSave = (id, newName) => {
-        updatePath.mutate({ id, data: {name: newName }} , {
-            onError: (err) => {
-                alert("Failed to update path");
-            }
-        });
-    };
-    if(isLoading){
-        return <aside className="menu"><p>Loading...</p></aside>;
-    }
 
-    if(error){
-        return <aside className="menu"><p>Error...</p></aside>;
-    }
+    const current = visibleTabs.find(t => t.id === selectedTab);
 
     return (
-        <aside className="menu">
-            <p className="menu-label">Markdown Directory</p>
-            <PermissionGuard rolesRequired={["admin", "creator"]}>
-                <a
-                    href="/markdown/create"
-                    className="button is-primary is-small"
-                >
-                    Create New Markdown
-                </a>
-            </PermissionGuard>
-            <ul className="menu-list">
-                {isLoading && <p>Loading...</p>}
-                {paths.map((path) => (
-                    <PathNode
-                        key={path.id}
-                        path={path}
-                        isRoot={false}
-                        onSave={handleSave}
-                        onDelete={handleDelete}
-                    />
-                ))}
-            </ul>
+        <aside className="side-nav">
+            <div className="tabs is-small">
+                <ul>
+                    {visibleTabs.map(tab => (
+                        <li
+                            key={tab.id}
+                            className={tab.id === selectedTab ? "is-active" : ""}
+                        >
+                            <a onClick={() => dispatch(setSelectedTab(tab.id))}>
+                                {tab.label}
+                            </a>
+                        </li>
+                    ))}
+                </ul>
+            </div>
+            <div className="tab-content">
+                {current?.component}
+            </div>
         </aside>
     );
 };

src/components/Navigations/SideTabs/TemplateTab.js

@@ -0,0 +1,174 @@
+import React, { useState } from "react";
+import { useMarkdownTemplates } from "../../../utils/queries/markdown-template-queries";
+import PermissionGuard from "../../PermissionGuard";
+import { useNavigate } from "react-router-dom";
+import JsonSchemaModal from "../../Modals/JsonSchemaModal";
+
+const TemplateTab = () => {
+    const { data: templates, isLoading, error } = useMarkdownTemplates();
+    const [keyword, setKeyword] = useState("");
+    const [selectedSchema, setSelectedSchema] = useState(null);
+    const navigate = useNavigate();
+
+    const filteredTemplates = templates?.filter(template => 
+        template.title.toLowerCase().includes(keyword.toLowerCase())
+    );
+
+    const handleTemplateClick = (templateId) => {
+        navigate(`/template/edit/${templateId}`);
+    };
+
+    const generateJsonSchema = (template) => {
+        const schema = {
+            type: "object",
+            properties: {},
+            $defs: {}
+        };
+
+        const generateTypeSchema = (param, defName) => {
+            switch (param.type.base_type) {
+                case "string":
+                    return {
+                        type: "string"
+                    };
+                case "markdown":
+                    return {
+                        type: "string",
+                        description: "Markdown content"
+                    };
+                case "enum":
+                    return {
+                        type: "string",
+                        enum: param.type.definition.enums
+                    };
+                case "list":
+                    if (param.type.extend_type.base_type === "string") {
+                        return {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            }
+                        };
+                    } else if (param.type.extend_type.base_type === "list" || 
+                             param.type.extend_type.base_type === "template") {
+                        const itemsDefName = `${defName}_items`;
+                        schema.$defs[itemsDefName] = generateTypeSchema(
+                            { type: param.type.extend_type },
+                            itemsDefName
+                        );
+                        return {
+                            type: "array",
+                            items: {
+                                $ref: `#/$defs/${itemsDefName}`
+                            }
+                        };
+                    } else {
+                        return {
+                            type: "array",
+                            items: generateTypeSchema(
+                                { type: param.type.extend_type },
+                                `${defName}_items`
+                            )
+                        };
+                    }
+                case "template":
+                    const nestedTemplate = templates.find(t => t.id === param.type.definition.template.id);
+                    if (nestedTemplate) {
+                        const nestedSchema = {
+                            type: "object",
+                            properties: {}
+                        };
+                        nestedTemplate.parameters.forEach(nestedParam => {
+                            nestedSchema.properties[nestedParam.name] = generateTypeSchema(
+                                nestedParam,
+                                `${defName}_${nestedParam.name}`
+                            );
+                        });
+                        return nestedSchema;
+                    } else {
+                        return {
+                            type: "object",
+                            properties: {}
+                        };
+                    }
+                default:
+                    return {
+                        type: "object",
+                        properties: {}
+                    };
+            }
+        };
+
+        template.parameters.forEach(param => {
+            const defName = `param_${param.name}`;
+            schema.properties[param.name] = generateTypeSchema(param, defName);
+        });
+
+        if (Object.keys(schema.$defs).length === 0) {
+            delete schema.$defs;
+        }
+
+        return schema;
+    };
+
+    if (isLoading) return <p>Loading...</p>;
+    if (error) return <p>Error loading templates</p>;
+
+    return (
+        <aside className="menu">
+            <div className="control is-expanded">
+                <input
+                    className="input is-small"
+                    type="text"
+                    placeholder="Search templates..."
+                    onChange={(e) => setKeyword(e.target.value)}
+                />
+            </div>
+            <PermissionGuard rolesRequired={["admin", "creator"]}>
+                <a
+                    href="/template/create"
+                    className="button is-primary is-small is-fullwidth"
+                    style={{ marginBottom: "10px" }}
+                >
+                    Create New Template
+                </a>
+            </PermissionGuard>
+            <ul className="menu-list">
+                {filteredTemplates?.map((template) => (
+                    <li key={template.id}>
+                        <div className="is-flex is-justify-content-space-between is-align-items-center">
+                            <span>{template.title}</span>
+                            <div className="field has-addons is-justify-content-flex-end">
+                                <button
+                                    className="button is-small control"
+                                    onClick={() => handleTemplateClick(template.id)}
+                                    type="button"
+                                >
+                                    <span className="icon">
+                                        <i className="fas fa-edit"></i>
+                                    </span>
+                                </button>
+                                <button
+                                    className="button is-small control"
+                                    onClick={() => setSelectedSchema(generateJsonSchema(template))}
+                                    type="button"
+                                >
+                                    <span className="icon">
+                                        <i className="fas fa-code"></i>
+                                    </span>
+                                </button>
+                            </div>
+                        </div>
+                    </li>
+                ))}
+            </ul>
+            <JsonSchemaModal
+                isActive={selectedSchema !== null}
+                onClose={() => setSelectedSchema(null)}
+                schema={selectedSchema}
+            />
+        </aside>
+    );
+};
+
+export default TemplateTab;

src/components/Navigations/SideTabs/TreeTab.js

@@ -0,0 +1,88 @@
+import PermissionGuard from "../../PermissionGuard";
+import PathNode from "../PathNode";
+import React from "react";
+import {useTree} from "../../../utils/queries/tree-queries";
+import {useDeletePath, useUpdatePath} from "../../../utils/queries/path-queries";
+
+const TreeTab = () => {
+    const {data: tree, isLoading, error} = useTree();
+    const deletePath = useDeletePath();
+    const updatePath = useUpdatePath();
+    const [keyword, setKeyword] = React.useState("");
+    const handleDelete = (id) => {
+        if (window.confirm("Are you sure you want to delete this path?")){
+            deletePath.mutate(id, {
+                onError: (err) => {
+                    alert("Failed to delete path");
+                },
+            });
+        }
+    };
+
+    const filterTree = (t, k) => {
+        if(t === undefined)
+            return undefined;
+        if (t.type === "path") {
+            if (t.name.includes(k)) {
+                return { ...t };
+            }
+            const filteredChildren = (t.children || [])
+                .map(c => filterTree(c, k))
+                .filter(Boolean);
+
+            if (filteredChildren.length > 0) {
+                return { ...t, children: filteredChildren };
+            }
+        } else if (t.type === "markdown") {
+            if (t.title.includes(k)) {
+                return { ...t };
+            }
+        }
+        return undefined;
+    };
+
+    const filteredTree = filterTree(tree, keyword);
+
+    const handleSave = (id, newName) => {
+        updatePath.mutate({ id, data: {name: newName }} , {
+            onError: (err) => {
+                alert("Failed to update path");
+            }
+        });
+    };
+    if (isLoading) return <p>Loading...</p>;
+    if (error) return <p>Error loading tree</p>;
+    return (
+        <aside className="menu">
+
+            <div className="control is-expanded">
+                <input
+                    className="input is-small"
+                    type="text"
+                    placeholder="Search..."
+                    onChange={(e) => setKeyword(e.target.value)}
+                />
+            </div>
+            <PermissionGuard rolesRequired={["admin", "creator"]}>
+                <a
+                    href="/markdown/create"
+                    className="button is-primary is-small"
+                >
+                    Create New Markdown
+                </a>
+            </PermissionGuard>
+            {!filteredTree || filteredTree.length === 0 ?
+                <p>No Result</p> :
+                <PathNode
+                    key={1}
+                    path={filteredTree}
+                    isRoot={true}
+                    onSave={handleSave}
+                    onDelete={handleDelete}
+                />
+            }
+        </aside>
+    );
+};
+
+export default TreeTab;

src/components/PathManager.js

@@ -1,13 +1,13 @@
-
 import React, {useEffect, useState, useRef, useContext} from "react";
-import { useCreatePath, usePaths } from "../utils/path-queries";
-import { useQueryClient } from "react-query";
+import {useCreatePath, usePaths} from "../utils/queries/path-queries";
+import { useQueryClient } from "@tanstack/react-query";
 import "./PathManager.css";
 import {fetch_} from "../utils/request-utils";
 import {ConfigContext} from "../ConfigProvider";
 
+
 const PathManager = ({ currentPathId = 1, onPathChange }) => {
-    const [currentPath, setCurrentPath] = useState([{ name: "Root", id: 1 }]);
+    const [currentFullPath, setCurrentFullPath] = useState([{ name: "Root", id: 1 }]);
     const [searchTerm, setSearchTerm] = useState("");
     const [dropdownActive, setDropdownActive] = useState(false);
 
@@ -18,15 +18,16 @@ const PathManager = ({ currentPathId = 1, onPathChange }) => {
     const createPath = useCreatePath();
     const config = useContext(ConfigContext).config;
 
-    const buildPath = async (pathId) => {
+
+    const buildFullPath = async (pathId) => {
         const path = [];
         let current_id = pathId;
         while (current_id) {
             try {
-                const pathData = await queryClient.fetchQuery(
-                    ["path", current_id],
-                    () => fetch_(`${config.BACKEND_HOST}/api/path/${current_id}`)
-                );
+                const pathData = await queryClient.fetchQuery({
+                    queryKey: ["path", current_id],
+                    queryFn: () => fetch_(`${config.BACKEND_HOST}/api/path/${current_id}`)
+                });
                 if (!pathData) break;
                 path.unshift({ name: pathData.name, id: pathData.id });
                 current_id = pathData.parent_id;
@@ -40,21 +41,21 @@ const PathManager = ({ currentPathId = 1, onPathChange }) => {
 
     useEffect(() => {
         const init = async () => {
-            const path = await buildPath(currentPathId);
-            setCurrentPath(path);
+            const path = await buildFullPath(currentPathId);
+            setCurrentFullPath(path);
         };
         init();
     }, [currentPathId, queryClient]);
 
     const handlePathClick = (pathId, pathIndex) => {
-        const newPath = currentPath.slice(0, pathIndex + 1);
-        setCurrentPath(newPath);
+        const newPath = currentFullPath.slice(0, pathIndex + 1);
+        setCurrentFullPath(newPath);
         onPathChange(pathId);
     };
 
     const handleSubPathSelect = (subPath) => {
-        const updatedPath = [...currentPath, { name: subPath.name, id: subPath.id }];
-        setCurrentPath(updatedPath);
+        const updatedPath = [...currentFullPath, { name: subPath.name, id: subPath.id }];
+        setCurrentFullPath(updatedPath);
         onPathChange(subPath.id);
         setSearchTerm("");
         setDropdownActive(false);
@@ -70,8 +71,8 @@ const PathManager = ({ currentPathId = 1, onPathChange }) => {
             { name: searchTerm.trim(), parent_id: currentPathId },
             {
                 onSuccess: (newDir) => {
-                    queryClient.setQueryData(["path", newDir.id], newDir);
-                    queryClient.invalidateQueries(["paths", currentPathId]);
+                    queryClient.setQueryData({queryKey: ["path", newDir.id]}, newDir);
+                    queryClient.invalidateQueries({queryKey: ["paths", currentPathId]});
                     setSearchTerm("");
                     alert("Directory created successfully.");
                 },
@@ -104,19 +105,21 @@ const PathManager = ({ currentPathId = 1, onPathChange }) => {
 
     return (
         <div className="path-manager">
-            <div className="path-manager-header">
-                <div className="current-path">
-                    {currentPath.map((path, index) => (
+            <div className="path-manager-header field has-addons">
+                <div className="current-path control">
+                    {currentFullPath.map((path, index) => (
                         <span
                             key={path.id}
-                            className="breadcrumb-item is-clickable"
+                            className="tag is-clickable is-link is-light"
                             onClick={() => handlePathClick(path.id, index)}
                         >
-                            {path.name}
-                            {index < currentPath.length - 1 && " / "}
+                            {path.name + "/"}
                         </span>
                     ))}
                 </div>
+                <div className="control">
+                    <span>&nbsp;&nbsp;&nbsp;&nbsp;</span>
+                </div>
             </div>
 
             <div className="path-manager-body">
@@ -144,6 +147,7 @@ const PathManager = ({ currentPathId = 1, onPathChange }) => {
                             Create "{searchTerm}"
                         </button>
                     </div>
+
                 </div>
                 {dropdownActive && (
                     <div className="dropdown is-active">

src/components/Settings/MarkdownSettings/MarkdownPermissionSettingPanel.js

@@ -0,0 +1,91 @@
+import {
+    useCreateMarkdownPermissionSetting,
+    useMarkdownPermissionSetting,
+    useUpdateMarkdownPermissionSetting
+} from "../../../utils/queries/markdown-permission-setting-queries";
+import React, {useEffect, useState} from "react";
+import {useUpdateMarkdownSetting} from "../../../utils/queries/markdown-setting-queries";
+
+const MarkdownPermissionSettingPanel = ({markdownSetting, onClose}) => {
+    const {data: setting, isFetching: settingIsFetching } = useMarkdownPermissionSetting(markdownSetting?.permission_setting_id);
+    const [permission, setPermission] = useState("");
+
+    const createMarkdownPermissionSetting = useCreateMarkdownPermissionSetting();
+    const updateMarkdownSetting = useUpdateMarkdownSetting();
+    const updateMarkdownPermissionSetting = useUpdateMarkdownPermissionSetting();
+
+    useEffect(() => {
+        if (setting && setting.permission !== undefined && setting.permission !== null) {
+            setPermission(setting.permission);
+        }
+    }, [setting]);
+
+    const handleCreatePermissionSetting = () => {
+        createMarkdownPermissionSetting.mutate({permission: null}, {
+           onSuccess: (data) => {
+               updateMarkdownSetting.mutate({
+                   id: markdownSetting.id,
+                   data: {
+                       permission_setting_id: data.id,
+                   }
+               });
+           }
+        });
+    };
+
+    const handleSaveMarkdownPermissionSetting = () => {
+        const permissionValue = permission === "" ? null : permission;
+
+        updateMarkdownPermissionSetting.mutate({
+            id: setting.id,
+            data: {
+                permission: permissionValue,
+            }
+        }, {
+            onSuccess: () => alert("Saved"),
+            onError: () => alert("Failed to save"),
+        });
+        onClose();
+    };
+
+    if (settingIsFetching) {
+        return (<p>Loading...</p>);
+    }
+
+    return setting ? (
+        <div className="box" style={{marginTop: "1rem"}}>
+            <h4 className="title is-5">Permission Setting</h4>
+            <div className="field">
+                <label className="label">Permission</label>
+                <div className="select is-fullwidth">
+                    <select
+                        value={permission}
+                        onChange={(e) => setPermission(e.target.value)}
+                    >
+                        <option value="">(None)</option>
+                        <option value="public">public</option>
+                        <option value="protected">protected</option>
+                        <option value="private">private</option>
+                    </select>
+                </div>
+            </div>
+            <button
+                className="button is-primary"
+                type="button"
+                onClick={handleSaveMarkdownPermissionSetting}
+            >
+                Save Permission Setting
+            </button>
+        </div>
+    ) : (
+        <button
+            className="button is-primary"
+            type="button"
+            onClick={handleCreatePermissionSetting}
+            >
+                Create Permission Setting
+        </button>
+    );
+};
+
+export default MarkdownPermissionSettingPanel;

src/components/Settings/MarkdownSettings/MarkdownTemplateSettingPanel.js

@@ -0,0 +1,95 @@
+import {
+    useMarkdownTemplate,
+    useMarkdownTemplates,
+} from "../../../utils/queries/markdown-template-queries";
+import {
+    useCreateMarkdownTemplateSetting,
+    useMarkdownTemplateSetting,
+    useUpdateMarkdownTemplateSetting
+} from "../../../utils/queries/markdown-template-setting-queries";
+import React, {useEffect, useState} from "react";
+import {useUpdateMarkdownSetting} from "../../../utils/queries/markdown-setting-queries";
+
+const MarkdownTemplateSettingPanel = ({markdownSetting, onClose}) => {
+    const {data: setting, isFetching: settingIsFetching } = useMarkdownTemplateSetting(markdownSetting?.template_setting_id);
+    const {data: templates, isFetching: templatesAreFetching}=useMarkdownTemplates();
+    const {data: template, isFetching: templateIsFetching} = useMarkdownTemplate(setting?.template_id);
+    const [selectedTemplateId, setSelectedTemplateId] = useState(template?.id ?? undefined);
+
+    const createMarkdownTemplateSetting = useCreateMarkdownTemplateSetting();
+    const updateMarkdownSetting = useUpdateMarkdownSetting();
+    const updateMarkdownTemplateSetting = useUpdateMarkdownTemplateSetting();
+    const handleCreateTemplateSetting = () => {
+        createMarkdownTemplateSetting.mutate({}, {
+           onSuccess: (data) => {
+               updateMarkdownSetting.mutate({
+                   id: markdownSetting.id,
+                   data: {
+                       template_setting_id: data.id,
+                   }
+               });
+           }
+        });
+    };
+
+    const handleSaveMarkdownTemplateSetting = () => {
+        updateMarkdownTemplateSetting.mutate({
+            id: setting.id,
+            data: {
+                template_id: selectedTemplateId,
+            }
+        }, {
+            onSuccess: () => alert("Saved"),
+            onError: () => alert("Failed to save"),
+        });
+        onClose();
+    };
+
+    useEffect(() => {
+        if(template?.id && selectedTemplateId === undefined) {
+            setSelectedTemplateId(template?.id ?? undefined);
+        }
+    },[template, selectedTemplateId]);
+    if (settingIsFetching || templatesAreFetching || templatesAreFetching || templateIsFetching) {
+        return (<p>Loading...</p>);
+    }
+    return setting ? (
+        <div className="box" style={{marginTop: "1rem"}}>
+            <h4 className="title is-5">Template Setting</h4>
+            <div className="field">
+                <label className="label">Use Template</label>
+                <div className="select is-fullwidth">
+                    <select
+                        value={selectedTemplateId}
+                        onChange={(e) => {
+                            setSelectedTemplateId(e.target.value);
+                        }}
+                    >
+                        <option value="">(default)</option>
+                        {templates.map((_template, index) => (
+                            <option key={index} value={_template.id}>{_template.title}</option>
+                        ))}
+
+                    </select>
+                </div>
+            </div>
+            <button
+                className="button is-primary"
+                type="button"
+                onClick={handleSaveMarkdownTemplateSetting}
+            >
+                Save Template Setting
+            </button>
+        </div>
+    ) : (
+        <button
+            className="button is-primary"
+            type="button"
+            onClick={handleCreateTemplateSetting}
+            >
+                Create Template Setting
+        </button>
+    );
+};
+
+export default MarkdownTemplateSettingPanel;

src/components/Settings/PathSettings/WebhookSettingPanel.js

@@ -0,0 +1,433 @@
+import React, { useEffect, useState } from "react";
+import {
+    useWebhookSetting,
+    useCreateWebhookSetting,
+    useUpdateWebhookSetting,
+    useWebhooks,
+} from "../../../utils/queries/webhook-queries";
+
+import {
+    useCreateWebhook,
+    useUpdateWebhook,
+    useDeleteWebhook,
+} from "../../../utils/queries/webhook-queries";
+import {useUpdatePathSetting} from "../../../utils/queries/path-setting-queries";
+
+const WebhookSettingPanel = ({pathSetting, onClose}) => {
+
+    const {data: setting} = useWebhookSetting(pathSetting?.webhook_setting_id || 0);
+    const {data: webhooks, isLoading: isWebhooksLoading} = useWebhooks();
+
+    const createWebhookSetting = useCreateWebhookSetting();
+    const updateWebhookSetting = useUpdateWebhookSetting();
+
+    const createWebhook = useCreateWebhook();
+    const updateWebhook = useUpdateWebhook();
+    const deleteWebhook = useDeleteWebhook();
+
+    const updatePathSetting = useUpdatePathSetting();
+
+
+    const [enabled, setEnabled] = useState(false);
+    const [isRecursive, setIsRecursive] = useState(false);
+    const [onEvents, setOnEvents] = useState(0);
+    const [selectedUrl, setSelectedUrl] = useState("");
+    const [headerList, setHeaderList] = useState([]);
+    const [additionalHeaders, setAdditionalHeaders] = useState({});
+
+    const [isOnMarkdownCreated, setIsOnMarkdownCreated] = useState(false);
+    const [isOnMarkdownUpdated, setIsOnMarkdownUpdated] = useState(false);
+    const [isOnMarkdownDeleted, setIsOnMarkdownDeleted] = useState(false);
+    const [isOnPathCreated, setIsOnPathCreated] = useState(false);
+    const [isOnPathUpdated, setIsOnPathUpdated] = useState(false);
+    const [isOnPathDeleted, setIsOnPathDeleted] = useState(false);
+
+    const assignFromOnEvents = (bits) => {
+        setIsOnMarkdownCreated(!!(bits & 1));
+        setIsOnMarkdownUpdated(!!(bits & 2));
+        setIsOnMarkdownDeleted(!!(bits & 4));
+        setIsOnPathCreated(!!(bits & 8));
+        setIsOnPathUpdated(!!(bits & 16));
+        setIsOnPathDeleted(!!(bits & 32));
+    };
+
+    const handleTriggerEventsUpdate = (eventType, isChecked) => {
+        setOnEvents((prev) => {
+            let nextVal = prev;
+            switch (eventType) {
+                case "MARKDOWN_CREATED":
+                    nextVal = isChecked ? nextVal | 1 : nextVal & ~1;
+                    setIsOnMarkdownCreated(isChecked);
+                    break;
+                case "MARKDOWN_UPDATED":
+                    nextVal = isChecked ? nextVal | 2 : nextVal & ~2;
+                    setIsOnMarkdownUpdated(isChecked);
+                    break;
+                case "MARKDOWN_DELETED":
+                    nextVal = isChecked ? nextVal | 4 : nextVal & ~4;
+                    setIsOnMarkdownDeleted(isChecked);
+                    break;
+                case "PATH_CREATED":
+                    nextVal = isChecked ? nextVal | 8 : nextVal & ~8;
+                    setIsOnPathCreated(isChecked);
+                    break;
+                case "PATH_UPDATED":
+                    nextVal = isChecked ? nextVal | 16 : nextVal & ~16;
+                    setIsOnPathUpdated(isChecked);
+                    break;
+                case "PATH_DELETED":
+                    nextVal = isChecked ? nextVal | 32 : nextVal & ~32;
+                    setIsOnPathUpdated(isChecked);
+                    break;
+                default:
+                    break;
+            }
+            return nextVal;
+        });
+    };
+
+    const handleCreateWebhookSetting = () => {
+        createWebhookSetting.mutate({}, {
+            onSuccess: (data) => {
+                updatePathSetting.mutate({
+                    id: pathSetting.id,
+                    data: {
+                        webhook_setting_id: data.id
+                    }
+                });
+            }
+        });
+    };
+
+    useEffect(() => {
+        if (setting && webhooks) {
+            setEnabled(setting.enabled);
+            setIsRecursive(setting.recursive);
+            setOnEvents(setting.on_events);
+            assignFromOnEvents(setting.on_events);
+
+            try {
+                const headers = setting.additional_header
+                    ? JSON.parse(setting.additional_header)
+                    : {};
+                setAdditionalHeaders(headers);
+                setHeaderList(
+                    Object.entries(headers).map(([k, v]) => ({ key: k, value: v }))
+                );
+            } catch (err) {
+                setAdditionalHeaders({});
+                setHeaderList([]);
+            }
+
+            const found = webhooks.find((wh) => wh.id === setting.webhook_id);
+            setSelectedUrl(found ? found.hook_url : "");
+        } else {
+            setEnabled(false);
+            setIsRecursive(false);
+            setOnEvents(0);
+            assignFromOnEvents(0);
+            setAdditionalHeaders({});
+            setHeaderList([]);
+            setSelectedUrl("");
+        }
+    }, [setting, webhooks]);
+
+    const handleAddHeader = () => {
+        setHeaderList([...headerList, { key: "", value: "" }]);
+    };
+    const handleHeaderChange = (index, field, val) => {
+        const updated = [...headerList];
+        updated[index][field] = val;
+        setHeaderList(updated);
+    };
+    const handleApplyHeaders = () => {
+        const out = {};
+        headerList.forEach(({ key, value }) => {
+            if (key.trim()) out[key] = value;
+        });
+        setAdditionalHeaders(out);
+    };
+
+    const handleCreateWebhook = () => {
+        const newUrl = prompt("Enter the new webhook URL");
+        if (!newUrl) return;
+        createWebhook.mutate(newUrl, {
+            onSuccess: () => alert("Created new Webhook successfully"),
+            onError: () => alert("Failed to create new Webhook"),
+        });
+    };
+    const handleUpdateWebhook = () => {
+        if (!setting || !setting.webhook_id) {
+            alert("No webhook selected. Must pick from dropdown first.");
+            return;
+        }
+        const newUrl = prompt("Enter updated Webhook URL", selectedUrl);
+        if (!newUrl) return;
+        updateWebhook.mutate(
+            { id: setting.webhook_id, data: { hook_url: newUrl } },
+            {
+                onSuccess: () => alert("Updated Webhook successfully"),
+                onError: () => alert("Failed to update Webhook"),
+            }
+        );
+    };
+    const handleDeleteWebhook = () => {
+        if (!setting || !setting.webhook_id) {
+            alert("No webhook selected to delete");
+            return;
+        }
+        if (!window.confirm("Are you sure?")) return;
+        deleteWebhook.mutate(setting.webhook_id, {
+            onSuccess: () => alert("Deleted Webhook successfully"),
+            onError: () => alert("Failed to delete Webhook"),
+        });
+    };
+
+    const handleSaveWebhookSetting = async () => {
+        const hook = webhooks.find((wh) => wh.hook_url === selectedUrl);
+        const payload = {
+            webhook_id: hook? hook.id : null,
+            recursive: isRecursive,
+            additional_header: JSON.stringify(additionalHeaders),
+            enabled,
+            on_events: onEvents,
+
+        };
+        if(!setting || !setting.id){
+            createWebhookSetting.mutate(payload, {
+                onSuccess: (res) => {
+                    updatePathSetting.mutate({id: pathSetting.id, data: {webhook_setting_id: res.id}},{
+                        onSuccess: () => alert("Webhook setting successfully created"),
+                        onError: () => alert("Failed to save Webhook"),
+                    })
+                },
+                onError: () => alert("Failed to save Webhook"),
+            });
+        } else {
+            updateWebhookSetting.mutate({id: setting.id, data: payload}, {
+                onSuccess: () => alert("Updated Webhook successfully"),
+                onError: () => alert("Failed to update Webhook"),
+            });
+        }
+        onClose();
+    };
+
+    return setting ? (
+        <div className="box" style={{ marginTop: "1rem" }}>
+            <h4 className="title is-5">Webhook Setting</h4>
+            <div className="field">
+                <label className="label">Select or Create a Webhook</label>
+                <div className="field has-addons">
+                    <div className="control is-expanded">
+                        {isWebhooksLoading ? (
+                            <p>Loading...</p>
+                        ) : (
+                            <div className="select is-fullwidth">
+                                <select
+                                    value={selectedUrl}
+                                    onChange={(e) => setSelectedUrl(e.target.value)}
+                                >
+                                    <option value="">(none)</option>
+                                    {webhooks.map((hook) => (
+                                        <option key={hook.id} value={hook.hook_url}>
+                                            {hook.hook_url}
+                                        </option>
+                                    ))}
+                                </select>
+                            </div>
+                        )}
+                    </div>
+                    <div className="control">
+                        <button
+                            type="button"
+                            className="button is-primary"
+                            onClick={handleCreateWebhook}
+                        >
+                            Add
+                        </button>
+                    </div>
+                </div>
+                {setting?.webhook_id && (
+                    <div className="buttons" style={{ marginTop: "0.5rem" }}>
+                        <button
+                            type="button"
+                            className="button is-info"
+                            onClick={handleUpdateWebhook}
+                        >
+                            Update Webhook URL
+                        </button>
+                        <button
+                            type="button"
+                            className="button is-danger"
+                            onClick={handleDeleteWebhook}
+                        >
+                            Delete Webhook
+                        </button>
+                    </div>
+                )}
+            </div>
+
+            <div className="field">
+                <label className="checkbox">
+                    <input
+                        type="checkbox"
+                        checked={enabled}
+                        onChange={(e) => setEnabled(e.target.checked)}
+                    />
+                    &nbsp; Enabled
+                </label>
+            </div>
+
+            <div className="field">
+                <label className="label">On Events</label>
+                <div className="box">
+                    <div className="columns">
+                        <div className="column">
+                            <label className="checkbox">
+                                <input
+                                    type="checkbox"
+                                    checked={isOnMarkdownCreated}
+                                    onChange={(e) =>
+                                        handleTriggerEventsUpdate("MARKDOWN_CREATED", e.target.checked)
+                                    }
+                                />
+                                &nbsp; Markdown Created
+                            </label>
+                            <br />
+                            <label className="checkbox">
+                                <input
+                                    type="checkbox"
+                                    checked={isOnMarkdownUpdated}
+                                    onChange={(e) =>
+                                        handleTriggerEventsUpdate("MARKDOWN_UPDATED", e.target.checked)
+                                    }
+                                />
+                                &nbsp; Markdown Updated
+                            </label>
+                            <br />
+                            <label className="checkbox">
+                                <input
+                                    type="checkbox"
+                                    checked={isOnMarkdownDeleted}
+                                    onChange={(e) =>
+                                        handleTriggerEventsUpdate("MARKDOWN_DELETED", e.target.checked)
+                                    }
+                                />
+                                &nbsp; Markdown Deleted
+                            </label>
+                        </div>
+                        <div className="column">
+                            <label className="checkbox">
+                                <input
+                                    type="checkbox"
+                                    checked={isOnPathCreated}
+                                    onChange={(e) =>
+                                        handleTriggerEventsUpdate("PATH_CREATED", e.target.checked)
+                                    }
+                                />
+                                &nbsp; Path Created
+                            </label>
+                            <br />
+                            <label className="checkbox">
+                                <input
+                                    type="checkbox"
+                                    checked={isOnPathUpdated}
+                                    onChange={(e) =>
+                                        handleTriggerEventsUpdate("PATH_UPDATED", e.target.checked)
+                                    }
+                                />
+                                &nbsp; Path Updated
+                            </label>
+                            <br />
+                            <label className="checkbox">
+                                <input
+                                    type="checkbox"
+                                    checked={isOnPathDeleted}
+                                    onChange={(e) =>
+                                        handleTriggerEventsUpdate("PATH_DELETED", e.target.checked)
+                                    }
+                                />
+                                &nbsp; Path Deleted
+                            </label>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <div className="field">
+                <label className="checkbox">
+                    <input
+                        type="checkbox"
+                        checked={isRecursive}
+                        onChange={(e) => setIsRecursive(e.target.checked)}
+                    />
+                    &nbsp; Recursive
+                </label>
+            </div>
+
+            <div className="field">
+                <label className="label">Additional Headers</label>
+                <div className="box">
+                    {headerList.map((h, idx) => (
+                        <div className="columns" key={idx}>
+                            <div className="column">
+                                <input
+                                    type="text"
+                                    className="input"
+                                    placeholder="key"
+                                    value={h.key}
+                                    onChange={(e) => handleHeaderChange(idx, "key", e.target.value)}
+                                />
+                            </div>
+                            <div className="column">
+                                <input
+                                    type="text"
+                                    className="input"
+                                    placeholder="value"
+                                    value={h.value}
+                                    onChange={(e) =>
+                                        handleHeaderChange(idx, "value", e.target.value)
+                                    }
+                                />
+                            </div>
+                        </div>
+                    ))}
+                    <button
+                        type="button"
+                        className="button is-small is-info"
+                        onClick={handleAddHeader}
+                    >
+                        + Header
+                    </button>
+                    <button
+                        type="button"
+                        className="button is-small is-success"
+                        onClick={handleApplyHeaders}
+                        style={{ marginLeft: "0.5rem" }}
+                    >
+                        Apply
+                    </button>
+                </div>
+            </div>
+
+            <button
+                type="button"
+                className="button is-primary"
+                onClick={handleSaveWebhookSetting}
+            >
+                Save Webhook Setting
+            </button>
+        </div>
+    ) : (
+        <button
+            className="button is-primary"
+            type="button"
+            onClick={handleCreateWebhookSetting}
+        >
+            Create Webhook Setting
+        </button>
+    );
+}
+
+
+export default WebhookSettingPanel

src/index.js

@@ -3,15 +3,16 @@ import ReactDOM from "react-dom/client";
 import App from "./App";
 import AuthProvider, {AuthContext} from "./AuthProvider";
 import "bulma/css/bulma.min.css";
-import {QueryClient, QueryClientProvider} from "react-query"
+import {QueryClient, QueryClientProvider} from "@tanstack/react-query"
 import ConfigProvider from "./ConfigProvider";
+import ControlledReactQueryDevtools from "./components/Debug/ControlledReactQueryDevtools";
 
 const queryClient = new QueryClient({
     defaultOptions: {
         queries: {
             retry: 2,
             refetchOnWindowFocus: false,
-            staleTimeout: 5 * 60 * 1000,
+            staleTime: 5 * 60 * 1000,
             onError: (error) => {
                 if (error.message === "Unauthorized"){
                     const {logout} = queryClient
@@ -38,7 +39,7 @@ const EnhancedAuthProvider = ({children}) => {
     };
 
     React.useEffect(() => {
-        queryClient.setQueryDefaults("auths", {
+        queryClient.setQueryDefaults(["auths"], {
             context: {logout}
         });
     }, [logout]);
@@ -52,6 +53,7 @@ root.render(
             <AuthProvider>
                 <EnhancedAuthProvider>
                     <App />
+                    <ControlledReactQueryDevtools />
                 </EnhancedAuthProvider>
             </AuthProvider>
         </QueryClientProvider>

src/store/index.js

@@ -0,0 +1,8 @@
+import { configureStore } from '@reduxjs/toolkit';
+import navigationReducer from './navigationSlice';
+
+export const store = configureStore({
+  reducer: {
+    navigation: navigationReducer,
+  },
+});

src/store/navigationSlice.js

@@ -0,0 +1,24 @@
+import { createSlice } from '@reduxjs/toolkit';
+
+const navigationSlice = createSlice({
+  name: 'navigation',
+  initialState: {
+    selectedTab: "tree",
+    expandedNodes: {}
+  },
+  reducers: {
+    setSelectedTab: (state, action) => {
+      state.selectedTab = action.payload;
+    },
+    toggleNodeExpansion: (state, action) => {
+      const nodeId = action.payload;
+      state.expandedNodes[nodeId] = !state.expandedNodes[nodeId];
+    },
+    setExpandedNodes: (state, action) => {
+      state.expandedNodes = action.payload;
+    }
+  }
+});
+
+export const { setSelectedTab, toggleNodeExpansion, setExpandedNodes } = navigationSlice.actions;
+export default navigationSlice.reducer;

src/utils/markdown-queries.js

@@ -1,62 +0,0 @@
-import {useQuery, useMutation, useQueryClient} from 'react-query';
-import {fetch_} from "./request-utils";
-import {useConfig} from "../ConfigProvider";
-
-
-
-export const useMarkdown = (id) => {
-    const config = useConfig();
-    return useQuery(
-        ["markdown", id],
-        () => fetch_(`${config.BACKEND_HOST}/api/markdown/${id}`),
-        {
-            enabled: !!id,
-        });
-};
-
-export const useIndexMarkdown = (path_id) => {
-    const queryClient = useQueryClient();
-    const config = useConfig();
-    return useQuery(
-        ["index_markdown", path_id],
-        () => fetch_(`${config.BACKEND_HOST}/api/markdown/get_index/${path_id}`),{
-            enabled: !!path_id,
-            onSuccess: (data) => {
-                if(data && data.id){
-                    queryClient.setQueryData(["markdown", data.id], data);
-                }
-            }
-        });
-};
-
-export const useMarkdownsByPath = (pathId) => {
-    const config = useConfig();
-    return useQuery(
-        ["markdownsByPath", pathId],
-        () => fetch_(`${config.BACKEND_HOST}/api/markdown/by_path/${pathId}`),
-        {
-            enabled: !!pathId
-        });
-};
-
-export const useSaveMarkdown = () => {
-    const queryClient = useQueryClient();
-    const config = useConfig();
-    return useMutation(({id, data}) => {
-        const url = id
-            ? `${config.BACKEND_HOST}/api/markdown/${id}`
-            : `${config.BACKEND_HOST}/api/markdown/`;
-        const method = id ? "PUT" : "POST";
-        return fetch_(url, {
-            method,
-            body: JSON.stringify(data),
-        })
-    },{
-        onSuccess: (res, variables) => {
-            queryClient.invalidateQueries(["markdownsByPath", variables.data.parent_id]);
-            queryClient.invalidateQueries(["markdown", variables.data.id]);
-        },
-    });
-};
-
-

src/utils/path-queries.js

@@ -1,95 +0,0 @@
-import { useQuery, useMutation, useQueryClient } from "react-query";
-import { fetch_ } from "./request-utils";
-import {useConfig} from "../ConfigProvider";
-
-
-export const usePaths = (parent_id) => {
-    const queryClient = useQueryClient();
-    const config = useConfig();
-    return useQuery(
-        ["paths", parent_id],
-        () => fetch_(`${config.BACKEND_HOST}/api/path/parent/${parent_id}`),
-        {
-            enabled: !!parent_id,
-            onSuccess: (data) => {
-                if(data) {
-                    for (const pth of data)
-                    {
-                        queryClient.setQueryData(["path", pth.id], pth);
-                    }
-                }
-            }
-        }
-    );
-}
-
-
-export const usePath = (id) => {
-    const config = useConfig();
-    const queryClient = useQueryClient();
-    const cachedData = queryClient.getQueryData(["path", id]);
-
-
-    return useQuery(
-        ["path", id],
-        () => fetch_(`${config.BACKEND_HOST}/api/path/${id}`),
-        {
-            enabled: !!id,
-            onSuccess: (data) => {
-                console.log(`path ${id} - ${cachedData}` );
-            }
-        }
-    );
-};
-
-export const useCreatePath = () => {
-    const config = useConfig();
-    const queryClient = useQueryClient();
-
-    return useMutation(
-        (data) => fetch_(`${config.BACKEND_HOST}/api/path/`, {
-            method: "POST",
-            body: JSON.stringify(data),
-        }),
-        {
-            onSuccess: (res, variables) => {
-                console.log(JSON.stringify(variables));
-                queryClient.invalidateQueries(["paths", variables.parent_id]);
-            },
-        }
-    );
-};
-
-export const useUpdatePath = () => {
-    const config = useConfig();
-    const queryClient = useQueryClient();
-
-    return useMutation(
-        ({ id, data }) => fetch_(`${config.BACKEND_HOST}/api/path/${id}`, {
-            method: "PATCH",
-            body: JSON.stringify(data),
-        }),
-        {
-            onSuccess: (res, variables) => {
-                queryClient.invalidateQueries(["paths", res.parent_id]);
-                queryClient.invalidateQueries(["path", variables.data.id]);
-            },
-        }
-    );
-};
-
-export const useDeletePath = () => {
-    const config = useConfig();
-    const queryClient = useQueryClient();
-
-    return useMutation(
-        (id) => fetch_(`${config.BACKEND_HOST}/api/path/${id}`, {
-            method: "DELETE",
-        }),
-        {
-            onSuccess: () => {
-                queryClient.invalidateQueries("paths");
-            },
-        }
-    );
-};

src/utils/pathUtils.js

@@ -0,0 +1,45 @@
+export const findMarkdownByPath = (tree, pathString) => {
+    if (!tree || !pathString) return null;
+    
+    const pathSegments = pathString.split('/').filter(segment => segment.length > 0);
+
+    if (pathSegments.length === 0) {
+        const rootIndex = tree.children?.find(
+            child => child.type === 'markdown' && child.title === 'index'
+        );
+        return rootIndex || null;
+    }
+    let currentNode = tree;
+
+    for (let i = 0; i < pathSegments.length; i++) {
+        const segment = pathSegments[i];
+
+        const childPath = currentNode.children?.find(
+            child => child.type === 'path' && child.name === segment
+        );
+        
+        if (!childPath) {
+            if (i === pathSegments.length - 1) {
+                const markdownNode = currentNode.children?.find(
+                    child => child.type === 'markdown' && child.title === segment
+                );
+                return markdownNode || null;
+            }
+            return null;
+        }
+        
+        currentNode = childPath;
+    }
+    
+
+    const indexMarkdown = currentNode.children?.find(
+        child => child.type === 'markdown' && child.title === 'index'
+    );
+    
+    return indexMarkdown || null;
+};
+
+export const getMarkdownIdByPath = (tree, pathString) => {
+    const markdownNode = findMarkdownByPath(tree, pathString);
+    return markdownNode?.id || null;
+};

src/utils/queries/apikey-queries.js

@@ -0,0 +1,32 @@
+import { useConfig } from "../../ConfigProvider";
+import { useMutation } from "@tanstack/react-query";
+import { fetch_ } from "../request-utils";
+
+export const useCreateApiKey = () => {
+    const config = useConfig();
+    return useMutation({
+        mutationFn: async ({ name, roles }) => {
+            const response = await fetch_(`${config.BACKEND_HOST}/api/apikey/`, {
+                method: "POST",
+                body: JSON.stringify({ name, roles }),
+            });
+            console.log("response", response);
+            return response;
+        },
+        cacheTime: 0,
+    });
+};
+
+export const useRevokeApiKey = () => {
+    const config = useConfig();
+    return useMutation({
+        mutationFn: async (apiKey) => {
+            const response = await fetch_(`${config.BACKEND_HOST}/api/apikey/revoke`, {
+                method: "POST",
+                body: JSON.stringify({ apiKey }),
+            });
+            return response;
+        },
+        cacheTime: 0,
+    });
+}; 

src/utils/queries/markdown-permission-setting-queries.js

@@ -0,0 +1,77 @@
+import {useConfig} from "../../ConfigProvider";
+import {useMutation, useQuery, useQueryClient} from "@tanstack/react-query";
+import {fetch_} from "../request-utils";
+
+export const useMarkdownPermissionSettings = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useQuery({
+            queryKey: ["markdown_permission_settings"],
+            queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/permission/`),
+            onSuccess: async (data) => {
+                if (data) {
+                    for (const setting of data) {
+                        await queryClient.invalidateQueries(["markdown_permission_setting", setting.id]);
+                    }
+                }
+            }
+        }
+    );
+};
+
+export const useMarkdownPermissionSetting = (setting_id) => {
+    const config = useConfig();
+    return useQuery({
+            queryKey: ["markdown_permission_setting", setting_id],
+            queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/permission/${setting_id}`),
+            enabled: !!setting_id,
+        }
+    );
+};
+
+export const useCreateMarkdownPermissionSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation(
+        {
+            mutationFn: (data) => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/permission/`, {
+                method: "POST",
+                body: JSON.stringify(data),
+            }),
+            onSuccess: async (data) => {
+                await queryClient.invalidateQueries(["markdown_permission_setting", data.id]);
+                await queryClient.invalidateQueries(["markdown_permission_settings"]);
+            }
+        });
+};
+
+export const useUpdateMarkdownPermissionSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation(
+        ({id, data}) => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/permission/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(data),
+        }),{
+            onSuccess: (res) => {
+                queryClient.invalidateQueries(["markdown_permission_setting", res.id]);
+                queryClient.invalidateQueries(["markdown_permission_settings"]);
+            }
+        }
+    );
+};
+
+export const useDeleteMarkdownPermissionSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation(
+        ({id}) => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/permission/${id}`, {
+            method: "DELETE",
+        }), {
+            onSuccess: (res, variables) => {
+                queryClient.invalidateQueries(["markdown_permission_setting", variables.id]);
+                queryClient.invalidateQueries(["markdown_permission_settings"]);
+            }
+        }
+    );
+};

src/utils/queries/markdown-queries.js

@@ -0,0 +1,133 @@
+import {useQuery, useMutation, useQueryClient} from '@tanstack/react-query';
+import {fetch_} from "../request-utils";
+import {useConfig} from "../../ConfigProvider";
+
+
+
+export const useMarkdown = (id) => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["markdown", id],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/markdown/${id}`),
+        enabled: !!id,
+    });
+};
+
+export const useIndexMarkdown = (path_id) => {
+    const queryClient = useQueryClient();
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["index_markdown", path_id],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/markdown/get_index/${path_id}`),
+        enabled: !!path_id,
+        onSuccess: (data) => {
+            if(data && data.id){
+                queryClient.setQueryData({queryKey: ["markdown", data.id]}, data);
+            }
+        }
+    });
+};
+
+export const useHomeMarkdown = () => {
+    const queryClient = useQueryClient();
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["home_markdown"],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/markdown/get_home`),
+        onSuccess: (data) => {
+            if (data && data.id){
+                queryClient.setQueryData({queryKey: ["markdown", data.id]}, data);
+            }
+        }
+    });
+};
+
+
+export const useMarkdownsByPath = (pathId) => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["markdownsByPath", pathId],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/markdown/by_path/${pathId}`),
+        enabled: !!pathId
+    });
+};
+
+
+export const useSaveMarkdown = () => {
+    const queryClient = useQueryClient();
+    const config = useConfig();
+    return useMutation({
+        mutationFn: ({id, data}) => {
+            const url = id
+                ? `${config.BACKEND_HOST}/api/markdown/${id}`
+                : `${config.BACKEND_HOST}/api/markdown/`;
+            const method = id ? "PATCH" : "POST";
+            return fetch_(url, {
+                method,
+                body: JSON.stringify(data),
+            });
+        },
+        onSuccess: async (res) => {
+            await queryClient.invalidateQueries({queryKey: ["markdownsByPath", res.path_id]});
+            await queryClient.invalidateQueries({queryKey: ["markdown", res.id]});
+            await queryClient.invalidateQueries({queryKey: ["tree"]});
+
+            console.log("invalidateQueries: ", res.id, typeof res.id);
+        },
+    });
+};
+
+
+export const useMoveMarkdown = () => {
+    const queryClient = useQueryClient();
+    const config = useConfig();
+
+    return useMutation({
+        mutationFn: ({markdown, direction}) => {
+            const apiEndpoint = `${config.BACKEND_HOST}/api/markdown/move_${direction}/${markdown.id}`;
+            return fetch_(apiEndpoint, {method: "PATCH"});
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({queryKey: ["paths"]});
+            queryClient.invalidateQueries({queryKey: ["tree"]});
+        }
+    });
+};
+
+export const useDeleteMarkdown = () => {
+    const queryClient = useQueryClient();
+    const config = useConfig();
+    
+    return useMutation({
+        mutationFn: (markdownId) => {
+            return fetch_(`${config.BACKEND_HOST}/api/markdown/${markdownId}`, {
+                method: "DELETE"
+            });
+        },
+        onSuccess: (data, markdownId) => {
+            queryClient.invalidateQueries({queryKey: ["markdown", markdownId]});
+            queryClient.invalidateQueries({queryKey: ["tree"]});
+            queryClient.invalidateQueries({queryKey: ["markdownsByPath"]});
+        }
+    });
+};
+
+export const useSearchMarkdown = (keyword) => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["markdownsByKeyword", keyword],
+        queryFn: () => fetch_(
+            `${config.BACKEND_HOST}/api/markdown/search/${encodeURIComponent(keyword)}`,
+        ),
+        enabled: !!keyword,
+    });
+};
+
+
+export const useLinks = () => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["links"], 
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/markdown/links`)
+    });
+}

src/utils/queries/markdown-setting-queries.js

@@ -0,0 +1,70 @@
+import {useConfig} from "../../ConfigProvider";
+import {useMutation, useQuery, useQueryClient} from "@tanstack/react-query";
+import {fetch_} from "../request-utils";
+
+export const useMarkdownSettings = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useQuery({
+        queryKey: ["markdown_setting"],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/`),
+        onSuccess: (data) => {
+            if(data){
+                for(const setting of data)
+                    queryClient.setQueryData({queryKey: ["markdown_setting", setting.id]}, setting);
+            }
+        }
+    });
+};
+
+export const useMarkdownSetting = (setting_id) => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["markdown_setting", setting_id],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/${setting_id}`, {}),
+        enabled: !!setting_id,
+    });
+};
+
+
+export const useCreateMarkdownSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data) => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/`, {
+            method: "POST",
+            body: JSON.stringify(data)
+        }),
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_setting", data.id]});
+        }
+    });
+};
+
+
+export const useUpdateMarkdownSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({id, data}) => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(data)
+        }),
+        onSuccess: (data, variables) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_setting", variables.id]});
+        }
+    });
+};
+
+export const useDeleteMarkdownSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/${id}`, {
+            method: "DELETE",
+        }),
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_setting", data.id]});
+        }
+    });
+};

src/utils/queries/markdown-template-queries.js

@@ -0,0 +1,96 @@
+import {useConfig} from "../../ConfigProvider";
+import {useMutation, useQuery, useQueryClient} from "@tanstack/react-query";
+import {fetch_} from "../request-utils";
+import {template} from "@babel/core";
+import {data} from "react-router-dom";
+
+
+export const useMarkdownTemplate = (template_id) => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["markdown_template", template_id],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/template/markdown/${template_id}`),
+        enabled: !!template_id,
+    });
+};
+
+export const useMarkdownTemplates = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useQuery({
+        queryKey: ["markdown_templates"],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/template/markdown/`),
+        onSuccess: (data) => {
+            if(data){
+                for(const template of data){
+                    queryClient.setQueryData({queryKey: ["markdown_template", template.id]}, template);
+                }
+            }
+        }
+    });
+};
+
+export const useUpdateMarkdownTemplate = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({id, data}) => fetch_(`${config.BACKEND_HOST}/api/template/markdown/${id}`, {
+            method: "PUT",
+            body: JSON.stringify(data),
+        }),
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_template", data.id]});
+            queryClient.invalidateQueries({queryKey: ["markdown_templates"]});
+        }
+    });
+}
+
+export const useCreateMarkdownTemplate = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data) => fetch_(`${config.BACKEND_HOST}/api/template/markdown/`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        }),
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_template", data.id]});
+            queryClient.invalidateQueries({queryKey: ["markdown_templates"]});
+        }
+    });
+}
+
+export const useDeleteMarkdownTemplate = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => fetch_(`${config.BACKEND_HOST}/api/template/markdown/${id}`, {
+            method: "DELETE"
+        }),
+        onSuccess: (res, variables) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_template", variables]});
+            queryClient.invalidateQueries({queryKey: ["markdown_templates"]});
+        }
+    });
+}
+
+export const useSaveMarkdownTemplate = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({id, data}) => {
+            const url = id
+                ? `${config.BACKEND_HOST}/api/template/markdown/${id}`
+                : `${config.BACKEND_HOST}/api/template/markdown/`;
+            const method = id? "PUT": "POST";
+            return fetch_(url, {
+                method,
+                body: JSON.stringify(data),
+            });
+        },
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_template", data.id]});
+            queryClient.invalidateQueries({queryKey: ["markdown_templates"]});
+        }
+    });
+}

src/utils/queries/markdown-template-setting-queries.js

@@ -0,0 +1,71 @@
+import {useConfig} from "../../ConfigProvider";
+import {useMutation, useQuery, useQueryClient} from "@tanstack/react-query";
+import {fetch_} from "../request-utils";
+
+export const useMarkdownTemplateSettings = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useQuery({
+        queryKey: ["markdown_template_settings"],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/template/`),
+        onSuccess: (data) => {
+            if(data){
+                for(const setting of data){
+                    queryClient.setQueryData({queryKey: ["markdown_template_setting", setting.id]}, setting);
+                }
+            }
+        }
+    });
+};
+
+export const useMarkdownTemplateSetting = (setting_id) => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["markdown_template_setting", setting_id],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/template/${setting_id}`),
+        enabled: !!setting_id,
+    });
+};
+
+
+export const useCreateMarkdownTemplateSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data) => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/template/`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        }),
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_template_setting", data.id]});
+        }
+    });
+};
+
+export const useUpdateMarkdownTemplateSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({id, data}) => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/template/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(data),
+        }),
+        onSuccess: (res) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_template_setting", res.id]});
+            queryClient.invalidateQueries({queryKey: ["markdown_template_settings"]});
+        }
+    });
+};
+
+export const useDeleteMarkdownTemplateSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({id}) => fetch_(`${config.BACKEND_HOST}/api/setting/markdown/template/${id}`, {
+            method: "DELETE",
+        }),
+        onSuccess: (res, variables) => {
+            queryClient.invalidateQueries({queryKey: ["markdown_template_setting", variables.id]});
+        }
+    });
+};

src/utils/queries/path-queries.js

@@ -0,0 +1,97 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { fetch_ } from "../request-utils";
+import {useConfig} from "../../ConfigProvider";
+
+
+export const usePaths = (parent_id) => {
+    const queryClient = useQueryClient();
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["paths", parent_id],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/path/parent/${parent_id}`),
+        enabled: !!parent_id,
+        onSuccess: (data) => {
+            if(data) {
+                for (const pth of data)
+                {
+                    queryClient.setQueryData({queryKey: ["path", pth.id]}, pth);
+                }
+            }
+        }
+    });
+};
+
+
+export const usePath = (id) => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["path", id],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/path/${id}`),
+        enabled: !!id
+    });
+};
+
+export const useCreatePath = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: (data) => fetch_(`${config.BACKEND_HOST}/api/path/`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        }),
+        onSuccess: (res) => {
+            queryClient.invalidateQueries({queryKey: ["paths", res.parent_id]});
+            queryClient.invalidateQueries({queryKey: ["tree"]});
+        },
+    });
+};
+
+export const useUpdatePath = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: ({ id, data }) => fetch_(`${config.BACKEND_HOST}/api/path/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(data),
+        }),
+        onSuccess: (res) => {
+            queryClient.invalidateQueries({queryKey: ["paths", res.parent_id]});
+            queryClient.invalidateQueries({queryKey: ["path", res.id]});
+            queryClient.invalidateQueries({queryKey: ["tree"]});
+        },
+    });
+};
+
+export const useDeletePath = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: (id) => fetch_(`${config.BACKEND_HOST}/api/path/${id}`, {
+            method: "DELETE",
+        }),
+        onSuccess: () => {
+            queryClient.invalidateQueries({queryKey: ["paths"]});
+            queryClient.invalidateQueries({queryKey: ["tree"]});
+        },
+    });
+};
+
+
+export const useMovePath = () => {
+    const queryClient = useQueryClient();
+    const config = useConfig();
+
+    return useMutation({
+        mutationFn: ({path, direction}) => {
+            const apiEndpoint = `${config.BACKEND_HOST}/api/path/move_${direction}/${path.id}`;
+            return fetch_(apiEndpoint, {method: "PATCH"});
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({queryKey: ["paths"]});
+            queryClient.invalidateQueries({queryKey: ["tree"]});
+        }
+    });
+};

src/utils/queries/path-setting-queries.js

@@ -0,0 +1,73 @@
+import {useConfig} from "../../ConfigProvider";
+import {useMutation, useQuery, useQueryClient} from "@tanstack/react-query";
+import {fetch_} from "../request-utils";
+
+export const usePathSettings = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useQuery({
+        queryKey: ["path_settings"],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/path/`),
+        onSuccess: (data) => {
+            if(data){
+                for(const setting of data)
+                    queryClient.setQueryData({queryKey: ["path_setting", setting.id]}, setting);
+            }
+        }
+    });
+};
+
+export const usePathSetting = (setting_id) => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["path_setting", setting_id],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/path/${setting_id}`),
+        enabled: !!setting_id,
+    });
+};
+
+export const useCreatePathSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data) => fetch_(`${config.BACKEND_HOST}/api/setting/path/`, {
+            method: "POST",
+            body: JSON.stringify(data)
+        }),
+        onSuccess: (data) => {
+            queryClient.invalidateQueries({queryKey: ["path_setting", data.id]});
+            queryClient.invalidateQueries({queryKey: ["path_settings"]});
+        }
+    });
+};
+
+
+export const useUpdatePathSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({id, data}) => fetch_(`${config.BACKEND_HOST}/api/setting/path/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(data)
+        }),
+        onSuccess: (data, variables) => {
+            queryClient.invalidateQueries({queryKey: ["path_setting", variables.id]});
+            queryClient.invalidateQueries({queryKey: ["path_settings"]});
+        }
+    });
+};
+
+
+export const useDeletePathSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => fetch_(`${config.BACKEND_HOST}/api/setting/path/${id}`, {
+            method: "DELETE",
+        }),
+        onSuccess: (data, variables) => {
+            queryClient.invalidateQueries({queryKey: ["path_setting", variables.id]});
+            queryClient.invalidateQueries({queryKey: ["path_settings"]});
+        }
+    });
+};

src/utils/queries/tree-queries.js

@@ -0,0 +1,17 @@
+import {useQuery, useMutation, useQueryClient} from "@tanstack/react-query";
+import {fetch_} from "../request-utils";
+import {useConfig} from "../../ConfigProvider";
+
+
+export const useTree = () => {
+    const queryClient = useQueryClient();
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["tree"],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/tree/`),
+        onSuccess: data => {
+            if(data)
+                queryClient.setQueryData({queryKey: ["tree"]}, data);
+        }
+    });
+};

src/utils/queries/webhook-queries.js

@@ -0,0 +1,136 @@
+import {fetch_ } from "../request-utils"
+import {useConfig} from "../../ConfigProvider";
+import {useMutation, useQuery, useQueryClient} from "@tanstack/react-query";
+
+export const useWebhooks = () =>{
+    const queryClient = useQueryClient();
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["webhooks"],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/webhook/`),
+        onSuccess: (data) => {
+            if(data){
+                for(const webhook of data){
+                    queryClient.setQueryData({queryKey: ["webhook", data.id]}, data);
+                }
+            }
+        }
+    });
+};
+
+export const useCreateWebhook = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationFn: (data) => fetch_(`${config.BACKEND_HOST}/api/webhook/`, {
+            method: "POST",
+            body: JSON.stringify({
+                "hook_url": data
+            }),
+        }),
+        onSuccess: () => {
+            queryClient.invalidateQueries({queryKey: ["webhooks"]});
+        }
+    });
+};
+
+export const useUpdateWebhook = () =>{
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({id, data}) => fetch_(`${config.BACKEND_HOST}/api/webhook/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(data)
+        }),
+        onSuccess: (res) => {
+            queryClient.invalidateQueries({queryKey: ["webhook", res.id]});
+            queryClient.invalidateQueries({queryKey: ["webhooks"]});
+        }
+    });
+};
+
+export const useDeleteWebhook = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => fetch_(`${config.BACKEND_HOST}/api/webhook/${id}`, {
+            method: "DELETE",
+        }),
+        onSuccess: (res, variables) => {
+            queryClient.invalidateQueries({queryKey: ["webhook", variables.id]});
+            queryClient.invalidateQueries({queryKey: ["webhooks"]});
+        }
+    });
+}
+
+export const useWebhookSettings = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useQuery({
+        queryKey: ["webhook_setting"],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/path/webhook/`),
+        onSuccess: (data) => {
+            if(data){
+                for(const setting of data){
+                    queryClient.setQueryData({queryKey: ["webhook_setting", setting.id]}, setting);
+                }
+            }
+        }
+    });
+};
+
+export const useWebhookSetting = (setting_id) => {
+    const config = useConfig();
+    return useQuery({
+        queryKey: ["webhook_setting", setting_id],
+        queryFn: () => fetch_(`${config.BACKEND_HOST}/api/setting/path/webhook/${setting_id}`),
+        enabled: !!setting_id,
+    });
+};
+
+
+export const useCreateWebhookSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data) => fetch_(`${config.BACKEND_HOST}/api/setting/path/webhook/`, {
+            method: "POST",
+            body: JSON.stringify(data)
+        }),
+        onSuccess: (res) => {
+            queryClient.invalidateQueries({queryKey: ["webhook_setting", res.id]});
+            queryClient.invalidateQueries({queryKey: ["webhook_setting"]});
+        }
+    });
+};
+
+export const useUpdateWebhookSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({id, data}) => fetch_(`${config.BACKEND_HOST}/api/setting/path/webhook/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(data)
+        }),
+        onSuccess: (res, variables) => {
+            queryClient.invalidateQueries({queryKey: ["webhook_setting", variables.id]});
+            queryClient.invalidateQueries({queryKey: ["webhook_setting"]});
+        }
+    });
+};
+
+
+export const useDeleteWebhookSetting = () => {
+    const config = useConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => fetch_(`${config.BACKEND_HOST}/api/setting/path/webhook/${id}`, {
+            method: "DELETE",
+        }),
+        onSuccess: (res, variables) => {
+            queryClient.invalidateQueries({queryKey: ["webhook_setting", variables.id]});
+            queryClient.invalidateQueries({queryKey: ["webhook_setting"]});
+        }
+    });
+};

src/utils/request-utils.js

@@ -24,5 +24,16 @@ export async function fetch_(url, init = {}) {
         return null;
     }
 
+    if (response.status === 203) {
+        const data = await response.json();
+        return {
+            id: null,
+            content: data.msg || "Non-authoritative information received",
+            title: "Message",
+            isMessage: true,
+            ...data
+        };
+    }
+
     return response.json();
-}
+}

tests/AuthProvider.test.js

@@ -0,0 +1,23 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import AuthProvider, { AuthContext } from "../src/AuthProvider";
+import "@testing-library/jest-dom";
+describe("AuthProvider", () => {
+    it("should provide default user and roles as null and empty array", () => {
+        render(
+            <AuthProvider>
+                <AuthContext.Consumer>
+                    {({ user, roles }) => (
+                        <>
+                            <div data-testid="user">{user ? user.name : "null"}</div>
+                            <div data-testid="roles">{roles.length}</div>
+                        </>
+                    )}
+                </AuthContext.Consumer>
+            </AuthProvider>
+        );
+
+        expect(screen.getByTestId("user")).toHaveTextContent("null");
+        expect(screen.getByTestId("roles")).toHaveTextContent("0");
+    });
+});

tests/ConfigProvider.test.js

@@ -0,0 +1,45 @@
+import React from "react";
+import { render, screen, act } from "@testing-library/react";
+import ConfigProvider from "../src/ConfigProvider";
+
+global.fetch = jest.fn(() =>
+    new Promise((resolve) =>
+        setTimeout(() => {
+            resolve({
+                ok: true,
+                json: () =>
+                    Promise.resolve({
+                        BACKEND_HOST: "http://localhost:5000",
+                        FRONTEND_HOST: "http://localhost:3000",
+                    }),
+            });
+        }, 100)
+    )
+);
+
+describe("ConfigProvider", () => {
+    it("should display loading initially", async () => {
+        await act(async () => {
+            render(
+                <ConfigProvider>
+                    <div>Loaded</div>
+                </ConfigProvider>
+            );
+        });
+
+        expect(screen.getByText(/Loading configuration/i)).toBeInTheDocument();
+    });
+
+    it("should display children after loading", async () => {
+        await act(async () => {
+            render(
+                <ConfigProvider>
+                    <div>Loaded</div>
+                </ConfigProvider>
+            );
+        });
+
+        const loadedText = await screen.findByText("Loaded");
+        expect(loadedText).toBeInTheDocument();
+    });
+});

tests/PermissionGuard.test.js

@@ -0,0 +1,31 @@
+import React from "react";
+import PermissionGuard from "../src/components/PermissionGuard";
+import { AuthContext } from "../src/AuthProvider";
+import { render, screen } from "@testing-library/react";
+describe("PermissionGuard", () => {
+    it("should render children for users with required roles", () => {
+        const roles = ["admin"];
+        render(
+            <AuthContext.Provider value={{ roles }}>
+                <PermissionGuard rolesRequired={["admin"]}>
+                    <div data-testid="protected-content">Protected Content</div>
+                </PermissionGuard>
+            </AuthContext.Provider>
+        );
+
+        expect(screen.getByTestId("protected-content")).toBeInTheDocument();
+    });
+
+    it("should not render children for users without required roles", () => {
+        const roles = ["user"];
+        render(
+            <AuthContext.Provider value={{ roles }}>
+                <PermissionGuard rolesRequired={["admin"]}>
+                    <div data-testid="protected-content">Protected Content</div>
+                </PermissionGuard>
+            </AuthContext.Provider>
+        );
+
+        expect(screen.queryByTestId("protected-content")).not.toBeInTheDocument();
+    });
+});

webpack.config.js

@@ -1,7 +1,6 @@
 const path = require('path');
 const HtmlWebpackPlugin = require('html-webpack-plugin');
-const Dotenv = require('dotenv-webpack');
-
+const webpack = require('webpack');
 module.exports = {
     entry: './src/index.js',
     output: {
@@ -30,6 +29,10 @@ module.exports = {
             template: "./public/index.html",
             inject: true
         }),
+        new webpack.ProvidePlugin({
+            process: 'process/browser.js'
+        })
+
     ],
     devServer: {
         static: path.join(__dirname, 'public'),
@@ -37,5 +40,17 @@ module.exports = {
         open: true,
         hot: true,
         historyApiFallback: true,
-    }
-};
+    },
+    resolve: {
+        alias: {
+            'process/browser': require.resolve('process/browser.js')
+        },
+        fallback: {
+            path: require.resolve('path-browserify'),
+            fs: false,
+            assert: require.resolve("assert/"),
+            process: require.resolve("process/browser.js"),
+        }
+    },
+    devtool: 'source-map',
+};