@@ -48,7 +67,9 @@
-
+ {{ if .telegramEnabled }}
+ {{ .strings.linkTelegram }}
+ {{ end }}
diff --git a/internal.go b/internal.go
index 92732c3..a2fc105 100644
--- a/internal.go
+++ b/internal.go
@@ -13,7 +13,7 @@ const binaryType = "internal"
//go:embed data data/html data/web data/web/css data/web/js
var loFS embed.FS
-//go:embed lang/common lang/admin lang/email lang/form lang/setup lang/pwreset
+//go:embed lang/common lang/admin lang/email lang/form lang/setup lang/pwreset lang/telegram
var laFS embed.FS
var langFS rewriteFS
diff --git a/lang.go b/lang.go
index ca415e1..69c9ef4 100644
--- a/lang.go
+++ b/lang.go
@@ -136,6 +136,23 @@ func (ls *setupLangs) getOptions() [][2]string {
return opts
}
+type telegramLangs map[string]telegramLang
+
+type telegramLang struct {
+ Meta langMeta `json:"meta"`
+ Strings langSection `json:"strings"`
+}
+
+func (ts *telegramLangs) getOptions() [][2]string {
+ opts := make([][2]string, len(*ts))
+ i := 0
+ for key, lang := range *ts {
+ opts[i] = [2]string{key, lang.Meta.Name}
+ i++
+ }
+ return opts
+}
+
type langSection map[string]string
type tmpl map[string]string
diff --git a/lang/form/en-us.json b/lang/form/en-us.json
index e1c0575..c6411e6 100644
--- a/lang/form/en-us.json
+++ b/lang/form/en-us.json
@@ -17,11 +17,14 @@
"successContinueButton": "Continue",
"confirmationRequired": "Email confirmation required",
"confirmationRequiredMessage": "Please check your email inbox to verify your address.",
- "yourAccountIsValidUntil": "Your account will be valid until {date}."
+ "yourAccountIsValidUntil": "Your account will be valid until {date}.",
+ "linkTelegram": "Link Telegram",
+ "sendPIN": "Send the PIN below to the bot, then come back here to link your account."
},
"notifications": {
"errorUserExists": "User already exists.",
- "errorInvalidCode": "Invalid invite code."
+ "errorInvalidCode": "Invalid invite code.",
+ "telegramVerified": "Telegram account verified."
},
"validationStrings": {
"length": {
diff --git a/main.go b/main.go
index dab521a..70af2e0 100644
--- a/main.go
+++ b/main.go
@@ -93,6 +93,7 @@ type appContext struct {
storage Storage
validator Validator
email *Emailer
+ telegram *TelegramDaemon
info, debug, err logger.Logger
host string
port int
@@ -257,6 +258,7 @@ func start(asDaemon, firstCall bool) {
app.storage.lang.FormPath = "form"
app.storage.lang.AdminPath = "admin"
app.storage.lang.EmailPath = "email"
+ app.storage.lang.TelegramPath = "telegram"
app.storage.lang.PasswordResetPath = "pwreset"
externalLang := app.config.Section("files").Key("lang_files").MustString("")
var err error
@@ -325,6 +327,10 @@ func start(asDaemon, firstCall bool) {
if err := app.storage.loadUsers(); err != nil {
app.err.Printf("Failed to load Users: %v", err)
}
+ app.storage.telegram_path = app.config.Section("files").Key("telegram_users").String()
+ if err := app.storage.loadTelegramUsers(); err != nil {
+ app.err.Printf("Failed to load Telegram users: %v", err)
+ }
app.storage.profiles_path = app.config.Section("files").Key("user_profiles").String()
app.storage.loadProfiles()
@@ -541,6 +547,16 @@ func start(asDaemon, firstCall bool) {
if app.config.Section("updates").Key("enabled").MustBool(false) {
go app.checkForUpdates()
}
+
+ if app.config.Section("telegram").Key("enabled").MustBool(false) {
+ app.telegram, err = newTelegramDaemon(app)
+ if err != nil {
+ app.err.Printf("Failed to authenticate with Telegram: %v", err)
+ } else {
+ go app.telegram.run()
+ defer app.telegram.Shutdown()
+ }
+ }
} else {
debugMode = false
address = "0.0.0.0:8056"
diff --git a/router.go b/router.go
index 4c15516..63892ad 100644
--- a/router.go
+++ b/router.go
@@ -118,6 +118,9 @@ func (app *appContext) loadRoutes(router *gin.Engine) {
router.POST(p+"/newUser", app.NewUser)
router.Use(static.Serve(p+"/invite/", app.webFS))
router.GET(p+"/invite/:invCode", app.InviteProxy)
+ if app.config.Section("telegram").Key("enabled").MustBool(false) {
+ router.GET(p+"/invite/:invCode/telegram/verified/:pin", app.TelegramVerified)
+ }
}
if *SWAGGER {
app.info.Print(warning("\n\nWARNING: Swagger should not be used on a public instance.\n\n"))
diff --git a/storage.go b/storage.go
index 1bc7fef..93dcc1a 100644
--- a/storage.go
+++ b/storage.go
@@ -15,18 +15,25 @@ import (
)
type Storage struct {
- timePattern string
- invite_path, emails_path, policy_path, configuration_path, displayprefs_path, ombi_path, profiles_path, customEmails_path, users_path string
- users map[string]time.Time
- invites Invites
- profiles map[string]Profile
- defaultProfile string
- emails, displayprefs, ombi_template map[string]interface{}
- customEmails customEmails
- policy mediabrowser.Policy
- configuration mediabrowser.Configuration
- lang Lang
- invitesLock, usersLock sync.Mutex
+ timePattern string
+ invite_path, emails_path, policy_path, configuration_path, displayprefs_path, ombi_path, profiles_path, customEmails_path, users_path, telegram_path string
+ users map[string]time.Time
+ invites Invites
+ profiles map[string]Profile
+ defaultProfile string
+ emails, displayprefs, ombi_template map[string]interface{}
+ telegram map[int64]TelegramUser
+ customEmails customEmails
+ policy mediabrowser.Policy
+ configuration mediabrowser.Configuration
+ lang Lang
+ invitesLock, usersLock sync.Mutex
+}
+
+type TelegramUser struct {
+ ChatID int64
+ Username string
+ Lang string
}
type customEmails struct {
@@ -81,23 +88,26 @@ type Invite struct {
}
type Lang struct {
- AdminPath string
- chosenAdminLang string
- Admin adminLangs
- AdminJSON map[string]string
- FormPath string
- chosenFormLang string
- Form formLangs
- PasswordResetPath string
- chosenPWRLang string
- PasswordReset pwrLangs
- EmailPath string
- chosenEmailLang string
- Email emailLangs
- CommonPath string
- Common commonLangs
- SetupPath string
- Setup setupLangs
+ AdminPath string
+ chosenAdminLang string
+ Admin adminLangs
+ AdminJSON map[string]string
+ FormPath string
+ chosenFormLang string
+ Form formLangs
+ PasswordResetPath string
+ chosenPWRLang string
+ PasswordReset pwrLangs
+ EmailPath string
+ chosenEmailLang string
+ Email emailLangs
+ CommonPath string
+ Common commonLangs
+ SetupPath string
+ Setup setupLangs
+ chosenTelegramLang string
+ TelegramPath string
+ Telegram telegramLangs
}
func (st *Storage) loadLang(filesystems ...fs.FS) (err error) {
@@ -118,6 +128,10 @@ func (st *Storage) loadLang(filesystems ...fs.FS) (err error) {
return
}
err = st.loadLangEmail(filesystems...)
+ if err != nil {
+ return
+ }
+ err = st.loadLangTelegram(filesystems...)
return
}
@@ -620,6 +634,83 @@ func (st *Storage) loadLangEmail(filesystems ...fs.FS) error {
return nil
}
+func (st *Storage) loadLangTelegram(filesystems ...fs.FS) error {
+ st.lang.Telegram = map[string]telegramLang{}
+ var english telegramLang
+ loadedLangs := make([]map[string]bool, len(filesystems))
+ var load loadLangFunc
+ load = func(fsIndex int, fname string) error {
+ filesystem := filesystems[fsIndex]
+ index := strings.TrimSuffix(fname, filepath.Ext(fname))
+ lang := telegramLang{}
+ f, err := fs.ReadFile(filesystem, FSJoin(st.lang.TelegramPath, fname))
+ if err != nil {
+ return err
+ }
+ if substituteStrings != "" {
+ f = []byte(strings.ReplaceAll(string(f), "Jellyfin", substituteStrings))
+ }
+ err = json.Unmarshal(f, &lang)
+ if err != nil {
+ return err
+ }
+ st.lang.Common.patchCommon(&lang.Strings, index)
+ if fname != "en-us.json" {
+ if lang.Meta.Fallback != "" {
+ fallback, ok := st.lang.Telegram[lang.Meta.Fallback]
+ err = nil
+ if !ok {
+ err = load(fsIndex, lang.Meta.Fallback+".json")
+ fallback = st.lang.Telegram[lang.Meta.Fallback]
+ }
+ if err == nil {
+ loadedLangs[fsIndex][lang.Meta.Fallback+".json"] = true
+ patchLang(&lang.Strings, &fallback.Strings, &english.Strings)
+ }
+ }
+ if (lang.Meta.Fallback != "" && err != nil) || lang.Meta.Fallback == "" {
+ patchLang(&lang.Strings, &english.Strings)
+ }
+ }
+ st.lang.Telegram[index] = lang
+ return nil
+ }
+ engFound := false
+ var err error
+ for i := range filesystems {
+ loadedLangs[i] = map[string]bool{}
+ err = load(i, "en-us.json")
+ if err == nil {
+ engFound = true
+ }
+ loadedLangs[i]["en-us.json"] = true
+ }
+ if !engFound {
+ return err
+ }
+ english = st.lang.Telegram["en-us"]
+ telegramLoaded := false
+ for i := range filesystems {
+ files, err := fs.ReadDir(filesystems[i], st.lang.TelegramPath)
+ if err != nil {
+ continue
+ }
+ for _, f := range files {
+ if !loadedLangs[i][f.Name()] {
+ err = load(i, f.Name())
+ if err == nil {
+ telegramLoaded = true
+ loadedLangs[i][f.Name()] = true
+ }
+ }
+ }
+ }
+ if !telegramLoaded {
+ return err
+ }
+ return nil
+}
+
type Invites map[string]Invite
func (st *Storage) loadInvites() error {
@@ -665,6 +756,14 @@ func (st *Storage) storeEmails() error {
return storeJSON(st.emails_path, st.emails)
}
+func (st *Storage) loadTelegramUsers() error {
+ return loadJSON(st.telegram_path, &st.telegram)
+}
+
+func (st *Storage) storeTelegramUsers() error {
+ return storeJSON(st.telegram_path, st.telegram)
+}
+
func (st *Storage) loadCustomEmails() error {
return loadJSON(st.customEmails_path, &st.customEmails)
}
diff --git a/telegram.go b/telegram.go
new file mode 100644
index 0000000..5d06e93
--- /dev/null
+++ b/telegram.go
@@ -0,0 +1,201 @@
+package main
+
+import (
+ "fmt"
+ "math/rand"
+ "strconv"
+ "strings"
+ "time"
+
+ tg "github.com/go-telegram-bot-api/telegram-bot-api"
+)
+
+type TelegramDaemon struct {
+ Stopped bool
+ ShutdownChannel chan string
+ bot *tg.BotAPI
+ username string
+ tokens []string
+ verifiedTokens []string
+ link string
+ app *appContext
+}
+
+func newTelegramDaemon(app *appContext) (*TelegramDaemon, error) {
+ token := app.config.Section("telegram").Key("token").String()
+ if token == "" {
+ return nil, fmt.Errorf("token was blank")
+ }
+ bot, err := tg.NewBotAPI(token)
+ if err != nil {
+ return nil, err
+ }
+ return &TelegramDaemon{
+ Stopped: false,
+ ShutdownChannel: make(chan string),
+ bot: bot,
+ username: bot.Self.UserName,
+ tokens: []string{},
+ verifiedTokens: []string{},
+ link: "https://t.me/" + bot.Self.UserName,
+ app: app,
+ }, nil
+}
+
+var runes = []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
+
+// NewAuthToken generates an 8-character pin in the form "A1-2B-CD".
+func (t *TelegramDaemon) NewAuthToken() string {
+ rand.Seed(time.Now().UnixNano())
+ pin := make([]rune, 8)
+ for i := range pin {
+ if i == 2 || i == 5 {
+ pin[i] = '-'
+ } else {
+ pin[i] = runes[rand.Intn(len(runes))]
+ }
+ }
+ t.tokens = append(t.tokens, string(pin))
+ return string(pin)
+}
+
+func (t *TelegramDaemon) run() {
+ t.app.info.Println("Starting Telegram bot daemon")
+ u := tg.NewUpdate(0)
+ u.Timeout = 60
+ updates, err := t.bot.GetUpdatesChan(u)
+ if err != nil {
+ t.app.err.Printf("Failed to start Telegram daemon: %v", err)
+ return
+ }
+ for {
+ var upd tg.Update
+ select {
+ case upd = <-updates:
+ if upd.Message == nil {
+ continue
+ }
+ sects := strings.Split(upd.Message.Text, " ")
+ if len(sects) == 0 {
+ continue
+ }
+ lang := t.app.storage.lang.chosenTelegramLang
+ user, ok := t.app.storage.telegram[upd.Message.Chat.ID]
+ if !ok {
+ user := TelegramUser{
+ Username: upd.Message.Chat.UserName,
+ ChatID: upd.Message.Chat.ID,
+ Lang: "",
+ }
+ t.app.storage.telegram[upd.Message.Chat.ID] = user
+ err := t.app.storage.storeTelegramUsers()
+ if err != nil {
+ t.app.err.Printf("Failed to store Telegram users: %v", err)
+ }
+ }
+ if user.Lang != "" {
+ lang = user.Lang
+ } else {
+ for code := range t.app.storage.lang.Telegram {
+ if code[:2] == upd.Message.From.LanguageCode {
+ lang = code
+ break
+ }
+ }
+ }
+ switch msg := sects[0]; msg {
+ case "/start":
+ content := t.app.storage.lang.Telegram[lang].Strings.get("startMessage") + "\n"
+ content += t.app.storage.lang.Telegram[lang].Strings.get("languageMessage")
+ err := t.Reply(&upd, content)
+ if err != nil {
+ t.app.err.Printf("Telegram: Failed to send message to \"%s\": %v", upd.Message.From.UserName, err)
+ }
+ continue
+ case "/lang":
+ if len(sects) == 1 {
+ list := "/lang \n"
+ for code := range t.app.storage.lang.Telegram {
+ list += fmt.Sprintf("%s: %s\n", code, t.app.storage.lang.Telegram[code].Meta.Name)
+ }
+ err := t.Reply(&upd, list)
+ if err != nil {
+ t.app.err.Printf("Telegram: Failed to send message to \"%s\": %v", upd.Message.From.UserName, err)
+ }
+ continue
+ }
+ if _, ok := t.app.storage.lang.Telegram[sects[1]]; ok {
+ user.Lang = sects[1]
+ t.app.storage.telegram[upd.Message.Chat.ID] = user
+ err := t.app.storage.storeTelegramUsers()
+ if err != nil {
+ t.app.err.Printf("Failed to store Telegram users: %v", err)
+ }
+ }
+ continue
+ default:
+ tokenIndex := -1
+ for i, token := range t.tokens {
+ if upd.Message.Text == token {
+ tokenIndex = i
+ break
+ }
+ }
+ if tokenIndex == -1 {
+ err := t.QuoteReply(&upd, t.app.storage.lang.Telegram[lang].Strings.get("invalidPIN"))
+ if err != nil {
+ t.app.err.Printf("Telegram: Failed to send message to \"%s\": %v", upd.Message.From.UserName, err)
+ }
+ continue
+ }
+ err := t.QuoteReply(&upd, t.app.storage.lang.Telegram[lang].Strings.get("success"))
+ if err != nil {
+ t.app.err.Printf("Telegram: Failed to send message to \"%s\": %v", upd.Message.From.UserName, err)
+ }
+ t.verifiedTokens = append(t.verifiedTokens, upd.Message.Text)
+ t.tokens[len(t.tokens)-1], t.tokens[tokenIndex] = t.tokens[tokenIndex], t.tokens[len(t.tokens)-1]
+ t.tokens = t.tokens[:len(t.tokens)-1]
+ }
+
+ case <-t.ShutdownChannel:
+ t.ShutdownChannel <- "Down"
+ return
+ }
+ }
+}
+
+func (t *TelegramDaemon) Reply(upd *tg.Update, content string) error {
+ msg := tg.NewMessage((*upd).Message.Chat.ID, content)
+ _, err := t.bot.Send(msg)
+ return err
+}
+
+func (t *TelegramDaemon) QuoteReply(upd *tg.Update, content string) error {
+ msg := tg.NewMessage((*upd).Message.Chat.ID, content)
+ msg.ReplyToMessageID = (*upd).Message.MessageID
+ _, err := t.bot.Send(msg)
+ return err
+}
+
+// Send adds compatibility with EmailClient, fromName/fromAddr are discarded, message.Text is used, addresses are Chat IDs as strings.
+func (t *TelegramDaemon) Send(fromName, fromAddr string, message *Message, address ...string) error {
+ for _, addr := range address {
+ ChatID, err := strconv.ParseInt(addr, 10, 64)
+ if err != nil {
+ return err
+ }
+ msg := tg.NewMessage(ChatID, message.Text)
+ _, err = t.bot.Send(msg)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (t *TelegramDaemon) Shutdown() {
+ t.Stopped = true
+ t.ShutdownChannel <- "Down"
+ <-t.ShutdownChannel
+ close(t.ShutdownChannel)
+}
diff --git a/ts/form.ts b/ts/form.ts
index 7bb56c6..c6a1adb 100644
--- a/ts/form.ts
+++ b/ts/form.ts
@@ -1,15 +1,20 @@
import { Modal } from "./modules/modal.js";
+import { notificationBox } from "./modules/common.js";
import { _get, _post, toggleLoader, toDateString } from "./modules/common.js";
import { loadLangSelector } from "./modules/lang.js";
interface formWindow extends Window {
validationStrings: pwValStrings;
invalidPassword: string;
- modal: Modal;
+ successModal: Modal;
+ telegramModal: Modal;
+ confirmationModal: Modal
code: string;
messages: { [key: string]: string };
confirmation: boolean;
- confirmationModal: Modal
+ telegramEnabled: boolean;
+ telegramRequired: boolean;
+ telegramPIN: string;
userExpiryEnabled: boolean;
userExpiryMonths: number;
userExpiryDays: number;
@@ -34,7 +39,37 @@ interface pwValStrings {
loadLangSelector("form");
-window.modal = new Modal(document.getElementById("modal-success"), true);
+window.notifications = new notificationBox(document.getElementById("notification-box") as HTMLDivElement);
+
+window.successModal = new Modal(document.getElementById("modal-success"), true);
+
+if (window.telegramEnabled) {
+ window.telegramModal = new Modal(document.getElementById("modal-telegram"), window.telegramRequired);
+ (document.getElementById("link-telegram") as HTMLSpanElement).onclick = () => {
+ const waiting = document.getElementById("telegram-waiting") as HTMLSpanElement;
+ toggleLoader(waiting);
+ window.telegramModal.show();
+ const checkVerified = () => _get("/invite/" + window.code + "/telegram/verified/" + window.telegramPIN, null, (req: XMLHttpRequest) => {
+ if (req.readyState == 4) {
+ if (req.status == 401) {
+ window.telegramModal.close();
+ window.notifications.customError("invalidCodeError", window.lang.notif("errorInvalidCode"));
+ return;
+ } else if (req.status == 200) {
+ if (req.response["success"] as boolean) {
+ toggleLoader(waiting);
+ window.telegramModal.close()
+ window.notifications.customSuccess("accountVerified", window.lang.notif("telegramVerified"))
+ } else {
+ setTimeout(checkVerified, 1500);
+ }
+ }
+ }
+ });
+ checkVerified();
+ };
+}
+
if (window.confirmation) {
window.confirmationModal = new Modal(document.getElementById("modal-confirmation"), true);
}
@@ -130,7 +165,7 @@ const create = (event: SubmitEvent) => {
if (!vals[type]) { valid = false; }
}
if (req.status == 200 && valid) {
- window.modal.show();
+ window.successModal.show();
} else {
submitSpan.classList.add("~critical");
submitSpan.classList.remove("~urge");
diff --git a/views.go b/views.go
index 8e7e801..f103bab 100644
--- a/views.go
+++ b/views.go
@@ -259,7 +259,7 @@ func (app *appContext) InviteProxy(gc *gin.Context) {
if strings.Contains(email, "Failed") {
email = ""
}
- gcHTML(gc, http.StatusOK, "form-loader.html", gin.H{
+ data := gin.H{
"urlBase": app.getURLBase(gc),
"cssClass": app.cssClass,
"contactMessage": app.config.Section("ui").Key("contact_message").String(),
@@ -282,7 +282,15 @@ func (app *appContext) InviteProxy(gc *gin.Context) {
"userExpiryMinutes": inv.UserMinutes,
"userExpiryMessage": app.storage.lang.Form[lang].Strings.get("yourAccountIsValidUntil"),
"langName": lang,
- })
+ "telegramEnabled": app.config.Section("telegram").Key("enabled").MustBool(false),
+ }
+ if data["telegramEnabled"].(bool) {
+ data["telegramPIN"] = app.telegram.NewAuthToken()
+ data["telegramUsername"] = app.telegram.username
+ data["telegramURL"] = app.telegram.link
+ data["telegramRequired"] = app.config.Section("telegram").Key("required").MustBool(false)
+ }
+ gcHTML(gc, http.StatusOK, "form-loader.html", data)
}
func (app *appContext) NoRouteHandler(gc *gin.Context) {