From 499b05da222deff73666f877964d5a92f0f16ac7 Mon Sep 17 00:00:00 2001 From: techknowlogick Date: Mon, 22 Nov 2021 04:47:23 -0500 Subject: [PATCH] Add user settings key/value DB table (#16834) --- cmd/web_https.go | 1 + models/migrations/migrations.go | 2 + models/migrations/v202.go | 25 +++++ models/user.go | 1 + models/user/main_test.go | 2 +- models/user/setting.go | 116 +++++++++++++++++++++ models/user/setting_test.go | 51 +++++++++ modules/avatar/identicon/identicon_test.go | 2 +- 8 files changed, 198 insertions(+), 2 deletions(-) create mode 100644 models/migrations/v202.go create mode 100644 models/user/setting.go create mode 100644 models/user/setting_test.go diff --git a/cmd/web_https.go b/cmd/web_https.go index b939dcab8a..b0910ca040 100644 --- a/cmd/web_https.go +++ b/cmd/web_https.go @@ -13,6 +13,7 @@ import ( "code.gitea.io/gitea/modules/graceful" "code.gitea.io/gitea/modules/log" "code.gitea.io/gitea/modules/setting" + "github.com/klauspost/cpuid/v2" ) diff --git a/models/migrations/migrations.go b/models/migrations/migrations.go index c0d8f111d3..6b7caba897 100644 --- a/models/migrations/migrations.go +++ b/models/migrations/migrations.go @@ -357,6 +357,8 @@ var migrations = []Migration{ NewMigration("Add table app_state", addTableAppState), // v201 -> v202 NewMigration("Drop table remote_version (if exists)", dropTableRemoteVersion), + // v202 -> v203 + NewMigration("Create key/value table for user settings", createUserSettingsTable), } // GetCurrentDBVersion returns the current db version diff --git a/models/migrations/v202.go b/models/migrations/v202.go new file mode 100644 index 0000000000..3e023543e4 --- /dev/null +++ b/models/migrations/v202.go @@ -0,0 +1,25 @@ +// Copyright 2021 The Gitea Authors. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package migrations + +import ( + "fmt" + + "xorm.io/xorm" +) + +func createUserSettingsTable(x *xorm.Engine) error { + type UserSetting struct { + ID int64 `xorm:"pk autoincr"` + UserID int64 `xorm:"index unique(key_userid)"` // to load all of someone's settings + SettingKey string `xorm:"varchar(255) index unique(key_userid)"` // ensure key is always lowercase + SettingValue string `xorm:"text"` + } + if err := x.Sync2(new(UserSetting)); err != nil { + return fmt.Errorf("sync2: %v", err) + } + return nil + +} diff --git a/models/user.go b/models/user.go index 4231597d42..5e3ee3f601 100644 --- a/models/user.go +++ b/models/user.go @@ -1192,6 +1192,7 @@ func DeleteUser(ctx context.Context, u *User) (err error) { &TeamUser{UID: u.ID}, &Collaboration{UserID: u.ID}, &Stopwatch{UserID: u.ID}, + &user_model.Setting{UserID: u.ID}, ); err != nil { return fmt.Errorf("deleteBeans: %v", err) } diff --git a/models/user/main_test.go b/models/user/main_test.go index 7862556a03..925af0e8b2 100644 --- a/models/user/main_test.go +++ b/models/user/main_test.go @@ -1,4 +1,4 @@ -// Copyright 2020 The Gitea Authors. All rights reserved. +// Copyright 2021 The Gitea Authors. All rights reserved. // Use of this source code is governed by a MIT-style // license that can be found in the LICENSE file. diff --git a/models/user/setting.go b/models/user/setting.go new file mode 100644 index 0000000000..c5a3d482b5 --- /dev/null +++ b/models/user/setting.go @@ -0,0 +1,116 @@ +// Copyright 2021 The Gitea Authors. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package user + +import ( + "context" + "fmt" + "strings" + + "code.gitea.io/gitea/models/db" + + "xorm.io/builder" +) + +// Setting is a key value store of user settings +type Setting struct { + ID int64 `xorm:"pk autoincr"` + UserID int64 `xorm:"index unique(key_userid)"` // to load all of someone's settings + SettingKey string `xorm:"varchar(255) index unique(key_userid)"` // ensure key is always lowercase + SettingValue string `xorm:"text"` +} + +// TableName sets the table name for the settings struct +func (s *Setting) TableName() string { + return "user_setting" +} + +func init() { + db.RegisterModel(new(Setting)) +} + +// GetSettings returns specific settings from user +func GetSettings(uid int64, keys []string) (map[string]*Setting, error) { + settings := make([]*Setting, 0, len(keys)) + if err := db.GetEngine(db.DefaultContext). + Where("user_id=?", uid). + And(builder.In("setting_key", keys)). + Find(&settings); err != nil { + return nil, err + } + settingsMap := make(map[string]*Setting) + for _, s := range settings { + settingsMap[s.SettingKey] = s + } + return settingsMap, nil +} + +// GetUserAllSettings returns all settings from user +func GetUserAllSettings(uid int64) (map[string]*Setting, error) { + settings := make([]*Setting, 0, 5) + if err := db.GetEngine(db.DefaultContext). + Where("user_id=?", uid). + Find(&settings); err != nil { + return nil, err + } + settingsMap := make(map[string]*Setting) + for _, s := range settings { + settingsMap[s.SettingKey] = s + } + return settingsMap, nil +} + +// DeleteSetting deletes a specific setting for a user +func DeleteSetting(setting *Setting) error { + _, err := db.GetEngine(db.DefaultContext).Delete(setting) + return err +} + +// SetSetting updates a users' setting for a specific key +func SetSetting(setting *Setting) error { + if strings.ToLower(setting.SettingKey) != setting.SettingKey { + return fmt.Errorf("setting key should be lowercase") + } + return upsertSettingValue(setting.UserID, setting.SettingKey, setting.SettingValue) +} + +func upsertSettingValue(userID int64, key string, value string) error { + return db.WithTx(func(ctx context.Context) error { + e := db.GetEngine(ctx) + + // here we use a general method to do a safe upsert for different databases (and most transaction levels) + // 1. try to UPDATE the record and acquire the transaction write lock + // if UPDATE returns non-zero rows are changed, OK, the setting is saved correctly + // if UPDATE returns "0 rows changed", two possibilities: (a) record doesn't exist (b) value is not changed + // 2. do a SELECT to check if the row exists or not (we already have the transaction lock) + // 3. if the row doesn't exist, do an INSERT (we are still protected by the transaction lock, so it's safe) + // + // to optimize the SELECT in step 2, we can use an extra column like `revision=revision+1` + // to make sure the UPDATE always returns a non-zero value for existing (unchanged) records. + + res, err := e.Exec("UPDATE user_setting SET setting_value=? WHERE setting_key=? AND user_id=?", value, key, userID) + if err != nil { + return err + } + rows, _ := res.RowsAffected() + if rows > 0 { + // the existing row is updated, so we can return + return nil + } + + // in case the value isn't changed, update would return 0 rows changed, so we need this check + has, err := e.Exist(&Setting{UserID: userID, SettingKey: key}) + if err != nil { + return err + } + if has { + return nil + } + + // if no existing row, insert a new row + _, err = e.Insert(&Setting{UserID: userID, SettingKey: key, SettingValue: value}) + return err + }) +} diff --git a/models/user/setting_test.go b/models/user/setting_test.go new file mode 100644 index 0000000000..81445a9f6f --- /dev/null +++ b/models/user/setting_test.go @@ -0,0 +1,51 @@ +// Copyright 2021 The Gitea Authors. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package user + +import ( + "testing" + + "code.gitea.io/gitea/models/unittest" + + "github.com/stretchr/testify/assert" +) + +func TestSettings(t *testing.T) { + keyName := "test_user_setting" + assert.NoError(t, unittest.PrepareTestDatabase()) + + newSetting := &Setting{UserID: 99, SettingKey: keyName, SettingValue: "Gitea User Setting Test"} + + // create setting + err := SetSetting(newSetting) + assert.NoError(t, err) + // test about saving unchanged values + err = SetSetting(newSetting) + assert.NoError(t, err) + + // get specific setting + settings, err := GetSettings(99, []string{keyName}) + assert.NoError(t, err) + assert.Len(t, settings, 1) + assert.EqualValues(t, newSetting.SettingValue, settings[keyName].SettingValue) + + // updated setting + updatedSetting := &Setting{UserID: 99, SettingKey: keyName, SettingValue: "Updated"} + err = SetSetting(updatedSetting) + assert.NoError(t, err) + + // get all settings + settings, err = GetUserAllSettings(99) + assert.NoError(t, err) + assert.Len(t, settings, 1) + assert.EqualValues(t, updatedSetting.SettingValue, settings[updatedSetting.SettingKey].SettingValue) + + // delete setting + err = DeleteSetting(&Setting{UserID: 99, SettingKey: keyName}) + assert.NoError(t, err) + settings, err = GetUserAllSettings(99) + assert.NoError(t, err) + assert.Len(t, settings, 0) +} diff --git a/modules/avatar/identicon/identicon_test.go b/modules/avatar/identicon/identicon_test.go index ab54183a46..ee44c95139 100644 --- a/modules/avatar/identicon/identicon_test.go +++ b/modules/avatar/identicon/identicon_test.go @@ -3,7 +3,7 @@ // license that can be found in the LICENSE file. //go:build test_avatar_identicon -// +build test_avatar_identicon +// +build test_avatar_identicon package identicon