diff --git a/ops/bots/hub/bots.py b/ops/bots/hub/bots.py
index 68c6c68..771a934 100644
--- a/ops/bots/hub/bots.py
+++ b/ops/bots/hub/bots.py
@@ -24,10 +24,68 @@ def _empty_hint():
class MediaBot(Bot):
+ ALIASES = dict(Bot.ALIASES, **{"связи": "связи", "тема": "тема",
+ "рекомендации": "рекомендации"})
name = "media"
title = "Медиа"
room_env = "MEDIA_ROOM"
+
+
+ def _theme_cmd(self, arg):
+ term = (arg or "").strip()
+ if not term:
+ return "Укажите тему: !тема artificial intelligence"
+ card, err = core_api.find_entity(term, kinds=["тема", "жанр"])
+ if err:
+ return "Ядро не ответило: " + str(err)
+ if not card:
+ return "Темы «" + term + "» в графе нет."
+ data, _ = core_api.links_of(card["id"])
+ links = (data or {}).get("links") or []
+ title = card.get("title") or term
+ if not links:
+ return "К теме «" + title + "» ничего не привязано."
+ lines = ["**" + title + "** — связей: " + str(len(links)), ""]
+ for l in links[:15]:
+ lines.append("• " + str(l.get("title")) + " (" + str(l.get("kind")) + ")")
+ return chr(10).join(lines)
+
+ def _recommend_cmd(self):
+ items, err = core_api.entities("кандидат", limit=200)
+ if err:
+ return "Ядро не ответило: " + str(err)
+ if not items:
+ return "Рекомендаций пока нет — нужен хотя бы один фильм в медиатеке."
+ lines = ["**Что посмотреть** (рекомендации по вашим фильмам)", ""]
+ for i in items[:15]:
+ lines.append("• " + str(i.get("title")))
+ lines.append("")
+ lines.append("_Это кандидаты: их нет в медиатеке, но они рекомендованы._")
+ return chr(10).join(lines)
+
+ def _graph_cmd(self, arg):
+ term = (arg or "").strip()
+ if not term:
+ return "Укажите название: !связи Дюна"
+ card, err = core_api.find_entity(term)
+ if err:
+ return "Ядро не ответило: " + str(err)
+ if not card:
+ return "«" + term + "» в графе нет."
+ data, _ = core_api.links_of(card["id"])
+ info = data or {}
+ links = info.get("links") or []
+ lines = ["**" + str(card.get("title")) + "** (" + str(card.get("kind")) + ")", ""]
+ by_rel = {}
+ for l in links:
+ by_rel.setdefault(l.get("relation") or "связь", []).append(str(l.get("title")))
+ for rel, titles in by_rel.items():
+ lines.append("• " + rel + ": " + ", ".join(titles[:8]))
+ if not links:
+ lines.append("_связей нет_")
+ return chr(10).join(lines)
+
def _media_hub_cmd(self):
"""Медиа Хаб: заявки, очередь, просмотр, нехватка, место."""
data, err = core_api.get_data("media", 1)
@@ -57,6 +115,9 @@ class MediaBot(Bot):
self.cmd("paths", "где лежат файлы и куда их класть")(lambda a: self._paths())
self.cmd("хаб", "медиа хаб: заявки, очередь, просмотр, место")(lambda a: self._media_hub_cmd())
+ self.cmd("тема", "подборка по теме: !тема artificial intelligence")(lambda a: self._theme_cmd(a))
+ self.cmd("рекомендации", "что посмотреть из рекомендаций")(lambda a: self._recommend_cmd())
+ self.cmd("связи", "все связи объекта: !связи Дюна")(lambda a: self._graph_cmd(a))
def _stats(self, jf):
c = jf.counts()
info, _ = jf.info()
diff --git a/ops/bots/hub/core_api.py b/ops/bots/hub/core_api.py
index afc5889..13460a9 100644
--- a/ops/bots/hub/core_api.py
+++ b/ops/bots/hub/core_api.py
@@ -80,3 +80,27 @@ def services():
def service_history(name, limit=30):
return _get(f"/service/{name}", {"limit": limit})
+
+
+def find_entity(text, kinds=None):
+ data, err = _get("/search", {"q": text, "limit": 20})
+ if err:
+ return None, err
+ items = (data or {}).get("items") or []
+ if kinds:
+ items = [i for i in items if i.get("kind") in kinds]
+ return (items[0] if items else None), None
+
+
+def links_of(entity_id):
+ return _get("/entity/%s" % entity_id)
+
+
+def entities(kind=None, limit=200):
+ data, err = _get("/entities", {"limit": limit})
+ if err:
+ return [], err
+ items = (data or {}).get("items") or []
+ if kind:
+ items = [i for i in items if i.get("kind") == kind]
+ return items, None
diff --git a/ops/media/CONTENT-GRAPH.md b/ops/media/CONTENT-GRAPH.md
index c116fd3..a87d983 100644
--- a/ops/media/CONTENT-GRAPH.md
+++ b/ops/media/CONTENT-GRAPH.md
@@ -1,74 +1,92 @@
# Граф контента
-Связи между фильмами, книгами, франшизами, жанрами, студиями, темами и
-эпохами. Превращает список файлов в медиатеку, по которой можно
-ориентироваться.
+Связи между фильмами, книгами, франшизами, персонами, темами и эпохами.
## Что связывается
-| Связь | Источник данных |
+| Связь | Источник |
|---|---|
-| фильм → коллекция «входит в» | `collection` из Radarr |
-| фильм → жанр «жанр» | `genres` из Radarr |
-| фильм → студия «снят студией» | `studio` из Radarr |
-| фильм → тема «тема» | `keywords` из Radarr (до 5 на фильм) |
+| фильм → коллекция «входит в» | `collection` Radarr (TMDB) |
+| фильм → жанр «жанр» | `genres` Radarr |
+| фильм → студия «снят студией» | `studio` Radarr |
+| фильм → тема «тема» | `keywords` Radarr |
| фильм → эпоха «снят в» | год → десятилетие |
-| фильм → фильм «продолжение» | коллекция, сортировка по году |
+| **фильм → режиссёр «снял»** | `Credits.Crew` (Job=Director) из SkyHook |
+| **фильм → актёр «снялся»** | `Credits.Cast` (до 5) из SkyHook |
+| **фильм → оценка «оценка»** | `MovieRatings.Imdb` → 8+/7–8/<7 |
+| **фильм → рейтинг «возрастной рейтинг»** | `Certifications` (US) |
+| **фильм → язык «язык»** | `OriginalLanguage` |
+| **фильм → кандидат «рекомендует»** | `Recommendations` TMDB |
+| фильм → фильм «продолжение» | коллекция по годам |
| фильм ↔ фильм «похож» | ≥2 общих жанра |
| книга → автор «написал» | авторы Calibre |
| книга → серия «входит в серию» | серия Calibre |
| книга → жанр «жанр» | теги Calibre |
-| книга ↔ фильм «экранизация» | совпадение нормализованного названия |
-| коллекция ↔ книжная серия «общая вселенная» | название коллекции = название серии |
+| книга ↔ фильм «экранизация» | совпадение названия |
+| коллекция ↔ книжная серия «общая вселенная» | название коллекции = серия |
-## Наполнение для проверки
+## Как получаются детали
-Метаданные без скачивания файлов:
+Radarr — это **SkyHook-прокси**: `https://api.radarr.video/v1/movie/{tmdb}`
+отдаёт `Credits` (30 человек), `Recommendations` (10), `MovieRatings`,
+`Certifications`, `AlternativeTitles`, `OriginalLanguage`.
-* **12 фильмов** (Radarr, через прокси к SkyHook): Matrix ×3, Dune ×2,
- Blade Runner ×2, Arrival, Interstellar, The Fifth Element, Alien, Prometheus;
-* **10 книг** (Calibre, созданы как минимальные EPUB с метаданными):
- Dune ×3, Hainish ×2, Hyperion Cantos ×2, Foundation, I Robot, Neuromancer;
-* теги книг: science fiction, space opera, cyberpunk, classic, robots.
+Запросы идут через прокси узла (`http://192.168.1.10:8888`), потому что
+домашний IP для SkyHook заблокирован Cloudflare.
+
+## Русские названия
+
+Из `AlternativeTitles` берутся варианты с `Language: ru` и сохраняются как
+алиасы карточки (поле `search_text`). Поэтому `!связи Дюна` находит
+`Dune (2021)` и `Dune: Part Two (2024)`.
## Результат
```
фильмов: 12, книг: 10
-карточек: 182, связей: 193
+персон связано: 75
+карточек: 359, связей: 376
-Связи:
- тема: 60 (ключевые слова фильмов)
- жанр: 49 (11 жанров)
- похож: 22 (общие жанры)
- снят в: 12 (6 эпох)
- снят студией: 12 (8 студий)
- написал: 10 (5 авторов)
- входит в: 9 (5 коллекций)
- входит в серию: 8 (4 серии)
- продолжение: 4
- экранизация: 1
- общая вселенная: 1
+По типам:
+ рекомендует: 72 тема: 60 снялся: 60
+ жанр: 49 похож: 22 снял: 15
+ снят в: 12 оценка: 12 язык: 12
+ снят студией: 12 возрастной: 12 написал: 10
+ входит в: 9 серия: 8 продолжение: 4
+ общая вселенная: 1 экранизация: 1
```
-Примеры:
+Карточки: 48 актёров, 42 темы, 41 кандидат, 12 фильмов, 11 жанров,
+10 книг, 8 студий, 6 режиссёров, 6 эпох, 5 авторов, 5 коллекций,
+4 книжные серии.
+
+## Команды бота Медиа
```
-Продолжения:
- Blade Runner (1982) → Blade Runner 2049 (2017)
- Dune (2021) → Dune: Part Two (2024)
- The Matrix (1999) → The Matrix Reloaded (2003)
- The Matrix Reloaded (2003) → The Matrix Revolutions (2003)
-
-Экранизация: Dune ↔ Dune (2021)
-Общая вселенная: Dune Collection ↔ Dune (книжная серия)
-
-Топ жанров: science fiction 21, Adventure 4, classic 4, Drama 4, Action 4
+тема artificial intelligence → 6 фильмов про ИИ
+связи Дюна → вся карточка: актёры, язык, оценка, темы,
+ жанры, похожие, студия, эпоха, рекомендации
+рекомендации → 15 кандидатов, которых нет в медиатеке
+хаб → полный обзор медиатеки
```
-## Где видно
+Пример `связи Дюна`:
-* `GET /links` — сводка по типам и список связей;
-* Медиа Хаб — блок «Связи контента»;
-* бот Медиа — команда `хаб`;
-* расписание — ежедневно 04:45.
+```
+Dune: Part Two (2024) (фильм)
+• снялся: Rebecca Ferguson, Timothée Chalamet, Zendaya, Javier Bardem
+• язык: английский · оценка: высокая (8+) · снят в: 2020-е
+• тема: based on novel or book, chosen one, ambiguous
+• жанр: science fiction, Adventure
+• похож: The Fifth Element, Dune (2021), Interstellar
+• снят студией: Legendary Pictures
+• рекомендует: Dune (2021), Avatar: Fire and Ash, …
+```
+
+## Ловушки
+
+* Кириллица в query-строке должна быть закодирована: `curl -G --data-urlencode`.
+ Без кодирования сервер видит мусор и возвращает пустой список.
+* `/entities` по умолчанию отдавал всё — добавлен фильтр `kind` и `limit`.
+* Псевдоним «связи» в базовом классе указывал на команду `link`, которой у
+ Медиа-бота нет. Пришлось переопределить `ALIASES` в классе MediaBot.
diff --git a/ops/media/content_graph.py b/ops/media/content_graph.py
index 1e12559..5adc3f8 100644
--- a/ops/media/content_graph.py
+++ b/ops/media/content_graph.py
@@ -1,38 +1,44 @@
-"""Граф контента v2: фильмы, книги, франшизы, жанры, студии, темы, эпохи.
+"""Граф контента v3: персоны, рекомендации, рейтинги, языки, подборки.
-Связи:
- фильм → коллекция «входит в»
- фильм → жанр «жанр»
- фильм → студия «снят студией»
- фильм → тема (ключевые слова) «тема»
- фильм → фильм «продолжение» (внутри коллекции по годам)
- фильм ↔ фильм «похож» (≥2 общих жанра)
- фильм → эпоха «снят в»
- книга → автор «написал»
- книга → серия «входит в серию»
- книга → жанр (тег) «жанр»
- книга ↔ фильм «экранизация»
- коллекция ↔ книжная серия «общая вселенная»
+Дополнительно к v2 (жанры, студии, темы, эпохи, продолжения, похожие):
+ фильм → режиссёр «снял»
+ фильм → актёр «снялся»
+ фильм → кандидат «рекомендует» (из TMDB, если фильма нет в медиатеке)
+ фильм → рейтинг «возрастной рейтинг»
+ фильм → оценка «оценка»
+ фильм → язык «язык»
"""
import json
import os
import re
import subprocess
import sys
+import urllib.error
import urllib.request
CORE = os.environ.get("CORE_URL", "http://127.0.0.1:9120")
RADARR = os.environ.get("RADARR_URL", "http://192.168.1.118:7878")
RADARR_KEY = os.environ.get("RADARR_KEY", "")
+SKYHOOK = "https://api.radarr.video/v1/movie"
+PROXY = "http://192.168.1.10:8888"
-MAX_THEMES_PER_ITEM = 5
+MAX_THEMES = 5
+MAX_CAST = 5
+MAX_RECOMMEND = 6
MAX_SIMILAR = 40
+LANGS = {"en": "английский", "ru": "русский", "fr": "французский",
+ "de": "немецкий", "ja": "японский", "es": "испанский"}
-def get(url, headers=None, timeout=25):
+
+def get(url, headers=None, timeout=25, proxy=None):
+ handlers = []
+ if proxy:
+ handlers.append(urllib.request.ProxyHandler({"https": proxy, "http": proxy}))
+ opener = urllib.request.build_opener(*handlers)
+ req = urllib.request.Request(url, headers=headers or {})
try:
- req = urllib.request.Request(url, headers=headers or {})
- with urllib.request.urlopen(req, timeout=timeout) as r:
+ with opener.open(req, timeout=timeout) as r:
return json.loads(r.read() or b"{}"), None
except Exception as e:
return None, str(e)[:100]
@@ -67,11 +73,18 @@ def movies():
"title": m.get("title"), "year": m.get("year"), "tmdb": m.get("tmdbId"),
"collection": col.get("title"), "collection_tmdb": col.get("tmdbId"),
"genres": m.get("genres") or [], "studio": m.get("studio"),
- "keywords": (m.get("keywords") or [])[:MAX_THEMES_PER_ITEM],
+ "keywords": (m.get("keywords") or [])[:MAX_THEMES],
})
return out
+def skyhook(tmdb):
+ data, err = get(f"{SKYHOOK}/{tmdb}", proxy=PROXY, timeout=40)
+ if err:
+ return {}, err
+ return data or {}, None
+
+
def books():
script = '''
import json, sqlite3
@@ -96,7 +109,6 @@ print(json.dumps(rows, ensure_ascii=False))
try:
return json.loads(out.stdout or "[]")
except Exception:
- print(" Calibre:", (out.stderr or "")[:80])
return []
@@ -113,13 +125,14 @@ def main():
bk = books()
print(f"фильмов: {len(mv)}, книг: {len(bk)}")
- ids = {}
- cards = 0
- links = 0
+ ids, cards, links = {}, 0, 0
- def card(kind, key, title, status=None):
+ def card(kind, key, title, status=None, aliases=None):
nonlocal cards
- res, err = post("/entity", {"kind": kind, "key": key, "title": title, "status": status})
+ payload = {"kind": kind, "key": key, "title": title, "status": status}
+ if aliases:
+ payload["aliases"] = aliases
+ res, err = post("/entity", payload)
if err or not res:
return None
cards += 1
@@ -134,41 +147,95 @@ def main():
if not err:
links += 1
- # фильмы и их метаданные
+ # ── фильмы и метаданные из Radarr ──
for m in mv:
mid = card("фильм", f"tmdb:{m['tmdb']}", f"{m['title']} ({m['year']})", "в медиатеке")
for g in m["genres"]:
- gid = card("жанр", f"genre:{norm(g)}", g)
- link(mid, gid, "жанр")
+ link(mid, card("жанр", f"genre:{norm(g)}", g), "жанр")
if m["studio"]:
- sid = card("студия", f"studio:{norm(m['studio'])}", m["studio"])
- link(mid, sid, "снят студией")
+ link(mid, card("студия", f"studio:{norm(m['studio'])}", m["studio"]), "снят студией")
for kw in m["keywords"]:
- tid = card("тема", f"theme:{norm(kw)}", kw)
- link(mid, tid, "тема")
+ link(mid, card("тема", f"theme:{norm(kw)}", kw), "тема")
dec = decade(m["year"])
if dec:
- did = card("эпоха", f"decade:{dec}", dec)
- link(mid, did, "снят в")
+ link(mid, card("эпоха", f"decade:{dec}", dec), "снят в")
if m["collection"]:
cid = card("коллекция", f"collection:{m['collection_tmdb'] or norm(m['collection'])}",
m["collection"], "франшиза")
link(mid, cid, "входит в")
- # книги
+ # ── детали из SkyHook: персоны, рейтинги, рекомендации, язык ──
+ in_library = {m["tmdb"] for m in mv}
+ persons = 0
+ for m in mv:
+ det, err = skyhook(m["tmdb"])
+ if err:
+ print(f" skyhook {m['title']}: {err}")
+ continue
+ mid = ids.get(f"tmdb:{m['tmdb']}")
+
+ # русские названия — для поиска «Дюна» вместо «Dune»
+ alts = []
+ for a in det.get("AlternativeTitles") or []:
+ if (a.get("Language") or "").lower() in ("ru", "ru-ru"):
+ t = a.get("Title")
+ if t and t not in alts:
+ alts.append(t)
+ if alts:
+ card("фильм", "tmdb:%s" % m["tmdb"], "%s (%s)" % (m["title"], m["year"]),
+ "в медиатеке", aliases=alts[:3])
+
+ credits = det.get("Credits") or {}
+ for c in (credits.get("Crew") or []):
+ if c.get("Job") == "Director" and c.get("Name"):
+ pid = card("режиссёр", f"person:{norm(c['Name'])}", c["Name"])
+ link(mid, pid, "снял")
+ persons += 1
+ for c in (credits.get("Cast") or [])[:MAX_CAST]:
+ if c.get("Name"):
+ pid = card("актёр", f"person:{norm(c['Name'])}", c["Name"])
+ link(mid, pid, "снялся")
+ persons += 1
+
+ ratings = det.get("MovieRatings") or {}
+ imdb = (ratings.get("Imdb") or {}).get("Value") or 0
+ if imdb:
+ bucket = "высокая (8+)" if imdb >= 8 else ("хорошая (7–8)" if imdb >= 7 else "средняя (<7)")
+ link(mid, card("оценка", f"rating:{bucket}", bucket), "оценка")
+
+ certs = det.get("Certifications") or []
+ us = next((c.get("Certification") for c in certs if c.get("Country") == "US"), None)
+ if us:
+ link(mid, card("рейтинг", f"cert:{us}", us), "возрастной рейтинг")
+
+ lang = det.get("OriginalLanguage") or ""
+ if lang:
+ name = LANGS.get(lang, lang)
+ link(mid, card("язык", f"lang:{lang}", name), "язык")
+
+ for r in (det.get("Recommendations") or [])[:MAX_RECOMMEND]:
+ rt = r.get("TmdbId")
+ if not rt or rt == m["tmdb"]:
+ continue
+ if rt in in_library:
+ link(mid, ids.get(f"tmdb:{rt}"), "рекомендует")
+ else:
+ title = r.get("Title") or f"tmdb:{rt}"
+ rid = card("кандидат", f"candidate:{rt}", title, "не в медиатеке")
+ link(mid, rid, "рекомендует")
+ print(f" персон связано: {persons}")
+
+ # ── книги ──
for b in bk:
bid = card("книга", f"calibre:{b['id']}", b["title"], "в библиотеке")
for a in b.get("authors") or []:
- aid = card("автор", f"author:{norm(a)}", a)
- link(bid, aid, "написал")
+ link(bid, card("автор", f"author:{norm(a)}", a), "написал")
if b.get("series"):
- sid = card("серия книг", f"series:{norm(b['series'])}", b["series"], "книжная серия")
- link(bid, sid, "входит в серию")
+ link(bid, card("серия книг", f"series:{norm(b['series'])}", b["series"]), "входит в серию")
for t in b.get("tags") or []:
- gid = card("жанр", f"genre:{norm(t)}", t)
- link(bid, gid, "жанр")
+ link(bid, card("жанр", f"genre:{norm(t)}", t), "жанр")
- # экранизации
+ # ── экранизации ──
by_title = {}
for m in mv:
by_title.setdefault(norm(m["title"]), []).append(m["tmdb"])
@@ -176,26 +243,25 @@ def main():
for tmdb in by_title.get(norm(b["title"]), []):
link(ids.get(f"calibre:{b['id']}"), ids.get(f"tmdb:{tmdb}"), "экранизация")
- # продолжения внутри коллекции (по году)
+ # ── продолжения ──
by_col = {}
for m in mv:
if m["collection"]:
by_col.setdefault(norm(m["collection"]), []).append(m)
- for col, items in by_col.items():
+ for _, items in by_col.items():
items.sort(key=lambda x: x.get("year") or 0)
for prev, nxt in zip(items, items[1:]):
link(ids.get(f"tmdb:{prev['tmdb']}"), ids.get(f"tmdb:{nxt['tmdb']}"), "продолжение")
- # похожие: ≥2 общих жанра
+ # ── похожие по жанрам ──
made = 0
for i, a in enumerate(mv):
for b in mv[i + 1:]:
- common = set(a["genres"]) & set(b["genres"])
- if len(common) >= 2 and made < MAX_SIMILAR:
+ if len(set(a["genres"]) & set(b["genres"])) >= 2 and made < MAX_SIMILAR:
link(ids.get(f"tmdb:{a['tmdb']}"), ids.get(f"tmdb:{b['tmdb']}"), "похож")
made += 1
- # общая вселенная: коллекция ↔ книжная серия
+ # ── общая вселенная ──
for m in mv:
if not m["collection"]:
continue
diff --git a/ops/media/core.py b/ops/media/core.py
new file mode 100644
index 0000000..5de791e
--- /dev/null
+++ b/ops/media/core.py
@@ -0,0 +1,881 @@
+"""Buryan Hub Core: шина событий и граф сущностей.
+
+Один процесс, три задачи:
+ 1) принимать события от сервисов и складывать в общую базу;
+ 2) хранить карточки сущностей и связи между ними;
+ 3) публиковать значимое в Matrix (личка владельцу).
+
+Запуск: python3 core.py (HTTP на порту 9120)
+"""
+import json
+import os
+import threading
+import time
+import urllib.request
+from datetime import datetime, timezone
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import psycopg2
+import psycopg2.extras
+
+DSN = os.environ.get("CORE_DSN", "dbname=hub_core user=hub_core password=hub_core host=127.0.0.1")
+PORT = int(os.environ.get("CORE_PORT", "9120"))
+MATRIX_HS = os.environ.get("MATRIX_HS", "https://matrix.buryans.ru")
+NOTIFY_TOKEN = os.environ.get("NOTIFY_TOKEN", "")
+NOTIFY_ROOM = os.environ.get("NOTIFY_ROOM", "")
+
+# какие события стоит показывать человеку сразу
+LOUD = {
+ "media.imported", "media.requested", "media.failed",
+ "backup.done", "backup.failed", "service.down", "service.up",
+ "monitor.down", "monitor.up", "camera.detection",
+ "photo.imported", "book.added", "document.added",
+}
+
+
+def db():
+ con = psycopg2.connect(DSN, connect_timeout=10)
+ con.autocommit = True
+ return con
+
+
+def ensure_schema():
+ sql = open(os.path.join(os.path.dirname(__file__), "schema.sql"), encoding="utf-8").read()
+ with db() as con, con.cursor() as cur:
+ cur.execute(sql)
+
+
+ROUTES_FILE = "/etc/hub-core/routes.json"
+_ROUTES = None
+
+
+def load_routes():
+ """Куда какое событие отправлять: тип → бот."""
+ global _ROUTES
+ if _ROUTES is not None:
+ return _ROUTES
+ try:
+ _ROUTES = json.load(open(ROUTES_FILE, encoding="utf-8"))
+ except Exception:
+ _ROUTES = {}
+ return _ROUTES
+
+
+def route_for(etype):
+ """Выбрать получателя по типу события."""
+ routes = load_routes()
+ for prefix in sorted(routes, key=len, reverse=True):
+ if etype.startswith(prefix):
+ return routes[prefix]
+ return {"token": NOTIFY_TOKEN, "room": NOTIFY_ROOM}
+
+
+def publish(text, etype=""):
+ """Короткое уведомление в личку владельцу."""
+ target = route_for(etype) if etype else {"token": NOTIFY_TOKEN, "room": NOTIFY_ROOM}
+ token, room = target.get("token") or NOTIFY_TOKEN, target.get("room") or NOTIFY_ROOM
+ if not (token and room):
+ return
+ txn = int(datetime.now().timestamp() * 1000)
+ import urllib.parse
+ rid = urllib.parse.quote(room, safe="")
+ body = json.dumps({"msgtype": "m.text", "body": text,
+ "format": "org.matrix.custom.html",
+ "formatted_body": text.replace("\n", "
")}).encode()
+ req = urllib.request.Request(
+ f"{MATRIX_HS}/_matrix/client/v3/rooms/{rid}/send/m.room.message/{txn}",
+ data=body, method="PUT",
+ headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"})
+ try:
+ urllib.request.urlopen(req, timeout=10)
+ except Exception:
+ pass
+
+
+def human_event(ev):
+ e = ev.get("entity") or {}
+ title = e.get("title") or e.get("key") or "объект"
+ t = ev.get("type", "")
+ icons = {"media.imported": "🎬", "media.requested": "🕓", "media.failed": "⚠️",
+ "backup.done": "💾", "backup.failed": "⚠️",
+ "service.down": "🔴", "service.up": "✅",
+ "photo.imported": "📷", "book.added": "📚", "document.added": "📄"}
+ icon = icons.get(t, "•")
+ src = ev.get("source", "?")
+ extra = ev.get("payload") or {}
+ line = f"{icon} **{title}** — {t} ({src})"
+ if extra.get("detail"):
+ line += f"\n{extra['detail']}"
+ return line
+
+
+
+
+
+
+def do_search(q, limit=20):
+ """Поиск по карточкам: название и внешние ключи."""
+ like = f"%{q.strip().lower()}%"
+ con = db()
+ cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+ cur.execute("""select id, kind, title, status, external_ids, updated_at
+ from entities where search_text like %s
+ order by updated_at desc limit %s""", (like, limit))
+ items = [dict(r) for r in cur.fetchall()]
+ con.close()
+ return {"query": q, "count": len(items), "items": items}
+
+
+def do_entity(eid):
+ """Карточка: сама сущность, её связи и история событий."""
+ con = db()
+ cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+ cur.execute("select * from entities where id = %s", (eid,))
+ row = cur.fetchone()
+ if not row:
+ con.close()
+ return None
+ card = dict(row)
+
+ cur.execute("""select e.id, e.kind, e.title, l.relation
+ from entity_links l
+ join entities e on e.id = case when l.from_id = %s then l.to_id else l.from_id end
+ where l.from_id = %s or l.to_id = %s""", (eid, eid, eid))
+ links = [dict(r) for r in cur.fetchall()]
+
+ cur.execute("""select at, source, type, payload from events
+ where entity_id = %s order by id desc limit 50""", (eid,))
+ history = [dict(r) for r in cur.fetchall()]
+ con.close()
+ return {"card": card, "links": links, "history": history}
+
+
+
+
+DATA_DIR = os.environ.get("PROJECT_DATA", "/root/buryan-infra/data")
+
+
+def _ensure_doc_table():
+ con = db()
+ with con.cursor() as cur:
+ cur.execute("""
+ create table if not exists data_docs (
+ id bigserial primary key,
+ collection text not null,
+ key text not null,
+ payload jsonb not null,
+ tags text[] not null default '{}',
+ created_at timestamptz not null default now(),
+ updated_at timestamptz not null default now(),
+ unique (collection, key)
+ )""")
+ cur.execute("create index if not exists idx_docs_collection on data_docs (collection)")
+ con.close()
+
+
+def do_data_put(collection, data):
+ """Сохранить документ: {key, payload, tags}."""
+ _ensure_doc_table()
+ key = str(data.get("key") or "").strip()
+ if not key:
+ return None, "нужен key"
+ payload = data.get("payload") or {}
+ tags = data.get("tags") or []
+ con = db()
+ cur = con.cursor()
+ cur.execute("""insert into data_docs (collection, key, payload, tags)
+ values (%s, %s, %s, %s)
+ on conflict (collection, key) do update
+ set payload = excluded.payload,
+ tags = excluded.tags,
+ updated_at = now()
+ returning id, updated_at""",
+ (collection, key, json.dumps(payload, ensure_ascii=False), tags))
+ row = cur.fetchone()
+ con.close()
+ return {"id": row[0], "updated_at": str(row[1])}, None
+
+
+def do_data_list(collection, limit=100, tag=None):
+ _ensure_doc_table()
+ con = db()
+ cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+ if tag:
+ cur.execute("""select id, key, payload, tags, updated_at from data_docs
+ where collection=%s and %s = any(tags)
+ order by updated_at desc limit %s""", (collection, tag, limit))
+ else:
+ cur.execute("""select id, key, payload, tags, updated_at from data_docs
+ where collection=%s order by updated_at desc limit %s""",
+ (collection, limit))
+ items = [dict(r) for r in cur.fetchall()]
+ con.close()
+ return {"collection": collection, "count": len(items), "items": items}, None
+
+
+def _jsonable(obj):
+ if isinstance(obj, dict):
+ return {k: _jsonable(v) for k, v in obj.items()}
+ if isinstance(obj, list):
+ return [_jsonable(v) for v in obj]
+ return str(obj) if hasattr(obj, "isoformat") else obj
+
+
+def do_export(collection, fmt="json", filename=None, limit=500):
+ """Выгрузить коллекцию в папку проекта."""
+ data, err = do_data_list(collection, limit=limit)
+ if err:
+ return None, err
+ items = _jsonable(data["items"])
+
+ folder = os.path.join(DATA_DIR, collection)
+ os.makedirs(folder, exist_ok=True)
+ stamp = datetime.now().strftime("%Y-%m-%d")
+ if fmt == "md":
+ name = filename or f"{collection}-{stamp}.md"
+ lines = [f"# {collection}", "", f"записей: {len(items)}", ""]
+ for it in items:
+ lines.append(f"## {it.get('key')}")
+ lines.append(f"обновлено: {it.get('updated_at')}")
+ payload = it.get("payload") or {}
+ for k, v in payload.items():
+ lines.append(f"* **{k}**: {v}")
+ lines.append("")
+ open(os.path.join(folder, name), "w", encoding="utf-8").write("\n".join(lines))
+ else:
+ name = filename or f"{collection}-{stamp}.json"
+ with open(os.path.join(folder, name), "w", encoding="utf-8") as f:
+ json.dump({"collection": collection, "exported_at": str(datetime.now()),
+ "count": len(items), "items": items},
+ f, ensure_ascii=False, indent=1, default=str)
+
+ path = os.path.join(folder, name)
+ return {"path": path, "count": len(items), "format": fmt}, None
+
+
+
+
+def do_services():
+ """Источники событий: сколько, когда последнее."""
+ con = db()
+ cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+ cur.execute("""select source, count(*) as total,
+ max(at) as last_at,
+ count(*) filter (where at > now() - interval '24 hours') as last24
+ from events group by source order by total desc""")
+ rows = [dict(r) for r in cur.fetchall()]
+ con.close()
+ return {"count": len(rows), "items": rows}
+
+
+def do_service_history(source, limit=50):
+ """История по одному сервису."""
+ con = db()
+ cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+ cur.execute("""select e.id, e.at, e.type, e.entity->>'title' as title, e.payload
+ from events e where e.source = %s order by e.id desc limit %s""",
+ (source, limit))
+ rows = [dict(r) for r in cur.fetchall()]
+ con.close()
+ return {"source": source, "count": len(rows), "items": rows}
+
+
+
+
+def do_metrics():
+ """Метрики в формате Prometheus."""
+ lines = []
+ con = db()
+ cur = con.cursor()
+
+ cur.execute("select source, count(*) from events group by source")
+ lines.append("# HELP hub_events_total События по источникам")
+ lines.append("# TYPE hub_events_total counter")
+ for src, n in cur.fetchall():
+ lines.append(f'hub_events_total{{source="{src}"}} {n}')
+
+ cur.execute("select count(*) from events where at > now() - interval '24 hours'")
+ lines.append("# HELP hub_events_24h События за сутки")
+ lines.append("# TYPE hub_events_24h gauge")
+ lines.append(f"hub_events_24h {cur.fetchone()[0]}")
+
+ cur.execute("select kind, count(*) from entities group by kind")
+ lines.append("# HELP hub_entities Карточки по видам")
+ lines.append("# TYPE hub_entities gauge")
+ for kind, n in cur.fetchall():
+ safe = (kind or "unknown").replace('"', "")
+ lines.append(f'hub_entities{{kind="{safe}"}} {n}')
+
+ cur.execute("select count(*) from problems where resolved_at is null")
+ lines.append("# HELP hub_problems_open Открытые проблемы")
+ lines.append("# TYPE hub_problems_open gauge")
+ lines.append(f"hub_problems_open {cur.fetchone()[0]}")
+
+ cur.execute("select kind, status, count(*) from actions group by kind, status")
+ lines.append("# HELP hub_actions Действия автоматики")
+ lines.append("# TYPE hub_actions counter")
+ for kind, status, n in cur.fetchall():
+ lines.append(f'hub_actions{{kind="{kind}",status="{status}"}} {n}')
+
+ cur.execute("select count(*) from entity_links")
+ lines.append("# HELP hub_links Связи между карточками")
+ lines.append("# TYPE hub_links gauge")
+ lines.append(f"hub_links {cur.fetchone()[0]}")
+
+ con.close()
+
+ # хранилища
+ try:
+ import subprocess
+ out = subprocess.run(["pvesm", "status"], capture_output=True, text=True, timeout=15)
+ lines.append("# HELP hub_storage_percent Заполненность хранилищ")
+ lines.append("# TYPE hub_storage_percent gauge")
+ for line in out.stdout.splitlines()[1:]:
+ parts = line.split()
+ if len(parts) >= 7 and parts[6].endswith("%"):
+ try:
+ lines.append(f'hub_storage_percent{{name="{parts[0]}",type="{parts[1]}"}} '
+ f'{float(parts[6].rstrip("%"))}')
+ except ValueError:
+ pass
+ except Exception:
+ pass
+
+ # возраст бэкапов
+ try:
+ import time
+ lines.append("# HELP hub_backup_age_hours Возраст последнего бэкапа")
+ lines.append("# TYPE hub_backup_age_hours gauge")
+ checks = {
+ "postgresql": "/var/log/hub-pg-verify.log",
+ "matrix": "/var/log/hub-matrix-backup.log",
+ "bots": "/var/log/hub-bots-verify.log",
+ "offsite": "/var/log/hub-offsite-verify.log",
+ "core": "/mnt/backups/hub-core",
+ }
+ for name, path in checks.items():
+ try:
+ if os.path.isdir(path):
+ files = [os.path.join(path, f) for f in os.listdir(path)]
+ mtime = max(os.path.getmtime(f) for f in files) if files else 0
+ else:
+ mtime = os.path.getmtime(path)
+ lines.append(f'hub_backup_age_hours{{name="{name}"}} '
+ f'{round((time.time() - mtime) / 3600, 1)}')
+ except OSError:
+ pass
+ except Exception:
+ pass
+
+ return "\n".join(lines) + "\n"
+
+
+
+
+JOBS = {
+ "коннекторы": ("/var/log/hub-connectors.log", 1),
+ "сверка": ("/var/log/hub-reconcile.log", 30),
+ "связка карточек": ("/var/log/hub-linker.log", 30),
+ "дайджест": ("/var/log/hub-digest.log", 30),
+ "инвентаризация": ("/var/log/hub-inventory.log", 30),
+ "каталог": ("/var/log/hub-catalog.log", 30),
+ "экспорт": ("/var/log/hub-export.log", 30),
+ "бэкап базы": ("/var/log/hub-backup.log", 30),
+ "проверка бэкапа PG": ("/var/log/hub-pg-verify.log", 30),
+ "проверка бэкапа ботов": ("/var/log/hub-bots-verify.log", 30),
+ "бэкап Matrix": ("/var/log/hub-matrix-backup.log", 30),
+ "офсайт": ("/var/log/hub-offsite-verify.log", 24 * 8),
+ "просмотр": ("/var/log/hub-resume.log", 30),
+ "недельный отчёт": ("/var/log/hub-weekly-core.log", 24 * 8),
+ "аудит доступов": ("/var/log/hub-identity.log", 24 * 8),
+ "восстановление CT": ("/var/log/hub-lxc-verify.log", 24 * 8),
+}
+
+
+def jobs_status():
+ """Состояние задач: когда последний раз отработали."""
+ now = time.time()
+ rows = []
+ for name, (path, limit_h) in JOBS.items():
+ try:
+ age_h = (now - os.path.getmtime(path)) / 3600
+ state = "ок" if age_h <= limit_h else "просрочено"
+ except OSError:
+ age_h, state = None, "не запускалась"
+ rows.append((name, age_h, limit_h, state))
+ return rows
+
+
+
+
+def do_links(limit=200):
+ """Связи контента: список и сводка по типам."""
+ con = db()
+ cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+ cur.execute("select relation, count(*) as n from entity_links group by relation order by n desc")
+ summary = {r["relation"]: r["n"] for r in cur.fetchall()}
+
+ cur.execute("""select a.title as from_title, a.kind as from_kind,
+ b.title as to_title, b.kind as to_kind, l.relation
+ from entity_links l
+ join entities a on a.id = l.from_id
+ join entities b on b.id = l.to_id
+ order by l.relation, a.title limit %s""", (limit,))
+ items = [dict(r) for r in cur.fetchall()]
+ con.close()
+ return {"total": sum(summary.values()), "by_relation": summary, "items": items}
+
+
+
+
+def do_entities(kind=None, limit=200, q=None):
+ con = db()
+ cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+ sql = "select id, kind, title, status, updated_at from entities where 1=1"
+ args = []
+ if kind:
+ sql += " and kind = %s"
+ args.append(kind)
+ if q:
+ sql += " and search_text like %s"
+ args.append(f"%{q.lower()}%")
+ sql += " order by updated_at desc limit %s"
+ args.append(limit)
+ cur.execute(sql, args)
+ items = [dict(r) for r in cur.fetchall()]
+ con.close()
+ return {"count": len(items), "items": items}
+
+
+def render_panel():
+ """HTML-страница: состояние системы в одном месте."""
+ try:
+ con = db()
+ cur = con.cursor()
+ cur.execute("select count(*) from entities")
+ entities = cur.fetchone()[0]
+ cur.execute("select count(*) from events")
+ events = cur.fetchone()[0]
+ cur.execute("select count(*) from events where at > now() - interval '24 hours'")
+ events24 = cur.fetchone()[0]
+ cur.execute("select count(*) from problems where resolved_at is null")
+ open_problems = cur.fetchone()[0]
+ cur.execute("""select check_name, detail, at from problems
+ where resolved_at is null order by at desc limit 10""")
+ problems = cur.fetchall()
+ cur.execute("""select at, source, type, entity->>'title'
+ from events order by id desc limit 25""")
+ recent = cur.fetchall()
+ cur.execute("""select source, count(*) as total,
+ count(*) filter (where at > now() - interval '24 hours') as last24,
+ max(at) as last_at
+ from events group by source order by total desc""")
+ by_source = cur.fetchall()
+ try:
+ cur.execute("""select payload from data_docs where collection='inventory'
+ order by updated_at desc limit 1""")
+ invrow = cur.fetchone()
+ inventory = invrow[0] if invrow else None
+ except Exception:
+ inventory = None
+ try:
+ cur.execute("""select payload from data_docs where collection='identity'
+ order by updated_at desc limit 1""")
+ idrow = cur.fetchone()
+ identity = idrow[0] if idrow else None
+ except Exception:
+ identity = None
+ jobs = jobs_status()
+ cur.execute("select count(*) from entity_links")
+ links = cur.fetchone()[0]
+ cur.execute("""select at, kind, target, detail, status from actions
+ order by id desc limit 10""")
+ actions = cur.fetchall()
+ con.close()
+ err = None
+ except Exception as e:
+ entities = events = events24 = open_problems = 0
+ problems, recent, by_source, actions, links, inventory, identity = [], [], [], [], 0, None, None
+ jobs = []
+ err = str(e)[:200]
+
+ def esc(x):
+ return (str(x) if x is not None else "—").replace("&", "&").replace("<", "<")
+
+ rows = "".join(
+ f"
| {esc(at.strftime('%d.%m %H:%M'))} | {esc(src)} | "
+ f"{esc(typ)} | {esc(title)} |
"
+ for at, src, typ, title in recent) or "| событий пока нет |
"
+
+ job_rows = "".join(
+ f"| {esc(n)} | {(str(round(a, 1)) + ' ч') if a is not None else '—'} | "
+ f"{lim} ч | {esc(st)} |
"
+ for n, a, lim, st in jobs) or "| нет данных |
"
+
+ identity_text = "аудит ещё не запускался"
+ if isinstance(identity, dict) and identity.get("table"):
+ identity_text = identity["table"]
+
+ inv_rows = ""
+ if isinstance(inventory, dict):
+ jf = inventory.get("jellyfin") or {}
+ nv = inventory.get("navidrome") or {}
+ cb = inventory.get("calibre") or {}
+ im = inventory.get("immich") or {}
+ pl = inventory.get("paperless") or {}
+ fr = inventory.get("frigate") or {}
+ inv_rows = (
+ f"| Jellyfin | {jf.get('Movie')} фильмов, {jf.get('Series')} сериалов, "
+ f"{jf.get('Episode')} серий |
"
+ f"| Navidrome | {nv.get('albums')} альбомов, {nv.get('tracks')} треков |
"
+ f"| Calibre | {cb.get('books')} книг |
"
+ f"| Immich | {im.get('assets')} снимков, {im.get('albums')} альбомов |
"
+ f"| Paperless | {pl.get('documents')} документов |
"
+ f"| Frigate | {fr.get('cameras')} камер |
")
+ if not inv_rows:
+ inv_rows = '| инвентаризация ещё не собиралась |
'
+
+ arows = "".join(
+ f"| {esc(at.strftime('%d.%m %H:%M'))} | {esc(kind)} | "
+ f"{esc(target)} | {esc(detail)} | "
+ f"{esc(st)} |
"
+ for at, kind, target, detail, st in actions) or "| действий не было |
"
+
+ prow = "".join(
+ f"| {esc(name)} | {esc(detail)} |
"
+ for name, detail, _ in problems) or "| открытых проблем нет |
"
+
+ src_rows = "".join(
+ f"| {esc(src)} | {total} | {last24} | {esc(str(last_at)[:16])} |
"
+ for src, total, last24, last_at in by_source) or "| событий пока нет |
"
+
+ return f"""
+Buryan Hub
+
+Buryan Hub
+ядро событий и карточек · обновлено сейчас
+{'Ошибка базы: ' + esc(err) + '
' if err else ''}
+
+
{entities}карточек
+
{events}событий всего
+
{events24}за 24 часа
+
{open_problems}проблем
+
{links}связей
+
+Задачи
+| задача | последний запуск | предел | состояние |
{job_rows}
+Проблемы
+Графики
+
+Доступы по сервисам
+аудит по понедельникам, команда !users у бота Инфраструктура
+{identity_text}
+Что есть в сервисах
+
+Действия сверки и автоисправлений
+| когда | что | цель | результат | статус |
{arows}
+Последние события
+| когда | источник | тип | объект |
{rows}
+Источники событий
+| источник | всего | за сутки | последнее |
{src_rows}
+"""
+
+
+
+JELLYFIN_URL = os.environ.get("JELLYFIN_URL", "http://192.168.1.103:8096")
+JELLYFIN_KEY = os.environ.get("JELLYFIN_KEY", "")
+
+
+def _jellyfin_scan():
+ """Просим Jellyfin пересканировать библиотеку."""
+ if not JELLYFIN_KEY:
+ return False, "нет ключа Jellyfin"
+ req = urllib.request.Request(
+ f"{JELLYFIN_URL}/Library/Refresh", data=b"", method="POST",
+ headers={"Authorization": f'MediaBrowser Token="{JELLYFIN_KEY}"'})
+ try:
+ with urllib.request.urlopen(req, timeout=20) as r:
+ return r.status in (200, 204), f"HTTP {r.status}"
+ except urllib.error.HTTPError as e:
+ return False, f"HTTP {e.code}"
+ except Exception as e:
+ return False, str(e)[:100]
+
+
+def _journal(kind, target, detail, status="done", rollback=None):
+ try:
+ con = db()
+ with con.cursor() as cur:
+ cur.execute("""insert into actions (kind, target, detail, status, rollback)
+ values (%s,%s,%s,%s,%s)""", (kind, target, detail, status, rollback))
+ con.close()
+ except Exception:
+ pass
+
+
+def auto_actions(ev, etype):
+ """Что сделать сразу после события."""
+ ent = ev.get("entity") or {}
+ title = ent.get("title") or ent.get("key") or "объект"
+
+ if etype == "media.imported":
+ ok, detail = _jellyfin_scan()
+ _journal("scan", "jellyfin", f"после импорта «{title}»: {detail}",
+ "done" if ok else "failed", None)
+ return ok
+
+ if etype == "media.requested":
+ # заявку просто фиксируем: одобрение — решение человека
+ _journal("note", "seerr", f"заявка «{title}» принята", "done", None)
+ return True
+
+ return False
+
+class Handler(BaseHTTPRequestHandler):
+ def log_message(self, *a):
+ pass
+
+ def _json(self, code, obj):
+ body = json.dumps(obj, ensure_ascii=False, default=str).encode()
+ self.send_response(code)
+ self.send_header("Content-Type", "application/json; charset=utf-8")
+ self.send_header("Content-Length", str(len(body)))
+ self.end_headers()
+ self.wfile.write(body)
+
+ def do_GET(self):
+ if self.path == "/" or self.path.startswith("/panel"):
+ body = render_panel().encode("utf-8")
+ self.send_response(200)
+ self.send_header("Content-Type", "text/html; charset=utf-8")
+ self.send_header("Content-Length", str(len(body)))
+ self.end_headers()
+ self.wfile.write(body)
+ return
+ if self.path.startswith("/data/"):
+ import urllib.parse as up
+ parts = self.path.split("?")[0].split("/data/")
+ coll = parts[1] if len(parts) > 1 else ""
+ qs = up.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
+ tag = (qs.get("tag") or [None])[0]
+ limit = int((qs.get("limit") or ["100"])[0])
+ try:
+ res, err = do_data_list(coll, limit, tag)
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+ return self._json(200 if not err else 500, res or {"error": err})
+ if self.path.startswith("/health"):
+ try:
+ with db() as con, con.cursor() as cur:
+ cur.execute("select count(*) from events")
+ n = cur.fetchone()[0]
+ return self._json(200, {"ok": True, "events": n})
+ except Exception as e:
+ return self._json(500, {"ok": False, "error": str(e)[:200]})
+ if self.path.startswith("/metrics"):
+ try:
+ body = do_metrics().encode("utf-8")
+ except Exception as e:
+ body = f"# error: {e}".encode()
+ self.send_response(200)
+ self.send_header("Content-Type", "text/plain; version=0.0.4; charset=utf-8")
+ self.send_header("Content-Length", str(len(body)))
+ self.end_headers()
+ self.wfile.write(body)
+ return
+ if self.path.startswith("/links"):
+ try:
+ return self._json(200, do_links())
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+ if self.path == "/services":
+ try:
+ return self._json(200, do_services())
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+ if self.path.startswith("/service/"):
+ src = self.path.split("/service/")[1].split("?")[0]
+ if not src:
+ return self._json(400, {"error": "нужно имя сервиса"})
+ try:
+ return self._json(200, do_service_history(src))
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+ if self.path.startswith("/search"):
+ import urllib.parse as up
+ q = (up.parse_qs(self.path.split("?", 1)[1]).get("q") or [""])[0] if "?" in self.path else ""
+ if not q:
+ return self._json(400, {"error": "нужен параметр q"})
+ try:
+ return self._json(200, do_search(q))
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+ if self.path.startswith("/entity/"):
+ try:
+ eid = int(self.path.split("/entity/")[1].split("?")[0])
+ except ValueError:
+ return self._json(400, {"error": "нужен числовой id"})
+ try:
+ data = do_entity(eid)
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+ if data is None:
+ return self._json(404, {"error": "карточка не найдена"})
+ return self._json(200, data)
+ if self.path.startswith("/entities"):
+ import urllib.parse as _up
+ qs = _up.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
+ kind = (qs.get("kind") or [None])[0]
+ q = (qs.get("q") or [None])[0]
+ try:
+ limit = int((qs.get("limit") or ["200"])[0])
+ except ValueError:
+ limit = 200
+ try:
+ return self._json(200, do_entities(kind, limit, q))
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+ if self.path.startswith("/events"):
+ try:
+ with db() as con, con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+ cur.execute("""select id, at, source, type, entity, payload
+ from events order by id desc limit 30""")
+ return self._json(200, {"items": [dict(r) for r in cur.fetchall()]})
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+ return self._json(404, {"error": "нет такого пути"})
+
+ def do_POST(self):
+ length = int(self.headers.get("Content-Length", 0))
+ raw = self.rfile.read(length) if length else b"{}"
+ try:
+ data = json.loads(raw or b"{}")
+ except json.JSONDecodeError:
+ return self._json(400, {"error": "не JSON"})
+
+ if self.path.startswith("/event"):
+ return self._event(data)
+ if self.path.startswith("/entity"):
+ return self._entity(data)
+ if self.path.startswith("/link"):
+ return self._link(data)
+ if self.path.startswith("/data/"):
+ coll = self.path.split("/data/")[1].split("?")[0]
+ if not coll:
+ return self._json(400, {"error": "нужна коллекция"})
+ res, err = do_data_put(coll, data)
+ return self._json(201 if not err else 500, res or {"error": err})
+ if self.path.startswith("/export"):
+ coll = data.get("collection") or ""
+ if not coll:
+ return self._json(400, {"error": "нужна collection"})
+ res, err = do_export(coll, data.get("format") or "json", data.get("filename"))
+ return self._json(200 if not err else 500, res or {"error": err})
+ return self._json(404, {"error": "нет такого пути"})
+
+ # ── события ──
+ def _event(self, ev):
+ src = (ev.get("source") or "").strip()
+ typ = (ev.get("type") or "").strip()
+ if not (src and typ):
+ return self._json(400, {"error": "нужны source и type"})
+ now = datetime.now(timezone.utc)
+ ent = ev.get("entity") or {}
+ payload = ev.get("payload") or {}
+ try:
+ with db() as con, con.cursor() as cur:
+ cur.execute(
+ """insert into events (at, source, type, entity, payload, actor)
+ values (%s, %s, %s, %s, %s, %s) returning id""",
+ (now, src, typ, json.dumps(ent, ensure_ascii=False),
+ json.dumps(payload, ensure_ascii=False), ev.get("actor") or "system"))
+ eid = cur.fetchone()[0]
+
+ # событие, связанное с сущностью, обновляет её статус
+ if ent.get("kind") and ent.get("key"):
+ cur.execute(
+ """insert into entities (kind, key, title, status, external_ids, search_text, updated_at)
+ values (%s, %s, %s, %s, %s, %s, %s)
+ on conflict (kind, key) do update
+ set status = excluded.status,
+ title = coalesce(excluded.title, entities.title),
+ updated_at = excluded.updated_at
+ returning id""",
+ (ent["kind"], ent["key"], ent.get("title") or ent["key"],
+ typ, json.dumps({src: ent.get("key")}, ensure_ascii=False),
+ f"{ent.get('title') or ''} {ent.get('key')}".lower(), now))
+ ent_id = cur.fetchone()[0]
+ cur.execute("update events set entity_id = %s where id = %s", (ent_id, eid))
+ threading.Thread(target=auto_actions, args=(ev, typ), daemon=True).start()
+ if typ in LOUD:
+ threading.Thread(target=publish, args=(human_event(ev), typ), daemon=True).start()
+ return self._json(201, {"ok": True, "id": eid})
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+
+ # ── сущности ──
+ def _entity(self, data):
+ kind = (data.get("kind") or "").strip()
+ key = (data.get("key") or "").strip()
+ if not (kind and key):
+ return self._json(400, {"error": "нужны kind и key"})
+ now = datetime.now(timezone.utc)
+ title = data.get("title") or key
+ aliases = " ".join(str(a) for a in (data.get("aliases") or []) if a)
+ try:
+ with db() as con, con.cursor() as cur:
+ cur.execute(
+ """insert into entities (kind, key, title, status, external_ids, search_text, updated_at)
+ values (%s, %s, %s, %s, %s, %s, %s)
+ on conflict (kind, key) do update
+ set title = excluded.title,
+ status = coalesce(excluded.status, entities.status),
+ external_ids = entities.external_ids || excluded.external_ids,
+ search_text = excluded.search_text,
+ updated_at = excluded.updated_at
+ returning id""",
+ (kind, key, title, data.get("status"),
+ json.dumps(data.get("external_ids") or {}, ensure_ascii=False),
+ f"{title} {key} {aliases}".lower(), now))
+ rid = cur.fetchone()[0]
+ return self._json(201, {"ok": True, "id": rid})
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+
+ def _link(self, data):
+ a, b = data.get("from"), data.get("to")
+ rel = data.get("relation") or "related"
+ if not (a and b):
+ return self._json(400, {"error": "нужны from и to (id)"})
+ try:
+ with db() as con, con.cursor() as cur:
+ cur.execute(
+ """insert into entity_links (from_id, to_id, relation)
+ values (%s, %s, %s) on conflict do nothing returning id""",
+ (a, b, rel))
+ row = cur.fetchone()
+ return self._json(201, {"ok": True, "id": row[0] if row else None})
+ except Exception as e:
+ return self._json(500, {"error": str(e)[:200]})
+
+
+def main():
+ ensure_schema()
+ srv = HTTPServer(("0.0.0.0", PORT), Handler)
+ print(f"hub-core слушает {PORT}", flush=True)
+ srv.serve_forever()
+
+
+if __name__ == "__main__":
+ main()