//

Reviewed-on: #3

config.toml.example

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

main.go

@@ -1,24 +1,40 @@
 package main
 
 import (
+	"bytes"
 	"database/sql"
+	"encoding/json"
 	"fmt"
 	"log"
+	"mime/multipart"
+	"net/http"
 	"os"
 	"os/signal"
+	"strconv"
+	"strings"
 	"syscall"
+	"time"
 
 	"github.com/BurntSushi/toml"
 	"github.com/bwmarrin/discordgo"
-	_ "github.com/lib/pq"
+	"github.com/lib/pq"
 )
 
+type UserResponse struct {
+	ID           string   `json:"id"`
+	Username     string   `json:"username"`
+	Subscription bool     `json:"subscription"`
+	Group        string   `json:"group"`
+	Expiration   string   `json:"expiration"`
+	Versions     []string `json:"versions"`
+	PFP          string   `json:"pfp"`
+	Message      int      `json:"message"`
+}
+
 var (
 	config Config
 	client *discordgo.Session
 	db     *sql.DB
-
-	globalCategoryID string
 )
 
 type Config struct {
@@ -27,9 +43,11 @@ type Config struct {
 }
 
 type Discord struct {
-	Token   string `toml:"token"`
-	AppID   string `toml:"appid"`
-	GuildID string `toml:"guildid"`
+	Token      string   `toml:"token"`
+	AppID      string   `toml:"appid"`
+	GuildID    string   `toml:"guildid"`
+	CategoryID string   `toml:"category_id"`
+	AdminRoles []string `toml:"admin_roles"`
 }
 
 type Database struct {
@@ -92,6 +110,26 @@ func init() {
 	}
 }
 
+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{
 		{
@@ -104,23 +142,45 @@ var (
 					Description: "Channel for ticket creation",
 					Required:    true,
 				},
-				{
-					Type:        discordgo.ApplicationCommandOptionChannel,
-					Name:        "category",
-					Description: "Category for tickets",
-					Required:    true,
-				},
 			},
 		},
 	}
 	commandsHandlers = map[string]func(client *discordgo.Session, i *discordgo.InteractionCreate){
 		"setup": func(client *discordgo.Session, i *discordgo.InteractionCreate) {
+			hasAdminPermission := false
+			for _, roleID := range config.Discord.AdminRoles {
+				member, err := client.GuildMember(i.GuildID, i.Member.User.ID)
+				if err != nil {
+					log.Println("Error fetching member info:", err)
+					return
+				}
+
+				for _, role := range member.Roles {
+					if role == roleID {
+						hasAdminPermission = true
+						break
+					}
+				}
+				if hasAdminPermission {
+					break
+				}
+			}
+
+			if !hasAdminPermission {
+				err := client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+					Type: discordgo.InteractionResponseChannelMessageWithSource,
+					Data: &discordgo.InteractionResponseData{
+						Content: "You do not have permission to run this command.",
+						Flags:   discordgo.MessageFlagsEphemeral,
+					},
+				})
+				if err != nil {
+					log.Println("Error sending interaction response:", err)
+				}
+				return
+			}
+
 			channelOption := i.ApplicationCommandData().Options[0].ChannelValue(client)
