Add page editing and publish
This commit is contained in:
@@ -26,7 +26,7 @@ site-engine/
|
||||
├── docs/ # ТЗ, ревью, журнал решений
|
||||
├── examples/studio-site/ # сайт-пример из SiteMap.md (услуги, формы, коллекция, редирект)
|
||||
├── .env.example # переменные окружения для админки
|
||||
├── tests/ # 112 тестов: ядро, сборка, безопасность, запись, вход в админку
|
||||
├── tests/ # 178 тестов: ядро, сборка, безопасность, запись, вход и редактор
|
||||
└── src/site_engine/
|
||||
├── cli.py # validate · build · preview · fragments
|
||||
├── errors.py # Issue/Report: код, путь к полю, серьёзность, подсказка
|
||||
@@ -37,6 +37,8 @@ site-engine/
|
||||
│ ├── routes.py # нормализация маршрутов, таблица, коллизии
|
||||
│ ├── resolve.py # привязки, ссылки, запросы MVP
|
||||
│ ├── validate.py # workspace-проверки, release-проверки, правила сайта
|
||||
│ ├── draft_check.py # проверка при сохранении: новый текст файла против реестра
|
||||
│ ├── page_ops.py # добавить, переместить, удалить блок по id в сыром front matter
|
||||
│ └── render.py # Jinja SandboxedEnvironment, разрешение props по схеме
|
||||
├── build/pipeline.py # load → validate → render → релиз → атомарный current
|
||||
├── parsing/ # безопасный YAML, front matter, Markdown (raw HTML выключен)
|
||||
@@ -44,7 +46,7 @@ site-engine/
|
||||
├── services/ # auth (вход админа), ContentService (if_match, история), publish; stubs: changeset, forms
|
||||
├── builtin/ # base.css и 15 фрагментов ядра (ADR-006)
|
||||
├── db/ # SQLAlchemy-модели служебных таблиц (M2)
|
||||
├── web/ # FastAPI-фабрика; admin/: handlers (вход, выход, обзор), шаблоны, routes-адаптер
|
||||
├── web/ # FastAPI-фабрика; admin/: handlers (вход, обзор), editor (страницы, блоки, записи, публикация), forms, шаблоны, routes-адаптер
|
||||
└── mcp/ # перечень инструментов MVP (M3)
|
||||
```
|
||||
|
||||
@@ -79,6 +81,33 @@ SITE_COOKIE_SECURE=0 uvicorn site_engine.web.app:create_app --factory --env-file
|
||||
- Выход завершает все сессии администратора сразу, отдельного списка устройств нет.
|
||||
- Отдельная смена пароля: сгенерировать новый хеш и перезапустить сервис; чтобы разлогинить всех, поменяйте `SITE_SECRET_KEY`.
|
||||
|
||||
## Редактор
|
||||
|
||||
После входа в `/admin/` доступны страницы, контент и публикация. Все правки идут через `ContentService`: блокировка сайта, `if_match` по хешу файла, проверка синтаксиса, история в `.engine/history/`, атомарная запись. Редактор пишет только в `pages/` и `content/`; фрагменты, layouts, схемы и `site.yaml` через него изменить нельзя.
|
||||
|
||||
| Экран | Что умеет |
|
||||
|---|---|
|
||||
| Страницы | Список со статусами и адресами; создание черновика (путь, заголовок, layout) |
|
||||
| Страница | Заголовок, статус, layout, адрес, описание, текст Markdown; блоки по регионам и слотам: добавить, ↑/↓, скрыть и показать, удалить; предпросмотр в изолированном фрейме; список проблем страницы |
|
||||
| Блок | Форма строится из манифеста фрагмента: текст, Markdown, число, список, группа, выбор, ссылка (страница, запись, адрес), запрос к коллекции, ассет; у каждого поля поле «привязка» (`entry.title`, `page.body`…); якорь, заметка, скрыть, `requires` по флагам сайта |
|
||||
| Контент | Записи коллекций: поля по схеме, статус, текст Markdown, создание черновика, предпросмотр |
|
||||
| Публикация | Сборка релиза, список релизов, возврат к прежнему релизу |
|
||||
|
||||
Гарантии, которые проверены тестами:
|
||||
|
||||
- **Без потерь.** Форма открывается из файла и отправляется обратно без изменений: у каждого блока примера, всех страниц и записей YAML остаётся тем же по смыслу. Неизвестные ключи не пропадают, привязки сохраняются.
|
||||
- **Конфликты.** Если файл изменили в другом окне, правка получит 409, а чужие изменения не будут перезаписаны.
|
||||
- **Проверка при сохранении.** Нельзя сохранить неизвестный фрагмент, несуществующий layout, блок в закреплённый регион, значение не того типа, `{{ }}` в данных, привязку к чужому корню. Пропуск обязательного поля не блокирует сохранение (ADR-003), но он виден в «Проверке страницы», и сборка релиза с ним не пройдёт; опубликованный сайт при этом не меняется.
|
||||
- **Безопасность.** Каждый POST требует CSRF-токен и Origin своего хоста; id страниц, блоков и записей проверяются регулярным выражением и поиском в реестре, до пути на диске недоступны; предпросмотр отдаётся в `sandbox`-фрейме с CSP без скриптов; в аудит попадают id и тип действия, но не содержимое.
|
||||
|
||||
Что работает иначе, чем можно ожидать:
|
||||
|
||||
- **Без JS.** Порядок блоков меняется кнопками ↑/↓, элементы списков добавляются через «пустую строку» формы. Скачать htmx и SortableJS в окружении без сети было нельзя, поэтому редактор целиком работает на обычных формах. Если положить `htmx.min.js` в `src/site_engine/web/admin/static/`, админка включит `hx-boost` сама (проверено только разметкой, с настоящим htmx не запускалось).
|
||||
- **Первая правка файла переформатирует его YAML** в блочный стиль: `{id: b_1, fragment: hero}` станет несколькими строками. Смысл и порядок ключей сохраняются.
|
||||
- **Ассеты** выбираются по пути из подсказки, загрузки файлов в редакторе пока нет.
|
||||
- **Блоки не переносятся между регионами**, только внутри своего списка.
|
||||
- **Запись коллекции со «лишним» ключом**, которого нет в схеме, нельзя сохранить в статусе `published`, пока ключ не уберут из файла: так требует ADR-003.
|
||||
|
||||
## Что реализовано
|
||||
|
||||
| Этап | Состояние |
|
||||
@@ -86,12 +115,12 @@ SITE_COOKIE_SECURE=0 uvicorn site_engine.web.app:create_app --factory --env-file
|
||||
| M0 Контракт и прототип | Готово: формат файлов, модель блоков, load → validate → render, CLI, 15 фрагментов, сайт-пример |
|
||||
| M1 Публикуемый движок | Частично: маршруты, ссылки, редиректы, sitemap, атомарная публикация, откат (`services/publish.py`), превью страницы через CLI. Нет: превью по токену, 404-страница из коробки, тема |
|
||||
| M2 Коллекции, заявки, доступ | Частично: коллекции, display templates, запросы, формы (разметка, версия формы в релизе), **вход одного администратора с аудитом входов и обзорная страница админки**. Нет: роли, приём заявок, outbox, аудит правок |
|
||||
| M3 MCP и редактор | `ContentService` с `if_match`, блокировкой и историей готов; нет редактора страниц, `patch_page`, changeset, MCP-сервера |
|
||||
| M3 MCP и редактор | Готово: редактор страниц, блоков и записей на `ContentService`, предпросмотр, публикация и откат из админки. Нет: `patch_page`, changeset (rename, delete), MCP-сервера, перетаскивания, загрузки файлов |
|
||||
| M4 | Не начат |
|
||||
|
||||
## Что проверено, а что нет
|
||||
|
||||
Тесты и сборка примера выполнялись в окружении без сети: ядро (`core/`, `build/`, `parsing/`, `storage/`, `services/`) и вся логика админки (`web/admin/handlers.py`, шаблоны, вход, CSRF, заголовки) запущены и покрыты 112 тестами. Тонкий FastAPI-адаптер `web/admin/routes.py` проверен на подставном модуле `fastapi`, а `web/app.py`, `db/`, `mcp/` и `Dockerfile` только компиляцией и чтением: FastAPI, SQLAlchemy и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp).
|
||||
Тесты и сборка примера выполнялись в окружении без сети: ядро (`core/`, `build/`, `parsing/`, `storage/`, `services/`) и вся логика админки (`web/admin/handlers.py`, `editor.py`, `forms.py`, шаблоны, вход, CSRF, заголовки) запущены и покрыты 178 тестами, включая сквозные через HTML-формы. Тонкий FastAPI-адаптер `web/admin/routes.py` проверен на подставном модуле `fastapi`, а `web/app.py`, `db/`, `mcp/` и `Dockerfile` только компиляцией и чтением: FastAPI, SQLAlchemy и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp).
|
||||
|
||||
## Соответствие журналу решений
|
||||
|
||||
@@ -115,4 +144,4 @@ SITE_COOKIE_SECURE=0 uvicorn site_engine.web.app:create_app --factory --env-file
|
||||
- Поле `props` в шаблоне — объект `Props`: `props.items` читает поле «items», а не метод словаря.
|
||||
- `layout.extends` проверяется на существование, наследование шаблонов делается обычным `{% extends 'layout/<id>' %}`.
|
||||
- CSS и JS собираются в один бандл с хешем в имени; минификации и изоляции по страницам пока нет.
|
||||
- Нет приёма заявок, редактора и MCP: сетевая поверхность записи включается только вместе с контуром «вход, роли, аудит, лимиты» (ADR-006). Вход уже есть, роли и аудит правок будут вместе с редактором.
|
||||
- Нет приёма заявок и MCP: сетевая поверхность записи включается только вместе с контуром «вход, роли, аудит, лимиты» (ADR-006). Вход, аудит правок и редактор уже есть; роли и приём заявок остаются на M2.
|
||||
|
||||
@@ -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
|
||||
@@ -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())
|
||||
@@ -0,0 +1,586 @@
|
||||
"""Редактор: страницы, блоки, записи коллекций, превью и публикация (M3, ТЗ раздел 10).
|
||||
|
||||
Все изменения идут через `ContentService`: блокировка сайта, `if_match` по хешу файла,
|
||||
проверка синтаксиса, история версий, атомарная запись. Редактор правит только `pages/` и
|
||||
`content/`; код сайта (фрагменты, layouts, схемы) ему недоступен. Любой POST требует
|
||||
CSRF-токен и Origin своего хоста. Логика не зависит от веб-фреймворка: `dispatch` принимает
|
||||
метод, путь и форму, возвращает `HttpResult`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from collections.abc import Mapping
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from ...build.pipeline import BUILD_ID_RE, preview_page
|
||||
from ...core import page_ops
|
||||
from ...core.draft_check import check_entry_text, check_page_text
|
||||
from ...core.models import STATUSES, Fragment
|
||||
from ...core.registry import Registry, load_site
|
||||
from ...core.routes import build_route_table
|
||||
from ...core.validate import validate_workspace
|
||||
from ...errors import ConflictError, EngineError, Report, UnsafePathError
|
||||
from ...parsing import frontmatter
|
||||
from ...services.auth import AuthService, Principal, is_same_origin
|
||||
from ...services.content import ABSENT, ContentService
|
||||
from ...services.publish import publish, rollback
|
||||
from .forms import FormData, _norm_text, build_view, parse_props
|
||||
from .handlers import ADMIN_HEADERS, HttpResult, htmx_available, page_result, redirect_result
|
||||
from .render import render
|
||||
|
||||
WRITE_PREFIXES = ("pages/", "content/")
|
||||
PAGE_ID_RE = re.compile(r"^[a-z0-9][a-z0-9_-]*(/[a-z0-9][a-z0-9_-]*)*$")
|
||||
SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9_-]*$")
|
||||
ANCHOR_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_-]{0,63}$")
|
||||
RESERVED_SEGMENTS = {"blocks", "add", "meta", "new"}
|
||||
_ENTRY_RESERVED = {"slug", "status", "regions", "regions_mode"}
|
||||
FLASH = {
|
||||
"saved": "Сохранено", "created": "Создано", "block_saved": "Блок сохранён",
|
||||
"moved": "Порядок изменён", "deleted": "Блок удалён", "added": "Блок добавлен: заполните поля",
|
||||
"toggled": "Видимость блока изменена", "published": "Опубликовано", "rolled_back": "Релиз возвращён",
|
||||
}
|
||||
PREVIEW_HEADERS = {
|
||||
"Cache-Control": "no-store", "X-Content-Type-Options": "nosniff", "X-Frame-Options": "SAMEORIGIN",
|
||||
"Referrer-Policy": "same-origin",
|
||||
"Content-Security-Policy": ("default-src 'none'; style-src 'unsafe-inline'; img-src 'self' data:; "
|
||||
"frame-ancestors 'self'; base-uri 'none'; form-action 'none'"),
|
||||
}
|
||||
|
||||
|
||||
def _issues(report: Report) -> list[dict]:
|
||||
return [i.to_dict() for i in report.issues]
|
||||
|
||||
|
||||
class EditorHandlers:
|
||||
def __init__(self, auth: AuthService, site_root: Path, dist: Path):
|
||||
self.auth, self.site_root, self.dist = auth, Path(site_root), Path(dist)
|
||||
page_id = r"(?P<page_id>[a-z0-9][a-z0-9_/-]*?)"
|
||||
block_id = r"(?P<block_id>[A-Za-z][A-Za-z0-9_-]{1,63})"
|
||||
coll = r"(?P<coll>[a-z][a-z0-9_]*)"
|
||||
slug = r"(?P<slug>[a-z0-9][a-z0-9_-]*)"
|
||||
table = [
|
||||
("GET", r"/pages", self.pages_list),
|
||||
("POST", r"/pages/new", self.page_create),
|
||||
("GET", rf"/pages/{page_id}/blocks/{block_id}", self.block_edit),
|
||||
("POST", rf"/pages/{page_id}/blocks/{block_id}", self.block_save),
|
||||
("POST", rf"/pages/{page_id}/blocks/{block_id}/(?P<action>move|delete|toggle)", self.block_action),
|
||||
("POST", rf"/pages/{page_id}/add", self.block_add),
|
||||
("POST", rf"/pages/{page_id}/meta", self.page_save),
|
||||
("GET", rf"/pages/{page_id}", self.page_edit),
|
||||
("GET", rf"/preview/pages/{page_id}", self.preview_page),
|
||||
("GET", rf"/preview/entries/{coll}/{slug}", self.preview_entry),
|
||||
("GET", r"/content", self.content_index),
|
||||
("GET", rf"/content/{coll}", self.entries_list),
|
||||
("POST", rf"/content/{coll}/new", self.entry_create),
|
||||
("GET", rf"/content/{coll}/{slug}", self.entry_edit),
|
||||
("POST", rf"/content/{coll}/{slug}", self.entry_save),
|
||||
("GET", r"/publish", self.publish_page),
|
||||
("POST", r"/publish", self.publish_run),
|
||||
("POST", r"/publish/rollback/(?P<build_id>\d{8}T\d{6}-[0-9a-f]{8})", self.publish_rollback),
|
||||
]
|
||||
self._routes = [(m, re.compile(f"^{p}$"), fn) for m, p, fn in table]
|
||||
|
||||
# ── диспетчер ─────────────────────────────────────────────────────────
|
||||
def dispatch(self, method: str, path: str, query: Mapping[str, str], form: FormData,
|
||||
cookie: str | None, headers: Mapping[str, str], ip: str) -> HttpResult:
|
||||
principal = self.auth.authenticate(cookie)
|
||||
if principal is None:
|
||||
return redirect_result("/admin/login")
|
||||
if method == "POST" and not (is_same_origin(headers, self.auth.cfg.public_host)
|
||||
and self.auth.verify_csrf(principal, form.first("csrf"))):
|
||||
return self._message(principal, "Запрос отклонён", "Недействительный токен или источник запроса.", 403)
|
||||
for route_method, rx, handler in self._routes:
|
||||
match = rx.match(path) if route_method == method else None
|
||||
if match is None:
|
||||
continue
|
||||
try:
|
||||
return handler(principal, match.groupdict(), query, form, ip)
|
||||
except ConflictError as exc:
|
||||
return self._message(
|
||||
principal, "Файл изменился", f"{exc} Откройте страницу заново и повторите правку: "
|
||||
"чужие изменения не перезаписаны.", 409, links=[{"url": "/admin/pages", "label": "К списку страниц"}])
|
||||
except UnsafePathError as exc:
|
||||
return self._message(principal, "Запись запрещена", str(exc), 403)
|
||||
except EngineError as exc:
|
||||
return self._message(principal, "Ошибка", str(exc), 422, issues=_issues(exc.report))
|
||||
return self._message(principal, "Не найдено", "Такой страницы в админке нет.", 404)
|
||||
|
||||
# ── общие помощники ───────────────────────────────────────────────────
|
||||
def _ctx(self, principal: Principal, section: str, query: Mapping[str, str] | None = None, **extra) -> dict:
|
||||
return {"login": principal.login, "csrf": self.auth.csrf_token(principal), "section": section,
|
||||
"flash": FLASH.get((query or {}).get("msg", ""), ""), "htmx": htmx_available(), **extra}
|
||||
|
||||
def _render(self, template: str, principal: Principal, section: str, query: Mapping[str, str] | None = None,
|
||||
status: int = 200, **extra) -> HttpResult:
|
||||
return page_result(render(template, **self._ctx(principal, section, query, **extra)), status)
|
||||
|
||||
def _message(self, principal: Principal, title: str, text: str = "", status: int = 200,
|
||||
issues: list[dict] | None = None, links: list[dict] | None = None) -> HttpResult:
|
||||
return self._render("message.html.j2", principal, "", None, status, title=title, text=text,
|
||||
issues=issues or [], links=links or [])
|
||||
|
||||
def _svc(self) -> ContentService:
|
||||
return ContentService(self.site_root, allowed_prefixes=WRITE_PREFIXES)
|
||||
|
||||
def _audit(self, principal: Principal, event: str, obj: str, ip: str) -> None:
|
||||
self.auth.audit.write(event, actor=principal.login, object=obj, ip=ip)
|
||||
|
||||
@staticmethod
|
||||
def _view_ctx(reg: Registry) -> dict:
|
||||
assets_dir = reg.root / "assets"
|
||||
assets = sorted(p.relative_to(reg.root).as_posix() for p in assets_dir.rglob("*") if p.is_file())[:500] \
|
||||
if assets_dir.is_dir() else []
|
||||
return {"collections": sorted(reg.collections), "assets": assets, "pages": sorted(reg.pages),
|
||||
"entries": {cid: sorted(e.slug for e in items) for cid, items in reg.entries.items()}}
|
||||
|
||||
@staticmethod
|
||||
def _summary(fragment: Fragment | None, props: dict) -> str:
|
||||
if fragment is None:
|
||||
return "неизвестный фрагмент"
|
||||
for fd in fragment.fields:
|
||||
value = props.get(fd.key)
|
||||
if fd.type in ("text", "textarea", "markdown") and value:
|
||||
if isinstance(value, dict) and "bind" in value:
|
||||
return f"← {value['bind']}"
|
||||
if isinstance(value, str):
|
||||
flat = " ".join(value.split())
|
||||
return flat[:70] + ("…" if len(flat) > 70 else "")
|
||||
return ""
|
||||
|
||||
def _view_blocks(self, reg: Registry, items: Any) -> list[dict]:
|
||||
out = []
|
||||
for b in items or []:
|
||||
if not isinstance(b, dict):
|
||||
continue
|
||||
frag = reg.fragments.get(b.get("fragment"))
|
||||
props = b.get("props") if isinstance(b.get("props"), dict) else {}
|
||||
raw_slots = b.get("slots") if isinstance(b.get("slots"), dict) else {}
|
||||
names = list(frag.slots) if frag else list(raw_slots)
|
||||
out.append({
|
||||
"id": b.get("id", "?"), "fragment": b.get("fragment", "?"), "hidden": bool(b.get("hidden")),
|
||||
"requires": list(b.get("requires") or []), "summary": self._summary(frag, props),
|
||||
"slots": [{"name": n, "blocks": self._view_blocks(reg, raw_slots.get(n))} for n in names],
|
||||
})
|
||||
return out
|
||||
|
||||
@staticmethod
|
||||
def _fragments_by_category(reg: Registry) -> list[tuple[str, list[str]]]:
|
||||
groups: dict[str, list[str]] = {}
|
||||
for f in reg.fragments.values():
|
||||
groups.setdefault(f.category, []).append(f.id)
|
||||
return [(cat, sorted(ids)) for cat, ids in sorted(groups.items())]
|
||||
|
||||
def _page_or_none(self, reg: Registry, page_id: str):
|
||||
return reg.pages.get(page_id)
|
||||
|
||||
def _read_page(self, reg: Registry, page_id: str):
|
||||
page = reg.pages.get(page_id)
|
||||
if page is None:
|
||||
return None
|
||||
text, etag = self._svc().read(page.file)
|
||||
meta, body = frontmatter.parse(text)
|
||||
return page, meta, body, etag
|
||||
|
||||
def _not_found(self, principal: Principal, what: str) -> HttpResult:
|
||||
return self._message(principal, "Не найдено", what, 404)
|
||||
|
||||
# ── страницы ──────────────────────────────────────────────────────────
|
||||
def pages_list(self, principal, g, query, form, ip, *, errors=None, values=None, status=200) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
table = build_route_table(reg, Report())
|
||||
routes = {r.page.id: r.route for r in table.values() if r.page}
|
||||
pages = [{"id": p.id, "title": p.title, "status": p.status, "route": routes.get(p.id, "—")}
|
||||
for p in sorted(reg.pages.values(), key=lambda x: routes.get(x.id, x.id))]
|
||||
return self._render("pages_list.html.j2", principal, "pages", query, status, pages=pages,
|
||||
errors=errors or [], layouts=sorted(reg.layouts),
|
||||
values=values or {"page_id": "", "title": "", "layout": ""})
|
||||
|
||||
def page_create(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
page_id = form.first("page_id").strip().strip("/")
|
||||
title = form.first("title").strip()
|
||||
layout = form.first("layout").strip()
|
||||
errors = []
|
||||
if not PAGE_ID_RE.match(page_id):
|
||||
errors.append("Путь: латиница в нижнем регистре, цифры, «-» и «_», сегменты через «/».")
|
||||
elif RESERVED_SEGMENTS & set(page_id.split("/")):
|
||||
errors.append(f"Сегменты {sorted(RESERVED_SEGMENTS)} зарезервированы.")
|
||||
elif page_id in reg.pages:
|
||||
errors.append(f"Страница «{page_id}» уже есть.")
|
||||
if not title:
|
||||
errors.append("Укажите заголовок.")
|
||||
if layout and layout not in reg.layouts:
|
||||
errors.append(f"Нет layout «{layout}».")
|
||||
values = {"page_id": page_id, "title": title, "layout": layout}
|
||||
if errors:
|
||||
return self.pages_list(principal, g, query, form, ip, errors=errors, values=values, status=422)
|
||||
meta: dict = {"schema": 1, "title": title, "status": "draft"}
|
||||
layout_id = layout or reg.site.defaults.get("layout")
|
||||
if layout:
|
||||
meta["layout"] = layout
|
||||
region = "main"
|
||||
if layout_id in reg.layouts:
|
||||
open_regions = [r.id for r in reg.layouts[layout_id].regions.values() if r.allow is not None or not r.fixed]
|
||||
region = open_regions[0] if open_regions else region
|
||||
meta["regions"] = {region: []}
|
||||
rel = f"pages/{page_id}.md"
|
||||
text = frontmatter.dumps(meta, "")
|
||||
report = check_page_text(reg, page_id, rel, text)
|
||||
if report.errors:
|
||||
return self.pages_list(principal, g, query, form, ip, errors=[str(i) for i in report.errors], values=values, status=422)
|
||||
self._svc().write(rel, text, if_match=ABSENT)
|
||||
self._audit(principal, "page_create", page_id, ip)
|
||||
return redirect_result(f"/admin/pages/{page_id}?msg=created")
|
||||
|
||||
def _page_issues(self, reg: Registry, page) -> list[dict]:
|
||||
report = Report()
|
||||
table = build_route_table(reg, report)
|
||||
found = report.issues + validate_workspace(reg, table).issues
|
||||
try:
|
||||
found += preview_page(self.site_root, page.id)[1].issues
|
||||
except EngineError:
|
||||
pass
|
||||
seen, out = set(), []
|
||||
for i in found:
|
||||
key = (i.code, i.path, i.message)
|
||||
if i.path.startswith(page.file) and key not in seen:
|
||||
seen.add(key)
|
||||
out.append(i.to_dict())
|
||||
return out
|
||||
|
||||
def _page_editor(self, principal, reg, page, meta, body, etag, query, *, values=None, errors=None, status=200):
|
||||
seo = meta.get("seo") if isinstance(meta.get("seo"), dict) else {}
|
||||
values = values or {"title": meta.get("title", ""), "status": meta.get("status", "draft"),
|
||||
"layout": meta.get("layout", ""), "route": meta.get("route", ""),
|
||||
"seo_description": seo.get("description", ""), "body": body}
|
||||
layout = reg.layouts.get(reg.effective_layout(page) or "")
|
||||
raw_regions = meta.get("regions") if isinstance(meta.get("regions"), dict) else {}
|
||||
names = list(layout.regions) if layout else []
|
||||
names += [n for n in raw_regions if n not in names]
|
||||
regions = []
|
||||
for name in names:
|
||||
rdef = layout.regions.get(name) if layout else None
|
||||
regions.append({
|
||||
"name": name, "blocks": self._view_blocks(reg, raw_regions.get(name)),
|
||||
"fixed": [{"fragment": b.fragment, "id": b.id} for b in (rdef.fixed if rdef else [])],
|
||||
"can_add": not (rdef is not None and rdef.allow is None and rdef.fixed),
|
||||
})
|
||||
table = build_route_table(reg, Report())
|
||||
route = next((r.route for r in table.values() if r.page and r.page.id == page.id), "—")
|
||||
return self._render(
|
||||
"page_edit.html.j2", principal, "pages", query, status, page_id=page.id, file=page.file, route=route,
|
||||
etag=etag, values=values, errors=errors or [], issues=self._page_issues(reg, page),
|
||||
statuses=list(STATUSES), layouts=sorted(reg.layouts), regions=regions,
|
||||
fragments=self._fragments_by_category(reg))
|
||||
|
||||
def page_edit(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
loaded = self._read_page(reg, g["page_id"])
|
||||
if loaded is None:
|
||||
return self._not_found(principal, f"Страницы «{g['page_id']}» нет.")
|
||||
page, meta, body, etag = loaded
|
||||
return self._page_editor(principal, reg, page, meta, body, etag, query)
|
||||
|
||||
def _commit_page(self, reg, page, meta, body, etag):
|
||||
"""(новый etag | None, отчёт проверки). Не записывает, если есть ошибки."""
|
||||
text = frontmatter.dumps(meta, body)
|
||||
report = check_page_text(reg, page.id, page.file, text)
|
||||
if report.errors:
|
||||
return None, report
|
||||
return self._svc().write(page.file, text, if_match=etag), report
|
||||
|
||||
def page_save(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
loaded = self._read_page(reg, g["page_id"])
|
||||
if loaded is None:
|
||||
return self._not_found(principal, f"Страницы «{g['page_id']}» нет.")
|
||||
page, meta, _, _ = loaded
|
||||
values = {"title": form.first("title").strip(), "status": form.first("status") or "draft",
|
||||
"layout": form.first("layout").strip(), "route": form.first("route").strip(),
|
||||
"seo_description": form.first("seo_description").strip(), "body": _norm_text(form.first("body"))}
|
||||
meta["title"] = values["title"]
|
||||
meta["status"] = values["status"]
|
||||
for key in ("layout", "route"):
|
||||
if values[key]:
|
||||
meta[key] = values[key]
|
||||
else:
|
||||
meta.pop(key, None)
|
||||
seo = dict(meta["seo"]) if isinstance(meta.get("seo"), dict) else {}
|
||||
if values["seo_description"]:
|
||||
seo["description"] = values["seo_description"]
|
||||
else:
|
||||
seo.pop("description", None)
|
||||
if seo:
|
||||
meta["seo"] = seo
|
||||
else:
|
||||
meta.pop("seo", None)
|
||||
body = values["body"] + ("\n" if values["body"] else "")
|
||||
new_etag, report = self._commit_page(reg, page, meta, body, form.first("etag"))
|
||||
if new_etag is None:
|
||||
_, current_meta, _, current_etag = self._read_page(reg, page.id)
|
||||
return self._page_editor(principal, reg, page, current_meta, body, form.first("etag"), query, values=values,
|
||||
errors=[str(i) for i in report.errors], status=422)
|
||||
self._audit(principal, "page_save", page.id, ip)
|
||||
return redirect_result(f"/admin/pages/{page.id}?msg=saved")
|
||||
|
||||
# ── блоки ─────────────────────────────────────────────────────────────
|
||||
def _block_form(self, principal, reg, page, meta, etag, block, fragment, query, *, props=None,
|
||||
settings=None, errors=None, status=200) -> HttpResult:
|
||||
vctx = self._view_ctx(reg)
|
||||
props = block.get("props") if props is None and isinstance(block.get("props"), dict) else (props or {})
|
||||
fields = [build_view(fd, props.get(fd.key), f"p.{fd.key}", vctx) for fd in fragment.fields]
|
||||
requires = set(block.get("requires") or []) if settings is None else set(settings["requires"])
|
||||
settings = settings or {"hidden": bool(block.get("hidden")), "anchor": block.get("anchor") or "",
|
||||
"note": block.get("note") or ""}
|
||||
return self._render(
|
||||
"block_edit.html.j2", principal, "pages", query, status, page_id=page.id, page_title=page.title,
|
||||
block_id=block["id"], fragment_name=fragment.name, etag=etag, fields=fields, settings=settings,
|
||||
errors=errors or [],
|
||||
features=[(name, f"feature.{name}" in requires) for name in sorted(reg.site.features)])
|
||||
|
||||
def _find_block(self, principal, reg, g):
|
||||
loaded = self._read_page(reg, g["page_id"])
|
||||
if loaded is None:
|
||||
return None, self._not_found(principal, f"Страницы «{g['page_id']}» нет.")
|
||||
page, meta, body, etag = loaded
|
||||
found = page_ops.find_block(meta, g["block_id"])
|
||||
if found is None:
|
||||
return None, self._not_found(principal, f"Блока «{g['block_id']}» на странице нет.")
|
||||
return (page, meta, body, etag, found[2]), None
|
||||
|
||||
def block_edit(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
ctx, error = self._find_block(principal, reg, g)
|
||||
if error:
|
||||
return error
|
||||
page, meta, body, etag, block = ctx
|
||||
fragment = reg.fragments.get(block.get("fragment"))
|
||||
if fragment is None:
|
||||
return self._message(principal, "Фрагмент не найден", f"В реестре нет фрагмента «{block.get('fragment')}».", 422)
|
||||
return self._block_form(principal, reg, page, meta, etag, block, fragment, query)
|
||||
|
||||
def block_save(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
ctx, error = self._find_block(principal, reg, g)
|
||||
if error:
|
||||
return error
|
||||
page, meta, body, etag, block = ctx
|
||||
fragment = reg.fragments.get(block.get("fragment"))
|
||||
if fragment is None:
|
||||
return self._message(principal, "Фрагмент не найден", f"В реестре нет фрагмента «{block.get('fragment')}».", 422)
|
||||
errors: list[str] = []
|
||||
props = parse_props(fragment.fields, form, "p", errors)
|
||||
settings = {"hidden": form.first("s.hidden") == "1", "anchor": form.first("s.anchor").strip(),
|
||||
"note": form.first("s.note").strip(),
|
||||
"requires": [r for r in form.all("s.requires") if r.startswith("feature.")]}
|
||||
if settings["anchor"] and not ANCHOR_RE.match(settings["anchor"]):
|
||||
errors.append("Якорь: латиница, цифры, «-» и «_», начинается с буквы.")
|
||||
if not errors:
|
||||
page_ops.replace_block_fields(
|
||||
block, props=props, manifest_keys={f.key for f in fragment.fields}, hidden=settings["hidden"],
|
||||
anchor=settings["anchor"], note=settings["note"], requires=settings["requires"])
|
||||
new_etag, report = self._commit_page(reg, page, meta, body, form.first("etag"))
|
||||
if new_etag is not None:
|
||||
self._audit(principal, "block_save", f"{page.id}#{block['id']}", ip)
|
||||
return redirect_result(f"/admin/pages/{page.id}?msg=block_saved")
|
||||
errors = [str(i) for i in report.errors]
|
||||
view_settings = {k: settings[k] for k in ("hidden", "anchor", "note", "requires")}
|
||||
return self._block_form(principal, reg, page, meta, form.first("etag"), {"id": g["block_id"], "requires": settings["requires"]},
|
||||
fragment, query, props=props, settings=view_settings, errors=errors, status=422)
|
||||
|
||||
def block_action(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
ctx, error = self._find_block(principal, reg, g)
|
||||
if error:
|
||||
return error
|
||||
page, meta, body, etag, block = ctx
|
||||
action, bid = g["action"], g["block_id"]
|
||||
if action == "move":
|
||||
moved = page_ops.move_block(meta, bid, form.first("dir"))
|
||||
msg = "moved"
|
||||
if not moved:
|
||||
return redirect_result(f"/admin/pages/{page.id}")
|
||||
elif action == "delete":
|
||||
page_ops.delete_block(meta, bid)
|
||||
msg = "deleted"
|
||||
else:
|
||||
page_ops.set_hidden(meta, bid, not bool(block.get("hidden")))
|
||||
msg = "toggled"
|
||||
new_etag, report = self._commit_page(reg, page, meta, body, form.first("etag"))
|
||||
if new_etag is None:
|
||||
return self._message(principal, "Не удалось сохранить", "", 422, issues=_issues(report),
|
||||
links=[{"url": f"/admin/pages/{page.id}", "label": "Назад к странице"}])
|
||||
self._audit(principal, f"block_{action}", f"{page.id}#{bid}", ip)
|
||||
return redirect_result(f"/admin/pages/{page.id}?msg={msg}")
|
||||
|
||||
def block_add(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
loaded = self._read_page(reg, g["page_id"])
|
||||
if loaded is None:
|
||||
return self._not_found(principal, f"Страницы «{g['page_id']}» нет.")
|
||||
page, meta, body, etag = loaded
|
||||
fragment_id = form.first("fragment")
|
||||
if fragment_id not in reg.fragments:
|
||||
return self._message(principal, "Нет такого фрагмента", fragment_id, 422)
|
||||
try:
|
||||
new_id = page_ops.add_block(meta, fragment_id, region=form.first("region") or None,
|
||||
parent=form.first("parent") or None, slot=form.first("slot") or None)
|
||||
except KeyError as exc:
|
||||
return self._message(principal, "Не удалось добавить блок", str(exc), 422)
|
||||
new_etag, report = self._commit_page(reg, page, meta, body, form.first("etag"))
|
||||
if new_etag is None:
|
||||
return self._message(principal, "Блок сюда добавить нельзя", "", 422, issues=_issues(report),
|
||||
links=[{"url": f"/admin/pages/{page.id}", "label": "Назад к странице"}])
|
||||
self._audit(principal, "block_add", f"{page.id}#{new_id}", ip)
|
||||
return redirect_result(f"/admin/pages/{page.id}/blocks/{new_id}?msg=added")
|
||||
|
||||
# ── предпросмотр ──────────────────────────────────────────────────────
|
||||
@staticmethod
|
||||
def _preview_result(html: str) -> HttpResult:
|
||||
return HttpResult(200, html or "<p>Страницу нельзя отрендерить: проверьте layout.</p>",
|
||||
headers=dict(PREVIEW_HEADERS))
|
||||
|
||||
def preview_page(self, principal, g, query, form, ip) -> HttpResult:
|
||||
try:
|
||||
html, _ = preview_page(self.site_root, g["page_id"])
|
||||
except EngineError:
|
||||
return self._not_found(principal, "Страницы для предпросмотра нет.")
|
||||
return self._preview_result(html)
|
||||
|
||||
def preview_entry(self, principal, g, query, form, ip) -> HttpResult:
|
||||
try:
|
||||
html, _ = preview_page(self.site_root, f"{g['coll']}/{g['slug']}")
|
||||
except EngineError:
|
||||
return self._not_found(principal, "Записи для предпросмотра нет.")
|
||||
return self._preview_result(html)
|
||||
|
||||
# ── записи коллекций ──────────────────────────────────────────────────
|
||||
def content_index(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
items = [{"id": c.id, "name": c.name, "total": len(reg.entries.get(c.id, [])),
|
||||
"published": sum(e.status == "published" for e in reg.entries.get(c.id, []))}
|
||||
for c in reg.collections.values()]
|
||||
return self._render("content_index.html.j2", principal, "content", query, collections=items)
|
||||
|
||||
def entries_list(self, principal, g, query, form, ip, *, errors=None, slug="", status=200) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
coll = reg.collections.get(g["coll"])
|
||||
if coll is None:
|
||||
return self._not_found(principal, f"Коллекции «{g['coll']}» нет.")
|
||||
table = build_route_table(reg, Report())
|
||||
routes = {(r.collection.id, r.entry.slug): r.route for r in table.values() if r.entry and r.collection}
|
||||
entries = [{"slug": e.slug, "title": e.data.get("title", e.slug), "status": e.status,
|
||||
"route": routes.get((coll.id, e.slug), "—")} for e in reg.entries.get(coll.id, [])]
|
||||
return self._render("entries_list.html.j2", principal, "content", query, status, collection=coll,
|
||||
entries=entries, errors=errors or [], slug=slug)
|
||||
|
||||
def entry_create(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
coll = reg.collections.get(g["coll"])
|
||||
if coll is None:
|
||||
return self._not_found(principal, f"Коллекции «{g['coll']}» нет.")
|
||||
slug = form.first("slug").strip()
|
||||
errors = []
|
||||
if not SLUG_RE.match(slug) or slug in RESERVED_SEGMENTS:
|
||||
errors.append("Slug: латиница в нижнем регистре, цифры, «-» и «_»; слова new, meta, add, blocks зарезервированы.")
|
||||
elif any(e.slug == slug for e in reg.entries.get(coll.id, [])):
|
||||
errors.append(f"Запись «{slug}» уже есть.")
|
||||
if errors:
|
||||
return self.entries_list(principal, g, query, form, ip, errors=errors, slug=slug, status=422)
|
||||
rel = f"content/{coll.id}/{slug}.md"
|
||||
text = frontmatter.dumps({"status": "draft"}, "")
|
||||
report = check_entry_text(reg, coll.id, slug, rel, text)
|
||||
if report.errors:
|
||||
return self.entries_list(principal, g, query, form, ip, errors=[str(i) for i in report.errors], slug=slug, status=422)
|
||||
self._svc().write(rel, text, if_match=ABSENT)
|
||||
self._audit(principal, "entry_create", f"{coll.id}/{slug}", ip)
|
||||
return redirect_result(f"/admin/content/{coll.id}/{slug}?msg=created")
|
||||
|
||||
def _entry_form(self, principal, reg, coll, entry, meta, body, etag, query, *, props=None, status_value=None,
|
||||
errors=None, issues=None, status=200) -> HttpResult:
|
||||
vctx = self._view_ctx(reg)
|
||||
values = props if props is not None else {k: v for k, v in meta.items() if k not in _ENTRY_RESERVED}
|
||||
fields = [build_view(fd, values.get(fd.key), f"p.{fd.key}", vctx) for fd in coll.fields]
|
||||
return self._render(
|
||||
"entry_edit.html.j2", principal, "content", query, status, collection=coll, slug=entry.slug, file=entry.file,
|
||||
etag=etag, entry_status=status_value or meta.get("status", "draft"), statuses=list(STATUSES), fields=fields,
|
||||
has_body=coll.body == "markdown", body=body, errors=errors or [], issues=issues or [],
|
||||
preview=coll.kind != "taxonomy")
|
||||
|
||||
def _read_entry(self, reg, g):
|
||||
coll = reg.collections.get(g["coll"])
|
||||
entry = next((e for e in reg.entries.get(g["coll"], []) if e.slug == g["slug"]), None)
|
||||
if coll is None or entry is None:
|
||||
return None
|
||||
text, etag = self._svc().read(entry.file)
|
||||
meta, body = frontmatter.parse(text)
|
||||
return coll, entry, meta, body, etag
|
||||
|
||||
def entry_edit(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
loaded = self._read_entry(reg, g)
|
||||
if loaded is None:
|
||||
return self._not_found(principal, "Такой записи нет.")
|
||||
coll, entry, meta, body, etag = loaded
|
||||
return self._entry_form(principal, reg, coll, entry, meta, body, etag, query)
|
||||
|
||||
def entry_save(self, principal, g, query, form, ip) -> HttpResult:
|
||||
reg = load_site(self.site_root)
|
||||
loaded = self._read_entry(reg, g)
|
||||
if loaded is None:
|
||||
return self._not_found(principal, "Такой записи нет.")
|
||||
coll, entry, meta, body, etag = loaded
|
||||
errors: list[str] = []
|
||||
props = parse_props(coll.fields, form, "p", errors)
|
||||
status_value = form.first("status") or "draft"
|
||||
new_body = _norm_text(form.first("body")) + "\n" if coll.body == "markdown" and form.first("body").strip() else (
|
||||
body if coll.body != "markdown" else "")
|
||||
if not errors:
|
||||
new_meta = dict(meta)
|
||||
for fd in coll.fields:
|
||||
if fd.key in props:
|
||||
new_meta[fd.key] = props[fd.key]
|
||||
else:
|
||||
new_meta.pop(fd.key, None)
|
||||
new_meta["status"] = status_value
|
||||
text = frontmatter.dumps(new_meta, new_body)
|
||||
report = check_entry_text(reg, coll.id, entry.slug, entry.file, text)
|
||||
if not report.errors:
|
||||
self._svc().write(entry.file, text, if_match=form.first("etag"))
|
||||
self._audit(principal, "entry_save", f"{coll.id}/{entry.slug}", ip)
|
||||
return redirect_result(f"/admin/content/{coll.id}/{entry.slug}?msg=saved")
|
||||
errors = [str(i) for i in report.errors]
|
||||
return self._entry_form(principal, reg, coll, entry, meta, new_body, form.first("etag"), query, props=props,
|
||||
status_value=status_value, errors=errors, status=422)
|
||||
|
||||
# ── публикация ────────────────────────────────────────────────────────
|
||||
def _builds(self) -> tuple[str | None, list[dict]]:
|
||||
if not self.dist.is_dir():
|
||||
return None, []
|
||||
current = (self.dist / "current").resolve().name if (self.dist / "current").exists() else None
|
||||
ids = sorted((p.name for p in self.dist.iterdir() if p.is_dir() and BUILD_ID_RE.match(p.name)), reverse=True)
|
||||
return current, [{"id": i, "current": i == current} for i in ids]
|
||||
|
||||
def publish_page(self, principal, g, query, form, ip, *, issues=None, status=200) -> HttpResult:
|
||||
current, builds = self._builds()
|
||||
return self._render("publish.html.j2", principal, "publish", query, status, current=current, builds=builds,
|
||||
issues=issues or [])
|
||||
|
||||
def publish_run(self, principal, g, query, form, ip) -> HttpResult:
|
||||
try:
|
||||
publish(self.site_root, self.dist)
|
||||
except EngineError as exc:
|
||||
self._audit(principal, "publish_failed", "site", ip)
|
||||
return self.publish_page(principal, g, query, form, ip, issues=_issues(exc.report), status=422)
|
||||
self._audit(principal, "publish", "site", ip)
|
||||
return redirect_result("/admin/publish?msg=published")
|
||||
|
||||
def publish_rollback(self, principal, g, query, form, ip) -> HttpResult:
|
||||
try:
|
||||
rollback(self.dist, g["build_id"])
|
||||
except ValueError as exc:
|
||||
return self._not_found(principal, str(exc))
|
||||
self._audit(principal, "rollback", g["build_id"], ip)
|
||||
return redirect_result("/admin/publish?msg=rolled_back")
|
||||
@@ -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
|
||||
@@ -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")
|
||||
|
||||
@@ -8,10 +8,12 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from ...services.auth import COOKIE_NAME
|
||||
from .editor import EditorHandlers
|
||||
from .forms import FormData
|
||||
from .handlers import AdminHandlers, HttpResult
|
||||
|
||||
|
||||
def create_admin_router(handlers: AdminHandlers):
|
||||
def create_admin_router(handlers: AdminHandlers, editor: EditorHandlers | None = None):
|
||||
from fastapi import APIRouter, Form, Request, Response
|
||||
|
||||
router = APIRouter(prefix="/admin")
|
||||
@@ -43,8 +45,23 @@ def create_admin_router(handlers: AdminHandlers):
|
||||
def dashboard(request: Request):
|
||||
return adapt(handlers.dashboard(request.cookies.get(COOKIE_NAME)))
|
||||
|
||||
@router.get("/static/admin.css")
|
||||
def admin_css():
|
||||
return adapt(handlers.static_css())
|
||||
@router.get("/static/{name}")
|
||||
def static_file(name: str):
|
||||
return adapt(handlers.static_file(name))
|
||||
|
||||
if editor is not None:
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
|
||||
# Все экраны редактора идут через один маршрут: `dispatch` сам сопоставляет путь и метод.
|
||||
# Он объявлен последним, поэтому /login, /logout, /static/* и обзор имеют приоритет.
|
||||
@router.api_route("/{rest:path}", methods=["GET", "POST"])
|
||||
async def editor_route(request: Request, rest: str):
|
||||
form = FormData()
|
||||
if request.method == "POST":
|
||||
form = FormData.from_pairs((await request.form()).multi_items())
|
||||
result = await run_in_threadpool(
|
||||
editor.dispatch, request.method, "/" + rest, dict(request.query_params), form,
|
||||
request.cookies.get(COOKIE_NAME), dict(request.headers), client_ip(request))
|
||||
return adapt(result)
|
||||
|
||||
return router
|
||||
|
||||
@@ -17,3 +17,33 @@ th, td { padding: .5rem .7rem; text-align: left; border-bottom: 1px solid var(--
|
||||
.status-published { background: #e3f6e8; }
|
||||
.status-draft { background: #fff4d6; }
|
||||
.summary { color: var(--c-muted); }
|
||||
.nav { display: flex; gap: .2rem; margin-left: 1rem; }
|
||||
.nav a { padding: .3rem .7rem; color: inherit; text-decoration: none; border-radius: .4rem; }
|
||||
.nav a.active, .nav a:hover { background: #eef0f4; }
|
||||
.flash { margin: 0; padding: .5rem 1rem; background: #e3f6e8; }
|
||||
.muted { color: var(--c-muted); }
|
||||
.crumbs { margin: 0 0 .3rem; }
|
||||
.stack { display: grid; gap: .8rem; max-width: 44rem; }
|
||||
.stack textarea, .field textarea { width: 100%; padding: .5rem; font: inherit; border: 1px solid var(--c-border); border-radius: .4rem; }
|
||||
.field input[type=text], .field select, .stack input[type=text], .stack select { width: 100%; }
|
||||
fieldset { border: 1px solid var(--c-border); border-radius: .4rem; padding: .6rem .8rem; background: #fff; }
|
||||
.row { padding: .5rem 0; border-top: 1px dashed var(--c-border); }
|
||||
.row.blank { opacity: .75; }
|
||||
details.bind { font-size: .8rem; color: var(--c-muted); }
|
||||
.hint { color: var(--c-muted); font-size: .8rem; }
|
||||
label.inline { display: inline-flex; gap: .3rem; align-items: center; margin-right: .8rem; }
|
||||
.issues { padding-left: 1.2rem; }
|
||||
.issues .error { color: #8a1c1c; }
|
||||
.issues .warning { color: #8a5a00; }
|
||||
.issues-box { margin: 1rem 0; }
|
||||
.region { margin: 1rem 0; padding: .6rem 1rem; background: #fff; border: 1px solid var(--c-border); border-radius: .5rem; }
|
||||
.blocks { list-style: none; padding: 0; margin: .4rem 0; }
|
||||
.block { padding: .5rem .7rem; margin-bottom: .4rem; border: 1px solid var(--c-border); border-radius: .4rem; }
|
||||
.block.is-hidden { opacity: .55; }
|
||||
.block .actions { display: flex; flex-wrap: wrap; gap: .4rem; align-items: center; margin-top: .3rem; }
|
||||
.slot { margin: .5rem 0 0 1rem; padding-left: .8rem; border-left: 3px solid var(--c-border); }
|
||||
.inline-form { display: inline; margin: 0; }
|
||||
button.small { padding: .2rem .6rem; font-size: .85rem; }
|
||||
button.danger { background: #b42318; }
|
||||
.add { display: flex; gap: .4rem; margin: .4rem 0; }
|
||||
iframe.preview { width: 100%; height: 28rem; border: 1px solid var(--c-border); background: #fff; }
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
{# Рекурсивные макросы для форм по схеме полей (см. web/admin/forms.py: build_view) #}
|
||||
{% macro bind_box(name, bind) %}
|
||||
<details class='bind'{% if bind %} open{% endif %}>
|
||||
<summary>привязка</summary>
|
||||
<input type='text' name='{{ name }}._bind' value='{{ bind }}' placeholder='entry.title · page.body · site.name'>
|
||||
</details>
|
||||
{% endmacro %}
|
||||
|
||||
{% macro datalist(f) %}
|
||||
{% if f.datalist %}<datalist id='dl-{{ f.name }}'>{% for v in f.datalist %}<option value='{{ v }}'>{% endfor %}</datalist>{% endif %}
|
||||
{% endmacro %}
|
||||
|
||||
{% macro field(f) %}
|
||||
<div class='field'>
|
||||
{% if f.kind == 'group' %}
|
||||
<fieldset>
|
||||
<legend>{{ f.label }}{% if f.required %} *{% endif %}</legend>
|
||||
{% for c in f.children %}{{ field(c) }}{% endfor %}
|
||||
{{ bind_box(f.name, f.bind) }}
|
||||
</fieldset>
|
||||
{% elif f.kind == 'list' %}
|
||||
<fieldset class='list'>
|
||||
<legend>{{ f.label }}{% if f.required %} *{% endif %}</legend>
|
||||
{% for row in f.rows %}
|
||||
<div class='row{% if row.blank %} blank{% endif %}'>
|
||||
{% if row.item %}{{ field(row.item) }}{% else %}{% for c in row.children %}{{ field(c) }}{% endfor %}{% endif %}
|
||||
{{ bind_box(row.name, row.bind) }}
|
||||
{% if row.blank %}
|
||||
<span class='hint'>Пустая строка: заполните её, чтобы добавить элемент.</span>
|
||||
{% else %}
|
||||
<label class='inline'><input type='checkbox' name='{{ row.name }}._del' value='1'> удалить элемент</label>
|
||||
{% endif %}
|
||||
</div>
|
||||
{% endfor %}
|
||||
</fieldset>
|
||||
{% elif f.kind == 'link' %}
|
||||
<fieldset class='link'>
|
||||
<legend>{{ f.label }}{% if f.required %} *{% endif %}</legend>
|
||||
{% set kinds = [('page', 'страница'), ('entry', 'запись'), ('url', 'адрес')] %}
|
||||
<select name='{{ f.name }}.kind'>
|
||||
{% for k, title in kinds %}<option value='{{ k }}'{% if f.link_kind == k %} selected{% endif %}>{{ title }}</option>{% endfor %}
|
||||
</select>
|
||||
<input type='text' name='{{ f.name }}.target' value='{{ f.target }}' placeholder='contacts · services/bots · https://…'>
|
||||
<input type='text' name='{{ f.name }}.label' value='{{ f.link_label }}' placeholder='подпись'>
|
||||
<label class='inline'><input type='checkbox' name='{{ f.name }}.new_tab' value='1'{% if f.new_tab %} checked{% endif %}> в новой вкладке</label>
|
||||
{{ bind_box(f.name, f.bind) }}
|
||||
</fieldset>
|
||||
{% elif f.kind == 'query' %}
|
||||
<fieldset class='query'>
|
||||
<legend>{{ f.label }}{% if f.required %} *{% endif %}</legend>
|
||||
<label>Коллекция
|
||||
<select name='{{ f.name }}.collection'>
|
||||
<option value=''>—</option>
|
||||
{% for c in f.collections %}<option value='{{ c }}'{% if c == f.collection %} selected{% endif %}>{{ c }}</option>{% endfor %}
|
||||
</select>
|
||||
</label>
|
||||
<label>Сортировка <input type='text' name='{{ f.name }}.sort' value='{{ f.sort }}' placeholder='order или -date'></label>
|
||||
<label>Лимит <input type='text' inputmode='numeric' name='{{ f.name }}.limit' value='{{ f.limit }}'></label>
|
||||
<label>Только эти записи (slug через запятую) <input type='text' name='{{ f.name }}.ids' value='{{ f.ids }}'></label>
|
||||
<label>Фильтр (YAML, например <code>featured: true</code>)
|
||||
<textarea name='{{ f.name }}.where' rows='2'>{{ f.where }}</textarea>
|
||||
</label>
|
||||
{{ bind_box(f.name, f.bind) }}
|
||||
</fieldset>
|
||||
{% elif f.kind == 'multiselect' %}
|
||||
<fieldset>
|
||||
<legend>{{ f.label }}</legend>
|
||||
{% for o in f.options %}
|
||||
<label class='inline'><input type='checkbox' name='{{ f.name }}' value='{{ o.value }}'{% if o.selected %} checked{% endif %}> {{ o.label }}</label>
|
||||
{% endfor %}
|
||||
{{ bind_box(f.name, f.bind) }}
|
||||
</fieldset>
|
||||
{% else %}
|
||||
<label>{{ f.label }}{% if f.required %} *{% endif %}
|
||||
{% if f.kind == 'textarea' %}
|
||||
<textarea name='{{ f.name }}' rows='6'>{{ f.value }}</textarea>
|
||||
{% elif f.kind == 'select' %}
|
||||
<select name='{{ f.name }}'>{% for o in f.options %}<option value='{{ o.value }}'{% if o.selected %} selected{% endif %}>{{ o.label }}</option>{% endfor %}</select>
|
||||
{% elif f.kind == 'date' %}
|
||||
<input type='date' name='{{ f.name }}' value='{{ f.value }}'>
|
||||
{% elif f.kind == 'number' %}
|
||||
<input type='text' inputmode='decimal' name='{{ f.name }}' value='{{ f.value }}'>
|
||||
{% else %}
|
||||
<input type='text' name='{{ f.name }}' value='{{ f.value }}'{% if f.datalist %} list='dl-{{ f.name }}'{% endif %}>
|
||||
{% endif %}
|
||||
</label>
|
||||
{{ datalist(f) }}
|
||||
{% if f.hint %}<small class='hint'>{{ f.hint }}</small>{% endif %}
|
||||
{{ bind_box(f.name, f.bind) }}
|
||||
{% endif %}
|
||||
</div>
|
||||
{% endmacro %}
|
||||
@@ -7,7 +7,8 @@
|
||||
<title>{% block title %}Админка{% endblock %}</title>
|
||||
<link rel='stylesheet' href='/admin/static/admin.css'>
|
||||
</head>
|
||||
<body>
|
||||
<body{% block bodyattrs %}{% endblock %}>
|
||||
{% block body %}{% endblock %}
|
||||
{% block scripts %}{% endblock %}
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
{% extends 'shell.html.j2' %}
|
||||
{% from '_fields.html.j2' import field %}
|
||||
{% block title %}Блок {{ block_id }} — админка{% endblock %}
|
||||
{% block content %}
|
||||
<p class='crumbs'><a href='/admin/pages/{{ page_id }}'>← {{ page_title }}</a></p>
|
||||
<h1>{{ fragment_name }} <small><code>{{ block_id }}</code></small></h1>
|
||||
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
|
||||
<form method='post' action='/admin/pages/{{ page_id }}/blocks/{{ block_id }}' class='stack'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<input type='hidden' name='etag' value='{{ etag }}'>
|
||||
{% for f in fields %}{{ field(f) }}{% else %}<p class='muted'>У этого фрагмента нет полей.</p>{% endfor %}
|
||||
<fieldset>
|
||||
<legend>Настройки блока</legend>
|
||||
<label class='inline'><input type='checkbox' name='s.hidden' value='1'{% if settings.hidden %} checked{% endif %}> скрыт (не выводится на сайте)</label>
|
||||
<label>Якорь <input type='text' name='s.anchor' value='{{ settings.anchor }}' placeholder='pricing'></label>
|
||||
<label>Заметка <input type='text' name='s.note' value='{{ settings.note }}'></label>
|
||||
{% if features %}
|
||||
<div>Показывать, только если включено:
|
||||
{% for name, on in features %}<label class='inline'><input type='checkbox' name='s.requires' value='feature.{{ name }}'{% if on %} checked{% endif %}> feature.{{ name }}</label>{% endfor %}
|
||||
</div>
|
||||
{% endif %}
|
||||
</fieldset>
|
||||
<button type='submit'>Сохранить блок</button>
|
||||
</form>
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,15 @@
|
||||
{% extends 'shell.html.j2' %}
|
||||
{% block title %}Контент — админка{% endblock %}
|
||||
{% block content %}
|
||||
<h1>Контент</h1>
|
||||
<table>
|
||||
<thead><tr><th>Коллекция</th><th>Записей</th><th>Опубликовано</th></tr></thead>
|
||||
<tbody>
|
||||
{% for c in collections %}
|
||||
<tr><td><a href='/admin/content/{{ c.id }}'>{{ c.name }}</a></td><td>{{ c.total }}</td><td>{{ c.published }}</td></tr>
|
||||
{% else %}
|
||||
<tr><td colspan='3'>Коллекций нет</td></tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
{% endblock %}
|
||||
@@ -1,16 +1,6 @@
|
||||
{% extends 'base.html.j2' %}
|
||||
{% extends 'shell.html.j2' %}
|
||||
{% block title %}Обзор — админка{% endblock %}
|
||||
{% block body %}
|
||||
<header class='bar'>
|
||||
<strong>Админка</strong>
|
||||
<span class='spacer'></span>
|
||||
<span>{{ login }}</span>
|
||||
<form method='post' action='/admin/logout'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<button type='submit'>Выйти</button>
|
||||
</form>
|
||||
</header>
|
||||
<main class='content'>
|
||||
{% block content %}
|
||||
{% if site_error %}
|
||||
<p class='error' role='alert'>Сайт не загружен: {{ site_error }}</p>
|
||||
{% else %}
|
||||
@@ -40,5 +30,4 @@
|
||||
{% endfor %}
|
||||
</ul>
|
||||
{% endif %}
|
||||
</main>
|
||||
{% endblock %}
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
{% extends 'shell.html.j2' %}
|
||||
{% block title %}{{ collection.name }} — админка{% endblock %}
|
||||
{% block content %}
|
||||
<p class='crumbs'><a href='/admin/content'>← Контент</a></p>
|
||||
<h1>{{ collection.name }}</h1>
|
||||
<table>
|
||||
<thead><tr><th>Запись</th><th>Адрес</th><th>Статус</th><th></th></tr></thead>
|
||||
<tbody>
|
||||
{% for e in entries %}
|
||||
<tr>
|
||||
<td>{{ e.title }}<br><small class='muted'>{{ e.slug }}</small></td>
|
||||
<td><code>{{ e.route }}</code></td>
|
||||
<td><span class='status status-{{ e.status }}'>{{ e.status }}</span></td>
|
||||
<td><a href='/admin/content/{{ collection.id }}/{{ e.slug }}'>Изменить</a></td>
|
||||
</tr>
|
||||
{% else %}
|
||||
<tr><td colspan='4'>Записей пока нет</td></tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
<h2>Новая запись</h2>
|
||||
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
|
||||
<form method='post' action='/admin/content/{{ collection.id }}/new' class='stack'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<label>Slug (латиница, цифры, - и _) <input type='text' name='slug' value='{{ slug }}' required></label>
|
||||
<button type='submit'>Создать черновик</button>
|
||||
</form>
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,26 @@
|
||||
{% extends 'shell.html.j2' %}
|
||||
{% from '_fields.html.j2' import field %}
|
||||
{% block title %}{{ slug }} — админка{% endblock %}
|
||||
{% block content %}
|
||||
<p class='crumbs'><a href='/admin/content/{{ collection.id }}'>← {{ collection.name }}</a></p>
|
||||
<h1>{{ slug }}</h1>
|
||||
<p class='muted'><code>{{ file }}</code></p>
|
||||
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
|
||||
{% if issues %}<ul class='issues'>{% for i in issues %}<li class='{{ i.severity }}'><code>{{ i.code }}</code> {{ i.message }}</li>{% endfor %}</ul>{% endif %}
|
||||
<form method='post' action='/admin/content/{{ collection.id }}/{{ slug }}' class='stack'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<input type='hidden' name='etag' value='{{ etag }}'>
|
||||
<label>Статус
|
||||
<select name='status'>{% for s in statuses %}<option value='{{ s }}'{% if s == entry_status %} selected{% endif %}>{{ s }}</option>{% endfor %}</select>
|
||||
</label>
|
||||
{% for f in fields %}{{ field(f) }}{% endfor %}
|
||||
{% if has_body %}
|
||||
<label>Текст (Markdown) <textarea name='body' rows='12'>{{ body }}</textarea></label>
|
||||
{% endif %}
|
||||
<button type='submit'>Сохранить</button>
|
||||
</form>
|
||||
{% if preview %}
|
||||
<h2>Предпросмотр</h2>
|
||||
<iframe class='preview' sandbox src='/admin/preview/entries/{{ collection.id }}/{{ slug }}' title='Предпросмотр записи'></iframe>
|
||||
{% endif %}
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,12 @@
|
||||
{% extends 'shell.html.j2' %}
|
||||
{% block title %}{{ title }} — админка{% endblock %}
|
||||
{% block content %}
|
||||
<h1>{{ title }}</h1>
|
||||
{% if text %}<p>{{ text }}</p>{% endif %}
|
||||
{% if issues %}
|
||||
<ul class='issues'>
|
||||
{% for i in issues %}<li class='{{ i.severity }}'><code>{{ i.code }}</code> {{ i.path }} {{ i.message }}{% if i.hint %} <small>({{ i.hint }})</small>{% endif %}</li>{% endfor %}
|
||||
</ul>
|
||||
{% endif %}
|
||||
{% for l in links %}<p><a href='{{ l.url }}'>{{ l.label }}</a></p>{% endfor %}
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,107 @@
|
||||
{% extends 'shell.html.j2' %}
|
||||
{% from '_fields.html.j2' import field %}
|
||||
{% block title %}{{ values.title }} — админка{% endblock %}
|
||||
|
||||
{% macro act(url, label, name='', value='', cls='') %}
|
||||
<form method='post' action='{{ url }}' class='inline-form'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<input type='hidden' name='etag' value='{{ etag }}'>
|
||||
{% if name %}<input type='hidden' name='{{ name }}' value='{{ value }}'>{% endif %}
|
||||
<button type='submit' class='small {{ cls }}'>{{ label }}</button>
|
||||
</form>
|
||||
{% endmacro %}
|
||||
|
||||
{% macro add_form(region='', parent='', slot='') %}
|
||||
<form method='post' action='/admin/pages/{{ page_id }}/add' class='add'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<input type='hidden' name='etag' value='{{ etag }}'>
|
||||
{% if region %}<input type='hidden' name='region' value='{{ region }}'>{% endif %}
|
||||
{% if parent %}<input type='hidden' name='parent' value='{{ parent }}'><input type='hidden' name='slot' value='{{ slot }}'>{% endif %}
|
||||
<select name='fragment' aria-label='Фрагмент'>
|
||||
{% for cat, ids in fragments %}<optgroup label='{{ cat }}'>{% for fid in ids %}<option value='{{ fid }}'>{{ fid }}</option>{% endfor %}</optgroup>{% endfor %}
|
||||
</select>
|
||||
<button type='submit' class='small'>+ Добавить блок</button>
|
||||
</form>
|
||||
{% endmacro %}
|
||||
|
||||
{% macro blocks(items) %}
|
||||
<ul class='blocks'>
|
||||
{% for b in items %}
|
||||
<li class='block{% if b.hidden %} is-hidden{% endif %}'>
|
||||
<div class='head'>
|
||||
<strong>{{ b.fragment }}</strong> <code>{{ b.id }}</code>
|
||||
{% if b.hidden %}<em>скрыт</em>{% endif %}
|
||||
{% if b.requires %}<small>нужны: {{ b.requires|join(', ') }}</small>{% endif %}
|
||||
<span class='muted'>{{ b.summary }}</span>
|
||||
</div>
|
||||
<div class='actions'>
|
||||
<a href='/admin/pages/{{ page_id }}/blocks/{{ b.id }}'>Изменить</a>
|
||||
{{ act('/admin/pages/' ~ page_id ~ '/blocks/' ~ b.id ~ '/move', '↑', 'dir', 'up') }}
|
||||
{{ act('/admin/pages/' ~ page_id ~ '/blocks/' ~ b.id ~ '/move', '↓', 'dir', 'down') }}
|
||||
{{ act('/admin/pages/' ~ page_id ~ '/blocks/' ~ b.id ~ '/toggle', 'Показать' if b.hidden else 'Скрыть') }}
|
||||
{{ act('/admin/pages/' ~ page_id ~ '/blocks/' ~ b.id ~ '/delete', 'Удалить', cls='danger') }}
|
||||
</div>
|
||||
{% for s in b.slots %}
|
||||
<div class='slot'>
|
||||
<h4>Слот «{{ s.name }}»</h4>
|
||||
{{ blocks(s.blocks) }}
|
||||
{{ add_form(parent=b.id, slot=s.name) }}
|
||||
</div>
|
||||
{% endfor %}
|
||||
</li>
|
||||
{% endfor %}
|
||||
</ul>
|
||||
{% endmacro %}
|
||||
|
||||
{% block content %}
|
||||
<p class='crumbs'><a href='/admin/pages'>← Все страницы</a></p>
|
||||
<h1>{{ values.title }}</h1>
|
||||
<p class='muted'><code>{{ file }}</code> · адрес <code>{{ route }}</code></p>
|
||||
|
||||
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
|
||||
{% if issues %}
|
||||
<details class='issues-box' open>
|
||||
<summary>Проверка страницы: {{ issues|length }}</summary>
|
||||
<ul class='issues'>
|
||||
{% for i in issues %}<li class='{{ i.severity }}'><code>{{ i.code }}</code> {{ i.message }} <small>{{ i.path }}</small></li>{% endfor %}
|
||||
</ul>
|
||||
</details>
|
||||
{% endif %}
|
||||
|
||||
<h2>Страница</h2>
|
||||
<form method='post' action='/admin/pages/{{ page_id }}/meta' class='stack'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<input type='hidden' name='etag' value='{{ etag }}'>
|
||||
<label>Заголовок * <input type='text' name='title' value='{{ values.title }}' required></label>
|
||||
<label>Статус
|
||||
<select name='status'>{% for s in statuses %}<option value='{{ s }}'{% if s == values.status %} selected{% endif %}>{{ s }}</option>{% endfor %}</select>
|
||||
</label>
|
||||
<label>Layout
|
||||
<select name='layout'>
|
||||
<option value=''>по умолчанию</option>
|
||||
{% for l in layouts %}<option value='{{ l }}'{% if l == values.layout %} selected{% endif %}>{{ l }}</option>{% endfor %}
|
||||
</select>
|
||||
</label>
|
||||
<label>Адрес (если не совпадает с путём файла) <input type='text' name='route' value='{{ values.route }}' placeholder='/scenarios/legal/'></label>
|
||||
<label>Описание для поисковиков <input type='text' name='seo_description' value='{{ values.seo_description }}'></label>
|
||||
<label>Текст страницы (Markdown, доступен блокам как <code>page.body</code>)
|
||||
<textarea name='body' rows='8'>{{ values.body }}</textarea>
|
||||
</label>
|
||||
<button type='submit'>Сохранить</button>
|
||||
</form>
|
||||
|
||||
<h2>Блоки</h2>
|
||||
{% for r in regions %}
|
||||
<section class='region'>
|
||||
<h3>Регион «{{ r.name }}»</h3>
|
||||
{% if r.fixed %}
|
||||
<p class='muted'>Закреплены в layout: {% for f in r.fixed %}<code>{{ f.fragment }}</code> {% endfor %}</p>
|
||||
{% endif %}
|
||||
{{ blocks(r.blocks) }}
|
||||
{% if r.can_add %}{{ add_form(region=r.name) }}{% endif %}
|
||||
</section>
|
||||
{% endfor %}
|
||||
|
||||
<h2>Предпросмотр</h2>
|
||||
<iframe class='preview' sandbox src='/admin/preview/pages/{{ page_id }}' title='Предпросмотр страницы'></iframe>
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,34 @@
|
||||
{% extends 'shell.html.j2' %}
|
||||
{% block title %}Страницы — админка{% endblock %}
|
||||
{% block content %}
|
||||
<h1>Страницы</h1>
|
||||
<table>
|
||||
<thead><tr><th>Страница</th><th>Адрес</th><th>Статус</th><th></th></tr></thead>
|
||||
<tbody>
|
||||
{% for p in pages %}
|
||||
<tr>
|
||||
<td>{{ p.title }}<br><small class='muted'>{{ p.id }}</small></td>
|
||||
<td><code>{{ p.route }}</code></td>
|
||||
<td><span class='status status-{{ p.status }}'>{{ p.status }}</span></td>
|
||||
<td><a href='/admin/pages/{{ p.id }}'>Изменить</a></td>
|
||||
</tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
<h2>Новая страница</h2>
|
||||
{% if errors %}<ul class='issues'>{% for e in errors %}<li class='error'>{{ e }}</li>{% endfor %}</ul>{% endif %}
|
||||
<form method='post' action='/admin/pages/new' class='stack'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<label>Путь страницы (латиница, <code>services/new</code>)
|
||||
<input type='text' name='page_id' value='{{ values.page_id }}' required>
|
||||
</label>
|
||||
<label>Заголовок <input type='text' name='title' value='{{ values.title }}' required></label>
|
||||
<label>Layout
|
||||
<select name='layout'>
|
||||
<option value=''>по умолчанию</option>
|
||||
{% for l in layouts %}<option value='{{ l }}'{% if l == values.layout %} selected{% endif %}>{{ l }}</option>{% endfor %}
|
||||
</select>
|
||||
</label>
|
||||
<button type='submit'>Создать черновик</button>
|
||||
</form>
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,32 @@
|
||||
{% extends 'shell.html.j2' %}
|
||||
{% block title %}Публикация — админка{% endblock %}
|
||||
{% block content %}
|
||||
<h1>Публикация</h1>
|
||||
{% if issues %}
|
||||
<h2>Проблемы сборки</h2>
|
||||
<ul class='issues'>{% for i in issues %}<li class='{{ i.severity }}'><code>{{ i.code }}</code> {{ i.path }} {{ i.message }}</li>{% endfor %}</ul>
|
||||
{% endif %}
|
||||
<p>Сейчас на сайте: {% if current %}<code>{{ current }}</code>{% else %}ничего не опубликовано{% endif %}</p>
|
||||
<form method='post' action='/admin/publish'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<button type='submit'>Опубликовать текущий черновик сайта</button>
|
||||
</form>
|
||||
<p class='muted'>В релиз попадают только страницы и записи со статусом published. Если сборка не пройдёт проверку, опубликованный сайт не изменится.</p>
|
||||
<h2>Релизы</h2>
|
||||
<table>
|
||||
<thead><tr><th>Релиз</th><th></th></tr></thead>
|
||||
<tbody>
|
||||
{% for b in builds %}
|
||||
<tr>
|
||||
<td><code>{{ b.id }}</code>{% if b.current %} <span class='status status-published'>текущий</span>{% endif %}</td>
|
||||
<td>{% if not b.current %}
|
||||
<form method='post' action='/admin/publish/rollback/{{ b.id }}' class='inline-form'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'><button type='submit' class='small'>Вернуть этот релиз</button>
|
||||
</form>{% endif %}</td>
|
||||
</tr>
|
||||
{% else %}
|
||||
<tr><td colspan='2'>Релизов пока нет</td></tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
{% endblock %}
|
||||
@@ -0,0 +1,24 @@
|
||||
{% extends 'base.html.j2' %}
|
||||
{% block bodyattrs %}{% if htmx %} hx-boost='true'{% endif %}{% endblock %}
|
||||
{% block scripts %}{% if htmx %}<script src='/admin/static/htmx.min.js' defer></script>{% endif %}{% endblock %}
|
||||
{% block body %}
|
||||
<header class='bar'>
|
||||
<strong>Админка</strong>
|
||||
<nav class='nav'>
|
||||
<a href='/admin/'{% if section == 'dashboard' %} class='active'{% endif %}>Обзор</a>
|
||||
<a href='/admin/pages'{% if section == 'pages' %} class='active'{% endif %}>Страницы</a>
|
||||
<a href='/admin/content'{% if section == 'content' %} class='active'{% endif %}>Контент</a>
|
||||
<a href='/admin/publish'{% if section == 'publish' %} class='active'{% endif %}>Публикация</a>
|
||||
</nav>
|
||||
<span class='spacer'></span>
|
||||
<span>{{ login }}</span>
|
||||
<form method='post' action='/admin/logout'>
|
||||
<input type='hidden' name='csrf' value='{{ csrf }}'>
|
||||
<button type='submit'>Выйти</button>
|
||||
</form>
|
||||
</header>
|
||||
{% if flash %}<p class='flash' role='status'>{{ flash }}</p>{% endif %}
|
||||
<main class='content'>
|
||||
{% block content %}{% endblock %}
|
||||
</main>
|
||||
{% endblock %}
|
||||
@@ -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")
|
||||
|
||||
@@ -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
|
||||
@@ -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()
|
||||
|
||||
@@ -0,0 +1,480 @@
|
||||
import json
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
from helpers import SiteTestCase
|
||||
from helpers_html import scrape_form
|
||||
from test_auth import PASSWORD, Clock, make_cfg
|
||||
|
||||
from site_engine.parsing import frontmatter
|
||||
from site_engine.services.auth import AuthService
|
||||
from site_engine.storage.history import list_versions
|
||||
from site_engine.web.admin.editor import EditorHandlers
|
||||
from site_engine.web.admin.forms import FormData
|
||||
|
||||
ORIGIN = {"host": "admin.example", "origin": "https://admin.example"}
|
||||
|
||||
|
||||
class EditorTestCase(SiteTestCase):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.auth = AuthService(make_cfg(), self.tmp / "state", clock=Clock())
|
||||
self.dist = self.tmp / "dist"
|
||||
self.ed = EditorHandlers(self.auth, self.site, self.dist)
|
||||
self.cookie = self.auth.login("admin", PASSWORD, "1.1.1.1")
|
||||
self.csrf = self.auth.csrf_token(self.auth.authenticate(self.cookie))
|
||||
|
||||
# запросы
|
||||
def get(self, path, query=None, cookie="default"):
|
||||
cookie = self.cookie if cookie == "default" else cookie
|
||||
return self.ed.dispatch("GET", path, query or {}, FormData(), cookie, ORIGIN, "1.1.1.1")
|
||||
|
||||
def post(self, path, data=None, *, csrf=True, headers=None, cookie="default"):
|
||||
cookie = self.cookie if cookie == "default" else cookie
|
||||
form = data if isinstance(data, FormData) else FormData({k: v if isinstance(v, list) else [v] for k, v in (data or {}).items()})
|
||||
if csrf and "csrf" not in form:
|
||||
form._d["csrf"] = [self.csrf]
|
||||
return self.ed.dispatch("POST", path, {}, form, cookie, headers or ORIGIN, "1.1.1.1")
|
||||
|
||||
def form(self, path, action):
|
||||
result = self.get(path)
|
||||
self.assertEqual(result.status, 200, result.body[:300])
|
||||
return FormData(scrape_form(result.body, action))
|
||||
|
||||
def submit_form(self, path, action, **changes):
|
||||
"""Как человек: открыть страницу, поправить поля, отправить форму."""
|
||||
form = self.form(path, action)
|
||||
for key, value in changes.items():
|
||||
form._d[key.replace("__", ".")] = value if isinstance(value, list) else [value]
|
||||
return self.post(action.removeprefix("/admin"), form)
|
||||
|
||||
# файлы
|
||||
def meta(self, rel):
|
||||
return frontmatter.parse((self.site / rel).read_text(encoding="utf-8"))
|
||||
|
||||
def block(self, rel, block_id, region="main"):
|
||||
meta, _ = self.meta(rel)
|
||||
return next(b for b in meta["regions"][region] if b["id"] == block_id)
|
||||
|
||||
def audit_text(self):
|
||||
return (self.tmp / "state" / "audit.jsonl").read_text(encoding="utf-8")
|
||||
|
||||
|
||||
class AccessTest(EditorTestCase):
|
||||
def test_everything_requires_login(self):
|
||||
for method, path in (("GET", "/pages"), ("GET", "/pages/index"), ("POST", "/pages/new"),
|
||||
("GET", "/preview/pages/index"), ("GET", "/publish"), ("POST", "/publish")):
|
||||
result = self.ed.dispatch(method, path, {}, FormData(), None, ORIGIN, "1.1.1.1")
|
||||
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/login"), path)
|
||||
|
||||
def test_post_needs_csrf_and_same_origin_and_changes_nothing(self):
|
||||
before = (self.site / "pages/privacy.md").read_bytes()
|
||||
form = {"etag": "x", "title": "Хак", "status": "published", "body": "x"}
|
||||
self.assertEqual(self.post("/pages/privacy/meta", form, csrf=False).status, 403)
|
||||
bad = {"csrf": "wrong", **form}
|
||||
self.assertEqual(self.post("/pages/privacy/meta", bad).status, 403)
|
||||
evil = {"host": "admin.example", "origin": "https://evil.example"}
|
||||
self.assertEqual(self.post("/pages/privacy/meta", form, headers=evil).status, 403)
|
||||
self.assertEqual((self.site / "pages/privacy.md").read_bytes(), before)
|
||||
|
||||
def test_unknown_and_malicious_paths(self):
|
||||
for path in ("/nope", "/pages/../../site", "/pages/a/../b", "/pages/UPPER", "/content/services/../x", "/pages//x"):
|
||||
self.assertEqual(self.get(path).status, 404, path)
|
||||
self.assertEqual(self.get("/pages/no-such-page").status, 404)
|
||||
self.assertEqual(self.get("/pages/index/blocks/nope").status, 404)
|
||||
self.assertEqual(self.get("/content/nope").status, 404)
|
||||
self.assertEqual(self.get("/content/services/nope").status, 404)
|
||||
|
||||
def test_editor_screens_keep_security_headers_and_no_inline_code(self):
|
||||
for path in ("/pages", "/pages/index", "/pages/index/blocks/b_hero", "/content", "/content/services",
|
||||
"/content/services/bots", "/publish"):
|
||||
result = self.get(path)
|
||||
self.assertEqual(result.status, 200, path)
|
||||
self.assertIn("frame-ancestors 'none'", result.headers["Content-Security-Policy"], path)
|
||||
self.assertEqual(result.headers["Cache-Control"], "no-store")
|
||||
for bad in ("<script", "style=", "<style", "onclick="):
|
||||
self.assertNotIn(bad, result.body, f"{path}: {bad}")
|
||||
|
||||
def test_htmx_is_enabled_only_when_the_file_is_present(self):
|
||||
self.assertNotIn("hx-boost", self.get("/pages").body)
|
||||
with mock.patch("site_engine.web.admin.editor.htmx_available", return_value=True):
|
||||
body = self.get("/pages").body
|
||||
self.assertIn("hx-boost='true'", body)
|
||||
self.assertIn("src='/admin/static/htmx.min.js'", body)
|
||||
|
||||
def test_titles_are_escaped(self):
|
||||
self.edit("pages/privacy.md", "title: Политика обработки персональных данных", "title: '<script>alert(1)</script>'")
|
||||
for path in ("/pages", "/pages/privacy", "/"):
|
||||
if path == "/":
|
||||
continue
|
||||
self.assertNotIn("<script>alert(1)</script>", self.get(path).body, path)
|
||||
self.assertIn("<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("Важная <strong>оговорка</strong>", self.get("/preview/pages/privacy").body)
|
||||
|
||||
def test_add_block_to_slot(self):
|
||||
self.post("/pages/privacy/add", {"etag": self.form("/pages/privacy", "/admin/pages/privacy/add").first("etag"),
|
||||
"region": "main", "fragment": "section"})
|
||||
section = self.meta("pages/privacy.md")[0]["regions"]["main"][-1]["id"]
|
||||
page = self.get("/pages/privacy").body
|
||||
self.assertIn("Слот «content»", page)
|
||||
etag = scrape_form(page, "/admin/pages/privacy/add")["etag"][0]
|
||||
result = self.post("/pages/privacy/add", {"etag": etag, "parent": section, "slot": "content", "fragment": "richtext"})
|
||||
self.assertEqual(result.status, 303)
|
||||
children = self.block("pages/privacy.md", section)["slots"]["content"]
|
||||
self.assertEqual(children[0]["fragment"], "richtext")
|
||||
|
||||
def test_adding_to_fixed_region_or_unknown_fragment_is_refused(self):
|
||||
before = (self.site / "pages/privacy.md").read_bytes()
|
||||
etag = self.form("/pages/privacy", "/admin/pages/privacy/add").first("etag")
|
||||
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "region": "header", "fragment": "hero"}).status, 422)
|
||||
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "region": "main", "fragment": "no_such"}).status, 422)
|
||||
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "fragment": "hero"}).status, 422)
|
||||
self.assertEqual(self.post("/pages/privacy/add", {"etag": etag, "parent": "ghost", "slot": "x", "fragment": "hero"}).status, 422)
|
||||
self.assertEqual((self.site / "pages/privacy.md").read_bytes(), before)
|
||||
|
||||
def _act(self, block_id, action, **extra):
|
||||
etag = scrape_form(self.get("/pages/index").body, f"/admin/pages/index/blocks/{block_id}/{action}")["etag"][0]
|
||||
return self.post(f"/pages/index/blocks/{block_id}/{action}", {"etag": etag, **extra})
|
||||
|
||||
def test_move_up_and_down_and_edges(self):
|
||||
ids = lambda: [b["id"] for b in self.meta("pages/index.md")[0]["regions"]["main"]]
|
||||
self.assertEqual(ids(), ["b_hero", "b_dirs", "b_demo", "b_steps", "b_cta"])
|
||||
self.assertEqual(self._act("b_cta", "move", dir="up").status, 303)
|
||||
self.assertEqual(ids(), ["b_hero", "b_dirs", "b_demo", "b_cta", "b_steps"])
|
||||
self._act("b_hero", "move", dir="down")
|
||||
self.assertEqual(ids()[:2], ["b_dirs", "b_hero"])
|
||||
before = (self.site / "pages/index.md").read_bytes()
|
||||
result = self._act("b_dirs", "move", dir="up") # уже первый
|
||||
self.assertEqual((result.status, (self.site / "pages/index.md").read_bytes()), (303, before))
|
||||
|
||||
def test_delete_and_toggle_hidden_change_the_preview(self):
|
||||
self.assertIn("Расскажите о задаче", self.get("/preview/pages/index").body)
|
||||
self._act("b_cta", "toggle")
|
||||
self.assertTrue(self.block("pages/index.md", "b_cta")["hidden"])
|
||||
self.assertNotIn("Расскажите о задаче", self.get("/preview/pages/index").body)
|
||||
self._act("b_cta", "toggle")
|
||||
self.assertNotIn("hidden", self.block("pages/index.md", "b_cta"))
|
||||
self._act("b_cta", "delete")
|
||||
self.assertEqual([b["id"] for b in self.meta("pages/index.md")[0]["regions"]["main"]],
|
||||
["b_hero", "b_dirs", "b_demo", "b_steps"])
|
||||
|
||||
def test_block_actions_use_if_match(self):
|
||||
etag = scrape_form(self.get("/pages/index").body, "/admin/pages/index/blocks/b_cta/delete")["etag"][0]
|
||||
self.edit("pages/index.md", "Расскажите о задаче", "Расскажите подробнее")
|
||||
result = self.post("/pages/index/blocks/b_cta/delete", {"etag": etag})
|
||||
self.assertEqual(result.status, 409)
|
||||
self.assertEqual(self.block("pages/index.md", "b_cta")["props"]["title"], "Расскажите подробнее")
|
||||
|
||||
def test_missing_required_prop_is_saved_but_reported_and_blocks_publish(self):
|
||||
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="")
|
||||
self.assertNotIn("title", self.block("pages/index.md", "b_hero")["props"])
|
||||
page = self.get("/pages/index").body
|
||||
self.assertIn("E_REQUIRED", page) # проверка страницы показывает проблему
|
||||
result = self.post("/publish")
|
||||
self.assertEqual(result.status, 422)
|
||||
self.assertIn("E_REQUIRED", result.body)
|
||||
self.assertFalse((self.dist / "current").exists())
|
||||
|
||||
|
||||
class PreviewTest(EditorTestCase):
|
||||
def test_preview_pages_entries_and_drafts(self):
|
||||
result = self.get("/preview/pages/index")
|
||||
self.assertEqual(result.status, 200)
|
||||
self.assertIn("Telegram-боты, AI-системы и автоматизации", result.body)
|
||||
self.assertIn("frame-ancestors 'self'", result.headers["Content-Security-Policy"])
|
||||
self.assertEqual(result.headers["X-Frame-Options"], "SAMEORIGIN")
|
||||
self.assertIn("Черновик", self.get("/preview/pages/drafts/next").body)
|
||||
self.assertIn("Автоматизация общения", self.get("/preview/entries/services/bots").body)
|
||||
self.assertEqual(self.get("/preview/pages/nope").status, 404)
|
||||
self.assertEqual(self.get("/preview/entries/services/nope").status, 404)
|
||||
|
||||
def test_preview_requires_login(self):
|
||||
self.assertEqual(self.get("/preview/pages/index", cookie=None).status, 303)
|
||||
|
||||
|
||||
class EntryTest(EditorTestCase):
|
||||
def test_collections_and_entries_screens(self):
|
||||
self.assertIn("Услуги", self.get("/content").body)
|
||||
body = self.get("/content/services").body
|
||||
for text in ("bots", "Telegram-боты", "/services/bots/", "Новая запись"):
|
||||
self.assertIn(text, body)
|
||||
body = self.get("/content/services/bots").body
|
||||
for text in ("name='p.title'", "name='p.tagline'", "name='p.order'", "name='status'", "name='body'", "Предпросмотр"):
|
||||
self.assertIn(text, body)
|
||||
|
||||
def test_noop_entry_save_is_lossless(self):
|
||||
for slug in ("bots", "ai", "automation"):
|
||||
rel = f"content/services/{slug}.md"
|
||||
before = self.meta(rel)
|
||||
action = f"/admin/content/services/{slug}"
|
||||
self.assertEqual(self.submit_form(f"/content/services/{slug}", action).status, 303, slug)
|
||||
after = self.meta(rel)
|
||||
self.assertEqual(after[0], before[0], slug)
|
||||
self.assertEqual(after[1].strip(), before[1].strip(), slug)
|
||||
|
||||
def test_edit_entry_fields_status_and_body(self):
|
||||
self.submit_form("/content/services/bots", "/admin/content/services/bots", p__tagline="Новый слоган",
|
||||
p__order="5", status="draft", body="Новый **текст**")
|
||||
meta, body = self.meta("content/services/bots.md")
|
||||
self.assertEqual((meta["tagline"], meta["order"], meta["status"]), ("Новый слоган", 5, "draft"))
|
||||
self.assertEqual(body.strip(), "Новый **текст**")
|
||||
# запись-черновик не попадает в запросы коллекции
|
||||
self.assertNotIn("Новый слоган", self.get("/preview/pages/index").body)
|
||||
|
||||
def test_invalid_entry_values(self):
|
||||
before = (self.site / "content/services/bots.md").read_bytes()
|
||||
result = self.submit_form("/content/services/bots", "/admin/content/services/bots", p__order="abc")
|
||||
self.assertEqual(result.status, 422)
|
||||
self.assertIn("ожидается число", result.body)
|
||||
self.assertEqual((self.site / "content/services/bots.md").read_bytes(), before)
|
||||
|
||||
def test_entry_stale_etag(self):
|
||||
form = self.form("/content/services/bots", "/admin/content/services/bots")
|
||||
self.edit("content/services/bots.md", "Автоматизация общения", "Чужая правка")
|
||||
form._d["p.tagline"] = ["Моя правка"]
|
||||
self.assertEqual(self.post("/content/services/bots", form).status, 409)
|
||||
self.assertIn("Чужая правка", (self.site / "content/services/bots.md").read_text(encoding="utf-8"))
|
||||
|
||||
def test_create_entry(self):
|
||||
result = self.post("/content/services/new", {"slug": "mobile"})
|
||||
self.assertEqual((result.status, result.headers["Location"]), (303, "/admin/content/services/mobile?msg=created"))
|
||||
self.assertEqual(self.meta("content/services/mobile.md")[0], {"status": "draft"})
|
||||
for slug in ("bots", "UPPER", "new", "a b", "../x", ""):
|
||||
self.assertEqual(self.post("/content/services/new", {"slug": slug}).status, 422, slug)
|
||||
|
||||
def test_unknown_key_blocks_published_entry_but_not_draft(self):
|
||||
self.edit("content/services/ai.md", "order: 2", "order: 2\nlegacy: 1")
|
||||
result = self.submit_form("/content/services/ai", "/admin/content/services/ai")
|
||||
self.assertEqual(result.status, 422)
|
||||
self.assertIn("не описано схемой", result.body)
|
||||
self.edit("content/services/ai.md", "status: published", "status: draft")
|
||||
self.assertEqual(self.submit_form("/content/services/ai", "/admin/content/services/ai").status, 303)
|
||||
self.assertEqual(self.meta("content/services/ai.md")[0]["legacy"], 1) # ничего не потеряно
|
||||
|
||||
|
||||
class PublishTest(EditorTestCase):
|
||||
def test_publish_and_rollback(self):
|
||||
self.assertIn("Релизов пока нет", self.get("/publish").body)
|
||||
self.assertEqual(self.post("/publish").headers["Location"], "/admin/publish?msg=published")
|
||||
first = (self.dist / "current").resolve().name
|
||||
self.assertTrue((self.dist / first / "index.html").is_file())
|
||||
# меняем страницу и публикуем снова (имя релиза содержит время: ждём другую секунду через правку содержимого)
|
||||
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="Заголовок v2")
|
||||
with mock.patch("site_engine.build.pipeline.dt") as fake_dt:
|
||||
import datetime as real
|
||||
fake_dt.datetime.now.return_value = real.datetime(2030, 1, 1, tzinfo=real.timezone.utc)
|
||||
fake_dt.timezone = real.timezone
|
||||
self.post("/publish")
|
||||
second = (self.dist / "current").resolve().name
|
||||
self.assertNotEqual(first, second)
|
||||
self.assertIn("Заголовок v2", (self.dist / second / "index.html").read_text(encoding="utf-8"))
|
||||
page = self.get("/publish").body
|
||||
self.assertIn("текущий", page)
|
||||
self.assertEqual(self.post(f"/publish/rollback/{first}").headers["Location"], "/admin/publish?msg=rolled_back")
|
||||
self.assertEqual((self.dist / "current").resolve().name, first)
|
||||
self.assertEqual(self.post("/publish/rollback/20300101T000000-deadbeef").status, 404)
|
||||
|
||||
def test_failed_publish_keeps_live_site(self):
|
||||
self.post("/publish")
|
||||
live = (self.dist / "current").resolve().name
|
||||
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="")
|
||||
self.assertEqual(self.post("/publish").status, 422)
|
||||
self.assertEqual((self.dist / "current").resolve().name, live)
|
||||
|
||||
def test_audit_trail_of_editor_actions_has_no_content(self):
|
||||
self.post("/pages/new", {"page_id": "audit-test", "title": "СекретныйЗаголовок"})
|
||||
self.submit_form("/pages/audit-test", "/admin/pages/audit-test/meta", body="СекретныйТекст")
|
||||
self.post("/publish")
|
||||
audit = self.audit_text()
|
||||
events = [json.loads(line)["event"] for line in audit.splitlines()]
|
||||
for event in ("page_create", "page_save", "publish"):
|
||||
self.assertIn(event, events)
|
||||
for secret in ("СекретныйЗаголовок", "СекретныйТекст"):
|
||||
self.assertNotIn(secret, audit)
|
||||
|
||||
|
||||
class WriteScopeTest(EditorTestCase):
|
||||
def test_editor_never_writes_outside_pages_and_content(self):
|
||||
snapshot = {p: p.read_bytes() for p in self.site.rglob("*") if p.is_file() and not any(
|
||||
part in (".engine",) for part in p.parts) and p.relative_to(self.site).parts[0] not in ("pages", "content")}
|
||||
self.post("/pages/new", {"page_id": "scope-test", "title": "T"})
|
||||
self.submit_form("/pages/index/blocks/b_hero", "/admin/pages/index/blocks/b_hero", p__title="X")
|
||||
self.post("/content/services/new", {"slug": "scope"})
|
||||
after = {p: p.read_bytes() for p in snapshot}
|
||||
self.assertEqual(after, snapshot)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user