Files
buryan-infra/ops/work/web/app.py
T

1630 lines
76 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Комбайн: веб-интерфейс (v2) — направления, сценарии, чипы, Link View.
Модель схемы повторяет Yealink Room Designer:
устройство = блок с ВХОДАМИ слева и ВЫХОДАМИ справа
связи — только между однотипными портами (HDMI→HDMI, USB→USB, VCH→VCH, LAN→LAN)
"""
import json
import os
import re
import glob
import socketserver
import time
import urllib.parse
from http.server import BaseHTTPRequestHandler
BASE = "/opt/work-hub/compat"
PROJECTS_DIR = "/opt/work-hub/compat/projects"
# направления (в перспективе — все три, сейчас ВКС)
VENDORS = [
{"id": "yealink", "name": "Yealink", "ready": True,
"note": "ВКС / PRO AV"},
{"id": "poly", "name": "Poly", "ready": True, "note": "15 моделей в каталоге (VCS)"},
{"id": "logitech", "name": "Logitech", "ready": True, "note": "16 моделей в каталоге (VCS)"},
{"id": "vinteo", "name": "VINTEO", "ready": True, "note": "4 модели в каталоге (VCS)"},
{"id": "iva", "name": "IVA", "ready": True, "note": "1 модель в каталоге (VCS)"},
{"id": "hitrolink", "name": "Hitrolink", "ready": True, "note": "31 модель в каталоге (VCS)"},
{"id": "cisco", "name": "Cisco", "ready": False, "note": "скоро"},
{"id": "other", "name": "Другие", "ready": False, "note": "по запросу"},
]
DIRECTIONS = [
{"id": "vcs", "name": "ВКС", "note": "видеоконференции: комнаты, бары, кодеки",
"ready": True},
{"id": "telephony", "name": "Телефония", "note": "SIP-аппараты, DECT, гарнитуры, линии",
"ready": True},
{"id": "webrtc", "name": "WebRTC", "note": "браузерные решения, шлюзы", "ready": False},
]
DOMAIN_LABELS = {
"vcs": "ВКС", "telephony": "Телефония", "pro_av": "PRO AV",
"infrastructure": "Инфраструктура", "passive": "Пассив",
"software": "Софт", "unknown": "Не разобрано",
}
CLASS_LABELS = {
"vcs.bar.compact": "Компакт-бар",
"vcs.bar.room": "Видеобар для переговорной",
"vcs.board": "Интерактивная панель",
"vcs.terminal.room": "Терминал / кодек",
"vcs.terminal.pc": "ПК-терминал",
"vcs.byod.kit": "BYOD-комплект",
"vcs.kit.room": "Комплект ВКС",
"vcs.camera.usb": "USB-камера",
"vcs.camera.ptz": "PTZ-камера",
"vcs.audio": "Аудио / микрофоны",
"vcs.control.touch": "Панель управления",
"vcs.sharing": "Презентация / BYOD",
"vcs.accessory": "Аксессуар",
"vcs.other": "Прочее",
"telephony.sip.desk": "SIP-телефон",
"telephony.sip.conference": "Конференц-телефон",
"telephony.dect": "DECT-телефон",
"telephony.headset": "Гарнитура",
"telephony.accessory": "Аксессуар телефонии",
"passive.display": "Дисплей",
"passive.mount": "Крепление",
"passive.power": "Питание",
"infrastructure.network": "Сеть / инфраструктура",
}
ROLE_LABELS = {
"codec": "Кодек / терминал", "pc": "ПК", "kit": "Комплект",
"camera": "Камера", "audio": "Аудио", "speaker": "Спикер",
"touch": "Панель", "display": "Дисплей", "mount": "Крепление",
"sharing_hub": "Презентация", "phone": "Телефон", "headset": "Гарнитура",
"power": "Питание", "unknown": "Не разобрано", "accessory": "Аксессуар",
}
def domain_label(v):
return DOMAIN_LABELS.get(v, str(v or "—"))
def class_label(v):
return CLASS_LABELS.get(v) or str(v or "—").replace(".", " · ").replace("_", " ").title()
def role_label(v):
return ROLE_LABELS.get(v, str(v or "—").title())
def norm(s):
return re.sub(r"[^a-z0-9]", "", str(s).lower())
def load_yaml(name):
import yaml
p = os.path.join(BASE, name)
if not os.path.exists(p):
return {}
try:
return yaml.safe_load(open(p, encoding="utf-8")) or {}
except Exception:
return {}
class Data:
def __init__(self):
self.cat = load_yaml("catalog.yaml")
# аналоги смотрят все вендорские ветки, но основной конструктор — Yealink
self.analog_devices = []
seen = set()
for f in [os.path.join(BASE, "catalog.yaml")] + sorted(glob.glob(os.path.join(BASE, "catalog-*.yaml"))):
if not os.path.exists(f):
continue
c = load_yaml(os.path.basename(f))
for d in c.get("devices") or []:
key = (d.get("vendor"), d.get("name") or d.get("model"))
if key in seen:
continue
seen.add(key)
self.analog_devices.append(d)
self.graph = load_yaml("graph.yaml")
self.values = load_yaml("values.yaml")
self.features = load_yaml("features.yaml")
self.protocols = load_yaml("protocols.yaml")
self.mounts = load_yaml("mounts.yaml")
self.iface = load_yaml("interfaces_verified.yaml")
self.iface_auto = load_yaml("interfaces.yaml")
self.pkg = load_yaml("package.yaml")
self.pkg_ver = load_yaml("package_verified.yaml")
self.kits = load_yaml("kits.yaml")
self.extra = load_yaml("specs_extra.yaml")
self.infra = load_yaml("infrastructure.yaml")
self.limits = load_yaml("limitations.yaml")
self.dante = load_yaml("dante.yaml")
self.devices = {norm(d["name"]): {"name": d["name"], "role": d.get("role", "unknown")}
for d in self.cat.get("devices") or []}
self.edges = {}
for e in self.graph.get("edges") or []:
self.edges.setdefault(norm(e.get("from")), []).append(e)
self.attrs = {norm(x.get("device")): x.get("attributes") or {}
for x in self.values.get("devices") or []}
self.feats = {}
for x in self.features.get("devices") or []:
self.feats.setdefault(norm(x.get("device")), set()).update(x.get("features") or [])
for x in self.protocols.get("devices") or []:
f = x.get("features") or {}
self.feats.setdefault(norm(x.get("device")), set()).update(
f.keys() if isinstance(f, dict) else f)
for x in self.dante.get("dante_devices") or []:
self.feats.setdefault(norm(x.get("device")), set()).add("Dante")
# доп. характеристики из specs_extra.yaml (проверено)
for x in (self.extra.get("devices") or []):
k = norm(x["device"])
self.attrs.setdefault(k, {})
for ak, av in (x.get("attributes") or {}).items():
self.attrs[k].setdefault(ak, av)
if x.get("package"):
self.pkg_map_extra = getattr(self, "pkg_map_extra", {})
self.pkg_map_extra[k] = x["package"]
self.pkg_map = {}
for x in (self.pkg_ver.get("devices") or []):
self.pkg_map[norm(x["device"])] = x
self.iface_map = {}
self.iface_auto_map = {}
for x in (self.iface.get("devices") or []):
self.iface_map[norm(x["device"])] = x
for x in (self.iface_auto.get("devices") or []):
self.iface_auto_map[norm(x["device"])] = x
self.mounts_map = {}
for e in self.mounts.get("edges") or []:
self.mounts_map.setdefault(norm(e["host"]), []).append(e["mount"])
# ── хосты ──
def hosts(self):
out = []
for k, v in self.devices.items():
if v["role"] not in ("codec", "pc"):
continue
if v["role"] != "pc" and not self.edges.get(k):
continue
acc = [e for e in self.edges.get(k, []) if e.get("supported")]
out.append({"key": k, "name": v["name"], "accessories": len(acc)})
return sorted(out, key=lambda x: x["name"])
# ── все доступные требования ──
def requirements(self):
groups = {
"Аудио": ["AEC", "ANC", "Dante", "AES67", "Wireless Microphone",
"Speaker Tracking", "Audio Fence"],
"Видео": ["Auto Framing", "Presenter Tracking", "4K", "IntelliFrame"],
"ВКС": ["Teams", "Zoom", "H.323", "SIP"],
"Сеть": ["PoE", "Wi-Fi", "Bluetooth", "802.1X", "VLAN", "SRTP"],
"Презентация": ["AirPlay", "Miracast", "USB-C"],
}
return [{"group": g, "items": items} for g, items in groups.items()]
def device_row(self, key):
d = self.devices[key]
return {"key": key, "name": d["name"], "role": d["role"],
"features": sorted(self.feats.get(key, [])),
"attributes": self.attrs.get(key, {}),
"accessories": [{"model": e["to"], "supported": e.get("supported"),
"max_qty": e.get("max_qty"),
"condition": e.get("condition"),
"usable": e.get("usable", True)}
for e in self.edges.get(key, [])],
"mounts": self.mounts_map.get(key, [])}
# ── порты по роли (если в даташите не указаны) ──
PORTS_BY_ROLE = {
"display": {"in": ["HDMI"], "out": []},
"camera": {"in": ["LAN"], "out": ["USB", "HDMI"]},
"audio": {"in": ["VCH"], "out": ["VCH"]},
"speaker": {"in": ["VCH"], "out": []},
"touch": {"in": ["LAN"], "out": ["USB"]},
"sharing_or_hub": {"in": ["USB"], "out": ["HDMI"]},
"mount": {"in": [], "out": []},
"codec": {"in": ["LAN"], "out": ["HDMI", "USB", "VCH"]},
"pc": {"in": ["USB", "LAN"], "out": ["HDMI"]},
}
# ── порты устройства для схемы ──
def ports(self, name):
iv = self.iface_map.get(norm(name))
if iv: # проверено по даташиту
return (list(iv.get("in") or []) or ["—"],
list(iv.get("out") or []) or ["—"])
a = self.attrs.get(norm(name), {})
ins, outs = [], []
out_map = (("ports.hdmi_out", "HDMI"), ("ports.usb", "USB"), ("ports.vch", "VCH"))
in_map = (("ports.hdmi_in", "HDMI"),)
for aid, label in out_map:
n = a.get(aid)
if n:
outs += [label] * int(n)
for aid, label in in_map:
n = a.get(aid)
if n:
ins += [label] * int(n)
role = self.devices.get(norm(name), {}).get("role", "unknown")
dflt = self.PORTS_BY_ROLE.get(role, {"in": ["LAN"], "out": ["—"]})
if not ins:
ins = list(dflt["in"])
if not outs:
outs = list(dflt["out"]) or ["—"]
return ins, outs
# ── ГРУППЫ оборудования (как в Yealink Room Calculator) ── GROUPS_V2
GROUP_DEFS = [
{"id": "mic", "name": "Микрофоны", "roles": ["audio"],
"skip": r"^CP50|^CP965|^CPE|^CP\d|^PA\d|^CS10-D|^CLS120"},
{"id": "speaker", "name": "Громкоговорители", "roles": ["speaker"],
"extra": r"^CS10-D|^CLS120|^MSpeaker"},
{"id": "camera", "name": "Камеры", "roles": ["camera"], "skip": None},
{"id": "panel", "name": "Панели управления", "roles": ["touch", "remote"], "skip": None},
{"id": "sharing", "name": "Презентация и хабы", "roles": ["sharing_or_hub"],
"skip": None},
{"id": "phone", "name": "Аудиоустройства и телефоны",
"roles": ["audio"], "only": r"^CP50|^CP965|^CPE|^CP\d|^PA\d"},
{"id": "display", "name": "Дисплеи", "roles": ["display"], "skip": None},
{"id": "mount", "name": "Кронштейны", "roles": ["mount"], "skip": None},
{"id": "infra", "name": "Инфраструктура (PoE, хабы)", "roles": [], "skip": None},
]
# ── ПОЗИЦИОННЫЙ конструктор: места установки ──
POSITIONS = [
{"id": "rack", "name": "Стойка / шкаф",
"hint": "кодек, DSP, коммутатор",
"roles": ["sharing_or_hub", "power"]},
{"id": "table", "name": "Стол",
"hint": "настольные микрофоны, панели, докстанции",
"roles": ["audio", "touch", "remote"]},
{"id": "ceiling", "name": "Потолок",
"hint": "потолочные микрофоны и громкоговорители",
"roles": ["audio", "speaker", "sensor"]},
{"id": "wall", "name": "Стена / экран",
"hint": "камеры, дисплеи",
"roles": ["camera", "display"]},
{"id": "perimeter", "name": "Периметр",
"hint": "кронштейны и крепления",
"roles": ["mount", "headset"]},
]
# позиция по имени устройства (важнее роли: VCM38 — потолочный, хотя роль audio)
POSITION_RULES = [
(r"^VCM|^CM50|^CS10-D|^CLS120|^MSpeaker|^CS10\b", "ceiling"),
(r"^CM20|^CS10|^CP50|^CPE|^CP965|^CP\d|^CTP|^MTouch|^VCR|^MB-Remote|^PA\d", "table"),
(r"^UVC|^MB-CAM|^MB-12X|^SmartVision|MeetingDisplay|^ETV|^VCC", "wall"),
(r"^MCore|^VCH|^WPP|^AP0|^AVBridge|^AVHub|^BYOD|^YPS|^PVB|^PVT|MeetingEye|^A\d|^MeetingBoard|^MB-FS|^Roomcast", "rack"),
(r"[Mm]ount|Bracket|Stand|^MB-Tray|^MB-Wall|^MD-", "perimeter"),
]
def pos_of(self, name):
for pat, pos in self.POSITION_RULES:
if re.match(pat, str(name)):
return pos
return None
def positions(self, host_key, need=None):
"""Позиции комнаты: в каждой только совместимые с хостом устройства."""
need_n = {norm(x) for x in (need or [])}
hk = norm(host_key)
if hk not in self.devices:
return {"error": "хост не найден"}
host_role = self.devices[hk]["role"]
# у бара камера обычно встроенная — позицию камеры скрываем, если нет совместимых
out = []
for pos in self.POSITIONS:
items = []
for e in self.edges.get(hk, []):
t = e["to"]
r = self.devices.get(norm(t), {}).get("role")
if r not in pos["roles"]:
continue
# уточнение по позиции устройства
real_pos = self.pos_of(t)
if real_pos and real_pos != pos["id"]:
continue
if not e.get("supported") or not e.get("usable", True):
continue
a = self.attrs.get(norm(t), {})
f = {norm(x) for x in self.feats.get(norm(t), set())}
if need_n and not need_n <= f:
continue
items.append({
"model": t, "role": r,
"max_qty": e.get("max_qty"),
"condition": (e.get("condition") or "").strip()[:160],
"power_w": a.get("power.consumption_w"),
"pickup_m": a.get("audio.pickup_m"),
"zoom": a.get("camera.zoom_optical") or a.get("camera.zoom_hybrid"),
"ports_vch": a.get("ports.vch"),
})
if pos["id"] == "perimeter":
for m in self.mounts_map.get(hk, []):
items.append({"model": m, "role": "mount", "max_qty": 1,
"condition": "лист Mounts & Bracket",
"power_w": None, "pickup_m": None, "zoom": None,
"ports_vch": None})
uniq = {}
for i in items:
uniq.setdefault(i["model"], i)
items = sorted(uniq.values(), key=lambda x: x["model"])
out.append({"id": pos["id"], "name": pos["name"], "hint": pos["hint"],
"items": items})
return {"host": self.devices[hk]["name"], "host_role": host_role,
"positions": out}
# какие разъёмы соединяются между собой
LINKABLE = {
("HDMI", "HDMI"): "видео",
("USB", "USB"): "данные",
("USB-C", "USB-C"): "данные + видео",
("USB", "USB-C"): "данные (через переходник)",
("VCH", "VCH"): "аудио + питание",
("LAN", "LAN"): "сеть / PoE",
("3.5mm", "3.5mm"): "аналоговый звук",
("DP", "DP"): "видео",
}
# запреты из официальных даташитов
FORBIDDEN = [
{"device": "UVC86", "port": "HDMI", "host_contains": "mvc",
"reason": "HDMI-выход UVC86 совместим с VCS, но НЕ с MVC (даташит)"},
]
def device_ports(self, name):
"""Порты: проверенные -> извлечённые -> по роли. Возвращает (in, out, source)."""
k = norm(name)
if k in self.iface_map:
v = self.iface_map[k]
return (v.get("in") or ["—"], v.get("out") or ["—"], "verified")
if k in self.iface_auto_map:
v = self.iface_auto_map[k]
ins = [p for p in (v.get("in") or []) if p]
outs = [p for p in (v.get("out") or []) if p]
if ins or outs:
return (ins or ["—"], outs or ["—"], "auto")
ins, outs = self.ports(name)
return (ins, outs, "role")
def link_plan(self, host_key, items):
"""План связей: каждый аксессуар -> хост, по совместимости разъёмов."""
hk = norm(host_key)
host = self.devices.get(hk, {}).get("name", host_key)
h_in, h_out, h_src = self.device_ports(host)
links = []
for row in items:
model = row[0] if isinstance(row, (list, tuple)) else row
acc_in, acc_out, src = self.device_ports(model)
link = {"device": model, "host": host, "ok": False,
"from_port": None, "to_port": None, "type": None,
"source": src, "reason": None}
# ищем пару: выход аксессуара -> вход хоста (и наоборот)
pairs = []
for a in acc_out:
for b in h_in:
if (a, b) in self.LINKABLE:
pairs.append((a, b, self.LINKABLE[(a, b)]))
elif (b, a) in self.LINKABLE:
pairs.append((a, b, self.LINKABLE[(b, a)]))
for a in h_out:
for b in acc_in:
if (a, b) in self.LINKABLE:
pairs.append((a, b, self.LINKABLE[(a, b)]))
if pairs:
p = pairs[0]
link.update({"ok": True, "from_port": p[0], "to_port": p[1],
"type": p[2]})
else:
link["reason"] = ("нет совместимого разъёма: %s in=%s out=%s / хост in=%s out=%s"
% (model, ",".join(acc_in) or "-", ",".join(acc_out) or "-",
",".join(h_in) or "-", ",".join(h_out) or "-"))
# запреты
for fb in self.FORBIDDEN:
if norm(fb["device"]) == norm(model) and \
fb["host_contains"] in norm(host) and \
(link.get("from_port") == fb["port"] or link.get("to_port") == fb["port"]):
link.update({"ok": False, "forbidden": True, "reason": fb["reason"]})
links.append(link)
return {"host": host, "host_ports": {"in": h_in, "out": h_out, "source": h_src},
"links": links}
# ── полнота данных по хосту ── data_completeness
def data_completeness(self, host_key):
hk = norm(host_key)
srcs = {}
for e in self.edges.get(hk, []):
srcs[e.get("source") or "?"] = srcs.get(e.get("source") or "?", 0) + 1
total = sum(srcs.values())
supported = sum(1 for e in self.edges.get(hk, []) if e.get("supported"))
if "matrix" in srcs and "accessories_list" in srcs:
level, note = "full", "два официальных источника: матрица + лист аксессуаров"
elif "matrix" in srcs:
level, note = "partial", "только матрица — лист аксессуаров не найден"
elif "accessories_list" in srcs:
level, note = "sparse", ("только лист аксессуаров (%d строк) — в основной "
"матрице Yealink этого хоста нет, данные могут быть "
"неполными" % total)
else:
level, note = "none", "связей нет — данных о совместимости не найдено"
return {"level": level, "note": note, "edges": total,
"supported": supported, "sources": srcs}
# ── группы оборудования ──
def groups(self, host_key, need=None):
need_n = {norm(x) for x in (need or [])}
hk = norm(host_key)
if hk not in self.devices:
return {"error": "хост не найден"}
out = []
used = set()
for g in self.GROUP_DEFS:
items = []
if g["id"] == "infra":
for x in (self.infra.get("devices") or []):
items.append({"model": x["device"], "role": "infrastructure",
"max_qty": 4, "condition": x.get("why") or "",
"pickup_m": None, "zoom": None,
"power_w": None, "ports_vch": None,
"specs": x.get("specs") or {}})
out.append({"id": g["id"], "name": g["name"], "hint":
"PoE-коммутаторы и хабы для роста системы", "items": items})
continue
for e in self.edges.get(hk, []):
t = e["to"]
k = norm(t)
if k in used:
continue
r = self.devices.get(k, {}).get("role")
if r not in g["roles"]:
continue
if not e.get("supported") or not e.get("usable", True):
continue
if g.get("skip") and re.match(g["skip"], t, re.I):
continue
if g.get("only") and not re.match(g["only"], t, re.I):
continue
a = self.attrs.get(k, {})
f = {norm(x) for x in self.feats.get(k, set())}
if need_n and not need_n <= f:
continue
used.add(k)
items.append({"model": t, "role": r,
"max_qty": e.get("max_qty"),
"condition": (e.get("condition") or "").strip()[:160],
"power_w": a.get("power.consumption_w"),
"pickup_m": a.get("audio.pickup_m"),
"zoom": a.get("camera.zoom_optical") or a.get("camera.zoom_hybrid"),
"ports_vch": a.get("ports.vch")})
if g["id"] == "mount":
have = {i["model"] for i in items}
for m in self.mounts_map.get(hk, []):
if m in have:
continue
items.append({"model": m, "role": "mount", "max_qty": 1,
"condition": "лист Mounts & Bracket",
"power_w": None, "pickup_m": None, "zoom": None,
"ports_vch": None})
if items:
out.append({"id": g["id"], "name": g["name"],
"hint": "", "items": sorted(items, key=lambda x: x["model"])})
return {"host": self.devices[hk]["name"], "groups": out,
"completeness": self.data_completeness(hk)}
# ── проверка одной пары: хост + устройство ──
def check_pair(self, host_key, accessory):
hk = norm(host_key)
ak = norm(accessory)
host = self.devices.get(hk, {}).get("name")
acc_name = self.devices.get(ak, {}).get("name") or accessory
if not host:
return {"error": "хост не найден"}
found = None
for e in self.edges.get(hk, []):
if norm(e["to"]) == ak:
found = e
break
if not found:
return {"host": host, "device": acc_name, "known": False,
"supported": False, "verdict": "нет в матрице для этого хоста",
"note": "устройство не описано как аксессуар этого хоста"}
supported = bool(found.get("supported"))
usable = found.get("usable", True)
if not usable:
verdict = "исключено: источники расходятся — требуется проверка у вендора"
elif supported:
q = found.get("max_qty")
verdict = "совместимо" + (" (до %s шт)" % q if q else "")
else:
verdict = "несовместимо"
cond = re.sub(r"^[\u221a\u2713\u2714\u00d7\u2717\u2718\u2022\s]+", "",
(found.get("condition") or "")).strip() # cond_clean
return {"host": host, "device": acc_name, "known": True,
"supported": supported, "usable": usable,
"max_qty": found.get("max_qty"),
"condition": cond,
"source": found.get("source") or "матрица",
"verdict": verdict}
# ── матрица: хосты × аксессуары + порты ──
def matrix(self):
hosts = [h for h in self.hosts()]
accs = {}
for hk in [h["key"] for h in hosts]:
for e in self.edges.get(hk, []):
if not e.get("supported") or not e.get("usable", True):
continue
accs[norm(e["to"])] = e["to"]
acc_list = sorted(accs.values())
rows = []
for h in hosts:
hk = h["key"]
cells = {}
for e in self.edges.get(hk, []):
if not e.get("supported") or not e.get("usable", True):
continue
k = norm(e["to"])
q = e.get("max_qty")
cells[k] = q if q else 1
ins, outs, src = self.device_ports(h["name"])
rows.append({"host": h["name"], "cells": cells,
"ports": {"in": ins, "out": outs, "source": src}})
return {"hosts": [r["host"] for r in rows],
"rows": rows,
"accessories": acc_list}
# ── порты всех устройств ──
def ports_table(self):
out = []
for k, v in sorted(self.devices.items(), key=lambda x: x[1]["name"]):
name = v["name"]
ins, outs, src = self.device_ports(name)
pkg = []
for x in (self.pkg.get("devices") or []):
if norm(x["device"]) == k:
pkg = x.get("items") or []
break
lim = []
for x in (self.limits.get("devices") or []):
if norm(x["device"]) == k:
lim = x.get("limits") or []
break
out.append({"device": name, "role": v["role"],
"in": ins, "out": outs, "source": src,
"package": pkg, "limits": lim})
return out
# ── предложения: как закрыть проблему ──
def suggest_fixes(self, host_key, items, issues, missing_power):
hk = norm(host_key)
ha = self.attrs.get(hk, {})
vch_ports = ha.get("ports.vch")
qtys = {}
for row in items:
qtys[row[0]] = qtys.get(row[0], 0) + int(row[1])
def compat(role):
out = []
for e in self.edges.get(hk, []):
if not e.get("supported") or not e.get("usable", True):
continue
if self.devices.get(norm(e["to"]), {}).get("role") != role:
continue
a = self.attrs.get(norm(e["to"]), {})
out.append({"model": e["to"], "max_qty": e.get("max_qty"),
"vch": a.get("ports.vch"), "wifi": a.get("network.wifi"),
"poe": a.get("network.poe"),
"power_w": a.get("power.consumption_w")})
return out
variants = []
need_vch = any("VCH" in i for i in issues)
# инфраструктура: RCH40 E2 даёт 4 PoE-порта
infra_items = []
for x in (self.infra.get("devices") or []):
sp = x.get("specs") or {}
infra_items.append({
"title": "Добавить %s" % x["device"],
"why": "%s PoE+ портов, бюджет %s Вт (%s Вт на порт), uplink 1G"
% (sp.get("poe_ports"), sp.get("poe_budget_w"),
sp.get("poe_per_port_w")),
"add": [[x["device"], 1]], "kind": "infra"})
variants.extend(infra_items)
if need_vch:
# вариант 1: добавить хаб с VCH-портами
# hub_filter: только реальные VCH-хабы (VCH51/VCH51 Pro), не донглы
hubs = []
for h in compat("sharing_or_hub"):
if not re.match(r"^VCH", h["model"], re.I):
iv = self.iface_map.get(norm(h["model"])) or {}
if "VCH" not in (iv.get("in") or []) + (iv.get("out") or []):
continue
hubs.append(h)
for h in hubs[:3]:
variants.append({
"title": "Добавить %s" % h["model"],
"why": "даёт %s VCH-порт(а) для цепочки" % (h["vch"] or 1),
"add": [[h["model"], 1]],
"kind": "hub"})
if not hubs:
for h in compat("sharing_or_hub")[:2]:
variants.append({
"title": "Добавить %s" % h["model"],
"why": "расширяет подключение (VCH-порты не указаны в данных — проверить)",
"add": [[h["model"], 1]], "kind": "hub_unknown"})
# вариант 2: беспроводные микрофоны
wifi = [a for a in compat("audio") if a.get("wifi")]
for a in wifi[:2]:
variants.append({
"title": "Заменить проводные на %s" % a["model"],
"why": "беспроводной микрофон — не занимает VCH-порт",
"replace_role": "audio", "add": [[a["model"], 1]],
"kind": "wireless"})
# вариант 3: уменьшить количество
variants.append({
"title": "Сократить количество на VCH",
"why": "у хоста %s VCH-порт(а) — распределить устройства или снизить число"
% (int(vch_ports) if vch_ports else "?"),
"kind": "reduce"})
if missing_power:
variants.append({
"title": "Уточнить питание",
"why": "нет данных о потреблении: %s — запросить у вендора"
% ", ".join(missing_power[:5]),
"kind": "data"})
# PoE-бюджет: если есть устройства без PoE, но с питанием
no_poe = [m for m in qtys if not (self.attrs.get(norm(m), {}) or {}).get("network.poe")]
if no_poe:
variants.append({
"title": "Проверить питание %s" % ", ".join(no_poe[:3]),
"why": "у этих устройств нет данных о PoE — возможно, нужен блок питания",
"kind": "data"})
return variants
# ── проверка ёмкости хоста ──
def capacity(self, host_key, items):
"""items: [[model, qty], ...]. Проверяет порты VCH, лимиты, питание."""
hk = norm(host_key)
if hk not in self.devices:
return {"error": "хост не найден"}
host = self.devices[hk]["name"]
ha = self.attrs.get(hk, {})
vch_ports = ha.get("ports.vch")
issues, notes = [], []
total_w, missing_w = 0.0, []
vch_users = 0
qtys = {}
for row in items:
model, qty = row[0], int(row[1])
qtys[model] = qtys.get(model, 0) + qty
# лимиты из матрицы
limits = {}
for e in self.edges.get(hk, []):
if e.get("supported"):
limits[norm(e["to"])] = (e.get("max_qty"), e["to"])
for model, q in qtys.items():
lim, name = limits.get(norm(model), (None, model))
if lim and q > lim:
issues.append("%s: %d шт при лимите %d" % (name, q, lim))
a = self.attrs.get(norm(model), {})
w = a.get("power.consumption_w")
if w:
total_w += w * q
else:
missing_w.append(model)
if a.get("audio.pickup_m") or a.get("ports.vch"):
vch_users += q
if vch_ports is not None and vch_users > 0:
notes.append("портов VCH у хоста: %s · устройств на VCH: %d"
% (int(vch_ports), vch_users))
if vch_users > vch_ports:
issues.append(
"VCH: %d устройств на %s порт(а) — требуется цепочка/расширитель; "
"ёмкость цепочки в данных отсутствует — ПРОВЕРИТЬ У ВЕНДОРА"
% (vch_users, int(vch_ports)))
notes.append("суммарное потребление: %.1f Вт (по данным)" % total_w)
if missing_w:
notes.append("нет данных о потреблении: %s" % ", ".join(sorted(set(missing_w))[:8]))
suggestions = self.suggest_fixes(host_key, items, issues, sorted(set(missing_w)))
return {"host": host, "vch_ports": vch_ports, "vch_users": vch_users,
"suggestions": suggestions,
"total_power_w": round(total_w, 1),
"missing_power": sorted(set(missing_w)),
"issues": issues, "notes": notes}
# ── варианты для ручной сборки (только совместимые!) ──
FEATURE_ROLE = {
"aec": "audio", "anc": "audio", "dante": "audio", "aes67": "audio",
"autoarchframing": "camera", "autoframing": "camera",
"speakertracking": "camera", "presentertracking": "camera", "4k": "camera",
"airplay": "sharing_or_hub", "miracast": "sharing_or_hub", "usbc": "sharing_or_hub",
"poe": "network", "wifi": "network", "bluetooth": "network",
"teams": "codec", "zoom": "codec", "h323": "codec", "sip": "codec",
}
ROLE_LABELS = [
("audio", "Аудио / микрофоны"),
("camera", "Камеры"),
("touch", "Панели управления"),
("sharing_or_hub", "Презентация / хабы"),
("display", "Дисплеи"),
("speaker", "Громкоговорители"),
("mount", "Кронштейны"),
("remote", "Пульты"),
("headset", "Гарнитуры"),
]
def options(self, host_key, need=None):
"""need — требования: фильтруют позиции внутри групп по ролям.""" # VENDOR_LAYER
need_n = {norm(x) for x in (need or [])}
hk = norm(host_key)
if hk not in self.devices:
return {"error": "хост не найден"}
groups, blocked_count = [], {}
for role, label in self.ROLE_LABELS:
items = []
blocked = 0
for e in self.edges.get(hk, []):
target = e["to"]
r = self.devices.get(norm(target), {}).get("role")
if r != role:
continue
# несовместимые по матрице НЕ показываем
if not e.get("supported") or not e.get("usable", True):
blocked += 1
continue
a = self.attrs.get(norm(target), {})
acc_feats = {norm(f) for f in self.feats.get(norm(target), set())}
# требование применяется к своей роли
role_needs = {n for n in need_n
if self.FEATURE_ROLE.get(n) in (role, None)}
if role_needs and not role_needs <= acc_feats:
blocked += 1
continue
items.append({
"model": target,
"max_qty": e.get("max_qty"),
"condition": (e.get("condition") or "").strip(),
"features": sorted(self.feats.get(norm(target), []))[:8],
"pickup_m": a.get("audio.pickup_m"),
"zoom": a.get("camera.zoom_optical") or a.get("camera.zoom_hybrid"),
})
# mount_merge: кронштейны из обоих источников
if role == "mount":
have = {i["model"] for i in items}
for m in self.mounts_map.get(hk, []):
if m in have:
continue
items.append({"model": m, "max_qty": 1,
"condition": "лист Mounts & Bracket",
"features": [], "pickup_m": None, "zoom": None})
have.add(m)
if items:
items.sort(key=lambda x: x["model"])
groups.append({"role": role, "label": label, "items": items})
if blocked:
blocked_count[role] = blocked
return {"host": self.devices[hk]["name"], "groups": groups,
"blocked": blocked_count}
# ── подбор ──
def bom(self, host_key, seats=8, need=None, add=None):
need = need or []
need_n = {norm(x) for x in need}
add = add or []
hk = norm(host_key)
if hk not in self.devices:
return {"error": "хост не найден"}
host = self.devices[hk]["name"]
need_m = 3 if seats <= 6 else 6 if seats <= 12 else 8 if seats <= 16 else 10
bom, warn, cross = [], [], []
def by_role(role):
return [e for e in self.edges.get(hk, [])
if e.get("supported") and e.get("usable", True)
and self.devices.get(norm(e["to"]), {}).get("role") == role]
bom.append({"role": "Хост", "model": host, "qty": 1, "why": "основа системы"})
def mark_included():
"""Помечает позиции, чьи кабели/крепёж уже в комплекте."""
for b in bom:
k = norm(b["model"])
pk = self.pkg_map.get(k) or {}
items = pk.get("items") or (getattr(self, "pkg_map_extra", {}) or {}).get(k) or []
if items:
b["included"] = items
ha = {norm(f) for f in self.feats.get(hk, [])}
for n in need:
if norm(n) not in ha:
warn.append("хост не имеет функции «%s»" % n)
built = self.attrs.get(hk, {}).get("audio.pickup_m")
if built and built >= need_m:
bom.append({"role": "Микрофон", "model": "встроенный " + host, "qty": 1,
"why": "захват %s м ≥ %s м" % (built, need_m)})
else:
cands = sorted(((self.attrs.get(norm(e["to"]), {}).get("audio.pickup_m") or 0, e)
for e in by_role("audio")), key=lambda x: -x[0])
if cands:
p, e = cands[0]
q = max(1, -(-need_m // max(int(p), 1))) if p else 1
bom.append({"role": "Микрофон", "model": e["to"], "qty": q,
"why": "нужно %s м, у %s %s м (до %s шт)"
% (need_m, e["to"], p or "—", e.get("max_qty") or "—")})
cams = by_role("camera")
if cams:
def sc(e):
a = self.attrs.get(norm(e["to"]), {})
z = (a.get("camera.zoom_optical") or 0) + (a.get("camera.zoom_hybrid") or 0)
return z - (100 if "content camera" in (e.get("condition") or "").lower() else 0)
cams.sort(key=sc, reverse=True)
bom.append({"role": "Камера", "model": cams[0]["to"], "qty": 1,
"why": "совместима, до %s шт" % (cams[0].get("max_qty") or "—")})
for role, label in (("touch", "Панель"), ("sharing_or_hub", "Презентация")):
it = by_role(role)
if it:
bom.append({"role": label, "model": it[0]["to"], "qty": 1,
"why": (it[0].get("condition") or "совместимо")[:70]})
disps = by_role("display")
bom.append({"role": "Дисплей", "model": disps[0]["to"] if disps else "внешний ТВ",
"qty": 1, "why": "совместим" if disps else "у Yealink нет дисплея"})
mnts = self.mounts_map.get(hk) or [e["to"] for e in by_role("mount")]
if mnts:
bom.append({"role": "Кронштейн", "model": mnts[0], "qty": 1,
"why": "вариантов: %d" % len(mnts)})
for n in add:
bom.append({"role": "Якорь", "model": n, "qty": 1, "why": "задано вручную"})
if any(norm(x) == "dante" for x in need):
bom.append({"role": "Dante", "model": "CM50+CS10-D+AP08", "qty": 1,
"why": "нативный Dante-комплект"})
chosen = {norm(b["model"]) for b in bom}
for e in self.edges.get(hk, []):
if norm(e["to"]) not in chosen:
continue
c = e.get("condition") or ""
for known, info in self.devices.items():
if len(known) > 3 and known in norm(c) and known not in chosen:
cross.append("%s требует %s" % (e["to"], info["name"]))
mark_included()
# что входит в комплект (не покупать отдельно)
included, kits = [], []
for b in bom:
if b["model"].startswith("встроенный") or b["model"].startswith("внешний"):
continue
k = norm(b["model"])
p = self.pkg_map.get(k)
if p:
included.append({"device": b["model"],
"items": p.get("items") or [],
"kits": p.get("optional_kits") or []})
for kk in (self.kits.get("kits") or []):
if norm(kk.get("base")) == hk:
kits.append(kk)
# схема: узлы с портами и связи
nodes = []
for b in bom:
if b["role"] in ("Кронштейн",) or b["model"].startswith("встроенный"):
continue
ins, outs = self.ports(b["model"])
nodes.append({"model": b["model"], "role": b["role"], "qty": b["qty"],
"ins": ins[:6], "outs": outs[:6],
"central": b["role"] == "Хост"})
links = []
center = next((n for n in nodes if n["central"]), None)
if center:
for n in nodes:
if n["central"]:
continue
links.append({"from": center["model"], "to": n["model"],
"type": (n["outs"] or ["-"])[0]})
return {"host": host, "seats": seats, "need_pickup": need_m,
"bom": bom, "warnings": warn, "cross": cross,
"included": included, "kits": kits,
"scheme": {"nodes": nodes, "links": links}}
D = Data()
ARCHIVE_FILE = os.path.join(BASE, "archive.yaml")
ARCHIVE_LOG = "/var/log/prism-archive.jsonl"
def _akey(d):
return str(d.get("id") or norm(_dev_name(d)))
def load_archive():
try:
import yaml
d = yaml.safe_load(open(ARCHIVE_FILE, encoding="utf-8")) or {}
return d.get("devices") or {}
except Exception:
return {}
ARCHIVE = load_archive()
def archive_info(d):
return ARCHIVE.get(_akey(d))
def is_archived(d):
return bool(archive_info(d))
def save_archive():
import yaml
os.makedirs(os.path.dirname(ARCHIVE_FILE), exist_ok=True)
tmp = ARCHIVE_FILE + ".tmp"
yaml.safe_dump({"devices": ARCHIVE}, open(tmp, "w", encoding="utf-8"), allow_unicode=True, sort_keys=True)
os.replace(tmp, ARCHIVE_FILE)
def set_archive(d, action, reason=""):
global ARCHIVE
k = _akey(d)
if action == "restore":
ARCHIVE.pop(k, None)
save_archive()
return {"ok": True, "archived": False, "key": k, "name": _dev_name(d)}
ARCHIVE[k] = {"name": _dev_name(d), "vendor": d.get("vendor"),
"archived_at": time.strftime("%Y-%m-%dT%H:%M:%S"),
"reason": reason or "устарело/снято с актуальности"}
save_archive()
try:
with open(ARCHIVE_LOG, "a", encoding="utf-8") as f:
f.write(json.dumps({"ts": ARCHIVE[k]["archived_at"], "key": k,
"name": _dev_name(d), "reason": ARCHIVE[k]["reason"]},
ensure_ascii=False) + "\n")
except Exception:
pass
return {"ok": True, "archived": True, "key": k, "name": _dev_name(d)}
def archived_items():
out = []
for k, v in ARCHIVE.items():
out.append(dict(v, key=k))
return sorted(out, key=lambda x: x.get("archived_at") or "", reverse=True)
def _dev_name(d):
return d.get("name") or d.get("model") or ""
def analog_search(query, domain="vcs"):
"""Подбор аналогов: строго domain + solution_class.
SIP — протокол, не домен: VCS-бар с SIP не становится телефонией.
"""
q = (query or "").strip()
domain = (domain or "vcs").strip().lower()
devices = D.analog_devices
target = None
if q:
for d in devices:
names = [_dev_name(d)] + [str(a) for a in (d.get("aliases") or [])]
if any(q.lower() == n.lower() for n in names):
target = d
break
if target is None:
for d in devices:
names = [_dev_name(d)] + [str(a) for a in (d.get("aliases") or [])]
if any(q.lower() in n.lower() for n in names):
target = d
break
parsed = {"class": "", "protocols": [], "features": [], "note": ""}
if target is not None:
domain = target.get("domain") or domain
cls = target.get("solution_class") or ""
parsed["class"] = cls
else:
low = q.lower()
cls = ""
if domain == "telephony":
if "dect" in low:
cls = "telephony.dect"
elif "гарнитур" in low or "headset" in low:
cls = "telephony.headset"
elif "конференц" in low:
cls = "telephony.sip.conference"
else:
cls = "telephony.sip.desk"
else:
if "бар" in low or "bar" in low:
cls = "vcs.bar.compact" if "компакт" in low else "vcs.bar.room"
elif "панел" in low or "board" in low:
cls = "vcs.board"
elif "терминал" in low or "кодек" in low or "codec" in low:
cls = "vcs.terminal.room"
elif "камер" in low:
cls = "vcs.camera.usb"
elif "аудио" in low or "микрофон" in low:
cls = "vcs.audio"
elif "панель управления" in low or "touch" in low:
cls = "vcs.control.touch"
parsed["class"] = cls
if "sip" in low:
parsed["protocols"].append("SIP")
if "h.323" in low or "h323" in low:
parsed["protocols"].append("H.323")
if "4k" in low:
parsed["features"].append("4K")
def val(d, k):
return d.get(k) or ""
cand = []
tspec = specs(target) if target is not None else {}
for d in devices:
if target is not None and d is target:
continue
if d.get("domain") != domain:
continue
if parsed["class"] and d.get("solution_class") != parsed["class"]:
continue
if target is not None and d.get("vendor") == target.get("vendor"):
continue
if domain == "vcs" and d.get("sales_scope") == "reference":
continue
if domain == "telephony" and d.get("sales_scope") != "reference":
continue
cs = specs(d)
# жёсткие характеристики: если у цели подтверждено, у кандидата не должно быть «нет»
if target is not None:
if tspec.get("4k") is True and cs.get("4k") is False:
continue
if tspec.get("sip") is True and cs.get("sip") is False:
continue
if tspec.get("pickup_m") and cs.get("pickup_m") and cs["pickup_m"] < tspec["pickup_m"] * 0.8:
continue
s, why = 0, []
if parsed["class"]:
s += 50
why.append("same solution_class")
prot = {str(x).upper() for x in (d.get("protocols") or [])}
if parsed["protocols"] and prot & set(parsed["protocols"]):
s += 15
why.append("protocol match")
feats = {str(x).lower() for x in (d.get("features") or [])}
if parsed["features"] and all(f.lower() in feats for f in parsed["features"]):
s += 10
why.append("feature match")
if d.get("form_factor") == (target or {}).get("form_factor"):
s += 10
why.append("same form_factor")
if d.get("sales_scope") == "alternative":
s += 5
why.append("alternative vendor")
# близость числовых характеристик
for k, label in (("zoom_optical", "зум"), ("pickup_m", "захват"), ("fov_h", "FOV")):
tv, cv = tspec.get(k), cs.get(k)
if tv and cv:
diff = abs(float(tv) - float(cv)) / max(float(tv), 1)
s += max(0, 10 - int(diff * 10))
why.append("%s ~ %s" % (label, cv))
gaps = []
if is_archived(d):
gaps.append("снято с продажи — нельзя купить, только замена/существующий парк")
else:
s += 3
why.append("active")
if target is not None:
if cs.get("4k") is None:
gaps.append("4K не подтверждён")
if cs.get("sip") is None and tspec.get("sip") is True:
gaps.append("SIP не подтверждён")
if tspec.get("pickup_m") and cs.get("pickup_m") and cs["pickup_m"] < tspec["pickup_m"]:
gaps.append("захват меньше: %s < %s м" % (cs["pickup_m"], tspec["pickup_m"]))
if tspec.get("zoom_optical") and cs.get("zoom_optical") and cs["zoom_optical"] < tspec["zoom_optical"]:
gaps.append("зум меньше")
if target.get("form_factor") and d.get("form_factor") != target.get("form_factor"):
gaps.append("другой форм-фактор")
if cs.get("room_size") is None:
gaps.append("вместимость комнаты не подтверждена")
cand.append({"name": _dev_name(d), "vendor": d.get("vendor"),
"domain": d.get("domain"), "domain_label": domain_label(d.get("domain")),
"solution_class": d.get("solution_class"), "class_label": class_label(d.get("solution_class")),
"sales_scope": d.get("sales_scope"),
"protocols": d.get("protocols") or [], "specs": cs,
"archived": is_archived(d),
"score": s, "why": why, "gaps": gaps})
cand.sort(key=lambda x: (-x["score"], x["vendor"] or "", x["name"]))
# если фильтр по протоколу/фиче дал 0 — не врём, а сообщаем о нехватке данных
if parsed["protocols"] and not any("protocol match" in x["why"] for x in cand):
parsed["note"] = "в каталоге нет подтверждённых protocols для этого класса — фильтр не применён"
if parsed["features"] and not any("feature match" in x["why"] for x in cand):
parsed["note"] = (parsed["note"] + "; " if parsed["note"] else "") + "нет подтверждённых features 4K"
return {"query": q, "domain": domain,
"target": ({"name": _dev_name(target), "vendor": target.get("vendor"),
"solution_class": target.get("solution_class"),
"deployment": target.get("deployment"),
"components": target.get("components") or []} if target else None),
"parsed": parsed,
"alternatives": cand[:6],
"note": "Только same domain + solution_class; телефония не предлагается для VCS."}
def specs(d):
"""Канонические характеристики для сравнения. None = нет подтверждённых данных."""
name = _dev_name(d)
a = D.attrs.get(norm(name), {})
fs = {str(x).lower() for x in _features(d)}
prot = {str(x).upper() for x in (d.get("protocols") or [])}
def num(k):
v = a.get(k)
try:
return float(v)
except Exception:
return None
maxres = str(a.get("camera.max_resolution") or "").lower()
fourk = ("4k" in fs or "3840" in maxres or "4k" in maxres)
return {
"4k": True if fourk else (False if fs or maxres else None),
"sip": True if "SIP" in prot else (False if prot else None),
"h323": True if any("H.323" in p or "H323" in p for p in prot) else (False if prot else None),
"zoom_optical": num("camera.zoom_optical"),
"fov_h": num("camera.fov_h"),
"pickup_m": num("audio.pickup_m"),
"mic_count": num("audio.mic_count"),
"room_size": d.get("room_size") or a.get("room.max_participants"),
"display_inch": d.get("display_inch"),
"form_factor": d.get("form_factor"),
"native_vcs": d.get("native_vcs"),
"deployment": d.get("deployment"),
"verified": bool((d.get("source") or {}).get("verified")),
"sources": (d.get("source") or {}).get("files") or [],
}
def compare_devices(keys):
ds = []
for k in keys:
d = find_device(k)
if d and d not in ds:
ds.append(d)
if not ds:
return {"error": "not_found", "keys": keys}
fields = [
("vendor", "Вендор"), ("solution_class", "Класс"), ("form_factor", "Форм-фактор"),
("4k", "4K"), ("sip", "SIP"), ("h323", "H.323"), ("zoom_optical", "Оптический зум"),
("fov_h", "FOV"), ("pickup_m", "Захват, м"), ("mic_count", "Микрофоны"),
("room_size", "Комната"), ("native_vcs", "Native VCS"), ("deployment", "Deployment"),
]
cols, rows = [], []
for d in ds:
s = specs(d)
cols.append({"key": _key(d), "name": _dev_name(d), "vendor": d.get("vendor")})
for f, label in fields:
vals = []
for d in ds:
v = specs(d).get(f) if f in specs(d) else d.get(f)
if v is None or v == "":
v = None
elif isinstance(v, bool):
v = "да" if v else "нет"
vals.append(v)
rows.append({"field": f, "label": label, "values": vals})
return {"columns": cols, "rows": rows, "note": "— = нет подтверждённых данных; не выдумываем."}
def _key(d):
return d.get("id") or norm(_dev_name(d))
def _features(d):
"""features из записи + глобального индекса (для Yealink)."""
fs = set(str(x) for x in (d.get("features") or []))
fs.update(D.feats.get(norm(_dev_name(d)), set()))
return sorted(fs)
def search_catalog(params):
q = (params.get("q", [""])[0] or "").strip()
vendor = (params.get("vendor", [""])[0] or "all").lower()
domain = (params.get("domain", [""])[0] or "all").lower()
cls = (params.get("class", [""])[0] or "").strip()
role = (params.get("role", [""])[0] or "").strip()
protocol = (params.get("protocol", [""])[0] or "").strip().upper()
feature = (params.get("feature", [""])[0] or "").strip()
arch_mode = (params.get("archived", ["all"])[0] or "all").lower()
low = q.lower()
interpreted = []
if not cls:
if "бар" in low or "bar" in low:
cls = "vcs.bar.room" if "компакт" not in low else "vcs.bar.compact"
interpreted.append("класс: бар")
elif "камер" in low:
cls = "vcs.camera.usb"
interpreted.append("класс: камера")
elif "терминал" in low or "кодек" in low:
cls = "vcs.terminal.room"
interpreted.append("класс: терминал")
elif "byod" in low:
interpreted.append("контекст: BYOD")
if not protocol and "sip" in low:
protocol = "SIP"
interpreted.append("протокол: SIP")
if "h.323" in low or "h323" in low:
protocol = "H.323"
interpreted.append("протокол: H.323")
if not feature and "4k" in low:
feature = "4K"
interpreted.append("4K")
items = []
target_hit = find_device(q) if q else None
apply_text = bool(low) and (target_hit is not None or not interpreted)
for d in D.analog_devices:
if arch_mode == "only" and not is_archived(d):
continue
if arch_mode not in ("only", "all") and is_archived(d):
continue
if vendor not in ("", "all") and d.get("vendor") != vendor:
continue
if domain not in ("", "all") and d.get("domain") != domain:
continue
if cls and d.get("solution_class") != cls:
continue
if role and d.get("role") != role:
continue
prot = [str(x).upper() for x in (d.get("protocols") or [])]
fs = _features(d)
text = " ".join([_dev_name(d), str(d.get("vendor")), str(d.get("solution_class")),
str(d.get("role")), " ".join(prot), " ".join(fs),
" ".join(str(x) for x in (d.get("aliases") or []))]).lower()
if apply_text and low not in text:
continue
items.append(d)
note = ""
# протокол/4K — мягкие фильтры: если подтверждённых данных нет,
# не обнуляем выдачу, а показываем кандидатов и предупреждение
if protocol:
strict = [d for d in items if protocol in [str(x).upper() for x in (d.get("protocols") or [])]]
if strict:
items = strict
else:
note = "нет подтверждённых %s — фильтр не применён" % protocol
if feature:
strict = [d for d in items if any(feature.lower() in str(x).lower() for x in _features(d))]
if strict:
items = strict
else:
note = (note + "; " if note else "") + "нет подтверждённых %s — фильтр не применён" % feature
fv, fd, fc, fp = {}, {}, {}, {}
for d in items:
fv[d.get("vendor")] = fv.get(d.get("vendor"), 0) + 1
fd[d.get("domain")] = fd.get(d.get("domain"), 0) + 1
fc[d.get("solution_class")] = fc.get(d.get("solution_class"), 0) + 1
for p in (d.get("protocols") or []):
fp[str(p).upper()] = fp.get(str(p).upper(), 0) + 1
items.sort(key=lambda d: ((d.get("vendor") or ""), (d.get("solution_class") or ""), _dev_name(d)))
out = [{"key": _key(d), "name": _dev_name(d), "vendor": d.get("vendor"),
"domain": d.get("domain"), "domain_label": domain_label(d.get("domain")),
"solution_class": d.get("solution_class"), "class_label": class_label(d.get("solution_class")),
"role": d.get("role"), "role_label": role_label(d.get("role")),
"form_factor": d.get("form_factor"),
"protocols": d.get("protocols") or [], "sales_scope": d.get("sales_scope"),
"deployment": d.get("deployment"), "features": _features(d)[:8],
"archived": is_archived(d), "specs": specs(d)}
for d in items[:100]]
return {"query": q, "vendor": vendor, "domain": domain,
"interpreted": interpreted, "total": len(items), "items": out,
"facets": {"vendors": fv, "domains": fd, "classes": fc, "protocols": fp},
"note": note}
def find_device(key):
k = (key or "").strip().lower()
for d in D.analog_devices:
if k in (_dev_name(d).lower(), str(d.get("id") or "").lower()):
return d
if any(k == str(a).lower() for a in (d.get("aliases") or [])):
return d
for d in D.analog_devices:
if k and k in _dev_name(d).lower():
return d
return None
def product_info(key):
d = find_device(key)
if not d:
return {"error": "not_found", "key": key}
return {"product": {"key": _key(d), "name": _dev_name(d), "vendor": d.get("vendor"),
"domain": d.get("domain"), "domain_label": domain_label(d.get("domain")),
"solution_class": d.get("solution_class"), "class_label": class_label(d.get("solution_class")),
"role": d.get("role"), "role_label": role_label(d.get("role")),
"form_factor": d.get("form_factor"),
"protocols": d.get("protocols") or [], "sales_scope": d.get("sales_scope"),
"deployment": d.get("deployment"), "components": d.get("components") or [],
"features": _features(d), "archived": is_archived(d),
"specs": specs(d),
"attributes": D.attrs.get(norm(_dev_name(d)), {})},
"analogs": analog_search(_dev_name(d), d.get("domain") or "vcs")}
def room_roles():
return {"roles": [
{"id": "terminal", "name": "Терминал / ПК", "roles": ["codec", "pc", "kit"], "required": True},
{"id": "camera", "name": "Камера", "roles": ["camera"], "required": False},
{"id": "audio", "name": "Аудио", "roles": ["audio", "speaker"], "required": False},
{"id": "touch", "name": "Панель", "roles": ["touch"], "required": False},
{"id": "display", "name": "Дисплей", "roles": ["display"], "required": False},
{"id": "mount", "name": "Крепление", "roles": ["mount"], "required": False},
]}
def compose_room(payload):
seats = int(payload.get("seats") or 8)
roles = payload.get("roles") or {}
vendor = (payload.get("vendor") or "").strip().lower()
if vendor == "all":
vendor = ""
expected = {"terminal": ("codec", "pc", "kit"), "camera": ("camera",),
"audio": ("audio", "speaker"), "touch": ("touch",),
"display": ("display",), "mount": ("mount",)}
items, warnings, seen = [], [], set()
for rid, model in roles.items():
if not model:
continue
d = find_device(model)
if not d:
warnings.append({"level": "warning", "text": "не найдено: %s" % model})
continue
if d.get("domain") != "vcs":
warnings.append({"level": "blocker", "text": "%s не из VCS — нельзя в комнату" % _dev_name(d)})
continue
if rid in expected and d.get("role") not in expected[rid]:
warnings.append({"level": "warning", "text": "%s не подходит на роль %s" % (_dev_name(d), rid)})
k = _key(d)
if k in seen:
continue
seen.add(k)
items.append({"role": rid, "key": k, "name": _dev_name(d), "vendor": d.get("vendor"),
"solution_class": d.get("solution_class"), "class_label": class_label(d.get("solution_class")),
"role_label": role_label(rid), "form_factor": d.get("form_factor"),
"archived": is_archived(d), "purchasable": not is_archived(d)})
if is_archived(d):
warnings.append({"level": "warning",
"text": "%s снято с продажи — в проект можно, купить нельзя" % _dev_name(d)})
terminal = next((x for x in items if x["role"] == "terminal"), None)
if not terminal:
warnings.append({"level": "blocker", "text": "нет терминала/ПК"})
if not vendor and terminal:
vendor = terminal.get("vendor") or ""
vendors = sorted({x.get("vendor") for x in items if x.get("vendor")})
if vendor:
bad = [x for x in items if x.get("vendor") != vendor]
if bad:
warnings.append({"level": "blocker",
"text": "Вендор комнаты — %s. Нельзя смешивать: %s" % (
vendor, ", ".join("%s (%s)" % (x["name"], x["vendor"]) for x in bad))})
elif len(vendors) > 1:
warnings.append({"level": "blocker",
"text": "Разные вендоры в одной комнате: " + ", ".join(vendors)})
deployment = "native_vcs"
if terminal:
d = find_device(terminal["key"])
if d and (d.get("role") == "pc" or d.get("solution_class") == "vcs.byod.kit" or d.get("deployment") == "byod"):
deployment = "byod"
return {"seats": seats, "vendor": vendor, "deployment": deployment, "items": items,
"purchasable": all(x.get("purchasable", True) for x in items),
"warnings": warnings, "ready": not any(w["level"] == "blocker" for w in warnings),
"note": "Вендор — жёсткая граница: аксессуары и компоненты только этого вендора. Порты — в классическом конструкторе."}
def _ensure_dir():
os.makedirs(PROJECTS_DIR, exist_ok=True)
def list_projects():
_ensure_dir()
out = []
for f in sorted(os.listdir(PROJECTS_DIR), reverse=True):
if not f.endswith(".json"):
continue
try:
d = json.load(open(os.path.join(PROJECTS_DIR, f), encoding="utf-8"))
except Exception:
continue
out.append({"id": d.get("id"), "name": d.get("name"),
"host": d.get("host"), "items": len(d.get("items") or []),
"updated": d.get("updated")})
return {"projects": out[:50]}
def load_project(pid):
if not pid or not re.match(r"^[\w-]{1,32}$", pid):
return {"error": "bad id"}
p = os.path.join(PROJECTS_DIR, pid + ".json")
if not os.path.exists(p):
return {"error": "not found"}
return json.load(open(p, encoding="utf-8"))
def save_project(payload):
_ensure_dir()
pid = payload.get("id") or ("p" + str(int(__import__("time").time())))
if not re.match(r"^[\w-]{1,32}$", str(pid)):
return {"error": "bad id"}
payload["id"] = pid
payload["updated"] = __import__("time").strftime("%Y-%m-%dT%H:%M:%S")
if not payload.get("created"):
payload["created"] = payload["updated"]
with open(os.path.join(PROJECTS_DIR, str(pid) + ".json"), "w", encoding="utf-8") as f:
json.dump(payload, f, ensure_ascii=False, indent=2)
return {"ok": True, "id": pid}
class H(BaseHTTPRequestHandler):
def _out(self, obj, code=200, ctype="application/json; charset=utf-8"):
body = obj if isinstance(obj, bytes) else json.dumps(obj, ensure_ascii=False).encode()
self.send_response(code)
self.send_header("Content-Type", ctype)
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def log_message(self, *a):
pass
def do_GET(self):
u = urllib.parse.urlparse(self.path)
q = urllib.parse.parse_qs(u.query)
p = u.path
if p in ("/", "/studio"):
f = os.path.join(os.path.dirname(__file__), "studio.html")
if not os.path.exists(f):
f = os.path.join(os.path.dirname(__file__), "index.html")
return self._out(open(f, encoding="utf-8").read().encode(), ctype="text/html; charset=utf-8")
if p == "/classic":
f = os.path.join(os.path.dirname(__file__), "index.html")
return self._out(open(f, encoding="utf-8").read().encode(), ctype="text/html; charset=utf-8")
if p in ("/health", "/api/health"):
return self._out({"ok": True, "service": "combine-web", "devices": len(D.devices)})
if p == "/api/stats":
return self._out({"devices": len(D.devices),
"edges": sum(len(v) for v in D.edges.values()),
"hosts": len(D.hosts()),
"mounts": len(D.mounts.get("mounts") or []),
"attrs": len(D.attrs)})
if p == "/api/directions":
return self._out(DIRECTIONS)
if p == "/api/telephony":
return self._out(load_yaml("telephony.yaml"))
if p == "/api/analogs":
return self._out(analog_search(q.get("q", [""])[0], q.get("domain", ["vcs"])[0]))
if p == "/api/vendor-catalog":
v = (q.get("vendor", ["yealink"])[0] or "yealink").lower()
domain = (q.get("domain", ["vcs"])[0] or "vcs").lower()
data = D.cat if v == "yealink" else load_yaml("catalog-%s.yaml" % v)
out = dict(data)
if domain not in ("", "all"):
out["devices"] = [x for x in (data.get("devices") or []) if x.get("domain") == domain]
return self._out(out)
if p == "/api/search":
return self._out(search_catalog(q))
if p == "/api/product":
return self._out(product_info(q.get("key", [""])[0]))
if p == "/api/compare":
keys = [x for x in (q.get("keys", [""])[0] or "").split(",") if x]
return self._out(compare_devices(keys))
if p == "/api/archive":
return self._out({"items": archived_items()})
if p == "/api/room-roles":
return self._out(room_roles())
if p == "/api/hosts":
return self._out(D.hosts())
if p == "/api/requirements":
return self._out(D.requirements())
if p == "/api/device":
k = norm(q.get("key", [""])[0])
if k not in D.devices:
return self._out({"error": "not found"}, 404)
return self._out(D.device_row(k))
if p == "/api/groups":
return self._out(D.groups(q.get("host", [""])[0],
[x for x in q.get("need", []) if x]))
if p == "/api/positions":
return self._out(D.positions(q.get("host", [""])[0],
[x for x in q.get("need", []) if x]))
if p == "/api/projects":
return self._out(list_projects())
if p == "/api/project":
pid = q.get("id", [""])[0]
return self._out(load_project(pid))
if p == "/api/save":
try:
length = int(self.headers.get("Content-Length") or 0)
payload = json.loads(self.rfile.read(length).decode() or "{}")
except Exception as e:
return self._out({"error": "bad json: %s" % e}, 400)
return self._out(save_project(payload))
if p == "/api/gaps":
return self._out({"missing": D.extra.get("missing") or []})
if p == "/api/kits":
return self._out(D.kits)
if p == "/api/check":
return self._out(D.check_pair(q.get("host", [""])[0],
q.get("device", [""])[0]))
if p == "/api/matrix":
return self._out(D.matrix())
if p == "/api/ports":
return self._out(D.ports_table())
if p == "/api/links":
items = [x for x in q.get("item", []) if x]
return self._out(D.link_plan(q.get("host", [""])[0], items))
if p == "/api/capacity":
items = []
for raw in q.get("item", []):
if ":" in raw:
m, n = raw.rsplit(":", 1)
try:
items.append([m, int(n)])
except ValueError:
pass
return self._out(D.capacity(q.get("host", [""])[0], items))
if p == "/api/vendors":
return self._out(VENDORS)
if p == "/api/options":
return self._out(D.options(q.get("host", [""])[0],
[x for x in q.get("need", []) if x]))
if p == "/api/bom":
need = [x for x in q.get("need", []) if x]
add = [x for x in q.get("add", []) if x]
return self._out(D.bom(q.get("host", [""])[0],
int(q.get("seats", ["8"])[0]), need, add))
return self._out({"error": "not found"}, 404)
def do_POST(self):
u = urllib.parse.urlparse(self.path)
if u.path == "/api/archive":
try:
n = int(self.headers.get("Content-Length") or 0)
payload = json.loads(self.rfile.read(n).decode() or "{}")
except Exception as e:
return self._out({"error": "bad json: %s" % e}, 400)
d = find_device(payload.get("key") or payload.get("name") or "")
if not d:
return self._out({"error": "not_found"}, 404)
return self._out(set_archive(d, payload.get("action") or "archive", payload.get("reason") or ""))
if u.path == "/api/room":
try:
n = int(self.headers.get("Content-Length") or 0)
payload = json.loads(self.rfile.read(n).decode() or "{}")
except Exception as e:
return self._out({"error": "bad json: %s" % e}, 400)
return self._out(compose_room(payload))
if u.path == "/api/save":
try:
n = int(self.headers.get("Content-Length") or 0)
payload = json.loads(self.rfile.read(n).decode() or "{}")
except Exception as e:
return self._out({"error": "bad json: %s" % e}, 400)
return self._out(save_project(payload))
return self._out({"error": "not found"}, 404)
class S(socketserver.ThreadingTCPServer):
allow_reuse_address = True
if __name__ == "__main__":
import sys
port = int(sys.argv[1]) if len(sys.argv) > 1 else 8095
print("combine v2 on :%d" % port, flush=True)
S(("0.0.0.0", port), H).serve_forever()