config.toml.example

@@ -1,8 +1,6 @@
 [discord]
-token = ""
+client = ""
-appid = ""
 guildid = ""
-category_id = ""
 
 [database]
 host = ""
@@ -11,4 +9,3 @@ name = ""
 username = ""
 password = ""
 
-admin_roles = [""]

go.mod

@@ -5,7 +5,6 @@ go 1.22.4
 require (
 	github.com/BurntSushi/toml v1.4.0
 	github.com/bwmarrin/discordgo v0.28.1
-	github.com/lib/pq v1.10.9
 )
 
 require (

main.go

@@ -1,36 +1,25 @@
 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 (
+var client *discordgo.Session
-	config Config
-	client *discordgo.Session
-	db     *sql.DB
-)
 
 type Config struct {
-	Discord    Discord    `toml:"discord"`
+	Discord  Discord  `toml:"discord"`
-	Database   Database   `toml:"database"`
+	Database Database `toml:"database"`
-	AdminRoles []string   `toml:"admin_roles"`
 }
 
 type Discord struct {
-	Token      string `toml:"token"`
+	Token   string `toml:"client"`
-	AppID      string `toml:"appid"`
+	GuildID string `toml:"guildid"`
-	GuildID    string `toml:"guildid"`
-	CategoryID string `toml:"category_id"`
 }
 
 type Database struct {
@@ -41,392 +30,42 @@ type Database struct {
 	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")
-	config, err = loadConfig("config.toml")
 	if err != nil {
-		log.Println("Error occurred whilst trying to load config:", err)
+		fmt.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)
+		fmt.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")
+		fmt.Println("Bot client is not initialized")
 		return
 	}
 
 	client.AddHandler(func(client *discordgo.Session, r *discordgo.Ready) {
-		log.Println("Bot is online")
+		fmt.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)
+		fmt.Println("Error opening connection:", err)
 		return
 	}
 
@@ -434,11 +73,7 @@ func main() {
 	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
 	<-stop
 
-	log.Println("Gracefully shutting down.")
+	fmt.Println("Gracefully shutting down.")
 	client.Close()
-
-	if db != nil {
-		db.Close()
-	}
 }