async def countmessages(event):
user, chat = await fetch_user(event, get_chat=True)
if not user:
return
if not chat:
await event.edit(msgRep.FAIL_CHAT)
return
remote = isRemoteCMD(event, chat.id)
try:
msg_info = await event.client(
SearchRequest(
peer=chat.id,
q="", # search for any message
filter=InputMessagesFilterEmpty(),
min_date=None,
max_date=None,
add_offset=0,
offset_id=0,
limit=0,
max_id=0,
min_id=0,
hash=0,
from_id=user.id))
except ChatAdminRequiredError:
await event.edit(msgRep.NO_ADMIN)
return
except InputUserDeactivatedError:
await event.edit(msgRep.CANNOT_COUNT_DEL)
return
except SearchQueryEmptyError as sqee:
log.warning(sqee)
await event.edit(msgRep.CANNOT_COUNT_FWD)
return
except Exception as e:
log.warning(e)
await event.edit(msgRep.FAIL_COUNT_MSG)
return
user_link = ("@" + user.username if user.username else
f"[{user.first_name}](tg://user?id={user.id})")
if hasattr(msg_info, "count"):
if remote:
await event.edit(
msgRep.USER_HAS_SENT_REMOTE.format(user_link, msg_info.count,
chat.title))
else:
await event.edit(
msgRep.USER_HAS_SENT.format(user_link, msg_info.count))
else:
if remote:
await event.edit(msgRep.CANNOT_COUNT_MSG_REMOTE.format(chat.title))
else:
await event.edit(msgRep.CANNOT_COUNT_MSG)
return
async def countmessages(event):
user = await fetch_entity(event)
chat = await event.get_chat()
if not user:
return
if not chat:
await event.edit(msgRep.FAIL_CHAT)
return
if not isinstance(user, (Channel, User)):
await event.edit(msgRep.CHANNEL_PERSONS_ONLY)
return
try:
msg_info = await event.client(
SearchRequest(
peer=chat.id,
q="", # search for any message
filter=InputMessagesFilterEmpty(),
min_date=None,
max_date=None,
add_offset=0,
offset_id=0,
limit=0,
max_id=0,
min_id=0,
hash=0,
from_id=user.id))
except ChatAdminRequiredError:
await event.edit(msgRep.NO_ADMIN)
return
except InputUserDeactivatedError:
await event.edit(msgRep.CANNOT_COUNT_DEL)
return
except SearchQueryEmptyError as sqee:
log.warning(sqee)
await event.edit(msgRep.CANNOT_QUERY_FWD)
return
except Exception as e:
log.warning(e)
await event.edit(msgRep.FAIL_COUNT_MSG)
return
if isinstance(user, Channel):
name = user.title
else:
name = f"[{user.first_name}](tg://user?id={user.id})"
user_link = "@" + user.username if user.username else name
if hasattr(msg_info, "count"):
await event.edit(msgRep.USER_HAS_SENT.format(user_link,
msg_info.count))
else:
await event.edit(msgRep.CANNOT_COUNT_MSG)
return
def get_messages(self,
peer_id: int,
peer_hash: str,
up_to_date,
limit: int = 100,
offset_id: int = 0,
max_id: int = 0,
min_id: int = 0) -> object:
"""
Collecting messages from defined chat peer(s) until provided date
"""
logging.info(f'Getting messages from peer {peer_id} '
f'until the date {up_to_date}...')
add_offset = 0
messages = list()
while True:
time.sleep(0.1)
search_result = self.telegram_client(
SearchRequest(peer=InputPeerChannel(peer_id, peer_hash),
q='',
filter=InputMessagesFilterEmpty(),
min_date=None,
max_date=None,
offset_id=offset_id,
add_offset=add_offset,
limit=limit,
max_id=max_id,
min_id=min_id,
from_id=None,
hash=0))
if search_result.messages:
logging.info(
f'Received: {len(search_result.messages)} messages. Offset: {add_offset}.'
)
for post in search_result.messages:
if post.date.replace(tzinfo=None) > up_to_date:
messages.extend([post])
add_offset += 1
else:
return messages
else:
logging.info("It's stopped because met end of chat")
return messages
def search(text, count=100, mes_author=None, mes_type=None):
count = int(count)
re_count = count + 0
messages = []
for chat in CHATS:
# print('!1', chat)
count = re_count + 0
offset = 0
while True:
count_new = 100 if not count else min(100, count)
# messages_new = client(SearchGlobalRequest(
# q=text,
# offset_date=datetime.datetime.now(),
# offset_peer=InputPeerChannel(**chat), # InputPeerEmpty(),
# offset_id=offset,
# limit=count_new,
# )).messages
try:
messages_new = client(SearchRequest(
peer=chat['channel_id'],
q=text,
filter=InputMessagesFilterEmpty(),
min_date=datetime.datetime(2017, 1, 1),
max_date=datetime.datetime(2019, 12, 30),
offset_id=offset,
add_offset=0,
max_id=0,
min_id=0,
hash=0, # chat['access_hash'],
limit=count_new,
)).messages
except:
break
messages.extend(messages_new)
if count:
count -= count_new
if len(messages_new) < 100 or count == 0:
break
offset += 100
return messages
def get_messages(client,
peer_id: Union[Channel],
peer_hash: str,
delete_up_to_date,
limit: int = 100,
offset_id: int = 0,
max_id: int = 0,
min_id: int = 0) -> List[int]:
print(
f'[INFO] Getting messages from peer {peer_id} for user '
f'{client.get_me().username or client.get_me().first_name} until the date {delete_up_to_date}...'
)
add_offset = 0
messages: List[int] = []
while True:
time.sleep(0.1)
search_result = client(
SearchRequest(peer=InputPeerChannel(peer_id, peer_hash),
q='',
filter=InputMessagesFilterEmpty(),
min_date=None,
max_date=None,
offset_id=offset_id,
add_offset=add_offset,
limit=limit,
max_id=max_id,
min_id=min_id,
from_id=InputUserSelf(),
hash=0))
if search_result.messages:
print(
f'[INFO] Received: {len(search_result.messages)} messages. Offset: {add_offset}.'
)
for post in search_result.messages:
if post.date.replace(tzinfo=None) > delete_up_to_date:
messages.extend([post])
add_offset += 1
else:
return messages
else:
print("[INFO] It's stopped because met end of chat.")
return messages
def history_function(chat_name, list_of_queries, min_date, limit):
filter = InputMessagesFilterEmpty()
for query in list_of_queries:
result = client(
SearchRequest(
peer=chat_name, # On which chat/conversation
q=query, # What to search for
filter=filter, # Filter to use (maybe filter for media)
min_date=min_date, # Unix time
max_date=None, # Maximum date
offset_id=0, # ID of the message to use as offset
add_offset=0, # Additional offset
limit=limit, # How many results
max_id=0, # Maximum message ID
min_id=0, # Minimum message ID
from_id=None # Who must have sent the message (peer)
))
#print(result.messages[0].message)
print(result.messages)
async def __get_messages(
self,
entity: hints.Entity,
limit: int = 100,
offset_id: int = 0,
max_id: int = 0,
min_id: int = 0,
) -> List[Any]:
print_header(f"Getting messages from {self.__display_name}...")
add_offset = 0
messages: List[Any] = []
while True:
result = await self(
SearchRequest(
peer=entity,
q="",
filter=InputMessagesFilterEmpty(),
min_date=None,
max_date=None,
offset_id=offset_id,
add_offset=add_offset,
limit=limit,
max_id=max_id,
min_id=min_id,
from_id=InputUserSelf(),
hash=0,
))
if result.messages:
print(
f"Received: {len(result.messages)} messages. Offset: {add_offset}."
)
messages.extend(result.messages)
add_offset += len(result.messages)
sleep(1)
else:
print("It's finished because it met end of chat.")
return messages
async def searchItems(itemList, channelList, limit=100000):
'''
Research of all items in all channels since _days_ before
'''
# Retrive messages that are already being forwarded to the
# _forward_channel_
messagesList = await getMessages()
for channel in channelList:
for item in itemList:
result = await client(SearchRequest(
peer=channel.id, # On which chat/conversation
q=item, # What to search for
filter=InputMessagesFilterEmpty(), # Filter to use (maybe filter for media)
min_date=days, # Minimum date
max_date=0, # Maximum date
offset_id=0, # ID of the message to use as offset
add_offset=0, # Additional offset
limit=limit, # How many results
max_id=0, # Maximum message ID
min_id=0, # Minimum message ID
# from_id=None # Who must have sent the message (peer)
hash=0
))
if result.count > 0:
for msgs in result.messages:
# if message id and channel id are different from the ones in
# the forward channel message list then forward the new
# search result
if str(channel.id)[4:] + "|" + str(msgs.id) not in messagesList:
print(str(channel.id)[4:] + "|" + str(msgs.id))
await client.forward_messages(
entity=await getForwardEntityId(forward_channel),
from_peer=await client.get_entity(channel.id),
messages=msgs.id)
# update messagelist adding the new message to the
# existing list.
messagesList = await getMessages()
def searchMessage(self, msg, acervo, target, string):
bot = self.bot
sendReply = self.msg_reply
link = "https://t.me/" + acervo[1:] + "/"
filter = InputMessagesFilterEmpty()
result = bot(
SearchRequest(peer=acervo,
q=string,
filter=filter,
min_date=None,
max_date=None,
offset_id=0,
add_offset=0,
limit=100,
max_id=0,
min_id=0,
from_id=None,
hash=0))
payload = ''
for i in range(len(result.messages)):
try:
pdf_file = result.messages[i]
file_name = pdf_file.media.document.attributes[0].file_name
file_link = link + str(pdf_file.id)
# example: [ [file_name](file_link) (file_data) ]
payload += "[{0}]({1})\n".format(file_name, file_link)
except Exception as error:
pass
if payload:
banner = "RESULTADOS PARA \"{0}\"".format(string)
banner = "**{0}**\n{1}\n".format(banner, (len(banner) * "="))
payload = banner + payload
sendReply(msg, payload, target)
else:
sendReply(msg, "Nenhum resultado foi encontrado.", target)
async def _search_messages_async(self, chat, query, slow, limit, user, output):
_filter = InputMessagesFilterEmpty()
peer = await self._client.get_entity(chat)
if user is not None:
user = await self._client.get_entity(user)
self._set_file_handler('search_messages', peer, user, query)
if slow:
if output == 'channel':
result = await self._client(CreateChannelRequest(
"Search Messages",
"Messages in {}".format(peer.title)))
output = result.chats[0]
self._logger.info("Channel: {} created.".format(output.title))
await self._iter_messages_async(peer, user, query, output)
else:
search_request = SearchRequest(
peer=peer,
q=query,
filter=_filter,
min_date=None,
max_date=None,
offset_id=0,
add_offset=0,
limit=limit,
max_id=0,
min_id=0,
hash=0,
from_id=user)
result = await self._client(search_request)
for msg in result.messages:
sender = user
if sender is None:
sender = await self._client.get_entity(msg.from_id)
self._log_message(msg, peer, sender)
def search_messages(client, chat, min_id):
# option 1: get all messages and filter them here
# messages = client.iter_messages(fk_entity)
# messages = client.get_messages('MezCollectorBot')
# option 2: get filtered messages from there
result = client(
SearchRequest(
peer=chat, # On which chat/conversation
q=MEZ_BEGIN, # What to search for
filter=InputMessagesFilterEmpty(
), # Filter to use (maybe filter for media)
min_date=date(2019, 8, 1), # Minimum date
max_date=None, # Maximum date
offset_id=0, # ID of the message to use as offset
add_offset=0, # Additional offset
limit=1000, # How many results
max_id=0, # Maximum message ID
min_id=min_id, # Minimum message ID
from_id=None, # Who must have sent the message (peer)
hash=0 # Special number to return nothing on no-change
))
return result
async def topusers(event):
""" For .topusers, lists the top active members in a chat. """
if not event.text[0].isalpha() and event.text[0] in ("."):
arg = event.pattern_match.group(1)
chat = None
try:
arg = int(arg)
except:
pass
if not arg and not hasattr(event.message.to_id, "channel_id"):
await event.edit("`Nope, it works with channels and groups only.`")
return
if not arg:
arg = event.chat_id
try:
chat = await event.client.get_entity(arg)
except Exception as e:
print("Exception:", e)
await event.edit("`Failed to get chat`")
return
chat_id = chat.id
chat_name = chat.title
users = {}
count = 0
await event.edit(
"`Picking the most active members. This might take up some time...`"
)
try:
async for user in event.client.iter_participants(chat_id):
# counting messages from deleted users would trigger InputUserDeactivatedError exception,
# so skip them.
if not user.deleted:
name = "@" + user.username if user.username else f"[{user.first_name}](tg://user?id={user.id})"
if not name in users.keys():
msg_info = await event.client(
SearchRequest(
peer=chat_id,
q="", # search for any message
filter=InputMessagesFilterEmpty(),
min_date=None,
max_date=None,
add_offset=0,
offset_id=0,
limit=0,
max_id=0,
min_id=0,
hash=0,
from_id=user.id))
users[name] = msg_info.count # add new key
count = len(users.keys()) if len(users.keys()) < 10 else 10
# sort the dictionary by highest value and limit it to 10 keys or lower
users = {
key: value
for key, value in sorted(users.items(),
key=lambda item: item[1],
reverse=True)[:count]
}
except ChatAdminRequiredError as care:
print("ChatAdminRequiredError:", care)
await event.edit("`Admin privileges are required!`")
return
except Exception as e: # for all other cases
print("Exception:", e)
await event.edit("`Failed to pick the most active members`")
return
text = "Top **{}** active members in **{}**:\n\n".format(
count, chat_name)
count = 1
for key, value in users.items():
text += "{}. {}: `{}` Messages\n".format(count, key, value)
count += 1
await event.edit(text)
return
async def countmessages(event):
""" For .count, counts the total amount of messages from a certain user has sent in a chat. """
if not event.text[0].isalpha() and event.text[0] in ("."):
if not hasattr(event.message.to_id, "channel_id"):
await event.edit("`Nope, it works in a channel or group only.`")
return
if event.reply_to_msg_id:
message = await event.get_reply_message()
user_id = message.sender.id if message.sender else None
username = message.sender.username if message.sender and message.sender.username is not None else None
first_name = message.sender.first_name if message.sender and message.sender.first_name is not None else None
else:
arg = event.pattern_match.group(1)
user = None
if arg.isnumeric():
arg = int(arg)
if not arg:
user = await event.client.get_me()
else:
try:
user = await event.client.get_entity(arg)
except Exception as e:
print("Exception:", e)
await event.edit("`Failed to get user`")
return
user_id = user.id
username = user.username if user.username is not None else None
first_name = user.first_name if user.first_name is not None else None
try:
msg_info = await event.client(
SearchRequest(
peer=event.chat_id,
q="", # search for any message
filter=InputMessagesFilterEmpty(),
min_date=None,
max_date=None,
add_offset=0,
offset_id=0,
limit=0,
max_id=0,
min_id=0,
hash=0,
from_id=user_id))
except ChatAdminRequiredError as care:
print("ChatAdminRequiredError:", care)
await event.edit("`Admin privileges are required!`")
return
except InputUserDeactivatedError as iude:
print("InputUserDeactivatedError:", iude)
await event.edit("`Can't count messages from a deleted user.`")
return
except SearchQueryEmptyError as sqee:
print("SearchQueryEmptyError:", sqee)
await event.edit("`Can't query forwarded messages from a channel.`"
)
return
except Exception as e: # for all other cases
print("Exception:", e)
await event.edit("`Failed to count messages`")
return
name = "@" + username if username else f"[{first_name}](tg://user?id={user_id})"
if hasattr(msg_info, "count"):
await event.edit(
f"{name} has sent `{msg_info.count}` messages in this chat")
else:
await event.edit("`Can't count messages in this chat!`")
return
from telethon import TelegramClient
app_id = 237708
app_hash = '500d225c06f5427ac74c38c69fb24686'
phone_number = '+8613020305798'
client = TelegramClient('zhangzhicong', app_id, app_hash)
client.start()
from telethon.tl.functions.messages import SearchRequest
from telethon.tl.types import InputMessagesFilterEmpty
filter = InputMessagesFilterEmpty()
result = client(SearchRequest(
peer=1116410516, # On which chat/conversation
q='', # What to search for
filter=filter, # Filter to use (maybe filter for media)
min_date=None, # Minimum date
max_date=None, # Maximum date
offset_id=0, # ID of the message to use as offset
add_offset=0, # Additional offset
limit=10, # How many results
max_id=0, # Maximum message ID
min_id=0, # Minimum message ID
from_id=557106529, # Who must have sent the message (peer)
hash=0 # Special number to return nothing on no-change
))
#print(result.to_dict()['messages'][0]['message'].encode('utf-8'))
print('count: '+str(len(result.to_dict()['messages'])))
for item in result.to_dict()['messages']:
print(item['message'])
def searchTelegram(self,ruleId,string):
f=open("/var/log/modosint/analyzer-telegram/cache.txt", 'a+')
repeated = False
filter = InputMessagesFilterEmpty()
try:
result = self.client(SearchRequest(
peer=self.chat, # On which chat/conversation
q=self.search, # What to search for
filter=filter, # Filter to use (maybe filter for media)
min_date=None, # Minimum date
max_date=None, # Maximum date
offset_id=0, # ID of the message to use as offset
add_offset=0, # Additional offset
limit=int(self.num), # How many results
max_id=0, # Maximum message ID
min_id=0 # Minimum message ID
))
except ValueError:
print('Search do not match with rule... Continue working...')
archivo1 = open("/var/log/modosint/analyzer-telegram/result.txt", "w" , encoding='utf8')
os.chmod("/var/log/modosint/analyzer-telegram/result.txt",0o777)
archivo1.write(str(result).replace('"', "'"))
archivo1.close()
archivo=open("/var/log/modosint/analyzer-telegram/result.txt", "r" , encoding='utf8')
resultMessages=archivo.readlines()
archivo.close()
y=1
for x in range(0,50):
try:
try:
messageid = resultMessages[0].split("Message(id=")[x+1].split(", ")[0].strip()
except Exception as e:
messageid = resultMessages[0].split("True, id=")[x+1].split(", ")[0].strip()
f.seek(0) #read temporary file correctly
content = f.readlines()
content = [x.strip('\n').strip('u') for x in content]
for i in range(len(content)):
if messageid in content:
repeated=True
else:
repeated=False
if repeated==False:
title = resultMessages[0].split("title='")[x+1].split("', ")[0]
try:
body = resultMessages[0].split("description='")[x+1].split("', ")[0]
except IndexError:
body = None
try:
url = resultMessages[0].split("display_url='")[x+1].split("', ")[0]
url = "http://" + url
except IndexError:
url = None
try:
created = resultMessages[0].split("date=datetime.utcfromtimestamp")[y].split(", ")[0]
y = y + 2
created = created.split("(")[1].split(")")[0]
created = datetime.datetime.fromtimestamp(int(created)).strftime('%Y-%m-%d %H:%M:%S')
except IndexError:
created = None
views = resultMessages[0].split("views=")[x+1].split(", ")[0]
try:
sitename= resultMessages[0].split("site_name=")[x+1].split(", ")[0]
except IndexError:
sitename = None
f.seek(0, 2) #write temporary file correctly
f.write(messageid + '\n')
telegramdata = {
"MessageId": messageid,
"TitleMessage": title,
"URL": url,
"CreatedTime": created,
"MessageViews": views,
"SiteName": sitename,
"short_message": body,
"Chat": self.chat,
"full_message": "Telegram matched with WORD: " + self.search
}
fichero = open("/var/log/modosint/analyzer-telegram/graylog.txt", "+a")
autotelegram = json.dumps(telegramdata)
fichero.write(autotelegram + '\n')
os.chmod("/var/log/modosint/analyzer-telegram/graylog.txt",0o777)
self.wcloud.write(str(telegramdata['short_message'])+'\n')
os.chmod("/var/log/modosint/analyzer-telegram/wcloudRule"+ruleId+"-"+self.search+".txt",0o777)
except IndexError:
error=True