async def view_blacklist(_, m: Message):
db = Blacklist(m.chat.id)
LOGGER.info(f"{m.from_user.id} checking blacklists in {m.chat.id}")
chat_title = m.chat.title
blacklists_chat = (tlang(m, "blacklist.curr_blacklist_initial")).format(
chat_title=chat_title,
)
all_blacklisted = db.get_blacklists()
if not all_blacklisted:
await m.reply_text(
(tlang(m, "blacklist.no_blacklist")).format(
chat_title=chat_title,
),
)
return
blacklists_chat += "\n".join(
f" • <code>{escape(i)}</code>" for i in all_blacklisted
)
await m.reply_text(blacklists_chat)
return
async def add_blacklist(_, m: Message):
db = Blacklist(m.chat.id)
if len(m.text.split()) < 2:
await m.reply_text(tlang(m, "general.check_help"))
return
bl_words = ((m.text.split(None, 1)[1]).lower()).split()
all_blacklisted = db.get_blacklists()
already_added_words, rep_text = [], ""
for bl_word in bl_words:
if bl_word in all_blacklisted:
already_added_words.append(bl_word)
continue
db.add_blacklist(bl_word)
if already_added_words:
rep_text = (
", ".join([f"<code>{i}</code>" for i in bl_words])
+ " already added in blacklist, skipped them!"
)
LOGGER.info(f"{m.from_user.id} added new blacklists ({bl_words}) in {m.chat.id}")
await m.reply_text(
(tlang(m, "blacklist.added_blacklist")).format(
trigger=", ".join(f"<code>{i}</code>" for i in bl_words),
)
+ (f"\n{rep_text}" if rep_text else ""),
)
await m.stop_propagation()
async def set_bl_action(_, m: Message):
db = Blacklist(m.chat.id)
if len(m.text.split()) == 2:
action = m.text.split(None, 1)[1]
valid_actions = ("ban", "kick", "mute", "warn", "none")
if action not in valid_actions:
await m.reply_text(
(
"Choose a valid blacklist action from "
+ ", ".join(f"<code>{i}</code>" for i in valid_actions)
),
)
return
db.set_action(action)
LOGGER.info(
f"{m.from_user.id} set blacklist action to '{action}' in {m.chat.id}",
)
await m.reply_text(
(tlang(m, "blacklist.action_set")).format(action=action),
)
elif len(m.text.split()) == 1:
action = db.get_action()
LOGGER.info(f"{m.from_user.id} checking blacklist action in {m.chat.id}")
await m.reply_text(
(tlang(m, "blacklist.action_get")).format(action=action),
)
else:
await m.reply_text(tlang(m, "general.check_help"))
return
async def rm_blacklist(_, m: Message):
db = Blacklist(m.chat.id)
if len(m.text.split()) < 2:
await m.reply_text(tlang(m, "general.check_help"))
return
chat_bl = db.get_blacklists()
non_found_words, rep_text = [], ""
bl_words = ((m.text.split(None, 1)[1]).lower()).split()
for bl_word in bl_words:
if bl_word not in chat_bl:
non_found_words.append(bl_word)
continue
db.remove_blacklist(bl_word)
if non_found_words == bl_words:
return await m.reply_text("Blacklists not found!")
if non_found_words:
rep_text = (
"Could not find " + ", ".join(f"<code>{i}</code>" for i in non_found_words)
) + " in blcklisted words, skipped them."
LOGGER.info(f"{m.from_user.id} removed blacklists ({bl_words}) in {m.chat.id}")
await m.reply_text(
(tlang(m, "blacklist.rm_blacklist")).format(
bl_words=", ".join(f"<code>{i}</code>" for i in bl_words),
)
+ (f"\n{rep_text}" if rep_text else ""),
)
await m.stop_propagation()
async def migrate_chat(m: Message, new_chat: int) -> None:
LOGGER.info(f"Migrating from {m.chat.id} to {new_chat}...")
langdb = Langs(m.chat.id)
notedb = Notes()
gdb = Greetings(m.chat.id)
ruledb = Rules(m.chat.id)
userdb = Users(m.chat.id)
chatdb = Chats(m.chat.id)
bldb = Blacklist(m.chat.id)
approvedb = Approve(m.chat.id)
reportdb = Reporting(m.chat.id)
notes_settings = NotesSettings()
pins_db = Pins(m.chat.id)
fldb = Filters()
disabl = Disabling(m.chat.id)
disabl.migrate_chat(new_chat)
gdb.migrate_chat(new_chat)
chatdb.migrate_chat(new_chat)
userdb.migrate_chat(new_chat)
langdb.migrate_chat(new_chat)
ruledb.migrate_chat(new_chat)
bldb.migrate_chat(new_chat)
notedb.migrate_chat(m.chat.id, new_chat)
approvedb.migrate_chat(new_chat)
reportdb.migrate_chat(new_chat)
notes_settings.migrate_chat(m.chat.id, new_chat)
pins_db.migrate_chat(new_chat)
fldb.migrate_chat(m.chat.id, new_chat)
LOGGER.info(f"Successfully migrated from {m.chat.id} to {new_chat}!")
async def blacklistreason(_, m: Message):
db = Blacklist(m.chat.id)
if len(m.text.split()) == 1:
curr = db.get_reason()
await m.reply_text(
f"The current reason for blacklists warn is:\n<code>{curr}</code>",
)
else:
reason = m.text.split(None, 1)[1]
db.set_reason(reason)
await m.reply_text(
f"Updated reason for blacklists warn is:\n<code>{reason}</code>",
)
return
async def rm_allblacklist(_, m: Message):
db = Blacklist(m.chat.id)
all_bls = db.get_blacklists()
if not all_bls:
await m.reply_text("No notes are blacklists in this chat")
return
await m.reply_text(
"Are you sure you want to clear all blacklists?",
reply_markup=ikb(
[[("⚠️ Confirm", "rm_allblacklist"), ("❌ Cancel", "close_admin")]],
),
)
return
async def rm_allbl_callback(_, q: CallbackQuery):
user_id = q.from_user.id
db = Blacklist(q.message.chat.id)
user_status = (await q.message.chat.get_member(user_id)).status
if user_status not in {"creator", "administrator"}:
await q.answer(
"You're not even an admin, don't try this explosive shit!",
show_alert=True,
)
return
if user_status != "creator":
await q.answer(
"You're just an admin, not owner\nStay in your limits!",
show_alert=True,
)
return
db.rm_all_blacklist()
await q.message.delete()
LOGGER.info(f"{user_id} removed all blacklists in {q.message.chat.id}")
await q.answer("Cleared all Blacklists!", show_alert=True)
return
from alita.bot_class import Alita
from alita.database import db
from alita.database.antichannelpin_db import Pins
from alita.database.antispam_db import GBan
from alita.database.approve_db import Approve
from alita.database.blacklist_db import Blacklist
from alita.database.chats_db import Chats
from alita.database.filters_db import Filters
from alita.database.notes_db import Notes, NotesSettings
from alita.database.rules_db import Rules
from alita.database.users_db import Users
from alita.database.warns_db import Warns, WarnSettings
from alita.utils.custom_filters import command, dev_filter
# initialise
bldb = Blacklist()
gbandb = GBan()
notesdb = Notes()
rulesdb = Rules()
userdb = Users()
appdb = Approve()
chatdb = Chats()
fldb = Filters()
pinsdb = Pins()
notesettings_db = NotesSettings()
warns_db = Warns()
warns_settings_db = WarnSettings()
@Alita.on_message(command("stats", DEV_PREFIX_HANDLER) & dev_filter)
async def get_stats(_, m: Message):
async def bl_watcher(_, m: Message):
if m and not m.from_user:
return
bl_db = Blacklist(m.chat.id)
async def perform_action_blacklist(m: Message, action: str, trigger: str):
if action == "kick":
await m.chat.kick_member(m.from_user.id, int(time() + 45))
await m.reply_text(
tlang(m, "blacklist.bl_watcher.action_kick").format(
user=m.from_user.username
or f"<b>{m.from_user.first_name}</b>", ), )
elif action == "ban":
(await m.chat.kick_member(m.from_user.id, ))
await m.reply_text(
tlang(m, "blacklist.bl_watcher.action_ban").format(
user=m.from_user.username
or f"<b>{m.from_user.first_name}</b>", ), )
elif action == "mute":
await m.chat.restrict_member(
m.from_user.id,
ChatPermissions(
can_send_messages=False,
can_send_media_messages=False,
can_send_stickers=False,
can_send_animations=False,
can_send_games=False,
can_use_inline_bots=False,
can_add_web_page_previews=False,
can_send_polls=False,
can_change_info=False,
can_invite_users=True,
can_pin_messages=False,
),
)
await m.reply_text(
tlang(m, "blacklist.bl_watcher.action_mute").format(
user=m.from_user.username
or f"<b>{m.from_user.first_name}</b>", ), )
elif action == "warn":
warns_settings_db = WarnSettings(m.chat.id)
warns_db = Warns(m.chat.id)
warn_settings = warns_settings_db.get_warnings_settings()
warn_reason = bl_db.get_reason()
_, num = warns_db.warn_user(m.from_user.id, warn_reason)
if num >= warn_settings["warn_limit"]:
if warn_settings["warn_mode"] == "kick":
await m.chat.kick_member(
m.from_user.id,
until_date=int(time() + 45),
)
action = "kicked"
elif warn_settings["warn_mode"] == "ban":
await m.chat.kick_member(m.from_user.id)
action = "banned"
elif warn_settings["warn_mode"] == "mute":
await m.chat.restrict_member(m.from_user.id,
ChatPermissions())
action = "muted"
await m.reply_text((
f"Warnings {num}/{warn_settings['warn_limit']}\n"
f"{(await mention_html(m.from_user.first_name, m.from_user.id))} has been <b>{action}!</b>"
), )
return
await m.reply_text(
(
f"{(await mention_html(m.from_user.first_name, m.from_user.id))} warned {num}/{warn_settings['warn_limit']}\n"
# f"Last warn was for:\n<i>{warn_reason}</i>"
f"Last warn was for:\n<i>{warn_reason.format(trigger)}</i>"
), )
return
if m.from_user.id in SUPPORT_STAFF:
# Don't work on Support Staff!
return
# If no blacklists, then return
chat_blacklists = bl_db.get_blacklists()
if not chat_blacklists:
return
# Get admins from admin_cache, reduces api calls
try:
admin_ids = {i[0] for i in ADMIN_CACHE[m.chat.id]}
except KeyError:
admin_ids = await admin_cache_reload(m, "blacklist_watcher")
if m.from_user.id in admin_ids:
return
# Get approved user from cache/database
app_users = Approve(m.chat.id).list_approved()
if m.from_user.id in {i[0] for i in app_users}:
return
# Get action for blacklist
action = bl_db.get_action()
for trigger in chat_blacklists:
pattern = r"( |^|[^\w])" + re_escape(trigger) + r"( |$|[^\w])"
match = await regex_searcher(pattern, m.text.lower())
if not match:
continue
if match:
try:
await perform_action_blacklist(m, action, trigger)
LOGGER.info(
f"{m.from_user.id} {action}ed for using blacklisted word {trigger} in {m.chat.id}",
)
await m.delete()
except RPCError as ef:
LOGGER.error(ef)
LOGGER.error(format_exc())
break
return
from alita import LOGGER, MESSAGE_DUMP, SUPPORT_STAFF
from alita.bot_class import Alita
from alita.database.antichannelpin_db import Pins
from alita.database.antispam_db import ANTISPAM_BANNED, GBan
from alita.database.approve_db import Approve
from alita.database.blacklist_db import Blacklist
from alita.database.group_blacklist import BLACKLIST_CHATS
from alita.database.warns_db import Warns, WarnSettings
from alita.tr_engine import tlang
from alita.utils.caching import ADMIN_CACHE, admin_cache_reload
from alita.utils.parser import mention_html
from alita.utils.regex_utils import regex_searcher
# Initialise
bl_db = Blacklist()
app_db = Approve()
gban_db = GBan()
pins_db = Pins()
warns_db = Warns()
warns_settings_db = WarnSettings()
@Alita.on_message(filters.linked_channel)
async def antichanpin_cleanlinked(c: Alita, m: Message):
try:
msg_id = m.message_id
curr = pins_db.get_current_stngs(m.chat.id)
if curr["antichannelpin"]:
await c.unpin_chat_message(chat_id=m.chat.id, message_id=msg_id)
LOGGER.info(f"AntiChannelPin: msgid-{m.message_id} unpinned in {m.chat.id}")