from telethon import events
from telethon.utils import pack_bot_file_id
from jarvis import CMD_HELP
from jarvis.plugins.sql_helper.welcome_sql import (
add_welcome_setting,
get_current_welcome_settings,
rm_welcome_setting,
update_previous_welcome,
)
from jarvis.utils import admin_cmd
@jarvis.on(events.ChatAction()) # pylint:disable=E0602
async def _(event):
cws = get_current_welcome_settings(event.chat_id)
if cws:
# logger.info(event.stringify())
"""user_added=False,
user_joined=True,
user_left=False,
user_kicked=False,"""
if event.user_joined:
if cws.should_clean_welcome:
try:
await bot.delete_messages( # pylint:disable=E0602
event.chat_id, cws.previous_welcome
)
except Exception as e: # pylint:disable=C0103,W0703
logger.warn(str(e)) # pylint:disable=E0602
a_user = await event.get_user()
def decorator(func):
telethn.add_event_handler(func, events.ChatAction(**args))
return func
c = words.index(word)
link = (
f"t.me/{event.chat.username}/{event.message.id}"
if event.chat.username
else f"Occurred in Private Chat - {event.chat.title}"
)
logmsg = f"""$AUTOSCAN\n**Scanned user:** [{event.from_id.user_id}](tg://user?id={event.from_id.user_id})\n**Reason:** 0x{c}\n**Chat:** {link}\n**Hue Color:** Yellow-green\n**Message:** {event.text}"""
await System.send_message(Sibyl_logs, logmsg)
System.processed += 1
System.processing -= 1
return
System.processed += 1
System.processing -= 1
@System.bot.on(events.ChatAction(func=lambda e: e.user_joined))
async def auto_wlc_gban(event):
System.processing += 1
user = await event.get_user()
if user.id in MANAGERS or user.id in CARDINAL:
return
words = await wlc_collection.get_wlc_bl()
if words:
text = user.first_name
if user.last_name:
text = text + " " + user.last_name
for word in words:
pattern = r"( |^|[^\w])" + word + r"( |$|[^\w])"
if re.search(pattern, text, flags=re.IGNORECASE):
c = words.index(word)
logmsg = f"""$AUTOSCAN\n**Scanned user:** [{user.id}](tg://user?id={user.id})\n**Reason:** 1x{c}\n**User joined and blacklisted string in name**\n**Matched String:** {word}\n"""
# don't log bots
return
if sender.verified:
# don't log verified accounts
return
if not pmpermit_sql.is_approved(chat_id):
# pm permit
await do_pm_permit_action(chat_id, event)
if not no_log_pms_sql.is_approved(chat_id):
# log pms
await do_log_pm_action(chat_id, message_text, message_media)
@borg.on(events.ChatAction(blacklist_chats=Config.UB_BLACK_LIST_CHAT))
async def on_new_chat_action_message(event):
if Config.PM_LOGGR_BOT_API_ID is None:
return
# logger.info(event.stringify())
chat_id = event.chat_id
message_id = event.action_message.id
if event.created or event.user_added:
added_by_users = event.action_message.action.users
if borg.uid in added_by_users:
added_by_user = event.action_message.from_id
# someone added me to chat
the_message = ""
the_message += "#MessageActionChatAddUser\n\n"
the_message += f"[User](tg://user?id={added_by_user}): `{added_by_user}`\n"
for entity in entities:
if isinstance(
entity,
(types.MessageEntityTextUrl, types.MessageEntityUrl)):
is_url = True
if is_url:
try:
await event.delete()
except Exception as e:
await event.reply(
"I don't seem to have ADMIN permission here. \n`{}`".
format(str(e)))
update_lock(peer_id, "url", False)
@WhiteEye.on(events.ChatAction()) # pylint:disable=E0602
async def _(event):
# TODO: exempt admins from locks
# check for "lock" "bots"
if is_locked(event.chat_id, "bots"):
# bots are limited Telegram accounts,
# and cannot join by themselves
if event.user_added:
users_added_by = event.action_message.from_id
is_ban_able = False
rights = types.ChatBannedRights(until_date=None,
view_messages=True)
added_users = event.action_message.action.users
for user_id in added_users:
user_obj = await borg.get_entity(user_id)
if user_obj.bot:
if event.chat_id == Sibyl_logs:
return
text = event.text
words = await db.get_blacklist()
if words:
for word in words:
pattern = r"( |^|[^\w])" + word + r"( |$|[^\w])"
if re.search(pattern, text, flags=re.IGNORECASE):
c = words.index(word)
link = f"t.me/{event.chat.username}/{event.message.id}" if event.chat.username else f"Occurred in Private Chat - {event.chat.title}"
logmsg = f"""$AUTOSCAN\n**Scanned user:** [{event.from_id}](tg://user?id={event.from_id})\n**Reason:** 0x{c}\n**Chat:** {link}\n**Hue Color:** Yellow-green\n**Message:** {event.text}"""
await System.send_message(Sibyl_logs, logmsg)
return
@System.on(events.ChatAction(func=lambda e: e.user_joined)) # pylint:disable=E0602
async def auto_wlc_gban(event):
user = await event.get_user()
if user.id in ENFORCERS or user.id in SIBYL:
return
words = await wlc_collection.get_wlc_bl()
if words:
text = user.first_name
if user.last_name: text = text + " " + user.last_name
for word in words:
pattern = r"( |^|[^\w])" + word + r"( |$|[^\w])"
if re.search(pattern, text, flags=re.IGNORECASE):
c = words.index(word)
logmsg = f"""$AUTOSCAN\n**Scanned user:** [{user.id}](tg://user?id={user.id})\n**Reason:** 1x{c}\n**User joined and blacklisted string in name**\n**Matched String:** {word}\n"""
await System.send_message(Sibyl_logs, logmsg)
await event.reply(beautiful)
else:
await event.reply(beautifuln)
@UltraBot.on(events.NewMessage(func=lambda e: e.is_private))
async def real_nigga(event):
if already_added(event.sender_id):
pass
elif not already_added(event.sender_id):
add_usersid_in_db(event.sender_id)
await UltraBot.send_message(Config.LOG_CHAT,
f"**New User :** `{event.sender_id}`")
@UltraBot.on(events.ChatAction())
async def _(event):
if event.chat_id == Config.LOG_CHAT:
return
okbruh = await UltraBot.get_me()
if event.user_joined or event.user_added == str(okbruh):
lol = event.chat_id
if already_added(event.chat_id):
pass
elif not already_added(event.chat_id):
add_usersid_in_db(event.chat_id)
await UltraBot.send_message(Config.LOG_CHAT,
f"**New ChatGroup :** `{lol}`")
@UltraBot.on(events.NewMessage(pattern="^/start ?(.*)"))
for entity in entities:
if isinstance(
entity,
(types.MessageEntityTextUrl, types.MessageEntityUrl)):
is_url = True
if is_url:
try:
await event.delete()
except Exception as e:
await event.reply(
"I don't seem to have ADMIN permission here. \n`{}`".
format(str(e)))
update_lock(peer_id, "url", False)
@ninjadeep.on(events.ChatAction()) # pylint:disable=E0602
async def _(event):
# TODO: exempt admins from locks
# check for "lock" "bots"
if is_locked(event.chat_id, "bots"):
# bots are limited Telegram accounts,
# and cannot join by themselves
if event.user_added:
users_added_by = event.action_message.from_id
is_ban_able = False
rights = types.ChatBannedRights(until_date=None,
view_messages=True)
added_users = event.action_message.action.users
for user_id in added_users:
user_obj = await borg.get_entity(user_id)
if user_obj.bot:
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()
ENABLE_LOG = True
LOGGING_CHATID = Config.PRIVATE_CHANNEL_BOT_API_ID
BANNED_RIGHTS = ChatBannedRights(
until_date=None,
view_messages=True,
send_messages=True,
send_media=True,
send_stickers=True,
send_gifs=True,
send_games=True,
send_inline=True,
embed_links=True,
)
@borg.on(events.ChatAction(func=lambda e: e.is_group))
async def spam_watch_(event):
chat = await event.get_chat()
if Config.SPAM_WATCHAPI:
client = spamwatch.Client(Config.SPAM_WATCH_API)
user = await event.get_user()
try:
if (chat.admin_rights or chat.creator):
if (event.user_joined or event.user_added):
try:
ban = client.get_ban(event.action_message.from_id)
if ban:
await borg(
EditBannedRequest(event.chat_id,
event.action_message.from_id,
BANNED_RIGHTS))
channel = xchannel.replace("@", "")
# join check
async def get_user_join(id):
ok = True
try:
await BotzHub(GetParticipantRequest(channel=channel, user_id=id))
ok = True
except UserNotParticipantError:
ok = False
return ok
@BotzHub.on(events.ChatAction())
async def _(event):
if on_join is False:
return
if event.user_joined or event.user_added:
user = await event.get_user()
chat = await event.get_chat()
title = chat.title if chat.title else "this chat"
pp = await BotzHub.get_participants(chat)
count = len(pp)
mention = f"[{get_display_name(user)}](tg://user?id={user.id})"
name = user.first_name
last = user.last_name
if last:
fullname = f"{name} {last}"
else:
from telethon.tl.types import InputPeerEmpty
from telethon.tl.types import ChannelAdminLogEventsFilter
from telethon.tl.types import ChannelAdminLogEventActionParticipantJoin
from telethon.tl.types import InputUserSelf
from telethon.tl.types import InputUser
import asyncio
import logging
api_id = 3409046
api_hash = '48ae9fbdf79edda291e1fa5796fc4665'
#phone_number = '+528132341246'
################################################
channel = '@pruebastienda'
@events.register(events.ChatAction(func=lambda e: e.action_message is None))
def chat_action_empty(event: events.ChatAction.Event):
#print(event.stringify())
print('this event')
async def main():
client = TelegramClient('sessionname', api_id, api_hash) # feel free to edit %sessionname% as you want
client.add_event_handler(chat_action_empty)
await client.start()
me = await client.get_me()
#print('Logged in as {} with Telethon version {}'.format(me.username, TelegramClient.__version__))
await client.run_until_disconnected()
asyncio.get_event_loop().run_until_complete(main())
async def handler(event):
# event.input_chat may be None, use event.get_input_chat()
__author__ = 'smailzhu'
parser = ConfigParser()
parser.read('config.ini', encoding='utf-8')
api_id = int(parser.get('api', 'id'))
api_hash = parser.get('api', 'hash')
try:
target_chat = int(parser.get('target', 'chat'))
except Exception:
target_chat = parser.get('target', 'chat')
with TelegramClient('session_name', api_id, api_hash) as client:
chat = client.get_entity(target_chat)
@client.on(events.ChatAction(chats=target_chat))
async def handler(event):
if not event.user_added:
return
from_id = event.action_message.from_id
msg = f"You have been invited by id: `{from_id}` to this spam group, " \
"Please click report button above and forward this message to @HexJudge\n" \
f"您已經被 id: `{from_id}` 給拉入到此騷擾群組，請點擊畫面上方回報來檢舉並轉傳此訊息至 @HexJudge"
await event.reply(msg)
client.start()
client.run_until_disconnected()
client.disconnect()
channel = xchannel.replace("@", "")
# join check
async def get_user_join(id):
ok = True
try:
await coffinx(GetParticipantRequest(channel=channel, user_id=id))
ok = True
except UserNotParticipantError:
ok = False
return ok
@coffinx.on(events.ChatAction())
async def _(event):
if on_join is False:
return
if event.user_joined or event.user_added:
user = await event.get_user()
chat = await event.get_chat()
title = chat.title if chat.title else "this chat"
pp = await BotzHub.get_participants(chat)
count = len(pp)
mention = f"[{get_display_name(user)}](tg://user?id={user.id})"
name = user.first_name
last = user.last_name
if last:
fullname = f"{name} {last}"
else:
from telethon.tl.functions.channels import JoinChannelRequest
from telethon.errors import ChannelPrivateError, ChannelBannedError
# How often to attempt to rejoin
REFETCH_TIME = 90
chat = "@telethonofftopic"
@borg.on(events.NewMessage(chats=chat))
async def last_msg_draft(event):
last_msg = event.id
storage.last_msg = last_msg
@borg.on(events.ChatAction(chats=chat, func=lambda e: e.user_joined))
async def joined(event):
if event.user_id != borg.uid:
return
last_msg = storage.last_msg or 0
await borg(SaveDraftRequest(peer=chat, message="", reply_to_msg_id=last_msg))
async def fetch_chats():
while True:
try:
await borg(JoinChannelRequest(chat))
except (ChannelBannedError, ChannelPrivateError):
logger.info("Still banned")
await sleep(REFETCH_TIME + 60)
await sleep(REFETCH_TIME)
See /help for more info.
"""
from asyncio import sleep
from telethon import events, errors
# /start
@borg.on(borg.cmd(r"start$"))
async def on_start(event):
if event.is_private: # If command was sent in private
await event.respond(__doc__, link_preview=False)
# Reply when added to group
@borg.on(events.ChatAction(func=lambda e: e.user_added and e.is_group))
async def added_to_group(event):
me = (await event.client.get_me()).id
response = None
# Check which users were added to the group,
# if the bot is amongst them, send the message
for u in event.users:
if me == u.id:
response = await event.respond(__doc__, link_preview=False)
if not response:
return
# Delete the message after a minute
await sleep(60)
# Ultroid - UserBot
# Copyright (C) 2021-2022 TeamUltroid
#
# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
# PLease read the GNU Affero General Public License in
# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
from telethon import events
from . import *
@asst.on(events.ChatAction(func=lambda x: x.user_added))
async def dueha(e):
user = await e.get_user()
if not user.is_self:
return
sm = udB.get_key("ON_MNGR_ADD")
if sm == "OFF":
return
if not sm:
sm = "Thanks for Adding me :)"
await e.reply(sm, link_preview=False)
format='[%(levelname) 5s/%(asctime)s] %(name)s: %(message)s',
level=logging.WARNING)
from telethon import events
from telethon.tl.functions.channels import EditBannedRequest
from telethon.tl.types import ChatBannedRights
CHATS_TO_MONITOR_FOR_ADDED_BOTS = [
# add the ID of the groups (Use .get_id command)
# seperated by commas
# usernames also work, but it is pointless,
# since non admin users cannot add bots to
# public groups (Telegram Limitation)
]
@borg.on(events.ChatAction(chats=CHATS_TO_MONITOR_FOR_ADDED_BOTS)) # pylint:disable=E0602
async def kick_if_bots(event):
if event.user_added:
users_added_by = event.action_message.from_id
if users_added_by == borg.uid:
logger.info("Don't BAN yourself")
return False
is_ban_able = False
rights = ChatBannedRights(until_date=None, view_messages=True)
added_users = event.action_message.action.users
for user_id in added_users:
user_obj = await borg.get_entity(user_id)
if user_obj.bot:
is_ban_able = True
try:
# kick the bot
for entity in entities:
if isinstance(
entity,
(types.MessageEntityTextUrl, types.MessageEntityUrl)):
is_url = True
if is_url:
try:
await event.delete()
except Exception as e:
await event.reply(
"I don't seem to have ADMIN permission here. \n`{}`".
format(str(e)))
update_lock(peer_id, "url", False)
@friday.on(events.ChatAction()) # pylint:disable=E0602
async def _(event):
# TODO: exempt admins from locks
# check for "lock" "bots"
if is_locked(event.chat_id, "bots"):
# bots are limited Telegram accounts,
# and cannot join by themselves
if event.user_added:
users_added_by = event.action_message.sender_id
is_ban_able = False
rights = types.ChatBannedRights(until_date=None,
view_messages=True)
added_users = event.action_message.action.users
for user_id in added_users:
user_obj = await borg.get_entity(user_id)
if user_obj.bot:
def save_config():
with open('config.json', 'w', encoding='utf-8') as f:
json.dump(config, f, indent=4)
async def safe_delete_message(bot, delay, *args, **kwarg):
await asyncio.sleep(delay)
try:
await bot(DeleteMessagesRequest(*args, **kwarg))
except errors.BadRequestError: # msg to delete not found
pass
@events.register(events.ChatAction())
async def challenge_user(event):
global config, current_challenges
bot = event.client
chat = event.chat
target = event.user
if event.user_added:
me = await bot.get_me()
if me.id in event.user_ids:
async with config_lock:
group_config = config.get(str(event.chat.id), config['*'])
await event.respond(
message=group_config['msg_self_introduction'])
return None
for entity in entities:
if isinstance(
entity, (types.MessageEntityTextUrl, types.MessageEntityUrl)
):
is_url = True
if is_url:
try:
await event.delete()
except Exception as e:
await event.reply(
"I don't seem to have ADMIN permission here. \n`{}`".format(str(e))
)
update_lock(peer_id, "url", False)
@bot.on(events.ChatAction())
async def _(event):
if not event.is_private:
chat = await event.get_chat()
admin = chat.admin_rights
creator = chat.creator
if not admin and not creator:
return
# check for "lock" "bots"
if not is_locked(event.chat_id, "bots"):
return
# bots are limited Telegram accounts,
# and cannot join by themselves
if event.user_added:
users_added_by = event.action_message.sender_id
is_ban_able = False
await event.reply("**This user is curently banned on this companion and it shouldn't be here**")
rights = ChatBannedRights(
until_date=None,
view_messages=True,
send_messages=True,
send_media=True,
send_stickers=True,
send_gifs=True,
send_games=True,
send_inline=True,
embed_links=True
)
await client(EditBannedRequest(chat.id, user, rights))
@client.on(events.ChatAction(chats=GBAN_ALLOWED_CHATS))
@client.log_exception
async def ban_on_join(event):
chat = await event.get_chat()
user = await event.get_user()
if event.user_joined:
if chat.creator or chat.admin_rights:
if user.id in GBANNED_USERS:
reason = GBANNED_USERS.get(user.id)
if reason:
await event.reply("**This user is curently banned on this companion and it shouldn't be here**\n"
f"__Reason:__ {reason}")
else:
await event.reply("**This user is curently banned on this companion and it shouldn't be here**")
rights = ChatBannedRights(
until_date=None,
for entity in entities:
if isinstance(
entity,
(types.MessageEntityTextUrl, types.MessageEntityUrl)):
is_url = True
if is_url:
try:
await event.delete()
except Exception as e:
await event.reply(
"I don't seem to have ADMIN permission here. \n`{}`".
format(str(e)))
update_lock(peer_id, "url", False)
@borg.on(events.ChatAction())
async def _(event):
try:
from sql_helpers.locks_sql import update_lock, is_locked
except Exception as e:
logger.info("DB_URI is not configured.")
logger.info(str(e))
return False
# TODO: exempt admins from locks
# check for "lock" "bots"
if is_locked(event.chat_id, "bots"):
# bots are limited Telegram accounts,
# and cannot join by themselves
if event.user_added:
users_added_by = event.action_message.from_id
is_ban_able = False
from telethon import events
from telethon.tl.functions.channels import EditBannedRequest
from telethon.tl.types import ChatBannedRights
from sample_config import Config
CHATS_TO_MONITOR_FOR_ADDED_BOTS = [
# add the ID of the groups (Use .get_id command)
# seperated by commas
# usernames also work, but it is pointless,
# since non admin users cannot add bots to
# public groups (Telegram Limitation)
]
@borg.on(events.ChatAction(chats=CHATS_TO_MONITOR_FOR_ADDED_BOTS))
async def kick_if_bots(event):
if event.user_added:
users_added_by = event.action_message.from_id
if users_added_by == borg.uid:
logger.info("Don't BAN yourself")
return False
is_ban_able = False
rights = ChatBannedRights(until_date=None, view_messages=True)
added_users = event.action_message.action.users
for user_id in added_users:
user_obj = await borg.get_entity(user_id)
if user_obj.bot:
is_ban_able = True
try:
# kick the bot
elif user.id not in users_ignored:
# TODO: when a account is deleted and recreated within one check interval, the
# recreation message should be reported after the deletion message
await report(
f"🆕 #u_{user.id} {render_user(user)} is #newly found:\n"
f"now is at {render_datetime()}")
logger.debug(f"{user.id} is newly found")
# TODO: avoid race condition
now_blocked.append(user)
if (serialized := serialize_vector(now_blocked)) != d:
await blockedUsersStorage.store(serialized)
tracked_user_ids = {user.id for user in now_blocked}
@client.on(
events.ChatAction(func=lambda event: event.user_joined or event.user_added)
)
async def handler_user_join(event):
# TODO: there is possibility that some of joining messages are discarded
async with check_lock:
for user in await event.get_users():
if user.id in tracked_user_ids:
chat = await event.get_chat()
await report(
f"❕ #u_{user.id} {render_user(user)} #joined {render_chat(chat)}\nnow is at {render_datetime()}"
)
# TODO: abstract blocked users manager like .contacts or .auth so that to avoid manually managing
# tracked_user_ids
#!/usr/bin/env python3
import aiocron
from telethon import events, utils, errors
@userbot.on(events.ChatAction(chats="@emacszh"))
async def remove_join_messages(event) -> None:
"""remove user joinning message."""
if event.user_joined:
await event.delete()
@aiocron.crontab("* 2 * * *")
async def remove_deleted_account(channel: str = "@emacszh") -> None:
"""remove all deleted account from channel everyday."""
async for user in userbot.iter_participants(channel):
if user.deleted:
try:
await userbot.kick_participant(channel, user)
except errors.rpcerrorlist.UserAdminInvalidError:
# 群主踢不掉
pass
if isinstance(entity, tl.types.ChannelForbidden):
return
if isinstance(entity, tl.types.Channel) and entity.left:
return
channel = await borg.get_input_entity(channel_id)
self_participant = await borg(
GetParticipantRequest(channel, InputUserSelf()))
if not isinstance(
self_participant,
(tl.types.ChannelParticipantSelf, tl.types.ChannelParticipantAdmin)):
return
inviter_id = self_participant.participant.inviter_id
await on_added(inviter_id, channel_id)
@borg.on(events.ChatAction(func=lambda e: e.user_added or e.created))
async def on_group_added(e):
am = e.action_message
if borg.uid not in getattr(am.action, 'users', []):
return
await on_added(am.from_id, am.to_id)
@borg.on(
events.NewMessage(pattern=r"\.auth",
outgoing=True,
func=lambda e: e.is_private))
async def on_auth(e):
logger.info(f'Adding temporary auth for {e.chat_id}')
add_auths[e.chat_id] = time.time() + AUTH_TIME
await e.delete()
@System.on(events.NewMessage(incoming=True))
async def auto_gban_request(event):
if event.from_id in ENFORCERS or event.from_id in SIBYL: return
text = event.text
words = await get_blacklist()
sender = await event.get_sender()
if event.chat_id == Sibyl_logs: return
if words:
for word in words:
pattern = r"( |^|[^\w])" + word + r"( |$|[^\w])"
if re.search(pattern, text, flags=re.IGNORECASE):
await System.send_message(Sibyl_logs, f"$AUTO\nTriggered by: [{event.from_id}](tg://user?id={event.from_id})\nMessage: {event.text}")
return
@System.on(events.ChatAction()) # pylint:disable=E0602
async def auto_wlc_gban(event):
user = await event.get_user()
if user.id in ENFORCERS or user.id in SIBYL: return
if event.user_joined:
words = await get_wlc_bl()
if words:
text = user.first_name
for word in words:
pattern = r"( |^|[^\w])" + word + r"( |$|[^\w])"
if re.search(pattern, text, flags=re.IGNORECASE):
await System.send_message(Sibyl_logs, f"$AUTO\nTriggered by: [{event.from_id}](tg://user?id={event.from_id})\nUser joined and blacklisted string in name\nMatched String = {word}")
__plugin_name__ ="blacklist"
help_plus ="""
from telethon import events
from telethon.utils import pack_bot_file_id
from userbot.plugins.sql_helper.welcome_sql import get_current_welcome_settings, \
add_welcome_setting, rm_welcome_setting, update_previous_welcome
from userbot.utils import admin_cmd
@bot.on(events.ChatAction()) # pylint:disable=E0602
async def _(event):
cws = get_current_welcome_settings(event.chat_id)
if cws:
# logger.info(event.stringify())
"""user_added=False,
user_joined=True,
user_left=False,
user_kicked=False,"""
if event.user_joined:
if cws.should_clean_welcome:
try:
await bot.delete_messages( # pylint:disable=E0602
event.chat_id, cws.previous_welcome)
except Exception as e: # pylint:disable=C0103,W0703
logger.warn(str(e)) # pylint:disable=E0602
a_user = await event.get_user()
chat = await event.get_chat()
me = await bot.get_me()
title = chat.title if chat.title else "this chat"
participants = await event.client.get_participants(chat)
count = len(participants)
mention = "[{}](tg://user?id={})".format(a_user.first_name,
# From CatUserbot , And Yes I am Noob
from requests import get
from telethon import events
from telethon.errors import ChatAdminRequiredError
from telethon.tl.types import ChannelParticipantsAdmins
from FreakyUserbot import BOTLOG, BOTLOG_CHATID, LOGS, spamwatch
from FreakyUserbot.sql_helper.gban_sql import get_gbanuser, is_gbanned
from FreakyUserbot.utils import Freaky_on_cmd, is_admin
if Config.ANTI_SPAMBOT:
@Freaky.on(events.ChatAction())
async def anti_spambot(event):
if not event.user_joined and not event.user_added:
return
chat = event.chat_id
user = await event.get_user()
freakadmin = await is_admin(bot, chat, bot.uid)
if not freakadmin:
return
freakbanned = None
adder = None
ignore = None
if event.user_added:
try:
adder = event.action_message.sender_id
except AttributeError:
return
async for admin in event.client.iter_participants(
