new message

main.go

@@ -15,80 +15,82 @@ import (
 )
 
 type Config struct {
-    DiscordBotToken string `json:"discord_bot_token"`
+	DiscordBotToken  string `json:"discord_bot_token"`
-    DiscordChannelID string `json:"discord_channel_id"`    // Add more configuration fields here
+	DiscordChannelID string `json:"discord_channel_id"` // Add more configuration fields here
 }
 
 func main() {
 
-    // Open and read the configuration file
+	// Open and read the configuration file
-    configFile, err := os.Open("config.json")
+	configFile, err := os.Open("config.json")
-    if err != nil {
+	if err != nil {
-        fmt.Println("Error opening config file:", err)
+		fmt.Println("Error opening config file:", err)
-        return
+		return
-    }
+	}
-    defer configFile.Close()
+	defer configFile.Close()
 
-    // Parse the configuration from JSON
+	// Parse the configuration from JSON
-    var config Config
+	var config Config
-    err = json.NewDecoder(configFile).Decode(&config)
+	err = json.NewDecoder(configFile).Decode(&config)
-    if err != nil {
+	if err != nil {
-        fmt.Println("Error decoding config JSON:", err)
+		fmt.Println("Error decoding config JSON:", err)
-        return
+		return
-    }
+	}
 
-    // Access the Discord bot token from the configuration
+	// Access the Discord bot token from the configuration
-    token := config.DiscordBotToken
+	token := config.DiscordBotToken
-    if token == "" {
+	if token == "" {
-        fmt.Println("Discord bot token is not set in config file")
+		fmt.Println("Discord bot token is not set in config file")
-        return
+		return
-    }
+	}
 
-    //
+	//
-    channelID := config.DiscordChannelID
+	channelID := config.DiscordChannelID
-    if channelID == "" {
+	if channelID == "" {
-        fmt.Println("Discord channel ID is not set in config file")
+		fmt.Println("Discord channel ID is not set in config file")
-    }
+	}
 
-    // Create a new Discord session using the provided bot token
+	// Create a new Discord session using the provided bot token
-    dg, err := discordgo.New("Bot " + token)
+	dg, err := discordgo.New("Bot " + token)
-    if err != nil {
+	if err != nil {
-        fmt.Println("Error creating Discord session:", err)
+		fmt.Println("Error creating Discord session:", err)
-        return
+		return
-    }
+	}
 
-    // Register messageCreate as a callback for the messageCreate events
+	// Register messageCreate as a callback for the messageCreate events
-    dg.AddHandler(messageCreate)
+	dg.AddHandler(messageCreate)
 
-    // Open a websocket connection to Discord and begin listening
+	dg.AddHandler(message2Create)
-    err = dg.Open()
+
-    if err != nil {
+	// Open a websocket connection to Discord and begin listening
-        fmt.Println("Error opening Discord connection:", err)
+	err = dg.Open()
-        return
+	if err != nil {
-    }
+		fmt.Println("Error opening Discord connection:", err)
-    
+		return
-    // Run the scraping and message sending function once at the specified time
+	}
+
+	// Run the scraping and message sending function once at the specified time
 	sendNotifications(dg, channelID, scrapeNews())
 
-    // Schedule the scraping and message sending function to run once a day
+	// Schedule the scraping and message sending function to run once a day
-    ticker := time.NewTicker(24 * time.Hour)
+	ticker := time.NewTicker(24 * time.Hour)
-    defer ticker.Stop()
+	defer ticker.Stop()
 
-    // Run the scraping and message sending function when the ticker ticks
+	// Run the scraping and message sending function when the ticker ticks
-    go func() {
+	go func() {
-        for {
+		for {
-            select {
+			select {
-            case <-ticker.C:
+			case <-ticker.C:
-                sendNotifications(dg, channelID, scrapeNews())
+				sendNotifications(dg, channelID, scrapeNews())
-            }
+			}
-        }
+		}
-    }()
+	}()
 
-    //test()
+	//test()
 
-    // Wait here until CTRL-C or other term signal is received
+	// Wait here until CTRL-C or other term signal is received
-    fmt.Println("Bot is now running. Press CTRL-C to exit.")
+	fmt.Println("Bot is now running. Press CTRL-C to exit.")
-    <-make(chan struct{})
+	<-make(chan struct{})
 }
 
 func scrapeNews() string {
@@ -114,47 +116,87 @@ func scrapeNews() string {
 	return html
 }
 
-// Function to scrape the webpage and send a message if the date matches
+// Add a function to extract relevant tags from the HTML content
-func sendNotifications(session *discordgo.Session, channelID string, html string) {
+func extractTags(html string) []string {
-	// Parse the HTML content
+	var tags []string
 	doc, err := goquery.NewDocumentFromReader(strings.NewReader(html))
 	if err != nil {
 		fmt.Println("Error parsing HTML:", err)
-		return
+		return tags
 	}
-
+	// Find and extract tags with class name "news-module-feed-item-details-tag"
-	// Find and extract the date from the webpage
+	doc.Find("span.news-module-feed-item-details-tag").Each(func(i int, s *goquery.Selection) {
-	var foundDate bool
+		tag := strings.TrimSpace(s.Text())
-	doc.Find("span.news-module-feed-item-details-date").Each(func(i int, s *goquery.Selection) {
+		tags = append(tags, tag)
-		dateString := strings.TrimSpace(s.Text())
-		fmt.Println("Found date:", dateString)
-		if dateString == time.Now().Format("January 2, 2006") {
-			foundDate = true
-		}
 	})
+	return tags
+}
 
-	// If today's date was found on the webpage, send a message to the Discord channel
+// Define a map to associate each desired tag with its corresponding Discord channel ID
-	if foundDate {
+var tagChannelMap = map[string]string{
-		_, err := session.ChannelMessageSend(channelID, "Today's date was found on the Fallout news page!")
+	"Patch Notes": "556093419341086749",
-		if err != nil {
+	"Atomic Shop": "590581442392621067",
-			fmt.Println("Error sending message to Discord:", err)
+	"News":        "558335339018846228",
-			return
+	// Add more tags and corresponding channel IDs as needed
+}
+
+func sendNotifications(session *discordgo.Session, channelID string, html string) {
+	// Extract tags from the HTML content
+	tags := extractTags(html)
+
+	// Define today's date string
+	today := time.Now().Format("January 2, 2006")
+
+	// Iterate over extracted tags
+	for _, tag := range tags {
+		// Check if the tag is in the desired tags list
+		if tagChannelID, ok := tagChannelMap[tag]; ok {
+			// Check if today's date matches the tag
+			if tag == today {
+				// Send a message to the corresponding Discord channel
+				message := fmt.Sprintf("Today's date matches the tag '%s' on the Fallout news page!", tag)
+				_, err := session.ChannelMessageSend(tagChannelID, message)
+				if err != nil {
+					fmt.Printf("Error sending message to Discord channel %s: %s\n", tagChannelID, err)
+					continue
+				}
+				fmt.Println("Message sent to Discord channel:", tagChannelID)
+			} else {
+				// Send a different message indicating the tag was found
+				message := fmt.Sprintf("Tag '%s' found on the Fallout news page, but it's not today's date.", tag)
+				_, err := session.ChannelMessageSend(tagChannelID, message)
+				if err != nil {
+					fmt.Printf("Error sending message to Discord channel %s: %s\n", tagChannelID, err)
+					continue
+				}
+				fmt.Println("Message sent to Discord channel:", tagChannelID)
+			}
 		}
-		fmt.Println("Message sent to Discord channel")
-	} else {
-		fmt.Println("Today's date not found on the Fallout news page")
 	}
 }
 
 // This function will be called whenever a new message is created
 func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
-    // Ignore messages created by the bot itself
+	// Ignore messages created by the bot itself
-    if m.Author.ID == s.State.User.ID {
+	if m.Author.ID == s.State.User.ID {
-        return
+		return
-    }
+	}
 
-    // If the message content is "!hello", respond with "Hello!"
+	// If the message content is "!hello", respond with "Hello!"
-    if m.Content == "!hello" {
+	if m.Content == "!hello1" {
-        _, _ = s.ChannelMessageSend(m.ChannelID, "Hello!")
+		_, _ = s.ChannelMessageSend(m.ChannelID, "Hello!")
-    }
+	}
+}
+
+// This function will be called whenever a new message is created
+func message2Create(s *discordgo.Session, m *discordgo.MessageCreate) {
+	// Ignore messages created by the bot itself
+	if m.Author.ID == s.State.User.ID {
+		return
+	}
+
+	// If the message content is "!hello", respond with "Hello!"
+	if m.Content == "!hello" {
+		_, _ = s.ChannelMessageSend(m.ChannelID, "You are SUCH a NERD")
+	}
 }