admin

Documentation

Index

• Variables

Variables

var DubStatus = internal.Command{
	Name:        "dubstatus",
	Description: "Ändrar statusen av boten",
	Aliases:     []string{},
	Group:       "admin",
	Usage:       "dubstatus <PLAYING|STREAMING|LISTENING|WATCHING> <status>",
	Example:     "dubstatus WATCHING kelvin's cat",
	ServerOnly:  true,
	AdminOnly:   true,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		if len(ctx.Args) == 0 {
			ctx.Reply("Du måste ange en status.")
			return nil
		}

		status := strings.ToUpper(ctx.Args[0])
		statusText := strings.Join(ctx.Args[1:], " ")
		discordStatus := discordgo.UpdateStatusData{}
		discordStatus.Game = new(discordgo.Game)

		switch status {
		case "PLAYING":
			discordStatus.Game.Type = discordgo.GameTypeGame
		case "STREAMING":
			discordStatus.Game.Type = discordgo.GameTypeStreaming
		case "LISTENING":
			discordStatus.Game.Type = discordgo.GameTypeListening
		case "WATCHING":
			discordStatus.Game.Type = discordgo.GameTypeWatching
		default:
			_, err := ctx.Reply("Felaktig status")
			if err != nil {
				return err
			}
			return nil
		}

		discordStatus.Status = statusText
		discordStatus.Game.Name = statusText

		err := ctx.Discord.UpdateStatusComplex(discordStatus)
		if err != nil {
			return err
		}

		server.Status = discordStatus

		ctx.Reply(fmt.Sprintf("Sätter statusen till `%v %v`", status, statusText))

		return nil
	},
}

var Join = internal.Command{
	Name:        "join",
	Description: "Simulerar en användare joinar",
	Aliases:     []string{},
	Group:       "admin",
	Usage:       "join @<user>",
	Example:     "join @kelszo#6200",
	ServerOnly:  true,
	AdminOnly:   true,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		var member *discordgo.Member

		if len(ctx.Message.Mentions) == 0 {
			ctx.Reply("Du måste ange en användare som ska joina.")
			return nil
		}

		for _, guildMember := range server.Guild.Members {
			if guildMember.User.ID == ctx.Message.Mentions[0].ID {
				member = guildMember
			}
		}

		guildMemberAdd := &discordgo.GuildMemberAdd{Member: member}

		events.GuildMemberAddHandler(server)(ctx.Discord, guildMemberAdd)

		return nil
	},
}

