From 53980a555849f124946eb0df56bf7899d37b073f Mon Sep 17 00:00:00 2001 From: Alexey Dudin Date: Mon, 9 Nov 2026 15:45:11 +0300 Subject: [PATCH] Add page editing and publish --- README.md | 39 +- src/site_engine/core/draft_check.py | 54 ++ src/site_engine/core/page_ops.py | 142 +++++ src/site_engine/web/admin/editor.py | 586 ++++++++++++++++++ src/site_engine/web/admin/forms.py | 321 ++++++++++ src/site_engine/web/admin/handlers.py | 24 +- src/site_engine/web/admin/routes.py | 25 +- src/site_engine/web/admin/static/admin.css | 30 + .../web/admin/templates/_fields.html.j2 | 92 +++ .../web/admin/templates/base.html.j2 | 3 +- .../web/admin/templates/block_edit.html.j2 | 25 + .../web/admin/templates/content_index.html.j2 | 15 + .../web/admin/templates/dashboard.html.j2 | 15 +- .../web/admin/templates/entries_list.html.j2 | 28 + .../web/admin/templates/entry_edit.html.j2 | 26 + .../web/admin/templates/message.html.j2 | 12 + .../web/admin/templates/page_edit.html.j2 | 107 ++++ .../web/admin/templates/pages_list.html.j2 | 34 + .../web/admin/templates/publish.html.j2 | 32 + .../web/admin/templates/shell.html.j2 | 24 + src/site_engine/web/app.py | 4 +- tests/helpers_html.py | 66 ++ tests/test_admin_routes_wiring.py | 61 +- tests/test_editor.py | 480 ++++++++++++++ tests/test_editor_forms.py | 190 ++++++ 25 files changed, 2402 insertions(+), 33 deletions(-) create mode 100644 src/site_engine/core/draft_check.py create mode 100644 src/site_engine/core/page_ops.py create mode 100644 src/site_engine/web/admin/editor.py create mode 100644 src/site_engine/web/admin/forms.py create mode 100644 src/site_engine/web/admin/templates/_fields.html.j2 create mode 100644 src/site_engine/web/admin/templates/block_edit.html.j2 create mode 100644 src/site_engine/web/admin/templates/content_index.html.j2 create mode 100644 src/site_engine/web/admin/templates/entries_list.html.j2 create mode 100644 src/site_engine/web/admin/templates/entry_edit.html.j2 create mode 100644 src/site_engine/web/admin/templates/message.html.j2 create mode 100644 src/site_engine/web/admin/templates/page_edit.html.j2 create mode 100644 src/site_engine/web/admin/templates/pages_list.html.j2 create mode 100644 src/site_engine/web/admin/templates/publish.html.j2 create mode 100644 src/site_engine/web/admin/templates/shell.html.j2 create mode 100644 tests/helpers_html.py create mode 100644 tests/test_editor.py create mode 100644 tests/test_editor_forms.py diff --git a/README.md b/README.md index 34ac5b7..3c17f86 100644 --- a/README.md +++ b/README.md @@ -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/' %}`. - CSS и JS собираются в один бандл с хешем в имени; минификации и изоляции по страницам пока нет. -- Нет приёма заявок, редактора и MCP: сетевая поверхность записи включается только вместе с контуром «вход, роли, аудит, лимиты» (ADR-006). Вход уже есть, роли и аудит правок будут вместе с редактором. +- Нет приёма заявок и MCP: сетевая поверхность записи включается только вместе с контуром «вход, роли, аудит, лимиты» (ADR-006). Вход, аудит правок и редактор уже есть; роли и приём заявок остаются на M2. diff --git a/src/site_engine/core/draft_check.py b/src/site_engine/core/draft_check.py new file mode 100644 index 0000000..79de319 --- /dev/null +++ b/src/site_engine/core/draft_check.py @@ -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 diff --git a/src/site_engine/core/page_ops.py b/src/site_engine/core/page_ops.py new file mode 100644 index 0000000..946cfde --- /dev/null +++ b/src/site_engine/core/page_ops.py @@ -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()) diff --git a/src/site_engine/web/admin/editor.py b/src/site_engine/web/admin/editor.py new file mode 100644 index 0000000..bec5cc2 --- /dev/null +++ b/src/site_engine/web/admin/editor.py @@ -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[a-z0-9][a-z0-9_/-]*?)" + block_id = r"(?P[A-Za-z][A-Za-z0-9_-]{1,63})" + coll = r"(?P[a-z][a-z0-9_]*)" + slug = r"(?P[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}/(?Pmove|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\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 "

Страницу нельзя отрендерить: проверьте layout.

