watn3y/steamsalty
1
0
Fork 0
mirror of https://github.com/watn3y/steamsalty.git synced 2025-10-25 09:51:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #2 from watn3y/feat/translation

Browse source 
feat/translation
This commit is contained in:
Noah 2025-10-13 16:06:02 +02:00 • committed by GitHub
commit ac2146af1b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
11 changed files with 266 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

22
README.md
View file

@ -1,6 +1,6 @@
# SteamSalty
SteamSalty notifies you on telegram about new comments on any steam profile.
SteamSalty notifies you on telegram about new comments on any steam profile **with build in auto translation**.
## Running with Docker Compose
@ -34,11 +34,15 @@ Grab a release from the [releases page](https://github.com/watn3y/steamsalty/rel
> [!NOTE]
> For development purposes, SteamSalty supports loading environment variables from a .env file placed in the project root directory.
| Variable | Description | Default | Required |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------| ------------------ | -------------- |
| `STEAMSALTY_LOGLEVEL` | LogLevel as described [in the zerolog documentation](https://pkg.go.dev/github.com/rs/zerolog@v1.34.0#readme-simple-leveled-logging-example) | 1 (Info) | ❌ |
| `STEAMSALTY_TELEGRAMAPITOKEN` | Telegram BotToken, get it from [@BotFather on Telegram](https://t.me/BotFather) | None | ✅ |
| `STEAMSALTY_STEAMAPIKEY` | Steam API Key, get it from [steamcommunity.com/dev/apikey](https://steamcommunity.com/dev/apikey) | None | ✅ |
| `STEAMSALTY_CHATID` | Chat to notify about new comments | None | ✅ |
| `STEAMSALTY_WATCHERS` | SteamIDs (in SteamID64 format) to check for new profile comments | None | ✅ |
| `STEAMSALTY_SLEEPINTERVAL` | Amount of time to wait between requests to Steam in seconds | 60 | ❌ |
| Variable | Description | Default | Required |
|---------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------|----------|
| `STEAMSALTY_LOGLEVEL` | LogLevel as described [in the zerolog documentation](https://pkg.go.dev/github.com/rs/zerolog@v1.34.0#readme-simple-leveled-logging-example) | 1 (Info) | ❌ |
| `STEAMSALTY_SLEEPINTERVAL` | Amount of time to wait between requests to Steam in seconds | 60 | ❌ |
| `STEAMSALTY_TRANSLATE_ENABLED` | Whether to enable translation of comments | False | ❌ |
| `STEAMSALTY_TRANSLATE_LANGUAGE` | Language to translate as described [in the DeepL API documentation](https://developers.deepl.com/docs/getting-started/supported-languages#translation-target-languages) | EN-US | ❌ |
| `STEAMSALTY_CHATID` | Chat to notify about new comments | None | ✅ |
| `STEAMSALTY_WATCHERS` | SteamIDs (in SteamID64 format) to check for new profile comments | None | ✅ |
| `STEAMSALTY_TELEGRAMAPITOKEN` | Telegram BotToken, get it from [@BotFather on Telegram](https://t.me/BotFather) | None | ✅ |
| `STEAMSALTY_STEAMAPIKEY` | Steam API Key, get it from [steamcommunity.com/dev/apikey](https://steamcommunity.com/dev/apikey) | None | ✅ |
| `STEAMSALTY_DEEPL_APIKEY` | DeepL API Key, get it from [deepl.com/en/your-account/keys](https://www.deepl.com/en/your-account/keys) | None | ❌ |
| `STEAMSALTY_DEEPL_FREETIER` | Whether you are using the DeepL Free Tier | True | ❌ |

2
botIO/authenticate.go
View file

@ -9,7 +9,7 @@ import (
func Authenticate() (tgbotapi.UpdatesChannel, *tgbotapi.BotAPI) {
bot, err := tgbotapi.NewBotAPI(config.BotConfig.TelegramAPIToken)
if err != nil {
log.Panic().Err(err).Msg("Failed to authenticate to Telegram")
log.Fatal().Err(err).Msg("Failed to authenticate to Telegram")
}
bot.Debug = false

11
config/config.go
View file

@ -2,28 +2,31 @@ package config
import (
"context"
"strings"
"github.com/joho/godotenv"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
"github.com/joho/godotenv"
envconfig "github.com/sethvargo/go-envconfig"
)
var BotConfig config
func LoadConfig() {
if err := godotenv.Load(); err != nil {
if err := godotenv.Load(); err != nil {
log.Info().Err(err).Msg("Failed to load .env file, using the system environment")
} else {
log.Info().Err(err).Msg(".env file loaded successfully")
}
if err := envconfig.Process(context.Background(), &BotConfig); err != nil {
log.Panic().Err(err).Msg("Failed to parse config from env variables")
log.Fatal().Err(err).Msg("Failed to parse config from env variables")
}
zerolog.SetGlobalLevel(zerolog.Level(BotConfig.LogLevel))
BotConfig.TranslateLanguage = strings.ToUpper(BotConfig.TranslateLanguage)
log.Info().Msg("Config loaded successfully")
log.Debug().Interface("config", BotConfig).Msg("")

21
config/types.go
View file

@ -1,10 +1,19 @@
package config
type config struct {
LogLevel int `env:"STEAMSALTY_LOGLEVEL, default=1"`
TelegramAPIToken string `env:"STEAMSALTY_TELEGRAMAPITOKEN, required"`
SteamAPIKey string `env:"STEAMSALTY_STEAMAPIKEY, required"`
ChatID int64 `env:"STEAMSALTY_CHATID, required"`
Watchers []uint64 `env:"STEAMSALTY_WATCHERS, required"`
SleepInterval int `env:"STEAMSALTY_SLEEPINTERVAL, default=60"`
LogLevel int `env:"STEAMSALTY_LOGLEVEL" default:"1"`
SleepInterval int `env:"STEAMSALTY_SLEEPINTERVAL" default:"60"`
ChatID int64 `env:"STEAMSALTY_CHATID" required:"true"`
Watchers []uint64 `env:"STEAMSALTY_WATCHERS" required:"true"`
TranslateEnabled bool `env:"STEAMSALTY_TRANSLATE_ENABLED" default:"false"`
TranslateLanguage string `env:"STEAMSALTY_TRANSLATE_LANGUAGE" default:"EN-US"`
TelegramAPIToken string `env:"STEAMSALTY_TELEGRAMAPITOKEN" required:"true"`
SteamAPIKey string `env:"STEAMSALTY_STEAMAPIKEY" required:"true"`
DeepL struct {
APIKey string `env:"STEAMSALTY_DEEPL_APIKEY"`
FreeTier bool `env:"STEAMSALTY_DEEPL_FREETIER" default:"true"`
}
}

60
deepL/http.go Normal file
View file

@ -0,0 +1,60 @@
package deepl
import (
"bytes"
"io"
"net/http"
"github.com/rs/zerolog/log"
)
func get(endpoint string) (responseBody []byte, err error) {
httpReq, _ := http.NewRequest("GET", client.baseURL+endpoint, nil)
httpReq.Header.Set("Authorization", "DeepL-Auth-Key "+client.authKey)
resp, err := client.httpClient.Do(httpReq)
if err != nil {
log.Error().Err(err).Str("endpoint", endpoint).Msg("Failed to send GET request to DeepL API")
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
log.Error().Str("response", resp.Status).Str("endpoint", endpoint).Msg("Failed to send GET request to DeepL API, non 200 HTTP response")
return nil, err
}
respBody, err := io.ReadAll(resp.Body)
if err != nil {
log.Error().Err(err).Str("endpoint", endpoint).Msg("Failed to read DeepL API response")
return nil, err
}
return respBody, nil
}
func post(endpoint string, data []byte) (responseBody []byte, err error) {
httpReq, _ := http.NewRequest("POST", client.baseURL+endpoint, bytes.NewReader(data))
httpReq.Header.Set("Authorization", "DeepL-Auth-Key "+client.authKey)
httpReq.Header.Set("Content-Type", "application/json")
resp, err := client.httpClient.Do(httpReq)
if err != nil {
log.Error().Err(err).Str("endpoint", endpoint).Msg("Failed to send request to POST DeepL API")
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
log.Error().Str("response", resp.Status).Str("endpoint", endpoint).Msg("Failed to send POST request to DeepL API, non 200 HTTP response")
return nil, err
}
respBody, err := io.ReadAll(resp.Body)
if err != nil {
log.Error().Err(err).Str("endpoint", endpoint).Msg("Failed to read DeepL API response")
return nil, err
}
return respBody, nil
}

108
deepL/translate.go Normal file
View file

@ -0,0 +1,108 @@
package deepl
import (
"encoding/json"
"fmt"
"net/http"
"time"
"watn3y/steamsalty/config"
"github.com/rs/zerolog/log"
)
var client *apiClient
var SourceLanguages map[string]string
var TargetLanguages map[string]string
func Init() {
log.Info().Msg("Translation is enabled, creating HTTP client for DeepL API")
baseURL := baseURLPro
if config.BotConfig.DeepL.FreeTier {
baseURL = baseURLFree
}
client = &apiClient{
authKey: config.BotConfig.DeepL.APIKey,
baseURL: baseURL,
httpClient: &http.Client{Timeout: 30 * time.Second},
}
err := getAndValidateLanguages()
if err != nil {
log.Fatal().Err(err).Msg("Failed to set up languages")
}
}
func Translate(text string) (translatedText string, sourceLanguage string, err error) {
log.Debug().Str("text", text).Msg("Starting translation")
req := translateRequest{
Text: []string{text},
TargetLang: config.BotConfig.TranslateLanguage,
}
body, err := json.Marshal(req)
if err != nil {
log.Error().Err(err).Msg("Failed to ")
return "", "", err
}
respBody, err := post("/translate", body)
if err != nil {
log.Error().Err(err).Msg("Failed to make DeepL API request")
return "", "", err
}
var result translateResponse
err = json.Unmarshal(respBody, &result)
if err != nil {
log.Error().Err(err).Msg("Failed to parse DeepL API response")
return "", "", err
}
return result.Translations[0].Text, result.Translations[0].DetectedSourceLanguage, nil
}
func getAndValidateLanguages() (err error) {
log.Info().Msg("Setting up supported languages")
respBody, err := get("/languages?type=source")
if err != nil {
log.Error().Err(err).Msg("Failed to make DeepL API request")
return err
}
var parsedResp languagesResponse
err = json.Unmarshal(respBody, &parsedResp)
if err != nil {
log.Error().Err(err).Msg("Failed to parse DeepL API response")
return err
}
SourceLanguages = make(map[string]string)
for _, l := range parsedResp {
SourceLanguages[l.Language] = l.Name
}
respBody, err = get("/languages?type=target")
if err != nil {
log.Error().Err(err).Msg("Failed to make DeepL API request")
return err
}
err = json.Unmarshal(respBody, &parsedResp)
if err != nil {
log.Error().Err(err).Msg("Failed to parse DeepL API response")
return err
}
TargetLanguages = make(map[string]string)
for _, l := range parsedResp {
TargetLanguages[l.Language] = l.Name
}
if _, ok := TargetLanguages[config.BotConfig.TranslateLanguage]; !ok {
return fmt.Errorf("Selected language not supported by DeepL")
}
return nil
}

35
deepL/types.go Normal file
View file

@ -0,0 +1,35 @@
package deepl
import (
"net/http"
)
type translateResponse struct {
Translations []struct {
DetectedSourceLanguage string `json:"detected_source_language"`
Text string `json:"text"`
} `json:"translations"`
}
type translateRequest struct {
Text []string `json:"text"`
TargetLang string `json:"target_lang"`
}
type languagesResponse []struct {
Language string `json:"language"`
Name string `json:"name"`
SupportsFormality bool `json:"supports_formality"` //unused
}
type apiClient struct {
authKey string
baseURL string
httpClient *http.Client
}
const (
baseURLPro = "https://api.deepl.com/v2"
baseURLFree = "https://api-free.deepl.com/v2"
)

2
go.mod
View file

@ -6,13 +6,13 @@ require (
github.com/Philipp15b/go-steamapi v0.0.0-20210114153316-ec4fdd23b4c1
github.com/PuerkitoBio/goquery v1.10.3
github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1
github.com/joho/godotenv v1.5.1
github.com/rs/zerolog v1.34.0
github.com/sethvargo/go-envconfig v1.3.0
)
require (
github.com/andybalholm/cascadia v1.3.3 // indirect
github.com/joho/godotenv v1.5.1 // indirect
github.com/mattn/go-colorable v0.1.14 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
golang.org/x/net v0.43.0 // indirect

8
main.go
View file

@ -8,16 +8,18 @@ import (
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
"watn3y/steamsalty/config"
deepl "watn3y/steamsalty/deepL"
)
func main() {
println("Starting SteamSalty...")
configureLogger()
config.LoadConfig()
if config.BotConfig.TranslateEnabled {
deepl.Init()
}
bot()

1
steam/http.go
View file

@ -39,7 +39,6 @@ func GetComments(steamID uint64, start int, count int) (page CommentsPage) {
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Error().Err(err).Msg("Failed to parse comments")
log.Trace().Interface("Body", resp.Body)
}
err = json.Unmarshal(body, &page)

25
steam/profile.go
View file

@ -3,19 +3,18 @@ package steam
import (
"fmt"
"math"
"strings"
"sync"
"time"
"watn3y/steamsalty/botIO"
"watn3y/steamsalty/config"
deepl "watn3y/steamsalty/deepL"
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
"github.com/rs/zerolog/log"
)
var steamContentCheckText string = "This comment is awaiting analysis by our automated content check system. It will be temporarily hidden until we verify that it does not contain harmful content (e.g. links to websites that attempt to steal information)."
const steamContentCheckText string = "This comment is awaiting analysis by our automated content check system. It will be temporarily hidden until we verify that it does not contain harmful content (e.g. links to websites that attempt to steal information)."
func StartWatchers(bot *tgbotapi.BotAPI) {
@ -69,9 +68,27 @@ func watcher(bot *tgbotapi.BotAPI, steamID uint64, sleeptime time.Duration) {
Text: fmt.Sprintf(`<b><a href="%s">%s</a> just commented on <a href="%s">%s</a>'s profile:</b>`, comment.AuthorProfileURL, comment.Author, profileOwner.ProfileURL, profileOwner.PersonaName) + "\n" +
"<blockquote>" + comment.Text + "</blockquote>",
}
if config.BotConfig.TranslateEnabled {
translatedText, translatedTextLanguage, err := deepl.Translate(comment.Text)
if translatedTextLanguage == config.BotConfig.TranslateLanguage {
continue
}
if err != nil {
log.Error().Err(err).Msg("Failed to translate comment, continuing without translation")
msg.Text += "\n" + "Translation failed"
} else {
msg.Text += "\n" +
fmt.Sprintf(`Translated from %s:`, deepl.SourceLanguages[translatedTextLanguage]) + "\n" +
"<blockquote>" + translatedText + "</blockquote>"
}
}
log.Info().Interface("Comment", comment).Msg("Notifying about new comment")
botIO.SendMessage(msg, bot)
time.Sleep(time.Minute / 20)
time.Sleep(time.Second * 3) //I have no Idea why this is here
}
newestProcessedComment = currentCommentsPage.TimeLastPost