snapshot of https://github.com/traggo/server.git (master, 2026-09-16; blobs > 131072B omitted)

setting/get.go

@@ -0,0 +1,37 @@
+package setting
+
+import (
+	"context"
+	"time"
+
+	"github.com/jinzhu/gorm"
+	"github.com/traggo/server/auth"
+	"github.com/traggo/server/model"
+)
+
+// Get returns the settings
+func Get(ctx context.Context, db *gorm.DB) (model.UserSetting, error) {
+	internal := model.UserSetting{}
+	user := auth.GetUser(ctx)
+	defaultSettings := model.UserSetting{
+		Theme:              model.ThemeGruvboxDark,
+		DateLocale:         model.DateLocaleAmerican,
+		FirstDayOfTheWeek:  time.Monday.String(),
+		DateTimeInputStyle: model.DateTimeInputFancy,
+	}
+
+	if user == nil {
+		return defaultSettings, nil
+	}
+	find := db.Where(&model.UserSetting{UserID: user.ID}).Find(&internal)
+
+	if find.RecordNotFound() {
+		return defaultSettings, nil
+	}
+
+	if find.Error != nil {
+		return defaultSettings, find.Error
+	}
+
+	return internal, nil
+}

setting/get_test.go

@@ -0,0 +1,47 @@
+package setting
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/traggo/server/model"
+	"github.com/traggo/server/test"
+	"github.com/traggo/server/test/fake"
+)
+
+func TestGet_noUser(t *testing.T) {
+	db := test.InMemoryDB(t)
+	defer db.Close()
+
+	settings, err := Get(context.Background(), db.DB)
+	require.NoError(t, err)
+	require.Equal(t, model.ThemeGruvboxDark, settings.Theme)
+}
+
+func TestGet_user_noSettings(t *testing.T) {
+	db := test.InMemoryDB(t)
+	defer db.Close()
+	db.User(1)
+
+	settings, err := Get(fake.User(1), db.DB)
+	require.NoError(t, err)
+	require.Equal(t, model.ThemeGruvboxDark, settings.Theme)
+}
+
+func TestGet_user(t *testing.T) {
+	db := test.InMemoryDB(t)
+	defer db.Close()
+	db.User(1)
+	db.Save(&model.UserSetting{
+		UserID:            1,
+		Theme:             model.ThemeGruvboxLight,
+		DateLocale:        model.DateLocaleGerman,
+		FirstDayOfTheWeek: time.Sunday.String(),
+	})
+
+	settings, err := Get(fake.User(1), db.DB)
+	require.NoError(t, err)
+	require.Equal(t, model.ThemeGruvboxLight, settings.Theme)
+}

setting/settingresolver.go

@@ -0,0 +1,8 @@
+package setting
+
+import "github.com/jinzhu/gorm"
+
+// ResolverForSettings resolves setting specific things.
+type ResolverForSettings struct {
+	DB *gorm.DB
+}

setting/usersettings.go

