756 lines
26 KiB
Python
Executable File
756 lines
26 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Mini-CMS: MD-Dateien in md/ per Browseroberflaeche bearbeiten
|
|
und als statische Seite (HTML + CSS) nach output/ exportieren.
|
|
Nur Python-Standardbibliothek, kein Internet noetig.
|
|
|
|
Aufruf:
|
|
python3 cms.py -> Server + UI starten (http://localhost:8500)
|
|
python3 cms.py export -> nur exportieren, kein Server
|
|
python3 cms.py port 9000 -> Server auf anderem Port
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
import re
|
|
import shutil
|
|
import sys
|
|
import threading
|
|
import webbrowser
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from urllib.parse import unquote, urlparse
|
|
|
|
ROOT = os.path.dirname(os.path.abspath(__file__))
|
|
MD_DIR = os.path.join(ROOT, "md")
|
|
TPL_DIR = os.path.join(ROOT, "templates")
|
|
CSS_DIR = os.path.join(ROOT, "css")
|
|
OUT_DIR = os.path.join(ROOT, "output")
|
|
PORT = 8500
|
|
|
|
for d in (MD_DIR, TPL_DIR, CSS_DIR, OUT_DIR):
|
|
os.makedirs(d, exist_ok=True)
|
|
|
|
SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9_-]*$", re.IGNORECASE)
|
|
START_PAGE = "startseite"
|
|
HEADER_PAGE = "header" # Baustein: wird ueber den Inhalt jeder Seite gesetzt
|
|
FOOTER_PAGE = "footer" # Baustein: wird unter den Inhalt jeder Seite gesetzt
|
|
|
|
|
|
# ---------------------------------------------------------------- markdown
|
|
|
|
def inline(s):
|
|
"""Inline-Markdown: bilder, code, fett, kursiv, Links."""
|
|
s = re.sub(r"`([^`]+)`", r"<code>\1</code>", s)
|
|
s = re.sub(r"!\[([^\]]*)\]\(([^)]+)\)", r'<img src="\2" alt="\1">', s)
|
|
s = re.sub(r"\*\*([^*]+)\*\*", r"<strong>\1</strong>", s)
|
|
s = re.sub(r"\*([^*]+)\*", r"<em>\1</em>", s)
|
|
s = re.sub(r"\[([^\]]+)\]\(([^)]+)\)", r'<a href="\2">\1</a>', s)
|
|
return s
|
|
|
|
|
|
def md_to_html(text, headings=None):
|
|
"""Minimaler Markdown->HTML-Konverter:
|
|
Ueberschriften, **fett**, *kursiv*, `code`, [Links](url),
|
|
Listen, Code-Bloecke, > Zitate, --- Trennlinien, Absaetze.
|
|
Ueberschriften bekommen id-Anker; in headings (Liste) werden
|
|
optional (anker, text) aller Ueberschriften gesammelt.
|
|
"""
|
|
# vergessenes Trigger-Wort "image" direkt vor einem Bild nicht mit ausgeben
|
|
text = re.sub(r"\bimage\s*(?=!\[)", "", text, flags=re.IGNORECASE)
|
|
lines = text.replace("\r\n", "\n").split("\n")
|
|
out = []
|
|
i = 0
|
|
in_code = False
|
|
in_list = False
|
|
list_tag = None
|
|
used_ids = {}
|
|
sec_stack = [] # offene Sektionen (pro # mehr eine Ebene, eingerueckt)
|
|
|
|
def close_list():
|
|
nonlocal in_list, list_tag
|
|
if in_list:
|
|
out.append("</%s>" % list_tag)
|
|
in_list = False
|
|
list_tag = None
|
|
|
|
while i < len(lines):
|
|
line = lines[i]
|
|
|
|
if line.strip().startswith("```"):
|
|
close_list()
|
|
if not in_code:
|
|
out.append("<pre><code>")
|
|
in_code = True
|
|
else:
|
|
out.append("</code></pre>")
|
|
in_code = False
|
|
i += 1
|
|
continue
|
|
|
|
if in_code:
|
|
out.append(_escape(line))
|
|
i += 1
|
|
continue
|
|
|
|
stripped = line.strip()
|
|
|
|
if not stripped:
|
|
close_list()
|
|
i += 1
|
|
continue
|
|
|
|
# Rohe HTML-Zeilen (z.B. <div>, <svg>) unveraendert durchreichen
|
|
if stripped.startswith("<"):
|
|
close_list()
|
|
out.append(stripped)
|
|
i += 1
|
|
continue
|
|
|
|
m = re.match(r"^(#{1,6})\s+(.*)$", stripped)
|
|
if m:
|
|
close_list()
|
|
level = len(m.group(1))
|
|
text_h = m.group(2)
|
|
hid = _slugify(text_h)
|
|
if hid in used_ids:
|
|
used_ids[hid] += 1
|
|
hid = "%s-%d" % (hid, used_ids[hid])
|
|
else:
|
|
used_ids[hid] = 0
|
|
if headings is not None:
|
|
headings.append((level, hid, text_h))
|
|
# tiefere Sektionen schliessen, bis die Ebene wieder passt
|
|
while sec_stack and sec_stack[-1] >= level:
|
|
out.append("</div>")
|
|
sec_stack.pop()
|
|
# ein # mehr als die umgebende Ueberschrift -> Stufe einruecken
|
|
if sec_stack:
|
|
out.append('<div class="sec">')
|
|
else:
|
|
out.append('<div class="sec0">')
|
|
out.append('<h%d id="%s">%s</h%d>'
|
|
% (level, hid, inline(_escape(text_h)), level))
|
|
sec_stack.append(level)
|
|
i += 1
|
|
continue
|
|
|
|
if re.match(r"^-{3,}$", stripped):
|
|
close_list()
|
|
out.append("<hr>")
|
|
i += 1
|
|
continue
|
|
|
|
# Tabellen: | zelle | zelle | mit --- Trennzeile
|
|
if stripped.startswith("|"):
|
|
close_list()
|
|
rows = []
|
|
j = i
|
|
while j < len(lines) and lines[j].strip().startswith("|"):
|
|
rows.append(lines[j].strip())
|
|
j += 1
|
|
tbl = _parse_table(rows)
|
|
if tbl:
|
|
out.append(tbl)
|
|
i = j
|
|
else:
|
|
# keine gueltige Tabelle -> als normaler Absatz
|
|
out.append("<p>%s</p>" % inline(_escape(stripped)))
|
|
i += 1
|
|
continue
|
|
|
|
m = re.match(r"^([-*+])\s+(.*)$", stripped)
|
|
if m:
|
|
if not in_list or list_tag != "ul":
|
|
close_list()
|
|
out.append("<ul>")
|
|
in_list, list_tag = True, "ul"
|
|
out.append("<li>%s</li>" % inline(_escape(m.group(2))))
|
|
i += 1
|
|
continue
|
|
|
|
m = re.match(r"^\d+\.\s+(.*)$", stripped)
|
|
if m:
|
|
if not in_list or list_tag != "ol":
|
|
close_list()
|
|
out.append("<ol>")
|
|
in_list, list_tag = True, "ol"
|
|
out.append("<li>%s</li>" % inline(_escape(m.group(1))))
|
|
i += 1
|
|
continue
|
|
|
|
if stripped.startswith(">"):
|
|
close_list()
|
|
quote = [stripped.lstrip("> ")]
|
|
while i + 1 < len(lines) and lines[i + 1].strip().startswith(">"):
|
|
i += 1
|
|
quote.append(lines[i].strip().lstrip("> "))
|
|
out.append("<blockquote><p>%s</p></blockquote>" % inline(_escape(" ".join(quote))))
|
|
i += 1
|
|
continue
|
|
|
|
close_list()
|
|
para = [stripped]
|
|
while (i + 1 < len(lines) and lines[i + 1].strip()
|
|
and not re.match(r"^(#{1,6}\s|[-*+]\s|\d+\.\s|>|```|-{3,}$|<|\|)",
|
|
lines[i + 1].strip())):
|
|
i += 1
|
|
para.append(lines[i].strip())
|
|
out.append("<p>%s</p>" % inline(_escape(" ".join(para))))
|
|
i += 1
|
|
|
|
close_list()
|
|
while sec_stack:
|
|
out.append("</div>")
|
|
sec_stack.pop()
|
|
return "\n".join(out)
|
|
|
|
|
|
def _escape(s):
|
|
return (s.replace("&", "&").replace("<", "<").replace(">", ">"))
|
|
|
|
|
|
def _parse_table(rows):
|
|
"""Baut aus |-getrennten Zeilen eine HTML-Tabelle.
|
|
Zeile 1: Kopfzeile, Zeile 2: Trenner (---, :---, ---:, :---:),
|
|
danach: Datenzeilen. Liefert None, wenn es keine gueltige Tabelle ist.
|
|
"""
|
|
def split_row(r):
|
|
if r.startswith("|"):
|
|
r = r[1:]
|
|
if r.endswith("|"):
|
|
r = r[:-1]
|
|
return [c.strip() for c in r.split("|")]
|
|
|
|
def is_sep(c):
|
|
return re.match(r"^:?-{2,}:?$", c) is not None
|
|
|
|
if len(rows) < 2 or not all(is_sep(c) and c for c in split_row(rows[1])):
|
|
return None
|
|
|
|
aligns = []
|
|
for c in split_row(rows[1]):
|
|
left, right = c.startswith(":"), c.endswith(":")
|
|
if left and right:
|
|
aligns.append("center")
|
|
elif right:
|
|
aligns.append("right")
|
|
else:
|
|
aligns.append("left")
|
|
|
|
def cell(tag, j, text):
|
|
style = ' style="text-align: %s"' % aligns[j] if j < len(aligns) else ""
|
|
return "<%s%s>%s</%s>" % (tag, style, inline(text), tag)
|
|
|
|
out = ["<table>", "<thead><tr>"]
|
|
for j, c in enumerate(split_row(rows[0])):
|
|
out.append(cell("th", j, _escape(c)))
|
|
out.append("</tr></thead>")
|
|
if len(rows) > 2:
|
|
out.append("<tbody>")
|
|
for r in rows[2:]:
|
|
out.append("<tr>")
|
|
for j, c in enumerate(split_row(r)):
|
|
out.append(cell("td", j, _escape(c)))
|
|
out.append("</tr>")
|
|
out.append("</tbody>")
|
|
out.append("</table>")
|
|
return "".join(out)
|
|
|
|
|
|
def _slugify(s):
|
|
"""Ueberschriftentext -> HTML-id (ankertauglich, klein, ohne Sonderzeichen)."""
|
|
s = s.lower()
|
|
for k, v in (("ä", "ae"), ("ö", "oe"), ("ü", "ue"), ("ß", "ss")):
|
|
s = s.replace(k, v)
|
|
s = re.sub(r"[^a-z0-9]+", "-", s).strip("-")
|
|
return s or "abschnitt"
|
|
|
|
|
|
def heading_nav(headings, prefix=""):
|
|
"""Baut die Anker-Navigation als verschachtelte ul/li-Liste:
|
|
Eine Ueberschrift mit einem # mehr als die vorherige wird als
|
|
Unterpunkt eingerueckt. prefix erlaubt Links auf eine andere Seite
|
|
(z.B. "index.html" -> href="index.html#anker").
|
|
headings: Liste von (level, anker, text).
|
|
"""
|
|
if not headings:
|
|
return ""
|
|
parts = []
|
|
levels = []
|
|
for level, hid, text in headings:
|
|
if not levels:
|
|
# erste Ueberschrift: aeusserste Liste oeffnen
|
|
parts.append("<ul>")
|
|
levels.append(level)
|
|
elif level > levels[-1]:
|
|
# tiefer -> neue verschachtelte Liste im letzten <li>
|
|
parts.append("<ul>")
|
|
levels.append(level)
|
|
else:
|
|
# gleiche oder hoehere Ebene -> Listen schliessen bis Ebene passt
|
|
while len(levels) > 1 and levels[-1] > level:
|
|
parts.append("</li></ul>")
|
|
levels.pop()
|
|
parts.append("</li>")
|
|
parts.append('<li><a href="%s#%s">%s</a>' % (prefix, hid, _escape(text)))
|
|
parts.append("</li>")
|
|
while len(levels) > 1:
|
|
parts.append("</ul></li>")
|
|
levels.pop()
|
|
parts.append("</ul>")
|
|
return "".join(parts)
|
|
|
|
|
|
# ------------------------------------------------------------------- seiten
|
|
|
|
def parse_md(raw):
|
|
"""Trennt Front-Matter (titel: ...) vom Inhalt."""
|
|
meta = {}
|
|
body = raw
|
|
if raw.startswith("---"):
|
|
parts = raw.split("---", 2)
|
|
if len(parts) >= 3:
|
|
for line in parts[1].strip().splitlines():
|
|
if ":" in line:
|
|
k, v = line.split(":", 1)
|
|
meta[k.strip().lower()] = v.strip()
|
|
body = parts[2].lstrip("\n")
|
|
return meta, body
|
|
|
|
|
|
def md_path(slug):
|
|
return os.path.join(MD_DIR, slug + ".md")
|
|
|
|
|
|
def list_pages():
|
|
pages = []
|
|
for f in sorted(os.listdir(MD_DIR)):
|
|
if f.endswith(".md") and f[:-3] not in (HEADER_PAGE, FOOTER_PAGE):
|
|
pages.append(f[:-3])
|
|
return pages
|
|
|
|
|
|
def load_page(slug):
|
|
with open(md_path(slug), encoding="utf-8") as fh:
|
|
return fh.read()
|
|
|
|
|
|
def save_page(slug, raw):
|
|
with open(md_path(slug), "w", encoding="utf-8") as fh:
|
|
fh.write(raw)
|
|
|
|
|
|
def delete_page(slug):
|
|
p = md_path(slug)
|
|
if os.path.exists(p):
|
|
os.remove(p)
|
|
|
|
|
|
# ------------------------------------------------------------------ export
|
|
|
|
def block_html(slug):
|
|
"""Rendert einen Baustein (header/footer) als HTML, leer wenn nicht vorhanden."""
|
|
if os.path.exists(md_path(slug)):
|
|
_, body = parse_md(load_page(slug))
|
|
return md_to_html(body)
|
|
return ""
|
|
|
|
|
|
def render_page(raw, template, header_html="", footer_html="", start_anker_html=""):
|
|
meta, body = parse_md(raw)
|
|
headings = []
|
|
html = md_to_html(body, headings)
|
|
anker_html = heading_nav(headings)
|
|
page = (template
|
|
.replace("{{titel}}", _escape(meta.get("titel", "")))
|
|
.replace("{{beschreibung}}", _escape(meta.get("beschreibung", "")))
|
|
.replace("{{inhalt}}", html))
|
|
# {{anker-start}}: Navigation der Startseite, verlinkt auf index.html#anker
|
|
if "{{anker-start}}" in template:
|
|
page = page.replace("{{anker-start}}", start_anker_html)
|
|
if "{{anker}}" in template:
|
|
page = page.replace("{{anker}}", anker_html)
|
|
elif (anker_html and "{{anker-start}}" not in template
|
|
and "{{header}}" in template):
|
|
# Template ganz ohne Anker-Platzhalter: eigene Anker ans Header-Ende
|
|
page = page.replace("{{header}}",
|
|
header_html + '\n<nav class="anker-nav">' + anker_html + "</nav>")
|
|
if "{{header}}" in template:
|
|
page = page.replace("{{header}}", header_html)
|
|
elif header_html and "<body>" in page:
|
|
# Template ohne {{header}}-Platzhalter: Baustein automatisch setzen
|
|
idx = page.index("<body>") + len("<body>")
|
|
page = page[:idx] + "\n<header>\n" + header_html + "\n</header>\n" + page[idx:]
|
|
if "{{footer}}" in template:
|
|
page = page.replace("{{footer}}", footer_html)
|
|
elif footer_html and "</body>" in page:
|
|
# Template ohne {{footer}}-Platzhalter: Baustein automatisch anhaengen
|
|
idx = page.rindex("</body>")
|
|
page = page[:idx] + "<footer>\n" + footer_html + "\n</footer>\n" + page[idx:]
|
|
return page, meta.get("titel", "")
|
|
|
|
|
|
def load_template(slug=None):
|
|
"""Template fuer eine Seite: templates/<slug>.html wenn vorhanden,
|
|
sonst default.html, sonst das erste gefundene Template."""
|
|
candidates = []
|
|
if slug:
|
|
candidates.append(os.path.join(TPL_DIR, slug + ".html"))
|
|
candidates.append(os.path.join(TPL_DIR, "default.html"))
|
|
for c in candidates:
|
|
if os.path.exists(c):
|
|
with open(c, encoding="utf-8") as fh:
|
|
return fh.read()
|
|
files = [f for f in os.listdir(TPL_DIR) if f.endswith(".html")]
|
|
if not files:
|
|
raise SystemExit("Kein Template in templates/ gefunden (z.B. default.html).")
|
|
with open(os.path.join(TPL_DIR, files[0]), encoding="utf-8") as fh:
|
|
return fh.read()
|
|
|
|
|
|
def export_site():
|
|
"""Baut output/: pro MD-Datei eine HTML-Seite, CSS wird kopiert."""
|
|
# Output leeren und neu aufbauen
|
|
if os.path.isdir(OUT_DIR):
|
|
shutil.rmtree(OUT_DIR)
|
|
os.makedirs(os.path.join(OUT_DIR, "css"), exist_ok=True)
|
|
|
|
for f in os.listdir(CSS_DIR):
|
|
if f.endswith(".css"):
|
|
shutil.copy2(os.path.join(CSS_DIR, f), os.path.join(OUT_DIR, "css", f))
|
|
|
|
# Bilder (z.B. Logo/Favicon) nach output/images/ kopieren
|
|
img_src = os.path.join(ROOT, "images")
|
|
if os.path.isdir(img_src):
|
|
shutil.copytree(img_src, os.path.join(OUT_DIR, "images"), dirs_exist_ok=True)
|
|
|
|
footer_html = block_html(FOOTER_PAGE)
|
|
header_html = block_html(HEADER_PAGE)
|
|
|
|
# Anker-Navigation der Startseite (fuer Templates mit {{anker-start}},
|
|
# z.B. impressum: Links auf index.html#anker)
|
|
start_headings = []
|
|
if os.path.exists(md_path(START_PAGE)):
|
|
_, s_body = parse_md(load_page(START_PAGE))
|
|
md_to_html(s_body, start_headings)
|
|
start_anker = heading_nav(start_headings, prefix="index.html")
|
|
|
|
exported = []
|
|
for slug in list_pages():
|
|
template = load_template(slug)
|
|
page, _ = render_page(load_page(slug), template, header_html, footer_html,
|
|
start_anker)
|
|
# startseite.md wird zur index.html
|
|
out_name = "index.html" if slug == START_PAGE else slug + ".html"
|
|
with open(os.path.join(OUT_DIR, out_name), "w", encoding="utf-8") as fh:
|
|
fh.write(page)
|
|
exported.append(out_name)
|
|
return exported
|
|
|
|
|
|
# ------------------------------------------------------------------- server
|
|
|
|
class Handler(BaseHTTPRequestHandler):
|
|
def log_message(self, *args):
|
|
pass
|
|
|
|
def _send(self, code, body, ctype="application/json; charset=utf-8"):
|
|
data = body.encode("utf-8") if isinstance(body, str) else body
|
|
self.send_response(code)
|
|
self.send_header("Content-Type", ctype)
|
|
self.send_header("Content-Length", str(len(data)))
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
|
|
def _json(self, obj, code=200):
|
|
self._send(code, json.dumps(obj))
|
|
|
|
def _body(self):
|
|
n = int(self.headers.get("Content-Length", 0))
|
|
return json.loads(self.rfile.read(n).decode("utf-8")) if n else {}
|
|
|
|
def do_GET(self):
|
|
path = urlparse(self.path).path
|
|
|
|
if path in ("/", "/admin"):
|
|
self._send(200, ADMIN_HTML, "text/html; charset=utf-8")
|
|
elif path == "/api/pages":
|
|
self._json({"pages": list_pages(), "start": START_PAGE,
|
|
"header": os.path.exists(md_path(HEADER_PAGE)),
|
|
"footer": os.path.exists(md_path(FOOTER_PAGE))})
|
|
elif path.startswith("/api/page/"):
|
|
slug = unquote(path[len("/api/page/"):])
|
|
if slug in (HEADER_PAGE, FOOTER_PAGE) or slug in list_pages():
|
|
self._json({"slug": slug, "raw": load_page(slug)})
|
|
else:
|
|
self._json({"error": "Seite nicht gefunden"}, 404)
|
|
elif path == "/api/images":
|
|
img_dir = os.path.join(ROOT, "images")
|
|
files = []
|
|
if os.path.isdir(img_dir):
|
|
for f in sorted(os.listdir(img_dir)):
|
|
if os.path.isfile(os.path.join(img_dir, f)) and not f.startswith("."):
|
|
files.append(f)
|
|
self._json({"images": files})
|
|
elif path == "/api/export":
|
|
self._json({"exported": export_site()})
|
|
else:
|
|
self._json({"error": "unbekannter Pfad"}, 404)
|
|
|
|
def do_POST(self):
|
|
path = urlparse(self.path).path
|
|
try:
|
|
data = self._body()
|
|
except (ValueError, json.JSONDecodeError):
|
|
return self._json({"error": "ungueltige Anfrage"}, 400)
|
|
|
|
if path == "/api/page":
|
|
slug = (data.get("slug") or "").strip()
|
|
raw = data.get("raw") or ""
|
|
if not SLUG_RE.match(slug):
|
|
return self._json({"error": "Ungueltiger Name (a-z, 0-9, -)."}, 400)
|
|
save_page(slug, raw)
|
|
self._json({"ok": True, "slug": slug})
|
|
elif path == "/api/delete":
|
|
slug = data.get("slug", "")
|
|
if slug not in (HEADER_PAGE, FOOTER_PAGE) and slug not in list_pages():
|
|
return self._json({"error": "Seite nicht gefunden"}, 404)
|
|
if slug in (START_PAGE, HEADER_PAGE, FOOTER_PAGE):
|
|
return self._json({"error": "Startseite und Bausteine koennen nicht geloescht werden."}, 400)
|
|
delete_page(slug)
|
|
self._json({"ok": True})
|
|
elif path == "/api/preview":
|
|
meta, body = parse_md(data.get("raw") or "")
|
|
self._json({"html": md_to_html(body)})
|
|
else:
|
|
self._json({"error": "unbekannter Pfad"}, 404)
|
|
|
|
|
|
ADMIN_HTML = """<!DOCTYPE html>
|
|
<html lang="de">
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<title>Mini-CMS</title>
|
|
<style>
|
|
body { font-family: -apple-system, "Segoe UI", sans-serif; margin: 0; display: flex; height: 100vh; }
|
|
#side { width: 220px; background: #f2f2f2; padding: 1rem; box-sizing: border-box; }
|
|
#side h1 { font-size: 1rem; }
|
|
#pages a { display: block; padding: .35rem .5rem; border-radius: 4px; cursor: pointer; text-decoration: none; color: #000; }
|
|
#pages a.active, #pages a:hover { background: #ddd; }
|
|
#main { flex: 1; display: flex; flex-direction: column; padding: 1rem; box-sizing: border-box; gap: .5rem; position: relative; }
|
|
#imgdrop { position: absolute; top: 3.2rem; left: 1rem; background: #fff; border: 1px solid #999; border-radius: 4px; box-shadow: 0 2px 10px rgba(0,0,0,.25); max-height: 220px; overflow: auto; z-index: 20; min-width: 240px; }
|
|
#imgdrop .imgdrop-title { font-size: .8rem; padding: .4rem .6rem; background: #eee; }
|
|
#imglist a { display: block; padding: .35rem .6rem; cursor: pointer; color: #000; }
|
|
#imglist a:hover { background: #dde8ff; }
|
|
#toolbar { display: flex; gap: .5rem; align-items: center; }
|
|
button { padding: .45rem .9rem; border: 1px solid #999; border-radius: 4px; background: #fff; cursor: pointer; }
|
|
button.primary { background: #0066cc; color: #fff; border-color: #0066cc; }
|
|
input[type=text] { padding: .45rem; border: 1px solid #999; border-radius: 4px; }
|
|
#editor { flex: 1; width: 100%; font-family: monospace; font-size: .9rem; padding: .5rem; box-sizing: border-box; border: 1px solid #ccc; border-radius: 4px; resize: none; }
|
|
#preview { flex: 1; overflow: auto; border: 1px solid #ccc; border-radius: 4px; padding: 1rem; display: none; }
|
|
#msg { min-height: 1.2rem; font-size: .85rem; color: #060; }
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div id="side">
|
|
<h1>Seiten</h1>
|
|
<div id="pages"></div>
|
|
<hr>
|
|
<p style="font-size:.8rem">Neue Seite:</p>
|
|
<input type="text" id="newslug" placeholder="z.B. ueber-uns" style="width:100%;box-sizing:border-box;padding:.35rem">
|
|
<button id="btn-new" style="width:100%;margin-top:.4rem">Neu</button>
|
|
</div>
|
|
<div id="main">
|
|
<div id="toolbar">
|
|
<b id="current">-</b>
|
|
<button id="btn-save" class="primary">Speichern</button>
|
|
<button id="btn-preview">Vorschau</button>
|
|
<button id="btn-export" class="primary">Nach output/ exportieren</button>
|
|
<button id="btn-delete" style="margin-left:auto">Seite löschen</button>
|
|
</div>
|
|
<div id="msg"></div>
|
|
<div id="imgdrop" style="display:none">
|
|
<div class="imgdrop-title">Bild aus images/ einfügen:</div>
|
|
<div id="imglist"></div>
|
|
</div>
|
|
<textarea id="editor" spellcheck="false">---
|
|
titel: Neue Seite
|
|
beschreibung: Kurze Seitenbeschreibung fuer Suchmaschinen (SEO).
|
|
---
|
|
|
|
Hier den Inhalt schreiben. **fett**, *kursiv*, [Link](seite.html), # Ueberschrift, - Liste.
|
|
Das Wort "image" tippen, um ein Bild aus dem images-Ordner einzufuegen.</textarea>
|
|
<div id="preview"></div>
|
|
</div>
|
|
<script>
|
|
let pages = [], current = null;
|
|
|
|
const $ = id => document.getElementById(id);
|
|
const msg = t => { $("msg").textContent = t; setTimeout(() => $("msg").textContent = "", 4000); };
|
|
async function api(path, opts) {
|
|
const r = await fetch(path, opts);
|
|
return r.json();
|
|
}
|
|
|
|
async function loadPages() {
|
|
const d = await api("/api/pages");
|
|
pages = d.pages;
|
|
$("pages").innerHTML = "";
|
|
for (const p of pages) {
|
|
const a = document.createElement("a");
|
|
a.textContent = p + (p === d.start ? " (Start)" : "");
|
|
a.onclick = () => openPage(p);
|
|
if (p === current) a.className = "active";
|
|
$("pages").appendChild(a);
|
|
}
|
|
for (const b of [["header", d.header], ["footer", d.footer]]) {
|
|
if (b[1]) {
|
|
const a = document.createElement("a");
|
|
a.textContent = b[0] + " (Baustein)";
|
|
a.onclick = () => openPage(b[0]);
|
|
if (current === b[0]) a.className = "active";
|
|
$("pages").appendChild(a);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function openPage(slug) {
|
|
const d = await api("/api/page/" + encodeURIComponent(slug));
|
|
current = slug;
|
|
$("current").textContent = slug;
|
|
$("editor").value = d.raw;
|
|
$("editor").disabled = false;
|
|
loadPages();
|
|
}
|
|
|
|
async function save() {
|
|
if (!current) return;
|
|
const d = await api("/api/page", {
|
|
method: "POST", headers: {"Content-Type": "application/json"},
|
|
body: JSON.stringify({slug: current, raw: $("editor").value})
|
|
});
|
|
msg(d.ok ? "Gespeichert." : ("Fehler: " + d.error));
|
|
if (d.ok) loadPages();
|
|
}
|
|
|
|
$("btn-save").onclick = save;
|
|
$("btn-delete").onclick = async () => {
|
|
if (!confirm("Seite '" + current + "' loeschen?")) return;
|
|
const d = await api("/api/delete", {
|
|
method: "POST", headers: {"Content-Type": "application/json"},
|
|
body: JSON.stringify({slug: current})
|
|
});
|
|
msg(d.ok ? "Geloescht." : ("Fehler: " + d.error));
|
|
current = null; $("current").textContent = "-"; $("editor").disabled = true;
|
|
loadPages();
|
|
};
|
|
$("btn-new").onclick = async () => {
|
|
const slug = $("newslug").value.trim().toLowerCase();
|
|
if (!slug) return msg("Bitte Namen eingeben.");
|
|
const d = await api("/api/page", {
|
|
method: "POST", headers: {"Content-Type": "application/json"},
|
|
body: JSON.stringify({slug, raw: "---\\ntitel: " + slug + "\\nbeschreibung: \\n---\\n\\nNeue Seite.\\n"})
|
|
});
|
|
if (d.ok) { $("newslug").value = ""; openPage(slug); }
|
|
else msg("Fehler: " + d.error);
|
|
};
|
|
$("btn-preview").onclick = async () => {
|
|
const ed = $("editor"), pv = $("preview");
|
|
if (pv.style.display === "block") {
|
|
pv.style.display = "none"; ed.style.display = "block"; return;
|
|
}
|
|
const d = await api("/api/preview", {
|
|
method: "POST", headers: {"Content-Type": "application/json"},
|
|
body: JSON.stringify({raw: ed.value})
|
|
});
|
|
pv.innerHTML = d.html; pv.style.display = "block"; ed.style.display = "none";
|
|
};
|
|
$("btn-export").onclick = async () => {
|
|
const d = await api("/api/export");
|
|
msg(d.exported ? "Exportiert: " + d.exported.join(", ") : ("Fehler: " + d.error));
|
|
};
|
|
|
|
// ---- Bild einfuegen: "image" tippen -> Dropdown mit Dateien aus images/ ----
|
|
let dropGen = 0;
|
|
let lastCaret = 0;
|
|
|
|
function hideImageDrop() {
|
|
dropGen++;
|
|
$("imgdrop").style.display = "none";
|
|
}
|
|
|
|
async function showImageDrop(caret) {
|
|
const gen = ++dropGen;
|
|
lastCaret = caret;
|
|
const d = await api("/api/images");
|
|
if (gen !== dropGen) return; // inzwischen wieder geschlossen
|
|
const list = $("imglist");
|
|
list.innerHTML = "";
|
|
if (!d.images.length) {
|
|
const p = document.createElement("div");
|
|
p.style.padding = ".4rem .6rem";
|
|
p.textContent = "Keine Dateien in images/.";
|
|
list.appendChild(p);
|
|
}
|
|
for (const f of d.images) {
|
|
const a = document.createElement("a");
|
|
a.textContent = f;
|
|
a.onmousedown = e => { e.preventDefault(); insertImage(f); };
|
|
list.appendChild(a);
|
|
}
|
|
$("imgdrop").style.display = "block";
|
|
}
|
|
|
|
function insertImage(name) {
|
|
const ed = $("editor");
|
|
let pos = lastCaret;
|
|
let before = ed.value.slice(0, pos), after = ed.value.slice(pos);
|
|
const md = "![" + name.replace(/\.[^.]+$/, "") + "](images/" + name + ")";
|
|
// das getippte Wort "image" durch die Bild-Syntax ersetzen
|
|
if (before.slice(-5).toLowerCase() === "image") before = before.slice(0, -5);
|
|
ed.value = before + md + after;
|
|
ed.focus();
|
|
ed.selectionStart = ed.selectionEnd = (before + md).length;
|
|
hideImageDrop();
|
|
}
|
|
|
|
$("editor").addEventListener("input", () => {
|
|
const ed = $("editor");
|
|
const pos = ed.selectionStart;
|
|
const tail = ed.value.slice(Math.max(0, pos - 5), pos).toLowerCase();
|
|
if (tail === "image") showImageDrop(pos);
|
|
else hideImageDrop();
|
|
});
|
|
$("editor").addEventListener("keydown", e => { if (e.key === "Escape") hideImageDrop(); });
|
|
|
|
loadPages();
|
|
</script>
|
|
</body>
|
|
</html>"""
|
|
|
|
|
|
def main():
|
|
global PORT
|
|
if len(sys.argv) > 1 and sys.argv[1] == "export":
|
|
files = export_site()
|
|
print("Exportiert nach output/:")
|
|
for f in files:
|
|
print(" -", f)
|
|
return
|
|
|
|
if len(sys.argv) > 2 and sys.argv[1] == "port":
|
|
PORT = int(sys.argv[2])
|
|
|
|
server = ThreadingHTTPServer(("127.0.0.1", PORT), Handler)
|
|
url = "http://localhost:%d" % PORT
|
|
print("Mini-CMS laeuft unter", url)
|
|
print("Beenden mit Strg+C.")
|
|
threading.Timer(1.0, lambda: webbrowser.open(url)).start()
|
|
try:
|
|
server.serve_forever()
|
|
except KeyboardInterrupt:
|
|
print("\nServer gestoppt.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|