async def handler(self, event: events.ChatAction,
request_context: RequestContext):
session_id = self.generate_session_id()
request_context.add_default_fields(session_id=session_id)
request_context.statbox(action='show', mode='submit')
if event.document.mime_type != 'application/pdf':
request_context.statbox(action='unknown_file_format')
request_context.error_log(
UnknownFileFormatError(format=event.document.mime_type))
return await asyncio.gather(
event.reply(
t('UNKNOWN_FILE_FORMAT_ERROR',
language=request_context.chat.language),
buttons=[close_button()],
),
event.delete(),
)
return await asyncio.gather(
self.application.hub_client.submit(
telegram_document=bytes(event.document),
telegram_file_id=event.file.id,
chat=request_context.chat,
request_id=request_context.request_id,
session_id=session_id,
),
event.delete(),
)
async def handler(self, event: events.ChatAction, request_context: RequestContext):
raw_query = event.pattern_match.group(1)
query = None
request_context.statbox(action='start', mode='start')
try:
query = decode_deep_query(raw_query)
except DecodeDeepQueryError as e:
request_context.error_log(e, mode='start', raw_query=raw_query)
if query:
request_context.statbox(action='query', mode='start', query=query)
request_message = await self.application.telegram_client.send_message(event.chat, query)
prefetch_message = await request_message.reply(
t("SEARCHING", language=request_context.chat.language),
)
self.application.user_manager.last_widget[request_context.chat.chat_id] = prefetch_message.id
await asyncio.gather(
event.delete(),
self.do_search(event, request_context, prefetch_message, query=query,
is_shortpath_enabled=True),
)
else:
request_context.statbox(action='show', mode='start')
await event.reply(t('HELP', language=request_context.chat.language))
async def handler(self, event: events.ChatAction,
request_context: RequestContext):
schema, session_id, document_id, vote, vote_value = self.parse_pattern(
event)
request_context.add_default_fields(mode='vote', session_id=session_id)
request_context.statbox(
action='vote',
document_id=document_id,
query=vote,
schema=schema,
)
document_operation_pb = DocumentOperationPb(vote=VotePb(
document_id=document_id,
value=vote_value,
voter_id=request_context.chat.chat_id,
), )
logging.getLogger('operation').info(
msg=MessageToDict(document_operation_pb), )
message = await event.get_message()
# ToDo: Generalize nexus.views.telegram.common.remove_button and use it here
return await asyncio.gather(
self.application.telegram_client.edit_message(
request_context.chat.chat_id,
message.id,
message.text,
buttons=None,
),
event.answer(t('TANKS_BRUH')),
)
async def handler(self, event: events.ChatAction,
request_context: RequestContext):
session_id = self.generate_session_id()
request_context.add_default_fields(mode='roll', session_id=session_id)
request_context.statbox(action='show')
roll_response_pb = await self.application.meta_api_client.roll(
language=request_context.chat.language,
session_id=session_id,
request_id=request_context.request_id,
user_id=str(request_context.chat.chat_id),
)
scitech_view = await self.resolve_scitech(
document_id=roll_response_pb.document_id,
position=0,
request_context=request_context,
session_id=session_id,
)
view, buttons = scitech_view.get_view(
language=request_context.chat.language,
session_id=session_id,
bot_external_name=self.application.config['telegram']
['bot_external_name'],
)
actions = [
self.application.telegram_client.send_message(
request_context.chat.chat_id,
view,
buttons=buttons,
),
event.delete(),
]
return await asyncio.gather(*actions)
async def handler(self, event: events.ChatAction, request_context: RequestContext):
schema, session_id, old_message_id, document_id, position, page = self.parse_pattern(event)
request_context.add_default_fields(mode='view', session_id=session_id)
request_context.statbox(action='view', document_id=document_id, position=position, schema=schema)
has_found_old_widget = old_message_id == self.application.user_manager.last_widget.get(request_context.chat.chat_id)
try:
message_id, link_preview = await self.process_widgeting(
has_found_old_widget=has_found_old_widget,
old_message_id=old_message_id,
request_context=request_context
)
document_view = await self.resolve_document(
schema,
document_id,
position,
session_id,
request_context,
)
try:
back_command = await self.compose_back_command(
session_id=session_id,
message_id=message_id,
page=page,
)
except MessageHasBeenDeletedError:
return await event.respond(
t('REPLY_MESSAGE_HAS_BEEN_DELETED', language=request_context.chat.language),
)
view, buttons = document_view.get_view(
language=request_context.chat.language,
session_id=session_id,
bot_external_name=self.application.config['telegram']['bot_external_name'],
position=position,
back_command=back_command,
)
actions = [
self.application.telegram_client.edit_message(
request_context.chat.chat_id,
message_id,
view,
buttons=buttons,
link_preview=link_preview,
),
event.delete(),
]
if not has_found_old_widget:
actions.append(
self.application.telegram_client.delete_messages(
request_context.chat.chat_id,
[old_message_id],
)
)
return await asyncio.gather(*actions)
except MessageIdInvalidError:
await event.reply(t("VIEWS_CANNOT_BE_SHARED", language=request_context.chat.language))
async def __init(self, configuration, loop):
await self.__client.get_dialogs()
# await self.__client.get_entity(89616296) # свея
self.__client.on(
ChatAction(configuration.group_id,
func=lambda __event: __event.user_joined or __event.
user_added))(self.__on_new_user_in_group, )
print("User bot configured")
def decorator(function):
async def func_callback(event):
try:
await function(event)
except Exception as e:
self.log.error(
f"Function '{function.__name__}' stopped due to an unhandled exception",
exc_info=True if self.traceback else False)
tgclient.add_event_handler(func_callback, ChatAction(**args))
return func_callback
async def handler(self, event: events.ChatAction,
request_context: RequestContext):
session_id, message_id, page = self.parse_pattern(event)
request_context.add_default_fields(mode='search_paging',
session_id=session_id)
start_time = time.time()
message = await event.get_message()
if not message:
return await event.answer()
reply_message = await message.get_reply_message()
try:
if not reply_message:
raise MessageHasBeenDeletedError()
query = self.preprocess_query(reply_message.raw_text)
search_widget = await SearchWidget.create(
application=self.application,
chat=request_context.chat,
session_id=session_id,
message_id=message_id,
request_id=request_context.request_id,
query=query,
page=page,
)
except MessageHasBeenDeletedError:
return await event.respond(
t('REPLY_MESSAGE_HAS_BEEN_DELETED',
language=request_context.chat.language), )
except AioRpcError as e:
if e.code() == StatusCode.INVALID_ARGUMENT or e.code(
) == StatusCode.CANCELLED:
request_context.error_log(e)
return await event.answer(
t('MAINTENANCE_WO_PIC',
language=request_context.chat.language), )
raise e
action = 'documents_found'
if len(search_widget.scored_documents) == 0:
action = 'documents_not_found'
request_context.statbox(
action=action,
duration=time.time() - start_time,
query=f'page:{page} query:{query}',
)
serp, buttons = await search_widget.render()
return await asyncio.gather(
event.answer(),
message.edit(serp, buttons=buttons, link_preview=False))
def decorator(function):
async def func_callback(event):
try:
await function(event)
except Exception as e:
self.log.error(
f"Function '{function.__name__}' stopped due to an unhandled exception",
exc_info=True if self.traceback else False)
try:
tgclient.add_event_handler(func_callback,
ChatAction(*args, **kwargs))
except Exception as e:
self.log.error(f"Failed to add a chat action feature to client "\
f"(in function '{function.__name__}')",
exc_info=True if self.traceback else False)
return None
return func_callback
async def handler(self, event: events.ChatAction,
request_context: RequestContext):
try:
self.check_search_ban_timeout(
user_id=str(request_context.chat.chat_id))
except BannedUserError as e:
request_context.error_log(e)
return await event.reply(
t('BANNED_FOR_SECONDS',
language=request_context.chat.language).format(
seconds=e.ban_timeout,
reason=t('BAN_MESSAGE_TOO_MANY_REQUESTS',
language=request_context.chat.language),
))
search_prefix, query, is_group_mode = self.parse_pattern(event)
if is_group_mode and not search_prefix:
return
if not is_group_mode and search_prefix:
query = event.raw_text
prefetch_message = await event.reply(
t("SEARCHING", language=request_context.chat.language), )
self.application.user_manager.last_widget[
request_context.chat.chat_id] = prefetch_message.id
try:
await self.do_search(
event=event,
request_context=request_context,
prefetch_message=prefetch_message,
query=query,
is_group_mode=is_group_mode,
is_shortpath_enabled=True,
)
except (AioRpcError, asyncio.CancelledError) as e:
await asyncio.gather(
event.delete(),
prefetch_message.delete(),
)
raise e
def decorator(function):
caller_name = basename(
getouterframes(currentframe(), 2)[1].filename)[:-3]
async def func_callback(event):
try:
await function(event)
except Exception:
self.log.error(
f"Function '{function.__name__}' stopped "
"due to an unhandled exception",
exc_info=True if self.traceback else False)
try:
_tgclient.add_event_handler(func_callback,
ChatAction(*args, **kwargs))
update_handlers(caller_name, func_callback)
except Exception:
self.log.error(
f"Failed to add a chat action feature to "
f"client (in function '{function.__name__}')",
exc_info=True if self.traceback else False)
return None
return func_callback
from requests import get
from telethon.errors import ChatAdminRequiredError
from telethon.events import ChatAction
from telethon.tl.types import ChannelParticipantsAdmins
from telethon.utils import get_display_name
from ..Config import Config
from ..sql_helper.gban_sql_helper import get_gbanuser, is_gbanned
from ..utils import is_admin
from . import BOTLOG, BOTLOG_CHATID, catub, edit_or_reply, logging, spamwatch
LOGS = logging.getLogger(__name__)
plugin_category = "admin"
if Config.ANTISPAMBOT_BAN:
@catub.on(ChatAction())
async def anti_spambot(event): # sourcery no-metrics
if not event.user_joined and not event.user_added:
return
user = await event.get_user()
catadmin = await is_admin(event.client, event.chat_id,
event.client.uid)
if not catadmin:
return
catbanned = None
adder = None
ignore = None
if event.user_added:
try:
adder = event.action_message.sender_id
except AttributeError:
def __init__(self,
session: str,
api_id: int,
api_hash: str,
loop: asyncio.AbstractEventLoop,
bot_id: int,
chats: Iterable[int] = tuple()):
"""
Need to create a client with API key, hash, and a session file
Need a list of whitelisted chat IDs
Create a queue for incoming messages.
Args:
session: Session authorization string
api_id: API ID of Telegram client
api_hash: API Hash of Telegram client
loop: Event loop to run the client on, (can be provided by ``pytest-asyncio``)
"""
# Build proxy parameters
# Currently only support SOCKS5 proxy in ALL_PROXY environment variable
proxy_env = os.environ.get('all_proxy') or os.environ.get('ALL_PROXY')
if proxy_env and proxy_env.startswith('socks5://'):
from socks import SOCKS5
hostname, port, username, password = parse_socks5_link(proxy_env)
proxy: Optional[Tuple] = (SOCKS5, hostname, port, True, username,
password)
else:
proxy = None
# Telethon client to use
self.client: TelegramClient = TelegramClient(StringSession(session),
api_id,
api_hash,
proxy=proxy,
loop=loop,
sequential_updates=True)
# Queue for incoming messages
self.queue: "asyncio.queues.Queue[EventCommon]" = asyncio.queues.Queue(
)
# Collect mappings from message ID to its chat (as Telegram API is not sending them)
self.message_chat_map: Dict[int, TypeInputPeer] = dict()
self.chats = list(map(abs, chats))
self.client.parse_mode = "html"
self.client.add_event_handler(
self.new_message_handler,
NewMessage(chats=self.chats, incoming=True, from_users=[bot_id]))
# self.client.add_event_handler(self.new_message_handler,
# NewMessage(incoming=True))
self.client.add_event_handler(self.deleted_message_handler,
MessageDeleted())
self.client.add_event_handler(self.update_handler,
UserUpdate(chats=self.chats))
self.client.add_event_handler(self.update_handler,
MessageEdited(chats=self.chats))
self.client.add_event_handler(self.update_handler,
ChatAction(chats=self.chats))
self.logger = logging.getLogger(__name__)
async def do_search(
self,
event: events.ChatAction,
request_context: RequestContext,
prefetch_message,
query: str,
is_group_mode: bool = False,
is_shortpath_enabled: bool = False,
):
session_id = self.generate_session_id()
message_id = prefetch_message.id
request_context.add_default_fields(is_group_mode=is_group_mode,
mode='search',
session_id=session_id)
start_time = time.time()
try:
search_widget = await SearchWidget.create(
application=self.application,
chat=request_context.chat,
session_id=session_id,
message_id=message_id,
request_id=request_context.request_id,
query=query,
is_group_mode=is_group_mode,
)
except AioRpcError as e:
actions = [
self.application.telegram_client.delete_messages(
request_context.chat.chat_id,
[message_id],
)
]
if e.code() == StatusCode.INVALID_ARGUMENT:
too_difficult_picture_url = self.application.config[
'application'].get('too_difficult_picture_url', '')
if e.details() == 'url_query_error':
actions.append(
event.reply(
t('INVALID_QUERY_ERROR',
language=request_context.chat.language).format(
too_difficult_picture_url=
too_difficult_picture_url, ),
buttons=[close_button()],
))
elif e.details() == 'invalid_query_error':
actions.append(
event.reply(
t('INVALID_SYNTAX_ERROR',
language=request_context.chat.language).format(
too_difficult_picture_url=
too_difficult_picture_url, ),
buttons=[close_button()],
))
return await asyncio.gather(*actions)
elif e.code() == StatusCode.CANCELLED:
maintenance_picture_url = self.application.config[
'application'].get('maintenance_picture_url', '')
request_context.error_log(e)
actions.append(
event.reply(
t('MAINTENANCE',
language=request_context.chat.language).format(
maintenance_picture_url=maintenance_picture_url,
),
buttons=[close_button()],
))
return await asyncio.gather(*actions)
await asyncio.gather(*actions)
raise e
action = 'documents_found'
if len(search_widget.scored_documents) == 0:
action = 'documents_not_found'
request_context.statbox(
action=action,
duration=time.time() - start_time,
query=f'page:0 query:{query}',
)
if len(search_widget.scored_documents) == 1 and is_shortpath_enabled:
scored_document = search_widget.scored_documents[0]
document_view = parse_typed_document_to_view(
scored_document.typed_document)
# Second (re-)fetching is required to retrieve duplicates
document_view = await self.resolve_document(
schema=scored_document.typed_document.WhichOneof('document'),
document_id=document_view.id,
position=0,
session_id=session_id,
request_context=request_context,
)
view, buttons = document_view.get_view(
language=request_context.chat.language,
session_id=session_id,
bot_external_name=self.application.config['telegram']
['bot_external_name'],
with_buttons=not is_group_mode,
)
return await asyncio.gather(
self.application.telegram_client.edit_message(
request_context.chat.chat_id,
message_id,
view,
buttons=buttons,
), )
serp, buttons = await search_widget.render()
return await self.application.telegram_client.edit_message(
request_context.chat.chat_id,
message_id,
serp,
buttons=buttons,
link_preview=False,
)