async def stats_handler(event):
global guilds_str
text = event.message.message if hasattr(event.message,
'message') else event.message.text
chat_id = event.message.to_id if hasattr(
event.message, 'to_id') else event.message.chat_id
message_id = event.message.id if hasattr(
event.message, 'id') else event.message.message_id
if ((type(chat_id) == PeerChannel and chat_id in [
PeerChannel(RESULTS_PARSE_CHANNEL_ID), PeerChannel(RESULTS_PARSE_CHANNEL_ID_DEBUG)
]) or chat_id == RESULTS_FORWARD_CHAT_ID) and \
('Результаты сражений:' in text or '⛺️Гильдия' in text or '⛺Гильдия' in text or "Headquarters" in text or
"🗺State of map" in text):
debug = type(chat_id) == PeerChannel and chat_id == PeerChannel(
RESULTS_PARSE_CHANNEL_ID_DEBUG)
logging.error("Received data from telegram, sending: {}".format(text))
if '⛺️Гильдия' in text:
guilds_str += text + "\n"
logging.info("Adding text to guilds_str = {}".format(guilds_str))
else:
print("put stats in queue")
castles_stats_queue.put({
"data": text,
"message_id": message_id,
"debug": debug
})
castles_stats_queue.put({"data": guilds_str, "debug": debug})
guilds_str = ""
return
elif chat_id == CHAT_WARS_ID and "🏆 очков" in text and "Past battles:" in text:
logging.info("Received /worldtop")
castles_stats_queue.put({"data": text, "type": "worldtop"})
def __init__(
self,
session_name: str,
api_id: int, api_hash: str, phone: str,
chat_id: int = None, channel_id: int = None,
bot_tk: str = None,
commands: dict = None,
passthrough: dict = None
):
self.me = None
self.session_name = session_name
self.api_id = api_id
self.api_hash = api_hash
self.bot_tk = bot_tk
self.phone = phone
self.chat_id = None
self.channel_id = None
self.client = None
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
if chat_id:
self.chat_id = PeerChannel(chat_id)
if channel_id:
self.channel_id = PeerChannel(channel_id)
self.client = self.get_telegram_client()
TeleBtn._telewrapper = self
TeleMsgTemplate.commands = commands
self.passthrough = passthrough
async def report(client: Client, chat: Channel, msg: Message, args, kwargs,
event):
config = Config()
sw_report = kwargs.get('sw', False)
if msg.is_reply:
reply: Message = await msg.get_reply_message()
result = await reply.forward_to(-1001187874753)
if sw_report:
client2: TelegramClient = TelegramClient('reporter',
api_id=config.api_id,
api_hash=config.api_hash)
await client2.connect()
if not await client2.is_user_authorized():
await client2.start(config.phone_reporter)
async with client2:
await client2.get_dialogs()
reported = await client2.forward_messages(
messages=result.id,
from_peer=PeerChannel(channel_id=1187874753),
entity=PeerChannel(channel_id=1251251585))
print(reported)
else:
return
def get_dest_channel(self, owner_client, client, channel_id, sources):
"""
:param sources:
:param TelegramClient owner_client:
:param TelegramClient client:
:param int channel_id:
:return: Channel
"""
try:
channel = client.get_entity(PeerChannel(channel_id))
if channel.admin_rights is None or not channel.admin_rights.post_messages or not channel.admin_rights.invite_link:
owner_channel = owner_client.get_entity(
PeerChannel(channel_id))
sender = client.get_me()
self.set_admin(owner_client, sender, owner_channel)
return channel
except (ValueError, ChannelPrivateError):
owner_channel = owner_client.get_entity(PeerChannel(channel_id))
inv = owner_client(ExportInviteRequest(owner_channel))
client(ImportChatInviteRequest(inv.link.split('/')[-1]))
channel = client.get_entity(PeerChannel(channel_id))
sender = client.get_me()
self.set_admin(owner_client, sender, owner_channel)
return channel
def my_event_handler(update):
if (update.message.message):
# channel id
channel_id = update.message.to_id.channel_id
# channel name
channel_name = client.get_entity(
PeerChannel(update.message.to_id.channel_id)).username
# channel message Date
date_message = update.message.date
# channel message
message = update.message.message
# print(channel_name,"-----",channel_id,"------",date_message,"-----",message)
if (channel_id in channel_lists):
client.send_message(PeerChannel(1194529271), message)
def update_handler(update):
try:
message = update.message
messages = []
if isinstance(update, UpdateShortMessage):
sender = client.get_entity(PeerUser(update.user_id))
messages.append(update.id)
elif isinstance(update, UpdateNewChannelMessage):
sender = client.get_entity(
PeerChannel(update.message.to_id.channel_id))
# print(update.message.id)
messages.append(update.message.id)
elif isinstance(update, UpdateEditChannelMessage):
pass
else:
# print(type(update))
# print(update)
return False
except Exception as e:
# print(e)
return
try:
client(
ForwardMessagesRequest(
from_peer=sender, # who sent these messages?
id=messages, # which are the messages?
to_peer=InputPeerSelf() # who are we forwarding them to?
))
print("FORWARD")
# print(get_text(update))
except Exception as e:
print("EXCEPTION")
print(get_text(update))
print(e)
def run(self):
database = Database()
client = TelegramClient('session_name', local.api_id, local.api_hash)
client.start()
add_notification = (
"INSERT INTO coin_notification (id, message, date) VALUES (%(notification_id)s, %(notification_message)s, %(notification_date)s)"
)
cursor = database.query("select max(id) as mx from coin_notification")
last_db_id = 0
for mx in cursor:
last_db_id = mx[0]
regex = r'[^a-zA-Z0-9.()%/#]+'
channel = PeerChannel(channel_id=1131948783)
while True:
messages = client.get_messages(channel,
min_id=last_db_id,
limit=1000)
if len(messages) == 0:
break
for m in messages:
m.message = re.sub(regex, ' ', m.message)
notification = {
'notification_id': m.id,
'notification_message': m.message.encode('utf8'),
'notification_date': m.date
}
database.execute(add_notification, notification)
database.close()
async def stats_handler(event):
text = event.message.message
if event.message.to_id == PeerChannel(
RESULTS_PARSE_CHANNEL_ID) and 'Результаты сражений:' in text:
print("put stats in queue")
castles_stats_queue.put(text)
return
async def check_access(event):
participants = await bot.get_participants(PeerChannel(chat_id))
participants_id = [user.id for user in participants]
if event.sender.id in participants_id:
return True
else:
await bot.send_message(event.sender, 'Отказано в доступе.')
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
async def get_channel_user_count(self, channel):
data = await self.client.get_entity(PeerChannel(-channel))
try:
users = await self.client.get_participants(data)
return users.total
except ChatAdminRequiredError:
return -1
def add_user_by_id(client, user_id, channel_id=DEFAULT_CHANNEL):
try:
# client.invoke(InviteToChannelRequest(get_input_peer(channel), [get_input_peer(user)]))
# client.invoke(InviteToChannelRequest(
# # InputChannel(get_input_peer(user.chats[0]).channel_id, get_input_peer(user.chats[0]).access_hash),
# InputChannel(channel.id, channel.access_hash),
# [InputUser(get_input_peer(user.users[0]).user_id, get_input_peer(user.users[0]).access_hash)]
# ))
# client.invoke(InviteToChannelRequest(InputChannel(channel.id, channel.access_hash), [InputUser(get_input_peer(user.users[0]).user_id, get_input_peer(user.users[0]).access_hash)]))
# client.invoke(InviteToChannelRequest(client.get_entity(PeerChannel(1188959006)), [user]))
# client.invoke(InviteToChannelRequest(client.get_input_entity(PeerChannel(channel_id)), [client.get_input_entity(PeerUser(user_id=user.users[0].id))]))
user_entity = client.get_input_entity(PeerUser(user_id))
channel_entity = client.get_entity(PeerChannel(channel_id=int(channel_id)))
client.invoke(InviteToChannelRequest(channel_entity, [user_entity]))
log.warning("Added User: {} to Channel: {}".format(user_id, channel_id))
return "User added successfully"
except Exception as err:
reason = err.args[1] if len(err.args) > 1 else err.message
msg = "Add User {} attempt to channel ({}) failed [{}]".format(user_id, channel_id, reason)
log.error(msg)
log.error(err)
return msg
async def main():
# Create the client and connect
client = TelegramClient(USERNAME, API_ID, API_HASH)
await client.start()
print("Client Created")
# Ensure you're authorized
if not await client.is_user_authorized():
await client.send_code_request(PHONE)
try:
await client.sign_in(PHONE, input('Enter the code: '))
except errors.SessionPasswordNeededError:
await client.sign_in(password=input('Password: '******'getting forwards for channel {username}\n')
with open(os.path.join(MSG_INPUT_DIR, username), 'rb') as f:
messages = pickle.load(f)
forward_list = list()
for message in messages:
try:
channel_id = message['fwd_from']['from_id']['channel_id']
forward_channel = await client.get_entity(
PeerChannel(channel_id))
forward_username = forward_channel.username
print(username, forward_username)
if forward_channel is not None:
forward_list.append(forward_username)
except:
pass
print(f'forwards from {username}: {dict( Counter( forward_list ))}')
user_connection_dict = dict(Counter(forward_list))
with open(os.path.join(OUTPUT_CONNECTION_DIR, f'{username}.pkl'),
'wb') as f:
pickle.dump(user_connection_dict, f)
connection_dict[username] = user_connection_dict
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 normal_handler(event):
post = WordPressPost()
msg = event.message.to_dict()
fwd_channel_name = (await client.get_entity(
PeerChannel(msg['fwd_from']['channel_id']))).username
title, content = tit_le(msg)
post.title = '@' + fwd_channel_name + ': ' + title
post.content = content
post.id = wp.call(posts.NewPost(post))
post.post_status = 'publish'
# add image
# set to the path to your file
try:
filename = (await event.message.download_media())
data = {
'name': 'picture.jpg',
'type': 'image/jpeg', # mimetype
}
with open(filename, 'rb') as img:
data['bits'] = xmlrpc_client.Binary(img.read())
response = wp.call(media.UploadFile(data))
attachment_id = response['id']
post.thumbnail = attachment_id
# delete pictures
remove(filename)
except:
print("with out pictures")
wp.call(posts.EditPost(post.id, post))
def update_handler(update):
print(type(update))
print(update)
print("------------------")
if isinstance(update, UpdateNewChannelMessage):
# message_from = client.get_entity(PeerChannel(update.message.to_id))
# print("From: "+str(update.message.to_id))
try:
for peer_from in peers_from:
if update.message.to_id.channel_id != peer_from.channel_id:
continue
if "http" in str(update.message.message) or "https" in str(
update.message.message):
continue
peer_to = client.get_input_entity(
PeerChannel(CHANNEL_TO.id))
print("Message comming from channel id: " +
str(update.message.to_id.channel_id))
print("To: " + str(peer_from.channel_id))
print("From: " + str(peer_to.channel_id))
print("########\nMessage:")
print(str(update.message.message))
print("########\nMessage id:")
print(str(update.message.id))
print("########:")
client(
ForwardMessagesRequest(
from_peer=
peer_from, # who sent these messages or what channel sent in?
id=[update.message.id], # which are the messages?
to_peer=
peer_to # who or what channel are we forwarding them to?
))
except Exception as ex:
print("Error: " + str(ex))
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)
def get_channel(self, client, channel_id):
"""
:param TelegramClient client:
:param int channel_id:
:return:
"""
return client.get_entity(PeerChannel(channel_id))
def callbackUpdate(update):
channel_name = client.get_entity(PeerChannel(update.message.to_id.channel_id)).username
if (update.message.message ==''):
if (channel_name == 'bigpumpsignal'): #name of the telegram channel
str_date='output'
client.download_media(update.message,str_date)
print("Image downloaded!")
client.disconnect()
async def _poll_pinned_msg(self):
client = self._client
logger = get_logger()
channel_entity = await client.get_entity(PeerChannel(self._CHANNEL_ID))
channel_info = await client(GetFullChannelRequest(channel_entity))
pinned_msg_id = channel_info.full_chat.pinned_msg_id
logger.debug("channel info", pinned_msg_id=pinned_msg_id)
return pinned_msg_id
async def main(phone):
await client.start()
print("Client Created")
# Check whether the authentication has been done or not?
if await client.is_user_authorized() == False:
await client.send_code_request(phone)
try:
await client.sign_in(phone, input('Enter the code: '))
except SessionPasswordNeededError:
await client.sign_in(password=input('Password: '******'confirmedChannelsList.txt', 'r')
for channel in channelLis:
if channel.isdigit():
entity = PeerChannel(int(channel))
else:
entity = channel
my_channel = await client.get_entity(entity)
print(str(channel))
offset_id = 0
limit = 1
all_messages = []
total_messages = 0
total_count_limit = 0
while True:
print("Current Offset ID is:", offset_id, "; Total Messages:",
total_messages)
history = await client(
functions.messages.SearchRequest(
peer=my_channel,
q='کرونا',
filter=types.InputMessagesFilterEmpty(),
# limited date because Covid-19 is a new problem
min_date=datetime(2019, 7, 1),
max_date=datetime(2020, 3, 30),
offset_id=offset_id,
add_offset=0,
limit=limit,
max_id=0,
min_id=0,
hash=0,
))
if not history.messages:
break
messages = history.messages
for message in messages:
all_messages.append(message.to_dict())
offset_id = messages[len(messages) - 1].id
total_messages = len(all_messages)
if total_count_limit != 0 and total_messages >= total_count_limit:
break
with open('FakesMessage.json', 'a') as outfile:
json.dump(all_messages, outfile, cls=DateTimeEncoder)
async def stats_handler(event):
global guilds_str
text = event.message.message
if event.message.to_id in [PeerChannel(RESULTS_PARSE_CHANNEL_ID), PeerChannel(RESULTS_PARSE_CHANNEL_ID_DEBUG)] and \
('Результаты сражений:' in text or '⛺️Гильдия' in text or '⛺Гильдия' in text or "Headquarters" in text or
"🗺State of map" in text):
debug = event.message.to_id == PeerChannel(
RESULTS_PARSE_CHANNEL_ID_DEBUG)
logging.error("Received data from telegram, sending: {}".format(text))
if '⛺️Гильдия' in text:
guilds_str += text + "\n"
logging.info("Adding text to guilds_str = {}".format(guilds_str))
else:
print("put stats in queue")
castles_stats_queue.put({"data": text, "debug": debug})
castles_stats_queue.put({"data": guilds_str, "debug": debug})
guilds_str = ""
return
async def _add_forward_header(source: 'AbstractUser', content: TextMessageEventContent,
fwd_from: MessageFwdHeader) -> None:
if not content.formatted_body or content.format != Format.HTML:
content.format = Format.HTML
content.formatted_body = escape(content.body)
fwd_from_html, fwd_from_text = None, None
if fwd_from.from_id:
user = u.User.get_by_tgid(TelegramID(fwd_from.from_id))
if user:
fwd_from_text = user.displayname or user.mxid
fwd_from_html = (f"<a href='https://matrix.to/#/{user.mxid}'>"
f"{escape(fwd_from_text)}</a>")
if not fwd_from_text:
puppet = pu.Puppet.get(TelegramID(fwd_from.from_id), create=False)
if puppet and puppet.displayname:
fwd_from_text = puppet.displayname or puppet.mxid
fwd_from_html = (f"<a href='https://matrix.to/#/{puppet.mxid}'>"
f"{escape(fwd_from_text)}</a>")
if not fwd_from_text:
try:
user = await source.client.get_entity(PeerUser(fwd_from.from_id))
if user:
fwd_from_text = pu.Puppet.get_displayname(user, False)
fwd_from_html = f"<b>{escape(fwd_from_text)}</b>"
except ValueError:
fwd_from_text = fwd_from_html = "unknown user"
elif fwd_from.channel_id:
portal = po.Portal.get_by_tgid(TelegramID(fwd_from.channel_id))
if portal:
fwd_from_text = portal.title
if portal.alias:
fwd_from_html = (f"<a href='https://matrix.to/#/{portal.alias}'>"
f"{escape(fwd_from_text)}</a>")
else:
fwd_from_html = f"channel <b>{escape(fwd_from_text)}</b>"
else:
try:
channel = await source.client.get_entity(PeerChannel(fwd_from.channel_id))
if channel:
fwd_from_text = f"channel {channel.title}"
fwd_from_html = f"channel <b>{escape(channel.title)}</b>"
except ValueError:
fwd_from_text = fwd_from_html = "unknown channel"
elif fwd_from.from_name:
fwd_from_text = fwd_from.from_name
fwd_from_html = f"<b>{escape(fwd_from.from_name)}</b>"
else:
fwd_from_text = "unknown source"
fwd_from_html = f"unknown source"
content.body = "\n".join([f"> {line}" for line in content.body.split("\n")])
content.body = f"Forwarded from {fwd_from_text}:\n{content.body}"
content.formatted_body = (
f"Forwarded message from {fwd_from_html}<br/>"
f"<tg-forward><blockquote>{content.formatted_body}</blockquote></tg-forward>")
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)
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, 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, 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_dest_channel_old(self, owner_client, client, channel_id, sources):
"""
:param sources:
:param TelegramClient owner_client:
:param TelegramClient client:
:param int channel_id:
:return: Channel
"""
try:
channel = client.get_entity(PeerChannel(channel_id))
print("get_dest_channel 1 channel:", channel)
exit(1)
client(ExportInviteRequest(channel))
# try:
# client(EditAboutRequest(channel, self.get_about(sources)))
# except Exception as e:
# print("error:", e)
# pass
# todo:: check the owner is in the channel members
# todo:: check members count
# todo:: set list of sources to the about
return channel
except (ValueError, ChannelPrivateError) as e:
owner_channel = owner_client.get_entity(PeerChannel(channel_id))
inv = owner_client(ExportInviteRequest(owner_channel))
client(ImportChatInviteRequest(inv.link.split('/')[-1]))
channel = client.get_entity(PeerChannel(channel_id))
print("e:", e)
print("get_dest_channel 2 channel:", channel)
exit(1)
sender = client.get_me()
self.set_admin(owner_client, sender, owner_channel)
return channel
except ChatAdminRequiredError:
owner_channel = owner_client.get_entity(PeerChannel(channel_id))
sender = client.get_me()
self.set_admin(owner_client, sender, owner_channel)
channel = client.get_entity(PeerChannel(channel_id))
print("get_dest_channel 3 channel:", channel)
exit(1)
return channel
async def main(phone, user_input_channel):
'''Asynchronosly ump messages in a channel as json file
:param phone: phone number as string
:param user_input_channel: channel to pull data from, either given as id or name
'''
await client.start()
print("Client Created")
# Ensure you're authorized
if await client.is_user_authorized() == False:
await client.send_code_request(phone)
try:
await client.sign_in(phone, input('Enter the code: '))
except SessionPasswordNeededError:
await client.sign_in(password=input('Password: '******'channel_messages.json', 'w') as outfile:
json.dump(all_messages, outfile, cls=DateTimeEncoder)
async def _build_message(self, msg, keywords, raw_text: str) -> str:
link = ''
if isinstance(msg.peer_id, PeerChannel):
channel = await self._client.get_entity(
PeerChannel(msg.peer_id.channel_id))
link = 'https://t.me/{0}/{1}'.format(channel.username, msg.id)
text = "keywords: " + "\n".join(
[self.decorate_tags(keywords), raw_text, link])
return text
