120 lines
4.3 KiB
Python
120 lines
4.3 KiB
Python
import logging
|
|
from contextlib import asynccontextmanager
|
|
|
|
from fastapi import FastAPI, Header, HTTPException, Query
|
|
from fastapi.responses import Response
|
|
from pydantic import BaseModel
|
|
|
|
from . import db, files
|
|
from .config import BASE_COLLECTIONS, COLLECTIONS, SYNC_TOKEN
|
|
|
|
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
|
|
log = logging.getLogger("app")
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(_app):
|
|
if not SYNC_TOKEN:
|
|
log.warning("SYNC_TOKEN ist leer, jede Anfrage wird abgelehnt.")
|
|
db.init()
|
|
with db.connect(write=True) as conn:
|
|
moved = files.migrate(conn)
|
|
if moved:
|
|
log.info("%d Dateien aus der Datenbank nach %s verschoben", moved, files.FILES_DIR)
|
|
yield
|
|
|
|
|
|
app = FastAPI(title="Desktop Sync", lifespan=lifespan)
|
|
|
|
|
|
def check_token(authorization: str):
|
|
if not SYNC_TOKEN or authorization != f"Bearer {SYNC_TOKEN}":
|
|
raise HTTPException(status_code=401, detail="Token fehlt oder ist falsch")
|
|
|
|
|
|
class SyncIn(BaseModel):
|
|
since: int = 0
|
|
events: list[dict] | None = None
|
|
todos: list[dict] | None = None
|
|
notes: list[dict] | None = None
|
|
folders: list[dict] | None = None
|
|
files: list[dict] | None = None
|
|
|
|
# Zurück kommen die Sammlungen der Anfrage. Ohne Sammlungen die vier Basis-Sammlungen,
|
|
# Dateien nur auf ausdrückliche Anfrage, sonst zieht das Handy Sitzungen mit.
|
|
@property
|
|
def requested(self):
|
|
named = [c for c in COLLECTIONS if getattr(self, c) is not None]
|
|
return named or list(BASE_COLLECTIONS)
|
|
|
|
|
|
@app.get("/api/health")
|
|
def health():
|
|
return {"ok": True}
|
|
|
|
|
|
@app.post("/api/sync")
|
|
def sync(body: SyncIn, authorization: str = Header(default="")):
|
|
"""Nimmt Änderungen des Clients an und gibt alles zurück, was sich seit seinem Stand geändert hat.
|
|
|
|
Konflikte: der Eintrag mit dem neueren updated gewinnt. Verliert der Client, bekommt er den
|
|
Server-Stand zurück. Die Antwort enthält auch die gerade angenommenen Einträge; der Client
|
|
erkennt sie am gleichen updated und überspringt sie.
|
|
"""
|
|
check_token(authorization)
|
|
with db.connect(write=True) as conn:
|
|
accepted = 0
|
|
rejected = {collection: [] for collection in COLLECTIONS}
|
|
for collection in COLLECTIONS:
|
|
merge = files.merge if collection == "files" else lambda c, item: db.merge(c, collection, item)
|
|
for item in getattr(body, collection) or []:
|
|
ok, stored = merge(conn, item)
|
|
if ok:
|
|
accepted += 1
|
|
elif stored:
|
|
rejected[collection].append(stored)
|
|
out = {}
|
|
for collection in body.requested:
|
|
changed = db.since(conn, collection, body.since)
|
|
ids = {item["id"] for item in changed}
|
|
out[collection] = changed + [item for item in rejected[collection] if item["id"] not in ids]
|
|
out["cursor"] = db.cursor(conn)
|
|
if accepted:
|
|
log.info("sync: %d Einträge übernommen", accepted)
|
|
return out
|
|
|
|
|
|
# Lesezugriff für andere Anwendungen
|
|
@app.get("/api/events")
|
|
def events(authorization: str = Header(default="")):
|
|
check_token(authorization)
|
|
with db.connect() as conn:
|
|
return db.alive(conn, "events")
|
|
|
|
|
|
@app.get("/api/todos")
|
|
def todos(authorization: str = Header(default="")):
|
|
check_token(authorization)
|
|
with db.connect() as conn:
|
|
return db.alive(conn, "todos")
|
|
|
|
|
|
@app.get("/api/notes")
|
|
def notes(authorization: str = Header(default="")):
|
|
check_token(authorization)
|
|
with db.connect() as conn:
|
|
return db.alive(conn, "notes")
|
|
|
|
|
|
# Inhalt einer Datei. Mit from und hash (Länge und Hash der letzten 64 KB des eigenen Stands)
|
|
# kommt nur der Rest ab dieser Position, sonst die ganze Datei. X-From sagt, ab wo.
|
|
@app.get("/api/files/{file_id:path}")
|
|
def file_content(file_id: str, from_: int = Query(0, alias="from"), hash: str = "", authorization: str = Header(default="")):
|
|
check_token(authorization)
|
|
with db.connect() as conn:
|
|
meta = files.meta(conn, file_id)
|
|
if not meta or meta.get("deleted"):
|
|
raise HTTPException(status_code=404, detail="Datei unbekannt")
|
|
data, start = files.read_from(file_id, from_, hash)
|
|
return Response(content=data, media_type="application/octet-stream", headers={"X-From": str(start), "X-Size": str(start + len(data))})
|