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))
