Create initial user if User table is empty. Also make model.QueryOptions compatible with rest.QueryOptions

persistence/album_repository_test.go

@@ -20,7 +20,7 @@ var _ = Describe("AlbumRepository", func() {
 		})
 
 		It("returns all records sorted", func() {
-			Expect(repo.GetAll(model.QueryOptions{SortBy: "Name"})).To(Equal(model.Albums{
+			Expect(repo.GetAll(model.QueryOptions{Sort: "Name"})).To(Equal(model.Albums{
 				albumAbbeyRoad,
 				albumRadioactivity,
 				albumSgtPeppers,
@@ -28,7 +28,7 @@ var _ = Describe("AlbumRepository", func() {
 		})
 
 		It("returns all records sorted desc", func() {
-			Expect(repo.GetAll(model.QueryOptions{SortBy: "Name", Desc: true})).To(Equal(model.Albums{
+			Expect(repo.GetAll(model.QueryOptions{Sort: "Name", Order: "desc"})).To(Equal(model.Albums{
 				albumSgtPeppers,
 				albumRadioactivity,
 				albumAbbeyRoad,
@@ -36,7 +36,7 @@ var _ = Describe("AlbumRepository", func() {
 		})
 
 		It("paginates the result", func() {
-			Expect(repo.GetAll(model.QueryOptions{Offset: 1, Size: 1})).To(Equal(model.Albums{
+			Expect(repo.GetAll(model.QueryOptions{Offset: 1, Max: 1})).To(Equal(model.Albums{
 				albumAbbeyRoad,
 			}))
 		})

persistence/mock_persistence.go

@@ -49,6 +49,10 @@ func (db *MockDataStore) Property() model.PropertyRepository {
 	return struct{ model.PropertyRepository }{}
 }
 
+func (db *MockDataStore) User() model.UserRepository {
+	return struct{ model.UserRepository }{}
+}
+
 func (db *MockDataStore) WithTx(block func(db model.DataStore) error) error {
 	return block(db)
 }

persistence/persistence.go

@@ -69,8 +69,12 @@ func (db *SQLStore) Property() model.PropertyRepository {
 	return NewPropertyRepository(db.getOrmer())
 }
 
+func (db *SQLStore) User() model.UserRepository {
+	return NewUserRepository(db.getOrmer())
+}
+
 func (db *SQLStore) Resource(model interface{}) model.ResourceRepository {
-	return NewResource(db.getOrmer(), model, mappedModels[model])
+	return NewResource(db.getOrmer(), model, getMappedModel(model))
 }
 
 func (db *SQLStore) WithTx(block func(tx model.DataStore) error) error {
@@ -129,19 +133,31 @@ func collectField(collection interface{}, getValue func(item interface{}) string
 	return result
 }
 
+func getType(myvar interface{}) string {
+	if t := reflect.TypeOf(myvar); t.Kind() == reflect.Ptr {
+		return t.Elem().Name()
+	} else {
+		return t.Name()
+	}
+}
+
 func registerModel(model interface{}, mappedModel interface{}) {
-	mappedModels[model] = mappedModel
+	mappedModels[getType(model)] = mappedModel
 	orm.RegisterModel(mappedModel)
 }
 
+func getMappedModel(model interface{}) interface{} {
+	return mappedModels[getType(model)]
+}
+
 func init() {
 	mappedModels = map[interface{}]interface{}{}
 
-	registerModel(new(model.Artist), new(artist))
-	registerModel(new(model.Album), new(album))
-	registerModel(new(model.MediaFile), new(mediaFile))
-	registerModel(new(model.Property), new(property))
-	registerModel(new(model.Playlist), new(playlist))
+	registerModel(model.Artist{}, new(artist))
+	registerModel(model.Album{}, new(album))
+	registerModel(model.MediaFile{}, new(mediaFile))
+	registerModel(model.Property{}, new(property))
+	registerModel(model.Playlist{}, new(playlist))
 	registerModel(model.User{}, new(user))
 
 	orm.RegisterModel(new(checksum))

persistence/sql_repository.go

@@ -16,14 +16,14 @@ func (r *sqlRepository) newQuery(options ...model.QueryOptions) orm.QuerySeter {
 	if len(options) > 0 {
 		opts := options[0]
 		q = q.Offset(opts.Offset)
-		if opts.Size > 0 {
-			q = q.Limit(opts.Size)
+		if opts.Max > 0 {
+			q = q.Limit(opts.Max)
 		}
-		if opts.SortBy != "" {
-			if opts.Desc {
-				q = q.OrderBy("-" + opts.SortBy)
+		if opts.Sort != "" {
+			if opts.Order == "desc" {
+				q = q.OrderBy("-" + opts.Sort)
 			} else {
-				q = q.OrderBy(opts.SortBy)
+				q = q.OrderBy(opts.Sort)
 			}
 		}
 	}

persistence/user_repository.go

@@ -3,13 +3,15 @@ package persistence
 import (
 	"time"
 
+	"github.com/astaxie/beego/orm"
 	"github.com/cloudsonic/sonic-server/model"
+	"github.com/deluan/rest"
 )
 
 type user struct {
 	ID           string     `json:"id"             orm:"pk;column(id)"`
 	Name         string     `json:"name"           orm:"index"`
-	Password     string     `json:"-"`
+	Password     string     `json:"password"`
 	IsAdmin      bool       `json:"isAdmin"`
 	LastLoginAt  *time.Time `json:"lastLoginAt"    orm:"null"`
 	LastAccessAt *time.Time `json:"lastAccessAt"   orm:"null"`
@@ -17,4 +19,45 @@ type user struct {
 	UpdatedAt    time.Time  `json:"updatedAt"      orm:"auto_now;type(datetime)"`
 }
 
+type userRepository struct {
+	ormer        orm.Ormer
+	userResource model.ResourceRepository
+}
+
+func (r *userRepository) CountAll(qo ...model.QueryOptions) (int64, error) {
+	if len(qo) > 0 {
+		return r.userResource.Count(rest.QueryOptions(qo[0]))
+	}
+	return r.userResource.Count()
+}
+
+func (r *userRepository) Get(id string) (*model.User, error) {
+	u, err := r.userResource.Read(id)
+	if err != nil {
+		return nil, err
+	}
+	res := model.User(u.(user))
+	return &res, nil
+}
+
+func (r *userRepository) Put(u *model.User) error {
+	c, err := r.CountAll()
+	if err != nil {
+		return err
+	}
+	if c == 0 {
+		mappedUser := user(*u)
+		_, err = r.userResource.Save(&mappedUser)
+		return err
+	}
+	return r.userResource.Update(u, "name", "is_admin", "password")
+}
+
+func NewUserRepository(o orm.Ormer) model.UserRepository {
+	r := &userRepository{ormer: o}
+	r.userResource = NewResource(o, model.User{}, new(user))
+	return r
+}
+
 var _ = model.User(user{})
+var _ model.UserRepository = (*userRepository)(nil)