-			categoryOption := i.ApplicationCommandData().Options[1].ChannelValue(client)
-
-			globalCategoryID = categoryOption.ID
-
-		
 			_, err := client.ChannelMessageSendComplex(channelOption.ID, &discordgo.MessageSend{
 				Content: "Click the button below to request a HWID reset:",
 				Components: []discordgo.MessageComponent{
@@ -139,7 +199,6 @@ var (
 				log.Println("Error sending message to the specified channel:", err)
 			}
 
-			
 			err = client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 				Type: discordgo.InteractionResponseChannelMessageWithSource,
 				Data: &discordgo.InteractionResponseData{
@@ -151,12 +210,13 @@ var (
 			}
 		},
 	}
+
 	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 u like a HWID reset:",
+					Content: "For what would you like a HWID reset:",
 					Components: []discordgo.MessageComponent{
 						discordgo.ActionsRow{
 							Components: []discordgo.MessageComponent{
@@ -195,25 +255,50 @@ var (
 				softwareType = "Mesa"
 			}
 
+			categoryID := config.Discord.CategoryID
 			guildID := i.GuildID
 			userID := i.Member.User.ID
-			userName := i.Member.User.Username
+			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
+			}
+
+			_, baseUrl := getTableNameAndBaseURL(selectedOption)
+			userUID, _ := fetchUserID(userName, baseUrl)
+			if userUID == 0 {
+				err := client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
+					Type: discordgo.InteractionResponseChannelMessageWithSource,
+					Data: &discordgo.InteractionResponseData{
+						Content: fmt.Sprintf("Account not found for %s", 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: globalCategoryID,
+				ParentID: categoryID,
 				PermissionOverwrites: []*discordgo.PermissionOverwrite{
 					{
-						ID:    guildID,
-						Type:  discordgo.PermissionOverwriteTypeRole,
-						Deny:  discordgo.PermissionViewChannel,
-					},
-					{
-						ID:    userID,
-						Type:  discordgo.PermissionOverwriteTypeMember,
-						Allow: discordgo.PermissionViewChannel,
+						ID:   guildID,
+						Type: discordgo.PermissionOverwriteTypeRole,
+						Deny: discordgo.PermissionViewChannel,
 					},
 				},
 			})
@@ -222,20 +307,257 @@ var (
 				return
 			}
 
+			for _, roleID := range config.Discord.AdminRoles {
+				if roleID != "" {
+					err := client.ChannelPermissionSet(channel.ID, roleID, discordgo.PermissionOverwriteTypeRole, discordgo.PermissionViewChannel|discordgo.PermissionSendMessages, 0)
+					if err != nil {
+						log.Printf("Error setting permissions for role %s: %v", roleID, err)
+					}
+				}
+
+			}
+
 			err = client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 				Type: discordgo.InteractionResponseChannelMessageWithSource,
 				Data: &discordgo.InteractionResponseData{
-					Content: fmt.Sprintf("Request created: %s", channel.Mention()),
+					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", userID, softwareType),
+				Components: []discordgo.MessageComponent{
+					discordgo.ActionsRow{
+						Components: []discordgo.MessageComponent{
+							discordgo.Button{
+								Label:    "Accept",
+								Style:    discordgo.PrimaryButton,
+								CustomID: fmt.Sprintf("accept_%s_%s_%d", userID, softwareType, userUID),
+							},
+							discordgo.Button{
+								Label:    "Decline",
+								Style:    discordgo.DangerButton,
+								CustomID: fmt.Sprintf("decline_%s_%s_%d", userID, softwareType, userUID),
+							},
+						},
+					},
+				},
+			})
+			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) != 4 {
+				log.Println("Invalid accept button custom ID")
+				return
+			}
+			userID := parts[1]
+			softwareType := parts[2]
+			userUID, _ := strconv.Atoi(parts[3])
+
+			member, err := client.GuildMember(i.GuildID, userID)
+			if err != nil {
+				log.Println("Error fetching member info:", err)
+				return
+			}
+			userName := getUsernameFromMember(member)
+
+			reset(userName, softwareType)
+			tableName, _ := getTableNameAndBaseURL(strings.ToLower(softwareType))
+
+			_, err = resetAndVerify(tableName, int(userUID))
+			if err != nil {
+				log.Println("Error resetting hwid:", err)
+			}
+			log.Printf("Reset the HWID of user %s with UID %d for %s", userName, userUID, 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) != 4 {
+				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 getTableNameAndBaseURL(choice string) (string, string) {
+	var tableName, baseURL string
+
+	switch choice {
+	case "vanity":
+		tableName = "AuthUserData"
+		baseURL = "http://vanitycheats.xyz/UserAuthentication.php"
+	case "mesa":
+		tableName = "AuthUserData-Mesachanger.com"
+		baseURL = "http://mesachanger.com/UserAuthentication.php"
+	default:
+		fmt.Println("Invalid choice. Please choose 'vanity' or 'mesa'.")
+	}
+
+	return tableName, baseURL
+}
+
+func fetchUserID(username string, baseURL string) (int, error) {
+	requestBody := &bytes.Buffer{}
+	multiPartWriter := multipart.NewWriter(requestBody)
+	err := multiPartWriter.WriteField("username", username)
+	if err != nil {
+		return 0, fmt.Errorf("error adding username field: %w", err)
+	}
+	multiPartWriter.Close()
+	request, err := http.NewRequest("POST", baseURL, requestBody)
+	if err != nil {
+		return 0, fmt.Errorf("error creating request: %w", err)
+	}
+	request.Header.Set("Content-Type", multiPartWriter.FormDataContentType())
+	client := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+	resp, err := client.Do(request)
+	if err != nil {
+		return 0, fmt.Errorf("error sending request: %w", err)
+	}
+	defer resp.Body.Close()
+	var userResp UserResponse
+	err = json.NewDecoder(resp.Body).Decode(&userResp)
+	if err != nil {
+		return 0, fmt.Errorf("error decoding JSON: %w", err)
+	}
+	uid, err := strconv.Atoi(userResp.ID)
+	if err != nil {
+		return 0, fmt.Errorf("error converting user ID: %w", err)
+	}
+	return uid, nil
+}
+
+func resetHWID(tableName string, uids []int) {
+	query := fmt.Sprintf(`UPDATE public.%q
+		SET "StorageIdentifier" = NULL, "BootIdentifier" = NULL
+		WHERE "UID" = ANY($1)`, tableName)
+
+	_, err := db.Exec(query, pq.Array(uids))
+	if err != nil {
+		log.Printf("Error resetting HWID: %v", err)
+		return
+	}
+}
+
+func resetAndVerify(tableName string, uid int) (bool, error) {
+	var beforeHash string
+	err := db.QueryRow(
+		fmt.Sprintf(`SELECT MD5(CONCAT("StorageIdentifier", "BootIdentifier")) FROM public.%q WHERE "UID" = $1`, tableName),
+		uid,
+	).Scan(&beforeHash)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return false, fmt.Errorf("no rows found for UID %d", uid)
+		}
+		return false, fmt.Errorf("error querying database: %v", err)
+	}
+
+	resetHWID(tableName, []int{uid})
+
+	var afterHash string
+	err = db.QueryRow(
+		fmt.Sprintf(`SELECT MD5(CONCAT("StorageIdentifier", "BootIdentifier")) FROM public.%q WHERE "UID" = $1`, tableName),
+		uid,
+	).Scan(&afterHash)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return false, fmt.Errorf("no rows found for UID %d after reset", uid)
+		}
+		return false, fmt.Errorf("error querying database after reset: %v", err)
+	}
+
+	return beforeHash != afterHash, nil
+}
+
 func main() {
 	if client == nil {
 		log.Println("Bot client is not initialized")
@@ -263,8 +585,13 @@ func main() {
 				h(client, i)
 			}
 		} else if i.Type == discordgo.InteractionMessageComponent {
-			if h, ok := componentsHandlers[i.MessageComponentData().CustomID]; ok {
+			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)
 			}
 		}
 	})
@@ -286,4 +613,3 @@ func main() {
 		db.Close()
 	}
 }
-