Files
2026-11-10 19:12:34 -06:00

568 lines
23 KiB
Python

import json
import time
from collections import deque
from datetime import datetime, timedelta, timezone
import discord
from discord import app_commands
from discord.ext import commands, tasks
import config
import data
import guildconf
import onboarding
VERIFY_TIMEOUT = 24 * 3600
REVIEW_TIMEOUT = 7 * 24 * 3600
NEW_ACCOUNT = timedelta(days=7)
YOUNG_ACCOUNT = timedelta(days=30)
SPIKE_JOINS = 5
SPIKE_WINDOW = 60
RULES_EMOJI = "\u2705"
REVIEW_ACTIONS = {
"approve": ("Approve", discord.ButtonStyle.success),
"kick": ("Kick", discord.ButtonStyle.secondary),
"ban": ("Ban", discord.ButtonStyle.danger),
}
async def dm(member, text):
try:
await member.send(text)
except discord.HTTPException:
pass
def flags_for(member, spike):
age = datetime.now(timezone.utc) - member.created_at
flags = []
if age < NEW_ACCOUNT:
flags.append(f"Account is less than {NEW_ACCOUNT.days} days old")
if spike:
flags.append("Joined during a spike of new members")
if member.avatar is None and age < YOUNG_ACCOUNT:
flags.append("Default avatar on an account under 30 days old")
return flags
class VerifyView(discord.ui.View):
def __init__(self):
super().__init__(timeout=None)
@discord.ui.button(label="Continue", style=discord.ButtonStyle.success,
custom_id="verify:start")
async def start(self, interaction: discord.Interaction, button):
await interaction.client.get_cog("Verification").handle_verify(interaction)
class ReviewButton(
discord.ui.DynamicItem[discord.ui.Button],
template=r"vreview:(?P<action>approve|kick|ban):(?P<uid>[0-9]+)",
):
def __init__(self, action, user_id):
label, style = REVIEW_ACTIONS[action]
super().__init__(discord.ui.Button(
label=label, style=style, custom_id=f"vreview:{action}:{user_id}"))
self.action = action
self.user_id = user_id
@classmethod
async def from_custom_id(cls, interaction, item, match):
return cls(match["action"], int(match["uid"]))
async def callback(self, interaction: discord.Interaction):
await interaction.client.get_cog("Verification").handle_review(
interaction, self.action, self.user_id)
def review_view(user_id):
view = discord.ui.View(timeout=None)
for action in REVIEW_ACTIONS:
view.add_item(ReviewButton(action, user_id))
return view
class Verification(commands.Cog):
def __init__(self, bot):
self.bot = bot
self.joins = deque()
async def cog_load(self):
self.bot.add_view(VerifyView())
self.bot.add_dynamic_items(ReviewButton)
self.sweep.start()
async def cog_unload(self):
self.sweep.cancel()
group = app_commands.Group(
name="verify",
description="Configure member verification",
guild_ids=[config.GUILD.id],
guild_only=True,
default_permissions=discord.Permissions(manage_guild=True),
)
async def enabled(self):
return await self.bot.db.get_setting(guildconf.VERIFY_ENABLED) == "1"
async def verified_role(self, guild):
role_id = await guildconf.get_id(self.bot, guildconf.VERIFIED_ROLE)
return guild.get_role(role_id) if role_id else None
async def review_channel(self, guild):
channel_id = await guildconf.get_id(self.bot, guildconf.VERIFY_REVIEW)
channel = guild.get_channel(channel_id) if channel_id else None
return channel or await guildconf.mod_log_channel(self.bot, guild)
async def track(self, member, spike=False):
now = int(time.time())
await self.bot.db.execute(
"INSERT OR IGNORE INTO pending_verifications "
"(user_id, joined_at, deadline, flags) VALUES (?, ?, ?, ?)",
member.id, now, now + VERIFY_TIMEOUT,
";".join(flags_for(member, spike)))
async def forget(self, user_id):
await self.bot.db.execute(
"DELETE FROM pending_verifications WHERE user_id = ?", user_id)
async def reconcile(self):
guild = self.bot.get_guild(config.GUILD.id)
role = await self.verified_role(guild) if guild else None
if role is None:
return
for member in guild.members:
if not member.bot and role not in member.roles:
await self.track(member)
async def grant(self, member, reason):
"""Gives the member their chosen roles plus Verified in one call."""
guild = member.guild
row = await self.bot.db.fetchone(
"SELECT choices FROM pending_verifications WHERE user_id = ?", member.id)
names = json.loads(row["choices"]) if row and row["choices"] else []
by_name = {r.name: r for r in guild.roles}
roles = [by_name[n] for n in names if n in by_name]
roles.append(await self.verified_role(guild))
await member.add_roles(*roles, reason=reason)
async def clear_rules_reaction(self, guild, user_id):
channel_id = await guildconf.get_id(self.bot, guildconf.VERIFY_CHANNEL)
message_id = await guildconf.get_id(self.bot, guildconf.VERIFY_RULES_MSG)
channel = guild.get_channel(channel_id) if channel_id else None
if channel is None or not message_id:
return
try:
await channel.get_partial_message(message_id).remove_reaction(
RULES_EMOJI, discord.Object(id=user_id))
except discord.HTTPException:
pass
async def send_review(self, member, flags, joined_at, choices):
channel = await self.review_channel(member.guild)
if channel is None:
return False
embed = discord.Embed(
title="Verification review",
description=f"{member.mention} ({member})",
colour=discord.Colour.orange())
embed.set_thumbnail(url=member.display_avatar.url)
embed.add_field(
name="Account created",
value=f"<t:{int(member.created_at.timestamp())}:R>")
embed.add_field(name="Joined", value=f"<t:{joined_at}:R>")
embed.add_field(
name="Flags", value="\n".join(f"- {f}" for f in flags), inline=False)
embed.add_field(
name="Selected roles", value=", ".join(choices) or "None", inline=False)
embed.set_footer(text=f"User ID: {member.id}")
try:
await channel.send(embed=embed, view=review_view(member.id))
except discord.HTTPException:
return False
return True
async def handle_verify(self, interaction):
member, guild = interaction.user, interaction.guild
role = await self.verified_role(guild)
async def say(text):
await interaction.response.send_message(text, ephemeral=True)
if role is None or not await self.enabled():
await say("Verification isn't active right now.")
return
if role in member.roles:
await say("You're already verified.")
return
await self.track(member)
row = await self.bot.db.fetchone(
"SELECT * FROM pending_verifications WHERE user_id = ?", member.id)
if row["in_review"]:
await say("A moderator is already reviewing your account. "
"You'll get access once it's approved.")
return
if not row["rules_ok"]:
await say(f"Please react with {RULES_EMOJI} on the rules message first. "
"If it's already there, remove it, add it again, "
"then press Continue.")
return
missing = onboarding.missing_roles(guild)
if missing:
print(f"verify: missing roles: {missing[:10]}", flush=True)
await say("Setup isn't finished yet. Please let a moderator know.")
return
state = onboarding.State(self)
await interaction.response.send_message(
onboarding.PARTY_TEXT, view=onboarding.party_view(state), ephemeral=True)
async def complete(self, interaction, state):
await interaction.response.edit_message(content="Finishing up...", view=None)
member = interaction.user
names = state.role_names()
async def reply(text):
await interaction.edit_original_response(content=text, view=None)
await self.track(member)
await self.bot.db.execute(
"UPDATE pending_verifications SET choices = ? WHERE user_id = ?",
json.dumps(names), member.id)
row = await self.bot.db.fetchone(
"SELECT * FROM pending_verifications WHERE user_id = ?", member.id)
if row["flags"]:
sent = await self.send_review(
member, row["flags"].split(";"), row["joined_at"], names)
if not sent:
await reply("Verification is temporarily unavailable. "
"Please try again later.")
return
await self.bot.db.execute(
"UPDATE pending_verifications SET in_review = 1, deadline = ? "
"WHERE user_id = ?",
int(time.time()) + REVIEW_TIMEOUT, member.id)
await reply("Thanks! A moderator needs to look at your account "
"before you get access. This can take a while.")
return
try:
await self.grant(member, "Passed verification")
except (discord.HTTPException, AttributeError) as e:
print(f"verify: could not grant roles: {e}", flush=True)
await reply("Something went wrong. Please contact a moderator.")
return
await self.forget(member.id)
await reply("You're verified. Welcome! You can change your roles "
"later from the role panels.")
async def handle_review(self, interaction, action, user_id):
check = guildconf.is_admin if action == "ban" else guildconf.is_mod
if not await check(self.bot, interaction.user):
await interaction.response.send_message(
"You don't have permission to do that.", ephemeral=True)
return
await interaction.response.defer()
guild = interaction.guild
member = guild.get_member(user_id)
by = interaction.user
reason = f"Verification review by {by}"
if member is None:
await self.forget(user_id)
outcome, colour = "User already left the server", discord.Colour.greyple()
else:
try:
if action == "approve":
await self.grant(member, reason)
outcome, colour = "Approved", discord.Colour.green()
elif action == "kick":
await dm(member, f"You were removed from {guild.name} after a "
"verification review. You're welcome to rejoin.")
await member.kick(reason=reason)
await self.bot.db.add_case(
user_id, by.id, "kick", "Failed verification review")
outcome, colour = "Kicked", discord.Colour.red()
else:
await dm(member, f"You were banned from {guild.name} after a "
"verification review.")
await guild.ban(member, reason=reason)
await self.bot.db.add_case(
user_id, by.id, "ban", "Failed verification review")
outcome, colour = "Banned", discord.Colour.red()
except (discord.Forbidden, AttributeError):
await interaction.followup.send(
"I couldn't do that. Check the Verified role exists and that "
"my role is above the member's and above the roles they chose.",
ephemeral=True)
return
await self.forget(user_id)
embed = interaction.message.embeds[0].copy()
embed.colour = colour
embed.add_field(
name="Decision", value=f"{outcome} by {by.mention}", inline=False)
await interaction.edit_original_response(embed=embed, view=None)
@commands.Cog.listener()
async def on_member_join(self, member):
if member.guild.id != config.GUILD.id or not await self.enabled():
return
role = await self.verified_role(member.guild)
if role is None:
return
if member.bot:
await member.add_roles(role, reason="Bot account")
return
now = time.time()
self.joins.append(now)
while self.joins and now - self.joins[0] > SPIKE_WINDOW:
self.joins.popleft()
await self.track(member, spike=len(self.joins) >= SPIKE_JOINS)
@commands.Cog.listener()
async def on_member_remove(self, member):
if member.guild.id == config.GUILD.id:
await self.forget(member.id)
await self.clear_rules_reaction(member.guild, member.id)
async def rules_reaction(self, payload, value):
if (payload.guild_id != config.GUILD.id
or payload.user_id == self.bot.user.id
or str(payload.emoji) != RULES_EMOJI):
return
message_id = await guildconf.get_id(self.bot, guildconf.VERIFY_RULES_MSG)
if payload.message_id != message_id:
return
await self.bot.db.execute(
"UPDATE pending_verifications SET rules_ok = ? WHERE user_id = ?",
value, payload.user_id)
@commands.Cog.listener()
async def on_raw_reaction_add(self, payload):
await self.rules_reaction(payload, 1)
@commands.Cog.listener()
async def on_raw_reaction_remove(self, payload):
await self.rules_reaction(payload, 0)
@tasks.loop(minutes=1)
async def sweep(self):
"""Kicks members who missed their verification deadline."""
try:
if not await self.enabled():
return
guild = self.bot.get_guild(config.GUILD.id)
role = await self.verified_role(guild) if guild else None
if role is None:
return
rows = await self.bot.db.fetchall(
"SELECT user_id FROM pending_verifications WHERE deadline < ?",
int(time.time()))
for row in rows:
member = guild.get_member(row["user_id"])
await self.forget(row["user_id"])
if (member is None or role in member.roles
or await guildconf.is_mod(self.bot, member)):
continue
await dm(member, f"You were removed from {guild.name} because you "
"didn't verify in time. You're welcome to rejoin.")
try:
await member.kick(reason="Did not verify in time")
except discord.HTTPException as e:
print(f"verify sweep: could not kick {member.id}: {e}", flush=True)
except Exception as e:
print(f"verify sweep: unexpected error: {e!r}", flush=True)
@sweep.before_loop
async def before_sweep(self):
await self.bot.wait_until_ready()
if await self.enabled():
await self.reconcile()
@group.command(name="setup",
description="Create the Verified role and prepare the verify channel")
@app_commands.describe(
channel="The channel unverified members will see",
review_channel="Where flagged members are sent for review (default: mod log)")
@guildconf.admin_only()
async def setup_cmd(self, interaction: discord.Interaction,
channel: discord.TextChannel,
review_channel: discord.TextChannel | None = None):
await interaction.response.defer(ephemeral=True)
guild = interaction.guild
role = (await self.verified_role(guild)
or discord.utils.get(guild.roles, name="Verified"))
reason = "Verification setup"
step = "creating the Verified role"
try:
if role is None:
role = await guild.create_role(
name="Verified",
permissions=discord.Permissions(view_channel=True),
reason=reason)
elif not role.permissions.view_channel:
step = "editing the Verified role"
perms = role.permissions
perms.view_channel = True
await role.edit(permissions=perms, reason=reason)
step = f"setting permissions for @everyone in {channel.mention}"
await channel.set_permissions(
guild.default_role, reason=reason,
overwrite=discord.PermissionOverwrite(
view_channel=True, read_message_history=True,
add_reactions=True, send_messages=False,
create_public_threads=False,
create_private_threads=False,
send_messages_in_threads=False))
step = f"setting permissions for Verified in {channel.mention}"
await channel.set_permissions(
role, reason=reason,
overwrite=discord.PermissionOverwrite(view_channel=False))
step = f"setting permissions for the bot in {channel.mention}"
await channel.set_permissions(
guild.me, reason=reason,
overwrite=discord.PermissionOverwrite(
view_channel=True, send_messages=True, embed_links=True,
add_reactions=True, read_message_history=True,
manage_messages=True))
except discord.Forbidden as e:
await interaction.followup.send(
f"Discord refused while {step}: {e.text}", ephemeral=True)
return
db = self.bot.db
await db.set_setting(guildconf.VERIFIED_ROLE, role.id)
await db.set_setting(guildconf.VERIFY_CHANNEL, channel.id)
if review_channel is not None:
await db.set_setting(guildconf.VERIFY_REVIEW, review_channel.id)
await interaction.followup.send(
f"Verified role: {role.mention}\nVerify channel: {channel.mention}\n"
"Next: `/verify panel`, `/verify grandfather`, then `/verify enable`.",
ephemeral=True)
@group.command(name="panel",
description="Post the rules and Continue button in the verify channel")
@guildconf.admin_only()
async def panel(self, interaction: discord.Interaction):
await interaction.response.defer(ephemeral=True)
channel_id = await guildconf.get_id(self.bot, guildconf.VERIFY_CHANNEL)
channel = interaction.guild.get_channel(channel_id) if channel_id else None
if channel is None:
await interaction.followup.send("Run `/verify setup` first.", ephemeral=True)
return
message = await channel.send(
embed=discord.Embed(
description=data.RULES_TEXT,
colour=discord.Colour(config.LIGHT_BLUE)),
view=VerifyView())
await message.add_reaction(RULES_EMOJI)
await self.bot.db.set_setting(guildconf.VERIFY_RULES_MSG, message.id)
await interaction.followup.send(f"Posted in {channel.mention}.", ephemeral=True)
@group.command(name="grandfather",
description="Give Verified to everyone already in the server")
@guildconf.admin_only()
async def grandfather(self, interaction: discord.Interaction):
await interaction.response.defer(ephemeral=True)
guild = interaction.guild
role = await self.verified_role(guild)
if role is None:
await interaction.followup.send("Run `/verify setup` first.", ephemeral=True)
return
done = failed = 0
for member in [m for m in guild.members if role not in m.roles]:
try:
await member.add_roles(role, reason="Existing member")
done += 1
except discord.HTTPException:
failed += 1
msg = f"Gave Verified to {done} members."
if failed:
msg += f" Failed for {failed}. Check my role position."
await interaction.followup.send(msg, ephemeral=True)
@group.command(name="enable",
description="Turn the verification gate on")
@guildconf.admin_only()
async def enable(self, interaction: discord.Interaction):
await interaction.response.defer(ephemeral=True)
guild = interaction.guild
role = await self.verified_role(guild)
channel_id = await guildconf.get_id(self.bot, guildconf.VERIFY_CHANNEL)
rules_id = await guildconf.get_id(self.bot, guildconf.VERIFY_RULES_MSG)
problem = None
if role is None or not channel_id or guild.get_channel(channel_id) is None:
problem = "Run `/verify setup` first."
elif not rules_id:
problem = "Run `/verify panel` first."
elif await self.review_channel(guild) is None:
problem = "Set a mod log (`/config modlog`) or a review channel first."
elif not guild.me.guild_permissions.view_channel:
problem = "My role needs the View Channels permission."
elif onboarding.missing_roles(guild):
problem = "Some self-assign roles are missing. Run `/setup_roles` first."
else:
missing = [m for m in guild.members if role not in m.roles]
if missing:
problem = (f"{len(missing)} members don't have Verified yet. "
"Run `/verify grandfather` first.")
if problem:
await interaction.followup.send(problem, ephemeral=True)
return
try:
perms = guild.default_role.permissions
perms.view_channel = False
await guild.default_role.edit(permissions=perms, reason="Verification enabled")
except discord.Forbidden:
await interaction.followup.send(
"I couldn't edit @everyone. I need Manage Roles.", ephemeral=True)
return
await self.bot.db.set_setting(guildconf.VERIFY_ENABLED, 1)
await interaction.followup.send(
"Verification is on. New members must verify to see the server.",
ephemeral=True)
@group.command(name="disable",
description="Turn the verification gate off")
@guildconf.admin_only()
async def disable(self, interaction: discord.Interaction):
await interaction.response.defer(ephemeral=True)
guild = interaction.guild
try:
perms = guild.default_role.permissions
perms.view_channel = True
await guild.default_role.edit(permissions=perms, reason="Verification disabled")
except discord.Forbidden:
await interaction.followup.send(
"I couldn't edit @everyone. I need Manage Roles.", ephemeral=True)
return
await self.bot.db.set_setting(guildconf.VERIFY_ENABLED, 0)
await self.bot.db.execute("DELETE FROM pending_verifications")
await interaction.followup.send(
"Verification is off and everyone can see the server again.",
ephemeral=True)
async def setup(bot):
await bot.add_cog(Verification(bot))