445 lines
12 KiB
Go
445 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"github.com/BurntSushi/toml"
|
|
"github.com/bwmarrin/discordgo"
|
|
_ "github.com/lib/pq"
|
|
)
|
|
|
|
var (
|
|
config Config
|
|
client *discordgo.Session
|
|
db *sql.DB
|
|
)
|
|
|
|
type Config struct {
|
|
Discord Discord `toml:"discord"`
|
|
Database Database `toml:"database"`
|
|
AdminRoles []string `toml:"admin_roles"`
|
|
}
|
|
|
|
type Discord struct {
|
|
Token string `toml:"token"`
|
|
AppID string `toml:"appid"`
|
|
GuildID string `toml:"guildid"`
|
|
CategoryID string `toml:"category_id"`
|
|
}
|
|
|
|
type Database struct {
|
|
Host string `toml:"host"`
|
|
Port int `toml:"port"`
|
|
Name string `toml:"name"`
|
|
Username string `toml:"username"`
|
|
Password string `toml:"password"`
|
|
}
|
|
|
|
func loadConfig(filename string) (Config, error) {
|
|
var config Config
|
|
_, err := toml.DecodeFile(filename, &config)
|
|
return config, err
|
|
}
|
|
|
|
func connectDb(config Config) (*sql.DB, error) {
|
|
connectionString := fmt.Sprintf(
|
|
"host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
|
|
config.Database.Host,
|
|
config.Database.Port,
|
|
config.Database.Username,
|
|
config.Database.Password,
|
|
config.Database.Name,
|
|
)
|
|
|
|
db, err := sql.Open("postgres", connectionString)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error connecting to the database: %v", err)
|
|
}
|
|
|
|
err = db.Ping()
|
|
if err != nil {
|
|
db.Close()
|
|
return nil, fmt.Errorf("error pinging the database: %v", err)
|
|
}
|
|
|
|
log.Println("Successfully connected to the database.")
|
|
return db, nil
|
|
}
|
|
|
|
func init() {
|
|
var err error
|
|
config, err = loadConfig("config.toml")
|
|
if err != nil {
|
|
log.Println("Error occurred whilst trying to load config:", err)
|
|
return
|
|
}
|
|
|
|
client, err = discordgo.New("Bot " + config.Discord.Token)
|
|
if err != nil {
|
|
log.Println("Error initializing bot:", err)
|
|
return
|
|
}
|
|
|
|
db, err = connectDb(config)
|
|
if err != nil {
|
|
log.Println("Error initializing db connection:", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func reset(userNickname, softwareType string) {
|
|
log.Printf("Resetting %s for user %s\n", softwareType, userNickname)
|
|
}
|
|
|
|
func getUsernameFromMember(member *discordgo.Member) string {
|
|
if member == nil {
|
|
return "UnknownUser"
|
|
}
|
|
|
|
var userName string
|
|
if member.Nick != "" {
|
|
userName = member.Nick
|
|
} else if member.User != nil && member.User.Username != "" {
|
|
userName = member.User.Username
|
|
} else {
|
|
userName = "UnknownUser"
|
|
}
|
|
return userName
|
|
}
|
|
|
|
|
|
var (
|
|
commands = []discordgo.ApplicationCommand{
|
|
{
|
|
Name: "setup",
|
|
Description: "Setup a channel for ticket creation",
|
|
Options: []*discordgo.ApplicationCommandOption{
|
|
{
|
|
Type: discordgo.ApplicationCommandOptionChannel,
|
|
Name: "channel",
|
|
Description: "Channel for ticket creation",
|
|
Required: true,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
commandsHandlers = map[string]func(client *discordgo.Session, i *discordgo.InteractionCreate){
|
|
"setup": func(client *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
channelOption := i.ApplicationCommandData().Options[0].ChannelValue(client)
|
|
_, err := client.ChannelMessageSendComplex(channelOption.ID, &discordgo.MessageSend{
|
|
Content: "Click the button below to request a HWID reset:",
|
|
Components: []discordgo.MessageComponent{
|
|
discordgo.ActionsRow{
|
|
Components: []discordgo.MessageComponent{
|
|
discordgo.Button{
|
|
Label: "Request Reset",
|
|
Style: discordgo.PrimaryButton,
|
|
CustomID: "create_ticket",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Error sending message to the specified channel:", err)
|
|
}
|
|
|
|
err = client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: fmt.Sprintf("Setup completed! Request creation button has been added to %s", channelOption.Mention()),
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Error sending interaction response:", err)
|
|
}
|
|
},
|
|
}
|
|
componentsHandlers = map[string]func(client *discordgo.Session, i *discordgo.InteractionCreate){
|
|
"create_ticket": func(client *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
err := client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "For what would you like a HWID reset:",
|
|
Components: []discordgo.MessageComponent{
|
|
discordgo.ActionsRow{
|
|
Components: []discordgo.MessageComponent{
|
|
discordgo.SelectMenu{
|
|
CustomID: "select_software_type",
|
|
Placeholder: "Choose which software",
|
|
Options: []discordgo.SelectMenuOption{
|
|
{
|
|
Label: "Vanity",
|
|
Value: "vanity",
|
|
Description: "Request a vanity reset",
|
|
},
|
|
{
|
|
Label: "Mesa",
|
|
Value: "mesa",
|
|
Description: "Request a mesa reset",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Error sending interaction response:", err)
|
|
}
|
|
},
|
|
"select_software_type": func(client *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
selectedOption := i.MessageComponentData().Values[0]
|
|
var softwareType string
|
|
if selectedOption == "vanity" {
|
|
softwareType = "Vanity"
|
|
} else if selectedOption == "mesa" {
|
|
softwareType = "Mesa"
|
|
}
|
|
|
|
categoryID := config.Discord.CategoryID
|
|
guildID := i.GuildID
|
|
userID := i.Member.User.ID
|
|
userName := getUsernameFromMember(i.Member)
|
|
|
|
if !canCreateTicket(userName, selectedOption) {
|
|
err := client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: fmt.Sprintf("You already have an active %s ticket. Please wait for the administrators to process it.", softwareType),
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Error sending interaction response:", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
channel, err := client.GuildChannelCreateComplex(guildID, discordgo.GuildChannelCreateData{
|
|
Name: fmt.Sprintf("reset-%s-%s", softwareType, userName),
|
|
Type: discordgo.ChannelTypeGuildText,
|
|
ParentID: categoryID,
|
|
PermissionOverwrites: []*discordgo.PermissionOverwrite{
|
|
{
|
|
ID: guildID,
|
|
Type: discordgo.PermissionOverwriteTypeRole,
|
|
Deny: discordgo.PermissionViewChannel,
|
|
},
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Error creating hwid request channel:", err)
|
|
return
|
|
}
|
|
|
|
for _, roleID := range config.AdminRoles {
|
|
client.ChannelPermissionSet(channel.ID, roleID, discordgo.PermissionOverwriteTypeRole, discordgo.PermissionViewChannel, 0)
|
|
}
|
|
|
|
err = client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "Request submitted, you'll get a PM when it has been processed",
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Error sending interaction response:", err)
|
|
return
|
|
}
|
|
|
|
_, err = client.ChannelMessageSendComplex(channel.ID, &discordgo.MessageSend{
|
|
Content: fmt.Sprintf("Reset request by %s for %s", userName, softwareType),
|
|
Components: []discordgo.MessageComponent{
|
|
discordgo.ActionsRow{
|
|
Components: []discordgo.MessageComponent{
|
|
discordgo.Button{
|
|
Label: "Accept",
|
|
Style: discordgo.PrimaryButton,
|
|
CustomID: fmt.Sprintf("accept_%s_%s", userID, softwareType),
|
|
},
|
|
discordgo.Button{
|
|
Label: "Decline",
|
|
Style: discordgo.DangerButton,
|
|
CustomID: fmt.Sprintf("decline_%s_%s", userID, softwareType),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Error sending message to the ticket channel:", err)
|
|
}
|
|
},
|
|
|
|
"accept": func(client *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
data := i.MessageComponentData().CustomID
|
|
parts := strings.Split(data, "_")
|
|
if len(parts) != 3 {
|
|
log.Println("Invalid accept button custom ID")
|
|
return
|
|
}
|
|
userID := parts[1]
|
|
softwareType := parts[2]
|
|
|
|
member, err := client.GuildMember(i.GuildID, userID)
|
|
if err != nil {
|
|
log.Println("Error fetching member info:", err)
|
|
return
|
|
}
|
|
userName := getUsernameFromMember(member)
|
|
|
|
reset(userName, softwareType)
|
|
|
|
err = client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "Request accepted and processed.",
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Error sending interaction response:", err)
|
|
}
|
|
|
|
_, err = client.ChannelDelete(i.ChannelID)
|
|
if err != nil {
|
|
log.Println("Error deleting channel:", err)
|
|
}
|
|
|
|
dmChannel, err := client.UserChannelCreate(userID)
|
|
if err != nil {
|
|
log.Println("Error creating DM channel:", err)
|
|
return
|
|
}
|
|
|
|
_, err = client.ChannelMessageSend(dmChannel.ID, fmt.Sprintf("Your reset request for %s has been accepted and processed.", softwareType))
|
|
if err != nil {
|
|
log.Println("Error sending DM:", err)
|
|
}
|
|
},
|
|
|
|
"decline": func(client *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
data := i.MessageComponentData().CustomID
|
|
parts := strings.Split(data, "_")
|
|
if len(parts) != 3 {
|
|
log.Println("Invalid decline button custom ID")
|
|
return
|
|
}
|
|
userID := parts[1]
|
|
|
|
err := client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "Request declined.",
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Error sending interaction response:", err)
|
|
}
|
|
|
|
_, err = client.ChannelDelete(i.ChannelID)
|
|
if err != nil {
|
|
log.Println("Error deleting channel:", err)
|
|
}
|
|
|
|
dmChannel, err := client.UserChannelCreate(userID)
|
|
if err != nil {
|
|
log.Println("Error creating DM channel:", err)
|
|
return
|
|
}
|
|
|
|
_, err = client.ChannelMessageSend(dmChannel.ID, "Your reset request has been declined.")
|
|
if err != nil {
|
|
log.Println("Error sending DM:", err)
|
|
}
|
|
},
|
|
}
|
|
)
|
|
|
|
func canCreateTicket(userName, softwareType string) bool {
|
|
guildChannels, err := client.GuildChannels(config.Discord.GuildID)
|
|
if err != nil {
|
|
log.Println("Error fetching guild channels:", err)
|
|
return false
|
|
}
|
|
|
|
for _, channel := range guildChannels {
|
|
if channel.Type == discordgo.ChannelTypeGuildText && channel.ParentID == config.Discord.CategoryID {
|
|
expectedName := fmt.Sprintf("reset-%s-%s", softwareType, userName)
|
|
if channel.Name == expectedName {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func main() {
|
|
if client == nil {
|
|
log.Println("Bot client is not initialized")
|
|
return
|
|
}
|
|
|
|
client.AddHandler(func(client *discordgo.Session, r *discordgo.Ready) {
|
|
log.Println("Bot is online")
|
|
|
|
cmdIDs := make(map[string]string, len(commands))
|
|
|
|
for _, cmd := range commands {
|
|
rcmd, err := client.ApplicationCommandCreate(client.State.User.ID, config.Discord.GuildID, &cmd)
|
|
if err != nil {
|
|
log.Fatalf("Cannot create slash command %q: %v", cmd.Name, err)
|
|
}
|
|
|
|
cmdIDs[rcmd.ID] = rcmd.Name
|
|
}
|
|
})
|
|
|
|
client.AddHandler(func(client *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
if i.Type == discordgo.InteractionApplicationCommand {
|
|
if h, ok := commandsHandlers[i.ApplicationCommandData().Name]; ok {
|
|
h(client, i)
|
|
}
|
|
} else if i.Type == discordgo.InteractionMessageComponent {
|
|
customID := i.MessageComponentData().CustomID
|
|
if h, ok := componentsHandlers[customID]; ok {
|
|
h(client, i)
|
|
} else if strings.HasPrefix(customID, "accept_") {
|
|
componentsHandlers["accept"](client, i)
|
|
} else if strings.HasPrefix(customID, "decline_") {
|
|
componentsHandlers["decline"](client, i)
|
|
}
|
|
}
|
|
})
|
|
|
|
err := client.Open()
|
|
if err != nil {
|
|
log.Println("Error opening connection:", err)
|
|
return
|
|
}
|
|
|
|
stop := make(chan os.Signal, 1)
|
|
signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
|
|
<-stop
|
|
|
|
log.Println("Gracefully shutting down.")
|
|
client.Close()
|
|
|
|
if db != nil {
|
|
db.Close()
|
|
}
|
|
}
|
|
|