commands

Documentation

Index

• Variables
• type PingPongCommand
• type PinterestResponse
• type PinterestResult

Variables

var Doggie = &gophelper.Command{
	ID: "Doggie",

	Name:    "🐕 Doggie",
	Aliases: []string{"doggie", "doggy", "dog"},

	Category: gophelper.CATEGORY_FUN,

	Description: "Random pics of cute doggies",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		arguments := context.Arguments
		message := context.Event.Message
		session := context.Session

		routerLanguage := context.Router.Config.Language
		language := context.Command.LanguageSettings

		isTag := false
		userID := message.Author.ID

		if len(arguments) > 0 {
			isTag = true
			userID = arguments[0]

			if utils.IsMention(userID) {
				userID = utils.MentionToID(userID)
			}
		}

		title := language.Response.NonMention

		if isTag {
			member, err := session.GuildMember(message.GuildID, userID)

			nick := message.Author.Username

			if err == nil {
				nick = member.User.Username
			}

			title = fmt.Sprintf(language.Response.Mention, nick)
		}

		index := rand.Intn(len(doggies))

		url := doggies[index]

		if strings.Contains(url, "?") {
			url = fmt.Sprintf("%s&nocache=%d", url, time.Now().UnixNano())
		} else {
			url = fmt.Sprintf("%s?nocache=%d", url, time.Now().UnixNano())
		}

		embed := &discordgo.MessageEmbed{
			Title: title,
			Color: 0xFFbbbb,
			Provider: &discordgo.MessageEmbedProvider{
				URL: url,
			},
			Image: &discordgo.MessageEmbedImage{
				URL: url,
			},
		}

		message, err := session.ChannelMessageSendEmbed(message.ChannelID, embed)

		if err != nil {
			_, err = session.ChannelMessageSend(message.ChannelID, routerLanguage.Errors.MessageSend)
			fmt.Println("Failed to send message")
		} else {
			err = session.MessageReactionAdd(message.ChannelID, message.ID, "🐕")
		}

		if err != nil {
			fmt.Println("Error on doggie command when reacting/sending message")
		}
	},
}

Doggie doggies

var EightBall = &gophelper.Command{
	ID: "8Ball",

	Name:    "🎱 8Ball",
	Aliases: []string{"8ball"},

	Category: gophelper.CATEGORY_FUN,

	Description: "I'll tell you truth",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		arguments := context.Arguments
		session := context.Session
		message := context.Event

		language := context.Command.LanguageSettings

		answers := language.Answers

		var err error

		if len(arguments) == 0 {
			_, err = session.ChannelMessageSend(message.ChannelID, language.NoArgumentsMessage)
		} else {
			index := rand.Intn(len(answers))
			randomAnswer := answers[index]
			_, err = session.ChannelMessageSend(message.ChannelID, randomAnswer)
		}

		if err != nil {
			fmt.Println("Error on 8ball command when sending message")
		}
	},
}

EightBall doggies

