overspend1/Ultroid-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4e65f218f58eeb0d8dc9fb1abb83cf116b67f9b2
Ultroid-fork/plugins/pmpermit.py
Anonymous 4e65f218f5 Ultroid v0.0.8 | 17-6-21 
Co-authored-by: Aditya <me@xditya.me>
Co-authored-by: Danish <danish@ultroid.tech>
Co-authored-by: Amit Sharma <48654350+buddhhu@users.noreply.github.com>
Co-authored-by: sppidy <sppidy@users.noreply.github.com>
Co-authored-by: Arnab Paryali <Arnabxd@users.noreply.github.com>
Co-authored-by: divkix <divkix@users.noreply.github.com>
Co-authored-by: hellboi_atul <hellboi-atul@users.noreply.github.com>
Co-authored-by: Programming Error <error@notavailable.live>
Co-authored-by: New-dev0 <New-dev0@users.noreply.github.com>
2021-06-17 21:18:55 +05:30

676 lines
22 KiB
Python
Raw Blame History

# Ultroid - UserBot
# Copyright (C) 2021 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/>.
"""
✘ Commands Available -
• `{i}a` or `{i}approve`
To Approve Someone In PM.
• `{i}da` or `{i}disapprove`
To Disapprove Someone In PM.
• `{i}block`
To Block Someone in PM.
• `{i}unblock`
To Unblock Someone in PM.
• `{i}nologpm`
To stop logging from that user.
• `{i}logpm`
Start logging again from that user.
• `{i}startarchive`
Will start adding new PMs to archive.
• `{i}stoparchive`
Will stop adding new PMs to archive.
• `{i}cleararchive`
Unarchive all chats.
"""
import re
from pyUltroid.functions.logusers_db import *
from pyUltroid.functions.pmpermit_db import *
from telethon import events
from telethon.tl.functions.contacts import BlockRequest, UnblockRequest
from telethon.tl.functions.messages import ReportSpamRequest
from telethon.utils import get_display_name
from . import *
# ========================= CONSTANTS =============================
COUNT_PM = {}
LASTMSG = {}
if Redis("PMPIC"):
PMPIC = Redis("PMPIC")
else:
PMPIC = "resources/extras/teamultroid.jpg"
UND = get_string("pmperm_1")
if not Redis("PM_TEXT"):
UNAPPROVED_MSG = """
**PMSecurity of {ON}!**
{UND}
You have {warn}/{twarn} warnings!"""
else:
UNAPPROVED_MSG = (
"""
**PMSecurity of {ON}!**"""
f"""
{Redis("PM_TEXT")}
"""
"""
You have {warn}/{twarn} warnings!"""
)
UNS = get_string("pmperm_2")
# 1
if Redis("PMWARNS"):
try:
WARNS = int(Redis("PMWARNS"))
except BaseException:
WARNS = 4
else:
WARNS = 4
NO_REPLY = get_string("pmperm_3")
PMCMDS = [
f"{hndlr}a",
f"{hndlr}approve",
f"{hndlr}da",
f"{hndlr}disapprove",
f"{hndlr}block",
f"{hndlr}unblock",
]
_not_approved = {}
# =================================================================
@ultroid_cmd(
pattern="logpm$",
)
async def _(e):
if not e.is_private:
return await eod(e, "`Use me in Private.`", time=3)
if is_logger(str(e.chat_id)):
nolog_user(str(e.chat_id))
return await eod(e, "`Now I Will log msgs from here.`", time=3)
else:
return await eod(e, "`Wasn't logging msgs from here.`", time=3)
@ultroid_cmd(
pattern="nologpm$",
)
async def _(e):
if not e.is_private:
return await eod(e, "`Use me in Private.`", time=3)
if not is_logger(str(e.chat_id)):
log_user(str(e.chat_id))
return await eod(e, "`Now I Won't log msgs from here.`", time=3)
else:
return await eod(e, "`Wasn't logging msgs from here.`", time=3)
@ultroid_bot.on(
events.NewMessage(
incoming=True,
func=lambda e: e.is_private,
),
)
async def permitpm(event):
user = await event.get_chat()
if user.bot or user.is_self or user.verified:
return
if is_logger(user.id):
return
if Redis("PMLOG") == "True":
pl = udB.get("PMLOGGROUP")
if pl is not None:
return await event.forward_to(int(pl))
await event.forward_to(int(udB.get("LOG_CHANNEL")))
sett = Redis("PMSETTING")
if sett is None:
sett = True
if sett == "True":
@ultroid_bot.on(
events.NewMessage(
outgoing=True,
func=lambda e: e.is_private,
),
)
async def autoappr(e):
miss = await e.get_chat()
if miss.bot or miss.is_self or miss.verified or Redis("AUTOAPPROVE") != "True":
return
if str(miss.id) in DEVLIST:
return
mssg = e.text
if mssg.startswith(HNDLR): # do not approve if outgoing is a command.
return
if not is_approved(e.chat_id):
approve_user(e.chat_id)
async for message in e.client.iter_messages(e.chat_id, search=UND):
await message.delete()
async for message in e.client.iter_messages(e.chat_id, search=UNS):
await message.delete()
try:
await ultroid_bot.edit_folder(e.chat_id, folder=0)
except BaseException:
pass
name = await e.client.get_entity(e.chat_id)
name0 = str(name.first_name)
await asst.send_message(
int(udB.get("LOG_CHANNEL")),
f"#AutoApproved\n**OutGoing Message.**\nUser - [{name0}](tg://user?id={e.chat_id})",
)
@ultroid_bot.on(
events.NewMessage(
incoming=True,
func=lambda e: e.is_private,
),
)
async def permitpm(event):
user = await event.get_chat()
if user.bot or user.is_self or user.verified:
return
if str(user.id) in DEVLIST:
return
apprv = is_approved(user.id)
if not apprv and event.text != UND:
if Redis("MOVE_ARCHIVE") == "True":
try:
await ultroid.edit_folder(user.id, folder=1)
except BaseException:
pass
if event.media:
await event.delete()
name = user.first_name
if user.last_name:
fullname = f"{name} {user.last_name}"
else:
fullname = name
username = f"@{user.username}"
mention = f"[{get_display_name(user)}](tg://user?id={user.id})"
count = len(get_approved())
try:
wrn = COUNT_PM[user.id] + 1
await asst.edit_message(
int(udB.get("LOG_CHANNEL")),
_not_approved[user.id],
f"Incoming PM from {mention} with {wrn}/{WARNS} warning!",
buttons=[
Button.inline("Approve PM", data=f"approve_{user.id}"),
Button.inline("Block PM", data=f"block_{user.id}"),
],
)
except KeyError:
_not_approved[user.id] = await asst.send_message(
int(udB.get("LOG_CHANNEL")),
f"Incoming PM from {mention} with 1/{WARNS} warning!",
buttons=[
Button.inline("Approve PM", data=f"approve_{user.id}"),
Button.inline("Block PM", data=f"block_{user.id}"),
],
)
wrn = 1
if user.id in LASTMSG:
prevmsg = LASTMSG[user.id]
if event.text != prevmsg:
if "PMSecurity" in event.text:
return
async for message in ultroid.iter_messages(
user.id,
search=UND,
):
await message.delete()
async for message in ultroid.iter_messages(
user.id,
search=UNS,
):
await message.delete()
message_ = UNAPPROVED_MSG.format(
ON=OWNER_NAME,
warn=wrn,
twarn=WARNS,
UND=UND,
name=name,
fullname=fullname,
username=username,
count=count,
mention=mention,
)
await ultroid.send_file(
user.id,
PMPIC,
caption=message_,
)
elif event.text == prevmsg:
async for message in ultroid.iter_messages(
user.id,
search=UND,
):
await message.delete()
message_ = UNAPPROVED_MSG.format(
ON=OWNER_NAME,
warn=wrn,
twarn=WARNS,
UND=UND,
name=name,
fullname=fullname,
username=username,
count=count,
mention=mention,
)
await ultroid.send_file(
user.id,
PMPIC,
caption=message_,
)
LASTMSG.update({user.id: event.text})
else:
async for message in ultroid.iter_messages(user.id, search=UND):
await message.delete()
message_ = UNAPPROVED_MSG.format(
ON=OWNER_NAME,
warn=wrn,
twarn=WARNS,
UND=UND,
name=name,
fullname=fullname,
username=username,
count=count,
mention=mention,
)
await ultroid.send_file(
user.id,
PMPIC,
caption=message_,
)
LASTMSG.update({user.id: event.text})
if user.id not in COUNT_PM:
COUNT_PM.update({user.id: 1})
else:
COUNT_PM[user.id] = COUNT_PM[user.id] + 1
if COUNT_PM[user.id] >= WARNS:
async for message in ultroid.iter_messages(user.id, search=UND):
await message.delete()
await event.respond(UNS)
try:
del COUNT_PM[user.id]
del LASTMSG[user.id]
except KeyError:
await asst.send_message(
int(udB.get("LOG_CHANNEL")),
"PMPermit is messed! Pls restart the bot!!",
)
return LOGS.info("COUNT_PM is messed.")
await ultroid(BlockRequest(user.id))
await ultroid(ReportSpamRequest(peer=user.id))
name = await ultroid.get_entity(user.id)
name0 = str(name.first_name)
await asst.edit_message(
int(udB.get("LOG_CHANNEL")),
_not_approved[user.id],
f"[{name0}](tg://user?id={user.id}) was Blocked for spamming.",
)
@ultroid_cmd(
pattern="(start|stop|clear)archive$",
)
async def _(e):
x = e.pattern_match.group(1)
if x == "start":
udB.set("MOVE_ARCHIVE", "True")
await eod(e, "Now I will move new Unapproved DM's to archive")
elif x == "stop":
udB.set("MOVE_ARCHIVE", "False")
await eod(e, "Now I won't move new Unapproved DM's to archive")
elif x == "clear":
try:
await e.client.edit_folder(unpack=1)
await eod(e, "Unarchived all chats")
except Exception as mm:
await eod(e, str(mm))
@ultroid_cmd(
pattern="(a|approve)(?: |$)",
)
async def approvepm(apprvpm):
if apprvpm.reply_to_msg_id:
reply = await apprvpm.get_reply_message()
replied_user = await apprvpm.client.get_entity(reply.sender_id)
aname = replied_user.id
if str(aname) in DEVLIST:
return await eor(
apprvpm,
"Lol, He is my Developer\nHe is auto Approved",
)
name0 = str(replied_user.first_name)
uid = replied_user.id
if not is_approved(uid):
approve_user(uid)
try:
await apprvpm.client.edit_folder(uid, folder=0)
except BaseException:
pass
await eod(apprvpm, f"[{name0}](tg://user?id={uid}) `approved to PM!`")
await asst.edit_message(
int(udB.get("LOG_CHANNEL")),
_not_approved[uid],
f"#APPROVED\n\n`User: `[{name0}](tg://user?id={uid})",
buttons=[
Button.inline("Disapprove PM", data=f"disapprove_{uid}"),
Button.inline("Block", data=f"block_{uid}"),
],
)
else:
await eod(apprvpm, "`User may already be approved.`")
elif apprvpm.is_private:
user = await apprvpm.get_chat()
aname = await apprvpm.client.get_entity(user.id)
if str(user.id) in DEVLIST:
return await eor(
apprvpm,
"Lol, He is my Developer\nHe is auto Approved",
)
name0 = str(aname.first_name)
uid = user.id
if not is_approved(uid):
approve_user(uid)
try:
await apprvpm.client.edit_folder(uid, folder=0)
except BaseException:
pass
await eod(apprvpm, f"[{name0}](tg://user?id={uid}) `approved to PM!`")
async for message in apprvpm.client.iter_messages(user.id, search=UND):
await message.delete()
async for message in apprvpm.client.iter_messages(user.id, search=UNS):
await message.delete()
await asst.edit_message(
int(udB.get("LOG_CHANNEL")),
_not_approved[uid],
f"#APPROVED\n\n`User: `[{name0}](tg://user?id={uid})",
buttons=[
Button.inline("Disapprove PM", data=f"disapprove_{uid}"),
Button.inline("Block", data=f"block_{uid}"),
],
)
else:
await eod(apprvpm, "`User may already be approved.`")
else:
await apprvpm.edit(NO_REPLY)
@ultroid_cmd(
pattern="(da|disapprove)(?: |$)",
)
async def disapprovepm(e):
if e.reply_to_msg_id:
reply = await e.get_reply_message()
replied_user = await e.client.get_entity(reply.sender_id)
aname = replied_user.id
if str(aname) in DEVLIST:
return await eor(
e,
"`Lol, He is my Developer\nHe Can't Be DisApproved.`",
)
name0 = str(replied_user.first_name)
if is_approved(aname):
disapprove_user(aname)
await e.edit(
f"[{name0}](tg://user?id={replied_user.id}) `Disaproved to PM!`",
)
await asyncio.sleep(5)
await e.delete()
await asst.edit_message(
int(udB.get("LOG_CHANNEL")),
_not_approved[aname],
f"#DISAPPROVED\n\n[{name0}](tg://user?id={bbb.id}) `was disapproved to PM you.`",
buttons=[
Button.inline("Approve PM", data=f"approve_{aname}"),
Button.inline("Block", data=f"block_{aname}"),
],
)
else:
await e.edit(
f"[{name0}](tg://user?id={replied_user.id}) was never approved!",
)
await asyncio.sleep(5)
await e.delete()
elif e.is_private:
bbb = await e.get_chat()
aname = await e.client.get_entity(bbb.id)
if str(bbb.id) in DEVLIST:
return await eor(
e,
"`Lol, He is my Developer\nHe Can't Be DisApproved.`",
)
name0 = str(aname.first_name)
if is_approved(bbb.id):
disapprove_user(bbb.id)
await e.edit(f"[{name0}](tg://user?id={bbb.id}) `Disaproved to PM!`")
await asyncio.sleep(5)
await e.delete()
await asst.edit_message(
int(udB.get("LOG_CHANNEL")),
_not_approved[bbb.id],
f"#DISAPPROVED\n\n[{name0}](tg://user?id={bbb.id}) `was disapproved to PM you.`",
buttons=[
Button.inline("Approve PM", data=f"approve_{bbb.id}"),
Button.inline("Block", data=f"block_{bbb.id}"),
],
)
else:
await e.edit(f"[{name0}](tg://user?id={bbb.id}) was never approved!")
await asyncio.sleep(5)
await e.delete()
else:
await e.edit(NO_REPLY)
@ultroid_cmd(
pattern="block ?(.*)",
)
async def blockpm(block):
match = block.pattern_match.group(1)
if block.is_reply:
reply = await block.get_reply_message()
user = reply.sender_id
elif match:
user = await get_user_id(match)
elif block.is_private:
user = block.chat_id
else:
return await eod(block, NO_REPLY)
if str(user) in DEVLIST:
return await eor(
block,
"`Lol, He is my Developer\nHe Can't Be Blocked`",
)
await block.client(BlockRequest(user))
aname = await block.client.get_entity(user)
await eor(block, f"`{aname.first_name} has been blocked!`")
try:
disapprove_user(user)
except AttributeError:
pass
await asst.edit_message(
int(udB.get("LOG_CHANNEL")),
_not_approved[user],
f"#BLOCKED\n\n[{aname.first_name}](tg://user?id={user}) has been **blocked**.",
buttons=Button.inline("UnBlock", data=f"unblock_{user}"),
)
@ultroid_cmd(
pattern="unblock ?(.*)",
)
async def unblockpm(unblock):
match = unblock.pattern_match.group(1)
if unblock.is_reply:
reply = await unblock.get_reply_message()
user = reply.sender_id
elif match:
user = await get_user_id(match)
else:
return await eod(unblock, NO_REPLY)
try:
await unblock.client(UnblockRequest(user))
aname = await unblock.client.get_entity(user)
await eor(unblock, f"`{aname.first_name} has been UnBlocked!`")
except Exception as et:
await eod(unblock, f"ERROR - {str(et)}")
await asst.edit_message(
int(udB.get("LOG_CHANNEL")),
_not_approved[user],
f"#UNBLOCKED\n\n[{aname.first_name}](tg://user?id={user}) has been **unblocked**.",
buttons=[
Button.inline("Block", data=f"block_{user}"),
Button.inline("Close", data="deletedissht"),
],
)
@callback(
re.compile(
b"approve_(.*)",
),
)
@owner
async def apr_in(event):
uid = int(event.data_match.group(1).decode("UTF-8"))
if str(uid) in DEVLIST:
await event.edit("It's a dev! Approved!")
if not is_approved(uid):
approve_user(uid)
try:
await ultroid_bot.edit_folder(uid, folder=0)
except BaseException:
pass
try:
user_name = (await ultroid.get_entity(uid)).first_name
except BaseException:
user_name = ""
await event.edit(
f"#APPROVED\n\n[{user_name}](tg://user?id={uid}) `approved to PM!`",
buttons=[
Button.inline("Disapprove PM", data=f"disapprove_{uid}"),
Button.inline("Block", data=f"block_{uid}"),
],
)
async for message in ultroid.iter_messages(uid, search=UND):
await message.delete()
async for message in ultroid.iter_messages(uid, search=UNS):
await message.delete()
await event.answer("Approved.")
x = await ultroid.send_message(uid, "You have been approved to PM me!")
await asyncio.sleep(5)
await x.delete()
else:
await event.edit(
"`User may already be approved.`",
buttons=[
Button.inline("Disapprove PM", data=f"disapprove_{uid}"),
Button.inline("Block", data=f"block_{uid}"),
],
)
@callback(
re.compile(
b"disapprove_(.*)",
),
)
@owner
async def disapr_in(event):
uid = int(event.data_match.group(1).decode("UTF-8"))
if is_approved(uid):
disapprove_user(uid)
try:
user_name = (await ultroid.get_entity(uid)).first_name
except BaseException:
user_name = ""
await event.edit(
f"#DISAPPROVED\n\n[{user_name}](tg://user?id={uid}) `disapproved from PMs!`",
buttons=[
Button.inline("Approve PM", data=f"approve_{uid}"),
Button.inline("Block", data=f"block_{uid}"),
],
)
await event.answer("DisApproved.")
x = await ultroid.send_message(uid, "You have been disapproved from PMing me!")
await asyncio.sleep(5)
await x.delete()
else:
await event.edit(
"`User was never approved!`",
buttons=[
Button.inline("Disapprove PM", data=f"disapprove_{uid}"),
Button.inline("Block", data=f"block_{uid}"),
],
)
@callback(
re.compile(
b"block_(.*)",
),
)
@owner
async def blck_in(event):
uid = int(event.data_match.group(1).decode("UTF-8"))
await ultroid(BlockRequest(uid))
try:
user_name = (await ultroid.get_entity(uid)).first_name
except BaseException:
user_name = ""
await event.answer("Blocked.")
await event.edit(
f"#BLOCKED\n\n[{user_name}](tg://user?id={uid}) has been **blocked!**",
buttons=Button.inline("UnBlock", data=f"unblock_{uid}"),
)
@callback(
re.compile(
b"unblock_(.*)",
),
)
@owner
async def unblck_in(event):
uid = int(event.data_match.group(1).decode("UTF-8"))
await ultroid(UnblockRequest(uid))
try:
user_name = (await ultroid.get_entity(uid)).first_name
except BaseException:
user_name = ""
await event.answer("UnBlocked.")
await event.edit(
f"#UNBLOCKED\n\n[{user_name}](tg://user?id={uid}) has been **unblocked!**",
buttons=[
Button.inline("Block", data=f"block_{uid}"),
Button.inline("Close", data="deletedissht"),
],
)
@callback("deletedissht")
async def ytfuxist(e):
await e.answer("Deleted.")
await e.delete()
Reference in New Issue View Git Blame Copy Permalink