587 lines
22 KiB
Rust
587 lines
22 KiB
Rust
//! Ticket handler - SelectMenu + Modal + private channels, claim/close with transcript.
|
||
use super::service;
|
||
use serenity::all::{
|
||
ChannelId, ChannelType, ComponentInteraction, Context, CreateActionRow, CreateChannel,
|
||
CreateEmbed, CreateInteractionResponse, CreateInteractionResponseMessage, CreateMessage,
|
||
CreateModal, CreateSelectMenu, CreateSelectMenuKind, CreateSelectMenuOption, GuildId,
|
||
InputTextStyle, ModalInteraction, PermissionOverwrite, PermissionOverwriteType, Permissions,
|
||
};
|
||
use tracing::{info, warn};
|
||
|
||
const SUPPORT_CATEGORY: u64 = 1547213779224363008;
|
||
const TICKET_LOGS: u64 = 1509503717127356446;
|
||
/// Dedicated panel channel (#open-ticket / #🎫｜open-ticket)
|
||
const TICKET_PANEL_CHANNEL: u64 = 1509503682914549861;
|
||
|
||
/// Canonical topics - single source of truth for select menu + modal title + validation.
|
||
struct Topic {
|
||
value: &'static str,
|
||
label: &'static str,
|
||
emoji: char,
|
||
desc: &'static str,
|
||
}
|
||
const TOPICS: &[Topic] = &[
|
||
Topic {
|
||
value: "general",
|
||
label: "General support",
|
||
emoji: '🛠',
|
||
desc: "Questions about bot / server",
|
||
},
|
||
Topic { value: "bug", label: "Bug report", emoji: '🐛', desc: "Report a bug or error" },
|
||
Topic {
|
||
value: "appeal", label: "Mute / ban appeal", emoji: '🔇', desc: "Appeal a punishment"
|
||
},
|
||
Topic { value: "report", label: "Report user", emoji: '😡', desc: "Report rule violation" },
|
||
Topic {
|
||
value: "owners",
|
||
label: "Contact owners",
|
||
emoji: '👑',
|
||
desc: "Private contact with owners",
|
||
},
|
||
];
|
||
|
||
fn topic_label(value: &str) -> Option<&'static str> {
|
||
TOPICS.iter().find(|t| t.value == value).map(|t| t.label)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Panel builders (pure, reusable)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
pub fn panel_embed() -> CreateEmbed {
|
||
CreateEmbed::new()
|
||
.title("🎫 Support tickets")
|
||
.description(
|
||
"**Choose a topic below to open a private ticket.**\n\
|
||
\n\
|
||
• Staff will respond shortly — please describe your issue clearly.\n\
|
||
• One open ticket per user.\n\
|
||
• Abuse / spam → blacklist.",
|
||
)
|
||
.color(0x0058_65F2)
|
||
.footer(serenity::all::CreateEmbedFooter::new(
|
||
"Loki Dev • Select topic → fill form → ticket created",
|
||
))
|
||
}
|
||
|
||
pub fn panel_select_row() -> CreateActionRow {
|
||
let options: Vec<CreateSelectMenuOption> = TOPICS
|
||
.iter()
|
||
.map(|t| CreateSelectMenuOption::new(t.label, t.value).description(t.desc).emoji(t.emoji))
|
||
.collect();
|
||
let menu = CreateSelectMenu::new("ticket_topic", CreateSelectMenuKind::String { options })
|
||
.placeholder("Choose topic…")
|
||
.min_values(1)
|
||
.max_values(1);
|
||
CreateActionRow::SelectMenu(menu)
|
||
}
|
||
|
||
/// Ensures panel exists in dedicated channel. Called on Ready + on demand from /ticket_panel.
|
||
/// Idempotent: checks last 20 messages for bot's panel (select `ticket_topic`), creates if missing.
|
||
pub async fn ensure_ticket_panel(
|
||
http: &serenity::http::Http,
|
||
guild_id: GuildId,
|
||
) -> anyhow::Result<()> {
|
||
// Prefer constant id, fallback to search by name "open-ticket"
|
||
let channel_id =
|
||
resolve_panel_channel(http, guild_id).await.unwrap_or(ChannelId::new(TICKET_PANEL_CHANNEL));
|
||
let msgs = channel_id.messages(http, serenity::all::GetMessages::new().limit(20)).await?;
|
||
let has_panel = msgs.iter().any(|m| {
|
||
m.author.id.get() == 1527966600173457408
|
||
&& m.components.iter().any(|row| {
|
||
row.components.iter().any(|c| match c {
|
||
serenity::all::ActionRowComponent::SelectMenu(sm) => {
|
||
sm.custom_id.as_deref() == Some("ticket_topic")
|
||
}
|
||
_ => false,
|
||
})
|
||
})
|
||
});
|
||
if has_panel {
|
||
info!(channel=%channel_id, "ticket panel already exists");
|
||
return Ok(());
|
||
}
|
||
channel_id
|
||
.send_message(
|
||
http,
|
||
CreateMessage::new().embed(panel_embed()).components(vec![panel_select_row()]),
|
||
)
|
||
.await?;
|
||
info!(channel=%channel_id, "ticket panel created on boot");
|
||
Ok(())
|
||
}
|
||
|
||
async fn resolve_panel_channel(
|
||
http: &serenity::http::Http,
|
||
guild_id: GuildId,
|
||
) -> Option<ChannelId> {
|
||
if let Ok(channels) = guild_id.channels(http).await {
|
||
if let Some((id, _)) = channels.iter().find(|(_, c)| c.name.contains("open-ticket")) {
|
||
return Some(*id);
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Interaction routing
|
||
// ---------------------------------------------------------------------------
|
||
|
||
/// Handles ticket buttons (claim/close) + legacy create buttons.
|
||
pub async fn on_button(ctx: Context, interaction: ComponentInteraction) {
|
||
match interaction.data.custom_id.as_str() {
|
||
"ticket_general" | "ticket_bug" => handle_create_legacy(ctx, interaction).await,
|
||
"ticket_claim" => handle_claim(ctx, interaction).await,
|
||
"ticket_close" => handle_close(ctx, interaction).await,
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
/// Handles select menu `ticket_topic` -> shows modal with subject/description.
|
||
pub async fn on_select(ctx: Context, interaction: ComponentInteraction) {
|
||
if interaction.data.custom_id != "ticket_topic" {
|
||
return;
|
||
}
|
||
let topic = match &interaction.data.kind {
|
||
serenity::all::ComponentInteractionDataKind::StringSelect { values } => {
|
||
values.first().cloned().unwrap_or_default()
|
||
}
|
||
_ => return,
|
||
};
|
||
if topic.is_empty() {
|
||
return;
|
||
}
|
||
let Some(label) = topic_label(&topic) else {
|
||
let _ = interaction
|
||
.create_response(
|
||
&ctx.http,
|
||
CreateInteractionResponse::Message(
|
||
CreateInteractionResponseMessage::new()
|
||
.content(format!("Unknown topic: {topic}"))
|
||
.ephemeral(true),
|
||
),
|
||
)
|
||
.await;
|
||
return;
|
||
};
|
||
// Pre-checks before showing modal (blacklist / existing ticket) to avoid wasted modal.
|
||
if let Some(guild_id) = interaction.guild_id {
|
||
if let Some(pool) = service::pool() {
|
||
if let Some(reason) =
|
||
service::is_blacklisted(pool, guild_id.get(), interaction.user.id.get()).await
|
||
{
|
||
let _ = interaction
|
||
.create_response(
|
||
&ctx.http,
|
||
CreateInteractionResponse::Message(
|
||
CreateInteractionResponseMessage::new()
|
||
.content(format!("You are blacklisted: {reason}"))
|
||
.ephemeral(true),
|
||
),
|
||
)
|
||
.await;
|
||
return;
|
||
}
|
||
}
|
||
if let Ok(channels) = guild_id.channels(&ctx.http).await {
|
||
let exists = channels.values().any(|c| {
|
||
c.name.starts_with(&format!("ticket-{}", interaction.user.name.to_lowercase()))
|
||
|| c.name.starts_with(&format!("ticket-{}", interaction.user.id))
|
||
});
|
||
if exists {
|
||
let _ = interaction
|
||
.create_response(
|
||
&ctx.http,
|
||
CreateInteractionResponse::Message(
|
||
CreateInteractionResponseMessage::new()
|
||
.content("You already have an open ticket.")
|
||
.ephemeral(true),
|
||
),
|
||
)
|
||
.await;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
let modal = CreateModal::new(format!("ticket_modal:{topic}"), format!("New ticket • {label}"))
|
||
.components(vec![
|
||
CreateActionRow::InputText(
|
||
serenity::all::CreateInputText::new(InputTextStyle::Short, "Subject", "subject")
|
||
.placeholder("Brief title (3-100 chars)")
|
||
.min_length(3)
|
||
.max_length(100)
|
||
.required(true),
|
||
),
|
||
CreateActionRow::InputText(
|
||
serenity::all::CreateInputText::new(
|
||
InputTextStyle::Paragraph,
|
||
"Description",
|
||
"description",
|
||
)
|
||
.placeholder("Describe your issue in detail (10-1000 chars)")
|
||
.min_length(10)
|
||
.max_length(1000)
|
||
.required(true),
|
||
),
|
||
]);
|
||
let _ = interaction.create_response(&ctx.http, CreateInteractionResponse::Modal(modal)).await;
|
||
}
|
||
|
||
/// Handles modal submit `ticket_modal:<topic>` -> creates private ticket channel.
|
||
pub async fn on_modal(ctx: Context, interaction: ModalInteraction) {
|
||
let Some(topic) = interaction.data.custom_id.strip_prefix("ticket_modal:") else {
|
||
return;
|
||
};
|
||
let Some(label) = topic_label(topic) else {
|
||
let _ = interaction
|
||
.create_response(
|
||
&ctx.http,
|
||
CreateInteractionResponse::Message(
|
||
CreateInteractionResponseMessage::new()
|
||
.content("Unknown ticket topic.")
|
||
.ephemeral(true),
|
||
),
|
||
)
|
||
.await;
|
||
return;
|
||
};
|
||
let subject =
|
||
extract_modal_field(&interaction, "subject").unwrap_or_else(|| "No subject".into());
|
||
let description = extract_modal_field(&interaction, "description").unwrap_or_default();
|
||
// Basic validation mirrored from modal (discord enforces, but double-check)
|
||
if subject.trim().len() < 3 || description.trim().len() < 10 {
|
||
let _ = interaction
|
||
.create_response(
|
||
&ctx.http,
|
||
CreateInteractionResponse::Message(
|
||
CreateInteractionResponseMessage::new()
|
||
.content("Subject ≥3 and description ≥10 chars required.")
|
||
.ephemeral(true),
|
||
),
|
||
)
|
||
.await;
|
||
return;
|
||
}
|
||
let Some(guild_id) = interaction.guild_id else {
|
||
return;
|
||
};
|
||
let user = interaction.user.clone();
|
||
// Re-check blacklist / duplicate (race between modal open and submit)
|
||
if let Some(pool) = service::pool() {
|
||
if let Some(reason) = service::is_blacklisted(pool, guild_id.get(), user.id.get()).await {
|
||
let _ = interaction
|
||
.create_response(
|
||
&ctx.http,
|
||
CreateInteractionResponse::Message(
|
||
CreateInteractionResponseMessage::new()
|
||
.content(format!("You are blacklisted: {reason}"))
|
||
.ephemeral(true),
|
||
),
|
||
)
|
||
.await;
|
||
return;
|
||
}
|
||
}
|
||
if let Ok(channels) = guild_id.channels(&ctx.http).await {
|
||
let exists = channels.values().any(|c| {
|
||
c.name.starts_with(&format!("ticket-{}", user.name.to_lowercase()))
|
||
|| c.name.starts_with(&format!("ticket-{}", user.id))
|
||
});
|
||
if exists {
|
||
let _ = interaction
|
||
.create_response(
|
||
&ctx.http,
|
||
CreateInteractionResponse::Message(
|
||
CreateInteractionResponseMessage::new()
|
||
.content("You already have an open ticket.")
|
||
.ephemeral(true),
|
||
),
|
||
)
|
||
.await;
|
||
return;
|
||
}
|
||
}
|
||
// Defer ephemeral thinking before heavy channel create (avoid 3s timeout)
|
||
let _ = interaction
|
||
.create_response(
|
||
&ctx.http,
|
||
CreateInteractionResponse::Defer(
|
||
CreateInteractionResponseMessage::new().ephemeral(true),
|
||
),
|
||
)
|
||
.await;
|
||
// Use helper that supports details
|
||
match create_ticket_channel(&ctx, guild_id, &user, topic, label, &subject, &description).await {
|
||
Ok(channel_id) => {
|
||
let _ = interaction
|
||
.create_followup(
|
||
&ctx.http,
|
||
serenity::all::CreateInteractionResponseFollowup::new()
|
||
.content(format!("Ticket created: <#{channel_id}>"))
|
||
.ephemeral(true),
|
||
)
|
||
.await;
|
||
}
|
||
Err(e) => {
|
||
warn!(error=%e, "failed to create ticket via modal");
|
||
let _ = interaction
|
||
.create_followup(
|
||
&ctx.http,
|
||
serenity::all::CreateInteractionResponseFollowup::new()
|
||
.content("Failed to create ticket. Try again later.")
|
||
.ephemeral(true),
|
||
)
|
||
.await;
|
||
}
|
||
}
|
||
}
|
||
|
||
fn extract_modal_field(modal: &ModalInteraction, custom_id: &str) -> Option<String> {
|
||
for row in &modal.data.components {
|
||
for comp in &row.components {
|
||
if let serenity::all::ActionRowComponent::InputText(it) = comp {
|
||
if it.custom_id == custom_id {
|
||
return it.value.clone();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Channel creation (shared for legacy + modal)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
async fn create_ticket_channel(
|
||
ctx: &Context,
|
||
guild_id: GuildId,
|
||
user: &serenity::all::User,
|
||
topic: &str,
|
||
label: &str,
|
||
subject: &str,
|
||
description: &str,
|
||
) -> anyhow::Result<ChannelId> {
|
||
let safe_user = sanitize_name(&user.name);
|
||
let name = format!("ticket-{topic}-{safe_user}");
|
||
// Discord channel name max 100, lowercase alphanumeric + dashes
|
||
let name = name.chars().take(90).collect::<String>();
|
||
let overwrites = build_ticket_overwrites(user.id.get());
|
||
let channel = guild_id
|
||
.create_channel(
|
||
&ctx.http,
|
||
CreateChannel::new(&name)
|
||
.kind(ChannelType::Text)
|
||
.category(ChannelId::new(SUPPORT_CATEGORY))
|
||
.permissions(overwrites),
|
||
)
|
||
.await?;
|
||
if let Some(pool) = service::pool() {
|
||
service::record_ticket(pool, channel.id.get(), guild_id.get(), user.id.get()).await;
|
||
}
|
||
let embed = CreateEmbed::new()
|
||
.title(subject)
|
||
.description(format!(
|
||
"Hello <@{}> — staff will be with you shortly.\n\n**Topic:** {label} (`{topic}`)\n**Description:**\n{description}",
|
||
user.id
|
||
))
|
||
.color(0x0058_65F2)
|
||
.footer(serenity::all::CreateEmbedFooter::new(format!("Opened by {} • {}", user.name, topic)));
|
||
let row = serenity::all::CreateActionRow::Buttons(vec![
|
||
serenity::all::CreateButton::new("ticket_claim")
|
||
.label("Claim")
|
||
.style(serenity::all::ButtonStyle::Primary)
|
||
.emoji('🙋'),
|
||
serenity::all::CreateButton::new("ticket_close")
|
||
.label("Close")
|
||
.style(serenity::all::ButtonStyle::Danger)
|
||
.emoji('🔒'),
|
||
]);
|
||
let _ = channel
|
||
.send_message(&ctx.http, CreateMessage::new().embed(embed).components(vec![row]))
|
||
.await;
|
||
// Log opening
|
||
let _ = ChannelId::new(TICKET_LOGS)
|
||
.send_message(
|
||
&ctx.http,
|
||
CreateMessage::new().embed(
|
||
CreateEmbed::new()
|
||
.title("Ticket opened")
|
||
.description(format!(
|
||
"<@{}> opened <#{}> — **{label}**\nSubject: {subject}",
|
||
user.id, channel.id
|
||
))
|
||
.color(0x0058_65F2),
|
||
),
|
||
)
|
||
.await;
|
||
info!(user=%user.name, channel=%channel.id, topic=%topic, "ticket created via modal");
|
||
Ok(channel.id)
|
||
}
|
||
|
||
fn sanitize_name(s: &str) -> String {
|
||
let lower = s.to_lowercase().replace(' ', "-");
|
||
let mut out = String::new();
|
||
for ch in lower.chars() {
|
||
if ch.is_ascii_alphanumeric() || ch == '-' {
|
||
out.push(ch);
|
||
} else {
|
||
out.push('-');
|
||
}
|
||
}
|
||
let collapsed = out.split('-').filter(|p| !p.is_empty()).collect::<Vec<_>>().join("-");
|
||
if collapsed.is_empty() { "user".into() } else { collapsed }
|
||
}
|
||
|
||
async fn ephemeral(ctx: &Context, i: &ComponentInteraction, content: String) {
|
||
let _ = i
|
||
.create_response(
|
||
&ctx.http,
|
||
CreateInteractionResponse::Message(
|
||
CreateInteractionResponseMessage::new().content(content).ephemeral(true),
|
||
),
|
||
)
|
||
.await;
|
||
}
|
||
|
||
async fn handle_create_legacy(ctx: Context, interaction: ComponentInteraction) {
|
||
// Legacy button path - create with generic subject/desc
|
||
let Some(guild_id) = interaction.guild_id else { return };
|
||
let user = interaction.user.clone();
|
||
let custom = interaction.data.custom_id.clone();
|
||
if let Some(pool) = service::pool() {
|
||
if let Some(reason) = service::is_blacklisted(pool, guild_id.get(), user.id.get()).await {
|
||
ephemeral(&ctx, &interaction, format!("You are blacklisted: {reason}")).await;
|
||
return;
|
||
}
|
||
}
|
||
let (topic, label) =
|
||
if custom == "ticket_bug" { ("bug", "Bug report") } else { ("general", "General support") };
|
||
if let Ok(channels) = guild_id.channels(&ctx.http).await {
|
||
let exists = channels.values().any(|c| {
|
||
c.name.starts_with(&format!("ticket-{}", user.name.to_lowercase()))
|
||
|| c.name.starts_with(&format!("ticket-{}", user.id))
|
||
});
|
||
if exists {
|
||
ephemeral(&ctx, &interaction, "You already have an open ticket.".into()).await;
|
||
return;
|
||
}
|
||
}
|
||
match create_ticket_channel(
|
||
&ctx,
|
||
guild_id,
|
||
&user,
|
||
topic,
|
||
label,
|
||
&format!("Ticket - {label}"),
|
||
"Opened via legacy button.",
|
||
)
|
||
.await
|
||
{
|
||
Ok(cid) => ephemeral(&ctx, &interaction, format!("Ticket created: <#{cid}>")).await,
|
||
Err(e) => {
|
||
warn!(error=%e, "failed to create legacy ticket");
|
||
ephemeral(&ctx, &interaction, "Failed to create ticket.".into()).await;
|
||
}
|
||
}
|
||
}
|
||
|
||
async fn handle_claim(ctx: Context, interaction: ComponentInteraction) {
|
||
let Some(guild_id) = interaction.guild_id else { return };
|
||
let channel_id = interaction.channel_id;
|
||
let claimer = interaction.user.clone();
|
||
if let Some(pool) = service::pool() {
|
||
if let Some(existing) = service::get_claim(pool, channel_id.get()).await {
|
||
ephemeral(&ctx, &interaction, format!("Already claimed by <@{existing}>")).await;
|
||
return;
|
||
}
|
||
if !service::try_claim(pool, channel_id.get(), guild_id.get(), claimer.id.get()).await {
|
||
ephemeral(&ctx, &interaction, "Claim failed, already claimed.".into()).await;
|
||
return;
|
||
}
|
||
}
|
||
ephemeral(&ctx, &interaction, format!("Ticket claimed by <@{}>", claimer.id)).await;
|
||
let _ = channel_id
|
||
.send_message(
|
||
&ctx.http,
|
||
CreateMessage::new().embed(
|
||
CreateEmbed::new()
|
||
.title("Ticket claimed")
|
||
.description(format!("Claimed by <@{}>", claimer.id))
|
||
.footer(serenity::all::CreateEmbedFooter::new(format!(
|
||
"Claimed by {}",
|
||
claimer.name
|
||
)))
|
||
.color(0x0057_F387),
|
||
),
|
||
)
|
||
.await;
|
||
let _ = ChannelId::new(TICKET_LOGS)
|
||
.send_message(
|
||
&ctx.http,
|
||
CreateMessage::new().embed(
|
||
CreateEmbed::new()
|
||
.title("Ticket claimed")
|
||
.description(format!("<@{}> claimed ticket <#{}>", claimer.id, channel_id))
|
||
.color(0x0057_F387),
|
||
),
|
||
)
|
||
.await;
|
||
info!(channel=%channel_id, claimer=%claimer.id, "ticket claimed");
|
||
}
|
||
|
||
async fn handle_close(ctx: Context, interaction: ComponentInteraction) {
|
||
let channel_id = interaction.channel_id;
|
||
let user = interaction.user.clone();
|
||
ephemeral(&ctx, &interaction, "Closing ticket... transcript will be saved.".into()).await;
|
||
let transcript = service::fetch_transcript(&ctx.http, channel_id).await;
|
||
let haste_url = service::upload_hastebin(&transcript).await;
|
||
service::deliver_transcript(
|
||
&ctx.http,
|
||
channel_id,
|
||
user.id.get(),
|
||
transcript.clone(),
|
||
haste_url.clone(),
|
||
)
|
||
.await;
|
||
if let Some(pool) = service::pool() {
|
||
service::cleanup_ticket(pool, channel_id.get()).await;
|
||
}
|
||
tokio::time::sleep(std::time::Duration::from_secs(2)).await; // SAFETY: small delay to let log flush, not in command path, jitter not needed
|
||
let _ = channel_id.delete(&ctx.http).await;
|
||
info!(channel=%channel_id, "ticket closed");
|
||
}
|
||
|
||
fn allow_view(id: serenity::all::RoleId) -> PermissionOverwrite {
|
||
PermissionOverwrite {
|
||
allow: Permissions::VIEW_CHANNEL
|
||
| Permissions::SEND_MESSAGES
|
||
| Permissions::READ_MESSAGE_HISTORY,
|
||
deny: Permissions::empty(),
|
||
kind: PermissionOverwriteType::Role(id),
|
||
}
|
||
}
|
||
fn build_ticket_overwrites(user_id: u64) -> Vec<PermissionOverwrite> {
|
||
let everyone = serenity::all::RoleId::new(1509503154708811837);
|
||
let staff = serenity::all::RoleId::new(1547203757711040572);
|
||
let owner = serenity::all::RoleId::new(1547203762035236925);
|
||
let moderator = serenity::all::RoleId::new(1547203753373859901);
|
||
let user = serenity::all::UserId::new(user_id);
|
||
vec![
|
||
PermissionOverwrite {
|
||
allow: Permissions::empty(),
|
||
deny: Permissions::VIEW_CHANNEL,
|
||
kind: PermissionOverwriteType::Role(everyone),
|
||
},
|
||
PermissionOverwrite {
|
||
allow: Permissions::VIEW_CHANNEL
|
||
| Permissions::SEND_MESSAGES
|
||
| Permissions::READ_MESSAGE_HISTORY,
|
||
deny: Permissions::empty(),
|
||
kind: PermissionOverwriteType::Member(user),
|
||
},
|
||
allow_view(staff),
|
||
allow_view(owner),
|
||
allow_view(moderator),
|
||
]
|
||
}
|