async def permitpm(e):
if PM_AUTO_BAN:
global COUNT_PM
if e.is_private and not (await e.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except:
return
apprv = is_approved(e.chat_id)
if not apprv and e.text != UNAPPROVED_MSG:
await e.reply(UNAPPROVED_MSG)
if NOTIF_OFF:
await e.client.send_read_acknowledge(e.chat_id)
if e.chat_id not in COUNT_PM:
COUNT_PM.update({e.chat_id: 1})
else:
COUNT_PM[e.chat_id] = COUNT_PM[e.chat_id] + 1
if COUNT_PM[e.chat_id] > 4:
await e.respond(
"`You were spamming my Master's PM, which I don't like.`"
"`I'mma Report Spam.`")
del COUNT_PM[e.chat_id]
await e.client(BlockRequest(e.chat_id))
await e.client(ReportSpamRequest(peer=e.chat_id))
if LOGGER:
name = await e.client.get_entity(e.chat_id)
name0 = str(name.first_name)
await e.client.send_message(
LOGGER_GROUP,
"[" + name0 + "](tg://user?id=" + str(e.chat_id) +
")" + " was just another retarded nibba",
)
async def permitpm(event):
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 710844948 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] == 3:
await event.respond(
f"`{JAVES_NNAME}`: ** Dont spam my master's pm this is your last warning!!**"
)
if COUNT_PM[event.chat_id] > 3:
await event.respond(
f"`{JAVES_NNAME}`: ** {BLOCK_MMSG} **")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, plis restart bot!",
)
return
await event.client(BlockRequest(event.chat_id))
await event.client(
ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" blocked for spam your PM",
)
async def permitpm(event):
""" Permits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
if event.sender_id in BRAIN_CHECKER:
return
if event.is_private and not (await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if NOTIF_OFF:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`You were spamming my master's PM, which I don't like.`"
" `I'mma Report Spam.`")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
LOGS.info("CountPM wen't rarted boi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if LOGGER:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
LOGGER_GROUP,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" was just another retarded nibba",
)
async def permitpm(e):
if PM_AUTO_BAN:
global COUNT_PM
if e.is_private and not (await e.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except:
return
apprv = is_approved(e.chat_id)
if not apprv and e.text != \
("`Bleep Blop! This is a Bot. Don't fret. \n\n`"
"`My Master hasn't approved you to PM.`. \n\n"
"`If You Are Hater then Maderchod Maa Chudao Bhosdike MaderHod`\n\n"
"`Currently i'm offline you can get help in` @zonerschat join @mkzone For new Bins\n\n"
"`If You Are One Of My Friends Kindly Wait Till Me Come Online.`"):
await e.reply(
"`Bleep Blop! This is a Bot. Don't fret. \n\n`"
"`If You Are Hater then Maderchod Maa Chudao Bhosdike MaderHod` \n\n"
"`If You Are One Of My Friends Kindly Wait Till Me Come Online.`\n\n"
"`As far as i know, he doesn't usually approve Retards.`"
)
if NOTIF_OFF:
await e.client.send_read_acknowledge(e.chat_id)
if e.chat_id not in COUNT_PM:
COUNT_PM.update({e.chat_id: 1})
else:
COUNT_PM[e.chat_id] = COUNT_PM[e.chat_id] + 1
if COUNT_PM[e.chat_id] > 3:
await e.respond(
"`You were spamming my Master's PM, which I don't like.`"
"`Reported Spam Of This MaderChod.`"
)
del COUNT_PM[e.chat_id]
await e.client(BlockRequest(e.chat_id))
await e.client(ReportSpamRequest(peer=e.chat_id))
if LOGGER:
name = await e.client.get_entity(e.chat_id)
name0 = str(name.first_name)
await e.client.send_message(
LOGGER_GROUP,
"["
+ name0
+ "](tg://user?id="
+ str(e.chat_id)
+ ")"
+ " was just another retarded nibba",
)
async def permitpm(e):
if PM_AUTO_BAN:
global COUNT_PM
if e.is_private and not (await e.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except:
return
apprv = is_approved(e.chat_id)
if not apprv and e.text != \
("`Bleep Blop! This is a Bot. Don't fret. \n\n`"
"`My Master hasn't approved you to PM.`"
"`Please wait for my Master to look in, he would mostly approve PMs.`\n\n"
"`As far as i know, he doesn't usually approve Retards.`"):
await e.reply(
"`Bleep Blop! This is a Bot. Don't fret. \n\n`"
"`My Master Divyanshu hasn't approved you to PM.`"
"`you will get block and spam after 3 message.`\n\n"
"`As far as i know, he doesn't usually approve Retards.`"
)
if NOTIF_OFF:
await bot.send_read_acknowledge(e.chat_id)
if e.chat_id not in COUNT_PM:
COUNT_PM.update({e.chat_id: 1})
else:
COUNT_PM[e.chat_id] = COUNT_PM[e.chat_id] + 1
if COUNT_PM[e.chat_id] > 4:
await e.respond(
"`You were spamming my Master's PM, which I don't like.`"
"`I'mma Report Spam.`"
)
del COUNT_PM[e.chat_id]
await bot(BlockRequest(e.chat_id))
await bot(ReportSpamRequest(peer='e.chat_id'))
if LOGGER:
name = await bot.get_entity(e.chat_id)
name0 = str(name.first_name)
await bot.send_message(
LOGGER_GROUP,
"["
+ name0
+ "](tg://user?id="
+ str(e.chat_id)
+ ")"
+ " was just another retarded nibba",
)
async def permitpm(event):
""" Permits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
if event.sender_id in BRAIN_CHECKER:
return
global COUNT_PM
if event.is_private and not (await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
if not apprv:
if event.raw_text != UNAPPROVED_MSG:
await event.reply("`" + UNAPPROVED_MSG + "`")
if NOTIF_OFF:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`You were spamming my master's PM, which I don't like.`"
" `I'mma Report Spam.`")
del COUNT_PM[event.chat_id]
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if LOGGER:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
LOGGER_GROUP,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" was just another retarded nibba",
)
async def permitpm(e):
if PM_AUTO_BAN:
global COUNT_PM
if e.is_private and not (await e.get_sender()).bot:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
E=is_approved(e.chat_id)
if not E:
await e.reply("`Bleep Blop! This is a Bot. Don't fret. \n\nMy Master hasn't approved you to PM. \
Please wait for my Master to look in, he would mostly approve PMs.\n\n\
As far as i know, he doesn't usually approve Retards.`")
if e.chat_id not in COUNT_PM:
COUNT_PM.update({e.chat_id:1})
else:
COUNT_PM[e.chat_id]=COUNT_PM[e.chat_id]+1
if COUNT_PM[e.chat_id]>4:
await e.respond('`You were spamming my Master\'s PM, which I don\'t like. I\'mma Report Spam.`')
del COUNT_PM[e.chat_id]
await bot(BlockRequest(e.chat_id))
if LOGGER:
name = await bot.get_entity(e.chat_id)
name0 = str(name.first_name)
await bot.send_message(LOGGER_GROUP,'['+ name0 +'](tg://user?id='+str(e.chat_id)+')'+" was just another retarded nibba")
async def permitpm(event):
""" Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if not PM_AUTO_BAN:
return
self_user = await event.client.get_me()
sender = await event.get_sender()
if (event.is_private and event.chat_id != 777000
and event.chat_id != self_user.id and not sender.bot
and not sender.contact):
try:
from userbot.modules.sql_helper.globals import gvarstatus
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Use user custom unapproved message
getmsg = gvarstatus("unapproved_msg")
UNAPPROVED_MSG = getmsg if getmsg is not None else DEF_UNAPPROVED_MSG
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id, from_user="******",
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(f"`{UNAPPROVED_MSG}`")
else:
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`Yᴏᴜ ᴡᴇʀᴇ sᴘᴀᴍᴍɪɴɢ Mʏ Kɪɴɢ PM, ᴡʜɪᴄʜ I ᴅɪᴅɴ'ᴛ ʟɪᴋᴇ.`\n"
"`Yᴏᴜ ʜᴀᴠᴇ ʙᴇᴇɴ ʙʟᴏᴄᴋᴇᴅ ᴀɴᴅ ʀᴇᴘᴏʀᴛᴇᴅ ᴀs sᴘᴀᴍ, ᴜɴᴛɪʟ ғᴜʀᴛʜᴇʀ ɴᴏᴛɪᴄᴇ.`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Cᴏᴜɴᴛ PM ɪs sᴇᴇᴍɪɴɢʟʏ ɢᴏɪɴɢ ʀᴇᴛᴀʀᴅ, ᴘʟɪs ʀᴇsᴛᴀʀᴛ ʙᴏᴛ!",
)
return LOGS.info("CᴏᴜɴᴛPM ᴡᴇɴ'ᴛ ʀᴀʀᴛᴇᴅ ʙᴏɪ")
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"Mʏ Kɪɴɢ [" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" ᴡᴀs sᴘᴀᴍᴍɪɴɢ ʏᴏᴜʀ PM sᴏ ʜᴇ ᴡᴀs ʙʟᴏᴄᴋᴇᴅ.",
)
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`I didn't like you spamming my PM.`\n"
"`You have been BLOCKED and reported as SPAM, wait a minute until i online.`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`You were spamming my PM, which I didn't like.`\n"
"`You have been BLOCKED and reported as SPAM, until further notice.`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
async def permitpm(event):
""" Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if not PM_AUTO_BAN:
return
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 777000 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Use user custom unapproved message
getmsg = gvarstatus("unapproved_msg")
if getmsg is not None:
UNAPPROVED_MSG = getmsg
else:
UNAPPROVED_MSG = DEF_UNAPPROVED_MSG
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id, from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(f"`{UNAPPROVED_MSG}`")
else:
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"Oops... you've been blocked since you were suspected as a spammer! \n"
"I already warned ya before so then you're unable to chat ma mastor ATM 'till he's gonna unblock ya.\n"
"But, who knows?")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, plis restart bot!",
)
LOGS.info("CountPM wen't rarted boi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" + str(event.chat_id) +
")" + " was just another retarded nibba",
)
async def permitpm(event):
""" Permits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
if event.sender_id in BRAIN_CHECKER:
return
if event.is_private and not (await event.get_sender()).bot:
if not is_mongo_alive() or not is_redis_alive():
return
apprv = await approval(event.chat_id)
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
# Searches for previously sent UNAPPROVED_MSGs
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
# ... and deletes them !!
await message.delete()
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if await notif_state() is False:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond("`Hai mandato più di 4 messaggi, "
" ciò che ti ho detto di non fare.`"
" `Ti reporto per spam e ti blocco.`")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, "
"plis restart bot!",
)
LOGS.info("CountPM wen't rarted boi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" was just another retarded nibba",
)
async def permitpm(event):
""" Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 777000 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 3:
await event.respond(
"`Anda mengirim spam ke PM saya, yang tidak saya sukai.`\n"
"`Anda telah DIBLOKIR dan dilaporkan sebagai SPAM, hingga pemberitahuan lebih lanjut..`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, plis restart bot!",
)
LOGS.info("CountPM wen't rarted boi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" was just another retarded nibba",
)
async def permitpm(event):
""" Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 710844948 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] == 3:
await event.respond(
f"`{JAVES_NNAME}`: ** Dont spam my master's pm this is your last warning!!**")
if COUNT_PM[event.chat_id] > 4:
await event.respond(
f"`{JAVES_NNAME}`: ** {BLOCK_MMSG} **")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, plis restart bot!",
)
LOGS.info("CountPM wen't rarted boi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" blocked for spam your PM",
)
async def permitpm(event):
"""Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically."""
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if (event.is_private and event.chat_id != 777000
and event.chat_id != self_user.id
and not (await event.get_sender()).bot):
try:
from userbot.modules.sql_helper.globals import gvarstatus
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Use user custom unapproved message
getmsg = gvarstatus("unapproved_msg")
if getmsg is not None:
UNAPPROVED_MSG = getmsg
else:
UNAPPROVED_MSG = DEF_UNAPPROVED_MSG
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user="******",
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"``Anda melakukan spamming pada PM saya, yang tidak saya sukai.`\n"
"`Saya tidak akan membiarkan Anda mengobrol dengan saya lagi sampai pemberitahuan lebih lanjut`\n"
"`Selamat Tinggal.`")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Hitung PM tampaknya akan terbelakang, silakan restart bot!",
)
return LOGS.info("CountPM menjadi lambat")
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" was spammed your PM and got blocked",
)
async def permitpm(event):
""" Untuk orang yg mengirim pesan tanpa persetujuan. \
Akan otomatis memblokir orang goblok itu. """
if not PM_AUTO_BAN:
return
self_user = await event.client.get_me()
if (
event.is_private
and event.chat_id != 777000
and event.chat_id != self_user.id
and not (await event.get_sender()).bot
):
try:
from userbot.modules.sql_helper.globals import gvarstatus
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Use user custom unapproved message
getmsg = gvarstatus("unapproved_msg")
if getmsg is not None:
UNAPPROVED_MSG = getmsg
else:
UNAPPROVED_MSG = DEF_UNAPPROVED_MSG
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id, from_user="******", search=UNAPPROVED_MSG
):
await message.delete()
await event.reply(f"`{UNAPPROVED_MSG}`")
else:
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`Kamu telah melakukan spam yg tidak aku suka.`\n"
"`Aku tidak mau melihatmu lagi disini!`\n"
"`Bye`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Penghitungan pesan spam terlalu berlebihan, tolong restart bot!",
)
LOGS.info("Spam pesan terdeteksi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"["
+ name0
+ "](tg://user?id="
+ str(event.chat_id)
+ ")"
+ " orang goblok yg masih spam",
)
async def permitpm(event):
""" Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 777000 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`Stavi spammando la chat del mio maestro.`\n"
"`Sei stato bloccato e segnalato come spam.`")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"L'userbot sta andando male per colpa delle persone che ne abusano, riavvialo",
)
LOGS.info("L'userbot sta andando male, riavvialo")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" era solo un altro ritardato",
)
async def permitpm(event):
""" Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 777000 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({eve"`Kau ini Sudah dibilangin masih aja susah gtd .`\n"
"`You have been BLOCKED and reported as SPAM, until further notice.`"
)
nt.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`Halah Ieu Budak Teu Ngarti Pisan?.`\n"
"`SIA NGGEUS DI BLOKIR KU AING, Tunggu We Sampe Aing Unblok!.`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, plis restart bot!",
)
LOGS.info("CountPM wen't rarted boi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" was just another retarded nibba",
)
async def permitpm(event):
""" Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 777000 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"You were 𝐒𝐏𝐀𝐌𝐌𝐄𝐑, which I didn't like.\n"
"You have been 𝐁𝐋𝐎𝐂𝐊𝐄𝐃 and 𝐑𝐄𝐏𝐎𝐑𝐓𝐄𝐃 as 𝐒𝐏𝐀𝐌.\n𝐇𝐀𝐕𝐄 𝐀 𝐍𝐈𝐂𝐄 𝐃𝐀𝐘."
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, plis restart bot!",
)
LOGS.info("CountPM wen't rarted boi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" was just another 𝐑𝐄𝐓𝐀𝐑𝐓𝐄𝐃.",
)
async def permitpm(event):
"""Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically."""
if not PM_AUTO_BAN:
return
self_user = await event.client.get_me()
if (event.is_private and event.chat_id != 777000
and event.chat_id != self_user.id
and not (await event.get_sender()).bot):
try:
from userbot.modules.sql_helper.globals import gvarstatus
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
pm_limit = gvarstatus("PM_LIMIT") or 5
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Use user custom unapproved message
getmsg = gvarstatus("unapproved_msg")
if getmsg is not None:
UNAPPROVED_MSG = getmsg
else:
UNAPPROVED_MSG = DEF_UNAPPROVED_MSG
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id, from_user="******",
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] == int(pm_limit):
await event.respond(
"`You were spamming my PM.`\n"
"`You have been blocked and reported as spam.`\n"
"`Bye.`")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, please restart bot!",
)
return LOGS.info("CountPM went retard")
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" + str(event.chat_id) +
")" + " was spammed your PM and got blocked",
)
async def permitpm(event):
""" Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 777000 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 2:
await event.respond(
"`Goblok, tolol banget si, udah dibilangin minta izin dulu, kalo gak di izinin ya gausah spam anjing🖕.`\n"
"`lu kena block otomatis dari bot, bye🖕 LOLOT.`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, plis restart bot!",
)
LOGS.info("CountPM wen't rarted boi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" Lapor, 1 orang kena block bosku",
)
async def permitpm(event):
""" İzniniz olmadan size PM gönderenleri yasaklamak içindir. \
Yazmaya devam eden kullanıcıları engeller. """
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 777000 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Bu bölüm basitçe akıl sağlığı kontrolüdür.
# Eğer mesaj daha önceden onaylanmamış olarak gönderildiyse
# flood yapmayı önlemek için unapprove mesajı göndermeyi durdurur.
if not apprv and event.text != PLUGIN_MESAJLAR['pm']:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# Eğer önceden gönderilmiş mesaj farklıysa unapprove mesajı tekrardan gönderilir.
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=PLUGIN_MESAJLAR['pm']):
await message.delete()
await event.reply(PLUGIN_MESAJLAR['pm'])
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(PLUGIN_MESAJLAR['pm'])
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`Sen benim sahibimin PM'ini spamlıyorsun, bu benim hoşuma gitmiyor.`\n"
"`Şu an ENGELLENDIN ve SPAM olarak bildirildin, ileride değişiklik olmadığı sürece..`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"PM sayacı kafayı yemiş gibi, botu lütfen yeniden başlatın.",
)
LOGS.info(
"PM sayacı kafayı yemiş gibi, botu lütfen yeniden başlatın."
)
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" kişisi sadece bir hayal kırıklığı idi. PM'ni meşgul ettiği için engellendi.",
)
async def permitpm(event):
""" İzniniz olmadan size PM gönderenleri yasaklamak içindir. \
Yazmaya devam eden kullanıcıları engeller. """
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 777000 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
if DEFAULT_NAME:
siri_sahip = f"{DEFAULT_NAME}"
else:
siri_sahip = "Sahibim"
reply_user = await event.get_sender()
id = reply_user.id
first_name = str(reply_user.first_name)
if reply_user.last_name:
last_name = str(reply_user.last_name)
else:
last_name = ''
username = '******' + reply_user.username if reply_user.username else f'[{first_name} {last_name}](tg://user?id={id})'
mention = f'[{first_name} {last_name}](tg://user?id={id})'
# Bu bölüm basitçe akıl sağlığı kontrolüdür.
# Eğer mesaj daha önceden onaylanmamış olarak gönderildiyse
# flood yapmayı önlemek için unapprove mesajı göndermeyi durdurur.
if not apprv and event.text != PLUGIN_MESAJLAR['pm']:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# Eğer önceden gönderilmiş mesaj farklıysa unapprove mesajı tekrardan gönderilir.
if event.text != prevmsg:
if type(PLUGIN_MESAJLAR['afk']) is str:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=PLUGIN_MESAJLAR['pm'].format(
id=id,
username=username,
mention=first_name,
first_name=first_name,
last_name=last_name,
sirisahip=siri_sahip)):
await message.delete()
await event.reply(PLUGIN_MESAJLAR['pm'].format(
id=id,
username=username,
mention=mention,
first_name=first_name,
last_name=last_name,
sirisahip=siri_sahip))
else:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
limit=PM_AUTO_BAN_LIMIT + 1):
await message.delete()
if not PLUGIN_MESAJLAR['pm'].text == '':
PLUGIN_MESAJLAR['pm'].text = PLUGIN_MESAJLAR[
'pm'].text.format(id=id,
username=username,
mention=mention,
first_name=first_name,
last_name=last_name,
sirisahip=siri_sahip)
await event.reply(PLUGIN_MESAJLAR['pm'])
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(PLUGIN_MESAJLAR['pm'].format(
id=id,
username=username,
mention=mention,
first_name=first_name,
last_name=last_name,
sirisahip=siri_sahip))
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > PM_AUTO_BAN_LIMIT:
await event.respond(LANG['BLOCKED'])
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
LANG['ERROR'],
)
LOGS.info(LANG['ERROR'])
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" + LANG['BOTLOG_BLOCKED'],
)
async def permitpm(event):
""" Permits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if PM_AUTO_BAN:
if event.is_private and not (await event.get_sender()).bot:
if not is_mongo_alive() or not is_redis_alive():
return
apprv = await approval(event.chat_id)
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
# Searches for previously sent UNAPPROVED_MSGs
async for message in event.client.iter_messages(
event.chat_id, from_user="******", search=UNAPPROVED_MSG
):
# ... and deletes them !!
await message.delete()
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if await notif_state() is False:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`You were spamming my owner's PM, "
"which I don't like.`"
" `Reporting you as spam.`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"PMPermit broke, please restart Paperplane.",
)
LOGS.info("PMPermit broke, please restart Paperplane.")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"["
+ name0
+ "](tg://user?id="
+ str(event.chat_id)
+ ")"
+ " was spamming your PM and has been blocked.",
)
async def permitpm(event):
""" PM """
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if event.is_private and event.chat_id != 777000 and event.chat_id != self_user.id and not (
await event.get_sender()).bot:
try:
from userbot.modules.sql_helper.pm_permit_sql import is_approved
from userbot.modules.sql_helper.globals import gvarstatus
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
reply_user = await event.get_sender()
id = reply_user.id
first_name = str(reply_user.first_name)
if reply_user.last_name:
last_name = str(reply_user.last_name)
else:
last_name = ''
username = '******' + reply_user.username if reply_user.username else f'[{first_name} {last_name}](tg://user?id={id})'
mention = f'[{first_name} {last_name}](tg://user?id={id})'
#
#
#
if not apprv and event.text != PLUGIN_MESAJLAR['pm']:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
#
if event.text != prevmsg:
if type(PLUGIN_MESAJLAR['afk']) is str:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
search=PLUGIN_MESAJLAR['pm'].format(
id=id,
username=username,
mention=first_name,
first_name=first_name,
last_name=last_name)):
await message.delete()
await event.reply(PLUGIN_MESAJLAR['pm'].format(
id=id,
username=username,
mention=mention,
first_name=first_name,
last_name=last_name))
else:
async for message in event.client.iter_messages(
event.chat_id,
from_user='******',
limit=PM_AUTO_BAN_LIMIT + 1):
await message.delete()
if not PLUGIN_MESAJLAR['pm'].text == '':
PLUGIN_MESAJLAR['pm'].text = PLUGIN_MESAJLAR[
'pm'].text.format(id=id,
username=username,
mention=mention,
first_name=first_name,
last_name=last_name)
await event.reply(PLUGIN_MESAJLAR['pm'])
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(PLUGIN_MESAJLAR['pm'].format(
id=id,
username=username,
mention=mention,
first_name=first_name,
last_name=last_name))
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > PM_AUTO_BAN_LIMIT:
await event.respond(LANG['BLOCKED'])
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
LANG['ERROR'],
)
LOGS.info(LANG['ERROR'])
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" + LANG['BOTLOG_BLOCKED'],
)
async def permitpm(event):
"""Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically."""
if PM_AUTO_BAN:
self_user = await event.client.get_me()
if (event.is_private and event.chat_id != 777000
and event.chat_id != self_user.id
and not (await event.get_sender()).bot):
try:
from userbot.modules.sql_helper.globals import gvarstatus
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Use user custom unapproved message
getmsg = gvarstatus("unapproved_msg")
if getmsg is not None:
UNAPPROVED_MSG = getmsg
else:
UNAPPROVED_MSG = DEF_UNAPPROVED_MSG
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id,
from_user="******",
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
else:
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 3:
await event.respond(
"**Anda mengirim spam pesan ke saya.**\n"
"**Anda telah diblokir dan dilaporkan sebagai spam.**\n"
"**Selamat tinggal.**")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Jumlah PM tampaknya akan memperlambat, tolong mulai ulang bot!",
)
return LOGS.info("Jumlah PM menjadikan lambat")
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" telah mengirim spam di PM Anda dan diblokir",
)
async def permitpm(event):
if not PM_AUTO_BAN:
return
self_user = await event.client.get_me()
if (event.is_private and event.chat_id != 777000
and event.chat_id != self_user.id
and not (await event.get_sender()).bot):
try:
from userbot.modules.sql_helper.globals import gvarstatus
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id, from_user="******",
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(UNAPPROVED_MSG)
else:
await event.reply(UNAPPROVED_MSG)
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`You were spamming my Mastor's PM, which I didn't like.`\n"
"`You have been BLOCKED and reported as SPAM, until further notice.`"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Count PM is seemingly going retard, plis restart bot!",
)
return LOGS.info("CountPM wen't rarted boi")
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" + str(event.chat_id) +
")" + " was just another retarded nibba",
)
async def permitpm(event):
""" Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically. """
if not PM_AUTO_BAN:
return
self_user = await event.client.get_me()
if (event.is_private and event.chat_id != 777000
and event.chat_id != self_user.id
and not (await event.get_sender()).bot):
try:
from userbot.modules.sql_helper.globals import gvarstatus
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Use user custom unapproved message
getmsg = gvarstatus("unapproved_msg")
if getmsg is not None:
UNAPPROVED_MSG = getmsg
else:
UNAPPROVED_MSG = DEF_UNAPPROVED_MSG
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id, from_user="******",
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(f"`{UNAPPROVED_MSG}`")
else:
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`Você está spammando meu PM, o que não é permitido.`\n"
"`Não permitirei que mande mensagens novamente até aviso prévio `\n"
"`Cya`")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Contador de PM está aparentemente ficando lento, plis reinicie o bot!",
)
LOGS.info("CountPM wen't rarted boi")
return
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" + str(event.chat_id) +
")" + " era só mais um retardado",
)
async def permitpm(event):
"""Prohibits people from PMing you without approval. \
Will block retarded nibbas automatically."""
if not PM_AUTO_BAN:
return
self_user = await event.client.get_me()
if (
event.is_private
and event.chat_id != 777000
and event.chat_id != self_user.id
and not (await event.get_sender()).bot
):
try:
from userbot.modules.sql_helper.globals import gvarstatus
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Use user custom unapproved message
getmsg = gvarstatus("unapproved_msg")
if getmsg is not None:
UNAPPROVED_MSG = getmsg
else:
UNAPPROVED_MSG = DEF_UNAPPROVED_MSG
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id, from_user="******", search=UNAPPROVED_MSG
):
await message.delete()
await event.reply(f"{UNAPPROVED_MSG}")
else:
await event.reply(f"{UNAPPROVED_MSG}")
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 8:
await event.respond(
"`Anda Telah Di Blokir Karna Melakukan Spam Pesan`\n"
"`Ke Room Chat Lord ツ`\n"
)
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"Terjadi Masalah Saat Menghitung Pesan Pribadi, Mohon Restart Bot!",
)
return LOGS.info(
"Penghitungan Pesan Pribadi Terjadi Kesalahan")
await event.client(BlockRequest(event.chat_id))
await event.client(ReportSpamRequest(peer=event.chat_id))
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"["
+ name0
+ "](tg://user?id="
+ str(event.chat_id)
+ ")"
+ " Terblokir Karna Melakukan Spamming Di Room Chat",
)
async def permitpm(event):
"""Prohibits people from PMing you without approval. Will block retarded nibbas automatically."""
if not PM_AUTO_BAN:
return
self_user = await event.client.get_me()
if (event.is_private and event.chat_id != 777000
and event.chat_id != self_user.id
and not (await event.get_sender()).bot):
try:
from userbot.modules.sql_helper.globals import gvarstatus
from userbot.modules.sql_helper.pm_permit_sql import is_approved
except AttributeError:
return
apprv = is_approved(event.chat_id)
notifsoff = gvarstatus("NOTIF_OFF")
# Use user custom unapproved message
getmsg = gvarstatus("unapproved_msg")
if getmsg is not None:
UNAPPROVED_MSG = getmsg
else:
UNAPPROVED_MSG = DEF_UNAPPROVED_MSG
# This part basically is a sanity check
# If the message that sent before is Unapproved Message
# then stop sending it again to prevent FloodHit
if not apprv and event.text != UNAPPROVED_MSG:
if event.chat_id in LASTMSG:
prevmsg = LASTMSG[event.chat_id]
# If the message doesn't same as previous one
# Send the Unapproved Message again
if event.text != prevmsg:
async for message in event.client.iter_messages(
event.chat_id, from_user="******",
search=UNAPPROVED_MSG):
await message.delete()
await event.reply(f"`{UNAPPROVED_MSG}`")
else:
await event.reply(f"`{UNAPPROVED_MSG}`")
LASTMSG.update({event.chat_id: event.text})
if notifsoff:
await event.client.send_read_acknowledge(event.chat_id)
if event.chat_id not in COUNT_PM:
COUNT_PM.update({event.chat_id: 1})
else:
COUNT_PM[event.chat_id] = COUNT_PM[event.chat_id] + 1
if COUNT_PM[event.chat_id] > 4:
await event.respond(
"`You were spamming my PM, which I didn't like.`\n"
"`I Wouldn't let you to chat me again until further notice`\n"
"`Bye`")
try:
del COUNT_PM[event.chat_id]
del LASTMSG[event.chat_id]
except KeyError:
if BOTLOG:
name = await event.client.get_entity(event.chat_id)
name0 = str(name.first_name)
await event.client.send_message(
BOTLOG_CHATID,
"[" + name0 + "](tg://user?id=" +
str(event.chat_id) + ")" +
" was just another retarded nibba",
)