var Help = &gophelper.Command{
	ID: "Help",

	Name:    "📜 Help",
	Aliases: []string{"help"},

	Category: gophelper.CATEGORY_MISC,

	Description: "Get some help",

	Usage: "help [_category [_page]/_command]",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 30,
	},

	Handler: func(context *gophelper.CommandContext) {
		session := context.Session
		message := context.Event
		router := context.Router
		arguments := context.Arguments
		language := context.Command.LanguageSettings

		var (
			embed           *discordgo.MessageEmbed
			reactMessage    *discordgo.Message
			closeHandler    func()
			page            int
			pages           int
			categoryAlias   string
			err             error
			categoryHandler func(session *discordgo.Session, event *discordgo.MessageReactionAdd)
			pageHandler     func(session *discordgo.Session, event *discordgo.MessageReactionAdd)

			expireCooldown int = 15
			expireTimer    int = expireCooldown
		)

		pageHandler = func(session *discordgo.Session, event *discordgo.MessageReactionAdd) {
			if event.UserID != session.State.User.ID {
				err := session.MessageReactionRemove(event.ChannelID, event.MessageID, event.Emoji.Name, event.UserID)
				if err != nil {
					fmt.Printf("Failed to remove reaction %s", event.Emoji.Name)
				}
			}

			if event.MessageID != reactMessage.ID || event.UserID != message.Author.ID {
				return
			}

			switch event.Emoji.Name {
			case "⬅️":
				page = utils.ClampInt(page-1, 0, pages-1)
			case "➡️":
				page = utils.ClampInt(page+1, 0, pages-1)
			case "⬇️":
				_, err = session.ChannelMessageEditEmbed(reactMessage.ChannelID, reactMessage.ID, middleware.MainHelpEmbed)
				if err != nil {
					fmt.Println("Failed to edit embed message")
				}

				go addCategoryReactions(context, reactMessage.ChannelID, reactMessage.ID)

				closeHandler()
				closeHandler = session.AddHandler(categoryHandler)
				return
			default:
				return
			}

			expireTimer = expireCooldown
			embed, pages = getCategoryEmbed(categoryAlias, page, &language)
			_, err = session.ChannelMessageEditEmbed(reactMessage.ChannelID, reactMessage.ID, embed)
			if err != nil {
				fmt.Println("Error on editing embed", err)
			}
		}

		categoryHandler = func(session *discordgo.Session, event *discordgo.MessageReactionAdd) {
			if event.UserID != session.State.User.ID {
				err = session.MessageReactionRemove(event.ChannelID, event.MessageID, event.Emoji.Name, event.UserID)
				if err != nil {
					fmt.Printf("Failed to remove reaction %s", event.Emoji.Name)
				}
			}

			if event.MessageID != reactMessage.ID || event.UserID != message.Author.ID {
				return
			}

			for _, category := range router.Categories {
				if category.ReactionEmoji == event.Emoji.Name {
					categoryAlias = category.Aliases[0]
					embed, pages = getCategoryEmbed(categoryAlias, 0, &language)

					expireTimer = expireCooldown

					_, err = session.ChannelMessageEditEmbed(reactMessage.ChannelID, reactMessage.ID, embed)

					if err != nil {
						fmt.Println("Failed to edit embed message")
					}

					go addPageReactions(session, reactMessage.ChannelID, reactMessage.ID)
					closeHandler()
					closeHandler = session.AddHandler(pageHandler)
					return
				}
			}
		}

		if len(arguments) == 0 {
			reactMessage, err = session.ChannelMessageSendEmbed(message.ChannelID, middleware.MainHelpEmbed)

			if err != nil {
				fmt.Println("Error while sending embed:", err)
				return
			}

			go addCategoryReactions(context, reactMessage.ChannelID, reactMessage.ID)

			closeHandler = session.AddHandler(categoryHandler)
		} else {
			name := arguments[0]

			if len(arguments) > 1 && utils.IsNumber(arguments[1]) {
				page = utils.StringToInt(arguments[1]) - 1
			}

			embed, _ = getCategoryEmbed(name, page, &language)
			if embed == nil {
				embed = getCommandEmbed(name)
				if embed == nil {
					return
				}
			}

			reactMessage, err = session.ChannelMessageSendEmbed(message.ChannelID, embed)
			go addPageReactions(session, reactMessage.ChannelID, reactMessage.ID)
			closeHandler = session.AddHandler(pageHandler)
		}

		ticker := time.NewTicker(time.Second)

		for range ticker.C {
			if expireTimer <= 0 {
				err = session.MessageReactionsRemoveAll(reactMessage.ChannelID, reactMessage.ID)
				err = session.MessageReactionAdd(reactMessage.ChannelID, reactMessage.ID, "⛔")

				closeHandler()
				ticker.Stop()
			}

			expireTimer--
		}

	},
}

Help shows help

var Hentai = &gophelper.Command{
	ID: "Hentai",

	Name:    "🐙 Hentai",
	Aliases: []string{"hentai"},

	Category: gophelper.CATEGORY_FUN,

	Description: "Just japanese cartoons",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		session := context.Session
		message := context.Event

		channel, err := session.Channel(message.ChannelID)

		if err != nil {
			return
		}

		if channel.NSFW {
			_, err = session.ChannelMessageSend(message.ChannelID, "ur still horni :|")
		} else {
			_, err = session.ChannelMessageSend(message.ChannelID, "u horni >:( its nsfw only")
		}

		if err != nil {
			fmt.Println("Error on hentai command when sending message")
		}
	},
}