var SendDM = internal.Command{
	Name:        "senddm",
	Description: "Skickar meddelande till medlemmarna via direct message",
	Aliases:     []string{},
	Group:       "admin",
	Usage:       "senddm <[!]groupID|userID|\"EVERYONE\"> <message|[{{{nick|username|mention}}}]>",
	Example:     "senddm !568110630809370624 Hej **{{{alias}}}**, vi ser att du inte är verifierad, bli det gärna!",
	ServerOnly:  true,
	AdminOnly:   true,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		if len(ctx.Args) < 2 {
			ctx.Reply("Du måste ange groupID|userID|\"EVERYONE\" och ett meddelande.")
			return nil
		}

		if strings.ToUpper(ctx.Args[0]) != "EVERYONE" && !pkg.IsSnowflake(ctx.Args[0]) && !pkg.IsSnowflake(string(ctx.Args[0][1:])) {
			ctx.Reply("Första argumentet måste vara en snowflake eller EVERYONE.")
			return nil
		}

		messageTemplate := strings.Join(ctx.Args[1:], " ")

		var membersToSend []*discordgo.Member

		if strings.ToUpper(ctx.Args[0]) == "EVERYONE" {
			membersToSend = server.Guild.Members
		} else {
			snowflake := ctx.Args[0]
			isOpposite := false
			isRole := false

			if string(snowflake[0]) == "!" {
				snowflake = string(snowflake[1:])
				isOpposite = true
			}

			for _, role := range server.Guild.Roles {
				if role.ID == snowflake {
					isRole = true
				}
			}

			if isOpposite {
				if !isRole {
					ctx.Reply("Ingen roll med det IDt finns.")
					return nil
				}

				for _, member := range server.Guild.Members {
					if !pkg.StringInSlice(snowflake, member.Roles) {
						membersToSend = append(membersToSend, member)
					}
				}
			} else {
				if isRole {
					for _, member := range server.Guild.Members {
						if pkg.StringInSlice(snowflake, member.Roles) {
							membersToSend = append(membersToSend, member)
						}
					}
				} else {
					for _, member := range server.Guild.Members {
						if member.User.ID == snowflake {
							membersToSend = append(membersToSend, member)
						}
					}
				}
			}
		}

		for _, member := range membersToSend {
			if member.User.Bot {
				continue
			}

			message, err := mustache.Render(messageTemplate, map[string]string{"nick": member.Nick, "username": member.User.Username, "mention": member.Mention()})
			if err != nil {
				ctx.Reply(fmt.Sprintf("Error med att kompilera meddelandet till %v.", member.Nick))
				return err
			}

			privateDM, err := ctx.Discord.UserChannelCreate(member.User.ID)
			if err != nil {
				ctx.Reply(fmt.Sprintf("Error med att skicka meddelandet till %v.", member.Nick))
				return err
			}

			ctx.Discord.ChannelMessageSend(privateDM.ID, message)
			if err != nil {
				ctx.Reply(fmt.Sprintf("Error med att skicka meddelandet till %v.", member.Nick))
				return err
			}
		}

		return nil
	},
}

var SendGuild = internal.Command{
	Name:        "sendguild",
	Description: "Skickar meddelande till medlemmarna via Discord kanalen",
	Aliases:     []string{},
	Group:       "admin",
	Usage:       "sendguild <channelID> <groupID|userID|\"EVERYONE\"> <message>",
	Example:     "sendguild 573654197703278593 228889878861971456 **Hej** {{{mention}}}, hur mår du?",
	ServerOnly:  true,
	AdminOnly:   true,

	Execute: func(ctx *pkg.Context, server *internal.Server) error {
		var err error

		if len(ctx.Args) < 3 {
			ctx.Reply("Du måste ange channelID, groupID|userID|\"EVERYONE\" och ett meddelande.")
			return nil
		}

		if !pkg.IsSnowflake(ctx.Args[0]) {
			ctx.Reply("channelID måste vara en snowflake.")
			return nil
		}

		var channel *discordgo.Channel
		channel, err = ctx.Discord.Channel(ctx.Args[0])
		if err != nil || channel.GuildID != server.Guild.ID {
			ctx.Reply("ChannelID måste vara ett giltigt ID.")
			return nil
		}

		if !pkg.IsSnowflake(ctx.Args[1]) && strings.ToUpper(ctx.Args[1]) != "EVERYONE" {
			ctx.Reply("Du måste ange en snowflake eller EVERYONE.")
			return nil
		}

		messageTemplate := strings.Join(ctx.Args[2:], " ")
		var message string
		var mention string

		if strings.ToUpper(ctx.Args[1]) == "EVERYONE" {
			mention = "@everyone"
		}

		if pkg.IsSnowflake(ctx.Args[1]) {
			for _, role := range server.Guild.Roles {
				if role.ID == ctx.Args[1] {
					mention = role.Mention()
				}
			}

			if mention == "" {
				for _, member := range server.Guild.Members {
					if member.User.ID == ctx.Args[1] {
						mention = member.Mention()
					}
				}
			}

			if mention == "" {
				ctx.Reply("Du måste ange ett giltigt channelID|userID")
				return nil
			}
		}

		message, err = mustache.Render(messageTemplate, map[string]string{"mention": mention})
		if err != nil {
			ctx.Reply("Error med att kompilera meddelandet.")
			return err
		}

		ctx.Discord.ChannelMessageSend(ctx.Args[0], message)

		return nil
	},
}