async def main():
if len(sys.argv) > 1 and sys.argv[1] == 'auth':
# TODO: perform logout in the code, in case the user use `auth` argument
logging.critical(
'You successfully authorized, please, run the same command without `auth` argument to '
'start monitoring your messages. If you want to log-out, remove the file `db/user.session`, '
'to log-out and re-execute this command')
exit(0)
if not await client.is_user_authorized():
logging.critical(
'Please, execute `auth` command before starting the daemon (see `README.md` file)'
)
exit(1)
if bool(os.getenv('NOTIFY_ONGOING_MESSAGES', '1')):
new_message_event = events.NewMessage()
else:
new_message_event = events.NewMessage(incoming=True, outgoing=False)
client.add_event_handler(on_new_message, new_message_event)
client.add_event_handler(get_on_message_deleted(client),
events.MessageDeleted())
await cycled_clean_old_messages()
async def set_event_handlers(self, channel, origin, messages_map):
@self.client.on(events.NewMessage(chats=origin))
async def channeller_new(new_message_event: NewMessage.Event):
message = new_message_event.message
if type(message) == MessageService:
print(message)
return
print(message.text)
# Unlike `JalaliDateTime`, `JalaliDate` doesn't need timestamp-converting
date_stamp = f'`{en_to_fa(JalaliDate(message.date).strftime("%Y/%m/%d"))}`'
await self.send_message(date_stamp, message, messages_map, channel,
origin)
# noinspection PyShadowingNames
@self.client.on(events.MessageEdited(chats=origin))
async def channeller_edit(edit_event: MessageEdited.Event):
print('Message', edit_event.id, 'changed at', edit_event.date)
message = edit_event.message
if type(message
) == MessageService or message.id not in messages_map:
print(message)
return
print(message.text)
# old_message = await self.client.get_messages(channel, ids=messages_map[message.id])
new_text = message.text
stamp = f'`{en_to_fa(JalaliDate(message.date).strftime("%Y/%m/%d"))}`'
message.text = new_text + '\n\n' + stamp
max_allowed_message_size = 1024 if message.media else 4096
if len(message.raw_text) > max_allowed_message_size:
message.text = new_text
# message.id = messages_map[message.id]
await self.client.edit_message(
channel,
messages_map[message.id],
text=message.text,
parse_mode=message.client.parse_mode,
link_preview=message.web_preview,
file=message.file,
# force_document=message.force_document,
buttons=message.buttons,
# schedule=message.schedule,
)
# noinspection PyShadowingNames
@self.client.on(events.MessageDeleted(chats=origin))
async def channeller_delete(delete_event: MessageDeleted.Event):
message_ids = []
for msg_id in delete_event.deleted_ids:
message_ids.append(messages_map[msg_id])
print('Message', msg_id, 'was deleted in',
delete_event.chat_id)
print(delete_event)
await self.client.delete_messages(channel, message_ids)
async def wait_for_updates(saver):
"""
:type saver: DialogSaver
"""
client = saver.client
@client.on(events.NewMessage())
@client.on(events.MessageEdited())
async def message_updated_handler(event):
await event.get_chat()
await event.get_sender()
if await filter_event(event):
saver.save_dialog(event.chat.id,
get_display_name(event.chat)) # the dialog
await saver.process_message(message=event.message,
dialog_id=event.chat_id)
@client.on(events.MessageRead())
async def message_read_handler(event):
if await filter_event(event):
read_time = datetime.utcnow()
message_ids = event._message_ids or [event._message_id]
for message_id in message_ids:
saver.set_message_attributes(message_id,
{"read_time": read_time},
commit=False)
saver.commit()
@client.on(events.MessageDeleted())
async def message_delete_handler(event):
if await filter_event(event):
for message_id in event.deleted_ids:
saver.set_message_attributes(message_id, {"deleted": True},
commit=False)
saver.commit()
while True:
try:
logger.info("Catching up")
await client.catch_up()
logger.info("Waiting for updates...")
await client.run_until_disconnected()
except ConnectionError:
await sleep(10)
class Command(BaseCommand):
help = 'Just testing stuff'
def add_arguments(self, parser):
#Positional arg example
parser.add_argument('nothing', nargs='+', type=int)
# Named (optional) arguments
parser.add_argument(
'--delete',
action='store_true',
help='Delete poll instead of closing it',
)
def handle(self, *args, **options):
with client:
client.run_until_disconnected()
@client.on(events.MessageDeleted())
async def deletedMessageHandler(event):
#THIS IS INCOMING DELETE:
#DeletedEvent: MessageDeleted.Event(original_update=UpdateDeleteChannelMessages(channel_id=1256178279, messages=[133], pts=135, pts_count=1), deleted_id=133, deleted_ids=[133])
try:
process_deleted_message(event)
except AttributeError as e:
logging.warning("AttributeError: %s" % e)
pass
except Exception as e:
logging.warning("Caught exception: %s" % e)
pass
#@client.on(events.NewMessage(pattern=r'(?is).*(entry|closing|close|buy|sell).*', forwards=False))
@client.on(events.NewMessage())
async def my_event_handler(event):
#THIS IS INCOMING MESSAGE:
#NewMessage.Event(original_update=UpdateNewChannelMessage(message=Message(id=133, to_id=PeerChannel(channel_id=1256178279), date=datetime.datetime(2019, 11, 4, 20, 22, 46, tzinfo=datetime.timezone.utc), message='USDJPY SELL \nEntry 108.533\nSL 109.150\nTp 107.100', out=True, mentioned=False, media_unread=False, silent=False, post=True, from_scheduled=False, legacy=False, edit_hide=False, from_id=None, fwd_from=None, via_bot_id=None, reply_to_msg_id=None, media=None, reply_markup=None, entities=[], views=1, edit_date=None, post_author=None, grouped_id=None, restriction_reason=[]), pts=134, pts_count=1), pattern_match=<re.Match object; span=(0, 48), match='USDJPY SELL \nEntry 108.533\nSL 109.150\nTp 107.1>, message=Message(id=133, to_id=PeerChannel(channel_id=1256178279), date=datetime.datetime(2019, 11, 4, 20, 22, 46, tzinfo=datetime.timezone.utc), message='USDJPY SELL \nEntry 108.533\nSL 109.150\nTp 107.100', out=True, mentioned=False, media_unread=False, silent=False, post=True, from_scheduled=False, legacy=False, edit_hide=False, from_id=None, fwd_from=None, via_bot_id=None, reply_to_msg_id=None, media=None, reply_markup=None, entities=[], views=1, edit_date=None, post_author=None, grouped_id=None, restriction_reason=[]))
try:
process_new_message(event)
except AttributeError as e:
logging.warning("AttributeError: %s" % e)
pass
except Exception as e:
logging.warning("Caught exception: %s" % e)
pass
ignored_ids = [1234902837]
if type(
event.message.to_id
) is PeerChannel and event.message.to_id.channel_id in ignored_ids:
return
c.execute(
"INSERT INTO messages (message_id, message, created) VALUES (?, ?, ?)",
(event.message.id,
sqlite3.Binary(SerializableMessage.serialize(
event.message)), str(datetime.now())))
conn.commit()
@client.on(events.MessageDeleted())
async def handler(event: events.MessageDeleted.Event):
db_result = c.execute(
"SELECT message_id, message FROM messages WHERE message_id IN ({0})"
.format(",".join(str(e) for e in event.deleted_ids))).fetchall()
messages = [SerializableMessage.deseriaze(i[1]) for i in db_result]
log_deleted_usernames = []
for message in messages:
user_request = await client(GetFullUserRequest(message.from_id))
user = user_request.user
if user.first_name or user.last_name:
mention_username = \
def main():
logging.basicConfig(level=logging.ERROR)
extract_configs()
setup_telegram_connection()
setup_sqlite_connection('logs.sqlite')
@CLIENT.on(events.NewMessage())
async def handlerNewMessage(event):
try:
await record_message(event.message, CLIENT)
except KeyboardInterrupt:
raise
except Exception as e:
print(e)
@CLIENT.on(events.ChatAction())
async def handlerChatAction(event):
event_name = type(event.original_update.message.action).__name__
date = event.original_update.message.date
date = date.strftime('%Y.%d.%m %H:%M:%S %a')
attributes = event.original_update.message.action.__dict__
attributes['id'] = event.original_update.message.id
attributes['to_id'] = list(
event.original_update.message.to_id.__dict__.values())[
0] ###########
attributes['event_name'] = event_name
attributes['date'] = date
for k, v in attributes.items():
if type(v) == list:
attributes[k] = str(v)
columns = ','.join(str(e) for e in list(attributes.keys()))
placeholders = ':' + ', :'.join(
str(e) for e in list(attributes.keys()))
CURSOR.execute(
"INSERT INTO ChatActions (%s) VALUES (%s)" %
(columns, placeholders), attributes)
CONN.commit()
@CLIENT.on(events.MessageEdited())
async def handlerMessageEdited(event):
_id = event.message.id
_to_id = list(event.message.to_id.__dict__.values())[0]
_from_id = event.message.from_id
_message = event.message.message
_date = event.message.date.strftime('%Y.%d.%m %H:%M:%S %a')
CURSOR.execute(
"UPDATE Messages SET edited=1 WHERE to_id=:to_id AND id=:id", {
'id': _id,
'to_id': _to_id
})
CURSOR.execute(
"INSERT INTO Edited VALUES (:id, :to_id, :from_id, :message, :date)",
{
'id': _id,
'to_id': _to_id,
'from_id': _from_id,
'message': _message,
'date': _date
})
CONN.commit()
@CLIENT.on(events.MessageDeleted())
async def handlerMessageDeleted(event):
print(event)
for i in range(len(event.deleted_ids)):
attributes = []
values = []
attributes.append("id=" + str(event.deleted_ids[i]))
values.append(str(event.deleted_ids[i]))
if isinstance(event.original_update, UpdateDeleteChannelMessages):
attributes.append("to_id=" +
str(event.original_update.channel_id))
values.append(str(event.original_update.channel_id))
CURSOR.execute("UPDATE Messages SET deleted=1 WHERE %s" %
' AND '.join(attributes))
#for i in range(len(event.deleted_ids)):
current_time = datetime.datetime.now()
values.append(current_time.strftime('"%Y.%d.%m %H:%M:%S %a"'))
CURSOR.execute("INSERT INTO Deleted VALUES (%s)" %
', '.join(values))
CONN.commit()
@CLIENT.on(events.UserUpdate())
async def handlerUserUpdate(event):
id = event.original_update.user_id
try:
user = (await CLIENT(
GetFullUserRequest(await CLIENT.get_input_entity(id)))).user
username = user.username
first_name = user.first_name
last_name = user.last_name
except Exception as e:
print(e)
username = ""
first_name = ""
last_name = ""
event_name = type(event.original_update).__name__
attributes = event.original_update.status.__dict__
if len(list(attributes.values())) > 0:
date = list(attributes.values())[0]
else:
date = [0, 0, 0, 0, 0, 0]
date = date.strftime('%Y.%d.%m %H:%M:%S %a')
CURSOR.execute(
"INSERT INTO UserUpdates VALUES(:id, :username, :firstName, :lastName, :update, :date)",
{
'id': id,
'username': username,
'firstName': first_name,
'lastName': last_name,
'update': event_name,
'date': date
})
CONN.commit()
CLIENT.start()
CLIENT.run_until_disconnected()
CONN.close()
return
logging.info(f"Message deleted in {chat_id}")
event_uid = EventUid(event)
fwded_msgs = _stored.get(event_uid)
if fwded_msgs:
for msg in fwded_msgs:
await msg.delete()
return
ALL_EVENTS = {
"new": (new_message_handler, events.NewMessage()),
"edited": (edited_message_handler, events.MessageEdited()),
"deleted": (deleted_message_handler, events.MessageDeleted()),
}
ALL_EVENTS.update(BOT_EVENTS)
for _, plugin in plugins.items():
try:
event_handlers = getattr(plugin, "event_handlers")
if event_handlers:
ALL_EVENTS.update(event_handlers)
except AttributeError:
pass
def start_sync():
"""Start tgcf live sync."""
url=url,
chat_id=share_id,
post_time=datetime.fromtimestamp(
event.date.timestamp()),
sender=sender)
self.newest_msg[share_id] = msg
self._indexer.add_document(msg)
@self.session.on(events.MessageEdited())
async def client_message_update_handler(
event: events.MessageEdited.Event):
if self._should_monitor(
event.chat_id) and (msg_text := self._extract_text(event)):
share_id = get_share_id(event.chat_id)
url = f'https://t.me/c/{share_id}/{event.id}'
self._logger.info(
f'Update message {url} to: "{brief_content(msg_text)}"')
self._indexer.update(url=url, content=msg_text)
@self.session.on(events.MessageDeleted())
async def client_message_delete_handler(
event: events.MessageDeleted.Event):
if not hasattr(event, 'chat_id') or event.chat_id is None:
return
share_id = get_share_id(event.chat_id)
if event.chat_id and self._should_monitor(event.chat_id):
for msg_id in event.deleted_ids:
url = f'https://t.me/c/{share_id}/{msg_id}'
self._logger.info(f'Delete message {url}')
self._indexer.delete(url=url)
async def handle(self):
me = await self._client.get_me()
messages_buffer = MessagesBuffer(limit=self._messages_buffer_size)
@self._client.on(event=events.NewMessage(incoming=True))
@self._notify(me=me)
async def handler_new(event):
print('Received message: {event}'.format(event=event))
print('Adding message to buffer...')
message = event.message
messages_buffer.add(message=message)
print(
'Message with id: {id} added to buffer. Current buffer size: {size}/{capacity}'
.format(id=message.id,
size=messages_buffer.size,
capacity=self._messages_buffer_size))
@self._client.on(event=events.MessageEdited(incoming=True))
@self._notify(me=me)
async def handler_edited(event):
print('Received edit for message: {event}'.format(event=event))
print('Adding edited message to buffer...')
message = event.message
messages_buffer.add(message=message)
print(
'Edited message with id: {id} added to buffer. Current buffer size: {size}/{capacity}'
.format(id=message.id,
size=messages_buffer.size,
capacity=self._messages_buffer_size))
@self._client.on(event=events.MessageDeleted())
@self._notify(me=me)
async def handler_deleted(event):
print('Messages deletion event received: {messages}'.format(
messages=event))
for deleted_id in event.deleted_ids:
message = messages_buffer.get(deleted_id)
if message is not None:
print('Message with id: {id} found in messages buffer'.
format(id=deleted_id))
print(
'Forwarding {revisions} revisions of message with id: {id}...'
.format(revisions=len(message.revisions),
id=deleted_id))
for index, revision in enumerate(message.revisions):
print('Forwarding revision: {revision}...'.format(
revision=revision))
await self._resend_message(to=me,
revision_number=index + 1,
message=revision)
messages_buffer.remove(deleted_id)
print('Revision forwarded')
print('Message with id: {id} forwarded'.format(
id=deleted_id))
else:
print('Message with id: {id} not found in message buffer'.
format(id=deleted_id))
try:
await self._client.run_until_disconnected()
finally:
self._client.disconnect()
elif text in cmds:
await actions[text]
async def download_handler():
# Referencing to the global variables
global client, queue, conn, is_downloading
# Stopping if one media is downloading
if not is_downloading:
is_downloading = True
await download.download(client, queue, conn)
is_downloading = False
@client.on(events.MessageDeleted(chats=chat))
async def remove_handler(event):
# Deleting every file which correspond
# to a deleted Telegram's message
for msg_id in event.deleted_ids:
file = dbm.delete_message(conn, msg_id)
if (file != ""):
remove(file)
else:
print("The message wasn't in database and thus it isn't deleted")
if __name__ == "__main__":
# Creating the download folder if it doesn't exist
if not path.isdir(download_folder):
mkdir(download_folder)