Hentai cartoons

var Hug = &gophelper.Command{
	ID: "Hug",

	Name:    "🤗 Hug",
	Aliases: []string{"hug"},

	Category: gophelper.CATEGORY_FUN,

	Description: "Hug someone or get hugged	",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		arguments := context.Arguments
		message := context.Event.Message
		session := context.Session

		routerLanguage := context.Router.Config.Language
		language := context.Command.LanguageSettings

		isTag := false
		userID := message.Author.ID

		if len(arguments) > 0 {
			isTag = true
			userID = arguments[0]

			if utils.IsMention(userID) {
				userID = utils.MentionToID(userID)
			}
		}

		title := language.Response.NonMention

		if isTag {
			member, err := session.GuildMember(message.GuildID, userID)

			nick := message.Author.Username

			if err == nil {
				nick = member.User.Username
			}

			title = fmt.Sprintf(language.Response.Mention, nick)
		}

		index := rand.Intn(len(hugs))

		url := hugs[index]

		if strings.Contains(url, "?") {
			url = fmt.Sprintf("%s&nocache=%d", url, time.Now().UnixNano())
		} else {
			url = fmt.Sprintf("%s?nocache=%d", url, time.Now().UnixNano())
		}

		embed := &discordgo.MessageEmbed{
			Title: title,
			Color: 0xFFbbbb,
			Provider: &discordgo.MessageEmbedProvider{
				URL: url,
			},
			Image: &discordgo.MessageEmbedImage{
				URL: url,
			},
		}

		message, err := session.ChannelMessageSendEmbed(message.ChannelID, embed)

		if err != nil {
			_, err = session.ChannelMessageSend(message.ChannelID, routerLanguage.Errors.MessageSend)
			fmt.Println("Failed to send message")
		} else {
			err = session.MessageReactionAdd(message.ChannelID, message.ID, "🤗")
		}

		if err != nil {
			fmt.Println("Error on hug command when reacting/sending message")
		}
	},
}

Hug hug

var Kiss = &gophelper.Command{
	ID: "Kiss",

	Name:    "😘 Kiss",
	Aliases: []string{"kiss"},

	Category: gophelper.CATEGORY_FUN,

	Description: "Kiss someone or get kissed :*",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		arguments := context.Arguments
		message := context.Event.Message
		session := context.Session

		routerLanguage := context.Router.Config.Language
		language := context.Command.LanguageSettings

		isTag := false
		userID := message.Author.ID

		if len(arguments) > 0 {
			isTag = true
			userID = arguments[0]

			if utils.IsMention(userID) {
				userID = utils.MentionToID(userID)
			}
		}

		title := language.Response.NonMention

		if isTag {
			member, err := session.GuildMember(message.GuildID, userID)

			nick := message.Author.Username

			if err == nil {
				nick = member.User.Username
			}

			title = fmt.Sprintf(language.Response.Mention, nick)
		}

		index := rand.Intn(len(kisses))

		url := kisses[index]

		if strings.Contains(url, "?") {
			url = fmt.Sprintf("%s&nocache=%d", url, time.Now().UnixNano())
		} else {
			url = fmt.Sprintf("%s?nocache=%d", url, time.Now().UnixNano())
		}

		embed := &discordgo.MessageEmbed{
			Title: title,
			Color: 0xFFbbbb,
			Provider: &discordgo.MessageEmbedProvider{
				URL: url,
			},
			Image: &discordgo.MessageEmbedImage{
				URL: url,
			},
		}

		message, err := session.ChannelMessageSendEmbed(message.ChannelID, embed)

		if err != nil {
			_, err = session.ChannelMessageSend(message.ChannelID, routerLanguage.Errors.MessageSend)
			fmt.Println("Failed to send message")
		} else {
			err = session.MessageReactionAdd(message.ChannelID, message.ID, "😘")
		}

		if err != nil {
			fmt.Println("Error on kiss command when reacting/sending message")
		}
	},
}

Kiss :*

