angel/site_aegisone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v1.7.0: refactor max_bot to flat structure, add VCF+UserModel+NLP history context, portal pages and proxy fixes

Browse Source 
- Refactored max_bot from nested packages to flat module structure
- Q2: Extended BotUser model (patronymic, email, org, address, vcf_raw, contact_hash, phone_verified, email_verified, last_interaction, total_conversations, total_tickets)
- Q2: VCF parser (FN, N, TEL, EMAIL, ORG, ADR), upsert on re-contact, NLP history context (_get_user_history_context -> YandexGPT)
- Q1: Broadcast preview modal with 10s confirmation timer
- Q3: CSS var(--white)->var(--bg-card), var(--text)->var(--text-primary)
- Q4: bot_settings showNotification(), editable max_bot_id
- Q5: Webhook secret passthrough via X-Max-Bot-Api-Secret
- Masking sensitive keys, dialog_cleared handler, migrate via _add_column_if_not_exists()
- Rate limit (asyncio.sleep 0.5 per 10), dead code removed, conv.intent context in contact.py
- Portal pages: bot_consent, bot_kb (edit), bot_settings, bot_test, bot_tickets, portal_settings
- Tests: 21/21 passing, added test_yandex_gpt.py, test_email_sender.py
- Deploy: deploy_full.sh, schema.sql, seed_knowledge_base.sql
This commit is contained in:
Sergey Korotonozhko
2026-05-29 02:30:30 +03:00
parent 493e0b37a1
commit 72b6879f4b
234 changed files with 26768 additions and 6240 deletions
Download Patch File Download Diff File Expand all files Collapse all files
max_bot/.env.example
-5
View File
@@ -1,5 +0,0 @@
DATABASE_URL=postgresql+asyncpg://aegisone:aegisone_pass@localhost:5432/aegisone
APP_ENV=production
LOG_LEVEL=info
WEBHOOK_SECRET=change-me-to-random-secret
WEBHOOK_PATH=/webhook
max_bot/CHANGELOG.md
+22 -23
View File
@@ -1,24 +1,23 @@
# Changelog
# Changelog — AegisOne MAX Bot
## v1.6.0 (2026-05-24)
### Bug Fixes
- **Features**: Исправлен feature_key `auto_notifications` → `notifications` (фича теперь отображается в меню)
- **Features**: Исправлен feature_key `commercial_offer` → `commercial` (унификация с кодом)
- **Заявки**: Исправлена критическая ошибка — `db.flush()` вместо `db.commit()` во всех write-эндпоинтах (данные не сохранялись)
- **Заявки**: Кнопка "Создать" теперь корректно сохраняет заявку в БД
- **Тест-прогон**: Исправлено — тестовые сообщения бота теперь содержат `role: "bot"`, отображаются в результате
- **Router proxy**: Добавлен `try/except` во все прокси-эндпоинты (500 → 503 с сообщением)
- **Mojibake**: Исправлена кириллица на всех страницах бота (добавлен `page_name` в `ctx()`)
- **Broadcast**: Добавлена колонка `recipient_ids` в таблицу `bot_broadcasts`
### New Features
- **Рассылки**: Добавлена отдельная страница **Рассылки** в меню Чат-бот Max (роут + шаблон + sidebar)
- **Категории**: Полностью обновлены категории обращений (7 новых с иконками и описаниями)
- **Permissions**: Добавлены `bot_*` права для роли `engineer` в `role_menu_permissions`
- **Deploy**: Улучшен `max_bot_deploy.sh` — теперь использует `docker exec -i` pipe вместо `docker cp`
- **Deploy**: Главный `deploy.sh` теперь включает развёртывание max_bot
### Infrastructure
- **Database**: `get_db()` теперь корректно вызывает `session.commit()` при выходе (аналогично py_service)
- **Permission config**: Добавлены все пропущенные маршруты в `ROUTE_PERMISSIONS`
## 1.7.0 (29.05.2026)
### Новые функции
- **Рефакторинг архитектуры:** плоская структура модулей (models.py, yandex_gpt.py, keyboards.py, email_sender.py, config_reader.py) вместо вложенных пакетов
- **VCF + User Model (Q2):**
- BotUser расширен: patronymic, email, organization, address, vcf_raw, contact_hash, phone_verified, email_verified
- VCF-парсер: FN, N, TEL, EMAIL, ORG, ADR — все поля сохраняются
- Upsert пользователя при повторном контакте (greeting.py)
- total_conversations инкремент, last_interaction обновление
- handle_contact_share сохраняет все VCF-поля (handoff.py)
- total_tickets инкремент в _finalize_ticket (inquiry.py)
- **NLP history context:** _get_user_history_context() — последние 10 сообщений + открытые заявки → YandexGPT
- **Broadcast с превью и таймером (Q1):** модалка подтверждения с таймером 10 секунд
- **CSS-переменные (Q3):** var(--white)→var(--bg-card), var(--text)→var(--text-primary)
- **bot_settings (Q4):** showNotification(), max_bot_id редактируемый
- **Webhook secret (Q5):** проброс X-Max-Bot-Api-Secret через прокси
- Маскировка sensitive API-ключей в /api/bot/settings
- dialog_cleared handler — сброс состояния диалога
- Миграции через _add_column_if_not_exists() — новые колонки BotUser
- Rate limit в broadcast: asyncio.sleep(0.5) после каждых 10
- Уточнение сообщения (contact.py) с учётом conv.intent
- Тесты: test_yandex_gpt.py, test_email_sender.py
max_bot/Dockerfile
+4 -6
View File
@@ -2,15 +2,13 @@ FROM python:3.12-slim
WORKDIR /app
# sendmail not available on trixie/slim; email sender falls back to debug log
COPY requirements.txt .
RUN pip install --no-cache-dir --only-binary :all: -r requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
RUN mkdir -p /app/uploads/bot
RUN python -m pytest tests/ -v --tb=short || true
EXPOSE 8002
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8002", "--workers", "2"]
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8002"]
max_bot/app/__pycache__/__init__.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/bot_engine.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/bot_engine.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/config.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/config.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/conversation.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/conversation.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/database.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/database.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/file_storage.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/fsm.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/fsm.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/main.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/main.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/max_api.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/max_api.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/settings_cache.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/settings_cache.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/text_renderer.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/__pycache__/text_renderer.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/bot_engine.py
-268
View File
@@ -1,268 +0,0 @@
import json
import logging
from typing import Optional
from app.max_api import MaxAPIClient
from app.settings_cache import SettingsCache
from app.fsm import BotState, FSM
from app.conversation import (
get_or_create_user, add_message,
get_template_rendered, find_in_knowledge_base
)
from app.utils.emotion_detector import detect_emotion
logger = logging.getLogger(__name__)
async def handle_update(bot, update: dict, db, max_api: MaxAPIClient):
update_type = update.get("update_type", "")
user_data = update.get("user", {})
max_user_id = user_data.get("user_id")
if not max_user_id:
return
await SettingsCache.refresh(db)
if update_type == "bot_started":
await _handle_bot_started(bot, user_data, db, max_api)
return
if update_type == "message_created":
await _handle_message_created(bot, user_data, update, db, max_api)
return
if update_type == "message_callback":
await _handle_callback(bot, user_data, update, db, max_api)
return
async def _handle_bot_started(bot, user_data, db, max_api):
await SettingsCache.refresh(db)
if not SettingsCache.is_work_hours():
from app.handlers.out_of_hours import handle_out_of_hours
await handle_out_of_hours(bot, user_data, db, max_api)
return
from app.handlers.greeting import handle_start
await handle_start(bot, user_data, db, max_api)
async def _handle_message_created(bot, user_data, update, db, max_api):
max_user_id = user_data["user_id"]
message = update.get("message", {})
body = message.get("body", {})
text = body.get("text", "").strip()
attachments = body.get("attachments", [])
user_data["text"] = text
user_data["ip"] = update.get("ip", "")
has_attachment = len(attachments) > 0
attachment_type = ""
attachment_path = ""
if has_attachment:
att = attachments[0]
attachment_type = att.get("type", "")
if attachment_type == "contact":
payload = att.get("payload", {})
vcf_info = payload.get("vcf_info", "")
import re
phone_match = re.search(r'TEL[^:]*:(\+?\d+)', vcf_info)
name_match = re.search(r'FN:(.+)', vcf_info)
if phone_match:
user_data["phone"] = phone_match.group(1)
if name_match:
user_data["first_name"] = name_match.group(1).strip()
await _handle_contact_shared(bot, user_data, db, max_api)
return
attachment_path = att.get("url", "")
user_data["has_attachment"] = has_attachment
user_data["attachment_type"] = attachment_type
user_data["attachment_path"] = attachment_path
state = FSM.get_state(max_user_id)
if state == BotState.IDLE:
if text.lower() in ("/start", "/help"):
if not SettingsCache.is_work_hours():
from app.handlers.out_of_hours import handle_out_of_hours
await handle_out_of_hours(bot, user_data, db, max_api)
return
from app.handlers.greeting import handle_start
await handle_start(bot, user_data, db, max_api)
return
if not SettingsCache.is_work_hours():
from app.handlers.out_of_hours import handle_out_of_hours
await handle_out_of_hours(bot, user_data, db, max_api)
return
emotion = await detect_emotion(text)
if emotion == "negative":
tmpl = await get_template_rendered(db, "emotion_escalate")
await max_api.send_message(max_user_id, tmpl)
from app.handlers.handoff import handle_handoff_request
await handle_handoff_request(bot, user_data, db, max_api)
from app.max_notifications import notify_handoff_escalation
user = await get_or_create_user(db, max_user_id)
conv = None
try:
from app.conversation import get_open_conversation
conv = await get_open_conversation(db, user.id)
except Exception:
pass
await notify_handoff_escalation(
db, max_api, user,
conv.id if conv else 0, text
)
return
kb_entry = await find_in_knowledge_base(db, text)
if kb_entry:
await max_api.send_message(max_user_id, kb_entry.answer, format="markdown")
return
from app.conversation import get_or_create_user
user = await get_or_create_user(db, max_user_id)
if not user.consent_given:
from app.handlers.greeting import handle_start
await handle_start(bot, user_data, db, max_api)
return
from app.handlers.main_menu import handle_main_menu
user_data["payload"] = "new_inquiry"
await handle_main_menu(bot, user_data, db, max_api)
return
if state == BotState.NAME_REQUEST:
if not text:
await max_api.send_message(max_user_id, "Как к вам обращаться?")
return
user = await get_or_create_user(db, max_user_id)
user.first_name = text
await db.flush()
from app.handlers.consent import handle_consent_request
await handle_consent_request(bot, user_data, db, max_api)
return
if state == BotState.CONSENT_REQUEST:
if text.lower() in ("да", "даю согласие", "согласен", "yes"):
from app.handlers.consent import handle_consent_given
await handle_consent_given(bot, user_data, db, max_api)
elif text.lower() in ("нет", "не даю", "не согласен", "no"):
from app.handlers.consent import handle_consent_refused
await handle_consent_refused(bot, user_data, db, max_api)
else:
from app.handlers.main_menu import handle_main_menu
user_data["payload"] = text.lower()
await handle_main_menu(bot, user_data, db, max_api)
return
if state == BotState.CONTACT_REQUEST:
from app.handlers.contact import handle_contact_text
await handle_contact_text(bot, user_data, db, max_api)
return
if state == BotState.INQUIRY_REQUEST:
from app.handlers.inquiry import handle_inquiry
await handle_inquiry(bot, user_data, db, max_api)
return
if state == BotState.CATEGORY_SELECT:
from app.handlers.inquiry import handle_inquiry
await handle_inquiry(bot, user_data, db, max_api)
return
if state == BotState.OUT_OF_HOURS:
from app.handlers.out_of_hours import handle_out_of_hours_callback
await handle_out_of_hours_callback(bot, user_data, db, max_api, text.lower())
return
_feature_handlers = {
BotState.FEATURE_RISK_SCORE: ("app.handlers.features.risk_score", "handle_risk_score"),
BotState.FEATURE_SLA_STATUS: ("app.handlers.features.sla_status", "handle_sla_status"),
BotState.FEATURE_PHOTO_REPORT: ("app.handlers.features.photo_report", "handle_photo_report"),
BotState.FEATURE_APPOINTMENT: ("app.handlers.features.appointment", "handle_appointment"),
BotState.FEATURE_COMMERCIAL: ("app.handlers.features.commercial", "handle_commercial"),
BotState.FEATURE_MY_OBJECTS: ("app.handlers.features.my_objects", "handle_my_objects"),
BotState.FEATURE_REMINDERS: ("app.handlers.features.reminders", "handle_reminders"),
BotState.FEATURE_QUALITY_RATE: ("app.handlers.features.quality_rate", "handle_quality_rate"),
BotState.FEATURE_NOTIFICATIONS: ("app.handlers.features.notifications", "handle_notifications"),
BotState.FEATURE_BROADCAST: ("app.handlers.features.broadcasts", "handle_broadcast_send"),
BotState.SLA_TICKET_CREATE: ("app.handlers.features.sla_ticket", "handle_sla_ticket"),
}
if state in _feature_handlers:
mod_path, func_name = _feature_handlers[state]
import importlib
mod = importlib.import_module(mod_path)
func = getattr(mod, func_name)
await func(bot, user_data, db, max_api)
return
if state == BotState.KB_SEARCH:
kb_entry = await find_in_knowledge_base(db, text)
if kb_entry:
await max_api.send_message(max_user_id, kb_entry.answer, format="markdown")
FSM.transition(max_user_id, "found")
else:
await max_api.send_message(max_user_id,
"К сожалению, не нашёл ответа на ваш вопрос. "
"Опишите подробнее или нажмите «Оставить заявку» для создания обращения.")
FSM.transition(max_user_id, "not_found")
from app.keyboards.inline import build_main_menu_buttons
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
return
from app.handlers.main_menu import handle_main_menu
user_data["payload"] = text.lower()
await handle_main_menu(bot, user_data, db, max_api)
async def _handle_callback(bot, user_data, update, db, max_api):
max_user_id = user_data["user_id"]
callback = update.get("callback", {})
payload = callback.get("payload", "")
callback_id = callback.get("id", "")
user_data["payload"] = payload
if payload == "cancel":
FSM.reset(max_user_id)
from app.keyboards.inline import build_main_menu_buttons
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
await max_api.answer_callback(callback_id)
return
if payload.startswith("rate_"):
from app.handlers.features.quality_rate import handle_quality_rate
await handle_quality_rate(bot, user_data, db, max_api)
await max_api.answer_callback(callback_id)
return
from app.handlers.main_menu import handle_main_menu
await handle_main_menu(bot, user_data, db, max_api)
await max_api.answer_callback(callback_id)
async def _handle_contact_shared(bot, user_data, db, max_api):
max_user_id = user_data["user_id"]
user = await get_or_create_user(db, max_user_id)
if user_data.get("phone"):
user.phone = user_data["phone"]
if user_data.get("first_name"):
user.first_name = user_data["first_name"]
await db.flush()
state = FSM.get_state(max_user_id)
if state == BotState.CONTACT_REQUEST:
from app.handlers.contact import handle_contact_provided
await handle_contact_provided(bot, user_data, db, max_api)
else:
from app.handlers.main_menu import handle_main_menu
user_data["payload"] = "new_inquiry"
await handle_main_menu(bot, user_data, db, max_api)
max_bot/app/config.py
+15 -17
View File
@@ -1,24 +1,22 @@
import os
from pathlib import Path
from typing import List, Optional
from pydantic_settings import BaseSettings
from functools import lru_cache
class Settings(BaseSettings):
DATABASE_URL: str = "postgresql+asyncpg://aegisone:aegisone_pass@localhost:5432/aegisone"
APP_ENV: str = "development"
LOG_LEVEL: str = "debug"
WEBHOOK_PATH: str = "/webhook"
WEBHOOK_SECRET: str = "change-me-to-random-secret"
UPLOADS_DIR: str = str(Path(__file__).parent.parent / "uploads" / "bot")
YANDEX_DISK_TOKEN: str = ""
YANDEX_DISK_ROOT: str = "/AegisOne_Service"
database_url: str = "postgresql+asyncpg://aegisone:aegisone_pass@localhost:5432/aegisone"
max_token: str = "f9LHodD0cOKkk03DYXj906MdIeRs3HdDo0BC5H2fLMVCMz3PA_Vx4aJqt2l2qPLM5zd5EQ1Zh6APxzpw2UYE"
max_api_base: str = "https://platform-api.max.ru"
webhook_url: str = "https://max.aegisone.ru/webhook"
webhook_secret: str = "aegisone_bot_secret_2026"
config_php_path: str = "/var/www/html/config.php"
php_sendmail_path: str = "/usr/sbin/sendmail"
default_assistant_name: str = "София"
default_assistant_role: str = "Представитель компании AegisOne Engineering, помогающий клиентам с запросами по безопасности"
default_support_email: str = "zakaz@aegisone.ru"
default_email_subject: str = "Обращение через Виртуального помощника AegisOne Engineering"
update_types: List[str] = ["bot_started", "message_created", "message_callback"]
class Config:
env_file = ".env"
env_file_encoding = "utf-8"
model_config = {"env_prefix": "BOT_", "env_file": ".env"}
@lru_cache()
def get_settings() -> Settings:
return Settings()
settings = Settings()
max_bot/app/config_reader.py
+61
View File
@@ -0,0 +1,61 @@
from __future__ import annotations
import re
import os
from typing import Optional, List, Tuple
from app.config import settings
class ConfigReader:
def __init__(self):
self._cache = {}
self._loaded = False
def load(self, path: Optional[str] = None) -> dict:
filepath = path or settings.config_php_path
if not os.path.isfile(filepath):
return self._fallback()
with open(filepath, "r", encoding="utf-8") as f:
content = f.read()
constants = {}
pattern = re.compile(r"define\(\s*'(\w+)'\s*,\s*'([^']*)'\s*\)")
for match in pattern.finditer(content):
constants[match.group(1)] = match.group(2)
self._cache = constants
self._loaded = True
return constants
def _fallback(self) -> dict:
self._cache = {
"PHONE_MAIN": "+7 (861) 203-33-30",
"PHONE_MAIN_LINK": "+78612033330",
"PHONE_SECOND": "+7 (995) 203-33-30",
"PHONE_SECOND_LINK": "+79952033330",
"SITE_MAIL": "mail@aegisone.ru",
"SITE_MAIL_FROM": "no-reply@aegisone.ru",
"SITE_MAIL_TO": "mail@aegisone.ru",
}
self._loaded = True
return self._cache
def get(self, key: str, default: str = "") -> str:
if not self._loaded:
self.load()
return self._cache.get(key, default)
def get_phones(self) -> List[Tuple[str, str]]:
return [
(self.get("PHONE_MAIN"), self.get("PHONE_MAIN_LINK")),
(self.get("PHONE_SECOND"), self.get("PHONE_SECOND_LINK")),
]
def get_site_mail(self) -> str:
return self.get("SITE_MAIL", "mail@aegisone.ru")
def get_mail_from(self) -> str:
return self.get("SITE_MAIL_FROM", "no-reply@aegisone.ru")
config_reader = ConfigReader()
max_bot/app/conversation.py
-142
View File
@@ -1,142 +0,0 @@
from datetime import datetime
from typing import Optional
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.models import (
BotUser, BotConversation, BotMessage, BotConsentLog,
BotCategory, BotSetting, BotFeature, BotResponseTemplate, BotKnowledgeBase
)
from app.settings_cache import SettingsCache
from app.text_renderer import render_template
async def get_or_create_user(db: AsyncSession, max_user_id: int,
first_name: str = "", last_name: str = "",
username: str = "") -> BotUser:
result = await db.execute(select(BotUser).where(BotUser.max_user_id == max_user_id))
user = result.scalar_one_or_none()
if user:
user.last_active_at = datetime.now()
if first_name and not user.first_name:
user.first_name = first_name
if last_name and not user.last_name:
user.last_name = last_name
if username and not user.username:
user.username = username
return user
user = BotUser(
max_user_id=max_user_id, first_name=first_name,
last_name=last_name, username=username
)
db.add(user)
await db.flush()
return user
async def get_open_conversation(db: AsyncSession, user_id: int) -> Optional[BotConversation]:
result = await db.execute(
select(BotConversation).where(
BotConversation.user_id == user_id,
BotConversation.status == "open"
).order_by(BotConversation.created_at.desc()).limit(1)
)
return result.scalar_one_or_none()
async def create_conversation(db: AsyncSession, user_id: int) -> BotConversation:
conv = BotConversation(user_id=user_id, status="open")
db.add(conv)
await db.flush()
return conv
async def add_message(db: AsyncSession, conversation_id: int, direction: str,
text: str = "", has_attachment: bool = False,
attachment_type: str = "", attachment_path: str = "",
max_message_id: int = None) -> BotMessage:
msg = BotMessage(
conversation_id=conversation_id, direction=direction, text=text,
has_attachment=has_attachment, attachment_type=attachment_type,
attachment_path=attachment_path, max_message_id=max_message_id
)
db.add(msg)
await db.flush()
return msg
async def log_consent(db: AsyncSession, user_id: int, action: str, method: str = "", ip: str = ""):
log = BotConsentLog(user_id=user_id, action=action, method=method, ip_address=ip)
db.add(log)
await db.flush()
async def get_template(db: AsyncSession, key: str) -> str:
await SettingsCache.refresh(db)
return SettingsCache.get_template(key)
async def get_template_rendered(db: AsyncSession, key: str, **kwargs) -> str:
tmpl = await get_template(db, key)
return render_template(tmpl, **kwargs)
async def find_in_knowledge_base(db: AsyncSession, query: str) -> Optional[BotKnowledgeBase]:
query_lower = query.lower()
result = await db.execute(
select(BotKnowledgeBase).where(BotKnowledgeBase.active == True)
)
entries = result.scalars().all()
for entry in entries:
if query_lower in entry.question.lower():
return entry
keywords = entry.keywords or []
for kw in keywords:
if kw.lower() in query_lower:
return entry
return None
async def auto_categorize_text(db: AsyncSession, text: str) -> Optional[BotCategory]:
text_lower = text.lower()
categories = SettingsCache.get_categories()
best_match = None
best_score = 0
for cat in categories:
keywords = cat.keywords or []
score = sum(1 for kw in keywords if kw.lower() in text_lower)
if score > best_score:
best_score = score
best_match = cat
return best_match if best_score > 0 else None
async def close_conversation(db: AsyncSession, conversation_id: int):
conv = await db.execute(
select(BotConversation).where(BotConversation.id == conversation_id)
)
conv = conv.scalar_one_or_none()
if conv:
conv.status = "closed"
conv.closed_at = datetime.now()
await db.flush()
async def update_conversation_status(db: AsyncSession, conversation_id: int, status: str):
conv = await db.execute(
select(BotConversation).where(BotConversation.id == conversation_id)
)
conv = conv.scalar_one_or_none()
if conv:
conv.status = status
await db.flush()
async def detect_negative_emotion(text: str) -> bool:
negative_words = [
"ужасно", "плохо", "долго", "кошмар", "отвратительно", "невыносимо",
"бесполезно", "халтура", "безобразие", "позор", "разочарован", "злюсь",
"раздражён", "недоволен", "жалоба", "претензия", "скандал", "суд",
"верните деньги", "мошенники", "обман"
]
text_lower = text.lower()
return any(word in text_lower for word in negative_words)
max_bot/app/database.py
+6 -15
View File
@@ -1,22 +1,13 @@
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
from app.config import get_settings
settings = get_settings()
engine_kwargs = {"echo": False}
if "postgresql" in settings.DATABASE_URL:
engine_kwargs["pool_size"] = 10
engine_kwargs["max_overflow"] = 20
engine = create_async_engine(settings.DATABASE_URL, **engine_kwargs)
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
from app.config import settings
engine = create_async_engine(settings.database_url, pool_size=10, max_overflow=20)
async_session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
async def get_db():
async def get_db() -> AsyncSession:
async with async_session() as session:
try:
yield session
await session.commit()
except Exception:
await session.rollback()
raise
finally:
await session.close()
max_bot/app/email_sender.py
+80
View File
@@ -0,0 +1,80 @@
import subprocess
import os
from typing import Optional
from app.config import settings
from app.config_reader import config_reader
class EmailSender:
def __init__(self):
self.sendmail_path = settings.php_sendmail_path
def send(
self,
to: str,
subject: str,
body: str,
from_addr: Optional[str] = None,
) -> bool:
if from_addr is None:
from_addr = config_reader.get_mail_from()
message = self._build_message(to, subject, body, from_addr)
try:
if os.name == "nt":
return self._send_debug(to, subject, body, from_addr)
proc = subprocess.run(
[self.sendmail_path, "-t", "-i"],
input=message,
capture_output=True,
text=True,
timeout=30,
)
return proc.returncode == 0
except Exception:
return self._send_debug(to, subject, body, from_addr)
def _send_debug(self, to: str, subject: str, body: str, from_addr: str) -> bool:
log_dir = os.path.join(os.path.dirname(__file__), "..", "logs")
os.makedirs(log_dir, exist_ok=True)
log_path = os.path.join(log_dir, "emails.log")
with open(log_path, "a", encoding="utf-8") as f:
f.write(f"=== EMAIL ===\nFrom: {from_addr}\nTo: {to}\nSubject: {subject}\n\n{body}\n\n")
return True
def _build_message(self, to: str, subject: str, body: str, from_addr: str) -> str:
lines = [
f"From: {from_addr}",
f"To: {to}",
f"Subject: {subject}",
"MIME-Version: 1.0",
"Content-Type: text/plain; charset=UTF-8",
"Content-Transfer-Encoding: 8bit",
"",
body,
]
return "\r\n".join(lines)
def send_ticket_escalation(
self,
to: str,
subject: str,
user_info: str,
contact: str,
inquiry: str,
history: str,
) -> bool:
body = (
f"Поступило новое обращение через Виртуального помощника AegisOne Engineering\n\n"
f"--- Данные клиента ---\n{user_info}\n"
f"--- Контактные данные ---\n{contact}\n"
f"--- Суть обращения ---\n{inquiry}\n"
f"--- История переписки ---\n{history}\n"
f"---\n"
f"Дата и время: {__import__('datetime').datetime.now().strftime('%d.%m.%Y %H:%M')}"
)
return self.send(to, subject, body)
email_sender = EmailSender()
max_bot/app/file_storage.py
-77
View File
@@ -1,77 +0,0 @@
import uuid
import json
import logging
from pathlib import Path
from datetime import datetime
ALLOWED_EXTENSIONS = {".pdf", ".docx", ".xlsx", ".txt", ".jpg", ".jpeg", ".png", ".gif"}
logger = logging.getLogger(__name__)
class FileStorage:
def __init__(self, base_dir: str = "uploads/bot"):
self.base_dir = Path(base_dir)
self.base_dir.mkdir(parents=True, exist_ok=True)
async def save_file(self, file_bytes: bytes, filename: str, conversation_id: int,
file_type: str = "document", db=None) -> str:
ext = Path(filename).suffix.lower()
if ext not in ALLOWED_EXTENSIONS:
ext = ".bin"
safe_name = f"{uuid.uuid4().hex}{ext}"
conv_dir = self.base_dir / str(conversation_id)
conv_dir.mkdir(parents=True, exist_ok=True)
file_path = conv_dir / safe_name
file_path.write_bytes(file_bytes)
meta = {
"type": "conversation",
"id": conversation_id,
"filename": filename,
"file_type": file_type,
"timestamp": datetime.now().isoformat(),
"local_path": str(file_path),
}
meta_path = conv_dir / "metadata.json"
if meta_path.exists():
try:
existing = json.loads(meta_path.read_text())
if "attachments" not in existing:
existing["attachments"] = []
existing["attachments"].append({"filename": safe_name, "original": filename})
meta_path.write_text(json.dumps(existing, ensure_ascii=False, indent=2))
except Exception:
meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2))
else:
meta["attachments"] = [{"filename": safe_name, "original": filename}]
meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2))
# Queue for Yandex Disk sync (service portal picks this up)
if db is not None:
try:
from app.models.models import FileSyncQueue
remote_path = f"bot/conversations/{conversation_id}/{safe_name}"
queue = FileSyncQueue(
local_path=str(file_path),
remote_path=remote_path,
entity_type="conversation",
entity_id=conversation_id,
status="pending",
)
db.add(queue)
await db.flush()
except Exception as e:
logger.error(f"Failed to queue file sync: {e}")
return str(file_path)
def get_file_type(self, filename: str) -> str:
ext = Path(filename).suffix.lower()
if ext in {".jpg", ".jpeg", ".png", ".gif"}:
return "image"
if ext in {".pdf", ".docx", ".xlsx", ".txt"}:
return "document"
return "other"
storage = FileStorage()
max_bot/app/fsm.py
-209
View File
@@ -1,209 +0,0 @@
from enum import Enum
class BotState(str, Enum):
IDLE = "idle"
NAME_REQUEST = "name_request"
CONSENT_REQUEST = "consent_request"
CONTACT_REQUEST = "contact_request"
INQUIRY_REQUEST = "inquiry_request"
CATEGORY_SELECT = "category_select"
CONFIRMATION = "confirmation"
HANDOFF_REQUEST = "handoff_request"
FEATURE_RISK_SCORE = "feature_risk_score"
FEATURE_SLA_STATUS = "feature_sla_status"
FEATURE_PHOTO_REPORT = "feature_photo_report"
FEATURE_APPOINTMENT = "feature_appointment"
FEATURE_QUALITY_RATE = "feature_quality_rate"
FEATURE_COMMERCIAL = "feature_commercial"
FEATURE_MY_OBJECTS = "feature_my_objects"
FEATURE_REMINDERS = "feature_reminders"
SLA_TICKET_CREATE = "sla_ticket_create"
KB_SEARCH = "kb_search"
FEATURE_NOTIFICATIONS = "feature_notifications"
FEATURE_BROADCAST = "feature_broadcast"
AWAITING_RATING = "awaiting_rating"
WAITING_1C_RESPONSE = "waiting_1c_response"
MAIN_MENU = "main_menu"
HANDOFF_CONFIRMATION = "handoff_confirmation"
OUT_OF_HOURS = "out_of_hours"
STATE_TRANSITIONS = {
BotState.IDLE: {
"start": BotState.NAME_REQUEST,
"new_inquiry": BotState.NAME_REQUEST,
"handoff": BotState.HANDOFF_REQUEST,
"main_menu": BotState.MAIN_MENU,
"cancel": BotState.IDLE,
},
BotState.NAME_REQUEST: {
"name_provided": BotState.CONSENT_REQUEST,
"cancel": BotState.IDLE,
},
BotState.CONSENT_REQUEST: {
"consent_given": BotState.CONTACT_REQUEST,
"consent_refused": BotState.IDLE,
"cancel": BotState.IDLE,
},
BotState.CONTACT_REQUEST: {
"contact_provided": BotState.INQUIRY_REQUEST,
"cancel": BotState.IDLE,
},
BotState.INQUIRY_REQUEST: {
"inquiry_provided": BotState.CATEGORY_SELECT,
"cancel": BotState.IDLE,
},
BotState.CATEGORY_SELECT: {
"category_selected": BotState.CONFIRMATION,
"cancel": BotState.IDLE,
},
BotState.CONFIRMATION: {
"done": BotState.IDLE,
"edit_name": BotState.NAME_REQUEST,
"edit_contact": BotState.CONTACT_REQUEST,
"edit_inquiry": BotState.INQUIRY_REQUEST,
},
BotState.HANDOFF_REQUEST: {
"confirmed": BotState.HANDOFF_CONFIRMATION,
"cancel": BotState.MAIN_MENU,
},
BotState.HANDOFF_CONFIRMATION: {
"done": BotState.IDLE,
"cancel": BotState.MAIN_MENU,
},
BotState.OUT_OF_HOURS: {
"leave_message": BotState.INQUIRY_REQUEST,
"callback": BotState.NAME_REQUEST,
"cancel": BotState.IDLE,
"main_menu": BotState.MAIN_MENU,
},
BotState.MAIN_MENU: {
"new_inquiry": BotState.NAME_REQUEST,
"feature_risk_score": BotState.FEATURE_RISK_SCORE,
"feature_sla_status": BotState.FEATURE_SLA_STATUS,
"feature_photo_report": BotState.FEATURE_PHOTO_REPORT,
"feature_appointment": BotState.FEATURE_APPOINTMENT,
"feature_quality_rate": BotState.FEATURE_QUALITY_RATE,
"feature_commercial": BotState.FEATURE_COMMERCIAL,
"feature_my_objects": BotState.FEATURE_MY_OBJECTS,
"feature_reminders": BotState.FEATURE_REMINDERS,
"feature_notifications": BotState.FEATURE_NOTIFICATIONS,
"feature_broadcast": BotState.FEATURE_BROADCAST,
"sla_ticket_create": BotState.SLA_TICKET_CREATE,
"handoff": BotState.HANDOFF_REQUEST,
"kb_search": BotState.KB_SEARCH,
"cancel": BotState.IDLE,
},
BotState.FEATURE_RISK_SCORE: {
"done": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.FEATURE_SLA_STATUS: {
"done": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.FEATURE_PHOTO_REPORT: {
"done": BotState.MAIN_MENU,
"photo_provided": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.FEATURE_APPOINTMENT: {
"done": BotState.MAIN_MENU,
"date_provided": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.FEATURE_QUALITY_RATE: {
"done": BotState.MAIN_MENU,
"rating_provided": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.FEATURE_COMMERCIAL: {
"done": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.FEATURE_MY_OBJECTS: {
"done": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.FEATURE_REMINDERS: {
"done": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.FEATURE_NOTIFICATIONS: {
"done": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.FEATURE_BROADCAST: {
"done": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.SLA_TICKET_CREATE: {
"done": BotState.MAIN_MENU,
"cancel": BotState.MAIN_MENU,
},
BotState.KB_SEARCH: {
"found": BotState.MAIN_MENU,
"not_found": BotState.INQUIRY_REQUEST,
"cancel": BotState.MAIN_MENU,
},
BotState.AWAITING_RATING: {
"rating_provided": BotState.IDLE,
"skip": BotState.IDLE,
},
BotState.WAITING_1C_RESPONSE: {
"received": BotState.MAIN_MENU,
"timeout": BotState.IDLE,
"cancel": BotState.MAIN_MENU,
},
}
class FSM:
_states: dict = {}
_tmp: dict = {}
@classmethod
def get_state(cls, user_id: int) -> BotState:
return cls._states.get(user_id, BotState.IDLE)
@classmethod
def set_state(cls, user_id: int, state: BotState):
cls._states[user_id] = state
@classmethod
def reset(cls, user_id: int):
cls._states.pop(user_id, None)
cls._tmp.pop(user_id, None)
@classmethod
def set_temp(cls, user_id: int, data: dict):
cls._tmp[user_id] = data
@classmethod
def get_temp(cls, user_id: int) -> dict:
return cls._tmp.get(user_id, {})
@classmethod
def clear_temp(cls, user_id: int):
cls._tmp.pop(user_id, None)
@classmethod
def can_transition(cls, user_id: int, event: str) -> bool:
current = cls.get_state(user_id)
return event in STATE_TRANSITIONS.get(current, {})
@classmethod
def transition(cls, user_id: int, event: str) -> BotState:
current = cls.get_state(user_id)
transitions = STATE_TRANSITIONS.get(current, {})
if event not in transitions:
return current
new_state = transitions[event]
cls.set_state(user_id, new_state)
return new_state
@classmethod
def clear_all(cls):
cls._states.clear()
cls._tmp.clear()
max_bot/app/handlers/__pycache__/__init__.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/consent.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/consent.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/contact.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/greeting.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/greeting.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/handoff.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/handoff.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/inquiry.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/inquiry.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/main_menu.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/main_menu.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/__pycache__/out_of_hours.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/consent.py
+97 -50
View File
@@ -1,60 +1,107 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, log_consent, get_template_rendered
from app.keyboards.inline import build_consent_buttons, build_contact_buttons
from app.fsm import BotState, FSM
import datetime
import logging
from sqlalchemy import select
from app.database import async_session
from app.models import BotUser, BotConversation, BotMessage
from app.max_api import max_api
from app.config_reader import config_reader
from app.keyboards import contact_keyboard, consent_keyboard, return_to_consent_keyboard
logger = logging.getLogger(__name__)
async def handle_consent_request(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
user = await get_or_create_user(db, max_user_id,
user_data.get("first_name", ""),
user_data.get("last_name", ""),
user_data.get("username", ""))
await db.flush()
await SettingsCache.refresh(db)
policy_url = SettingsCache.get("consent_policy_url", "https://aegisone.ru/politica.php")
text = await get_template_rendered(db, "consent_request", policy_url=policy_url)
buttons = build_consent_buttons()
await max_api.send_message_with_keyboard(max_user_id, text, buttons, format="markdown")
FSM.set_state(max_user_id, BotState.CONSENT_REQUEST)
async def handle_consent_callback(user_id: int, conv_id: int, callback_id: str) -> None:
if callback_id == "consent_yes":
await handle_consent_yes(user_id, conv_id)
elif callback_id == "consent_no":
await handle_consent_no(user_id, conv_id)
async def handle_consent_given(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
user = await get_or_create_user(db, max_user_id)
async def handle_consent_response(user_id: int, conv_id: int, text: str) -> None:
text_lower = text.strip().lower()
consent_words = ["да", "даю", "согласен", "согласна", "yes", "ok", "хорошо", "даю согласие"]
refuse_words = ["нет", "не даю", "отказ", "no", "не согласен", "не согласна"]
user.consent_given = True
from datetime import datetime
user.consent_timestamp = datetime.now()
user.consent_method = "button"
await log_consent(db, user.id, "given", "button", user_data.get("ip", ""))
await db.flush()
text = await get_template_rendered(db, "contact_request")
buttons = build_contact_buttons()
await max_api.send_message_with_keyboard(max_user_id, text, buttons)
FSM.set_state(max_user_id, BotState.CONTACT_REQUEST)
if any(w in text_lower for w in consent_words):
await handle_consent_yes(user_id, conv_id)
elif any(w in text_lower for w in refuse_words):
await handle_consent_no(user_id, conv_id)
else:
await max_api.send_message(
user_id,
"Пожалуйста, дайте чёткий ответ — даёте ли вы согласие на обработку "
"персональных данных? Это необходимо для обработки вашего запроса.",
attachments=consent_keyboard(),
)
async def handle_consent_refused(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
user = await get_or_create_user(db, max_user_id)
async def handle_consent_yes(user_id: int, conv_id: int) -> None:
async with async_session() as db:
result = await db.execute(select(BotUser).where(BotUser.id == user_id))
user = result.scalar_one_or_none()
if user:
user.consent_given = True
user.consent_date = datetime.datetime.utcnow()
await log_consent(db, user.id, "revoked", "button", user_data.get("ip", ""))
await db.flush()
result = await db.execute(
select(BotConversation).where(BotConversation.id == conv_id)
)
conv = result.scalar_one_or_none()
if conv:
conv.state = "awaiting_contact"
await SettingsCache.refresh(db)
phone_1 = SettingsCache.get("phone_1")
phone_2 = SettingsCache.get("phone_2")
email = SettingsCache.get("support_email")
await db.commit()
text = await get_template_rendered(db, "consent_refused",
phone_1=phone_1, phone_2=phone_2,
support_email=email)
from app.keyboards.inline import build_phone_email_buttons
subject = SettingsCache.get("email_subject")
buttons = build_phone_email_buttons(phone_1, phone_2, email, subject)
await max_api.send_message_with_keyboard(max_user_id, text, buttons, format="markdown")
FSM.reset(max_user_id)
await max_api.send_message(
user_id,
"Спасибо! Поделитесь, пожалуйста, вашим контактом, чтобы мы могли "
"связаться с вами.\n\n"
"Нажмите кнопку «Поделиться контактом» или введите номер телефона / email вручную.",
attachments=contact_keyboard(),
)
async def handle_consent_no(user_id: int, conv_id: int) -> None:
async with async_session() as db:
result = await db.execute(
select(BotConversation).where(BotConversation.id == conv_id)
)
conv = result.scalar_one_or_none()
if conv:
conv.state = "consent_refused"
await db.commit()
phones = config_reader.get_phones()
email = config_reader.get_site_mail()
phone_text = "\n".join(
f"📞 {phone}" for phone, _ in phones
)
await max_api.send_message(
user_id,
f"Без вашего согласия мы не можем обработать обращение.\n\n"
f"Вы можете позвонить нам:\n{phone_text}\n\n"
f"Или написать на почту: {email}\n\n"
f"Если передумаете и захотите дать согласие — просто напишите об этом.",
)
async def handle_refused_again(user_id: int, conv_id: int, text: str) -> None:
text_lower = text.strip().lower()
consent_words = ["да", "даю", "согласен", "согласна", "yes", "ok", "хорошо", "даю согласие", "передумал", "согласен дать"]
if any(w in text_lower for w in consent_words):
await handle_consent_yes(user_id, conv_id)
else:
phones = config_reader.get_phones()
email = config_reader.get_site_mail()
phone_text = ", ".join(phone for phone, _ in phones)
await max_api.send_message(
user_id,
f"Связаться с нами можно только по телефону {phone_text} "
f"или по почте {email}. "
f"Если хотите дать согласие на обработку данных — напишите «Даю согласие».",
attachments=return_to_consent_keyboard(),
)
max_bot/app/handlers/contact.py
+66 -32
View File
@@ -1,43 +1,77 @@
import datetime
import re
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
import logging
from sqlalchemy import select
from app.database import async_session
from app.models import BotUser, BotConversation, BotMessage
from app.max_api import max_api
logger = logging.getLogger(__name__)
PHONE_PATTERN = re.compile(r"^(\+7|8|7)?[\s\-]?\(?\d{3}\)?[\s\-]?\d{3}[\s\-]?\d{2}[\s\-]?\d{2}$")
EMAIL_PATTERN = re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$")
async def handle_contact_provided(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
user = await get_or_create_user(db, max_user_id)
async def handle_contact_received(user_id: int, conv_id: int, contact_text: str) -> None:
async with async_session() as db:
result = await db.execute(select(BotUser).where(BotUser.id == user_id))
user = result.scalar_one_or_none()
if user:
if PHONE_PATTERN.match(contact_text):
user.phone = contact_text
elif EMAIL_PATTERN.match(contact_text):
user.phone = contact_text
phone = user_data.get("phone", "")
email = user_data.get("email", "")
result = await db.execute(
select(BotConversation).where(BotConversation.id == conv_id)
)
conv = result.scalar_one_or_none()
if conv:
conv.state = "awaiting_inquiry"
if conv.intent == "unknown" or not conv.intent:
await _ask_inquiry(user_id, conv)
else:
await _ask_inquiry_with_context(user_id, conv)
if phone:
user.phone = phone
if email:
user.email = email
await db.flush()
text = await get_template_rendered(db, "inquiry_request")
await max_api.send_message(max_user_id, text, format="markdown")
FSM.set_state(max_user_id, BotState.INQUIRY_REQUEST)
await db.commit()
async def handle_contact_text(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
user = await get_or_create_user(db, max_user_id)
async def handle_manual_contact(user_id: int, conv_id: int, text: str) -> None:
text = text.strip()
phone_match = re.search(r'(\+?7[\s\-\(]?\d{3}[\s\-\)]?\d{3}[\s\-]?\d{2}[\s\-]?\d{2})', text)
email_match = re.search(r'([\w.-]+@[\w.-]+\.\w+)', text)
async with async_session() as db:
msg = BotMessage(
conversation_id=conv_id,
direction="incoming",
text=text,
created_at=datetime.datetime.utcnow(),
)
db.add(msg)
await db.commit()
if phone_match:
user.phone = phone_match.group(1)
if email_match:
user.email = email_match.group(1)
if PHONE_PATTERN.match(text) or EMAIL_PATTERN.match(text):
await handle_contact_received(user_id, conv_id, text)
else:
await max_api.send_message(
user_id,
"Пожалуйста, введите корректный номер телефона (например, +7 (861) 203-33-30) "
"или адрес электронной почты.",
)
if phone_match or email_match:
await db.flush()
await handle_contact_provided(bot, user_data, db, max_api)
return
await max_api.send_message(max_user_id, "Пожалуйста, укажите номер телефона или email, чтобы мы могли с вами связаться.")
async def _ask_inquiry(user_id: int, conv: BotConversation) -> None:
await max_api.send_message(
user_id,
"Опишите, пожалуйста, ваш вопрос или задачу. "
"Расскажите подробнее, чем мы можем вам помочь.",
)
async def _ask_inquiry_with_context(user_id: int, conv: BotConversation) -> None:
intent_label = "вопрос" if conv.intent == "question" else "заявку на услугу" if conv.intent == "ticket" else "обращение"
await max_api.send_message(
user_id,
f"Ранее вы упомянули, что хотите оставить {intent_label}. "
"Опишите подробнее суть вашего обращения, чтобы я могла передать "
"информацию специалисту.",
)
max_bot/app/handlers/features/__init__.py
View File
max_bot/app/handlers/features/__pycache__/appointment.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/features/__pycache__/commercial.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/features/__pycache__/my_objects.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/features/__pycache__/photo_report.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/features/__pycache__/quality_rate.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/features/__pycache__/risk_score.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/features/__pycache__/sla_status.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/handlers/features/appointment.py
-105
View File
@@ -1,105 +0,0 @@
from datetime import datetime
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
from app.keyboards.inline import build_main_menu_buttons
_DATE_KEY = "appt_date"
_SLOT_KEY = "appt_slot"
async def handle_appointment(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
payload = user_data.get("payload", "")
state = FSM.get_state(max_user_id)
if state != BotState.FEATURE_APPOINTMENT:
FSM.set_state(max_user_id, BotState.FEATURE_APPOINTMENT)
FSM.set_temp(max_user_id, {})
await max_api.send_message(
max_user_id,
"📅 **Запись на визит**\n\nУкажите желаемую дату (ДД.ММ.ГГГГ):"
)
return
tmp = FSM.get_temp(max_user_id)
if _DATE_KEY not in tmp:
try:
parsed = datetime.strptime(text.strip(), "%d.%m.%Y")
tmp[_DATE_KEY] = parsed.strftime("%Y-%m-%d")
FSM.set_temp(max_user_id, tmp)
slots = _generate_slots()
msg_lines = [f"📅 **{parsed.strftime('%d.%m.%Y')}**\n\nДоступные слоты:\n"]
for i, slot in enumerate(slots, 1):
msg_lines.append(f"{i}. {slot}")
msg_lines.append("\nВведите номер слота (1-{}):".format(len(slots)))
await max_api.send_message(max_user_id, "\n".join(msg_lines), format="markdown")
except Exception:
await max_api.send_message(max_user_id, "Неверный формат даты. Укажите дату в формате ДД.ММ.ГГГГ")
return
if _SLOT_KEY not in tmp:
slots = _generate_slots()
try:
idx = int(text.strip()) - 1
if 0 <= idx < len(slots):
tmp[_SLOT_KEY] = slots[idx]
FSM.set_temp(max_user_id, tmp)
await _confirm_appointment(bot, user_data, db, max_api, tmp)
return
except (ValueError, IndexError):
pass
await max_api.send_message(max_user_id, f"Укажите номер слота (1-{len(slots)}):")
return
await _confirm_appointment(bot, user_data, db, max_api, tmp)
def _generate_slots() -> list:
start_h = SettingsCache.get_int("work_hours_start", 9)
end_h = SettingsCache.get_int("work_hours_end", 18)
slots = []
for h in range(start_h, end_h):
slots.append(f"{h:02d}:00-{h + 1:02d}:00")
return slots
async def _confirm_appointment(bot, user_data, db, max_api, tmp):
max_user_id = user_data["user_id"]
date_str = tmp.get(_DATE_KEY, "—")
slot_str = tmp.get(_SLOT_KEY, "—")
user = await get_or_create_user(db, max_user_id)
text = await get_template_rendered(db, "appointment_confirm",
date=f"{date_str} {slot_str}",
engineer="будет назначен")
await max_api.send_message(max_user_id, text, format="markdown")
conv = await _create_appointment_conv(db, user.id, f"{date_str} {slot_str}")
from app.integrations import _1c_unf as ic_integration
await ic_integration.send_to_1c(db, conv)
FSM.clear_temp(max_user_id)
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
async def _create_appointment_conv(db, user_id, details):
from app.conversation import create_conversation, add_message
from sqlalchemy import select
from app.models.models import BotCategory
result = await db.execute(
select(BotCategory).where(BotCategory.name == "Обслуживание").limit(1)
)
cat = result.scalar_one_or_none()
conv = await create_conversation(db, user_id)
conv.inquiry_text = f"Запись на визит: {details}"
conv.inquiry_type = cat.id if cat else None
conv.priority = "normal"
await db.flush()
await add_message(db, conv.id, "in", details)
return conv
max_bot/app/handlers/features/broadcasts.py
-44
View File
@@ -1,44 +0,0 @@
from datetime import datetime
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
async def handle_broadcast_send(bot, user_data: dict, db, max_api):
from app.models.models import BotUser
from sqlalchemy import select
text = user_data.get("text", "").strip()
if not text:
await max_api.send_message(
user_data["user_id"],
"Укажите текст рассылки в параметре broadcast_text."
)
return
result = await db.execute(select(BotUser).where(BotUser.consent_given == True))
users = result.scalars().all()
sent = 0
failed = 0
sent_ids = []
for u in users:
try:
await max_api.send_message(user_id=u.max_user_id, text=text, format="markdown")
sent += 1
sent_ids.append(u.max_user_id)
except Exception:
failed += 1
from app.models.models import BotBroadcast
bc = BotBroadcast(
text=text,
sent_at=datetime.now(),
recipient_count=len(users),
recipient_ids=sent_ids,
status="sent",
)
db.add(bc)
await db.flush()
result = f"📨 Рассылка завершена.\nОтправлено: {sent}\nОшибок: {failed}"
await max_api.send_message(user_data["user_id"], result)
max_bot/app/handlers/features/commercial.py
-101
View File
@@ -1,101 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
from app.keyboards.inline import build_main_menu_buttons
_STEPS = ["service_type", "scope", "address", "comment"]
_STEP_LABELS = {
"service_type": "Тип услуги (Видеонаблюдение, СКУД, Пожарная сигнализация, IT-инфраструктура, Обслуживание, Другое)",
"scope": "Объём работ (краткое описание)",
"address": "Адрес объекта",
"comment": "Дополнительные пожелания (или отправьте «-» для пропуска)",
}
_COLLECT_KEY = "commercial_data"
_STEP_KEY = "commercial_step"
async def handle_commercial(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
state = FSM.get_state(max_user_id)
if state != BotState.FEATURE_COMMERCIAL:
FSM.set_state(max_user_id, BotState.FEATURE_COMMERCIAL)
FSM.set_temp(max_user_id, {_STEP_KEY: 0, _COLLECT_KEY: {}})
await max_api.send_message(
max_user_id,
f"📄 **Коммерческое предложение**\n\nШаг 1/{len(_STEPS)}:\n{_STEP_LABELS['service_type']}"
)
return
tmp = FSM.get_temp(max_user_id)
step = tmp.get(_STEP_KEY, 0)
data = tmp.get(_COLLECT_KEY, {})
if step >= len(_STEPS):
await _finish_commercial(bot, user_data, db, max_api, data)
return
step_key = _STEPS[step]
if not text and step_key != "comment":
await max_api.send_message(max_user_id, f"Пожалуйста, заполните поле:\n{_STEP_LABELS[step_key]}")
return
data[step_key] = text if text else ""
step += 1
if step < len(_STEPS):
FSM.set_temp(max_user_id, {_STEP_KEY: step, _COLLECT_KEY: data})
next_key = _STEPS[step]
await max_api.send_message(
max_user_id,
f"📄 Шаг {step + 1}/{len(_STEPS)}:\n{_STEP_LABELS[next_key]}"
)
else:
await _finish_commercial(bot, user_data, db, max_api, data)
async def _finish_commercial(bot, user_data, db, max_api, data):
max_user_id = user_data["user_id"]
user = await get_or_create_user(db, max_user_id)
summary = (
f"📄 **Коммерческое предложение**\n\n"
f"Услуга: {data.get('service_type', '—')}\n"
f"Объём: {data.get('scope', '—')}\n"
f"Адрес: {data.get('address', '—')}\n"
f"Комментарий: {data.get('comment', '—')}\n\n"
f"Спасибо, {user.first_name}! Мы подготовим КП и свяжемся с вами."
)
await max_api.send_message(max_user_id, summary, format="markdown")
conv_text = (
f"Коммерческое предложение: услуга={data.get('service_type', '')}, "
f"объём={data.get('scope', '')}, адрес={data.get('address', '')}, "
f"комментарий={data.get('comment', '')}"
)
conv = await _create_commercial_conv(db, user.id, conv_text)
from app.integrations import _1c_unf as ic_integration
await ic_integration.send_to_1c(db, conv)
FSM.clear_temp(max_user_id)
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
async def _create_commercial_conv(db, user_id, details):
from app.conversation import create_conversation, add_message
from sqlalchemy import select
from app.models.models import BotCategory
result = await db.execute(
select(BotCategory).where(BotCategory.name == "Консультация").limit(1)
)
cat = result.scalar_one_or_none()
conv = await create_conversation(db, user_id)
conv.inquiry_text = details
conv.inquiry_type = cat.id if cat else None
await db.flush()
await add_message(db, conv.id, "in", details)
return conv
max_bot/app/handlers/features/my_objects.py
-39
View File
@@ -1,39 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
from app.keyboards.inline import build_main_menu_buttons
async def handle_my_objects(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
if FSM.get_state(max_user_id) != BotState.FEATURE_MY_OBJECTS:
FSM.set_state(max_user_id, BotState.FEATURE_MY_OBJECTS)
user = await get_or_create_user(db, max_user_id)
await max_api.send_message(max_user_id,
"🏢 **Мои объекты**\n\n"
"Укажите название вашей компании для поиска объектов."
)
return
if not text:
await max_api.send_message(max_user_id, "Укажите название компании.")
return
from app.integrations.portal_db import get_objects_for_customer
objects = await get_objects_for_customer(db, text)
if not objects:
await max_api.send_message(max_user_id, "Объекты не найдены. Проверьте название компании.")
else:
lines = [f"🏢 **{obj.name}** — {obj.status}" for obj in objects[:10]]
msg = "Ваши объекты:\n\n" + "\n".join(lines)
if len(objects) > 10:
msg += f"\n\n...и ещё {len(objects) - 10} объектов"
await max_api.send_message(max_user_id, msg, format="markdown")
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
max_bot/app/handlers/features/notifications.py
-68
View File
@@ -1,68 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
from app.keyboards.inline import build_main_menu_buttons
async def handle_notifications(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
payload = user_data.get("payload", "")
if FSM.get_state(max_user_id) != BotState.FEATURE_NOTIFICATIONS:
FSM.set_state(max_user_id, BotState.FEATURE_NOTIFICATIONS)
user = await get_or_create_user(db, max_user_id)
from sqlalchemy import select
from app.models.models import BotNotificationSubscription
result = await db.execute(
select(BotNotificationSubscription).where(
BotNotificationSubscription.user_id == user.id
).limit(1)
)
sub = result.scalar_one_or_none()
status_change = "✅" if sub and sub.notify_on_status_change else "⬜"
reply = "✅" if sub and sub.notify_on_reply else "⬜"
broadcast = "✅" if sub and sub.notify_on_broadcast else "⬜"
text = (
"🔔 **Уведомления**\n\n"
"Выберите, о чём уведомлять:\n\n"
f"{status_change} /status — Смена статуса обращения\n"
f"{reply} /reply — Ответ оператора\n"
f"{broadcast} /broadcast — Новости и рассылки\n\n"
"Нажмите на пункт, чтобы переключить."
)
await max_api.send_message(max_user_id, text, format="markdown")
return
user = await get_or_create_user(db, max_user_id)
from sqlalchemy import select
from app.models.models import BotNotificationSubscription
result = await db.execute(
select(BotNotificationSubscription).where(
BotNotificationSubscription.user_id == user.id
).limit(1)
)
sub = result.scalar_one_or_none()
if not sub:
sub = BotNotificationSubscription(user_id=user.id)
db.add(sub)
await db.flush()
toggle_map = {
"/status": "notify_on_status_change",
"/reply": "notify_on_reply",
"/broadcast": "notify_on_broadcast",
}
key = payload if payload.startswith("/") else (payload if payload in toggle_map else user_data.get("text", "").strip())
if key in toggle_map:
col = toggle_map[key]
current = getattr(sub, col)
setattr(sub, col, not current)
await db.flush()
await max_api.send_message(max_user_id, f"Настройка «{key}» изменена.")
else:
await max_api.send_message(max_user_id, "Нажмите /status, /reply или /broadcast для переключения.")
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
max_bot/app/handlers/features/photo_report.py
-69
View File
@@ -1,69 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_open_conversation, create_conversation, add_message, get_template_rendered
from app.fsm import BotState, FSM
from app.keyboards.inline import build_main_menu_buttons
async def handle_photo_report(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
if FSM.get_state(max_user_id) != BotState.FEATURE_PHOTO_REPORT:
FSM.set_state(max_user_id, BotState.FEATURE_PHOTO_REPORT)
await max_api.send_message(max_user_id,
"📸 **Фото-отчёт**\n\n"
"Отправьте фото проблемы и опишите, что произошло.\n"
"Вы можете прикрепить документ (PDF, DOCX, XLSX, TXT)."
)
return
user = await get_or_create_user(db, max_user_id)
conv = await get_open_conversation(db, user.id)
if not conv:
conv = await create_conversation(db, user.id)
has_attachment = user_data.get("has_attachment", False)
attachment_type = user_data.get("attachment_type", "")
attachment_path = user_data.get("attachment_path", "")
conv.inquiry_text = text or "Фото-отчёт"
conv.has_attachment = has_attachment
conv.attachment_type = attachment_type
conv.attachment_path = attachment_path
conv.priority = "high"
await db.flush()
await add_message(db, conv.id, "in", text, has_attachment, attachment_type, attachment_path)
ooh = not SettingsCache.is_work_hours()
if ooh:
start = SettingsCache.get_int("work_hours_start", 9)
end = SettingsCache.get_int("work_hours_end", 18)
ooh_text = await get_template_rendered(db, "out_of_hours",
work_hours_start=start, work_hours_end=end)
await max_api.send_message(max_user_id, ooh_text)
text = await get_template_rendered(db, "confirmation_ooh" if ooh else "confirmation",
first_name=user.first_name, conv_id=conv.id)
await max_api.send_message(max_user_id, text, format="markdown")
from app.integrations import _1c_unf as ic_integration
await ic_integration.send_to_1c(db, conv)
from app.models.models import Incident
incident = Incident(
object_id=0,
reported_by=None,
title=f"Фото-отчёт от {user.first_name or 'клиента'}",
description=text or "Фото-отчёт через бота",
severity="P3",
status="open",
)
db.add(incident)
await db.flush()
conv.attachment_path = f"incident_{incident.id}"
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
max_bot/app/handlers/features/quality_rate.py
-35
View File
@@ -1,35 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_open_conversation, get_template_rendered
from app.keyboards.inline import build_quality_buttons, build_main_menu_buttons
from app.fsm import BotState, FSM
async def handle_quality_rate(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
payload = user_data.get("payload", "")
if FSM.get_state(max_user_id) != BotState.FEATURE_QUALITY_RATE:
FSM.set_state(max_user_id, BotState.FEATURE_QUALITY_RATE)
conv = await get_open_conversation(db, (await get_or_create_user(db, max_user_id)).id)
conv_id = conv.id if conv else "—"
text = await get_template_rendered(db, "quality_request", conv_id=conv_id)
buttons = build_quality_buttons()
await max_api.send_message_with_keyboard(max_user_id, text, buttons)
return
if payload.startswith("rate_"):
try:
rating = int(payload.replace("rate_", ""))
except ValueError:
return
await max_api.send_message(max_user_id, f"Спасибо за оценку: {rating}/5! Ваш отзыв важен для нас.")
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
return
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
max_bot/app/handlers/features/reminders.py
-48
View File
@@ -1,48 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
from app.keyboards.inline import build_main_menu_buttons
async def handle_reminders(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
if FSM.get_state(max_user_id) != BotState.FEATURE_REMINDERS:
FSM.set_state(max_user_id, BotState.FEATURE_REMINDERS)
user = await get_or_create_user(db, max_user_id)
phone = user.phone or ""
from sqlalchemy import select, func
from app.models.models import BotConversation, BotTicket, Customer
open_convs = await db.execute(
select(func.count(BotConversation.id))
.where(BotConversation.status.in_(["open", "handoff"]))
)
total_open = open_convs.scalar() or 0
open_tickets = await db.execute(
select(func.count(BotTicket.id))
.where(BotTicket.status.in_(["open", "in_progress"]))
)
total_tickets = open_tickets.scalar() or 0
my_convs = await db.execute(
select(func.count(BotConversation.id))
.where(BotConversation.user_id == user.id, BotConversation.status.in_(["open", "handoff"]))
)
my_open = my_convs.scalar() or 0
text = (
"🔔 **Напоминания**\n\n"
f"У вас открыто обращений: {my_open}\n"
f"Всего в системе: {total_open} обращений, {total_tickets} заявок\n\n"
"Напоминания о плановом ТО настраиваются в портале."
)
await max_api.send_message(max_user_id, text, format="markdown")
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
return
max_bot/app/handlers/features/risk_score.py
-100
View File
@@ -1,100 +0,0 @@
from sqlalchemy import select
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
from app.keyboards.inline import build_main_menu_buttons
_ANSWERS_KEY = "risk_answers"
_STEP_KEY = "risk_step"
async def _load_questions(db):
from app.models.models import BotRiskQuestion
result = await db.execute(
select(BotRiskQuestion)
.where(BotRiskQuestion.is_active == True)
.order_by(BotRiskQuestion.sort_order)
)
return result.scalars().all()
async def handle_risk_score(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
state = FSM.get_state(max_user_id)
questions = await _load_questions(db)
if not questions:
await max_api.send_message(max_user_id, "Анкета риск-инжиниринга временно недоступна.")
FSM.transition(max_user_id, "cancel")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
return
if state != BotState.FEATURE_RISK_SCORE:
FSM.set_state(max_user_id, BotState.FEATURE_RISK_SCORE)
FSM.set_temp(max_user_id, {_STEP_KEY: 0, _ANSWERS_KEY: {}})
q = questions[0]
await max_api.send_message(
max_user_id,
f"📊 **Risk Score — анкета**\n\nВопрос 1/{len(questions)}:\n{q.question}\n\nОтветьте «да» или «нет»."
)
return
tmp = FSM.get_temp(max_user_id)
step = tmp.get(_STEP_KEY, 0)
answers = tmp.get(_ANSWERS_KEY, {})
if step >= len(questions):
await _finish_risk_score(max_user_id, answers, questions, db, max_api)
return
if text.lower() in ("да", "yes", "+", "1"):
answers[questions[step].question_key] = True
elif text.lower() in ("нет", "no", "-", "0"):
answers[questions[step].question_key] = False
else:
await max_api.send_message(max_user_id, "Пожалуйста, ответьте «да» или «нет».")
return
step += 1
if step < len(questions):
q = questions[step]
FSM.set_temp(max_user_id, {_STEP_KEY: step, _ANSWERS_KEY: answers})
await max_api.send_message(
max_user_id,
f"📊 Вопрос {step + 1}/{len(questions)}:\n{q.question}\n\n«да» или «нет»?"
)
else:
await _finish_risk_score(max_user_id, answers, questions, db, max_api)
async def _finish_risk_score(max_user_id, answers, questions, db, max_api):
score = 0
for q in questions:
if answers.get(q.question_key):
score += q.weight
score = min(score, 100)
if score < 20:
label = "Низкий"
rec = "Поддерживайте текущий уровень обслуживания"
elif score < 50:
label = "Средний"
rec = "Рекомендуем провести аудит систем"
elif score < 75:
label = "Высокий"
rec = "Необходимо срочное обслуживание"
else:
label = "Критический"
rec = "Требуется немедленное вмешательство"
tmpl = await get_template_rendered(db, "risk_result", score=score, label=label, recommendation=rec)
await max_api.send_message(max_user_id, tmpl, format="markdown")
FSM.clear_temp(max_user_id)
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
max_bot/app/handlers/features/sla_status.py
-54
View File
@@ -1,54 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
from app.keyboards.inline import build_main_menu_buttons
async def handle_sla_status(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
if FSM.get_state(max_user_id) != BotState.FEATURE_SLA_STATUS:
FSM.set_state(max_user_id, BotState.FEATURE_SLA_STATUS)
await max_api.send_message(max_user_id,
"🔍 **Проверка SLA статуса**\n\n"
"Укажите номер или название объекта."
)
return
if not text:
await max_api.send_message(max_user_id, "Укажите номер или название объекта.")
return
from app.integrations.portal_db import get_object_by_name_or_id, get_sla_for_object, get_last_incident_for_object, get_active_tasks_for_object
obj = await get_object_by_name_or_id(db, text)
if not obj:
await max_api.send_message(max_user_id, "Объект не найден.")
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
return
sla = await get_sla_for_object(db, obj.id)
if not sla:
text = await get_template_rendered(db, "sla_not_found")
await max_api.send_message(max_user_id, text)
else:
level_map = {"start": "Базовый", "business": "Оптимальный", "enterprise": "Максимальный"}
last_incident = await get_last_incident_for_object(db, obj.id)
open_tasks = await get_active_tasks_for_object(db, obj.id)
last_visit = last_incident.created_at.strftime("%d.%m.%Y") if last_incident else "—"
tasks_count = len(open_tasks)
text = await get_template_rendered(db, "sla_found",
object_name=obj.name,
service_level=level_map.get(sla.service_level, sla.service_level),
status=sla.status,
price=sla.sla_price_monthly or 0)
text += f"\n📅 Последний визит: {last_visit}\n📋 Открытых задач: {tasks_count}"
await max_api.send_message(max_user_id, text, format="markdown")
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
max_bot/app/handlers/features/sla_ticket.py
-155
View File
@@ -1,155 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.fsm import BotState, FSM
from app.keyboards.inline import build_main_menu_buttons
async def handle_sla_ticket(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
if FSM.get_state(max_user_id) != BotState.SLA_TICKET_CREATE:
FSM.set_state(max_user_id, BotState.SLA_TICKET_CREATE)
await max_api.send_message(max_user_id, "🔧 **Заявка по SLA**\n\nПроверяю ваш SLA контракт...")
user = await get_or_create_user(db, max_user_id)
phone = user.phone or ""
if not phone:
await max_api.send_message(max_user_id, "Не могу найти ваш номер телефона. Укажите его, пожалуйста.")
return
from sqlalchemy import select
from app.models.models import Customer, Object, SLAContract
result = await db.execute(
select(Customer).where(Customer.contact_phone.ilike(f"%{phone[-10:]}%")).limit(1)
)
customer = result.scalar_one_or_none()
if not customer:
await _send_no_sla(bot, user_data, db, max_api)
return
result = await db.execute(
select(Object).where(Object.customer_id == customer.id, Object.status == "active").limit(1)
)
obj = result.scalar_one_or_none()
if not obj:
await _send_no_sla(bot, user_data, db, max_api)
return
result = await db.execute(
select(SLAContract).where(
SLAContract.object_id == obj.id,
SLAContract.status == "active"
).order_by(SLAContract.created_at.desc()).limit(1)
)
sla = result.scalar_one_or_none()
if not sla:
await _send_no_sla(bot, user_data, db, max_api)
return
level_map = {"start": "Базовый", "business": "Оптимальный", "enterprise": "Максимальный"}
text = await get_template_rendered(db, "sla_ticket_found",
object_name=obj.name,
service_level=level_map.get(sla.service_level, sla.service_level))
await max_api.send_message(max_user_id, text, format="markdown")
return
if not text:
await max_api.send_message(max_user_id, "Опишите неисправность. Вы можете прикрепить фото или документ.")
return
user = await get_or_create_user(db, max_user_id)
from sqlalchemy import select, func
from app.models.models import Customer, Object, SLAContract, BotTicket
result = await db.execute(
select(Customer).where(Customer.contact_phone.ilike(f"%{user.phone[-10:]}%")).limit(1)
)
customer = result.scalar_one_or_none()
obj = None
sla = None
if customer:
result = await db.execute(
select(Object).where(Object.customer_id == customer.id, Object.status == "active").limit(1)
)
obj = result.scalar_one_or_none()
if obj:
result = await db.execute(
select(SLAContract).where(
SLAContract.object_id == obj.id, SLAContract.status == "active"
).order_by(SLAContract.created_at.desc()).limit(1)
)
sla = result.scalar_one_or_none()
priority_map = {"start": "low", "business": "normal", "enterprise": "high"}
response_map = {"start": "4 часа", "business": "2 часа", "enterprise": "30 минут"}
sla_level = sla.service_level if sla else "start"
priority = priority_map.get(sla_level, "normal")
result = await db.execute(select(func.count(BotTicket.id)))
ticket_num = f"T-{result.scalar() + 1:04d}"
from app.models.models import BotTicket, BotTicketMessage, BotTicketStatus
ticket = BotTicket(
ticket_number=ticket_num,
user_id=user.id,
object_id=obj.id if obj else None,
customer_id=customer.id if customer else None,
title=text[:100],
description=text,
priority=priority,
status="open",
created_by="bot",
sla_contract_id=sla.id if sla else None,
has_attachment=user_data.get("has_attachment", False),
attachment_type=user_data.get("attachment_type", ""),
attachment_path=user_data.get("attachment_path", ""),
)
db.add(ticket)
await db.flush()
db.add(BotTicketMessage(ticket_id=ticket.id, direction="in", text=text, sender="client"))
db.add(BotTicketStatus(ticket_id=ticket.id, old_status="", new_status="open", changed_by="bot"))
await db.flush()
has_attachment = user_data.get("has_attachment", False)
attachment_type = user_data.get("attachment_type", "")
attachment_path = user_data.get("attachment_path", "")
if has_attachment:
ticket.has_attachment = True
ticket.attachment_type = attachment_type
ticket.attachment_path = attachment_path
await db.flush()
text = await get_template_rendered(db, "sla_ticket_created",
ticket_number=ticket_num,
priority=priority,
response_time=response_map.get(sla_level, "2 часа"))
await max_api.send_message(max_user_id, text, format="markdown")
from app.max_notifications import notify_ticket_created as nt
await nt(db, ticket, max_api)
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
async def _send_no_sla(bot, user_data, db, max_api):
max_user_id = user_data["user_id"]
await SettingsCache.refresh(db)
phone_1 = SettingsCache.get("phone_1")
phone_2 = SettingsCache.get("phone_2")
email = SettingsCache.get("support_email")
text = await get_template_rendered(db, "sla_ticket_not_found",
phone_1=phone_1, phone_2=phone_2,
support_email=email)
from app.keyboards.inline import build_phone_email_buttons
subject = SettingsCache.get("email_subject")
buttons = build_phone_email_buttons(phone_1, phone_2, email, subject)
await max_api.send_message_with_keyboard(max_user_id, text, buttons, format="markdown")
FSM.transition(max_user_id, "done")
buttons = build_main_menu_buttons()
menu_text = await get_template_rendered(db, "main_menu")
await max_api.send_message_with_keyboard(max_user_id, menu_text, buttons)
max_bot/app/handlers/greeting.py
+262 -25
View File
@@ -1,33 +1,270 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_open_conversation, get_template_rendered
from app.keyboards.inline import build_main_menu_buttons
from app.fsm import BotState, FSM
import logging
import datetime
from typing import Optional
from sqlalchemy import select
from app.database import async_session
from app.models import BotUser, BotConversation, BotMessage, BotKnowledgeBase, BotCategory
from app.max_api import max_api
from app.yandex_gpt import yandex_gpt
from app.config_reader import config_reader
from app.settings_cache import settings_cache
from app.keyboards import consent_keyboard, return_to_consent_keyboard
logger = logging.getLogger(__name__)
async def handle_start(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
first_name = user_data.get("first_name", "")
last_name = user_data.get("last_name", "")
username = user_data.get("username", "")
async def handle_greeting(
user_id: int,
text: Optional[str] = None,
first_name: str = "",
last_name: str = "",
username: str = "",
) -> None:
assistant_name = await settings_cache.get("assistant_name", "София")
user = await get_or_create_user(db, max_user_id, first_name, last_name, username)
await db.flush()
greeting_text = (
f"Здравствуйте! Я {assistant_name}, помощник AegisOne Engineering. "
f"Чем я могу быть вам полезна?"
)
await SettingsCache.refresh(db)
await max_api.send_message(user_id, greeting_text)
open_conv = await get_open_conversation(db, user.id)
name = SettingsCache.get_assistant_name()
async with async_session() as db:
existing = await db.execute(
select(BotUser).where(BotUser.id == user_id)
)
user = existing.scalar_one_or_none()
if open_conv:
text = await get_template_rendered(db, "greeting_returning",
first_name=user.first_name or first_name,
conv_id=open_conv.id)
buttons = build_main_menu_buttons()
await max_api.send_message_with_keyboard(max_user_id, text, buttons, format="markdown")
FSM.set_state(max_user_id, BotState.IDLE)
now = datetime.datetime.utcnow()
if not user:
user = BotUser(
id=user_id,
first_name=first_name,
last_name=last_name,
username=username,
last_interaction=now,
total_conversations=1,
created_at=now,
)
db.add(user)
else:
if first_name:
user.first_name = first_name
if last_name:
user.last_name = last_name
if username:
user.username = username
user.last_interaction = now
user.total_conversations = (user.total_conversations or 0) + 1
await db.commit()
await db.refresh(user)
conv = BotConversation(
user_id=user_id,
state="analyzing",
created_at=now,
)
db.add(conv)
await db.commit()
await db.refresh(conv)
if text:
await analyze_and_respond(user_id, conv.id, text)
else:
async with async_session() as db:
conv.state = "awaiting_input"
await db.commit()
async def handle_message(user_id: int, text: str) -> None:
async with async_session() as db:
result = await db.execute(
select(BotConversation)
.where(BotConversation.user_id == user_id)
.order_by(BotConversation.id.desc())
.limit(1)
)
conv = result.scalar_one_or_none()
if not conv:
await handle_greeting(user_id, text)
return
msg = BotMessage(
conversation_id=conv.id,
direction="incoming",
text=text,
created_at=datetime.datetime.utcnow(),
)
db.add(msg)
await db.commit()
state = conv.state if conv else "greeting"
if state in ("greeting", "analyzing", "awaiting_input"):
await analyze_and_respond(user_id, conv.id, text)
elif state == "awaiting_consent":
from app.handlers.consent import handle_consent_response
await handle_consent_response(user_id, conv.id, text)
elif state == "consent_refused":
from app.handlers.consent import handle_refused_again
await handle_refused_again(user_id, conv.id, text)
elif state == "awaiting_contact":
from app.handlers.contact import handle_manual_contact
await handle_manual_contact(user_id, conv.id, text)
elif state == "awaiting_inquiry":
from app.handlers.inquiry import handle_inquiry
await handle_inquiry(user_id, conv.id, text)
elif state in ("completed", "escalated"):
await max_api.send_message(
user_id,
"Ваше обращение уже передано специалисту. "
"Если у вас новый вопрос, напишите его, и я помогу.",
)
async def _get_user_history_context(user_id: int) -> str:
from app.models import BotTicket
async with async_session() as db:
recent_msgs = await db.execute(
select(BotMessage)
.join(BotConversation)
.where(BotConversation.user_id == user_id)
.order_by(BotMessage.id.desc())
.limit(10)
)
messages = list(reversed(recent_msgs.scalars().all()))
open_tickets = await db.execute(
select(BotTicket)
.where(BotTicket.user_id == user_id)
.where(BotTicket.status != "Закрыта")
.order_by(BotTicket.id.desc())
)
tickets = open_tickets.scalars().all()
parts = []
if messages:
msg_lines = []
for m in messages:
who = "Клиент" if m.direction == "incoming" else "Бот"
msg_lines.append(f"{who}: {m.text or ''}")
parts.append("Последние сообщения из прошлых диалогов:\n" + "\n".join(msg_lines))
if tickets:
ticket_lines = []
for t in tickets:
ticket_lines.append(f" - Заявка #{t.id}: {t.title} (статус: {t.status})")
parts.append("Открытые заявки пользователя:\n" + "\n".join(ticket_lines))
return "\n\n".join(parts)
async def analyze_and_respond(user_id: int, conv_id: int, text: str) -> None:
gpt_available = await yandex_gpt.is_available()
if not gpt_available:
await _limited_mode(user_id, conv_id)
return
text = await get_template_rendered(db, "greeting", name=name)
buttons = build_main_menu_buttons()
await max_api.send_message_with_keyboard(max_user_id, text, buttons, format="markdown")
FSM.set_state(max_user_id, BotState.IDLE)
history_context = await _get_user_history_context(user_id)
intent = await yandex_gpt.analyze_intent(text, history_context)
async with async_session() as db:
result = await db.execute(
select(BotConversation).where(BotConversation.id == conv_id)
)
conv = result.scalar_one_or_none()
if not conv:
return
conv.intent = intent
if intent == "question":
kb_context = await _get_knowledge_base_context(text)
answer = await yandex_gpt.generate_answer(text, kb_context, history_context)
if answer:
await max_api.send_message(user_id, answer)
else:
await _send_contacts(user_id)
conv.state = "completed"
elif intent == "ticket":
conv.state = "awaiting_consent"
consent_text = (
"Для обработки Вашего запроса нам нужны ваши контактные данные "
"для обратной связи. Даёте согласие на обработку "
"персональных данных?"
)
await max_api.send_message(
user_id, consent_text, attachments=consent_keyboard()
)
else:
clarification = await yandex_gpt.clarify_intent(text, history_context)
await max_api.send_message(user_id, clarification)
conv.state = "awaiting_consent"
after_text = (
"\n\nДля обработки Вашего запроса нам нужны ваши контактные данные "
"для обратной связи. Даёте согласие на обработку "
"персональных данных?"
)
await max_api.send_message(
user_id, after_text, attachments=consent_keyboard()
)
await db.commit()
async def _limited_mode(user_id: int, conv_id: int) -> None:
async with async_session() as db:
result = await db.execute(
select(BotConversation).where(BotConversation.id == conv_id)
)
conv = result.scalar_one_or_none()
if conv:
conv.state = "completed"
await db.commit()
await _send_contacts(user_id)
async def _send_contacts(user_id: int) -> None:
phones = config_reader.get_phones()
email = config_reader.get_site_mail()
phone_text = "\n".join(
f"📞 {phone} — [позвонить](tel:{link})"
for phone, link in phones
)
message = (
"Вы можете связаться с нами:\n\n"
f"{phone_text}\n"
f"📧 [Написать на почту](mailto:{email})\n\n"
f"Или написать на почту: {email}"
)
await max_api.send_message(user_id, message, format="markdown")
async def _get_knowledge_base_context(query: str) -> str:
async with async_session() as db:
result = await db.execute(
select(BotKnowledgeBase)
.where(BotKnowledgeBase.is_active == True)
.order_by(BotKnowledgeBase.sort_order)
)
cards = result.scalars().all()
if not cards:
return ""
parts = []
for card in cards:
keywords = " ".join(card.keywords) if card.keywords else ""
answer = card.answer or "Нет ответа"
cat_name = card.category.name if card.category else "Общее"
parts.append(f"[{cat_name}] {card.question}: {answer} (ключевые слова: {keywords})")
return "\n\n".join(parts[:20])
max_bot/app/handlers/handoff.py
+86 -26
View File
@@ -1,32 +1,92 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_open_conversation, get_template_rendered
from app.fsm import BotState, FSM
import datetime
import logging
from sqlalchemy import select
from app.database import async_session
from app.models import BotConversation, BotMessage
from app.max_api import max_api
from app.keyboards import consent_keyboard
logger = logging.getLogger(__name__)
async def handle_handoff_request(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
user = await get_or_create_user(db, max_user_id)
async def handle_callback(user_id: int, callback_id: str, callback_data: dict) -> None:
async with async_session() as db:
result = await db.execute(
select(BotConversation)
.where(BotConversation.user_id == user_id)
.order_by(BotConversation.id.desc())
.limit(1)
)
conv = result.scalar_one_or_none()
if not SettingsCache.is_work_hours():
from app.handlers.out_of_hours import handle_out_of_hours
await handle_out_of_hours(bot, user_data, db, max_api)
return
conv_id = conv.id if conv else 0
text = await get_template_rendered(db, "handoff")
await max_api.send_message(max_user_id, text)
conv = await get_open_conversation(db, user.id)
if conv:
conv.status = "handoff"
conv.priority = "high"
await db.flush()
from app.integrations import _1c_unf as ic_integration
await ic_integration.send_to_1c(db, conv)
FSM.set_state(max_user_id, BotState.HANDOFF_REQUEST)
if callback_id.startswith("consent_"):
from app.handlers.consent import handle_consent_callback
await handle_consent_callback(user_id, conv_id, callback_id)
else:
await max_api.send_message(
user_id,
"Извините, я не распознала действие. Пожалуйста, воспользуйтесь кнопками.",
)
async def handle_inquiry_fallback(bot, user_data, db, max_api):
from app.handlers.inquiry import handle_inquiry
await handle_inquiry(bot, user_data, db, max_api)
async def handle_contact_share(
user_id: int,
conv_id: int,
phone: str,
vcf_info: str = "",
vcf_data: dict = None,
contact_hash: str = "",
) -> None:
if vcf_data is None:
vcf_data = {}
async with async_session() as db:
from app.models import BotUser
user_result = await db.execute(select(BotUser).where(BotUser.id == user_id))
user = user_result.scalar_one_or_none()
if user:
user.phone = phone or user.phone
if vcf_data.get("first_name"):
user.first_name = vcf_data["first_name"]
if vcf_data.get("last_name"):
user.last_name = vcf_data["last_name"]
if vcf_data.get("patronymic"):
user.patronymic = vcf_data["patronymic"]
if vcf_data.get("email"):
user.email = vcf_data["email"]
if vcf_data.get("organization"):
user.organization = vcf_data["organization"]
if vcf_data.get("address"):
user.address = vcf_data["address"]
if vcf_info:
user.vcf_raw = vcf_info
if contact_hash:
user.contact_hash = contact_hash
user.phone_verified = True
if phone:
user.phone_verified = True
msg = BotMessage(
conversation_id=conv_id,
direction="incoming",
text=f"[Контакт поделен] {phone or vcf_data.get('phone', '')}",
created_at=datetime.datetime.utcnow(),
)
db.add(msg)
conv_result = await db.execute(
select(BotConversation).where(BotConversation.id == conv_id)
)
conv = conv_result.scalar_one_or_none()
if conv:
conv.state = "awaiting_inquiry"
await db.commit()
await max_api.send_message(
user_id,
"Спасибо! Ваш контакт получен.\n\n"
"Опишите, пожалуйста, суть вашего обращения — "
"расскажите подробнее, чем мы можем вам помочь.",
)
max_bot/app/handlers/inquiry.py
+117 -111
View File
@@ -1,122 +1,128 @@
from app.settings_cache import SettingsCache
from app.conversation import (
get_or_create_user, get_open_conversation, create_conversation,
add_message, auto_categorize_text, get_template_rendered
)
from app.integrations.yandex_gpt import categorize_with_gpt
from app.keyboards.inline import build_category_buttons
from app.fsm import BotState, FSM
import datetime
import logging
from sqlalchemy import select
from app.database import async_session
from app.models import BotUser, BotConversation, BotMessage, BotTicket, BotTicketMessage, BotTicketStatus
from app.max_api import max_api
from app.settings_cache import settings_cache
from app.config_reader import config_reader
from app.email_sender import email_sender
logger = logging.getLogger(__name__)
async def handle_inquiry(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
text = user_data.get("text", "").strip()
user = await get_or_create_user(db, max_user_id)
async def handle_inquiry(user_id: int, conv_id: int, text: str) -> None:
async with async_session() as db:
result = await db.execute(
select(BotConversation).where(BotConversation.id == conv_id)
)
conv = result.scalar_one_or_none()
if not conv:
return
if not text:
await max_api.send_message(max_user_id, "Пожалуйста, опишите ваш вопрос.")
return
user_result = await db.execute(select(BotUser).where(BotUser.id == user_id))
user = user_result.scalar_one_or_none()
conv = await get_open_conversation(db, user.id)
if not conv:
conv = await create_conversation(db, user.id)
conv.inquiry_text = text
conv.state = "escalated"
await db.commit()
conv.inquiry_text = text
has_attachment = user_data.get("has_attachment", False)
attachment_type = user_data.get("attachment_type", "")
attachment_path_str = user_data.get("attachment_path", "")
if has_attachment:
conv.has_attachment = True
conv.attachment_type = attachment_type
conv.attachment_path = attachment_path_str
await add_message(db, conv.id, "in", text, has_attachment, attachment_type, attachment_path_str)
if has_attachment and attachment_path_str and max_api:
try:
file_url = await max_api.get_file_url(attachment_path_str)
if file_url:
import os
import aiohttp
from app.config import get_settings
from app.models.models import FileSyncQueue
settings = get_settings()
local_dir = settings.UPLOADS_DIR
os.makedirs(local_dir, exist_ok=True)
local_filename = f"conv_{conv.id}_{int(datetime.now().timestamp())}_{attachment_type}"
local_path = os.path.join(local_dir, local_filename)
async with aiohttp.ClientSession() as session:
async with session.get(file_url) as resp:
if resp.status == 200:
with open(local_path, "wb") as f:
f.write(await resp.read())
sync_entry = FileSyncQueue(
local_path=local_path,
remote_path=f"/AegisOne_Service/bot/{local_filename}",
entity_type="conversation",
entity_id=conv.id,
status="pending",
)
db.add(sync_entry)
except Exception:
pass
gpt_key = SettingsCache.get("yandex_gpt_key")
if gpt_key:
cat_name = await categorize_with_gpt(text)
if cat_name:
from sqlalchemy import select
from app.models.models import BotCategory
result = await db.execute(
select(BotCategory).where(
BotCategory.name.ilike(f"%{cat_name}%"),
BotCategory.active == True
).limit(1)
)
cat = result.scalar_one_or_none()
if cat:
conv.inquiry_type = cat.id
await db.flush()
confirm_text = await get_template_rendered(db, "auto_categorize_confirm", category=cat.name)
from app.keyboards.inline import build_category_buttons
buttons = build_category_buttons()
await max_api.send_message_with_keyboard(max_user_id, confirm_text, buttons)
FSM.set_state(max_user_id, BotState.CATEGORY_SELECT)
return
else:
cat = await auto_categorize_text(db, text)
if cat:
conv.inquiry_type = cat.id
await db.flush()
await db.flush()
ooh = not SettingsCache.is_work_hours()
if ooh:
start = SettingsCache.get_int("work_hours_start", 9)
end = SettingsCache.get_int("work_hours_end", 18)
ooh_text = await get_template_rendered(db, "out_of_hours",
work_hours_start=start, work_hours_end=end)
await max_api.send_message(max_user_id, ooh_text)
await _confirm_inquiry(bot, user_data, db, max_api, conv, ooh)
await _finalize_ticket(user_id, conv, user, text)
async def _confirm_inquiry(bot, user_data, db, max_api, conv, is_ooh: bool):
max_user_id = user_data["user_id"]
user = await get_or_create_user(db, max_user_id)
async def _finalize_ticket(
user_id: int,
conv: BotConversation,
user: BotUser,
inquiry_text: str,
) -> None:
async with async_session() as db:
user_name = user.first_name or user.last_name or ""
ticket_title = f"Обращение от {user_name or 'клиента'} ({user_id})"
if len(inquiry_text) > 100:
ticket_title = inquiry_text[:97] + "..."
if is_ooh:
text = await get_template_rendered(db, "confirmation_ooh",
first_name=user.first_name, conv_id=conv.id)
else:
text = await get_template_rendered(db, "confirmation",
first_name=user.first_name, conv_id=conv.id)
ticket = BotTicket(
user_id=user_id,
title=ticket_title,
description=inquiry_text,
priority="normal",
status="Новая",
created_by="bot",
)
db.add(ticket)
await db.commit()
await db.refresh(ticket)
await max_api.send_message(max_user_id, text, format="markdown")
msg = BotTicketMessage(
ticket_id=ticket.id,
direction="incoming",
text=inquiry_text,
)
db.add(msg)
from app.integrations import _1c_unf as ic_integration
await ic_integration.send_to_1c(db, conv)
status_log = BotTicketStatus(
ticket_id=ticket.id,
new_status="Новая",
changed_by="bot",
)
db.add(status_log)
FSM.set_state(max_user_id, BotState.CONFIRMATION)
conv_result = await db.execute(
select(BotConversation).where(BotConversation.id == conv.id)
)
conv_obj = conv_result.scalar_one_or_none()
if conv_obj:
conv_obj.state = "completed"
await db.commit()
async with async_session() as db2:
user_obj = await db2.get(BotUser, user_id)
if user_obj:
user_obj.total_tickets = (user_obj.total_tickets or 0) + 1
await db2.commit()
user_info = f"ID: {user_id}\nИмя: {user.first_name or 'не указано'} {user.last_name or ''}"
contact = user.phone or "не указан"
history = await _get_conversation_history(conv.id)
support_email = await settings_cache.get("support_email", "zakaz@aegisone.ru")
email_subject = await settings_cache.get(
"email_subject",
"Обращение через Виртуального помощника AegisOne Engineering",
)
email_sender.send_ticket_escalation(
to=support_email,
subject=email_subject,
user_info=user_info,
contact=contact,
inquiry=inquiry_text,
history=history,
)
await max_api.send_message(
user_id,
f"Зафиксировала: {inquiry_text}\n\n"
f"Ваша заявка отправлена инженеру. В ближайшее время он обязательно "
f"свяжется с вами.",
)
async def _get_conversation_history(conv_id: int) -> str:
async with async_session() as db:
result = await db.execute(
select(BotMessage)
.where(BotMessage.conversation_id == conv_id)
.order_by(BotMessage.id)
)
messages = result.scalars().all()
lines = []
for msg in messages:
direction = "Клиент" if msg.direction == "incoming" else "Бот"
time_str = msg.created_at.strftime("%d.%m.%Y %H:%M") if msg.created_at else ""
lines.append(f"[{time_str}] {direction}: {msg.text or ''}")
return "\n".join(lines)
max_bot/app/handlers/main_menu.py
-103
View File
@@ -1,103 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_or_create_user, get_template_rendered
from app.keyboards.inline import build_main_menu_buttons
from app.fsm import BotState, FSM
async def handle_main_menu(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
payload = user_data.get("payload", "")
if payload == "new_inquiry":
user = await get_or_create_user(db, max_user_id)
if user.consent_given:
from app.handlers.contact import handle_contact_provided
await handle_contact_provided(bot, user_data, db, max_api)
else:
from app.handlers.consent import handle_consent_request
await handle_consent_request(bot, user_data, db, max_api)
return
if payload == "handoff":
from app.handlers.handoff import handle_handoff_request
await handle_handoff_request(bot, user_data, db, max_api)
return
if payload == "kb_search":
FSM.set_state(max_user_id, BotState.KB_SEARCH)
await max_api.send_message(max_user_id, "Задайте ваш вопрос, и я постараюсь найти ответ.")
return
if payload.startswith("feature_"):
feature_key = payload.replace("feature_", "")
if SettingsCache.is_feature_enabled(feature_key):
await _handle_feature(bot, user_data, db, max_api, feature_key)
else:
await max_api.send_message(max_user_id, "Этот функционал временно недоступен.")
return
if payload.startswith("cat_"):
await _handle_category_select(bot, user_data, db, max_api, payload)
return
if payload == "cancel":
FSM.reset(max_user_id)
text = await get_template_rendered(db, "main_menu")
buttons = build_main_menu_buttons()
await max_api.send_message_with_keyboard(max_user_id, text, buttons)
return
FSM.reset(max_user_id)
text = await get_template_rendered(db, "main_menu")
buttons = build_main_menu_buttons()
await max_api.send_message_with_keyboard(max_user_id, text, buttons)
async def _handle_feature(bot, user_data, db, max_api, feature_key: str):
feature_handlers = {
"risk_score": ("app.handlers.features.risk_score", "handle_risk_score"),
"sla_status": ("app.handlers.features.sla_status", "handle_sla_status"),
"photo_report": ("app.handlers.features.photo_report", "handle_photo_report"),
"appointment": ("app.handlers.features.appointment", "handle_appointment"),
"quality_rate": ("app.handlers.features.quality_rate", "handle_quality_rate"),
"commercial_offer": ("app.handlers.features.commercial", "handle_commercial"),
"my_objects": ("app.handlers.features.my_objects", "handle_my_objects"),
"reminders": ("app.handlers.features.reminders", "handle_reminders"),
"sla_ticket": ("app.handlers.features.sla_ticket", "handle_sla_ticket"),
"notifications": ("app.handlers.features.notifications", "handle_notifications"),
"broadcasts": ("app.handlers.features.broadcasts", "handle_broadcast_send"),
}
handler = feature_handlers.get(feature_key)
if handler:
import importlib
mod = importlib.import_module(handler[0])
func = getattr(mod, handler[1])
await func(bot, user_data, db, max_api)
else:
await max_api.send_message(max_user_id, "Функция в разработке.")
async def _handle_category_select(bot, user_data, db, max_api, payload: str):
max_user_id = user_data["user_id"]
try:
cat_id = int(payload.replace("cat_", ""))
except ValueError:
return
from sqlalchemy import select
from app.models.models import BotCategory
result = await db.execute(select(BotCategory).where(BotCategory.id == cat_id))
cat = result.scalar_one_or_none()
if not cat:
return
from app.conversation import get_open_conversation, get_or_create_user
user = await get_or_create_user(db, max_user_id)
conv = await get_open_conversation(db, user.id)
if conv:
conv.inquiry_type = cat.id
await db.flush()
ooh = not SettingsCache.is_work_hours()
from app.handlers.inquiry import _confirm_inquiry
await _confirm_inquiry(bot, user_data, db, max_api, conv, ooh)
max_bot/app/handlers/out_of_hours.py
-43
View File
@@ -1,43 +0,0 @@
from app.settings_cache import SettingsCache
from app.conversation import get_template_rendered
from app.keyboards.inline import build_cancel_button
from app.fsm import BotState, FSM
from app.handlers.main_menu import handle_main_menu
async def handle_out_of_hours(bot, user_data: dict, db, max_api):
max_user_id = user_data["user_id"]
await SettingsCache.refresh(db)
start = SettingsCache.get_int("work_hours_start", 9)
end = SettingsCache.get_int("work_hours_end", 18)
hours_str = SettingsCache.get_work_hours_str()
text = (
f"Сейчас мы не работаем. Наше рабочее время: Пн-Пт {hours_str} (МСК).\n\n"
f"Оставьте сообщение — мы ответим как можно быстрее."
)
buttons = [
[{"type": "message", "text": "✉️ Оставить сообщение", "payload": "leave_message"}],
[{"type": "message", "text": "📞 Заказать звонок", "payload": "callback"}],
]
await max_api.send_message_with_keyboard(max_user_id, text, buttons)
FSM.set_state(max_user_id, BotState.OUT_OF_HOURS)
async def handle_out_of_hours_callback(bot, user_data: dict, db, max_api, payload: str):
max_user_id = user_data["user_id"]
if payload == "leave_message":
FSM.set_state(max_user_id, BotState.INQUIRY_REQUEST)
from app.handlers.inquiry import handle_inquiry
await handle_inquiry(bot, user_data, db, max_api)
return
if payload == "callback":
from app.handlers.consent import handle_consent_request
FSM.set_state(max_user_id, BotState.NAME_REQUEST)
await max_api.send_message(max_user_id, "Как к вам обращаться?")
return
await handle_main_menu(bot, user_data, db, max_api)
max_bot/app/integrations/_1c_unf.py
-100
View File
@@ -1,100 +0,0 @@
import json
import logging
from datetime import datetime
from typing import Optional
import aiohttp
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.models import BotConversation, Bot1CSyncLog, BotSetting
from app.settings_cache import SettingsCache
logger = logging.getLogger(__name__)
async def send_to_1c(db: AsyncSession, conversation: BotConversation) -> Optional[dict]:
webhook_url = SettingsCache.get("1c_webhook_url")
if not webhook_url:
return None
user = conversation.user
category = conversation.category
payload = {
"conversation_id": conversation.id,
"user": {
"max_user_id": user.max_user_id,
"first_name": user.first_name,
"last_name": user.last_name,
"phone": user.phone,
"email": user.email,
},
"inquiry": {
"text": conversation.inquiry_text,
"category": category.name if category else "",
"priority": conversation.priority,
"has_attachment": conversation.has_attachment,
"attachment_type": conversation.attachment_type,
},
"created_at": conversation.created_at.isoformat() if conversation.created_at else "",
}
sync_log = Bot1CSyncLog(
conversation_id=conversation.id,
status="pending",
request_payload=json.dumps(payload, ensure_ascii=False),
)
db.add(sync_log)
await db.flush()
try:
async with aiohttp.ClientSession() as session:
async with session.post(webhook_url, json=payload, timeout=aiohttp.ClientTimeout(total=30)) as resp:
response_text = await resp.text()
sync_log.status = "sent" if resp.status == 200 else "error"
sync_log.response_payload = response_text
sync_log.sent_at = datetime.now()
await db.flush()
if resp.status == 200:
try:
return await resp.json()
except Exception:
return {"raw": response_text}
logger.warning(f"1C webhook returned {resp.status}: {response_text[:500]}")
return None
except Exception as e:
logger.error(f"1C webhook error: {e}")
sync_log.status = "error"
sync_log.response_payload = str(e)
sync_log.sent_at = datetime.now()
await db.flush()
return None
async def handle_1c_response(db: AsyncSession, data: dict) -> bool:
conversation_id = data.get("conversation_id")
if not conversation_id:
return False
result = await db.execute(select(BotConversation).where(BotConversation.id == int(conversation_id)))
conv = result.scalar_one_or_none()
if not conv:
return False
sync_log = Bot1CSyncLog(
conversation_id=conv.id,
status="confirmed",
response_payload=json.dumps(data, ensure_ascii=False),
confirmed_at=datetime.now(),
)
db.add(sync_log)
status = data.get("status", "")
if status:
conv.status = status
assigned = data.get("assigned_to", "")
if assigned:
conv.assigned_to = assigned
await db.flush()
return True
max_bot/app/integrations/__init__.py
View File
max_bot/app/integrations/__pycache__/_1c_unf.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/integrations/__pycache__/_1c_unf.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/integrations/__pycache__/__init__.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/integrations/__pycache__/portal_db.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/integrations/__pycache__/portal_db.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/integrations/__pycache__/yandex_gpt.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/integrations/__pycache__/yandex_gpt.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/integrations/portal_db.py
-57
View File
@@ -1,57 +0,0 @@
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.models import Object, SLAContract, Task, Incident, Customer
async def get_object_by_name_or_id(db: AsyncSession, query: str) -> Object:
try:
obj_id = int(query)
return await db.get(Object, obj_id)
except (ValueError, TypeError):
result = await db.execute(
select(Object).where(Object.name.ilike(f"%{query}%")).limit(1)
)
return result.scalar_one_or_none()
async def get_sla_for_object(db: AsyncSession, object_id: int) -> SLAContract:
result = await db.execute(
select(SLAContract).where(
SLAContract.object_id == object_id,
SLAContract.status == "active"
).order_by(SLAContract.created_at.desc()).limit(1)
)
return result.scalar_one_or_none()
async def get_objects_for_customer(db: AsyncSession, customer_name: str) -> list:
result = await db.execute(
select(Customer).where(Customer.name.ilike(f"%{customer_name}%")).limit(1)
)
customer = result.scalar_one_or_none()
if not customer:
return []
result = await db.execute(
select(Object).where(Object.customer_id == customer.id, Object.status == "active")
)
return result.scalars().all()
async def get_active_tasks_for_object(db: AsyncSession, object_id: int) -> list:
result = await db.execute(
select(Task).where(
Task.object_id == object_id,
Task.status.in_(["open", "in_progress"])
)
)
return result.scalars().all()
async def get_last_incident_for_object(db: AsyncSession, object_id: int):
result = await db.execute(
select(Incident).where(
Incident.object_id == object_id,
Incident.status.in_(["resolved", "closed"])
).order_by(Incident.created_at.desc()).limit(1)
)
return result.scalar_one_or_none()
max_bot/app/integrations/yandex_gpt.py
-80
View File
@@ -1,80 +0,0 @@
import aiohttp
import logging
from app.settings_cache import SettingsCache
logger = logging.getLogger(__name__)
async def categorize_with_gpt(text: str) -> str:
gpt_key = SettingsCache.get("yandex_gpt_key")
folder_id = SettingsCache.get("yandex_folder_id")
if not gpt_key or not folder_id:
return ""
prompt = (
"Определи категорию обращения клиента из списка: "
"Видеонаблюдение, СКУД, Пожарная сигнализация, IT-инфраструктура, "
"Обслуживание, Консультация, Другое. "
"Ответь только названием категории, без пояснений. "
f"Текст обращения: {text}"
)
url = "https://llm.api.cloud.yandex.net/foundationModels/v1/completion"
headers = {
"Authorization": f"Api-Key {gpt_key}",
"Content-Type": "application/json",
"x-folder-id": folder_id,
}
body = {
"modelUri": f"gpt://{folder_id}/yandexgpt-lite/latest",
"completionOptions": {"stream": False, "temperature": 0.1, "maxTokens": 50},
"messages": [{"role": "user", "text": prompt}],
}
try:
async with aiohttp.ClientSession() as session:
async with session.post(url, headers=headers, json=body) as resp:
if resp.status == 200:
data = await resp.json()
return data.get("result", {}).get("alternatives", [{}])[0].get("message", {}).get("text", "").strip()
logger.warning(f"GPT categorize returned {resp.status}")
except Exception as e:
logger.error(f"GPT categorize error: {e}")
return ""
async def analyze_emotion_with_gpt(text: str) -> str:
gpt_key = SettingsCache.get("yandex_gpt_key")
folder_id = SettingsCache.get("yandex_folder_id")
if not gpt_key or not folder_id:
return "neutral"
prompt = (
"Определи эмоциональную окраску текста клиента. "
"Варианты: positive, neutral, negative. "
"Ответь только одним словом. "
f"Текст: {text}"
)
url = "https://llm.api.cloud.yandex.net/foundationModels/v1/completion"
headers = {
"Authorization": f"Api-Key {gpt_key}",
"Content-Type": "application/json",
"x-folder-id": folder_id,
}
body = {
"modelUri": f"gpt://{folder_id}/yandexgpt-lite/latest",
"completionOptions": {"stream": False, "temperature": 0.1, "maxTokens": 10},
"messages": [{"role": "user", "text": prompt}],
}
try:
async with aiohttp.ClientSession() as session:
async with session.post(url, headers=headers, json=body) as resp:
if resp.status == 200:
data = await resp.json()
return data.get("result", {}).get("alternatives", [{}])[0].get("message", {}).get("text", "").strip().lower()
logger.warning(f"GPT emotion analysis returned {resp.status}")
except Exception as e:
logger.error(f"GPT emotion analysis error: {e}")
return "neutral"
max_bot/app/keyboards.py
+77
View File
@@ -0,0 +1,77 @@
from typing import Optional, List, Dict, Any
POLITICA_URL = "https://aegisone.ru/politica.php"
def _callback_button(text: str, payload: str, intent: str = "default") -> dict:
return {
"type": "callback",
"text": text,
"payload": payload,
"intent": intent,
}
def _link_button(text: str, url: str) -> dict:
return {
"type": "link",
"text": text,
"url": url,
}
def _request_contact_button(text: str) -> dict:
return {
"type": "request_contact",
"text": text,
}
def _message_button(text: str) -> dict:
return {
"type": "message",
"text": text,
}
def make_inline_keyboard(buttons: List[List[Dict[str, Any]]]) -> List[Dict[str, Any]]:
return [
{
"type": "inline_keyboard",
"payload": {"buttons": buttons},
}
]
def consent_keyboard() -> list:
return make_inline_keyboard([
[
_callback_button("✅ Даю согласие", "consent_yes", intent="positive"),
_link_button("📄 Подробнее", POLITICA_URL),
_callback_button("❌ Не даю согласие", "consent_no", intent="negative"),
],
])
def contact_keyboard() -> list:
return make_inline_keyboard([
[
_request_contact_button("📱 Поделиться контактом"),
],
])
def single_button_keyboard(text: str, payload: str, intent: str = "default") -> list:
return make_inline_keyboard([
[
_callback_button(text, payload, intent),
],
])
def return_to_consent_keyboard() -> list:
return make_inline_keyboard([
[
_callback_button("✅ Даю согласие", "consent_yes", intent="positive"),
],
])
max_bot/app/keyboards/__init__.py
View File
max_bot/app/keyboards/__pycache__/__init__.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/keyboards/__pycache__/inline.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/keyboards/__pycache__/inline.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/keyboards/inline.py
-90
View File
@@ -1,90 +0,0 @@
from app.settings_cache import SettingsCache
def build_main_menu_buttons() -> list:
buttons = []
row = [
{"type": "message", "text": "📋 Оставить заявку", "payload": "new_inquiry"},
{"type": "message", "text": "📞 Связаться с оператором", "payload": "handoff"},
]
buttons.append(row)
features = SettingsCache.get_enabled_features()
feature_buttons = []
feature_map = {
"risk_score": ("📊 Risk Score", "feature_risk_score"),
"sla_status": ("🔍 SLA статус", "feature_sla_status"),
"photo_report": ("📸 Фото-отчёт", "feature_photo_report"),
"appointment": ("📅 Запись на визит", "feature_appointment"),
"quality_rate": ("⭐ Оценка качества", "feature_quality_rate"),
"commercial_offer": ("📄 Коммерческое предложение", "feature_commercial"),
"my_objects": ("🏢 Мои объекты", "feature_my_objects"),
"reminders": ("🔔 Напоминания", "feature_reminders"),
"notifications": ("🔔 Уведомления", "feature_notifications"),
"broadcasts": ("📢 Рассылки", "feature_broadcast"),
}
for key, (label, payload) in feature_map.items():
if key in features:
feature_buttons.append({"type": "message", "text": label, "payload": payload})
while feature_buttons:
buttons.append(feature_buttons[:2])
feature_buttons = feature_buttons[2:]
row = [{"type": "message", "text": "❓ Задать вопрос", "payload": "kb_search"}]
buttons.append(row)
return buttons
def build_consent_buttons() -> list:
return [[
{"type": "message", "text": "✅ Даю согласие", "payload": "consent_given"},
], [
{"type": "message", "text": "❌ Не даю согласие", "payload": "consent_refused"},
]]
def build_contact_buttons() -> list:
return [[
{"type": "request_contact", "text": "📱 Поделиться контактом"},
]]
def build_category_buttons() -> list:
categories = SettingsCache.get_categories()
buttons = []
row = []
for cat in categories:
row.append({"type": "message", "text": f"{cat.icon_emoji} {cat.name}", "payload": f"cat_{cat.id}"})
if len(row) >= 2:
buttons.append(row)
row = []
if row:
buttons.append(row)
return buttons
def build_quality_buttons() -> list:
return [[
{"type": "callback", "text": "⭐", "payload": "rate_1"},
{"type": "callback", "text": "⭐⭐", "payload": "rate_2"},
{"type": "callback", "text": "⭐⭐⭐", "payload": "rate_3"},
], [
{"type": "callback", "text": "⭐⭐⭐⭐", "payload": "rate_4"},
{"type": "callback", "text": "⭐⭐⭐⭐⭐", "payload": "rate_5"},
]]
def build_cancel_button() -> list:
return [[{"type": "message", "text": "↩️ Отмена", "payload": "cancel"}]]
def build_phone_email_buttons(phone_1: str, phone_2: str, email: str, subject: str) -> list:
from urllib.parse import quote
buttons = [
[{"type": "link", "text": f"📞 {phone_1}", "url": f"tel:{phone_1.replace(' ', '').replace('-', '').replace('(', '').replace(')', '')}"}],
[{"type": "link", "text": f"📞 {phone_2}", "url": f"tel:{phone_2.replace(' ', '').replace('-', '').replace('(', '').replace(')', '')}"}],
[{"type": "link", "text": f"✉️ {email}", "url": f"mailto:{email}?subject={quote(subject)}"}],
]
return buttons
max_bot/app/main.py
+474 -806
View File
File diff suppressed because it is too large Load Diff
max_bot/app/max_api.py
+81 -143
View File
@@ -1,159 +1,97 @@
import os
import re
import hmac
import hashlib
import logging
from datetime import datetime
import httpx
from typing import Optional
import aiohttp
logger = logging.getLogger(__name__)
MAX_API_URL = "https://platform-api.max.ru"
from app.config import settings
class MaxAPIClient:
def __init__(self, token: str, test_mode: bool = False):
self.token = token
self.test_mode = test_mode
self._session: Optional[aiohttp.ClientSession] = None
self.test_messages: list = []
async def _get_session(self) -> aiohttp.ClientSession:
if self._session is None or self._session.closed:
self._session = aiohttp.ClientSession()
return self._session
async def close(self):
if self._session and not self._session.closed:
await self._session.close()
class MaxAPI:
def __init__(self):
self.base_url = settings.max_api_base
self.token = settings.max_token
self.client = httpx.AsyncClient(timeout=30.0)
def _headers(self) -> dict:
return {"Authorization": self.token, "Content-Type": "application/json"}
async def _request(self, method: str, path: str, **kwargs) -> dict:
if self.test_mode:
logger.info(f"[TEST_MODE] {method} {path} kwargs={kwargs}")
return {"ok": True, "test_mode": True}
session = await self._get_session()
url = f"{MAX_API_URL}{path}"
async with session.request(method, url, headers=self._headers(), **kwargs) as resp:
if resp.status >= 400:
body = await resp.text()
logger.error(f"Max API error {resp.status}: {body}")
resp.raise_for_status()
return await resp.json()
return {
"Authorization": self.token,
"Content-Type": "application/json",
}
async def get_me(self) -> dict:
return await self._request("GET", "/me")
r = await self.client.get(f"{self.base_url}/me", headers=self._headers())
r.raise_for_status()
return r.json()
async def send_message(self, user_id: int = None, chat_id: int = None, text: str = "",
attachments: list = None, format: str = None,
disable_link_preview: bool = False, notify: bool = True) -> dict:
body = {"text": text}
if attachments:
body["attachments"] = attachments
if format:
body["format"] = format
if not disable_link_preview:
body["disable_link_preview"] = False
if not notify:
body["notify"] = False
params = {}
if user_id:
params["user_id"] = user_id
if chat_id:
params["chat_id"] = chat_id
if self.test_mode:
msg = {"role": "bot", "text": text, "format": format}
if attachments:
msg["attachments"] = attachments
self.test_messages.append(msg)
return await self._request("POST", "/messages", json=body, params=params)
async def send_message_with_keyboard(self, user_id: int, text: str, buttons: list,
format: str = None) -> dict:
attachments = [{
"type": "inline_keyboard",
"payload": {"buttons": buttons}
}]
return await self.send_message(user_id=user_id, text=text, attachments=attachments, format=format)
async def edit_message(self, message_id: int, text: str, attachments: list = None) -> dict:
body = {"text": text}
if attachments:
body["attachments"] = attachments
return await self._request("PUT", f"/messages/{message_id}", json=body)
async def get_message(self, message_id: int) -> dict:
return await self._request("GET", f"/messages/{message_id}")
async def get_messages(self, user_id: int = None, chat_id: int = None, limit: int = 10) -> dict:
params = {"limit": limit}
if user_id:
params["user_id"] = user_id
if chat_id:
params["chat_id"] = chat_id
return await self._request("GET", "/messages", params=params)
async def answer_callback(self, callback_id: str, text: str = "", show_alert: bool = False) -> dict:
body = {"callback_id": callback_id}
if text:
body["text"] = text
if show_alert:
body["show_alert"] = True
return await self._request("POST", "/answers", json=body)
async def subscribe_webhook(self, url: str, update_types: list = None, secret: str = None) -> dict:
body = {"url": url}
if update_types:
body["update_types"] = update_types
if secret:
body["secret"] = secret
return await self._request("POST", "/subscriptions", json=body)
async def get_subscriptions(self) -> dict:
return await self._request("GET", "/subscriptions")
async def subscribe_webhook(self) -> dict:
payload = {
"url": settings.webhook_url,
"update_types": settings.update_types,
"secret": settings.webhook_secret,
}
r = await self.client.post(
f"{self.base_url}/subscriptions",
headers=self._headers(),
json=payload,
)
r.raise_for_status()
return r.json()
async def unsubscribe_webhook(self) -> dict:
return await self._request("DELETE", "/subscriptions")
r = await self.client.delete(
f"{self.base_url}/subscriptions",
headers=self._headers(),
)
r.raise_for_status()
return r.json()
async def upload_file(self, file_path: str) -> dict:
session = await self._get_session()
url = f"{MAX_API_URL}/uploads"
with open(file_path, "rb") as f:
data = aiohttp.FormData()
data.add_field("file", f, filename=os.path.basename(file_path))
async with session.post(url, headers={"Authorization": self.token}, data=data) as resp:
resp.raise_for_status()
return await resp.json()
async def get_subscriptions(self) -> dict:
r = await self.client.get(
f"{self.base_url}/subscriptions",
headers=self._headers(),
)
r.raise_for_status()
return r.json()
def verify_webhook_secret(self, header_value: str, expected_secret: str) -> bool:
if not expected_secret:
return True
return hmac.compare_digest(header_value, expected_secret)
async def send_message(
self,
user_id: int,
text: str,
attachments: Optional[list] = None,
format: Optional[str] = None,
notify: bool = True,
) -> dict:
payload = {"text": text, "notify": notify}
if attachments:
payload["attachments"] = attachments
if format:
payload["format"] = format
r = await self.client.post(
f"{self.base_url}/messages?user_id={user_id}",
headers=self._headers(),
json=payload,
)
r.raise_for_status()
return r.json()
async def send_file(self, user_id: int, file_path: str, caption: str = "") -> dict:
upload = await self.upload_file(file_path)
file_id = upload.get("file_id", "")
body = {"text": caption, "attachments": [{"type": "file", "payload": {"file_id": file_id}}]}
return await self._request("POST", "/messages", json=body, params={"user_id": user_id})
async def answer_callback(
self,
callback_id: str,
message: Optional[dict] = None,
notification: Optional[str] = None,
) -> dict:
payload = {}
if message is not None:
payload["message"] = message
if notification is not None:
payload["notification"] = notification
r = await self.client.post(
f"{self.base_url}/answers?callback_id={callback_id}",
headers=self._headers(),
json=payload,
)
r.raise_for_status()
return r.json()
async def get_file_url(self, file_id: str) -> str:
resp = await self._request("GET", f"/uploads/{file_id}")
return resp.get("url", "")
async def close(self):
await self.client.aclose()
async def send_contact_request(self, user_id: int, text: str = "Пожалуйста, отправьте ваш контакт") -> dict:
attachments = [{
"type": "contact_request",
"payload": {"text": text}
}]
return await self.send_message(user_id=user_id, text=text, attachments=attachments)
def verify_contact_hash(self, vcf_info: str, access_token: str, expected_hash: str) -> bool:
vcf_normalized = vcf_info.replace("\\r\\n", "\r\n")
computed = hmac.new(access_token.encode(), vcf_normalized.encode(), hashlib.sha256).hexdigest()
return hmac.compare_digest(computed, expected_hash)
max_api = MaxAPI()
max_bot/app/max_notifications.py
-148
View File
@@ -1,148 +0,0 @@
from datetime import datetime
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.models import (
BotNotification, BotNotificationSubscription, BotUser,
)
from app.settings_cache import SettingsCache
try:
from app.models.models import User
except ImportError:
User = None
async def _get_max_user_id_by_role(db: AsyncSession, role: str) -> int | None:
if User is None:
return None
result = await db.execute(
select(User.max_user_id).where(
User.role == role, User.is_active == True,
User.max_user_id.isnot(None)
).limit(1)
)
return result.scalar_one_or_none()
async def _get_user_max_ids_by_role(db: AsyncSession, role: str) -> list[int]:
if User is None:
return []
result = await db.execute(
select(User.max_user_id).where(
User.role == role, User.is_active == True,
User.max_user_id.isnot(None)
)
)
return [row[0] for row in result.fetchall() if row[0]]
async def _log_notification(db: AsyncSession, ntype: str, recipient_type: str,
recipient_max_user_id: int | None, title: str, body: str,
related_type: str = "", related_id: int | None = None):
n = BotNotification(
type=ntype, recipient_type=recipient_type,
recipient_max_user_id=recipient_max_user_id,
title=title, body=body,
related_type=related_type, related_id=related_id
)
db.add(n)
await db.flush()
return n
async def notify_operator(db: AsyncSession, max_api, text: str, title: str = "",
related_type: str = "", related_id: int | None = None):
max_ids = await _get_user_max_ids_by_role(db, "owner")
sent_count = 0
for mid in max_ids:
try:
await max_api.send_message(user_id=mid, text=text, format="markdown")
sent_count += 1
except Exception:
pass
await _log_notification(
db, "operator_alert", "operator", max_ids[0] if max_ids else None,
title or "Уведомление оператору", text,
related_type, related_id
)
return sent_count
async def notify_level2(db: AsyncSession, max_api, text: str, title: str = "",
related_type: str = "", related_id: int | None = None):
max_ids = await _get_user_max_ids_by_role(db, "engineer")
sent_count = 0
for mid in max_ids:
try:
await max_api.send_message(user_id=mid, text=text, format="markdown")
sent_count += 1
except Exception:
pass
await _log_notification(
db, "level2_alert", "level2", max_ids[0] if max_ids else None,
title or "Уведомление инженеру", text,
related_type, related_id
)
return sent_count
async def notify_client_status_change(db: AsyncSession, max_api,
bot_user: BotUser, conv_id: int,
new_status: str):
text = f"Статус вашего обращения №{conv_id} изменён на «{new_status}»."
try:
await max_api.send_message(user_id=bot_user.max_user_id, text=text, format="markdown")
except Exception:
pass
await _log_notification(
db, "status_change", "client", bot_user.max_user_id,
"Статус обращения", text, "conversation", conv_id
)
async def notify_ticket_created(db: AsyncSession, ticket, max_api):
ticket_text = (
f"🆕 **Новый тикет {ticket.ticket_number}**\n"
f"Приоритет: {ticket.priority}\n"
f"Описание: {ticket.description[:200]}\n"
f"Обращение №{ticket.id}"
)
await notify_level2(
db, max_api, ticket_text,
title=f"Тикет {ticket.ticket_number}",
related_type="ticket", related_id=ticket.id
)
async def notify_handoff_escalation(db: AsyncSession, max_api,
bot_user: BotUser, conv_id: int,
text: str = ""):
msg = (
f"🔴 **Эскалация оператору**\n"
f"Пользователь: {bot_user.first_name or '—'} (ID {bot_user.max_user_id})\n"
f"Обращение №{conv_id}\n"
f"Текст: {text[:200] if text else '—'}"
)
await notify_operator(
db, max_api, msg,
title="Эскалация",
related_type="conversation", related_id=conv_id
)
async def get_subscribed_users(db: AsyncSession, notify_type: str = "broadcast") -> list[BotUser]:
col_map = {
"broadcast": BotNotificationSubscription.notify_on_broadcast,
"status_change": BotNotificationSubscription.notify_on_status_change,
"reply": BotNotificationSubscription.notify_on_reply,
}
col = col_map.get(notify_type)
if col is None:
return []
result = await db.execute(
select(BotUser).join(
BotNotificationSubscription,
BotNotificationSubscription.user_id == BotUser.id
).where(col == True)
)
return list(result.scalars().all())
max_bot/app/models.py
+140
View File
@@ -0,0 +1,140 @@
from __future__ import annotations
import datetime
from sqlalchemy import Column, Integer, BigInteger, String, Text, Boolean, DateTime, ForeignKey, ARRAY
from sqlalchemy.orm import DeclarativeBase, relationship
class Base(DeclarativeBase):
pass
class BotSetting(Base):
__tablename__ = "bot_settings"
id = Column(Integer, primary_key=True, autoincrement=True)
key = Column(String(255), unique=True, nullable=False)
value = Column(Text, nullable=True)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
class BotFeature(Base):
__tablename__ = "bot_features"
id = Column(Integer, primary_key=True, autoincrement=True)
key = Column(String(255), unique=True, nullable=False)
name = Column(String(255), nullable=False)
description = Column(Text, nullable=True)
is_enabled = Column(Boolean, default=False)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
class BotCategory(Base):
__tablename__ = "bot_categories"
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(255), nullable=False)
description = Column(Text, nullable=True)
sort_order = Column(Integer, default=0)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
class BotKnowledgeBase(Base):
__tablename__ = "bot_knowledge_base"
id = Column(Integer, primary_key=True, autoincrement=True)
category_id = Column(Integer, ForeignKey("bot_categories.id"), nullable=True)
question = Column(Text, nullable=False)
answer = Column(Text, nullable=True)
keywords = Column(ARRAY(String), nullable=True)
is_active = Column(Boolean, default=True)
source_url = Column(String(500), nullable=True)
sort_order = Column(Integer, default=0)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
category = relationship("BotCategory", lazy="joined")
class BotUser(Base):
__tablename__ = "bot_users"
id = Column(BigInteger, primary_key=True)
first_name = Column(String(255), nullable=True)
last_name = Column(String(255), nullable=True)
patronymic = Column(String(255), nullable=True)
username = Column(String(255), nullable=True)
phone = Column(String(50), nullable=True)
email = Column(String(255), nullable=True)
organization = Column(String(255), nullable=True)
address = Column(Text, nullable=True)
vcf_raw = Column(Text, nullable=True)
contact_hash = Column(String(255), nullable=True)
phone_verified = Column(Boolean, default=False)
email_verified = Column(Boolean, default=False)
consent_given = Column(Boolean, default=False)
consent_date = Column(DateTime, nullable=True)
last_interaction = Column(DateTime, nullable=True)
total_conversations = Column(Integer, default=0)
total_tickets = Column(Integer, default=0)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
class BotConversation(Base):
__tablename__ = "bot_conversations"
id = Column(BigInteger, primary_key=True, autoincrement=True)
user_id = Column(BigInteger, ForeignKey("bot_users.id"), nullable=False)
state = Column(String(50), default="greeting")
intent = Column(String(50), nullable=True)
inquiry_text = Column(Text, nullable=True)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
user = relationship("BotUser", lazy="joined")
class BotMessage(Base):
__tablename__ = "bot_messages"
id = Column(BigInteger, primary_key=True, autoincrement=True)
conversation_id = Column(BigInteger, ForeignKey("bot_conversations.id"), nullable=False)
direction = Column(String(10), nullable=False)
text = Column(Text, nullable=True)
attachment_json = Column(Text, nullable=True)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
conversation = relationship("BotConversation", lazy="joined")
class BotTicket(Base):
__tablename__ = "bot_tickets"
id = Column(BigInteger, primary_key=True, autoincrement=True)
user_id = Column(BigInteger, ForeignKey("bot_users.id"), nullable=False)
title = Column(String(500), nullable=True)
description = Column(Text, nullable=True)
priority = Column(String(20), default="normal")
status = Column(String(20), default="Новая")
created_by = Column(String(100), default="bot")
assigned_to = Column(BigInteger, nullable=True)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
user = relationship("BotUser", lazy="joined")
class BotTicketMessage(Base):
__tablename__ = "bot_ticket_messages"
id = Column(BigInteger, primary_key=True, autoincrement=True)
ticket_id = Column(BigInteger, ForeignKey("bot_tickets.id"), nullable=False)
direction = Column(String(10), nullable=False)
text = Column(Text, nullable=True)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
ticket = relationship("BotTicket", lazy="joined")
class BotTicketStatus(Base):
__tablename__ = "bot_ticket_statuses"
id = Column(BigInteger, primary_key=True, autoincrement=True)
ticket_id = Column(BigInteger, ForeignKey("bot_tickets.id"), nullable=False)
old_status = Column(String(20), nullable=True)
new_status = Column(String(20), nullable=False)
changed_by = Column(String(100), nullable=True)
created_at = Column(DateTime, default=datetime.datetime.utcnow)
ticket = relationship("BotTicket", lazy="joined")
max_bot/app/models/__init__.py
View File
max_bot/app/models/__pycache__/__init__.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/models/__pycache__/models.cpython-314.pyc
BIN
View File
Binary file not shown.
max_bot/app/models/__pycache__/models.cpython-38.pyc
BIN
View File
Binary file not shown.
max_bot/app/models/models.py
-350
View File
@@ -1,350 +0,0 @@
from datetime import datetime
from sqlalchemy import (
Column, Integer, String, Boolean, Text, DateTime, BigInteger, SmallInteger, JSON, ForeignKey, CheckConstraint, text as sa_text
)
from sqlalchemy.orm import relationship, declarative_base
Base = declarative_base()
class BotUser(Base):
__tablename__ = "bot_users"
id = Column(Integer, primary_key=True, autoincrement=True)
max_user_id = Column(BigInteger, unique=True, nullable=False)
first_name = Column(String(255), default="")
last_name = Column(String(255), default="")
username = Column(String(255), default="")
phone = Column(String(50), default="")
email = Column(String(255), default="")
consent_given = Column(Boolean, nullable=False, default=False)
consent_timestamp = Column(DateTime, nullable=True)
consent_method = Column(String(50), default="")
created_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
last_active_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
conversations = relationship("BotConversation", back_populates="user")
consent_logs = relationship("BotConsentLog", back_populates="user")
notification_subscriptions = relationship("BotNotificationSubscription", back_populates="user", uselist=False)
class BotConversation(Base):
__tablename__ = "bot_conversations"
id = Column(Integer, primary_key=True, autoincrement=True)
user_id = Column(Integer, ForeignKey("bot_users.id", ondelete="CASCADE"), nullable=False)
status = Column(String(20), nullable=False, default="open")
inquiry_type = Column(Integer, ForeignKey("bot_categories.id", ondelete="SET NULL"), nullable=True)
inquiry_text = Column(Text, default="")
priority = Column(String(20), default="normal")
created_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
closed_at = Column(DateTime, nullable=True)
assigned_to = Column(String(255), default="")
has_attachment = Column(Boolean, default=False)
attachment_type = Column(String(50), default="")
attachment_path = Column(String(500), default="")
__table_args__ = (
CheckConstraint("status IN ('open','closed','handoff','1c_sent','awaiting_rating')", name="ck_bot_conv_status"),
CheckConstraint("priority IN ('low','normal','high','urgent')", name="ck_bot_conv_priority"),
)
user = relationship("BotUser", back_populates="conversations")
category = relationship("BotCategory", back_populates="conversations")
messages = relationship("BotMessage", back_populates="conversation", order_by="BotMessage.timestamp")
sync_log = relationship("Bot1CSyncLog", back_populates="conversation")
class BotMessage(Base):
__tablename__ = "bot_messages"
id = Column(Integer, primary_key=True, autoincrement=True)
conversation_id = Column(Integer, ForeignKey("bot_conversations.id", ondelete="CASCADE"), nullable=False)
direction = Column(String(3), nullable=False)
text = Column(Text, default="")
has_attachment = Column(Boolean, default=False)
attachment_type = Column(String(50), default="")
attachment_path = Column(String(500), default="")
max_message_id = Column(BigInteger, nullable=True)
timestamp = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
__table_args__ = (
CheckConstraint("direction IN ('in','out')", name="ck_bot_msg_direction"),
)
conversation = relationship("BotConversation", back_populates="messages")
class BotConsentLog(Base):
__tablename__ = "bot_consent_logs"
id = Column(Integer, primary_key=True, autoincrement=True)
user_id = Column(Integer, ForeignKey("bot_users.id", ondelete="CASCADE"), nullable=False)
action = Column(String(20), nullable=False)
timestamp = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
method = Column(String(50), default="")
ip_address = Column(String(45), default="")
__table_args__ = (
CheckConstraint("action IN ('given','revoked')", name="ck_bot_consent_action"),
)
user = relationship("BotUser", back_populates="consent_logs")
class Bot1CSyncLog(Base):
__tablename__ = "bot_1c_sync_log"
id = Column(Integer, primary_key=True, autoincrement=True)
conversation_id = Column(Integer, ForeignKey("bot_conversations.id", ondelete="CASCADE"), nullable=False)
status = Column(String(20), nullable=False, default="pending")
request_payload = Column(Text, default="")
response_payload = Column(Text, default="")
sent_at = Column(DateTime, nullable=True)
confirmed_at = Column(DateTime, nullable=True)
__table_args__ = (
CheckConstraint("status IN ('pending','sent','confirmed','error')", name="ck_bot_1c_status"),
)
conversation = relationship("BotConversation", back_populates="sync_log")
class BotKnowledgeBase(Base):
__tablename__ = "bot_knowledge_base"
id = Column(Integer, primary_key=True, autoincrement=True)
question = Column(String(500), nullable=False)
answer = Column(Text, nullable=False)
category = Column(String(100), default="")
keywords = Column(JSON, default=list)
active = Column(Boolean, nullable=False, default=True)
sort_order = Column(Integer, default=0)
class BotCategory(Base):
__tablename__ = "bot_categories"
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(100), nullable=False)
description = Column(String(500), default="")
active = Column(Boolean, nullable=False, default=True)
sort_order = Column(Integer, default=0)
icon_emoji = Column(String(10), default="📋")
keywords = Column(JSON, default=list)
conversations = relationship("BotConversation", back_populates="category")
class BotSetting(Base):
__tablename__ = "bot_settings"
id = Column(Integer, primary_key=True, autoincrement=True)
key = Column(String(100), unique=True, nullable=False)
value = Column(Text, default="")
description = Column(String(500), default="")
class BotFeature(Base):
__tablename__ = "bot_features"
id = Column(Integer, primary_key=True, autoincrement=True)
feature_key = Column(String(100), unique=True, nullable=False)
name = Column(String(100), nullable=False)
description = Column(String(500), default="")
enabled = Column(Boolean, nullable=False, default=False)
sort_order = Column(Integer, default=0)
class BotResponseTemplate(Base):
__tablename__ = "bot_response_templates"
id = Column(Integer, primary_key=True, autoincrement=True)
template_key = Column(String(100), unique=True, nullable=False)
template_text = Column(Text, nullable=False)
description = Column(String(500), default="")
variables = Column(JSON, default=list)
class FileSyncQueue(Base):
__tablename__ = "file_sync_queue"
id = Column(Integer, primary_key=True, autoincrement=True)
local_path = Column(String(500), nullable=False)
remote_path = Column(String(500), default="")
entity_type = Column(String(50), nullable=False)
entity_id = Column(Integer, nullable=False)
status = Column(String(20), nullable=False, default="pending")
error = Column(Text, default="")
created_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
__table_args__ = (
CheckConstraint("status IN ('pending','uploading','synced','error')", name="ck_file_sync_status"),
)
class BotBroadcast(Base):
__tablename__ = "bot_broadcasts"
id = Column(Integer, primary_key=True, autoincrement=True)
text = Column(Text, nullable=False)
sent_at = Column(DateTime, nullable=True)
sent_by = Column(Integer, nullable=True)
recipient_count = Column(Integer, default=0)
recipient_ids = Column(JSON, default=list)
status = Column(String(20), default="draft")
__table_args__ = (
CheckConstraint("status IN ('draft','sent','failed')", name="ck_bot_broadcast_status"),
)
class BotNotification(Base):
__tablename__ = "bot_notifications"
id = Column(Integer, primary_key=True, autoincrement=True)
type = Column(String(50), nullable=False)
recipient_type = Column(String(20), nullable=False)
recipient_max_user_id = Column(BigInteger, nullable=True)
title = Column(String(255), default="")
body = Column(Text, default="")
related_type = Column(String(50), default="")
related_id = Column(Integer, nullable=True)
is_read = Column(Boolean, nullable=False, default=False)
created_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
__table_args__ = (
CheckConstraint("recipient_type IN ('operator','level2','client')", name="ck_bot_notif_recipient"),
)
class BotNotificationSubscription(Base):
__tablename__ = "bot_notification_subscriptions"
id = Column(Integer, primary_key=True, autoincrement=True)
user_id = Column(Integer, ForeignKey("bot_users.id", ondelete="CASCADE"), nullable=False)
notify_on_status_change = Column(Boolean, nullable=False, default=False)
notify_on_reply = Column(Boolean, nullable=False, default=False)
notify_on_broadcast = Column(Boolean, nullable=False, default=False)
user = relationship("BotUser", back_populates="notification_subscriptions")
class Customer(Base):
__tablename__ = "customers"
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(255), nullable=False)
contact_phone = Column(String(50), default="")
class Object(Base):
__tablename__ = "objects"
id = Column(Integer, primary_key=True, autoincrement=True)
customer_id = Column(Integer, ForeignKey("customers.id", ondelete="SET NULL"), nullable=True)
name = Column(String(255), nullable=False)
status = Column(String(20), nullable=False, default="active")
risk_score = Column(Integer, default=0)
class SLAContract(Base):
__tablename__ = "sla_contracts"
id = Column(Integer, primary_key=True, autoincrement=True)
object_id = Column(Integer, ForeignKey("objects.id", ondelete="CASCADE"), nullable=False)
status = Column(String(20), nullable=False, default="negotiation")
created_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
service_level = Column(String(20), default="start")
sla_price_monthly = Column(Integer, default=0)
class Task(Base):
__tablename__ = "tasks"
id = Column(Integer, primary_key=True, autoincrement=True)
object_id = Column(Integer, ForeignKey("objects.id", ondelete="CASCADE"), nullable=False)
status = Column(String(20), nullable=False, default="open")
class Incident(Base):
__tablename__ = "incidents"
id = Column(Integer, primary_key=True, autoincrement=True)
object_id = Column(Integer, ForeignKey("objects.id", ondelete="CASCADE"), nullable=False)
status = Column(String(20), nullable=False, default="open")
created_at = Column(DateTime, nullable=False, server_default="NOW()")
title = Column(String(500), default="")
description = Column(Text, default="")
severity = Column(String(4), nullable=False, default="P3")
reported_by = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, autoincrement=True)
login = Column(String(50), default="")
full_name = Column(String(255), default="")
role = Column(String(20), nullable=False, default="technician")
is_active = Column(Boolean, nullable=False, default=True)
max_user_id = Column(BigInteger, nullable=True)
class BotRiskQuestion(Base):
__tablename__ = "bot_risk_questions"
id = Column(Integer, primary_key=True, autoincrement=True)
question_key = Column(String(100), unique=True, nullable=False)
question = Column(String(500), nullable=False)
weight = Column(Integer, nullable=False, default=10)
sort_order = Column(Integer, default=0)
is_active = Column(Boolean, nullable=False, default=True)
class BotTicket(Base):
__tablename__ = "bot_tickets"
id = Column(Integer, primary_key=True, autoincrement=True)
ticket_number = Column(String(20), unique=True, nullable=False)
user_id = Column(Integer, ForeignKey("bot_users.id", ondelete="SET NULL"), nullable=True)
object_id = Column(Integer, nullable=True)
customer_id = Column(Integer, nullable=True)
title = Column(String(255), nullable=False)
description = Column(Text, default="")
priority = Column(String(20), default="normal")
status = Column(String(20), nullable=False, default="open")
created_by = Column(String(20), default="bot")
sla_contract_id = Column(Integer, nullable=True)
has_attachment = Column(Boolean, default=False)
attachment_type = Column(String(50), default="")
attachment_path = Column(String(500), default="")
created_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
updated_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
__table_args__ = (
CheckConstraint("priority IN ('low','normal','high','urgent')", name="ck_bot_ticket_priority"),
CheckConstraint("status IN ('open','in_progress','resolved','closed')", name="ck_bot_ticket_status"),
)
class BotTicketMessage(Base):
__tablename__ = "bot_ticket_messages"
id = Column(Integer, primary_key=True, autoincrement=True)
ticket_id = Column(Integer, ForeignKey("bot_tickets.id", ondelete="CASCADE"), nullable=False)
direction = Column(String(10), nullable=False)
text = Column(Text, default="")
sender = Column(String(50), default="")
created_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
class BotTicketStatus(Base):
__tablename__ = "bot_ticket_statuses"
id = Column(Integer, primary_key=True, autoincrement=True)
ticket_id = Column(Integer, ForeignKey("bot_tickets.id", ondelete="CASCADE"), nullable=False)
old_status = Column(String(20), default="")
new_status = Column(String(20), nullable=False)
changed_by = Column(String(50), default="")
created_at = Column(DateTime, nullable=False, server_default=sa_text("CURRENT_TIMESTAMP"))
max_bot/app/settings_cache.py
+34 -118
View File
@@ -1,129 +1,45 @@
import time
from typing import Optional
from typing import Optional, Dict
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.models import BotSetting, BotFeature, BotResponseTemplate, BotCategory
from app.database import async_session
from app.models import BotSetting
class SettingsCache:
_cache: dict = {}
_features: dict = {}
_templates: dict = {}
_categories: list = []
_last_update: float = 0
TTL = 300 # 5 minutes
def __init__(self):
self._cache: dict[str, str] = {}
self._loaded = False
@classmethod
async def refresh(cls, db: AsyncSession):
now = time.time()
if now - cls._last_update < cls.TTL and cls._cache:
return
async def _load(self):
async with async_session() as db:
result = await db.execute(select(BotSetting))
rows = result.scalars().all()
self._cache = {row.key: row.value or "" for row in rows}
self._loaded = True
result = await db.execute(select(BotSetting))
cls._cache = {row.key: row.value for row in result.scalars().all()}
async def get(self, key: str, default: str = "") -> str:
if not self._loaded:
await self._load()
return self._cache.get(key, default)
result = await db.execute(select(BotFeature).where(BotFeature.enabled == True))
cls._features = {row.feature_key: row for row in result.scalars().all()}
async def set(self, key: str, value: str) -> bool:
async with async_session() as db:
result = await db.execute(select(BotSetting).where(BotSetting.key == key))
setting = result.scalar_one_or_none()
if setting:
setting.value = value
else:
db.add(BotSetting(key=key, value=value))
await db.commit()
self._cache[key] = value
return True
result = await db.execute(select(BotFeature))
all_features = {row.feature_key: row for row in result.scalars().all()}
async def get_all(self) -> Dict[str, str]:
if not self._loaded:
await self._load()
return dict(self._cache)
result = await db.execute(select(BotResponseTemplate))
cls._templates = {row.template_key: row.template_text for row in result.scalars().all()}
def invalidate(self):
self._loaded = False
result = await db.execute(
select(BotCategory).where(BotCategory.active == True).order_by(BotCategory.sort_order)
)
cls._categories = result.scalars().all()
cls._last_update = now
@classmethod
def get(cls, key: str, default: str = "") -> str:
return cls._cache.get(key, default)
@classmethod
def get_int(cls, key: str, default: int = 0) -> int:
val = cls._cache.get(key, str(default))
try:
return int(val)
except (ValueError, TypeError):
return default
@classmethod
def get_list(cls, key: str, default: list = None) -> list:
val = cls._cache.get(key, "")
if not val:
return default or []
return [x.strip() for x in val.split(",")]
@classmethod
def get_all(cls) -> dict:
return dict(cls._cache)
@classmethod
def is_feature_enabled(cls, feature_key: str) -> bool:
return feature_key in cls._features
@classmethod
def get_enabled_features(cls) -> dict:
return dict(cls._features)
@classmethod
def get_template(cls, key: str, default: str = "") -> str:
return cls._templates.get(key, default)
@classmethod
def get_all_templates(cls) -> dict:
return dict(cls._templates)
@classmethod
def get_categories(cls) -> list:
return list(cls._categories)
@classmethod
def get_bot_token(cls) -> str:
return cls._cache.get("bot_token", "")
@classmethod
def get_assistant_name(cls) -> str:
return cls._cache.get("assistant_name", "София")
@classmethod
def is_work_hours(cls) -> bool:
import datetime
import pytz
tz_name = cls._cache.get("timezone", "Europe/Moscow")
try:
tz = pytz.timezone(tz_name)
except Exception:
tz = pytz.timezone("Europe/Moscow")
now = datetime.datetime.now(tz)
work_days = cls.get_list("work_days", ["1", "2", "3", "4", "5"])
weekday = str(now.isoweekday())
if weekday not in work_days:
return False
start = cls.get_int("work_hours_start", 9)
end = cls.get_int("work_hours_end", 18)
return start <= now.hour < end
@classmethod
def get_work_hours_str(cls) -> str:
start = cls.get_int("work_hours_start", 9)
end = cls.get_int("work_hours_end", 18)
return f"{start}:00-{end}:00"
@classmethod
def get_phones(cls) -> list:
phones = []
p1 = cls._cache.get("phone_1", "")
p2 = cls._cache.get("phone_2", "")
if p1:
phones.append(p1)
if p2:
phones.append(p2)
return phones
@classmethod
def get_email(cls) -> str:
return cls._cache.get("support_email", "")
settings_cache = SettingsCache()
max_bot/app/text_renderer.py
-34
View File
@@ -1,34 +0,0 @@
import re
from typing import Optional
def render_template(template: str, **kwargs) -> str:
result = template
for key, value in kwargs.items():
result = result.replace("{" + key + "}", str(value))
remaining = re.findall(r'\{(\w+)\}', result)
for var in remaining:
result = result.replace("{" + var + "}", "")
return result
def parse_link_text(text: str) -> str:
text = re.sub(r'\[([^\]]+)\]\(tel:[^\)]+\)', r'\1', text)
text = re.sub(r'\[([^\]]+)\]\(mailto:[^\)]+\)', r'\1', text)
text = re.sub(r'\[([^\]]+)\]\(https?://[^\)]+\)', r'\1', text)
return text
def make_clickable_links(text: str, phone_1: str = "", phone_2: str = "",
email: str = "", email_subject: str = "") -> str:
phone_1_raw = re.sub(r'[^\d+]', '', phone_1)
phone_2_raw = re.sub(r'[^\d+]', '', phone_2)
email_encoded = email.replace(' ', '%20')
subject_encoded = email_subject.replace(' ', '%20')
text = text.replace("{phone_1_raw}", phone_1_raw)
text = text.replace("{phone_2_raw}", phone_2_raw)
text = text.replace("{email_encoded}", email_encoded)
text = text.replace("{email_subject_encoded}", subject_encoded)
return text
max_bot/app/utils/__init__.py
View File
max_bot/app/utils/__pycache__/__init__.cpython-314.pyc
BIN
View File
Binary file not shown.

Some files were not shown because too many files have changed in this diff Show More