Add page editing and publish

This commit is contained in:
Alexey Dudin
2026-11-09 15:45:11 +03:00
parent ecad6f183c
commit 53980a5558
25 changed files with 2402 additions and 33 deletions
+34 -5
View File
@@ -26,7 +26,7 @@ site-engine/
├── docs/ # ТЗ, ревью, журнал решений
├── examples/studio-site/ # сайт-пример из SiteMap.md (услуги, формы, коллекция, редирект)
├── .env.example # переменные окружения для админки
├── tests/ # 112 тестов: ядро, сборка, безопасность, запись, вход в админку
├── tests/ # 178 тестов: ядро, сборка, безопасность, запись, вход и редактор
└── src/site_engine/
├── cli.py # validate · build · preview · fragments
├── errors.py # Issue/Report: код, путь к полю, серьёзность, подсказка
@@ -37,6 +37,8 @@ site-engine/
│ ├── routes.py # нормализация маршрутов, таблица, коллизии
│ ├── resolve.py # привязки, ссылки, запросы MVP
│ ├── validate.py # workspace-проверки, release-проверки, правила сайта
│ ├── draft_check.py # проверка при сохранении: новый текст файла против реестра
│ ├── page_ops.py # добавить, переместить, удалить блок по id в сыром front matter
│ └── render.py # Jinja SandboxedEnvironment, разрешение props по схеме
├── build/pipeline.py # load → validate → render → релиз → атомарный current
├── parsing/ # безопасный YAML, front matter, Markdown (raw HTML выключен)
@@ -44,7 +46,7 @@ site-engine/
├── services/ # auth (вход админа), ContentService (if_match, история), publish; stubs: changeset, forms
├── builtin/ # base.css и 15 фрагментов ядра (ADR-006)
├── db/ # SQLAlchemy-модели служебных таблиц (M2)
├── web/ # FastAPI-фабрика; admin/: handlers (вход, выход, обзор), шаблоны, routes-адаптер
├── web/ # FastAPI-фабрика; admin/: handlers (вход, обзор), editor (страницы, блоки, записи, публикация), forms, шаблоны, routes-адаптер
└── mcp/ # перечень инструментов MVP (M3)
```
@@ -79,6 +81,33 @@ SITE_COOKIE_SECURE=0 uvicorn site_engine.web.app:create_app --factory --env-file
- Выход завершает все сессии администратора сразу, отдельного списка устройств нет.
- Отдельная смена пароля: сгенерировать новый хеш и перезапустить сервис; чтобы разлогинить всех, поменяйте `SITE_SECRET_KEY`.
## Редактор
После входа в `/admin/` доступны страницы, контент и публикация. Все правки идут через `ContentService`: блокировка сайта, `if_match` по хешу файла, проверка синтаксиса, история в `.engine/history/`, атомарная запись. Редактор пишет только в `pages/` и `content/`; фрагменты, layouts, схемы и `site.yaml` через него изменить нельзя.
| Экран | Что умеет |
|---|---|
| Страницы | Список со статусами и адресами; создание черновика (путь, заголовок, layout) |
| Страница | Заголовок, статус, layout, адрес, описание, текст Markdown; блоки по регионам и слотам: добавить, ↑/↓, скрыть и показать, удалить; предпросмотр в изолированном фрейме; список проблем страницы |
| Блок | Форма строится из манифеста фрагмента: текст, Markdown, число, список, группа, выбор, ссылка (страница, запись, адрес), запрос к коллекции, ассет; у каждого поля поле «привязка» (`entry.title`, `page.body`…); якорь, заметка, скрыть, `requires` по флагам сайта |
| Контент | Записи коллекций: поля по схеме, статус, текст Markdown, создание черновика, предпросмотр |
| Публикация | Сборка релиза, список релизов, возврат к прежнему релизу |
Гарантии, которые проверены тестами:
- **Без потерь.** Форма открывается из файла и отправляется обратно без изменений: у каждого блока примера, всех страниц и записей YAML остаётся тем же по смыслу. Неизвестные ключи не пропадают, привязки сохраняются.
- **Конфликты.** Если файл изменили в другом окне, правка получит 409, а чужие изменения не будут перезаписаны.
- **Проверка при сохранении.** Нельзя сохранить неизвестный фрагмент, несуществующий layout, блок в закреплённый регион, значение не того типа, `{{ }}` в данных, привязку к чужому корню. Пропуск обязательного поля не блокирует сохранение (ADR-003), но он виден в «Проверке страницы», и сборка релиза с ним не пройдёт; опубликованный сайт при этом не меняется.
- **Безопасность.** Каждый POST требует CSRF-токен и Origin своего хоста; id страниц, блоков и записей проверяются регулярным выражением и поиском в реестре, до пути на диске недоступны; предпросмотр отдаётся в `sandbox`-фрейме с CSP без скриптов; в аудит попадают id и тип действия, но не содержимое.
Что работает иначе, чем можно ожидать:
- **Без JS.** Порядок блоков меняется кнопками ↑/↓, элементы списков добавляются через «пустую строку» формы. Скачать htmx и SortableJS в окружении без сети было нельзя, поэтому редактор целиком работает на обычных формах. Если положить `htmx.min.js` в `src/site_engine/web/admin/static/`, админка включит `hx-boost` сама (проверено только разметкой, с настоящим htmx не запускалось).
- **Первая правка файла переформатирует его YAML** в блочный стиль: `{id: b_1, fragment: hero}` станет несколькими строками. Смысл и порядок ключей сохраняются.
- **Ассеты** выбираются по пути из подсказки, загрузки файлов в редакторе пока нет.
- **Блоки не переносятся между регионами**, только внутри своего списка.
- **Запись коллекции со «лишним» ключом**, которого нет в схеме, нельзя сохранить в статусе `published`, пока ключ не уберут из файла: так требует ADR-003.
## Что реализовано
| Этап | Состояние |
@@ -86,12 +115,12 @@ SITE_COOKIE_SECURE=0 uvicorn site_engine.web.app:create_app --factory --env-file
| M0 Контракт и прототип | Готово: формат файлов, модель блоков, load → validate → render, CLI, 15 фрагментов, сайт-пример |
| M1 Публикуемый движок | Частично: маршруты, ссылки, редиректы, sitemap, атомарная публикация, откат (`services/publish.py`), превью страницы через CLI. Нет: превью по токену, 404-страница из коробки, тема |
| M2 Коллекции, заявки, доступ | Частично: коллекции, display templates, запросы, формы (разметка, версия формы в релизе), **вход одного администратора с аудитом входов и обзорная страница админки**. Нет: роли, приём заявок, outbox, аудит правок |
| M3 MCP и редактор | `ContentService` с `if_match`, блокировкой и историей готов; нет редактора страниц, `patch_page`, changeset, MCP-сервера |
| M3 MCP и редактор | Готово: редактор страниц, блоков и записей на `ContentService`, предпросмотр, публикация и откат из админки. Нет: `patch_page`, changeset (rename, delete), MCP-сервера, перетаскивания, загрузки файлов |
| M4 | Не начат |
## Что проверено, а что нет
Тесты и сборка примера выполнялись в окружении без сети: ядро (`core/`, `build/`, `parsing/`, `storage/`, `services/`) и вся логика админки (`web/admin/handlers.py`, шаблоны, вход, CSRF, заголовки) запущены и покрыты 112 тестами. Тонкий FastAPI-адаптер `web/admin/routes.py` проверен на подставном модуле `fastapi`, а `web/app.py`, `db/`, `mcp/` и `Dockerfile` только компиляцией и чтением: FastAPI, SQLAlchemy и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp).
Тесты и сборка примера выполнялись в окружении без сети: ядро (`core/`, `build/`, `parsing/`, `storage/`, `services/`) и вся логика админки (`web/admin/handlers.py`, `editor.py`, `forms.py`, шаблоны, вход, CSRF, заголовки) запущены и покрыты 178 тестами, включая сквозные через HTML-формы. Тонкий FastAPI-адаптер `web/admin/routes.py` проверен на подставном модуле `fastapi`, а `web/app.py`, `db/`, `mcp/` и `Dockerfile` только компиляцией и чтением: FastAPI, SQLAlchemy и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp).
## Соответствие журналу решений
@@ -115,4 +144,4 @@ SITE_COOKIE_SECURE=0 uvicorn site_engine.web.app:create_app --factory --env-file
- Поле `props` в шаблоне — объект `Props`: `props.items` читает поле «items», а не метод словаря.
- `layout.extends` проверяется на существование, наследование шаблонов делается обычным `{% extends 'layout/<id>' %}`.
- CSS и JS собираются в один бандл с хешем в имени; минификации и изоляции по страницам пока нет.
- Нет приёма заявок, редактора и MCP: сетевая поверхность записи включается только вместе с контуром «вход, роли, аудит, лимиты» (ADR-006). Вход уже есть, роли и аудит правок будут вместе с редактором.
- Нет приёма заявок и MCP: сетевая поверхность записи включается только вместе с контуром «вход, роли, аудит, лимиты» (ADR-006). Вход, аудит правок и редактор уже есть; роли и приём заявок остаются на M2.
+54
View File
@@ -0,0 +1,54 @@
"""Проверка при сохранении (ADR-003): синтаксис, известные фрагменты, типы указанных значений.
Работает с новым текстом файла и текущим реестром, на диск ничего не пишет. Обязательные поля
здесь не требуются: у черновика их может не быть, а полноту проверяет сборка релиза.
"""
from __future__ import annotations
from ..errors import Report
from ..parsing import frontmatter
from ..parsing.yamlio import YamlError
from .models import parse_entry, parse_page
from .registry import Registry
from .validate import _check_entry, check_regions, check_seo
def check_page_text(reg: Registry, page_id: str, rel: str, text: str) -> Report:
report = Report()
try:
meta, body = frontmatter.parse(text)
except YamlError as exc:
report.add("E_YAML", str(exc), rel)
return report
page = parse_page(meta, body, page_id, rel, report)
if page is None:
return report
layout_id = reg.effective_layout(page)
layout = reg.layouts.get(layout_id) if layout_id else None
if layout is None:
report.add("E_LAYOUT_MISSING", f"layout «{layout_id}» не найден", rel)
check_regions(page.regions, layout, rel, reg, report)
check_seo(page.seo, rel, report)
return report
def check_entry_text(reg: Registry, collection_id: str, slug: str, rel: str, text: str) -> Report:
report = Report()
coll = reg.collections.get(collection_id)
if coll is None:
report.add("E_ENTRY_COLLECTION", f"нет коллекции «{collection_id}»", rel)
return report
try:
meta, body = frontmatter.parse(text)
except YamlError as exc:
report.add("E_YAML", str(exc), rel)
return report
entry = parse_entry(meta, body, collection_id, slug, rel, report)
if entry is None:
return report
sub = Report()
_check_entry(reg, coll.fields, entry, sub, coll.display or coll.id)
for issue in sub.issues: # у черновика неизвестные поля — предупреждение, у опубликованной записи — ошибка
report.issues.append(issue)
return report
+142
View File
@@ -0,0 +1,142 @@
"""Операции над деревом блоков в «сыром» front matter (dict): добавить, переместить, удалить.
Работаем с исходной структурой, а не с dataclass-ами: так сохраняются неизвестные ключи и
порядок. Блоки адресуются по `id`, не по индексу (принцип 4 ТЗ, ADR-004).
"""
from __future__ import annotations
import secrets
import string
from typing import Iterator
_ALPHABET = string.ascii_lowercase + string.digits
def _blocks_of(container: dict) -> Iterator[dict]:
"""Блоки одного списка региона/слота вместе с вложенными."""
yield container
for slot in (container.get("slots") or {}).values():
if isinstance(slot, list):
for child in slot:
if isinstance(child, dict):
yield from _blocks_of(child)
def all_blocks(meta: dict) -> Iterator[dict]:
for items in (meta.get("regions") or {}).values():
if isinstance(items, list):
for block in items:
if isinstance(block, dict):
yield from _blocks_of(block)
def all_ids(meta: dict) -> set[str]:
return {b["id"] for b in all_blocks(meta) if isinstance(b.get("id"), str)}
def _sibling_lists(meta: dict) -> Iterator[list]:
def walk(items: list) -> Iterator[list]:
yield items
for block in items:
if isinstance(block, dict):
for slot in (block.get("slots") or {}).values():
if isinstance(slot, list):
yield from walk(slot)
for items in (meta.get("regions") or {}).values():
if isinstance(items, list):
yield from walk(items)
def find_block(meta: dict, block_id: str) -> tuple[list, int, dict] | None:
for siblings in _sibling_lists(meta):
for index, block in enumerate(siblings):
if isinstance(block, dict) and block.get("id") == block_id:
return siblings, index, block
return None
def new_block_id(meta: dict) -> str:
taken = all_ids(meta)
while True:
candidate = "b_" + "".join(secrets.choice(_ALPHABET) for _ in range(5))
if candidate not in taken:
return candidate
def add_block(meta: dict, fragment_id: str, *, region: str | None = None,
parent: str | None = None, slot: str | None = None) -> str:
"""Добавляет пустой блок в конец региона или слота родителя. Возвращает id нового блока."""
block = {"id": new_block_id(meta), "fragment": fragment_id}
if parent:
found = find_block(meta, parent)
if found is None or not slot:
raise KeyError(f"нет блока «{parent}» или не указан слот")
slots = found[2].setdefault("slots", {})
slots.setdefault(slot, []).append(block)
elif region:
regions = meta.setdefault("regions", {})
if not isinstance(regions.get(region), list):
regions[region] = []
regions[region].append(block)
else:
raise KeyError("нужен region или parent+slot")
return block["id"]
def move_block(meta: dict, block_id: str, direction: str) -> bool:
"""`up`/`down` в пределах своего списка. False, если двигаться некуда."""
found = find_block(meta, block_id)
if found is None:
raise KeyError(block_id)
siblings, index, _ = found
target = index - 1 if direction == "up" else index + 1
if direction not in ("up", "down") or not 0 <= target < len(siblings):
return False
siblings[index], siblings[target] = siblings[target], siblings[index]
return True
def delete_block(meta: dict, block_id: str) -> None:
found = find_block(meta, block_id)
if found is None:
raise KeyError(block_id)
siblings, index, _ = found
del siblings[index]
def set_hidden(meta: dict, block_id: str, hidden: bool) -> None:
found = find_block(meta, block_id)
if found is None:
raise KeyError(block_id)
block = found[2]
if hidden:
block["hidden"] = True
else:
block.pop("hidden", None)
def replace_block_fields(block: dict, *, props: dict, manifest_keys: set[str], hidden: bool,
anchor: str | None, note: str | None, requires: list[str]) -> None:
"""Обновляет props и настройки блока. Ключи props, которых нет в манифесте, сохраняются
как есть (их пометит валидация), чтобы правка формы ничего не теряла молча."""
old = block.get("props") if isinstance(block.get("props"), dict) else {}
merged = dict(props)
for key, value in old.items():
if key not in manifest_keys and key not in merged:
merged[key] = value
if merged:
block["props"] = merged
else:
block.pop("props", None)
for key, value in (("hidden", True if hidden else None), ("anchor", anchor or None),
("note", note or None), ("requires", requires or None)):
if value is None:
block.pop(key, None)
else:
block[key] = value
def region_names(meta: dict) -> list[str]:
return list((meta.get("regions") or {}).keys())
+586
View File
@@ -0,0 +1,586 @@
"""Редактор: страницы, блоки, записи коллекций, превью и публикация (M3, ТЗ раздел 10).
Все изменения идут через `ContentService`: блокировка сайта, `if_match` по хешу файла,
проверка синтаксиса, история версий, атомарная запись. Редактор правит только `pages/` и
`content/`; код сайта (фрагменты, layouts, схемы) ему недоступен. Любой POST требует
CSRF-токен и Origin своего хоста. Логика не зависит от веб-фреймворка: `dispatch` принимает
метод, путь и форму, возвращает `HttpResult`.
"""
from __future__ import annotations
import re
from collections.abc import Mapping
from pathlib import Path
from typing import Any
from ...build.pipeline import BUILD_ID_RE, preview_page
from ...core import page_ops
from ...core.draft_check import check_entry_text, check_page_text
from ...core.models import STATUSES, Fragment
from ...core.registry import Registry, load_site
from ...core.routes import build_route_table
from ...core.validate import validate_workspace
from ...errors import ConflictError, EngineError, Report, UnsafePathError
from ...parsing import frontmatter
from ...services.auth import AuthService, Principal, is_same_origin
from ...services.content import ABSENT, ContentService
from ...services.publish import publish, rollback
from .forms import FormData, _norm_text, build_view, parse_props
from .handlers import ADMIN_HEADERS, HttpResult, htmx_available, page_result, redirect_result
from .render import render
WRITE_PREFIXES = ("pages/", "content/")
PAGE_ID_RE = re.compile(r"^[a-z0-9][a-z0-9_-]*(/[a-z0-9][a-z0-9_-]*)*$")
SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9_-]*$")
ANCHOR_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_-]{0,63}$")
RESERVED_SEGMENTS = {"blocks", "add", "meta", "new"}
_ENTRY_RESERVED = {"slug", "status", "regions", "regions_mode"}
FLASH = {
"saved": "Сохранено", "created": "Создано", "block_saved": "Блок сохранён",
"moved": "Порядок изменён", "deleted": "Блок удалён", "added": "Блок добавлен: заполните поля",
"toggled": "Видимость блока изменена", "published": "Опубликовано", "rolled_back": "Релиз возвращён",
}
PREVIEW_HEADERS = {
"Cache-Control": "no-store", "X-Content-Type-Options": "nosniff", "X-Frame-Options": "SAMEORIGIN",
"Referrer-Policy": "same-origin",
"Content-Security-Policy": ("default-src 'none'; style-src 'unsafe-inline'; img-src 'self' data:; "
"frame-ancestors 'self'; base-uri 'none'; form-action 'none'"),
}
def _issues(report: Report) -> list[dict]:
return [i.to_dict() for i in report.issues]
class EditorHandlers:
def __init__(self, auth: AuthService, site_root: Path, dist: Path):
self.auth, self.site_root, self.dist = auth, Path(site_root), Path(dist)
page_id = r"(?P<page_id>[a-z0-9][a-z0-9_/-]*?)"
block_id = r"(?P<block_id>[A-Za-z][A-Za-z0-9_-]{1,63})"
coll = r"(?P<coll>[a-z][a-z0-9_]*)"
slug = r"(?P<slug>[a-z0-9][a-z0-9_-]*)"
table = [
("GET", r"/pages", self.pages_list),
("POST", r"/pages/new", self.page_create),
("GET", rf"/pages/{page_id}/blocks/{block_id}", self.block_edit),
("POST", rf"/pages/{page_id}/blocks/{block_id}", self.block_save),
("POST", rf"/pages/{page_id}/blocks/{block_id}/(?P<action>move|delete|toggle)", self.block_action),
("POST", rf"/pages/{page_id}/add", self.block_add),
("POST", rf"/pages/{page_id}/meta", self.page_save),
("GET", rf"/pages/{page_id}", self.page_edit),
("GET", rf"/preview/pages/{page_id}", self.preview_page),
("GET", rf"/preview/entries/{coll}/{slug}", self.preview_entry),
("GET", r"/content", self.content_index),
("GET", rf"/content/{coll}", self.entries_list),
("POST", rf"/content/{coll}/new", self.entry_create),
("GET", rf"/content/{coll}/{slug}", self.entry_edit),
("POST", rf"/content/{coll}/{slug}", self.entry_save),
("GET", r"/publish", self.publish_page),
("POST", r"/publish", self.publish_run),
("POST", r"/publish/rollback/(?P<build_id>\d{8}T\d{6}-[0-9a-f]{8})", self.publish_rollback),
]
self._routes = [(m, re.compile(f"^{p}$"), fn) for m, p, fn in table]
# ── диспетчер ─────────────────────────────────────────────────────────
def dispatch(self, method: str, path: str, query: Mapping[str, str], form: FormData,
cookie: str | None, headers: Mapping[str, str], ip: str) -> HttpResult:
principal = self.auth.authenticate(cookie)
if principal is None:
return redirect_result("/admin/login")
if method == "POST" and not (is_same_origin(headers, self.auth.cfg.public_host)
and self.auth.verify_csrf(principal, form.first("csrf"))):
return self._message(principal, "Запрос отклонён", "Недействительный токен или источник запроса.", 403)
for route_method, rx, handler in self._routes:
match = rx.match(path) if route_method == method else None
if match is None:
continue
try:
return handler(principal, match.groupdict(), query, form, ip)
except ConflictError as exc:
return self._message(
principal, "Файл изменился", f"{exc} Откройте страницу заново и повторите правку: "
"чужие изменения не перезаписаны.", 409, links=[{"url": "/admin/pages", "label": "К списку страниц"}])
except UnsafePathError as exc:
return self._message(principal, "Запись запрещена", str(exc), 403)
except EngineError as exc:
return self._message(principal, "Ошибка", str(exc), 422, issues=_issues(exc.report))
return self._message(principal, "Не найдено", "Такой страницы в админке нет.", 404)
# ── общие помощники ───────────────────────────────────────────────────
def _ctx(self, principal: Principal, section: str, query: Mapping[str, str] | None = None, **extra) -> dict:
return {"login": principal.login, "csrf": self.auth.csrf_token(principal), "section": section,
"flash": FLASH.get((query or {}).get("msg", ""), ""), "htmx": htmx_available(), **extra}
def _render(self, template: str, principal: Principal, section: str, query: Mapping[str, str] | None = None,
status: int = 200, **extra) -> HttpResult:
return page_result(render(template, **self._ctx(principal, section, query, **extra)), status)
def _message(self, principal: Principal, title: str, text: str = "", status: int = 200,
issues: list[dict] | None = None, links: list[dict] | None = None) -> HttpResult:
return self._render("message.html.j2", principal, "", None, status, title=title, text=text,
issues=issues or [], links=links or [])
def _svc(self) -> ContentService:
return ContentService(self.site_root, allowed_prefixes=WRITE_PREFIXES)
def _audit(self, principal: Principal, event: str, obj: str, ip: str) -> None:
self.auth.audit.write(event, actor=principal.login, object=obj, ip=ip)
@staticmethod
def _view_ctx(reg: Registry) -> dict:
assets_dir = reg.root / "assets"
assets = sorted(p.relative_to(reg.root).as_posix() for p in assets_dir.rglob("*") if p.is_file())[:500] \
if assets_dir.is_dir() else []
return {"collections": sorted(reg.collections), "assets": assets, "pages": sorted(reg.pages),
"entries": {cid: sorted(e.slug for e in items) for cid, items in reg.entries.items()}}
@staticmethod
def _summary(fragment: Fragment | None, props: dict) -> str:
if fragment is None:
return "неизвестный фрагмент"
for fd in fragment.fields:
value = props.get(fd.key)
if fd.type in ("text", "textarea", "markdown") and value:
if isinstance(value, dict) and "bind" in value:
return f"← {value['bind']}"
if isinstance(value, str):
flat = " ".join(value.split())
return flat[:70] + ("…" if len(flat) > 70 else "")
return ""
def _view_blocks(self, reg: Registry, items: Any) -> list[dict]:
out = []
for b in items or []:
if not isinstance(b, dict):
continue
frag = reg.fragments.get(b.get("fragment"))
props = b.get("props") if isinstance(b.get("props"), dict) else {}
raw_slots = b.get("slots") if isinstance(b.get("slots"), dict) else {}
names = list(frag.slots) if frag else list(raw_slots)
out.append({
"id": b.get("id", "?"), "fragment": b.get("fragment", "?"), "hidden": bool(b.get("hidden")),
"requires": list(b.get("requires") or []), "summary": self._summary(frag, props),
"slots": [{"name": n, "blocks": self._view_blocks(reg, raw_slots.get(n))} for n in names],
})
return out
@staticmethod
def _fragments_by_category(reg: Registry) -> list[tuple[str, list[str]]]:
groups: dict[str, list[str]] = {}
for f in reg.fragments.values():
groups.setdefault(f.category, []).append(f.id)
return [(cat, sorted(ids)) for cat, ids in sorted(groups.items())]
def _page_or_none(self, reg: Registry, page_id: str):
return reg.pages.get(page_id)
def _read_page(self, reg: Registry, page_id: str):
page = reg.pages.get(page_id)
if page is None:
return None
text, etag = self._svc().read(page.file)
meta, body = frontmatter.parse(text)
return page, meta, body, etag
def _not_found(self, principal: Principal, what: str) -> HttpResult:
return self._message(principal, "Не найдено", what, 404)
# ── страницы ──────────────────────────────────────────────────────────
def pages_list(self, principal, g, query, form, ip, *, errors=None, values=None, status=200) -> HttpResult:
reg = load_site(self.site_root)
table = build_route_table(reg, Report())
routes = {r.page.id: r.route for r in table.values() if r.page}
pages = [{"id": p.id, "title": p.title, "status": p.status, "route": routes.get(p.id, "—")}
for p in sorted(reg.pages.values(), key=lambda x: routes.get(x.id, x.id))]
return self._render("pages_list.html.j2", principal, "pages", query, status, pages=pages,
errors=errors or [], layouts=sorted(reg.layouts),
values=values or {"page_id": "", "title": "", "layout": ""})
def page_create(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
page_id = form.first("page_id").strip().strip("/")
title = form.first("title").strip()
layout = form.first("layout").strip()
errors = []
if not PAGE_ID_RE.match(page_id):
errors.append("Путь: латиница в нижнем регистре, цифры, «-» и «_», сегменты через «/».")
elif RESERVED_SEGMENTS & set(page_id.split("/")):
errors.append(f"Сегменты {sorted(RESERVED_SEGMENTS)} зарезервированы.")
elif page_id in reg.pages:
errors.append(f"Страница «{page_id}» уже есть.")
if not title:
errors.append("Укажите заголовок.")
if layout and layout not in reg.layouts:
errors.append(f"Нет layout «{layout}».")
values = {"page_id": page_id, "title": title, "layout": layout}
if errors:
return self.pages_list(principal, g, query, form, ip, errors=errors, values=values, status=422)
meta: dict = {"schema": 1, "title": title, "status": "draft"}
layout_id = layout or reg.site.defaults.get("layout")
if layout:
meta["layout"] = layout
region = "main"
if layout_id in reg.layouts:
open_regions = [r.id for r in reg.layouts[layout_id].regions.values() if r.allow is not None or not r.fixed]
region = open_regions[0] if open_regions else region
meta["regions"] = {region: []}
rel = f"pages/{page_id}.md"
text = frontmatter.dumps(meta, "")
report = check_page_text(reg, page_id, rel, text)
if report.errors:
return self.pages_list(principal, g, query, form, ip, errors=[str(i) for i in report.errors], values=values, status=422)
self._svc().write(rel, text, if_match=ABSENT)
self._audit(principal, "page_create", page_id, ip)
return redirect_result(f"/admin/pages/{page_id}?msg=created")
def _page_issues(self, reg: Registry, page) -> list[dict]:
report = Report()
table = build_route_table(reg, report)
found = report.issues + validate_workspace(reg, table).issues
try:
found += preview_page(self.site_root, page.id)[1].issues
except EngineError:
pass
seen, out = set(), []
for i in found:
key = (i.code, i.path, i.message)
if i.path.startswith(page.file) and key not in seen:
seen.add(key)
out.append(i.to_dict())
return out
def _page_editor(self, principal, reg, page, meta, body, etag, query, *, values=None, errors=None, status=200):
seo = meta.get("seo") if isinstance(meta.get("seo"), dict) else {}
values = values or {"title": meta.get("title", ""), "status": meta.get("status", "draft"),
"layout": meta.get("layout", ""), "route": meta.get("route", ""),
"seo_description": seo.get("description", ""), "body": body}
layout = reg.layouts.get(reg.effective_layout(page) or "")
raw_regions = meta.get("regions") if isinstance(meta.get("regions"), dict) else {}
names = list(layout.regions) if layout else []
names += [n for n in raw_regions if n not in names]
regions = []
for name in names:
rdef = layout.regions.get(name) if layout else None
regions.append({
"name": name, "blocks": self._view_blocks(reg, raw_regions.get(name)),
"fixed": [{"fragment": b.fragment, "id": b.id} for b in (rdef.fixed if rdef else [])],
"can_add": not (rdef is not None and rdef.allow is None and rdef.fixed),
})
table = build_route_table(reg, Report())
route = next((r.route for r in table.values() if r.page and r.page.id == page.id), "—")
return self._render(
"page_edit.html.j2", principal, "pages", query, status, page_id=page.id, file=page.file, route=route,
etag=etag, values=values, errors=errors or [], issues=self._page_issues(reg, page),
statuses=list(STATUSES), layouts=sorted(reg.layouts), regions=regions,
fragments=self._fragments_by_category(reg))
def page_edit(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
loaded = self._read_page(reg, g["page_id"])
if loaded is None:
return self._not_found(principal, f"Страницы «{g['page_id']}» нет.")
page, meta, body, etag = loaded
return self._page_editor(principal, reg, page, meta, body, etag, query)
def _commit_page(self, reg, page, meta, body, etag):
"""(новый etag | None, отчёт проверки). Не записывает, если есть ошибки."""
text = frontmatter.dumps(meta, body)
report = check_page_text(reg, page.id, page.file, text)
if report.errors:
return None, report
return self._svc().write(page.file, text, if_match=etag), report
def page_save(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
loaded = self._read_page(reg, g["page_id"])
if loaded is None:
return self._not_found(principal, f"Страницы «{g['page_id']}» нет.")
page, meta, _, _ = loaded
values = {"title": form.first("title").strip(), "status": form.first("status") or "draft",
"layout": form.first("layout").strip(), "route": form.first("route").strip(),
"seo_description": form.first("seo_description").strip(), "body": _norm_text(form.first("body"))}
meta["title"] = values["title"]
meta["status"] = values["status"]
for key in ("layout", "route"):
if values[key]:
meta[key] = values[key]
else:
meta.pop(key, None)
seo = dict(meta["seo"]) if isinstance(meta.get("seo"), dict) else {}
if values["seo_description"]:
seo["description"] = values["seo_description"]
else:
seo.pop("description", None)
if seo:
meta["seo"] = seo
else:
meta.pop("seo", None)
body = values["body"] + ("\n" if values["body"] else "")
new_etag, report = self._commit_page(reg, page, meta, body, form.first("etag"))
if new_etag is None:
_, current_meta, _, current_etag = self._read_page(reg, page.id)
return self._page_editor(principal, reg, page, current_meta, body, form.first("etag"), query, values=values,
errors=[str(i) for i in report.errors], status=422)
self._audit(principal, "page_save", page.id, ip)
return redirect_result(f"/admin/pages/{page.id}?msg=saved")
# ── блоки ─────────────────────────────────────────────────────────────
def _block_form(self, principal, reg, page, meta, etag, block, fragment, query, *, props=None,
settings=None, errors=None, status=200) -> HttpResult:
vctx = self._view_ctx(reg)
props = block.get("props") if props is None and isinstance(block.get("props"), dict) else (props or {})
fields = [build_view(fd, props.get(fd.key), f"p.{fd.key}", vctx) for fd in fragment.fields]
requires = set(block.get("requires") or []) if settings is None else set(settings["requires"])
settings = settings or {"hidden": bool(block.get("hidden")), "anchor": block.get("anchor") or "",
"note": block.get("note") or ""}
return self._render(
"block_edit.html.j2", principal, "pages", query, status, page_id=page.id, page_title=page.title,
block_id=block["id"], fragment_name=fragment.name, etag=etag, fields=fields, settings=settings,
errors=errors or [],
features=[(name, f"feature.{name}" in requires) for name in sorted(reg.site.features)])
def _find_block(self, principal, reg, g):
loaded = self._read_page(reg, g["page_id"])
if loaded is None:
return None, self._not_found(principal, f"Страницы «{g['page_id']}» нет.")
page, meta, body, etag = loaded
found = page_ops.find_block(meta, g["block_id"])
if found is None:
return None, self._not_found(principal, f"Блока «{g['block_id']}» на странице нет.")
return (page, meta, body, etag, found[2]), None
def block_edit(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
ctx, error = self._find_block(principal, reg, g)
if error:
return error
page, meta, body, etag, block = ctx
fragment = reg.fragments.get(block.get("fragment"))
if fragment is None:
return self._message(principal, "Фрагмент не найден", f"В реестре нет фрагмента «{block.get('fragment')}».", 422)
return self._block_form(principal, reg, page, meta, etag, block, fragment, query)
def block_save(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
ctx, error = self._find_block(principal, reg, g)
if error:
return error
page, meta, body, etag, block = ctx
fragment = reg.fragments.get(block.get("fragment"))
if fragment is None:
return self._message(principal, "Фрагмент не найден", f"В реестре нет фрагмента «{block.get('fragment')}».", 422)
errors: list[str] = []
props = parse_props(fragment.fields, form, "p", errors)
settings = {"hidden": form.first("s.hidden") == "1", "anchor": form.first("s.anchor").strip(),
"note": form.first("s.note").strip(),
"requires": [r for r in form.all("s.requires") if r.startswith("feature.")]}
if settings["anchor"] and not ANCHOR_RE.match(settings["anchor"]):
errors.append("Якорь: латиница, цифры, «-» и «_», начинается с буквы.")
if not errors:
page_ops.replace_block_fields(
block, props=props, manifest_keys={f.key for f in fragment.fields}, hidden=settings["hidden"],
anchor=settings["anchor"], note=settings["note"], requires=settings["requires"])
new_etag, report = self._commit_page(reg, page, meta, body, form.first("etag"))
if new_etag is not None:
self._audit(principal, "block_save", f"{page.id}#{block['id']}", ip)
return redirect_result(f"/admin/pages/{page.id}?msg=block_saved")
errors = [str(i) for i in report.errors]
view_settings = {k: settings[k] for k in ("hidden", "anchor", "note", "requires")}
return self._block_form(principal, reg, page, meta, form.first("etag"), {"id": g["block_id"], "requires": settings["requires"]},
fragment, query, props=props, settings=view_settings, errors=errors, status=422)
def block_action(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
ctx, error = self._find_block(principal, reg, g)
if error:
return error
page, meta, body, etag, block = ctx
action, bid = g["action"], g["block_id"]
if action == "move":
moved = page_ops.move_block(meta, bid, form.first("dir"))
msg = "moved"
if not moved:
return redirect_result(f"/admin/pages/{page.id}")
elif action == "delete":
page_ops.delete_block(meta, bid)
msg = "deleted"
else:
page_ops.set_hidden(meta, bid, not bool(block.get("hidden")))
msg = "toggled"
new_etag, report = self._commit_page(reg, page, meta, body, form.first("etag"))
if new_etag is None:
return self._message(principal, "Не удалось сохранить", "", 422, issues=_issues(report),
links=[{"url": f"/admin/pages/{page.id}", "label": "Назад к странице"}])
self._audit(principal, f"block_{action}", f"{page.id}#{bid}", ip)
return redirect_result(f"/admin/pages/{page.id}?msg={msg}")
def block_add(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
loaded = self._read_page(reg, g["page_id"])
if loaded is None:
return self._not_found(principal, f"Страницы «{g['page_id']}» нет.")
page, meta, body, etag = loaded
fragment_id = form.first("fragment")
if fragment_id not in reg.fragments:
return self._message(principal, "Нет такого фрагмента", fragment_id, 422)
try:
new_id = page_ops.add_block(meta, fragment_id, region=form.first("region") or None,
parent=form.first("parent") or None, slot=form.first("slot") or None)
except KeyError as exc:
return self._message(principal, "Не удалось добавить блок", str(exc), 422)
new_etag, report = self._commit_page(reg, page, meta, body, form.first("etag"))
if new_etag is None:
return self._message(principal, "Блок сюда добавить нельзя", "", 422, issues=_issues(report),
links=[{"url": f"/admin/pages/{page.id}", "label": "Назад к странице"}])
self._audit(principal, "block_add", f"{page.id}#{new_id}", ip)
return redirect_result(f"/admin/pages/{page.id}/blocks/{new_id}?msg=added")
# ── предпросмотр ──────────────────────────────────────────────────────
@staticmethod
def _preview_result(html: str) -> HttpResult:
return HttpResult(200, html or "<p>Страницу нельзя отрендерить: проверьте layout.</p>",
headers=dict(PREVIEW_HEADERS))
def preview_page(self, principal, g, query, form, ip) -> HttpResult:
try:
html, _ = preview_page(self.site_root, g["page_id"])
except EngineError:
return self._not_found(principal, "Страницы для предпросмотра нет.")
return self._preview_result(html)
def preview_entry(self, principal, g, query, form, ip) -> HttpResult:
try:
html, _ = preview_page(self.site_root, f"{g['coll']}/{g['slug']}")
except EngineError:
return self._not_found(principal, "Записи для предпросмотра нет.")
return self._preview_result(html)
# ── записи коллекций ──────────────────────────────────────────────────
def content_index(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
items = [{"id": c.id, "name": c.name, "total": len(reg.entries.get(c.id, [])),
"published": sum(e.status == "published" for e in reg.entries.get(c.id, []))}
for c in reg.collections.values()]
return self._render("content_index.html.j2", principal, "content", query, collections=items)
def entries_list(self, principal, g, query, form, ip, *, errors=None, slug="", status=200) -> HttpResult:
reg = load_site(self.site_root)
coll = reg.collections.get(g["coll"])
if coll is None:
return self._not_found(principal, f"Коллекции «{g['coll']}» нет.")
table = build_route_table(reg, Report())
routes = {(r.collection.id, r.entry.slug): r.route for r in table.values() if r.entry and r.collection}
entries = [{"slug": e.slug, "title": e.data.get("title", e.slug), "status": e.status,
"route": routes.get((coll.id, e.slug), "—")} for e in reg.entries.get(coll.id, [])]
return self._render("entries_list.html.j2", principal, "content", query, status, collection=coll,
entries=entries, errors=errors or [], slug=slug)
def entry_create(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
coll = reg.collections.get(g["coll"])
if coll is None:
return self._not_found(principal, f"Коллекции «{g['coll']}» нет.")
slug = form.first("slug").strip()
errors = []
if not SLUG_RE.match(slug) or slug in RESERVED_SEGMENTS:
errors.append("Slug: латиница в нижнем регистре, цифры, «-» и «_»; слова new, meta, add, blocks зарезервированы.")
elif any(e.slug == slug for e in reg.entries.get(coll.id, [])):
errors.append(f"Запись «{slug}» уже есть.")
if errors:
return self.entries_list(principal, g, query, form, ip, errors=errors, slug=slug, status=422)
rel = f"content/{coll.id}/{slug}.md"
text = frontmatter.dumps({"status": "draft"}, "")
report = check_entry_text(reg, coll.id, slug, rel, text)
if report.errors:
return self.entries_list(principal, g, query, form, ip, errors=[str(i) for i in report.errors], slug=slug, status=422)
self._svc().write(rel, text, if_match=ABSENT)
self._audit(principal, "entry_create", f"{coll.id}/{slug}", ip)
return redirect_result(f"/admin/content/{coll.id}/{slug}?msg=created")
def _entry_form(self, principal, reg, coll, entry, meta, body, etag, query, *, props=None, status_value=None,
errors=None, issues=None, status=200) -> HttpResult:
vctx = self._view_ctx(reg)
values = props if props is not None else {k: v for k, v in meta.items() if k not in _ENTRY_RESERVED}
fields = [build_view(fd, values.get(fd.key), f"p.{fd.key}", vctx) for fd in coll.fields]
return self._render(
"entry_edit.html.j2", principal, "content", query, status, collection=coll, slug=entry.slug, file=entry.file,
etag=etag, entry_status=status_value or meta.get("status", "draft"), statuses=list(STATUSES), fields=fields,
has_body=coll.body == "markdown", body=body, errors=errors or [], issues=issues or [],
preview=coll.kind != "taxonomy")
def _read_entry(self, reg, g):
coll = reg.collections.get(g["coll"])
entry = next((e for e in reg.entries.get(g["coll"], []) if e.slug == g["slug"]), None)
if coll is None or entry is None:
return None
text, etag = self._svc().read(entry.file)
meta, body = frontmatter.parse(text)
return coll, entry, meta, body, etag
def entry_edit(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
loaded = self._read_entry(reg, g)
if loaded is None:
return self._not_found(principal, "Такой записи нет.")
coll, entry, meta, body, etag = loaded
return self._entry_form(principal, reg, coll, entry, meta, body, etag, query)
def entry_save(self, principal, g, query, form, ip) -> HttpResult:
reg = load_site(self.site_root)
loaded = self._read_entry(reg, g)
if loaded is None:
return self._not_found(principal, "Такой записи нет.")
coll, entry, meta, body, etag = loaded
errors: list[str] = []
props = parse_props(coll.fields, form, "p", errors)
status_value = form.first("status") or "draft"
new_body = _norm_text(form.first("body")) + "\n" if coll.body == "markdown" and form.first("body").strip() else (
body if coll.body != "markdown" else "")
if not errors:
new_meta = dict(meta)
for fd in coll.fields:
if fd.key in props:
new_meta[fd.key] = props[fd.key]
else:
new_meta.pop(fd.key, None)
new_meta["status"] = status_value
text = frontmatter.dumps(new_meta, new_body)
report = check_entry_text(reg, coll.id, entry.slug, entry.file, text)
if not report.errors:
self._svc().write(entry.file, text, if_match=form.first("etag"))
self._audit(principal, "entry_save", f"{coll.id}/{entry.slug}", ip)
return redirect_result(f"/admin/content/{coll.id}/{entry.slug}?msg=saved")
errors = [str(i) for i in report.errors]
return self._entry_form(principal, reg, coll, entry, meta, new_body, form.first("etag"), query, props=props,
status_value=status_value, errors=errors, status=422)
# ── публикация ────────────────────────────────────────────────────────
def _builds(self) -> tuple[str | None, list[dict]]:
if not self.dist.is_dir():
return None, []
current = (self.dist / "current").resolve().name if (self.dist / "current").exists() else None
ids = sorted((p.name for p in self.dist.iterdir() if p.is_dir() and BUILD_ID_RE.match(p.name)), reverse=True)
return current, [{"id": i, "current": i == current} for i in ids]
def publish_page(self, principal, g, query, form, ip, *, issues=None, status=200) -> HttpResult:
current, builds = self._builds()
return self._render("publish.html.j2", principal, "publish", query, status, current=current, builds=builds,
issues=issues or [])
def publish_run(self, principal, g, query, form, ip) -> HttpResult:
try:
publish(self.site_root, self.dist)
except EngineError as exc:
self._audit(principal, "publish_failed", "site", ip)
return self.publish_page(principal, g, query, form, ip, issues=_issues(exc.report), status=422)
self._audit(principal, "publish", "site", ip)
return redirect_result("/admin/publish?msg=published")
def publish_rollback(self, principal, g, query, form, ip) -> HttpResult:
try:
rollback(self.dist, g["build_id"])
except ValueError as exc:
return self._not_found(principal, str(exc))
self._audit(principal, "rollback", g["build_id"], ip)
return redirect_result("/admin/publish?msg=rolled_back")
+321
View File
@@ -0,0 +1,321 @@
"""Формы редактора, построенные из схемы полей (FieldDef): разбор отправленных данных и
модель представления для шаблонов.
Имена полей плоские: `p.title`, `p.items.0.title`, `p.cta.target`; числовой сегмент — строка
списка. У любого поля есть необязательная привязка `<имя>._bind` → значение `{bind: путь}`.
Пустое поле не пишется в файл (UNSET), поэтому форма не раздувает front matter значениями
по умолчанию.
"""
from __future__ import annotations
import datetime as dt
import re
from collections.abc import Mapping, Sequence
from typing import Any
from ...core.models import FieldDef
from ...core.values import ValueShapeError, classify
from ...parsing.yamlio import YamlError, dump_yaml, load_yaml
UNSET = object()
_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
_TEXT_TYPES = ("text", "slug", "color", "icon", "asset", "ref")
_LINK_KINDS = ("page", "entry", "url")
class FormData:
"""Многозначные данные формы: имя → список значений."""
def __init__(self, data: Mapping[str, Sequence[str]] | None = None):
self._d: dict[str, list[str]] = {k: list(v) for k, v in (data or {}).items()}
@classmethod
def from_pairs(cls, pairs) -> "FormData":
d: dict[str, list[str]] = {}
for key, value in pairs:
d.setdefault(str(key), []).append(str(value))
return cls(d)
def first(self, name: str, default: str = "") -> str:
values = self._d.get(name)
return values[0] if values else default
def all(self, name: str) -> list[str]:
return list(self._d.get(name, []))
def __contains__(self, name: str) -> bool:
return name in self._d
def keys(self):
return self._d.keys()
def child_indices(self, prefix: str) -> list[int]:
found: set[int] = set()
for key in self._d:
if key.startswith(prefix + "."):
head = key[len(prefix) + 1:].split(".", 1)[0]
if head.isdigit():
found.add(int(head))
return sorted(found)
def label_of(fd: FieldDef) -> str:
return fd.label or fd.key
def _norm_text(value: str) -> str:
return value.replace("\r\n", "\n").replace("\r", "\n").rstrip()
def _pick_option(fd: FieldDef, raw: str) -> Any:
for option in fd.options:
if str(option) == raw:
return option
return UNSET
# ── разбор формы → значения ───────────────────────────────────────────────────
def parse_props(fields: list[FieldDef], form: FormData, prefix: str, errors: list[str]) -> dict:
out: dict = {}
for fd in fields:
value = parse_field(fd, form, f"{prefix}.{fd.key}", errors)
if value is not UNSET:
out[fd.key] = value
return out
def parse_field(fd: FieldDef, form: FormData, name: str, errors: list[str]) -> Any:
label = label_of(fd)
bind = form.first(name + "._bind").strip()
if bind:
try:
classify({"bind": bind})
except ValueShapeError as exc:
errors.append(f"{label}: {exc}")
return UNSET
return {"bind": bind}
t = fd.type
if t in _TEXT_TYPES:
value = form.first(name).strip()
return value if value else UNSET
if t in ("textarea", "markdown"):
value = _norm_text(form.first(name))
return value if value.strip() else UNSET
if t == "number":
text = form.first(name).strip().replace(",", ".")
if not text:
return UNSET
try:
return int(text) if re.fullmatch(r"-?\d+", text) else float(text)
except ValueError:
errors.append(f"{label}: ожидается число")
return UNSET
if t == "boolean":
value = form.first(name)
return {"true": True, "false": False}.get(value, UNSET)
if t == "select":
raw = form.first(name)
if not raw:
return UNSET
option = _pick_option(fd, raw)
if option is UNSET:
errors.append(f"{label}: значение «{raw}» не из списка")
return option
if t == "multiselect":
picked = []
for raw in form.all(name):
option = _pick_option(fd, raw)
if option is UNSET:
errors.append(f"{label}: значение «{raw}» не из списка")
else:
picked.append(option)
return picked or UNSET
if t in ("date", "datetime"):
text = form.first(name).strip()
if not text:
return UNSET
if t == "date":
if not _DATE_RE.match(text):
errors.append(f"{label}: ожидается дата ГГГГ-ММ-ДД")
return UNSET
try:
return dt.date.fromisoformat(text)
except ValueError:
errors.append(f"{label}: несуществующая дата")
return UNSET
return text
if t == "refs":
items = [s for s in re.split(r"[,\s]+", form.first(name)) if s]
return items or UNSET
if t == "link":
target = form.first(name + ".target").strip()
if not target:
return UNSET
kind = form.first(name + ".kind") or "url"
if kind not in _LINK_KINDS:
errors.append(f"{label}: неизвестный вид ссылки «{kind}»")
return UNSET
link: dict = {kind: target}
if form.first(name + ".label").strip():
link["label"] = form.first(name + ".label").strip()
if form.first(name + ".new_tab") == "1":
link["target"] = "_blank"
return link
if t == "group":
group = parse_props(fd.fields, form, name, errors)
return group or UNSET
if t == "list":
rows: list = []
for i in form.child_indices(name):
row_name = f"{name}.{i}"
if form.first(row_name + "._del") == "1":
continue
row_bind = form.first(row_name + "._bind").strip()
if row_bind and not fd.of:
try:
classify({"bind": row_bind})
rows.append({"bind": row_bind})
except ValueShapeError as exc:
errors.append(f"{label}[{i + 1}]: {exc}")
continue
if fd.of:
value = parse_field(FieldDef(key=str(i), type=fd.of, label=f"{label}[{i + 1}]"), form, row_name, errors)
else:
value = parse_props(fd.fields, form, row_name, errors) or UNSET
if value is not UNSET:
rows.append(value)
return rows or UNSET
if t == "query":
collection = form.first(name + ".collection").strip()
if not collection:
return UNSET
query: dict = {"collection": collection}
ids = [s for s in re.split(r"[,\s]+", form.first(name + ".ids")) if s]
if ids:
query["ids"] = ids
where_text = form.first(name + ".where").strip()
if where_text:
try:
where = load_yaml(where_text)
except YamlError as exc:
errors.append(f"{label}: where — {exc}")
where = None
if isinstance(where, dict):
query["where"] = where
elif where is not None:
errors.append(f"{label}: where должен быть объектом вида {{поле: значение}}")
if form.first(name + ".sort").strip():
query["sort"] = form.first(name + ".sort").strip()
limit = form.first(name + ".limit").strip()
if limit:
if limit.isdigit() and int(limit) > 0:
query["limit"] = int(limit)
else:
errors.append(f"{label}: limit — целое больше 0")
try:
classify({"query": query}, "query")
except ValueShapeError as exc:
errors.append(f"{label}: {exc}")
return UNSET
return {"query": query}
if t == "json":
text = form.first(name).strip()
if not text:
return UNSET
try:
return load_yaml(text)
except YamlError as exc:
errors.append(f"{label}: {exc}")
return UNSET
errors.append(f"{label}: тип «{t}» не поддерживается редактором")
return UNSET
# ── значения → модель представления ──────────────────────────────────────────
def _is_bind(raw: Any) -> bool:
return isinstance(raw, dict) and set(raw) == {"bind"}
def build_view(fd: FieldDef, raw: Any, name: str, ctx: Mapping[str, Any]) -> dict:
"""Описание поля для шаблона: вид контрола, значение, варианты, дочерние поля."""
t = fd.type
view: dict[str, Any] = {
"name": name, "key": fd.key, "label": label_of(fd), "type": t, "required": fd.required,
"hint": fd.extra.get("hint"), "bind": "", "value": "", "options": [], "children": [],
"rows": [], "kind": "input", "datalist": [],
}
if _is_bind(raw):
view["bind"] = str(raw["bind"])
raw = None
if raw is None and fd.default is not None:
view["default"] = fd.default
if t in _TEXT_TYPES:
view["value"] = "" if raw is None else str(raw)
if t == "asset":
view["datalist"] = ctx.get("assets", [])
elif t == "ref" and fd.to:
view["datalist"] = ctx.get("entries", {}).get(fd.to, [])
elif t in ("textarea", "markdown"):
view["kind"], view["value"] = "textarea", "" if raw is None else str(raw)
elif t == "number":
view["kind"], view["value"] = "number", "" if raw is None else str(raw)
elif t == "boolean":
view["kind"] = "select"
current = "" if raw is None else ("true" if raw else "false")
view["options"] = [{"value": "", "label": "по умолчанию", "selected": current == ""},
{"value": "true", "label": "да", "selected": current == "true"},
{"value": "false", "label": "нет", "selected": current == "false"}]
elif t == "select":
view["kind"] = "select"
current = "" if raw is None else str(raw)
view["options"] = [{"value": "", "label": "—", "selected": current == ""}] + [
{"value": str(o), "label": str(o), "selected": str(o) == current} for o in fd.options]
elif t == "multiselect":
view["kind"] = "multiselect"
chosen = {str(v) for v in raw} if isinstance(raw, list) else set()
view["options"] = [{"value": str(o), "label": str(o), "selected": str(o) in chosen} for o in fd.options]
elif t in ("date", "datetime"):
view["kind"], view["value"] = "date" if t == "date" else "input", "" if raw is None else str(raw)
elif t == "refs":
view["value"] = ", ".join(str(v) for v in raw) if isinstance(raw, list) else ""
view["datalist"] = ctx.get("entries", {}).get(fd.to or "", [])
elif t == "link":
view["kind"] = "link"
link = raw if isinstance(raw, dict) else {}
kind = next((k for k in _LINK_KINDS if k in link), "url")
view.update(link_kind=kind, target=str(link.get(kind, "")), link_label=str(link.get("label", "")),
new_tab=link.get("target") == "_blank", pages=ctx.get("pages", []))
elif t == "group":
view["kind"] = "group"
data = raw if isinstance(raw, dict) else {}
view["children"] = [build_view(sub, data.get(sub.key), f"{name}.{sub.key}", ctx) for sub in fd.fields]
elif t == "list":
view["kind"] = "list"
items = raw if isinstance(raw, list) else []
for i, item in enumerate(list(items) + [None]): # последняя строка пустая: «добавить»
row_name = f"{name}.{i}"
row: dict[str, Any] = {"name": row_name, "blank": i == len(items), "bind": "", "children": [], "item": None}
if _is_bind(item):
row["bind"], item = str(item["bind"]), None
if fd.of:
row["item"] = build_view(FieldDef(key=str(i), type=fd.of, label=f"{label_of(fd)} {i + 1}"), item, row_name, ctx)
else:
data = item if isinstance(item, dict) else {}
row["children"] = [build_view(sub, data.get(sub.key), f"{row_name}.{sub.key}", ctx) for sub in fd.fields]
view["rows"].append(row)
elif t == "query":
view["kind"] = "query"
query = raw.get("query") if isinstance(raw, dict) and "query" in raw else {}
collection = str(query.get("collection", ""))
view.update(
collection=collection, collections=ctx.get("collections", []),
sort=str(query.get("sort", "")), limit="" if query.get("limit") is None else str(query["limit"]),
ids=", ".join(query.get("ids", [])) if isinstance(query.get("ids"), list) else "",
where=dump_yaml(query["where"]).strip() if query.get("where") else "",
)
elif t == "json":
view["kind"], view["value"] = "textarea", dump_yaml(raw).strip() if raw is not None else ""
return view
+21 -3
View File
@@ -14,7 +14,7 @@ from ...core.routes import build_route_table
from ...core.validate import validate_release, validate_workspace
from ...errors import EngineError, Report
from ...services.auth import COOKIE_NAME, AuthError, AuthService, is_same_origin
from .render import read_static, render
from .render import ADMIN_DIR, read_static, render
ADMIN_HEADERS = {
"Cache-Control": "no-store",
@@ -52,6 +52,15 @@ def _redirect(location: str, cookies: list[str] | None = None) -> HttpResult:
return HttpResult(303, "", headers={**ADMIN_HEADERS, "Location": location}, cookies=cookies or [])
page_result = _page
redirect_result = _redirect
def htmx_available() -> bool:
"""htmx подключается, только если файл положен в static/ (в репозиторий не входит)."""
return (ADMIN_DIR / "static" / "htmx.min.js").is_file()
class AdminHandlers:
def __init__(self, auth: AuthService, site_root: Path):
self.auth = auth
@@ -99,6 +108,7 @@ class AdminHandlers:
if principal is None:
return _redirect("/admin/login")
ctx: dict = {"login": principal.login, "csrf": self.auth.csrf_token(principal),
"section": "dashboard", "flash": "", "htmx": htmx_available(),
"site_error": "", "site_name": "", "pages": [], "collections": [],
"errors": 0, "warnings": 0}
try:
@@ -120,6 +130,14 @@ class AdminHandlers:
ctx["site_error"] = str(exc)
return _page(render("dashboard.html.j2", **ctx))
def static_css(self) -> HttpResult:
return HttpResult(200, read_static("admin.css"), "text/css; charset=utf-8",
_STATIC = {"admin.css": "text/css; charset=utf-8", "htmx.min.js": "text/javascript; charset=utf-8"}
def static_file(self, name: str) -> HttpResult:
content_type = self._STATIC.get(name)
if content_type is None or not (ADMIN_DIR / "static" / name).is_file():
return HttpResult(404, "Не найдено", "text/plain; charset=utf-8")
return HttpResult(200, read_static(name), content_type,
headers={"Cache-Control": "public, max-age=3600", "X-Content-Type-Options": "nosniff"})
def static_css(self) -> HttpResult:
return self.static_file("admin.css")
+21 -4
View File
@@ -8,10 +8,12 @@
from __future__ import annotations
from ...services.auth import COOKIE_NAME
from .editor import EditorHandlers
from .forms import FormData
from .handlers import AdminHandlers, HttpResult
def create_admin_router(handlers: AdminHandlers):
def create_admin_router(handlers: AdminHandlers, editor: EditorHandlers | None = None):
from fastapi import APIRouter, Form, Request, Response
router = APIRouter(prefix="/admin")
@@ -43,8 +45,23 @@ def create_admin_router(handlers: AdminHandlers):
def dashboard(request: Request):
return adapt(handlers.dashboard(request.cookies.get(COOKIE_NAME)))
@router.get("/static/admin.css")
def admin_css():
return adapt(handlers.static_css())
@router.get("/static/{name}")
def static_file(name: str):
return adapt(handlers.static_file(name))
if editor is not None:
from starlette.concurrency import run_in_threadpool
# Все экраны редактора идут через один маршрут: `dispatch` сам сопоставляет путь и метод.
# Он объявлен последним, поэтому /login, /logout, /static/* и обзор имеют приоритет.
@router.api_route("/{rest:path}", methods=["GET", "POST"])
async def editor_route(request: Request, rest: str):
form = FormData()
if request.method == "POST":
form = FormData.from_pairs((await request.form()).multi_items())
result = await run_in_threadpool(
editor.dispatch, request.method, "/" + rest, dict(request.query_params), form,
request.cookies.get(COOKIE_NAME), dict(request.headers), client_ip(request))
return adapt(result)
return router
@@ -17,3 +17,33 @@ th, td { padding: .5rem .7rem; text-align: left; border-bottom: 1px solid var(--
.status-published { background: #e3f6e8; }
.status-draft { background: #fff4d6; }
.summary { color: var(--c-muted); }
.nav { display: flex; gap: .2rem; margin-left: 1rem; }
.nav a { padding: .3rem .7rem; color: inherit; text-decoration: none; border-radius: .4rem; }
.nav a.active, .nav a:hover { background: #eef0f4; }
.flash { margin: 0; padding: .5rem 1rem; background: #e3f6e8; }
.muted { color: var(--c-muted); }
.crumbs { margin: 0 0 .3rem; }
.stack { display: grid; gap: .8rem; max-width: 44rem; }
.stack textarea, .field textarea { width: 100%; padding: .5rem; font: inherit; border: 1px solid var(--c-border); border-radius: .4rem; }
.field input[type=text], .field select, .stack input[type=text], .stack select { width: 100%; }
fieldset { border: 1px solid var(--c-border); border-radius: .4rem; padding: .6rem .8rem; background: #fff; }
.row { padding: .5rem 0; border-top: 1px dashed var(--c-border); }
.row.blank { opacity: .75; }
details.bind { font-size: .8rem; color: var(--c-muted); }
.hint { color: var(--c-muted); font-size: .8rem; }
label.inline { display: inline-flex; gap: .3rem; align-items: center; margin-right: .8rem; }
.issues { padding-left: 1.2rem; }
.issues .error { color: #8a1c1c; }
.issues .warning { color: #8a5a00; }
.issues-box { margin: 1rem 0; }
.region { margin: 1rem 0; padding: .6rem 1rem; background: #fff; border: 1px solid var(--c-border); border-radius: .5rem; }
.blocks { list-style: none; padding: 0; margin: .4rem 0; }
.block { padding: .5rem .7rem; margin-bottom: .4rem; border: 1px solid var(--c-border); border-radius: .4rem; }
.block.is-hidden { opacity: .55; }
.block .actions { display: flex; flex-wrap: wrap; gap: .4rem; align-items: center; margin-top: .3rem; }
.slot { margin: .5rem 0 0 1rem; padding-left: .8rem; border-left: 3px solid var(--c-border); }
.inline-form { display: inline; margin: 0; }
button.small { padding: .2rem .6rem; font-size: .85rem; }
button.danger { background: #b42318; }
.add { display: flex; gap: .4rem; margin: .4rem 0; }
iframe.preview { width: 100%; height: 28rem; border: 1px solid var(--c-border); background: #fff; }
@@ -0,0 +1,92 @@
{# Рекурсивные макросы для форм по схеме полей (см. web/admin/forms.py: build_view) #}
{% macro bind_box(name, bind) %}
<details class='bind'{% if bind %} open{% endif %}>
<summary>привязка</summary>
<input type='text' name='{{ name }}._bind' value='{{ bind }}' placeholder='entry.title · page.body · site.name'>
</details>
{% endmacro %}
{% macro datalist(f) %}
{% if f.datalist %}<datalist id='dl-{{ f.name }}'>{% for v in f.datalist %}<option value='{{ v }}'>{% endfor %}</datalist>{% endif %}
{% endmacro %}
{% macro field(f) %}
<div class='field'>
{% if f.kind == 'group' %}
<fieldset>
<legend>{{ f.label }}{% if f.required %} *{% endif %}</legend>
{% for c in f.children %}{{ field(c) }}{% endfor %}
{{ bind_box(f.name, f.bind) }}
</fieldset>
{% elif f.kind == 'list' %}
<fieldset class='list'>
<legend>{{ f.label }}{% if f.required %} *{% endif %}</legend>
{% for row in f.rows %}
<div class='row{% if row.blank %} blank{% endif %}'>
{% if row.item %}{{ field(row.item) }}{% else %}{% for c in row.children %}{{ field(c) }}{% endfor %}{% endif %}
{{ bind_box(row.name, row.bind) }}
{% if row.blank %}
<span class='hint'>Пустая строка: заполните её, чтобы добавить элемент.</span>
{% else %}
<label class='inline'><input type='checkbox' name='{{ row.name }}._del' value='1'> удалить элемент</label>
{% endif %}
</div>
{% endfor %}
</fieldset>
{% elif f.kind == 'link' %}
<fieldset class='link'>
<legend>{{ f.label }}{% if f.required %} *{% endif %}</legend>
{% set kinds = [('page', 'страница'), ('entry', 'запись'), ('url', 'адрес')] %}
<select name='{{ f.name }}.kind'>
{% for k, title in kinds %}<option value='{{ k }}'{% if f.link_kind == k %} selected{% endif %}>{{ title }}</option>{% endfor %}
</select>
<input type='text' name='{{ f.name }}.target' value='{{ f.target }}' placeholder='contacts · services/bots · https://…'>
<input type='text' name='{{ f.name }}.label' value='{{ f.link_label }}' placeholder='подпись'>
<label class='inline'><input type='checkbox' name='{{ f.name }}.new_tab' value='1'{% if f.new_tab %} checked{% endif %}> в новой вкладке</label>
{{ bind_box(f.name, f.bind) }}
</fieldset>
{% elif f.kind == 'query' %}
<fieldset class='query'>
<legend>{{ f.label }}{% if f.required %} *{% endif %}</legend>
<label>Коллекция
<select name='{{ f.name }}.collection'>
<option value=''>—</option>
{% for c in f.collections %}<option value='{{ c }}'{% if c == f.collection %} selected{% endif %}>{{ c }}</option>{% endfor %}
</select>
</label>
<label>Сортировка <input type='text' name='{{ f.name }}.sort' value='{{ f.sort }}' placeholder='order или -date'></label>
<label>Лимит <input type='text' inputmode='numeric' name='{{ f.name }}.limit' value='{{ f.limit }}'></label>
<label>Только эти записи (slug через запятую) <input type='text' name='{{ f.name }}.ids' value='{{ f.ids }}'></label>
<label>Фильтр (YAML, например <code>featured: true</code>)
<textarea name='{{ f.name }}.where' rows='2'>{{ f.where }}</textarea>
</label>
{{ bind_box(f.name, f.bind) }}
</fieldset>
{% elif f.kind == 'multiselect' %}
<fieldset>
<legend>{{ f.label }}</legend>
{% for o in f.options %}
<label class='inline'><input type='checkbox' name='{{ f.name }}' value='{{ o.value }}'{% if o.selected %} checked{% endif %}> {{ o.label }}</label>
{% endfor %}
{{ bind_box(f.name, f.bind) }}
</fieldset>
{% else %}
<label>{{ f.label }}{% if f.required %} *{% endif %}
{% if f.kind == 'textarea' %}
<textarea name='{{ f.name }}' rows='6'>{{ f.value }}</textarea>
{% elif f.kind == 'select' %}
<select name='{{ f.name }}'>{% for o in f.options %}<option value='{{ o.value }}'{% if o.selected %} selected{% endif %}>{{ o.label }}</option>{% endfor %}</select>
{% elif f.kind == 'date' %}
<input type='date' name='{{ f.name }}' value='{{ f.value }}'>
{% elif f.kind == 'number' %}
<input type='text' inputmode='decimal' name='{{ f.name }}' value='{{ f.value }}'>
{% else %}
<input type='text' name='{{ f.name }}' value='{{ f.value }}'{% if f.datalist %} list='dl-{{ f.name }}'{% endif %}>
{% endif %}
</label>
{{ datalist(f) }}
{% if f.hint %}<small class='hint'>{{ f.hint }}</small>{% endif %}
{{ bind_box(f.name, f.bind) }}
{% endif %}
</div>
{% endmacro %}
@@ -7,7 +7,8 @@
<title>{% block title %}Админка{% endblock %}</title>
<link rel='stylesheet' href='/admin/static/admin.css'>
</head>
<body>
<body{% block bodyattrs %}{% endblock %}>
{% block body %}{% endblock %}
{% block scripts %}{% endblock %}
</body>
</html>
@@ -0,0 +1,25 @@
{% extends 'shell.html.j2' %}
{% from '_fields.html.j2' import field %}
{% block title %}Блок {{ block_id }} — админка{% endblock %}
{% block content %}
<p class='crumbs'><a href='/admin/pages/{{ page_id }}'>← {{ page_title }}</a></p>
<h1>{{ fragment_name }} <small><code>{{ block_id }}</code></small></h1>
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
<form method='post' action='/admin/pages/{{ page_id }}/blocks/{{ block_id }}' class='stack'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<input type='hidden' name='etag' value='{{ etag }}'>
{% for f in fields %}{{ field(f) }}{% else %}<p class='muted'>У этого фрагмента нет полей.</p>{% endfor %}
<fieldset>
<legend>Настройки блока</legend>
<label class='inline'><input type='checkbox' name='s.hidden' value='1'{% if settings.hidden %} checked{% endif %}> скрыт (не выводится на сайте)</label>
<label>Якорь <input type='text' name='s.anchor' value='{{ settings.anchor }}' placeholder='pricing'></label>
<label>Заметка <input type='text' name='s.note' value='{{ settings.note }}'></label>
{% if features %}
<div>Показывать, только если включено:
{% for name, on in features %}<label class='inline'><input type='checkbox' name='s.requires' value='feature.{{ name }}'{% if on %} checked{% endif %}> feature.{{ name }}</label>{% endfor %}
</div>
{% endif %}
</fieldset>
<button type='submit'>Сохранить блок</button>
</form>
{% endblock %}
@@ -0,0 +1,15 @@
{% extends 'shell.html.j2' %}
{% block title %}Контент — админка{% endblock %}
{% block content %}
<h1>Контент</h1>
<table>
<thead><tr><th>Коллекция</th><th>Записей</th><th>Опубликовано</th></tr></thead>
<tbody>
{% for c in collections %}
<tr><td><a href='/admin/content/{{ c.id }}'>{{ c.name }}</a></td><td>{{ c.total }}</td><td>{{ c.published }}</td></tr>
{% else %}
<tr><td colspan='3'>Коллекций нет</td></tr>
{% endfor %}
</tbody>
</table>
{% endblock %}
@@ -1,16 +1,6 @@
{% extends 'base.html.j2' %}
{% extends 'shell.html.j2' %}
{% block title %}Обзор — админка{% endblock %}
{% block body %}
<header class='bar'>
<strong>Админка</strong>
<span class='spacer'></span>
<span>{{ login }}</span>
<form method='post' action='/admin/logout'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<button type='submit'>Выйти</button>
</form>
</header>
<main class='content'>
{% block content %}
{% if site_error %}
<p class='error' role='alert'>Сайт не загружен: {{ site_error }}</p>
{% else %}
@@ -40,5 +30,4 @@
{% endfor %}
</ul>
{% endif %}
</main>
{% endblock %}
@@ -0,0 +1,28 @@
{% extends 'shell.html.j2' %}
{% block title %}{{ collection.name }} — админка{% endblock %}
{% block content %}
<p class='crumbs'><a href='/admin/content'>← Контент</a></p>
<h1>{{ collection.name }}</h1>
<table>
<thead><tr><th>Запись</th><th>Адрес</th><th>Статус</th><th></th></tr></thead>
<tbody>
{% for e in entries %}
<tr>
<td>{{ e.title }}<br><small class='muted'>{{ e.slug }}</small></td>
<td><code>{{ e.route }}</code></td>
<td><span class='status status-{{ e.status }}'>{{ e.status }}</span></td>
<td><a href='/admin/content/{{ collection.id }}/{{ e.slug }}'>Изменить</a></td>
</tr>
{% else %}
<tr><td colspan='4'>Записей пока нет</td></tr>
{% endfor %}
</tbody>
</table>
<h2>Новая запись</h2>
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
<form method='post' action='/admin/content/{{ collection.id }}/new' class='stack'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<label>Slug (латиница, цифры, - и _) <input type='text' name='slug' value='{{ slug }}' required></label>
<button type='submit'>Создать черновик</button>
</form>
{% endblock %}
@@ -0,0 +1,26 @@
{% extends 'shell.html.j2' %}
{% from '_fields.html.j2' import field %}
{% block title %}{{ slug }} — админка{% endblock %}
{% block content %}
<p class='crumbs'><a href='/admin/content/{{ collection.id }}'>← {{ collection.name }}</a></p>
<h1>{{ slug }}</h1>
<p class='muted'><code>{{ file }}</code></p>
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
{% if issues %}<ul class='issues'>{% for i in issues %}<li class='{{ i.severity }}'><code>{{ i.code }}</code> {{ i.message }}</li>{% endfor %}</ul>{% endif %}
<form method='post' action='/admin/content/{{ collection.id }}/{{ slug }}' class='stack'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<input type='hidden' name='etag' value='{{ etag }}'>
<label>Статус
<select name='status'>{% for s in statuses %}<option value='{{ s }}'{% if s == entry_status %} selected{% endif %}>{{ s }}</option>{% endfor %}</select>
</label>
{% for f in fields %}{{ field(f) }}{% endfor %}
{% if has_body %}
<label>Текст (Markdown) <textarea name='body' rows='12'>{{ body }}</textarea></label>
{% endif %}
<button type='submit'>Сохранить</button>
</form>
{% if preview %}
<h2>Предпросмотр</h2>
<iframe class='preview' sandbox src='/admin/preview/entries/{{ collection.id }}/{{ slug }}' title='Предпросмотр записи'></iframe>
{% endif %}
{% endblock %}
@@ -0,0 +1,12 @@
{% extends 'shell.html.j2' %}
{% block title %}{{ title }} — админка{% endblock %}
{% block content %}
<h1>{{ title }}</h1>
{% if text %}<p>{{ text }}</p>{% endif %}
{% if issues %}
<ul class='issues'>
{% for i in issues %}<li class='{{ i.severity }}'><code>{{ i.code }}</code> {{ i.path }} {{ i.message }}{% if i.hint %} <small>({{ i.hint }})</small>{% endif %}</li>{% endfor %}
</ul>
{% endif %}
{% for l in links %}<p><a href='{{ l.url }}'>{{ l.label }}</a></p>{% endfor %}
{% endblock %}
@@ -0,0 +1,107 @@
{% extends 'shell.html.j2' %}
{% from '_fields.html.j2' import field %}
{% block title %}{{ values.title }} — админка{% endblock %}
{% macro act(url, label, name='', value='', cls='') %}
<form method='post' action='{{ url }}' class='inline-form'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<input type='hidden' name='etag' value='{{ etag }}'>
{% if name %}<input type='hidden' name='{{ name }}' value='{{ value }}'>{% endif %}
<button type='submit' class='small {{ cls }}'>{{ label }}</button>
</form>
{% endmacro %}
{% macro add_form(region='', parent='', slot='') %}
<form method='post' action='/admin/pages/{{ page_id }}/add' class='add'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<input type='hidden' name='etag' value='{{ etag }}'>
{% if region %}<input type='hidden' name='region' value='{{ region }}'>{% endif %}
{% if parent %}<input type='hidden' name='parent' value='{{ parent }}'><input type='hidden' name='slot' value='{{ slot }}'>{% endif %}
<select name='fragment' aria-label='Фрагмент'>
{% for cat, ids in fragments %}<optgroup label='{{ cat }}'>{% for fid in ids %}<option value='{{ fid }}'>{{ fid }}</option>{% endfor %}</optgroup>{% endfor %}
</select>
<button type='submit' class='small'>+ Добавить блок</button>
</form>
{% endmacro %}
{% macro blocks(items) %}
<ul class='blocks'>
{% for b in items %}
<li class='block{% if b.hidden %} is-hidden{% endif %}'>
<div class='head'>
<strong>{{ b.fragment }}</strong> <code>{{ b.id }}</code>
{% if b.hidden %}<em>скрыт</em>{% endif %}
{% if b.requires %}<small>нужны: {{ b.requires|join(', ') }}</small>{% endif %}
<span class='muted'>{{ b.summary }}</span>
</div>
<div class='actions'>
<a href='/admin/pages/{{ page_id }}/blocks/{{ b.id }}'>Изменить</a>
{{ act('/admin/pages/' ~ page_id ~ '/blocks/' ~ b.id ~ '/move', '↑', 'dir', 'up') }}
{{ act('/admin/pages/' ~ page_id ~ '/blocks/' ~ b.id ~ '/move', '↓', 'dir', 'down') }}
{{ act('/admin/pages/' ~ page_id ~ '/blocks/' ~ b.id ~ '/toggle', 'Показать' if b.hidden else 'Скрыть') }}
{{ act('/admin/pages/' ~ page_id ~ '/blocks/' ~ b.id ~ '/delete', 'Удалить', cls='danger') }}
</div>
{% for s in b.slots %}
<div class='slot'>
<h4>Слот «{{ s.name }}»</h4>
{{ blocks(s.blocks) }}
{{ add_form(parent=b.id, slot=s.name) }}
</div>
{% endfor %}
</li>
{% endfor %}
</ul>
{% endmacro %}
{% block content %}
<p class='crumbs'><a href='/admin/pages'>← Все страницы</a></p>
<h1>{{ values.title }}</h1>
<p class='muted'><code>{{ file }}</code> · адрес <code>{{ route }}</code></p>
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
{% if issues %}
<details class='issues-box' open>
<summary>Проверка страницы: {{ issues|length }}</summary>
<ul class='issues'>
{% for i in issues %}<li class='{{ i.severity }}'><code>{{ i.code }}</code> {{ i.message }} <small>{{ i.path }}</small></li>{% endfor %}
</ul>
</details>
{% endif %}
<h2>Страница</h2>
<form method='post' action='/admin/pages/{{ page_id }}/meta' class='stack'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<input type='hidden' name='etag' value='{{ etag }}'>
<label>Заголовок * <input type='text' name='title' value='{{ values.title }}' required></label>
<label>Статус
<select name='status'>{% for s in statuses %}<option value='{{ s }}'{% if s == values.status %} selected{% endif %}>{{ s }}</option>{% endfor %}</select>
</label>
<label>Layout
<select name='layout'>
<option value=''>по умолчанию</option>
{% for l in layouts %}<option value='{{ l }}'{% if l == values.layout %} selected{% endif %}>{{ l }}</option>{% endfor %}
</select>
</label>
<label>Адрес (если не совпадает с путём файла) <input type='text' name='route' value='{{ values.route }}' placeholder='/scenarios/legal/'></label>
<label>Описание для поисковиков <input type='text' name='seo_description' value='{{ values.seo_description }}'></label>
<label>Текст страницы (Markdown, доступен блокам как <code>page.body</code>)
<textarea name='body' rows='8'>{{ values.body }}</textarea>
</label>
<button type='submit'>Сохранить</button>
</form>
<h2>Блоки</h2>
{% for r in regions %}
<section class='region'>
<h3>Регион «{{ r.name }}»</h3>
{% if r.fixed %}
<p class='muted'>Закреплены в layout: {% for f in r.fixed %}<code>{{ f.fragment }}</code> {% endfor %}</p>
{% endif %}
{{ blocks(r.blocks) }}
{% if r.can_add %}{{ add_form(region=r.name) }}{% endif %}
</section>
{% endfor %}
<h2>Предпросмотр</h2>
<iframe class='preview' sandbox src='/admin/preview/pages/{{ page_id }}' title='Предпросмотр страницы'></iframe>
{% endblock %}
@@ -0,0 +1,34 @@
{% extends 'shell.html.j2' %}
{% block title %}Страницы — админка{% endblock %}
{% block content %}
<h1>Страницы</h1>
<table>
<thead><tr><th>Страница</th><th>Адрес</th><th>Статус</th><th></th></tr></thead>
<tbody>
{% for p in pages %}
<tr>
<td>{{ p.title }}<br><small class='muted'>{{ p.id }}</small></td>
<td><code>{{ p.route }}</code></td>
<td><span class='status status-{{ p.status }}'>{{ p.status }}</span></td>
<td><a href='/admin/pages/{{ p.id }}'>Изменить</a></td>
</tr>
{% endfor %}
</tbody>
</table>
<h2>Новая страница</h2>
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
<form method='post' action='/admin/pages/new' class='stack'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<label>Путь страницы (латиница, <code>services/new</code>)
<input type='text' name='page_id' value='{{ values.page_id }}' required>
</label>
<label>Заголовок <input type='text' name='title' value='{{ values.title }}' required></label>
<label>Layout
<select name='layout'>
<option value=''>по умолчанию</option>
{% for l in layouts %}<option value='{{ l }}'{% if l == values.layout %} selected{% endif %}>{{ l }}</option>{% endfor %}
</select>
</label>
<button type='submit'>Создать черновик</button>
</form>
{% endblock %}
@@ -0,0 +1,32 @@
{% extends 'shell.html.j2' %}
{% block title %}Публикация — админка{% endblock %}
{% block content %}
<h1>Публикация</h1>
{% if issues %}
<h2>Проблемы сборки</h2>
<ul class='issues'>{% for i in issues %}<li class='{{ i.severity }}'><code>{{ i.code }}</code> {{ i.path }} {{ i.message }}</li>{% endfor %}</ul>
{% endif %}
<p>Сейчас на сайте: {% if current %}<code>{{ current }}</code>{% else %}ничего не опубликовано{% endif %}</p>
<form method='post' action='/admin/publish'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<button type='submit'>Опубликовать текущий черновик сайта</button>
</form>
<p class='muted'>В релиз попадают только страницы и записи со статусом published. Если сборка не пройдёт проверку, опубликованный сайт не изменится.</p>
<h2>Релизы</h2>
<table>
<thead><tr><th>Релиз</th><th></th></tr></thead>
<tbody>
{% for b in builds %}
<tr>
<td><code>{{ b.id }}</code>{% if b.current %} <span class='status status-published'>текущий</span>{% endif %}</td>
<td>{% if not b.current %}
<form method='post' action='/admin/publish/rollback/{{ b.id }}' class='inline-form'>
<input type='hidden' name='csrf' value='{{ csrf }}'><button type='submit' class='small'>Вернуть этот релиз</button>
</form>{% endif %}</td>
</tr>
{% else %}
<tr><td colspan='2'>Релизов пока нет</td></tr>
{% endfor %}
</tbody>
</table>
{% endblock %}
@@ -0,0 +1,24 @@
{% extends 'base.html.j2' %}
{% block bodyattrs %}{% if htmx %} hx-boost='true'{% endif %}{% endblock %}
{% block scripts %}{% if htmx %}<script src='/admin/static/htmx.min.js' defer></script>{% endif %}{% endblock %}
{% block body %}
<header class='bar'>
<strong>Админка</strong>
<nav class='nav'>
<a href='/admin/'{% if section == 'dashboard' %} class='active'{% endif %}>Обзор</a>
<a href='/admin/pages'{% if section == 'pages' %} class='active'{% endif %}>Страницы</a>
<a href='/admin/content'{% if section == 'content' %} class='active'{% endif %}>Контент</a>
<a href='/admin/publish'{% if section == 'publish' %} class='active'{% endif %}>Публикация</a>
</nav>
<span class='spacer'></span>
<span>{{ login }}</span>
<form method='post' action='/admin/logout'>
<input type='hidden' name='csrf' value='{{ csrf }}'>
<button type='submit'>Выйти</button>
</form>
</header>
{% if flash %}<p class='flash' role='status'>{{ flash }}</p>{% endif %}
<main class='content'>
{% block content %}{% endblock %}
</main>
{% endblock %}
+3 -1
View File
@@ -20,6 +20,7 @@ def create_app():
from fastapi.staticfiles import StaticFiles
from ..services.auth import AuthConfig, AuthService, ConfigError
from .admin.editor import EditorHandlers
from .admin.handlers import AdminHandlers
from .admin.routes import create_admin_router
@@ -41,7 +42,8 @@ def create_app():
log.warning("админка отключена: %s", exc)
else:
state_dir = Path(os.environ.get("SITE_STATE_DIR", root / ".engine"))
app.include_router(create_admin_router(AdminHandlers(AuthService(cfg, state_dir), root)))
auth = AuthService(cfg, state_dir)
app.include_router(create_admin_router(AdminHandlers(auth, root), EditorHandlers(auth, root, dist)))
if (dist / "current").exists(): # маршруты выше имеют приоритет над раздачей статики
app.mount("/", StaticFiles(directory=dist / "current", html=True), name="site")
+66
View File
@@ -0,0 +1,66 @@
"""Мини-«браузер» для тестов: вынимает значения формы из HTML так же, как это делает браузер."""
from html.parser import HTMLParser
class _FormScraper(HTMLParser):
def __init__(self, action: str):
super().__init__(convert_charrefs=True)
self.action, self.data = action, {}
self._in_target = False
self._select = None
self._select_options: list[tuple[str, bool]] = []
self._textarea = None
self._textarea_text: list[str] = []
self.found = False
def _put(self, name, value):
self.data.setdefault(name, []).append(value)
def handle_starttag(self, tag, attrs):
a = dict(attrs)
if tag == "form":
self._in_target = a.get("action") == self.action
self.found = self.found or self._in_target
return
if not self._in_target:
return
if tag == "input":
name, kind = a.get("name"), (a.get("type") or "text").lower()
if not name or kind in ("submit", "button", "file"):
return
if kind in ("checkbox", "radio"):
if "checked" in a:
self._put(name, a.get("value", "on"))
else:
self._put(name, a.get("value") or "")
elif tag == "select":
self._select, self._select_options = a.get("name"), []
elif tag == "option" and self._select is not None:
self._select_options.append((a.get("value", ""), "selected" in a))
elif tag == "textarea":
self._textarea, self._textarea_text = a.get("name"), []
def handle_data(self, data):
if self._textarea is not None:
self._textarea_text.append(data)
def handle_endtag(self, tag):
if tag == "form":
self._in_target = False
elif tag == "select" and self._select is not None:
chosen = next((v for v, sel in self._select_options if sel), self._select_options[0][0] if self._select_options else "")
if self._select_options:
self._put(self._select, chosen)
self._select = None
elif tag == "textarea" and self._textarea is not None:
self._put(self._textarea, "".join(self._textarea_text))
self._textarea = None
def scrape_form(html: str, action: str) -> dict[str, list[str]]:
scraper = _FormScraper(action)
scraper.feed(html)
if not scraper.found:
raise AssertionError(f"форма {action} не найдена в HTML")
return scraper.data
+55 -6
View File
@@ -14,6 +14,7 @@ from helpers import SiteTestCase
from test_auth import PASSWORD, Clock, make_cfg
from site_engine.services.auth import COOKIE_NAME, AuthService
from site_engine.web.admin.editor import EditorHandlers
from site_engine.web.admin.handlers import AdminHandlers
ORIGIN = {"host": "admin.example", "origin": "https://admin.example"}
@@ -50,11 +51,22 @@ class FakeRouter:
def post(self, path):
return self._register("POST", path)
def api_route(self, path, methods):
def deco(fn):
for method in methods:
self.routes[(method, self.prefix + path)] = fn
return fn
return deco
class FakeRequest:
def __init__(self, cookies=None, headers=None, ip="1.2.3.4"):
def __init__(self, cookies=None, headers=None, ip="1.2.3.4", method="GET", query=None, form=None):
self.cookies, self.headers = cookies or {}, headers or {}
self.client = types.SimpleNamespace(host=ip)
self.method, self.query_params, self._form = method, query or {}, form or []
async def form(self):
return types.SimpleNamespace(multi_items=lambda: list(self._form))
def fake_fastapi():
@@ -64,14 +76,25 @@ def fake_fastapi():
return mod
def fake_starlette():
pkg, conc = types.ModuleType("starlette"), types.ModuleType("starlette.concurrency")
async def run_in_threadpool(fn, *args):
return fn(*args)
conc.run_in_threadpool = run_in_threadpool
return {"starlette": pkg, "starlette.concurrency": conc}
class RoutesWiringTest(SiteTestCase):
def setUp(self):
super().setUp()
self.auth = AuthService(make_cfg(), self.tmp / "state", clock=Clock())
handlers = AdminHandlers(self.auth, self.site)
with mock.patch.dict(sys.modules, {"fastapi": fake_fastapi()}):
self.editor = EditorHandlers(self.auth, self.site, self.tmp / "dist")
with mock.patch.dict(sys.modules, {"fastapi": fake_fastapi(), **fake_starlette()}):
from site_engine.web.admin.routes import create_admin_router
self.router = create_admin_router(handlers)
self.router = create_admin_router(handlers, self.editor)
def route(self, method, path):
return self.router.routes[(method, path)]
@@ -79,8 +102,9 @@ class RoutesWiringTest(SiteTestCase):
def test_all_expected_routes_exist(self):
self.assertEqual(
sorted(self.router.routes),
[("GET", "/admin/"), ("GET", "/admin/login"), ("GET", "/admin/static/admin.css"),
("POST", "/admin/login"), ("POST", "/admin/logout")],
[("GET", "/admin/"), ("GET", "/admin/login"), ("GET", "/admin/static/{name}"),
("GET", "/admin/{rest:path}"), ("POST", "/admin/login"), ("POST", "/admin/logout"),
("POST", "/admin/{rest:path}")],
)
def test_login_flow_through_routes(self):
@@ -111,11 +135,36 @@ class RoutesWiringTest(SiteTestCase):
self.assertIn("Max-Age=0", out.headers.appended[0][1])
def test_static_and_login_page_routes(self):
css = self.route("GET", "/admin/static/admin.css")()
css = self.route("GET", "/admin/static/{name}")("admin.css")
self.assertTrue(css.media_type.startswith("text/css"))
self.assertEqual(self.route("GET", "/admin/static/{name}")("secret.txt").status_code, 404)
page = self.route("GET", "/admin/login")(FakeRequest())
self.assertEqual(page.status_code, 200)
def test_editor_catch_all_passes_method_path_query_form_and_cookie(self):
import asyncio
good = self.route("POST", "/admin/login")(FakeRequest(headers=ORIGIN), login="admin", password=PASSWORD)
value = good.headers.appended[0][1].split(";")[0].split("=", 1)[1]
cookies = {COOKIE_NAME: value}
get = self.route("GET", "/admin/{rest:path}")
response = asyncio.run(get(FakeRequest(cookies=cookies, query={"msg": "saved"}), rest="pages"))
self.assertEqual(response.status_code, 200)
self.assertIn("Новая страница", response.content)
self.assertIn("Сохранено", response.content) # query дошёл до обработчика
csrf = self.auth.csrf_token(self.auth.authenticate(value))
post = self.route("POST", "/admin/{rest:path}")
request = FakeRequest(cookies=cookies, headers=ORIGIN, method="POST",
form=[("csrf", csrf), ("page_id", "wired-page"), ("title", "Через адаптер")])
response = asyncio.run(post(request, rest="pages/new"))
self.assertEqual((response.status_code, response.headers["Location"]),
(303, "/admin/pages/wired-page?msg=created"))
self.assertTrue((self.site / "pages" / "wired-page.md").is_file())
nobody = asyncio.run(get(FakeRequest(), rest="pages"))
self.assertEqual((nobody.status_code, nobody.headers["Location"]), (303, "/admin/login"))
if __name__ == "__main__":
unittest.main()
+480
View File
@@ -0,0 +1,480 @@
import json
import unittest
from unittest import mock
from helpers import SiteTestCase
from helpers_html import scrape_form
from test_auth import PASSWORD, Clock, make_cfg
from site_engine.parsing import frontmatter
from site_engine.services.auth import AuthService
from site_engine.storage.history import list_versions
from site_engine.web.admin.editor import EditorHandlers
from site_engine.web.admin.forms import FormData
ORIGIN = {"host": "admin.example", "origin": "https://admin.example"}
class EditorTestCase(SiteTestCase):
def setUp(self):
super().setUp()
self.auth = AuthService(make_cfg(), self.tmp / "state", clock=Clock())
self.dist = self.tmp / "dist"
self.ed = EditorHandlers(self.auth, self.site, self.dist)
self.cookie = self.auth.login("admin", PASSWORD, "1.1.1.1")
self.csrf = self.auth.csrf_token(self.auth.authenticate(self.cookie))
# запросы
def get(self, path, query=None, cookie="default"):
cookie = self.cookie if cookie == "default" else cookie
return self.ed.dispatch("GET", path, query or {}, FormData(), cookie, ORIGIN, "1.1.1.1")
def post(self, path, data=None, *, csrf=True, headers=None, cookie="default"):
cookie = self.cookie if cookie == "default" else cookie
form = data if isinstance(data, FormData) else FormData({k: v if isinstance(v, list) else [v] for k, v in (data or {}).items()})
if csrf and "csrf" not in form:
form._d["csrf"] = [self.csrf]
return self.ed.dispatch("POST", path, {}, form, cookie, headers or ORIGIN, "1.1.1.1")
def form(self, path, action):
result = self.get(path)
self.assertEqual(result.status, 200, result.body[:300])
return FormData(scrape_form(result.body, action))
def submit_form(self, path, action, **changes):
"""Как человек: открыть страницу, поправить поля, отправить форму."""
form = self.form(path, action)
for key, value in changes.items():
form._d[key.replace("__", ".")] = value if isinstance(value, list) else [value]
return self.post(action.removeprefix("/admin"), form)
# файлы
def meta(self, rel):
return frontmatter.parse((self.site / rel).read_text(encoding="utf-8"))
def block(self, rel, block_id, region="main"):
meta, _ = self.meta(rel)
return next(b for b in meta["regions"][region] if b["id"] == block_id)
def audit_text(self):
return (self.tmp / "state" / "audit.jsonl").read_text(encoding="utf-8")
class AccessTest(EditorTestCase):
def test_everything_requires_login(self):
for method, path in (("GET", "/pages"), ("GET", "/pages/index"), ("POST", "/pages/new"),
("GET", "/preview/pages/index"), ("GET", "/publish"), ("POST", "/publish")):
result = self.ed.dispatch(method, path, {}, FormData(), None, ORIGIN, "1.1.1.1")
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/login"), path)
def test_post_needs_csrf_and_same_origin_and_changes_nothing(self):
before = (self.site / "pages/privacy.md").read_bytes()
form = {"etag": "x", "title": "Хак", "status": "published", "body": "x"}
self.assertEqual(self.post("/pages/privacy/meta", form, csrf=False).status, 403)
bad = {"csrf": "wrong", **form}
self.assertEqual(self.post("/pages/privacy/meta", bad).status, 403)
evil = {"host": "admin.example", "origin": "https://evil.example"}
self.assertEqual(self.post("/pages/privacy/meta", form, headers=evil).status, 403)
self.assertEqual((self.site / "pages/privacy.md").read_bytes(), before)
def test_unknown_and_malicious_paths(self):
for path in ("/nope", "/pages/../../site", "/pages/a/../b", "/pages/UPPER", "/content/services/../x", "/pages//x"):
self.assertEqual(self.get(path).status, 404, path)
self.assertEqual(self.get("/pages/no-such-page").status, 404)
self.assertEqual(self.get("/pages/index/blocks/nope").status, 404)
self.assertEqual(self.get("/content/nope").status, 404)
self.assertEqual(self.get("/content/services/nope").status, 404)
def test_editor_screens_keep_security_headers_and_no_inline_code(self):
for path in ("/pages", "/pages/index", "/pages/index/blocks/b_hero", "/content", "/content/services",
"/content/services/bots", "/publish"):
result = self.get(path)
self.assertEqual(result.status, 200, path)
self.assertIn("frame-ancestors 'none'", result.headers["Content-Security-Policy"], path)
self.assertEqual(result.headers["Cache-Control"], "no-store")
for bad in ("<script", "style=", "<style", "onclick="):
self.assertNotIn(bad, result.body, f"{path}: {bad}")
def test_htmx_is_enabled_only_when_the_file_is_present(self):
self.assertNotIn("hx-boost", self.get("/pages").body)
with mock.patch("site_engine.web.admin.editor.htmx_available", return_value=True):
body = self.get("/pages").body
self.assertIn("hx-boost='true'", body)
self.assertIn("src='/admin/static/htmx.min.js'", body)
def test_titles_are_escaped(self):
self.edit("pages/privacy.md", "title: Политика обработки персональных данных", "title: '<script>alert(1)</script>'")
for path in ("/pages", "/pages/privacy", "/"):
if path == "/":
continue
self.assertNotIn("<script>alert(1)</script>", self.get(path).body, path)
self.assertIn("&lt;script&gt;", self.get(path).body)
class PageTest(EditorTestCase):
def test_pages_list_and_editor_screen(self):
body = self.get("/pages").body
for text in ("Главная", "Контакты", "drafts/next", "Новая страница"):
self.assertIn(text, body)
body = self.get("/pages/index").body
for text in ("Регион «main»", "b_hero", "hero", "collection_list", "Закреплены в layout", "site_header",
"name='etag'", "/admin/preview/pages/index", "+ Добавить блок"):
self.assertIn(text, body)
self.assertIn("sandbox", body) # предпросмотр в изолированном фрейме
def test_save_meta_writes_file_history_and_audit_without_content(self):
before = (self.site / "pages/privacy.md").read_text(encoding="utf-8")
result = self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", title="Новый заголовок политики")
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/pages/privacy?msg=saved"))
meta, body = self.meta("pages/privacy.md")
self.assertEqual(meta["title"], "Новый заголовок политики")
self.assertIn("Текст политики добавляет", body)
self.assertEqual(list_versions(self.site, "pages/privacy.md")[0].read_text(encoding="utf-8"), before)
audit = self.audit_text()
self.assertIn('"event": "page_save"', audit)
self.assertNotIn("Новый заголовок политики", audit)
def test_noop_save_keeps_page_semantically_identical(self):
for page_id in ("index", "contacts", "services/index", "privacy", "drafts/next"):
rel = f"pages/{page_id}.md"
before = self.meta(rel)
self.assertEqual(self.submit_form(f"/pages/{page_id}", f"/admin/pages/{page_id}/meta").status, 303, page_id)
after = self.meta(rel)
self.assertEqual(after[0], before[0], page_id)
self.assertEqual(after[1].strip(), before[1].strip(), page_id)
def test_body_and_seo_and_status_and_route(self):
self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", body="Новый **текст**", seo_description="Описание",
status="published", route="/legal/privacy/")
meta, body = self.meta("pages/privacy.md")
self.assertEqual((meta["seo"], meta["route"], meta["status"]), ({"description": "Описание"}, "/legal/privacy/", "published"))
self.assertEqual(body.strip(), "Новый **текст**")
self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", seo_description="", route="")
meta, _ = self.meta("pages/privacy.md")
self.assertNotIn("seo", meta)
self.assertNotIn("route", meta)
def test_stale_etag_gives_409_and_keeps_foreign_edit(self):
form = self.form("/pages/privacy", "/admin/pages/privacy/meta")
self.edit("pages/privacy.md", "Текст политики", "Правка в другом окне")
form._d["title"] = ["Моя правка"]
result = self.post("/pages/privacy/meta", form)
self.assertEqual(result.status, 409)
self.assertIn("Файл изменился", result.body)
meta, body = self.meta("pages/privacy.md")
self.assertIn("Правка в другом окне", body)
self.assertNotEqual(meta["title"], "Моя правка")
def test_save_level_validation_blocks_invalid_layout(self):
before = (self.site / "pages/privacy.md").read_bytes()
result = self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", layout="no_such_layout")
self.assertEqual(result.status, 422)
self.assertIn("E_LAYOUT_MISSING", result.body)
self.assertEqual((self.site / "pages/privacy.md").read_bytes(), before)
def test_empty_title_is_rejected(self):
result = self.submit_form("/pages/privacy", "/admin/pages/privacy/meta", title="")
self.assertEqual(result.status, 422)
def test_create_page(self):
result = self.post("/pages/new", {"page_id": "services/new-one", "title": "Новая услуга", "layout": "default"})
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/pages/services/new-one?msg=created"))
meta, _ = self.meta("pages/services/new-one.md")
self.assertEqual((meta["status"], meta["title"], meta["regions"]), ("draft", "Новая услуга", {"main": []}))
self.assertEqual(self.get("/pages/services/new-one").status, 200)
def test_create_page_rejects_bad_input(self):
for page_id in ["../x", "UPPER", "a//b", "blocks", "a/meta/b", "index", "", "a b", "ключ", "/../x", "a/../b"]:
result = self.post("/pages/new", {"page_id": page_id, "title": "T"})
self.assertEqual(result.status, 422, page_id)
self.assertEqual(self.post("/pages/new", {"page_id": "contacts", "title": "T"}).status, 422)
self.assertEqual(self.post("/pages/new", {"page_id": "ok-page", "title": ""}).status, 422)
self.assertEqual(self.post("/pages/new", {"page_id": "ok-page2", "title": "T", "layout": "nope"}).status, 422)
self.assertFalse((self.site / "pages" / "ok-page2.md").exists())
self.assertFalse((self.tmp / "x.md").exists())
before = sorted(p.relative_to(self.site).as_posix() for p in (self.site / "pages").rglob("*.md"))
self.post("/pages/new", {"page_id": "x/", "title": "T"}) # слеши по краям нормализуются
after = sorted(p.relative_to(self.site).as_posix() for p in (self.site / "pages").rglob("*.md"))
self.assertEqual(set(after) - set(before), {"pages/x.md"})
class BlockTest(EditorTestCase):
def test_block_screen_shows_fields_from_the_fragment_schema(self):
body = self.get("/pages/index/blocks/b_hero").body
for text in ("name='p.title'", "Telegram-боты, AI-системы и автоматизации", "name='p.variant'",
"name='p.actions.0.target'", "value='contacts'", "name='p.actions.1.target'", # вторая строка пустая
"name='p.subtitle._bind'", "name='s.hidden'", "feature.demo"):
self.assertIn(text, body)
def test_binding_is_preserved_through_the_form(self):
body = self.get("/pages/contacts/blocks/b_text").body
self.assertIn("name='p.content._bind' value='page.body'", body)
self.assertEqual(self.submit_form("/pages/contacts/blocks/b_text", "/admin/pages/contacts/blocks/b_text").status, 303)
self.assertEqual(self.block("pages/contacts.md", "b_text")["props"], {"content": {"bind": "page.body"}})
def test_noop_block_save_is_lossless_for_every_block_of_the_example(self):
for page_id in ("index", "contacts", "services/index"):
meta, _ = self.meta(f"pages/{page_id}.md")
for block in meta["regions"]["main"]:
action = f"/admin/pages/{page_id}/blocks/{block['id']}"
before = self.block(f"pages/{page_id}.md", block["id"])
result = self.submit_form(f"/pages/{page_id}/blocks/{block['id']}", action)
self.assertEqual(result.status, 303, f"{page_id}/{block['id']}: {result.body[:400]}")
self.assertEqual(self.block(f"pages/{page_id}.md", block["id"]), before, f"{page_id}/{block['id']}")
def test_edit_text_add_list_row_and_keep_other_props(self):
action = "/admin/pages/index/blocks/b_hero"
self.submit_form("/pages/index/blocks/b_hero", action, p__title="Новый заголовок",
**{"p.actions.1.kind": "url", "p.actions.1.target": "https://t.me/acme_studio",
"p.actions.1.label": "Telegram", "p.actions.1.new_tab": "1"})
props = self.block("pages/index.md", "b_hero")["props"]
self.assertEqual(props["title"], "Новый заголовок")
self.assertEqual(props["variant"], "dark")
self.assertEqual(props["actions"][0], {"page": "contacts", "label": "Обсудить задачу"})
self.assertEqual(props["actions"][1], {"url": "https://t.me/acme_studio", "label": "Telegram", "target": "_blank"})
def test_delete_list_row(self):
action = "/admin/pages/index/blocks/b_steps"
self.submit_form("/pages/index/blocks/b_steps", action, **{"p.items.0._del": "1", "p.items.4._del": "1"})
titles = [i["title"] for i in self.block("pages/index.md", "b_steps")["props"]["items"]]
self.assertEqual(titles, ["Постановка", "Разработка", "Запуск"])
def test_query_edit(self):
action = "/admin/pages/index/blocks/b_dirs"
self.submit_form("/pages/index/blocks/b_dirs", action, **{"p.source.limit": "2", "p.source.sort": "-order"})
self.assertEqual(self.block("pages/index.md", "b_dirs")["props"]["source"],
{"query": {"collection": "services", "sort": "-order", "limit": 2}})
def test_invalid_field_values_give_422_and_do_not_touch_the_file(self):
before = (self.site / "pages/index.md").read_bytes()
result = self.submit_form("/pages/index/blocks/b_dirs", "/admin/pages/index/blocks/b_dirs", **{"p.source.limit": "abc"})
self.assertEqual(result.status, 422)
self.assertIn("limit", result.body)
result = self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", **{"p.subtitle._bind": "os.environ"})
self.assertEqual(result.status, 422)
result = self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="{{ 7*7 }}")
self.assertEqual(result.status, 422)
self.assertIn("E_TEMPLATE_IN_DATA", result.body)
result = self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", **{"s.anchor": "1 bad"})
self.assertEqual(result.status, 422)
self.assertEqual((self.site / "pages/index.md").read_bytes(), before)
def test_error_response_keeps_what_the_user_typed(self):
result = self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero",
p__title="Мой текст", **{"s.anchor": "1 bad"})
self.assertEqual(result.status, 422)
self.assertIn("Мой текст", result.body)
def test_block_settings(self):
action = "/admin/pages/index/blocks/b_cta"
self.submit_form("/pages/index/blocks/b_cta", action, **{"s.hidden": "1", "s.anchor": "contact", "s.note": "временно",
"s.requires": ["feature.demo"]})
block = self.block("pages/index.md", "b_cta")
self.assertEqual((block["hidden"], block["anchor"], block["note"], block["requires"]), (True, "contact", "временно", ["feature.demo"]))
def test_add_block_to_region_then_fill_it_and_see_it_in_preview(self):
result = self.post("/pages/privacy/add", {"etag": self.form("/pages/privacy", "/admin/pages/privacy/add").first("etag"),
"region": "main", "fragment": "disclaimer"})
self.assertEqual(result.status, 303)
location = result.headers["Location"]
self.assertRegex(location, r"^/admin/pages/privacy/blocks/b_[a-z0-9]{5}\?msg=added$")
block_id = location.split("/blocks/")[1].split("?")[0]
path = f"/pages/privacy/blocks/{block_id}"
self.submit_form(path, f"/admin{path}", p__text="Важная **оговорка**")
self.assertIn("Важная <strong>оговорка</strong>", self.get("/preview/pages/privacy").body)
def test_add_block_to_slot(self):
self.post("/pages/privacy/add", {"etag": self.form("/pages/privacy", "/admin/pages/privacy/add").first("etag"),
"region": "main", "fragment": "section"})
section = self.meta("pages/privacy.md")[0]["regions"]["main"][-1]["id"]
page = self.get("/pages/privacy").body
self.assertIn("Слот «content»", page)
etag = scrape_form(page, "/admin/pages/privacy/add")["etag"][0]
result = self.post("/pages/privacy/add", {"etag": etag, "parent": section, "slot": "content", "fragment": "richtext"})
self.assertEqual(result.status, 303)
children = self.block("pages/privacy.md", section)["slots"]["content"]
self.assertEqual(children[0]["fragment"], "richtext")
def test_adding_to_fixed_region_or_unknown_fragment_is_refused(self):
before = (self.site / "pages/privacy.md").read_bytes()
etag = self.form("/pages/privacy", "/admin/pages/privacy/add").first("etag")
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "region": "header", "fragment": "hero"}).status, 422)
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "region": "main", "fragment": "no_such"}).status, 422)
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "fragment": "hero"}).status, 422)
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "parent": "ghost", "slot": "x", "fragment": "hero"}).status, 422)
self.assertEqual((self.site / "pages/privacy.md").read_bytes(), before)
def _act(self, block_id, action, **extra):
etag = scrape_form(self.get("/pages/index").body, f"/admin/pages/index/blocks/{block_id}/{action}")["etag"][0]
return self.post(f"/pages/index/blocks/{block_id}/{action}", {"etag": etag, **extra})
def test_move_up_and_down_and_edges(self):
ids = lambda: [b["id"] for b in self.meta("pages/index.md")[0]["regions"]["main"]]
self.assertEqual(ids(), ["b_hero", "b_dirs", "b_demo", "b_steps", "b_cta"])
self.assertEqual(self._act("b_cta", "move", dir="up").status, 303)
self.assertEqual(ids(), ["b_hero", "b_dirs", "b_demo", "b_cta", "b_steps"])
self._act("b_hero", "move", dir="down")
self.assertEqual(ids()[:2], ["b_dirs", "b_hero"])
before = (self.site / "pages/index.md").read_bytes()
result = self._act("b_dirs", "move", dir="up") # уже первый
self.assertEqual((result.status, (self.site / "pages/index.md").read_bytes()), (303, before))
def test_delete_and_toggle_hidden_change_the_preview(self):
self.assertIn("Расскажите о задаче", self.get("/preview/pages/index").body)
self._act("b_cta", "toggle")
self.assertTrue(self.block("pages/index.md", "b_cta")["hidden"])
self.assertNotIn("Расскажите о задаче", self.get("/preview/pages/index").body)
self._act("b_cta", "toggle")
self.assertNotIn("hidden", self.block("pages/index.md", "b_cta"))
self._act("b_cta", "delete")
self.assertEqual([b["id"] for b in self.meta("pages/index.md")[0]["regions"]["main"]],
["b_hero", "b_dirs", "b_demo", "b_steps"])
def test_block_actions_use_if_match(self):
etag = scrape_form(self.get("/pages/index").body, "/admin/pages/index/blocks/b_cta/delete")["etag"][0]
self.edit("pages/index.md", "Расскажите о задаче", "Расскажите подробнее")
result = self.post("/pages/index/blocks/b_cta/delete", {"etag": etag})
self.assertEqual(result.status, 409)
self.assertEqual(self.block("pages/index.md", "b_cta")["props"]["title"], "Расскажите подробнее")
def test_missing_required_prop_is_saved_but_reported_and_blocks_publish(self):
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="")
self.assertNotIn("title", self.block("pages/index.md", "b_hero")["props"])
page = self.get("/pages/index").body
self.assertIn("E_REQUIRED", page) # проверка страницы показывает проблему
result = self.post("/publish")
self.assertEqual(result.status, 422)
self.assertIn("E_REQUIRED", result.body)
self.assertFalse((self.dist / "current").exists())
class PreviewTest(EditorTestCase):
def test_preview_pages_entries_and_drafts(self):
result = self.get("/preview/pages/index")
self.assertEqual(result.status, 200)
self.assertIn("Telegram-боты, AI-системы и автоматизации", result.body)
self.assertIn("frame-ancestors 'self'", result.headers["Content-Security-Policy"])
self.assertEqual(result.headers["X-Frame-Options"], "SAMEORIGIN")
self.assertIn("Черновик", self.get("/preview/pages/drafts/next").body)
self.assertIn("Автоматизация общения", self.get("/preview/entries/services/bots").body)
self.assertEqual(self.get("/preview/pages/nope").status, 404)
self.assertEqual(self.get("/preview/entries/services/nope").status, 404)
def test_preview_requires_login(self):
self.assertEqual(self.get("/preview/pages/index", cookie=None).status, 303)
class EntryTest(EditorTestCase):
def test_collections_and_entries_screens(self):
self.assertIn("Услуги", self.get("/content").body)
body = self.get("/content/services").body
for text in ("bots", "Telegram-боты", "/services/bots/", "Новая запись"):
self.assertIn(text, body)
body = self.get("/content/services/bots").body
for text in ("name='p.title'", "name='p.tagline'", "name='p.order'", "name='status'", "name='body'", "Предпросмотр"):
self.assertIn(text, body)
def test_noop_entry_save_is_lossless(self):
for slug in ("bots", "ai", "automation"):
rel = f"content/services/{slug}.md"
before = self.meta(rel)
action = f"/admin/content/services/{slug}"
self.assertEqual(self.submit_form(f"/content/services/{slug}", action).status, 303, slug)
after = self.meta(rel)
self.assertEqual(after[0], before[0], slug)
self.assertEqual(after[1].strip(), before[1].strip(), slug)
def test_edit_entry_fields_status_and_body(self):
self.submit_form("/content/services/bots", "/admin/content/services/bots", p__tagline="Новый слоган",
p__order="5", status="draft", body="Новый **текст**")
meta, body = self.meta("content/services/bots.md")
self.assertEqual((meta["tagline"], meta["order"], meta["status"]), ("Новый слоган", 5, "draft"))
self.assertEqual(body.strip(), "Новый **текст**")
# запись-черновик не попадает в запросы коллекции
self.assertNotIn("Новый слоган", self.get("/preview/pages/index").body)
def test_invalid_entry_values(self):
before = (self.site / "content/services/bots.md").read_bytes()
result = self.submit_form("/content/services/bots", "/admin/content/services/bots", p__order="abc")
self.assertEqual(result.status, 422)
self.assertIn("ожидается число", result.body)
self.assertEqual((self.site / "content/services/bots.md").read_bytes(), before)
def test_entry_stale_etag(self):
form = self.form("/content/services/bots", "/admin/content/services/bots")
self.edit("content/services/bots.md", "Автоматизация общения", "Чужая правка")
form._d["p.tagline"] = ["Моя правка"]
self.assertEqual(self.post("/content/services/bots", form).status, 409)
self.assertIn("Чужая правка", (self.site / "content/services/bots.md").read_text(encoding="utf-8"))
def test_create_entry(self):
result = self.post("/content/services/new", {"slug": "mobile"})
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/content/services/mobile?msg=created"))
self.assertEqual(self.meta("content/services/mobile.md")[0], {"status": "draft"})
for slug in ("bots", "UPPER", "new", "a b", "../x", ""):
self.assertEqual(self.post("/content/services/new", {"slug": slug}).status, 422, slug)
def test_unknown_key_blocks_published_entry_but_not_draft(self):
self.edit("content/services/ai.md", "order: 2", "order: 2\nlegacy: 1")
result = self.submit_form("/content/services/ai", "/admin/content/services/ai")
self.assertEqual(result.status, 422)
self.assertIn("не описано схемой", result.body)
self.edit("content/services/ai.md", "status: published", "status: draft")
self.assertEqual(self.submit_form("/content/services/ai", "/admin/content/services/ai").status, 303)
self.assertEqual(self.meta("content/services/ai.md")[0]["legacy"], 1) # ничего не потеряно
class PublishTest(EditorTestCase):
def test_publish_and_rollback(self):
self.assertIn("Релизов пока нет", self.get("/publish").body)
self.assertEqual(self.post("/publish").headers["Location"], "/admin/publish?msg=published")
first = (self.dist / "current").resolve().name
self.assertTrue((self.dist / first / "index.html").is_file())
# меняем страницу и публикуем снова (имя релиза содержит время: ждём другую секунду через правку содержимого)
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="Заголовок v2")
with mock.patch("site_engine.build.pipeline.dt") as fake_dt:
import datetime as real
fake_dt.datetime.now.return_value = real.datetime(2030, 1, 1, tzinfo=real.timezone.utc)
fake_dt.timezone = real.timezone
self.post("/publish")
second = (self.dist / "current").resolve().name
self.assertNotEqual(first, second)
self.assertIn("Заголовок v2", (self.dist / second / "index.html").read_text(encoding="utf-8"))
page = self.get("/publish").body
self.assertIn("текущий", page)
self.assertEqual(self.post(f"/publish/rollback/{first}").headers["Location"], "/admin/publish?msg=rolled_back")
self.assertEqual((self.dist / "current").resolve().name, first)
self.assertEqual(self.post("/publish/rollback/20300101T000000-deadbeef").status, 404)
def test_failed_publish_keeps_live_site(self):
self.post("/publish")
live = (self.dist / "current").resolve().name
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="")
self.assertEqual(self.post("/publish").status, 422)
self.assertEqual((self.dist / "current").resolve().name, live)
def test_audit_trail_of_editor_actions_has_no_content(self):
self.post("/pages/new", {"page_id": "audit-test", "title": "СекретныйЗаголовок"})
self.submit_form("/pages/audit-test", "/admin/pages/audit-test/meta", body="СекретныйТекст")
self.post("/publish")
audit = self.audit_text()
events = [json.loads(line)["event"] for line in audit.splitlines()]
for event in ("page_create", "page_save", "publish"):
self.assertIn(event, events)
for secret in ("СекретныйЗаголовок", "СекретныйТекст"):
self.assertNotIn(secret, audit)
class WriteScopeTest(EditorTestCase):
def test_editor_never_writes_outside_pages_and_content(self):
snapshot = {p: p.read_bytes() for p in self.site.rglob("*") if p.is_file() and not any(
part in (".engine",) for part in p.parts) and p.relative_to(self.site).parts[0] not in ("pages", "content")}
self.post("/pages/new", {"page_id": "scope-test", "title": "T"})
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="X")
self.post("/content/services/new", {"slug": "scope"})
after = {p: p.read_bytes() for p in snapshot}
self.assertEqual(after, snapshot)
if __name__ == "__main__":
unittest.main()
+190
View File
@@ -0,0 +1,190 @@
import datetime as dt
import unittest
from site_engine.core import page_ops
from site_engine.core.models import FieldDef
from site_engine.web.admin.forms import UNSET, FormData, build_view, parse_field, parse_props
F = FieldDef
def form(**kw):
return FormData({k.replace("__", "."): ([v] if isinstance(v, str) else v) for k, v in kw.items()})
class ParseTest(unittest.TestCase):
def parse(self, fd, data, name="p.x"):
errors: list[str] = []
value = parse_field(fd, FormData(data), name, errors)
return value, errors
def test_empty_values_are_unset(self):
for fd in (F("x", "text"), F("x", "textarea"), F("x", "number"), F("x", "select", options=["a"]),
F("x", "boolean"), F("x", "list", of="text"), F("x", "link"), F("x", "query")):
self.assertIs(self.parse(fd, {})[0], UNSET, fd.type)
self.assertIs(self.parse(fd, {"p.x": [""]})[0], UNSET, fd.type)
def test_text_number_boolean_select(self):
self.assertEqual(self.parse(F("x", "text"), {"p.x": [" привет "]})[0], "привет")
self.assertEqual(self.parse(F("x", "number"), {"p.x": ["3"]})[0], 3)
self.assertEqual(self.parse(F("x", "number"), {"p.x": ["2,5"]})[0], 2.5)
self.assertEqual(self.parse(F("x", "boolean"), {"p.x": ["false"]})[0], False)
self.assertEqual(self.parse(F("x", "select", options=[2, 3, 4]), {"p.x": ["3"]})[0], 3) # тип варианта сохраняется
def test_errors_are_reported_not_raised(self):
value, errors = self.parse(F("x", "number", label="Число"), {"p.x": ["abc"]})
self.assertIs(value, UNSET)
self.assertIn("Число", errors[0])
self.assertTrue(self.parse(F("x", "select", options=["a"]), {"p.x": ["b"]})[1])
self.assertTrue(self.parse(F("x", "date"), {"p.x": ["31.12.2026"]})[1])
self.assertTrue(self.parse(F("x", "date"), {"p.x": ["2026-02-31"]})[1])
def test_date_becomes_date_object(self):
self.assertEqual(self.parse(F("x", "date"), {"p.x": ["2026-03-12"]})[0], dt.date(2026, 3, 12))
def test_textarea_normalizes_newlines(self):
self.assertEqual(self.parse(F("x", "markdown"), {"p.x": ["a\r\nb\r\n\r\n"]})[0], "a\nb")
def test_bind_wins_over_literal_and_is_validated(self):
value, _ = self.parse(F("x", "markdown"), {"p.x": ["текст"], "p.x._bind": ["page.body"]})
self.assertEqual(value, {"bind": "page.body"})
value, errors = self.parse(F("x", "text"), {"p.x._bind": ["os.environ"]})
self.assertIs(value, UNSET)
self.assertTrue(errors)
def test_link(self):
value, _ = self.parse(F("x", "link"), {"p.x.kind": ["page"], "p.x.target": ["contacts"], "p.x.label": ["Связь"]})
self.assertEqual(value, {"page": "contacts", "label": "Связь"})
value, _ = self.parse(F("x", "link"), {"p.x.kind": ["url"], "p.x.target": ["https://t.me/x"], "p.x.new_tab": ["1"]})
self.assertEqual(value, {"url": "https://t.me/x", "target": "_blank"})
self.assertTrue(self.parse(F("x", "link"), {"p.x.kind": ["file"], "p.x.target": ["a"]})[1])
def test_list_of_groups_skips_blank_and_deleted_rows(self):
fd = F("items", "list", fields=[F("title", "text", required=True), F("text", "markdown")])
data = {
"p.items.0.title": ["Один"], "p.items.0.text": ["a"],
"p.items.1.title": ["Удалить"], "p.items.1._del": ["1"],
"p.items.2.title": ["Три"],
"p.items.3.title": [""], "p.items.3.text": [""], # пустая строка «добавить»
}
value, errors = self.parse(fd, data, "p.items")
self.assertEqual(value, [{"title": "Один", "text": "a"}, {"title": "Три"}])
self.assertEqual(errors, [])
def test_list_of_primitives_and_links(self):
self.assertEqual(self.parse(F("t", "list", of="text"), {"p.t.0": ["a"], "p.t.1": [""], "p.t.2": ["b"]}, "p.t")[0], ["a", "b"])
value, _ = self.parse(F("a", "list", of="link"),
{"p.a.0.kind": ["page"], "p.a.0.target": ["contacts"], "p.a.1.target": [""]}, "p.a")
self.assertEqual(value, [{"page": "contacts"}])
def test_list_row_bind(self):
fd = F("meta", "list", of="text")
value, _ = self.parse(fd, {"p.meta.0._bind": ["entry.tagline"]}, "p.meta")
self.assertEqual(value, [{"bind": "entry.tagline"}])
def test_query(self):
data = {"p.s.collection": ["services"], "p.s.limit": ["3"], "p.s.sort": ["-date"], "p.s.where": ["featured: true"]}
value, errors = self.parse(F("s", "query"), data, "p.s")
self.assertEqual(value, {"query": {"collection": "services", "where": {"featured": True}, "sort": "-date", "limit": 3}})
self.assertEqual(errors, [])
self.assertTrue(self.parse(F("s", "query"), {"p.s.collection": ["a"], "p.s.limit": ["0"]}, "p.s")[1])
self.assertTrue(self.parse(F("s", "query"), {"p.s.collection": ["a"], "p.s.where": ["x: {contains: 1}"]}, "p.s")[1])
def test_refs_and_multiselect(self):
self.assertEqual(self.parse(F("r", "refs", to="s"), {"p.r": ["a, b c"]}, "p.r")[0], ["a", "b", "c"])
self.assertEqual(self.parse(F("m", "multiselect", options=["a", "b"]), {"p.m": ["a", "b"]}, "p.m")[0], ["a", "b"])
def test_parse_props_omits_unset(self):
errors: list[str] = []
props = parse_props([F("a", "text"), F("b", "text")], form(p__a="x"), "p", errors)
self.assertEqual(props, {"a": "x"})
class ViewTest(unittest.TestCase):
CTX = {"collections": ["services"], "assets": ["assets/hero.svg"], "entries": {"services": ["bots"]}, "pages": ["contacts"]}
def test_parse_of_view_roundtrip(self):
# значения → форма → значения: ничего не теряется
fields = [
F("title", "text"), F("variant", "select", options=["light", "dark"]),
F("actions", "list", of="link"),
F("items", "list", fields=[F("title", "text"), F("text", "markdown")]),
F("src", "query"), F("flag", "boolean"),
]
props = {
"title": "Привет", "variant": "dark", "flag": False,
"actions": [{"page": "contacts", "label": "Связь"}, {"url": "https://t.me/x", "target": "_blank"}],
"items": [{"title": "Один", "text": "x"}, {"title": "Два"}],
"src": {"query": {"collection": "services", "limit": 3}},
}
views = {f.key: build_view(f, props.get(f.key), f"p.{f.key}", self.CTX) for f in fields}
self.assertEqual(views["title"]["value"], "Привет")
self.assertEqual([r["blank"] for r in views["items"]["rows"]], [False, False, True])
self.assertEqual(views["actions"]["rows"][0]["item"]["target"], "contacts")
self.assertEqual(views["src"]["limit"], "3")
def test_bind_is_exposed_separately(self):
view = build_view(F("content", "markdown"), {"bind": "page.body"}, "p.content", self.CTX)
self.assertEqual((view["bind"], view["value"]), ("page.body", ""))
def test_select_marks_current_option(self):
view = build_view(F("v", "select", options=["a", "b"]), "b", "p.v", self.CTX)
self.assertEqual([o["selected"] for o in view["options"]], [False, False, True])
class PageOpsTest(unittest.TestCase):
def meta(self):
return {"title": "T", "regions": {"main": [
{"id": "b_a", "fragment": "hero"},
{"id": "b_s", "fragment": "section", "slots": {"content": [
{"id": "b_x", "fragment": "richtext"}, {"id": "b_y", "fragment": "faq"}]}},
{"id": "b_c", "fragment": "cta_banner"},
]}}
def test_find_in_slots(self):
siblings, index, block = page_ops.find_block(self.meta(), "b_y")
self.assertEqual((index, block["fragment"]), (1, "faq"))
self.assertIsNone(page_ops.find_block(self.meta(), "nope"))
def test_move_within_own_list(self):
m = self.meta()
self.assertTrue(page_ops.move_block(m, "b_y", "up"))
self.assertEqual([b["id"] for b in m["regions"]["main"][1]["slots"]["content"]], ["b_y", "b_x"])
self.assertFalse(page_ops.move_block(m, "b_y", "up")) # уже первый
self.assertFalse(page_ops.move_block(m, "b_c", "down")) # уже последний
self.assertFalse(page_ops.move_block(m, "b_c", "sideways"))
def test_delete_nested_and_unknown(self):
m = self.meta()
page_ops.delete_block(m, "b_x")
self.assertEqual([b["id"] for b in m["regions"]["main"][1]["slots"]["content"]], ["b_y"])
with self.assertRaises(KeyError):
page_ops.delete_block(m, "b_x")
def test_add_to_region_and_slot_with_unique_ids(self):
m = self.meta()
a = page_ops.add_block(m, "image", region="main")
b = page_ops.add_block(m, "disclaimer", parent="b_s", slot="content")
c = page_ops.add_block(m, "image", region="new_region")
self.assertEqual(len({a, b, c, "b_a", "b_s", "b_x", "b_y", "b_c"}), 8)
self.assertEqual(m["regions"]["main"][-1]["id"], a)
self.assertEqual(m["regions"]["main"][1]["slots"]["content"][-1]["id"], b)
self.assertIn("new_region", m["regions"])
with self.assertRaises(KeyError):
page_ops.add_block(m, "image", parent="missing", slot="content")
def test_hidden_and_field_replace_keep_unknown_props(self):
m = self.meta()
block = page_ops.find_block(m, "b_a")[2]
block["props"] = {"title": "Старый", "legacy": 1}
page_ops.replace_block_fields(block, props={"title": "Новый"}, manifest_keys={"title"}, hidden=True,
anchor="top", note=None, requires=["feature.demo"])
self.assertEqual(block["props"], {"title": "Новый", "legacy": 1})
self.assertEqual((block["hidden"], block["anchor"], block["requires"]), (True, "top", ["feature.demo"]))
page_ops.replace_block_fields(block, props={}, manifest_keys={"title", "legacy"}, hidden=False,
anchor=None, note=None, requires=[])
self.assertEqual(block, {"id": "b_a", "fragment": "hero"})
if __name__ == "__main__":
unittest.main()