var Kitty = &gophelper.Command{
	ID: "Kitty",

	Name:    "🐈 Kitty",
	Aliases: []string{"kitty", "kittie", "cat"},

	Category: gophelper.CATEGORY_FUN,

	Description: "random pics of cute kitties",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		arguments := context.Arguments
		message := context.Event.Message
		session := context.Session

		routerLanguage := context.Router.Config.Language
		language := context.Command.LanguageSettings

		isTag := false
		userID := message.Author.ID

		if len(arguments) > 0 {
			isTag = true
			userID = arguments[0]

			if utils.IsMention(userID) {
				userID = utils.MentionToID(userID)
			}
		}

		title := language.Response.NonMention

		if isTag {
			member, err := session.GuildMember(message.GuildID, userID)

			nick := message.Author.Username

			if err == nil {
				nick = member.User.Username
			}

			title = fmt.Sprintf(language.Response.Mention, nick)
		}

		index := rand.Intn(len(kitties))

		url := kitties[index]

		if strings.Contains(url, "?") {
			url = fmt.Sprintf("%s&nocache=%d", url, time.Now().UnixNano())
		} else {
			url = fmt.Sprintf("%s?nocache=%d", url, time.Now().UnixNano())
		}

		embed := &discordgo.MessageEmbed{
			Title: title,
			Color: 0xFFbbbb,
			Provider: &discordgo.MessageEmbedProvider{
				URL: url,
			},
			Image: &discordgo.MessageEmbedImage{
				URL: url,
			},
		}

		message, err := session.ChannelMessageSendEmbed(message.ChannelID, embed)

		if err != nil {
			_, err = session.ChannelMessageSend(message.ChannelID, routerLanguage.Errors.MessageSend)
			fmt.Println("Failed to send message")
		} else {
			err = session.MessageReactionAdd(message.ChannelID, message.ID, "🐈")
		}

		if err != nil {
			fmt.Println("Error on kitty command when reacting/sending message")
		}
	},
}

Kitty kitties

var LanguageSwitcher = &gophelper.Command{
	Name:    "👅 Language",
	Aliases: []string{"lang"},

	Category: gophelper.CATEGORY_CONFIG,

	NeededPermissions: discordgo.PermissionAdministrator,

	Description: "Change router language config on the fly (Admin only)",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 30,
	},

	Handler: func(context *gophelper.CommandContext) {
		arguments := context.Arguments
		session := context.Session
		message := context.Event

		if len(arguments) == 0 {
			_, err := session.ChannelMessageSend(message.ChannelID, "You need to specify language config file")
			if err != nil {
				fmt.Println("Error on language command when sending message")
			}
			return
		}

		config := context.Router.Config

		err := config.LoadLanguage("configs/languages/" + arguments[0])
		context.Router.RefreshCommands()
		context.Router.RefreshCategories()

		if err != nil {
			_, err = session.ChannelMessageSend(message.ChannelID, "Something happened while loading this config file, are you sure it exists?")
			fmt.Println("Failed on language command when loading language file")
		} else {
			_, err = session.ChannelMessageSend(message.ChannelID, fmt.Sprintf("Successfully changed language config file to %s", arguments[0]))
		}

		if err != nil {
			fmt.Println("Error on language command when sending message")
		}
	},
}

LanguageSwitcher command, this command i keep in english and english only for understandable reasons

var Pet = &gophelper.Command{
	ID: "Pet",

	Category: gophelper.CATEGORY_FUN,

	Name:    "✋ Pet",
	Aliases: []string{"pet"},

	Description: "Pet someone or get pet",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		arguments := context.Arguments
		message := context.Event.Message
		session := context.Session

		routerLanguage := context.Router.Config.Language
		language := context.Command.LanguageSettings

		isTag := false
		userID := message.Author.ID

		if len(arguments) > 0 {
			isTag = true
			userID = arguments[0]

			if utils.IsMention(userID) {
				userID = utils.MentionToID(userID)
			}
		}

		title := language.Response.NonMention

		if isTag {
			member, err := session.GuildMember(message.GuildID, userID)

			nick := message.Author.Username

			if err == nil {
				nick = member.User.Username
			}

			title = fmt.Sprintf(language.Response.Mention, nick)
		}

		index := rand.Intn(len(pets))

		url := pets[index]

		if strings.Contains(url, "?") {
			url = fmt.Sprintf("%s&nocache=%d", url, time.Now().UnixNano())
		} else {
			url = fmt.Sprintf("%s?nocache=%d", url, time.Now().UnixNano())
		}

		embed := &discordgo.MessageEmbed{
			Title: title,
			Color: 0xFFbbbb,
			Provider: &discordgo.MessageEmbedProvider{
				URL: url,
			},
			Image: &discordgo.MessageEmbedImage{
				URL: url,
			},
		}

		message, err := session.ChannelMessageSendEmbed(message.ChannelID, embed)

		if err != nil {
			_, err = session.ChannelMessageSend(message.ChannelID, routerLanguage.Errors.MessageSend)
			fmt.Println("Failed to send message")
		} else {
			err = session.MessageReactionAdd(message.ChannelID, message.ID, "✋")
		}

		if err != nil {
			fmt.Println("Error on pet command when sending message")
		}
	},
}

