You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
405 lines
13 KiB
405 lines
13 KiB
package guild
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/bwmarrin/discordgo"
|
|
"github.com/dustinpianalto/disgoman"
|
|
"github.com/dustinpianalto/geeksbot"
|
|
"github.com/dustinpianalto/geeksbot/internal/discord_utils"
|
|
"github.com/dustinpianalto/geeksbot/internal/services"
|
|
"github.com/dustinpianalto/geeksbot/internal/utils"
|
|
)
|
|
|
|
var AddModeratorRoleCommand = &disgoman.Command{
|
|
Name: "addMod",
|
|
Aliases: []string{"addModerator", "addModRole"},
|
|
Description: "Add a role which is allowed to run moderator commands",
|
|
OwnerOnly: false,
|
|
Hidden: false,
|
|
RequiredPermissions: disgoman.PermissionManageServer,
|
|
Invoke: addModeratorRoleCommandFunc,
|
|
}
|
|
|
|
func addModeratorRoleCommandFunc(ctx disgoman.Context, args []string) {
|
|
var count int
|
|
added := make(map[string]bool)
|
|
guild, err := services.GuildService.GetOrCreateGuild(ctx.Guild.ID)
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, "Something went wrong getting the guild", err)
|
|
return
|
|
}
|
|
roles := append(args, ctx.Message.MentionRoles...)
|
|
if len(roles) > 0 {
|
|
for _, id := range roles {
|
|
if strings.HasPrefix(id, "<@&") && strings.HasSuffix(id, ">") {
|
|
continue
|
|
}
|
|
if _, ok := added[id]; ok {
|
|
continue
|
|
}
|
|
if _, err = ctx.Session.State.Role(ctx.Guild.ID, id); err != nil {
|
|
_, _ = ctx.Send(fmt.Sprintf("%s does not reference a valid role for this guild.", id))
|
|
continue
|
|
}
|
|
_, err := services.GuildService.CreateOrUpdateRole(geeksbot.Role{
|
|
ID: id,
|
|
RoleType: "moderator",
|
|
Guild: guild,
|
|
})
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("There was a problem adding <@&%s>", id), err)
|
|
continue
|
|
}
|
|
added[id] = true
|
|
count++
|
|
_, _ = ctx.Send(fmt.Sprintf("Added <@&%s> as a moderator role.", id))
|
|
}
|
|
_, _ = ctx.Send(fmt.Sprintf("Added %d moderator %s.", count, utils.PluralizeString("role", count)))
|
|
} else {
|
|
_, _ = ctx.Send("Please include at least one role to make a moderator role.")
|
|
}
|
|
}
|
|
|
|
var AddAdminRoleCommand = &disgoman.Command{
|
|
Name: "addAdmin",
|
|
Aliases: []string{"addAdminRole"},
|
|
Description: "Add a role which is allowed to run admin commands",
|
|
OwnerOnly: false,
|
|
Hidden: false,
|
|
RequiredPermissions: disgoman.PermissionManageServer,
|
|
Invoke: addAdminRoleCommandFunc,
|
|
}
|
|
|
|
func addAdminRoleCommandFunc(ctx disgoman.Context, args []string) {
|
|
var count int
|
|
added := make(map[string]bool)
|
|
guild, err := services.GuildService.GetOrCreateGuild(ctx.Guild.ID)
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, "Something went wrong getting the guild", err)
|
|
return
|
|
}
|
|
roles := append(args, ctx.Message.MentionRoles...)
|
|
if len(roles) > 0 {
|
|
for _, id := range roles {
|
|
if strings.HasPrefix(id, "<@&") && strings.HasSuffix(id, ">") {
|
|
continue
|
|
}
|
|
if _, ok := added[id]; ok {
|
|
continue
|
|
}
|
|
if _, err = ctx.Session.State.Role(ctx.Guild.ID, id); err != nil {
|
|
_, _ = ctx.Send(fmt.Sprintf("%s does not reference a valid role for this guild.", id))
|
|
continue
|
|
}
|
|
_, err := services.GuildService.CreateOrUpdateRole(geeksbot.Role{
|
|
ID: id,
|
|
RoleType: "admin",
|
|
Guild: guild,
|
|
})
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("There was a problem adding <@&%s>", id), err)
|
|
continue
|
|
}
|
|
added[id] = true
|
|
count++
|
|
_, _ = ctx.Send(fmt.Sprintf("Added <@&%s> as an admin role.", id))
|
|
}
|
|
_, _ = ctx.Send(fmt.Sprintf("Added %d admin %s.", count, utils.PluralizeString("role", count)))
|
|
} else {
|
|
_, _ = ctx.Send("Please include at least one role to make an admin role.")
|
|
}
|
|
}
|
|
|
|
var RemoveModRoleCommand = &disgoman.Command{
|
|
Name: "removeMod",
|
|
Aliases: []string{"removeModeratorRole", "removeModRole", "removeAdmin", "removeAdminRole"},
|
|
Description: "Remove a role or several roles from the moderator or admin list",
|
|
OwnerOnly: false,
|
|
Hidden: false,
|
|
RequiredPermissions: disgoman.PermissionManageServer,
|
|
Invoke: removeModRoleCommandFunc,
|
|
}
|
|
|
|
func removeModRoleCommandFunc(ctx disgoman.Context, args []string) {
|
|
var count int
|
|
added := make(map[string]bool)
|
|
guild, err := services.GuildService.GetOrCreateGuild(ctx.Guild.ID)
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, "Something went wrong getting the guild", err)
|
|
return
|
|
}
|
|
roles := append(args, ctx.Message.MentionRoles...)
|
|
if len(roles) > 0 {
|
|
for _, id := range roles {
|
|
if strings.HasPrefix(id, "<@&") && strings.HasSuffix(id, ">") {
|
|
continue
|
|
}
|
|
if _, ok := added[id]; ok {
|
|
continue
|
|
}
|
|
if _, err = ctx.Session.State.Role(ctx.Guild.ID, id); err != nil {
|
|
if r, err := services.GuildService.Role(id); err != nil {
|
|
_, _ = ctx.Send(fmt.Sprintf("%s does not reference a valid role for this guild.", id))
|
|
continue
|
|
} else {
|
|
err = services.GuildService.DeleteRole(r)
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, "Something went wrong deleting the role", err)
|
|
}
|
|
_, _ = ctx.Send(fmt.Sprintf("Deleted <@&%s> as a no longer a valid role.", id))
|
|
continue
|
|
}
|
|
}
|
|
_, err := services.GuildService.CreateOrUpdateRole(geeksbot.Role{
|
|
ID: id,
|
|
RoleType: "normal",
|
|
Guild: guild,
|
|
})
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("There was a problem updating <@&%s>", id), err)
|
|
continue
|
|
}
|
|
added[id] = true
|
|
count++
|
|
_, _ = ctx.Send(fmt.Sprintf("Set <@&%s> as a normal role.", id))
|
|
}
|
|
_, _ = ctx.Send(fmt.Sprintf("Set %d %s to normal.", count, utils.PluralizeString("role", count)))
|
|
} else {
|
|
_, _ = ctx.Send("Please include at least one role to remove from the moderator or admin lists.")
|
|
}
|
|
}
|
|
|
|
var MakeRoleSelfAssignableCommand = &disgoman.Command{
|
|
Name: "make-role-self-assignable",
|
|
Aliases: []string{"makesar", "addsar"},
|
|
Description: "Makes the passed in role self assignable by anyone",
|
|
OwnerOnly: false,
|
|
Hidden: false,
|
|
RequiredPermissions: disgoman.PermissionManageServer,
|
|
Invoke: makeRoleSelfAssignableCommandFunc,
|
|
}
|
|
|
|
func makeRoleSelfAssignableCommandFunc(ctx disgoman.Context, args []string) {
|
|
added := make(map[string]bool)
|
|
guild, err := services.GuildService.GetOrCreateGuild(ctx.Guild.ID)
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, "Something went wrong getting the guild", err)
|
|
return
|
|
}
|
|
|
|
roles := append(args, ctx.Message.MentionRoles...)
|
|
if len(roles) > 0 {
|
|
for _, id := range roles {
|
|
if strings.HasPrefix(id, "<@&") && strings.HasSuffix(id, ">") {
|
|
continue
|
|
}
|
|
if _, ok := added[id]; ok {
|
|
continue
|
|
}
|
|
|
|
var role *discordgo.Role
|
|
var err error
|
|
if role, err = ctx.Session.State.Role(ctx.Guild.ID, id); err != nil {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("%s does not reference a valid role for this guild", id), err)
|
|
return
|
|
}
|
|
|
|
_, err = services.GuildService.CreateOrUpdateRole(geeksbot.Role{
|
|
ID: role.ID,
|
|
RoleType: "sar",
|
|
Guild: guild,
|
|
})
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("There was a problem updating <@&%s>", role.ID), err)
|
|
return
|
|
}
|
|
_, _ = ctx.Send(fmt.Sprintf("%s is now self assignable", role.Name))
|
|
|
|
}
|
|
} else {
|
|
_, _ = ctx.Send("Please include at least one role to make self assignable")
|
|
}
|
|
|
|
}
|
|
|
|
var RemoveSelfAssignableCommand = &disgoman.Command{
|
|
Name: "remove-self-assignable-role",
|
|
Aliases: []string{"removesar"},
|
|
Description: "Makes a role that was previously self assignable not so",
|
|
OwnerOnly: false,
|
|
Hidden: false,
|
|
RequiredPermissions: disgoman.PermissionManageServer,
|
|
Invoke: removeSelfAssignableRoleCommandFunc,
|
|
}
|
|
|
|
func removeSelfAssignableRoleCommandFunc(ctx disgoman.Context, args []string) {
|
|
removed := make(map[string]bool)
|
|
guild, err := services.GuildService.GetOrCreateGuild(ctx.Guild.ID)
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, "Something went wrong getting the guild", err)
|
|
return
|
|
}
|
|
|
|
roles := append(args, ctx.Message.MentionRoles...)
|
|
if len(roles) > 0 {
|
|
for _, id := range roles {
|
|
if strings.HasPrefix(id, "<@&") && strings.HasSuffix(id, ">") {
|
|
continue
|
|
}
|
|
if _, ok := removed[id]; ok {
|
|
continue
|
|
}
|
|
|
|
var err error
|
|
var role *discordgo.Role
|
|
if role, err = ctx.Session.State.Role(ctx.Guild.ID, id); err != nil {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("%s does not reference a valid role for this guild", id), err)
|
|
return
|
|
}
|
|
_, err = services.GuildService.CreateOrUpdateRole(geeksbot.Role{
|
|
ID: role.ID,
|
|
RoleType: "normal",
|
|
Guild: guild,
|
|
})
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("There was a problem updating <@&%s>", role.ID), err)
|
|
return
|
|
}
|
|
_, _ = ctx.Send(fmt.Sprintf("%s's self assignability has been removed.", role.Name))
|
|
}
|
|
} else {
|
|
_, _ = ctx.Send("Please include at least one role to make self assignable")
|
|
}
|
|
|
|
}
|
|
|
|
var SelfAssignRoleCommand = &disgoman.Command{
|
|
Name: "giverole",
|
|
Aliases: []string{"iwant", "givetome", "addrole"},
|
|
Description: "Assigns a person the passed in role if it is self assignable",
|
|
OwnerOnly: false,
|
|
Hidden: false,
|
|
RequiredPermissions: 0,
|
|
Invoke: selfAssignRoleCommandFunc,
|
|
}
|
|
|
|
func selfAssignRoleCommandFunc(ctx disgoman.Context, args []string) {
|
|
added := make(map[string]bool)
|
|
roles := append(args, ctx.Message.MentionRoles...)
|
|
if len(roles) > 0 {
|
|
for _, id := range roles {
|
|
var roleID string
|
|
if strings.HasPrefix(id, "<@&") && strings.HasSuffix(id, ">") {
|
|
continue
|
|
} else if _, err := strconv.Atoi(id); err == nil {
|
|
roleID = id
|
|
} else {
|
|
for _, role := range ctx.Guild.Roles {
|
|
if strings.ToLower(id) == strings.ToLower(role.Name) {
|
|
roleID = role.ID
|
|
}
|
|
}
|
|
}
|
|
|
|
if _, ok := added[id]; ok {
|
|
continue
|
|
}
|
|
var role *discordgo.Role
|
|
var err error
|
|
if role, err = ctx.Session.State.Role(ctx.Guild.ID, roleID); err != nil {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("%s does not reference a valid role for this guild", roleID), err)
|
|
return
|
|
}
|
|
if memberHasRole(ctx.Member, role.ID) {
|
|
_, _ = ctx.Send(fmt.Sprintf("You already have the %s role silly...", role.Name))
|
|
return
|
|
}
|
|
r, err := services.GuildService.Role(role.ID)
|
|
if err != nil || r.RoleType != "sar" {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("You aren't allowed to assign yourself the %s role", role.Name), err)
|
|
return
|
|
}
|
|
err = ctx.Session.GuildMemberRoleAdd(ctx.Guild.ID, ctx.User.ID, role.ID)
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, "There was a problem adding that role to you.", err)
|
|
return
|
|
}
|
|
_, _ = ctx.Send(fmt.Sprintf("Congratulations! The %s role has been added to your... Ummm... Thing.", role.Name))
|
|
}
|
|
} else {
|
|
_, _ = ctx.Send("Please include at least one role to make self assignable")
|
|
}
|
|
|
|
}
|
|
|
|
var UnAssignRoleCommand = &disgoman.Command{
|
|
Name: "removerole",
|
|
Aliases: []string{"idon'twant"},
|
|
Description: "Removes a role from a person if the role is self assignable",
|
|
OwnerOnly: false,
|
|
Hidden: false,
|
|
RequiredPermissions: 0,
|
|
Invoke: unAssignRoleCommandFunc,
|
|
}
|
|
|
|
func unAssignRoleCommandFunc(ctx disgoman.Context, args []string) {
|
|
removed := make(map[string]bool)
|
|
roles := append(args, ctx.Message.MentionRoles...)
|
|
if len(roles) > 0 {
|
|
for _, id := range roles {
|
|
var roleID string
|
|
if strings.HasPrefix(id, "<@&") && strings.HasSuffix(id, ">") {
|
|
continue
|
|
} else if _, err := strconv.Atoi(id); err == nil {
|
|
roleID = id
|
|
} else {
|
|
for _, role := range ctx.Guild.Roles {
|
|
if strings.ToLower(id) == strings.ToLower(role.Name) {
|
|
roleID = role.ID
|
|
}
|
|
}
|
|
}
|
|
if _, ok := removed[id]; ok {
|
|
continue
|
|
}
|
|
|
|
var role *discordgo.Role
|
|
var err error
|
|
if role, err = ctx.Session.State.Role(ctx.Guild.ID, roleID); err != nil {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("%s does not reference a valid role for this guild", roleID), err)
|
|
return
|
|
}
|
|
if !memberHasRole(ctx.Member, role.ID) {
|
|
_, _ = ctx.Send(fmt.Sprintf("I can't remove the %s role from you because you don't have it...", role.Name))
|
|
return
|
|
}
|
|
r, err := services.GuildService.Role(role.ID)
|
|
if err != nil || r.RoleType != "sar" {
|
|
discord_utils.SendErrorMessage(ctx, fmt.Sprintf("You aren't allowed to assign yourself the %s role", role.Name), err)
|
|
return
|
|
}
|
|
err = ctx.Session.GuildMemberRoleRemove(ctx.Guild.ID, ctx.User.ID, role.ID)
|
|
if err != nil {
|
|
discord_utils.SendErrorMessage(ctx, "There was a problem removing that role from your account", err)
|
|
return
|
|
}
|
|
_, _ = ctx.Send(fmt.Sprintf("Sad to see you go... but the %s role has been removed.", role.Name))
|
|
}
|
|
} else {
|
|
_, _ = ctx.Send("Please include at least one role to make self assignable")
|
|
}
|
|
|
|
}
|
|
|
|
func memberHasRole(m *discordgo.Member, id string) bool {
|
|
for _, r := range m.Roles {
|
|
if r == id {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|