def get_entity_rows_by_id(self, entity_id, exact=True): if exact: key = "{}:entities:{}".format(self.sess_prefix, entity_id) s = self.redis_connection.get(key) if not s: return None try: s = self._unpack(s) return entity_id, s["hash"] except Exception as ex: __log__.exception(ex.args) return None else: ids = ( utils.get_peer_id(PeerUser(entity_id)), utils.get_peer_id(PeerChat(entity_id)), utils.get_peer_id(PeerChannel(entity_id)) ) try: for key in self._get_entities(): entity = self._unpack(self.redis_connection.get(key)) if "id" in entity and entity["id"] in ids: return entity["id"], entity["hash"] except Exception as ex: __log__.exception(ex.args)
async def get_telegram_id(phone_number, user_mode=False): """ Tries to get a telegram ID for the passed in phone number. """ async with start_bot_client() as bot: if user_mode: # just leaving this code here in case it proves useful. # It only works if you use a user, not a bot. # more details: https://stackoverflow.com/a/51196276/8207 # https://tl.telethon.dev/methods/contacts/import_contacts.html#examples contact = InputPhoneContact(client_id=0, phone=phone_number, first_name="a", last_name="") result = await bot(ImportContactsRequest([contact])) print(result) else: # this only works if you have already messaged the contact, so only will allow looking # up "known" users. # more details: https://stackoverflow.com/a/41696457/8207 room_id = settings.MPACT_CONTACT_LOOKUP_ROOM_ID or GroupChat.objects.all( )[0].id print('room id', room_id) receiver = await bot.get_entity(PeerChat(room_id)) msg_inst = await bot.send_file( receiver, InputMediaContact( phone_number=phone_number, first_name='Jane', last_name='Doe', vcard='', )) # "unknown" users return "0" instead of the actual ID return msg_inst.media.user_id if msg_inst.media.user_id != 0 else None
async def edit_message(room_id, data): """ Returns the updated message """ async with start_bot_client() as bot: msg_inst = Message.objects.get(id=data["message_id"]) if msg_inst.from_group: receiver = await bot.get_entity(PeerChat(room_id)) else: receiver = await bot.get_entity(PeerUser(room_id)) msg = await bot.get_messages(receiver, ids=msg_inst.telegram_msg_id) try: await bot.edit_message(msg, data[MESSAGE]) except MessageIdInvalidError: logger.exception(exception) return { DATA: { MESSAGE: EDIT_FAIL, IS_SUCCESS: False }, STATUS: status.HTTP_400_BAD_REQUEST, } msg_inst.message = data[MESSAGE] msg_inst.save() return { DATA: { MESSAGE: data, IS_SUCCESS: True }, STATUS: status.HTTP_200_OK, }
def update_handler(self, update): """Callback method for received Updates""" # We have full control over what we want to do with the updates. # In our case we only want to react to chat messages, so we use # isinstance() to behave accordingly on these cases. if isinstance(update, UpdateShortMessage): who = self.get_entity(update.user_id) if update.out: sprint('>> "{}" to user {}'.format(update.message, get_display_name(who))) else: sprint('<< {} sent "{}"]'.format(get_display_name(who), update.message)) elif isinstance(update, UpdateShortChatMessage): which = self.get_entity(PeerChat(update.chat_id)) if update.out: sprint('>> sent "{}" to chat {}'.format( update.message, get_display_name(which))) else: who = self.get_entity(update.from_id) sprint('<< {} @ {} sent "{}"'.format(get_display_name(which), get_display_name(who), update.message))
def get_chat_messages(client, chat): if chat.is_channel: entity = PeerChannel(chat.id) elif chat.is_group: entity = PeerChat(chat.id) else: raise ValueError('Unknown type of group chat!') chat_entity = client.get_input_entity(entity) history = dict() for message in tqdm(client.iter_messages(chat_entity), desc='# messages retrieved', unit=''): sender = message.sender username = '******'.format(sender.username) if message.sender.username is None: username = sender.first_name if sender.last_name is not None: username = '******'.format(username, sender.last_name) if not username in history: history[username] = {'raw_messages': []} history[username]['raw_messages'].append(message) return history
def peer(self) -> Union[TypePeer, TypeInputPeer]: if self.peer_type == "user": return PeerUser(user_id=self.tgid) elif self.peer_type == "chat": return PeerChat(chat_id=self.tgid) elif self.peer_type == "channel": return PeerChannel(channel_id=self.tgid)
async def get_entity(chat_id, client): try: entity = await client.get_entity(PeerUser(chat_id)) except: try: entity = await client.get_entity(PeerChannel(chat_id)) except: entity = await client.get_entity(PeerChat(chat_id)) return entity
def get_entity_rows_by_id(self, id, exact=True): with switch_db(Entity, self.database) as _Entity: if exact: return _Entity.objects(id=id) else: ids = (utils.get_peer_id(PeerUser(id)), utils.get_peer_id(PeerChat(id)), utils.get_peer_id(PeerChannel(id))) return _Entity.objects(id__in=ids)
def get_channel_info_by_group_id(self, id): channel = self.client.get_entity(PeerChat(id)) return { 'channel_id': channel.id, 'channel_title': channel.title, 'is_broadcast': False, 'is_mega_group': False, 'channel_access_hash': None, }
def get_entity_rows_by_id(self, id, exact=True): if exact: query = "SELECT * FROM c WHERE c.id = {}".format(id) else: query = "SELECT * FROM c WHERE c.id in ({}, {}, {})".format( utils.get_peer_id(PeerUser(id)), utils.get_peer_id(PeerChat(id)), utils.get_peer_id(PeerChannel(id)) ) return self.get_entity_from_container(query)
def get_entity_rows_by_id(self, key, exact=True): if exact: row = models.Entity.objects.filter(id=key).first() else: ids = (utils.get_peer_id(PeerUser(key)), utils.get_peer_id(PeerChat(key)), utils.get_peer_id(PeerChannel(key))) row = models.Entity.objects.filter(id__in=ids).first() return (row.id, row.hash) if row else None
def get_entity_rows_by_id(self, key, exact=True): if exact: query = self._db_query(self.Entity, self.Entity.id == key) else: ids = (utils.get_peer_id(PeerUser(key)), utils.get_peer_id(PeerChat(key)), utils.get_peer_id(PeerChannel(key))) query = self._db_query(self.Entity, self.Entity.id in ids) row = query.one_or_none() return (row.id, row.hash) if row else None
def effective_chat_id(update): if update.CONSTRUCTOR_ID == 0x914fbf11: return (update.user_id, PeerUser(update.user_id)) elif update.CONSTRUCTOR_ID == 0x16812688: return (update.chat_id, PeerChat(update.chat_id)) else: return (update.message.to_id.channel_id, update.message.to_id)
def get_channel_all_users(self, channel_id): # TODO: this function is not complete channel = self.client.get_entity(PeerChat(channel_id)) users = self.client.get_participants(channel) print('total users: {}'.format(users.total)) for user in users: if user.username is not None and not user.is_self: print(utils.get_display_name(user), user.username, user.id, user.bot, user.verified, user.restricted, user.first_name, user.last_name, user.phone, user.is_self)
async def normal_handler(event): try: some_id = event.chat_id r = await client.get_entity(PeerChannel(some_id)) except Exception as e: some_id = (-1) * (event.chat_id) r = await client.get_entity(PeerChat(some_id)) pass try: id = event.from_id user_id = await client.get_entity(id) first_name = user_id.first_name if first_name == None: first_name = '' print(first_name) last_name = user_id.last_name if last_name == None: last_name = '' print(last_name) user_name = user_id.username if user_name == None: user_name = '' else: user_name = f'@{user_name}' print(user_name) l = f'{first_name} {last_name} {user_name}' except Exception as e: l = 'Невозможно определить имя' print(e) pass s = event.raw_text t = db.get_cotegory() r = r.title if r in t: chat_id = db.channe_id(r) re = event.media result = translator.translate(str(s), src='en', dest='ru') result_1 = result.text if result_1 != s: result_1 = f'Написал <b>{l}</b>\nОригинал текста:\n<i>{s}</i>\nПеревод:\n <b>{result_1}</b>' else: result_1 = f'Написал <b>{l}</b>\n<i>{s}</i>' if re != None: await client.download_media(message=re, file='photo.jpg') await bot.send_photo(chat_id, open('photo.jpg', 'rb'), result_1, parse_mode='HTML') else: await bot.send_message(chat_id, result_1, parse_mode='HTML')
def get_entity_rows_by_id(self, key: int, exact: bool = True) -> Optional[Tuple[int, int]]: if exact: query = self._db_query(self.Entity, self.Entity.id == key) else: ids = ( utils.get_peer_id(PeerUser(key)), utils.get_peer_id(PeerChat(key)), utils.get_peer_id(PeerChannel(key)) ) query = self._db_query(self.Entity, self.Entity.id.in_(ids)) row = query.one_or_none() return (row.id, row.hash) if row else None
async def get_chat_by_id(chat_id, client): try: chat = await client.get_entity(PeerChat(chat_id)) return chat except Exception: pass try: channel = await client.get_entity(PeerChannel(chat_id)) return channel except Exception: pass return None
def get_info(infoType, info): print("infoType=" + infoType + ";info=" + info) result = None if "user" == infoType: result = user_1.get_entity(PeerUser(info)) elif "chat" == infoType: result = user_1.get_entity(PeerChat(info)) elif "channel" == infoType: result = user_1.get_entity(PeerChannel(int(info))) elif "id" == infoType: result = user_1.get_entity(info) print(result) # return jsonpickle.encode(result, False) return "get group info."
def get_all_pseudousers(client, entities): users = {} me = client.get_me() for e in entities + [me]: tmp_user = {} if isinstance(e, User): tmp_user['name'] = get_user_name(e).strip() tmp_user['peer'] = PeerUser(e.id) elif isinstance(e, Chat): tmp_user['name'] = e.title.strip() tmp_user['peer'] = PeerChat(e.id) tmp_user['id'] = e.id tmp_user['last_msg_id'] = get_entity_last_msg(tmp_user) users[e.id] = tmp_user return users
async def send_msg(room_id, message, from_group=None): """ Sends the message to the particular chat """ async with start_bot_client() as bot: current_bot = await bot.get_me() chat_object = get_chat_by_telegram_id(room_id) # dynamically set from_group or ensure explicit param correctly identified the chat type computed_from_group = isinstance(chat_object, GroupChat) if from_group is None: from_group = computed_from_group elif from_group != computed_from_group: raise Exception('Unexpected chat type / group flag combination') if from_group: receiver = await bot.get_entity(PeerChat(room_id)) else: access_hash = chat_object.access_hash receiver = InputPeerUser(room_id, int(access_hash)) msg_inst = await bot.send_message(receiver, message) message_data = { ROOM_ID: room_id, MESSAGE: message, FROM_GROUP: from_group, SENDER_ID: current_bot.id, SENDER_NAME: current_bot.first_name, TELEGRAM_MSG_ID: msg_inst.id } serializer = MessageSerializer(data=message_data) if serializer.is_valid(): serializer.save() await handle_post_message_send_actions(chat_object, serializer.data) return { DATA: { MESSAGE: serializer.data, IS_SUCCESS: True }, STATUS: status.HTTP_200_OK, }
def get_entity_rows_by_id(self, key: int, exact: bool = True) -> Optional[Tuple[int, int]]: t = self.Entity.__table__ if exact: rows = self.engine.execute( select([t.c.id, t.c.hash]).where( and_(t.c.session_id == self.session_id, t.c.id == key))) else: ids = (utils.get_peer_id(PeerUser(key)), utils.get_peer_id(PeerChat(key)), utils.get_peer_id(PeerChannel(key))) rows = self.engine.execute( select([t.c.id, t.c.hash]).where( and_(t.c.session_id == self.session_id, t.c.id.in_(ids)))) try: return next(rows) except StopIteration: return None
def update_handler(self, update): if isinstance(update, UpdateShortMessage): who = self.get_entity(update.user_id) if update.out: sprint('>> "{}" to user {}'.format(update.message, get_display_name(who))) else: sprint('<< {} sent "{}"]'.format(get_display_name(who), update.message)) elif isinstance(update, UpdateShortChatMessage): which = self.get_entity(PeerChat(update.chat_id)) if update.out: sprint('>> sent "{}" to chat {}'.format( update.message, get_display_name(which))) else: who = self.get_entity(update.from_id) sprint('<< {} @ {} sent "{}"'.format(get_display_name(which), get_display_name(who), update.message))
def send_message(args): client = get_client() if not client.is_user_authorized(): print(str(errors.ERROR_NOT_CONNECTED)) return id = int(args.contact) receiver = None if args.mode == "user": receiver = client.get_entity(PeerUser(id)) else: try: receiver = client.get_entity(PeerChannel(id)) except: receiver = client.get_entity(PeerChat(id)) if receiver is None: print(str(errors.ERROR_RECEIVER_NOT_FOUND)) return client.send_message(receiver, ' '.join(args.msg)) print(0)
def messages(self, entity_id, limit=20, offset_date=None, offset_id=0, max_id=0, min_id=0): if isinstance(entity_id, str) and entity_id.startswith( '@') or entity_id.startswith('+'): entity = self.client.get_entity(entity_id) else: try: entity = self.client.get_entity(PeerUser(int(entity_id))) except ValueError: try: entity = self.client.get_entity(PeerChat(int(entity_id))) except ValueError: entity = self.client.get_entity(PeerChannel( int(entity_id))) count, messages, senders = self.client.get_message_history( entity, limit=limit, offset_date=offset_date, offset_id=offset_id, max_id=max_id, min_id=min_id, ) messages = [m.to_dict() for m in messages] # ToDo: Fix media! for m in messages: if 'media' in m and m['media']: m.update({'media': None}) _senders = (s.to_dict() for s in senders) senders = {s['id']: s for s in _senders} messages.sort(key=itemgetter('date'), reverse=False) return {'count': count, 'messages': messages, 'senders': senders}
def get_entity_rows_by_id(self, id, exact=True): # print('django session get_entity_rows_by_id') if exact: try: entity = TelethonEntity.objects.get( client_session_name=self.client_session_name, identifier=id) return [entity.identifier, entity.hash] except TelethonEntity.DoesNotExist: return None # return self._execute( # 'select id, hash from entities where id = ?', id) else: try: entity = TelethonEntity.objects.get( client_session_name=self.client_session_name, identifier__in=[ utils.get_peer_id(PeerUser(id)), utils.get_peer_id(PeerChat(id)), utils.get_peer_id(PeerChannel(id)) ]) return [entity.identifier, entity.hash] except TelethonEntity.DoesNotExist: return None
def __init__(self, api_id, api_hash, phone_number, admins, enabled_chats, output_path): self.api_id = api_id self.api_hash = api_hash self.phone_number = phone_number self.admins_id = admins self.enabled_chats_id = enabled_chats self.output_path = output_path self.client = TelegramClient(settings.TELETHON_SESSION_NAME, self.api_id, self.api_hash, update_workers=1, spawn_read_thread=False) self.client.start(phone=self.phone_number) # Getting information about yourself self.me = self.client.get_me() # print(self.me.stringify()) # Getting all the dialogs (conversations you have open) # !!! get_dialogs is MANDATORY !!! dialogs = self.client.get_dialogs() # for i, dialog in enumerate(dialogs, start=1): # sprint('{:3d}. {} | {}'.format( # i, get_display_name(dialog.entity), dialog.entity.id)) self.admins_entities = {} for admin_id in self.admins_id: self.admins_entities[admin_id] = \ self.client.get_entity(PeerUser(admin_id)) self.chats_entities = {} for chat_id in self.enabled_chats_id: self.chats_entities[chat_id] = \ self.client.get_entity(PeerChat(chat_id))
async def get_entity_name(self, entity_id, entity_type='', allow_str_id=True, with_additional_text=False): if not entity_id: return None str_entity_id = str(entity_id) if entity_type in ['User', 'Bot']: if str_entity_id not in self.user_logins: if with_additional_text: print('Trying to find user login for id=' + str_entity_id) try: entity = await self.tg_client.get_entity( PeerUser(entity_id)) if type(entity) != User: raise ValueError(str_entity_id + ' is not user') if entity.bot and (entity_type == 'User'): entity_type = 'Bot' self.user_logins[str_entity_id] = self.get_user_name_text( entity) self.add_entity_db_name(entity_id, entity_type, self.user_logins[str_entity_id]) if with_additional_text: if entity.is_self: msg = ' - me' elif entity.mutual_contact: msg = ' from contacts (mutual)' elif entity.contact: msg = ' from contacts' elif entity.bot: msg = ' - bot' else: msg = '' print('Found. It is "' + self.user_logins[str_entity_id] + '"' + msg) except ValueError as e: res_msg = 'Not user ' + str_entity_id if allow_str_id: print(res_msg) else: raise TypeError(res_msg) self.user_logins[str_entity_id] = str_entity_id return self.user_logins[str_entity_id] elif entity_type == 'Chat': if str_entity_id not in self.chat_names: try: entity = await self.tg_client.get_entity( PeerChat(entity_id)) if type(entity) != Chat: raise ValueError(str_entity_id + ' is not chat') self.chat_names[str_entity_id] = get_display_name(entity) self.add_entity_db_name(entity_id, entity_type, self.chat_names[str_entity_id]) except (ValueError, ChatIdInvalidError) as e: res_msg = 'Not chat ' + str_entity_id if allow_str_id: print(res_msg) else: raise TypeError(res_msg) self.chat_names[str_entity_id] = str_entity_id return self.chat_names[str_entity_id] elif entity_type in ['Channel', 'Megagroup']: if str_entity_id not in self.channel_names: try: entity = await self.tg_client.get_entity( PeerChannel(entity_id)) if type(entity) != Channel: raise ValueError(str_entity_id + ' is not channel') self.channel_names[str_entity_id] = get_display_name( entity) self.channel_megagroups[str_entity_id] = entity.megagroup self.add_entity_db_name(entity_id, entity_type, self.channel_names[str_entity_id], None, entity.megagroup) except ValueError as e: res_msg = 'Not channel ' + str_entity_id if allow_str_id: print(res_msg) else: raise TypeError(res_msg) self.channel_names[str_entity_id] = str_entity_id return self.channel_names[str_entity_id] elif entity_type == '': if str_entity_id in self.user_logins: return self.user_logins[str_entity_id] elif str_entity_id in self.chat_names: return self.chat_names[str_entity_id] elif str_entity_id in self.channel_names: return self.channel_names[str_entity_id] else: try: entity_name = await self.get_entity_name( entity_id, 'User', False, False) except (TypeError, ValueError) as e: try: entity_name = await self.get_entity_name( entity_id, 'Chat', False, False) except (TypeError, ValueError) as e: try: entity_name = await self.get_entity_name( entity_id, 'Channel', False, False) except (TypeError, ValueError) as e: res_msg = 'Unknown entity ' + str_entity_id if allow_str_id: print(res_msg) else: raise TypeError(res_msg) entity_name = str_entity_id return entity_name return str_entity_id
q = Queue() t = Thread(target=queue_putter) t.daemon = True t.start() tg = TelegramClient(StringSession(config.session), config.api_id, config.api_hash) tg.start() while True: item = q.get() if item is None: break try: if item.chattype == 'channel': entity = tg.get_entity(PeerChannel(int(item.chat))) elif item.chattype == 'user': entity = tg.get_entity(PeerUser(int(item.chat))) elif item.chattype == 'chat': entity = tg.get_entity(PeerChat(int(item.chat))) else: entity = item.chat msg = tg.send_message(entity, item.text) if item.delete: msg.delete() except ValueError as e: print(e.args) q.task_done()
def terminate_handler(signum, frame): log('terminate instance') onliner.stop() asyncio.ensure_future(client.disconnect()) if SIGHUP_AVAILABLE: signal.signal(signal.SIGHUP, sighup_handler) signal.signal(signal.SIGINT, terminate_handler) signal.signal(signal.SIGTERM, terminate_handler) client.start() if ctl_chat_id: ctl_chat = client.get_entity(PeerChat(int(ctl_chat_id))) @client.on(events.NewMessage(outgoing=True, chats=[ctl_chat])) async def ctl_handler(event): log('👀%s got ctl request: %s' % (event.message.id, event.raw_text)) try: reply = onliner.handle_incoming_control_message(event) except Exception as e: exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1] log('🖕%s exception %s\n%s %s:%s' % (event.message.id, e, exc_type, fname, exc_tb.tb_lineno)) await client.send_message( ctl_chat_id, '🖕%s exception %s\n%s %s:%s' % (event.message.id, e, exc_type, fname, exc_tb.tb_lineno))