api-invites.go

@@ -15,6 +15,7 @@ import (
 
 func (app *appContext) checkInvites() {
 	currentTime := time.Now()
+	app.storage.loadInvites()
 	for _, data := range app.storage.GetInvites() {
 		expiry := data.ValidTill
 		if !currentTime.After(expiry) {
@@ -58,6 +59,7 @@ func (app *appContext) checkInvites() {
 
 func (app *appContext) checkInvite(code string, used bool, username string) bool {
 	currentTime := time.Now()
+	app.storage.loadInvites()
 	inv, match := app.storage.GetInvitesKey(code)
 	if !match {
 		return false
@@ -126,6 +128,7 @@ func (app *appContext) checkInvite(code string, used bool, username string) bool
 func (app *appContext) GenerateInvite(gc *gin.Context) {
 	var req generateInviteDTO
 	app.debug.Println("Generating new invite")
+	app.storage.loadInvites()
 	gc.BindJSON(&req)
 	currentTime := time.Now()
 	validTill := currentTime.AddDate(0, req.Months, req.Days)
@@ -219,6 +222,7 @@ func (app *appContext) GenerateInvite(gc *gin.Context) {
 func (app *appContext) GetInvites(gc *gin.Context) {
 	app.debug.Println("Invites requested")
 	currentTime := time.Now()
+	app.storage.loadInvites()
 	app.checkInvites()
 	var invites []inviteDTO
 	for _, inv := range app.storage.GetInvites() {
@@ -340,6 +344,8 @@ func (app *appContext) SetNotify(gc *gin.Context) {
 	changed := false
 	for code, settings := range req {
 		app.debug.Printf("%s: Notification settings change requested", code)
+		app.storage.loadInvites()
+		app.storage.loadEmails()
 		invite, ok := app.storage.GetInvitesKey(code)
 		if !ok {
 			app.err.Printf("%s Notification setting change failed: Invalid code", code)

api-messages.go

@@ -25,18 +25,18 @@ func (app *appContext) GetCustomContent(gc *gin.Context) {
 		adminLang = app.storage.lang.chosenAdminLang
 	}
 	list := emailListDTO{
-		"UserCreated":       {Name: app.storage.lang.Email[lang].UserCreated["name"], Enabled: app.storage.MustGetCustomContentKey("UserCreated").Enabled},
+		"UserCreated":       {Name: app.storage.lang.Email[lang].UserCreated["name"], Enabled: app.storage.customEmails.UserCreated.Enabled},
-		"InviteExpiry":      {Name: app.storage.lang.Email[lang].InviteExpiry["name"], Enabled: app.storage.MustGetCustomContentKey("InviteExpiry").Enabled},
+		"InviteExpiry":      {Name: app.storage.lang.Email[lang].InviteExpiry["name"], Enabled: app.storage.customEmails.InviteExpiry.Enabled},
-		"PasswordReset":     {Name: app.storage.lang.Email[lang].PasswordReset["name"], Enabled: app.storage.MustGetCustomContentKey("PasswordReset").Enabled},
+		"PasswordReset":     {Name: app.storage.lang.Email[lang].PasswordReset["name"], Enabled: app.storage.customEmails.PasswordReset.Enabled},
-		"UserDeleted":       {Name: app.storage.lang.Email[lang].UserDeleted["name"], Enabled: app.storage.MustGetCustomContentKey("UserDeleted").Enabled},
+		"UserDeleted":       {Name: app.storage.lang.Email[lang].UserDeleted["name"], Enabled: app.storage.customEmails.UserDeleted.Enabled},
-		"UserDisabled":      {Name: app.storage.lang.Email[lang].UserDisabled["name"], Enabled: app.storage.MustGetCustomContentKey("UserDisabled").Enabled},
+		"UserDisabled":      {Name: app.storage.lang.Email[lang].UserDisabled["name"], Enabled: app.storage.customEmails.UserDisabled.Enabled},
-		"UserEnabled":       {Name: app.storage.lang.Email[lang].UserEnabled["name"], Enabled: app.storage.MustGetCustomContentKey("UserEnabled").Enabled},
+		"UserEnabled":       {Name: app.storage.lang.Email[lang].UserEnabled["name"], Enabled: app.storage.customEmails.UserEnabled.Enabled},
-		"InviteEmail":       {Name: app.storage.lang.Email[lang].InviteEmail["name"], Enabled: app.storage.MustGetCustomContentKey("InviteEmail").Enabled},
+		"InviteEmail":       {Name: app.storage.lang.Email[lang].InviteEmail["name"], Enabled: app.storage.customEmails.InviteEmail.Enabled},
-		"WelcomeEmail":      {Name: app.storage.lang.Email[lang].WelcomeEmail["name"], Enabled: app.storage.MustGetCustomContentKey("WelcomeEmail").Enabled},
+		"WelcomeEmail":      {Name: app.storage.lang.Email[lang].WelcomeEmail["name"], Enabled: app.storage.customEmails.WelcomeEmail.Enabled},
-		"EmailConfirmation": {Name: app.storage.lang.Email[lang].EmailConfirmation["name"], Enabled: app.storage.MustGetCustomContentKey("EmailConfirmation").Enabled},
+		"EmailConfirmation": {Name: app.storage.lang.Email[lang].EmailConfirmation["name"], Enabled: app.storage.customEmails.EmailConfirmation.Enabled},
-		"UserExpired":       {Name: app.storage.lang.Email[lang].UserExpired["name"], Enabled: app.storage.MustGetCustomContentKey("UserExpired").Enabled},
+		"UserExpired":       {Name: app.storage.lang.Email[lang].UserExpired["name"], Enabled: app.storage.customEmails.UserExpired.Enabled},
-		"UserLogin":         {Name: app.storage.lang.Admin[adminLang].Strings["userPageLogin"], Enabled: app.storage.MustGetCustomContentKey("Login").Enabled},
+		"UserLogin":         {Name: app.storage.lang.Admin[adminLang].Strings["userPageLogin"], Enabled: app.storage.userPage.Login.Enabled},
-		"UserPage":          {Name: app.storage.lang.Admin[adminLang].Strings["userPagePage"], Enabled: app.storage.MustGetCustomContentKey("Page").Enabled},
+		"UserPage":          {Name: app.storage.lang.Admin[adminLang].Strings["userPagePage"], Enabled: app.storage.userPage.Page.Enabled},
 	}
 
 	filter := gc.Query("filter")
@@ -50,11 +50,10 @@ func (app *appContext) GetCustomContent(gc *gin.Context) {
 	gc.JSON(200, list)
 }
 
-// No longer needed, these are stored by string keys in the database now.
+func (app *appContext) getCustomMessage(id string) *customContent {
-/* func (app *appContext) getCustomMessage(id string) *CustomContent {
 	switch id {
 	case "Announcement":
-		return &CustomContent{}
+		return &customContent{}
 	case "UserCreated":
 		return &app.storage.customEmails.UserCreated
 	case "InviteExpiry":
@@ -81,38 +80,45 @@ func (app *appContext) GetCustomContent(gc *gin.Context) {
 		return &app.storage.userPage.Page
 	}
 	return nil
-} */
+}
 
-// @Summary Sets the corresponding custom content.
+// @Summary Sets the corresponding custom email.
 // @Produce json
-// @Param CustomContent body CustomContent true "Content = email (in markdown)."
+// @Param customEmails body customEmails true "Content = email (in markdown)."
 // @Success 200 {object} boolResponse
 // @Failure 400 {object} boolResponse
 // @Failure 500 {object} boolResponse
-// @Param id path string true "ID of content"
+// @Param id path string true "ID of email"
 // @Router /config/emails/{id} [post]
 // @Security Bearer
 // @tags Configuration
 func (app *appContext) SetCustomMessage(gc *gin.Context) {
-	var req CustomContent
+	var req customContent
 	gc.BindJSON(&req)
 	id := gc.Param("id")
 	if req.Content == "" {
 		respondBool(400, false, gc)
 		return
 	}
-	message, ok := app.storage.GetCustomContentKey(id)
+	message := app.getCustomMessage(id)
-	if !ok {
+	if message == nil {
 		respondBool(400, false, gc)
 		return
 	}
 	message.Content = req.Content
 	message.Enabled = true
-	app.storage.SetCustomContentKey(id, message)
+	if app.storage.storeCustomEmails() != nil {
+		respondBool(500, false, gc)
+		return
+	}
+	if app.storage.storeUserPageContent() != nil {
+		respondBool(500, false, gc)
+		return
+	}
 	respondBool(200, true, gc)
 }
 
-// @Summary Enable/Disable custom content.
+// @Summary Enable/Disable custom email.
 // @Produce json
 // @Success 200 {object} boolResponse
 // @Failure 400 {object} boolResponse
@@ -131,17 +137,24 @@ func (app *appContext) SetCustomMessageState(gc *gin.Context) {
 	} else if s != "disable" {
 		respondBool(400, false, gc)
 	}
-	message, ok := app.storage.GetCustomContentKey(id)
+	message := app.getCustomMessage(id)
-	if !ok {
+	if message == nil {
 		respondBool(400, false, gc)
 		return
 	}
 	message.Enabled = enabled
-	app.storage.SetCustomContentKey(id, message)
+	if app.storage.storeCustomEmails() != nil {
+		respondBool(500, false, gc)
+		return
+	}
+	if app.storage.storeUserPageContent() != nil {
+		respondBool(500, false, gc)
+		return
+	}
 	respondBool(200, true, gc)
 }
 
-// @Summary Returns the custom content/message (generating it if not set) and list of used variables in it.
+// @Summary Returns the custom email/message (generating it if not set) and list of used variables in it.
 // @Produce json
 // @Success 200 {object} customEmailDTO
 // @Failure 400 {object} boolResponse
@@ -161,8 +174,8 @@ func (app *appContext) GetCustomMessageTemplate(gc *gin.Context) {
 	var values map[string]interface{}
 	username := app.storage.lang.Email[lang].Strings.get("username")
 	emailAddress := app.storage.lang.Email[lang].Strings.get("emailAddress")
-	customMessage, ok := app.storage.GetCustomContentKey(id)
+	customMessage := app.getCustomMessage(id)
-	if !ok {
+	if customMessage == nil {
 		app.err.Printf("Failed to get custom message with ID \"%s\"", id)
 		respondBool(400, false, gc)
 		return
@@ -267,7 +280,13 @@ func (app *appContext) GetCustomMessageTemplate(gc *gin.Context) {
 	if variables == nil {
 		variables = []string{}
 	}
-	app.storage.SetCustomContentKey(id, customMessage)
+	if app.storage.storeCustomEmails() != nil {
+		respondBool(500, false, gc)
+		return
+	}
+	if app.storage.storeUserPageContent() != nil {
+		respondBool(500, false, gc)
+	}
 	var mail *Message
 	if id != "UserLogin" && id != "UserPage" {
 		mail, err = app.email.constructTemplate("", "<div class=\"preview-content\"></div>", app)

api-userpage.go

@@ -42,6 +42,11 @@ func (app *appContext) MyDetails(gc *gin.Context) {
 		resp.Expiry = exp.Expiry.Unix()
 	}
 
+	app.storage.loadEmails()
+	app.storage.loadDiscordUsers()
+	app.storage.loadMatrixUsers()
+	app.storage.loadTelegramUsers()
+
 	if emailEnabled {
 		resp.Email = &MyDetailsContactMethodsDTO{}
 		if email, ok := app.storage.GetEmailsKey(user.ID); ok && email.Addr != "" {

api-users.go

@@ -44,16 +44,16 @@ func (app *appContext) NewUserAdmin(gc *gin.Context) {
 		return
 	}
 	id := user.ID
-	profile := app.storage.GetDefaultProfile()
+	if app.storage.policy.BlockedTags != nil {
-	// Check profile isn't empty
+		status, err = app.jf.SetPolicy(id, app.storage.policy)
-	if profile.Policy.BlockedTags != nil {
-		status, err = app.jf.SetPolicy(id, profile.Policy)
 		if !(status == 200 || status == 204 || err == nil) {
 			app.err.Printf("%s: Failed to set user policy (%d): %v", req.Username, status, err)
 		}
-		status, err = app.jf.SetConfiguration(id, profile.Configuration)
+	}
+	if app.storage.configuration.GroupedFolders != nil && len(app.storage.displayprefs) != 0 {
+		status, err = app.jf.SetConfiguration(id, app.storage.configuration)
 		if (status == 200 || status == 204) && err == nil {
-			status, err = app.jf.SetDisplayPreferences(id, profile.Displayprefs)
+			status, err = app.jf.SetDisplayPreferences(id, app.storage.displayprefs)
 		}
 		if !((status == 200 || status == 204) && err == nil) {
 			app.err.Printf("%s: Failed to set configuration template (%d): %v", req.Username, status, err)
@@ -64,16 +64,15 @@ func (app *appContext) NewUserAdmin(gc *gin.Context) {
 		app.storage.SetEmailsKey(id, EmailAddress{Addr: req.Email, Contact: true})
 	}
 	if app.config.Section("ombi").Key("enabled").MustBool(false) {
-		profile := app.storage.GetDefaultProfile()
+		app.storage.loadOmbiTemplate()
-		if profile.Ombi == nil {
+		if len(app.storage.ombi_template) != 0 {
-			profile.Ombi = map[string]interface{}{}
+			errors, code, err := app.ombi.NewUser(req.Username, req.Password, req.Email, app.storage.ombi_template)
-		}
+			if err != nil || code != 200 {
-		errors, code, err := app.ombi.NewUser(req.Username, req.Password, req.Email, profile.Ombi)
+				app.err.Printf("Failed to create Ombi user (%d): %v", code, err)
-		if err != nil || code != 200 {
+				app.debug.Printf("Errors reported by Ombi: %s", strings.Join(errors, ", "))
-			app.err.Printf("Failed to create Ombi user (%d): %v", code, err)
+			} else {
-			app.debug.Printf("Errors reported by Ombi: %s", strings.Join(errors, ", "))
+				app.info.Println("Created Ombi user")
-		} else {
+			}
-			app.info.Println("Created Ombi user")
 		}
 	}
 	if emailEnabled && app.config.Section("welcome_email").Key("enabled").MustBool(false) && req.Email != "" {

config.go

@@ -37,6 +37,8 @@ func (app *appContext) loadConfig() error {
 		return err
 	}
 
+	app.MustSetValue("", "migrated_to_db", "false")
+
 	app.MustSetValue("jellyfin", "public_server", app.config.Section("jellyfin").Key("server").String())
 
 	app.MustSetValue("ui", "redirect_url", app.config.Section("jellyfin").Key("public_server").String())
@@ -157,6 +159,15 @@ func (app *appContext) loadConfig() error {
 		app.MustSetValue("updates", "channel", releaseChannel)
 	}
 
+	app.storage.customEmails_path = app.config.Section("files").Key("custom_emails").String()
+	app.storage.loadCustomEmails()
+
+	app.MustSetValue("user_page", "enabled", "true")
+	if app.config.Section("user_page").Key("enabled").MustBool(false) {
+		app.storage.userPage_path = app.config.Section("files").Key("custom_user_page_content").String()
+		app.storage.loadUserPageContent()
+	}
+
 	substituteStrings = app.config.Section("jellyfin").Key("substitute_jellyfin_strings").MustString("")
 
 	if substituteStrings != "" {

daemon.go

@@ -116,6 +116,7 @@ func (rt *housekeepingDaemon) run() {
 			break
 		}
 		started := time.Now()
+		rt.app.storage.loadInvites()
 
 		for _, job := range rt.jobs {
 			job(rt.app)

email.go

@@ -331,11 +331,10 @@ func (emailer *Emailer) constructConfirmation(code, username, key string, app *a
 	}
 	var err error
 	template := emailer.confirmationValues(code, username, key, app, noSub)
-	message := app.storage.MustGetCustomContentKey("EmailConfirmation")
+	if app.storage.customEmails.EmailConfirmation.Enabled {
-	if message.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.EmailConfirmation.Content,
-			message.Variables,
+			app.storage.customEmails.EmailConfirmation.Variables,
 			nil,
 			template,
 		)
@@ -415,11 +414,10 @@ func (emailer *Emailer) constructInvite(code string, invite Invite, app *appCont
 	}
 	template := emailer.inviteValues(code, invite, app, noSub)
 	var err error
-	message := app.storage.MustGetCustomContentKey("InviteEmail")
+	if app.storage.customEmails.InviteEmail.Enabled {
-	if message.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.InviteEmail.Content,
-			message.Variables,
+			app.storage.customEmails.InviteEmail.Variables,
 			nil,
 			template,
 		)
@@ -455,11 +453,10 @@ func (emailer *Emailer) constructExpiry(code string, invite Invite, app *appCont
 	}
 	var err error
 	template := emailer.expiryValues(code, invite, app, noSub)
-	message := app.storage.MustGetCustomContentKey("InviteExpiry")
+	if app.storage.customEmails.InviteExpiry.Enabled {
-	if message.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.InviteExpiry.Content,
-			message.Variables,
+			app.storage.customEmails.InviteExpiry.Variables,
 			nil,
 			template,
 		)
@@ -510,11 +507,10 @@ func (emailer *Emailer) constructCreated(code, username, address string, invite
 	}
 	template := emailer.createdValues(code, username, address, invite, app, noSub)
 	var err error
-	message := app.storage.MustGetCustomContentKey("UserCreated")
+	if app.storage.customEmails.UserCreated.Enabled {
-	if message.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.UserCreated.Content,
-			message.Variables,
+			app.storage.customEmails.UserCreated.Variables,
 			nil,
 			template,
 		)
@@ -584,11 +580,10 @@ func (emailer *Emailer) constructReset(pwr PasswordReset, app *appContext, noSub
 	}
 	template := emailer.resetValues(pwr, app, noSub)
 	var err error
-	message := app.storage.MustGetCustomContentKey("PasswordReset")
+	if app.storage.customEmails.PasswordReset.Enabled {
-	if message.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.PasswordReset.Content,
-			message.Variables,
+			app.storage.customEmails.PasswordReset.Variables,
 			nil,
 			template,
 		)
@@ -626,11 +621,10 @@ func (emailer *Emailer) constructDeleted(reason string, app *appContext, noSub b
 	}
 	var err error
 	template := emailer.deletedValues(reason, app, noSub)
-	message := app.storage.MustGetCustomContentKey("UserDeleted")
+	if app.storage.customEmails.UserDeleted.Enabled {
-	if message.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.UserDeleted.Content,
-			message.Variables,
+			app.storage.customEmails.UserDeleted.Variables,
 			nil,
 			template,
 		)
@@ -668,11 +662,10 @@ func (emailer *Emailer) constructDisabled(reason string, app *appContext, noSub
 	}
 	var err error
 	template := emailer.disabledValues(reason, app, noSub)
-	message := app.storage.MustGetCustomContentKey("UserDisabled")
+	if app.storage.customEmails.UserDisabled.Enabled {
-	if message.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.UserDisabled.Content,
-			message.Variables,
+			app.storage.customEmails.UserDisabled.Variables,
 			nil,
 			template,
 		)
@@ -710,11 +703,10 @@ func (emailer *Emailer) constructEnabled(reason string, app *appContext, noSub b
 	}
 	var err error
 	template := emailer.enabledValues(reason, app, noSub)
-	message := app.storage.MustGetCustomContentKey("UserEnabled")
+	if app.storage.customEmails.UserEnabled.Enabled {
-	if message.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.UserEnabled.Content,
-			message.Variables,
+			app.storage.customEmails.UserEnabled.Variables,
 			nil,
 			template,
 		)
@@ -766,8 +758,7 @@ func (emailer *Emailer) constructWelcome(username string, expiry time.Time, app
 	}
 	var err error
 	var template map[string]interface{}
-	message := app.storage.MustGetCustomContentKey("WelcomeEmail")
+	if app.storage.customEmails.WelcomeEmail.Enabled {
-	if message.Enabled {
 		template = emailer.welcomeValues(username, expiry, app, noSub, true)
 	} else {
 		template = emailer.welcomeValues(username, expiry, app, noSub, false)
@@ -777,11 +768,11 @@ func (emailer *Emailer) constructWelcome(username string, expiry time.Time, app
 			"date": "{yourAccountWillExpire}",
 		})
 	}
-	if message.Enabled {
+	if app.storage.customEmails.WelcomeEmail.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.WelcomeEmail.Content,
-			message.Variables,
+			app.storage.customEmails.WelcomeEmail.Variables,
-			message.Conditionals,
+			app.storage.customEmails.WelcomeEmail.Conditionals,
 			template,
 		)
 		email, err = emailer.constructTemplate(email.Subject, content, app)
@@ -812,11 +803,10 @@ func (emailer *Emailer) constructUserExpired(app *appContext, noSub bool) (*Mess
 	}
 	var err error
 	template := emailer.userExpiredValues(app, noSub)
-	message := app.storage.MustGetCustomContentKey("UserExpired")
+	if app.storage.customEmails.UserExpired.Enabled {
-	if message.Enabled {
 		content := templateEmail(
-			message.Content,
+			app.storage.customEmails.UserExpired.Content,
-			message.Variables,
+			app.storage.customEmails.UserExpired.Variables,
 			nil,
 			template,
 		)

main.go

@@ -335,8 +335,59 @@ func start(asDaemon, firstCall bool) {
 
 		app.debug.Printf("Loaded config file \"%s\"", app.configPath)
 
+		app.debug.Println("Loading storage")
+
+		app.storage.invite_path = app.config.Section("files").Key("invites").String()
+		if err := app.storage.loadInvites(); err != nil {
+			app.err.Printf("Failed to load Invites: %v", err)
+		}
+		app.storage.emails_path = app.config.Section("files").Key("emails").String()
+		if err := app.storage.loadEmails(); err != nil {
+			app.err.Printf("Failed to load Emails: %v", err)
+			err := migrateEmailStorage(app)
+			if err != nil {
+				app.err.Printf("Failed to migrate Email storage: %v", err)
+			}
+		}
+		app.storage.policy_path = app.config.Section("files").Key("user_template").String()
+		if err := app.storage.loadPolicy(); err != nil {
+			app.err.Printf("Failed to load Policy: %v", err)
+		}
+		app.storage.configuration_path = app.config.Section("files").Key("user_configuration").String()
+		if err := app.storage.loadConfiguration(); err != nil {
+			app.err.Printf("Failed to load Configuration: %v", err)
+		}
+		app.storage.displayprefs_path = app.config.Section("files").Key("user_displayprefs").String()
+		if err := app.storage.loadDisplayprefs(); err != nil {
+			app.err.Printf("Failed to load Displayprefs: %v", err)
+		}
+		app.storage.users_path = app.config.Section("files").Key("users").String()
+		if err := app.storage.loadUserExpiries(); 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.discord_path = app.config.Section("files").Key("discord_users").String()
+		if err := app.storage.loadDiscordUsers(); err != nil {
+			app.err.Printf("Failed to load Discord users: %v", err)
+		}
+		app.storage.matrix_path = app.config.Section("files").Key("matrix_users").String()
+		if err := app.storage.loadMatrixUsers(); err != nil {
+			app.err.Printf("Failed to load Matrix users: %v", err)
+		}
+		app.storage.announcements_path = app.config.Section("files").Key("announcements").String()
+		if err := app.storage.loadAnnouncements(); err != nil {
+			app.err.Printf("Failed to load announcement templates: %v", err)
+		}
+
+		app.storage.profiles_path = app.config.Section("files").Key("user_profiles").String()
+		app.storage.loadProfiles()
+
 		if app.config.Section("ombi").Key("enabled").MustBool(false) {
-			app.debug.Printf("Connecting to Ombi")
+			app.storage.ombi_path = app.config.Section("files").Key("ombi_template").String()
+			app.storage.loadOmbiTemplate()
 			ombiServer := app.config.Section("ombi").Key("server").String()
 			app.ombi = ombi.NewOmbi(
 				ombiServer,

migrations.go

@@ -21,7 +21,7 @@ func runMigrations(app *appContext) {
 
 // Migrate pre-0.2.0 user templates to profiles
 func migrateProfiles(app *appContext) {
-	if app.storage.deprecatedPolicy.BlockedTags == nil && app.storage.deprecatedConfiguration.GroupedFolders == nil && len(app.storage.deprecatedDisplayprefs) == 0 {
+	if app.storage.policy.BlockedTags == nil && app.storage.configuration.GroupedFolders == nil && len(app.storage.displayprefs) == 0 {
 		return
 	}
 	app.info.Println("Migrating user template files to new profile format")
@@ -196,141 +196,51 @@ func linkExistingOmbiDiscordTelegram(app *appContext) error {
 	return nil
 }
 
-// MigrationStatus is just used to store whether data from JSON files has been migrated to the DB.
-type MigrationStatus struct {
-	Done bool
-}
-
-func loadLegacyData(app *appContext) {
-	app.storage.invite_path = app.config.Section("files").Key("invites").String()
-	if err := app.storage.loadInvites(); err != nil {
-		app.err.Printf("LegacyData: Failed to load Invites: %v", err)
-	}
-	app.storage.emails_path = app.config.Section("files").Key("emails").String()
-	if err := app.storage.loadEmails(); err != nil {
-		app.err.Printf("LegacyData: Failed to load Emails: %v", err)
-		err := migrateEmailStorage(app)
-		if err != nil {
-			app.err.Printf("LegacyData: Failed to migrate Email storage: %v", err)
-		}
-	}
-	app.storage.users_path = app.config.Section("files").Key("users").String()
-	if err := app.storage.loadUserExpiries(); err != nil {
-		app.err.Printf("LegacyData: 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("LegacyData: Failed to load Telegram users: %v", err)
-	}
-	app.storage.discord_path = app.config.Section("files").Key("discord_users").String()
-	if err := app.storage.loadDiscordUsers(); err != nil {
-		app.err.Printf("LegacyData: Failed to load Discord users: %v", err)
-	}
-	app.storage.matrix_path = app.config.Section("files").Key("matrix_users").String()
-	if err := app.storage.loadMatrixUsers(); err != nil {
-		app.err.Printf("LegacyData: Failed to load Matrix users: %v", err)
-	}
-	app.storage.announcements_path = app.config.Section("files").Key("announcements").String()
-	if err := app.storage.loadAnnouncements(); err != nil {
-		app.err.Printf("LegacyData: Failed to load announcement templates: %v", err)
-	}
-
-	app.storage.profiles_path = app.config.Section("files").Key("user_profiles").String()
-	app.storage.loadProfiles()
-
-	app.storage.customEmails_path = app.config.Section("files").Key("custom_emails").String()
-	app.storage.loadCustomEmails()
-
-	app.MustSetValue("user_page", "enabled", "true")
-	if app.config.Section("user_page").Key("enabled").MustBool(false) {
-		app.storage.userPage_path = app.config.Section("files").Key("custom_user_page_content").String()
-		app.storage.loadUserPageContent()
-	}
-}
-
 func migrateToBadger(app *appContext) {
-	// Check the DB to see if we've already migrated
+	if app.config.Section("").Key("migrated_to_db").MustBool(false) {
-	migrated := MigrationStatus{}
-	app.storage.db.Get("migrated_to_db", &migrated)
-	if migrated.Done {
 		return
+		// FIXME: Mark as done at some point
 	}
 	app.info.Println("Migrating to Badger(hold)")
-	loadLegacyData(app)
+	app.storage.loadAnnouncements()
 	for k, v := range app.storage.deprecatedAnnouncements {
 		app.storage.SetAnnouncementsKey(k, v)
 	}
 
+	app.storage.loadDiscordUsers()
 	for jfID, v := range app.storage.deprecatedDiscord {
 		app.storage.SetDiscordKey(jfID, v)
 	}
 
+	app.storage.loadTelegramUsers()
 	for jfID, v := range app.storage.deprecatedTelegram {
 		app.storage.SetTelegramKey(jfID, v)
 	}
 
+	app.storage.loadMatrixUsers()
 	for jfID, v := range app.storage.deprecatedMatrix {
 		app.storage.SetMatrixKey(jfID, v)
 	}
 
+	app.storage.loadEmails()
 	for jfID, v := range app.storage.deprecatedEmails {
 		app.storage.SetEmailsKey(jfID, v)
 	}
 
+	app.storage.loadInvites()
 	for k, v := range app.storage.deprecatedInvites {
 		app.storage.SetInvitesKey(k, v)
 	}
 
+	app.storage.loadUserExpiries()
 	for k, v := range app.storage.deprecatedUserExpiries {
 		app.storage.SetUserExpiryKey(k, UserExpiry{Expiry: v})
 	}
 
+	app.storage.loadProfiles()
 	for k, v := range app.storage.deprecatedProfiles {
 		app.storage.SetProfileKey(k, v)
 	}
-
-	if _, ok := app.storage.GetCustomContentKey("UserCreated"); !ok {
-		app.storage.SetCustomContentKey("UserCreated", app.storage.deprecatedCustomEmails.UserCreated)
-	}
-	if _, ok := app.storage.GetCustomContentKey("InviteExpiry"); !ok {
-		app.storage.SetCustomContentKey("InviteExpiry", app.storage.deprecatedCustomEmails.InviteExpiry)
-	}
-	if _, ok := app.storage.GetCustomContentKey("PasswordReset"); !ok {
-		app.storage.SetCustomContentKey("PasswordReset", app.storage.deprecatedCustomEmails.PasswordReset)
-	}
-	if _, ok := app.storage.GetCustomContentKey("UserDeleted"); !ok {
-		app.storage.SetCustomContentKey("UserDeleted", app.storage.deprecatedCustomEmails.UserDeleted)
-	}
-	if _, ok := app.storage.GetCustomContentKey("UserDisabled"); !ok {
-		app.storage.SetCustomContentKey("UserDisabled", app.storage.deprecatedCustomEmails.UserDisabled)
-	}
-	if _, ok := app.storage.GetCustomContentKey("UserEnabled"); !ok {
-		app.storage.SetCustomContentKey("UserEnabled", app.storage.deprecatedCustomEmails.UserEnabled)
-	}
-	if _, ok := app.storage.GetCustomContentKey("InviteEmail"); !ok {
-		app.storage.SetCustomContentKey("InviteEmail", app.storage.deprecatedCustomEmails.InviteEmail)
-	}
-	if _, ok := app.storage.GetCustomContentKey("WelcomeEmail"); !ok {
-		app.storage.SetCustomContentKey("WelcomeEmail", app.storage.deprecatedCustomEmails.WelcomeEmail)
-	}
-	if _, ok := app.storage.GetCustomContentKey("EmailConfirmation"); !ok {
-		app.storage.SetCustomContentKey("EmailConfirmation", app.storage.deprecatedCustomEmails.EmailConfirmation)
-	}
-	if _, ok := app.storage.GetCustomContentKey("UserExpired"); !ok {
-		app.storage.SetCustomContentKey("UserExpired", app.storage.deprecatedCustomEmails.UserExpired)
-	}
-	if _, ok := app.storage.GetCustomContentKey("UserLogin"); !ok {
-		app.storage.SetCustomContentKey("UserLogin", app.storage.deprecatedUserPageContent.Login)
-	}
-	if _, ok := app.storage.GetCustomContentKey("UserPage"); !ok {
-		app.storage.SetCustomContentKey("UserPage", app.storage.deprecatedUserPageContent.Page)
-	}
-
-	err := app.storage.db.Upsert("migrated_to_db", MigrationStatus{true})
-	if err != nil {
-		app.err.Fatalf("Failed to migrate to DB: %v\n", err)
-	}
-	app.info.Println("All data migrated to database. JSON files in the config folder can be deleted if you are sure all data is correct in the app. Create an issue if you have problems.")
 }
 
 // Migrate between hyphenated & non-hyphenated user IDs. Doesn't seem to happen anymore, so disabled.

pwreset.go

@@ -100,6 +100,7 @@ func pwrMonitor(app *appContext, watcher *fsnotify.Watcher) {
 						app.debug.Printf("Error: %s", err)
 						return
 					}
+					app.storage.loadEmails()
 					uid := user.ID
 					if uid == "" {
 						app.err.Printf("Couldn't get user ID for user \"%s\"", pwr.Username)

storage.go

@@ -35,17 +35,17 @@ type Storage struct {
 	deprecatedUserExpiries                                                                                                                                                                                                              map[string]time.Time // Map of Jellyfin User IDs to their expiry times.
 	deprecatedInvites                                                                                                                                                                                                                   Invites
 	deprecatedProfiles                                                                                                                                                                                                                  map[string]Profile
-	deprecatedDisplayprefs, deprecatedOmbiTemplate                                                                                                                                                                                      map[string]interface{}
+	displayprefs, ombi_template                                                                                                                                                                                                         map[string]interface{}
 	deprecatedEmails                                                                                                                                                                                                                    emailStore    // Map of Jellyfin User IDs to Email addresses.
 	deprecatedTelegram                                                                                                                                                                                                                  telegramStore // Map of Jellyfin User IDs to telegram users.
 	deprecatedDiscord                                                                                                                                                                                                                   discordStore  // Map of Jellyfin user IDs to discord users.
 	deprecatedMatrix                                                                                                                                                                                                                    matrixStore   // Map of Jellyfin user IDs to Matrix users.
-	deprecatedPolicy                                                                                                                                                                                                                    mediabrowser.Policy
+	customEmails                                                                                                                                                                                                                        customEmails
-	deprecatedConfiguration                                                                                                                                                                                                             mediabrowser.Configuration
+	userPage                                                                                                                                                                                                                            userPageContent
-	deprecatedAnnouncements                                                                                                                                                                                                             map[string]announcementTemplate
+	policy                                                                                                                                                                                                                              mediabrowser.Policy
-	deprecatedCustomEmails                                                                                                                                                                                                              customEmails
+	configuration                                                                                                                                                                                                                       mediabrowser.Configuration
-	deprecatedUserPageContent                                                                                                                                                                                                           userPageContent
 	lang                                                                                                                                                                                                                                Lang
+	deprecatedAnnouncements                                                                                                                                                                                                             map[string]announcementTemplate
 }
 
 func (app *appContext) ConnectDB() {
@@ -368,49 +368,6 @@ func (st *Storage) GetDefaultProfile() Profile {
 	return defaultProfile
 }
 
-// GetCustomContent returns a copy of the store.
-func (st *Storage) GetCustomContent() []CustomContent {
-	result := []CustomContent{}
-	err := st.db.Find(&result, &badgerhold.Query{})
-	if err != nil {
-		// fmt.Printf("Failed to find custom content: %v\n", err)
-	}
-	return result
-}
-
-// GetCustomContentKey returns the value stored in the store's key.
-func (st *Storage) GetCustomContentKey(k string) (CustomContent, bool) {
-	result := CustomContent{}
-	err := st.db.Get(k, &result)
-	ok := true
-	if err != nil {
-		// fmt.Printf("Failed to find custom content: %v\n", err)
-		ok = false
-	}
-	return result, ok
-}
-
-// MustGetCustomContentKey returns the value stored in the store's key, or an empty value.
-func (st *Storage) MustGetCustomContentKey(k string) CustomContent {
-	result := CustomContent{}
-	st.db.Get(k, &result)
-	return result
-}
-
-// SetCustomContentKey stores value v in key k.
-func (st *Storage) SetCustomContentKey(k string, v CustomContent) {
-	v.Name = k
-	err := st.db.Upsert(k, v)
-	if err != nil {
-		// fmt.Printf("Failed to set custom content: %v\n", err)
-	}
-}
-
-// DeleteCustomContentKey deletes value at key k.
-func (st *Storage) DeleteCustomContentKey(k string) {
-	st.db.Delete(k, CustomContent{})
-}
-
 type TelegramUser struct {
 	JellyfinID string `badgerhold:"key"`
 	ChatID     int64  `badgerhold:"index"`
@@ -438,21 +395,19 @@ type EmailAddress struct {
 }
 
 type customEmails struct {
-	UserCreated       CustomContent `json:"userCreated"`
+	UserCreated       customContent `json:"userCreated"`
-	InviteExpiry      CustomContent `json:"inviteExpiry"`
+	InviteExpiry      customContent `json:"inviteExpiry"`
-	PasswordReset     CustomContent `json:"passwordReset"`
+	PasswordReset     customContent `json:"passwordReset"`
-	UserDeleted       CustomContent `json:"userDeleted"`
+	UserDeleted       customContent `json:"userDeleted"`
-	UserDisabled      CustomContent `json:"userDisabled"`
+	UserDisabled      customContent `json:"userDisabled"`
-	UserEnabled       CustomContent `json:"userEnabled"`
+	UserEnabled       customContent `json:"userEnabled"`
-	InviteEmail       CustomContent `json:"inviteEmail"`
+	InviteEmail       customContent `json:"inviteEmail"`
-	WelcomeEmail      CustomContent `json:"welcomeEmail"`
+	WelcomeEmail      customContent `json:"welcomeEmail"`
-	EmailConfirmation CustomContent `json:"emailConfirmation"`
+	EmailConfirmation customContent `json:"emailConfirmation"`
-	UserExpired       CustomContent `json:"userExpired"`
+	UserExpired       customContent `json:"userExpired"`
 }
 
-// CustomContent stores customized versions of jfa-go content, including emails and user messages.
+type customContent struct {
-type CustomContent struct {
-	Name         string   `json:"name" badgerhold:"key"`
 	Enabled      bool     `json:"enabled,omitempty"`
 	Content      string   `json:"content"`
 	Variables    []string `json:"variables,omitempty"`
@@ -460,8 +415,8 @@ type CustomContent struct {
 }
 
 type userPageContent struct {
-	Login CustomContent `json:"login"`
+	Login customContent `json:"login"`
-	Page  CustomContent `json:"page"`
+	Page  customContent `json:"page"`
 }
 
 // timePattern: %Y-%m-%dT%H:%M:%S.%f
@@ -1242,51 +1197,51 @@ func (st *Storage) storeMatrixUsers() error {
 }
 
 func (st *Storage) loadCustomEmails() error {
-	return loadJSON(st.customEmails_path, &st.deprecatedCustomEmails)
+	return loadJSON(st.customEmails_path, &st.customEmails)
 }
 
 func (st *Storage) storeCustomEmails() error {
-	return storeJSON(st.customEmails_path, st.deprecatedCustomEmails)
+	return storeJSON(st.customEmails_path, st.customEmails)
 }
 
 func (st *Storage) loadUserPageContent() error {
-	return loadJSON(st.userPage_path, &st.deprecatedUserPageContent)
+	return loadJSON(st.userPage_path, &st.userPage)
 }
 
 func (st *Storage) storeUserPageContent() error {
-	return storeJSON(st.userPage_path, st.deprecatedUserPageContent)
+	return storeJSON(st.userPage_path, st.userPage)
 }
 
 func (st *Storage) loadPolicy() error {
-	return loadJSON(st.policy_path, &st.deprecatedPolicy)
+	return loadJSON(st.policy_path, &st.policy)
 }
 
 func (st *Storage) storePolicy() error {
-	return storeJSON(st.policy_path, st.deprecatedPolicy)
+	return storeJSON(st.policy_path, st.policy)
 }
 
 func (st *Storage) loadConfiguration() error {
-	return loadJSON(st.configuration_path, &st.deprecatedConfiguration)
+	return loadJSON(st.configuration_path, &st.configuration)
 }
 
 func (st *Storage) storeConfiguration() error {
-	return storeJSON(st.configuration_path, st.deprecatedConfiguration)
+	return storeJSON(st.configuration_path, st.configuration)
 }
 
 func (st *Storage) loadDisplayprefs() error {
-	return loadJSON(st.displayprefs_path, &st.deprecatedDisplayprefs)
+	return loadJSON(st.displayprefs_path, &st.displayprefs)
 }
 
 func (st *Storage) storeDisplayprefs() error {
-	return storeJSON(st.displayprefs_path, st.deprecatedDisplayprefs)
+	return storeJSON(st.displayprefs_path, st.displayprefs)
 }
 
 func (st *Storage) loadOmbiTemplate() error {
-	return loadJSON(st.ombi_path, &st.deprecatedOmbiTemplate)
+	return loadJSON(st.ombi_path, &st.ombi_template)
 }
 
 func (st *Storage) storeOmbiTemplate() error {
-	return storeJSON(st.ombi_path, st.deprecatedOmbiTemplate)
+	return storeJSON(st.ombi_path, st.ombi_template)
 }
 
 func (st *Storage) loadAnnouncements() error {
@@ -1343,9 +1298,9 @@ func (st *Storage) migrateToProfile() error {
 	st.loadDisplayprefs()
 	st.loadProfiles()
 	st.deprecatedProfiles["Default"] = Profile{
-		Policy:        st.deprecatedPolicy,
+		Policy:        st.policy,
-		Configuration: st.deprecatedConfiguration,
+		Configuration: st.configuration,
-		Displayprefs:  st.deprecatedDisplayprefs,
+		Displayprefs:  st.displayprefs,
 	}
 	return st.storeProfiles()
 }

views.go

@@ -224,13 +224,13 @@ func (app *appContext) MyUserPage(gc *gin.Context) {
 		data["discordInviteLink"] = app.discord.inviteChannelName != ""
 	}
 
-	pageMessagesExist := map[string]bool{}
+	pageMessages := map[string]*customContent{
-	pageMessages := map[string]CustomContent{}
+		"Login": app.getCustomMessage("UserLogin"),
-	pageMessages["Login"], pageMessagesExist["Login"] = app.storage.GetCustomContentKey("UserLogin")
+		"Page":  app.getCustomMessage("UserPage"),
-	pageMessages["Page"], pageMessagesExist["Page"] = app.storage.GetCustomContentKey("UserPage")
+	}
 
 	for name, msg := range pageMessages {
-		if !pageMessagesExist[name] {
+		if msg == nil {
 			continue
 		}
 		data[name+"MessageEnabled"] = msg.Enabled