diff --git a/engine/browser.go b/engine/browser.go
index f63eb434d..4a9f0df06 100644
--- a/engine/browser.go
+++ b/engine/browser.go
@@ -20,7 +20,7 @@ type Browser interface {
 
 func NewBrowser(pr PropertyRepository, fr domain.MediaFolderRepository, ir domain.ArtistIndexRepository,
 	ar domain.ArtistRepository, alr domain.AlbumRepository, mr domain.MediaFileRepository) Browser {
-	return browser{pr, fr, ir, ar, alr, mr}
+	return &browser{pr, fr, ir, ar, alr, mr}
 }
 
 type browser struct {
@@ -32,11 +32,11 @@ type browser struct {
 	mfileRepo  domain.MediaFileRepository
 }
 
-func (b browser) MediaFolders() (domain.MediaFolders, error) {
+func (b *browser) MediaFolders() (domain.MediaFolders, error) {
 	return b.folderRepo.GetAll()
 }
 
-func (b browser) Indexes(ifModifiedSince time.Time) (domain.ArtistIndexes, time.Time, error) {
+func (b *browser) Indexes(ifModifiedSince time.Time) (domain.ArtistIndexes, time.Time, error) {
 	l, err := b.propRepo.DefaultGet(consts.LastScan, "-1")
 	ms, _ := strconv.ParseInt(l, 10, 64)
 	lastModified := utils.ToTime(ms)
@@ -63,23 +63,23 @@ type DirectoryInfo struct {
 	UserRating int
 }
 
-func (c browser) Directory(id string) (*DirectoryInfo, error) {
+func (b *browser) Directory(id string) (*DirectoryInfo, error) {
 	var dir *DirectoryInfo
 	switch {
-	case c.isArtist(id):
+	case b.isArtist(id):
 		beego.Debug("Found Artist with id", id)
-		a, albums, err := c.retrieveArtist(id)
+		a, albums, err := b.retrieveArtist(id)
 		if err != nil {
 			return nil, err
 		}
-		dir = c.buildArtistDir(a, albums)
-	case c.isAlbum(id):
+		dir = b.buildArtistDir(a, albums)
+	case b.isAlbum(id):
 		beego.Debug("Found Album with id", id)
-		al, tracks, err := c.retrieveAlbum(id)
+		al, tracks, err := b.retrieveAlbum(id)
 		if err != nil {
 			return nil, err
 		}
-		dir = c.buildAlbumDir(al, tracks)
+		dir = b.buildAlbumDir(al, tracks)
 	default:
 		beego.Debug("Id", id, "not found")
 		return nil, ErrDataNotFound
@@ -88,7 +88,7 @@ func (c browser) Directory(id string) (*DirectoryInfo, error) {
 	return dir, nil
 }
 
-func (c browser) buildArtistDir(a *domain.Artist, albums domain.Albums) *DirectoryInfo {
+func (b *browser) buildArtistDir(a *domain.Artist, albums domain.Albums) *DirectoryInfo {
 	dir := &DirectoryInfo{Id: a.Id, Name: a.Name}
 
 	dir.Entries = make(Entries, len(albums))
@@ -99,7 +99,7 @@ func (c browser) buildArtistDir(a *domain.Artist, albums domain.Albums) *Directo
 	return dir
 }
 
-func (c browser) buildAlbumDir(al *domain.Album, tracks domain.MediaFiles) *DirectoryInfo {
+func (b *browser) buildAlbumDir(al *domain.Album, tracks domain.MediaFiles) *DirectoryInfo {
 	dir := &DirectoryInfo{
 		Id:         al.Id,
 		Name:       al.Name,
@@ -118,8 +118,8 @@ func (c browser) buildAlbumDir(al *domain.Album, tracks domain.MediaFiles) *Dire
 	return dir
 }
 
-func (c browser) isArtist(id string) bool {
-	found, err := c.artistRepo.Exists(id)
+func (b *browser) isArtist(id string) bool {
+	found, err := b.artistRepo.Exists(id)
 	if err != nil {
 		beego.Debug(fmt.Errorf("Error searching for Artist %s: %v", id, err))
 		return false
@@ -127,8 +127,8 @@ func (c browser) isArtist(id string) bool {
 	return found
 }
 
-func (c browser) isAlbum(id string) bool {
-	found, err := c.albumRepo.Exists(id)
+func (b *browser) isAlbum(id string) bool {
+	found, err := b.albumRepo.Exists(id)
 	if err != nil {
 		beego.Debug(fmt.Errorf("Error searching for Album %s: %v", id, err))
 		return false
@@ -136,27 +136,27 @@ func (c browser) isAlbum(id string) bool {
 	return found
 }
 
-func (c browser) retrieveArtist(id string) (a *domain.Artist, as domain.Albums, err error) {
-	a, err = c.artistRepo.Get(id)
+func (b *browser) retrieveArtist(id string) (a *domain.Artist, as domain.Albums, err error) {
+	a, err = b.artistRepo.Get(id)
 	if err != nil {
 		err = fmt.Errorf("Error reading Artist %s from DB: %v", id, err)
 		return
 	}
 
-	if as, err = c.albumRepo.FindByArtist(id); err != nil {
+	if as, err = b.albumRepo.FindByArtist(id); err != nil {
 		err = fmt.Errorf("Error reading %s's albums from DB: %v", a.Name, err)
 	}
 	return
 }
 
-func (c browser) retrieveAlbum(id string) (al *domain.Album, mfs domain.MediaFiles, err error) {
-	al, err = c.albumRepo.Get(id)
+func (b *browser) retrieveAlbum(id string) (al *domain.Album, mfs domain.MediaFiles, err error) {
+	al, err = b.albumRepo.Get(id)
 	if err != nil {
 		err = fmt.Errorf("Error reading Album %s from DB: %v", id, err)
 		return
 	}
 
-	if mfs, err = c.mfileRepo.FindByAlbum(id); err != nil {
+	if mfs, err = b.mfileRepo.FindByAlbum(id); err != nil {
 		err = fmt.Errorf("Error reading %s's tracks from DB: %v", al.Name, err)
 	}
 	return
diff --git a/engine/cover.go b/engine/cover.go
index db93d9102..8a18affbd 100644
--- a/engine/cover.go
+++ b/engine/cover.go
@@ -23,10 +23,10 @@ type cover struct {
 }
 
 func NewCover(mr domain.MediaFileRepository) Cover {
-	return cover{mr}
+	return &cover{mr}
 }
 
-func (c cover) Get(id string, size int, out io.Writer) error {
+func (c *cover) Get(id string, size int, out io.Writer) error {
 	mf, err := c.mfileRepo.Get(id)
 	if err != nil && err != domain.ErrNotFound {
 		return err
diff --git a/engine/list_generator.go b/engine/list_generator.go
index 952a0cb5f..7114cc7b3 100644
--- a/engine/list_generator.go
+++ b/engine/list_generator.go
@@ -21,7 +21,7 @@ type ListGenerator interface {
 }
 
 func NewListGenerator(alr domain.AlbumRepository, mfr domain.MediaFileRepository, npr NowPlayingRepository) ListGenerator {
-	return listGenerator{alr, mfr, npr}
+	return &listGenerator{alr, mfr, npr}
 }
 
 type listGenerator struct {
@@ -30,7 +30,7 @@ type listGenerator struct {
 	npRepo       NowPlayingRepository
 }
 
-func (g listGenerator) query(qo domain.QueryOptions, offset int, size int) (Entries, error) {
+func (g *listGenerator) query(qo domain.QueryOptions, offset int, size int) (Entries, error) {
 	qo.Offset = offset
 	qo.Size = size
 	albums, err := g.albumRepo.GetAll(qo)
@@ -38,37 +38,37 @@ func (g listGenerator) query(qo domain.QueryOptions, offset int, size int) (Entr
 	return FromAlbums(albums), err
 }
 
-func (g listGenerator) GetNewest(offset int, size int) (Entries, error) {
+func (g *listGenerator) GetNewest(offset int, size int) (Entries, error) {
 	qo := domain.QueryOptions{SortBy: "CreatedAt", Desc: true, Alpha: true}
 	return g.query(qo, offset, size)
 }
 
-func (g listGenerator) GetRecent(offset int, size int) (Entries, error) {
+func (g *listGenerator) GetRecent(offset int, size int) (Entries, error) {
 	qo := domain.QueryOptions{SortBy: "PlayDate", Desc: true, Alpha: true}
 	return g.query(qo, offset, size)
 }
 
-func (g listGenerator) GetFrequent(offset int, size int) (Entries, error) {
+func (g *listGenerator) GetFrequent(offset int, size int) (Entries, error) {
 	qo := domain.QueryOptions{SortBy: "PlayCount", Desc: true}
 	return g.query(qo, offset, size)
 }
 
-func (g listGenerator) GetHighest(offset int, size int) (Entries, error) {
+func (g *listGenerator) GetHighest(offset int, size int) (Entries, error) {
 	qo := domain.QueryOptions{SortBy: "Rating", Desc: true}
 	return g.query(qo, offset, size)
 }
 
-func (g listGenerator) GetByName(offset int, size int) (Entries, error) {
+func (g *listGenerator) GetByName(offset int, size int) (Entries, error) {
 	qo := domain.QueryOptions{SortBy: "Name", Alpha: true}
 	return g.query(qo, offset, size)
 }
 
-func (g listGenerator) GetByArtist(offset int, size int) (Entries, error) {
+func (g *listGenerator) GetByArtist(offset int, size int) (Entries, error) {
 	qo := domain.QueryOptions{SortBy: "Artist", Alpha: true}
 	return g.query(qo, offset, size)
 }
 
-func (g listGenerator) GetRandom(offset int, size int) (Entries, error) {
+func (g *listGenerator) GetRandom(offset int, size int) (Entries, error) {
 	ids, err := g.albumRepo.GetAllIds()
 	if err != nil {
 		return nil, err
@@ -88,7 +88,7 @@ func (g listGenerator) GetRandom(offset int, size int) (Entries, error) {
 	return r, nil
 }
 
-func (g listGenerator) GetStarred(offset int, size int) (Entries, error) {
+func (g *listGenerator) GetStarred(offset int, size int) (Entries, error) {
 	qo := domain.QueryOptions{Offset: offset, Size: size}
 	albums, err := g.albumRepo.GetStarred(qo)
 	if err != nil {
@@ -98,7 +98,7 @@ func (g listGenerator) GetStarred(offset int, size int) (Entries, error) {
 	return FromAlbums(albums), nil
 }
 
-func (g listGenerator) GetNowPlaying() (Entries, error) {
+func (g *listGenerator) GetNowPlaying() (Entries, error) {
 	npInfo, err := g.npRepo.GetAll()
 	if err != nil {
 		return nil, err
diff --git a/engine/playlists.go b/engine/playlists.go
index ebeefe9f6..ede8455d0 100644
--- a/engine/playlists.go
+++ b/engine/playlists.go
@@ -10,7 +10,7 @@ type Playlists interface {
 }
 
 func NewPlaylists(pr domain.PlaylistRepository, mr domain.MediaFileRepository) Playlists {
-	return playlists{pr, mr}
+	return &playlists{pr, mr}
 }
 
 type playlists struct {
@@ -18,7 +18,7 @@ type playlists struct {
 	mfileRepo domain.MediaFileRepository
 }
 
-func (p playlists) GetAll() (domain.Playlists, error) {
+func (p *playlists) GetAll() (domain.Playlists, error) {
 	return p.plsRepo.GetAll(domain.QueryOptions{})
 }
 
@@ -32,7 +32,7 @@ type PlaylistInfo struct {
 	Owner     string
 }
 
-func (p playlists) Get(id string) (*PlaylistInfo, error) {
+func (p *playlists) Get(id string) (*PlaylistInfo, error) {
 	pl, err := p.plsRepo.Get(id)
 	if err == domain.ErrNotFound {
 		return nil, ErrDataNotFound
diff --git a/engine/search.go b/engine/search.go
index 7731e859e..53c3cf301 100644
--- a/engine/search.go
+++ b/engine/search.go
@@ -37,7 +37,7 @@ type search struct {
 }
 
 func NewSearch(ar domain.ArtistRepository, alr domain.AlbumRepository, mr domain.MediaFileRepository, db gomate.DB) Search {
-	s := search{artistRepo: ar, albumRepo: alr, mfileRepo: mr}
+	s := &search{artistRepo: ar, albumRepo: alr, mfileRepo: mr}
 	s.idxArtist = gomate.NewIndexer(db, "gomate-artist-idx")
 	s.sArtist = gomate.NewSearcher(db, "gomate-artist-idx")
 	s.idxAlbum = gomate.NewIndexer(db, "gomate-album-idx")
@@ -47,37 +47,37 @@ func NewSearch(ar domain.ArtistRepository, alr domain.AlbumRepository, mr domain
 	return s
 }
 
-func (s search) ClearAll() error {
+func (s *search) ClearAll() error {
 	return s.idxArtist.Clear()
 	return s.idxAlbum.Clear()
 	return s.idxSong.Clear()
 }
 
-func (s search) IndexArtist(ar *domain.Artist) error {
+func (s *search) IndexArtist(ar *domain.Artist) error {
 	return s.idxArtist.Index(ar.Id, sanitize.Accents(strings.ToLower(ar.Name)))
 }
 
-func (s search) IndexAlbum(al *domain.Album) error {
+func (s *search) IndexAlbum(al *domain.Album) error {
 	return s.idxAlbum.Index(al.Id, sanitize.Accents(strings.ToLower(al.Name)))
 }
 
-func (s search) IndexMediaFile(mf *domain.MediaFile) error {
+func (s *search) IndexMediaFile(mf *domain.MediaFile) error {
 	return s.idxSong.Index(mf.Id, sanitize.Accents(strings.ToLower(mf.Title)))
 }
 
-func (s search) RemoveArtist(ids []string) error {
+func (s *search) RemoveArtist(ids []string) error {
 	return s.idxArtist.Remove(ids...)
 }
 
-func (s search) RemoveAlbum(ids []string) error {
+func (s *search) RemoveAlbum(ids []string) error {
 	return s.idxAlbum.Remove(ids...)
 }
 
-func (s search) RemoveMediaFile(ids []string) error {
+func (s *search) RemoveMediaFile(ids []string) error {
 	return s.idxSong.Remove(ids...)
 }
 
-func (s search) SearchArtist(q string, offset int, size int) (Entries, error) {
+func (s *search) SearchArtist(q string, offset int, size int) (Entries, error) {
 	q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
 	min := offset
 	max := min + size - 1
@@ -98,7 +98,7 @@ func (s search) SearchArtist(q string, offset int, size int) (Entries, error) {
 	return res, nil
 }
 
-func (s search) SearchAlbum(q string, offset int, size int) (Entries, error) {
+func (s *search) SearchAlbum(q string, offset int, size int) (Entries, error) {
 	q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
 	min := offset
 	max := min + size - 1
@@ -119,7 +119,7 @@ func (s search) SearchAlbum(q string, offset int, size int) (Entries, error) {
 	return res, nil
 }
 
-func (s search) SearchSong(q string, offset int, size int) (Entries, error) {
+func (s *search) SearchSong(q string, offset int, size int) (Entries, error) {
 	q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
 	min := offset
 	max := min + size - 1