Pet pet

var Ping = &gophelper.Command{
	ID: "Ping",

	Name:    "🏓 Ping",
	Aliases: []string{"ping"},

	Category: gophelper.CATEGORY_MISC,

	Description: "Literally pong",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		session := context.Session
		message := context.Event

		var timeDiff, timeDiff2 int64
		var msgTime, msgTime2 time.Time

		msgTime, _ = message.Timestamp.Parse()
		timeDiff = time.Since(msgTime).Milliseconds()

		msg, err := session.ChannelMessageSend(message.ChannelID, fmt.Sprintf("🏓 Pong\n Discord: `%d ms`", timeDiff))

		if err != nil {
			fmt.Println("Error on ping command when sending message")
		}

		msgTime2, _ = msg.Timestamp.Parse()
		timeDiff2 = msgTime2.Sub(msgTime).Milliseconds()

		_, err = session.ChannelMessageEdit(msg.ChannelID, msg.ID, fmt.Sprintf("🏓 Pong\n Discord: `%d ms`\n Took: `%d ms`", timeDiff, timeDiff2))

		if err != nil {
			fmt.Println("Error on ping command when editing message")
		}
	},
}

Ping pong

var PingPong = &gophelper.Command{
	ID: "PingPong",

	Name:    "🏓 Ping Pong",
	Aliases: []string{"game pingpong"},

	Category: gophelper.CATEGORY_GAMES,

	Description: "ping pong king kong",

	Usage: "game pingpong [_number of points to win] [_reaction ms]",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		session := context.Session
		message := context.Event
		arguments := context.Arguments

		language := context.Command.LanguageSettings

		userScore := 0
		gopherScore := 0

		winPoints := 5
		pointLimit := 15
		delay := time.Millisecond * 1000

		if len(arguments) > 0 && utils.IsNumber(arguments[0]) {
			num := utils.StringToInt(arguments[0])
			if num <= pointLimit {
				winPoints = num
			} else {
				_, err := session.ChannelMessageSend(message.ChannelID, fmt.Sprintf(language.TooManyMatchesMessage, pointLimit))
				if err != nil {
					fmt.Println("Error on ping pong command when sending message")
				}
				return
			}
		}

		if len(arguments) > 1 && utils.IsNumber(arguments[1]) {
			delay = time.Millisecond * time.Duration(utils.StringToInt(arguments[1]))
		}

		userName := message.Member.Nick
		if userName == "" {
			userName = message.Author.Username
		}

		getScore := func(msg string) string {
			return fmt.Sprintf("**🏓 %s** \n\t**· %s**: %d\n\t**· %s**: %d\n%s", language.ScoreboardMessage, userName, userScore, session.State.User.Username, gopherScore, msg)
		}

		getWinMessage := func() string {
			winner := "Gopher"
			trophyMessage := language.Win.BotTrophyMessage

			if userScore > gopherScore {
				winner = userName
				trophyMessage = language.Win.UserTrophyMessage
			}

			return fmt.Sprintf("**🏓 %s %s**\n\t%s\n\n%s", winner, language.Win.Message, trophyMessage, getScore(""))

		}

		gameMessage, _ := session.ChannelMessageSend(message.ChannelID, getScore("Ping!"))
		err := session.MessageReactionAdd(gameMessage.ChannelID, gameMessage.ID, "🏓")
		if err != nil {
			fmt.Println("Error on ping pong command when adding reaction")
		}

		closeReactionHandler := session.AddHandler(func(session *discordgo.Session, event *discordgo.MessageReactionAdd) {
			if event.UserID != session.State.User.ID {
				err := session.MessageReactionRemove(event.ChannelID, event.MessageID, event.Emoji.ID, event.UserID)
				if err != nil {
					fmt.Println("Error on ping pong command when removing reaction")
				}
			}

			if event.MessageID != gameMessage.ID || event.UserID != message.Author.ID || event.Emoji.Name != "🏓" {
				return
			}

			userScore++
		})

		ticker := time.NewTicker(time.Millisecond * 250)

		for range ticker.C {
			oldUserScore := userScore

			if userScore >= winPoints || gopherScore >= winPoints {
				closeReactionHandler()
				_, err := session.ChannelMessageEdit(gameMessage.ChannelID, gameMessage.ID, getWinMessage())

				if err != nil {
					fmt.Println("Error on ping pong command when editing message")
				}

				ticker.Stop()
				break
			}

			time.Sleep(delay)

			if userScore == oldUserScore {
				gopherScore++
			}

			err := session.MessageReactionRemove(gameMessage.ChannelID, gameMessage.ID, "🏓", message.Author.ID)

			if err != nil {
				fmt.Println("Error on ping pong command when removing reaction")
			}

			_, err = session.ChannelMessageEdit(gameMessage.ChannelID, gameMessage.ID, getScore(""))

			if err != nil {
				fmt.Println("Error on ping pong command when sending message")
			}
		}
	},
}

