Compare commits

..

No commits in common. "main" and "Perms" have entirely different histories.
main ... Perms

231
main.go
View File

@ -122,10 +122,10 @@ func getUsernameFromMember(member *discordgo.Member) string {
var userName string
if member.Nick != "" {
userName = member.Nick
} else if member.User.GlobalName != "" {
userName = member.User.GlobalName
} else {
} else if member.User != nil && member.User.Username != "" {
userName = member.User.Username
} else {
userName = "UnknownUser"
}
return userName
}
@ -144,30 +144,6 @@ var (
},
},
},
{
Name: "resetvanity",
Description: "Reset a user's HWID for Vanity by username or UID",
Options: []*discordgo.ApplicationCommandOption{
{
Type: discordgo.ApplicationCommandOptionString,
Name: "identifier",
Description: "Usernames or UIDs, separated by commas",
Required: true,
},
},
},
{
Name: "resetmesa",
Description: "Reset a user's HWID for Mesa by username or UID",
Options: []*discordgo.ApplicationCommandOption{
{
Type: discordgo.ApplicationCommandOptionString,
Name: "identifier",
Description: "Usernames or UIDs, separated by commas",
Required: true,
},
},
},
}
commandsHandlers = map[string]func(client *discordgo.Session, i *discordgo.InteractionCreate){
"setup": func(client *discordgo.Session, i *discordgo.InteractionCreate) {
@ -233,12 +209,6 @@ var (
log.Println("Error sending interaction response:", err)
}
},
"resetvanity": func(client *discordgo.Session, i *discordgo.InteractionCreate) {
resetCommandHandler(client, i, "vanity")
},
"resetmesa": func(client *discordgo.Session, i *discordgo.InteractionCreate) {
resetCommandHandler(client, i, "mesa")
},
}
componentsHandlers = map[string]func(client *discordgo.Session, i *discordgo.InteractionCreate){
@ -360,7 +330,7 @@ var (
}
_, err = client.ChannelMessageSendComplex(channel.ID, &discordgo.MessageSend{
Content: fmt.Sprintf("Reset request by <@%s> for %s", userID, softwareType),
Content: fmt.Sprintf("Reset request by %s for %s", userName, softwareType),
Components: []discordgo.MessageComponent{
discordgo.ActionsRow{
Components: []discordgo.MessageComponent{
@ -404,20 +374,10 @@ var (
reset(userName, softwareType)
tableName, _ := getTableNameAndBaseURL(strings.ToLower(softwareType))
successes, errors := resetAndVerify(tableName, []int{userUID})
if len(errors) > 0 {
for _, err := range errors {
_, err = resetAndVerify(tableName, int(userUID))
if err != nil {
log.Println("Error resetting hwid:", err)
}
} else {
for _, success := range successes {
if success {
log.Printf("Reset successful for UID %d", userUID)
} else {
log.Printf("Reset unsuccessful for UID %d", userUID)
}
}
}
log.Printf("Reset the HWID of user %s with UID %d for %s", userName, userUID, softwareType)
err = client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
@ -487,122 +447,6 @@ var (
}
)
func resetCommandHandler(client *discordgo.Session, i *discordgo.InteractionCreate, softwareType string) {
hasAdminPermission := false
var err error
var tableName string
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
}
identifier := i.ApplicationCommandData().Options[0].StringValue()
identifierList := strings.Split(identifier, ",")
var userUIDs []int
for _, identifier := range identifierList {
identifier = strings.TrimSpace(identifier)
var userName string
var userUID int
var err error
if uid, err := strconv.Atoi(identifier); err == nil {
userUID = uid
} else {
userName = identifier
}
if userName != "" {
_, baseURL := getTableNameAndBaseURL(softwareType)
userUID, err = fetchUserID(userName, baseURL)
if err != nil {
log.Println("Error fetching user ID:", err)
continue
}
}
if userUID != 0 {
userUIDs = append(userUIDs, userUID)
}
}
if len(userUIDs) == 0 {
err := client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
Type: discordgo.InteractionResponseChannelMessageWithSource,
Data: &discordgo.InteractionResponseData{
Content: "No valid users found to reset.",
Flags: discordgo.MessageFlagsEphemeral,
},
})
if err != nil {
log.Println("Error sending interaction response:", err)
}
return
}
tableName, _ = getTableNameAndBaseURL(softwareType)
successes, errors := resetAndVerify(tableName, userUIDs)
if len(errors) > 0 {
for _, err := range errors {
log.Println("Error:", err)
}
} else {
for i, success := range successes {
if success {
log.Printf("Reset successful for UID %d", userUIDs[i])
} else {
log.Printf("Reset unsuccessful for UID %d", userUIDs[i])
}
}
}
for _, uid := range userUIDs {
log.Printf("Reset the HWID of user with UID %d for %s", uid, softwareType)
}
err = client.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
Type: discordgo.InteractionResponseChannelMessageWithSource,
Data: &discordgo.InteractionResponseData{
Content: fmt.Sprintf("Successfully reset HWID for %d users.", len(userUIDs)),
Flags: discordgo.MessageFlagsEphemeral,
},
})
if err != nil {
log.Println("Error sending interaction response:", err)
}
}
func canCreateTicket(userName, softwareType string) bool {
guildChannels, err := client.GuildChannels(config.Discord.GuildID)
if err != nil {
@ -684,63 +528,34 @@ func resetHWID(tableName string, uids []int) {
}
}
func resetAndVerify(tableName string, uids []int) ([]bool, []error) {
var successes []bool
var errorsSlice []error
rows, err := db.Query(fmt.Sprintf(`SELECT "UID", MD5(CONCAT("StorageIdentifier", "BootIdentifier")) FROM public.%q WHERE "UID" = ANY($1)`, tableName), pq.Array(uids))
if err != nil {
log.Printf("Error querying database for before hashes: %v", err)
return nil, []error{err}
}
defer rows.Close()
beforeHashesMap := make(map[int]string)
for rows.Next() {
var uid int
func resetAndVerify(tableName string, uid int) (bool, error) {
var beforeHash string
err := rows.Scan(&uid, &beforeHash)
err := db.QueryRow(
fmt.Sprintf(`SELECT MD5(CONCAT("StorageIdentifier", "BootIdentifier")) FROM public.%q WHERE "UID" = $1`, tableName),
uid,
).Scan(&beforeHash)
if err != nil {
log.Printf("Error scanning rows: %v", err)
errorsSlice = append(errorsSlice, err)
continue
if err == sql.ErrNoRows {
return false, fmt.Errorf("no rows found for UID %d", uid)
}
beforeHashesMap[uid] = beforeHash
return false, fmt.Errorf("error querying database: %v", err)
}
resetHWID(tableName, uids)
resetHWID(tableName, []int{uid})
rows, err = db.Query(fmt.Sprintf(`SELECT "UID", MD5(CONCAT("StorageIdentifier", "BootIdentifier")) FROM public.%q WHERE "UID" = ANY($1)`, tableName), pq.Array(uids))
if err != nil {
log.Printf("Error querying database for after hashes: %v", err)
return nil, []error{err}
}
defer rows.Close()
afterHashesMap := make(map[int]string)
for rows.Next() {
var uid int
var afterHash string
err := rows.Scan(&uid, &afterHash)
err = db.QueryRow(
fmt.Sprintf(`SELECT MD5(CONCAT("StorageIdentifier", "BootIdentifier")) FROM public.%q WHERE "UID" = $1`, tableName),
uid,
).Scan(&afterHash)
if err != nil {
log.Printf("Error scanning rows: %v", err)
errorsSlice = append(errorsSlice, err)
continue
if err == sql.ErrNoRows {
return false, fmt.Errorf("no rows found for UID %d after reset", uid)
}
afterHashesMap[uid] = afterHash
return false, fmt.Errorf("error querying database after reset: %v", err)
}
for _, uid := range uids {
afterHash, ok := afterHashesMap[uid]
if !ok {
errorsSlice = append(errorsSlice, fmt.Errorf("no rows found for UID %d after reset", uid))
successes = append(successes, false)
continue
}
successes = append(successes, beforeHashesMap[uid] != afterHash || afterHash == "d41d8cd98f00b204e9800998ecf8427e")
}
return successes, errorsSlice
return beforeHash != afterHash, nil
}
func main() {