Update translations for playlists

See: https://github.com/lijinke666/react-music-player/issues/90

.dockerignore

@@ -1,8 +1,8 @@
 .DS_Store
 ui/node_modules
-ui/build
 Jamstash-master
 Dockerfile
+docker-compose*.yml
 data
 *.db
 testDB
@@ -10,4 +10,4 @@ navidrome
 navidrome.db
 navidrome.toml
 assets/*gen.go
-dist
+

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Upgrade Prettier to 2.0.4. Reformatted all JS files
+b3f70538a9138bc279a451f4f358605097210d41

.github/workflows/build.yml

@@ -1,53 +0,0 @@
-name: Build
-on: [push]
-jobs:
-  go:
-    name: Test Server on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-# TODO Fix tests in Windows
-#        os: [macOS-latest, ubuntu-latest, windows-latest]
-        os: [macOS-latest, ubuntu-latest]
-
-    steps:
-      - name: Set up Go 1.14
-        uses: actions/setup-go@v1
-        with:
-          go-version: 1.14
-        id: go
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v1
-
-      - name: Download dependencies
-        run: go mod download
-
-      - name: Test
-        run: go test -cover ./... -v
-
-  js:
-    name: Test UI
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v1
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 13
-
-      - name: npm install dependencies
-        run: |
-          cd ui
-          npm ci
-
-# TODO: Enable when there are tests to run
-#      - name: npm test
-#        run: |
-#          cd ui
-#          CI=test npm test
-
-      - name: npm build
-        run: |
-          cd ui
-          npm run build

.github/workflows/docker-tags.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+GIT_TAG="${GITHUB_REF##refs/tags/}"
+GIT_BRANCH="${GITHUB_REF##refs/heads/}"
+GIT_SHA=$(git rev-parse --short HEAD)
+PR_NUM=$(jq --raw-output .pull_request.number "$GITHUB_EVENT_PATH")
+
+DOCKER_IMAGE_TAG="--tag ${DOCKER_IMAGE}:sha-${GIT_SHA}"
+
+if [[ $PR_NUM != "null" ]]; then
+  DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:pr-${PR_NUM}"
+fi
+
+if [[ $GITHUB_REF != "$GIT_TAG" ]]; then
+    DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:${GIT_TAG#v}  --tag ${DOCKER_IMAGE}:latest"
+elif [[ $GITHUB_REF == "refs/heads/master" ]]; then
+    DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:develop"
+elif [[ $GIT_BRANCH = feature/* ]]; then
+    DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:$(echo $GIT_BRANCH | tr / -)"
+fi
+
+echo ${DOCKER_IMAGE_TAG}

.github/workflows/pipeline.dockerfile

@@ -0,0 +1,40 @@
+#####################################################
+### Copy platform specific binary
+FROM bash as copy-binary
+ARG TARGETPLATFORM
+
+RUN echo "Target Platform = ${TARGETPLATFORM}"
+
+COPY dist .
+RUN if [ "$TARGETPLATFORM" = "linux/amd64" ];  then cp navidrome_linux_musl_amd64_linux_amd64/navidrome /navidrome; fi
+RUN if [ "$TARGETPLATFORM" = "linux/arm64" ];  then cp navidrome_linux_arm64_linux_arm64/navidrome /navidrome; fi
+RUN if [ "$TARGETPLATFORM" = "linux/arm/v6" ]; then cp navidrome_linux_arm_linux_arm_6/navidrome /navidrome; fi
+RUN if [ "$TARGETPLATFORM" = "linux/arm/v7" ]; then cp navidrome_linux_arm_linux_arm_7/navidrome /navidrome; fi
+RUN chmod +x /navidrome
+
+
+#####################################################
+### Build Final Image
+FROM alpine as release
+LABEL maintainer="deluan@navidrome.org"
+
+# Install ffmpeg and output build config
+RUN apk add --no-cache ffmpeg
+RUN ffmpeg -buildconf
+
+COPY --from=copy-binary /navidrome /app/
+
+VOLUME ["/data", "/music"]
+ENV ND_MUSICFOLDER /music
+ENV ND_DATAFOLDER /data
+ENV ND_SCANINTERVAL 1m
+ENV ND_TRANSCODINGCACHESIZE 100MB
+ENV ND_SESSIONTIMEOUT 30m
+ENV ND_LOGLEVEL info
+ENV ND_PORT 4533
+
+EXPOSE ${ND_PORT}
+HEALTHCHECK CMD wget -O- http://localhost:${ND_PORT}/ping || exit 1
+WORKDIR /app
+
+ENTRYPOINT ["/app/navidrome"]

.github/workflows/pipeline.yml

@@ -0,0 +1,161 @@
+name: Pipeline
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - "v*"
+  pull_request:
+    branches:
+      - master
+jobs:
+  golangci-lint:
+    name: Lint Server
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v0.1.7
+        with:
+          version: v1.26
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+  go:
+    name: Test Server on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        # TODO Fix tests in Windows
+        #        os: [macOS-latest, ubuntu-latest, windows-latest]
+        os: [macOS-latest, ubuntu-latest]
+
+    steps:
+      - name: Set up Go 1.14
+        uses: actions/setup-go@v1
+        with:
+          go-version: 1.14
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - uses: actions/cache@v1
+        id: cache-go
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Download dependencies
+        if: steps.cache-go.outputs.cache-hit != 'true'
+        run: go mod download
+
+      - name: Test
+        run: go test -cover ./... -v
+  js:
+    name: Build JS bundle
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 13
+
+      - uses: actions/cache@v1
+        id: cache-npm
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('ui/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: npm install dependencies
+        run: |
+          cd ui
+          npm ci
+
+      - name: npm check-formatting
+        run: |
+          cd ui
+          npm run check-formatting
+
+      - name: npm build
+        run: |
+          cd ui
+          npm run build
+
+      - uses: actions/upload-artifact@v1
+        with:
+          name: js-bundle
+          path: ui/build
+
+  binaries:
+    name: Binaries
+    needs: [js, go, golangci-lint]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v2
+
+      - name: Unshallow
+        run: git fetch --prune --unshallow
+
+      - uses: actions/download-artifact@v1
+        with:
+          name: js-bundle
+          path: ui/build
+
+      - name: Run GoReleaser - SNAPSHOT
+        if: startsWith(github.ref, 'refs/tags/') != true
+        uses: docker://deluan/ci-goreleaser:1.14.1-1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          args: goreleaser release --rm-dist --skip-publish --snapshot
+
+      - name: Run GoReleaser - RELEASE
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: docker://deluan/ci-goreleaser:1.14.1-1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          args: goreleaser release --rm-dist
+
+      - uses: actions/upload-artifact@v1
+        with:
+          name: binaries
+          path: dist
+
+  docker:
+    name: Docker images
+    needs: [binaries]
+    runs-on: ubuntu-latest
+    env:
+      DOCKER_IMAGE: ${{secrets.DOCKER_IMAGE}}
+    steps:
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: crazy-max/ghaction-docker-buildx@v1
+        if: env.DOCKER_IMAGE != ''
+        with:
+          buildx-version: latest
+          qemu-version: latest
+
+      - uses: actions/checkout@v1
+        if: env.DOCKER_IMAGE != ''
+
+      - uses: actions/download-artifact@v1
+        if: env.DOCKER_IMAGE != ''
+        with:
+          name: binaries
+          path: dist
+
+      - name: Build the Docker image and push
+        if: env.DOCKER_IMAGE != ''
+        env:
+          DOCKER_IMAGE: ${{secrets.DOCKER_IMAGE}}
+          DOCKER_PLATFORM: linux/amd64,linux/arm/v7,linux/arm64
+        run: |
+          echo ${{secrets.DOCKER_PASSWORD}} | docker login -u ${{secrets.DOCKER_USERNAME}} --password-stdin
+          docker buildx build --platform ${DOCKER_PLATFORM} `.github/workflows/docker-tags.sh` -f .github/workflows/pipeline.dockerfile --push .

.github/workflows/release.yml

@@ -1,32 +0,0 @@
-name: Release
-
-on:
-  create:
-    tags:
-      - v*.*.*
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v1
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 13.10
-      - name: Build UI
-        run: |
-          cd ui
-          npm ci
-          npm run build
-      - name: Fetch tags
-        run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
-      - name: Run GoReleaser
-        uses: docker://bepsays/ci-goreleaser:1.14-1
-
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          args: goreleaser release --rm-dist

.github/workflows/remove-old-artifacts.yml

@@ -0,0 +1,18 @@
+name: Remove old artifacts
+
+on:
+  schedule:
+    # Every day at 1am
+    - cron: '0 1 * * *'
+
+jobs:
+  remove-old-artifacts:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Remove old artifacts
+        uses: c-hive/gha-remove-artifacts@v1
+        with:
+          age: '7 days'
+          skip-tags: false

.gitignore

@@ -9,7 +9,6 @@ vendor/*/
 wiki
 TODO.md
 var
-Artwork
 navidrome.toml
 master.zip
 Jamstash-master
@@ -20,3 +19,7 @@ navidrome.db
 dist
 music
 docker-compose.override.yml
+navidrome.db-shm
+navidrome.db-wal
+tags
+

.golangci.yml

@@ -0,0 +1,29 @@
+linters:
+  enable:
+    - bodyclose
+    - deadcode
+    - dogsled
+    - errcheck
+    - gocyclo
+    - goimports
+    - goprintffuncname
+    - gosec
+    - gosimple
+    - govet
+    - ineffassign
+    - interfacer
+    - misspell
+    - rowserrcheck
+    - staticcheck
+    - structcheck
+    - typecheck
+    - unconvert
+    - unused
+    - varcheck
+    - whitespace
+
+issues:
+  exclude-rules:
+    - linters:
+        - gosec
+      text: "(G501|G401):"

.goreleaser.yml

@@ -1,12 +1,10 @@
 # GoReleaser config
+project_name: navidrome
 
 before:
   hooks:
-    - apt-get update
-    - apt-get install -y gcc-arm-linux-gnueabi gcc-aarch64-linux-gnu
-    - go get -u github.com/go-bindata/go-bindata/...
+    - go-bindata -fs -prefix resources -tags embed -ignore="\\\*.go" -pkg resources -o resources/embedded_gen.go resources/...
     - go-bindata -fs -prefix ui/build -tags embed -nocompress -pkg assets -o assets/embedded_gen.go ui/build/...
-    - git checkout .
 
 builds:
   - id: navidrome_darwin
@@ -21,7 +19,7 @@ builds:
     flags:
       - -tags=embed
     ldflags:
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_linux_amd64
     env:
@@ -34,7 +32,21 @@ builds:
       - -tags=embed
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_linux_musl_amd64
+    env:
+      - CGO_ENABLED=1
+      - CC=musl-gcc
+    goos:
+      - linux
+    goarch:
+      - amd64
+    flags:
+      - -tags=embed
+    ldflags:
+      - "-extldflags '-static'"
+      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_linux_arm
     env:
@@ -51,8 +63,7 @@ builds:
       - -tags=embed
     ldflags:
       - "-extldflags '-static'"
-      - "-extld=$CC"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_linux_arm64
     env:
@@ -66,7 +77,7 @@ builds:
       - -tags=embed
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_windows_i686
     env:
@@ -81,7 +92,7 @@ builds:
       - -tags=embed
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_windows_x64
     env:
@@ -96,10 +107,24 @@ builds:
       - -tags=embed
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
 
 archives:
-  -
+  - id: musl
+    builds:
+      - navidrome_linux_musl_amd64
+    name_template: "{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_musl_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
+    replacements:
+      linux: Linux
+      amd64: x86_64
+  - id: default
+    builds:
+      - navidrome_darwin
+      - navidrome_linux_amd64
+      - navidrome_linux_arm
+      - navidrome_linux_arm64
+      - navidrome_windows_i686
+      - navidrome_windows_x64
     format_overrides:
       - goos: windows
         format: zip
@@ -111,16 +136,16 @@ archives:
       amd64: x86_64
 
 checksum:
-  name_template: '{{ .ProjectName }}_checksums.txt'
+  name_template: "{{ .ProjectName }}_checksums.txt"
 
 snapshot:
-  name_template: "{{ .Tag }}-next"
+  name_template: "{{ .Tag }}-SNAPSHOT"
 
 release:
   draft: true
 
 changelog:
-  sort: asc
+  # sort: asc
   filters:
     exclude:
-      - '^docs:'
+      - "^docs:"

.nvmrc

@@ -1 +1 @@
-v13.10.1
+v13

API_COMPATIBILITY.md