PingPong simple game

var Pinterest = &gophelper.Command{
	ID: "Pinterest",

	Name:    "📷 Pinterest",
	Aliases: []string{"pinterest"},

	Category: gophelper.CATEGORY_FUN,

	Description: "Cool pics",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		message := context.Event.Message
		session := context.Session

		arguments := context.Arguments

		if len(arguments) < 1 {
			return
		}

		queryPhrase := strings.Join(arguments, " ")

		images := getPinterestQuery(queryPhrase).ResourceResponse.Data.Results

		if len(images) == 0 {
			_, err := session.ChannelMessageSend(message.ChannelID, "no images :(")
			if err != nil {
				fmt.Println("Failed on pinterest command, failed to send error")
			}
			return
		}

		img := images[rand.Intn(len(images))]

		_, err := session.ChannelMessageSendEmbed(message.ChannelID, &discordgo.MessageEmbed{
			Title:       img.RichSummary.DisplayName,
			Description: img.Description,
			Image: &discordgo.MessageEmbedImage{
				URL: img.Images["orig"].Url,
			},
			Footer: &discordgo.MessageEmbedFooter{
				IconURL: "https://s.pinimg.com/webapp/favicon-54a5b2af.png",
				Text:    fmt.Sprintf("Made by %s (%s)", img.Pinner.FullName, img.Pinner.Username),
			},
		})

		if err != nil {
			fmt.Println("Failed to send pinterest image")
		}
	},
}

Pinterest cool pics

var Stats = &gophelper.Command{
	ID: "Stats",

	Name:    "📑 Stats",
	Aliases: []string{"stats"},

	Category: gophelper.CATEGORY_MOD,

	Description: "Gives you information about user",

	Usage: "stats [_user{mention/id}]",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		session := context.Session
		message := context.Event
		arguments := context.Arguments

		language := context.Command.LanguageSettings
		routerLanguage := context.Router.Config.Language

		memberID := message.Author.ID

		if len(arguments) > 0 {
			memberID = arguments[0]

			if utils.IsMention(memberID) {
				memberID = utils.MentionToID(memberID)
			}
		}

		member, err := session.GuildMember(message.GuildID, memberID)

		if err != nil {
			_, err := session.ChannelMessageSend(message.ChannelID, language.UserNotFound)
			if err != nil {
				fmt.Println("Error on stats command when sending message")
			}
			return
		}

		creationDate, _ := discordgo.SnowflakeTimestamp(memberID)
		joinDate, _ := member.JoinedAt.Parse()

		embed := &discordgo.MessageEmbed{
			Color: 0x007d9c,
			Title: fmt.Sprintf(language.Title, member.User.Username, member.User.Discriminator),
			Thumbnail: &discordgo.MessageEmbedThumbnail{
				URL: member.User.AvatarURL("512"),
			},
			Fields: []*discordgo.MessageEmbedField{
				{
					Name:   language.CreationDate,
					Value:  creationDate.Format("2 January 2006 **15:04**"),
					Inline: false,
				},
				{
					Name:   language.JoinDate,
					Value:  joinDate.Format("2 January 2006 **15:04**"),
					Inline: false,
				},
			},
			Footer: &discordgo.MessageEmbedFooter{
				Text: utils.RandomStringElement(routerLanguage.FunFacts),
			},
		}

		_, err = session.ChannelMessageSendEmbed(message.ChannelID, embed)

		if err != nil {
			fmt.Println("Error on stats command when sending message")
		}
	},
}

