mirror of
https://github.com/openmax-server/server.git
synced 2026-07-15 16:30:14 +03:00
W.I.P.: OpenMAX 0.1.0 (#28)
* Различные фиксы (#14)
* Исключаем только ошибку валидации
* Небольшие правки вебсокета тамтама
* Теперь номера брутить чутка сложнее
* Авторизация теперь проверяется для некоторых команд
* Теперь проверяется orign у вебсокета тамтама
* Дополнил пример env
* Починил немного сокет тамтама
* Теперь все должно работать исправно
* Документация: описал про SESSION_INIT
* Update deviceId description in tamtam_ws.md
* feat: 16 опкод для обновления профиля
* feat: 23 опкод для регистрации, смс шлюз, докер
* SQLite: Ошибка
И вообще не юзайте sqlite пожалуйста, он баганный
* Серверный конфиг снова сломался
* Починил изменение профиля
* История сообщений (вроде как даже работает)
* Дополнил немного 48 опкод, и починил отдачу истории в избранном (избранное все равно не работает)
* Доделал авторизацию в ТамТаме
* Швырнул архитектуру, чтобы позже объединить контроллеры веба и сокета в одно, а также разделить процессоры
* Удалил tamtam.proto, поскольку нигде больше не используется
* Поделил процессоры в таме
* Коды стран
* Генерируем айди, за вместо того, чтобы писать его попорядку
* Вынес список участников чата в отдельную таблицу
* Теперь мы не должны отправлять 128 опкод самому себе. вроде
* ТамТам: реализация 32 опкода. Надеюсь, будет работать
* ТамТам: обработчик 5 и 1 опкода
* ТамТам: починил 32 опкод и добавил серверный конфиг. Избранное больше не добавляется в список чатов
MAX: починил 32 опкод
* TT: oops
* MAX: заглушка в 158 опкоде
* Common: поправил 1 прикол
* TamTam: websocket transport for web version
* TamTam && MAX: история (в мохе она вроде теперь получше работает)
* Правка контроллеров небольшая
* MAX: Разделил процессоры
* TG Bot: переписал на aiogram
* Common: фикс года
* Начальная реализация транспорта ws для max web и прочие улучшения
* Common: добавил сжатие lz4
* Исправление конфликтов
* TT: фикс вебсокета
* Fix OpenMAX mobile compatibility and Telegram auth fallback (#30)
* Fix OpenMAX mobile compatibility and Telegram auth fallback
* Common: Убрал скобку в конфиге
---------
Co-authored-by: Alexey Polyakov <starwear3000@mail.ru>
* MAX: заглушка для баннеров, правка пакета со списком жалоб, отдача контактов и прочие улучшения
* oops
* MAX: Рабочие баннеры
* MAX: обновление настроек приватности
* MAX: пуши через firebase (особо не тестил, вроде работает)
* MAX: Рефактор папок
* MAX: фикс версий < 25.8.0
* MAX: отдача черного списка
* Теперь ID пользователей идут по порядку, как и раньше
* MAX: создание папок
* MAX: oops
* MAX: добавление/удаление контактов, статусы
* MAX & TT: теперь в качестве страны локации используется настоящая страна пользователя, а также зафиксировал версии библиотек в зависимостях
* TT: ну вроде шире поддержка, а вообще обратная совместимость с максом клас
* oops
* TG Bot: возможность включения белого списка
* Решение проблемы обработки sigterm
* nothing
* fix
* TG Bot: fix
* TG Bot: fix username
* MAX && TT: общение в таме, и корректировки под веб морду
* MAX: Почистил серверный конфиг
* nothing
* MAX: web fix
* MAX: web fix 2
* oops
* nothing
* MAX: теперь для избранного не сравниваем айди с нулём
* Вынес sqlite в отдельный модуль
* MAX: блокировка и разблокировка контакта
* oops
* TT: тоже самое что в макс
* MAX && TT: обновление контакта
* MAX: добавление контакта по номеру телефона
* MAX: исправление уязвимости с избранными
* Генерируем айди пользователей рандомно (опять, да)
* update sql scheme
* Фикс сборки избранного
* Попытка починить историю (спойлер, нихуя не получилось)
* MAX: история таки заработала — cid/link/reactionInfo обязательны в схеме
Десктопный MAX подключается через TCP (mobile-протокол) и парсит
msgpack по фиксированной схеме. Если в сообщении выпадает любое из
полей — клиент молча обрывает соединение. После 87cfc19 как раз
такие условные `if elements: ...` / `if link: ...` (а link и
reaction_info там всегда были `{}`, то есть falsy) вырезали поля
из ответа CHAT_HISTORY и MSG_SEND, чем и сломали историю.
- src/common/tools.py: новый build_message_dict() — единая сборка
тела сообщения, где все поля (id, cid, time, type, sender, text,
attaches, elements, reactionInfo, link) присутствуют ВСЕГДА.
get_last_message переписан через него.
- src/oneme/processors/history.py: chat_history использует
build_message_dict вместо ручной логики с условными if-ками.
- src/oneme/processors/messages.py: msg_send.bodyMessage теперь
отдает cid / reactionInfo / link даже пустыми и приводит id
к int для mobile, str для web.
Цепная польза: auth.py LOGIN bootstrap (через generate_chats →
get_last_message) и search.py тоже теперь шлют корректную схему.
* MAX: bootstrap-история в LOGIN — клиент перестал думать что всё уже синканулось
В ответе LOGIN сервер слал messages: {} и chatMarker: 0. Десктопный
клиент в этом случае считает, что локальная история уже синхронизирована
со старого запуска, и НЕ отправляет CHAT_HISTORY (49) при открытии чата.
В окне видно только lastMessage из chats[], а вся реальная переписка —
ничерта.
- src/common/tools.py: collect_bootstrap_history(chatIds, ...) —
собирает карту {chatId: [последние N сообщений]}, в т.ч. избранное
под клиентским id = senderId ^ senderId.
- src/oneme/processors/auth.py: подсовываем эту карту в
payload.messages, chatMarker = текущее время вместо 0.
* fix(chat history): фикс
* fix(chat history): фикс
* fix(chat history): фикс
* fix(chat history): фикс
* fix(chat history): фикс
* fix(chat history): фикс
* fix(chat history): фикс
* MAX & TT: теперь полноценный чёрный список
* TT: регистрация через клиент
* Вроде как нормальные заглушки под ассеты
* maybe fixes
---------
Co-authored-by: WowInceptionGood <143893762+WowInceptionGood@users.noreply.github.com>
Co-authored-by: zavolo <me@kirillka.ru>
Co-authored-by: Aleksandr Kosachev <38947781+gohryt@users.noreply.github.com>
This commit is contained in:
Alexey Polyakov
@@ -0,0 +1,336 @@
|
||||
class OnemeConfig:
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
SERVER_CONFIG = {
|
||||
"account-nickname-enabled": False,
|
||||
"account-removal-enabled": False,
|
||||
"anr-config": {
|
||||
"enabled": True,
|
||||
"timeout": {
|
||||
"low": 5000,
|
||||
"avg": 5000,
|
||||
"high": 5000
|
||||
}
|
||||
},
|
||||
"appearance-multi-theme-screen-enabled": True,
|
||||
"audio-transcription-locales": [],
|
||||
"available-complaints": [
|
||||
"FAKE",
|
||||
"SPAM",
|
||||
"PORNO",
|
||||
"EXTREMISM",
|
||||
"THREAT",
|
||||
"OTHER"
|
||||
],
|
||||
"avatars-screen-enabled": True,
|
||||
"bad-networ-indicator-config": {
|
||||
"signalingConfig": {
|
||||
"dcReportNetworkStatEnabled": False
|
||||
}
|
||||
},
|
||||
"bots-channel-adding": True,
|
||||
"cache-msg-preprocess": True,
|
||||
"call-incoming-ab": 2,
|
||||
"call-permissions-interval": 259200,
|
||||
"call-pinch-to-zoom": True,
|
||||
"call-rate": {
|
||||
"limit": 3,
|
||||
"sdk-limit": 2,
|
||||
"duration": 10,
|
||||
"delay": 86400
|
||||
},
|
||||
"callDontUseVpnForRtp": False,
|
||||
"callEnableIceRenomination": False,
|
||||
"calls-endpoint": "",
|
||||
"calls-sdk-am-speaker-fix": True,
|
||||
"calls-sdk-audio-dynamic-redundancy": {
|
||||
"mab": 16,
|
||||
"dsb": 64,
|
||||
"nl": True,
|
||||
"df": True,
|
||||
"dlb": True
|
||||
},
|
||||
"calls-sdk-enable-nohost": True,
|
||||
"calls-sdk-incall-stat": False,
|
||||
"calls-sdk-linear-opus-bwe": True,
|
||||
"calls-sdk-mapping": {
|
||||
"off": True
|
||||
},
|
||||
"calls-sdk-remove-nonopus-audiocodecs": True,
|
||||
"calls-use-call-end-reason-fix": True,
|
||||
"calls-use-ws-url-validation": True,
|
||||
"cfs": True,
|
||||
"channels-complaint-enabled": True,
|
||||
"channels-enabled": True,
|
||||
"channels-search-subscribers-visible": True,
|
||||
"chat-complaint-enabled": False,
|
||||
"chat-gif-autoplay-enabled": True,
|
||||
"chat-history-notif-msg-strategy": 1,
|
||||
"chat-history-persist": False,
|
||||
"chat-history-warm-opts": 0,
|
||||
"chat-invite-link-permissions-enabled": True,
|
||||
"chat-media-scrollable-caption-enabled": True,
|
||||
"chat-video-autoplay-enabled": True,
|
||||
"chat-video-call-button": True,
|
||||
"chatlist-subtitle-ver": 1,
|
||||
"chats-folder-enabled": True,
|
||||
"chats-page-size": 50,
|
||||
"chats-preload-period": 15,
|
||||
"cis-enabled": True,
|
||||
"contact-add-bottom-sheet": True,
|
||||
"creation-2fa-config": {
|
||||
"pass_min_len": 6,
|
||||
"pass_max_len": 64,
|
||||
"hint_max_len": 30,
|
||||
"enabled": True
|
||||
},
|
||||
"debug-profile-info": False,
|
||||
"default-reactions-settings": {
|
||||
"isActive": True,
|
||||
"count": 8,
|
||||
"included": False,
|
||||
"reactionIds": []
|
||||
},
|
||||
"delete-msg-fys-large-chat-disabled": True,
|
||||
"devnull": {
|
||||
"opcode": True,
|
||||
"upload_hang": True
|
||||
},
|
||||
"disconnect-timeout": 300,
|
||||
"double-tap-reaction": "👍",
|
||||
"double-tap-reaction-enabled": True,
|
||||
"drafts-sync-enabled": False,
|
||||
"edit-chat-type-screen-enabled": False,
|
||||
"edit-timeout": 604800,
|
||||
"enable-filters-for-folders": True,
|
||||
"enable-unknown-contact-bottom-sheet": 2,
|
||||
"fake-chats": True,
|
||||
"family-protection-botid": 67804175,
|
||||
"february-23-26-theme": True,
|
||||
"file-preview": True,
|
||||
"file-upload-enabled": True,
|
||||
"file-upload-max-size": 4294967296,
|
||||
"file-upload-unsupported-types": [
|
||||
"exe"
|
||||
],
|
||||
"force-play-embed": True,
|
||||
"gc-from-p2p": True,
|
||||
"gce": False,
|
||||
"group-call-part-limit": 100,
|
||||
"grse": False,
|
||||
"gsse": True,
|
||||
"hide-incoming-call-notif": True,
|
||||
"host-reachability": True,
|
||||
"image-height": 1920,
|
||||
"image-quality": 0.800000011920929,
|
||||
"image-size": 40000000,
|
||||
"image-width": 1920,
|
||||
"in-app-review-triggers": 255,
|
||||
"informer-enabled": True,
|
||||
"inline-ev-player": True,
|
||||
"invalidate-db-msg-exception": True,
|
||||
"invite-friends-sheet-frequency": [
|
||||
2,
|
||||
7
|
||||
],
|
||||
"invite-link": "",
|
||||
"invite-long": "",
|
||||
"invite-short": "",
|
||||
"join-requests": True,
|
||||
"js-download-delegate": False,
|
||||
"keep-connection": 2,
|
||||
"lebedev-theme-enabled": True,
|
||||
"lgce": True,
|
||||
"markdown-enabled": True,
|
||||
"markdown-menu": 0,
|
||||
"max-audio-length": 3600,
|
||||
"max-description-length": 400,
|
||||
"max-favorite-chats": 5,
|
||||
"max-favorite-sticker-sets": 100,
|
||||
"max-favorite-stickers": 100,
|
||||
"max-msg-length": 4000,
|
||||
"max-participants": 20000,
|
||||
"max-readmarks": 100,
|
||||
"max-theme-length": 200,
|
||||
"max-video-duration-download": 1200,
|
||||
"max-video-message-length": 60,
|
||||
"media-order": 1,
|
||||
"media-playlist-enabled": True,
|
||||
"media-transform": {
|
||||
"enabled": True,
|
||||
"hdr_enabled": False,
|
||||
"hevc_enabled": True,
|
||||
"max_enc_frames": {
|
||||
"low": 1,
|
||||
"avg": 1,
|
||||
"high": 2
|
||||
}
|
||||
},
|
||||
"media-viewer-rotation-enabled": True,
|
||||
"media-viewer-video-collage-enabled": True,
|
||||
"mentions-enabled": True,
|
||||
"mentions_entity_names_limit": 3,
|
||||
"migrate-unsafe-warn": True,
|
||||
"min-image-side-size": 64,
|
||||
"miui-menu-enabled": True,
|
||||
"money-transfer-botid": 1134691,
|
||||
"moscow-theme-enabled": True,
|
||||
"msg-get-reactions-page-size": 40,
|
||||
"music-files-enabled": False,
|
||||
"mytracker-enabled": True,
|
||||
"net-client-dns-enabled": True,
|
||||
"net-session-suppress-bad-disconnected-state": True,
|
||||
"net-stat-config": [
|
||||
64,
|
||||
48,
|
||||
128,
|
||||
135
|
||||
],
|
||||
"new-admin-permissions": True,
|
||||
"new-logout-logic": False,
|
||||
"new-media-upload-ui": True,
|
||||
"new-media-viewer-enabled": True,
|
||||
"new-settings-storage-screen-enabled": False,
|
||||
"new-width-text-bubbles-mob": True,
|
||||
"new-year-theme-2026": False,
|
||||
"nick-max-length": 60,
|
||||
"nick-min-length": 7,
|
||||
"official-org": True,
|
||||
"one-video-failover": True,
|
||||
"one-video-player": True,
|
||||
"one-video-uploader": True,
|
||||
"one-video-uploader-audio": True,
|
||||
"one-video-uploader-progress-fix": True,
|
||||
"perf-events": {
|
||||
"startup_report": 2,
|
||||
"web_app": 2
|
||||
},
|
||||
"player-load-control": {
|
||||
"mp_autoplay_enabled": False,
|
||||
"time_over_size": False,
|
||||
"buffer_after_rebuffer_ms": 3000,
|
||||
"buffer_ms": 500,
|
||||
"max_buffer_ms": 13000,
|
||||
"min_buffer_ms": 5000,
|
||||
"use_min_size_lc": True,
|
||||
"min_size_lc_fmt_mis_sf": 4
|
||||
},
|
||||
"progress-diff-for-notify": 1,
|
||||
"push-delivery": True,
|
||||
"qr-auth-enabled": True,
|
||||
"quotes-enabled": True,
|
||||
"react-errors": [
|
||||
"error.comment.chat.access",
|
||||
"error.comment.invalid",
|
||||
"error.message.invalid",
|
||||
"error.message.chat.access",
|
||||
"error.message.like.unknown.like",
|
||||
"error.message.like.unknown.reaction",
|
||||
"error.too-many-unlikes-dialog",
|
||||
"error.too-many-unlikes-chat",
|
||||
"error.too-many-likes",
|
||||
"error.reactions.not.allowed"
|
||||
],
|
||||
"react-permission": 2,
|
||||
"reactions-enabled": True,
|
||||
"reactions-max": 8,
|
||||
"reactions-menu": [
|
||||
"👍",
|
||||
"❤️",
|
||||
"🤣",
|
||||
"🔥",
|
||||
"😭",
|
||||
"💯",
|
||||
"💩",
|
||||
"😡"
|
||||
],
|
||||
"reactions-settings-enabled": True,
|
||||
"reconnect-call-ringtone": True,
|
||||
"ringtone-am-mode": True,
|
||||
"saved-messages-aliases": [
|
||||
"избранное",
|
||||
"saved",
|
||||
"favourite",
|
||||
"favorite",
|
||||
"личное",
|
||||
"моё",
|
||||
"мои",
|
||||
"мой",
|
||||
"моя",
|
||||
"любимое",
|
||||
"сохраненные",
|
||||
"сохраненное",
|
||||
"заметки",
|
||||
"закладки"
|
||||
],
|
||||
"scheduled-messages-enabled": True,
|
||||
"scheduled-posts-enabled": True,
|
||||
"search-webapps-showcase": {
|
||||
"items": []
|
||||
},
|
||||
"send-location-enabled": True,
|
||||
"send-logs-interval-sec": 900,
|
||||
"server-side-complains-enabled": True,
|
||||
"set-audio-device": False,
|
||||
"set-unread-timeout": 31536000,
|
||||
"settings-entry-banners": [],
|
||||
"show-reactions-on-multiselect": True,
|
||||
"show-warning-links": True,
|
||||
"speedy-upload": True,
|
||||
"speedy-voice-messages": True,
|
||||
"sse": True,
|
||||
"stat-session-background-threshold": 60000,
|
||||
"sticker-suggestion": [
|
||||
"RECENT",
|
||||
"NEW",
|
||||
"TOP"
|
||||
],
|
||||
"stickers-controller-suspend": True,
|
||||
"stickers-db-batch": True,
|
||||
"streamable-mp4": True,
|
||||
"stub": "stub2",
|
||||
"suspend-video-converter": True,
|
||||
"system-default-ringtone-opt": True,
|
||||
"transfer-botid": 1134691,
|
||||
"typing-enabled-FILE": True,
|
||||
"unique-favorites": True,
|
||||
"unsafe-files-alert": True,
|
||||
"upload-reusability": True,
|
||||
"upload-rx-no-blocking": True,
|
||||
"user-debug-report": 2340932,
|
||||
"video-msg-channels-enabled": True,
|
||||
"video-msg-config": {
|
||||
"duration": 60,
|
||||
"quality": 480,
|
||||
"min_frame_rate": 30,
|
||||
"max_frame_rate": 30
|
||||
},
|
||||
"video-msg-enabled": True,
|
||||
"video-transcoding-class": [
|
||||
2,
|
||||
3
|
||||
],
|
||||
"views-count-enabled": True,
|
||||
"watchdog-config": {
|
||||
"enabled": True,
|
||||
"stuck": 10,
|
||||
"hang": 60
|
||||
},
|
||||
"webapp-exc": [],
|
||||
"webapp-push-open": True,
|
||||
"webview-cache-enabled": False,
|
||||
"welcome-sticker-ids": [],
|
||||
"white-list-links": [],
|
||||
"wm-analytics-enabled": True,
|
||||
"wm-workers-limit": 80,
|
||||
"wud": False,
|
||||
"y-map": {
|
||||
"tile": "34c7fd82-723d-4b23-8abb-33376729a893",
|
||||
"geocoder": "34c7fd82-723d-4b23-8abb-33376729a893",
|
||||
"static": "34c7fd82-723d-4b23-8abb-33376729a893",
|
||||
"logoLight": "https://st.max.ru/icons/ya_maps_logo_light.webp",
|
||||
"logoDark": "https://st.max.ru/icons/ya_maps_logo_dark.webp"
|
||||
},
|
||||
"has-phone": True
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
import asyncio
|
||||
from oneme.socket import OnemeMobile
|
||||
from oneme.websocket import OnemeWS
|
||||
from common.proto_tcp import MobileProto
|
||||
from common.proto_web import WebProto
|
||||
from classes.controllerbase import ControllerBase
|
||||
from common.config import ServerConfig
|
||||
from common.opcodes import Opcodes
|
||||
|
||||
class OnemeController(ControllerBase):
|
||||
def __init__(self):
|
||||
self.config = ServerConfig()
|
||||
self.proto_tcp = MobileProto()
|
||||
self.proto_web = WebProto()
|
||||
self.opcodes = Opcodes()
|
||||
|
||||
async def event(self, target, client, eventData):
|
||||
# Извлекаем тип события и врайтер
|
||||
eventType = eventData.get("eventType")
|
||||
writer = client.get("writer")
|
||||
is_web = client.get("type") == "web"
|
||||
|
||||
# Выбираем протокол в зависимости от типа подключения
|
||||
proto = self.proto_web if is_web else self.proto_tcp
|
||||
packet = None
|
||||
|
||||
# Не отправляем событие самому себе
|
||||
if writer == eventData.get("writer"):
|
||||
return
|
||||
|
||||
# Обрабатываем событие
|
||||
if eventType == "new_msg":
|
||||
# Данные сообщения
|
||||
chatId = eventData.get("chatId")
|
||||
message = eventData.get("message")
|
||||
prevMessageId = eventData.get("prevMessageId")
|
||||
time = eventData.get("time")
|
||||
|
||||
# Данные пакета
|
||||
payload = {
|
||||
"chatId": chatId,
|
||||
"message": message,
|
||||
"prevMessageId": prevMessageId,
|
||||
"ttl": False,
|
||||
"unread": 0,
|
||||
"mark": time
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
packet = proto.pack_packet(
|
||||
cmd=0, seq=1, opcode=self.opcodes.NOTIF_MESSAGE, payload=payload
|
||||
)
|
||||
elif eventType == "typing":
|
||||
# Данные события
|
||||
chatId = eventData.get("chatId")
|
||||
userId = eventData.get("userId")
|
||||
type = eventData.get("type")
|
||||
|
||||
# Данные пакета
|
||||
payload = {
|
||||
"chatId": chatId,
|
||||
"userId": userId,
|
||||
"type": type
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
packet = proto.pack_packet(
|
||||
cmd=0, seq=1, opcode=self.opcodes.NOTIF_TYPING, payload=payload
|
||||
)
|
||||
elif eventType == "profile_updated":
|
||||
# Данные события
|
||||
profile = eventData.get("profile")
|
||||
|
||||
# Данные пакета
|
||||
payload = {
|
||||
"profile": profile
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
packet = proto.pack_packet(
|
||||
cmd=0, seq=1, opcode=self.opcodes.NOTIF_PROFILE, payload=payload
|
||||
)
|
||||
elif eventType == "presence":
|
||||
userId = eventData.get("userId")
|
||||
presence = eventData.get("presence")
|
||||
event_time = eventData.get("time")
|
||||
|
||||
payload = {
|
||||
"userId": userId,
|
||||
"presence": presence,
|
||||
"time": event_time
|
||||
}
|
||||
|
||||
packet = proto.pack_packet(
|
||||
cmd=0, seq=1, opcode=self.opcodes.NOTIF_PRESENCE, payload=payload
|
||||
)
|
||||
|
||||
if not packet:
|
||||
return
|
||||
|
||||
if is_web:
|
||||
await writer.send(packet)
|
||||
else:
|
||||
writer.write(packet)
|
||||
await writer.drain()
|
||||
|
||||
def launch(self, api):
|
||||
async def _start_all():
|
||||
await asyncio.gather(
|
||||
OnemeMobile(
|
||||
host=self.config.host,
|
||||
port=self.config.oneme_tcp_port,
|
||||
ssl_context=api['ssl'],
|
||||
db_pool=api['db'],
|
||||
clients=api['clients'],
|
||||
send_event=api['event'],
|
||||
telegram_bot=api.get('telegram_bot'),
|
||||
).start(),
|
||||
OnemeWS(
|
||||
host=self.config.host,
|
||||
port=self.config.oneme_ws_port,
|
||||
ssl_context=api['ssl'],
|
||||
db_pool=api['db'],
|
||||
clients=api['clients'],
|
||||
send_event=api['event'],
|
||||
telegram_bot=api.get('telegram_bot'),
|
||||
).start()
|
||||
)
|
||||
|
||||
return _start_all()
|
||||
@@ -0,0 +1,182 @@
|
||||
import pydantic
|
||||
|
||||
class UserAgentModel(pydantic.BaseModel):
|
||||
deviceType: str
|
||||
appVersion: str
|
||||
osVersion: str
|
||||
timezone: str
|
||||
release: int = None
|
||||
screen: str
|
||||
pushDeviceType: str = None
|
||||
arch: str = None
|
||||
locale: str
|
||||
buildNumber: int = None
|
||||
deviceName: str
|
||||
deviceLocale: str
|
||||
|
||||
class HelloPayloadModel(pydantic.BaseModel):
|
||||
clientSessionId: int = None
|
||||
mt_instanceid: str = None
|
||||
userAgent: UserAgentModel
|
||||
deviceId: str
|
||||
|
||||
class RequestCodePayloadModel(pydantic.BaseModel):
|
||||
phone: str
|
||||
type: str
|
||||
|
||||
@pydantic.field_validator('phone')
|
||||
def validate_phone(cls, v):
|
||||
"""Валидация номера телефона"""
|
||||
if not v.replace("+", "").replace(" ", "").replace("-", "").isdigit():
|
||||
raise ValueError('phone must be digits')
|
||||
return v
|
||||
|
||||
@pydantic.field_validator('type')
|
||||
def validate_type(cls, v):
|
||||
"""Валидация типа запроса"""
|
||||
if not v in ("START_AUTH", "RESEND"):
|
||||
raise ValueError('type must be valid')
|
||||
return v
|
||||
|
||||
class VerifyCodePayloadModel(pydantic.BaseModel):
|
||||
verifyCode: str
|
||||
authTokenType: str
|
||||
token: str
|
||||
|
||||
class LoginPayloadModel(pydantic.BaseModel):
|
||||
interactive: bool
|
||||
token: str
|
||||
|
||||
class PingPayloadModel(pydantic.BaseModel):
|
||||
interactive: bool = None
|
||||
|
||||
class AssetsPayloadModel(pydantic.BaseModel):
|
||||
sync: int
|
||||
type: str
|
||||
|
||||
class AssetsGetPayloadModel(pydantic.BaseModel):
|
||||
type: str
|
||||
count: int = 100
|
||||
query: str = None
|
||||
|
||||
class AssetsGetByIdsPayloadModel(pydantic.BaseModel):
|
||||
type: str
|
||||
ids: list
|
||||
|
||||
class AssetsAddPayloadModel(pydantic.BaseModel):
|
||||
type: str
|
||||
id: int = None
|
||||
|
||||
class AssetsRemovePayloadModel(pydantic.BaseModel):
|
||||
type: str
|
||||
ids: list
|
||||
|
||||
class AssetsMovePayloadModel(pydantic.BaseModel):
|
||||
type: str
|
||||
id: int
|
||||
position: int
|
||||
|
||||
class AssetsListModifyPayloadModel(pydantic.BaseModel):
|
||||
type: str
|
||||
ids: list
|
||||
|
||||
class GetCallHistoryPayloadModel(pydantic.BaseModel):
|
||||
forward: bool
|
||||
count: int
|
||||
|
||||
class MessageModel(pydantic.BaseModel):
|
||||
isLive: bool = None
|
||||
detectShare: bool = None
|
||||
elements: list = None
|
||||
attaches: list = None
|
||||
cid: int = None
|
||||
text: str = None
|
||||
|
||||
class SendMessagePayloadModel(pydantic.BaseModel):
|
||||
# TODO: пишем сервер макса в 2 ночи и не понимаем как это валидировать (блять)
|
||||
userId: int = None
|
||||
chatId: int = None
|
||||
message: MessageModel
|
||||
|
||||
class SyncFoldersPayloadModel(pydantic.BaseModel):
|
||||
folderSync: int
|
||||
|
||||
class CreateFolderPayloadModel(pydantic.BaseModel):
|
||||
id: str
|
||||
title: str
|
||||
filters: list = []
|
||||
include: list = []
|
||||
|
||||
class SearchChatsPayloadModel(pydantic.BaseModel):
|
||||
chatIds: list
|
||||
|
||||
class SearchByPhonePayloadModel(pydantic.BaseModel):
|
||||
phone: str
|
||||
|
||||
class GetCallTokenPayloadModel(pydantic.BaseModel):
|
||||
userId: int
|
||||
value: str
|
||||
|
||||
class TypingPayloadModel(pydantic.BaseModel):
|
||||
chatId: int
|
||||
type: str = None
|
||||
|
||||
class SearchUsersPayloadModel(pydantic.BaseModel):
|
||||
contactIds: list
|
||||
|
||||
class ComplainReasonsGetPayloadModel(pydantic.BaseModel):
|
||||
complainSync: int
|
||||
|
||||
class UpdateProfilePayloadModel(pydantic.BaseModel):
|
||||
description: str = None
|
||||
firstName: str = None
|
||||
lastName: str = None
|
||||
|
||||
class AuthConfirmRegisterPayloadModel(pydantic.BaseModel):
|
||||
token: str
|
||||
firstName: str
|
||||
lastName: str = None
|
||||
tokenType: str
|
||||
|
||||
@pydantic.field_validator('firstName')
|
||||
def validate_first_name(cls, v):
|
||||
v = v.strip()
|
||||
if not v:
|
||||
raise ValueError('firstName must not be empty')
|
||||
if len(v) > 59:
|
||||
raise ValueError('firstName too long')
|
||||
return v
|
||||
|
||||
@pydantic.field_validator('lastName')
|
||||
def validate_last_name(cls, v):
|
||||
if v is None:
|
||||
return v
|
||||
v = v.strip()
|
||||
if len(v) > 59:
|
||||
raise ValueError('lastName too long')
|
||||
return v
|
||||
|
||||
class ChatHistoryPayloadModel(pydantic.BaseModel):
|
||||
chatId: int
|
||||
backward: int
|
||||
|
||||
class ChatSubscribePayloadModel(pydantic.BaseModel):
|
||||
chatId: int
|
||||
subscribe: bool
|
||||
|
||||
class ContactListPayloadModel(pydantic.BaseModel):
|
||||
status: str
|
||||
count: int = None
|
||||
|
||||
class ContactPresencePayloadModel(pydantic.BaseModel):
|
||||
contactIds: list
|
||||
|
||||
class ContactAddByPhonePayloadModel(pydantic.BaseModel):
|
||||
phone: str
|
||||
firstName: str
|
||||
|
||||
class ContactUpdatePayloadModel(pydantic.BaseModel):
|
||||
action: str
|
||||
contactId: int
|
||||
firstName: str = None
|
||||
lastName: str = None
|
||||
@@ -0,0 +1,28 @@
|
||||
from .assets import AssetsProcessors
|
||||
from .auth import AuthProcessors
|
||||
from .calls import CallsProcessors
|
||||
from .chats import ChatsProcessors
|
||||
from .complaints import ComplaintsProcessors
|
||||
from .contacts import ContactsProcessors
|
||||
from .folders import FoldersProcessors
|
||||
from .history import HistoryProcessors
|
||||
from .main import MainProcessors
|
||||
from .messages import MessagesProcessors
|
||||
from .search import SearchProcessors
|
||||
from .sessions import SessionsProcessors
|
||||
|
||||
class Processors(
|
||||
AssetsProcessors,
|
||||
AuthProcessors,
|
||||
CallsProcessors,
|
||||
ChatsProcessors,
|
||||
ComplaintsProcessors,
|
||||
ContactsProcessors,
|
||||
FoldersProcessors,
|
||||
HistoryProcessors,
|
||||
MainProcessors,
|
||||
MessagesProcessors,
|
||||
SearchProcessors,
|
||||
SessionsProcessors
|
||||
):
|
||||
pass
|
||||
@@ -0,0 +1,167 @@
|
||||
import pydantic
|
||||
import time
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import (
|
||||
AssetsPayloadModel,
|
||||
AssetsGetPayloadModel,
|
||||
AssetsGetByIdsPayloadModel,
|
||||
AssetsAddPayloadModel,
|
||||
AssetsRemovePayloadModel,
|
||||
AssetsMovePayloadModel,
|
||||
AssetsListModifyPayloadModel,
|
||||
)
|
||||
|
||||
class AssetsProcessors(BaseProcessor):
|
||||
async def assets_update(self, payload, seq, writer):
|
||||
try:
|
||||
AssetsPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.ASSETS_UPDATE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
response = {
|
||||
"sync": int(time.time() * 1000),
|
||||
"stickerSetsUpdates": {},
|
||||
"stickersUpdates": {},
|
||||
"stickersOrder": [
|
||||
"RECENT",
|
||||
"FAVORITE_STICKERS",
|
||||
"FAVORITE_STICKER_SETS",
|
||||
"TOP",
|
||||
"NEW",
|
||||
"NEW_STICKER_SETS",
|
||||
],
|
||||
"sections": [
|
||||
{
|
||||
"id": "RECENT",
|
||||
"type": "RECENTS",
|
||||
"recentsList": [],
|
||||
},
|
||||
{
|
||||
"id": "FAVORITE_STICKERS",
|
||||
"type": "STICKERS",
|
||||
"stickers": [],
|
||||
"marker": None,
|
||||
},
|
||||
{
|
||||
"id": "FAVORITE_STICKER_SETS",
|
||||
"type": "STICKER_SETS",
|
||||
"stickerSets": [],
|
||||
"marker": None,
|
||||
},
|
||||
{
|
||||
"id": "TOP",
|
||||
"type": "STICKERS",
|
||||
"stickers": [],
|
||||
"marker": None,
|
||||
},
|
||||
{
|
||||
"id": "NEW",
|
||||
"type": "STICKERS",
|
||||
"stickers": [],
|
||||
"marker": None,
|
||||
},
|
||||
{
|
||||
"id": "NEW_STICKER_SETS",
|
||||
"type": "STICKER_SETS",
|
||||
"stickerSets": [],
|
||||
"marker": None,
|
||||
},
|
||||
],
|
||||
}
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.ASSETS_UPDATE, payload=response
|
||||
)
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def assets_get(self, payload, seq, writer):
|
||||
try:
|
||||
data = AssetsGetPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.ASSETS_GET, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
asset_type = data.type
|
||||
if asset_type == "STICKER_SET":
|
||||
response = {"stickerSets": [], "marker": None}
|
||||
else:
|
||||
response = {"stickers": [], "marker": None}
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.ASSETS_GET, payload=response
|
||||
)
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def assets_get_by_ids(self, payload, seq, writer):
|
||||
try:
|
||||
data = AssetsGetByIdsPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.ASSETS_GET_BY_IDS, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
asset_type = data.type
|
||||
if asset_type == "STICKER_SET":
|
||||
response = {"stickerSets": []}
|
||||
else:
|
||||
response = {"stickers": []}
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.ASSETS_GET_BY_IDS, payload=response
|
||||
)
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def assets_add(self, payload, seq, writer):
|
||||
try:
|
||||
AssetsAddPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.ASSETS_ADD, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.ASSETS_ADD, payload={}
|
||||
)
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def assets_remove(self, payload, seq, writer):
|
||||
try:
|
||||
AssetsRemovePayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.ASSETS_REMOVE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.ASSETS_REMOVE, payload={}
|
||||
)
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def assets_move(self, payload, seq, writer):
|
||||
try:
|
||||
AssetsMovePayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.ASSETS_MOVE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.ASSETS_MOVE, payload={}
|
||||
)
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def assets_list_modify(self, payload, seq, writer):
|
||||
try:
|
||||
AssetsListModifyPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.ASSETS_LIST_MODIFY, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.ASSETS_LIST_MODIFY, payload={}
|
||||
)
|
||||
await self._send(writer, packet)
|
||||
@@ -0,0 +1,666 @@
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import secrets
|
||||
import time
|
||||
|
||||
import pydantic
|
||||
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from common.sms import send_sms_code
|
||||
from oneme.config import OnemeConfig
|
||||
from oneme.models import (
|
||||
AuthConfirmRegisterPayloadModel,
|
||||
LoginPayloadModel,
|
||||
RequestCodePayloadModel,
|
||||
VerifyCodePayloadModel,
|
||||
)
|
||||
|
||||
class AuthProcessors(BaseProcessor):
|
||||
def __init__(
|
||||
self,
|
||||
db_pool=None,
|
||||
clients=None,
|
||||
send_event=None,
|
||||
telegram_bot=None,
|
||||
type="socket",
|
||||
):
|
||||
super().__init__(db_pool, clients, send_event, type)
|
||||
self.server_config = OnemeConfig().SERVER_CONFIG
|
||||
self.telegram_bot = telegram_bot
|
||||
|
||||
def _check_legacy_version(self, app_version):
|
||||
"""
|
||||
Функция определения легаси версий клиентов,
|
||||
для которых потребуются некоторые корректировки ответов сервера
|
||||
|
||||
Сейчас данная функция используется для форматирования ответов
|
||||
под версии ниже 25.8.0
|
||||
|
||||
Функция вернет True, если версия слишком старая,
|
||||
или False в противном случае
|
||||
|
||||
[fun fact] С 25.8.0, похоже, начали корректировать протокол, поскольку это
|
||||
самая старая версия, которая работала без всяких корректировок сервера
|
||||
"""
|
||||
|
||||
return tuple(int(v) for v in app_version.split(".")) < (25, 8, 0)
|
||||
|
||||
async def _send_banners(self, writer):
|
||||
"""Функция отправки баннеров клиенту"""
|
||||
# Итоговый список баннеров для отдачи клиенту
|
||||
banners = []
|
||||
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
# Собираем все баннеры, которые есть в бд
|
||||
await cursor.execute(
|
||||
"SELECT * FROM banners WHERE enabled = TRUE"
|
||||
)
|
||||
rows = await cursor.fetchall()
|
||||
|
||||
# Добавляем каждый баннер в лист
|
||||
for row in rows:
|
||||
banner = {
|
||||
"description": row.get("description"),
|
||||
"title": row.get("title"),
|
||||
"priority": row.get("priority"),
|
||||
"type": row.get("type"),
|
||||
"hideCloseButton": bool(row.get("hide_close_button")),
|
||||
"rerun": row.get("rerun"),
|
||||
"url": row.get("url"),
|
||||
"animojiId": row.get("animoji_id"),
|
||||
"repeat": row.get("repeat"),
|
||||
"hideOnClick": bool(row.get("hide_on_click")),
|
||||
"id": row.get("id"),
|
||||
"isTitleAnimated": bool(row.get("is_title_animated")),
|
||||
}
|
||||
|
||||
banners.append(banner)
|
||||
|
||||
# Собираем данные пакета
|
||||
payload = {
|
||||
"showTime": 86400000,
|
||||
"updateTime": int(time.time() * 1000),
|
||||
"banners": banners
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=0, opcode=self.opcodes.NOTIF_BANNERS, payload=payload
|
||||
)
|
||||
|
||||
# Отправляет
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def auth_request(self, payload, seq, writer):
|
||||
"""Обработчик запроса кода"""
|
||||
try:
|
||||
RequestCodePayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(
|
||||
seq, self.opcodes.AUTH_REQUEST, self.error_types.INVALID_PAYLOAD, writer
|
||||
)
|
||||
return
|
||||
|
||||
# Извлекаем телефон из пакета
|
||||
phone = payload.get("phone").replace("+", "").replace(" ", "").replace("-", "")
|
||||
|
||||
# Генерируем токен
|
||||
token = secrets.token_urlsafe(102)
|
||||
token_hash = hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
# Время истечения токена
|
||||
expires = int(time.time()) + 300
|
||||
|
||||
user_exists = False
|
||||
|
||||
# Ищем пользователя
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute("SELECT * FROM users WHERE phone = %s", (phone,))
|
||||
user = await cursor.fetchone()
|
||||
|
||||
# Получаем код через SMS шлюз или генерируем локально (безопасность прежде всего)
|
||||
local_fallback_code = False
|
||||
if self.config.sms_gateway_url:
|
||||
code = await send_sms_code(self.config.sms_gateway_url, phone)
|
||||
|
||||
if code is None:
|
||||
code = str(secrets.randbelow(900000) + 100000)
|
||||
local_fallback_code = True
|
||||
else:
|
||||
code = str(secrets.randbelow(900000) + 100000)
|
||||
local_fallback_code = True
|
||||
|
||||
# Хешируем
|
||||
code_hash = hashlib.sha256(code.encode()).hexdigest()
|
||||
|
||||
# Сохраняем токен и если нужно отправляем код через тг
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
if user:
|
||||
user_exists = True
|
||||
# Сохраняем токен
|
||||
await cursor.execute(
|
||||
"INSERT INTO auth_tokens (phone, token_hash, code_hash, expires) VALUES (%s, %s, %s, %s)",
|
||||
(
|
||||
phone,
|
||||
token_hash,
|
||||
code_hash,
|
||||
expires,
|
||||
),
|
||||
)
|
||||
|
||||
# Если код был сгенерирован локально, а тг привязан к аккаунту - отправляем туда сообщение
|
||||
if (
|
||||
local_fallback_code
|
||||
and self.telegram_bot
|
||||
and user.get("telegram_id")
|
||||
):
|
||||
await self.telegram_bot.send_code(
|
||||
chat_id=int(user.get("telegram_id")), phone=phone, code=code
|
||||
)
|
||||
else:
|
||||
# Пользователь не найден - сохраняем токен со state='register'
|
||||
# чтобы после верификации кода направить на экран регистрации
|
||||
await cursor.execute(
|
||||
"INSERT INTO auth_tokens (phone, token_hash, code_hash, expires, state) VALUES (%s, %s, %s, %s, %s)",
|
||||
(
|
||||
phone,
|
||||
token_hash,
|
||||
code_hash,
|
||||
expires,
|
||||
"register",
|
||||
),
|
||||
)
|
||||
|
||||
# Данные пакета
|
||||
payload = {
|
||||
"token": token,
|
||||
"codeLength": 6,
|
||||
"requestMaxDuration": 60000,
|
||||
"requestCountLeft": 10,
|
||||
"altActionDuration": 60000,
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK,
|
||||
seq=seq,
|
||||
opcode=self.opcodes.AUTH_REQUEST,
|
||||
payload=payload,
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, packet)
|
||||
self.logger.debug(f"Код для {phone}: {code} (существующий={user_exists})")
|
||||
|
||||
async def auth(self, payload, seq, writer, deviceType, deviceName, appVersion, ip):
|
||||
"""Обработчик проверки кода"""
|
||||
try:
|
||||
VerifyCodePayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(
|
||||
seq, self.opcodes.AUTH, self.error_types.INVALID_PAYLOAD, writer
|
||||
)
|
||||
return
|
||||
|
||||
# Извлекаем данные из пакета
|
||||
code = payload.get("verifyCode")
|
||||
token = payload.get("token")
|
||||
|
||||
# Хешируем токен с кодом
|
||||
hashed_code = hashlib.sha256(code.encode()).hexdigest()
|
||||
hashed_token = hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
# Генерируем постоянный токен
|
||||
login = secrets.token_urlsafe(128)
|
||||
hashed_login = hashlib.sha256(login.encode()).hexdigest()
|
||||
|
||||
# Ищем токен с кодом
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
# Ищем токен
|
||||
await cursor.execute(
|
||||
"SELECT * FROM auth_tokens WHERE token_hash = %s AND expires > UNIX_TIMESTAMP()",
|
||||
(hashed_token,),
|
||||
)
|
||||
stored_token = await cursor.fetchone()
|
||||
|
||||
# Если токен просрочен, или его нет - отправляем ошибку
|
||||
if stored_token is None:
|
||||
await self._send_error(
|
||||
seq, self.opcodes.AUTH, self.error_types.CODE_EXPIRED, writer
|
||||
)
|
||||
return
|
||||
|
||||
# Проверяем код
|
||||
if stored_token.get("code_hash") != hashed_code:
|
||||
await self._send_error(
|
||||
seq, self.opcodes.AUTH, self.error_types.INVALID_CODE, writer
|
||||
)
|
||||
return
|
||||
|
||||
# Если это новый пользователь - переводим токен в state='verified'
|
||||
# и отдаём клиенту REGISTER токен, чтобы он показал экран ввода имени
|
||||
if stored_token.get("state") == "register":
|
||||
await cursor.execute(
|
||||
"UPDATE auth_tokens SET state = %s WHERE token_hash = %s",
|
||||
(
|
||||
"verified",
|
||||
hashed_token,
|
||||
),
|
||||
)
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK,
|
||||
seq=seq,
|
||||
opcode=self.opcodes.AUTH,
|
||||
payload={
|
||||
"tokenAttrs": {"REGISTER": {"token": token}},
|
||||
"presetAvatars": [],
|
||||
},
|
||||
)
|
||||
await self._send(writer, packet)
|
||||
return
|
||||
|
||||
# Ищем аккаунт
|
||||
await cursor.execute(
|
||||
"SELECT * FROM users WHERE phone = %s", (stored_token.get("phone"),)
|
||||
)
|
||||
account = await cursor.fetchone()
|
||||
|
||||
# Удаляем токен
|
||||
await cursor.execute(
|
||||
"DELETE FROM auth_tokens WHERE token_hash = %s", (hashed_token,)
|
||||
)
|
||||
|
||||
# Создаем сессию
|
||||
await cursor.execute(
|
||||
"INSERT INTO tokens (phone, token_hash, device_type, device_name, location, time) VALUES (%s, %s, %s, %s, %s, %s)",
|
||||
(
|
||||
stored_token.get("phone"),
|
||||
hashed_login,
|
||||
deviceType,
|
||||
deviceName,
|
||||
self.tools.get_geo(
|
||||
ip=ip, db_path=self.config.geo_db_path
|
||||
),
|
||||
int(time.time() * 1000),
|
||||
), # весь покрытый зеленью, абсолютно весь, остров невезения в океане есть
|
||||
)
|
||||
|
||||
# Генерируем профиль
|
||||
# Аватарка с биографией
|
||||
photoId = (
|
||||
None if not account.get("avatar_id") else int(account.get("avatar_id"))
|
||||
)
|
||||
avatar_url = None if not photoId else self.config.avatar_base_url + str(photoId)
|
||||
description = (
|
||||
None if not account.get("description") else account.get("description")
|
||||
)
|
||||
|
||||
if self._check_legacy_version(appVersion):
|
||||
include_profile_options = False
|
||||
else:
|
||||
include_profile_options = True
|
||||
|
||||
# Собираем данные пакета
|
||||
payload = {
|
||||
"tokenAttrs": {"LOGIN": {"token": login}},
|
||||
"profile": self.tools.generate_profile(
|
||||
id=account.get("id"),
|
||||
phone=int(account.get("phone")),
|
||||
avatarUrl=avatar_url,
|
||||
photoId=photoId,
|
||||
updateTime=int(account.get("updatetime")),
|
||||
firstName=account.get("firstname"),
|
||||
lastName=account.get("lastname"),
|
||||
options=json.loads(account.get("options")),
|
||||
description=description,
|
||||
accountStatus=int(account.get("accountstatus")),
|
||||
profileOptions=json.loads(account.get("profileoptions")),
|
||||
includeProfileOptions=include_profile_options,
|
||||
username=account.get("username"),
|
||||
),
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.AUTH, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def auth_confirm(self, payload, seq, writer, deviceType, deviceName, appVersion, ip):
|
||||
"""Обработчик подтверждения регистрации нового пользователя"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
AuthConfirmRegisterPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(
|
||||
seq, self.opcodes.AUTH_CONFIRM, self.error_types.INVALID_PAYLOAD, writer
|
||||
)
|
||||
return
|
||||
|
||||
# Извлекаем данные из пакета
|
||||
token = payload.get("token")
|
||||
first_name = payload.get("firstName").strip()
|
||||
last_name = (payload.get("lastName") or "").strip()
|
||||
|
||||
# Хешируем токен
|
||||
hashed_token = hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
# Генерируем постоянный логин-токен
|
||||
login = secrets.token_urlsafe(128)
|
||||
hashed_login = hashlib.sha256(login.encode()).hexdigest()
|
||||
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
# Ищем токен - он должен быть в state='verified'
|
||||
await cursor.execute(
|
||||
"SELECT * FROM auth_tokens WHERE token_hash = %s AND expires > UNIX_TIMESTAMP() AND state = %s",
|
||||
(
|
||||
hashed_token,
|
||||
"verified",
|
||||
),
|
||||
)
|
||||
stored_token = await cursor.fetchone()
|
||||
|
||||
# Если токен не найден или просрочен - отправляем ошибку
|
||||
if stored_token is None:
|
||||
await self._send_error(
|
||||
seq,
|
||||
self.opcodes.AUTH_CONFIRM,
|
||||
self.error_types.CODE_EXPIRED,
|
||||
writer,
|
||||
)
|
||||
return
|
||||
|
||||
phone = stored_token.get("phone")
|
||||
|
||||
# Проверяем что пользователь с таким телефоном ещё не существует
|
||||
await cursor.execute("SELECT id FROM users WHERE phone = %s", (phone,))
|
||||
if await cursor.fetchone():
|
||||
await self._send_error(
|
||||
seq,
|
||||
self.opcodes.AUTH_CONFIRM,
|
||||
self.error_types.INVALID_PAYLOAD,
|
||||
writer,
|
||||
)
|
||||
return
|
||||
|
||||
now_ms = int(time.time() * 1000)
|
||||
now_s = int(time.time())
|
||||
|
||||
# Генерируем ID пользователя
|
||||
user_id = await self.tools.generate_user_id(self.db_pool)
|
||||
|
||||
# Создаем пользователя
|
||||
await cursor.execute(
|
||||
"""
|
||||
INSERT INTO users
|
||||
(id, phone, telegram_id, firstname, lastname, username,
|
||||
profileoptions, options, accountstatus, updatetime, lastseen)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
""",
|
||||
(
|
||||
user_id,
|
||||
phone,
|
||||
None,
|
||||
first_name,
|
||||
last_name,
|
||||
None,
|
||||
json.dumps([]),
|
||||
json.dumps(["TT", "ONEME"]),
|
||||
0,
|
||||
str(now_ms),
|
||||
str(now_s),
|
||||
),
|
||||
)
|
||||
|
||||
# Добавляем данные аккаунта
|
||||
await cursor.execute(
|
||||
"""
|
||||
INSERT INTO user_data
|
||||
(phone, user_config, chat_config)
|
||||
VALUES (%s, %s, %s)
|
||||
""",
|
||||
(
|
||||
phone,
|
||||
json.dumps(self.static.USER_SETTINGS),
|
||||
json.dumps({}),
|
||||
),
|
||||
)
|
||||
|
||||
# Добавляем дефолтную папку
|
||||
await cursor.execute(
|
||||
"""
|
||||
INSERT INTO user_folders
|
||||
(id, phone, title, sort_order)
|
||||
VALUES ('all.chat.folder', %s, 'Все', 0)
|
||||
""",
|
||||
(phone,),
|
||||
)
|
||||
|
||||
# Удаляем токен
|
||||
await cursor.execute(
|
||||
"DELETE FROM auth_tokens WHERE token_hash = %s", (hashed_token,)
|
||||
)
|
||||
|
||||
# Создаем сессию
|
||||
await cursor.execute(
|
||||
"INSERT INTO tokens (phone, token_hash, device_type, device_name, location, time) VALUES (%s, %s, %s, %s, %s, %s)",
|
||||
(
|
||||
phone,
|
||||
hashed_login,
|
||||
deviceType or "ANDROID",
|
||||
deviceName or "Unknown",
|
||||
self.tools.get_geo(
|
||||
ip=ip, db_path=self.config.geo_db_path
|
||||
),
|
||||
now_ms,
|
||||
),
|
||||
)
|
||||
|
||||
if self._check_legacy_version(appVersion):
|
||||
include_profile_options = False
|
||||
else:
|
||||
include_profile_options = True
|
||||
|
||||
# Генерируем профиль
|
||||
profile = self.tools.generate_profile(
|
||||
id=user_id,
|
||||
phone=int(phone),
|
||||
avatarUrl=None,
|
||||
photoId=None,
|
||||
updateTime=now_ms,
|
||||
firstName=first_name,
|
||||
lastName=last_name,
|
||||
options=["ONEME"],
|
||||
description=None,
|
||||
accountStatus=0,
|
||||
profileOptions=[],
|
||||
includeProfileOptions=include_profile_options,
|
||||
username=None,
|
||||
)
|
||||
|
||||
# Собираем данные пакета
|
||||
payload = {
|
||||
"userToken": "0",
|
||||
"profile": profile,
|
||||
"tokenType": "LOGIN",
|
||||
"token": login,
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK,
|
||||
seq=seq,
|
||||
opcode=self.opcodes.AUTH_CONFIRM,
|
||||
payload=payload,
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, packet)
|
||||
self.logger.info(
|
||||
f"Новый пользователь зарегистрирован: phone={phone} id={user_id} name={first_name} {last_name}"
|
||||
)
|
||||
|
||||
async def login(self, payload, seq, writer, appVersion):
|
||||
"""Обработчик авторизации клиента на сервере"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
LoginPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(
|
||||
seq, self.opcodes.LOGIN, self.error_types.INVALID_PAYLOAD, writer
|
||||
)
|
||||
return None, None, None
|
||||
|
||||
# Чаты, где состоит пользователь
|
||||
chats = []
|
||||
|
||||
# Получаем данные из пакета
|
||||
token = payload.get("token")
|
||||
|
||||
# Хешируем токен
|
||||
hashed_token = hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
# Ищем токен в бд
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT * FROM tokens WHERE token_hash = %s", (hashed_token,)
|
||||
)
|
||||
token_data = await cursor.fetchone()
|
||||
|
||||
# Если токен не найден, отправляем ошибку
|
||||
if token_data is None:
|
||||
await self._send_error(
|
||||
seq, self.opcodes.LOGIN, self.error_types.INVALID_TOKEN, writer
|
||||
)
|
||||
return None, None, None
|
||||
|
||||
# Ищем аккаунт пользователя в бд
|
||||
await cursor.execute(
|
||||
"SELECT * FROM users WHERE phone = %s", (token_data.get("phone"),)
|
||||
)
|
||||
user = await cursor.fetchone()
|
||||
|
||||
# Ищем данные пользователя в бд
|
||||
await cursor.execute(
|
||||
"SELECT * FROM user_data WHERE phone = %s",
|
||||
(token_data.get("phone"),),
|
||||
)
|
||||
user_data = await cursor.fetchone()
|
||||
|
||||
# Ищем все чаты, где состоит пользователь
|
||||
await cursor.execute(
|
||||
"SELECT * FROM chat_participants WHERE user_id = %s",
|
||||
(user.get("id"),),
|
||||
)
|
||||
user_chats = await cursor.fetchall()
|
||||
|
||||
for chat in user_chats:
|
||||
chats.append(chat.get("chat_id"))
|
||||
|
||||
# Обновляем юзер конфиг
|
||||
updated_user_config = await self.tools.update_user_config(
|
||||
cursor, token_data.get("phone"),
|
||||
user_data.get("user_config"), self.static.USER_SETTINGS
|
||||
)
|
||||
|
||||
# Аватарка с биографией
|
||||
photoId = None if not user.get("avatar_id") else int(user.get("avatar_id"))
|
||||
avatar_url = None if not photoId else self.config.avatar_base_url + str(photoId)
|
||||
description = None if not user.get("description") else user.get("description")
|
||||
|
||||
if self._check_legacy_version(appVersion):
|
||||
include_profile_options = False
|
||||
else:
|
||||
include_profile_options = True
|
||||
|
||||
# Генерируем профиль
|
||||
profile = self.tools.generate_profile(
|
||||
id=user.get("id"),
|
||||
phone=int(user.get("phone")),
|
||||
avatarUrl=avatar_url,
|
||||
photoId=photoId,
|
||||
updateTime=int(user.get("updatetime")),
|
||||
firstName=user.get("firstname"),
|
||||
lastName=user.get("lastname"),
|
||||
options=json.loads(user.get("options")),
|
||||
description=description,
|
||||
accountStatus=int(user.get("accountstatus")),
|
||||
profileOptions=json.loads(user.get("profileoptions")),
|
||||
includeProfileOptions=include_profile_options,
|
||||
username=user.get("username"),
|
||||
)
|
||||
|
||||
# Генерируем список чатов
|
||||
chats = await self.tools.generate_chats(
|
||||
chats, self.db_pool, user.get("id"), protocol_type=self.type
|
||||
)
|
||||
|
||||
# Генерируем список контактов
|
||||
contacts = await self.tools.collect_user_contacts(
|
||||
user.get("id"), self.db_pool, self.config.avatar_base_url
|
||||
)
|
||||
|
||||
# Собираем статусы контактов
|
||||
contact_ids = [c.get("id") for c in contacts if c.get("id") is not None]
|
||||
presence = await self.tools.collect_presence(contact_ids, self.clients, self.db_pool)
|
||||
|
||||
# Формируем данные пакета
|
||||
payload = {
|
||||
"profile": profile,
|
||||
"chats": chats,
|
||||
"chatMarker": 0,
|
||||
"messages": {},
|
||||
"contacts": contacts,
|
||||
"presence": presence,
|
||||
"config": {
|
||||
"hash": "0",
|
||||
"server": self.server_config,
|
||||
"user": updated_user_config,
|
||||
},
|
||||
"token": token,
|
||||
"videoChatHistory": False,
|
||||
"time": int(time.time() * 1000),
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.LOGIN, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, packet)
|
||||
|
||||
# Отправляем баннеры
|
||||
await self._send_banners(writer)
|
||||
|
||||
return int(user.get("phone")), int(user.get("id")), hashed_token
|
||||
|
||||
async def logout(self, seq, writer, hashedToken):
|
||||
"""Обработчик завершения сессии"""
|
||||
# Удаляем токен из бд
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"DELETE FROM tokens WHERE token_hash = %s", (hashedToken,)
|
||||
)
|
||||
|
||||
# Создаем пакет
|
||||
response = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.LOGOUT, payload=None
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, response)
|
||||
@@ -0,0 +1,64 @@
|
||||
import pydantic
|
||||
import secrets
|
||||
import time
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import (
|
||||
GetCallTokenPayloadModel,
|
||||
GetCallHistoryPayloadModel
|
||||
)
|
||||
|
||||
class CallsProcessors(BaseProcessor):
|
||||
async def ok_token(self, payload, seq, writer):
|
||||
"""Получение токена для звонка"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
GetCallTokenPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.OK_TOKEN, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# TODO: когда-то взяться за звонки
|
||||
|
||||
# Данные пакета
|
||||
payload = {
|
||||
"token": secrets.token_urlsafe(128),
|
||||
"token_lifetime_ts": int(time.time() * 1000),
|
||||
"token_refresh_ts": int(time.time() * 1000)
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.OK_TOKEN, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def video_chat_history(self, payload, seq, writer):
|
||||
"""Обработчик получения истории звонков"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
GetCallHistoryPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.VIDEO_CHAT_HISTORY, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# TODO: сейчас это заглушка, а попозже нужно сделать полноценную реализацию
|
||||
|
||||
# Данные пакета
|
||||
payload = {
|
||||
"hasMore": False,
|
||||
"history": [],
|
||||
"backwardMarker": 0,
|
||||
"forwardMarker": 0
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.VIDEO_CHAT_HISTORY, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, packet)
|
||||
@@ -0,0 +1,20 @@
|
||||
import pydantic
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import ChatSubscribePayloadModel
|
||||
|
||||
class ChatsProcessors(BaseProcessor):
|
||||
async def chat_subscribe(self, payload, seq, writer):
|
||||
# Валидируем входные данные
|
||||
try:
|
||||
ChatSubscribePayloadModel.model_validate(payload)
|
||||
except Exception as e:
|
||||
await self._send_error(seq, self.opcodes.CHAT_SUBSCRIBE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Созадаем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CHAT_SUBSCRIBE, payload=None
|
||||
)
|
||||
|
||||
# Отправялем
|
||||
await self._send(writer, packet)
|
||||
@@ -0,0 +1,29 @@
|
||||
import pydantic
|
||||
import time
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import ComplainReasonsGetPayloadModel
|
||||
|
||||
class ComplaintsProcessors(BaseProcessor):
|
||||
async def complain_reasons_get(self, payload, seq, writer):
|
||||
"""Обработчик получения причин жалоб"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
ComplainReasonsGetPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.COMPLAIN_REASONS_GET, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Собираем данные пакета
|
||||
payload = {
|
||||
"complains": self.static.COMPLAIN_REASONS,
|
||||
"complainSync": int(time.time())
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
seq=seq, opcode=self.opcodes.COMPLAIN_REASONS_GET, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем пакет
|
||||
await self._send(writer, packet)
|
||||
@@ -0,0 +1,412 @@
|
||||
import pydantic
|
||||
import json
|
||||
import time
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import ContactAddByPhonePayloadModel, ContactListPayloadModel, ContactPresencePayloadModel, ContactUpdatePayloadModel
|
||||
|
||||
class ContactsProcessors(BaseProcessor):
|
||||
async def contact_list(self, payload, seq, writer, userId):
|
||||
"""Обработчик получения контактов"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
ContactListPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.CONTACT_LIST, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
status = payload.get("status")
|
||||
count = payload.get("count")
|
||||
|
||||
# Итоговый контакт-лист
|
||||
contact_list = []
|
||||
|
||||
if status == "BLOCKED":
|
||||
# Собираем контакты, которые в черном списке
|
||||
blocked = []
|
||||
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
if count:
|
||||
await cursor.execute(
|
||||
"SELECT * FROM contacts WHERE owner_id = %s AND is_blocked = TRUE LIMIT %s",
|
||||
(userId, count),
|
||||
)
|
||||
else:
|
||||
await cursor.execute(
|
||||
"SELECT * FROM contacts WHERE owner_id = %s AND is_blocked = TRUE",
|
||||
(userId,),
|
||||
)
|
||||
rows = await cursor.fetchall()
|
||||
|
||||
for row in rows:
|
||||
blocked.append(
|
||||
{
|
||||
"id": int(row.get("contact_id")),
|
||||
"firstname": row.get("custom_firstname"),
|
||||
"lastname": row.get("custom_lastname"),
|
||||
"blocked": True,
|
||||
}
|
||||
)
|
||||
|
||||
# Генерируем контакт-лист
|
||||
contact_list = await self.tools.generate_contacts(
|
||||
blocked, self.db_pool, avatar_base_url=self.config.avatar_base_url
|
||||
)
|
||||
|
||||
# Собираем данные пакета
|
||||
response_payload = {
|
||||
"contacts": contact_list
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
seq=seq, opcode=self.opcodes.CONTACT_LIST, payload=response_payload
|
||||
)
|
||||
|
||||
# Отправляем пакет
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def contact_update(self, payload, seq, writer, userId):
|
||||
"""
|
||||
Обработчик опкода какого-то там
|
||||
(их хуй запомнишь, даже в мриме команды помню, бля)
|
||||
|
||||
Отвечает за добавку, удаление, блокировку и разблокировку контакта
|
||||
"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
ContactUpdatePayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.CONTACT_UPDATE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
action = payload.get("action")
|
||||
contactId = payload.get("contactId")
|
||||
firstName = payload.get("firstName")
|
||||
lastName = payload.get("lastName", "")
|
||||
|
||||
if action == "ADD":
|
||||
# Проверяем, существует ли пользователь с таким ID
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute("SELECT * FROM users WHERE id = %s", (contactId,))
|
||||
user = await cursor.fetchone()
|
||||
|
||||
if not user:
|
||||
await self._send_error(seq, self.opcodes.CONTACT_UPDATE, self.error_types.CONTACT_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
# Проверяем, не добавлен ли уже контакт
|
||||
await cursor.execute(
|
||||
"SELECT * FROM contacts WHERE owner_id = %s AND contact_id = %s",
|
||||
(userId, contactId)
|
||||
)
|
||||
row = await cursor.fetchone()
|
||||
|
||||
# Если контакта не существует, то можем продолжать,
|
||||
if not row:
|
||||
# Добавляем контакт
|
||||
await cursor.execute(
|
||||
"INSERT INTO contacts (owner_id, contact_id, custom_firstname, custom_lastname, is_blocked) VALUES (%s, %s, %s, %s, FALSE)",
|
||||
(userId, contactId, firstName, lastName)
|
||||
)
|
||||
|
||||
# Создаем диалог, если его нет
|
||||
chatId = userId ^ contactId
|
||||
await cursor.execute("SELECT * FROM chats WHERE id = %s", (chatId,))
|
||||
chat = await cursor.fetchone()
|
||||
|
||||
if not chat:
|
||||
await cursor.execute(
|
||||
"INSERT INTO chats (id, owner, type) VALUES (%s, %s, %s)",
|
||||
(chatId, userId, "DIALOG")
|
||||
)
|
||||
|
||||
for uid in [int(userId), int(contactId)]:
|
||||
await cursor.execute(
|
||||
"INSERT INTO chat_participants (chat_id, user_id) VALUES (%s, %s)",
|
||||
(chatId, uid)
|
||||
)
|
||||
# а если уже существует, отправляем ошибку
|
||||
else:
|
||||
await self._send_error(seq, self.opcodes.CONTACT_UPDATE, self.error_types.CONTACT_ALREADY_ADDED, writer)
|
||||
return
|
||||
|
||||
# Генерируем профиль
|
||||
photoId = None if not user.get("avatar_id") else int(user.get("avatar_id"))
|
||||
avatar_url = None if not photoId else self.config.avatar_base_url + str(photoId)
|
||||
|
||||
contact = self.tools.generate_profile(
|
||||
id=user.get("id"),
|
||||
phone=int(user.get("phone")),
|
||||
avatarUrl=avatar_url,
|
||||
photoId=photoId,
|
||||
updateTime=int(user.get("updatetime")),
|
||||
firstName=user.get("firstname"),
|
||||
lastName=user.get("lastname"),
|
||||
options=json.loads(user.get("options")),
|
||||
accountStatus=int(user.get("accountstatus")),
|
||||
includeProfileOptions=False,
|
||||
custom_firstname=firstName,
|
||||
custom_lastname=lastName,
|
||||
)
|
||||
|
||||
response_payload = {
|
||||
"contact": contact
|
||||
}
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONTACT_UPDATE, payload=response_payload
|
||||
)
|
||||
|
||||
await self._send(writer, packet)
|
||||
|
||||
elif action == "REMOVE":
|
||||
# Удаляем контакт
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"DELETE FROM contacts WHERE owner_id = %s AND contact_id = %s",
|
||||
(userId, contactId)
|
||||
)
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONTACT_UPDATE, payload=None
|
||||
)
|
||||
|
||||
await self._send(writer, packet)
|
||||
|
||||
elif action == "BLOCK":
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
# Проверяем, существует ли контакт
|
||||
await cursor.execute(
|
||||
"SELECT * FROM contacts WHERE owner_id = %s AND contact_id = %s",
|
||||
(userId, contactId)
|
||||
)
|
||||
row = await cursor.fetchone()
|
||||
|
||||
# Обновляем существующий контакт, если такой есть
|
||||
if row:
|
||||
await cursor.execute(
|
||||
"UPDATE contacts SET is_blocked = TRUE WHERE owner_id = %s AND contact_id = %s",
|
||||
(userId, contactId)
|
||||
)
|
||||
else: # В ином случае добавляем новую запись в бд
|
||||
await cursor.execute("SELECT * FROM users WHERE id = %s", (contactId,))
|
||||
user = await cursor.fetchone()
|
||||
if not user:
|
||||
await self._send_error(seq, self.opcodes.CONTACT_UPDATE, self.error_types.USER_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
await cursor.execute(
|
||||
"INSERT INTO contacts (owner_id, contact_id, custom_firstname, custom_lastname, is_blocked) VALUES (%s, %s, %s, %s, TRUE)",
|
||||
(userId, contactId, firstName, lastName)
|
||||
)
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONTACT_UPDATE, payload=None
|
||||
)
|
||||
|
||||
await self._send(writer, packet)
|
||||
|
||||
elif action == "UNBLOCK":
|
||||
# Разблокируем контакт
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
# Проверяем, существует ли контакт
|
||||
await cursor.execute(
|
||||
"SELECT * FROM contacts WHERE owner_id = %s AND contact_id = %s",
|
||||
(userId, contactId)
|
||||
)
|
||||
row = await cursor.fetchone()
|
||||
|
||||
# Обновляем контакт, если он есть
|
||||
if row:
|
||||
await cursor.execute(
|
||||
"UPDATE contacts SET is_blocked = FALSE WHERE owner_id = %s AND contact_id = %s",
|
||||
(userId, contactId)
|
||||
)
|
||||
else: # В ином случае отправляем ошибку
|
||||
await self._send_error(seq, self.opcodes.CONTACT_UPDATE, self.error_types.CONTACT_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONTACT_UPDATE, payload=None
|
||||
)
|
||||
|
||||
await self._send(writer, packet)
|
||||
|
||||
elif action == "UPDATE":
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
# Проверяем, существует ли контакт
|
||||
await cursor.execute(
|
||||
"SELECT * FROM contacts WHERE owner_id = %s AND contact_id = %s",
|
||||
(userId, contactId)
|
||||
)
|
||||
row = await cursor.fetchone()
|
||||
|
||||
# Если контакта нет, отдаем ошибку
|
||||
if not row:
|
||||
await self._send_error(seq, self.opcodes.CONTACT_UPDATE, self.error_types.CONTACT_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
# Обновляем контакт
|
||||
await cursor.execute(
|
||||
"UPDATE contacts SET custom_firstname = %s, custom_lastname = %s WHERE owner_id = %s AND contact_id = %s",
|
||||
(firstName, lastName, userId, contactId)
|
||||
)
|
||||
|
||||
# Получаем данные пользователя
|
||||
await cursor.execute("SELECT * FROM users WHERE id = %s", (contactId,))
|
||||
user = await cursor.fetchone()
|
||||
|
||||
# Генерируем профиль
|
||||
photoId = None if not user.get("avatar_id") else int(user.get("avatar_id"))
|
||||
avatar_url = None if not photoId else self.config.avatar_base_url + str(photoId)
|
||||
|
||||
contact = self.tools.generate_profile(
|
||||
id=user.get("id"),
|
||||
phone=int(user.get("phone")),
|
||||
avatarUrl=avatar_url,
|
||||
photoId=photoId,
|
||||
updateTime=int(user.get("updatetime")),
|
||||
firstName=user.get("firstname"),
|
||||
lastName=user.get("lastname"),
|
||||
options=json.loads(user.get("options")),
|
||||
accountStatus=int(user.get("accountstatus")),
|
||||
description=user.get("description"),
|
||||
includeProfileOptions=False,
|
||||
custom_firstname=firstName,
|
||||
custom_lastname=lastName,
|
||||
)
|
||||
|
||||
response_payload = {
|
||||
"contact": contact
|
||||
}
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONTACT_UPDATE, payload=response_payload
|
||||
)
|
||||
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def contact_add_by_phone(self, payload, seq, writer, userId):
|
||||
"""Добавление контакта по номеру телефона"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
ContactAddByPhonePayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.CONTACT_ADD_BY_PHONE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
phone = payload.get("phone")
|
||||
firstName = payload.get("firstName")
|
||||
lastName = payload.get("lastName")
|
||||
|
||||
# Ищем пользователя по номеру телефона
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute("SELECT * FROM users WHERE phone = %s", (int(phone),))
|
||||
user = await cursor.fetchone()
|
||||
|
||||
if not user:
|
||||
await self._send_error(seq, self.opcodes.CONTACT_ADD_BY_PHONE, self.error_types.CONTACT_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
contactId = user.get("id")
|
||||
|
||||
# Проверяем, не добавлен ли уже контакт
|
||||
await cursor.execute(
|
||||
"SELECT * FROM contacts WHERE owner_id = %s AND contact_id = %s",
|
||||
(userId, contactId)
|
||||
)
|
||||
existing_contact = await cursor.fetchone()
|
||||
|
||||
is_new = existing_contact is None
|
||||
|
||||
if is_new:
|
||||
# Добавляем контакт
|
||||
await cursor.execute(
|
||||
"INSERT INTO contacts (owner_id, contact_id, custom_firstname, custom_lastname) VALUES (%s, %s, %s, %s)",
|
||||
(userId, contactId, firstName, lastName)
|
||||
)
|
||||
|
||||
# Создаем диалог, если его нет
|
||||
chatId = userId ^ contactId
|
||||
await cursor.execute("SELECT * FROM chats WHERE id = %s", (chatId,))
|
||||
chat = await cursor.fetchone()
|
||||
|
||||
if not chat:
|
||||
await cursor.execute(
|
||||
"INSERT INTO chats (id, owner, type) VALUES (%s, %s, %s)",
|
||||
(chatId, userId, "DIALOG")
|
||||
)
|
||||
|
||||
for uid in [int(userId), int(contactId)]:
|
||||
await cursor.execute(
|
||||
"INSERT INTO chat_participants (chat_id, user_id) VALUES (%s, %s)",
|
||||
(chatId, uid)
|
||||
)
|
||||
|
||||
# Генерируем профиль
|
||||
photoId = None if not user.get("avatar_id") else int(user.get("avatar_id"))
|
||||
avatar_url = None if not photoId else self.config.avatar_base_url + str(photoId)
|
||||
|
||||
contact = self.tools.generate_profile(
|
||||
id=user.get("id"),
|
||||
phone=int(user.get("phone")),
|
||||
avatarUrl=avatar_url,
|
||||
photoId=photoId,
|
||||
updateTime=int(user.get("updatetime")),
|
||||
firstName=user.get("firstname"),
|
||||
lastName=user.get("lastname"),
|
||||
options=json.loads(user.get("options")),
|
||||
accountStatus=int(user.get("accountstatus")),
|
||||
description=user.get("description"),
|
||||
includeProfileOptions=False,
|
||||
custom_firstname=firstName,
|
||||
custom_lastname=lastName,
|
||||
username=user.get("username"),
|
||||
)
|
||||
|
||||
response_payload = {
|
||||
"new": is_new,
|
||||
"contact": contact
|
||||
}
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONTACT_ADD_BY_PHONE, payload=response_payload
|
||||
)
|
||||
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def contact_presence(self, payload, seq, writer):
|
||||
"""Обработчик получения статуса контактов"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
ContactPresencePayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.CONTACT_PRESENCE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
contact_ids = payload.get("contactIds", [])
|
||||
now_ms = int(time.time() * 1000)
|
||||
|
||||
presence = await self.tools.collect_presence(contact_ids, self.clients, self.db_pool)
|
||||
|
||||
response_payload = {
|
||||
"presence": presence,
|
||||
"time": now_ms
|
||||
}
|
||||
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONTACT_PRESENCE, payload=response_payload
|
||||
)
|
||||
|
||||
await self._send(writer, packet)
|
||||
@@ -0,0 +1,133 @@
|
||||
import pydantic
|
||||
import json
|
||||
import time
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import SyncFoldersPayloadModel, CreateFolderPayloadModel
|
||||
|
||||
class FoldersProcessors(BaseProcessor):
|
||||
async def folders_get(self, payload, seq, writer, senderPhone):
|
||||
"""Синхронизация папок с сервером"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
SyncFoldersPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.FOLDERS_GET, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Ищем папки в бд
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT id, title, filters, `include`, options, update_time, source_id "
|
||||
"FROM user_folders WHERE phone = %s ORDER BY sort_order",
|
||||
(int(senderPhone),)
|
||||
)
|
||||
result_folders = await cursor.fetchall()
|
||||
|
||||
folders = [
|
||||
{
|
||||
"id": folder["id"],
|
||||
"title": folder["title"],
|
||||
"filters": json.loads(folder["filters"]),
|
||||
"include": json.loads(folder["include"]),
|
||||
"updateTime": folder["update_time"],
|
||||
"options": json.loads(folder["options"]),
|
||||
"sourceId": folder["source_id"]
|
||||
}
|
||||
for folder in result_folders
|
||||
]
|
||||
|
||||
# Создаем данные пакета
|
||||
payload = {
|
||||
"folderSync": int(time.time() * 1000),
|
||||
"folders": folders,
|
||||
"foldersOrder": [folder["id"] for folder in result_folders],
|
||||
"allFilterExcludeFolders": []
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.FOLDERS_GET, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def folders_update(self, payload, seq, writer, senderPhone):
|
||||
"""Создание папки"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
CreateFolderPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.FOLDERS_UPDATE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
update_time = int(time.time() * 1000)
|
||||
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT COALESCE(MAX(sort_order), -1) as max_order FROM user_folders WHERE phone = %s",
|
||||
(int(senderPhone),)
|
||||
)
|
||||
row = await cursor.fetchone()
|
||||
next_order = row["max_order"] + 1
|
||||
|
||||
# Создаем новую папку
|
||||
await cursor.execute(
|
||||
"INSERT INTO user_folders (id, phone, title, filters, `include`, options, source_id, update_time, sort_order) "
|
||||
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)",
|
||||
(
|
||||
payload.get("id"),
|
||||
int(senderPhone),
|
||||
payload.get("title"),
|
||||
json.dumps(payload.get("filters")),
|
||||
json.dumps(payload.get("include", [])),
|
||||
json.dumps([]),
|
||||
1,
|
||||
update_time,
|
||||
next_order,
|
||||
)
|
||||
)
|
||||
await conn.commit()
|
||||
|
||||
# Получаем обновленный порядок папок
|
||||
await cursor.execute(
|
||||
"SELECT id FROM user_folders WHERE phone = %s ORDER BY sort_order",
|
||||
(int(senderPhone),)
|
||||
)
|
||||
all_folders = await cursor.fetchall()
|
||||
|
||||
folders_order = [f["id"] for f in all_folders]
|
||||
|
||||
# Формируем данные пакета
|
||||
response_payload = {
|
||||
"folder": {
|
||||
"id": payload.get("id"),
|
||||
"title": payload.get("title"),
|
||||
"include": payload.get("include"),
|
||||
"filters": payload.get("filters"),
|
||||
"updateTime": update_time,
|
||||
"options": [],
|
||||
"sourceId": 1,
|
||||
},
|
||||
"folderSync": update_time,
|
||||
"foldersOrder": folders_order,
|
||||
}
|
||||
|
||||
# Формируем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.FOLDERS_UPDATE, payload=response_payload
|
||||
)
|
||||
|
||||
await self._send(writer, packet)
|
||||
|
||||
# Разработчики протокола, объяснитесь, что за хеш !!! а еще подарите нам способ его формирования
|
||||
notify_about_hash = self.proto.pack_packet(
|
||||
cmd=0, seq=1, opcode=self.opcodes.NOTIF_CONFIG,
|
||||
payload={"config": {"hash": "0"}}
|
||||
)
|
||||
|
||||
await self._send(writer, notify_about_hash)
|
||||
@@ -0,0 +1,94 @@
|
||||
import pydantic
|
||||
import json
|
||||
import time
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import ChatHistoryPayloadModel
|
||||
|
||||
class HistoryProcessors(BaseProcessor):
|
||||
async def chat_history(self, payload, seq, writer, senderId):
|
||||
"""Обработчик получения истории чата"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
ChatHistoryPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.CHAT_HISTORY, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Извлекаем данные из пакета
|
||||
chatId = payload.get("chatId")
|
||||
forward = payload.get("forward", 0)
|
||||
backward = payload.get("backward", 0)
|
||||
from_time = payload.get("from", 0)
|
||||
getMessages = payload.get("getMessages", True)
|
||||
getChat = payload.get("getChat", False)
|
||||
messages = []
|
||||
|
||||
# Если пользователь хочет получить историю из избранного,
|
||||
# то выставляем в качестве ID чата отрицательный ID отправителя
|
||||
isFavourite = chatId == (senderId ^ senderId)
|
||||
if isFavourite:
|
||||
chatId = -senderId
|
||||
|
||||
# Проверяем, существует ли чат
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
# Проверяем состоит ли пользователь в чате,
|
||||
# только в случае того, если это не избранное
|
||||
if not isFavourite:
|
||||
await cursor.execute("SELECT * FROM chats WHERE id = %s", (chatId,))
|
||||
chat = await cursor.fetchone()
|
||||
|
||||
# Выбрасываем ошибку, если чата нет
|
||||
if not chat:
|
||||
await self._send_error(seq, self.opcodes.CHAT_HISTORY, self.error_types.CHAT_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
# Проверяем, является ли пользователь участником чата
|
||||
participants = await self.tools.get_chat_participants(chatId, self.db_pool)
|
||||
if int(senderId) not in participants:
|
||||
await self._send_error(seq, self.opcodes.CHAT_HISTORY, self.error_types.CHAT_NOT_ACCESS, writer)
|
||||
return
|
||||
|
||||
# Если запрошены сообщения
|
||||
if getMessages:
|
||||
if backward > 0:
|
||||
await cursor.execute(
|
||||
"SELECT * FROM messages WHERE chat_id = %s AND time < %s ORDER BY time ASC LIMIT %s",
|
||||
(chatId, from_time, backward)
|
||||
)
|
||||
|
||||
result = await cursor.fetchall()
|
||||
|
||||
for row in result:
|
||||
messages.append(self.tools.build_message_dict(row, self.type))
|
||||
backward_count = len(result)
|
||||
if forward > 0:
|
||||
await cursor.execute(
|
||||
"SELECT * FROM messages WHERE chat_id = %s AND time > %s ORDER BY time ASC LIMIT %s",
|
||||
(chatId, from_time, forward)
|
||||
)
|
||||
|
||||
result = await cursor.fetchall()
|
||||
|
||||
for row in result:
|
||||
messages.append(self.tools.build_message_dict(row, self.type))
|
||||
forward_count = len(result)
|
||||
|
||||
# Сортируем сообщения по времени
|
||||
messages.sort(key=lambda x: x["time"])
|
||||
|
||||
payload = {
|
||||
"messages": messages
|
||||
}
|
||||
|
||||
if getChat:
|
||||
payload["chat"] = {}
|
||||
|
||||
# Собираем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CHAT_HISTORY, payload=payload
|
||||
)
|
||||
|
||||
# Отправялем
|
||||
await self._send(writer, packet)
|
||||
@@ -0,0 +1,244 @@
|
||||
import pydantic
|
||||
import json
|
||||
import time
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import (
|
||||
HelloPayloadModel,
|
||||
PingPayloadModel,
|
||||
UpdateProfilePayloadModel
|
||||
)
|
||||
|
||||
|
||||
class MainProcessors(BaseProcessor):
|
||||
def __init__(self, db_pool=None, clients=None, send_event=None, type="socket"):
|
||||
super().__init__(db_pool, clients, send_event, type)
|
||||
|
||||
async def session_init(self, payload, seq, writer):
|
||||
"""Обработчик приветствия"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
HelloPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.SESSION_INIT, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return None, None, None
|
||||
|
||||
# Получаем данные из пакета
|
||||
userAgent = payload.get("userAgent")
|
||||
deviceType = userAgent.get("deviceType")
|
||||
deviceName = userAgent.get("deviceName")
|
||||
appVersion = userAgent.get("appVersion")
|
||||
|
||||
# Данные пакета
|
||||
payload = {
|
||||
"callsSeed": int(time.time() * 1000),
|
||||
"location": "RU",
|
||||
"app-update-type": 0, # 1 = принудительное обновление
|
||||
"reg-country-code": self.static.REG_COUNTRY_CODES,
|
||||
"phone-auto-complete-enabled": False,
|
||||
"qr-auth-enabled": False,
|
||||
"lang": True
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.SESSION_INIT, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, packet)
|
||||
return deviceType, deviceName, appVersion
|
||||
|
||||
async def ping(self, payload, seq, writer, userId=None):
|
||||
"""Обработчик пинга"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
PingPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.PING, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Обновляем статус пользователя, если он авторизован
|
||||
# и в пакете отправлен интерактив
|
||||
interactive = payload.get("interactive") if payload else None
|
||||
if userId and interactive is not None:
|
||||
now = int(time.time())
|
||||
user = self.clients.get(userId)
|
||||
if user:
|
||||
if interactive:
|
||||
user["status"] = 2
|
||||
user["last_seen"] = now
|
||||
else:
|
||||
user["status"] = 0
|
||||
user["last_seen"] = now
|
||||
|
||||
# Сохраняем последнее время посещения
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"UPDATE users SET lastseen = %s WHERE id = %s",
|
||||
(str(now), userId)
|
||||
)
|
||||
|
||||
# Рассылаем статус контактам пользователя
|
||||
now_ms = int(time.time() * 1000)
|
||||
if interactive:
|
||||
presence_data = {"on": "ON", "seen": now, "status": 1}
|
||||
else:
|
||||
presence_data = {"seen": now}
|
||||
|
||||
# Находим всех, у кого этот пользователь в контактах
|
||||
async with self.db_pool.acquire() as conn2:
|
||||
async with conn2.cursor() as cursor2:
|
||||
await cursor2.execute(
|
||||
"SELECT owner_id FROM contacts WHERE contact_id = %s",
|
||||
(userId,)
|
||||
)
|
||||
contact_owners = await cursor2.fetchall()
|
||||
|
||||
# Рассылаем
|
||||
for row in contact_owners:
|
||||
owner_id = int(row.get("owner_id"))
|
||||
if owner_id in self.clients:
|
||||
await self.event(
|
||||
owner_id,
|
||||
{
|
||||
"eventType": "presence",
|
||||
"userId": userId,
|
||||
"presence": presence_data,
|
||||
"time": now_ms,
|
||||
}
|
||||
)
|
||||
|
||||
# Собираем пакет
|
||||
response = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.PING, payload=None
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, response)
|
||||
|
||||
async def log(self, payload, seq, writer):
|
||||
"""Обработчик телеметрии"""
|
||||
# TODO: можно было бы реализовать валидацию телеметрии, но сейчас это не особо важно
|
||||
|
||||
# Собираем пакет
|
||||
response = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.LOG, payload=None
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, response)
|
||||
|
||||
async def profile(self, payload, seq, writer, userId):
|
||||
# Валидируем входные данные
|
||||
try:
|
||||
UpdateProfilePayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.PROFILE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Ищем пользователя в бд
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute("SELECT * FROM users WHERE id = %s", (userId,))
|
||||
user = await cursor.fetchone()
|
||||
|
||||
# Если пользователь не найден
|
||||
if not user:
|
||||
await self._send_error(seq, self.opcodes.PROFILE, self.error_types.USER_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
# Аватарка с биографией
|
||||
photoId = None if not user.get("avatar_id") else int(user.get("avatar_id"))
|
||||
avatar_url = None if not photoId else self.config.avatar_base_url + str(photoId)
|
||||
description = None if not user.get("description") else user.get("description")
|
||||
|
||||
# Генерируем профиль
|
||||
profile = self.tools.generate_profile(
|
||||
id=user.get("id"),
|
||||
phone=int(user.get("phone")),
|
||||
avatarUrl=avatar_url,
|
||||
photoId=photoId,
|
||||
updateTime=int(user.get("updatetime")),
|
||||
firstName=user.get("firstname"),
|
||||
lastName=user.get("lastname"),
|
||||
options=json.loads(user.get("options")),
|
||||
description=description,
|
||||
accountStatus=int(user.get("accountstatus")),
|
||||
profileOptions=json.loads(user.get("profileoptions")),
|
||||
includeProfileOptions=True,
|
||||
username=user.get("username")
|
||||
)
|
||||
|
||||
# Создаем данные пакета
|
||||
payload = {
|
||||
"profile": profile
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
response = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.PROFILE, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, response)
|
||||
|
||||
async def update_config(self, payload, seq, writer, userPhone, hashedToken=None):
|
||||
"""
|
||||
Обработчик 22 опкода (config)
|
||||
Он отвечает за обновление настроек приватности
|
||||
и пуш токена для пушей
|
||||
"""
|
||||
# Пейлоад, который отдадим клиенту
|
||||
# а отдавать его нужно только при изменении настроек приватности
|
||||
result_payload = None
|
||||
|
||||
if payload.get("pushToken"):
|
||||
push_token = payload.get("pushToken")
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"UPDATE tokens SET push_token = %s WHERE phone = %s AND token_hash = %s",
|
||||
(push_token, str(userPhone), hashedToken)
|
||||
)
|
||||
elif payload.get("settings") and payload.get("settings").get("user"):
|
||||
"""Обновление настроек приватности"""
|
||||
new_settings = payload.get("settings").get("user")
|
||||
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
# Получаем текущий конфиг
|
||||
await cursor.execute(
|
||||
"SELECT user_config FROM user_data WHERE phone = %s", (userPhone,)
|
||||
)
|
||||
row = await cursor.fetchone()
|
||||
|
||||
if row:
|
||||
current_config = json.loads(row.get("user_config"))
|
||||
|
||||
# Обновляем настройки
|
||||
for key, value in new_settings.items():
|
||||
if key in current_config:
|
||||
current_config[key] = value
|
||||
|
||||
# Сохраняем обновлённый конфиг
|
||||
await cursor.execute(
|
||||
"UPDATE user_data SET user_config = %s WHERE phone = %s",
|
||||
(json.dumps(current_config), userPhone)
|
||||
)
|
||||
|
||||
result_payload = {
|
||||
"user": current_config,
|
||||
"hash": "0"
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
response = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONFIG, payload=result_payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, response)
|
||||
@@ -0,0 +1,181 @@
|
||||
import pydantic
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import (
|
||||
TypingPayloadModel,
|
||||
SendMessagePayloadModel
|
||||
)
|
||||
|
||||
class MessagesProcessors(BaseProcessor):
|
||||
async def msg_typing(self, payload, seq, writer, senderId):
|
||||
"""Обработчик события печатания"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
TypingPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.MSG_TYPING, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Извлекаем данные из пакета
|
||||
chatId = payload.get("chatId")
|
||||
type = payload.get("type") or "TYPING"
|
||||
|
||||
# Ищем чат в базе данных
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute("SELECT * FROM chats WHERE id = %s", (chatId,))
|
||||
chat = await cursor.fetchone()
|
||||
|
||||
# Если чат не найден, отправляем ошибку
|
||||
if not chat:
|
||||
await self._send_error(seq, self.opcodes.MSG_TYPING, self.error_types.CHAT_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
# Участники чата
|
||||
participants = await self.tools.get_chat_participants(chatId, self.db_pool)
|
||||
|
||||
# Проверяем, является ли отправитель участником чата
|
||||
if int(senderId) not in participants:
|
||||
await self._send_error(seq, self.opcodes.MSG_TYPING, self.error_types.CHAT_NOT_ACCESS, writer)
|
||||
return
|
||||
|
||||
# Рассылаем событие участникам чата
|
||||
for participant in participants:
|
||||
if participant != senderId:
|
||||
# Если участник не является отправителем, отправляем
|
||||
await self.event(
|
||||
participant,
|
||||
{
|
||||
"eventType": "typing",
|
||||
"chatId": chatId,
|
||||
"type": type,
|
||||
"userId": senderId,
|
||||
"writer": writer,
|
||||
}
|
||||
)
|
||||
|
||||
# Создаем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
seq=seq, opcode=self.opcodes.MSG_TYPING
|
||||
)
|
||||
|
||||
# Отправляем пакет
|
||||
await self._send(writer, packet)
|
||||
|
||||
async def msg_send(self, payload, seq, writer, senderId, db_pool):
|
||||
"""Функция отправки сообщения"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
SendMessagePayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.MSG_SEND, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Извлекаем данные из пакета
|
||||
userId = payload.get("userId")
|
||||
chatId = payload.get("chatId")
|
||||
message = payload.get("message")
|
||||
|
||||
elements = message.get("elements") or []
|
||||
attaches = message.get("attaches") or []
|
||||
cid = message.get("cid") or 0
|
||||
text = message.get("text") or ""
|
||||
|
||||
# Вычисляем ID чата по ID пользователя и ID отправителя,
|
||||
# в случае отсутствия ID чата
|
||||
if chatId is None:
|
||||
chatId = userId ^ senderId
|
||||
|
||||
# Если клиент хочет отправить сообщение в избранное,
|
||||
# то выставляем в качестве ID чата отрицательный ID отправителя
|
||||
if chatId == (senderId ^ senderId):
|
||||
chatId = -senderId
|
||||
participants = [senderId]
|
||||
else:
|
||||
# Если все таки клиент хочет отправить сообщение в нормальный чат,
|
||||
# то ищем его в базе данных (извлекать список участников все таки тоже надо)
|
||||
async with db_pool.acquire() as db_connection:
|
||||
async with db_connection.cursor() as cursor:
|
||||
await cursor.execute("SELECT * FROM chats WHERE id = %s", (chatId,))
|
||||
chat = await cursor.fetchone()
|
||||
|
||||
# Если нет такого чата - выбрасываем ошибку
|
||||
if not chat:
|
||||
await self._send_error(seq, self.opcodes.MSG_SEND, self.error_types.CHAT_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
# Список участников
|
||||
participants = await self.tools.get_chat_participants(chatId, db_pool)
|
||||
|
||||
# Проверяем, является ли отправитель участником чата
|
||||
if int(senderId) not in participants:
|
||||
await self._send_error(seq, self.opcodes.MSG_SEND, self.error_types.CHAT_NOT_ACCESS, writer)
|
||||
return
|
||||
|
||||
# Проверяем блокировку собеседника
|
||||
if chat.get("type") == "DIALOG":
|
||||
contactid = [p for p in participants if p != int(senderId)][0]
|
||||
# Проверяем, заблокировал ли отправитель собеседника
|
||||
if await self.tools.contact_is_blocked(contactid, senderId, db_pool):
|
||||
await self._send_error(seq, self.opcodes.MSG_SEND, self.error_types.CONTACT_BLOCKED, writer)
|
||||
return
|
||||
|
||||
# Добавляем сообщение в историю
|
||||
messageId, lastMessageId, messageTime = await self.tools.insert_message(
|
||||
chatId=chatId,
|
||||
senderId=senderId,
|
||||
text=text,
|
||||
attaches=attaches,
|
||||
elements=elements,
|
||||
cid=cid,
|
||||
type="USER",
|
||||
db_pool=self.db_pool
|
||||
)
|
||||
|
||||
# Готовое тело сообщения. Поля cid / elements / reactionInfo / link
|
||||
# должны присутствовать ВСЕГДА (даже пустые) — десктопный MAX
|
||||
# ожидает фиксированную msgpack-схему и обрывает соединение
|
||||
# при отсутствии любого из них (см. регрессию из 87cfc19).
|
||||
bodyMessage = {
|
||||
"id": messageId if self.type == "mobile" else str(messageId),
|
||||
"cid": int(cid or 0),
|
||||
"time": messageTime,
|
||||
"type": "USER",
|
||||
"sender": senderId,
|
||||
"text": text,
|
||||
"attaches": attaches if isinstance(attaches, list) else [],
|
||||
"elements": elements if isinstance(elements, list) else [],
|
||||
"reactionInfo": {},
|
||||
"link": {},
|
||||
}
|
||||
|
||||
# Отправляем событие всем участникам чата
|
||||
for participant in participants:
|
||||
await self.event(
|
||||
participant,
|
||||
{
|
||||
"eventType": "new_msg",
|
||||
"chatId": 0 if chatId == -senderId else chatId,
|
||||
"message": bodyMessage,
|
||||
"prevMessageId": lastMessageId,
|
||||
"time": messageTime,
|
||||
"writer": writer
|
||||
}
|
||||
)
|
||||
|
||||
# Данные пакета
|
||||
payload = {
|
||||
"chatId": 0 if chatId == -senderId else chatId,
|
||||
"message": bodyMessage,
|
||||
"unread": 0,
|
||||
"mark": messageTime
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
packet = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.MSG_SEND, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, packet)
|
||||
@@ -0,0 +1,254 @@
|
||||
import json
|
||||
import pydantic
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
from oneme.models import (
|
||||
SearchUsersPayloadModel,
|
||||
SearchChatsPayloadModel,
|
||||
SearchByPhonePayloadModel
|
||||
)
|
||||
|
||||
|
||||
class SearchProcessors(BaseProcessor):
|
||||
async def contact_info(self, payload, seq, writer, senderId):
|
||||
"""Поиск пользователей по ID"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
SearchUsersPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.CONTACT_INFO, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Итоговый список пользователей
|
||||
users = []
|
||||
|
||||
# ID пользователей, которые нам предстоит найти
|
||||
contactIds = payload.get("contactIds")
|
||||
|
||||
# Ищем пользователей в бд
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
for contactId in contactIds:
|
||||
await cursor.execute("SELECT * FROM users WHERE id = %s", (contactId,))
|
||||
user = await cursor.fetchone()
|
||||
|
||||
# Если такой пользователь есть, добавляем его в список
|
||||
if user:
|
||||
# Аватарка с биографией
|
||||
photoId = None if not user.get("avatar_id") else int(user.get("avatar_id"))
|
||||
avatar_url = None if not photoId else self.config.avatar_base_url + str(photoId)
|
||||
description = None if not user.get("description") else user.get("description")
|
||||
|
||||
# Получаем данные контакта
|
||||
await cursor.execute(
|
||||
"SELECT * FROM contacts WHERE owner_id = %s AND contact_id = %s",
|
||||
(senderId, contactId),
|
||||
)
|
||||
contact_row = await cursor.fetchone()
|
||||
custom_firstname = contact_row.get("custom_firstname") if contact_row else None
|
||||
custom_lastname = contact_row.get("custom_lastname") if contact_row else None
|
||||
blocked = bool(contact_row.get("is_blocked")) if contact_row else False
|
||||
|
||||
# Генерируем профиль
|
||||
users.append(
|
||||
self.tools.generate_profile(
|
||||
id=user.get("id"),
|
||||
phone=int(user.get("phone")),
|
||||
avatarUrl=avatar_url,
|
||||
photoId=photoId,
|
||||
updateTime=int(user.get("updatetime")),
|
||||
firstName=user.get("firstname"),
|
||||
lastName=user.get("lastname"),
|
||||
options=json.loads(user.get("options")),
|
||||
description=description,
|
||||
accountStatus=int(user.get("accountstatus")),
|
||||
profileOptions=json.loads(user.get("profileoptions")),
|
||||
includeProfileOptions=False,
|
||||
username=user.get("username"),
|
||||
custom_firstname=custom_firstname,
|
||||
custom_lastname=custom_lastname,
|
||||
blocked=blocked,
|
||||
)
|
||||
)
|
||||
|
||||
# Создаем данные пакета
|
||||
payload = {
|
||||
"contacts": users
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
response = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONTACT_INFO, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, response)
|
||||
|
||||
async def contact_info_by_phone(self, payload, seq, writer, senderId):
|
||||
"""Поиск по номеру телефона"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
SearchByPhonePayloadModel.model_validate(payload)
|
||||
except Exception as e:
|
||||
await self._send_error(seq, self.opcodes.CONTACT_INFO_BY_PHONE, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Ищем пользователя в бд
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute("SELECT * FROM users WHERE phone = %s", (int(payload.get("phone")),))
|
||||
user = await cursor.fetchone()
|
||||
|
||||
# Если пользователь не найден, отправляем ошибку
|
||||
if not user:
|
||||
await self._send_error(seq, self.opcodes.CONTACT_INFO_BY_PHONE, self.error_types.USER_NOT_FOUND, writer)
|
||||
return
|
||||
|
||||
# ID чата
|
||||
chatId = senderId ^ user.get("id")
|
||||
|
||||
# Ищем диалог в бд
|
||||
await cursor.execute("SELECT * FROM chats WHERE id = %s", (chatId,))
|
||||
chat = await cursor.fetchone()
|
||||
|
||||
# Если диалога нет - создаем
|
||||
if not chat:
|
||||
await cursor.execute(
|
||||
"INSERT INTO chats (id, owner, type) VALUES (%s, %s, %s)",
|
||||
(chatId, senderId, "DIALOG")
|
||||
)
|
||||
|
||||
# Добавляем участников в таблицу chat_participants
|
||||
participants = [int(senderId), int(user.get("id"))]
|
||||
|
||||
for user_id in participants:
|
||||
await cursor.execute(
|
||||
"INSERT INTO chat_participants (chat_id, user_id) VALUES (%s, %s)",
|
||||
(chatId, user_id)
|
||||
)
|
||||
|
||||
# Аватарка с биографией
|
||||
photoId = None if not user.get("avatar_id") else int(user.get("avatar_id"))
|
||||
avatar_url = None if not photoId else self.config.avatar_base_url + str(photoId)
|
||||
description = None if not user.get("description") else user.get("description")
|
||||
|
||||
# Получаем данные контакта
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT * FROM contacts WHERE owner_id = %s AND contact_id = %s",
|
||||
(senderId, user.get("id")),
|
||||
)
|
||||
contact_row = await cursor.fetchone()
|
||||
custom_firstname = contact_row.get("custom_firstname") if contact_row else None
|
||||
custom_lastname = contact_row.get("custom_lastname") if contact_row else None
|
||||
blocked = bool(contact_row.get("is_blocked")) if contact_row else False
|
||||
|
||||
# Генерируем профиль
|
||||
profile = self.tools.generate_profile(
|
||||
id=user.get("id"),
|
||||
phone=int(user.get("phone")),
|
||||
avatarUrl=avatar_url,
|
||||
photoId=photoId,
|
||||
updateTime=int(user.get("updatetime")),
|
||||
firstName=user.get("firstname"),
|
||||
lastName=user.get("lastname"),
|
||||
options=json.loads(user.get("options")),
|
||||
description=description,
|
||||
accountStatus=int(user.get("accountstatus")),
|
||||
profileOptions=json.loads(user.get("profileoptions")),
|
||||
includeProfileOptions=False,
|
||||
username=user.get("username"),
|
||||
custom_firstname=custom_firstname,
|
||||
custom_lastname=custom_lastname,
|
||||
blocked=blocked,
|
||||
)
|
||||
|
||||
# Создаем данные пакета
|
||||
payload = {
|
||||
"contact": profile
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
response = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CONTACT_INFO_BY_PHONE, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, response)
|
||||
|
||||
async def chat_info(self, payload, seq, writer, senderId):
|
||||
"""Поиск чатов по ID"""
|
||||
# Валидируем данные пакета
|
||||
try:
|
||||
SearchChatsPayloadModel.model_validate(payload)
|
||||
except pydantic.ValidationError as error:
|
||||
self.logger.error(f"Возникли ошибки при валидации пакета: {error}")
|
||||
await self._send_error(seq, self.opcodes.CHAT_INFO, self.error_types.INVALID_PAYLOAD, writer)
|
||||
return
|
||||
|
||||
# Итоговый список чатов
|
||||
chats = []
|
||||
|
||||
# ID чатов, которые нам предстоит найти
|
||||
chatIds = payload.get("chatIds")
|
||||
|
||||
# Ищем чаты в бд
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
for chatId in chatIds:
|
||||
if chatId != 0:
|
||||
await cursor.execute("SELECT * FROM chats WHERE id = %s", (chatId,))
|
||||
chat = await cursor.fetchone()
|
||||
|
||||
if chat:
|
||||
# Проверяем, является ли пользователь участником чата
|
||||
participants = await self.tools.get_chat_participants(chatId, self.db_pool)
|
||||
# (в max нельзя смотреть и отправлять сообщения в чат, в котором ты не участник, в отличие от tg (например, комментарии в каналах),
|
||||
# так что надо тоже так делать)
|
||||
if int(senderId) not in participants:
|
||||
continue
|
||||
|
||||
# Получаем последнее сообщение из чата
|
||||
message, messageTime = await self.tools.get_last_message(
|
||||
chatId, self.db_pool, protocol_type=self.type
|
||||
)
|
||||
|
||||
# Добавляем чат в список
|
||||
chats.append(
|
||||
self.tools.generate_chat(
|
||||
chatId, chat.get("owner"),
|
||||
chat.get("type"), participants,
|
||||
message, messageTime
|
||||
)
|
||||
)
|
||||
else:
|
||||
# Получаем последнее сообщение из избранного
|
||||
message, messageTime = await self.tools.get_last_message(
|
||||
-senderId, self.db_pool, protocol_type=self.type
|
||||
)
|
||||
|
||||
# ID избранного для клиента
|
||||
chatId = senderId ^ senderId
|
||||
|
||||
# Добавляем чат в список
|
||||
chats.append(
|
||||
self.tools.generate_chat(
|
||||
chatId, senderId,
|
||||
"DIALOG", [senderId],
|
||||
message, messageTime
|
||||
)
|
||||
)
|
||||
|
||||
# Создаем данные пакета
|
||||
payload = {
|
||||
"chats": chats
|
||||
}
|
||||
|
||||
# Собираем пакет
|
||||
response = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.CHAT_INFO, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, response)
|
||||
@@ -0,0 +1,38 @@
|
||||
from classes.baseprocessor import BaseProcessor
|
||||
|
||||
class SessionsProcessors(BaseProcessor):
|
||||
async def sessions_info(self, payload, seq, writer, senderPhone, hashedToken):
|
||||
"""Получение активных сессий на аккаунте"""
|
||||
# Готовый список сессий
|
||||
sessions = []
|
||||
|
||||
# Ищем сессии в бд
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute("SELECT * FROM tokens WHERE phone = %s", (str(senderPhone),))
|
||||
user_sessions = await cursor.fetchall()
|
||||
|
||||
# Собираем сессии в список
|
||||
for session in user_sessions:
|
||||
sessions.append(
|
||||
{
|
||||
"time": int(session.get("time")),
|
||||
"client": f"MAX {session.get('device_type')}",
|
||||
"info": session.get("device_name"),
|
||||
"location": session.get("location"),
|
||||
"current": True if session.get("token_hash") == hashedToken else False
|
||||
}
|
||||
)
|
||||
|
||||
# Создаем данные пакета
|
||||
payload = {
|
||||
"sessions": sessions
|
||||
}
|
||||
|
||||
# Создаем пакет
|
||||
response = self.proto.pack_packet(
|
||||
cmd=self.proto.CMD_OK, seq=seq, opcode=self.opcodes.SESSIONS_INFO, payload=payload
|
||||
)
|
||||
|
||||
# Отправляем
|
||||
await self._send(writer, response)
|
||||
@@ -0,0 +1,496 @@
|
||||
import asyncio
|
||||
import logging
|
||||
import time
|
||||
import traceback
|
||||
|
||||
from common.opcodes import Opcodes
|
||||
from common.proto_tcp import MobileProto
|
||||
from common.rate_limiter import RateLimiter
|
||||
from common.tools import Tools
|
||||
from oneme.processors import Processors
|
||||
|
||||
|
||||
class OnemeMobile:
|
||||
def __init__(
|
||||
self, host, port, ssl_context, db_pool, clients, send_event, telegram_bot
|
||||
):
|
||||
self.host = host
|
||||
self.port = port
|
||||
self.ssl_context = ssl_context
|
||||
self.server = None
|
||||
self.logger = logging.getLogger(__name__)
|
||||
self.db_pool = db_pool
|
||||
self.clients = clients
|
||||
|
||||
self.proto = MobileProto()
|
||||
self.auth_required = Tools().auth_required
|
||||
self.processors = Processors(
|
||||
db_pool=db_pool,
|
||||
clients=clients,
|
||||
send_event=send_event,
|
||||
telegram_bot=telegram_bot,
|
||||
)
|
||||
self.opcodes = Opcodes()
|
||||
|
||||
# rate limiter anti ddos brute force protection
|
||||
self.auth_rate_limiter = RateLimiter(max_attempts=15, window_seconds=60)
|
||||
|
||||
self.read_timeout = 300 # Таймаут чтения из сокета (секунды)
|
||||
self.max_read_size = 65536 # Максимальный размер данных из сокета
|
||||
|
||||
async def handle_client(self, reader, writer):
|
||||
"""Функция для обработки подключений"""
|
||||
# IP-адрес клиента
|
||||
address = writer.get_extra_info("peername")
|
||||
self.logger.info(f"Работаю с клиентом {address[0]}:{address[1]}")
|
||||
|
||||
deviceType = None
|
||||
deviceName = None
|
||||
appVersion = None
|
||||
|
||||
userPhone = None
|
||||
userId = None
|
||||
hashedToken = None
|
||||
|
||||
try:
|
||||
while True:
|
||||
# Читаем новые данные из сокета с таймаутом
|
||||
try:
|
||||
data = await asyncio.wait_for(
|
||||
reader.read(self.max_read_size), timeout=self.read_timeout
|
||||
)
|
||||
except asyncio.TimeoutError:
|
||||
self.logger.info(
|
||||
f"Таймаут соединения для {address[0]}:{address[1]}"
|
||||
)
|
||||
break
|
||||
|
||||
# Если сокет закрыт - выходим из цикла
|
||||
if not data:
|
||||
break
|
||||
|
||||
if len(data) > self.max_read_size:
|
||||
self.logger.warning(
|
||||
f"Пакет от {address[0]}:{address[1]} превышает лимит ({len(data)} байт)"
|
||||
)
|
||||
break
|
||||
|
||||
# Распаковываем данные
|
||||
packet = self.proto.unpack_packet(data)
|
||||
|
||||
# Скип если пакет невалидный
|
||||
if packet is None:
|
||||
self.logger.warning(
|
||||
f"Невалидный пакет от {address[0]}:{address[1]}"
|
||||
)
|
||||
continue
|
||||
|
||||
opcode = packet.get("opcode")
|
||||
seq = packet.get("seq")
|
||||
payload = packet.get("payload")
|
||||
|
||||
match opcode:
|
||||
case self.opcodes.SESSION_INIT:
|
||||
deviceType, deviceName, appVersion = await self.processors.session_init(
|
||||
payload, seq, writer
|
||||
)
|
||||
case self.opcodes.AUTH_REQUEST:
|
||||
if not self.auth_rate_limiter.is_allowed(address[0]):
|
||||
await self.processors._send_error(
|
||||
seq,
|
||||
self.opcodes.AUTH_REQUEST,
|
||||
self.processors.error_types.RATE_LIMITED,
|
||||
writer,
|
||||
)
|
||||
else:
|
||||
await self.processors.auth_request(payload, seq, writer)
|
||||
case self.opcodes.AUTH:
|
||||
if not self.auth_rate_limiter.is_allowed(address[0]):
|
||||
await self.processors._send_error(
|
||||
seq,
|
||||
self.opcodes.AUTH,
|
||||
self.processors.error_types.RATE_LIMITED,
|
||||
writer,
|
||||
)
|
||||
else:
|
||||
await self.processors.auth(
|
||||
payload, seq, writer, deviceType, deviceName, appVersion, address[0]
|
||||
)
|
||||
case self.opcodes.AUTH_CONFIRM:
|
||||
if not self.auth_rate_limiter.is_allowed(address[0]):
|
||||
await self.processors._send_error(
|
||||
seq,
|
||||
self.opcodes.AUTH_CONFIRM,
|
||||
self.processors.error_types.RATE_LIMITED,
|
||||
writer,
|
||||
)
|
||||
elif payload and payload.get("tokenType") == "REGISTER":
|
||||
await self.processors.auth_confirm(
|
||||
payload, seq, writer, deviceType, deviceName, appVersion, address[0]
|
||||
)
|
||||
else:
|
||||
self.logger.warning(
|
||||
f"AUTH_CONFIRM с неизвестным tokenType: {payload}"
|
||||
)
|
||||
case self.opcodes.LOGIN:
|
||||
if not self.auth_rate_limiter.is_allowed(address[0]):
|
||||
await self.processors._send_error(
|
||||
seq,
|
||||
self.opcodes.LOGIN,
|
||||
self.processors.error_types.RATE_LIMITED,
|
||||
writer,
|
||||
)
|
||||
else:
|
||||
(
|
||||
userPhone,
|
||||
userId,
|
||||
hashedToken,
|
||||
) = await self.processors.login(payload, seq, writer, appVersion)
|
||||
|
||||
if userPhone:
|
||||
await self._finish_auth(
|
||||
writer, address, userPhone, userId
|
||||
)
|
||||
case self.opcodes.LOGOUT:
|
||||
await self.processors.logout(
|
||||
seq, writer, hashedToken=hashedToken
|
||||
)
|
||||
break
|
||||
case self.opcodes.PING:
|
||||
await self.processors.ping(payload, seq, writer, userId)
|
||||
case self.opcodes.LOG:
|
||||
await self.processors.log(payload, seq, writer)
|
||||
case self.opcodes.ASSETS_UPDATE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_update,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.ASSETS_GET:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_get,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.ASSETS_GET_BY_IDS:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_get_by_ids,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.ASSETS_ADD:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_add,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.ASSETS_REMOVE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_remove,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.ASSETS_MOVE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_move,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.ASSETS_LIST_MODIFY:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_list_modify,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.VIDEO_CHAT_HISTORY:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.video_chat_history,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.MSG_SEND:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.msg_send,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userId,
|
||||
self.db_pool,
|
||||
)
|
||||
case self.opcodes.FOLDERS_GET:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.folders_get,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userPhone,
|
||||
)
|
||||
case self.opcodes.FOLDERS_UPDATE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.folders_update,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userPhone,
|
||||
)
|
||||
case self.opcodes.SESSIONS_INFO:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.sessions_info,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userPhone,
|
||||
hashedToken,
|
||||
)
|
||||
case self.opcodes.CHAT_INFO:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.chat_info,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CHAT_HISTORY:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.chat_history,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_INFO_BY_PHONE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_info_by_phone,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.OK_TOKEN:
|
||||
await self.auth_required(
|
||||
userPhone, self.processors.ok_token, payload, seq, writer
|
||||
)
|
||||
case self.opcodes.MSG_TYPING:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.msg_typing,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_INFO:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_info,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_LIST:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_list,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.COMPLAIN_REASONS_GET:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.complain_reasons_get,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.PROFILE:
|
||||
await self.processors.profile(
|
||||
payload, seq, writer, userId=userId
|
||||
)
|
||||
case self.opcodes.CHAT_SUBSCRIBE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.chat_subscribe,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
)
|
||||
case self.opcodes.CONFIG:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.update_config,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userPhone,
|
||||
hashedToken,
|
||||
)
|
||||
case self.opcodes.CONTACT_UPDATE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_update,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_ADD_BY_PHONE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_add_by_phone,
|
||||
payload,
|
||||
seq,
|
||||
writer,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_PRESENCE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_presence,
|
||||
payload,
|
||||
seq,
|
||||
writer
|
||||
)
|
||||
case _:
|
||||
self.logger.warning(f"Неизвестный опкод {opcode}")
|
||||
except Exception as e:
|
||||
self.logger.error(
|
||||
f"Произошла ошибка при работе с клиентом {address[0]}:{address[1]}: {e}"
|
||||
)
|
||||
traceback.print_exc()
|
||||
|
||||
# Удаляем клиента из словаря
|
||||
if userPhone:
|
||||
await self._end_session(userId, address[0], address[1])
|
||||
|
||||
writer.close()
|
||||
self.logger.info(
|
||||
f"Прекратил работать работать с клиентом {address[0]}:{address[1]}"
|
||||
)
|
||||
|
||||
async def _finish_auth(self, writer, addr, phone, id):
|
||||
"""Завершение открытия сессии"""
|
||||
# Ищем пользователя в словаре
|
||||
user = self.clients.get(id)
|
||||
|
||||
# Добавляем новое подключение в словарь
|
||||
if user:
|
||||
user["clients"].append(
|
||||
{"writer": writer, "ip": addr[0], "port": addr[1], "protocol": "oneme"}
|
||||
)
|
||||
else:
|
||||
self.clients[id] = {
|
||||
"phone": phone,
|
||||
"id": id,
|
||||
"status": 2,
|
||||
"last_seen": 0,
|
||||
"clients": [
|
||||
{
|
||||
"writer": writer,
|
||||
"ip": addr[0],
|
||||
"port": addr[1],
|
||||
"protocol": "oneme",
|
||||
}
|
||||
],
|
||||
}
|
||||
|
||||
await self._broadcast_presence(id, True)
|
||||
|
||||
async def _broadcast_presence(self, userId, online):
|
||||
now = int(time.time())
|
||||
now_ms = int(time.time() * 1000)
|
||||
|
||||
if online:
|
||||
presence_data = {"on": "ON", "seen": now, "status": 1}
|
||||
else:
|
||||
presence_data = {"seen": now}
|
||||
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT owner_id FROM contacts WHERE contact_id = %s",
|
||||
(userId,)
|
||||
)
|
||||
contact_owners = await cursor.fetchall()
|
||||
|
||||
for row in contact_owners:
|
||||
owner_id = int(row.get("owner_id"))
|
||||
if owner_id in self.clients:
|
||||
await self.processors.event(
|
||||
owner_id,
|
||||
{
|
||||
"eventType": "presence",
|
||||
"userId": userId,
|
||||
"presence": presence_data,
|
||||
"time": now_ms,
|
||||
}
|
||||
)
|
||||
|
||||
async def _end_session(self, id, ip, port):
|
||||
"""Завершение сессии"""
|
||||
# Получаем пользователя в списке
|
||||
user = self.clients.get(id)
|
||||
if not user:
|
||||
return
|
||||
|
||||
# Получаем подключения пользователя
|
||||
clients = user.get("clients", [])
|
||||
|
||||
# Удаляем нужное подключение из словаря
|
||||
for i, client in enumerate(clients):
|
||||
if (client.get("ip"), client.get("port")) == (ip, port):
|
||||
clients.pop(i)
|
||||
|
||||
if not clients:
|
||||
now = int(time.time())
|
||||
user["status"] = 0
|
||||
user["last_seen"] = now
|
||||
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"UPDATE users SET lastseen = %s WHERE id = %s",
|
||||
(str(now), id)
|
||||
)
|
||||
|
||||
await self._broadcast_presence(id, False)
|
||||
|
||||
async def start(self):
|
||||
"""Функция для запуска сервера"""
|
||||
self.server = await asyncio.start_server(
|
||||
self.handle_client, self.host, self.port, ssl=self.ssl_context
|
||||
)
|
||||
|
||||
self.logger.info(f"Сокет запущен на порту {self.port}")
|
||||
|
||||
try:
|
||||
async with self.server:
|
||||
await self.server.serve_forever()
|
||||
except asyncio.CancelledError:
|
||||
self.server.close()
|
||||
await self.server.wait_closed()
|
||||
@@ -0,0 +1,486 @@
|
||||
import logging
|
||||
import time
|
||||
import traceback
|
||||
import websockets
|
||||
import asyncio
|
||||
from common.proto_web import WebProto
|
||||
from oneme.processors import Processors
|
||||
from common.rate_limiter import RateLimiter
|
||||
from common.opcodes import Opcodes
|
||||
from common.tools import Tools
|
||||
|
||||
class OnemeWS:
|
||||
def __init__(
|
||||
self, host, port, ssl_context, db_pool, clients, send_event, telegram_bot
|
||||
):
|
||||
self.host = host
|
||||
self.port = port
|
||||
self.ssl_context = ssl_context
|
||||
self.server = None
|
||||
self.logger = logging.getLogger(__name__)
|
||||
self.db_pool = db_pool
|
||||
self.clients = clients
|
||||
|
||||
self.opcodes = Opcodes()
|
||||
|
||||
self.proto = WebProto()
|
||||
self.processors = Processors(
|
||||
db_pool=db_pool,
|
||||
clients=clients,
|
||||
send_event=send_event,
|
||||
telegram_bot=telegram_bot,
|
||||
type="web"
|
||||
)
|
||||
self.auth_required = Tools().auth_required
|
||||
|
||||
# rate limiter
|
||||
self.auth_rate_limiter = RateLimiter(max_attempts=5, window_seconds=60)
|
||||
|
||||
self.read_timeout = 300 # Таймаут чтения из websocket (секунды)
|
||||
self.max_read_size = 65536 # Максимальный размер данных
|
||||
|
||||
async def handle_client(self, websocket):
|
||||
"""Функция для обработки WebSocket подключений"""
|
||||
# IP-адрес клиента
|
||||
address = websocket.remote_address
|
||||
self.logger.info(f"Работаю с клиентом {address[0]}:{address[1]}")
|
||||
|
||||
deviceType = None
|
||||
deviceName = None
|
||||
appVersion = None
|
||||
|
||||
userPhone = None
|
||||
userId = None
|
||||
hashedToken = None
|
||||
|
||||
try:
|
||||
async for message in websocket:
|
||||
# Проверяем размер данных
|
||||
if len(message) > self.max_read_size:
|
||||
self.logger.warning(f"Пакет от {address[0]}:{address[1]} превышает лимит ({len(message)} байт)")
|
||||
break
|
||||
|
||||
# Распаковываем данные
|
||||
packet = self.proto.unpack_packet(message)
|
||||
|
||||
# Если пакет невалидный — пропускаем
|
||||
if not packet:
|
||||
self.logger.warning(f"Невалидный пакет от {address[0]}:{address[1]}")
|
||||
continue
|
||||
|
||||
opcode = packet.get("opcode")
|
||||
seq = packet.get("seq")
|
||||
payload = packet.get("payload")
|
||||
|
||||
match opcode:
|
||||
case self.opcodes.SESSION_INIT:
|
||||
deviceType, deviceName, appVersion = await self.processors.session_init(
|
||||
payload, seq, websocket
|
||||
)
|
||||
case self.opcodes.AUTH_REQUEST:
|
||||
if not self.auth_rate_limiter.is_allowed(address[0]):
|
||||
await self.processors._send_error(
|
||||
seq,
|
||||
self.opcodes.AUTH_REQUEST,
|
||||
self.processors.error_types.RATE_LIMITED,
|
||||
websocket,
|
||||
)
|
||||
else:
|
||||
await self.processors.auth_request(payload, seq, websocket)
|
||||
case self.opcodes.AUTH:
|
||||
if not self.auth_rate_limiter.is_allowed(address[0]):
|
||||
await self.processors._send_error(
|
||||
seq,
|
||||
self.opcodes.AUTH,
|
||||
self.processors.error_types.RATE_LIMITED,
|
||||
websocket,
|
||||
)
|
||||
else:
|
||||
await self.processors.auth(
|
||||
payload, seq, websocket, deviceType, deviceName, appVersion, address[0]
|
||||
)
|
||||
case self.opcodes.AUTH_CONFIRM:
|
||||
if not self.auth_rate_limiter.is_allowed(address[0]):
|
||||
await self.processors._send_error(
|
||||
seq,
|
||||
self.opcodes.AUTH_CONFIRM,
|
||||
self.processors.error_types.RATE_LIMITED,
|
||||
websocket,
|
||||
)
|
||||
elif payload and payload.get("tokenType") == "REGISTER":
|
||||
await self.processors.auth_confirm(
|
||||
payload, seq, websocket, deviceType, deviceName, appVersion, address[0]
|
||||
)
|
||||
else:
|
||||
self.logger.warning(
|
||||
f"AUTH_CONFIRM с неизвестным tokenType: {payload}"
|
||||
)
|
||||
case self.opcodes.LOGIN:
|
||||
if not self.auth_rate_limiter.is_allowed(address[0]):
|
||||
await self.processors._send_error(
|
||||
seq,
|
||||
self.opcodes.LOGIN,
|
||||
self.processors.error_types.RATE_LIMITED,
|
||||
websocket,
|
||||
)
|
||||
else:
|
||||
(
|
||||
userPhone,
|
||||
userId,
|
||||
hashedToken,
|
||||
) = await self.processors.login(payload, seq, websocket, appVersion)
|
||||
|
||||
if userPhone:
|
||||
await self._finish_auth(
|
||||
websocket, address, userPhone, userId
|
||||
)
|
||||
case self.opcodes.LOGOUT:
|
||||
await self.processors.logout(
|
||||
seq, websocket, hashedToken=hashedToken
|
||||
)
|
||||
break
|
||||
case self.opcodes.PING:
|
||||
await self.processors.ping(payload, seq, websocket, userId)
|
||||
case self.opcodes.LOG:
|
||||
await self.processors.log(payload, seq, websocket)
|
||||
case self.opcodes.ASSETS_UPDATE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_update,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.ASSETS_GET:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_get,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.ASSETS_GET_BY_IDS:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_get_by_ids,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.ASSETS_ADD:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_add,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.ASSETS_REMOVE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_remove,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.ASSETS_MOVE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_move,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.ASSETS_LIST_MODIFY:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.assets_list_modify,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.VIDEO_CHAT_HISTORY:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.video_chat_history,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.MSG_SEND:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.msg_send,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userId,
|
||||
self.db_pool,
|
||||
)
|
||||
case self.opcodes.FOLDERS_GET:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.folders_get,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userPhone,
|
||||
)
|
||||
case self.opcodes.FOLDERS_UPDATE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.folders_update,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userPhone,
|
||||
)
|
||||
case self.opcodes.SESSIONS_INFO:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.sessions_info,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userPhone,
|
||||
hashedToken,
|
||||
)
|
||||
case self.opcodes.CHAT_INFO:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.chat_info,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CHAT_HISTORY:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.chat_history,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_INFO_BY_PHONE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_info_by_phone,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.OK_TOKEN:
|
||||
await self.auth_required(
|
||||
userPhone, self.processors.ok_token, payload, seq, websocket
|
||||
)
|
||||
case self.opcodes.MSG_TYPING:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.msg_typing,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_INFO:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_info,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_LIST:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_list,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.COMPLAIN_REASONS_GET:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.complain_reasons_get,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.PROFILE:
|
||||
await self.processors.profile(
|
||||
payload, seq, websocket, userId=userId
|
||||
)
|
||||
case self.opcodes.CHAT_SUBSCRIBE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.chat_subscribe,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
)
|
||||
case self.opcodes.CONFIG:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.update_config,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userPhone,
|
||||
hashedToken,
|
||||
)
|
||||
case self.opcodes.CONTACT_UPDATE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_update,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_ADD_BY_PHONE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_add_by_phone,
|
||||
payload,
|
||||
seq,
|
||||
websocket,
|
||||
userId,
|
||||
)
|
||||
case self.opcodes.CONTACT_PRESENCE:
|
||||
await self.auth_required(
|
||||
userPhone,
|
||||
self.processors.contact_presence,
|
||||
payload,
|
||||
seq,
|
||||
websocket
|
||||
)
|
||||
case _:
|
||||
self.logger.warning(f"Неизвестный опкод {opcode}")
|
||||
except websockets.exceptions.ConnectionClosed:
|
||||
self.logger.info(f"Прекратил работать с клиентом {address[0]}:{address[1]}")
|
||||
except Exception as e:
|
||||
self.logger.error(f" Произошла ошибка при работе с клиентом {address[0]}:{address[1]}: {e}")
|
||||
traceback.print_exc()
|
||||
|
||||
# Удаляем клиента из словаря при отключении
|
||||
if userId:
|
||||
await self._end_session(userId, address[0], address[1])
|
||||
|
||||
self.logger.info(f"Прекратил работать с клиентом {address[0]}:{address[1]}")
|
||||
|
||||
async def _finish_auth(self, websocket, addr, phone, id):
|
||||
"""Завершение открытия сессии"""
|
||||
# Ищем пользователя в словаре
|
||||
user = self.clients.get(id)
|
||||
|
||||
# Добавляем новое подключение в словарь
|
||||
if user:
|
||||
user["clients"].append(
|
||||
{
|
||||
"writer": websocket,
|
||||
"ip": addr[0],
|
||||
"port": addr[1],
|
||||
"protocol": "oneme",
|
||||
"type": "web"
|
||||
}
|
||||
)
|
||||
else:
|
||||
self.clients[id] = {
|
||||
"phone": phone,
|
||||
"id": id,
|
||||
"status": 2,
|
||||
"last_seen": 0,
|
||||
"clients": [
|
||||
{
|
||||
"writer": websocket,
|
||||
"ip": addr[0],
|
||||
"port": addr[1],
|
||||
"protocol": "oneme",
|
||||
"type": "web"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
await self._broadcast_presence(id, True)
|
||||
|
||||
async def _broadcast_presence(self, userId, online):
|
||||
now = int(time.time())
|
||||
now_ms = int(time.time() * 1000)
|
||||
|
||||
if online:
|
||||
presence_data = {"on": "ON", "seen": now, "status": 1}
|
||||
else:
|
||||
presence_data = {"seen": now}
|
||||
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT owner_id FROM contacts WHERE contact_id = %s",
|
||||
(userId,)
|
||||
)
|
||||
contact_owners = await cursor.fetchall()
|
||||
|
||||
for row in contact_owners:
|
||||
owner_id = int(row.get("owner_id"))
|
||||
if owner_id in self.clients:
|
||||
await self.processors.event(
|
||||
owner_id,
|
||||
{
|
||||
"eventType": "presence",
|
||||
"userId": userId,
|
||||
"presence": presence_data,
|
||||
"time": now_ms,
|
||||
}
|
||||
)
|
||||
|
||||
async def _end_session(self, id, ip, port):
|
||||
"""Завершение сессии"""
|
||||
# Получаем пользователя в списке
|
||||
user = self.clients.get(id)
|
||||
if not user:
|
||||
return
|
||||
|
||||
# Получаем подключения пользователя
|
||||
clients = user.get("clients", [])
|
||||
|
||||
# Удаляем нужное подключение из словаря
|
||||
for i, client in enumerate(clients):
|
||||
if (client.get("ip"), client.get("port")) == (ip, port):
|
||||
clients.pop(i)
|
||||
|
||||
if not clients:
|
||||
now = int(time.time())
|
||||
user["status"] = 0
|
||||
user["last_seen"] = now
|
||||
|
||||
async with self.db_pool.acquire() as conn:
|
||||
async with conn.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"UPDATE users SET lastseen = %s WHERE id = %s",
|
||||
(str(now), id)
|
||||
)
|
||||
|
||||
await self._broadcast_presence(id, False)
|
||||
|
||||
async def start(self):
|
||||
"""Функция для запуска WebSocket сервера"""
|
||||
self.server = await websockets.serve(
|
||||
self.handle_client,
|
||||
self.host,
|
||||
self.port,
|
||||
ssl=self.ssl_context
|
||||
)
|
||||
|
||||
self.logger.info(f"WebSocket запущен на порту {self.port}")
|
||||
|
||||
try:
|
||||
await self.server.wait_closed()
|
||||
except asyncio.CancelledError:
|
||||
self.server.close()
|
||||
await self.server.wait_closed()
|
||||
raise
|
||||
Reference in New Issue
Block a user