@@ -1,69 +0,0 @@
-
-###  Supported Subsonic API endpoints
-
-Navidrome is currently compatible with [Subsonic API](http://www.subsonic.org/pages/api.jsp) v1.8.0, with some exceptions.
-
-This is an (almost) up to date list of all Subsonic API endpoints implemented by Navidrome. 
-Check the "Notes" column for limitations/missing behaviour. Also keep in mind these differences between 
-Navidrome and Subsonic:
-
-* Right now, Navidrome only works with a single Music Library (Music Folder)
-* Navidrome does not mark songs as played by calls to `stream`, only when 
- `scrobble` is called with `submission=true`
-* Next features to be implemented: Last.FM integration, Jukebox, Sharing, Bookmarks, Podcasts, Internet Radio. 
-
-Navidrome is actively being tested with:
-[DSub](http://www.subsonic.org/pages/apps.jsp#dsub),
-[Music Stash](https://play.google.com/store/apps/details?id=com.ghenry22.mymusicstash) and
-[Jamstash](http://www.subsonic.org/pages/apps.jsp#jamstash))
-
-
-| ENDPOINT               | NOTES |
-|------------------------|-------|
-| _SYSTEM_               ||
-| `ping`                 | |
-| `getLicense`           | Always valid ;) |    
-| ||
-| _BROWSING_             ||
-| `getMusicFolders`      | Hardcoded to just one, set with ND_MUSICFOLDER configuration |
-| `getIndexes`           | Doesn't support shortcuts, nor direct children |
-| `getMusicDirectory`    | |
-| `getSong`              | |
-| `getArtists`           | |
-| `getArtist`            | |
-| `getAlbum`             | |
-| `getGenres`            | |
-| ||
-| _ALBUM/SONGS LISTS_    ||
-| `getAlbumList`         | `byYear` and `byGenre` are not implemented |
-| `getAlbumList2`        | `byYear` and `byGenre` are not implemented |
-| `getStarred`           | |
-| `getStarred2`          | |
-| `getNowPlaying`        | |
-| `getRandomSongs`       | Ignores `fromYear` and `toYear` parameters |
-| ||
-| _SEARCHING_            ||
-| `search2`              | Doesn't support Lucene queries, only simple auto complete queries |
-| `search3`              | Doesn't support Lucene queries, only simple auto complete queries |
-| ||
-| _PLAYLISTS_            ||
-| `getPlaylists`         | `username` parameter is not implemented |
-| `getPlaylist`          | |
-| `createPlaylist`       | Return empty response on success |
-| `updatePlaylist`       | `comment` and `public` are not implemented. All playlists are public |
-| `deletePlaylist`       | |
-| ||
-| _MEDIA RETRIEVAL_      ||
-| `stream`               | |
-| `download`             | |
-| `getCoverArt`          | Only gets embedded artwork |
-| `getAvatar`            | Always returns the same image |
-| ||
-| _MEDIA ANNOTATION_     ||
-| `star`                 | |
-| `unstar`               | |
-| `setRating`            | |
-| `scrobble`             | No Last.FM support yet. It is used to update play count and last played |
-| ||
-| _USER MANAGEMENT_      ||
-| `getUser`              | Hardcoded all roles, ignores `username` parameter|

Dockerfile

@@ -1,6 +1,6 @@
 #####################################################
 ### Build UI bundles
-FROM node:13.10-alpine AS jsbuilder
+FROM node:13-alpine AS jsbuilder
 WORKDIR /src
 COPY ui/package.json ui/package-lock.json ./
 RUN npm ci
@@ -17,11 +17,6 @@ RUN mkdir -p /src/ui/build
 RUN apk add -U --no-cache build-base git
 RUN go get -u github.com/go-bindata/go-bindata/...
 
-# Download and unpack static ffmpeg
-ARG FFMPEG_URL=https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz
-RUN wget -O /tmp/ffmpeg.tar.xz ${FFMPEG_URL}
-RUN cd /tmp && tar xJf ffmpeg.tar.xz && rm ffmpeg.tar.xz
-
 # Download project dependencies
 WORKDIR /src
 COPY go.mod go.sum ./
@@ -40,34 +35,32 @@ RUN GIT_TAG=$(git describe --tags `git rev-list --tags --max-count=1`) && \
     GIT_TAG=${GIT_TAG#"tags/"} && \
     GIT_SHA=$(git rev-parse --short HEAD) && \
     echo "Building version: ${GIT_TAG} (${GIT_SHA})" && \
+    go-bindata -fs -prefix resources -tags embed -ignore="\\\*.go" -pkg resources -o resources/embedded_gen.go resources/...
     go-bindata -fs -prefix ui/build -tags embed -nocompress -pkg assets -o assets/embedded_gen.go ui/build/... && \
     go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=${GIT_SHA} -X github.com/deluan/navidrome/consts.gitTag=${GIT_TAG}" -tags=embed
 
 #####################################################
 ### Build Final Image
 FROM alpine as release
-MAINTAINER  Deluan Quintao <navidrome@deluan.com>
-
-# Download Tini
-ENV TINI_VERSION v0.18.0
-ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini-static /tini
-RUN chmod +x /tini
+LABEL maintainer="deluan@navidrome.org"
 
 COPY --from=gobuilder /src/navidrome /app/
-COPY --from=gobuilder /tmp/ffmpeg*/ffmpeg /usr/bin/
 
-# Check if ffmpeg runs properly
+# Install ffmpeg and output build config
+RUN apk add --no-cache ffmpeg
 RUN ffmpeg -buildconf
 
 VOLUME ["/data", "/music"]
 ENV ND_MUSICFOLDER /music
 ENV ND_DATAFOLDER /data
 ENV ND_SCANINTERVAL 1m
+ENV ND_TRANSCODINGCACHESIZE 100MB
+ENV ND_SESSIONTIMEOUT 30m
 ENV ND_LOGLEVEL info
 ENV ND_PORT 4533
 
-EXPOSE 4533
+EXPOSE ${ND_PORT}
+HEALTHCHECK CMD wget -O- http://localhost:${ND_PORT}/ping || exit 1
 WORKDIR /app
 
-ENTRYPOINT ["/tini", "--"]
-CMD ["/app/navidrome"]
+ENTRYPOINT ["/app/navidrome"]

Makefile

@@ -2,73 +2,93 @@ GO_VERSION=$(shell grep -e "^go " go.mod | cut -f 2 -d ' ')
 NODE_VERSION=$(shell cat .nvmrc)
 
 GIT_SHA=$(shell git rev-parse --short HEAD)
+GIT_TAG=$(shell git describe --tags `git rev-list --tags --max-count=1`)
+
+## Default target just build the Go project.
+default:
+	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=master"
+.PHONY: default
 
-.PHONY: dev
 dev: check_env
-	@goreman -f Procfile.dev -b 4533 start
+	npx foreman -j Procfile.dev -p 4533 start
+.PHONY: dev
 
-.PHONY: server
 server: check_go_env
 	@reflex -d none -c reflex.conf
+.PHONY: server
+
+wire: check_go_env
+	wire ./...
+.PHONY: wire
 
-.PHONY: watch
 watch: check_go_env
 	ginkgo watch -notify ./...
+.PHONY: watch
 
-.PHONY: test
 test: check_go_env
 	go test ./... -v
-#	@(cd ./ui && npm test -- --watchAll=false)
+.PHONY: test
 
-.PHONY: testall
 testall: check_go_env test
 	@(cd ./ui && npm test -- --watchAll=false)
+.PHONY: testall
 
-.PHONY: setup
-setup: Jamstash-master
-	@which goconvey   || (echo "Installing GoConvey" && GO111MODULE=off go get -u github.com/smartystreets/goconvey)
-	@which wire       || (echo "Installing Wire"     && GO111MODULE=off go get -u github.com/google/wire/cmd/wire)
+update-snapshots: check_go_env
+	UPDATE_SNAPSHOTS=true ginkgo ./server/subsonic/...
+.PHONY: update-snapshots
+
+setup:
 	@which go-bindata || (echo "Installing BinData"  && GO111MODULE=off go get -u github.com/go-bindata/go-bindata/...)
-	@which reflex     || (echo "Installing Reflex"   && GO111MODULE=off go get -u github.com/cespare/reflex)
-	@which goreman    || (echo "Installing Goreman"  && GO111MODULE=off go get -u github.com/mattn/goreman)
-	@which ginkgo     || (echo "Installing Ginkgo"   && GO111MODULE=off go get -u github.com/onsi/ginkgo/ginkgo)
-	@which goose      || (echo "Installing Goose"    && GO111MODULE=off go get -u github.com/pressly/goose/cmd/goose)
 	go mod download
 	@(cd ./ui && npm ci)
+.PHONY: setup
 
-.PHONY: static
-static:
-	cd static && go-bindata -fs -prefix "static" -nocompress -ignore="\\\*.go" -pkg static .
+setup-dev: setup
+	@which wire          || (echo "Installing Wire"          && GO111MODULE=off go get -u github.com/google/wire/cmd/wire)
+	@which ginkgo        || (echo "Installing Ginkgo"        && GO111MODULE=off go get -u github.com/onsi/ginkgo/ginkgo)
+	@which goose         || (echo "Installing Goose"         && GO111MODULE=off go get -u github.com/pressly/goose/cmd/goose)
+	@which reflex        || (echo "Installing Reflex"        && GO111MODULE=off go get -u github.com/cespare/reflex)
+	@which golangci-lint || (echo "Installing GolangCI-Lint" && cd .. && GO111MODULE=on go get github.com/golangci/golangci-lint/cmd/golangci-lint@v1.26.0)
+	@which lefthook      || (echo "Installing Lefthook"      && GO111MODULE=off go get -u github.com/Arkweid/lefthook)
+	@lefthook install
+.PHONY: setup
 
 Jamstash-master:
 	wget -N https://github.com/tsquillario/Jamstash/archive/master.zip
 	unzip -o master.zip
 	rm master.zip
+	(cd Jamstash-master && npm ci && npx bower install && npx grunt build)
+	rm -rf Jamstash-master/node_modules Jamstash-master/bower_components
 
-.PHONE: check_env
 check_env: check_go_env check_node_env
+.PHONE: check_env
+
+check_hooks:
+	@lefthook add pre-commit
+	@lefthook add pre-push
+.PHONE: check_hooks
 
-.PHONY: check_go_env
 check_go_env:
 	@(hash go) || (echo "\nERROR: GO environment not setup properly!\n"; exit 1)
 	@go version | grep -q $(GO_VERSION) || (echo "\nERROR: Please upgrade your GO version\nThis project requires version $(GO_VERSION)"; exit 1)
+.PHONY: check_go_env
 
-.PHONY: check_node_env
 check_node_env:
 	@(hash node) || (echo "\nERROR: Node environment not setup properly!\n"; exit 1)
 	@node --version | grep -q $(NODE_VERSION) || (echo "\nERROR: Please check your Node version. Should be $(NODE_VERSION)\n"; exit 1)
+.PHONY: check_node_env
 
-.PHONY: build
 build: check_go_env
-	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=master"
+	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT"
+.PHONY: build
 
-.PHONY: buildall
 buildall: check_env
 	@(cd ./ui && npm run build)
+	go-bindata -fs -prefix "resources" -tags embed -ignore="\\\*.go" -pkg resources -o resources/embedded_gen.go resources/...
 	go-bindata -fs -prefix "ui/build" -tags embed -nocompress -pkg assets -o assets/embedded_gen.go ui/build/...
-	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=master" -tags=embed
+	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT" -tags=embed
+.PHONY: buildall
 
-.PHONY: release
 release:
 	@if [[ ! "${V}" =~ ^[0-9]+\.[0-9]+\.[0-9]+.*$$ ]]; then echo "Usage: make release V=X.X.X"; exit 1; fi
 	go mod tidy
@@ -76,7 +96,8 @@ release:
 	make test
 	git tag v${V}
 	git push origin v${V}
+.PHONY: release
 
-.PHONY: dist
-dist:
-	 docker run -it -v $(PWD):/github/workspace -w /github/workspace bepsays/ci-goreleaser:1.14-1 goreleaser release --rm-dist --skip-publish --snapshot
+snapshot:
+	 docker run -it -v $(PWD):/workspace -w /workspace deluan/ci-goreleaser:1.14.1-1 goreleaser release --rm-dist --skip-publish --snapshot
+.PHONY: snapshot

README.md

@@ -1,153 +1,39 @@
 # Navidrome Music Streamer
 
-[![Build](https://img.shields.io/github/workflow/status/deluan/navidrome/Build?style=for-the-badge)](https://github.com/deluan/navidrome/actions)
-[![Last Release](https://img.shields.io/github/v/release/deluan/navidrome?label=latest&style=for-the-badge)](https://github.com/deluan/navidrome/releases)
-[![Docker Pulls](https://img.shields.io/docker/pulls/deluan/navidrome?style=for-the-badge)](https://hub.docker.com/r/deluan/navidrome)
-[![Join the Chat](https://img.shields.io/discord/671335427726114836?style=for-the-badge)](https://discord.gg/xh7j7yF)
+[![Last Release](https://img.shields.io/github/v/release/deluan/navidrome?label=latest&style=flat-square)](https://github.com/deluan/navidrome/releases)
+[![Build](https://img.shields.io/github/workflow/status/deluan/navidrome/Build?style=flat-square)](https://github.com/deluan/navidrome/actions)
+[![Docker Pulls](https://img.shields.io/docker/pulls/deluan/navidrome?style=flat-square)](https://hub.docker.com/r/deluan/navidrome)
+[![Dev Chat](https://img.shields.io/discord/671335427726114836?label=chat&style=flat-square)](https://discord.gg/xh7j7yF)
+[![Subreddit](https://img.shields.io/reddit/subreddit-subscribers/navidrome?style=flat-square)](https://www.reddit.com/r/navidrome/)
 
 Navidrome is an open source web-based music collection server and streamer. It gives you freedom to listen to your 
 music collection from any browser or mobile device. It's like your personal Spotify!
 
 __Any feedback is welcome!__ If you need/want a new feature, find a bug or think of any way to improve Navidrome, 
-please fill a [GitHub issue](https://github.com/deluan/navidrome/issues) or join the chat in 
-our [Discord server](https://discord.gg/xh7j7yF)
+please fill a [GitHub issue](https://github.com/deluan/navidrome/issues) or join the discussion in our 
+[Subreddit](https://www.reddit.com/r/navidrome/). If you want to contribute to the project in any other way 
+([ui/backend dev](https://www.navidrome.org/docs/developers/), 
+[translations](https://www.navidrome.org/docs/developers/translations/), 
+[themes](https://www.navidrome.org/docs/developers/creating-themes)), please join the chat in our 
+[Discord server](https://discord.gg/xh7j7yF). 
 
+## Documentation
+All documentation can be found in the project's homepage: https://www.navidrome.org/docs. 
+Here are some useful direct links:
 
-## Features
-
-- Handles very large music collections
-- Streams virtually any audio format available
-- Reads and uses all your beautifully curated metadata (id3 tags)
-- Multi-user, each user has their own play counts, playlists, favourites, etc..
-- Very low resource usage: Ex: with a library of 300GB (~29000 songs), it uses less than 50MB of RAM
-- Multi-platform, runs on macOS, Linux and Windows. Docker images are also provided
-- Ready to use Raspberry Pi binaries available
-- Automatically monitors your library for changes, importing new files and reloading new metadata 
-- Modern and responsive Web interface based on Material UI, to manage users and browse your library
-- Compatible with all Subsonic/Madsonic/Airsonic clients. See bellow for a list of tested clients
-- Transcoding/Downsampling on-the-fly. Can be set per user/player. Opus encoding is supported
-- Integrated music player (WIP)
-
-Navidrome should be compatible with all Subsonic clients. The following clients are tested and confirmed to work properly:
-- Android:
-    - [DSub](https://play.google.com/store/apps/details?id=github.daneren2005.dsub)
-    - [Ultrasonic](https://play.google.com/store/apps/details?id=org.moire.ultrasonic)
-    - [Music Stash](https://play.google.com/store/apps/details?id=com.ghenry22.mymusicstash)
-- iOS:
-    - [play:Sub](http://michaelsapps.dk/playsubapp/)
-- Web:
-    - [Jamstash](http://jamstash.com)
-    - [Aurial](http://shrimpza.github.io/aurial/)
-    - [Subfire](http://p.subfireplayer.net/)
-    - [Subplayer](https://github.com/peguerosdc/subplayer)
-    
-For more options, look at the [list of clients](https://airsonic.github.io/docs/apps/) maintained by 
-the Airsonic project. Please open an [issue](https://github.com/deluan/navidrome/issues) if you have any 
-trouble with the client of your choice.
-
-
-## Road map
-
-This project is being actively worked on. Expect a more polished experience and new features/releases 
-on a frequent basis. Some upcoming features planned: 
-
-- Last.FM integration
-- Smart/dynamic playlists (similar to iTunes)
-- Support for audiobooks (bookmarking)
-- Jukebox mode
-- Sharing links to albums/songs/playlists
-- Podcasts
-
-
-## Installation
-
-Various options are available:
-
-### Pre-built executables
-
-Just head to the [releases page](https://github.com/deluan/navidrome/releases) and download the latest version for you 
-platform. There are builds available for Linux (amd64 and arm), macOS and Windows (32 and 64 bits). 
-For Raspberry Pi (tested with Raspbian Buster on Pi 4), use the Linux arm builds.
-
-Remember to install [ffmpeg](https://ffmpeg.org/download.html) in your system, a requirement for Navidrome to work 
-properly. You may find the latest static build for your platform here: https://johnvansickle.com/ffmpeg/ 
-
-If you have any issues with these binaries, or need a binary for a different platform, please 
-[open an issue](https://github.com/deluan/navidrome/issues) 
-
-### Docker
-
-[Docker images](https://hub.docker.com/r/deluan/navidrome) are available. They include everything needed 
-to run Navidrome. Example of usage:
-
-```yaml
-# This is just an example. Customize it to your needs.
-
-version: "3"
-services:
-  navidrome:
-    image: deluan/navidrome:latest
-    ports:
-      - "4533:4533"
-    environment:
-      # All options with their default values:
-      ND_MUSICFOLDER: /music
-      ND_DATAFOLDER: /data
-      ND_SCANINTERVAL: 1m
-      ND_LOGLEVEL: info  
-      ND_PORT: 4533
-      ND_TRANSCODINGCACHESIZE: 100MB
-      ND_SESSIONTIMEOUT: 30m
-    volumes:
-      - "./data:/data"
-      - "/path/to/your/music/folder:/music:ro"
-```
-
-To get the cutting-edge, latest version from master, use the image `deluan/navidrome:develop`
-
-### Build from source
-
-You will need to install [Go 1.14](https://golang.org/dl/) and [Node 13.10.1](http://nodejs.org).
-You'll also need [ffmpeg](https://ffmpeg.org) installed in your system. The setup is very strict, and 
-the steps bellow only work with these specific versions (enforced in the Makefile) 
-
-After the prerequisites above are installed, clone this repository and build the application with:
-
-```shell script
-$ git clone https://github.com/deluan/navidrome
-$ cd navidrome
-$ make setup        # Install tools required for Navidrome's development 
-$ make buildall     # Build UI and server, generates a single executable
-```
-
-This will generate the `navidrome` executable binary in the project's root folder. 
-
-### Running for the first time
-
-Start the server with:
-```shell script
-./navidrome
-```
-The server should start listening for requests on the default port __4533__
-
-After starting Navidrome for the first time, go to http://localhost:4533. It will ask you to create your first admin 
-user.
-
-For more options, run `navidrome --help` 
+- [Overview](https://www.navidrome.org/docs/overview/)
+- [Installation](https://www.navidrome.org/docs/installation/)
+  - [Docker](https://www.navidrome.org/docs/installation/docker/)
+  - [Binaries](https://www.navidrome.org/docs/installation/pre-built-binaries/)
+  - [Build from source](https://www.navidrome.org/docs/installation/build-from-source/)
+- [Development](https://www.navidrome.org/docs/developers/)
+- [Subsonic API Compatibility](https://www.navidrome.org/docs/developers/subsonic-api/)
 
 ## Screenshots
 
-<p align="center">
-<p float="left">
-    <img width="270" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-login.png">
-    <img width="270" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-player.png">
-    <img width="270" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-album-view.png">
-    <img width="900"src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-desktop-player.png">
+<p align="left">
+    <img height="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-login.png">
+    <img height="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-player.png">
+    <img height="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-album-view.png">
+    <img width="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-desktop-player.png">
 </p>
-</p>
-
-
-## Subsonic API Version Compatibility
-
-Check the up to date [compatibility table](https://github.com/deluan/navidrome/blob/master/API_COMPATIBILITY.md) 
-for the latest Subsonic features available.

assets/external.go

@@ -6,7 +6,6 @@ import (
 	"net/http"
 	"sync"
 
-	"github.com/deluan/navidrome/consts"
 	"github.com/deluan/navidrome/log"
 )
 
@@ -14,7 +13,7 @@ var once sync.Once
 
 func AssetFile() http.FileSystem {
 	once.Do(func() {
-		log.Warn("Using external assets from " + consts.UIAssetsLocalPath)
+		log.Warn("Using external assets from 'ui/build' folder")
 	})
-	return http.Dir(consts.UIAssetsLocalPath)
+	return http.Dir("ui/build")
 }

bin/fmt.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-gofmtcmd=`which goimports || echo "gofmt"`
-
-gofiles=$(git diff --name-only --diff-filter=ACM | grep '.go$')
-[ -z "$gofiles" ] && exit 0
-
-unformatted=`$gofmtcmd -l $gofiles`
-[ -z "$unformatted" ] && exit 0
-
-for f in $unformatted; do
-    $gofmtcmd -w -l "$f"
-    gofmt -s -w -l "$f"
-done

bin/pre-commit

@@ -1,28 +0,0 @@
-#!/bin/sh
-# Copyright 2012 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-# git gofmt pre-commit hook
-#
-# To use, store as .git/hooks/pre-commit inside your repository and make sure
-# it has execute permissions.
-#
-# This script does not handle file names that contain spaces.
-
-gofmtcmd=`which goimports || echo "gofmt"`
-
-gofiles=$(git diff --cached --name-only --diff-filter=ACM | grep '.go$')
-[ -z "$gofiles" ] && exit 0
-
-unformatted=$($gofmtcmd -l $gofiles)
-[ -z "$unformatted" ] && exit 0
-
-# Some files are not gofmt'd. Print message and fail.
-
-echo >&2 "Go files must be formatted with $gofmcmd. Please run:"
-for fn in $unformatted; do
-	echo >&2 "  $gofmtcmd -w $PWD/$fn"
-done
-
-exit 1

conf/configuration.go

@@ -13,28 +13,56 @@ import (
 )
 
 type nd struct {
+	ConfigFile     string `default:"./navidrome.toml"`
 	Port           string `default:"4533"`
 	MusicFolder    string `default:"./music"`
 	DataFolder     string `default:"./"`
 	ScanInterval   string `default:"1m"`
 	DbPath         string ``
 	LogLevel       string `default:"info"`
-	SessionTimeout string `default:"30s"`
+	SessionTimeout string `default:"30m"`
+	BaseURL        string `default:""`
+
+	UILoginBackgroundURL string `default:"https://source.unsplash.com/random/1600x900?music"`
 
 	IgnoredArticles string `default:"The El La Los Las Le Les Os As O A"`
 	IndexGroups     string `default:"A B C D E F G H I J K L M N O P Q R S T U V W X-Z(XYZ) [Unknown]([)"`
 
-	TranscodingCacheSize string `default:"100MB"` // in MB
-	ProbeCommand         string `default:"ffmpeg -i %s -f ffmetadata"`
+	EnableTranscodingConfig bool   `default:"false"`
+	TranscodingCacheSize    string `default:"100MB"` // in MB
+	ImageCacheSize          string `default:"100MB"` // in MB
+	ProbeCommand            string `default:"ffmpeg %s -f ffmetadata"`
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
-	DevDisableBanner           bool   `default:"false"`
 	DevLogSourceLine           bool   `default:"false"`
 	DevAutoCreateAdminPassword string `default:""`
+	DevEnableUIPlaylists       bool   `default:"true"`
 }
 
 var Server = &nd{}
 
+// TODO refactor configuration and use something different. Maybe https://github.com/spf13/cobra
+// This function loads the config just load the ConfigFile. This is very cumbersome, but doesn't
+// seem there's a simpler way to do thiswith multiconfig. Time to replace this library?
+func configFile() string {
+	conf := &nd{}
+	loader := multiconfig.MultiLoader(
+		&multiconfig.TagLoader{},
+		&multiconfig.EnvironmentLoader{},
+		&multiconfig.FlagLoader{},
+	)
+	d := &multiconfig.DefaultLoader{}
+	d.Loader = loader
+	d.Validator = multiconfig.MultiValidator(&multiconfig.RequiredValidator{})
+	if err := d.Load(conf); err != nil {
+		return consts.LocalConfigFile
+	}
+	if _, err := os.Stat(conf.ConfigFile); err != nil {
+		return consts.LocalConfigFile
+	}
+	return conf.ConfigFile
+}
+
 func newWithPath(path string, skipFlags ...bool) *multiconfig.DefaultLoader {
 	var loaders []multiconfig.Loader
 
@@ -88,9 +116,9 @@ func LoadFromFile(confFile string, skipFlags ...bool) {
 	}
 	log.SetLevelString(Server.LogLevel)
 	log.SetLogSourceLine(Server.DevLogSourceLine)
-	log.Trace("Loaded configuration", "file", confFile, "config", fmt.Sprintf("%#v", Server))
+	log.Debug("Loaded configuration", "file", confFile, "config", fmt.Sprintf("%#v", Server))
 }
 
 func Load() {
-	LoadFromFile(consts.LocalConfigFile)
+	LoadFromFile(configFile())
 }

consts/banner.go

@@ -3,17 +3,18 @@ package consts
 import (
 	"fmt"
 	"strings"
+	"unicode"
 
-	"github.com/deluan/navidrome/static"
+	"github.com/deluan/navidrome/resources"
 )
 
 func getBanner() string {
-	data, _ := static.Asset("banner.txt")
-	return strings.TrimSuffix(string(data), "\n")
+	data, _ := resources.Asset("banner.txt")
+	return strings.TrimRightFunc(string(data), unicode.IsSpace)
 }
 
 func Banner() string {
 	version := "Version: " + Version()
 	padding := strings.Repeat(" ", 52-len(version))
-	return fmt.Sprintf("%s%s%s\n", getBanner(), padding, version)
+	return fmt.Sprintf("%s\n%s%s\n", getBanner(), padding, version)
 }

consts/consts.go

@@ -1,6 +1,11 @@
 package consts
 
-import "time"
+import (
+	"crypto/md5"
+	"fmt"
+	"strings"
+	"time"
+)
 
 const (
 	AppName = "navidrome"
@@ -9,19 +14,33 @@ const (
 	DefaultDbPath       = "navidrome.db?cache=shared&_busy_timeout=15000&_journal_mode=WAL"
 	InitialSetupFlagKey = "InitialSetup"
 
+	UIAuthorizationHeader = "X-ND-Authorization"
 	JWTSecretKey          = "JWTSecret"
 	JWTIssuer             = "ND"
 	DefaultSessionTimeout = 30 * time.Minute
 
-	UIAssetsLocalPath = "ui/build"
-
-	CacheDir                             = "cache"
-	DefaultTranscodingCacheSize          = 100 * 1024 * 1024 // 100MB
-	DefaultTranscodingCacheMaxItems      = 0                 // Unlimited
-	DefaultTranscodingCachePurgeInterval = 10 * time.Minute
-
 	DevInitialUserName = "admin"
 	DevInitialName     = "Dev Admin"
+
+	URLPathUI          = "/app"
+	URLPathSubsonicAPI = "/rest"
+
+	RequestThrottleBacklogLimit   = 100
+	RequestThrottleBacklogTimeout = time.Minute
+
+	I18nFolder = "i18n"
+)
+
+// Cache options
+const (
+	TranscodingCacheDir             = "cache/transcoding"
+	DefaultTranscodingCacheMaxItems = 0 // Unlimited
+
+	ImageCacheDir             = "cache/images"
+	DefaultImageCacheMaxItems = 0 // Unlimited
+
+	DefaultCacheSize            = 100 * 1024 * 1024 // 100MB
+	DefaultCacheCleanUpInterval = 10 * time.Minute
 )
 
 var (
@@ -30,7 +49,7 @@ var (
 			"name":           "mp3 audio",
 			"targetFormat":   "mp3",
 			"defaultBitRate": 192,
-			"command":        "ffmpeg -i %s -ab %bk -v 0 -f mp3 -",
+			"command":        "ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -f mp3 -",
 		},
 		{
 			"name":           "opus audio",
@@ -40,3 +59,9 @@ var (
 		},
 	}
 )
+
+var (
+	VariousArtists   = "Various Artists"
+	VariousArtistsID = fmt.Sprintf("%x", md5.Sum([]byte(strings.ToLower(VariousArtists))))
+	UnknownArtist    = "[Unknown Artist]"
+)

contrib/navidrome

@@ -0,0 +1,15 @@
+#!/sbin/openrc-run
+  
+name=$RC_SVCNAME
+command="/opt/navidrome/${RC_SVCNAME}"
+command_args="-datafolder /opt/navidrome"
+command_user="${RC_SVCNAME}"
+pidfile="/var/run/${RC_SVCNAME}.pid"
+output_log="/opt/navidrome/${RC_SVCNAME}.log"
+error_log="/opt/navidrome/${RC_SVCNAME}.err"
+command_background="yes"
+
+depend() {
+        need net
+}
+

contrib/navidrome.service

@@ -0,0 +1,45 @@
+# This file ususaly goes in /etc/systemd/system
+
+[Unit]
+Description=Navidrome Music Server and Streamer compatible with Subsonic/Airsonic
+After=remote-fs.target network.target
+AssertPathExists=/var/lib/navidrome
+
+[Service]
+User=navidrome
+Group=navidrome
+Type=simple
+ExecStart=/usr/bin/navidrome
+WorkingDirectory=/var/lib/navidrome
+TimeoutStopSec=20
+KillMode=process
+Restart=on-failure
+
+EnvironmentFile=-/etc/sysconfig/navidrome
+
+# See https://www.freedesktop.org/software/systemd/man/systemd.exec.html
+DevicePolicy=closed
+NoNewPrivileges=yes
+PrivateTmp=yes
+PrivateUsers=yes
+ProtectControlGroups=yes
+ProtectKernelModules=yes
+ProtectKernelTunables=yes
+RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
+RestrictNamespaces=yes
+RestrictRealtime=yes
+SystemCallFilter=~@clock @debug @module @mount @obsolete @privileged @reboot @setuid @swap
+ReadWritePaths=/var/lib/navidrome
+
+# You can uncomment the following line if you're not using the jukebox This
+# will prevent navidrome from accessing any real (physical) devices
+#PrivateDevices=yes
+
+# You can change the following line to `strict` instead of `full` if you don't
+# want navidrome to be able to write anything on your filesystem outside of
+# /var/lib/navidrome.
+ProtectSystem=full
+
+# You can comment the following line if you don't have any media in /home/*.
+# This will prevent navidrome from ever reading/writing anything there.
+ProtectHome=true

db/migration/20200131183653_standardize_item_type.go

@@ -37,7 +37,7 @@ update annotation set item_type = 'media_file' where item_type = 'mediaFile';
 }
 
 func Down20200131183653(tx *sql.Tx) error {
-	tx.Exec(`
+	_, err := tx.Exec(`
 create table search_dg_tmp
 (
 	id varchar(255) not null
@@ -59,5 +59,5 @@ create index search_table
 
 update annotation set item_type = 'mediaFile' where item_type = 'media_file';
 `)
-	return nil
+	return err
 }

db/migration/20200208222418_add_defaults_to_annotations.go

@@ -51,6 +51,5 @@ create index annotation_starred
 }
 
 func Down20200208222418(tx *sql.Tx) error {
-	// This code is executed when the migration is rolled back.
 	return nil
 }

db/migration/20200310171621_enable_search_by_albumartist.go

@@ -16,6 +16,5 @@ func Up20200310171621(tx *sql.Tx) error {
 }
 
 func Down20200310171621(tx *sql.Tx) error {
-	// This code is executed when the migration is rolled back.
 	return nil
 }

db/migration/20200319211049_merge_search_into_main_tables.go

@@ -0,0 +1,41 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200319211049, Down20200319211049)
+}
+
+func Up20200319211049(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table media_file
+	add full_text varchar(255) default '';
+create index if not exists media_file_full_text
+	on media_file (full_text);
+
+alter table album
+	add full_text varchar(255) default '';
+create index if not exists album_full_text
+	on album (full_text);
+
+alter table artist
+	add full_text varchar(255) default '';
+create index if not exists artist_full_text
+	on artist (full_text);
+
+drop table if exists search;
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed!")
+	return forceFullRescan(tx)
+}
+
+func Down20200319211049(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200325185135_add_album_artist_id.go

@@ -0,0 +1,34 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200325185135, Down20200325185135)
+}
+
+func Up20200325185135(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table album
+	add album_artist_id varchar(255) default '';
+create index album_artist_album_id
+	on album (album_artist_id);
+
+alter table media_file
+	add album_artist_id varchar(255) default '';
+create index media_file_artist_album_id
+	on media_file (album_artist_id);
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed!")
+	return forceFullRescan(tx)
+}
+
+func Down20200325185135(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200326090707_fix_album_artists_importing.go

@@ -0,0 +1,20 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200326090707, Down20200326090707)
+}
+
+func Up20200326090707(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed!")
+	return forceFullRescan(tx)
+}
+
+func Down20200326090707(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200327193744_add_year_range_to_album.go

@@ -0,0 +1,80 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200327193744, Down20200327193744)
+}
+
+func Up20200327193744(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table album_dg_tmp
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	artist_id varchar(255) default '' not null,
+	cover_art_path varchar(255) default '' not null,
+	cover_art_id varchar(255) default '' not null,
+	artist varchar(255) default '' not null,
+	album_artist varchar(255) default '' not null,
+    min_year int default 0 not null,
+	max_year integer default 0 not null,
+	compilation bool default FALSE not null,
+	song_count integer default 0 not null,
+	duration real default 0 not null,
+	genre varchar(255) default '' not null,
+	created_at datetime,
+	updated_at datetime,
+	full_text varchar(255) default '',
+	album_artist_id varchar(255) default ''
+);
+
+insert into album_dg_tmp(id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, max_year, compilation, song_count, duration, genre, created_at, updated_at, full_text, album_artist_id) select id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, year, compilation, song_count, duration, genre, created_at, updated_at, full_text, album_artist_id from album;
+
+drop table album;
+
+alter table album_dg_tmp rename to album;
+
+create index album_artist
+	on album (artist);
+
+create index album_artist_album
+	on album (artist);
+
+create index album_artist_album_id
+	on album (album_artist_id);
+
+create index album_artist_id
+	on album (artist_id);
+
+create index album_full_text
+	on album (full_text);
+
+create index album_genre
+	on album (genre);
+
+create index album_name
+	on album (name);
+
+create index album_min_year
+	on album (min_year);
+
+create index album_max_year
+	on album (max_year);
+
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed!")
+	return forceFullRescan(tx)
+}
+
+func Down20200327193744(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200404214704_add_indexes.go

@@ -0,0 +1,29 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200404214704, Down20200404214704)
+}
+
+func Up20200404214704(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create index if not exists media_file_year
+	on media_file (year);
+
+create index if not exists media_file_duration
+	on media_file (duration);
+
+create index if not exists media_file_track_number
+	on media_file (disc_number, track_number);
+`)
+	return err
+}
+
+func Down20200404214704(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200409002249_enable_search_by_tracks_artists.go

@@ -0,0 +1,20 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200409002249, Down20200409002249)
+}
+
+func Up20200409002249(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed to enable search by individual Artist in an Album!")
+	return forceFullRescan(tx)
+}
+
+func Down20200409002249(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200411164603_add_created_and_updated_fields_to_playlists.go

@@ -0,0 +1,27 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200411164603, Down20200411164603)
+}
+
+func Up20200411164603(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table playlist
+	add created_at datetime;
+alter table playlist
+	add updated_at datetime;
+update playlist 
+	set created_at = datetime('now'), updated_at = datetime('now');
+`)
+	return err
+}
+
+func Down20200411164603(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200418110522_reindex_to_fix_album_years.go

@@ -0,0 +1,20 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200418110522, Down20200418110522)
+}
+
+func Up20200418110522(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed to fix search Albums by year")
+	return forceFullRescan(tx)
+}
+
+func Down20200418110522(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200419222708_reindex_to_change_full_text_search.go

@@ -0,0 +1,20 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200419222708, Down20200419222708)
+}
+
+func Up20200419222708(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed to change the search behaviour")
+	return forceFullRescan(tx)
+}
+
+func Down20200419222708(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200423204116_add_sort_fields.go

@@ -0,0 +1,65 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200423204116, Down20200423204116)
+}
+
+func Up20200423204116(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table artist
+	add order_artist_name varchar(255) collate nocase;
+alter table artist
+	add sort_artist_name varchar(255) collate nocase;
+create index if not exists artist_order_artist_name
+	on artist (order_artist_name);
+
+alter table album
+	add order_album_name varchar(255) collate nocase;
+alter table album
+	add order_album_artist_name varchar(255) collate nocase;
+alter table album
+	add sort_album_name varchar(255) collate nocase;
+alter table album
+	add sort_artist_name varchar(255) collate nocase;
+alter table album
+	add sort_album_artist_name varchar(255) collate nocase;
+create index if not exists album_order_album_name
+	on album (order_album_name);
+create index if not exists album_order_album_artist_name
+	on album (order_album_artist_name);
+
+alter table media_file
+	add order_album_name varchar(255) collate nocase;
+alter table media_file
+	add order_album_artist_name varchar(255) collate nocase;
+alter table media_file
+	add order_artist_name varchar(255) collate nocase;
+alter table media_file
+	add sort_album_name varchar(255) collate nocase;
+alter table media_file
+	add sort_artist_name varchar(255) collate nocase;
+alter table media_file
+	add sort_album_artist_name varchar(255) collate nocase;
+alter table media_file
+	add sort_title varchar(255) collate nocase;
+create index if not exists media_file_order_album_name
+	on media_file (order_album_name);
+create index if not exists media_file_order_artist_name
+	on media_file (order_artist_name);
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed to change the search behaviour")
+	return forceFullRescan(tx)
+}
+
+func Down20200423204116(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200508093059_add_artist_song_count.go

@@ -0,0 +1,27 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200508093059, Down20200508093059)
+}
+
+func Up20200508093059(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table artist
+	add song_count integer default 0 not null;
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed to calculate artists' song counts")
+	return forceFullRescan(tx)
+}
+
+func Down20200508093059(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200512104202_add_disc_subtitle.go

@@ -0,0 +1,27 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200512104202, Down20200512104202)
+}
+
+func Up20200512104202(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table media_file 
+    add disc_subtitle varchar(255);
+    `)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed to import disc subtitles")
+	return forceFullRescan(tx)
+}
+
+func Down20200512104202(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200516140647_add_playlist_tracks_table.go

@@ -0,0 +1,100 @@
+package migration
+
+import (
+	"database/sql"
+	"strings"
+
+	"github.com/deluan/navidrome/log"
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200516140647, Down20200516140647)
+}
+
+func Up20200516140647(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table if not exists playlist_tracks
+(
+	id integer default 0 not null, 
+    playlist_id varchar(255) not null, 
+	media_file_id varchar(255) not null
+);
+
+create unique index if not exists playlist_tracks_pos
+	on playlist_tracks (playlist_id, id);
+`)
+	if err != nil {
+		return err
+	}
+	rows, err := tx.Query("select id, tracks from playlist")
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+	var id, tracks string
+	for rows.Next() {
+		err := rows.Scan(&id, &tracks)
+		if err != nil {
+			return err
+		}
+		err = Up20200516140647UpdatePlaylistTracks(tx, id, tracks)
+		if err != nil {
+			return err
+		}
+	}
+	err = rows.Err()
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(`
+create table playlist_dg_tmp
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	comment varchar(255) default '' not null,
+	duration real default 0 not null,
+	song_count integer default 0 not null,
+	owner varchar(255) default '' not null,
+	public bool default FALSE not null,
+	created_at datetime,
+	updated_at datetime
+);
+
+insert into playlist_dg_tmp(id, name, comment, duration, owner, public, created_at, updated_at) 
+	select id, name, comment, duration, owner, public, created_at, updated_at from playlist;
+
+drop table playlist;
+
+alter table playlist_dg_tmp rename to playlist;
+
+create index playlist_name
+	on playlist (name);
+
+update playlist set song_count = (select count(*) from playlist_tracks where playlist_id = playlist.id)
+where id <> ''
+
+`)
+	return err
+}
+
+func Up20200516140647UpdatePlaylistTracks(tx *sql.Tx, id string, tracks string) error {
+	trackList := strings.Split(tracks, ",")
+	stmt, err := tx.Prepare("insert into playlist_tracks (playlist_id, media_file_id, id) values (?, ?, ?)")
+	if err != nil {
+		return err
+	}
+	for i, trackId := range trackList {
+		_, err := stmt.Exec(id, trackId, i)
+		if err != nil {
+			log.Error("Error adding track to playlist", "playlistId", id, "trackId", trackId, err)
+		}
+	}
+	return nil
+}
+
+func Down20200516140647(tx *sql.Tx) error {
+	return nil
+}

docker-compose.yml

@@ -13,6 +13,9 @@ services:
       ND_SCANINTERVAL: 1m
       ND_LOGLEVEL: info
       ND_PORT: 4533
+      ND_TRANSCODINGCACHESIZE: 100MB
+      ND_SESSIONTIMEOUT: 30m
+      ND_BASEURL: ""
     volumes:
       - "./data:/data"
       - "./music:/music"

engine/auth/auth.go

@@ -1,6 +1,7 @@
 package auth
 
 import (
+	"context"
 	"fmt"
 	"sync"
 	"time"
@@ -22,7 +23,7 @@ var (
 
 func InitTokenAuth(ds model.DataStore) {
 	once.Do(func() {
-		secret, err := ds.Property(nil).DefaultGet(consts.JWTSecretKey, "not so secret")
+		secret, err := ds.Property(context.TODO()).DefaultGet(consts.JWTSecretKey, "not so secret")
 		if err != nil {
 			log.Error("No JWT secret found in DB. Setting a temp one, but please report this error", err)
 		}

engine/browser.go

@@ -37,7 +37,7 @@ func (b *browser) MediaFolders(ctx context.Context) (model.MediaFolders, error)
 
 func (b *browser) Indexes(ctx context.Context, mediaFolderId string, ifModifiedSince time.Time) (model.ArtistIndexes, time.Time, error) {
 	// TODO Proper handling of mediaFolderId param
-	folder, err := b.ds.MediaFolder(ctx).Get(mediaFolderId)
+	folder, _ := b.ds.MediaFolder(ctx).Get(mediaFolderId)
 
 	l, err := b.ds.Property(ctx).DefaultGet(model.PropLastScan+"-"+folder.Path, "-1")
 	ms, _ := strconv.ParseInt(l, 10, 64)
@@ -80,10 +80,6 @@ func (b *browser) Artist(ctx context.Context, id string) (*DirectoryInfo, error)
 		return nil, err
 	}
 	log.Debug(ctx, "Found Artist", "id", id, "name", a.Name)
-	var albumIds []string
-	for _, al := range albums {
-		albumIds = append(albumIds, al.ID)
-	}
 	return b.buildArtistDir(a, albums), nil
 }
 
@@ -93,11 +89,6 @@ func (b *browser) Album(ctx context.Context, id string) (*DirectoryInfo, error)
 		return nil, err
 	}
 	log.Debug(ctx, "Found Album", "id", id, "name", al.Name)
-	var mfIds []string
-	for _, mf := range tracks {
-		mfIds = append(mfIds, mf.ID)
-	}
-
 	return b.buildAlbumDir(al, tracks), nil
 }
 
@@ -144,7 +135,8 @@ func (b *browser) buildArtistDir(a *model.Artist, albums model.Albums) *Director
 	}
 
 	dir.Entries = make(Entries, len(albums))
-	for i, al := range albums {
+	for i := range albums {
+		al := albums[i]
 		dir.Entries[i] = FromAlbum(&al)
 		dir.PlayCount += int32(al.PlayCount)
 	}
@@ -155,13 +147,13 @@ func (b *browser) buildAlbumDir(al *model.Album, tracks model.MediaFiles) *Direc
 	dir := &DirectoryInfo{
 		Id:         al.ID,
 		Name:       al.Name,
-		Parent:     al.ArtistID,
-		Artist:     al.Artist,
-		ArtistId:   al.ArtistID,
+		Parent:     al.AlbumArtistID,
+		Artist:     al.AlbumArtist,
+		ArtistId:   al.AlbumArtistID,
 		SongCount:  al.SongCount,
 		Duration:   int(al.Duration),
 		Created:    al.CreatedAt,
-		Year:       al.Year,
+		Year:       al.MaxYear,
 		Genre:      al.Genre,
 		CoverArt:   al.CoverArtId,
 		PlayCount:  int32(al.PlayCount),

engine/common.go

@@ -1,10 +1,13 @@
 package engine
 
 import (
+	"context"
 	"fmt"
 	"time"
 
+	"github.com/deluan/navidrome/consts"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 )
 
 type Entry struct {
@@ -62,15 +65,15 @@ func FromAlbum(al *model.Album) Entry {
 	e.Id = al.ID
 	e.Title = al.Name
 	e.IsDir = true
-	e.Parent = al.ArtistID
+	e.Parent = al.AlbumArtistID
 	e.Album = al.Name
-	e.Year = al.Year
+	e.Year = al.MaxYear
 	e.Artist = al.AlbumArtist
 	e.Genre = al.Genre
 	e.CoverArt = al.CoverArtId
 	e.Created = al.CreatedAt
 	e.AlbumId = al.ID
-	e.ArtistId = al.ArtistID
+	e.ArtistId = al.AlbumArtistID
 	e.Duration = int(al.Duration)
 	e.SongCount = al.SongCount
 	if al.Starred {
@@ -121,7 +124,7 @@ func FromMediaFile(mf *model.MediaFile) Entry {
 func realArtistName(mf *model.MediaFile) string {
 	switch {
 	case mf.Compilation:
-		return "Various Artists"
+		return consts.VariousArtists
 	case mf.AlbumArtist != "":
 		return mf.AlbumArtist
 	}
@@ -131,7 +134,8 @@ func realArtistName(mf *model.MediaFile) string {
 
 func FromAlbums(albums model.Albums) Entries {
 	entries := make(Entries, len(albums))
-	for i, al := range albums {
+	for i := range albums {
+		al := albums[i]
 		entries[i] = FromAlbum(&al)
 	}
 	return entries
@@ -139,7 +143,8 @@ func FromAlbums(albums model.Albums) Entries {
 
 func FromMediaFiles(mfs model.MediaFiles) Entries {
 	entries := make(Entries, len(mfs))
-	for i, mf := range mfs {
+	for i := range mfs {
+		mf := mfs[i]
 		entries[i] = FromMediaFile(&mf)
 	}
 	return entries
@@ -147,8 +152,17 @@ func FromMediaFiles(mfs model.MediaFiles) Entries {
 
 func FromArtists(ars model.Artists) Entries {
 	entries := make(Entries, len(ars))
-	for i, ar := range ars {
+	for i := range ars {
+		ar := ars[i]
 		entries[i] = FromArtist(&ar)
 	}
 	return entries
 }
+
+func userName(ctx context.Context) string {
+	if user, ok := request.UserFrom(ctx); !ok {
+		return "UNKNOWN"
+	} else {
+		return user.UserName
+	}
+}

engine/cover.go

@@ -4,95 +4,155 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"fmt"
 	"image"
 	_ "image/gif"
 	"image/jpeg"
 	_ "image/png"
 	"io"
-	"net/http"
 	"os"
 	"strings"
+	"time"
 
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/consts"
+	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/static"
+	"github.com/deluan/navidrome/resources"
 	"github.com/dhowden/tag"
-	"github.com/nfnt/resize"
+	"github.com/disintegration/imaging"
+	"github.com/djherbis/fscache"
 )
 
 type Cover interface {
 	Get(ctx context.Context, id string, size int, out io.Writer) error
 }
 
+type ImageCache fscache.Cache
+
+func NewCover(ds model.DataStore, cache ImageCache) Cover {
+	return &cover{ds: ds, cache: cache}
+}
+
 type cover struct {
-	ds model.DataStore
-}
-
-func NewCover(ds model.DataStore) Cover {
-	return &cover{ds}
-}
-
-func (c *cover) getCoverPath(ctx context.Context, id string) (string, error) {
-	switch {
-	case strings.HasPrefix(id, "al-"):
-		id = id[3:]
-		al, err := c.ds.Album(ctx).Get(id)
-		if err != nil {
-			return "", err
-		}
-		return al.CoverArtPath, nil
-	default:
-		mf, err := c.ds.MediaFile(ctx).Get(id)
-		if err != nil {
-			return "", err
-		}
-		if mf.HasCoverArt {
-			return mf.Path, nil
-		}
-	}
-	return "", model.ErrNotFound
+	ds    model.DataStore
+	cache fscache.Cache
 }
 
 func (c *cover) Get(ctx context.Context, id string, size int, out io.Writer) error {
-	path, err := c.getCoverPath(ctx, id)
+	id = strings.TrimPrefix(id, "al-")
+	path, lastUpdate, err := c.getCoverPath(ctx, id)
 	if err != nil && err != model.ErrNotFound {
 		return err
 	}
 
-	var reader io.Reader
-
-	if err != model.ErrNotFound {
-		reader, err = readFromTag(path)
-	} else {
-		var f http.File
-		f, err = static.AssetFile().Open("default_cover.jpg")
-		if err == nil {
-			defer f.Close()
-			reader = f
+	// If cache is disabled, just read the coverart directly from file
+	if c.cache == nil {
+		log.Trace(ctx, "Retrieving cover art from file", "path", path, "size", size, err)
+		reader, err := c.getCover(ctx, path, size)
+		if err != nil {
+			log.Error(ctx, "Error loading cover art", "path", path, "size", size, err)
+		} else {
+			_, err = io.Copy(out, reader)
 		}
-	}
-
-	if err != nil {
-		return model.ErrNotFound
-	}
-
-	if size > 0 {
-		return resizeImage(reader, size, out)
-	}
-	_, err = io.Copy(out, reader)
-	return err
-}
-
-func resizeImage(reader io.Reader, size int, out io.Writer) error {
-	img, _, err := image.Decode(reader)
-	if err != nil {
 		return err
 	}
 
-	m := resize.Resize(uint(size), 0, img, resize.NearestNeighbor)
-	return jpeg.Encode(out, m, &jpeg.Options{Quality: 75})
+	cacheKey := imageCacheKey(path, size, lastUpdate)
+	r, w, err := c.cache.Get(cacheKey)
+	if err != nil {
+		log.Error(ctx, "Error reading from image cache", "path", path, "size", size, err)
+		return err
+	}
+	defer r.Close()
+	if w != nil {
+		log.Trace(ctx, "Image cache miss", "path", path, "size", size, "lastUpdate", lastUpdate)
+		go func() {
+			defer w.Close()
+			reader, err := c.getCover(ctx, path, size)
+			if err != nil {
+				log.Error(ctx, "Error loading cover art", "path", path, "size", size, err)
+				return
+			}
+			if _, err := io.Copy(w, reader); err != nil {
+				log.Error(ctx, "Error saving covert art to cache", "path", path, "size", size, err)
+			}
+		}()
+	} else {
+		log.Trace(ctx, "Loading image from cache", "path", path, "size", size, "lastUpdate", lastUpdate)
+	}
+
+	_, err = io.Copy(out, r)
+	return err
 }
 
-func readFromTag(path string) (io.Reader, error) {
+func (c *cover) getCoverPath(ctx context.Context, id string) (path string, lastUpdated time.Time, err error) {
+	var found bool
+	if found, err = c.ds.Album(ctx).Exists(id); err != nil {
+		return
+	}
+	if found {
+		var al *model.Album
+		al, err = c.ds.Album(ctx).Get(id)
+		if err != nil {
+			return
+		}
+		if al.CoverArtId == "" {
+			err = model.ErrNotFound
+			return
+		}
+		id = al.CoverArtId
+	}
+	var mf *model.MediaFile
+	mf, err = c.ds.MediaFile(ctx).Get(id)
+	if err != nil {
+		return
+	}
+	if mf.HasCoverArt {
+		return mf.Path, mf.UpdatedAt, nil
+	}
+	return "", time.Time{}, model.ErrNotFound
+}
+
+func imageCacheKey(path string, size int, lastUpdate time.Time) string {
+	return fmt.Sprintf("%s.%d.%s", path, size, lastUpdate.Format(time.RFC3339Nano))
+}
+
+func (c *cover) getCover(ctx context.Context, path string, size int) (reader io.Reader, err error) {
+	defer func() {
+		if err != nil {
+			log.Warn(ctx, "Error extracting image", "path", path, "size", size, err)
+			reader, err = resources.AssetFile().Open("navidrome-310x310.png")
+		}
+	}()
+	var data []byte
+	data, err = readFromTag(path)
+
+	if err == nil && size > 0 {
+		data, err = resizeImage(bytes.NewReader(data), size)
+	}
+
+	// Confirm the image is valid. Costly, but necessary
+	_, _, err = image.Decode(bytes.NewReader(data))
+	if err == nil {
+		reader = bytes.NewReader(data)
+	}
+
+	return
+}
+
+func resizeImage(reader io.Reader, size int) ([]byte, error) {
+	img, _, err := image.Decode(reader)
+	if err != nil {
+		return nil, err
+	}
+	m := imaging.Resize(img, size, size, imaging.Lanczos)
+	buf := new(bytes.Buffer)
+	err = jpeg.Encode(buf, m, &jpeg.Options{Quality: 75})
+	return buf.Bytes(), err
+}
+
+func readFromTag(path string) ([]byte, error) {
 	f, err := os.Open(path)
 	if err != nil {
 		return nil, err
@@ -106,7 +166,11 @@ func readFromTag(path string) (io.Reader, error) {
 
 	picture := m.Picture()
 	if picture == nil {
-		return nil, errors.New("error extracting art from file " + path)
+		return nil, errors.New("file does not contain embedded art")
 	}
-	return bytes.NewReader(picture.Data), nil
+	return picture.Data, nil
+}
+
+func NewImageCache() (ImageCache, error) {
+	return newFileCache("Image", conf.Server.ImageCacheSize, consts.ImageCacheDir, consts.DefaultImageCacheMaxItems)
 }

engine/cover_test.go

@@ -0,0 +1,126 @@
+package engine
+
+import (
+	"bytes"
+	"context"
+	"image"
+
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/persistence"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Cover", func() {
+	var cover Cover
+	var ds model.DataStore
+	ctx := log.NewContext(context.TODO())
+
+	BeforeEach(func() {
+		ds = &persistence.MockDataStore{MockedTranscoding: &mockTranscodingRepository{}}
+		ds.Album(ctx).(*persistence.MockAlbum).SetData(`[{"id": "222", "coverArtId": "123"}, {"id": "333", "coverArtId": ""}]`)
+		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "hasCoverArt": true, "updatedAt":"2020-04-02T21:29:31.6377Z"}]`)
+	})
+
+	Context("Cache is configured", func() {
+		BeforeEach(func() {
+			cover = NewCover(ds, testCache)
+		})
+
+		It("retrieves the original cover art from an album", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(cover.Get(ctx, "222", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("jpeg"))
+		})
+
+		It("accepts albumIds with 'al-' prefix", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(cover.Get(ctx, "al-222", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("jpeg"))
+		})
+
+		It("returns the default cover if album does not have cover", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(cover.Get(ctx, "333", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("png"))
+		})
+
+		It("returns the default cover if album is not found", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(cover.Get(ctx, "444", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("png"))
+		})
+
+		It("retrieves the original cover art from a media_file", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(cover.Get(ctx, "123", 0, buf)).To(BeNil())
+
+			img, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("jpeg"))
+			Expect(img.Bounds().Size().X).To(Equal(600))
+			Expect(img.Bounds().Size().Y).To(Equal(600))
+		})
+
+		It("resized cover art as requested", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(cover.Get(ctx, "123", 200, buf)).To(BeNil())
+
+			img, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("jpeg"))
+			Expect(img.Bounds().Size().X).To(Equal(200))
+			Expect(img.Bounds().Size().Y).To(Equal(200))
+		})
+
+		Context("Errors", func() {
+			It("returns err if gets error from album table", func() {
+				ds.Album(ctx).(*persistence.MockAlbum).SetError(true)
+				buf := new(bytes.Buffer)
+
+				Expect(cover.Get(ctx, "222", 0, buf)).To(MatchError("Error!"))
+			})
+
+			It("returns err if gets error from media_file table", func() {
+				ds.MediaFile(ctx).(*persistence.MockMediaFile).SetError(true)
+				buf := new(bytes.Buffer)
+
+				Expect(cover.Get(ctx, "123", 0, buf)).To(MatchError("Error!"))
+			})
+		})
+	})
+	Context("Cache is NOT configured", func() {
+		BeforeEach(func() {
+			cover = NewCover(ds, nil)
+		})
+
+		It("retrieves the original cover art from an album", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(cover.Get(ctx, "222", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("jpeg"))
+		})
+	})
+})

engine/engine_suite_test.go

@@ -1,10 +1,13 @@
 package engine
 
 import (
+	"io/ioutil"
+	"os"
 	"testing"
 
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/tests"
+	"github.com/djherbis/fscache"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -15,3 +18,18 @@ func TestEngine(t *testing.T) {
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Engine Suite")
 }
+
+var testCache fscache.Cache
+var testCacheDir string
+
+var _ = Describe("Engine Suite Setup", func() {
+	BeforeSuite(func() {
+		testCacheDir, _ = ioutil.TempDir("", "engine_test_cache")
+		fs, _ := fscache.NewFs(testCacheDir, 0755)
+		testCache, _ = fscache.NewCache(fs, nil)
+	})
+
+	AfterSuite(func() {
+		os.RemoveAll(testCacheDir)
+	})
+})

engine/file_caches.go

@@ -0,0 +1,32 @@
+package engine
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/consts"
+	"github.com/deluan/navidrome/log"
+	"github.com/djherbis/fscache"
+	"github.com/dustin/go-humanize"
+)
+
+func newFileCache(name, cacheSize, cacheFolder string, maxItems int) (fscache.Cache, error) {
+	if cacheSize == "0" {
+		log.Warn(fmt.Sprintf("%s cache disabled", name))
+		return nil, nil
+	}
+	size, err := humanize.ParseBytes(cacheSize)
+	if err != nil {
+		size = consts.DefaultCacheSize
+	}
+	lru := fscache.NewLRUHaunter(maxItems, int64(size), consts.DefaultCacheCleanUpInterval)
+	h := fscache.NewLRUHaunterStrategy(lru)
+	cacheFolder = filepath.Join(conf.Server.DataFolder, cacheFolder)
+	log.Info(fmt.Sprintf("Creating %s cache", name), "path", cacheFolder, "maxSize", humanize.Bytes(size))
+	fs, err := fscache.NewFs(cacheFolder, 0755)
+	if err != nil {
+		return nil, err
+	}
+	return fscache.NewCacheWithHaunter(fs, h)
+}

engine/file_caches_test.go

@@ -0,0 +1,37 @@
+package engine
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/deluan/navidrome/conf"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("File Caches", func() {
+	BeforeEach(func() {
+		conf.Server.DataFolder, _ = ioutil.TempDir("", "file_caches")
+	})
+	AfterEach(func() {
+		os.RemoveAll(conf.Server.DataFolder)
+	})
+
+	Describe("newFileCache", func() {
+		It("creates the cache folder", func() {
+			Expect(newFileCache("test", "1k", "test", 10)).ToNot(BeNil())
+
+			_, err := os.Stat(filepath.Join(conf.Server.DataFolder, "test"))
+			Expect(os.IsNotExist(err)).To(BeFalse())
+		})
+
+		It("creates the cache folder with invalid size", func() {
+			Expect(newFileCache("test", "abc", "test", 10)).ToNot(BeNil())
+		})
+
+		It("returns empty if cache size is '0'", func() {
+			Expect(newFileCache("test", "0", "test", 10)).To(BeNil())
+		})
+	})
+})

engine/list_generator.go

@@ -9,88 +9,108 @@ import (
 )
 
 type ListGenerator interface {
-	GetNewest(ctx context.Context, offset int, size int) (Entries, error)
-	GetRecent(ctx context.Context, offset int, size int) (Entries, error)
-	GetFrequent(ctx context.Context, offset int, size int) (Entries, error)
-	GetHighest(ctx context.Context, offset int, size int) (Entries, error)
-	GetRandom(ctx context.Context, offset int, size int) (Entries, error)
-	GetByName(ctx context.Context, offset int, size int) (Entries, error)
-	GetByArtist(ctx context.Context, offset int, size int) (Entries, error)
-	GetStarred(ctx context.Context, offset int, size int) (Entries, error)
 	GetAllStarred(ctx context.Context) (artists Entries, albums Entries, mediaFiles Entries, err error)
 	GetNowPlaying(ctx context.Context) (Entries, error)
-	GetRandomSongs(ctx context.Context, size int, genre string) (Entries, error)
+	GetSongs(ctx context.Context, offset, size int, filter ListFilter) (Entries, error)
+	GetAlbums(ctx context.Context, offset, size int, filter ListFilter) (Entries, error)
 }
 
 func NewListGenerator(ds model.DataStore, npRepo NowPlayingRepository) ListGenerator {
 	return &listGenerator{ds, npRepo}
 }
 
+type ListFilter model.QueryOptions
+
+func ByNewest() ListFilter {
+	return ListFilter{Sort: "createdAt", Order: "desc"}
+}
+
+func ByRecent() ListFilter {
+	return ListFilter{Sort: "playDate", Order: "desc", Filters: squirrel.Gt{"play_date": time.Time{}}}
+}
+
+func ByFrequent() ListFilter {
+	return ListFilter{Sort: "playCount", Order: "desc", Filters: squirrel.Gt{"play_count": 0}}
+}
+
+func ByRandom() ListFilter {
+	return ListFilter{Sort: "random()"}
+}
+
+func ByName() ListFilter {
+	return ListFilter{Sort: "name"}
+}
+
+func ByArtist() ListFilter {
+	return ListFilter{Sort: "artist"}
+}
+
+func ByStarred() ListFilter {
+	return ListFilter{Sort: "starred_at", Order: "desc", Filters: squirrel.Eq{"starred": true}}
+}
+
+func ByRating() ListFilter {
+	return ListFilter{Sort: "Rating", Order: "desc", Filters: squirrel.Gt{"rating": 0}}
+}
+
+func ByGenre(genre string) ListFilter {
+	return ListFilter{
+		Sort:    "genre asc, name asc",
+		Filters: squirrel.Eq{"genre": genre},
+	}
+}
+
+func ByYear(fromYear, toYear int) ListFilter {
+	return ListFilter{
+		Sort: "max_year, name",
+		Filters: squirrel.Or{
+			squirrel.And{
+				squirrel.GtOrEq{"min_year": fromYear},
+				squirrel.LtOrEq{"min_year": toYear},
+			},
+			squirrel.And{
+				squirrel.GtOrEq{"max_year": fromYear},
+				squirrel.LtOrEq{"max_year": toYear},
+			},
+		},
+	}
+}
+
+func SongsByGenre(genre string) ListFilter {
+	return ListFilter{
+		Sort:    "genre asc, title asc",
+		Filters: squirrel.Eq{"genre": genre},
+	}
+}
+
+func SongsByRandom(genre string, fromYear, toYear int) ListFilter {
+	options := ListFilter{
+		Sort: "random()",
+	}
+	ff := squirrel.And{}
+	if genre != "" {
+		ff = append(ff, squirrel.Eq{"genre": genre})
+	}
+	if fromYear != 0 {
+		ff = append(ff, squirrel.GtOrEq{"year": fromYear})
+	}
+	if toYear != 0 {
+		ff = append(ff, squirrel.LtOrEq{"year": toYear})
+	}
+	options.Filters = ff
+	return options
+}
+
 type listGenerator struct {
 	ds     model.DataStore
 	npRepo NowPlayingRepository
 }
 
-func (g *listGenerator) query(ctx context.Context, qo model.QueryOptions) (Entries, error) {
-	albums, err := g.ds.Album(ctx).GetAll(qo)
-	if err != nil {
-		return nil, err
-	}
-	albumIds := make([]string, len(albums))
-	for i, al := range albums {
-		albumIds[i] = al.ID
-	}
-	return FromAlbums(albums), err
-}
-
-func (g *listGenerator) GetNewest(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "CreatedAt", Order: "desc", Offset: offset, Max: size}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetRecent(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "PlayDate", Order: "desc", Offset: offset, Max: size,
-		Filters: squirrel.Gt{"play_date": time.Time{}}}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetFrequent(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "PlayCount", Order: "desc", Offset: offset, Max: size,
-		Filters: squirrel.Gt{"play_count": 0}}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetHighest(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "Rating", Order: "desc", Offset: offset, Max: size,
-		Filters: squirrel.Gt{"rating": 0}}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetByName(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "Name", Offset: offset, Max: size}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetByArtist(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "Artist", Offset: offset, Max: size}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetRandom(ctx context.Context, offset int, size int) (Entries, error) {
-	albums, err := g.ds.Album(ctx).GetRandom(model.QueryOptions{Max: size, Offset: offset})
-	if err != nil {
-		return nil, err
-	}
-
-	return FromAlbums(albums), nil
-}
-
-func (g *listGenerator) GetRandomSongs(ctx context.Context, size int, genre string) (Entries, error) {
-	options := model.QueryOptions{Max: size}
-	if genre != "" {
-		options.Filters = squirrel.Eq{"genre": genre}
-	}
-	mediaFiles, err := g.ds.MediaFile(ctx).GetRandom(options)
+func (g *listGenerator) GetSongs(ctx context.Context, offset, size int, filter ListFilter) (Entries, error) {
+	qo := model.QueryOptions(filter)
+	qo.Offset = offset
+	qo.Max = size
+	mediaFiles, err := g.ds.MediaFile(ctx).GetAll(qo)
 	if err != nil {
 		return nil, err
 	}
@@ -98,6 +118,18 @@ func (g *listGenerator) GetRandomSongs(ctx context.Context, size int, genre stri
 	return FromMediaFiles(mediaFiles), nil
 }
 
+func (g *listGenerator) GetAlbums(ctx context.Context, offset, size int, filter ListFilter) (Entries, error) {
+	qo := model.QueryOptions(filter)
+	qo.Offset = offset
+	qo.Max = size
+	albums, err := g.ds.Album(ctx).GetAll(qo)
+	if err != nil {
+		return nil, err
+	}
+
+	return FromAlbums(albums), nil
+}
+
 func (g *listGenerator) GetStarred(ctx context.Context, offset int, size int) (Entries, error) {
 	qo := model.QueryOptions{Offset: offset, Max: size, Sort: "starred_at", Order: "desc"}
 	albums, err := g.ds.Album(ctx).GetStarred(qo)
@@ -126,16 +158,6 @@ func (g *listGenerator) GetAllStarred(ctx context.Context) (artists Entries, alb
 		return nil, nil, nil, err
 	}
 
-	var mfIds []string
-	for _, mf := range mfs {
-		mfIds = append(mfIds, mf.ID)
-	}
-
-	var artistIds []string
-	for _, ar := range ars {
-		artistIds = append(artistIds, ar.ID)
-	}
-
 	artists = FromArtists(ars)
 	albums = FromAlbums(als)
 	mediaFiles = FromMediaFiles(mfs)
@@ -156,10 +178,9 @@ func (g *listGenerator) GetNowPlaying(ctx context.Context) (Entries, error) {
 		}
 		entries[i] = FromMediaFile(mf)
 		entries[i].UserName = np.Username
-		entries[i].MinutesAgo = int(time.Now().Sub(np.Start).Minutes())
+		entries[i].MinutesAgo = int(time.Since(np.Start).Minutes())
 		entries[i].PlayerId = np.PlayerId
 		entries[i].PlayerName = np.PlayerName
-
 	}
 	return entries, nil
 }

engine/media_streamer.go

@@ -6,7 +6,6 @@ import (
 	"io"
 	"mime"
 	"os"
-	"path/filepath"
 	"time"
 
 	"github.com/deluan/navidrome/conf"
@@ -14,15 +13,17 @@ import (
 	"github.com/deluan/navidrome/engine/transcoder"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	"github.com/djherbis/fscache"
-	"github.com/dustin/go-humanize"
 )
 
 type MediaStreamer interface {
 	NewStream(ctx context.Context, id string, reqFormat string, reqBitRate int) (*Stream, error)
 }
 
-func NewMediaStreamer(ds model.DataStore, ffm transcoder.Transcoder, cache fscache.Cache) MediaStreamer {
+type TranscodingCache fscache.Cache
+
+func NewMediaStreamer(ds model.DataStore, ffm transcoder.Transcoder, cache TranscodingCache) MediaStreamer {
 	return &mediaStreamer{ds: ds, ffm: ffm, cache: cache}
 }
 
@@ -38,7 +39,14 @@ func (ms *mediaStreamer) NewStream(ctx context.Context, id string, reqFormat str
 		return nil, err
 	}
 
-	format, bitRate := selectTranscodingOptions(ctx, ms.ds, mf, reqFormat, reqBitRate)
+	var format string
+	var bitRate int
+	defer func() {
+		log.Info("Streaming file", "title", mf.Title, "artist", mf.Artist, "format", format,
+			"bitRate", bitRate, "user", userName(ctx), "transcoding", format != "raw", "originalFormat", mf.Suffix)
+	}()
+
+	format, bitRate = selectTranscodingOptions(ctx, ms.ds, mf, reqFormat, reqBitRate)
 	log.Trace(ctx, "Selected transcoding options",
 		"requestBitrate", reqBitRate, "requestFormat", reqFormat,
 		"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix,
@@ -76,7 +84,7 @@ func (ms *mediaStreamer) NewStream(ctx context.Context, id string, reqFormat str
 			log.Error(ctx, "Error loading transcoding command", "format", format, err)
 			return nil, os.ErrInvalid
 		}
-		out, err := ms.ffm.Start(ctx, t.Command, mf.Path, bitRate, format)
+		out, err := ms.ffm.Start(ctx, t.Command, mf.Path, bitRate)
 		if err != nil {
 			log.Error(ctx, "Error starting transcoder", "id", mf.ID, err)
 			return nil, os.ErrInvalid
@@ -138,8 +146,11 @@ type Stream struct {
 func (s *Stream) Seekable() bool      { return s.Seeker != nil }
 func (s *Stream) Duration() float32   { return s.mf.Duration }
 func (s *Stream) ContentType() string { return mime.TypeByExtension("." + s.format) }
-func (s *Stream) Name() string        { return s.mf.Path }
+func (s *Stream) Name() string        { return s.mf.Title + "." + s.format }
 func (s *Stream) ModTime() time.Time  { return s.mf.UpdatedAt }
+func (s *Stream) EstimatedContentLength() int {
+	return int(s.mf.Duration * float32(s.bitRate) / 8 * 1024)
+}
 
 // TODO This function deserves some love (refactoring)
 func selectTranscodingOptions(ctx context.Context, ds model.DataStore, mf *model.MediaFile, reqFormat string, reqBitRate int) (format string, bitRate int) {
@@ -147,7 +158,11 @@ func selectTranscodingOptions(ctx context.Context, ds model.DataStore, mf *model
 	if reqFormat == "raw" {
 		return
 	}
-	trc, hasDefault := ctx.Value("transcoding").(model.Transcoding)
+	if reqFormat == mf.Suffix && reqBitRate == 0 {
+		bitRate = mf.BitRate
+		return
+	}
+	trc, hasDefault := request.TranscodingFrom(ctx)
 	var cFormat string
 	var cBitRate int
 	if reqFormat != "" {
@@ -156,7 +171,7 @@ func selectTranscodingOptions(ctx context.Context, ds model.DataStore, mf *model
 		if hasDefault {
 			cFormat = trc.TargetFormat
 			cBitRate = trc.DefaultBitRate
-			if p, ok := ctx.Value("player").(model.Player); ok {
+			if p, ok := request.PlayerFrom(ctx); ok {
 				cBitRate = p.MaxBitRate
 			}
 		}
@@ -176,7 +191,7 @@ func selectTranscodingOptions(ctx context.Context, ds model.DataStore, mf *model
 			bitRate = t.DefaultBitRate
 		}
 	}
-	if format == mf.Suffix && bitRate > mf.BitRate {
+	if format == mf.Suffix && bitRate >= mf.BitRate {
 		format = "raw"
 		bitRate = 0
 	}
@@ -198,19 +213,6 @@ func getFinalCachedSize(r fscache.ReadAtCloser) int64 {
 	return -1
 }
 
-func NewTranscodingCache() (fscache.Cache, error) {
-	cacheSize, err := humanize.ParseBytes(conf.Server.TranscodingCacheSize)
-	if err != nil {
-		cacheSize = consts.DefaultTranscodingCacheSize
-	}
-	lru := fscache.NewLRUHaunter(consts.DefaultTranscodingCacheMaxItems, int64(cacheSize), consts.DefaultTranscodingCachePurgeInterval)
-	h := fscache.NewLRUHaunterStrategy(lru)
-	cacheFolder := filepath.Join(conf.Server.DataFolder, consts.CacheDir)
-	log.Info("Creating transcoding cache", "path", cacheFolder, "maxSize", humanize.Bytes(cacheSize),
-		"cleanUpInterval", consts.DefaultTranscodingCachePurgeInterval)
-	fs, err := fscache.NewFs(cacheFolder, 0755)
-	if err != nil {
-		return nil, err
-	}
-	return fscache.NewCacheWithHaunter(fs, h)
+func NewTranscodingCache() (TranscodingCache, error) {
+	return newFileCache("Transcoding", conf.Server.TranscodingCacheSize, consts.TranscodingCacheDir, consts.DefaultTranscodingCacheMaxItems)
 }

engine/media_streamer_test.go

@@ -3,14 +3,12 @@ package engine
 import (
 	"context"
 	"io"
-	"io/ioutil"
-	"os"
 	"strings"
 
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	"github.com/deluan/navidrome/persistence"
-	"github.com/djherbis/fscache"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -18,25 +16,13 @@ import (
 var _ = Describe("MediaStreamer", func() {
 	var streamer MediaStreamer
 	var ds model.DataStore
-	var cache fscache.Cache
-	var tempDir string
 	ffmpeg := &fakeFFmpeg{Data: "fake data"}
-	ctx := log.NewContext(nil)
-
-	BeforeSuite(func() {
-		tempDir, _ = ioutil.TempDir("", "stream_tests")
-		fs, _ := fscache.NewFs(tempDir, 0755)
-		cache, _ = fscache.NewCache(fs, nil)
-	})
+	ctx := log.NewContext(context.TODO())
 
 	BeforeEach(func() {
 		ds = &persistence.MockDataStore{MockedTranscoding: &mockTranscodingRepository{}}
-		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "suffix": "mp3", "bitRate": 128, "duration": 257.0}]`, 1)
-		streamer = NewMediaStreamer(ds, ffmpeg, cache)
-	})
-
-	AfterSuite(func() {
-		os.RemoveAll(tempDir)
+		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "suffix": "mp3", "bitRate": 128, "duration": 257.0}]`)
+		streamer = NewMediaStreamer(ds, ffmpeg, testCache)
 	})
 
 	Context("NewStream", func() {
@@ -104,12 +90,19 @@ var _ = Describe("MediaStreamer", func() {
 				Expect(format).To(Equal("mp3"))
 				Expect(bitRate).To(Equal(192))
 			})
+			It("returns raw if requested format is the same as the original, but requested BitRate is 0", func() {
+				mf.Suffix = "mp3"
+				mf.BitRate = 320
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0)
+				Expect(format).To(Equal("raw"))
+				Expect(bitRate).To(Equal(320))
+			})
 		})
 
 		Context("player has format configured", func() {
 			BeforeEach(func() {
 				t := model.Transcoding{ID: "oga1", TargetFormat: "oga", DefaultBitRate: 96}
-				ctx = context.WithValue(ctx, "transcoding", t)
+				ctx = request.WithTranscoding(ctx, t)
 			})
 			It("returns raw if raw is requested", func() {
 				mf.Suffix = "flac"
@@ -138,13 +131,20 @@ var _ = Describe("MediaStreamer", func() {
 				Expect(format).To(Equal("oga"))
 				Expect(bitRate).To(Equal(80))
 			})
+			It("returns raw if selected bitrate and format is the same as original", func() {
+				mf.Suffix = "mp3"
+				mf.BitRate = 192
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 192)
+				Expect(format).To(Equal("raw"))
+				Expect(bitRate).To(Equal(0))
+			})
 		})
 		Context("player has maxBitRate configured", func() {
 			BeforeEach(func() {
 				t := model.Transcoding{ID: "oga1", TargetFormat: "oga", DefaultBitRate: 96}
 				p := model.Player{ID: "player1", TranscodingId: t.ID, MaxBitRate: 80}
-				ctx = context.WithValue(ctx, "transcoding", t)
-				ctx = context.WithValue(ctx, "player", p)
+				ctx = request.WithTranscoding(ctx, t)
+				ctx = request.WithPlayer(ctx, p)
 			})
 			It("returns raw if raw is requested", func() {
 				mf.Suffix = "flac"
@@ -183,7 +183,7 @@ type fakeFFmpeg struct {
 	closed bool
 }
 
-func (ff *fakeFFmpeg) Start(ctx context.Context, cmd, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
+func (ff *fakeFFmpeg) Start(ctx context.Context, cmd, path string, maxBitRate int) (f io.ReadCloser, err error) {
 	ff.r = strings.NewReader(ff.Data)
 	return ff, nil
 }

engine/mock_nowplaying_repo.go

@@ -1,86 +0,0 @@
-package engine
-
-import (
-	"errors"
-	"time"
-)
-
-func CreateMockNowPlayingRepo() *MockNowPlaying {
-	return &MockNowPlaying{}
-}
-
-type MockNowPlaying struct {
-	NowPlayingRepository
-	data []NowPlayingInfo
-	t    time.Time
-	err  bool
-}
-
-func (m *MockNowPlaying) SetError(err bool) {
-	m.err = err
-}
-
-func (m *MockNowPlaying) Enqueue(info *NowPlayingInfo) error {
-	if m.err {
-		return errors.New("Error!")
-	}
-
-	m.data = append(m.data, NowPlayingInfo{})
-	copy(m.data[1:], m.data[0:])
-	m.data[0] = *info
-
-	if !m.t.IsZero() {
-		m.data[0].Start = m.t
-		m.t = time.Time{}
-	}
-
-	return nil
-}
-
-func (m *MockNowPlaying) Dequeue(playerId int) (*NowPlayingInfo, error) {
-	if len(m.data) == 0 {
-		return nil, nil
-	}
-	l := len(m.data)
-	info := m.data[l-1]
-	m.data = m.data[:l-1]
-
-	return &info, nil
-}
-
-func (m *MockNowPlaying) Count(playerId int) (int64, error) {
-	return int64(len(m.data)), nil
-}
-
-func (m *MockNowPlaying) GetAll() ([]*NowPlayingInfo, error) {
-	np, err := m.Head(1)
-	if np == nil || err != nil {
-		return nil, err
-	}
-	return []*NowPlayingInfo{np}, err
-}
-
-func (m *MockNowPlaying) Head(playerId int) (*NowPlayingInfo, error) {
-	if len(m.data) == 0 {
-		return nil, nil
-	}
-	info := m.data[0]
-	return &info, nil
-}
-
-func (m *MockNowPlaying) Tail(playerId int) (*NowPlayingInfo, error) {
-	if len(m.data) == 0 {
-		return nil, nil
-	}
-	info := m.data[len(m.data)-1]
-	return &info, nil
-}
-
-func (m *MockNowPlaying) ClearAll() {
-	m.data = make([]NowPlayingInfo, 0)
-	m.err = false
-}
-
-func (m *MockNowPlaying) OverrideNow(t time.Time) {
-	m.t = t
-}

engine/mock_property_repo.go

@@ -1,46 +0,0 @@
-package engine
-
-import (
-	"errors"
-
-	"github.com/deluan/navidrome/model"
-)
-
-func CreateMockPropertyRepo() *MockProperty {
-	return &MockProperty{data: make(map[string]string)}
-}
-
-type MockProperty struct {
-	model.PropertyRepository
-	data map[string]string
-	err  bool
-}
-
-func (m *MockProperty) SetError(err bool) {
-	m.err = err
-}
-
-func (m *MockProperty) Put(id string, value string) error {
-	if m.err {
-		return errors.New("Error!")
-	}
-	m.data[id] = value
-	return nil
-}
-
-func (m *MockProperty) Get(id string) (string, error) {
-	if m.err {
-		return "", errors.New("Error!")
-	}
-	return m.data[id], nil
-}
-
-func (m *MockProperty) DefaultGet(id string, defaultValue string) (string, error) {
-	v, err := m.Get(id)
-
-	if v == "" {
-		v = defaultValue
-	}
-
-	return v, err
-}

engine/nowplaying.go

@@ -110,7 +110,7 @@ func checkExpired(l *list.List, f func() *list.Element) *list.Element {
 			return nil
 		}
 		start := e.Value.(*NowPlayingInfo).Start
-		if time.Now().Sub(start) < NowPlayingExpire {
+		if time.Since(start) < NowPlayingExpire {
 			return e
 		}
 		l.Remove(e)

engine/players.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	"github.com/google/uuid"
 )
 
@@ -27,7 +28,7 @@ func (p *players) Register(ctx context.Context, id, client, typ, ip string) (*mo
 	var plr *model.Player
 	var trc *model.Transcoding
 	var err error
-	userName := ctx.Value("username").(string)
+	userName, _ := request.UsernameFrom(ctx)
 	if id != "" {
 		plr, err = p.ds.Player(ctx).Get(id)
 		if err == nil && plr.Client != client {

engine/players_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	"github.com/deluan/navidrome/persistence"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -14,8 +15,9 @@ import (
 var _ = Describe("Players", func() {
 	var players Players
 	var repo *mockPlayerRepository
-	ctx := context.WithValue(log.NewContext(nil), "user", model.User{ID: "userid", UserName: "johndoe"})
-	ctx = context.WithValue(ctx, "username", "johndoe")
+	ctx := log.NewContext(context.TODO())
+	ctx = request.WithUser(ctx, model.User{ID: "userid", UserName: "johndoe"})
+	ctx = request.WithUsername(ctx, "johndoe")
 	var beforeRegister time.Time
 
 	BeforeEach(func() {

engine/playlists.go

@@ -2,8 +2,10 @@ package engine
 
 import (
 	"context"
+	"time"
 
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	"github.com/deluan/navidrome/utils"
 )
 
@@ -24,34 +26,37 @@ type playlists struct {
 }
 
 func (p *playlists) Create(ctx context.Context, playlistId, name string, ids []string) error {
-	owner := p.getUser(ctx)
-	var pls *model.Playlist
-	var err error
-	// If playlistID is present, override tracks
-	if playlistId != "" {
-		pls, err = p.ds.Playlist(ctx).Get(playlistId)
-		if err != nil {
-			return err
-		}
-		if owner != pls.Owner {
-			return model.ErrNotAuthorized
-		}
-		pls.Tracks = nil
-	} else {
-		pls = &model.Playlist{
-			Name:  name,
-			Owner: owner,
-		}
-	}
-	for _, id := range ids {
-		pls.Tracks = append(pls.Tracks, model.MediaFile{ID: id})
-	}
+	return p.ds.WithTx(func(tx model.DataStore) error {
+		owner := p.getUser(ctx)
+		var pls *model.Playlist
+		var err error
 
-	return p.ds.Playlist(ctx).Put(pls)
+		// If playlistID is present, override tracks
+		if playlistId != "" {
+			pls, err = tx.Playlist(ctx).Get(playlistId)
+			if err != nil {
+				return err
+			}
+			if owner != pls.Owner {
+				return model.ErrNotAuthorized
+			}
+			pls.Tracks = nil
+		} else {
+			pls = &model.Playlist{
+				Name:  name,
+				Owner: owner,
+			}
+		}
+		for _, id := range ids {
+			pls.Tracks = append(pls.Tracks, model.MediaFile{ID: id})
+		}
+
+		return tx.Playlist(ctx).Put(pls)
+	})
 }
 
 func (p *playlists) getUser(ctx context.Context) string {
-	user, ok := ctx.Value("user").(model.User)
+	user, ok := request.UserFrom(ctx)
 	if ok {
 		return user.UserName
 	}
@@ -59,54 +64,54 @@ func (p *playlists) getUser(ctx context.Context) string {
 }
 
 func (p *playlists) Delete(ctx context.Context, playlistId string) error {
-	pls, err := p.ds.Playlist(ctx).Get(playlistId)
-	if err != nil {
-		return err
-	}
+	return p.ds.WithTx(func(tx model.DataStore) error {
+		pls, err := tx.Playlist(ctx).Get(playlistId)
+		if err != nil {
+			return err
+		}
 
-	owner := p.getUser(ctx)
-	if owner != pls.Owner {
-		return model.ErrNotAuthorized
-	}
-	return p.ds.Playlist(nil).Delete(playlistId)
+		owner := p.getUser(ctx)
+		if owner != pls.Owner {
+			return model.ErrNotAuthorized
+		}
+		return tx.Playlist(ctx).Delete(playlistId)
+	})
 }
 
 func (p *playlists) Update(ctx context.Context, playlistId string, name *string, idsToAdd []string, idxToRemove []int) error {
-	pls, err := p.ds.Playlist(ctx).Get(playlistId)
-
-	owner := p.getUser(ctx)
-	if owner != pls.Owner {
-		return model.ErrNotAuthorized
-	}
-
-	if err != nil {
-		return err
-	}
-	if name != nil {
-		pls.Name = *name
-	}
-	newTracks := model.MediaFiles{}
-	for i, t := range pls.Tracks {
-		if utils.IntInSlice(i, idxToRemove) {
-			continue
+	return p.ds.WithTx(func(tx model.DataStore) error {
+		pls, err := tx.Playlist(ctx).Get(playlistId)
+		if err != nil {
+			return err
 		}
-		newTracks = append(newTracks, t)
-	}
 
-	for _, id := range idsToAdd {
-		newTracks = append(newTracks, model.MediaFile{ID: id})
-	}
-	pls.Tracks = newTracks
+		owner := p.getUser(ctx)
+		if owner != pls.Owner {
+			return model.ErrNotAuthorized
+		}
 
-	return p.ds.Playlist(ctx).Put(pls)
+		if name != nil {
+			pls.Name = *name
+		}
+		newTracks := model.MediaFiles{}
+		for i, t := range pls.Tracks {
+			if utils.IntInSlice(i, idxToRemove) {
+				continue
+			}
+			newTracks = append(newTracks, t)
+		}
+
+		for _, id := range idsToAdd {
+			newTracks = append(newTracks, model.MediaFile{ID: id})
+		}
+		pls.Tracks = newTracks
+
+		return tx.Playlist(ctx).Put(pls)
+	})
 }
 
 func (p *playlists) GetAll(ctx context.Context) (model.Playlists, error) {
-	all, err := p.ds.Playlist(ctx).GetAll(model.QueryOptions{})
-	for i := range all {
-		all[i].Public = true
-	}
-	return all, err
+	return p.ds.Playlist(ctx).GetAll()
 }
 
 type PlaylistInfo struct {
@@ -118,10 +123,12 @@ type PlaylistInfo struct {
 	Public    bool
 	Owner     string
 	Comment   string
+	Created   time.Time
+	Changed   time.Time
 }
 
 func (p *playlists) Get(ctx context.Context, id string) (*PlaylistInfo, error) {
-	pl, err := p.ds.Playlist(ctx).GetWithTracks(id)
+	pl, err := p.ds.Playlist(ctx).Get(id)
 	if err != nil {
 		return nil, err
 	}
@@ -130,11 +137,13 @@ func (p *playlists) Get(ctx context.Context, id string) (*PlaylistInfo, error) {
 	plsInfo := &PlaylistInfo{
 		Id:        pl.ID,
 		Name:      pl.Name,
-		SongCount: len(pl.Tracks),
+		SongCount: pl.SongCount,
 		Duration:  int(pl.Duration),
 		Public:    pl.Public,
 		Owner:     pl.Owner,
 		Comment:   pl.Comment,
+		Changed:   pl.UpdatedAt,
+		Created:   pl.CreatedAt,
 	}
 
 	plsInfo.Entries = FromMediaFiles(pl.Tracks)

engine/scrobbler.go

@@ -2,10 +2,10 @@ package engine
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"time"
 
+	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
 )
 
@@ -42,6 +42,9 @@ func (s *scrobbler) Register(ctx context.Context, playerId int, trackId string,
 		err = s.ds.Artist(ctx).IncPlayCount(mf.ArtistID, playTime)
 		return err
 	})
+
+	log.Info("Scrobbled", "title", mf.Title, "artist", mf.Artist, "user", userName(ctx))
+
 	return mf, err
 }
 
@@ -53,9 +56,11 @@ func (s *scrobbler) NowPlaying(ctx context.Context, playerId int, playerName, tr
 	}
 
 	if mf == nil {
-		return nil, errors.New(fmt.Sprintf(`ID "%s" not found`, trackId))
+		return nil, fmt.Errorf(`ID "%s" not found`, trackId)
 	}
 
+	log.Info("Now Playing", "title", mf.Title, "artist", mf.Artist, "user", userName(ctx))
+
 	info := &NowPlayingInfo{TrackID: trackId, Username: username, Start: time.Now(), PlayerId: playerId, PlayerName: playerName}
 	return mf, s.npRepo.Enqueue(info)
 }

engine/transcoder/ffmpeg.go

@@ -12,20 +12,25 @@ import (
 )
 
 type Transcoder interface {
-	Start(ctx context.Context, command, path string, maxBitRate int, format string) (f io.ReadCloser, err error)
+	Start(ctx context.Context, command, path string, maxBitRate int) (f io.ReadCloser, err error)
 }
 
 func New() Transcoder {
+	path, err := exec.LookPath("ffmpeg")
+	if err != nil {
+		log.Error("Unable to find ffmpeg", err)
+	}
+	log.Debug("Found ffmpeg", "path", path)
 	return &ffmpeg{}
 }
 
 type ffmpeg struct{}
 
-func (ff *ffmpeg) Start(ctx context.Context, command, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
-	arg0, args := createTranscodeCommand(command, path, maxBitRate, format)
+func (ff *ffmpeg) Start(ctx context.Context, command, path string, maxBitRate int) (f io.ReadCloser, err error) {
+	args := createTranscodeCommand(command, path, maxBitRate)
 
-	log.Trace(ctx, "Executing ffmpeg command", "cmd", arg0, "args", args)
-	cmd := exec.Command(arg0, args...)
+	log.Trace(ctx, "Executing ffmpeg command", "cmd", args)
+	cmd := exec.Command(args[0], args[1:]...) // #nosec
 	cmd.Stderr = os.Stderr
 	if f, err = cmd.StdoutPipe(); err != nil {
 		return
@@ -33,11 +38,14 @@ func (ff *ffmpeg) Start(ctx context.Context, command, path string, maxBitRate in
 	if err = cmd.Start(); err != nil {
 		return
 	}
-	go cmd.Wait() // prevent zombies
+
+	go func() { _ = cmd.Wait() }() // prevent zombies
+
 	return
 }
 
-func createTranscodeCommand(cmd, path string, maxBitRate int, format string) (string, []string) {
+// Path will always be an absolute path
+func createTranscodeCommand(cmd, path string, maxBitRate int) []string {
 	split := strings.Split(cmd, " ")
 	for i, s := range split {
 		s = strings.Replace(s, "%s", path, -1)
@@ -45,5 +53,5 @@ func createTranscodeCommand(cmd, path string, maxBitRate int, format string) (st
 		split[i] = s
 	}
 
-	return split[0], split[1:]
+	return split
 }

engine/transcoder/ffmpeg_test.go

@@ -18,8 +18,7 @@ func TestTranscoder(t *testing.T) {
 
 var _ = Describe("createTranscodeCommand", func() {
 	It("creates a valid command line", func() {
-		cmd, args := createTranscodeCommand("ffmpeg -i %s -b:a %bk mp3 -", "/music library/file.mp3", 123, "")
-		Expect(cmd).To(Equal("ffmpeg"))
-		Expect(args).To(Equal([]string{"-i", "/music library/file.mp3", "-b:a", "123k", "mp3", "-"}))
+		args := createTranscodeCommand("ffmpeg -i %s -b:a %bk mp3 -", "/music library/file.mp3", 123)
+		Expect(args).To(Equal([]string{"ffmpeg", "-i", "/music library/file.mp3", "-b:a", "123k", "mp3", "-"}))
 	})
 })

engine/wire_providers.go

@@ -18,5 +18,6 @@ var Set = wire.NewSet(
 	NewMediaStreamer,
 	transcoder.New,
 	NewTranscodingCache,
+	NewImageCache,
 	NewPlayers,
 )

go.mod

@@ -4,18 +4,19 @@ go 1.14
 
 require (
 	github.com/BurntSushi/toml v0.3.1 // indirect
-	github.com/Masterminds/squirrel v1.2.0
+	github.com/Masterminds/squirrel v1.4.0
 	github.com/astaxie/beego v1.12.1
 	github.com/bradleyjkemp/cupaloy v2.3.0+incompatible
-	github.com/deluan/rest v0.0.0-20200114062534-0653ffe9eab4
+	github.com/deluan/rest v0.0.0-20200327222046-b71e558c45d0
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
-	github.com/dhowden/tag v0.0.0-20191122115059-7e5c04feccd8
-	github.com/djherbis/fscache v0.10.0
+	github.com/dhowden/tag v0.0.0-20200412032933-5d76b8eaae27
+	github.com/disintegration/imaging v1.6.2
+	github.com/djherbis/fscache v0.10.1
 	github.com/dustin/go-humanize v1.0.0
 	github.com/fatih/camelcase v0.0.0-20160318181535-f6a740d52f96 // indirect
 	github.com/fatih/structs v1.0.0 // indirect
-	github.com/go-chi/chi v4.0.3+incompatible
-	github.com/go-chi/cors v1.0.1
+	github.com/go-chi/chi v4.1.1+incompatible
+	github.com/go-chi/cors v1.1.1
 	github.com/go-chi/jwtauth v4.0.4+incompatible
 	github.com/go-sql-driver/mysql v1.5.0 // indirect
 	github.com/golang/protobuf v1.3.1 // indirect
@@ -26,14 +27,11 @@ require (
 	github.com/kr/pretty v0.1.0 // indirect
 	github.com/lib/pq v1.3.0 // indirect
 	github.com/mattn/go-sqlite3 v2.0.3+incompatible
-	github.com/nfnt/resize v0.0.0-20160724205520-891127d8d1b5
 	github.com/onsi/ginkgo v1.12.0
-	github.com/onsi/gomega v1.9.0
+	github.com/onsi/gomega v1.10.0
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pressly/goose v2.6.0+incompatible
-	github.com/sirupsen/logrus v1.4.2
-	github.com/smartystreets/assertions v1.0.1 // indirect
-	github.com/smartystreets/goconvey v1.6.4
+	github.com/sirupsen/logrus v1.6.0
 	github.com/stretchr/testify v1.4.0 // indirect
 	golang.org/x/net v0.0.0-20200202094626-16171245cfb2 // indirect
 	golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5 // indirect
@@ -41,6 +39,6 @@ require (
 	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/djherbis/atime.v1 v1.0.0 // indirect
-	gopkg.in/djherbis/stream.v1 v1.2.0 // indirect
+	gopkg.in/djherbis/stream.v1 v1.3.1 // indirect
 	gopkg.in/yaml.v2 v2.2.8 // indirect
 )

go.sum

@@ -1,8 +1,8 @@
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/Knetic/govaluate v3.0.0+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
-github.com/Masterminds/squirrel v1.2.0 h1:K1NhbTO21BWG47IVR0OnIZuE0LZcXAYqywrC3Ko53KI=
-github.com/Masterminds/squirrel v1.2.0/go.mod h1:yaPeOnPG5ZRwL9oKdTsO/prlkPbXWZlRVMQ/gGlzIuA=
+github.com/Masterminds/squirrel v1.4.0 h1:he5i/EXixZxrBUWcxzDYMiju9WZ3ld/l7QBNuo/eN3w=
+github.com/Masterminds/squirrel v1.4.0/go.mod h1:yaPeOnPG5ZRwL9oKdTsO/prlkPbXWZlRVMQ/gGlzIuA=
 github.com/OwnLocal/goes v1.0.0/go.mod h1:8rIFjBGTue3lCU0wplczcUgt9Gxgrkkrw7etMIcn8TM=
 github.com/astaxie/beego v1.12.1 h1:dfpuoxpzLVgclveAXe4PyNKqkzgm5zF4tgF2B3kkM2I=
 github.com/astaxie/beego v1.12.1/go.mod h1:kPBWpSANNbSdIqOc8SUL9h+1oyBMZhROeYsXQDbidWQ=
@@ -22,14 +22,16 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/deluan/rest v0.0.0-20200114062534-0653ffe9eab4 h1:VSoAcWJvj656TSyWbJ5KuGsi/J8dO5+iO9+5/7I8wao=
-github.com/deluan/rest v0.0.0-20200114062534-0653ffe9eab4/go.mod h1:tSgDythFsl0QgS/PFWfIZqcJKnkADWneY80jaVRlqK8=
+github.com/deluan/rest v0.0.0-20200327222046-b71e558c45d0 h1:qHX6TTBIsrpg0JkYNkoePIpstV37lhRVLj23bHUDNwk=
+github.com/deluan/rest v0.0.0-20200327222046-b71e558c45d0/go.mod h1:tSgDythFsl0QgS/PFWfIZqcJKnkADWneY80jaVRlqK8=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/dhowden/tag v0.0.0-20191122115059-7e5c04feccd8 h1:nmFnmD8VZXkjDHIb1Gnfz50cgzUvGN72zLjPRXBW/hU=
-github.com/dhowden/tag v0.0.0-20191122115059-7e5c04feccd8/go.mod h1:SniNVYuaD1jmdEEvi+7ywb1QFR7agjeTdGKyFb0p7Rw=
-github.com/djherbis/fscache v0.10.0 h1:+O3s3LwKL1Jfz7txRHpgKOz8/krh9w+NzfzxtFdbsQg=
-github.com/djherbis/fscache v0.10.0/go.mod h1:yyPYtkNnnPXsW+81lAcQS6yab3G2CRfnPLotBvtbf0c=
+github.com/dhowden/tag v0.0.0-20200412032933-5d76b8eaae27 h1:Z6xaGRBbqfLR797upHuzQ6w4zg33BLKfAKtVCcmMDgg=
+github.com/dhowden/tag v0.0.0-20200412032933-5d76b8eaae27/go.mod h1:SniNVYuaD1jmdEEvi+7ywb1QFR7agjeTdGKyFb0p7Rw=
+github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
+github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
+github.com/djherbis/fscache v0.10.1 h1:hDv+RGyvD+UDKyRYuLoVNbuRTnf2SrA2K3VyR1br9lk=
+github.com/djherbis/fscache v0.10.1/go.mod h1:yyPYtkNnnPXsW+81lAcQS6yab3G2CRfnPLotBvtbf0c=
 github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 h1:aaQcKT9WumO6JEJcRyTqFVq4XUZiUcKR2/GI31TOcz8=
@@ -41,10 +43,10 @@ github.com/fatih/structs v1.0.0 h1:BrX964Rv5uQ3wwS+KRUAJCBBw5PQmgJfJ6v4yly5QwU=
 github.com/fatih/structs v1.0.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/go-chi/chi v4.0.3+incompatible h1:gakN3pDJnzZN5jqFV2TEdF66rTfKeITyR8qu6ekICEY=
-github.com/go-chi/chi v4.0.3+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
-github.com/go-chi/cors v1.0.1 h1:56TT/uWGoLWZpnMI/AwAmCneikXr5eLsiIq27wrKecw=
-github.com/go-chi/cors v1.0.1/go.mod h1:K2Yje0VW/SJzxiyMYu6iPQYa7hMjQX2i/F491VChg1I=
+github.com/go-chi/chi v4.1.1+incompatible h1:MmTgB0R8Bt/jccxp+t6S/1VGIKdJw5J74CK/c9tTfA4=
+github.com/go-chi/chi v4.1.1+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
+github.com/go-chi/cors v1.1.1 h1:eHuqxsIw89iXcWnWUN8R72JMibABJTN/4IOYI5WERvw=
+github.com/go-chi/cors v1.1.1/go.mod h1:K2Yje0VW/SJzxiyMYu6iPQYa7hMjQX2i/F491VChg1I=
 github.com/go-chi/jwtauth v4.0.4+incompatible h1:LGIxg6YfvSBzxU2BljXbrzVc1fMlgqSKBQgKOGAVtPY=
 github.com/go-chi/jwtauth v4.0.4+incompatible/go.mod h1:Q5EIArY/QnD6BdS+IyDw7B2m6iNbnPxtfd6/BcmtWbs=
 github.com/go-redis/redis v6.14.2+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
@@ -78,6 +80,8 @@ github.com/koding/multiconfig v0.0.0-20170327155832-26b6dfd3a84a h1:KZAp4Cn6Wybs
 github.com/koding/multiconfig v0.0.0-20170327155832-26b6dfd3a84a/go.mod h1:Y2SaZf2Rzd0pXkLVhLlCiAXFCLSXAIbTKDivVgff/AM=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
@@ -93,14 +97,12 @@ github.com/lib/pq v1.3.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/mattn/go-sqlite3 v2.0.3+incompatible h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U=
 github.com/mattn/go-sqlite3 v2.0.3+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
-github.com/nfnt/resize v0.0.0-20160724205520-891127d8d1b5 h1:BvoENQQU+fZ9uukda/RzCAL/191HHwJA5b13R6diVlY=
-github.com/nfnt/resize v0.0.0-20160724205520-891127d8d1b5/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.12.0 h1:Iw5WCbBcaAAd0fpRb1c9r5YCylv4XDoCSigm1zLevwU=
 github.com/onsi/ginkgo v1.12.0/go.mod h1:oUhWkIvk5aDxtKvDDuw8gItl8pKl42LzjC9KZE0HfGg=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
-github.com/onsi/gomega v1.9.0 h1:R1uwffexN6Pr340GtYRIdZmAiN4J+iw6WG4wog1DUXg=
-github.com/onsi/gomega v1.9.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
+github.com/onsi/gomega v1.10.0 h1:Gwkk+PTu/nfOwNMtUB/mRUv0X7ewW5dO4AERT1ThVKo=
+github.com/onsi/gomega v1.10.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
 github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
@@ -119,10 +121,10 @@ github.com/siddontang/rdb v0.0.0-20150307021120-fc89ed2e418d h1:NVwnfyR3rENtlz62
 github.com/siddontang/rdb v0.0.0-20150307021120-fc89ed2e418d/go.mod h1:AMEsy7v5z92TR1JKMkLLoaOQk++LVnOKL3ScbJ8GNGA=
 github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
-github.com/smartystreets/assertions v1.0.1 h1:voD4ITNjPL5jjBfgR/r8fPIIBrliWrWHeiJApdr3r4w=
-github.com/smartystreets/assertions v1.0.1/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
 github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/ssdb/gossdb v0.0.0-20180723034631-88f6b59b84ec/go.mod h1:QBvMkMya+gXctz3kmljlUCu/yB3GZ6oee+dUozsezQE=
@@ -137,6 +139,8 @@ github.com/wendal/errors v0.0.0-20130201093226-f66c77a7882b/go.mod h1:Q12BUT7DqI
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8 h1:hVwzHzIUGRjiF7EcUjqNxk3NCfkPxbDKRdnNE1Rpg0U=
+golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628=
@@ -166,6 +170,7 @@ golang.org/x/tools v0.0.0-20190328211700-ab21143f2384 h1:TFlARGu6Czu1z7q93HTxcP1
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190422233926-fe54fb35175b h1:NVD8gBK33xpdqCaZVVtd6OFJp+3dxkXuz7+U7KaVN6s=
 golang.org/x/tools v0.0.0-20190422233926-fe54fb35175b/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20200117065230-39095c1d176c h1:FodBYPZKH5tAN2O60HlglMwXGAeV/4k+NKbli79M/2c=
 golang.org/x/tools v0.0.0-20200117065230-39095c1d176c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7 h1:9zdDQZ7Thm29KFXgAX/+yaf3eVbP7djjWp/dXAppNCc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -178,8 +183,8 @@ gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/djherbis/atime.v1 v1.0.0 h1:eMRqB/JrLKocla2PBPKgQYg/p5UG4L6AUAs92aP7F60=
 gopkg.in/djherbis/atime.v1 v1.0.0/go.mod h1:hQIUStKmJfvf7xdh/wtK84qe+DsTV5LnA9lzxxtPpJ8=
-gopkg.in/djherbis/stream.v1 v1.2.0 h1:3tZuXO+RK8opjw8/BJr780h+eAPwOFfLHCKRKyYxk3s=
-gopkg.in/djherbis/stream.v1 v1.2.0/go.mod h1:aEV8CBVRmSpLamVJfM903Npic1IKmb2qS30VAZ+sssg=
+gopkg.in/djherbis/stream.v1 v1.3.1 h1:uGfmsOY1qqMjQQphhRBSGLyA9qumJ56exkRu9ASTjCw=
+gopkg.in/djherbis/stream.v1 v1.3.1/go.mod h1:aEV8CBVRmSpLamVJfM903Npic1IKmb2qS30VAZ+sssg=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=

lefthook.yml

@@ -0,0 +1,17 @@
+pre-push:
+  parallel: true
+  commands:
+    unit-tests:
+      tags: tests
+      run: go test ./...
+    lint:
+      tags: tests
+      run: golangci-lint run
+
+pre-commit:
+  parallel: false
+  commands:
+    gofmt:
+      tags: style
+      glob: "*.go"
+      run: gofmt -w {staged_files}; git add {staged_files}

log/log.go

@@ -24,6 +24,10 @@ const (
 	LevelTrace    = Level(logrus.TraceLevel)
 )
 
+type contextKey string
+
+const loggerCtxKey = contextKey("logger")
+
 var (
 	currentLevel  Level
 	defaultLogger = logrus.New()
@@ -66,7 +70,7 @@ func NewContext(ctx context.Context, keyValuePairs ...interface{}) context.Conte
 	}
 
 	logger := addFields(createNewLogger(), keyValuePairs)
-	ctx = context.WithValue(ctx, "logger", logger)
+	ctx = context.WithValue(ctx, loggerCtxKey, logger)
 
 	return ctx
 }
@@ -176,10 +180,11 @@ func extractLogger(ctx interface{}) (*logrus.Entry, error) {
 	case *logrus.Entry:
 		return ctx, nil
 	case context.Context:
-		logger := ctx.Value("logger")
+		logger := ctx.Value(loggerCtxKey)
 		if logger != nil {
 			return logger.(*logrus.Entry), nil
 		}
+		return extractLogger(NewContext(ctx))
 	case *http.Request:
 		return extractLogger(ctx.Context())
 	}

log/log_test.go

@@ -6,105 +6,175 @@ import (
 	"net/http/httptest"
 	"testing"
 
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
 	"github.com/sirupsen/logrus"
 	"github.com/sirupsen/logrus/hooks/test"
-	. "github.com/smartystreets/goconvey/convey"
 )
 
 func TestLog(t *testing.T) {
+	SetLevel(LevelInfo)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Log Suite")
+}
 
-	Convey("Test Logger", t, func() {
-		l, hook := test.NewNullLogger()
+var _ = Describe("Logger", func() {
+	var l *logrus.Logger
+	var hook *test.Hook
+
+	BeforeEach(func() {
+		l, hook = test.NewNullLogger()
 		SetLevel(LevelInfo)
 		SetDefaultLogger(l)
+	})
 
-		Convey("Plain message", func() {
+	Context("Logging", func() {
+		It("logs a simple message", func() {
 			Error("Simple Message")
-			So(hook.LastEntry().Message, ShouldEqual, "Simple Message")
-			So(hook.LastEntry().Data, ShouldBeEmpty)
+			Expect(hook.LastEntry().Message).To(Equal("Simple Message"))
+			Expect(hook.LastEntry().Data).To(BeEmpty())
 		})
 
-		Convey("Passing nil as context", func() {
+		It("logs a message when context is nil", func() {
 			Error(nil, "Simple Message")
-			So(hook.LastEntry().Message, ShouldEqual, "Simple Message")
-			So(hook.LastEntry().Data, ShouldBeEmpty)
+			Expect(hook.LastEntry().Message).To(Equal("Simple Message"))
+			Expect(hook.LastEntry().Data).To(BeEmpty())
 		})
 
-		SkipConvey("Empty context", func() {
-			Error(context.Background(), "Simple Message")
-			So(hook.LastEntry().Message, ShouldEqual, "Simple Message")
-			So(hook.LastEntry().Data, ShouldBeEmpty)
+		It("Empty context", func() {
+			Error(context.TODO(), "Simple Message")
+			Expect(hook.LastEntry().Message).To(Equal("Simple Message"))
+			Expect(hook.LastEntry().Data).To(BeEmpty())
 		})
 
-		Convey("Message with two kv pairs", func() {
+		It("logs messages with two kv pairs", func() {
 			Error("Simple Message", "key1", "value1", "key2", "value2")
-			So(hook.LastEntry().Message, ShouldEqual, "Simple Message")
-			So(hook.LastEntry().Data["key1"], ShouldEqual, "value1")
-			So(hook.LastEntry().Data["key2"], ShouldEqual, "value2")
-			So(hook.LastEntry().Data, ShouldHaveLength, 2)
+			Expect(hook.LastEntry().Message).To(Equal("Simple Message"))
+			Expect(hook.LastEntry().Data["key1"]).To(Equal("value1"))
+			Expect(hook.LastEntry().Data["key2"]).To(Equal("value2"))
+			Expect(hook.LastEntry().Data).To(HaveLen(2))
 		})
 
-		Convey("Only error", func() {
+		It("logs error objects as simple messages", func() {
 			Error(errors.New("error test"))
-			So(hook.LastEntry().Message, ShouldEqual, "error test")
-			So(hook.LastEntry().Data, ShouldBeEmpty)
+			Expect(hook.LastEntry().Message).To(Equal("error test"))
+			Expect(hook.LastEntry().Data).To(BeEmpty())
 		})
 
-		Convey("Error as last argument", func() {
+		It("logs errors passed as last argument", func() {
 			Error("Error scrobbling track", "id", 1, errors.New("some issue"))
-			So(hook.LastEntry().Message, ShouldEqual, "Error scrobbling track")
-			So(hook.LastEntry().Data["id"], ShouldEqual, 1)
-			So(hook.LastEntry().Data["error"], ShouldEqual, "some issue")
-			So(hook.LastEntry().Data, ShouldHaveLength, 2)
+			Expect(hook.LastEntry().Message).To(Equal("Error scrobbling track"))
+			Expect(hook.LastEntry().Data["id"]).To(Equal(1))
+			Expect(hook.LastEntry().Data["error"]).To(Equal("some issue"))
+			Expect(hook.LastEntry().Data).To(HaveLen(2))
 		})
 
-		Convey("Passing a request", func() {
-			ctx := NewContext(nil, "foo", "bar")
+		It("can get data from the request's context", func() {
+			ctx := NewContext(context.TODO(), "foo", "bar")
 			req := httptest.NewRequest("get", "/", nil).WithContext(ctx)
 
 			Error(req, "Simple Message", "key1", "value1")
-			So(hook.LastEntry().Message, ShouldEqual, "Simple Message")
-			So(hook.LastEntry().Data["foo"], ShouldEqual, "bar")
-			So(hook.LastEntry().Data["key1"], ShouldEqual, "value1")
-			So(hook.LastEntry().Data, ShouldHaveLength, 2)
+
+			Expect(hook.LastEntry().Message).To(Equal("Simple Message"))
+			Expect(hook.LastEntry().Data["foo"]).To(Equal("bar"))
+			Expect(hook.LastEntry().Data["key1"]).To(Equal("value1"))
+			Expect(hook.LastEntry().Data).To(HaveLen(2))
 		})
 
-		Convey("Skip if level is lower", func() {
+		It("does not log anything if level is lower", func() {
 			SetLevel(LevelError)
 			Info("Simple Message")
-			So(hook.LastEntry(), ShouldBeNil)
+			Expect(hook.LastEntry()).To(BeNil())
+		})
+
+		It("logs source file and line number, if requested", func() {
+			SetLogSourceLine(true)
+			Error("A crash happened")
+			Expect(hook.LastEntry().Message).To(Equal("A crash happened"))
+			// NOTE: This assertions breaks if the line number changes
+			Expect(hook.LastEntry().Data[" source"]).To(ContainSubstring("/log/log_test.go:92"))
 		})
 	})
 
-	Convey("Test extractLogger", t, func() {
-		Convey("It returns an error if the context is nil", func() {
+	Context("Levels", func() {
+		BeforeEach(func() {
+			SetLevel(LevelTrace)
+		})
+		It("logs error messages", func() {
+			Error("msg")
+			Expect(hook.LastEntry().Level).To(Equal(logrus.ErrorLevel))
+		})
+		It("logs warn messages", func() {
+			Warn("msg")
+			Expect(hook.LastEntry().Level).To(Equal(logrus.WarnLevel))
+		})
+		It("logs info messages", func() {
+			Info("msg")
+			Expect(hook.LastEntry().Level).To(Equal(logrus.InfoLevel))
+		})
+		It("logs debug messages", func() {
+			Debug("msg")
+			Expect(hook.LastEntry().Level).To(Equal(logrus.DebugLevel))
+		})
+		It("logs info messages", func() {
+			Trace("msg")
+			Expect(hook.LastEntry().Level).To(Equal(logrus.TraceLevel))
+		})
+	})
+
+	Context("extractLogger", func() {
+		It("returns an error if the context is nil", func() {
 			_, err := extractLogger(nil)
-			So(err, ShouldNotBeNil)
+			Expect(err).ToNot(BeNil())
 		})
 
-		Convey("It returns an error if the context is a string", func() {
+		It("returns an error if the context is a string", func() {
 			_, err := extractLogger("any msg")
-			So(err, ShouldNotBeNil)
+			Expect(err).ToNot(BeNil())
 		})
 
-		Convey("It returns the logger from context if it has one", func() {
+		It("returns the logger from context if it has one", func() {
 			logger := logrus.NewEntry(logrus.New())
 			ctx := context.Background()
-			ctx = context.WithValue(ctx, "logger", logger)
+			ctx = context.WithValue(ctx, loggerCtxKey, logger)
 
-			l, err := extractLogger(ctx)
-			So(err, ShouldBeNil)
-			So(l, ShouldEqual, logger)
+			Expect(extractLogger(ctx)).To(Equal(logger))
 		})
 
-		Convey("It returns the logger from request's context if it has one", func() {
+		It("returns the logger from request's context if it has one", func() {
 			logger := logrus.NewEntry(logrus.New())
 			ctx := context.Background()
-			ctx = context.WithValue(ctx, "logger", logger)
+			ctx = context.WithValue(ctx, loggerCtxKey, logger)
 			req := httptest.NewRequest("get", "/", nil).WithContext(ctx)
-			l, err := extractLogger(req)
-			So(err, ShouldBeNil)
-			So(l, ShouldEqual, logger)
+
+			Expect(extractLogger(req)).To(Equal(logger))
 		})
 	})
-}
+
+	Context("SetLevelString", func() {
+		It("converts Critical level", func() {
+			SetLevelString("Critical")
+			Expect(CurrentLevel()).To(Equal(LevelCritical))
+		})
+		It("converts Error level", func() {
+			SetLevelString("ERROR")
+			Expect(CurrentLevel()).To(Equal(LevelError))
+		})
+		It("converts Warn level", func() {
+			SetLevelString("warn")
+			Expect(CurrentLevel()).To(Equal(LevelWarn))
+		})
+		It("converts Info level", func() {
+			SetLevelString("info")
+			Expect(CurrentLevel()).To(Equal(LevelInfo))
+		})
+		It("converts Debug level", func() {
+			SetLevelString("debug")
+			Expect(CurrentLevel()).To(Equal(LevelDebug))
+		})
+		It("converts Trace level", func() {
+			SetLevelString("trace")
+			Expect(CurrentLevel()).To(Equal(LevelTrace))
+		})
+	})
+})

main.go

@@ -9,9 +9,7 @@ import (
 )
 
 func main() {
-	if !conf.Server.DevDisableBanner {
-		println(consts.Banner())
-	}
+	println(consts.Banner())
 
 	conf.Load()
 	db.EnsureLatestVersion()
@@ -21,7 +19,7 @@ func main() {
 		panic(fmt.Sprintf("Could not create the Subsonic API router. Aborting! err=%v", err))
 	}
 	a := CreateServer(conf.Server.MusicFolder)
-	a.MountRouter("/rest", subsonic)
-	a.MountRouter("/app", CreateAppRouter("/app"))
+	a.MountRouter(consts.URLPathSubsonicAPI, subsonic)
+	a.MountRouter(consts.URLPathUI, CreateAppRouter())
 	a.Run(":" + conf.Server.Port)
 }

model/album.go

@@ -3,27 +3,35 @@ package model
 import "time"
 
 type Album struct {
-	ID           string    `json:"id"            orm:"column(id)"`
-	Name         string    `json:"name"`
-	ArtistID     string    `json:"artistId"      orm:"pk;column(artist_id)"`
-	CoverArtPath string    `json:"coverArtPath"`
-	CoverArtId   string    `json:"coverArtId"`
-	Artist       string    `json:"artist"`
-	AlbumArtist  string    `json:"albumArtist"`
-	Year         int       `json:"year"`
-	Compilation  bool      `json:"compilation"`
-	SongCount    int       `json:"songCount"`
-	Duration     float32   `json:"duration"`
-	Genre        string    `json:"genre"`
-	CreatedAt    time.Time `json:"createdAt"`
-	UpdatedAt    time.Time `json:"updatedAt"`
+	ID                   string    `json:"id"            orm:"column(id)"`
+	Name                 string    `json:"name"`
+	CoverArtPath         string    `json:"coverArtPath"`
+	CoverArtId           string    `json:"coverArtId"`
+	ArtistID             string    `json:"artistId"      orm:"pk;column(artist_id)"`
+	Artist               string    `json:"artist"`
+	AlbumArtistID        string    `json:"albumArtistId" orm:"pk;column(album_artist_id)"`
+	AlbumArtist          string    `json:"albumArtist"`
+	MaxYear              int       `json:"maxYear"`
+	MinYear              int       `json:"minYear"`
+	Compilation          bool      `json:"compilation"`
+	SongCount            int       `json:"songCount"`
+	Duration             float32   `json:"duration"`
+	Genre                string    `json:"genre"`
+	FullText             string    `json:"fullText"`
+	SortAlbumName        string    `json:"sortAlbumName"`
+	SortArtistName       string    `json:"sortArtistName"`
+	SortAlbumArtistName  string    `json:"sortAlbumArtistName"`
+	OrderAlbumName       string    `json:"orderAlbumName"`
+	OrderAlbumArtistName string    `json:"orderAlbumArtistName"`
+	CreatedAt            time.Time `json:"createdAt"`
+	UpdatedAt            time.Time `json:"updatedAt"`
 
 	// Annotations
-	PlayCount int       `json:"-"   orm:"-"`
-	PlayDate  time.Time `json:"-"   orm:"-"`
-	Rating    int       `json:"-"   orm:"-"`
-	Starred   bool      `json:"-"   orm:"-"`
-	StarredAt time.Time `json:"-"   orm:"-"`
+	PlayCount int       `json:"playCount"   orm:"-"`
+	PlayDate  time.Time `json:"playDate"    orm:"-"`
+	Rating    int       `json:"rating"      orm:"-"`
+	Starred   bool      `json:"starred"     orm:"-"`
+	StarredAt time.Time `json:"starredAt"   orm:"-"`
 }
 
 type Albums []Album
@@ -31,9 +39,8 @@ type Albums []Album
 type AlbumRepository interface {
 	CountAll(...QueryOptions) (int64, error)
 	Exists(id string) (bool, error)
-	Put(m *Album) error
 	Get(id string) (*Album, error)
-	FindByArtist(artistId string) (Albums, error)
+	FindByArtist(albumArtistId string) (Albums, error)
 	GetAll(...QueryOptions) (Albums, error)
 	GetRandom(...QueryOptions) (Albums, error)
 	GetStarred(options ...QueryOptions) (Albums, error)

model/annotation.go

@@ -7,3 +7,7 @@ type AnnotatedRepository interface {
 	SetStar(starred bool, itemIDs ...string) error
 	SetRating(rating int, itemID string) error
 }
+
+// While I can't find a better way to make these fields optional in the models, I keep this list here
+// to be used in other packages
+var AnnotationFields = []string{"playCount", "playDate", "rating", "starred", "starredAt"}

model/artist.go

@@ -3,16 +3,20 @@ package model
 import "time"
 
 type Artist struct {
-	ID         string `json:"id"          orm:"column(id)"`
-	Name       string `json:"name"`
-	AlbumCount int    `json:"albumCount"  orm:"column(album_count)"`
+	ID              string `json:"id"          orm:"column(id)"`
+	Name            string `json:"name"`
+	AlbumCount      int    `json:"albumCount"`
+	SongCount       int    `json:"songCount"`
+	FullText        string `json:"fullText"`
+	SortArtistName  string `json:"sortArtistName"`
+	OrderArtistName string `json:"orderArtistName"`
 
 	// Annotations
-	PlayCount int       `json:"-"   orm:"-"`
-	PlayDate  time.Time `json:"-"   orm:"-"`
-	Rating    int       `json:"-"   orm:"-"`
-	Starred   bool      `json:"-"   orm:"-"`
-	StarredAt time.Time `json:"-"   orm:"-"`
+	PlayCount int       `json:"playCount"   orm:"-"`
+	PlayDate  time.Time `json:"playDate"    orm:"-"`
+	Rating    int       `json:"rating"      orm:"-"`
+	Starred   bool      `json:"starred"     orm:"-"`
+	StarredAt time.Time `json:"starredAt"   orm:"-"`
 }
 
 type Artists []Artist

model/mediafile.go

@@ -6,33 +6,43 @@ import (
 )
 
 type MediaFile struct {
-	ID          string    `json:"id"            orm:"pk;column(id)"`
-	Path        string    `json:"path"`
-	Title       string    `json:"title"`
-	Album       string    `json:"album"`
-	Artist      string    `json:"artist"`
-	ArtistID    string    `json:"artistId"      orm:"pk;column(artist_id)"`
-	AlbumArtist string    `json:"albumArtist"`
-	AlbumID     string    `json:"albumId"       orm:"pk;column(album_id)"`
-	HasCoverArt bool      `json:"hasCoverArt"`
-	TrackNumber int       `json:"trackNumber"`
-	DiscNumber  int       `json:"discNumber"`
-	Year        int       `json:"year"`
-	Size        int       `json:"size"`
-	Suffix      string    `json:"suffix"`
-	Duration    float32   `json:"duration"`
-	BitRate     int       `json:"bitRate"`
-	Genre       string    `json:"genre"`
-	Compilation bool      `json:"compilation"`
-	CreatedAt   time.Time `json:"createdAt"`
-	UpdatedAt   time.Time `json:"updatedAt"`
+	ID                   string    `json:"id"            orm:"pk;column(id)"`
+	Path                 string    `json:"path"`
+	Title                string    `json:"title"`
+	Album                string    `json:"album"`
+	ArtistID             string    `json:"artistId"      orm:"pk;column(artist_id)"`
+	Artist               string    `json:"artist"`
+	AlbumArtistID        string    `json:"albumArtistId"`
+	AlbumArtist          string    `json:"albumArtist"`
+	AlbumID              string    `json:"albumId"       orm:"pk;column(album_id)"`
+	HasCoverArt          bool      `json:"hasCoverArt"`
+	TrackNumber          int       `json:"trackNumber"`
+	DiscNumber           int       `json:"discNumber"`
+	DiscSubtitle         string    `json:"discSubtitle"`
+	Year                 int       `json:"year"`
+	Size                 int       `json:"size"`
+	Suffix               string    `json:"suffix"`
+	Duration             float32   `json:"duration"`
+	BitRate              int       `json:"bitRate"`
+	Genre                string    `json:"genre"`
+	FullText             string    `json:"fullText"`
+	SortTitle            string    `json:"sortTitle"`
+	SortAlbumName        string    `json:"sortAlbumName"`
+	SortArtistName       string    `json:"sortArtistName"`
+	SortAlbumArtistName  string    `json:"sortAlbumArtistName"`
+	OrderAlbumName       string    `json:"orderAlbumName"`
+	OrderArtistName      string    `json:"orderArtistName"`
+	OrderAlbumArtistName string    `json:"orderAlbumArtistName"`
+	Compilation          bool      `json:"compilation"`
+	CreatedAt            time.Time `json:"createdAt"`
+	UpdatedAt            time.Time `json:"updatedAt"`
 
 	// Annotations
-	PlayCount int       `json:"-"   orm:"-"`
-	PlayDate  time.Time `json:"-"   orm:"-"`
-	Rating    int       `json:"-"   orm:"-"`
-	Starred   bool      `json:"-"   orm:"-"`
-	StarredAt time.Time `json:"-"   orm:"-"`
+	PlayCount int       `json:"playCount"   orm:"-"`
+	PlayDate  time.Time `json:"playDate"    orm:"-"`
+	Rating    int       `json:"rating"      orm:"-"`
+	Starred   bool      `json:"starred"     orm:"-"`
+	StarredAt time.Time `json:"starredAt"   orm:"-"`
 }
 
 func (mf *MediaFile) ContentType() string {
@@ -46,6 +56,7 @@ type MediaFileRepository interface {
 	Exists(id string) (bool, error)
 	Put(m *MediaFile) error
 	Get(id string) (*MediaFile, error)
+	GetAll(options ...QueryOptions) (MediaFiles, error)
 	FindByAlbum(albumId string) (MediaFiles, error)
 	FindByPath(path string) (MediaFiles, error)
 	GetStarred(options ...QueryOptions) (MediaFiles, error)

model/mediafolder.go

@@ -1,7 +1,7 @@
 package model
 
 type MediaFolder struct {
-	ID   string
+	ID   int32
 	Name string
 	Path string
 }

model/playlist.go

@@ -1,23 +1,46 @@
 package model
 
-type Playlist struct {
-	ID       string
-	Name     string
-	Comment  string
-	Duration float32
-	Owner    string
-	Public   bool
-	Tracks   MediaFiles
-}
+import (
+	"time"
+)
 
-type PlaylistRepository interface {
-	CountAll() (int64, error)
-	Exists(id string) (bool, error)
-	Put(pls *Playlist) error
-	Get(id string) (*Playlist, error)
-	GetWithTracks(id string) (*Playlist, error)
-	GetAll(options ...QueryOptions) (Playlists, error)
-	Delete(id string) error
+type Playlist struct {
+	ID        string     `json:"id"          orm:"column(id)"`
+	Name      string     `json:"name"`
+	Comment   string     `json:"comment"`
+	Duration  float32    `json:"duration"`
+	SongCount int        `json:"songCount"`
+	Owner     string     `json:"owner"`
+	Public    bool       `json:"public"`
+	Tracks    MediaFiles `json:"tracks,omitempty"`
+	CreatedAt time.Time  `json:"createdAt"`
+	UpdatedAt time.Time  `json:"updatedAt"`
 }
 
 type Playlists []Playlist
+
+type PlaylistRepository interface {
+	CountAll(options ...QueryOptions) (int64, error)
+	Exists(id string) (bool, error)
+	Put(pls *Playlist) error
+	Get(id string) (*Playlist, error)
+	GetAll(options ...QueryOptions) (Playlists, error)
+	Delete(id string) error
+	Tracks(playlistId string) PlaylistTrackRepository
+}
+
+type PlaylistTrack struct {
+	ID          string `json:"id"          orm:"column(id)"`
+	MediaFileID string `json:"mediaFileId" orm:"column(media_file_id)"`
+	PlaylistID  string `json:"playlistId" orm:"column(playlist_id)"`
+	MediaFile
+}
+
+type PlaylistTracks []PlaylistTrack
+
+type PlaylistTrackRepository interface {
+	ResourceRepository
+	Add(mediaFileIds []string) error
+	Update(mediaFileIds []string) error
+	Delete(id string) error
+}

model/request/request.go

@@ -0,0 +1,72 @@
+package request
+
+import (
+	"context"
+
+	"github.com/deluan/navidrome/model"
+)
+
+type contextKey string
+
+const (
+	User        = contextKey("user")
+	Username    = contextKey("username")
+	Client      = contextKey("client")
+	Version     = contextKey("version")
+	Player      = contextKey("player")
+	Transcoding = contextKey("transcoding")
+)
+
+func WithUser(ctx context.Context, u model.User) context.Context {
+	return context.WithValue(ctx, User, u)
+}
+
+func WithUsername(ctx context.Context, username string) context.Context {
+	return context.WithValue(ctx, Username, username)
+}
+
+func WithClient(ctx context.Context, client string) context.Context {
+	return context.WithValue(ctx, Client, client)
+}
+
+func WithVersion(ctx context.Context, version string) context.Context {
+	return context.WithValue(ctx, Version, version)
+}
+
+func WithPlayer(ctx context.Context, player model.Player) context.Context {
+	return context.WithValue(ctx, Player, player)
+}
+
+func WithTranscoding(ctx context.Context, t model.Transcoding) context.Context {
+	return context.WithValue(ctx, Transcoding, t)
+}
+
+func UserFrom(ctx context.Context) (model.User, bool) {
+	v, ok := ctx.Value(User).(model.User)
+	return v, ok
+}
+
+func UsernameFrom(ctx context.Context) (string, bool) {
+	v, ok := ctx.Value(Username).(string)
+	return v, ok
+}
+
+func ClientFrom(ctx context.Context) (string, bool) {
+	v, ok := ctx.Value(Client).(string)
+	return v, ok
+}
+
+func VersionFrom(ctx context.Context) (string, bool) {
+	v, ok := ctx.Value(Version).(string)
+	return v, ok
+}
+
+func PlayerFrom(ctx context.Context) (model.Player, bool) {
+	v, ok := ctx.Value(Player).(model.Player)
+	return v, ok
+}
+
+func TranscodingFrom(ctx context.Context) (model.Transcoding, bool) {
+	v, ok := ctx.Value(Transcoding).(model.Transcoding)
+	return v, ok
+}

persistence/album_repository.go

@@ -2,10 +2,14 @@ package persistence
 
 import (
 	"context"
+	"sort"
+	"strconv"
+	"strings"
 	"time"
 
 	. "github.com/Masterminds/squirrel"
 	"github.com/astaxie/beego/orm"
+	"github.com/deluan/navidrome/consts"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
 	"github.com/deluan/rest"
@@ -13,6 +17,7 @@ import (
 
 type albumRepository struct {
 	sqlRepository
+	sqlRestful
 }
 
 func NewAlbumRepository(ctx context.Context, o orm.Ormer) model.AlbumRepository {
@@ -20,9 +25,41 @@ func NewAlbumRepository(ctx context.Context, o orm.Ormer) model.AlbumRepository
 	r.ctx = ctx
 	r.ormer = o
 	r.tableName = "album"
+	r.sortMappings = map[string]string{
+		"artist": "compilation asc, order_album_artist_name asc, order_album_name asc",
+		"random": "RANDOM()",
+	}
+	r.filterMappings = map[string]filterFunc{
+		"name":        fullTextFilter,
+		"compilation": booleanFilter,
+		"artist_id":   artistFilter,
+		"year":        yearFilter,
+	}
+
 	return r
 }
 
+func yearFilter(field string, value interface{}) Sqlizer {
+	return Or{
+		And{
+			Gt{"min_year": 0},
+			LtOrEq{"min_year": value},
+			GtOrEq{"max_year": value},
+		},
+		Eq{"max_year": value},
+	}
+}
+
+func artistFilter(field string, value interface{}) Sqlizer {
+	return exists("media_file", And{
+		ConcatExpr("album_id=album.id"),
+		Or{
+			Eq{"artist_id": value},
+			Eq{"album_artist_id": value},
+		},
+	})
+}
+
 func (r *albumRepository) CountAll(options ...model.QueryOptions) (int64, error) {
 	return r.count(Select(), options...)
 }
@@ -31,14 +68,6 @@ func (r *albumRepository) Exists(id string) (bool, error) {
 	return r.exists(Select().Where(Eq{"id": id}))
 }
 
-func (r *albumRepository) Put(a *model.Album) error {
-	_, err := r.put(a.ID, a)
-	if err != nil {
-		return err
-	}
-	return r.index(a.ID, a.Name, a.Artist, a.AlbumArtist)
-}
-
 func (r *albumRepository) selectAlbum(options ...model.QueryOptions) SelectBuilder {
 	return r.newSelectWithAnnotation("album.id", options...).Columns("*")
 }
@@ -54,7 +83,7 @@ func (r *albumRepository) Get(id string) (*model.Album, error) {
 }
 
 func (r *albumRepository) FindByArtist(artistId string) (model.Albums, error) {
-	sq := r.selectAlbum().Where(Eq{"artist_id": artistId}).OrderBy("year")
+	sq := r.selectAlbum().Where(Eq{"album_artist_id": artistId}).OrderBy("max_year")
 	res := model.Albums{}
 	err := r.queryAll(sq, &res)
 	return res, err
@@ -79,13 +108,20 @@ func (r *albumRepository) GetRandom(options ...model.QueryOptions) (model.Albums
 func (r *albumRepository) Refresh(ids ...string) error {
 	type refreshAlbum struct {
 		model.Album
-		CurrentId   string
-		HasCoverArt bool
+		CurrentId     string
+		HasCoverArt   bool
+		SongArtists   string
+		Years         string
+		DiscSubtitles string
 	}
 	var albums []refreshAlbum
-	sel := Select(`album_id as id, album as name, f.artist, f.album_artist, f.artist_id, f.compilation, f.genre,
-		max(f.year) as year, sum(f.duration) as duration, count(*) as song_count, a.id as current_id, 
-		f.id as cover_art_id, f.path as cover_art_path, f.has_cover_art`).
+	sel := Select(`album_id as id, album as name, f.artist, f.album_artist, f.artist_id, f.album_artist_id, 
+		f.sort_album_name, f.sort_artist_name, f.sort_album_artist_name,
+		f.order_album_name, f.order_album_artist_name,
+		f.compilation, f.genre, max(f.year) as max_year, sum(f.duration) as duration, 
+		count(*) as song_count, a.id as current_id, f.id as cover_art_id, f.path as cover_art_path, f.has_cover_art, 
+		group_concat(f.disc_subtitle, ' ') as disc_subtitles,
+		group_concat(f.artist, ' ') as song_artists, group_concat(f.year, ' ') as years`).
 		From("media_file f").
 		LeftJoin("album a on f.album_id = a.id").
 		Where(Eq{"f.album_id": ids}).GroupBy("album_id").OrderBy("f.id")
@@ -101,11 +137,14 @@ func (r *albumRepository) Refresh(ids ...string) error {
 			al.CoverArtId = ""
 		}
 		if al.Compilation {
-			al.AlbumArtist = "Various Artists"
+			al.AlbumArtist = consts.VariousArtists
+			al.AlbumArtistID = consts.VariousArtistsID
 		}
 		if al.AlbumArtist == "" {
 			al.AlbumArtist = al.Artist
+			al.AlbumArtistID = al.ArtistID
 		}
+		al.MinYear = getMinYear(al.Years)
 		al.UpdatedAt = time.Now()
 		if al.CurrentId != "" {
 			toUpdate++
@@ -113,7 +152,9 @@ func (r *albumRepository) Refresh(ids ...string) error {
 			toInsert++
 			al.CreatedAt = time.Now()
 		}
-		err := r.Put(&al.Album)
+		al.FullText = getFullText(al.Name, al.Artist, al.AlbumArtist, al.SongArtists,
+			al.SortAlbumName, al.SortArtistName, al.SortAlbumArtistName, al.DiscSubtitles)
+		_, err := r.put(al.ID, al.Album)
 		if err != nil {
 			return err
 		}
@@ -127,6 +168,18 @@ func (r *albumRepository) Refresh(ids ...string) error {
 	return err
 }
 
+func getMinYear(years string) int {
+	ys := strings.Fields(years)
+	sort.Strings(ys)
+	for _, y := range ys {
+		if y != "0" {
+			r, _ := strconv.Atoi(y)
+			return r
+		}
+	}
+	return 0
+}
+
 func (r *albumRepository) PurgeEmpty() error {
 	del := Delete(r.tableName).Where("id not in (select distinct(album_id) from media_file)")
 	c, err := r.executeSQL(del)

persistence/album_repository_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/astaxie/beego/orm"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -14,13 +15,13 @@ var _ = Describe("AlbumRepository", func() {
 	var repo model.AlbumRepository
 
 	BeforeEach(func() {
-		ctx := context.WithValue(log.NewContext(nil), "user", model.User{ID: "userid"})
+		ctx := request.WithUser(log.NewContext(context.TODO()), model.User{ID: "userid", UserName: "johndoe"})
 		repo = NewAlbumRepository(ctx, orm.NewOrm())
 	})
 
 	Describe("Get", func() {
 		It("returns an existent album", func() {
-			Expect(repo.Get("3")).To(Equal(&albumRadioactivity))
+			Expect(repo.Get("103")).To(Equal(&albumRadioactivity))
 		})
 		It("returns ErrNotFound when the album does not exist", func() {
 			_, err := repo.Get("666")
@@ -73,4 +74,16 @@ var _ = Describe("AlbumRepository", func() {
 		})
 	})
 
+	Describe("getMinYear", func() {
+		It("returns 0 when there's no valid year", func() {
+			Expect(getMinYear("a b c")).To(Equal(0))
+			Expect(getMinYear("")).To(Equal(0))
+		})
+		It("returns 0 when all values are 0", func() {
+			Expect(getMinYear("0 0 0 ")).To(Equal(0))
+		})
+		It("returns the smallest value from the list", func() {
+			Expect(getMinYear("2000 0 1800")).To(Equal(1800))
+		})
+	})
 })

persistence/artist_repository.go

@@ -16,6 +16,7 @@ import (
 
 type artistRepository struct {
 	sqlRepository
+	sqlRestful
 	indexGroups utils.IndexGroups
 }
 
@@ -25,6 +26,12 @@ func NewArtistRepository(ctx context.Context, o orm.Ormer) model.ArtistRepositor
 	r.ormer = o
 	r.indexGroups = utils.ParseIndexGroups(conf.Server.IndexGroups)
 	r.tableName = "artist"
+	r.sortMappings = map[string]string{
+		"name": "order_artist_name",
+	}
+	r.filterMappings = map[string]filterFunc{
+		"name": fullTextFilter,
+	}
 	return r
 }
 
@@ -40,23 +47,10 @@ func (r *artistRepository) Exists(id string) (bool, error) {
 	return r.exists(Select().Where(Eq{"id": id}))
 }
 
-func (r *artistRepository) getIndexKey(a *model.Artist) string {
-	name := strings.ToLower(utils.NoArticle(a.Name))
-	for k, v := range r.indexGroups {
-		key := strings.ToLower(k)
-		if strings.HasPrefix(name, key) {
-			return v
-		}
-	}
-	return "#"
-}
-
 func (r *artistRepository) Put(a *model.Artist) error {
+	a.FullText = getFullText(a.Name, a.SortArtistName)
 	_, err := r.put(a.ID, a)
-	if err != nil {
-		return err
-	}
-	return r.index(a.ID, a.Name)
+	return err
 }
 
 func (r *artistRepository) Get(id string) (*model.Artist, error) {
@@ -73,18 +67,29 @@ func (r *artistRepository) GetAll(options ...model.QueryOptions) (model.Artists,
 	return res, err
 }
 
+func (r *artistRepository) getIndexKey(a *model.Artist) string {
+	name := strings.ToLower(utils.NoArticle(a.Name))
+	for k, v := range r.indexGroups {
+		key := strings.ToLower(k)
+		if strings.HasPrefix(name, key) {
+			return v
+		}
+	}
+	return "#"
+}
+
 // TODO Cache the index (recalculate when there are changes to the DB)
 func (r *artistRepository) GetIndex() (model.ArtistIndexes, error) {
-	sq := r.selectArtist().OrderBy("name")
+	sq := r.selectArtist().OrderBy("order_artist_name")
 	var all model.Artists
-	// TODO Paginate
 	err := r.queryAll(sq, &all)
 	if err != nil {
 		return nil, err
 	}
 
 	fullIdx := make(map[string]*model.ArtistIndex)
-	for _, a := range all {
+	for i := range all {
+		a := all[i]
 		ax := r.getIndexKey(&a)
 		idx, ok := fullIdx[ax]
 		if !ok {
@@ -106,17 +111,16 @@ func (r *artistRepository) GetIndex() (model.ArtistIndexes, error) {
 func (r *artistRepository) Refresh(ids ...string) error {
 	type refreshArtist struct {
 		model.Artist
-		CurrentId   string
-		AlbumArtist string
-		Compilation bool
+		CurrentId string
 	}
 	var artists []refreshArtist
-	sel := Select("f.artist_id as id", "f.artist as name", "f.album_artist", "f.compilation",
-		"count(*) as album_count", "a.id as current_id").
+	sel := Select("f.album_artist_id as id", "f.album_artist as name", "count(*) as album_count", "a.id as current_id",
+		"f.sort_album_artist_name as sort_artist_name", "f.order_album_artist_name as order_artist_name",
+		"sum(f.song_count) as song_count").
 		From("album f").
-		LeftJoin("artist a on f.artist_id = a.id").
-		Where(Eq{"f.artist_id": ids}).
-		GroupBy("f.artist_id").OrderBy("f.id")
+		LeftJoin("artist a on f.album_artist_id = a.id").
+		Where(Eq{"f.album_artist_id": ids}).
+		GroupBy("f.album_artist_id").OrderBy("f.id")
 	err := r.queryAll(sel, &artists)
 	if err != nil {
 		return err
@@ -125,12 +129,6 @@ func (r *artistRepository) Refresh(ids ...string) error {
 	toInsert := 0
 	toUpdate := 0
 	for _, ar := range artists {
-		if ar.Compilation {
-			ar.AlbumArtist = "Various Artists"
-		}
-		if ar.AlbumArtist != "" {
-			ar.Name = ar.AlbumArtist
-		}
 		if ar.CurrentId != "" {
 			toUpdate++
 		} else {
@@ -158,7 +156,7 @@ func (r *artistRepository) GetStarred(options ...model.QueryOptions) (model.Arti
 }
 
 func (r *artistRepository) PurgeEmpty() error {
-	del := Delete(r.tableName).Where("id not in (select distinct(artist_id) from album)")
+	del := Delete(r.tableName).Where("id not in (select distinct(album_artist_id) from album)")
 	c, err := r.executeSQL(del)
 	if err == nil {
 		if c > 0 {

persistence/artist_repository_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/astaxie/beego/orm"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -14,7 +15,8 @@ var _ = Describe("ArtistRepository", func() {
 	var repo model.ArtistRepository
 
 	BeforeEach(func() {
-		ctx := context.WithValue(log.NewContext(nil), "user", model.User{ID: "userid"})
+		ctx := log.NewContext(context.TODO())
+		ctx = request.WithUser(ctx, model.User{ID: "userid"})
 		repo = NewArtistRepository(ctx, orm.NewOrm())
 	})
 
@@ -24,7 +26,7 @@ var _ = Describe("ArtistRepository", func() {
 		})
 	})
 
-	Describe("Exist", func() {
+	Describe("Exists", func() {
 		It("returns true for an artist that is in the DB", func() {
 			Expect(repo.Exists("3")).To(BeTrue())
 		})

persistence/genre_repository_test.go

@@ -1,6 +1,8 @@
 package persistence_test
 
 import (
+	"context"
+
 	"github.com/astaxie/beego/orm"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
@@ -13,7 +15,7 @@ var _ = Describe("GenreRepository", func() {
 	var repo model.GenreRepository
 
 	BeforeEach(func() {
-		repo = persistence.NewGenreRepository(log.NewContext(nil), orm.NewOrm())
+		repo = persistence.NewGenreRepository(log.NewContext(context.TODO()), orm.NewOrm())
 	})
 
 	It("returns all records", func() {

persistence/helpers.go

@@ -5,6 +5,10 @@ import (
 	"fmt"
 	"regexp"
 	"strings"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/utils"
 )
 
 func toSqlArgs(rec interface{}) (map[string]interface{}, error) {
@@ -19,7 +23,9 @@ func toSqlArgs(rec interface{}) (map[string]interface{}, error) {
 	err = json.Unmarshal(b, &m)
 	r := make(map[string]interface{}, len(m))
 	for f, v := range m {
-		r[toSnakeCase(f)] = v
+		if !utils.StringInSlice(f, model.AnnotationFields) && v != nil {
+			r[toSnakeCase(f)] = v
+		}
 	}
 	return r, err
 }
@@ -33,30 +39,17 @@ func toSnakeCase(str string) string {
 	return strings.ToLower(snake)
 }
 
-func ToStruct(m map[string]interface{}, rec interface{}, fieldNames []string) error {
-	var r = make(map[string]interface{}, len(m))
-	for _, f := range fieldNames {
-		v, ok := m[f]
-		if !ok {
-			return fmt.Errorf("invalid field '%s'", f)
-		}
-		r[toCamelCase(f)] = v
-	}
-	// Convert to JSON...
-	b, err := json.Marshal(r)
-	if err != nil {
-		return err
-	}
-
-	// ... then convert to struct
-	err = json.Unmarshal(b, &rec)
-	return err
+func exists(subTable string, cond squirrel.Sqlizer) existsCond {
+	return existsCond{subTable: subTable, cond: cond}
 }
 
-var matchUnderscore = regexp.MustCompile("_([A-Za-z])")
-
-func toCamelCase(str string) string {
-	return matchUnderscore.ReplaceAllStringFunc(str, func(s string) string {
-		return strings.ToUpper(strings.Replace(s, "_", "", -1))
-	})
+type existsCond struct {
+	subTable string
+	cond     squirrel.Sqlizer
+}
+
+func (e existsCond) ToSql() (string, []interface{}, error) {
+	sql, args, err := e.cond.ToSql()
+	sql = fmt.Sprintf("exists (select 1 from %s where %s)", e.subTable, sql)
+	return sql, args, err
 }

persistence/helpers_test.go

@@ -0,0 +1,64 @@
+package persistence
+
+import (
+	"time"
+
+	"github.com/Masterminds/squirrel"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Helpers", func() {
+	Describe("toSnakeCase", func() {
+		It("converts camelCase", func() {
+			Expect(toSnakeCase("camelCase")).To(Equal("camel_case"))
+		})
+		It("converts PascalCase", func() {
+			Expect(toSnakeCase("PascalCase")).To(Equal("pascal_case"))
+		})
+		It("converts ALLCAPS", func() {
+			Expect(toSnakeCase("ALLCAPS")).To(Equal("allcaps"))
+		})
+		It("does not converts snake_case", func() {
+			Expect(toSnakeCase("snake_case")).To(Equal("snake_case"))
+		})
+	})
+	Describe("toSqlArgs", func() {
+		type Model struct {
+			ID        string `json:"id"`
+			AlbumId   string `json:"albumId"`
+			PlayCount int    `json:"playCount"`
+			CreatedAt *time.Time
+		}
+
+		It("returns a map with snake_case keys", func() {
+			now := time.Now()
+			m := &Model{ID: "123", AlbumId: "456", CreatedAt: &now, PlayCount: 2}
+			args, err := toSqlArgs(m)
+			Expect(err).To(BeNil())
+			Expect(args).To(HaveKeyWithValue("id", "123"))
+			Expect(args).To(HaveKeyWithValue("album_id", "456"))
+			Expect(args).To(HaveKey("created_at"))
+			Expect(args).To(HaveLen(3))
+		})
+
+		It("remove null fields", func() {
+			m := &Model{ID: "123", AlbumId: "456"}
+			args, err := toSqlArgs(m)
+			Expect(err).To(BeNil())
+			Expect(args).To(HaveKey("id"))
+			Expect(args).To(HaveKey("album_id"))
+			Expect(args).To(HaveLen(2))
+		})
+	})
+
+	Describe("Exists", func() {
+		It("constructs the correct EXISTS query", func() {
+			e := exists("album", squirrel.Eq{"id": 1})
+			sql, args, err := e.ToSql()
+			Expect(sql).To(Equal("exists (select 1 from album where id = ?)"))
+			Expect(args).To(Equal([]interface{}{1}))
+			Expect(err).To(BeNil())
+		})
+	})
+})

persistence/mediafile_repository.go

@@ -14,6 +14,7 @@ import (
 
 type mediaFileRepository struct {
 	sqlRepository
+	sqlRestful
 }
 
 func NewMediaFileRepository(ctx context.Context, o orm.Ormer) *mediaFileRepository {
@@ -22,8 +23,12 @@ func NewMediaFileRepository(ctx context.Context, o orm.Ormer) *mediaFileReposito
 	r.ormer = o
 	r.tableName = "media_file"
 	r.sortMappings = map[string]string{
-		"artist": "artist asc, album asc, disc_number asc, track_number asc",
-		"album":  "album asc, disc_number asc, track_number asc",
+		"artist": "order_artist_name asc, album asc, disc_number asc, track_number asc",
+		"album":  "order_album_name asc, disc_number asc, track_number asc",
+		"random": "RANDOM()",
+	}
+	r.filterMappings = map[string]filterFunc{
+		"title": fullTextFilter,
 	}
 	return r
 }
@@ -37,11 +42,10 @@ func (r mediaFileRepository) Exists(id string) (bool, error) {
 }
 
 func (r mediaFileRepository) Put(m *model.MediaFile) error {
+	m.FullText = getFullText(m.Title, m.Album, m.Artist, m.AlbumArtist,
+		m.SortTitle, m.SortAlbumName, m.SortArtistName, m.SortAlbumArtistName, m.DiscSubtitle)
 	_, err := r.put(m.ID, m)
-	if err != nil {
-		return err
-	}
-	return r.index(m.ID, m.Title, m.Album, m.Artist, m.AlbumArtist)
+	return err
 }
 
 func (r mediaFileRepository) selectMediaFile(options ...model.QueryOptions) SelectBuilder {

persistence/mediafile_repository_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/astaxie/beego/orm"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	"github.com/google/uuid"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -16,12 +17,13 @@ var _ = Describe("MediaRepository", func() {
 	var mr model.MediaFileRepository
 
 	BeforeEach(func() {
-		ctx := context.WithValue(log.NewContext(nil), "user", model.User{ID: "userid"})
+		ctx := log.NewContext(context.TODO())
+		ctx = request.WithUser(ctx, model.User{ID: "userid"})
 		mr = NewMediaFileRepository(ctx, orm.NewOrm())
 	})
 
 	It("gets mediafile from the DB", func() {
-		Expect(mr.Get("4")).To(Equal(&songAntenna))
+		Expect(mr.Get("1004")).To(Equal(&songAntenna))
 	})
 
 	It("returns ErrNotFound", func() {
@@ -39,7 +41,7 @@ var _ = Describe("MediaRepository", func() {
 	})
 
 	It("find mediafiles by album", func() {
-		Expect(mr.FindByAlbum("3")).To(Equal(model.MediaFiles{
+		Expect(mr.FindByAlbum("103")).To(Equal(model.MediaFiles{
 			songRadioactivity,
 			songAntenna,
 		}))

persistence/mediafolders_repository.go

@@ -29,7 +29,7 @@ func (*mediaFolderRepository) GetAll() (model.MediaFolders, error) {
 }
 
 func hardCoded() model.MediaFolder {
-	mediaFolder := model.MediaFolder{ID: "0", Path: conf.Server.MusicFolder}
+	mediaFolder := model.MediaFolder{ID: 0, Path: conf.Server.MusicFolder}
 	mediaFolder.Name = "Music Library"
 	return mediaFolder
 }

persistence/mock_album_repo.go

@@ -14,7 +14,7 @@ func CreateMockAlbumRepo() *MockAlbum {
 
 type MockAlbum struct {
 	model.AlbumRepository
-	data    map[string]*model.Album
+	data    map[string]model.Album
 	all     model.Albums
 	err     bool
 	Options model.QueryOptions
@@ -24,19 +24,22 @@ func (m *MockAlbum) SetError(err bool) {
 	m.err = err
 }
 
-func (m *MockAlbum) SetData(j string, size int) {
-	m.data = make(map[string]*model.Album)
-	m.all = make(model.Albums, size)
+func (m *MockAlbum) SetData(j string) {
+	m.data = make(map[string]model.Album)
+	m.all = model.Albums{}
 	err := json.Unmarshal([]byte(j), &m.all)
 	if err != nil {
 		fmt.Println("ERROR: ", err)
 	}
 	for _, a := range m.all {
-		m.data[a.ID] = &a
+		m.data[a.ID] = a
 	}
 }
 
 func (m *MockAlbum) Exists(id string) (bool, error) {
+	if m.err {
+		return false, errors.New("Error!")
+	}
 	_, found := m.data[id]
 	return found, nil
 }
@@ -46,7 +49,7 @@ func (m *MockAlbum) Get(id string) (*model.Album, error) {
 		return nil, errors.New("Error!")
 	}
 	if d, ok := m.data[id]; ok {
-		return d, nil
+		return &d, nil
 	}
 	return nil, model.ErrNotFound
 }
@@ -68,8 +71,8 @@ func (m *MockAlbum) FindByArtist(artistId string) (model.Albums, error) {
 	var res = make(model.Albums, len(m.data))
 	i := 0
 	for _, a := range m.data {
-		if a.ArtistID == artistId {
-			res[i] = *a
+		if a.AlbumArtistID == artistId {
+			res[i] = a
 			i++
 		}
 	}

persistence/mock_artist_repo.go

@@ -14,7 +14,7 @@ func CreateMockArtistRepo() *MockArtist {
 
 type MockArtist struct {
 	model.ArtistRepository
-	data map[string]*model.Artist
+	data map[string]model.Artist
 	err  bool
 }
 
@@ -22,19 +22,22 @@ func (m *MockArtist) SetError(err bool) {
 	m.err = err
 }
 
-func (m *MockArtist) SetData(j string, size int) {
-	m.data = make(map[string]*model.Artist)
-	var l = make([]model.Artist, size)
+func (m *MockArtist) SetData(j string) {
+	m.data = make(map[string]model.Artist)
+	var l = model.Artists{}
 	err := json.Unmarshal([]byte(j), &l)
 	if err != nil {
 		fmt.Println("ERROR: ", err)
 	}
 	for _, a := range l {
-		m.data[a.ID] = &a
+		m.data[a.ID] = a
 	}
 }
 
 func (m *MockArtist) Exists(id string) (bool, error) {
+	if m.err {
+		return false, errors.New("Error!")
+	}
 	_, found := m.data[id]
 	return found, nil
 }
@@ -44,7 +47,7 @@ func (m *MockArtist) Get(id string) (*model.Artist, error) {
 		return nil, errors.New("Error!")
 	}
 	if d, ok := m.data[id]; ok {
-		return d, nil
+		return &d, nil
 	}
 	return nil, model.ErrNotFound
 }

persistence/mock_mediafile_repo.go

@@ -22,9 +22,9 @@ func (m *MockMediaFile) SetError(err bool) {
 	m.err = err
 }
 
-func (m *MockMediaFile) SetData(j string, size int) {
+func (m *MockMediaFile) SetData(j string) {
 	m.data = make(map[string]model.MediaFile)
-	var l = make(model.MediaFiles, size)
+	var l = model.MediaFiles{}
 	err := json.Unmarshal([]byte(j), &l)
 	if err != nil {
 		fmt.Println("ERROR: ", err)

persistence/persistence.go

@@ -3,7 +3,6 @@ package persistence
 import (
 	"context"
 	"reflect"
-	"sync"
 
 	"github.com/astaxie/beego/orm"
 	"github.com/deluan/navidrome/db"
@@ -11,10 +10,6 @@ import (
 	"github.com/deluan/navidrome/model"
 )
 
-var (
-	once sync.Once
-)
-
 type SQLStore struct {
 	orm orm.Ormer
 }
@@ -77,8 +72,10 @@ func (s *SQLStore) Resource(ctx context.Context, m interface{}) model.ResourceRe
 		return s.Album(ctx).(model.ResourceRepository)
 	case model.MediaFile:
 		return s.MediaFile(ctx).(model.ResourceRepository)
+	case model.Playlist:
+		return s.Playlist(ctx).(model.ResourceRepository)
 	}
-	log.Error("Resource no implemented", "model", reflect.TypeOf(m).Name())
+	log.Error("Resource not implemented", "model", reflect.TypeOf(m).Name())
 	return nil
 }
 
@@ -119,18 +116,6 @@ func (s *SQLStore) GC(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	err = s.MediaFile(ctx).(*mediaFileRepository).cleanSearchIndex()
-	if err != nil {
-		return err
-	}
-	err = s.Album(ctx).(*albumRepository).cleanSearchIndex()
-	if err != nil {
-		return err
-	}
-	err = s.Artist(ctx).(*artistRepository).cleanSearchIndex()
-	if err != nil {
-		return err
-	}
 	err = s.MediaFile(ctx).(*mediaFileRepository).cleanAnnotations()
 	if err != nil {
 		return err

persistence/persistence_suite_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/deluan/navidrome/db"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	"github.com/deluan/navidrome/tests"
 	_ "github.com/mattn/go-sqlite3"
 	. "github.com/onsi/ginkgo"
@@ -22,8 +23,7 @@ func TestPersistence(t *testing.T) {
 	//os.Remove("./test-123.db")
 	//conf.Server.Path = "./test-123.db"
 	conf.Server.DbPath = "file::memory:?cache=shared"
-	orm.RegisterDataBase("default", db.Driver, conf.Server.DbPath)
-	New()
+	_ = orm.RegisterDataBase("default", db.Driver, conf.Server.DbPath)
 	db.EnsureLatestVersion()
 	log.SetLevel(log.LevelCritical)
 	RegisterFailHandler(Fail)
@@ -31,8 +31,8 @@ func TestPersistence(t *testing.T) {
 }
 
 var (
-	artistKraftwerk = model.Artist{ID: "2", Name: "Kraftwerk", AlbumCount: 1}
-	artistBeatles   = model.Artist{ID: "3", Name: "The Beatles", AlbumCount: 2}
+	artistKraftwerk = model.Artist{ID: "2", Name: "Kraftwerk", AlbumCount: 1, FullText: " kraftwerk"}
+	artistBeatles   = model.Artist{ID: "3", Name: "The Beatles", AlbumCount: 2, FullText: " beatles the"}
 	testArtists     = model.Artists{
 		artistKraftwerk,
 		artistBeatles,
@@ -40,9 +40,9 @@ var (
 )
 
 var (
-	albumSgtPeppers    = model.Album{ID: "1", Name: "Sgt Peppers", Artist: "The Beatles", ArtistID: "3", Genre: "Rock", CoverArtId: "1", CoverArtPath: P("/beatles/1/sgt/a day.mp3"), SongCount: 1, Year: 1967}
-	albumAbbeyRoad     = model.Album{ID: "2", Name: "Abbey Road", Artist: "The Beatles", ArtistID: "3", Genre: "Rock", CoverArtId: "2", CoverArtPath: P("/beatles/1/come together.mp3"), SongCount: 1, Year: 1969}
-	albumRadioactivity = model.Album{ID: "3", Name: "Radioactivity", Artist: "Kraftwerk", ArtistID: "2", Genre: "Electronic", CoverArtId: "3", CoverArtPath: P("/kraft/radio/radio.mp3"), SongCount: 2}
+	albumSgtPeppers    = model.Album{ID: "101", Name: "Sgt Peppers", Artist: "The Beatles", AlbumArtistID: "3", Genre: "Rock", CoverArtId: "1", CoverArtPath: P("/beatles/1/sgt/a day.mp3"), SongCount: 1, MaxYear: 1967, FullText: " beatles peppers sgt the"}
+	albumAbbeyRoad     = model.Album{ID: "102", Name: "Abbey Road", Artist: "The Beatles", AlbumArtistID: "3", Genre: "Rock", CoverArtId: "2", CoverArtPath: P("/beatles/1/come together.mp3"), SongCount: 1, MaxYear: 1969, FullText: " abbey beatles road the"}
+	albumRadioactivity = model.Album{ID: "103", Name: "Radioactivity", Artist: "Kraftwerk", AlbumArtistID: "2", Genre: "Electronic", CoverArtId: "3", CoverArtPath: P("/kraft/radio/radio.mp3"), SongCount: 2, FullText: " kraftwerk radioactivity"}
 	testAlbums         = model.Albums{
 		albumSgtPeppers,
 		albumAbbeyRoad,
@@ -51,10 +51,10 @@ var (
 )
 
 var (
-	songDayInALife    = model.MediaFile{ID: "1", Title: "A Day In A Life", ArtistID: "3", Artist: "The Beatles", AlbumID: "1", Album: "Sgt Peppers", Genre: "Rock", Path: P("/beatles/1/sgt/a day.mp3")}
-	songComeTogether  = model.MediaFile{ID: "2", Title: "Come Together", ArtistID: "3", Artist: "The Beatles", AlbumID: "2", Album: "Abbey Road", Genre: "Rock", Path: P("/beatles/1/come together.mp3")}
-	songRadioactivity = model.MediaFile{ID: "3", Title: "Radioactivity", ArtistID: "2", Artist: "Kraftwerk", AlbumID: "3", Album: "Radioactivity", Genre: "Electronic", Path: P("/kraft/radio/radio.mp3")}
-	songAntenna       = model.MediaFile{ID: "4", Title: "Antenna", ArtistID: "2", Artist: "Kraftwerk", AlbumID: "3", Genre: "Electronic", Path: P("/kraft/radio/antenna.mp3")}
+	songDayInALife    = model.MediaFile{ID: "1001", Title: "A Day In A Life", ArtistID: "3", Artist: "The Beatles", AlbumID: "101", Album: "Sgt Peppers", Genre: "Rock", Path: P("/beatles/1/sgt/a day.mp3"), FullText: " a beatles day in life peppers sgt the"}
+	songComeTogether  = model.MediaFile{ID: "1002", Title: "Come Together", ArtistID: "3", Artist: "The Beatles", AlbumID: "102", Album: "Abbey Road", Genre: "Rock", Path: P("/beatles/1/come together.mp3"), FullText: " abbey beatles come road the together"}
+	songRadioactivity = model.MediaFile{ID: "1003", Title: "Radioactivity", ArtistID: "2", Artist: "Kraftwerk", AlbumID: "103", Album: "Radioactivity", Genre: "Electronic", Path: P("/kraft/radio/radio.mp3"), FullText: " kraftwerk radioactivity"}
+	songAntenna       = model.MediaFile{ID: "1004", Title: "Antenna", ArtistID: "2", Artist: "Kraftwerk", AlbumID: "103", Genre: "Electronic", Path: P("/kraft/radio/antenna.mp3"), FullText: " antenna kraftwerk"}
 	testSongs         = model.MediaFiles{
 		songDayInALife,
 		songComeTogether,
@@ -65,16 +65,15 @@ var (
 
 var (
 	plsBest = model.Playlist{
-		ID:       "10",
-		Name:     "Best",
-		Comment:  "No Comments",
-		Duration: 10,
-		Owner:    "userid",
-		Public:   true,
-		Tracks:   model.MediaFiles{{ID: "1"}, {ID: "3"}},
+		Name:      "Best",
+		Comment:   "No Comments",
+		Owner:     "userid",
+		Public:    true,
+		SongCount: 2,
+		Tracks:    model.MediaFiles{{ID: "1001"}, {ID: "1003"}},
 	}
-	plsCool       = model.Playlist{ID: "11", Name: "Cool", Tracks: model.MediaFiles{{ID: "4"}}}
-	testPlaylists = model.Playlists{plsBest, plsCool}
+	plsCool       = model.Playlist{Name: "Cool", Owner: "userid", Tracks: model.MediaFiles{{ID: "1004"}}}
+	testPlaylists = []*model.Playlist{&plsBest, &plsCool}
 )
 
 func P(path string) string {
@@ -86,25 +85,29 @@ var _ = Describe("Initialize test DB", func() {
 	// TODO Load this data setup from file(s)
 	BeforeSuite(func() {
 		o := orm.NewOrm()
-		ctx := context.WithValue(log.NewContext(nil), "user", model.User{ID: "userid"})
+		ctx := log.NewContext(context.TODO())
+		ctx = request.WithUser(ctx, model.User{ID: "userid"})
 		mr := NewMediaFileRepository(ctx, o)
-		for _, s := range testSongs {
+		for i := range testSongs {
+			s := testSongs[i]
 			err := mr.Put(&s)
 			if err != nil {
 				panic(err)
 			}
 		}
 
-		alr := NewAlbumRepository(ctx, o)
-		for _, a := range testAlbums {
-			err := alr.Put(&a)
+		alr := NewAlbumRepository(ctx, o).(*albumRepository)
+		for i := range testAlbums {
+			a := testAlbums[i]
+			_, err := alr.put(a.ID, &a)
 			if err != nil {
 				panic(err)
 			}
 		}
 
 		arr := NewArtistRepository(ctx, o)
-		for _, a := range testArtists {
+		for i := range testArtists {
+			a := testArtists[i]
 			err := arr.Put(&a)
 			if err != nil {
 				panic(err)
@@ -112,8 +115,8 @@ var _ = Describe("Initialize test DB", func() {
 		}
 
 		pr := NewPlaylistRepository(ctx, o)
-		for _, pls := range testPlaylists {
-			err := pr.Put(&pls)
+		for i := range testPlaylists {
+			err := pr.Put(testPlaylists[i])
 			if err != nil {
 				panic(err)
 			}

persistence/player_repository.go

@@ -11,6 +11,7 @@ import (
 
 type playerRepository struct {
 	sqlRepository
+	sqlRestful
 }
 
 func NewPlayerRepository(ctx context.Context, o orm.Ormer) model.PlayerRepository {

persistence/playlist_repository.go

@@ -2,25 +2,18 @@ package persistence
 
 import (
 	"context"
-	"strings"
+	"time"
 
 	. "github.com/Masterminds/squirrel"
 	"github.com/astaxie/beego/orm"
+	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/rest"
 )
 
-type playlist struct {
-	ID       string `orm:"column(id)"`
-	Name     string
-	Comment  string
-	Duration float32
-	Owner    string
-	Public   bool
-	Tracks   string
-}
-
 type playlistRepository struct {
 	sqlRepository
+	sqlRestful
 }
 
 func NewPlaylistRepository(ctx context.Context, o orm.Ormer) model.PlaylistRepository {
@@ -31,100 +24,147 @@ func NewPlaylistRepository(ctx context.Context, o orm.Ormer) model.PlaylistRepos
 	return r
 }
 
-func (r *playlistRepository) CountAll() (int64, error) {
-	return r.count(Select())
+func (r *playlistRepository) userFilter() Sqlizer {
+	user := loggedUser(r.ctx)
+	if user.IsAdmin {
+		return And{}
+	}
+	return Or{
+		Eq{"public": true},
+		Eq{"owner": user.UserName},
+	}
+}
+
+func (r *playlistRepository) CountAll(options ...model.QueryOptions) (int64, error) {
+	sql := Select().Where(r.userFilter())
+	return r.count(sql, options...)
 }
 
 func (r *playlistRepository) Exists(id string) (bool, error) {
-	return r.exists(Select().Where(Eq{"id": id}))
+	return r.exists(Select().Where(And{Eq{"id": id}, r.userFilter()}))
 }
 
 func (r *playlistRepository) Delete(id string) error {
-	return r.delete(Eq{"id": id})
-}
-
-func (r *playlistRepository) Put(p *model.Playlist) error {
-	pls := r.fromModel(p)
-	_, err := r.put(pls.ID, pls)
+	err := r.delete(And{Eq{"id": id}, r.userFilter()})
+	if err != nil {
+		return err
+	}
+	del := Delete("playlist_tracks").Where(Eq{"playlist_id": id})
+	_, err = r.executeSQL(del)
 	return err
 }
 
-func (r *playlistRepository) Get(id string) (*model.Playlist, error) {
-	sel := r.newSelect().Columns("*").Where(Eq{"id": id})
-	var res playlist
-	err := r.queryOne(sel, &res)
-	pls := r.toModel(&res)
-	return &pls, err
+func (r *playlistRepository) Put(p *model.Playlist) error {
+	if p.ID == "" {
+		p.CreatedAt = time.Now()
+	} else {
+		ok, err := r.Exists(p.ID)
+		if err != nil {
+			return err
+		}
+		if !ok {
+			return model.ErrNotAuthorized
+		}
+	}
+	p.UpdatedAt = time.Now()
+
+	// Save tracks for later and set it to nil, to avoid trying to save it to the DB
+	tracks := p.Tracks
+	p.Tracks = nil
+
+	id, err := r.put(p.ID, p)
+	if err != nil {
+		return err
+	}
+	p.ID = id
+	err = r.updateTracks(id, tracks)
+	if err != nil {
+		return err
+	}
+	return r.loadTracks(p)
 }
 
-func (r *playlistRepository) GetWithTracks(id string) (*model.Playlist, error) {
-	pls, err := r.Get(id)
+func (r *playlistRepository) Get(id string) (*model.Playlist, error) {
+	sel := r.newSelect().Columns("*").Where(And{Eq{"id": id}, r.userFilter()})
+	var pls model.Playlist
+	err := r.queryOne(sel, &pls)
 	if err != nil {
 		return nil, err
 	}
-	mfRepo := NewMediaFileRepository(r.ctx, r.ormer)
-	pls.Duration = 0
-	newTracks := model.MediaFiles{}
-	for _, t := range pls.Tracks {
-		mf, err := mfRepo.Get(t.ID)
-		if err != nil {
-			continue
-		}
-		pls.Duration += mf.Duration
-		newTracks = append(newTracks, model.MediaFile(*mf))
-	}
-	pls.Tracks = newTracks
-	return pls, err
+	err = r.loadTracks(&pls)
+	return &pls, err
 }
 
 func (r *playlistRepository) GetAll(options ...model.QueryOptions) (model.Playlists, error) {
-	sel := r.newSelect(options...).Columns("*")
-	var res []playlist
+	sel := r.newSelect(options...).Columns("*").Where(r.userFilter())
+	res := model.Playlists{}
 	err := r.queryAll(sel, &res)
-	return r.toModels(res), err
+	return res, err
 }
 
-func (r *playlistRepository) toModels(all []playlist) model.Playlists {
-	result := make(model.Playlists, len(all))
-	for i, p := range all {
-		result[i] = r.toModel(&p)
+func (r *playlistRepository) updateTracks(id string, tracks model.MediaFiles) error {
+	ids := make([]string, len(tracks))
+	for i := range tracks {
+		ids[i] = tracks[i].ID
 	}
-	return result
+	return r.Tracks(id).Update(ids)
 }
 
-func (r *playlistRepository) toModel(p *playlist) model.Playlist {
-	pls := model.Playlist{
-		ID:       p.ID,
-		Name:     p.Name,
-		Comment:  p.Comment,
-		Duration: p.Duration,
-		Owner:    p.Owner,
-		Public:   p.Public,
+func (r *playlistRepository) loadTracks(pls *model.Playlist) error {
+	tracksQuery := Select().From("playlist_tracks").
+		LeftJoin("annotation on ("+
+			"annotation.item_id = media_file_id"+
+			" AND annotation.item_type = 'media_file'"+
+			" AND annotation.user_id = '"+userId(r.ctx)+"')").
+		Columns("starred", "starred_at", "play_count", "play_date", "rating", "f.*").
+		Join("media_file f on f.id = media_file_id").
+		Where(Eq{"playlist_id": pls.ID}).OrderBy("playlist_tracks.id")
+	err := r.queryAll(tracksQuery, &pls.Tracks)
+	if err != nil {
+		log.Error("Error loading playlist tracks", "playlist", pls.Name, "id", pls.ID)
 	}
-	if strings.TrimSpace(p.Tracks) != "" {
-		tracks := strings.Split(p.Tracks, ",")
-		for _, t := range tracks {
-			pls.Tracks = append(pls.Tracks, model.MediaFile{ID: t})
-		}
-	}
-	return pls
+	return err
 }
 
-func (r *playlistRepository) fromModel(p *model.Playlist) playlist {
-	pls := playlist{
-		ID:       p.ID,
-		Name:     p.Name,
-		Comment:  p.Comment,
-		Duration: p.Duration,
-		Owner:    p.Owner,
-		Public:   p.Public,
+func (r *playlistRepository) Count(options ...rest.QueryOptions) (int64, error) {
+	return r.CountAll(r.parseRestOptions(options...))
+}
+
+func (r *playlistRepository) Read(id string) (interface{}, error) {
+	return r.Get(id)
+}
+
+func (r *playlistRepository) ReadAll(options ...rest.QueryOptions) (interface{}, error) {
+	return r.GetAll(r.parseRestOptions(options...))
+}
+
+func (r *playlistRepository) EntityName() string {
+	return "playlist"
+}
+
+func (r *playlistRepository) NewInstance() interface{} {
+	return &model.Playlist{}
+}
+
+func (r *playlistRepository) Save(entity interface{}) (string, error) {
+	pls := entity.(*model.Playlist)
+	pls.Owner = loggedUser(r.ctx).UserName
+	err := r.Put(pls)
+	if err != nil {
+		return "", err
 	}
-	var newTracks []string
-	for _, t := range p.Tracks {
-		newTracks = append(newTracks, t.ID)
+	return pls.ID, err
+}
+
+func (r *playlistRepository) Update(entity interface{}, cols ...string) error {
+	pls := entity.(*model.Playlist)
+	err := r.Put(pls)
+	if err == model.ErrNotFound {
+		return rest.ErrNotFound
 	}
-	pls.Tracks = strings.Join(newTracks, ",")
-	return pls
+	return err
 }
 
 var _ model.PlaylistRepository = (*playlistRepository)(nil)
+var _ rest.Repository = (*playlistRepository)(nil)
+var _ rest.Persistable = (*playlistRepository)(nil)

persistence/playlist_repository_test.go

@@ -1,9 +1,12 @@
 package persistence
 
 import (
+	"context"
+
 	"github.com/astaxie/beego/orm"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -12,7 +15,9 @@ var _ = Describe("PlaylistRepository", func() {
 	var repo model.PlaylistRepository
 
 	BeforeEach(func() {
-		repo = NewPlaylistRepository(log.NewContext(nil), orm.NewOrm())
+		ctx := log.NewContext(context.TODO())
+		ctx = request.WithUser(ctx, model.User{ID: "userid", UserName: "userid", IsAdmin: true})
+		repo = NewPlaylistRepository(ctx, orm.NewOrm())
 	})
 
 	Describe("Count", func() {
@@ -21,9 +26,9 @@ var _ = Describe("PlaylistRepository", func() {
 		})
 	})
 
-	Describe("Exist", func() {
+	Describe("Exists", func() {
 		It("returns true for an existing playlist", func() {
-			Expect(repo.Exists("11")).To(BeTrue())
+			Expect(repo.Exists(plsCool.ID)).To(BeTrue())
 		})
 		It("returns false for a non-existing playlist", func() {
 			Expect(repo.Exists("666")).To(BeFalse())
@@ -32,34 +37,25 @@ var _ = Describe("PlaylistRepository", func() {
 
 	Describe("Get", func() {
 		It("returns an existing playlist", func() {
-			Expect(repo.Get("10")).To(Equal(&plsBest))
+			p, err := repo.Get(plsBest.ID)
+			Expect(err).To(BeNil())
+			// Compare all but Tracks and timestamps
+			p2 := *p
+			p2.Tracks = plsBest.Tracks
+			p2.UpdatedAt = plsBest.UpdatedAt
+			p2.CreatedAt = plsBest.CreatedAt
+			Expect(p2).To(Equal(plsBest))
+			// Compare tracks
+			for i := range p.Tracks {
+				Expect(p.Tracks[i].ID).To(Equal(plsBest.Tracks[i].ID))
+			}
 		})
 		It("returns ErrNotFound for a non-existing playlist", func() {
 			_, err := repo.Get("666")
 			Expect(err).To(MatchError(model.ErrNotFound))
 		})
-	})
-
-	Describe("Put/Get/Delete", func() {
-		newPls := model.Playlist{ID: "22", Name: "Great!", Tracks: model.MediaFiles{{ID: "4"}}}
-		It("saves the playlist to the DB", func() {
-			Expect(repo.Put(&newPls)).To(BeNil())
-		})
-		It("returns the newly created playlist", func() {
-			Expect(repo.Get("22")).To(Equal(&newPls))
-		})
-		It("returns deletes the playlist", func() {
-			Expect(repo.Delete("22")).To(BeNil())
-		})
-		It("returns error if tries to retrieve the deleted playlist", func() {
-			_, err := repo.Get("22")
-			Expect(err).To(MatchError(model.ErrNotFound))
-		})
-	})
-
-	Describe("GetWithTracks", func() {
-		It("returns an existing playlist", func() {
-			pls, err := repo.GetWithTracks("10")
+		It("returns all tracks", func() {
+			pls, err := repo.Get(plsBest.ID)
 			Expect(err).To(BeNil())
 			Expect(pls.Name).To(Equal(plsBest.Name))
 			Expect(pls.Tracks).To(Equal(model.MediaFiles{
@@ -69,9 +65,39 @@ var _ = Describe("PlaylistRepository", func() {
 		})
 	})
 
+	It("Put/Exists/Delete", func() {
+		By("saves the playlist to the DB")
+		newPls := model.Playlist{Name: "Great!", Owner: "userid",
+			Tracks: model.MediaFiles{{ID: "1004"}, {ID: "1003"}}}
+
+		By("saves the playlist to the DB")
+		Expect(repo.Put(&newPls)).To(BeNil())
+
+		By("adds repeated songs to a playlist and keeps the order")
+		newPls.Tracks = append(newPls.Tracks, model.MediaFile{ID: "1004"})
+		Expect(repo.Put(&newPls)).To(BeNil())
+		saved, _ := repo.Get(newPls.ID)
+		Expect(saved.Tracks).To(HaveLen(3))
+		Expect(saved.Tracks[0].ID).To(Equal("1004"))
+		Expect(saved.Tracks[1].ID).To(Equal("1003"))
+		Expect(saved.Tracks[2].ID).To(Equal("1004"))
+
+		By("returns the newly created playlist")
+		Expect(repo.Exists(newPls.ID)).To(BeTrue())
+
+		By("returns deletes the playlist")
+		Expect(repo.Delete(newPls.ID)).To(BeNil())
+
+		By("returns error if tries to retrieve the deleted playlist")
+		Expect(repo.Exists(newPls.ID)).To(BeFalse())
+	})
+
 	Describe("GetAll", func() {
 		It("returns all playlists from DB", func() {
-			Expect(repo.GetAll()).To(Equal(model.Playlists{plsBest, plsCool}))
+			all, err := repo.GetAll()
+			Expect(err).To(BeNil())
+			Expect(all[0].ID).To(Equal(plsBest.ID))
+			Expect(all[1].ID).To(Equal(plsCool.ID))
 		})
 	})
 })

persistence/playlist_track_repository.go

@@ -0,0 +1,157 @@
+package persistence
+
+import (
+	. "github.com/Masterminds/squirrel"
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/rest"
+)
+
+type playlistTrackRepository struct {
+	sqlRepository
+	sqlRestful
+	playlistId string
+}
+
+func (r *playlistRepository) Tracks(playlistId string) model.PlaylistTrackRepository {
+	p := &playlistTrackRepository{}
+	p.playlistId = playlistId
+	p.ctx = r.ctx
+	p.ormer = r.ormer
+	p.tableName = "playlist_tracks"
+	p.sortMappings = map[string]string{
+		"id": "playlist_tracks.id",
+	}
+	return p
+}
+
+func (r *playlistTrackRepository) Count(options ...rest.QueryOptions) (int64, error) {
+	return r.count(Select().Where(Eq{"playlist_id": r.playlistId}), r.parseRestOptions(options...))
+}
+
+func (r *playlistTrackRepository) Read(id string) (interface{}, error) {
+	sel := r.newSelect().
+		LeftJoin("annotation on ("+
+			"annotation.item_id = media_file_id"+
+			" AND annotation.item_type = 'media_file'"+
+			" AND annotation.user_id = '"+userId(r.ctx)+"')").
+		Columns("starred", "starred_at", "play_count", "play_date", "rating", "f.*", "playlist_tracks.*").
+		Join("media_file f on f.id = media_file_id").
+		Where(And{Eq{"playlist_id": r.playlistId}, Eq{"id": id}})
+	var trk model.PlaylistTrack
+	err := r.queryOne(sel, &trk)
+	return &trk, err
+}
+
+func (r *playlistTrackRepository) ReadAll(options ...rest.QueryOptions) (interface{}, error) {
+	sel := r.newSelect(r.parseRestOptions(options...)).
+		LeftJoin("annotation on ("+
+			"annotation.item_id = media_file_id"+
+			" AND annotation.item_type = 'media_file'"+
+			" AND annotation.user_id = '"+userId(r.ctx)+"')").
+		Columns("starred", "starred_at", "play_count", "play_date", "rating", "f.*", "playlist_tracks.*").
+		Join("media_file f on f.id = media_file_id").
+		Where(Eq{"playlist_id": r.playlistId})
+	res := model.PlaylistTracks{}
+	err := r.queryAll(sel, &res)
+	return res, err
+}
+
+func (r *playlistTrackRepository) EntityName() string {
+	return "playlist_tracks"
+}
+
+func (r *playlistTrackRepository) NewInstance() interface{} {
+	return &model.PlaylistTrack{}
+}
+
+func (r *playlistTrackRepository) Add(mediaFileIds []string) error {
+	log.Debug(r.ctx, "Adding songs to playlist", "playlistId", r.playlistId, "mediaFileIds", mediaFileIds)
+
+	// Get all current tracks
+	all := r.newSelect().Columns("media_file_id").Where(Eq{"playlist_id": r.playlistId}).OrderBy("id")
+	var tracks model.PlaylistTracks
+	err := r.queryAll(all, &tracks)
+	if err != nil {
+		log.Error("Error querying current tracks from playlist", "playlistId", r.playlistId, err)
+		return err
+	}
+	ids := make([]string, len(tracks))
+	for i := range tracks {
+		ids[i] = tracks[i].MediaFileID
+	}
+
+	// Append new tracks
+	ids = append(ids, mediaFileIds...)
+
+	// Update tracks and playlist
+	return r.Update(ids)
+}
+
+func (r *playlistTrackRepository) Update(mediaFileIds []string) error {
+	// Remove old tracks
+	del := Delete(r.tableName).Where(Eq{"playlist_id": r.playlistId})
+	_, err := r.executeSQL(del)
+	if err != nil {
+		return err
+	}
+
+	// Break the track list in chunks to avoid hitting SQLITE_MAX_FUNCTION_ARG limit
+	numTracks := len(mediaFileIds)
+	const chunkSize = 50
+	var chunks [][]string
+	for i := 0; i < numTracks; i += chunkSize {
+		end := i + chunkSize
+		if end > numTracks {
+			end = numTracks
+		}
+
+		chunks = append(chunks, mediaFileIds[i:end])
+	}
+
+	// Add new tracks, chunk by chunk
+	pos := 0
+	for i := range chunks {
+		ins := Insert(r.tableName).Columns("playlist_id", "media_file_id", "id")
+		for _, t := range chunks[i] {
+			ins = ins.Values(r.playlistId, t, pos)
+			pos++
+		}
+		_, err = r.executeSQL(ins)
+		if err != nil {
+			return err
+		}
+	}
+
+	return r.updateStats()
+}
+
+func (r *playlistTrackRepository) updateStats() error {
+	// Get total playlist duration and count
+	statsSql := Select("sum(duration) as duration", "count(*) as count").From("media_file").
+		Join("playlist_tracks f on f.media_file_id = media_file.id").
+		Where(Eq{"playlist_id": r.playlistId})
+	var res struct{ Duration, Count float32 }
+	err := r.queryOne(statsSql, &res)
+	if err != nil {
+		return err
+	}
+
+	// Update playlist's total duration and count
+	upd := Update("playlist").
+		Set("duration", res.Duration).
+		Set("song_count", res.Count).
+		Where(Eq{"id": r.playlistId})
+	_, err = r.executeSQL(upd)
+	return err
+}
+
+func (r *playlistTrackRepository) Delete(id string) error {
+	err := r.delete(And{Eq{"playlist_id": r.playlistId}, Eq{"id": id}})
+	if err != nil {
+		return err
+	}
+	return r.updateStats()
+}
+
+var _ model.PlaylistTrackRepository = (*playlistTrackRepository)(nil)

persistence/property_repository.go

@@ -8,11 +8,6 @@ import (
 	"github.com/deluan/navidrome/model"
 )
 
-type property struct {
-	ID    string `orm:"pk;column(id)"`
-	Value string
-}
-
 type propertyRepository struct {
 	sqlRepository
 }

persistence/property_repository_test.go

@@ -1,8 +1,10 @@
 package persistence
 
 import (
+	"context"
+
 	"github.com/astaxie/beego/orm"
-	. "github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -12,7 +14,7 @@ var _ = Describe("Property Repository", func() {
 	var pr model.PropertyRepository
 
 	BeforeEach(func() {
-		pr = NewPropertyRepository(NewContext(nil), orm.NewOrm())
+		pr = NewPropertyRepository(log.NewContext(context.TODO()), orm.NewOrm())
 	})
 
 	It("saves and restore a new property", func() {

persistence/sql_annotations.go

@@ -10,18 +10,6 @@ import (
 	"github.com/google/uuid"
 )
 
-type annotation struct {
-	AnnID     string    `json:"annID"        orm:"pk;column(ann_id)"`
-	UserID    string    `json:"userID"       orm:"pk;column(user_id)"`
-	ItemID    string    `json:"itemID"       orm:"pk;column(item_id)"`
-	ItemType  string    `json:"itemType"`
-	PlayCount int       `json:"playCount"`
-	PlayDate  time.Time `json:"playDate"`
-	Rating    int       `json:"rating"`
-	Starred   bool      `json:"starred"`
-	StarredAt time.Time `json:"starredAt"`
-}
-
 const annotationTable = "annotation"
 
 func (r sqlRepository) newSelectWithAnnotation(idField string, options ...model.QueryOptions) SelectBuilder {

persistence/sql_base_repository.go

@@ -11,7 +11,7 @@ import (
 	"github.com/astaxie/beego/orm"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
-	"github.com/deluan/rest"
+	"github.com/deluan/navidrome/model/request"
 	"github.com/google/uuid"
 )
 
@@ -25,21 +25,19 @@ type sqlRepository struct {
 const invalidUserId = "-1"
 
 func userId(ctx context.Context) string {
-	user := ctx.Value("user")
-	if user == nil {
+	if user, ok := request.UserFrom(ctx); !ok {
 		return invalidUserId
+	} else {
+		return user.ID
 	}
-	usr := user.(model.User)
-	return usr.ID
 }
 
 func loggedUser(ctx context.Context) *model.User {
-	user := ctx.Value("user")
-	if user == nil {
+	if user, ok := request.UserFrom(ctx); !ok {
 		return &model.User{}
+	} else {
+		return &user
 	}
-	u := user.(model.User)
-	return &u
 }
 
 func (r sqlRepository) newSelect(options ...model.QueryOptions) SelectBuilder {
@@ -161,6 +159,7 @@ func (r sqlRepository) count(countQuery SelectBuilder, options ...model.QueryOpt
 
 func (r sqlRepository) put(id string, m interface{}) (newId string, err error) {
 	values, _ := toSqlArgs(m)
+	// Remove created_at from args and save it for later, if needed for insert
 	createdAt := values["created_at"]
 	delete(values, "created_at")
 	if id != "" {
@@ -173,12 +172,13 @@ func (r sqlRepository) put(id string, m interface{}) (newId string, err error) {
 			return id, nil
 		}
 	}
-	// if does not have an id OR could not update (new record with predefined id)
+	// If does not have an id OR could not update (new record with predefined id)
 	if id == "" {
 		rand, _ := uuid.NewRandom()
 		id = rand.String()
 		values["id"] = id
 	}
+	// It is a insert. if there was a created_at, add it back to args
 	if createdAt != nil {
 		values["created_at"] = createdAt
 	}
@@ -215,21 +215,3 @@ func (r sqlRepository) logSQL(sql string, args []interface{}, err error, rowsAff
 		log.Trace(r.ctx, "SQL: `"+sql+"`", "args", `[`+strings.Join(fmtArgs, ",")+`]`, "rowsAffected", rowsAffected, "elapsedTime", elapsed)
 	}
 }
-
-func (r sqlRepository) parseRestOptions(options ...rest.QueryOptions) model.QueryOptions {
-	qo := model.QueryOptions{}
-	if len(options) > 0 {
-		qo.Sort = options[0].Sort
-		qo.Order = strings.ToLower(options[0].Order)
-		qo.Max = options[0].Max
-		qo.Offset = options[0].Offset
-		if len(options[0].Filters) > 0 {
-			filters := And{}
-			for f, v := range options[0].Filters {
-				filters = append(filters, Like{f: fmt.Sprintf("%s%%", v)})
-			}
-			qo.Filters = filters
-		}
-	}
-	return qo
-}

persistence/sql_restful.go

@@ -0,0 +1,68 @@
+package persistence
+
+import (
+	"fmt"
+	"strings"
+
+	. "github.com/Masterminds/squirrel"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/rest"
+)
+
+type filterFunc = func(field string, value interface{}) Sqlizer
+
+type sqlRestful struct {
+	filterMappings map[string]filterFunc
+}
+
+func (r sqlRestful) parseRestFilters(options rest.QueryOptions) Sqlizer {
+	if len(options.Filters) == 0 {
+		return nil
+	}
+	filters := And{}
+	for f, v := range options.Filters {
+		if ff, ok := r.filterMappings[f]; ok {
+			filters = append(filters, ff(f, v))
+		} else if f == "id" {
+			filters = append(filters, eqFilter(f, v))
+		} else {
+			filters = append(filters, startsWithFilter(f, v))
+		}
+	}
+	return filters
+}
+
+func (r sqlRestful) parseRestOptions(options ...rest.QueryOptions) model.QueryOptions {
+	qo := model.QueryOptions{}
+	if len(options) > 0 {
+		qo.Sort = options[0].Sort
+		qo.Order = strings.ToLower(options[0].Order)
+		qo.Max = options[0].Max
+		qo.Offset = options[0].Offset
+		qo.Filters = r.parseRestFilters(options[0])
+	}
+	return qo
+}
+
+func eqFilter(field string, value interface{}) Sqlizer {
+	return Eq{field: value}
+}
+
+func startsWithFilter(field string, value interface{}) Sqlizer {
+	return Like{field: fmt.Sprintf("%s%%", value)}
+}
+
+func booleanFilter(field string, value interface{}) Sqlizer {
+	v := strings.ToLower(value.(string))
+	return Eq{field: strings.ToLower(v) == "true"}
+}
+
+func fullTextFilter(field string, value interface{}) Sqlizer {
+	q := sanitizeStrings(value.(string))
+	parts := strings.Split(q, " ")
+	filters := And{}
+	for _, part := range parts {
+		filters = append(filters, Like{"full_text": "% " + part + "%"})
+	}
+	return filters
+}

persistence/sql_restful_test.go

@@ -0,0 +1,49 @@
+package persistence
+
+import (
+	"github.com/Masterminds/squirrel"
+	"github.com/deluan/rest"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("sqlRestful", func() {
+	Describe("parseRestFilters", func() {
+		var r sqlRestful
+		var options rest.QueryOptions
+
+		BeforeEach(func() {
+			r = sqlRestful{}
+		})
+
+		It("returns nil if filters is empty", func() {
+			options.Filters = nil
+			Expect(r.parseRestFilters(options)).To(BeNil())
+		})
+
+		It("returns a '=' condition for 'id' filter", func() {
+			options.Filters = map[string]interface{}{"id": "123"}
+			Expect(r.parseRestFilters(options)).To(Equal(squirrel.And{squirrel.Eq{"id": "123"}}))
+		})
+
+		It("returns a 'in' condition for multiples 'id' filters", func() {
+			options.Filters = map[string]interface{}{"id": []string{"123", "456"}}
+			Expect(r.parseRestFilters(options)).To(Equal(squirrel.And{squirrel.Eq{"id": []string{"123", "456"}}}))
+		})
+
+		It("returns a 'like' condition for other filters", func() {
+			options.Filters = map[string]interface{}{"name": "joe"}
+			Expect(r.parseRestFilters(options)).To(Equal(squirrel.And{squirrel.Like{"name": "joe%"}}))
+		})
+
+		It("uses the custom filter", func() {
+			r.filterMappings = map[string]filterFunc{
+				"test": func(field string, value interface{}) squirrel.Sqlizer {
+					return squirrel.Gt{field: value}
+				},
+			}
+			options.Filters = map[string]interface{}{"test": 100}
+			Expect(r.parseRestFilters(options)).To(Equal(squirrel.And{squirrel.Gt{"test": 100}}))
+		})
+	})
+})