391 lines
11 KiB
Go
391 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"math/rand"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
|
|
"github.com/bwmarrin/discordgo"
|
|
|
|
"github.com/vartanbeno/go-reddit/v2/reddit"
|
|
)
|
|
|
|
var config Config
|
|
|
|
func init() {
|
|
log.SetFlags(log.LstdFlags | log.Lshortfile)
|
|
}
|
|
|
|
func init() {
|
|
loadedConfig, err := Load()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
config = *loadedConfig
|
|
}
|
|
|
|
func GetPostsFromReddit(subreddit string) (string, error) {
|
|
if subreddit == "" {
|
|
return "", fmt.Errorf("subreddit cannot be empty")
|
|
}
|
|
|
|
client, err := reddit.NewReadonlyClient()
|
|
if err != nil {
|
|
log.Println("Failed to create Reddit client:", err)
|
|
return "", err
|
|
}
|
|
|
|
posts, _, err := client.Subreddit.TopPosts(context.Background(), subreddit, &reddit.ListPostOptions{
|
|
ListOptions: reddit.ListOptions{
|
|
Limit: 100,
|
|
},
|
|
Time: "all",
|
|
})
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to get posts from Reddit: %v", err)
|
|
}
|
|
|
|
// Check if the subreddit exists
|
|
if len(posts) == 0 {
|
|
return "", fmt.Errorf("subreddit '%v' does not exist", subreddit)
|
|
}
|
|
|
|
// [Title](<https://old.reddit.com{Permalink}>)\n{URL}
|
|
randInt := rand.Intn(len(posts))
|
|
discordMessage := fmt.Sprintf("[%v](<https://old.reddit.com%v>)\n%v", posts[randInt].Title, posts[randInt].Permalink, posts[randInt].URL)
|
|
|
|
return discordMessage, nil
|
|
|
|
}
|
|
|
|
func handleRedditCommand(s *discordgo.Session, i *discordgo.InteractionCreate, subreddit string) {
|
|
post, err := GetPostsFromReddit(subreddit)
|
|
if err = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: fmt.Sprintf("Cannot get a random post: %v", err),
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
}); err != nil {
|
|
log.Println("Failed to respond to interaction:", err)
|
|
return
|
|
}
|
|
|
|
if err := s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: post,
|
|
},
|
|
}); err != nil {
|
|
log.Println("Failed to respond to interaction:", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
var (
|
|
commands = []*discordgo.ApplicationCommand{
|
|
{
|
|
Name: "dank_memes",
|
|
Description: "Sends dank meme from /r/GoodAnimemes",
|
|
},
|
|
{
|
|
Name: "waifus",
|
|
Description: "Sends waifu from /r/WatchItForThePlot",
|
|
},
|
|
{
|
|
Name: "milkers",
|
|
Description: "Sends milkers from /r/RetrousseTits",
|
|
},
|
|
{
|
|
Name: "thighs",
|
|
Description: "Sends thighs from /r/ZettaiRyouiki",
|
|
},
|
|
}
|
|
|
|
commandHandlers = map[string]func(s *discordgo.Session, i *discordgo.InteractionCreate){
|
|
// Dank memes command
|
|
"dank_memes": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
handleRedditCommand(s, i, "GoodAnimemes")
|
|
},
|
|
|
|
// Waifus command
|
|
"waifus": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
handleRedditCommand(s, i, "WatchItForThePlot")
|
|
},
|
|
|
|
// Milkers command
|
|
"milkers": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
handleRedditCommand(s, i, "RetrousseTits")
|
|
},
|
|
|
|
// Thighs command
|
|
"thighs": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
handleRedditCommand(s, i, "ZettaiRyouiki")
|
|
},
|
|
// Echo command
|
|
"echo": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
// Check if the user provided a message
|
|
if len(i.ApplicationCommandData().Options) == 0 {
|
|
// If not, send an ephemeral message to the user
|
|
err := s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "You need to provide a message!",
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Failed to respond to interaction:", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Check that the option is not empty
|
|
if i.ApplicationCommandData().Options[0].StringValue() == "" {
|
|
// If not, send an ephemeral message to the user
|
|
err := s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "The message cannot be empty!",
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Println("Failed to respond to interaction:", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Respond to the original message so we don't get "This interaction failed" error
|
|
if _, err := s.ChannelMessageSend(i.ChannelID, i.ApplicationCommandData().Options[0].StringValue()); err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
},
|
|
}
|
|
)
|
|
|
|
func onMessageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
|
|
if m.Author.ID == s.State.User.ID {
|
|
return
|
|
}
|
|
|
|
// Don't allow DMs
|
|
if m.GuildID == "" {
|
|
return
|
|
}
|
|
|
|
allowedUsers := []string{
|
|
"thelovinator",
|
|
"killyoy",
|
|
"forgefilip",
|
|
"plubplub",
|
|
"nobot",
|
|
"kao172",
|
|
}
|
|
|
|
// Have a 1/100 chance of replying to a message if written by a user in allowedUsers
|
|
randInt := rand.Intn(100)
|
|
log.Println("Random number:", randInt)
|
|
log.Println("Mentions:", m.Mentions)
|
|
if len(m.Mentions) == 0 && randInt == 4 {
|
|
for _, user := range allowedUsers {
|
|
log.Println("User:", user)
|
|
if m.Author.Username == user {
|
|
log.Println("User is in allowedUsers")
|
|
r, err := GenerateGPT4Response(m.Content, m.Author.Username)
|
|
if err != nil {
|
|
log.Println("Failed to get OpenAI response:", err)
|
|
return
|
|
}
|
|
log.Println("OpenAI response:", r)
|
|
log.Println("Channel ID:", m.ChannelID)
|
|
_, err = s.ChannelMessageSend(m.ChannelID, r)
|
|
if err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if m.Mentions != nil {
|
|
for _, mention := range m.Mentions {
|
|
if mention.ID == s.State.User.ID {
|
|
r, err := GenerateGPT4Response(m.Content, m.Author.Username)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "prompt is too long") {
|
|
if _, err := s.ChannelMessageSend(m.ChannelID, "Message is too long!"); err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
if strings.Contains(err.Error(), "prompt is too short") {
|
|
if _, err := s.ChannelMessageSend(m.ChannelID, "Message is too short!"); err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
message, err := s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("Brain broke :flushed: %v", err))
|
|
if err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
_ = message
|
|
return
|
|
}
|
|
_, err = s.ChannelMessageSend(m.ChannelID, r)
|
|
if err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if strings.HasPrefix(strings.ToLower(m.Content), "lovibot") {
|
|
r, err := GenerateGPT4Response(m.Content, m.Author.Username)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "prompt is too long") {
|
|
_, err := s.ChannelMessageSend(m.ChannelID, "Message is too long!")
|
|
if err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
if strings.Contains(err.Error(), "prompt is too short") {
|
|
_, err := s.ChannelMessageSend(m.ChannelID, "Message is too short!")
|
|
if err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
message, err := s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("Brain broke :flushed: %v", err))
|
|
if err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
_ = message
|
|
return
|
|
}
|
|
_, err = s.ChannelMessageSend(m.ChannelID, r)
|
|
if err != nil {
|
|
log.Println("Failed to send message to channel:", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func main() {
|
|
discordToken := config.DiscordToken
|
|
|
|
// Create a new Discord session using the provided bot token.
|
|
session, err := discordgo.New("Bot " + discordToken)
|
|
if err != nil {
|
|
log.Fatalf("Cannot create a new Discord session: %v", err)
|
|
}
|
|
|
|
// Add a handler function to the discordgo.Session that is triggered when a slash command is received.
|
|
session.AddHandler(func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
if h, ok := commandHandlers[i.ApplicationCommandData().Name]; ok {
|
|
log.Printf("Handling '%v' command. %+v", i.ApplicationCommandData().Name, i.ApplicationCommandData())
|
|
h(s, i)
|
|
}
|
|
})
|
|
|
|
// Add a handler function to the discordgo.Session that is triggered when a message is received.
|
|
session.AddHandler(onMessageCreate)
|
|
|
|
// Print the user we are logging in as.
|
|
session.AddHandler(func(s *discordgo.Session, _ *discordgo.Ready) {
|
|
log.Printf("Logged in as: %v#%v", s.State.User.Username, s.State.User.Discriminator)
|
|
})
|
|
|
|
// Open a websocket connection to Discord and begin listening.
|
|
err = session.Open()
|
|
if err != nil {
|
|
log.Fatalf("Cannot open the session: %v", err)
|
|
}
|
|
|
|
// Remove all existing commands.
|
|
appID := session.State.User.ID
|
|
log.Println("Removing existing commands from all servers for the bot", appID)
|
|
|
|
// Remove the commands for guild 98905546077241344
|
|
log.Println("Removing commands for Killyoy's server...")
|
|
old_commands, err := session.ApplicationCommands(appID, "98905546077241344")
|
|
if err != nil {
|
|
log.Panicf("Cannot get commands for guild 98905546077241344: %v", err)
|
|
}
|
|
for _, v := range old_commands {
|
|
err := session.ApplicationCommandDelete(session.State.User.ID, "98905546077241344", v.ID)
|
|
if err != nil {
|
|
log.Panicf("Cannot delete '%v' command: %v", v.Name, err)
|
|
}
|
|
log.Printf("Deleted '%v' command.", v.Name)
|
|
}
|
|
|
|
// Remove the commands for guild 341001473661992962
|
|
log.Println("Removing commands for TheLovinator's server...")
|
|
old_commands2, err := session.ApplicationCommands(appID, "341001473661992962")
|
|
if err != nil {
|
|
log.Panicf("Cannot get commands for guild 341001473661992962: %v", err)
|
|
}
|
|
for _, v := range old_commands2 {
|
|
err := session.ApplicationCommandDelete(session.State.User.ID, "341001473661992962", v.ID)
|
|
if err != nil {
|
|
log.Panicf("Cannot delete '%v' command: %v", v.Name, err)
|
|
}
|
|
log.Printf("Deleted '%v' command.", v.Name)
|
|
}
|
|
|
|
// Register the commands for guild 98905546077241344
|
|
log.Println("Registering commands for Killyoy's server...")
|
|
registeredCommands := make([]*discordgo.ApplicationCommand, len(commands))
|
|
for i, v := range commands {
|
|
cmd, err := session.ApplicationCommandCreate(session.State.User.ID, "98905546077241344", v)
|
|
if err != nil {
|
|
log.Panicf("Cannot create '%v' command: %v", v.Name, err)
|
|
}
|
|
registeredCommands[i] = cmd
|
|
log.Printf("Registered '%v' command.", cmd.Name)
|
|
}
|
|
|
|
// Register the commands for guild 341001473661992962
|
|
log.Println("Registering commands for TheLovinator's server...")
|
|
registeredCommands2 := make([]*discordgo.ApplicationCommand, len(commands))
|
|
for i, v := range commands {
|
|
cmd, err := session.ApplicationCommandCreate(session.State.User.ID, "341001473661992962", v)
|
|
if err != nil {
|
|
log.Panicf("Cannot create '%v' command: %v", v.Name, err)
|
|
}
|
|
registeredCommands2[i] = cmd
|
|
log.Printf("Registered '%v' command.", cmd.Name)
|
|
}
|
|
|
|
// Run s.Close() when the program exits.
|
|
defer session.Close()
|
|
|
|
// Wait here until CTRL-C or other term signal is received.
|
|
stop := make(chan os.Signal, 1)
|
|
signal.Notify(stop, os.Interrupt)
|
|
log.Println("Press Ctrl+C to exit")
|
|
<-stop
|
|
|
|
// Bye bye!
|
|
log.Println("Gracefully shutting down.")
|
|
}
|