Поиск идёт в /search ядра, старый SQLite-индекс остался запасным. Добавлены команды: !card <id> (карточка, связи, история), !feed (последние события), !s теперь показывает номер карточки для !card. Проверено: !feed отдал события, !s нашёл «Дюна: часть вторая #1», !card 1 показал ключ tmdb:693134 и историю radarr: media.imported.
666 lines
31 KiB
Python
666 lines
31 KiB
Python
"""Флот ботов: у каждого свой домен и свои команды."""
|
|
import datetime
|
|
|
|
from . import catalog, core_api, index, local, sources, util
|
|
from .matrix import Bot
|
|
from .sources import CFG, RADARR, SONARR, Jellyfin, Prom, Seerr
|
|
|
|
|
|
def _fmt_item(it):
|
|
year = it.get("ProductionYear")
|
|
name = it.get("Name", "без названия")
|
|
kind = {"Movie": "фильм", "Series": "сериал", "Audio": "трек"}.get(it.get("Type"), it.get("Type", ""))
|
|
return f"{name}" + (f" ({year})" if year else "") + (f" — {kind}" if kind else "")
|
|
|
|
|
|
def _empty_hint():
|
|
return ("\n\n_Библиотека пуста._ Наполнить можно так: "
|
|
"положить файлы в папку сервиса и запустить сканирование.")
|
|
|
|
|
|
class MediaBot(Bot):
|
|
name = "media"
|
|
title = "Медиа"
|
|
room_env = "MEDIA_ROOM"
|
|
|
|
def register(self):
|
|
jf = Jellyfin()
|
|
seerr = Seerr()
|
|
|
|
self.cmd("stats", "что есть в медиатеке: фильмы, сериалы, музыка")(lambda a: self._stats(jf))
|
|
self.cmd("new", "что добавилось последним")(lambda a: self._new(jf))
|
|
self.cmd("find", "поиск по медиатеке: `!find матрица`")(lambda a: self._find(jf, a))
|
|
self.cmd("now", "кто что смотрит прямо сейчас")(lambda a: self._now(jf))
|
|
self.cmd("queue", "очередь загрузок в Sonarr и Radarr")(lambda a: self._queue())
|
|
self.cmd("requests", "последние заявки в Seerr")(lambda a: self._requests(seerr))
|
|
self.cmd("disk", "место на дисках медиасервисов")(lambda a: self._disk())
|
|
self.cmd("wanted", "сколько ещё не найдено")(lambda a: self._wanted())
|
|
self.cmd("paths", "где лежат файлы и куда их класть")(lambda a: self._paths())
|
|
|
|
def _stats(self, jf):
|
|
c = jf.counts()
|
|
info, _ = jf.info()
|
|
names = {"Movie": "Фильмы", "Series": "Сериалы", "Episode": "Серии",
|
|
"Audio": "Треки", "MusicAlbum": "Альбомы"}
|
|
lines = ["**Медиатека**", ""]
|
|
total = 0
|
|
for k, v in c.items():
|
|
lines.append(f"• {names.get(k, k)}: {v}")
|
|
total += v or 0
|
|
if info:
|
|
lines.append(f"\nСервер: {info.get('ServerName')} {info.get('Version')}")
|
|
|
|
nav = local.Navidrome().counts()
|
|
if nav and not nav[1]:
|
|
lines.append(f"• Музыка (Navidrome): {nav[0]['albums']} альбомов, "
|
|
f"{nav[0]['tracks']} треков, {nav[0]['artists']} исполнителей")
|
|
total += nav[0]["tracks"]
|
|
|
|
if total == 0:
|
|
lines.append(_empty_hint())
|
|
return "\n".join(lines)
|
|
|
|
def _new(self, jf):
|
|
items, err = jf.recent(10)
|
|
if err:
|
|
return f"Jellyfin не ответил: {err}"
|
|
if not items:
|
|
return "В медиатеке пока ничего нет." + _empty_hint()
|
|
lines = ["**Последние поступления**", ""]
|
|
for it in items:
|
|
lines.append(f"• {_fmt_item(it)}")
|
|
return "\n".join(lines)
|
|
|
|
def _find(self, jf, term):
|
|
if not term:
|
|
return "Напишите, что искать: `!find дюна`"
|
|
items, err = jf.search(term)
|
|
if err:
|
|
return f"Jellyfin не ответил: {err}"
|
|
if not items:
|
|
return f"По запросу «{term}» ничего не нашлось."
|
|
lines = [f"**Найдено по «{term}»**", ""]
|
|
for it in items:
|
|
lines.append(f"• {_fmt_item(it)}")
|
|
return "\n".join(lines)
|
|
|
|
def _now(self, jf):
|
|
sess, err = jf.sessions()
|
|
if err:
|
|
return f"Jellyfin не ответил: {err}"
|
|
if not sess:
|
|
return "Сейчас никто ничего не смотрит."
|
|
lines = ["**Смотрят сейчас**", ""]
|
|
for s in sess:
|
|
item = s.get("NowPlayingItem", {})
|
|
user = s.get("UserName", "?")
|
|
pos = s.get("PlayState", {}).get("PositionTicks", 0) / 10_000_000
|
|
lines.append(f"• {user}: {item.get('Name')} — {util.human_time(pos)}")
|
|
return "\n".join(lines)
|
|
|
|
def _queue(self):
|
|
lines = ["**Очередь загрузок**", ""]
|
|
for svc in (SONARR, RADARR):
|
|
total, err = svc.queue()
|
|
lines.append(f"• {svc.name}: {'—' if err else total}")
|
|
return "\n".join(lines)
|
|
|
|
def _requests(self, seerr):
|
|
reqs, err = seerr.requests(6)
|
|
if err:
|
|
return f"Seerr не ответил: {err}"
|
|
if not reqs:
|
|
return "Заявок пока нет. Заказать можно на https://ombi.buryans.ru"
|
|
lines = ["**Последние заявки**", ""]
|
|
for r in reqs:
|
|
media = r.get("media", {}) or {}
|
|
title = media.get("title") or media.get("name") or "?"
|
|
status = {1: "ожидает", 2: "одобрено", 3: "отклонено"}.get(r.get("status"), "?")
|
|
who = (r.get("requestedBy") or {}).get("displayName", "?")
|
|
lines.append(f"• {title} — {status} (просил {who})")
|
|
return "\n".join(lines)
|
|
|
|
def _disk(self):
|
|
lines = ["**Диски**", ""]
|
|
for svc in (SONARR, RADARR):
|
|
disks, err = svc.diskspace()
|
|
if err:
|
|
lines.append(f"• {svc.name}: ошибка")
|
|
continue
|
|
for d in disks:
|
|
free = d.get("freeSpace", 0)
|
|
total = d.get("totalSpace", 1)
|
|
pct = 100 * free / total if total else 0
|
|
lines.append(f"• {svc.name} {d.get('path','?')}: свободно "
|
|
f"{util.human_bytes(free)} ({pct:.0f}%)")
|
|
return "\n".join(lines)
|
|
|
|
def _wanted(self):
|
|
lines = ["**Чего не хватает**", ""]
|
|
for svc in (SONARR, RADARR):
|
|
n, err = svc.wanted()
|
|
lines.append(f"• {svc.name}: {'—' if err else f'{n} позиций'}")
|
|
return "\n".join(lines)
|
|
|
|
def _paths(self):
|
|
return ("**Куда класть файлы**\n\n"
|
|
"• Jellyfin: `/media/movies`, `/media/series`, `/media/music` (CT 103)\n"
|
|
"• Plex: `/opt/plex/media` (CT 116)\n"
|
|
"• Музыка: папка музыки (CT 125)\n\n"
|
|
"После копирования запустите в Jellyfin «Сканировать библиотеку».")
|
|
|
|
|
|
class PhotoBot(Bot):
|
|
name = "photo"
|
|
title = "Фото"
|
|
room_env = "PHOTO_ROOM"
|
|
|
|
def register(self):
|
|
self.cmd("stats", "сколько снимков, альбомов и людей в Immich")(lambda a: self._stats())
|
|
self.cmd("space", "сколько занимает база фото")(lambda a: self._space())
|
|
|
|
def _stats(self):
|
|
c, err = local.ImmichDb().counts()
|
|
if err:
|
|
return f"Не смог прочитать базу Immich: {err}"
|
|
lines = ["**Фотографии**", "",
|
|
f"• Снимков: {c['assets']}",
|
|
f"• Альбомов: {c['albums']}",
|
|
f"• Пользователей: {c['users']}",
|
|
"", "Адрес: https://immich.buryans.ru"]
|
|
if c["assets"] == 0:
|
|
lines.append("\n_Фотографий пока нет._ Загрузите с телефона через приложение Immich — "
|
|
"оно само синхронизирует снимки.")
|
|
return "\n".join(lines)
|
|
|
|
def _space(self):
|
|
out, err = local.pct_exec(151, ["su", "-", "postgres", "-c",
|
|
"psql -d immich_db -tAc \"select pg_size_pretty(pg_database_size('immich_db'))\""])
|
|
if err:
|
|
return f"Не удалось узнать размер: {err}"
|
|
return f"База Immich занимает {out}. Снимки лежат в хранилище рядом с базой."
|
|
|
|
|
|
class BookBot(Bot):
|
|
name = "book"
|
|
title = "Книги"
|
|
room_env = "BOOK_ROOM"
|
|
|
|
def register(self):
|
|
books = local.Books()
|
|
self.cmd("stats", "сколько книг в библиотеке")(lambda a: self._stats(books))
|
|
self.cmd("new", "последние поступления")(lambda a: self._new(books))
|
|
self.cmd("find", "поиск книги: `!find стругацкие`")(lambda a: self._find(books, a))
|
|
|
|
def _stats(self, books):
|
|
c, err = books.counts()
|
|
if err:
|
|
return f"Библиотека недоступна: {err}"
|
|
lines = [f"**Библиотека**\n\n• Книг: {c['books']}\n\nЧитать: https://books.buryans.ru"]
|
|
if c["books"] == 0:
|
|
lines.append("\n_Книг пока нет._ Добавить: https://books.buryans.ru → "
|
|
"«Загрузить книгу», либо положить файлы в каталог библиотеки.")
|
|
return "\n".join(lines)
|
|
|
|
def _new(self, books):
|
|
rows, err = books.recent(8)
|
|
if err:
|
|
return f"Не удалось получить список: {err}"
|
|
if not rows:
|
|
return "Библиотека пуста."
|
|
lines = ["**Новые книги**", ""]
|
|
for r in rows:
|
|
lines.append(f"• {r['title']} — {r['author']}")
|
|
return "\n".join(lines)
|
|
|
|
def _find(self, books, term):
|
|
if not term:
|
|
return "Что искать? `!find пелевин`"
|
|
rows, err = books.search(term)
|
|
if err:
|
|
return f"Поиск не сработал: {err}"
|
|
if not rows:
|
|
return f"По запросу «{term}» ничего нет."
|
|
lines = [f"**Книги по «{term}»**", ""]
|
|
for r in rows:
|
|
lines.append(f"• {r['title']} — {r['author']}")
|
|
return "\n".join(lines)
|
|
|
|
|
|
class HomeBot(Bot):
|
|
name = "home"
|
|
title = "Дом"
|
|
room_env = "HOME_ROOM"
|
|
|
|
def register(self):
|
|
self.cmd("stats", "сколько устройств и датчиков в Home Assistant")(lambda a: self._stats())
|
|
self.cmd("status", "кратко о состоянии дома")(lambda a: self._status())
|
|
|
|
def _stats(self):
|
|
data, err = local.HomeDb().entities()
|
|
if err:
|
|
return f"Не смог прочитать реестр HA: {err}"
|
|
lines = ["**Дом**", "", f"• Устройств и сущностей: {data['total']}"]
|
|
if data["kinds"]:
|
|
lines.append("• По типам: " + ", ".join(data["kinds"].split("|")))
|
|
lines.append("\nУправление: https://home.buryans.ru")
|
|
if data["total"] < 20:
|
|
lines.append("\n_Устройств мало._ Добавить: Home Assistant → Настройки → "
|
|
"Устройства и службы → «Добавить интеграцию».")
|
|
return "\n".join(lines)
|
|
|
|
def _status(self):
|
|
data, err = local.HomeDb().states()
|
|
if err:
|
|
return f"Не удалось прочитать состояние: {err}"
|
|
return (f"**Состояние дома**\n\n• Запомненных состояний: {data['restored']}\n\n"
|
|
"Полная картина — на панели: https://home.buryans.ru")
|
|
|
|
|
|
class InfraBot(Bot):
|
|
name = "infra"
|
|
title = "Инфраструктура"
|
|
room_env = "INFRA_ROOM"
|
|
|
|
def register(self):
|
|
prom = Prom()
|
|
self.cmd("status", "какие службы живы, а какие нет")(lambda a: self._status(prom))
|
|
self.cmd("alerts", "активные тревоги")(lambda a: self._alerts(prom))
|
|
self.cmd("disk", "место на дисках")(lambda a: self._disk(prom))
|
|
self.cmd("backups", "последние резервные копии")(lambda a: self._backups())
|
|
self.cmd("content", "что лежит в библиотеках")(lambda a: self._content())
|
|
self.cmd("services", "полный список служб и адресов")(lambda a: self._services())
|
|
self.cmd("gaps", "чего не хватает, чтобы всё заработало полностью")(lambda a: self._gaps())
|
|
self.cmd("inbox", "пожелания и просьбы, которые собрали боты")(lambda a: self._inbox())
|
|
|
|
def _status(self, prom):
|
|
targets, err = prom.targets()
|
|
if err:
|
|
return f"Prometheus не ответил: {err}"
|
|
up = [t for t in targets if t.get("health") == "up"]
|
|
down = [t for t in targets if t.get("health") != "up"]
|
|
lines = [f"**Службы**: {len(up)} в норме, {len(down)} проблемных", ""]
|
|
for t in down[:12]:
|
|
job = t["labels"].get("job", "?")
|
|
app = t["labels"].get("app", "")
|
|
lines.append(f"• ⚠ {job} {app} — {t.get('health')}")
|
|
return "\n".join(lines)
|
|
|
|
def _alerts(self, prom):
|
|
alerts, err = prom.alerts()
|
|
if err:
|
|
return f"Не смог получить тревоги: {err}"
|
|
if not alerts:
|
|
return "Активных тревог нет."
|
|
lines = ["**Тревоги**", ""]
|
|
for a in alerts:
|
|
lines.append(f"• {a.get('labels', {}).get('alertname')} — {a.get('state')}")
|
|
return "\n".join(lines)
|
|
|
|
def _disk(self, prom):
|
|
q = '(node_filesystem_avail_bytes{mountpoint="/"} * 100 / node_filesystem_size_bytes{mountpoint="/"})'
|
|
v, err = prom.query(q + " < 15")
|
|
if err:
|
|
return f"Не удалось: {err}"
|
|
host = catalog.host_df()
|
|
lines = ["**Место**", ""]
|
|
if host:
|
|
lines.append(f"• Узел: {host.split()[3] if len(host.split()) > 3 else '—'} свободно "
|
|
f"({host.split()[4] if len(host.split()) > 4 else '—'})")
|
|
if v:
|
|
lines.append(f"• Узлов с запасом меньше 15%: {int(v)}")
|
|
else:
|
|
lines.append("• Все узлы имеют больше 15% запаса")
|
|
return "\n".join(lines)
|
|
|
|
def _backups(self):
|
|
out, err = local.pct_exec(10, ["sh", "-c", "ls -t /mnt/backups/dump/*.tar.zst 2>/dev/null | head -3"])
|
|
if err or not out:
|
|
try:
|
|
import subprocess
|
|
r = subprocess.run(["bash", "-c", "ls -t /mnt/backups/dump/*.tar.zst 2>/dev/null | head -3"],
|
|
capture_output=True, text=True, timeout=15)
|
|
out = r.stdout.strip()
|
|
except Exception:
|
|
out = ""
|
|
if not out:
|
|
return "Свежих архивов не нашёл в /mnt/backups."
|
|
lines = ["**Последние архивы**", ""]
|
|
for line in out.splitlines():
|
|
lines.append(f"• {line.split('/')[-1]}")
|
|
return "\n".join(lines)
|
|
|
|
def _content(self):
|
|
c = catalog.content_state()
|
|
jf = c.get("jellyfin") or {}
|
|
nav = c.get("navidrome") or {}
|
|
books = c.get("books") or {}
|
|
img = c.get("immich") or {}
|
|
ha = c.get("home") or {}
|
|
return ("**Что лежит в библиотеках**\n\n"
|
|
f"• Фильмы: {jf.get('Movie', 0)}\n"
|
|
f"• Сериалы: {jf.get('Series', 0)}\n"
|
|
f"• Музыка: {nav.get('tracks', 0)} треков / {nav.get('albums', 0)} альбомов\n"
|
|
f"• Книги: {books.get('books', 0)}\n"
|
|
f"• Фото: {img.get('assets', 0)}\n"
|
|
f"• Дом: {ha.get('total', 0)} сущностей")
|
|
|
|
def _services(self):
|
|
lines = ["**Все службы**", ""]
|
|
for name, addr, domain, holds, fill in catalog.SERVICES:
|
|
link = f"https://{domain}" if domain and domain != "—" else addr
|
|
lines.append(f"• **{name}** — {holds}\n {link} · {addr}")
|
|
return "\n".join(lines)
|
|
|
|
def _inbox(self):
|
|
from . import inbox as inbox_mod
|
|
s = inbox_mod.stats()
|
|
rows = inbox_mod.pending(10)
|
|
lines = ["**Входящие**", "",
|
|
f"• За сегодня: {s['today']}",
|
|
f"• Дней с записями: {s['days']}", ""]
|
|
if not rows:
|
|
lines.append("_Пожеланий пока нет._ Напишите любому боту в личку — "
|
|
"он передаст сюда.")
|
|
return "\n".join(lines)
|
|
for r in rows:
|
|
lines.append(f"• #{r['id']} от {r['from'].split(':')[0]} "
|
|
f"через {r['bot']} ({r['at'][11:16]}):\n {r['text'][:200]}")
|
|
return "\n".join(lines)
|
|
|
|
def _gaps(self):
|
|
"""Честный список того, что мешает системе работать целиком."""
|
|
c = catalog.content_state()
|
|
jf = c.get("jellyfin") or {}
|
|
nav = c.get("navidrome") or {}
|
|
books = c.get("books") or {}
|
|
img = c.get("immich") or {}
|
|
ha = c.get("home") or {}
|
|
empty = []
|
|
problems = []
|
|
hints = []
|
|
|
|
if (jf.get("Movie", 0) + jf.get("Series", 0)) == 0:
|
|
empty.append("медиатека Jellyfin")
|
|
hints.append("медиа: положить файлы в `/media/{movies,series}` (CT 103) и запустить сканирование")
|
|
if nav.get("tracks", 0) == 0:
|
|
empty.append("музыка")
|
|
hints.append("музыка: залить альбомы в папку Navidrome (CT 125)")
|
|
if books.get("books", 0) == 0:
|
|
empty.append("книги")
|
|
hints.append("книги: загрузить через books.buryans.ru")
|
|
if img.get("assets", 0) == 0:
|
|
empty.append("фото Immich")
|
|
hints.append("фото: поставить приложение Immich на телефоны, включить автозагрузку")
|
|
if ha.get("total", 0) < 20:
|
|
hints.append("дом: добавить устройства в Home Assistant")
|
|
|
|
# загрузчик — без него заявки в Seerr не превращаются в файлы
|
|
try:
|
|
data, err = util.get(
|
|
f"{CFG.sonarr_url}/api/v3/downloadclient",
|
|
{"X-Api-Key": CFG.sonarr_key}, ttl=120)
|
|
if not err and not data:
|
|
problems.append("в Sonarr не настроен клиент загрузки")
|
|
hints.append("загрузчик: поставить qBittorrent и подключить его в Sonarr и Radarr")
|
|
except Exception:
|
|
pass
|
|
|
|
if not CFG.frigate_url:
|
|
problems.append("Frigate не развёрнут — камеры не наблюдают")
|
|
hints.append("камеры: дать RTSP-адреса, разверну сервер наблюдения")
|
|
|
|
lines = ["**Что мешает работать целиком**", ""]
|
|
if problems:
|
|
lines.append("**Блокирует:**")
|
|
lines += [f"• {p}" for p in problems]
|
|
if empty:
|
|
lines.append("\n**Пусто:**")
|
|
lines += [f"• {e}" for e in empty]
|
|
if hints:
|
|
lines.append("\n**Что нужно сделать:**")
|
|
lines += [f"• {h}" for h in hints]
|
|
if not (problems or empty):
|
|
lines.append("Всё на месте: блокирующих проблем нет.")
|
|
return "\n".join(lines)
|
|
|
|
|
|
class SearchBot(Bot):
|
|
name = "search"
|
|
title = "Поиск"
|
|
room_env = "SEARCH_ROOM"
|
|
|
|
def register(self):
|
|
self.cmd("s", "поиск по всему: `!s дюна`")(lambda a: self._search(a))
|
|
self.cmd("index", "что попало в общий индекс и когда он обновлён")(lambda a: self._index())
|
|
self.cmd("reindex", "перестроить индекс сейчас")(lambda a: self._reindex())
|
|
self.cmd("link", "связи: где встречается одно и то же название")(lambda a: self._link(a))
|
|
self.cmd("card", "карточка объекта с историей: `!card 74`")(lambda a: self._card(a))
|
|
self.cmd("feed", "последние события системы")(lambda a: self._feed())
|
|
|
|
|
|
def _card(self, eid):
|
|
if not eid.strip().isdigit():
|
|
return "Нужен номер карточки: `!card 74`. Найти номер — `!s <название>`."
|
|
data, err = core_api.card(int(eid))
|
|
if err:
|
|
return f"Ядро не ответило: {err}"
|
|
if not data:
|
|
return f"Карточка {eid} не найдена."
|
|
c = data.get("card", {})
|
|
lines = [f"**{c.get('title')}** ({c.get('kind')})", "",
|
|
f"• Ключ: {c.get('key')}",
|
|
f"• Статус: {c.get('status') or '—'}",
|
|
f"• Обновлено: {(c.get('updated_at') or '')[:16]}"]
|
|
links = data.get("links") or []
|
|
if links:
|
|
lines.append("• Связи: " + ", ".join(f"{l['title']} ({l['kind']})" for l in links))
|
|
hist = data.get("history") or []
|
|
if hist:
|
|
lines.append("")
|
|
lines.append("**История**")
|
|
for h in hist[:5]:
|
|
lines.append(f"• {(h.get('at') or '')[:16]} — {h.get('source')}: {h.get('type')}")
|
|
return "\n".join(lines)
|
|
|
|
def _feed(self):
|
|
data, err = core_api.events()
|
|
if err:
|
|
return f"Ядро не ответило: {err}"
|
|
items = (data or {}).get("items") or []
|
|
if not items:
|
|
return "Событий пока нет."
|
|
lines = ["**Последние события**", ""]
|
|
for e in items[:10]:
|
|
ent = e.get("entity") or {}
|
|
title = ent.get("title") if isinstance(ent, dict) else None
|
|
lines.append(f"• {(e.get('at') or '')[:16]} {e.get('source')}: {e.get('type')}"
|
|
+ (f" — {title}" if title else ""))
|
|
return "\n".join(lines)
|
|
|
|
def _search(self, term):
|
|
if not term:
|
|
return "Что искать? Например `!s дюна`"
|
|
out = [f"**Поиск «{term}»**", ""]
|
|
found = False
|
|
|
|
# сначала ядро — единый источник карточек
|
|
core, err = core_api.search(term)
|
|
if core and core.get("items"):
|
|
found = True
|
|
for r in core["items"][:12]:
|
|
sub = f" — {r['status']}" if r.get("status") else ""
|
|
out.append(f"• [{r['kind']}] {r['title']}{sub} `#{r['id']}`")
|
|
out.append("\n_Подробнее о карточке: `!card <номер>`_")
|
|
return "\n".join(out)
|
|
|
|
# затем общий индекс — он знает про все сервисы
|
|
rows = index.search(term, 12)
|
|
if rows:
|
|
found = True
|
|
for r in rows:
|
|
sub = f" — {r['subtitle']}" if r["subtitle"] else ""
|
|
out.append(f"• [{r['kind']}] {r['title']}{sub}\n {r['url']}")
|
|
else:
|
|
# индекс пуст или не обновлён — спрашиваем живые сервисы
|
|
items, err = Jellyfin().search(term, 5)
|
|
if items:
|
|
found = True
|
|
out.append("**Медиа (вживую)**")
|
|
for it in items:
|
|
out.append(f"• {_fmt_item(it)}")
|
|
|
|
books, berr = local.Books().search(term, 5)
|
|
if books:
|
|
found = True
|
|
out.append("\n**Книги (вживую)**")
|
|
for r in books:
|
|
out.append(f"• {r['title']} — {r['author']}")
|
|
|
|
docs, _ = util.get(
|
|
f"{CFG.paperless_url}/api/documents/?query={util.quote(term)}&page_size=5",
|
|
{"Authorization": f"Token {CFG.paperless_token}"}, ttl=60)
|
|
if docs and docs.get("results"):
|
|
found = True
|
|
out.append("\n**Документы**")
|
|
for d in docs["results"]:
|
|
out.append(f"• {d.get('title')}")
|
|
|
|
if not found:
|
|
out.append("Ничего не нашлось. Попробуйте другое слово.")
|
|
return "\n".join(out)
|
|
|
|
def _index(self):
|
|
s = index.stats()
|
|
lines = ["**Общий индекс**", "",
|
|
f"• Записей: {s['total']}",
|
|
f"• Обновлён: {s['built_at'] or 'ещё не строился'}"]
|
|
if s["kinds"]:
|
|
lines.append("• По видам: " + ", ".join(f"{k} — {n}" for k, n in s["kinds"]))
|
|
if s["sources"]:
|
|
lines.append("• По источникам: " + ", ".join(f"{k} — {n}" for k, n in s["sources"]))
|
|
else:
|
|
lines.append("\n_Индекс пуст: в сервисах пока нет контента._")
|
|
return "\n".join(lines)
|
|
|
|
def _reindex(self):
|
|
report = index.rebuild()
|
|
lines = ["**Индекс перестроен**", ""]
|
|
for name, r in report.items():
|
|
if r.get("error"):
|
|
lines.append(f"• {name}: ошибка — {r['error']}")
|
|
else:
|
|
lines.append(f"• {name}: {r['count']} записей")
|
|
return "\n".join(lines)
|
|
|
|
def _link(self, term):
|
|
if not term:
|
|
return "Что искать? `!link дюна`"
|
|
grouped = index.links(term)
|
|
if not grouped:
|
|
return f"Связей по «{term}» не нашлось."
|
|
lines = [f"**Где встречается «{term}»**", ""]
|
|
for kind, items in grouped.items():
|
|
lines.append(f"**{kind.capitalize()}**")
|
|
for it in items[:6]:
|
|
sub = f" — {it['subtitle']}" if it["subtitle"] else ""
|
|
lines.append(f"• {it['title']}{sub}")
|
|
lines.append("")
|
|
return "\n".join(lines)
|
|
|
|
|
|
class DigestBot(Bot):
|
|
name = "digest"
|
|
title = "Дайджест"
|
|
room_env = "DIGEST_ROOM"
|
|
|
|
def register(self):
|
|
self.cmd("digest", "сводка по всем сервисам прямо сейчас")(lambda a: self.build())
|
|
self.cmd("map", "карта платформы: что где живёт")(lambda a: self._map())
|
|
|
|
def build(self):
|
|
parts = [f"**Сводка · {datetime.date.today().strftime('%d.%m.%Y')}**", ""]
|
|
c = catalog.content_state()
|
|
|
|
jf = c.get("jellyfin") or {}
|
|
parts.append(f"**Медиа**: {jf.get('Movie', 0)} фильмов, {jf.get('Series', 0)} сериалов, "
|
|
f"{jf.get('MusicAlbum', 0)} альбомов")
|
|
|
|
nav = c.get("navidrome") or {}
|
|
parts.append(f"**Музыка**: {nav.get('albums', 0)} альбомов, {nav.get('tracks', 0)} треков")
|
|
|
|
img = c.get("immich") or {}
|
|
parts.append(f"**Фото**: {img.get('assets', 0)} снимков в {img.get('albums', 0)} альбомах")
|
|
|
|
books = c.get("books") or {}
|
|
parts.append(f"**Книги**: {books.get('books', 0)}")
|
|
|
|
ha = c.get("home") or {}
|
|
parts.append(f"**Дом**: {ha.get('total', 0)} сущностей")
|
|
|
|
prom = Prom()
|
|
targets, err = prom.targets()
|
|
if targets:
|
|
down = sum(1 for t in targets if t.get("health") != "up")
|
|
parts.append(f"**Службы**: {len(targets) - down} в норме, {down} проблемных")
|
|
alerts, _ = prom.alerts()
|
|
parts.append(f"**Тревоги**: {len(alerts)} активных")
|
|
|
|
# заявки в Seerr и состояние индекса
|
|
try:
|
|
counts, _ = Seerr().counts()
|
|
if counts:
|
|
parts.append(f"**Заявки**: {counts.get('pending', 0)} в ожидании, "
|
|
f"{counts.get('approved', 0)} одобрено, "
|
|
f"{counts.get('available', 0)} готово")
|
|
except Exception:
|
|
pass
|
|
try:
|
|
s = index.stats()
|
|
parts.append(f"**Индекс**: {s['total']} записей "
|
|
f"(обновлён {(s['built_at'] or '—')[11:16]})")
|
|
except Exception:
|
|
pass
|
|
|
|
return "\n".join(parts)
|
|
|
|
def _map(self):
|
|
lines = ["**Карта платформы**", "", "Один вход: Authentik. Внутри — домены, боты, мониторинг.", ""]
|
|
groups = {
|
|
"Медиа": ["Jellyfin", "Plex", "Sonarr", "Radarr", "Prowlarr", "Bazarr", "Seerr"],
|
|
"Контент": ["Immich", "Calibre-Web", "Paperless", "Home Assistant"],
|
|
"Сервисы": ["Nextcloud", "Vaultwarden", "Gitea", "Matrix"],
|
|
"Наблюдение": ["Prometheus", "Grafana", "Loki", "Uptime Kuma"],
|
|
"Автоматизация": ["n8n", "Node-RED"],
|
|
}
|
|
by_name = {s[0]: s for s in catalog.SERVICES}
|
|
for group, names in groups.items():
|
|
lines.append(f"**{group}**")
|
|
for n in names:
|
|
s = by_name.get(n)
|
|
if s:
|
|
lines.append(f"• {s[0]} — {s[3]} ({s[2] if s[2] != '—' else s[1]})")
|
|
lines.append("")
|
|
lines.append("Подробности: `!services` у бота инфраструктуры, состав библиотек — `!content`.")
|
|
return "\n".join(lines)
|
|
|
|
|
|
class CamBot(Bot):
|
|
name = "cam"
|
|
title = "Камеры"
|
|
room_env = "CAM_ROOM"
|
|
|
|
def register(self):
|
|
self.cmd("status", "есть ли подключённый сервер наблюдения")(lambda a: self._status())
|
|
|
|
def _status(self):
|
|
if not CFG.frigate_url:
|
|
return ("**Камеры**\n\n"
|
|
"Frigate пока не развёрнут — сервер наблюдения не найден ни в одном контейнере.\n\n"
|
|
"Чтобы я начал показывать события, нужно:\n"
|
|
"1. Развернуть Frigate (нужны RTSP-адреса камер).\n"
|
|
"2. Дать адрес Frigate и его ключ.\n\n"
|
|
"После этого здесь появятся: список камер, события движения, "
|
|
"детекция людей и машин, ссылки на записи.")
|
|
return "Frigate отвечает — уточните, что показать."
|