", + 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") diff --git a/src/site_engine/web/admin/forms.py b/src/site_engine/web/admin/forms.py new file mode 100644 index 0000000..6e79622 --- /dev/null +++ b/src/site_engine/web/admin/forms.py @@ -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 diff --git a/src/site_engine/web/admin/handlers.py b/src/site_engine/web/admin/handlers.py index b0d90bc..fdfb606 100644 --- a/src/site_engine/web/admin/handlers.py +++ b/src/site_engine/web/admin/handlers.py @@ -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") diff --git a/src/site_engine/web/admin/routes.py b/src/site_engine/web/admin/routes.py index e649c37..3d16cda 100644 --- a/src/site_engine/web/admin/routes.py +++ b/src/site_engine/web/admin/routes.py @@ -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 diff --git a/src/site_engine/web/admin/static/admin.css b/src/site_engine/web/admin/static/admin.css index 28d2c2b..b3e230b 100644 --- a/src/site_engine/web/admin/static/admin.css +++ b/src/site_engine/web/admin/static/admin.css @@ -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; } diff --git a/src/site_engine/web/admin/templates/_fields.html.j2 b/src/site_engine/web/admin/templates/_fields.html.j2 new file mode 100644 index 0000000..4115706 --- /dev/null +++ b/src/site_engine/web/admin/templates/_fields.html.j2 @@ -0,0 +1,92 @@ +{# Рекурсивные макросы для форм по схеме полей (см. web/admin/forms.py: build_view) #} +{% macro bind_box(name, bind) %} +
+ привязка + +
+{% endmacro %} + +{% macro datalist(f) %} +{% if f.datalist %}{% for v in f.datalist %}{% endif %} +{% endmacro %} + +{% macro field(f) %} +
+{% if f.kind == 'group' %} +
+ {{ f.label }}{% if f.required %} *{% endif %} + {% for c in f.children %}{{ field(c) }}{% endfor %} + {{ bind_box(f.name, f.bind) }} +
+{% elif f.kind == 'list' %} +
+ {{ f.label }}{% if f.required %} *{% endif %} + {% for row in f.rows %} +
+ {% 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 %} + Пустая строка: заполните её, чтобы добавить элемент. + {% else %} + + {% endif %} +
+ {% endfor %} +
+{% elif f.kind == 'link' %} + +{% elif f.kind == 'query' %} +
+ {{ f.label }}{% if f.required %} *{% endif %} + + + + + + {{ bind_box(f.name, f.bind) }} +
+{% elif f.kind == 'multiselect' %} +
+ {{ f.label }} + {% for o in f.options %} + + {% endfor %} + {{ bind_box(f.name, f.bind) }} +
+{% else %} + + {{ datalist(f) }} + {% if f.hint %}{{ f.hint }}{% endif %} + {{ bind_box(f.name, f.bind) }} +{% endif %} +
+{% endmacro %} diff --git a/src/site_engine/web/admin/templates/base.html.j2 b/src/site_engine/web/admin/templates/base.html.j2 index a785c19..6df5314 100644 --- a/src/site_engine/web/admin/templates/base.html.j2 +++ b/src/site_engine/web/admin/templates/base.html.j2 @@ -7,7 +7,8 @@ {% block title %}Админка{% endblock %} - + {% block body %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/src/site_engine/web/admin/templates/block_edit.html.j2 b/src/site_engine/web/admin/templates/block_edit.html.j2 new file mode 100644 index 0000000..47252f8 --- /dev/null +++ b/src/site_engine/web/admin/templates/block_edit.html.j2 @@ -0,0 +1,25 @@ +{% extends 'shell.html.j2' %} +{% from '_fields.html.j2' import field %} +{% block title %}Блок {{ block_id }} — админка{% endblock %} +{% block content %} +

← {{ page_title }}

+

{{ fragment_name }} {{ block_id }}

+{% if errors %}
    {% for e in errors %}
  • {{ e }}
  • {% endfor %}
{% endif %} +
+ + + {% for f in fields %}{{ field(f) }}{% else %}

У этого фрагмента нет полей.

{% endfor %} +
+ Настройки блока + + + + {% if features %} +
Показывать, только если включено: + {% for name, on in features %}{% endfor %} +
+ {% endif %} +
+ +
+{% endblock %} diff --git a/src/site_engine/web/admin/templates/content_index.html.j2 b/src/site_engine/web/admin/templates/content_index.html.j2 new file mode 100644 index 0000000..67f24eb --- /dev/null +++ b/src/site_engine/web/admin/templates/content_index.html.j2 @@ -0,0 +1,15 @@ +{% extends 'shell.html.j2' %} +{% block title %}Контент — админка{% endblock %} +{% block content %} +

Контент

+ + + + {% for c in collections %} + + {% else %} + + {% endfor %} + +
КоллекцияЗаписейОпубликовано
{{ c.name }}{{ c.total }}{{ c.published }}
Коллекций нет
+{% endblock %} diff --git a/src/site_engine/web/admin/templates/dashboard.html.j2 b/src/site_engine/web/admin/templates/dashboard.html.j2 index f8b95d8..d33bdb8 100644 --- a/src/site_engine/web/admin/templates/dashboard.html.j2 +++ b/src/site_engine/web/admin/templates/dashboard.html.j2 @@ -1,16 +1,6 @@ -{% extends 'base.html.j2' %} +{% extends 'shell.html.j2' %} {% block title %}Обзор — админка{% endblock %} -{% block body %} -
- Админка - - {{ login }} -
- - -
-
-
+{% block content %} {% if site_error %} {% else %} @@ -40,5 +30,4 @@ {% endfor %} {% endif %} -
{% endblock %} diff --git a/src/site_engine/web/admin/templates/entries_list.html.j2 b/src/site_engine/web/admin/templates/entries_list.html.j2 new file mode 100644 index 0000000..ca96d0e --- /dev/null +++ b/src/site_engine/web/admin/templates/entries_list.html.j2 @@ -0,0 +1,28 @@ +{% extends 'shell.html.j2' %} +{% block title %}{{ collection.name }} — админка{% endblock %} +{% block content %} +

← Контент

+

{{ collection.name }}

+ + + + {% for e in entries %} + + + + + + + {% else %} + + {% endfor %} + +
ЗаписьАдресСтатус
{{ e.title }}
{{ e.slug }}
{{ e.route }}{{ e.status }}Изменить
Записей пока нет
+

Новая запись

+{% if errors %}
    {% for e in errors %}
  • {{ e }}
  • {% endfor %}
{% endif %} +
+ + + +
+{% endblock %} diff --git a/src/site_engine/web/admin/templates/entry_edit.html.j2 b/src/site_engine/web/admin/templates/entry_edit.html.j2 new file mode 100644 index 0000000..8468c05 --- /dev/null +++ b/src/site_engine/web/admin/templates/entry_edit.html.j2 @@ -0,0 +1,26 @@ +{% extends 'shell.html.j2' %} +{% from '_fields.html.j2' import field %} +{% block title %}{{ slug }} — админка{% endblock %} +{% block content %} +

← {{ collection.name }}

+

{{ slug }}

+

{{ file }}

+{% if errors %}
    {% for e in errors %}
  • {{ e }}
  • {% endfor %}
{% endif %} +{% if issues %}
    {% for i in issues %}
  • {{ i.code }} {{ i.message }}
  • {% endfor %}
{% endif %} +
+ + + + {% for f in fields %}{{ field(f) }}{% endfor %} + {% if has_body %} + + {% endif %} + +
+{% if preview %} +

Предпросмотр

+ +{% endif %} +{% endblock %} diff --git a/src/site_engine/web/admin/templates/message.html.j2 b/src/site_engine/web/admin/templates/message.html.j2 new file mode 100644 index 0000000..28e199a --- /dev/null +++ b/src/site_engine/web/admin/templates/message.html.j2 @@ -0,0 +1,12 @@ +{% extends 'shell.html.j2' %} +{% block title %}{{ title }} — админка{% endblock %} +{% block content %} +

{{ title }}

+{% if text %}

{{ text }}

{% endif %} +{% if issues %} +
    +{% for i in issues %}
  • {{ i.code }} {{ i.path }} {{ i.message }}{% if i.hint %} ({{ i.hint }}){% endif %}
  • {% endfor %} +
+{% endif %} +{% for l in links %}

{{ l.label }}

{% endfor %} +{% endblock %} diff --git a/src/site_engine/web/admin/templates/page_edit.html.j2 b/src/site_engine/web/admin/templates/page_edit.html.j2 new file mode 100644 index 0000000..bc34b1c --- /dev/null +++ b/src/site_engine/web/admin/templates/page_edit.html.j2 @@ -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='') %} +
+ + + {% if name %}{% endif %} + +
+{% endmacro %} + +{% macro add_form(region='', parent='', slot='') %} +
+ + + {% if region %}{% endif %} + {% if parent %}{% endif %} + + +
+{% endmacro %} + +{% macro blocks(items) %} +
    +{% for b in items %} +
  • +
    + {{ b.fragment }} {{ b.id }} + {% if b.hidden %}скрыт{% endif %} + {% if b.requires %}нужны: {{ b.requires|join(', ') }}{% endif %} + {{ b.summary }} +
    +
    + Изменить + {{ 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') }} +
    + {% for s in b.slots %} +
    +

    Слот «{{ s.name }}»

    + {{ blocks(s.blocks) }} + {{ add_form(parent=b.id, slot=s.name) }} +
    + {% endfor %} +
  • +{% endfor %} +
+{% endmacro %} + +{% block content %} +

← Все страницы

+

{{ values.title }}

+

{{ file }} · адрес {{ route }}

+ +{% if errors %}
    {% for e in errors %}
  • {{ e }}
  • {% endfor %}
{% endif %} +{% if issues %} +
+ Проверка страницы: {{ issues|length }} +
    + {% for i in issues %}
  • {{ i.code }} {{ i.message }} {{ i.path }}
  • {% endfor %} +
+
+{% endif %} + +

Страница

+
+ + + + + + + + + +
+ +

Блоки

+{% for r in regions %} +
+

Регион «{{ r.name }}»

+ {% if r.fixed %} +

Закреплены в layout: {% for f in r.fixed %}{{ f.fragment }} {% endfor %}

+ {% endif %} + {{ blocks(r.blocks) }} + {% if r.can_add %}{{ add_form(region=r.name) }}{% endif %} +
+{% endfor %} + +

Предпросмотр

+ +{% endblock %} diff --git a/src/site_engine/web/admin/templates/pages_list.html.j2 b/src/site_engine/web/admin/templates/pages_list.html.j2 new file mode 100644 index 0000000..dcc7cd0 --- /dev/null +++ b/src/site_engine/web/admin/templates/pages_list.html.j2 @@ -0,0 +1,34 @@ +{% extends 'shell.html.j2' %} +{% block title %}Страницы — админка{% endblock %} +{% block content %} +

Страницы

+ + + + {% for p in pages %} + + + + + + + {% endfor %} + +
СтраницаАдресСтатус
{{ p.title }}
{{ p.id }}
{{ p.route }}{{ p.status }}Изменить
+

Новая страница

+{% if errors %}
    {% for e in errors %}
  • {{ e }}
  • {% endfor %}
{% endif %} +
+ + + + + +
+{% endblock %} diff --git a/src/site_engine/web/admin/templates/publish.html.j2 b/src/site_engine/web/admin/templates/publish.html.j2 new file mode 100644 index 0000000..66ecff0 --- /dev/null +++ b/src/site_engine/web/admin/templates/publish.html.j2 @@ -0,0 +1,32 @@ +{% extends 'shell.html.j2' %} +{% block title %}Публикация — админка{% endblock %} +{% block content %} +

Публикация

+{% if issues %} +

Проблемы сборки

+
    {% for i in issues %}
  • {{ i.code }} {{ i.path }} {{ i.message }}
  • {% endfor %}
+{% endif %} +

Сейчас на сайте: {% if current %}{{ current }}{% else %}ничего не опубликовано{% endif %}

+
+ + +
+

В релиз попадают только страницы и записи со статусом published. Если сборка не пройдёт проверку, опубликованный сайт не изменится.

+

Релизы

+ + + + {% for b in builds %} + + + + + {% else %} + + {% endfor %} + +
Релиз
{{ b.id }}{% if b.current %} текущий{% endif %}{% if not b.current %} +
+ +
{% endif %}
Релизов пока нет
+{% endblock %} diff --git a/src/site_engine/web/admin/templates/shell.html.j2 b/src/site_engine/web/admin/templates/shell.html.j2 new file mode 100644 index 0000000..b22a021 --- /dev/null +++ b/src/site_engine/web/admin/templates/shell.html.j2 @@ -0,0 +1,24 @@ +{% extends 'base.html.j2' %} +{% block bodyattrs %}{% if htmx %} hx-boost='true'{% endif %}{% endblock %} +{% block scripts %}{% if htmx %}{% endif %}{% endblock %} +{% block body %} +
+ Админка + + + {{ login }} +
+ + +
+
+{% if flash %}

{{ flash }}

{% endif %} +
+{% block content %}{% endblock %} +
+{% endblock %} diff --git a/src/site_engine/web/app.py b/src/site_engine/web/app.py index 4c9bddb..67954ce 100644 --- a/src/site_engine/web/app.py +++ b/src/site_engine/web/app.py @@ -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") diff --git a/tests/helpers_html.py b/tests/helpers_html.py new file mode 100644 index 0000000..d299a64 --- /dev/null +++ b/tests/helpers_html.py @@ -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 diff --git a/tests/test_admin_routes_wiring.py b/tests/test_admin_routes_wiring.py index 8f7aa04..d34b82f 100644 --- a/tests/test_admin_routes_wiring.py +++ b/tests/test_admin_routes_wiring.py @@ -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() diff --git a/tests/test_editor.py b/tests/test_editor.py new file mode 100644 index 0000000..aee1fdf --- /dev/null +++ b/tests/test_editor.py @@ -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 ("alert(1)'") + for path in ("/pages", "/pages/privacy", "/"): + if path == "/": + continue + self.assertNotIn("", self.get(path).body, path) + self.assertIn("<script>", 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("Важная оговорка", 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() diff --git a/tests/test_editor_forms.py b/tests/test_editor_forms.py new file mode 100644 index 0000000..9f9efb9 --- /dev/null +++ b/tests/test_editor_forms.py @@ -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()