async def get_chatinfo(event): chat = event.pattern_match.group(1) chat_info = None if chat: try: chat = int(chat) except ValueError: pass if not chat: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id is not None: chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await event.client(GetFullChatRequest(chat)) except: try: chat_info = await event.client(GetFullChannelRequest(chat)) except ChannelInvalidError: await event.edit("`Invalid channel/group`") return None except ChannelPrivateError: await event.edit( "`This is a private channel/group or I am banned from there`") return None except ChannelPublicGroupNaError: await event.edit("`Channel or supergroup doesn't exist`") return None except (TypeError, ValueError) as err: await event.edit(str(err)) return None return chat_info
async def get_chatinfo(event): chat = event.pattern_match.group(1) chat_info = None if chat: try: chat = int(chat) except ValueError: pass if not chat: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id is not None: chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await event.client(GetFullChatRequest(chat)) except BaseException: try: chat_info = await event.client(GetFullChannelRequest(chat)) except ChannelInvalidError: await event.reply("`channel/group tidak valid`") return None except ChannelPrivateError: await event.reply( "`Ini adalah channel/group pribadi atau saya dibanned dari sana`" ) return None except ChannelPublicGroupNaError: await event.reply("`Channel atau supergroup tidak ada`") return None except (TypeError, ValueError): await event.reply("`channel/group tidak valid`") return None return chat_info
async def get_chatinfo(event): chat = event.pattern_match.group(1) chat_info = None if chat: try: chat = int(chat) except ValueError: pass if not chat: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id is not None: chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await event.client(GetFullChatRequest(chat)) except: try: chat_info = await event.client(GetFullChannelRequest(chat)) except ChannelInvalidError: await event.reply("`Geçersiz kanal/grup`") return None except ChannelPrivateError: await event.reply("`Burası gizli grup veya Ben burdan ban yedim.`") return None except ChannelPublicGroupNaError: await event.reply("`Böyle bir supergrup veya kanal yok`") return None except (TypeError, ValueError) as err: await event.reply(str(err)) return None return chat_info
async def _get_users( self, user: '******', entity: Union[TypeInputPeer, InputUser, TypeChat, TypeUser, InputChannel] ) -> List[TypeUser]: if self.peer_type == "chat": chat = await user.client(GetFullChatRequest(chat_id=self.tgid)) return list( self._filter_participants( chat.users, chat.full_chat.participants.participants)) elif self.peer_type == "channel": if not self.megagroup and not self.sync_channel_members: return [] limit = self.max_initial_member_sync if limit == 0: return [] try: return await self._get_channel_users(user, entity, limit) except ChatAdminRequiredError: return [] elif self.peer_type == "user": return [entity] else: raise RuntimeError(f"Unexpected peer type {self.peer_type}")
async def get_chatinfo(event): chat = event.pattern_match.group(1) chat_info = None if chat: try: chat = int(chat) except ValueError: pass if not chat: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id is not None: chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await event.client(GetFullChatRequest(chat)) except BaseException: try: chat_info = await event.client(GetFullChannelRequest(chat)) except ChannelInvalidError: await event.edit("`Grup/Channel Tidak Valid`") return None except ChannelPrivateError: await event.edit( "`Ini Adalah Grup/Channel Privasi Atau Lord Dibanned Dari Sana`" ) return None except ChannelPublicGroupNaError: await event.edit("`Channel Atau Supergrup Tidak Ditemukan`") return None except (TypeError, ValueError) as err: await event.edit(str(err)) return None return chat_info
async def get_chatinfo(event): chat = event.pattern_match.group(1) chat_info = None if chat: try: chat = int(chat) except ValueError: pass if not chat: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id is not None: chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await event.client(GetFullChatRequest(chat)) except: try: chat_info = await event.client(GetFullChannelRequest(chat)) except ChannelInvalidError: await event.reply("`Səhv kanal/qrup`") return None except ChannelPrivateError: await event.reply("`Bura gizli qrup və ya Mən buradan ban aldım.`") return None except ChannelPublicGroupNaError: await event.reply("`Belə bir süper qrup və ya kanal yoxdur`") return None except (TypeError, ValueError) as err: await event.reply(str(err)) return None return chat_info
async def get_call( self, chat_id: int, ) -> Optional[InputGroupCall]: chat = await self._app.get_input_entity(chat_id) if isinstance(chat, InputPeerChannel): input_call = (await self._app( GetFullChannelRequest( InputChannel( chat.channel_id, chat.access_hash, ), ), )).full_chat.call else: input_call = (await self._app( GetFullChatRequest(chat_id), )).full_chat.call if input_call is not None: try: call: GroupCall = (await self._app( GetGroupCallRequest( call=input_call, limit=-1, ), )).call if call.schedule_date is not None: return None except Exception as e: print(e) return input_call
async def get_chatinfo(event): chat = extract_args(event) chat_info = None if chat.isdigit(): chat = int(chat) else: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id : chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await event.client(GetFullChatRequest(chat)) except: try: chat_info = await event.client(GetFullChannelRequest(chat)) except ChannelInvalidError: await event.edit("`Geçersiz kanal/grup`") return None except ChannelPrivateError: await event.edit("`Bu özel bir kanal/grup veya oradan yasaklandım`") return None except ChannelPublicGroupNaError: await event.edit("`Kanal veya süpergrup mevcut değil`") return None except (TypeError, ValueError) as err: await event.edit(str(err)) return None return chat_info
async def get_chatinfo(event): chat = event.pattern_match.group(1) chat_info = None if chat: try: chat = int(chat) except ValueError: pass if not chat: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id is not None: chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await event.client(GetFullChatRequest(chat)) except: try: chat_info = await event.client(GetFullChannelRequest(chat)) except ChannelInvalidError: await event.reply("`Saluran / grup tidak valid`") return None except ChannelPrivateError: await event.reply("`Ini adalah grup rahasia atau saya dilarang dari sini.`") return None except ChannelPublicGroupNaError: await event.reply("`Tidak ada supergrup atau saluran seperti itu`") return None except (TypeError, ValueError) as err: await event.reply(str(err)) return None return chat_info
async def get_chatinfo(event): chat = event.pattern_match.group(1) chat_info = None if chat: try: chat = int(chat) except ValueError: pass if not chat: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id is not None: chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await event.client(GetFullChatRequest(chat)) except: try: chat_info = await event.client(GetFullChannelRequest(chat)) except ChannelInvalidError: await event.edit("**❌Errore:** `Gruppo/canale non valido.`") return None except ChannelPrivateError: await event.edit( "**❌Errore:** `In questo in gruppo/canale sono bannato (oppure è privato).`" ) return None except ChannelPublicGroupNaError: await event.edit("**❌Errore:** `Questo gruppo/canale non esiste.`") return None except (TypeError, ValueError) as err: await event.edit(str(err)) return None return chat_info
async def get_chatinfo(event): chat = event.pattern_match.group(1) chat_info = None if chat: try: chat = int(chat) except ValueError: pass if not chat: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id is not None: chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await event.client(GetFullChatRequest(chat)) except BaseException: try: chat_info = await event.client(GetFullChannelRequest(chat)) except ChannelInvalidError: await event.edit("`Canal/grupo inválido`") return None except ChannelPrivateError: await event.edit( "`Este é um canal/grupo privado ou fui banido de lá`") return None except ChannelPublicGroupNaError: await event.edit("`Canal ou supergrupo não existe`") return None except (TypeError, ValueError) as err: await event.edit(str(err)) return None return chat_info
async def _get_users( self, user: '******', entity: Union[TypeInputPeer, InputUser, TypeChat, TypeUser, InputChannel] ) -> Tuple[List[TypeUser], List[TypeParticipant]]: # TODO replace with client.get_participants if self.peer_type == "chat": chat = await user.client(GetFullChatRequest(chat_id=self.tgid)) return chat.users, chat.full_chat.participants.participants elif self.peer_type == "channel": if not self.megagroup and not self.sync_channel_members: return [], [] limit = self.max_initial_member_sync if limit == 0: return [], [] try: if 0 < limit <= 200: response = await user.client( GetParticipantsRequest(entity, ChannelParticipantsRecent(), offset=0, limit=limit, hash=0)) return response.users, response.participants elif limit > 200 or limit == -1: users: List[TypeUser] = [] participants: List[TypeParticipant] = [] offset = 0 remaining_quota = limit if limit > 0 else 1000000 query = (ChannelParticipantsSearch("") if limit == -1 else ChannelParticipantsRecent()) while True: if remaining_quota <= 0: break response = await user.client( GetParticipantsRequest(entity, query, offset=offset, limit=min( remaining_quota, 100), hash=0)) if not response.users: break participants += response.participants users += response.users offset += len(response.participants) remaining_quota -= len(response.participants) return users, participants except ChatAdminRequiredError: return [], [] elif self.peer_type == "user": return [entity], [] return [], []
async def _(e): reply = await e.get_reply_message() match = e.pattern_match.group(1).strip() if reply and not isinstance(reply.sender, User): chat = await reply.get_sender() else: chat = await e.get_chat() if hasattr(chat, "username") and chat.username: return await e.eor(f"Username: @{chat.username}") request, usage, title = None, None, None if match: split = match.split(maxsplit=1) request = bool(split[0] in ["r", "request"]) title = "Created by Ultroid" if len(split) > 1: match = split[1] spli = match.split(maxsplit=1) if spli[0].isdigit(): usage = int(spli[0]) if len(spli) > 1: title = spli[1] elif not request: if match.isdigit(): usage = int(match) else: title = match if request and usage: usage = 0 if request or title: try: r = await e.client( ExportChatInviteRequest( e.chat_id, request_needed=request, usage_limit=usage, title=title, ), ) except no_admin: return await e.eor(get_string("chats_2"), time=10) link = r.link else: if isinstance(chat, types.Chat): FC = await e.client(GetFullChatRequest(chat.id)) elif isinstance(chat, types.Channel): FC = await e.client(GetFullChannelRequest(chat.id)) else: return Inv = FC.full_chat.exported_invite if Inv and not Inv.revoked: link = Inv.link if link: return await e.eor(f"Link:- {link}") await e.eor( "`Failed to getlink!\nSeems like link is inaccessible to you...`")
async def djshsh(event): chat = await event.get_chat() if isinstance(chat, types.Chat): FChat = await event.client(GetFullChatRequest(chat.id)) elif isinstance(chat, types.Channel): FChat = await event.client(GetFullChannelRequest(chat.id)) else: return msg_id = FChat.full_chat.pinned_msg_id if not msg_id: return await event.eor(get_string("pinned_1")) msg = await event.client.get_messages(chat.id, ids=msg_id) if msg: await event.eor(get_string("pinned_2").format(msg.message_link))
async def get_call( self, chat_id: int, ) -> Optional[InputGroupCall]: chat = await self._app.get_input_entity(chat_id) if isinstance(chat, InputPeerChannel): return (await self._app( GetFullChannelRequest( InputChannel( chat.channel_id, chat.access_hash, ), ), )).full_chat.call else: return (await self._app(GetFullChatRequest(chat_id), )).full_chat.call
async def djshsh(event): chat = await event.get_chat() if isinstance(chat, types.Chat): FChat = await event.client(GetFullChatRequest(chat.id)) elif isinstance(chat, types.Channel): FChat = await event.client(GetFullChannelRequest(chat.id)) else: return msg_id = FChat.full_chat.pinned_msg_id if not msg_id: return await eor(event, "No Pinned Message Found!") msg = await event.client.get_messages(chat.id, ids=msg_id) await eor( event, f"Pinned Message in Current chat is [here]({msg.message_link}).")
async def whois(event): match = event.matches[0].group(1) reply_id = None if event.entities or match: user = await get_user_from_msg(event) if not user: await event.edit("`Couldn't get user/chat from the message.`") return else: user = "******" if event.reply_to_msg_id: reply_id = event.reply_to_msg_id if not match: reply = await event.get_reply_message() if reply.fwd_from: if reply.fwd_from.from_id: user = reply.fwd_from.from_id else: user = reply.sender_id try: input_entity = await client.get_input_entity(user) except Exception as e: await event.reply('`' + type(e).__name__ + ': ' + str(e) + '`') return try: if isinstance(input_entity, InputPeerChat): full_chat = await client(GetFullChatRequest(chat_id=input_entity)) string = await Parser.parse_full_chat(full_chat, event) elif isinstance(input_entity, InputPeerChannel): full_channel = await client( GetFullChannelRequest(channel=input_entity)) string = await Parser.parse_full_chat(full_channel, event) else: full_user = await client(GetFullUserRequest(id=input_entity)) string = await Parser.parse_full_user(full_user, event) except Exception as e: await event.reply('`' + type(e).__name__ + ': ' + str(e) + '`') return if reply_id: await event.delete() await event.respond(string, reply_to=reply_id)
async def get_chat_from_event(event: NewMessage.Event, **kwargs): chat = kwargs.get('chat', None) if chat: try: input_entity = await event.client.get_input_entity(chat) if isinstance(input_entity, InputPeerChannel): return await event.client(GetFullChannelRequest(input_entity.channel_id)) elif isinstance(input_entity, InputPeerChat): return await event.client(GetFullChatRequest(input_entity.chat_id)) else: return None except(TypeError, ValueError): return None else: chat = await event.get_chat() return await event.client(GetFullChannelRequest(chat.id))
async def _(e): chat = await e.get_chat() if chat.username: return await eor(e, f"Username: @{chat.username}") if isinstance(chat, types.Chat): FC = await e.client(GetFullChatRequest(chat.id)) elif isinstance(chat, types.Channel): FC = await e.client(GetFullChannelRequest(chat.id)) Inv = FC.full_chat.exported_invite if Inv and not Inv.revoked: link = Inv.link else: try: r = await e.client(ExportChatInviteRequest(e.chat_id), ) except no_admin: return await eor(e, get_string("chats_2"), time=10) link = r.link await eor(e, f"Link:- {link}")
async def test_update_info_group_user(helper, client, bot_group, channel, slave, bot_id, chat_type, alias, avatar): chat = slave.get_chat_by_criteria(chat_type=chat_type, alias=alias, avatar=avatar) # Set bot as admin if needed if await is_bot_admin(client, bot_id, bot_group): await client.edit_admin(bot_group, bot_id, change_info=True, is_admin=True, delete_messages=False) with link_chats(channel, (chat, ), bot_group): await client.send_message(bot_group, "/update_info") title = (await helper.wait_for_event(in_chats(bot_group) & new_title)).new_title if alias: assert chat.alias in title else: assert chat.name in title if avatar: await helper.wait_for_event(in_chats(bot_group) & new_photo) if chat_type == "GroupChat": # Get group description bot_group_t, peer_type = resolve_id(bot_group) if peer_type == PeerChannel: group: ChatFull = await client( GetFullChannelRequest(bot_group_t)) else: group: ChatFull = await client(GetFullChatRequest(bot_group_t)) desc = group.full_chat.about chats_found = sum( int((i.name in desc) and # Original name is found, and (i.alias is None or i.alias in desc ) # alias is found too if available ) for i in chat.members) assert len(chat.members) >= 5 assert chats_found >= 5, f"At least 5 members shall be found in the description: {desc}"
async def _can_use_commands(self, chat, tgid): if tgid in self.tg_whitelist: return True user = u.User.get_by_tgid(tgid) if user and user.is_admin: self.tg_whitelist.append(user.tgid) return True if self.whitelist_group_admins: if isinstance(chat, PeerChannel): p = await self.client(GetParticipantRequest(chat, tgid)) return isinstance(p, (ChannelParticipantCreator, ChannelParticipantAdmin)) elif isinstance(chat, PeerChat): chat = await self.client(GetFullChatRequest(chat.chat_id)) participants = chat.full_chat.participants.participants for p in participants: if p.user_id == tgid: return isinstance(p, (ChatParticipantCreator, ChatParticipantAdmin))
async def get_chatinfo(event): chat = event.pattern_match.group(1) if event.reply_to_msg_id and not chat: replied_msg = await event.get_reply_message() if replied_msg.from_id and isinstance(replied_msg.from_id, PeerChannel): chat = replied_msg.from_id.channel_id elif (replied_msg.fwd_from and replied_msg.fwd_from.from_id and isinstance(replied_msg.fwd_from.from_id, PeerChannel)): chat = replied_msg.fwd_from.from_id.channel_id else: await event.edit(msgRep.REPLY_NOT_CHANNEL) return None else: try: chat = int(chat) except ValueError: pass if not chat: chat = event.chat_id try: if not isinstance(chat, int): # if input is not an ID, skip GetFullChatRequest as it # accepts only integers raise Exception("'chat' is not an integer") chat_info = await event.client(GetFullChatRequest(chat)) return chat_info except Exception: try: chat_info = await event.client(GetFullChannelRequest(chat)) return chat_info except ChannelInvalidError: await event.edit(msgRep.INVALID_CH_GRP) except ChannelPrivateError: await event.edit(msgRep.PRV_BAN) except ChannelPublicGroupNaError: await event.edit(msgRep.NOT_EXISTS) except Exception as e: log.warning(e) await event.edit(msgRep.CANNOT_GET_CHATINFO.format(chat)) return None
async def on_new_mssg(event): who = event.sender_id # doesn't reply to that user anymore if event.text.startswith("/") or who == OWNER_ID: return if FSUB: MSG = "" BTTS = [] for chat in FSUB: try: await event.client.get_permissions(chat, event.sender_id) except UserNotParticipantError: if not MSG: MSG += get_string("pmbot_1") try: TAHC_ = await event.client.get_entity(chat) if hasattr(TAHC_, "username") and TAHC_.username: uri = "t.me/" + TAHC_.username elif CACHE.get(chat): uri = CACHE[chat] else: if isinstance(TAHC_, Channel): FUGB = await event.client( GetFullChannelRequest(chat)) elif isinstance(TAHC_, Chat): FUGB = await event.client(GetFullChatRequest(chat)) else: return if FUGB.full_chat.exported_invite: CACHE[chat] = FUGB.full_chat.exported_invite.link uri = CACHE[chat] BTTS.append(Button.url(get_display_name(TAHC_), uri)) except Exception as er: LOGS.exception( f"Error On PmBot Force Sub!\n - {chat} \n{er}") if MSG and BTTS: return await event.reply(MSG, buttons=BTTS) xx = await event.forward_to(OWNER_ID) if event.fwd_from: await xx.reply( f"From {inline_mention(event.sender)} [`{event.sender_id}`]") add_stuff(xx.id, who)
async def sync_full(evt: CommandEvent) -> EventID: portal = po.Portal.get_by_mxid(evt.room_id) if not portal: return await evt.reply("This is not a portal room.") if len(evt.args) > 0 and evt.args[0] == "--usebot" and evt.sender.is_admin: src = evt.tgbot else: src = evt.tgbot if await evt.sender.needs_relaybot(portal) else evt.sender try: if portal.peer_type == "channel": res = await src.client(GetFullChannelRequest(portal.peer)) elif portal.peer_type == "chat": res = await src.client(GetFullChatRequest(portal.tgid)) else: return await evt.reply("This is not a channel or chat portal.") except (ValueError, RPCError): return await evt.reply("Failed to get portal info from Telegram.") await portal.update_matrix_room(src, res.full_chat) return await evt.reply("Portal synced successfully.")
async def _(e): reply = await e.get_reply_message() if reply and not isinstance(reply.sender, User): chat = await reply.get_sender() else: chat = await e.get_chat() if hasattr(chat, "username") and chat.username: return await e.eor(f"Username: @{chat.username}") if isinstance(chat, types.Chat): FC = await e.client(GetFullChatRequest(chat.id)) elif isinstance(chat, types.Channel): FC = await e.client(GetFullChannelRequest(chat.id)) Inv = FC.full_chat.exported_invite if Inv and not Inv.revoked: link = Inv.link else: try: r = await e.client(ExportChatInviteRequest(e.chat_id), ) except no_admin: return await e.eor(get_string("chats_2"), time=10) link = r.link await e.eor(f"Link:- {link}")
async def get_users( client: MautrixTelegramClient, tgid: int, entity: TypeInputPeer | InputUser | TypeChat | TypeUser | InputChannel, limit: int, peer_type: str, ) -> list[TypeUser]: if peer_type == "chat": chat = await client(GetFullChatRequest(chat_id=tgid)) users = list( _filter_participants(chat.users, chat.full_chat.participants.participants)) return users[:limit] if limit > 0 else users elif peer_type == "channel": try: return await _get_channel_users(client, entity, limit) except ChatAdminRequiredError: return [] elif peer_type == "user": return [entity] else: raise RuntimeError(f"Unexpected peer type {peer_type}")
async def get_chatinfo(event): chat = event.pattern_match.group(1) chat_info = None if chat: try: chat = int(chat) except ValueError: pass if not chat: if event.reply_to_msg_id: replied_msg = await event.get_reply_message() if replied_msg.fwd_from and replied_msg.fwd_from.channel_id is not None: chat = replied_msg.fwd_from.channel_id else: chat = event.chat_id try: chat_info = await king_bot(GetFullChatRequest(chat)) except BaseException: try: chat_info = await king_bot(GetFullChannelRequest(chat)) except ChannelInvalidError: await eor(event, "`Grup atau channel invalid.`") return None except ChannelPrivateError: await eor( event, "`Ini adalah grup/channel privat atau mungkin saya di ban disana.`" ) return None except ChannelPublicGroupNaError: await eor(event, "`Channel atau supergroup tidak ditemukan.`") return None except (TypeError, ValueError) as err: await eor(event, str(err)) return None return chat_info
def xmpp_update_handler(self, obj): print('new update for ' + self.jid) print(type(obj), obj.__dict__) ''' Боты Сделать запоминание ростера в бд Сделать лучше хендлинг ошибок Доделать все типы информационных сообщений Сделать джойны по линкам в чаты/каналы Сделать поиск и добавление пользователей Сделать листание истории Сделать отправку всех непрочтенных сообщений при входе ''' # Здесь будет очень длинный пиздец ^__^ nl = '\n' if self.user_options['nl_after_info'] else '' try: if type( obj ) is Updates: # Какой-то общий тип обновления (всегда большое со списками) print('Updates') # Делаем разбор пользователей/чатов, которые учавствуют в апдейте updates_users = {usr.id: usr for usr in obj.users} updates_groups = {} updates_channels = {} updates_supergroups = {} updates_type_channels = {} # Супегруппы и каналы вместе for chat in obj.chats: if type(chat) is Chat: # Обычная группа updates_groups[chat.id] = chat elif type(chat) is Channel: if chat.broadcast: # Канал updates_channels[chat.id] = chat else: # Супегруппа updates_supergroups[chat.id] = chat updates_type_channels[chat.id] = chat # ------------------------------------------------------------------------------------------- for update in obj.updates: # Апдейт содержит список с апдейтами # Новое сообщение или отредактированное в супегруппе или канале # А так же отредактированные и новые сообщения с медиа в ЛС и группах if type(update) in [ UpdateNewChannelMessage, UpdateEditChannelMessage, UpdateNewMessage, UpdateEditMessage ]: if update.message.out: # Игнорируем исходящее сообщение return uid = update.message.from_id # Будет None, если канал, а так же post=True mid = update.message.id cid = None is_post = update.message.post usr = updates_users[uid] if uid else None nickname = display_tg_name( usr.first_name, usr.last_name) if usr else None from_type = 'c' if is_post else 's' msg = '' alt_msg = None edited = '' fwd_reply = '' orig_msg = None is_user = type(update.message.to_id) is PeerUser is_group = type(update.message.to_id) is PeerChat is_supergroup = type( update.message.to_id) is PeerChannel if is_user: cid = update.message.from_id elif is_group: cid = update.message.to_id.chat_id elif is_supergroup: cid = update.message.to_id.channel_id if type( update.message ) is MessageService: # Сервисные уведомления в чате print('messageService detected') with open( '/home/sofia/tgdebug/' + str(mid) + '.txt', 'w') as f: f.write(var_dump(obj)) ################################################################## alt_msg = self._process_info_msg( update.message, obj.users) else: # Обычное сообщение в чате msg = update.message.message if update.message.media: print('media detected') ####################################################### msg = '[{}] {}'.format( update.message.media.__class__.__name__, '{} {}'.format( self._process_media_msg( update.message.media), msg)) if update.message.reply_to_msg_id: fwd_reply = '|Reply to MID: {}'.format( update.message.reply_to_msg_id) reply_mid = update.message.reply_to_msg_id orig_msg = self.get_cached_message( cid, reply_mid, is_user, is_group, is_supergroup) if update.message.fwd_from: # Пересланное сообщение fwd_reply = self._process_forward_msg( update.message, updates_users, updates_channels) if update.message.edit_date: # Если новое - отмечаем прочитанным edited = '|Edited' if alt_msg is None: if is_post or type( update.message.to_id) is PeerUser: header = '[MID:{}{}{}] '.format( mid, fwd_reply, edited) else: header = '[User: {}|UID:{}|MID:{}{}{}] {}'\ .format(nickname, uid, mid, fwd_reply, edited, nl) alt_msg = '{}{}'.format(header, msg) self.set_cached_message( # Кэшируем без цитаты cid, mid, alt_msg, user=is_user, group=is_group, supergroup=is_supergroup) if orig_msg is not None: # Перестраиваем сообщение уже с цитатой alt_msg = '{}> {}\n{}'.format( header, orig_msg.replace('\n', '\n> '), msg) if is_user: self.gate_send_message(mfrom='u' + str(cid), mbody=alt_msg) if False: # Зарезервируем рекурсивные цитаты под опцию self.set_cached_message(cid, mid, alt_msg, user=True) if not update.message.edit_date: self.invoke( ReadHistoryRequest( # Отмечаем прочитанным InputPeerUser(usr.id, usr.access_hash), mid)) elif is_group: self.gate_send_message( mfrom='g' + str(update.message.to_id.chat_id), mbody=alt_msg) if False: # ... self.set_cached_message(cid, mid, alt_msg, group=True) if not update.message.edit_date: self.invoke( ReadHistoryRequest(InputPeerChat(cid), mid)) elif is_supergroup: self.gate_send_message(mfrom=from_type + str(cid), mbody=alt_msg) if False: # ... self.set_cached_message(cid, mid, alt_msg, supergroup=True) if not update.message.edit_date: access_hash = updates_type_channels[ cid].access_hash self.invoke( ReadHistoryChannel( InputPeerChannel(cid, access_hash), mid)) elif type( update ) is UpdateDeleteChannelMessages: # Удаленные сообщения в супергруппе/канале channel_id = update.channel_id channel_type = 's' if self.xmpp_gate.tg_dialogs[self.jid]['supergroups'][ channel_id].broadcast: # А может канал? channel_type = 'c' self.gate_send_message( mfrom=channel_type + str(channel_id), mbody='[Deleted messages IDs: {}]'.format( ', '.join( [str(mid) for mid in update.messages]))) elif type(update) is UpdateDeleteMessages: # Этот ивент обновления присылается при удалении сообщения в личном сообщении или группе. # Только id сообщения. Нет информации об диалоге/пользователе/группе. pass if type(obj.updates) is list and type( obj.updates[0]) is UpdateChannelTooLong: print('too long') # ***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^*** if type( obj ) is UpdateShort: # Тоже какой-то общий тип обновления (всегда маленькое) if type( obj.update ) is UpdateUserStatus: # Обновление статуса пользователя в сети Tg print('UpdateUserStatus') if type(obj.update.status) is UserStatusOnline: self.xmpp_gate.send_presence( pto=self.jid, pfrom='u' + str(obj.update.user_id) + '@' + self.xmpp_gate.config['jid']) elif type(obj.update.status) is UserStatusOffline: self.xmpp_gate.send_presence( pto=self.jid, pfrom='u' + str(obj.update.user_id) + '@' + self.xmpp_gate.config['jid'], ptype='xa', pstatus=obj.update.status.was_online.strftime( 'Last seen at %H:%M %d/%m/%Y')) elif type(obj.update.status) is UserStatusRecently: self.xmpp_gate.send_presence( pto=self.jid, pfrom='u' + str(obj.update.user_id) + '@' + self.xmpp_gate.config['jid'], pstatus='Last seen recently') else: print(type(obj.update.status)) print(obj.update.status.__dict__) elif type( obj.update ) is UpdateDeleteChannelMessages: # Удаленное сообщение в супергруппе if obj.update.pts > self._del_pts: # Фильтруем дубли обновлений channel_id = obj.update.channel_id channel_type = 's' if self.xmpp_gate.tg_dialogs[ self.jid]['supergroups'][channel_id].broadcast: channel_type = 'c' msg = '[Deleted messages IDs: {}]'.format(', '.join( [str(mid) for mid in obj.update.messages])) self.gate_send_message(mfrom=channel_type + str(channel_id), mbody=msg) self._del_pts = obj.update.pts # ***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^***^__^*** # Входящее сообщение в ЛС или группу (без медиа вложений) if type(obj) in [UpdateShortMessage, UpdateShortChatMessage ] and not obj.out: fwd_reply = '' nickname = '' if type(obj) is UpdateShortChatMessage: # Так как в апдейте есть только ID пользователя, то запрашиваем с сервера информацию о группе if obj.from_id not in self._groups_users: chat_info = self.invoke(GetFullChatRequest( obj.chat_id)) for usr in chat_info.users: self._groups_users[usr.id] = usr nickname = display_tg_name( self._groups_users[obj.from_id].first_name, self._groups_users[obj.from_id].last_name) if obj.reply_to_msg_id: fwd_reply = '|Reply to MID: {}'.format(obj.reply_to_msg_id) if obj.fwd_from: full_update = self.invoke( GetDifferenceRequest(obj.pts - 1, obj.date, -1, 1)) fwd_reply = self._process_forward_msg( full_update.new_messages[0], {usr.id: usr for usr in full_update.users}, {}) if type(obj) is UpdateShortMessage: self.gate_send_message(mfrom='u' + str(obj.user_id), mbody='[MID:{}{}] {}'.format( obj.id, fwd_reply, obj.message)) if obj.user_id in self.xmpp_gate.tg_dialogs[ self.jid]['users']: usr = self.xmpp_gate.tg_dialogs[self.jid]['users'][ obj.user_id] self.invoke( ReadHistoryRequest( # Отмечаем прочитанным InputPeerUser(usr.id, usr.access_hash), obj.id)) elif type(obj) is UpdateShortChatMessage: self.gate_send_message( mfrom='g' + str(obj.chat_id), mbody='[User: {}|UID:{}|MID:{}{}] {}'.format( nickname, obj.from_id, obj.id, fwd_reply, obj.message)) self.invoke( ReadHistoryRequest(InputPeerChat(obj.chat_id), obj.id)) except Exception: print('Exception occurs!') print(traceback.format_exc()) print(' ')
async def _check(self, message, func): self._reload_rights() config = self.get_flags(func) if not config: # Either False or 0, either way we can failfast return False logger.debug("Checking security match for %d", config) f_owner = config & OWNER f_sudo = config & SUDO f_support = config & SUPPORT f_group_owner = config & GROUP_OWNER f_group_admin_add_admins = config & GROUP_ADMIN_ADD_ADMINS f_group_admin_change_info = config & GROUP_ADMIN_CHANGE_INFO f_group_admin_ban_users = config & GROUP_ADMIN_BAN_USERS f_group_admin_delete_messages = config & GROUP_ADMIN_DELETE_MESSAGES f_group_admin_pin_messages = config & GROUP_ADMIN_PIN_MESSAGES f_group_admin_invite_users = config & GROUP_ADMIN_INVITE_USERS f_group_admin = config & GROUP_ADMIN f_group_member = config & GROUP_MEMBER f_pm = config & PM f_group_admin_any = ( f_group_admin_add_admins or f_group_admin_change_info or f_group_admin_ban_users or f_group_admin_delete_messages or f_group_admin_pin_messages or f_group_admin_invite_users or f_group_admin ) if f_owner and message.sender_id in self._owner + [self._me]: return True if f_sudo and message.sender_id in self._sudo: return True if f_support and message.sender_id in self._support: return True if message.sender_id in self._db.get(main.__name__, "blacklist_users", []): return False if f_pm and message.is_private: return True if f_group_member and message.is_group: return True if message.is_channel: if not message.is_group: if message.edit_date: return False chat = await message.get_chat() if not chat.creator and not ( chat.admin_rights and chat.admin_rights.post_messages ): return False if self._any_admin and f_group_admin_any: return True if f_group_admin: return True else: if f_group_admin_any or f_group_owner: participant = await message.client( GetParticipantRequest( await message.get_input_chat(), await message.get_input_sender(), ) ) participant = participant.participant if isinstance( participant, telethon.types.ChannelParticipantCreator ): return True if isinstance(participant, telethon.types.ChannelParticipantAdmin): if self._any_admin and f_group_admin_any: return True rights = participant.admin_rights if ( f_group_admin or f_group_admin_add_admins and rights.add_admins or f_group_admin_change_info and rights.change_info or f_group_admin_ban_users and rights.ban_users or f_group_admin_delete_messages and rights.delete_messages or f_group_admin_pin_messages and rights.pin_messages or f_group_admin_invite_users and rights.invite_users ): return True chat = await message.get_chat() if message.out: if chat.creator and f_group_owner: return True me_id = (await message.client.get_me(True)).user_id if ( f_owner and me_id in self._owner or f_sudo and me_id in self._sudo or f_support and me_id in self._support ): return True elif message.is_group: if f_group_admin_any or f_group_owner: full_chat = await message.client(GetFullChatRequest(message.chat_id)) participants = full_chat.full_chat.participants.participants participant = next( ( possible_participant for possible_participant in participants if possible_participant.user_id == message.sender_id ), None, ) if not participant: return if isinstance(participant, telethon.types.ChatParticipantCreator): return True if ( isinstance(participant, telethon.types.ChatParticipantAdmin) and f_group_admin_any ): return True return False