@@ -0,0 +1,139 @@
+package setting
+
+import (
+	"context"
+	"time"
+
+	"github.com/traggo/server/auth"
+	"github.com/traggo/server/generated/gqlmodel"
+	"github.com/traggo/server/model"
+)
+
+// SetUserSettings sets the user settings.
+func (r *ResolverForSettings) SetUserSettings(ctx context.Context, settings gqlmodel.InputUserSettings) (*gqlmodel.UserSettings, error) {
+	internal := model.UserSetting{
+		Theme:              toInternalTheme(settings.Theme),
+		FirstDayOfTheWeek:  toInternalWeekday(settings.FirstDayOfTheWeek).String(),
+		UserID:             auth.GetUser(ctx).ID,
+		DateLocale:         toInternalDateLocale(settings.DateLocale),
+		DateTimeInputStyle: toInternalDateTimeInputStyle(settings.DateTimeInputStyle),
+	}
+
+	save := r.DB.Save(internal)
+
+	return toExternal(internal), save.Error
+}
+
+// UserSettings returns the user settings.
+func (r *ResolverForSettings) UserSettings(ctx context.Context) (*gqlmodel.UserSettings, error) {
+	settings, err := Get(ctx, r.DB)
+	return toExternal(settings), err
+}
+
+func toExternal(internal model.UserSetting) *gqlmodel.UserSettings {
+	return &gqlmodel.UserSettings{
+		Theme:              toExternalTheme(internal.Theme),
+		DateLocale:         toExternalDateLocale(internal.DateLocale),
+		FirstDayOfTheWeek:  toExternalWeekday(internal.FirstDayOfTheWeekTimeWeekday()),
+		DateTimeInputStyle: toExternalDateTimeInputStyle(internal.DateTimeInputStyle),
+	}
+}
+
+func toInternalDateLocale(locale gqlmodel.DateLocale) string {
+	switch locale.String() {
+	case model.DateLocaleAmerican, model.DateLocaleGerman, model.DateLocaleAmerican24h, model.DateLocaleAustralian, model.DateLocaleBritish:
+		return locale.String()
+	default:
+		return model.DateLocaleAmerican
+	}
+}
+
+func toExternalDateLocale(dateLocale string) gqlmodel.DateLocale {
+	if gqlmodel.DateLocale(dateLocale).IsValid() {
+		return gqlmodel.DateLocale(dateLocale)
+	}
+	if dateLocale == "English24h" {
+		return gqlmodel.DateLocaleAmerican24h
+	}
+	return gqlmodel.DateLocaleAmerican
+}
+
+func toInternalTheme(theme gqlmodel.Theme) string {
+	switch theme.String() {
+	case model.ThemeGruvboxDark, model.ThemeGruvboxLight, model.ThemeMaterialLight, model.ThemeMaterialDark:
+		return theme.String()
+	default:
+		return model.ThemeGruvboxDark
+	}
+}
+
+func toExternalTheme(theme string) gqlmodel.Theme {
+	if gqlmodel.Theme(theme).IsValid() {
+		return gqlmodel.Theme(theme)
+	}
+	return gqlmodel.ThemeGruvboxDark
+}
+
+func toExternalWeekday(weekday time.Weekday) gqlmodel.WeekDay {
+	switch weekday {
+	case time.Monday:
+		return gqlmodel.WeekDayMonday
+	case time.Tuesday:
+		return gqlmodel.WeekDayTuesday
+	case time.Wednesday:
+		return gqlmodel.WeekDayWednesday
+	case time.Thursday:
+		return gqlmodel.WeekDayThursday
+	case time.Friday:
+		return gqlmodel.WeekDayFriday
+	case time.Saturday:
+		return gqlmodel.WeekDaySaturday
+	case time.Sunday:
+		return gqlmodel.WeekDaySunday
+	default:
+		panic("unknown weekday")
+	}
+}
+
+func toInternalWeekday(weekday gqlmodel.WeekDay) time.Weekday {
+	switch weekday {
+	case gqlmodel.WeekDayMonday:
+		return time.Monday
+	case gqlmodel.WeekDayTuesday:
+		return time.Tuesday
+	case gqlmodel.WeekDayWednesday:
+		return time.Wednesday
+	case gqlmodel.WeekDayThursday:
+		return time.Thursday
+	case gqlmodel.WeekDayFriday:
+		return time.Friday
+	case gqlmodel.WeekDaySaturday:
+		return time.Saturday
+	case gqlmodel.WeekDaySunday:
+		return time.Sunday
+	default:
+		panic("unknown weekday")
+	}
+}
+
+func toExternalDateTimeInputStyle(style string) gqlmodel.DateTimeInputStyle {
+	switch style {
+	case model.DateTimeInputFancy:
+		return gqlmodel.DateTimeInputStyleFancy
+	case model.DateTimeInputNative:
+		return gqlmodel.DateTimeInputStyleNative
+	default:
+		return gqlmodel.DateTimeInputStyleFancy
+	}
+}
+
+func toInternalDateTimeInputStyle(style gqlmodel.DateTimeInputStyle) string {
+	switch style {
+	case gqlmodel.DateTimeInputStyleFancy:
+		return model.DateTimeInputFancy
+	case gqlmodel.DateTimeInputStyleNative:
+		return model.DateTimeInputNative
+	default:
+		return model.DateTimeInputFancy
+	}
+}

setting/usersettings_test.go

@@ -0,0 +1,68 @@
+package setting
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/traggo/server/generated/gqlmodel"
+	"github.com/traggo/server/test"
+	"github.com/traggo/server/test/fake"
+)
+
+const (
+	invalidInternalWeekday = time.Weekday(100)
+	invalidExternalWeekday = gqlmodel.WeekDay("abc")
+)
+
+func TestSettingsResolver(t *testing.T) {
+	db := test.InMemoryDB(t)
+	defer db.Close()
+
+	db.User(1)
+
+	resolver := &ResolverForSettings{DB: db.DB}
+
+	settings, err := resolver.UserSettings(fake.User(1))
+	require.NoError(t, err)
+	require.Equal(t, gqlmodel.ThemeGruvboxDark, settings.Theme)
+
+	_, err = resolver.SetUserSettings(fake.User(1), gqlmodel.InputUserSettings{
+		Theme:              gqlmodel.ThemeGruvboxLight,
+		DateLocale:         gqlmodel.DateLocaleGerman,
+		FirstDayOfTheWeek:  gqlmodel.WeekDayWednesday,
+		DateTimeInputStyle: gqlmodel.DateTimeInputStyleFancy,
+	})
+	require.NoError(t, err)
+
+	settings, err = resolver.UserSettings(fake.User(1))
+	require.NoError(t, err)
+	require.Equal(t, &gqlmodel.UserSettings{
+		Theme:              gqlmodel.ThemeGruvboxLight,
+		DateLocale:         gqlmodel.DateLocaleGerman,
+		FirstDayOfTheWeek:  gqlmodel.WeekDayWednesday,
+		DateTimeInputStyle: gqlmodel.DateTimeInputStyleFancy,
+	}, settings)
+}
+
+func TestWeekDayConvert(t *testing.T) {
+	for _, day := range gqlmodel.AllWeekDay {
+		require.Equal(t, day, toExternalWeekday(toInternalWeekday(day)))
+	}
+	require.Panics(t, func() {
+		toInternalWeekday(invalidExternalWeekday)
+	})
+	require.Panics(t, func() {
+		toExternalWeekday(invalidInternalWeekday)
+	})
+}
+
+func TestShouldHandleInvalidInputs(t *testing.T) {
+	toExternalTheme("aoeuaoeu")
+	toInternalTheme("aoeuaoeu")
+	toExternalDateLocale("aeu")
+	toInternalDateLocale("aoeu")
+	toExternalDateTimeInputStyle("aoeu")
+	toInternalDateTimeInputStyle("aoeu")
+
+}