Stats statistics about user

var Waifu = &gophelper.Command{
	ID: "Waifu",

	Name:    "🌸 Waifu",
	Aliases: []string{"waifu"},

	Category: gophelper.CATEGORY_FUN,

	Description: "Some weird weeb shit",

	RateLimit: middleware.RateLimit{
		Limit:    1,
		Duration: time.Second * 5,
	},

	Handler: func(context *gophelper.CommandContext) {
		arguments := context.Arguments
		message := context.Event.Message
		session := context.Session

		routerLanguage := context.Router.Config.Language
		language := context.Command.LanguageSettings

		isTag := false
		userID := message.Author.ID

		if len(arguments) > 0 {
			isTag = true
			userID = arguments[0]

			if utils.IsMention(userID) {
				userID = utils.MentionToID(userID)
			}
		}

		title := language.Response.NonMention

		if isTag {
			member, err := session.GuildMember(message.GuildID, userID)

			nick := message.Author.Username

			if err == nil {
				nick = member.User.Username
			}

			title = fmt.Sprintf(language.Response.Mention, nick)
		}

		index := rand.Intn(len(waifus))

		url := waifus[index]

		if strings.Contains(url, "?") {
			url = fmt.Sprintf("%s&nocache=%d", url, time.Now().UnixNano())
		} else {
			url = fmt.Sprintf("%s?nocache=%d", url, time.Now().UnixNano())
		}

		embed := &discordgo.MessageEmbed{
			Title: title,
			Color: 0xFFbbbb,
			Provider: &discordgo.MessageEmbedProvider{
				URL: url,
			},
			Image: &discordgo.MessageEmbedImage{
				URL: url,
			},
		}

		message, err := session.ChannelMessageSendEmbed(message.ChannelID, embed)

		if err != nil {
			_, err = session.ChannelMessageSend(message.ChannelID, routerLanguage.Errors.MessageSend)
			fmt.Println("Failed to send message")
		} else {
			err = session.MessageReactionAdd(message.ChannelID, message.ID, "🌸")
		}

		if err != nil {
			fmt.Println("Error on waifu command when reacting/sending message")
		}
	},
}

Waifu waifu

Types

type PingPongCommand

type PingPongCommand struct {
	TooManyMatchesMessage string `json:"tooManyMatches,omitempty"`

	Win struct {
		BotTrophyMessage  string `json:"botTrophyMessage"`
		UserTrophyMessage string `json:"userTrophyMessage"`
		Message           string `json:"message"`
	} `json:"win,omitempty"`

	ScoreboardMessage string `json:"scoreboardMessage,omitempty"`
}

PingPongCommand Config structure

type PinterestResponse

type PinterestResponse struct {
	ResourceResponse struct {
		Data struct {
			Results []PinterestResult `json:"results"`
		} `json:"data"`
	} `json:"resource_response"`
}

type PinterestResult

type PinterestResult struct {
	Description string `json:"description"`

	RichSummary struct {
		URL         string `json:"url"`
		DisplayName string `json:"display_name"`
	} `json:"rich_summary"`

	Pinner struct {
		FullName string `json:"full_name"`
		Username string `json:"username"`
	} `json:"pinner"`

	Images map[string]struct {
		Height int    `json:"height"`
		Width  int    `json:"width"`
		Url    string `json:"url"`
	} `json:"images"`
}