720 lines
29 KiB
Python
720 lines
29 KiB
Python
# modules/pirate_report/pirate_report.py
|
||
import re
|
||
import time
|
||
from datetime import datetime, timezone
|
||
from urllib.parse import urlparse
|
||
import discord
|
||
from discord.ext import commands
|
||
from discord import app_commands
|
||
from modules.common.settings import cfg
|
||
|
||
from mod_perms import (
|
||
is_moderator_member,
|
||
is_moderator_userid,
|
||
require_mod_ctx,
|
||
require_mod_interaction,
|
||
)
|
||
|
||
CHECK = '✅'
|
||
CROSS = '❌'
|
||
|
||
# --------------------- Helpers ---------------------
|
||
|
||
_ACCT_RE = re.compile(r'.+#\d{5}$')
|
||
|
||
DISCORD_MEDIA_HOSTS = {"cdn.discordapp.com", "media.discordapp.net"}
|
||
MEDIA_EXTS_IMAGE = {".png", ".jpg", ".jpeg", ".gif", ".webp"}
|
||
MEDIA_EXTS_VIDEO = {".mp4", ".webm", ".mov"}
|
||
MEDIA_EXTS_ALL = MEDIA_EXTS_IMAGE | MEDIA_EXTS_VIDEO
|
||
|
||
|
||
def _acct_ok(s: str) -> bool:
|
||
return bool(_ACCT_RE.fullmatch(s.strip()))
|
||
|
||
|
||
def _now_utc_str() -> str:
|
||
return datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M UTC')
|
||
|
||
|
||
def _parse_bool(s: str) -> bool:
|
||
v = s.strip().lower()
|
||
if v in ('y', 'yes', 'true', 't', '1'):
|
||
return True
|
||
if v in ('n', 'no', 'false', 'f', '0'):
|
||
return False
|
||
raise ValueError("Please enter yes or no")
|
||
|
||
|
||
def _classify_discord_media(url: str):
|
||
"""
|
||
Return ('image'|'video', normalized_url) if valid Discord CDN media; else (None, reason).
|
||
We only accept direct CDN links so media can render inline without leaving the channel.
|
||
"""
|
||
try:
|
||
u = url.strip()
|
||
if not u:
|
||
return (None, "Empty URL.")
|
||
pr = urlparse(u)
|
||
if pr.scheme not in ("http", "https"):
|
||
return (None, "URL must start with http:// or https://")
|
||
host = pr.netloc.lower()
|
||
if host not in DISCORD_MEDIA_HOSTS:
|
||
return (None, "URL must be a **Discord media** link (cdn.discordapp.com or media.discordapp.net).")
|
||
path = pr.path or ""
|
||
dot = path.rfind(".")
|
||
if dot == -1:
|
||
return (None, "URL must end with a known media file extension.")
|
||
ext = path[dot:].lower()
|
||
if ext not in MEDIA_EXTS_ALL:
|
||
return (None, f"Unsupported media type `{ext}`. Allowed: images {sorted(MEDIA_EXTS_IMAGE)}, videos {sorted(MEDIA_EXTS_VIDEO)}.")
|
||
kind = "image" if ext in MEDIA_EXTS_IMAGE else "video"
|
||
return (kind, u)
|
||
except Exception:
|
||
return (None, "Invalid URL format.")
|
||
|
||
|
||
def _jump_url(guild_id: int, channel_id: int, message_id: int) -> str:
|
||
return f"https://discord.com/channels/{guild_id}/{channel_id}/{message_id}"
|
||
|
||
|
||
def _make_report_embed(title: str, color: discord.Color, report_dict: dict, include_status: bool = False):
|
||
e = discord.Embed(title=title, color=color, timestamp=datetime.utcnow())
|
||
e.add_field(name="Character", value=report_dict['character_name'], inline=False)
|
||
e.add_field(name="Account", value=report_dict['account_name'], inline=False)
|
||
e.add_field(name="Submitted by", value=f"<@{report_dict['submitter_id']}>", inline=False)
|
||
|
||
proof_url = (report_dict.get('proof_url') or "").strip()
|
||
proof_type = (report_dict.get('proof_type') or "").strip()
|
||
|
||
if include_status:
|
||
e.add_field(
|
||
name="Status",
|
||
value=report_dict.get('status_line', 'Pending'),
|
||
inline=False
|
||
)
|
||
|
||
# Show proof inline if it's an image; for videos we'll keep the URL in message content.
|
||
if proof_url and proof_type == 'image':
|
||
e.set_image(url=proof_url)
|
||
|
||
# Add a compact proof field for quick visibility (always safe to include)
|
||
e.add_field(
|
||
name="Proof",
|
||
value=proof_url if proof_url else "_No proof provided — strongly encouraged._",
|
||
inline=False
|
||
)
|
||
|
||
# A small hint footer
|
||
e.set_footer(text="Attach proof when possible to speed up moderation.")
|
||
return e
|
||
|
||
|
||
# --------------------- Views ----------------------
|
||
|
||
class ReportJumpView(discord.ui.View):
|
||
"""Simple link button to jump to the user's original ack message."""
|
||
def __init__(self, url: str):
|
||
super().__init__(timeout=None)
|
||
if url:
|
||
self.add_item(discord.ui.Button(label="Jump to message", style=discord.ButtonStyle.link, url=url))
|
||
|
||
|
||
# --------------------- Modals ----------------------
|
||
|
||
class ReportModal(discord.ui.Modal, title="Submit Pirate Report"):
|
||
def __init__(self, cog: "PirateReportCog"):
|
||
super().__init__()
|
||
self.cog = cog
|
||
|
||
self.character_name = discord.ui.TextInput(
|
||
label="In-game nickname",
|
||
placeholder="e.g., SandStalker",
|
||
max_length=64,
|
||
required=True
|
||
)
|
||
self.account_name = discord.ui.TextInput(
|
||
label="Account (Name#12345)",
|
||
placeholder="Must end with # and 5 digits",
|
||
max_length=64,
|
||
required=True
|
||
)
|
||
self.proof_url = discord.ui.TextInput(
|
||
label="Proof (Discord media URL — optional)",
|
||
placeholder="Direct Discord CDN link to image/video (highly encouraged, but optional)",
|
||
required=False,
|
||
max_length=300
|
||
)
|
||
|
||
self.add_item(self.character_name)
|
||
self.add_item(self.account_name)
|
||
self.add_item(self.proof_url)
|
||
|
||
async def on_submit(self, interaction: discord.Interaction):
|
||
if not interaction.guild:
|
||
return await interaction.response.send_message("Use this in a server.", ephemeral=True)
|
||
|
||
char = self.character_name.value.strip()
|
||
acct = self.account_name.value.strip()
|
||
proof_raw = (self.proof_url.value or "").strip()
|
||
|
||
if not _acct_ok(acct):
|
||
return await interaction.response.send_message(
|
||
"❌ Invalid account format. It must end with `#` and **five digits** (e.g. `SomeUser#12345`).",
|
||
ephemeral=True
|
||
)
|
||
|
||
proof_type = ""
|
||
proof_val = ""
|
||
if proof_raw:
|
||
pt, pv = _classify_discord_media(proof_raw)
|
||
if pt is None:
|
||
return await interaction.response.send_message(f"❌ Invalid proof link: {pv}", ephemeral=True)
|
||
proof_type, proof_val = pt, pv # valid
|
||
|
||
dm = self.cog.bot.data_manager
|
||
char_l = char.lower()
|
||
acct_l = acct.lower()
|
||
|
||
# Anti-spam: 60s per reporter
|
||
now = time.time()
|
||
recent = [r for r in dm.get('reports')
|
||
if r.get('submitter_id') == interaction.user.id and (now - r.get('ts', now)) < 60]
|
||
if recent:
|
||
return await interaction.response.send_message("⏱️ Please wait 60 seconds before submitting another report.", ephemeral=True)
|
||
|
||
# Already approved?
|
||
if any(p['account_name'].lower() == acct_l for p in dm.get('pirates')):
|
||
return await interaction.response.send_message("❌ This player is already in the pirate list.", ephemeral=True)
|
||
|
||
# Pending duplicate?
|
||
if any(r['character_name'].lower() == char_l and r['account_name'].lower() == acct_l for r in dm.get('reports')):
|
||
return await interaction.response.send_message("⏳ A report for this player is already pending moderation.", ephemeral=True)
|
||
|
||
# Acknowledge in channel so we can edit later when approved/rejected
|
||
try:
|
||
ack = await interaction.channel.send(f"{interaction.user.mention} thanks — your report was sent to moderators for review.")
|
||
except Exception as e:
|
||
print("[pirate_report] ack send failed:", repr(e))
|
||
ack = None
|
||
|
||
# Send to mod channel with ✅/❌, including inline media if present
|
||
mod_ch = interaction.guild.get_channel(self.cog.mod_channel)
|
||
if not mod_ch:
|
||
return await interaction.response.send_message("❌ Mod channel not configured.", ephemeral=True)
|
||
|
||
report_payload = {
|
||
'character_name': char,
|
||
'account_name': acct,
|
||
'submitter_id': interaction.user.id,
|
||
'proof_url': proof_val,
|
||
'proof_type': proof_type,
|
||
}
|
||
|
||
# Build jump button (if ack exists)
|
||
view = None
|
||
if ack:
|
||
try:
|
||
url = _jump_url(interaction.guild.id, interaction.channel.id, ack.id)
|
||
view = ReportJumpView(url)
|
||
except Exception:
|
||
view = None
|
||
|
||
try:
|
||
embed = _make_report_embed("🚩 Pirate Report", discord.Color.orange(), report_payload, include_status=False)
|
||
# Video must be in message content for inline player; images live in the embed
|
||
content = proof_val if proof_type == 'video' else None
|
||
mod_msg = await mod_ch.send(content=content, embed=embed, view=view)
|
||
await mod_msg.add_reaction(CHECK)
|
||
await mod_msg.add_reaction(CROSS)
|
||
except Exception as e:
|
||
print("[pirate_report] mod message failed:", repr(e))
|
||
return await interaction.response.send_message("❌ Failed to send to mod channel.", ephemeral=True)
|
||
|
||
dm.add('reports', {
|
||
'report_id': mod_msg.id,
|
||
'guild_id': interaction.guild.id,
|
||
'character_name': char,
|
||
'account_name': acct,
|
||
'submitter_id': interaction.user.id,
|
||
'origin_channel_id': interaction.channel.id if interaction.channel else 0,
|
||
'ack_message_id': ack.id if ack else 0,
|
||
'status': 'pending',
|
||
'ts': now,
|
||
'proof_url': proof_val,
|
||
'proof_type': proof_type,
|
||
})
|
||
|
||
await interaction.response.send_message("✅ Report submitted to moderators.", ephemeral=True)
|
||
|
||
|
||
class EditPirateModal(discord.ui.Modal, title="Edit Pirate Entry"):
|
||
def __init__(self, cog: "PirateReportCog"):
|
||
super().__init__()
|
||
self.cog = cog
|
||
|
||
self.old_account = discord.ui.TextInput(
|
||
label="Current account (Name#12345)",
|
||
placeholder="Exact current account in the list",
|
||
max_length=64,
|
||
required=True
|
||
)
|
||
self.new_character = discord.ui.TextInput(
|
||
label="New in-game nickname (optional)",
|
||
placeholder="Leave blank to keep existing",
|
||
max_length=64,
|
||
required=False
|
||
)
|
||
self.new_account = discord.ui.TextInput(
|
||
label="New account (optional, Name#12345)",
|
||
placeholder="Leave blank to keep existing",
|
||
max_length=64,
|
||
required=False
|
||
)
|
||
|
||
self.add_item(self.old_account)
|
||
self.add_item(self.new_character)
|
||
self.add_item(self.new_account)
|
||
|
||
async def on_submit(self, interaction: discord.Interaction):
|
||
if not interaction.guild:
|
||
return await interaction.response.send_message("Use this in a server.", ephemeral=True)
|
||
|
||
if not is_moderator_member(interaction.user, self.cog.bot):
|
||
return await interaction.response.send_message("This action is restricted to moderators.", ephemeral=True)
|
||
|
||
old_acct = self.old_account.value.strip()
|
||
new_char = (self.new_character.value or "").strip()
|
||
new_acct = (self.new_account.value or "").strip()
|
||
|
||
if not new_char and not new_acct:
|
||
return await interaction.response.send_message(
|
||
"❌ Provide **at least one** of: new nickname or new account.",
|
||
ephemeral=True
|
||
)
|
||
|
||
dm = self.cog.bot.data_manager
|
||
pirates = dm.get('pirates')
|
||
rec = next((p for p in pirates if p['account_name'].lower() == old_acct.lower()), None)
|
||
if not rec:
|
||
return await interaction.response.send_message("❌ Pirate not found.", ephemeral=True)
|
||
|
||
if new_acct:
|
||
if not _acct_ok(new_acct):
|
||
return await interaction.response.send_message("❌ Invalid new account format (Name#12345).", ephemeral=True)
|
||
if new_acct.lower() != old_acct.lower() and any(p['account_name'].lower() == new_acct.lower() for p in pirates):
|
||
return await interaction.response.send_message("❌ Another pirate already has that account.", ephemeral=True)
|
||
|
||
before = rec.copy()
|
||
dm.remove('pirates', lambda p: p['account_name'].lower() == old_acct.lower())
|
||
if new_char:
|
||
rec['character_name'] = new_char
|
||
if new_acct:
|
||
rec['account_name'] = new_acct
|
||
dm.add('pirates', rec)
|
||
|
||
await self.cog._modlog(
|
||
interaction.guild,
|
||
f"✏️ Edited pirate by {interaction.user.mention}: "
|
||
f"{'name ' + before['character_name'] + ' → ' + rec['character_name'] if new_char else ''} "
|
||
f"{'/ account ' + before['account_name'] + ' → ' + rec['account_name'] if new_acct else ''}".strip()
|
||
)
|
||
await interaction.response.send_message("✅ Pirate updated.", ephemeral=True)
|
||
await self.cog._refresh_pirates_list(interaction.guild)
|
||
|
||
|
||
class EncounterModal(discord.ui.Modal, title="Log Pirate Encounter"):
|
||
def __init__(self, cog: "PirateReportCog"):
|
||
super().__init__()
|
||
self.cog = cog
|
||
|
||
self.identifier = discord.ui.TextInput(
|
||
label="Pirate (name or account)",
|
||
placeholder="MuadDib or MuadDib#12345",
|
||
required=True,
|
||
max_length=64
|
||
)
|
||
self.group_size = discord.ui.TextInput(
|
||
label="Group size (including this pirate)",
|
||
placeholder="How many pirates were in the group?",
|
||
required=True
|
||
)
|
||
self.kills = discord.ui.TextInput(
|
||
label="Kills (integer ≥ 0; 0 = none/unknown)",
|
||
placeholder="How many did the pirate kill during the encounter",
|
||
required=True
|
||
)
|
||
self.destruction = discord.ui.TextInput(
|
||
label="Destructive? (yes/no)",
|
||
placeholder="Did they destroy a base/ornithopter? yes or no",
|
||
required=True
|
||
)
|
||
self.skill = discord.ui.TextInput(
|
||
label="Perceived Skill (0–5, 0 = unknown)",
|
||
placeholder="0..5",
|
||
required=True
|
||
)
|
||
|
||
self.add_item(self.identifier)
|
||
self.add_item(self.group_size)
|
||
self.add_item(self.kills)
|
||
self.add_item(self.destruction)
|
||
self.add_item(self.skill)
|
||
|
||
async def on_submit(self, interaction: discord.Interaction):
|
||
ident_raw = self.identifier.value.strip()
|
||
guild = interaction.guild
|
||
if guild is None:
|
||
return await interaction.response.send_message("This can only be used in a server.", ephemeral=True)
|
||
|
||
# Parse numeric fields
|
||
try:
|
||
group_size = int(self.group_size.value.strip()); assert group_size >= 1
|
||
except Exception:
|
||
return await interaction.response.send_message("❌ **Group size** must be an integer ≥ 1.", ephemeral=True)
|
||
try:
|
||
kills = int(self.kills.value.strip()); assert kills >= 0
|
||
except Exception:
|
||
return await interaction.response.send_message("❌ **Kills** must be an integer ≥ 0.", ephemeral=True)
|
||
try:
|
||
destruction = _parse_bool(self.destruction.value)
|
||
except ValueError:
|
||
return await interaction.response.send_message("❌ **Destructive** must be **yes** or **no**.", ephemeral=True)
|
||
try:
|
||
skill = int(self.skill.value.strip()); assert 0 <= skill <= 5
|
||
except Exception:
|
||
return await interaction.response.send_message("❌ **Skill** must be an integer between **0** and **5**.", ephemeral=True)
|
||
|
||
# Resolve to a single pirate record and canonical account identifier
|
||
pirate, error = self.cog.resolve_pirate(ident_raw)
|
||
if error:
|
||
return await interaction.response.send_message(error, ephemeral=True)
|
||
if not pirate:
|
||
return await interaction.response.send_message(
|
||
"❌ No such pirate registered. Ask a moderator to add them, or submit a **/report** for review.",
|
||
ephemeral=True
|
||
)
|
||
|
||
canonical_acct = pirate['account_name'] # <- always store account here
|
||
acct_l = canonical_acct.lower()
|
||
char_l = pirate['character_name'].lower()
|
||
|
||
dm = self.cog.bot.data_manager
|
||
now = time.time()
|
||
|
||
# Rate-limit by canonical account
|
||
recent = [
|
||
e for e in dm.get('encounters')
|
||
if e['reporter_id'] == interaction.user.id
|
||
and e.get('identifier','').lower() in (acct_l, char_l) # respect legacy
|
||
and (now - e['timestamp']) < 600
|
||
]
|
||
if recent:
|
||
return await interaction.response.send_message(
|
||
"⏱️ You can only report the same pirate once every **10 minutes**.",
|
||
ephemeral=True
|
||
)
|
||
|
||
# Store with canonical account as identifier
|
||
rec = {
|
||
'identifier': canonical_acct,
|
||
'reporter_id': interaction.user.id,
|
||
'timestamp': now,
|
||
'group_size': group_size,
|
||
'kills': kills,
|
||
'destruction': destruction,
|
||
'skill': skill
|
||
}
|
||
dm.add('encounters', rec)
|
||
|
||
# Recalculate threat (count both new account-based and legacy name-based entries)
|
||
encs = [e for e in dm.get('encounters') if e.get('identifier','').lower() in (acct_l, char_l)]
|
||
total = len(encs)
|
||
if total:
|
||
group_threshold = self.cog.group_threshold
|
||
kill_rate = sum(e['kills'] > 0 for e in encs) / total
|
||
group_rate = sum(e['group_size'] >= group_threshold for e in encs) / total
|
||
destroy_rate = sum(bool(e['destruction']) for e in encs) / total
|
||
skill_samples = [e['skill'] / 5 for e in encs if e['skill'] > 0]
|
||
skill_rate = (sum(skill_samples) / len(skill_samples)) if skill_samples else 0.0
|
||
|
||
w_k, w_d, w_g, w_s = self.cog.w_kill, self.cog.w_destruction, self.cog.w_group, self.cog.w_skill
|
||
weighted = (w_k * kill_rate) + (w_d * destroy_rate) + (w_g * group_rate) + (w_s * skill_rate)
|
||
threat_level = int(round(100 * min(1.0, max(0.0, weighted))))
|
||
|
||
# Update pirate record
|
||
pirates = dm.get('pirates')
|
||
def match(p): return p['account_name'].lower() == acct_l
|
||
rec0 = next((p for p in pirates if match(p)), None)
|
||
if rec0:
|
||
dm.remove('pirates', match)
|
||
rec0.update({'threat_level': threat_level, 'encounter_count': total})
|
||
dm.add('pirates', rec0)
|
||
|
||
await interaction.response.send_message(
|
||
f"✅ Encounter recorded for **{canonical_acct}**.",
|
||
ephemeral=True
|
||
)
|
||
|
||
await self.cog._refresh_pirates_list(interaction.guild)
|
||
|
||
|
||
# -------------- Cog: commands + listeners ---------------
|
||
|
||
class PirateReportCog(commands.Cog):
|
||
def __init__(self, bot):
|
||
self.bot = bot
|
||
r = cfg(bot)
|
||
|
||
# Channels
|
||
self.mod_channel = r.int('mod_channel_id', 0)
|
||
self.modlog_channel_id = r.int('modlog_channel_id', 0)
|
||
|
||
# Threat config
|
||
self.group_threshold = r.int('threat_group_threshold', 3)
|
||
|
||
def _f(key: str, default: float) -> float:
|
||
try:
|
||
return float(r.get(key, str(default)))
|
||
except Exception:
|
||
return default
|
||
|
||
self.w_kill = _f('threat_w_kill', 0.35)
|
||
self.w_destruction = _f('threat_w_destruction', 0.30)
|
||
self.w_group = _f('threat_w_group', 0.20)
|
||
self.w_skill = _f('threat_w_skill', 0.15)
|
||
|
||
async def _refresh_pirates_list(self, guild: discord.Guild):
|
||
plist = self.bot.get_cog('PiratesListCog')
|
||
if plist:
|
||
await plist.refresh_list(guild)
|
||
|
||
async def _modlog(self, guild: discord.Guild, content: str):
|
||
if not self.modlog_channel_id:
|
||
return
|
||
ch = guild.get_channel(self.modlog_channel_id)
|
||
if ch:
|
||
try:
|
||
await ch.send(content)
|
||
except Exception as e:
|
||
print("[pirate_report] modlog send failed:", repr(e))
|
||
self.bot.data_manager.add('modlog', {'ts': time.time(), 'guild_id': guild.id, 'content': content})
|
||
|
||
# --- Resolver: name/account -> pirate record (handles ambiguity) ---
|
||
def resolve_pirate(self, ident: str):
|
||
"""Return (pirate_record or None, error_message or None)."""
|
||
dm = self.bot.data_manager
|
||
pirates = dm.get('pirates')
|
||
s = ident.strip()
|
||
s_l = s.lower()
|
||
if '#' in s and _acct_ok(s):
|
||
rec = next((p for p in pirates if p['account_name'].lower() == s_l), None)
|
||
return (rec, None)
|
||
# resolve by character; must be unambiguous
|
||
matches = [p for p in pirates if p['character_name'].lower() == s_l]
|
||
if not matches:
|
||
return (None, None)
|
||
if len(matches) > 1:
|
||
return (None, "❌ That character name is **ambiguous**. Please use the account (e.g. `Name#12345`).")
|
||
return (matches[0], None)
|
||
|
||
# Remove pirate (mod-only)
|
||
@app_commands.command(name="remove_pirate", description="[MOD] Remove an approved pirate entry")
|
||
@app_commands.describe(account_name="Account name to remove")
|
||
async def remove_pirate(self, interaction: discord.Interaction, account_name: str):
|
||
if not interaction.guild:
|
||
return await interaction.response.send_message("Use this in a server.", ephemeral=True)
|
||
if not await require_mod_interaction(interaction, "This command is restricted to moderators."):
|
||
return
|
||
|
||
acct_lower = account_name.strip().lower()
|
||
dm = self.bot.data_manager
|
||
if not any(p['account_name'].lower() == acct_lower for p in dm.get('pirates')):
|
||
return await interaction.response.send_message("Pirate not found.", ephemeral=True)
|
||
|
||
dm.remove('pirates', lambda p: p['account_name'].lower() == acct_lower)
|
||
await self._modlog(interaction.guild, f"🗑️ Removed pirate {account_name} by {interaction.user.mention}")
|
||
await self._refresh_pirates_list(interaction.guild)
|
||
await interaction.response.send_message("Removed.", ephemeral=True)
|
||
|
||
# Modal launchers
|
||
@app_commands.command(name="report", description="Submit a pirate report for moderator review (opens a form)")
|
||
async def report(self, interaction: discord.Interaction):
|
||
if not interaction.guild:
|
||
return await interaction.response.send_message("Use this in a server.", ephemeral=True)
|
||
await interaction.response.send_modal(ReportModal(self))
|
||
|
||
@app_commands.command(name="edit_pirate", description="[MOD] Edit a pirate entry (opens a form)")
|
||
async def edit_pirate(self, interaction: discord.Interaction):
|
||
if not await require_mod_interaction(interaction):
|
||
return
|
||
await interaction.response.send_modal(EditPirateModal(self))
|
||
|
||
@app_commands.command(name="encounter", description="Log a pirate encounter (opens a form)")
|
||
async def encounter(self, interaction: discord.Interaction):
|
||
if not interaction.guild:
|
||
return await interaction.response.send_message("Use this in a server.", ephemeral=True)
|
||
await interaction.response.send_modal(EncounterModal(self))
|
||
|
||
# ---- Migration: convert encounter identifiers to accounts (mod-only) ----
|
||
@app_commands.command(name="encounters_migrate_ids", description="[MOD] Migrate encounter identifiers to account names")
|
||
async def encounters_migrate_ids(self, interaction: discord.Interaction):
|
||
if not interaction.guild:
|
||
return await interaction.response.send_message("Use this in a server.", ephemeral=True)
|
||
if not await require_mod_interaction(interaction, "This command is restricted to moderators."):
|
||
return
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
|
||
dm = self.bot.data_manager
|
||
pirates = dm.get('pirates')
|
||
by_char = {}
|
||
for p in pirates:
|
||
by_char.setdefault(p['character_name'].lower(), []).append(p)
|
||
by_acct = {p['account_name'].lower(): p for p in pirates}
|
||
|
||
changed = ambiguous = missing = already = 0
|
||
|
||
for e in dm.get('encounters'):
|
||
ident = e.get('identifier', '')
|
||
if not ident:
|
||
continue
|
||
if '#' in ident:
|
||
already += 1
|
||
continue
|
||
key = ident.lower()
|
||
matches = by_char.get(key, [])
|
||
if not matches:
|
||
missing += 1
|
||
continue
|
||
if len(matches) > 1:
|
||
ambiguous += 1
|
||
continue
|
||
acct = matches[0]['account_name']
|
||
|
||
def pred(x, ts=e['timestamp'], rid=e['reporter_id'], ident_old=ident):
|
||
return x.get('timestamp') == ts and x.get('reporter_id') == rid and x.get('identifier') == ident_old
|
||
def upd(x, acct_new=acct):
|
||
x['identifier'] = acct_new
|
||
return x
|
||
|
||
ok = dm.update('encounters', pred, upd)
|
||
if ok:
|
||
changed += 1
|
||
|
||
await interaction.followup.send(
|
||
"Migration complete.\n"
|
||
f"- Updated to accounts: **{changed}**\n"
|
||
f"- Already accounts: **{already}**\n"
|
||
f"- Ambiguous character names (skipped): **{ambiguous}**\n"
|
||
f"- Not found in pirates list (skipped): **{missing}**",
|
||
ephemeral=True
|
||
)
|
||
|
||
await self._refresh_pirates_list(interaction.guild)
|
||
|
||
# Moderator reaction handling (atomic claim)
|
||
@commands.Cog.listener()
|
||
async def on_raw_reaction_add(self, payload: discord.RawReactionActionEvent):
|
||
if (
|
||
payload.channel_id != self.mod_channel
|
||
or str(payload.emoji) not in (CHECK, CROSS)
|
||
or payload.user_id == self.bot.user.id
|
||
):
|
||
return
|
||
|
||
channel = self.bot.get_channel(payload.channel_id)
|
||
if not channel or not channel.guild:
|
||
return
|
||
if not is_moderator_userid(channel.guild, payload.user_id, self.bot):
|
||
return
|
||
|
||
try:
|
||
msg = await channel.fetch_message(payload.message_id)
|
||
except Exception as e:
|
||
print("[pirate_report] fetch mod msg failed:", repr(e))
|
||
return
|
||
|
||
dm = self.bot.data_manager
|
||
|
||
# Atomically claim this report
|
||
claimed = dm.update(
|
||
'reports',
|
||
lambda r: r.get('report_id') == msg.id and r.get('status') == 'pending',
|
||
lambda r: (r.update({'status': 'deciding'}), r)[1]
|
||
)
|
||
if not claimed:
|
||
return
|
||
|
||
report = next((r for r in dm.get('reports') if r.get('report_id') == msg.id), None)
|
||
if not report:
|
||
return
|
||
|
||
approved = (str(payload.emoji) == CHECK)
|
||
guild = channel.guild
|
||
stamp = _now_utc_str()
|
||
|
||
# Build new embed + content (keep proof visible if present)
|
||
status_text = f"{'Approved' if approved else 'Rejected'} by <@{payload.user_id}> on {stamp}"
|
||
report_view = {
|
||
'character_name': report['character_name'],
|
||
'account_name': report['account_name'],
|
||
'submitter_id': report['submitter_id'],
|
||
'proof_url': report.get('proof_url', ''),
|
||
'proof_type': report.get('proof_type', ''),
|
||
'status_line': status_text,
|
||
}
|
||
color = discord.Color.green() if approved else discord.Color.red()
|
||
title = "✅ Pirate Report — Approved" if approved else "❌ Pirate Report — Rejected"
|
||
new_embed = _make_report_embed(title, color, report_view, include_status=True)
|
||
|
||
# For videos, ensure the URL stays in message content so the inline player remains visible.
|
||
new_content = report_view['proof_url'] if report_view.get('proof_type') == 'video' else None
|
||
|
||
# Always (re)attach jump button if we have the ack info
|
||
view = None
|
||
try:
|
||
if report.get('origin_channel_id') and report.get('ack_message_id'):
|
||
url = _jump_url(guild.id, report['origin_channel_id'], report['ack_message_id'])
|
||
view = ReportJumpView(url)
|
||
except Exception:
|
||
view = None
|
||
|
||
try:
|
||
await msg.clear_reactions()
|
||
except Exception as e:
|
||
print("[pirate_report] clear reactions failed:", repr(e))
|
||
try:
|
||
await msg.edit(content=new_content, embed=new_embed, view=view)
|
||
except Exception as e:
|
||
print("[pirate_report] edit mod msg failed:", repr(e))
|
||
|
||
if approved:
|
||
acct_lower = report['account_name'].lower()
|
||
if not any(p['account_name'].lower() == acct_lower for p in dm.get('pirates')):
|
||
dm.add('pirates', {
|
||
'character_name': report['character_name'],
|
||
'account_name': report['account_name'],
|
||
'submitter': str(report['submitter_id']),
|
||
'threat_level': 0,
|
||
'encounter_count': 0,
|
||
'added_ts': time.time()
|
||
})
|
||
await self._refresh_pirates_list(guild)
|
||
|
||
await self._modlog(guild, f"{'✅ Approved' if approved else '❌ Rejected'} report for {report['character_name']} ({report['account_name']}) by <@{payload.user_id}>.")
|
||
|
||
try:
|
||
if report.get('origin_channel_id') and report.get('ack_message_id'):
|
||
ch = guild.get_channel(report['origin_channel_id'])
|
||
if ch:
|
||
ack_msg = await ch.fetch_message(report['ack_message_id'])
|
||
await ack_msg.edit(content=f"{('✅ Approved' if approved else '❌ Rejected')} pirate report of {report['character_name']} ({report['account_name']}) by <@{payload.user_id}> on {stamp}.")
|
||
except Exception as e:
|
||
print("[pirate_report] edit ack msg failed:", repr(e))
|
||
|
||
dm.remove('reports', lambda r: r.get('report_id') == msg.id)
|
||
|
||
|
||
async def setup(bot):
|
||
await bot.add_cog(PirateReportCog(bot))
|