Sansan/MusicServer
1
0
Fork 0
Code Issues 15 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Sansan/MusicServer:dbef39b8289a2b30c2eb5cead5f1ef792e7b5a93
Branches Tags
Sansan/MusicServer:main Sansan/MusicServer:develop Sansan/MusicServer:4.5.1 Sansan/MusicServer:4.5.0 Sansan/MusicServer:4.0.0
..
compare: Sansan/MusicServer:develop
Branches Tags
Sansan/MusicServer:develop Sansan/MusicServer:main Sansan/MusicServer:4.5.1 Sansan/MusicServer:4.5.0 Sansan/MusicServer:4.0.0
2 Commits
dbef39b828 .. develop
Author SHA1 Message Date
Sansan eda60e0c07 Added fuzzy finder to search, made sync check as middleware, .id file is never used
Build / build (push) Successful in 45s
Details
2026-07-02 09:30:24 +02:00
Sansan a8df738108 #9 Changed the term game to soundtrack everywhere
Build / build (push) Successful in 45s
Details
2026-06-29 18:39:09 +02:00
24 changed files with 1219 additions and 953 deletions
Expand all files Collapse all files
.dockerignore
+31
View File
@@ -0,0 +1,31 @@
# Directories
.gitea
git
.idea
testMusic
testCharacters
# Files
Dockerfile
docker-compose*
compose.yaml
.dockerignore
.gitignore
*.pprof
main
conf.yaml
output.css
tailwindcss
.env
# Node.js (frontend build artifacts)
node_modules
package.json
package-lock.json
# Test files
*_test.go
integration_test.go
# OS
.DS_Store
Dockerfile
+10 -15
View File
@@ -1,33 +1,28 @@
# Stage 1: Build frontend # Stage 1: Build backend
FROM node:18-alpine AS frontend-builder
RUN apk add --no-cache git
WORKDIR /app
RUN git clone https://gitea.sanplex.xyz/Sansan/MusicFrontend.git
WORKDIR /app/MusicFrontend
RUN npm install
RUN npm run build
# Generate config.js with empty API_HOSTNAME (relative paths)
RUN echo "window.__RUNTIME_CONFIG__ = { API_HOSTNAME: '' };" > dist/config.js
# Stage 2: Build backend
FROM golang:1.25-alpine as build_go FROM golang:1.25-alpine as build_go
RUN apk add --no-cache curl RUN apk add --no-cache curl
WORKDIR /app WORKDIR /app
COPY go.mod go.sum ./ COPY go.mod go.sum ./
RUN go mod download RUN go mod download
COPY . . COPY cmd/ ./cmd/
COPY internal/ ./internal/
COPY *.go ./
RUN find . -name "*_test.go" -delete && \
find . -name "integration_test.go" -delete
RUN go install github.com/a-h/templ/cmd/templ@latest RUN go install github.com/a-h/templ/cmd/templ@latest
RUN templ generate RUN templ generate
RUN go build -o main cmd/main.go RUN go build -o main cmd/main.go
# Stage 3: Final image # Stage 2: Final image
FROM golang:1.25-alpine FROM golang:1.25-alpine
EXPOSE 8080 EXPOSE 8080
VOLUME /sorted VOLUME /sorted
VOLUME /characters VOLUME /characters
COPY --from=build_go /app/main . COPY --from=build_go /app/main .
COPY --from=frontend-builder /app/MusicFrontend/dist /frontend COPY --from=gitea.sanplex.xyz/sansan/musicfrontend:latest /usr/share/nginx/html /frontend
# Generate config.js with empty API_HOSTNAME (relative paths)
RUN echo "window.__RUNTIME_CONFIG__ = { API_HOSTNAME: '' };" > /frontend/config.js
COPY ./songs/ ./songs/ COPY ./songs/ ./songs/
ENV PORT 8080 ENV PORT 8080
cmd/docs/docs.go
+40 -40
View File
@@ -23,9 +23,9 @@ var doc = `{
"host": "{{.Host}}", "host": "{{.Host}}",
"basePath": "{{.BasePath}}", "basePath": "{{.BasePath}}",
"paths": { "paths": {
"/api/v1/statistics/games/last-played": { "/api/v1/statistics/soundtracks/last-played": {
"get": { "get": {
"description": "Returns the most recently played games", "description": "Returns the most recently played soundtracks",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -35,7 +35,7 @@ var doc = `{
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get last played games", "summary": "Get last played soundtracks",
"parameters": [ "parameters": [
{ {
"type": "integer", "type": "integer",
@@ -50,7 +50,7 @@ var doc = `{
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -75,9 +75,9 @@ var doc = `{
} }
} }
}, },
"/api/v1/statistics/games/least-played": { "/api/v1/statistics/soundtracks/least-played": {
"get": { "get": {
"description": "Returns the top N least played games with their songs", "description": "Returns the top N least played soundtracks with their songs",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -87,7 +87,7 @@ var doc = `{
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get least played games", "summary": "Get least played soundtracks",
"parameters": [ "parameters": [
{ {
"type": "integer", "type": "integer",
@@ -102,7 +102,7 @@ var doc = `{
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -127,9 +127,9 @@ var doc = `{
} }
} }
}, },
"/api/v1/statistics/games/most-played": { "/api/v1/statistics/soundtracks/most-played": {
"get": { "get": {
"description": "Returns the top N most played games with their songs", "description": "Returns the top N most played soundtracks with their songs",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -139,7 +139,7 @@ var doc = `{
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get most played games", "summary": "Get most played soundtracks",
"parameters": [ "parameters": [
{ {
"type": "integer", "type": "integer",
@@ -154,7 +154,7 @@ var doc = `{
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -179,9 +179,9 @@ var doc = `{
} }
} }
}, },
"/api/v1/statistics/games/never-played": { "/api/v1/statistics/soundtracks/never-played": {
"get": { "get": {
"description": "Returns all games that have never been played (times_played = 0)", "description": "Returns all soundtracks that have never been played (times_played = 0)",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -191,14 +191,14 @@ var doc = `{
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get never played games", "summary": "Get never played soundtracks",
"responses": { "responses": {
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -214,9 +214,9 @@ var doc = `{
} }
} }
}, },
"/api/v1/statistics/games/oldest-played": { "/api/v1/statistics/soundtracks/oldest-played": {
"get": { "get": {
"description": "Returns the least recently played games (that have been played at least once)", "description": "Returns the least recently played soundtracks (that have been played at least once)",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -226,7 +226,7 @@ var doc = `{
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get oldest played games", "summary": "Get oldest played soundtracks",
"parameters": [ "parameters": [
{ {
"type": "integer", "type": "integer",
@@ -241,7 +241,7 @@ var doc = `{
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -824,7 +824,7 @@ var doc = `{
}, },
"/music/all/order": { "/music/all/order": {
"get": { "get": {
"description": "Returns a list of all games in order", "description": "Returns a list of all soundtracks in order",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -857,7 +857,7 @@ var doc = `{
}, },
"/music/all/random": { "/music/all/random": {
"get": { "get": {
"description": "Returns a list of all games in random order", "description": "Returns a list of all soundtracks in random order",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -1197,7 +1197,7 @@ var doc = `{
}, },
"/sync": { "/sync": {
"get": { "get": {
"description": "Starts syncing games with only new changes", "description": "Starts syncing soundtracks with only new changes",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -1226,7 +1226,7 @@ var doc = `{
}, },
"/sync/full": { "/sync/full": {
"get": { "get": {
"description": "Starts a full sync of all games", "description": "Starts a full sync of all soundtracks",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -1236,7 +1236,7 @@ var doc = `{
"tags": [ "tags": [
"sync" "sync"
], ],
"summary": "Sync all games fully", "summary": "Sync all soundtracks fully",
"responses": { "responses": {
"200": { "200": {
"description": "Start syncing soundtracks full", "description": "Start syncing soundtracks full",
@@ -1279,7 +1279,7 @@ var doc = `{
}, },
"/sync/reset": { "/sync/reset": {
"get": { "get": {
"description": "Resets the games database by deleting all games and songs", "description": "Resets the soundtracks database by deleting all soundtracks and songs",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -1369,19 +1369,19 @@ var doc = `{
} }
}, },
"definitions": { "definitions": {
"backend.GameWithSongs": { "backend.SoundtrackWithSongs": {
"type": "object", "type": "object",
"properties": { "properties": {
"game_id": { "soundtrack_id": {
"type": "integer" "type": "integer"
}, },
"game_last_played": { "soundtrack_last_played": {
"type": "string" "type": "string"
}, },
"game_name": { "soundtrack_name": {
"type": "string" "type": "string"
}, },
"game_played": { "soundtrack_played": {
"type": "integer" "type": "integer"
}, },
"songs": { "songs": {
@@ -1398,10 +1398,10 @@ var doc = `{
"file_name": { "file_name": {
"type": "string" "type": "string"
}, },
"game_id": { "soundtrack_id": {
"type": "integer" "type": "integer"
}, },
"game_name": { "soundtrack_name": {
"type": "string" "type": "string"
}, },
"path": { "path": {
@@ -1418,25 +1418,25 @@ var doc = `{
"backend.StatisticsSummary": { "backend.StatisticsSummary": {
"type": "object", "type": "object",
"properties": { "properties": {
"avg_game_plays": { "avg_soundtrack_plays": {
"type": "number" "type": "number"
}, },
"max_game_plays": { "max_soundtrack_plays": {
"type": "integer" "type": "integer"
}, },
"min_game_plays": { "min_soundtrack_plays": {
"type": "integer" "type": "integer"
}, },
"never_played_games": { "never_played_soundtracks": {
"type": "integer" "type": "integer"
}, },
"played_games": { "played_soundtracks": {
"type": "integer" "type": "integer"
}, },
"total_game_plays": { "total_soundtrack_plays": {
"type": "integer" "type": "integer"
}, },
"total_games": { "total_soundtracks": {
"type": "integer" "type": "integer"
} }
} }
cmd/docs/swagger.json
+42 -42
View File
@@ -4,9 +4,9 @@
"contact": {} "contact": {}
}, },
"paths": { "paths": {
"/api/v1/statistics/games/last-played": { "/api/v1/statistics/soundtracks/last-played": {
"get": { "get": {
"description": "Returns the most recently played games", "description": "Returns the most recently played soundtracks",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -16,7 +16,7 @@
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get last played games", "summary": "Get last played soundtracks",
"parameters": [ "parameters": [
{ {
"type": "integer", "type": "integer",
@@ -31,7 +31,7 @@
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -56,9 +56,9 @@
} }
} }
}, },
"/api/v1/statistics/games/least-played": { "/api/v1/statistics/soundtracks/least-played": {
"get": { "get": {
"description": "Returns the top N least played games with their songs", "description": "Returns the top N least played soundtracks with their songs",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -68,7 +68,7 @@
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get least played games", "summary": "Get least played soundtracks",
"parameters": [ "parameters": [
{ {
"type": "integer", "type": "integer",
@@ -83,7 +83,7 @@
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -108,9 +108,9 @@
} }
} }
}, },
"/api/v1/statistics/games/most-played": { "/api/v1/statistics/soundtracks/most-played": {
"get": { "get": {
"description": "Returns the top N most played games with their songs", "description": "Returns the top N most played soundtracks with their songs",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -120,7 +120,7 @@
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get most played games", "summary": "Get most played soundtracks",
"parameters": [ "parameters": [
{ {
"type": "integer", "type": "integer",
@@ -135,7 +135,7 @@
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -160,9 +160,9 @@
} }
} }
}, },
"/api/v1/statistics/games/never-played": { "/api/v1/statistics/soundtracks/never-played": {
"get": { "get": {
"description": "Returns all games that have never been played (times_played = 0)", "description": "Returns all soundtracks that have never been played (times_played = 0)",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -172,14 +172,14 @@
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get never played games", "summary": "Get never played soundtracks",
"responses": { "responses": {
"200": { "200": {
"description": "OK", "description": "OK",
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -195,9 +195,9 @@
} }
} }
}, },
"/api/v1/statistics/games/oldest-played": { "/api/v1/statistics/soundtracks/oldest-played": {
"get": { "get": {
"description": "Returns the least recently played games (that have been played at least once)", "description": "Returns the least recently played soundtracks (that have been played at least once)",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -207,7 +207,7 @@
"tags": [ "tags": [
"statistics" "statistics"
], ],
"summary": "Get oldest played games", "summary": "Get oldest played soundtracks",
"parameters": [ "parameters": [
{ {
"type": "integer", "type": "integer",
@@ -222,7 +222,7 @@
"schema": { "schema": {
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/backend.GameWithSongs" "$ref": "#/definitions/backend.SoundtrackWithSongs"
} }
} }
}, },
@@ -249,7 +249,7 @@
}, },
"/api/v1/statistics/songs/least-played": { "/api/v1/statistics/songs/least-played": {
"get": { "get": {
"description": "Returns the top N least played songs with their game info", "description": "Returns the top N least played songs with their soundtrack info",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -301,7 +301,7 @@
}, },
"/api/v1/statistics/songs/most-played": { "/api/v1/statistics/songs/most-played": {
"get": { "get": {
"description": "Returns the top N most played songs with their game info", "description": "Returns the top N most played songs with their soundtrack info",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -805,7 +805,7 @@
}, },
"/music/all/order": { "/music/all/order": {
"get": { "get": {
"description": "Returns a list of all games in order", "description": "Returns a list of all soundtracks in order",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -838,7 +838,7 @@
}, },
"/music/all/random": { "/music/all/random": {
"get": { "get": {
"description": "Returns a list of all games in random order", "description": "Returns a list of all soundtracks in random order",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -1178,7 +1178,7 @@
}, },
"/sync": { "/sync": {
"get": { "get": {
"description": "Starts syncing games with only new changes", "description": "Starts syncing soundtracks with only new changes",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -1207,7 +1207,7 @@
}, },
"/sync/full": { "/sync/full": {
"get": { "get": {
"description": "Starts a full sync of all games", "description": "Starts a full sync of all soundtracks",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -1217,7 +1217,7 @@
"tags": [ "tags": [
"sync" "sync"
], ],
"summary": "Sync all games fully", "summary": "Sync all soundtracks fully",
"responses": { "responses": {
"200": { "200": {
"description": "Start syncing soundtracks full", "description": "Start syncing soundtracks full",
@@ -1260,7 +1260,7 @@
}, },
"/sync/reset": { "/sync/reset": {
"get": { "get": {
"description": "Resets the games database by deleting all games and songs", "description": "Resets the soundtracks database by deleting all soundtracks and songs",
"consumes": [ "consumes": [
"application/json" "application/json"
], ],
@@ -1350,19 +1350,19 @@
} }
}, },
"definitions": { "definitions": {
"backend.GameWithSongs": { "backend.SoundtrackWithSongs": {
"type": "object", "type": "object",
"properties": { "properties": {
"game_id": { "soundtrack_id": {
"type": "integer" "type": "integer"
}, },
"game_last_played": { "soundtrack_last_played": {
"type": "string" "type": "string"
}, },
"game_name": { "soundtrack_name": {
"type": "string" "type": "string"
}, },
"game_played": { "soundtrack_played": {
"type": "integer" "type": "integer"
}, },
"songs": { "songs": {
@@ -1379,10 +1379,10 @@
"file_name": { "file_name": {
"type": "string" "type": "string"
}, },
"game_id": { "soundtrack_id": {
"type": "integer" "type": "integer"
}, },
"game_name": { "soundtrack_name": {
"type": "string" "type": "string"
}, },
"path": { "path": {
@@ -1399,25 +1399,25 @@
"backend.StatisticsSummary": { "backend.StatisticsSummary": {
"type": "object", "type": "object",
"properties": { "properties": {
"avg_game_plays": { "avg_soundtrack_plays": {
"type": "number" "type": "number"
}, },
"max_game_plays": { "max_soundtrack_plays": {
"type": "integer" "type": "integer"
}, },
"min_game_plays": { "min_soundtrack_plays": {
"type": "integer" "type": "integer"
}, },
"never_played_games": { "never_played_soundtracks": {
"type": "integer" "type": "integer"
}, },
"played_games": { "played_soundtracks": {
"type": "integer" "type": "integer"
}, },
"total_game_plays": { "total_soundtrack_plays": {
"type": "integer" "type": "integer"
}, },
"total_games": { "total_soundtracks": {
"type": "integer" "type": "integer"
} }
} }
cmd/web/hello.go
-117
View File
@@ -1,117 +0,0 @@
package web
import (
"log"
"music-server/internal/backend"
"net/http"
"regexp"
"strings"
)
var games_added []string
func FindGameWebHandler(w http.ResponseWriter, r *http.Request) {
err := r.ParseForm()
if err != nil {
http.Error(w, "Bad Request", http.StatusBadRequest)
}
search_term := r.FormValue("search_term")
search(search_term)
component := FoundGames(games_added)
err = component.Render(r.Context(), w)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
log.Fatalf("Error rendering in FindGameWebHandler: %e", err)
}
}
func search(searchText string) {
games_added = nil
games := backend.GetAllSoundtracks()
for _, game := range games {
if is_match_exact(searchText, game) {
add_game(game)
}
}
for _, game := range games {
if is_match_contains(clean_term(searchText), clean_term(game)) {
add_game(game)
}
}
for _, game := range games {
if is_match_regex(clean_term(searchText), clean_term(game)) {
add_game(game)
}
}
}
func is_match_exact(search_term string, game_name string) bool {
search_term = strings.ToLower(search_term)
game_name = strings.ToLower(game_name)
if search_term == "" {
return true
} else if strings.Contains(game_name, search_term) {
return true
} else {
return false
}
}
func is_match_contains(search_term string, game_name string) bool {
if search_term == "" {
return true
} else if strings.Contains(game_name, search_term) {
return true
} else {
return false
}
}
func is_match_regex(search_term string, game_name string) bool {
if search_term == "" {
return true
} else if compile_regex(search_term).MatchString(game_name) {
return true
} else {
return false
}
}
func add_game(game string) {
if !check_if_game_exists(game) {
games_added = append(games_added, game)
}
}
func check_if_game_exists(gameName string) bool {
game_exists := false
for _, child := range games_added {
if child == gameName {
game_exists = true
}
}
return game_exists
}
func compile_regex(search_term string) *regexp.Regexp {
regText := ".*"
for _, letter := range search_term {
regText += string(letter) + ".*"
}
r, _ := regexp.Compile(regText)
return r
}
func clean_term(term string) string {
term = strings.ReplaceAll(term, " ", "")
term = strings.ReplaceAll(term, "é", "e")
term = strings.ReplaceAll(term, "+", "plus")
term = strings.ReplaceAll(term, "&", "and")
term = strings.ReplaceAll(term, "'n", "and")
return strings.ToLower(term)
}
cmd/web/hello.templ
-54
View File
@@ -1,54 +0,0 @@
package web
templ HelloForm() {
@Base() {
<button id="dark-mode-toggle">🌙</button>
<div id="search-container">
<input id="search_term" name="search_term" type="text" hx-post="/find" hx-trigger="keyup changed delay:0.25s" hx-target="#games-container"/>
<button type="button" id="clear" name="clear">Clear</button>
</div>
<div id="games-container"></div>
<script>
document.addEventListener('readystatechange', () => {
if (document.readyState == 'complete') {
htmx.ajax('POST', '/find', '#games-container');
document.getElementById("search_term").focus();
// Initialize dark mode from localStorage (default to dark)
const savedTheme = localStorage.getItem('theme') || 'dark';
if (savedTheme === 'dark') {
document.documentElement.setAttribute('data-theme', 'dark');
document.getElementById('dark-mode-toggle').textContent = '☀️';
}
}
});
// Dark mode toggle functionality
document.getElementById("dark-mode-toggle").addEventListener("click", function() {
const html = document.documentElement;
const currentTheme = html.getAttribute('data-theme');
const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
html.setAttribute('data-theme', newTheme);
localStorage.setItem('theme', newTheme);
// Update toggle button text
this.textContent = newTheme === 'dark' ? '☀️' : '🌙';
});
document.getElementById("clear").addEventListener("click", function (event) {
document.getElementById("search_term").value = "";
htmx.ajax('POST', '/find', '#games-container');
document.getElementById("search_term").focus();
});
</script>
}
}
templ FoundGames(games []string) {
for _, game := range games {
<div class="bg-green-100 p-4 shadow-md rounded-lg mt-6">
<p class="game-text">{ game }</p>
</div>
}
}
cmd/web/search.go
+403
View File
@@ -0,0 +1,403 @@
package web
import (
"log"
"music-server/internal/backend"
"net/http"
"regexp"
"sort"
"strings"
"sync"
"unicode"
)
var soundtracks_added []string
// Precomputed data for optimization
type SoundtrackData struct {
Original string
Cleaned string
Abbreviation string
}
var (
precomputedSoundtracks []SoundtrackData
precomputedOnce sync.Once
regexCache = make(map[string]*regexp.Regexp)
regexCacheMutex sync.Mutex
)
func FindSoundtrackWebHandler(w http.ResponseWriter, r *http.Request) {
err := r.ParseForm()
if err != nil {
http.Error(w, "Bad Request", http.StatusBadRequest)
}
search_term := r.FormValue("search_term")
search(search_term)
component := FoundSoundtracks(soundtracks_added)
err = component.Render(r.Context(), w)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
log.Fatalf("Error rendering in FindSoundtrackWebHandler: %e", err)
}
}
func search(searchText string) {
soundtracks_added = nil
// Precompute cleaned search term once
cleanedSearchTerm := clean_term(searchText)
// Use precomputed data for efficiency
soundtrackData := getPrecomputedSoundtracks()
seen := make(map[string]bool) // O(1) duplicate checking
for _, data := range soundtrackData {
// Check exact match (case-insensitive contains)
if is_match_exact(searchText, data.Original) && !seen[data.Original] {
soundtracks_added = append(soundtracks_added, data.Original)
seen[data.Original] = true
}
}
for _, data := range soundtrackData {
// Check contains match with cleaned terms
if !seen[data.Original] && is_match_contains(cleanedSearchTerm, data.Cleaned) {
soundtracks_added = append(soundtracks_added, data.Original)
seen[data.Original] = true
}
}
for _, data := range soundtrackData {
// Check regex match with cleaned terms
if !seen[data.Original] && is_match_regex_cached(cleanedSearchTerm, data.Cleaned) {
soundtracks_added = append(soundtracks_added, data.Original)
seen[data.Original] = true
}
}
}
func is_match_exact(search_term string, soundtrack_name string) bool {
search_term = strings.ToLower(search_term)
soundtrack_name = strings.ToLower(soundtrack_name)
if search_term == "" {
return true
} else if strings.Contains(soundtrack_name, search_term) {
return true
} else {
return false
}
}
func is_match_contains(search_term string, soundtrack_name string) bool {
if search_term == "" {
return true
} else if strings.Contains(soundtrack_name, search_term) {
return true
} else {
return false
}
}
func is_match_regex(search_term string, soundtrack_name string) bool {
if search_term == "" {
return true
} else if compile_regex(search_term).MatchString(soundtrack_name) {
return true
} else {
return false
}
}
func compile_regex(search_term string) *regexp.Regexp {
regText := ".*"
for _, letter := range search_term {
regText += string(letter) + ".*"
}
r, _ := regexp.Compile(regText)
return r
}
// is_match_regex_cached uses cached compiled regex patterns for better performance
func is_match_regex_cached(search_term string, soundtrack_name string) bool {
if search_term == "" {
return true
}
// Check cache first
regexCacheMutex.Lock()
re, exists := regexCache[search_term]
if !exists {
re = compile_regex(search_term)
regexCache[search_term] = re
}
regexCacheMutex.Unlock()
return re.MatchString(soundtrack_name)
}
func clean_term(term string) string {
term = strings.ReplaceAll(term, " ", "")
term = strings.ReplaceAll(term, "é", "e")
term = strings.ReplaceAll(term, "+", "plus")
term = strings.ReplaceAll(term, "&", "and")
term = strings.ReplaceAll(term, "'n", "and")
return strings.ToLower(term)
}
// toLower converts a string to lowercase.
func toLower(s string) string {
return strings.Map(unicode.ToLower, s)
}
// levenshteinWithThreshold calculates Levenshtein distance with early termination and space optimization.
// Uses O(min(n,m)) space instead of O(n*m) and stops early if threshold is exceeded.
func levenshteinWithThreshold(s, t string, threshold int) int {
if threshold < 0 {
threshold = 2 // default threshold
}
m, n := len(s), len(t)
// Quick checks for early termination
if m == 0 {
return n
}
if n == 0 {
return m
}
if abs(m-n) > threshold {
return threshold + 1 // Can't be within threshold
}
// Use the shorter string for the row to minimize space
if m < n {
s, t = t, s
m, n = n, m
}
// Space optimization: only store two rows
prevRow := make([]int, n+1)
currRow := make([]int, n+1)
// Initialize first row
for j := 0; j <= n; j++ {
prevRow[j] = j
}
for i := 1; i <= m; i++ {
currRow[0] = i
minInRow := currRow[0]
for j := 1; j <= n; j++ {
if s[i-1] == t[j-1] {
currRow[j] = prevRow[j-1]
} else {
currRow[j] = min3(prevRow[j], currRow[j-1], prevRow[j-1]) + 1
}
if currRow[j] < minInRow {
minInRow = currRow[j]
}
}
// Early termination: if minimum in current row exceeds threshold
if minInRow > threshold {
return threshold + 1
}
// Swap rows for next iteration
prevRow, currRow = currRow, prevRow
}
return prevRow[n]
}
// Helper functions for optimized Levenshtein
func abs(x int) int {
if x < 0 {
return -x
}
return x
}
func min3(a, b, c int) int {
if a < b {
if a < c {
return a
}
return c
}
if b < c {
return b
}
return c
}
// precomputeSoundtrackData initializes cleaned terms and abbreviations for all soundtracks
func precomputeSoundtrackData() {
precomputedOnce.Do(func() {
soundtracks := backend.GetAllSoundtracks()
precomputedSoundtracks = make([]SoundtrackData, len(soundtracks))
for i, soundtrack := range soundtracks {
cleaned := clean_term(soundtrack)
precomputedSoundtracks[i] = SoundtrackData{
Original: soundtrack,
Cleaned: cleaned,
Abbreviation: extractAbbreviation(soundtrack),
}
}
})
}
// getPrecomputedSoundtracks ensures precomputed data is available and returns it
func getPrecomputedSoundtracks() []SoundtrackData {
precomputeSoundtrackData()
return precomputedSoundtracks
}
// levenshtein maintains backward compatibility by calling the optimized version
func levenshtein(s, t string) int {
return levenshteinWithThreshold(s, t, -1) // -1 uses default threshold
}
// extractAbbreviation extracts the first letters of each word in a string.
func extractAbbreviation(s string) string {
words := strings.Fields(s)
abbr := ""
for _, word := range words {
if len(word) > 0 {
abbr += string(word[0])
}
}
return toLower(abbr)
}
// fuzzyFindSubstring checks if the query fuzzy-matches any substring of the item.
func fuzzyFindSubstring(query, item string, threshold int) (bool, int) {
query = toLower(query)
item = toLower(item)
queryLen := len(query)
itemLen := len(item)
if queryLen > itemLen {
return false, 0
}
// Check for exact substring match first (weight: 100)
if strings.Contains(item, query) {
return true, 100
}
// Check for fuzzy substring match using optimized Levenshtein
for i := 0; i <= itemLen-queryLen; i++ {
substring := item[i : i+queryLen]
distance := levenshteinWithThreshold(query, substring, threshold)
if distance <= threshold {
// Weight: higher for matches at the start of the string
weight := 50 - i // Higher weight for earlier matches
return true, weight
}
}
return false, 0
}
// fuzzyFind checks if the query matches the item (substring or abbreviation).
func fuzzyFind(query string, item string, threshold int) (bool, int) {
query = toLower(query)
item = toLower(item)
// Check for substring fuzzy match
if matched, weight := fuzzyFindSubstring(query, item, threshold); matched {
return true, weight
}
// Check for abbreviation match using optimized Levenshtein
abbr := extractAbbreviation(item)
distance := levenshteinWithThreshold(query, abbr, threshold)
if distance <= threshold {
// Weight: higher for exact abbreviation matches
weight := 100 - distance*10 // Higher weight for exact matches
return true, weight
}
return false, 0
}
// getAdaptiveThreshold returns a threshold based on query length
func getAdaptiveThreshold(query string) int {
threshold := 2 // Base threshold for minor typos
queryLen := len(query)
if queryLen > 6 {
// For longer queries, allow more tolerance
threshold = queryLen / 3
if threshold < 2 {
threshold = 2
} else if threshold > 4 {
threshold = 4 // Cap at 4 for very long queries
}
}
return threshold
}
// fuzzySearch performs fuzzy search on soundtracks using the cleaned terms for consistency
func fuzzySearch(searchText string) []string {
query := clean_term(searchText)
threshold := getAdaptiveThreshold(query)
// Use precomputed data for efficiency
soundtrackData := getPrecomputedSoundtracks()
type match struct {
item string
weight int
}
var matches []match
seen := make(map[string]bool) // O(1) duplicate checking
for _, data := range soundtrackData {
if matched, weight := fuzzyFind(query, data.Cleaned, threshold); matched {
if !seen[data.Original] {
matches = append(matches, match{data.Original, weight})
seen[data.Original] = true
}
}
}
// Sort matches by weight (descending)
sort.Slice(matches, func(i, j int) bool {
return matches[i].weight > matches[j].weight
})
// Extract just the soundtrack names in order
result := make([]string, len(matches))
for i, m := range matches {
result[i] = m.item
}
return result
}
// FindSoundtrackFuzzyWebHandler handles fuzzy search requests
func FindSoundtrackFuzzyWebHandler(w http.ResponseWriter, r *http.Request) {
err := r.ParseForm()
if err != nil {
http.Error(w, "Bad Request", http.StatusBadRequest)
return
}
search_term := r.FormValue("search_term")
results := fuzzySearch(search_term)
component := FoundSoundtracks(results)
err = component.Render(r.Context(), w)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
log.Fatalf("Error rendering in FindSoundtrackFuzzyWebHandler: %e", err)
}
}
cmd/web/search.templ
+81
View File
@@ -0,0 +1,81 @@
package web
templ SearchForm() {
@Base() {
<button id="dark-mode-toggle">🌙</button>
<div id="search-container">
<input id="search_term" name="search_term" type="text" hx-post="/findfuzzy" hx-trigger="keyup changed delay:0.25s" hx-target="#soundtracks-container"/>
<div class="radio-group" style="display: inline-block; margin-left: 10px;">
<label><input type="radio" name="search_type" value="fuzzy" checked> Fuzzy</label>
<label><input type="radio" name="search_type" value="normal"> Normal</label>
</div>
<button type="button" id="clear" name="clear">Clear</button>
</div>
<div id="soundtracks-container"></div>
<script>
// Get current search type from radio buttons
function getSearchType() {
return document.querySelector('input[name="search_type"]:checked').value;
}
// Get endpoint based on search type
function getSearchEndpoint() {
return getSearchType() === 'fuzzy' ? '/findfuzzy' : '/find';
}
// Update search input endpoint
function updateSearchEndpoint() {
const endpoint = getSearchEndpoint();
document.getElementById('search_term').setAttribute('hx-post', endpoint);
}
document.addEventListener('readystatechange', () => {
if (document.readyState == 'complete') {
// Initialize with fuzzy search (default)
htmlx.ajax('POST', '/findfuzzy', '#soundtracks-container');
document.getElementById("search_term").focus();
// Add event listeners for radio buttons
document.querySelectorAll('input[name="search_type"]').forEach(radio => {
radio.addEventListener('change', updateSearchEndpoint);
});
// Initialize dark mode from localStorage (default to dark)
const savedTheme = localStorage.getItem('theme') || 'dark';
if (savedTheme === 'dark') {
document.documentElement.setAttribute('data-theme', 'dark');
document.getElementById('dark-mode-toggle').textContent = '☀️';
}
}
});
// Dark mode toggle functionality
document.getElementById("dark-mode-toggle").addEventListener("click", function() {
const html = document.documentElement;
const currentTheme = html.getAttribute('data-theme');
const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
html.setAttribute('data-theme', newTheme);
localStorage.setItem('theme', newTheme);
// Update toggle button text
this.textContent = newTheme === 'dark' ? '☀️' : '🌙';
});
document.getElementById("clear").addEventListener("click", function (event) {
document.getElementById("search_term").value = "";
// Use current search type endpoint
htmlx.ajax('POST', getSearchEndpoint(), '#soundtracks-container');
document.getElementById("search_term").focus();
});
</script>
}
}
templ FoundSoundtracks(soundtracks []string) {
for _, soundtrack := range soundtracks {
<div class="bg-green-100 p-4 shadow-md rounded-lg mt-6">
<p class="soundtrack-text">{ soundtrack }</p>
</div>
}
}
internal/backend/music.go
+50 -50
View File
@@ -12,8 +12,8 @@ import (
) )
type SongInfo struct { type SongInfo struct {
Game string `json:"Game"` Soundtrack string `json:"Soundtrack"`
GamePlayed int32 `json:"GamePlayed"` SoundtrackPlayed int32 `json:"SoundtrackPlayed"`
Song string `json:"Song"` Song string `json:"Song"`
SongPlayed int32 `json:"SongPlayed"` SongPlayed int32 `json:"SongPlayed"`
CurrentlyPlaying bool `json:"CurrentlyPlaying"` CurrentlyPlaying bool `json:"CurrentlyPlaying"`
@@ -22,7 +22,7 @@ type SongInfo struct {
var currentSong = -1 var currentSong = -1
var gamesNew []repository.Soundtrack var soundtracksNew []repository.Soundtrack
var songQueNew []repository.Song var songQueNew []repository.Song
@@ -37,12 +37,12 @@ func initRepo() {
} }
} }
func getAllGames() []repository.Soundtrack { func getAllSoundtracks() []repository.Soundtrack {
if len(gamesNew) == 0 { if len(soundtracksNew) == 0 {
initRepo() initRepo()
gamesNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx()) soundtracksNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
} }
return gamesNew return soundtracksNew
} }
@@ -59,7 +59,7 @@ func Reset() {
songQueNew = nil songQueNew = nil
currentSong = -1 currentSong = -1
initRepo() initRepo()
gamesNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx()) soundtracksNew, _ = BackendRepo().FindAllSoundtracks(BackendCtx())
} }
func AddLatestToQue() { func AddLatestToQue() {
@@ -92,34 +92,34 @@ func SetPlayed(songNumber int) {
} }
func GetRandomSong() string { func GetRandomSong() string {
getAllGames() getAllSoundtracks()
if len(gamesNew) == 0 { if len(soundtracksNew) == 0 {
return "" return ""
} }
song := getSongFromList(gamesNew) song := getSongFromList(soundtracksNew)
lastFetchedNew = song lastFetchedNew = song
return song.Path return song.Path
} }
func GetRandomSongLowChance() string { func GetRandomSongLowChance() string {
getAllGames() getAllSoundtracks()
var listOfGames []repository.Soundtrack var listOfSoundtracks []repository.Soundtrack
var averagePlayed = getAveragePlayed() var averagePlayed = getAveragePlayed()
for _, data := range gamesNew { for _, data := range soundtracksNew {
timesToAdd := averagePlayed - data.TimesPlayed timesToAdd := averagePlayed - data.TimesPlayed
if timesToAdd <= 0 { if timesToAdd <= 0 {
listOfGames = append(listOfGames, data) listOfSoundtracks = append(listOfSoundtracks, data)
} else { } else {
for i := int32(0); i < timesToAdd; i++ { for i := int32(0); i < timesToAdd; i++ {
listOfGames = append(listOfGames, data) listOfSoundtracks = append(listOfSoundtracks, data)
} }
} }
} }
song := getSongFromList(listOfGames) song := getSongFromList(listOfSoundtracks)
lastFetchedNew = song lastFetchedNew = song
return song.Path return song.Path
@@ -127,11 +127,11 @@ func GetRandomSongLowChance() string {
} }
func GetRandomSongClassic() string { func GetRandomSongClassic() string {
getAllGames() getAllSoundtracks()
var listOfAllSongs []repository.Song var listOfAllSongs []repository.Song
for _, game := range gamesNew { for _, soundtrack := range soundtracksNew {
songList, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), game.ID) songList, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), soundtrack.ID)
listOfAllSongs = append(listOfAllSongs, songList...) listOfAllSongs = append(listOfAllSongs, songList...)
} }
@@ -139,25 +139,25 @@ func GetRandomSongClassic() string {
var song repository.Song var song repository.Song
for !songFound { for !songFound {
song = listOfAllSongs[rand.Intn(len(listOfAllSongs))] song = listOfAllSongs[rand.Intn(len(listOfAllSongs))]
gameData, err := BackendRepo().GetSoundtrackById(BackendCtx(), song.SoundtrackID) soundtrackData, err := BackendRepo().GetSoundtrackById(BackendCtx(), song.SoundtrackID)
if err != nil { if err != nil {
BackendRepo().RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: song.SoundtrackID, Path: song.Path}) BackendRepo().RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: song.SoundtrackID, Path: song.Path})
logging.GetLogger().Warn("Song not found, removed from database", logging.GetLogger().Warn("Song not found, removed from database",
zap.String("song", song.SongName), zap.String("song", song.SongName),
zap.String("game", gameData.SoundtrackName), zap.String("soundtrack", soundtrackData.SoundtrackName),
zap.String("filename", *song.FileName)) zap.String("filename", *song.FileName))
continue continue
} }
//Check if file exists and open //Check if file exists and open
openFile, err := os.Open(song.Path) openFile, err := os.Open(song.Path)
if err != nil || (song.FileName != nil && gameData.Path+*song.FileName != song.Path) { if err != nil || (song.FileName != nil && soundtrackData.Path+*song.FileName != song.Path) {
//File not found //File not found
BackendRepo().RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: song.SoundtrackID, Path: song.Path}) BackendRepo().RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: song.SoundtrackID, Path: song.Path})
logging.GetLogger().Warn("Song not found, removed from database", logging.GetLogger().Warn("Song not found, removed from database",
zap.String("song", song.SongName), zap.String("song", song.SongName),
zap.String("game", gameData.SoundtrackName), zap.String("soundtrack", soundtrackData.SoundtrackName),
zap.String("filename", *song.FileName)) zap.String("filename", *song.FileName))
} else { } else {
songFound = true songFound = true
@@ -177,11 +177,11 @@ func GetSongInfo() SongInfo {
} }
var currentSongData = songQueNew[currentSong] var currentSongData = songQueNew[currentSong]
currentGameData := getCurrentGame(currentSongData) currentSoundtrackData := getCurrentSoundtrack(currentSongData)
return SongInfo{ return SongInfo{
Game: currentGameData.SoundtrackName, Soundtrack: currentSoundtrackData.SoundtrackName,
GamePlayed: currentGameData.TimesPlayed, SoundtrackPlayed: currentSoundtrackData.TimesPlayed,
Song: currentSongData.SongName, Song: currentSongData.SongName,
SongPlayed: currentSongData.TimesPlayed, SongPlayed: currentSongData.TimesPlayed,
CurrentlyPlaying: true, CurrentlyPlaying: true,
@@ -193,10 +193,10 @@ func GetPlayedSongs() []SongInfo {
var songList []SongInfo var songList []SongInfo
for i, song := range songQueNew { for i, song := range songQueNew {
gameData := getCurrentGame(song) soundtrackData := getCurrentSoundtrack(song)
songList = append(songList, SongInfo{ songList = append(songList, SongInfo{
Game: gameData.SoundtrackName, Soundtrack: soundtrackData.SoundtrackName,
GamePlayed: gameData.TimesPlayed, SoundtrackPlayed: soundtrackData.TimesPlayed,
Song: song.SongName, Song: song.SongName,
SongPlayed: song.TimesPlayed, SongPlayed: song.TimesPlayed,
CurrentlyPlaying: i == currentSong, CurrentlyPlaying: i == currentSong,
@@ -218,21 +218,21 @@ func GetSong(song string) string {
} }
func GetAllSoundtracks() []string { func GetAllSoundtracks() []string {
getAllGames() getAllSoundtracks()
var jsonArray []string var jsonArray []string
for _, game := range gamesNew { for _, soundtrack := range soundtracksNew {
jsonArray = append(jsonArray, game.SoundtrackName) jsonArray = append(jsonArray, soundtrack.SoundtrackName)
} }
return jsonArray return jsonArray
} }
func GetAllSoundtracksRandom() []string { func GetAllSoundtracksRandom() []string {
getAllGames() getAllSoundtracks()
var jsonArray []string var jsonArray []string
for _, game := range gamesNew { for _, soundtrack := range soundtracksNew {
jsonArray = append(jsonArray, game.SoundtrackName) jsonArray = append(jsonArray, soundtrack.SoundtrackName)
} }
rand.Shuffle(len(jsonArray), func(i, j int) { jsonArray[i], jsonArray[j] = jsonArray[j], jsonArray[i] }) rand.Shuffle(len(jsonArray), func(i, j int) { jsonArray[i], jsonArray[j] = jsonArray[j], jsonArray[i] })
return jsonArray return jsonArray
@@ -266,12 +266,12 @@ func GetPreviousSong() string {
} }
} }
func getSongFromList(games []repository.Soundtrack) repository.Song { func getSongFromList(soundtracks []repository.Soundtrack) repository.Song {
songFound := false songFound := false
var song repository.Song var song repository.Song
for !songFound { for !songFound {
game := getRandomGame(games) soundtrack := getRandomSoundtrack(soundtracks)
songs, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), game.ID) songs, _ := BackendRepo().FindSongsFromSoundtrack(BackendCtx(), soundtrack.ID)
if len(songs) == 0 { if len(songs) == 0 {
continue continue
} }
@@ -280,12 +280,12 @@ func getSongFromList(games []repository.Soundtrack) repository.Song {
//Check if file exists and open //Check if file exists and open
openFile, err := os.Open(song.Path) openFile, err := os.Open(song.Path)
if err != nil || (song.FileName != nil && game.Path+*song.FileName != song.Path) || (song.FileName != nil && strings.HasSuffix(*song.FileName, ".wav")) { if err != nil || (song.FileName != nil && soundtrack.Path+*song.FileName != song.Path) || (song.FileName != nil && strings.HasSuffix(*song.FileName, ".wav")) {
//File not found //File not found
BackendRepo().RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: song.SoundtrackID, Path: song.Path}) BackendRepo().RemoveBrokenSong(BackendCtx(), repository.RemoveBrokenSongParams{SoundtrackID: song.SoundtrackID, Path: song.Path})
logging.GetLogger().Warn("Song not found, removed from database", logging.GetLogger().Warn("Song not found, removed from database",
zap.String("song", song.SongName), zap.String("song", song.SongName),
zap.String("game", game.SoundtrackName), zap.String("soundtrack", soundtrack.SoundtrackName),
zap.Any("filename", song.FileName)) zap.Any("filename", song.FileName))
} else { } else {
songFound = true songFound = true
@@ -299,24 +299,24 @@ func getSongFromList(games []repository.Soundtrack) repository.Song {
return song return song
} }
func getCurrentGame(currentSongData repository.Song) repository.Soundtrack { func getCurrentSoundtrack(currentSongData repository.Song) repository.Soundtrack {
for _, game := range gamesNew { for _, soundtrack := range soundtracksNew {
if game.ID == currentSongData.SoundtrackID { if soundtrack.ID == currentSongData.SoundtrackID {
return game return soundtrack
} }
} }
return repository.Soundtrack{} return repository.Soundtrack{}
} }
func getAveragePlayed() int32 { func getAveragePlayed() int32 {
getAllGames() getAllSoundtracks()
var sum int32 var sum int32
for _, data := range gamesNew { for _, data := range soundtracksNew {
sum += data.TimesPlayed sum += data.TimesPlayed
} }
return sum / int32(len(gamesNew)) return sum / int32(len(soundtracksNew))
} }
func getRandomGame(listOfGames []repository.Soundtrack) repository.Soundtrack { func getRandomSoundtrack(listOfSoundtracks []repository.Soundtrack) repository.Soundtrack {
return listOfGames[rand.Intn(len(listOfGames))] return listOfSoundtracks[rand.Intn(len(listOfSoundtracks))]
} }
internal/backend/music_test.go
+62 -62
View File
@@ -9,17 +9,17 @@ import (
// Test the average calculation logic directly without database access // Test the average calculation logic directly without database access
func TestCalculateAverage(t *testing.T) { func TestCalculateAverage(t *testing.T) {
games := []repository.Soundtrack{ soundtracks := []repository.Soundtrack{
{SoundtrackName: "Game1", TimesPlayed: 10}, {SoundtrackName: "Soundtrack1", TimesPlayed: 10},
{SoundtrackName: "Game2", TimesPlayed: 20}, {SoundtrackName: "Soundtrack2", TimesPlayed: 20},
{SoundtrackName: "Game3", TimesPlayed: 30}, {SoundtrackName: "Soundtrack3", TimesPlayed: 30},
} }
var sum int32 var sum int32
for _, data := range games { for _, data := range soundtracks {
sum += data.TimesPlayed sum += data.TimesPlayed
} }
result := sum / int32(len(games)) result := sum / int32(len(soundtracks))
expected := int32(20) expected := int32(20)
if result != expected { if result != expected {
@@ -28,9 +28,9 @@ func TestCalculateAverage(t *testing.T) {
} }
func TestCalculateAverageEmpty(t *testing.T) { func TestCalculateAverageEmpty(t *testing.T) {
games := []repository.Soundtrack{} soundtracks := []repository.Soundtrack{}
if len(games) == 0 { if len(soundtracks) == 0 {
result := int32(0) result := int32(0)
expected := int32(0) expected := int32(0)
if result != expected { if result != expected {
@@ -40,10 +40,10 @@ func TestCalculateAverageEmpty(t *testing.T) {
} }
var sum int32 var sum int32
for _, data := range games { for _, data := range soundtracks {
sum += data.TimesPlayed sum += data.TimesPlayed
} }
result := sum / int32(len(games)) result := sum / int32(len(soundtracks))
expected := int32(0) expected := int32(0)
if result != expected { if result != expected {
@@ -52,107 +52,107 @@ func TestCalculateAverageEmpty(t *testing.T) {
} }
func TestCalculateAverageSingle(t *testing.T) { func TestCalculateAverageSingle(t *testing.T) {
games := []repository.Soundtrack{ soundtracks := []repository.Soundtrack{
{SoundtrackName: "Game1", TimesPlayed: 42}, {SoundtrackName: "Soundtrack1", TimesPlayed: 42},
} }
var sum int32 var sum int32
for _, data := range games { for _, data := range soundtracks {
sum += data.TimesPlayed sum += data.TimesPlayed
} }
result := sum / int32(len(games)) result := sum / int32(len(soundtracks))
expected := int32(42) expected := int32(42)
if result != expected { if result != expected {
t.Errorf("Average calculation with single game = %v, want %v", result, expected) t.Errorf("Average calculation with single soundtrack = %v, want %v", result, expected)
} }
} }
func TestGetRandomGame(t *testing.T) { func TestGetRandomSoundtrack(t *testing.T) {
games := []repository.Soundtrack{ soundtracks := []repository.Soundtrack{
{SoundtrackName: "Game1", TimesPlayed: 10}, {SoundtrackName: "Soundtrack1", TimesPlayed: 10},
{SoundtrackName: "Game2", TimesPlayed: 20}, {SoundtrackName: "Soundtrack2", TimesPlayed: 20},
{SoundtrackName: "Game3", TimesPlayed: 30}, {SoundtrackName: "Soundtrack3", TimesPlayed: 30},
} }
// Set seed for reproducible tests // Set seed for reproducible tests
rand.Seed(42) rand.Seed(42)
result := games[rand.Intn(len(games))] result := soundtracks[rand.Intn(len(soundtracks))]
if result.SoundtrackName == "" { if result.SoundtrackName == "" {
t.Error("random game selection returned empty game") t.Error("random soundtrack selection returned empty soundtrack")
} }
found := false found := false
for _, g := range games { for _, s := range soundtracks {
if g.SoundtrackName == result.SoundtrackName { if s.SoundtrackName == result.SoundtrackName {
found = true found = true
break break
} }
} }
if !found { if !found {
t.Errorf("random game selection returned game not in list: %v", result.SoundtrackName) t.Errorf("random soundtrack selection returned soundtrack not in list: %v", result.SoundtrackName)
} }
} }
func TestFindGameByID(t *testing.T) { func TestFindSoundtrackByID(t *testing.T) {
games := []repository.Soundtrack{ soundtracks := []repository.Soundtrack{
{ID: 1, SoundtrackName: "Game1", TimesPlayed: 10}, {ID: 1, SoundtrackName: "Soundtrack1", TimesPlayed: 10},
{ID: 2, SoundtrackName: "Game2", TimesPlayed: 20}, {ID: 2, SoundtrackName: "Soundtrack2", TimesPlayed: 20},
{ID: 3, SoundtrackName: "Game3", TimesPlayed: 30}, {ID: 3, SoundtrackName: "Soundtrack3", TimesPlayed: 30},
} }
tests := []struct { tests := []struct {
name string name string
games []repository.Soundtrack soundtracks []repository.Soundtrack
gameID int32 soundtrackID int32
expected repository.Soundtrack expected repository.Soundtrack
}{ }{
{ {
name: "existing game", name: "existing soundtrack",
games: games, soundtracks: soundtracks,
gameID: 2, soundtrackID: 2,
expected: repository.Soundtrack{ID: 2, SoundtrackName: "Game2", TimesPlayed: 20}, expected: repository.Soundtrack{ID: 2, SoundtrackName: "Soundtrack2", TimesPlayed: 20},
}, },
{ {
name: "non-existing game", name: "non-existing soundtrack",
games: games, soundtracks: soundtracks,
gameID: 99, soundtrackID: 99,
expected: repository.Soundtrack{}, expected: repository.Soundtrack{},
}, },
} }
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
var result repository.Soundtrack var result repository.Soundtrack
for _, game := range tt.games { for _, s := range tt.soundtracks {
if game.ID == tt.gameID { if s.ID == tt.soundtrackID {
result = game result = s
break break
} }
} }
if result.ID != tt.expected.ID || result.SoundtrackName != tt.expected.SoundtrackName { if result.ID != tt.expected.ID || result.SoundtrackName != tt.expected.SoundtrackName {
t.Errorf("findGameByID() = %v, want %v", result, tt.expected) t.Errorf("findSoundtrackByID() = %v, want %v", result, tt.expected)
} }
}) })
} }
} }
func TestExtractSoundtrackNames(t *testing.T) { func TestExtractSoundtrackNames(t *testing.T) {
games := []repository.Soundtrack{ soundtracks := []repository.Soundtrack{
{SoundtrackName: "Game1", TimesPlayed: 10}, {SoundtrackName: "Soundtrack1", TimesPlayed: 10},
{SoundtrackName: "Game2", TimesPlayed: 20}, {SoundtrackName: "Soundtrack2", TimesPlayed: 20},
{SoundtrackName: "Game3", TimesPlayed: 30}, {SoundtrackName: "Soundtrack3", TimesPlayed: 30},
} }
var result []string var result []string
for _, game := range games { for _, s := range soundtracks {
result = append(result, game.SoundtrackName) result = append(result, s.SoundtrackName)
} }
expected := []string{"Game1", "Game2", "Game3"} expected := []string{"Soundtrack1", "Soundtrack2", "Soundtrack3"}
if len(result) != len(expected) { if len(result) != len(expected) {
t.Errorf("extractSoundtrackNames() length = %d, want %d", len(result), len(expected)) t.Errorf("extractSoundtrackNames() length = %d, want %d", len(result), len(expected))
@@ -167,29 +167,29 @@ func TestExtractSoundtrackNames(t *testing.T) {
} }
func TestShuffleSoundtrackNames(t *testing.T) { func TestShuffleSoundtrackNames(t *testing.T) {
games := []string{"Game1", "Game2", "Game3"} soundtracks := []string{"Soundtrack1", "Soundtrack2", "Soundtrack3"}
// Test that shuffle doesn't lose any elements // Test that shuffle doesn't lose any elements
// We can't test the order since it's random, but we can test length and contents // We can't test the order since it's random, but we can test length and contents
original := make([]string, len(games)) original := make([]string, len(soundtracks))
copy(original, games) copy(original, soundtracks)
// Simple shuffle implementation for testing // Simple shuffle implementation for testing
for i := range games { for i := range soundtracks {
j := i // In real code this would be random j := i // In real code this would be random
games[i], games[j] = games[j], games[i] soundtracks[i], soundtracks[j] = soundtracks[j], soundtracks[i]
} }
if len(games) != len(original) { if len(soundtracks) != len(original) {
t.Errorf("shuffleSoundtrackNames() changed length from %d to %d", len(original), len(games)) t.Errorf("shuffleSoundtrackNames() changed length from %d to %d", len(original), len(soundtracks))
return return
} }
// Check all original elements are still present // Check all original elements are still present
for _, orig := range original { for _, orig := range original {
found := false found := false
for _, g := range games { for _, s := range soundtracks {
if g == orig { if s == orig {
found = true found = true
break break
} }
internal/backend/statistics.go
+108 -108
View File
@@ -9,34 +9,34 @@ import (
"go.uber.org/zap" "go.uber.org/zap"
) )
// GameWithSongs represents a game with its songs for statistics // SoundtrackWithSongs represents a soundtrack with its songs for statistics
type GameWithSongs struct { type SoundtrackWithSongs struct {
SoundtrackID int32 `json:"game_id"` SoundtrackID int32 `json:"soundtrack_id"`
SoundtrackName string `json:"game_name"` SoundtrackName string `json:"soundtrack_name"`
SoundtrackPlayed int32 `json:"game_played"` SoundtrackPlayed int32 `json:"soundtrack_played"`
SoundtrackLastPlayed *time.Time `json:"game_last_played,omitempty"` SoundtrackLastPlayed *time.Time `json:"soundtrack_last_played,omitempty"`
Songs []SongInfoForStats `json:"songs"` Songs []SongInfoForStats `json:"songs"`
} }
// SongInfoForStats represents a song with game info for statistics // SongInfoForStats represents a song with soundtrack info for statistics
type SongInfoForStats struct { type SongInfoForStats struct {
SoundtrackID int32 `json:"game_id"` SoundtrackID int32 `json:"soundtrack_id"`
SoundtrackName string `json:"game_name"` SoundtrackName string `json:"soundtrack_name"`
SongName string `json:"song_name"` SongName string `json:"song_name"`
Path string `json:"path"` Path string `json:"path"`
TimesPlayed int32 `json:"times_played"` TimesPlayed int32 `json:"times_played"`
FileName *string `json:"file_name,omitempty"` FileName *string `json:"file_name,omitempty"`
} }
// StatisticsSummary holds overall statistics // StatisticsSummary holds overall statistics
type StatisticsSummary struct { type StatisticsSummary struct {
TotalGames int64 `json:"total_games"` TotalSoundtracks int64 `json:"total_soundtracks"`
PlayedGames int64 `json:"played_games"` PlayedSoundtracks int64 `json:"played_soundtracks"`
NeverPlayedGames int64 `json:"never_played_games"` NeverPlayedSoundtracks int64 `json:"never_played_soundtracks"`
TotalGamePlays int64 `json:"total_game_plays"` TotalSoundtrackPlays int64 `json:"total_soundtrack_plays"`
AvgGamePlays float64 `json:"avg_game_plays"` AvgSoundtrackPlays float64 `json:"avg_soundtrack_plays"`
MaxGamePlays int64 `json:"max_game_plays"` MaxSoundtrackPlays int64 `json:"max_soundtrack_plays"`
MinGamePlays int64 `json:"min_game_plays"` MinSoundtrackPlays int64 `json:"min_soundtrack_plays"`
} }
// StatisticsHandler manages statistics operations // StatisticsHandler manages statistics operations
@@ -49,19 +49,19 @@ func NewStatisticsHandler() *StatisticsHandler {
return &StatisticsHandler{} return &StatisticsHandler{}
} }
// GetMostPlayedGamesWithSongs returns the top N most played games with their songs // GetMostPlayedSoundtracksWithSongs returns the top N most played soundtracks with their songs
func (h *StatisticsHandler) GetMostPlayedGamesWithSongs(limit int32) ([]GameWithSongs, error) { func (h *StatisticsHandler) GetMostPlayedSoundtracksWithSongs(limit int32) ([]SoundtrackWithSongs, error) {
queries := BackendRepo() queries := BackendRepo()
ctx := BackendCtx() ctx := BackendCtx()
// Get raw results // Get raw results
rows, err := queries.GetMostPlayedGamesWithSongs(ctx, limit) rows, err := queries.GetMostPlayedSoundtracksWithSongs(ctx, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Convert to GameWithSongs // Convert to SoundtrackWithSongs
var result []GameWithSongs var result []SoundtrackWithSongs
for _, row := range rows { for _, row := range rows {
var songs []SongInfoForStats var songs []SongInfoForStats
if row.Songs != nil { if row.Songs != nil {
@@ -71,28 +71,28 @@ func (h *StatisticsHandler) GetMostPlayedGamesWithSongs(limit int32) ([]GameWith
songs = make([]SongInfoForStats, 0) songs = make([]SongInfoForStats, 0)
} }
} }
result = append(result, GameWithSongs{ result = append(result, SoundtrackWithSongs{
SoundtrackID: row.SoundtrackID, SoundtrackID: row.SoundtrackID,
SoundtrackName: row.SoundtrackName, SoundtrackName: row.SoundtrackName,
SoundtrackPlayed: row.SoundtrackPlayed, SoundtrackPlayed: row.SoundtrackPlayed,
SoundtrackLastPlayed: row.SoundtrackLastPlayed, SoundtrackLastPlayed: row.SoundtrackLastPlayed,
Songs: songs, Songs: songs,
}) })
} }
return result, nil return result, nil
} }
// GetLeastPlayedGamesWithSongs returns the top N least played games with their songs // GetLeastPlayedSoundtracksWithSongs returns the top N least played soundtracks with their songs
func (h *StatisticsHandler) GetLeastPlayedGamesWithSongs(limit int32) ([]GameWithSongs, error) { func (h *StatisticsHandler) GetLeastPlayedSoundtracksWithSongs(limit int32) ([]SoundtrackWithSongs, error) {
queries := BackendRepo() queries := BackendRepo()
ctx := BackendCtx() ctx := BackendCtx()
rows, err := queries.GetLeastPlayedGamesWithSongs(ctx, limit) rows, err := queries.GetLeastPlayedSoundtracksWithSongs(ctx, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var result []GameWithSongs var result []SoundtrackWithSongs
for _, row := range rows { for _, row := range rows {
var songs []SongInfoForStats var songs []SongInfoForStats
if row.Songs != nil { if row.Songs != nil {
@@ -100,76 +100,76 @@ func (h *StatisticsHandler) GetLeastPlayedGamesWithSongs(limit int32) ([]GameWit
songs = make([]SongInfoForStats, 0) songs = make([]SongInfoForStats, 0)
} }
} }
result = append(result, GameWithSongs{ result = append(result, SoundtrackWithSongs{
SoundtrackID: row.SoundtrackID, SoundtrackID: row.SoundtrackID,
SoundtrackName: row.SoundtrackName, SoundtrackName: row.SoundtrackName,
SoundtrackPlayed: row.SoundtrackPlayed, SoundtrackPlayed: row.SoundtrackPlayed,
SoundtrackLastPlayed: row.SoundtrackLastPlayed, SoundtrackLastPlayed: row.SoundtrackLastPlayed,
Songs: songs, Songs: songs,
}) })
} }
return result, nil return result, nil
} }
// GetMostPlayedSongsWithGame returns the top N most played songs with their game info // GetMostPlayedSongsWithSoundtrack returns the top N most played songs with their soundtrack info
func (h *StatisticsHandler) GetMostPlayedSongsWithGame(limit int32) ([]SongInfoForStats, error) { func (h *StatisticsHandler) GetMostPlayedSongsWithSoundtrack(limit int32) ([]SongInfoForStats, error) {
queries := BackendRepo() queries := BackendRepo()
ctx := BackendCtx() ctx := BackendCtx()
rows, err := queries.GetMostPlayedSongsWithGame(ctx, limit) rows, err := queries.GetMostPlayedSongsWithSoundtrack(ctx, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var result []SongInfoForStats var result []SongInfoForStats
for _, row := range rows { for _, row := range rows {
result = append(result, SongInfoForStats{ result = append(result, SongInfoForStats{
SoundtrackID: row.SoundtrackID, SoundtrackID: row.SoundtrackID,
SoundtrackName: row.SoundtrackName, SoundtrackName: row.SoundtrackName,
SongName: row.SongName, SongName: row.SongName,
Path: row.Path, Path: row.Path,
TimesPlayed: row.TimesPlayed, TimesPlayed: row.TimesPlayed,
FileName: row.FileName, FileName: row.FileName,
}) })
} }
return result, nil return result, nil
} }
// GetLeastPlayedSongsWithGame returns the top N least played songs with their game info // GetLeastPlayedSongsWithSoundtrack returns the top N least played songs with their soundtrack info
func (h *StatisticsHandler) GetLeastPlayedSongsWithGame(limit int32) ([]SongInfoForStats, error) { func (h *StatisticsHandler) GetLeastPlayedSongsWithSoundtrack(limit int32) ([]SongInfoForStats, error) {
queries := BackendRepo() queries := BackendRepo()
ctx := BackendCtx() ctx := BackendCtx()
rows, err := queries.GetLeastPlayedSongsWithGame(ctx, limit) rows, err := queries.GetLeastPlayedSongsWithSoundtrack(ctx, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var result []SongInfoForStats var result []SongInfoForStats
for _, row := range rows { for _, row := range rows {
result = append(result, SongInfoForStats{ result = append(result, SongInfoForStats{
SoundtrackID: row.SoundtrackID, SoundtrackID: row.SoundtrackID,
SoundtrackName: row.SoundtrackName, SoundtrackName: row.SoundtrackName,
SongName: row.SongName, SongName: row.SongName,
Path: row.Path, Path: row.Path,
TimesPlayed: row.TimesPlayed, TimesPlayed: row.TimesPlayed,
FileName: row.FileName, FileName: row.FileName,
}) })
} }
return result, nil return result, nil
} }
// GetNeverPlayedGames returns games that have never been played // GetNeverPlayedSoundtracks returns soundtracks that have never been played
func (h *StatisticsHandler) GetNeverPlayedGames() ([]GameWithSongs, error) { func (h *StatisticsHandler) GetNeverPlayedSoundtracks() ([]SoundtrackWithSongs, error) {
queries := BackendRepo() queries := BackendRepo()
ctx := BackendCtx() ctx := BackendCtx()
rows, err := queries.GetNeverPlayedGames(ctx) rows, err := queries.GetNeverPlayedSoundtracks(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var result []GameWithSongs var result []SoundtrackWithSongs
for _, row := range rows { for _, row := range rows {
var songs []SongInfoForStats var songs []SongInfoForStats
if row.Songs != nil { if row.Songs != nil {
@@ -177,28 +177,28 @@ func (h *StatisticsHandler) GetNeverPlayedGames() ([]GameWithSongs, error) {
songs = make([]SongInfoForStats, 0) songs = make([]SongInfoForStats, 0)
} }
} }
result = append(result, GameWithSongs{ result = append(result, SoundtrackWithSongs{
SoundtrackID: row.SoundtrackID, SoundtrackID: row.SoundtrackID,
SoundtrackName: row.SoundtrackName, SoundtrackName: row.SoundtrackName,
SoundtrackPlayed: row.SoundtrackPlayed, SoundtrackPlayed: row.SoundtrackPlayed,
SoundtrackLastPlayed: nil, SoundtrackLastPlayed: nil,
Songs: songs, Songs: songs,
}) })
} }
return result, nil return result, nil
} }
// GetLastPlayedGames returns the most recently played games // GetLastPlayedSoundtracks returns the most recently played soundtracks
func (h *StatisticsHandler) GetLastPlayedGames(limit int32) ([]GameWithSongs, error) { func (h *StatisticsHandler) GetLastPlayedSoundtracks(limit int32) ([]SoundtrackWithSongs, error) {
queries := BackendRepo() queries := BackendRepo()
ctx := BackendCtx() ctx := BackendCtx()
rows, err := queries.GetLastPlayedGames(ctx, limit) rows, err := queries.GetLastPlayedSoundtracks(ctx, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var result []GameWithSongs var result []SoundtrackWithSongs
for _, row := range rows { for _, row := range rows {
var songs []SongInfoForStats var songs []SongInfoForStats
if row.Songs != nil { if row.Songs != nil {
@@ -206,28 +206,28 @@ func (h *StatisticsHandler) GetLastPlayedGames(limit int32) ([]GameWithSongs, er
songs = make([]SongInfoForStats, 0) songs = make([]SongInfoForStats, 0)
} }
} }
result = append(result, GameWithSongs{ result = append(result, SoundtrackWithSongs{
SoundtrackID: row.SoundtrackID, SoundtrackID: row.SoundtrackID,
SoundtrackName: row.SoundtrackName, SoundtrackName: row.SoundtrackName,
SoundtrackPlayed: row.SoundtrackPlayed, SoundtrackPlayed: row.SoundtrackPlayed,
SoundtrackLastPlayed: row.SoundtrackLastPlayed, SoundtrackLastPlayed: row.SoundtrackLastPlayed,
Songs: songs, Songs: songs,
}) })
} }
return result, nil return result, nil
} }
// GetOldestPlayedGames returns the least recently played games // GetOldestPlayedSoundtracks returns the least recently played soundtracks
func (h *StatisticsHandler) GetOldestPlayedGames(limit int32) ([]GameWithSongs, error) { func (h *StatisticsHandler) GetOldestPlayedSoundtracks(limit int32) ([]SoundtrackWithSongs, error) {
queries := BackendRepo() queries := BackendRepo()
ctx := BackendCtx() ctx := BackendCtx()
rows, err := queries.GetOldestPlayedGames(ctx, limit) rows, err := queries.GetOldestPlayedSoundtracks(ctx, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var result []GameWithSongs var result []SoundtrackWithSongs
for _, row := range rows { for _, row := range rows {
var songs []SongInfoForStats var songs []SongInfoForStats
if row.Songs != nil { if row.Songs != nil {
@@ -235,12 +235,12 @@ func (h *StatisticsHandler) GetOldestPlayedGames(limit int32) ([]GameWithSongs,
songs = make([]SongInfoForStats, 0) songs = make([]SongInfoForStats, 0)
} }
} }
result = append(result, GameWithSongs{ result = append(result, SoundtrackWithSongs{
SoundtrackID: row.SoundtrackID, SoundtrackID: row.SoundtrackID,
SoundtrackName: row.SoundtrackName, SoundtrackName: row.SoundtrackName,
SoundtrackPlayed: row.SoundtrackPlayed, SoundtrackPlayed: row.SoundtrackPlayed,
SoundtrackLastPlayed: row.SoundtrackLastPlayed, SoundtrackLastPlayed: row.SoundtrackLastPlayed,
Songs: songs, Songs: songs,
}) })
} }
return result, nil return result, nil
@@ -250,20 +250,20 @@ func (h *StatisticsHandler) GetOldestPlayedGames(limit int32) ([]GameWithSongs,
func (h *StatisticsHandler) GetStatisticsSummary() (*StatisticsSummary, error) { func (h *StatisticsHandler) GetStatisticsSummary() (*StatisticsSummary, error) {
queries := BackendRepo() queries := BackendRepo()
ctx := BackendCtx() ctx := BackendCtx()
row, err := queries.GetStatisticsSummary(ctx) row, err := queries.GetStatisticsSummary(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &StatisticsSummary{ return &StatisticsSummary{
TotalGames: int64(row.TotalSoundtracks), TotalSoundtracks: int64(row.TotalSoundtracks),
PlayedGames: int64(row.PlayedSoundtracks), PlayedSoundtracks: int64(row.PlayedSoundtracks),
NeverPlayedGames: int64(row.NeverPlayedSoundtracks), NeverPlayedSoundtracks: int64(row.NeverPlayedSoundtracks),
TotalGamePlays: int64(row.TotalSoundtrackPlays), TotalSoundtrackPlays: int64(row.TotalSoundtrackPlays),
AvgGamePlays: float64(row.AvgSoundtrackPlays), AvgSoundtrackPlays: float64(row.AvgSoundtrackPlays),
MaxGamePlays: int64(row.MaxSoundtrackPlays), MaxSoundtrackPlays: int64(row.MaxSoundtrackPlays),
MinGamePlays: int64(row.MinSoundtrackPlays), MinSoundtrackPlays: int64(row.MinSoundtrackPlays),
}, nil }, nil
} }
internal/backend/sync.go
+132 -164
View File
@@ -30,14 +30,14 @@ var start time.Time
var totalTime time.Duration var totalTime time.Duration
var timeSpent time.Duration var timeSpent time.Duration
var allGames []repository.Soundtrack var allSoundtracks []repository.Soundtrack
var gamesBeforeSync []repository.Soundtrack var soundtracksBeforeSync []repository.Soundtrack
var gamesAfterSync []repository.Soundtrack var soundtracksAfterSync []repository.Soundtrack
var gamesAdded []string var soundtracksAdded []string
var gamesReAdded []string var soundtracksReAdded []string
var gamesChangedTitle map[string]string var soundtracksChangedTitle map[string]string
var gamesChangedContent []string var soundtracksChangedContent []string
var gamesRemoved []string var soundtracksRemoved []string
var catchedErrors []string var catchedErrors []string
type brokenSong struct { type brokenSong struct {
@@ -50,13 +50,13 @@ var pool *ants.Pool
var poolSong *ants.Pool var poolSong *ants.Pool
type SyncResponse struct { type SyncResponse struct {
GamesAdded []string `json:"games_added"` SoundtracksAdded []string `json:"soundtracks_added"`
GamesReAdded []string `json:"games_re_added"` SoundtracksReAdded []string `json:"soundtracks_re_added"`
GamesChangedTitle map[string]string `json:"games_changed_title"` SoundtracksChangedTitle map[string]string `json:"soundtracks_changed_title"`
GamesChangedContent []string `json:"games_changed_content"` SoundtracksChangedContent []string `json:"soundtracks_changed_content"`
GamesRemoved []string `json:"games_removed"` SoundtracksRemoved []string `json:"soundtracks_removed"`
CatchedErrors []string `json:"catched_errors"` CatchedErrors []string `json:"catched_errors"`
TotalTime string `json:"total_time"` TotalTime string `json:"total_time"`
} }
type ProgressResponse struct { type ProgressResponse struct {
@@ -64,24 +64,24 @@ type ProgressResponse struct {
TimeSpent string `json:"time_spent"` TimeSpent string `json:"time_spent"`
} }
type GameStatus int type SoundtrackStatus int
const ( const (
NotChanged GameStatus = iota NotChanged SoundtrackStatus = iota
TitleChanged TitleChanged
GameChanged SoundtrackChanged
NewGame NewSoundtrack
) )
var statusName = map[GameStatus]string{ var statusName = map[SoundtrackStatus]string{
NotChanged: "Not changed", NotChanged: "Not changed",
TitleChanged: "Title changed", TitleChanged: "Title changed",
GameChanged: "Game changed", SoundtrackChanged: "Soundtrack changed",
NewGame: "New game", NewSoundtrack: "New soundtrack",
} }
func (gs GameStatus) String() string { func (ss SoundtrackStatus) String() string {
return statusName[gs] return statusName[ss]
} }
func ResetDB() { func ResetDB() {
@@ -107,54 +107,54 @@ func SyncProgress() ProgressResponse {
func SyncResult() SyncResponse { func SyncResult() SyncResponse {
logging.GetLogger().Info("Sync completed", logging.GetLogger().Info("Sync completed",
zap.Int("games_before", len(gamesBeforeSync)), zap.Int("soundtracks_before", len(soundtracksBeforeSync)),
zap.Int("games_after", len(gamesAfterSync))) zap.Int("soundtracks_after", len(soundtracksAfterSync)))
if len(gamesAdded) > 0 { if len(soundtracksAdded) > 0 {
logging.GetLogger().Debug("Games added", zap.Strings("games", gamesAdded)) logging.GetLogger().Debug("Soundtracks added", zap.Strings("soundtracks", soundtracksAdded))
} }
if len(gamesReAdded) > 0 { if len(soundtracksReAdded) > 0 {
logging.GetLogger().Debug("Games readded", zap.Strings("games", gamesReAdded)) logging.GetLogger().Debug("Soundtracks readded", zap.Strings("soundtracks", soundtracksReAdded))
} }
if len(gamesChangedTitle) > 0 { if len(soundtracksChangedTitle) > 0 {
logging.GetLogger().Debug("Games with changed title", zap.Any("changes", gamesChangedTitle)) logging.GetLogger().Debug("Soundtracks with changed title", zap.Any("changes", soundtracksChangedTitle))
} }
if len(gamesChangedContent) > 0 { if len(soundtracksChangedContent) > 0 {
logging.GetLogger().Debug("Games with changed content", zap.Strings("games", gamesChangedContent)) logging.GetLogger().Debug("Soundtracks with changed content", zap.Strings("soundtracks", soundtracksChangedContent))
} }
var gamesRemovedTemp []string var soundtracksRemovedTemp []string
for _, beforeGame := range gamesBeforeSync { for _, beforeSoundtrack := range soundtracksBeforeSync {
var found = false var found = false
for _, afterGame := range gamesAfterSync { for _, afterSoundtrack := range soundtracksAfterSync {
if beforeGame.SoundtrackName == afterGame.SoundtrackName { if beforeSoundtrack.SoundtrackName == afterSoundtrack.SoundtrackName {
found = true found = true
break break
} }
} }
if !found { if !found {
gamesRemovedTemp = append(gamesRemovedTemp, beforeGame.SoundtrackName) soundtracksRemovedTemp = append(soundtracksRemovedTemp, beforeSoundtrack.SoundtrackName)
} }
} }
for _, game := range gamesRemovedTemp { for _, soundtrack := range soundtracksRemovedTemp {
var found bool = false var found bool = false
for key := range gamesChangedTitle { for key := range soundtracksChangedTitle {
if game == key { if soundtrack == key {
found = true found = true
break break
} }
} }
if !found { if !found {
gamesRemoved = append(gamesRemoved, game) soundtracksRemoved = append(soundtracksRemoved, soundtrack)
} }
} }
if len(gamesRemoved) > 0 { if len(soundtracksRemoved) > 0 {
logging.GetLogger().Debug("Games removed", zap.Strings("games", gamesRemoved)) logging.GetLogger().Debug("Soundtracks removed", zap.Strings("soundtracks", soundtracksRemoved))
} }
if len(catchedErrors) > 0 { if len(catchedErrors) > 0 {
@@ -165,27 +165,27 @@ func SyncResult() SyncResponse {
logging.GetLogger().Info("Sync completed", zap.String("total_time", out.Format("15:04:05.00000"))) logging.GetLogger().Info("Sync completed", zap.String("total_time", out.Format("15:04:05.00000")))
return SyncResponse{ return SyncResponse{
GamesAdded: gamesAdded, SoundtracksAdded: soundtracksAdded,
GamesReAdded: gamesReAdded, SoundtracksReAdded: soundtracksReAdded,
GamesChangedTitle: gamesChangedTitle, SoundtracksChangedTitle: soundtracksChangedTitle,
GamesChangedContent: gamesChangedContent, SoundtracksChangedContent: soundtracksChangedContent,
GamesRemoved: gamesRemoved, SoundtracksRemoved: soundtracksRemoved,
CatchedErrors: catchedErrors, CatchedErrors: catchedErrors,
TotalTime: out.Format("15:04:05"), TotalTime: out.Format("15:04:05"),
} }
} }
func SyncSoundtracksNewFull() { func SyncSoundtracksFull() {
syncGamesNew(true) syncSoundtracks(true)
Reset() Reset()
} }
func SyncSoundtracksNewOnlyChanges() { func SyncSoundtracksOnlyChanges() {
syncGamesNew(false) syncSoundtracks(false)
Reset() Reset()
} }
func syncGamesNew(full bool) { func syncSoundtracks(full bool) {
musicPath := os.Getenv("MUSIC_PATH") musicPath := os.Getenv("MUSIC_PATH")
fmt.Printf("dir: %s\n", musicPath) fmt.Printf("dir: %s\n", musicPath)
logging.GetLogger().Debug("Folder to sync", zap.String("MUSIC_PATH", musicPath)) logging.GetLogger().Debug("Folder to sync", zap.String("MUSIC_PATH", musicPath))
@@ -201,19 +201,19 @@ func syncGamesNew(full bool) {
logging.GetLogger().Debug("Folders to skip during sync", zap.Strings("folders", foldersToSkip)) logging.GetLogger().Debug("Folders to skip during sync", zap.Strings("folders", foldersToSkip))
var err error var err error
gamesAdded = nil soundtracksAdded = nil
gamesReAdded = nil soundtracksReAdded = nil
gamesChangedTitle = nil soundtracksChangedTitle = nil
gamesChangedContent = nil soundtracksChangedContent = nil
gamesRemoved = nil soundtracksRemoved = nil
catchedErrors = nil catchedErrors = nil
brokenSongs = nil brokenSongs = nil
gamesBeforeSync, err = repo.FindAllSoundtracks(BackendCtx()) soundtracksBeforeSync, err = repo.FindAllSoundtracks(BackendCtx())
handleError("FindAllSoundtracks Before", err, "") handleError("FindAllSoundtracks Before", err, "")
logging.GetLogger().Info("Starting sync", zap.Int("games_before", len(gamesBeforeSync))) logging.GetLogger().Info("Starting sync", zap.Int("soundtracks_before", len(soundtracksBeforeSync)))
allGames, err = repo.GetAllSoundtracksIncludingDeleted(BackendCtx()) allSoundtracks, err = repo.GetAllSoundtracksIncludingDeleted(BackendCtx())
handleError("GetAllSoundtracksIncludingDeleted", err, "") handleError("GetAllSoundtracksIncludingDeleted", err, "")
err = repo.SetSoundtrackDeletionDate(BackendCtx()) err = repo.SetSoundtrackDeletionDate(BackendCtx())
handleError("SetSoundtrackDeletionDate", err, "") handleError("SetSoundtrackDeletionDate", err, "")
@@ -233,13 +233,13 @@ func syncGamesNew(full bool) {
for _, dir := range directories { for _, dir := range directories {
pool.Submit(func() { pool.Submit(func() {
defer syncWg.Done() defer syncWg.Done()
syncGameNew(dir, foldersToSkip, musicPath, full) syncSoundtrack(dir, foldersToSkip, musicPath, full)
}) })
} }
syncWg.Wait() syncWg.Wait()
checkBrokenSongsNew() checkBrokenSongs()
gamesAfterSync, err = repo.FindAllSoundtracks(BackendCtx()) soundtracksAfterSync, err = repo.FindAllSoundtracks(BackendCtx())
handleError("FindAllSoundtracks After", err, "") handleError("FindAllSoundtracks After", err, "")
finished := time.Now() finished := time.Now()
@@ -250,7 +250,7 @@ func syncGamesNew(full bool) {
Syncing = false Syncing = false
} }
func checkBrokenSongsNew() { func checkBrokenSongs() {
allSongs, err := repo.FetchAllSongs(BackendCtx()) allSongs, err := repo.FetchAllSongs(BackendCtx())
handleError("FetchAllSongs", err, "") handleError("FetchAllSongs", err, "")
var brokenWg sync.WaitGroup var brokenWg sync.WaitGroup
@@ -261,7 +261,7 @@ func checkBrokenSongsNew() {
for _, song := range allSongs { for _, song := range allSongs {
poolBroken.Submit(func() { poolBroken.Submit(func() {
defer brokenWg.Done() defer brokenWg.Done()
checkBrokenSongNew(song) checkBrokenSong(song)
}) })
} }
brokenWg.Wait() brokenWg.Wait()
@@ -271,7 +271,7 @@ func checkBrokenSongsNew() {
} }
} }
func checkBrokenSongNew(song repository.Song) { func checkBrokenSong(song repository.Song) {
//Check if file exists and open //Check if file exists and open
openFile, err := os.Open(song.Path) openFile, err := os.Open(song.Path)
if err != nil { if err != nil {
@@ -286,118 +286,86 @@ func checkBrokenSongNew(song repository.Song) {
} }
} }
func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full bool) { func syncSoundtrack(file os.DirEntry, foldersToSkip []string, baseDir string, full bool) {
if file.IsDir() && !contains(foldersToSkip, file.Name()) { if file.IsDir() && !contains(foldersToSkip, file.Name()) {
logging.GetLogger().Debug("Syncing game", zap.String("game", file.Name())) logging.GetLogger().Debug("Syncing soundtrack", zap.String("soundtrack", file.Name()))
gameDir := baseDir + file.Name() + "/" soundtrackDir := baseDir + file.Name() + "/"
dirHash := getHashForDir(gameDir) dirHash := getHashForDir(soundtrackDir)
var status GameStatus = NewGame var status SoundtrackStatus = NewSoundtrack
var oldGame repository.Soundtrack var oldSoundtrack repository.Soundtrack
var id int32 = -1 var id int32 = -1
//fmt.Printf("Games before: %d\n", len(gamesBeforeSync)) //fmt.Printf("Soundtracks before: %d\n", len(soundtracksBeforeSync))
for _, currentGame := range allGames { for _, currentSoundtrack := range allSoundtracks {
oldGame = currentGame oldSoundtrack = currentSoundtrack
//fmt.Printf("%s | %s\n", oldGame.SoundtrackName, oldGame.Hash) //fmt.Printf("%s | %s\n", oldSoundtrack.SoundtrackName, oldSoundtrack.Hash)
if oldGame.SoundtrackName == file.Name() && oldGame.Hash == dirHash { if oldSoundtrack.SoundtrackName == file.Name() && oldSoundtrack.Hash == dirHash {
status = NotChanged status = NotChanged
id = oldGame.ID id = oldSoundtrack.ID
//fmt.Printf("Game not changed\n") //fmt.Printf("Soundtrack not changed\n")
break break
} else if oldGame.SoundtrackName == file.Name() && oldGame.Hash != dirHash { } else if oldSoundtrack.SoundtrackName == file.Name() && oldSoundtrack.Hash != dirHash {
status = GameChanged status = SoundtrackChanged
id = oldGame.ID id = oldSoundtrack.ID
//fmt.Printf("Game changed\n") //fmt.Printf("Soundtrack changed\n")
break break
} else if oldGame.SoundtrackName != file.Name() && oldGame.Hash == dirHash { } else if oldSoundtrack.SoundtrackName != file.Name() && oldSoundtrack.Hash == dirHash {
status = TitleChanged status = TitleChanged
id = oldGame.ID id = oldSoundtrack.ID
//fmt.Printf("SoundtrackName changed\n") //fmt.Printf("SoundtrackName changed\n")
break break
} }
} }
if full && status != NewGame { if full && status != NewSoundtrack {
status = TitleChanged status = TitleChanged
} }
entries, err := os.ReadDir(gameDir) entries, err := os.ReadDir(soundtrackDir)
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to read game directory", zap.String("path", gameDir), zap.String("error", err.Error())) logging.GetLogger().Error("Failed to read soundtrack directory", zap.String("path", soundtrackDir), zap.String("error", err.Error()))
} }
switch status { switch status {
case NewGame: case NewSoundtrack:
if id != -1 { id = insertSoundtrack(file.Name(), soundtrackDir, dirHash)
for _, entry := range entries { logging.GetLogger().Debug("New soundtrack detected",
fileInfo, err := entry.Info()
if err != nil {
logging.GetLogger().Error("Failed to get file info", zap.String("error", err.Error()))
continue
}
id = getIdFromFileNew(fileInfo)
if id != -1 {
break
}
}
err = repo.InsertSoundtrackWithExistingId(BackendCtx(), repository.InsertSoundtrackWithExistingIdParams{ID: id, SoundtrackName: file.Name(), Path: gameDir, Hash: dirHash})
handleError("InsertSoundtrackWithExistingId", err, "")
if err != nil {
logging.GetLogger().Debug("Game already exists, removing old ID file",
zap.Int32("id", id),
zap.String("game_dir", gameDir))
fileName := gameDir + "/." + strconv.Itoa(int(id)) + ".id"
logging.GetLogger().Debug("Removing ID file", zap.String("filename", fileName))
err := os.Remove(fileName)
if err != nil {
logging.GetLogger().Error("Failed to remove ID file", zap.String("filename", fileName), zap.String("error", err.Error()))
}
newDirHash := getHashForDir(gameDir)
id = insertGameNew(file.Name(), gameDir, newDirHash)
}
} else {
id = insertGameNew(file.Name(), gameDir, dirHash)
}
logging.GetLogger().Debug("New game detected",
zap.Int32("id", id), zap.Int32("id", id),
zap.String("game", file.Name()), zap.String("soundtrack", file.Name()),
zap.String("hash", dirHash), zap.String("hash", dirHash),
zap.String("status", status.String())) zap.String("status", status.String()))
gamesAdded = append(gamesAdded, file.Name()) soundtracksAdded = append(soundtracksAdded, file.Name())
newCheckSongs(entries, gameDir, id) checkSongs(entries, soundtrackDir, id)
case GameChanged: case SoundtrackChanged:
logging.GetLogger().Debug("Game changed", logging.GetLogger().Debug("Soundtrack changed",
zap.Int32("id", id), zap.Int32("id", id),
zap.String("game", file.Name()), zap.String("soundtrack", file.Name()),
zap.String("hash", dirHash), zap.String("hash", dirHash),
zap.String("status", status.String())) zap.String("status", status.String()))
err = repo.UpdateSoundtrackHash(BackendCtx(), repository.UpdateSoundtrackHashParams{Hash: dirHash, ID: id}) err = repo.UpdateSoundtrackHash(BackendCtx(), repository.UpdateSoundtrackHashParams{Hash: dirHash, ID: id})
handleError("UpdateSoundtrackHash", err, "") handleError("UpdateSoundtrackHash", err, "")
gamesChangedContent = append(gamesChangedContent, file.Name()) soundtracksChangedContent = append(soundtracksChangedContent, file.Name())
newCheckSongs(entries, gameDir, id) checkSongs(entries, soundtrackDir, id)
case TitleChanged: case TitleChanged:
logging.GetLogger().Debug("Game title changed", logging.GetLogger().Debug("Soundtrack title changed",
zap.Int32("id", id), zap.Int32("id", id),
zap.String("oldName", oldGame.SoundtrackName), zap.String("oldName", oldSoundtrack.SoundtrackName),
zap.String("newName", file.Name()), zap.String("newName", file.Name()),
zap.String("hash", dirHash), zap.String("hash", dirHash),
zap.String("status", status.String())) zap.String("status", status.String()))
err = repo.UpdateSoundtrackName(BackendCtx(), repository.UpdateSoundtrackNameParams{Name: file.Name(), Path: gameDir, ID: id}) err = repo.UpdateSoundtrackName(BackendCtx(), repository.UpdateSoundtrackNameParams{Name: file.Name(), Path: soundtrackDir, ID: id})
handleError("UpdateSoundtrackName", err, "") handleError("UpdateSoundtrackName", err, "")
newCheckSongs(entries, gameDir, id) checkSongs(entries, soundtrackDir, id)
if gamesChangedTitle == nil { if soundtracksChangedTitle == nil {
gamesChangedTitle = make(map[string]string) soundtracksChangedTitle = make(map[string]string)
} }
gamesChangedTitle[oldGame.SoundtrackName] = file.Name() soundtracksChangedTitle[oldSoundtrack.SoundtrackName] = file.Name()
case NotChanged: case NotChanged:
var found bool = false var found bool = false
for _, beforeGame := range gamesBeforeSync { for _, beforeSoundtrack := range soundtracksBeforeSync {
if dirHash == beforeGame.Hash { if dirHash == beforeSoundtrack.Hash {
found = true found = true
logging.GetLogger().Debug("Game not changed", logging.GetLogger().Debug("Soundtrack not changed",
zap.Int32("id", id), zap.Int32("id", id),
zap.String("newName", file.Name()), zap.String("newName", file.Name()),
zap.String("hash", dirHash), zap.String("hash", dirHash),
@@ -405,9 +373,9 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
} }
} }
if !found { if !found {
newCheckSongs(entries, gameDir, id) checkSongs(entries, soundtrackDir, id)
gamesReAdded = append(gamesReAdded, file.Name()) soundtracksReAdded = append(soundtracksReAdded, file.Name())
logging.GetLogger().Debug("Game added again", logging.GetLogger().Debug("Soundtrack added again",
zap.Int32("id", id), zap.Int32("id", id),
zap.String("newName", file.Name()), zap.String("newName", file.Name()),
zap.String("hash", dirHash), zap.String("hash", dirHash),
@@ -415,9 +383,9 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
} }
} }
logging.GetLogger().Debug("Game sync status", logging.GetLogger().Debug("Soundtrack sync status",
zap.Int32("id", id), zap.Int32("id", id),
zap.String("game", file.Name()), zap.String("soundtrack", file.Name()),
zap.String("hash", dirHash), zap.String("hash", dirHash),
zap.String("status", status.String())) zap.String("status", status.String()))
err = repo.RemoveSoundtrackDeletionDate(BackendCtx(), id) err = repo.RemoveSoundtrackDeletionDate(BackendCtx(), id)
@@ -430,24 +398,24 @@ func syncGameNew(file os.DirEntry, foldersToSkip []string, baseDir string, full
zap.Int("percent", int((foldersSynced/numberOfFoldersToSync)*100))) zap.Int("percent", int((foldersSynced/numberOfFoldersToSync)*100)))
} }
func insertGameNew(name string, path string, hash string) int32 { func insertSoundtrack(name string, path string, hash string) int32 {
var duplicateError = errors.New("ERROR: duplicate key value violates unique") var duplicateError = errors.New("ERROR: duplicate key value violates unique")
id, err := repo.InsertSoundtrack(BackendCtx(), repository.InsertSoundtrackParams{SoundtrackName: name, Path: path, Hash: hash}) id, err := repo.InsertSoundtrack(BackendCtx(), repository.InsertSoundtrackParams{SoundtrackName: name, Path: path, Hash: hash})
handleError("InsertSoundtrack", err, "") handleError("InsertSoundtrack", err, "")
if err != nil { if err != nil {
logging.GetLogger().Warn("ID collision detected, resetting sequence") logging.GetLogger().Warn("ID collision detected, resetting sequence")
if strings.HasPrefix(err.Error(), duplicateError.Error()) { if strings.HasPrefix(err.Error(), duplicateError.Error()) {
logging.GetLogger().Debug("Resetting game ID sequence") logging.GetLogger().Debug("Resetting soundtrack ID sequence")
_, err = repo.ResetSoundtrackIdSeq(BackendCtx()) _, err = repo.ResetSoundtrackIdSeq(BackendCtx())
handleError("ResetSoundtrackIdSeq", err, "") handleError("ResetSoundtrackIdSeq", err, "")
id = insertGameNew(name, path, hash) id = insertSoundtrack(name, path, hash)
} }
} }
return id return id
} }
func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 { func checkSongs(entries []os.DirEntry, soundtrackDir string, id int32) int32 {
//hasher := md5.New() //hasher := md5.New()
var numberOfSongs int32 var numberOfSongs int32
numberOfFiles := len(entries) numberOfFiles := len(entries)
@@ -457,7 +425,7 @@ func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
for _, entry := range entries { for _, entry := range entries {
poolSong.Submit(func() { poolSong.Submit(func() {
defer songWg.Done() defer songWg.Done()
if newCheckSong(entry, gameDir, id) { if checkSong(entry, soundtrackDir, id) {
numberOfSongs++ numberOfSongs++
} }
}) })
@@ -466,7 +434,7 @@ func newCheckSongs(entries []os.DirEntry, gameDir string, id int32) int32 {
return numberOfSongs return numberOfSongs
} }
func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool { func checkSong(entry os.DirEntry, soundtrackDir string, id int32) bool {
fileInfo, err := entry.Info() fileInfo, err := entry.Info()
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to get file info", zap.String("filename", entry.Name()), zap.String("error", err.Error())) logging.GetLogger().Error("Failed to get file info", zap.String("filename", entry.Name()), zap.String("error", err.Error()))
@@ -474,7 +442,7 @@ func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
} }
if isSong(fileInfo) { if isSong(fileInfo) {
path := gameDir + entry.Name() path := soundtrackDir + entry.Name()
songHash := getHashForFile(path) songHash := getHashForFile(path)
//numberOfSongs++ //numberOfSongs++
@@ -490,7 +458,7 @@ func newCheckSong(entry os.DirEntry, gameDir string, id int32) bool {
} }
} }
logging.GetLogger().Debug("Song changed", logging.GetLogger().Debug("Song changed",
zap.Int32("game_id", id), zap.Int32("soundtrack_id", id),
zap.String("path", path), zap.String("path", path),
zap.String("song_name", songName), zap.String("song_name", songName),
zap.String("song_hash", songHash)) zap.String("song_hash", songHash))
@@ -548,8 +516,8 @@ func handleError(funcName string, err error, msg string) {
} }
} }
func getHashForDir(gameDir string) string { func getHashForDir(soundtrackDir string) string {
directory, _ := directory_checksum.ScanDirectory(gameDir, afero.NewOsFs()) directory, _ := directory_checksum.ScanDirectory(soundtrackDir, afero.NewOsFs())
hash, _ := directory.ComputeDirectoryChecksums() hash, _ := directory.ComputeDirectoryChecksums()
return hash return hash
@@ -570,7 +538,7 @@ func getHashForFile(path string) string {
return hex.EncodeToString(hasher.Sum(nil)) return hex.EncodeToString(hasher.Sum(nil))
} }
func getIdFromFileNew(file os.FileInfo) int32 { func getIdFromFile(file os.FileInfo) int32 {
name := file.Name() name := file.Name()
if !file.IsDir() && strings.HasSuffix(name, ".id") { if !file.IsDir() && strings.HasSuffix(name, ".id") {
name = strings.Replace(name, ".id", "", 1) name = strings.Replace(name, ".id", "", 1)
internal/backend/sync_test.go
+18 -18
View File
@@ -9,10 +9,10 @@ import (
func TestContains(t *testing.T) { func TestContains(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
slice []string slice []string
search string search string
expected bool expected bool
}{ }{
{ {
name: "element exists", name: "element exists",
@@ -155,9 +155,9 @@ func TestGetIdFromFileNew(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
result := getIdFromFileNew(tt.fileInfo) result := getIdFromFile(tt.fileInfo)
if result != tt.expected { if result != tt.expected {
t.Errorf("getIdFromFileNew() = %v, want %v", result, tt.expected) t.Errorf("getIdFromFile() = %v, want %v", result, tt.expected)
} }
}) })
} }
@@ -172,10 +172,10 @@ type mockFileInfoForSong struct {
func (m *mockFileInfoForSong) Name() string { return m.name } func (m *mockFileInfoForSong) Name() string { return m.name }
func (m *mockFileInfoForSong) Size() int64 { return m.size } func (m *mockFileInfoForSong) Size() int64 { return m.size }
func (m *mockFileInfoForSong) Mode() os.FileMode { return 0 } func (m *mockFileInfoForSong) Mode() os.FileMode { return 0 }
func (m *mockFileInfoForSong) ModTime() time.Time { return time.Time{} } func (m *mockFileInfoForSong) ModTime() time.Time { return time.Time{} }
func (m *mockFileInfoForSong) IsDir() bool { return m.isDir } func (m *mockFileInfoForSong) IsDir() bool { return m.isDir }
func (m *mockFileInfoForSong) Sys() interface{} { return nil } func (m *mockFileInfoForSong) Sys() interface{} { return nil }
type mockFileInfoForCover struct { type mockFileInfoForCover struct {
name string name string
@@ -185,10 +185,10 @@ type mockFileInfoForCover struct {
func (m *mockFileInfoForCover) Name() string { return m.name } func (m *mockFileInfoForCover) Name() string { return m.name }
func (m *mockFileInfoForCover) Size() int64 { return m.size } func (m *mockFileInfoForCover) Size() int64 { return m.size }
func (m *mockFileInfoForCover) Mode() os.FileMode { return 0 } func (m *mockFileInfoForCover) Mode() os.FileMode { return 0 }
func (m *mockFileInfoForCover) ModTime() time.Time { return time.Time{} } func (m *mockFileInfoForCover) ModTime() time.Time { return time.Time{} }
func (m *mockFileInfoForCover) IsDir() bool { return m.isDir } func (m *mockFileInfoForCover) IsDir() bool { return m.isDir }
func (m *mockFileInfoForCover) Sys() interface{} { return nil } func (m *mockFileInfoForCover) Sys() interface{} { return nil }
type mockFileInfoForId struct { type mockFileInfoForId struct {
name string name string
@@ -198,7 +198,7 @@ type mockFileInfoForId struct {
func (m *mockFileInfoForId) Name() string { return m.name } func (m *mockFileInfoForId) Name() string { return m.name }
func (m *mockFileInfoForId) Size() int64 { return m.size } func (m *mockFileInfoForId) Size() int64 { return m.size }
func (m *mockFileInfoForId) Mode() os.FileMode { return 0 } func (m *mockFileInfoForId) Mode() os.FileMode { return 0 }
func (m *mockFileInfoForId) ModTime() time.Time { return time.Time{} } func (m *mockFileInfoForId) ModTime() time.Time { return time.Time{} }
func (m *mockFileInfoForId) IsDir() bool { return m.isDir } func (m *mockFileInfoForId) IsDir() bool { return m.isDir }
func (m *mockFileInfoForId) Sys() interface{} { return nil } func (m *mockFileInfoForId) Sys() interface{} { return nil }
internal/db/dbHelper.go
+3 -3
View File
@@ -56,10 +56,10 @@ func CloseDb() {
Dbpool.Close() Dbpool.Close()
} }
func ResetGameIdSeq() { func ResetSoundtrackIdSeq() {
_, err := Dbpool.Query(Ctx, "SELECT setval('game_id_seq', (SELECT MAX(id) FROM game)+1);") _, err := Dbpool.Query(Ctx, "SELECT setval('soundtrack_id_seq', (SELECT MAX(id) FROM soundtrack)+1);")
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to reset game ID sequence", zap.String("error", err.Error())) logging.GetLogger().Error("Failed to reset soundtrack ID sequence", zap.String("error", err.Error()))
} }
} }
internal/db/queries/statistics.sql
+8 -8
View File
@@ -1,5 +1,5 @@
-- Most played soundtracks with their songs -- Most played soundtracks with their songs
-- name: GetMostPlayedGamesWithSongs :many -- name: GetMostPlayedSoundtracksWithSongs :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -21,7 +21,7 @@ ORDER BY g.times_played DESC, g.soundtrack_name
LIMIT $1; LIMIT $1;
-- Least played soundtracks with their songs -- Least played soundtracks with their songs
-- name: GetLeastPlayedGamesWithSongs :many -- name: GetLeastPlayedSoundtracksWithSongs :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -43,7 +43,7 @@ ORDER BY g.times_played ASC, g.soundtrack_name
LIMIT $1; LIMIT $1;
-- Most played songs with their soundtrack info -- Most played songs with their soundtrack info
-- name: GetMostPlayedSongsWithGame :many -- name: GetMostPlayedSongsWithSoundtrack :many
SELECT SELECT
s.soundtrack_id as soundtrack_id, s.soundtrack_id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -58,7 +58,7 @@ ORDER BY s.times_played DESC, s.song_name
LIMIT $1; LIMIT $1;
-- Least played songs with their soundtrack info -- Least played songs with their soundtrack info
-- name: GetLeastPlayedSongsWithGame :many -- name: GetLeastPlayedSongsWithSoundtrack :many
SELECT SELECT
s.soundtrack_id as soundtrack_id, s.soundtrack_id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -72,8 +72,8 @@ WHERE g.deleted IS NULL
ORDER BY s.times_played ASC, s.song_name ORDER BY s.times_played ASC, s.song_name
LIMIT $1; LIMIT $1;
-- Games that have never been played (times_played = 0) -- Soundtracks that have never been played (times_played = 0)
-- name: GetNeverPlayedGames :many -- name: GetNeverPlayedSoundtracks :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -93,7 +93,7 @@ GROUP BY g.id, g.soundtrack_name, g.times_played, g.added
ORDER BY g.soundtrack_name; ORDER BY g.soundtrack_name;
-- Last played soundtracks (most recently played) -- Last played soundtracks (most recently played)
-- name: GetLastPlayedGames :many -- name: GetLastPlayedSoundtracks :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -114,7 +114,7 @@ ORDER BY g.last_played DESC
LIMIT $1; LIMIT $1;
-- Oldest played soundtracks (least recently played, but has been played at least once) -- Oldest played soundtracks (least recently played, but has been played at least once)
-- name: GetOldestPlayedGames :many -- name: GetOldestPlayedSoundtracks :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
internal/db/repository/statistics.sql.go
+43 -43
View File
@@ -10,7 +10,7 @@ import (
"time" "time"
) )
const getLastPlayedGames = `-- name: GetLastPlayedGames :many const getLastPlayedSoundtracks = `-- name: GetLastPlayedSoundtracks :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -31,7 +31,7 @@ ORDER BY g.last_played DESC
LIMIT $1 LIMIT $1
` `
type GetLastPlayedGamesRow struct { type GetLastPlayedSoundtracksRow struct {
SoundtrackID int32 `json:"soundtrack_id"` SoundtrackID int32 `json:"soundtrack_id"`
SoundtrackName string `json:"soundtrack_name"` SoundtrackName string `json:"soundtrack_name"`
SoundtrackPlayed int32 `json:"soundtrack_played"` SoundtrackPlayed int32 `json:"soundtrack_played"`
@@ -40,15 +40,15 @@ type GetLastPlayedGamesRow struct {
} }
// Last played soundtracks (most recently played) // Last played soundtracks (most recently played)
func (q *Queries) GetLastPlayedGames(ctx context.Context, limit int32) ([]GetLastPlayedGamesRow, error) { func (q *Queries) GetLastPlayedSoundtracks(ctx context.Context, limit int32) ([]GetLastPlayedSoundtracksRow, error) {
rows, err := q.db.Query(ctx, getLastPlayedGames, limit) rows, err := q.db.Query(ctx, getLastPlayedSoundtracks, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer rows.Close() defer rows.Close()
var items []GetLastPlayedGamesRow var items []GetLastPlayedSoundtracksRow
for rows.Next() { for rows.Next() {
var i GetLastPlayedGamesRow var i GetLastPlayedSoundtracksRow
if err := rows.Scan( if err := rows.Scan(
&i.SoundtrackID, &i.SoundtrackID,
&i.SoundtrackName, &i.SoundtrackName,
@@ -66,7 +66,7 @@ func (q *Queries) GetLastPlayedGames(ctx context.Context, limit int32) ([]GetLas
return items, nil return items, nil
} }
const getLeastPlayedGamesWithSongs = `-- name: GetLeastPlayedGamesWithSongs :many const getLeastPlayedSoundtracksWithSongs = `-- name: GetLeastPlayedSoundtracksWithSongs :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -88,7 +88,7 @@ ORDER BY g.times_played ASC, g.soundtrack_name
LIMIT $1 LIMIT $1
` `
type GetLeastPlayedGamesWithSongsRow struct { type GetLeastPlayedSoundtracksWithSongsRow struct {
SoundtrackID int32 `json:"soundtrack_id"` SoundtrackID int32 `json:"soundtrack_id"`
SoundtrackName string `json:"soundtrack_name"` SoundtrackName string `json:"soundtrack_name"`
SoundtrackPlayed int32 `json:"soundtrack_played"` SoundtrackPlayed int32 `json:"soundtrack_played"`
@@ -97,15 +97,15 @@ type GetLeastPlayedGamesWithSongsRow struct {
} }
// Least played soundtracks with their songs // Least played soundtracks with their songs
func (q *Queries) GetLeastPlayedGamesWithSongs(ctx context.Context, limit int32) ([]GetLeastPlayedGamesWithSongsRow, error) { func (q *Queries) GetLeastPlayedSoundtracksWithSongs(ctx context.Context, limit int32) ([]GetLeastPlayedSoundtracksWithSongsRow, error) {
rows, err := q.db.Query(ctx, getLeastPlayedGamesWithSongs, limit) rows, err := q.db.Query(ctx, getLeastPlayedSoundtracksWithSongs, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer rows.Close() defer rows.Close()
var items []GetLeastPlayedGamesWithSongsRow var items []GetLeastPlayedSoundtracksWithSongsRow
for rows.Next() { for rows.Next() {
var i GetLeastPlayedGamesWithSongsRow var i GetLeastPlayedSoundtracksWithSongsRow
if err := rows.Scan( if err := rows.Scan(
&i.SoundtrackID, &i.SoundtrackID,
&i.SoundtrackName, &i.SoundtrackName,
@@ -123,7 +123,7 @@ func (q *Queries) GetLeastPlayedGamesWithSongs(ctx context.Context, limit int32)
return items, nil return items, nil
} }
const getLeastPlayedSongsWithGame = `-- name: GetLeastPlayedSongsWithGame :many const getLeastPlayedSongsWithSoundtrack = `-- name: GetLeastPlayedSongsWithSoundtrack :many
SELECT SELECT
s.soundtrack_id as soundtrack_id, s.soundtrack_id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -138,7 +138,7 @@ ORDER BY s.times_played ASC, s.song_name
LIMIT $1 LIMIT $1
` `
type GetLeastPlayedSongsWithGameRow struct { type GetLeastPlayedSongsWithSoundtrackRow struct {
SoundtrackID int32 `json:"soundtrack_id"` SoundtrackID int32 `json:"soundtrack_id"`
SoundtrackName string `json:"soundtrack_name"` SoundtrackName string `json:"soundtrack_name"`
SongName string `json:"song_name"` SongName string `json:"song_name"`
@@ -148,15 +148,15 @@ type GetLeastPlayedSongsWithGameRow struct {
} }
// Least played songs with their soundtrack info // Least played songs with their soundtrack info
func (q *Queries) GetLeastPlayedSongsWithGame(ctx context.Context, limit int32) ([]GetLeastPlayedSongsWithGameRow, error) { func (q *Queries) GetLeastPlayedSongsWithSoundtrack(ctx context.Context, limit int32) ([]GetLeastPlayedSongsWithSoundtrackRow, error) {
rows, err := q.db.Query(ctx, getLeastPlayedSongsWithGame, limit) rows, err := q.db.Query(ctx, getLeastPlayedSongsWithSoundtrack, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer rows.Close() defer rows.Close()
var items []GetLeastPlayedSongsWithGameRow var items []GetLeastPlayedSongsWithSoundtrackRow
for rows.Next() { for rows.Next() {
var i GetLeastPlayedSongsWithGameRow var i GetLeastPlayedSongsWithSoundtrackRow
if err := rows.Scan( if err := rows.Scan(
&i.SoundtrackID, &i.SoundtrackID,
&i.SoundtrackName, &i.SoundtrackName,
@@ -175,7 +175,7 @@ func (q *Queries) GetLeastPlayedSongsWithGame(ctx context.Context, limit int32)
return items, nil return items, nil
} }
const getMostPlayedGamesWithSongs = `-- name: GetMostPlayedGamesWithSongs :many const getMostPlayedSoundtracksWithSongs = `-- name: GetMostPlayedSoundtracksWithSongs :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -197,7 +197,7 @@ ORDER BY g.times_played DESC, g.soundtrack_name
LIMIT $1 LIMIT $1
` `
type GetMostPlayedGamesWithSongsRow struct { type GetMostPlayedSoundtracksWithSongsRow struct {
SoundtrackID int32 `json:"soundtrack_id"` SoundtrackID int32 `json:"soundtrack_id"`
SoundtrackName string `json:"soundtrack_name"` SoundtrackName string `json:"soundtrack_name"`
SoundtrackPlayed int32 `json:"soundtrack_played"` SoundtrackPlayed int32 `json:"soundtrack_played"`
@@ -206,15 +206,15 @@ type GetMostPlayedGamesWithSongsRow struct {
} }
// Most played soundtracks with their songs // Most played soundtracks with their songs
func (q *Queries) GetMostPlayedGamesWithSongs(ctx context.Context, limit int32) ([]GetMostPlayedGamesWithSongsRow, error) { func (q *Queries) GetMostPlayedSoundtracksWithSongs(ctx context.Context, limit int32) ([]GetMostPlayedSoundtracksWithSongsRow, error) {
rows, err := q.db.Query(ctx, getMostPlayedGamesWithSongs, limit) rows, err := q.db.Query(ctx, getMostPlayedSoundtracksWithSongs, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer rows.Close() defer rows.Close()
var items []GetMostPlayedGamesWithSongsRow var items []GetMostPlayedSoundtracksWithSongsRow
for rows.Next() { for rows.Next() {
var i GetMostPlayedGamesWithSongsRow var i GetMostPlayedSoundtracksWithSongsRow
if err := rows.Scan( if err := rows.Scan(
&i.SoundtrackID, &i.SoundtrackID,
&i.SoundtrackName, &i.SoundtrackName,
@@ -232,7 +232,7 @@ func (q *Queries) GetMostPlayedGamesWithSongs(ctx context.Context, limit int32)
return items, nil return items, nil
} }
const getMostPlayedSongsWithGame = `-- name: GetMostPlayedSongsWithGame :many const getMostPlayedSongsWithSoundtrack = `-- name: GetMostPlayedSongsWithSoundtrack :many
SELECT SELECT
s.soundtrack_id as soundtrack_id, s.soundtrack_id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -247,7 +247,7 @@ ORDER BY s.times_played DESC, s.song_name
LIMIT $1 LIMIT $1
` `
type GetMostPlayedSongsWithGameRow struct { type GetMostPlayedSongsWithSoundtrackRow struct {
SoundtrackID int32 `json:"soundtrack_id"` SoundtrackID int32 `json:"soundtrack_id"`
SoundtrackName string `json:"soundtrack_name"` SoundtrackName string `json:"soundtrack_name"`
SongName string `json:"song_name"` SongName string `json:"song_name"`
@@ -257,15 +257,15 @@ type GetMostPlayedSongsWithGameRow struct {
} }
// Most played songs with their soundtrack info // Most played songs with their soundtrack info
func (q *Queries) GetMostPlayedSongsWithGame(ctx context.Context, limit int32) ([]GetMostPlayedSongsWithGameRow, error) { func (q *Queries) GetMostPlayedSongsWithSoundtrack(ctx context.Context, limit int32) ([]GetMostPlayedSongsWithSoundtrackRow, error) {
rows, err := q.db.Query(ctx, getMostPlayedSongsWithGame, limit) rows, err := q.db.Query(ctx, getMostPlayedSongsWithSoundtrack, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer rows.Close() defer rows.Close()
var items []GetMostPlayedSongsWithGameRow var items []GetMostPlayedSongsWithSoundtrackRow
for rows.Next() { for rows.Next() {
var i GetMostPlayedSongsWithGameRow var i GetMostPlayedSongsWithSoundtrackRow
if err := rows.Scan( if err := rows.Scan(
&i.SoundtrackID, &i.SoundtrackID,
&i.SoundtrackName, &i.SoundtrackName,
@@ -284,7 +284,7 @@ func (q *Queries) GetMostPlayedSongsWithGame(ctx context.Context, limit int32) (
return items, nil return items, nil
} }
const getNeverPlayedGames = `-- name: GetNeverPlayedGames :many const getNeverPlayedSoundtracks = `-- name: GetNeverPlayedSoundtracks :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -304,7 +304,7 @@ GROUP BY g.id, g.soundtrack_name, g.times_played, g.added
ORDER BY g.soundtrack_name ORDER BY g.soundtrack_name
` `
type GetNeverPlayedGamesRow struct { type GetNeverPlayedSoundtracksRow struct {
SoundtrackID int32 `json:"soundtrack_id"` SoundtrackID int32 `json:"soundtrack_id"`
SoundtrackName string `json:"soundtrack_name"` SoundtrackName string `json:"soundtrack_name"`
SoundtrackPlayed int32 `json:"soundtrack_played"` SoundtrackPlayed int32 `json:"soundtrack_played"`
@@ -312,16 +312,16 @@ type GetNeverPlayedGamesRow struct {
Songs []byte `json:"songs"` Songs []byte `json:"songs"`
} }
// Games that have never been played (times_played = 0) // Soundtracks that have never been played (times_played = 0)
func (q *Queries) GetNeverPlayedGames(ctx context.Context) ([]GetNeverPlayedGamesRow, error) { func (q *Queries) GetNeverPlayedSoundtracks(ctx context.Context) ([]GetNeverPlayedSoundtracksRow, error) {
rows, err := q.db.Query(ctx, getNeverPlayedGames) rows, err := q.db.Query(ctx, getNeverPlayedSoundtracks)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer rows.Close() defer rows.Close()
var items []GetNeverPlayedGamesRow var items []GetNeverPlayedSoundtracksRow
for rows.Next() { for rows.Next() {
var i GetNeverPlayedGamesRow var i GetNeverPlayedSoundtracksRow
if err := rows.Scan( if err := rows.Scan(
&i.SoundtrackID, &i.SoundtrackID,
&i.SoundtrackName, &i.SoundtrackName,
@@ -339,7 +339,7 @@ func (q *Queries) GetNeverPlayedGames(ctx context.Context) ([]GetNeverPlayedGame
return items, nil return items, nil
} }
const getOldestPlayedGames = `-- name: GetOldestPlayedGames :many const getOldestPlayedSoundtracks = `-- name: GetOldestPlayedSoundtracks :many
SELECT SELECT
g.id as soundtrack_id, g.id as soundtrack_id,
g.soundtrack_name, g.soundtrack_name,
@@ -360,7 +360,7 @@ ORDER BY g.last_played ASC
LIMIT $1 LIMIT $1
` `
type GetOldestPlayedGamesRow struct { type GetOldestPlayedSoundtracksRow struct {
SoundtrackID int32 `json:"soundtrack_id"` SoundtrackID int32 `json:"soundtrack_id"`
SoundtrackName string `json:"soundtrack_name"` SoundtrackName string `json:"soundtrack_name"`
SoundtrackPlayed int32 `json:"soundtrack_played"` SoundtrackPlayed int32 `json:"soundtrack_played"`
@@ -369,15 +369,15 @@ type GetOldestPlayedGamesRow struct {
} }
// Oldest played soundtracks (least recently played, but has been played at least once) // Oldest played soundtracks (least recently played, but has been played at least once)
func (q *Queries) GetOldestPlayedGames(ctx context.Context, limit int32) ([]GetOldestPlayedGamesRow, error) { func (q *Queries) GetOldestPlayedSoundtracks(ctx context.Context, limit int32) ([]GetOldestPlayedSoundtracksRow, error) {
rows, err := q.db.Query(ctx, getOldestPlayedGames, limit) rows, err := q.db.Query(ctx, getOldestPlayedSoundtracks, limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer rows.Close() defer rows.Close()
var items []GetOldestPlayedGamesRow var items []GetOldestPlayedSoundtracksRow
for rows.Next() { for rows.Next() {
var i GetOldestPlayedGamesRow var i GetOldestPlayedSoundtracksRow
if err := rows.Scan( if err := rows.Scan(
&i.SoundtrackID, &i.SoundtrackID,
&i.SoundtrackName, &i.SoundtrackName,
internal/server/middleware/sync_check.go
+22
View File
@@ -0,0 +1,22 @@
package middleware
import (
"music-server/internal/backend"
"music-server/internal/logging"
"net/http"
"github.com/labstack/echo/v5"
)
// SyncCheckMiddleware blocks requests when syncing is in progress.
// It returns HTTP 423 Locked with a standard message.
// This middleware should be applied to handlers that cannot execute during sync.
func SyncCheckMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
return func(c *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress - request blocked")
return c.JSON(http.StatusLocked, "Syncing is in progress")
}
return next(c)
}
}
internal/server/musicHandler.go
+3 -55
View File
@@ -31,10 +31,6 @@ func NewMusicHandler() *MusicHandler {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music [get] // @Router /music [get]
func (m *MusicHandler) GetSong(ctx *echo.Context) error { func (m *MusicHandler) GetSong(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
song := ctx.QueryParam("song") song := ctx.QueryParam("song")
if song == "" { if song == "" {
return ctx.String(http.StatusBadRequest, "song can't be empty") return ctx.String(http.StatusBadRequest, "song can't be empty")
@@ -58,10 +54,6 @@ func (m *MusicHandler) GetSong(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/soundTest [get] // @Router /music/soundTest [get]
func (m *MusicHandler) GetSoundCheckSong(ctx *echo.Context) error { func (m *MusicHandler) GetSoundCheckSong(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
songPath := backend.GetSoundCheckSong() songPath := backend.GetSoundCheckSong()
file, err := os.Open(songPath) file, err := os.Open(songPath)
if err != nil { if err != nil {
@@ -80,10 +72,6 @@ func (m *MusicHandler) GetSoundCheckSong(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/reset [get] // @Router /music/reset [get]
func (m *MusicHandler) ResetMusic(ctx *echo.Context) error { func (m *MusicHandler) ResetMusic(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
backend.Reset() backend.Reset()
return ctx.NoContent(http.StatusOK) return ctx.NoContent(http.StatusOK)
} }
@@ -98,10 +86,6 @@ func (m *MusicHandler) ResetMusic(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/rand [get] // @Router /music/rand [get]
func (m *MusicHandler) GetRandomSong(ctx *echo.Context) error { func (m *MusicHandler) GetRandomSong(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
songPath := backend.GetRandomSong() songPath := backend.GetRandomSong()
file, err := os.Open(songPath) file, err := os.Open(songPath)
if err != nil { if err != nil {
@@ -121,10 +105,6 @@ func (m *MusicHandler) GetRandomSong(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/rand/low [get] // @Router /music/rand/low [get]
func (m *MusicHandler) GetRandomSongLowChance(ctx *echo.Context) error { func (m *MusicHandler) GetRandomSongLowChance(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
songPath := backend.GetRandomSongLowChance() songPath := backend.GetRandomSongLowChance()
file, err := os.Open(songPath) file, err := os.Open(songPath)
if err != nil { if err != nil {
@@ -144,10 +124,6 @@ func (m *MusicHandler) GetRandomSongLowChance(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/rand/classic [get] // @Router /music/rand/classic [get]
func (m *MusicHandler) GetRandomSongClassic(ctx *echo.Context) error { func (m *MusicHandler) GetRandomSongClassic(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
songPath := backend.GetRandomSongClassic() songPath := backend.GetRandomSongClassic()
file, err := os.Open(songPath) file, err := os.Open(songPath)
if err != nil { if err != nil {
@@ -193,10 +169,6 @@ func (m *MusicHandler) GetPlayedSongs(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/next [get] // @Router /music/next [get]
func (m *MusicHandler) GetNextSong(ctx *echo.Context) error { func (m *MusicHandler) GetNextSong(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
songPath := backend.GetNextSong() songPath := backend.GetNextSong()
file, err := os.Open(songPath) file, err := os.Open(songPath)
if err != nil { if err != nil {
@@ -216,10 +188,6 @@ func (m *MusicHandler) GetNextSong(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/previous [get] // @Router /music/previous [get]
func (m *MusicHandler) GetPreviousSong(ctx *echo.Context) error { func (m *MusicHandler) GetPreviousSong(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
songPath := backend.GetPreviousSong() songPath := backend.GetPreviousSong()
file, err := os.Open(songPath) file, err := os.Open(songPath)
if err != nil { if err != nil {
@@ -231,7 +199,7 @@ func (m *MusicHandler) GetPreviousSong(ctx *echo.Context) error {
// GetAllSoundtracks godoc // GetAllSoundtracks godoc
// @Summary Get all soundtracks // @Summary Get all soundtracks
// @Description Returns a list of all games in order // @Description Returns a list of all soundtracks in order
// @Tags music // @Tags music
// @Accept json // @Accept json
// @Produce json // @Produce json
@@ -239,17 +207,13 @@ func (m *MusicHandler) GetPreviousSong(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/all/order [get] // @Router /music/all/order [get]
func (m *MusicHandler) GetAllSoundtracks(ctx *echo.Context) error { func (m *MusicHandler) GetAllSoundtracks(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
soundtrackList := backend.GetAllSoundtracks() soundtrackList := backend.GetAllSoundtracks()
return ctx.JSON(http.StatusOK, soundtrackList) return ctx.JSON(http.StatusOK, soundtrackList)
} }
// GetAllSoundtracksRandom godoc // GetAllSoundtracksRandom godoc
// @Summary Get all soundtracks random // @Summary Get all soundtracks random
// @Description Returns a list of all games in random order // @Description Returns a list of all soundtracks in random order
// @Tags music // @Tags music
// @Accept json // @Accept json
// @Produce json // @Produce json
@@ -257,10 +221,6 @@ func (m *MusicHandler) GetAllSoundtracks(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/all/random [get] // @Router /music/all/random [get]
func (m *MusicHandler) GetAllSoundtracksRandom(ctx *echo.Context) error { func (m *MusicHandler) GetAllSoundtracksRandom(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
soundtrackList := backend.GetAllSoundtracksRandom() soundtrackList := backend.GetAllSoundtracksRandom()
return ctx.JSON(http.StatusOK, soundtrackList) return ctx.JSON(http.StatusOK, soundtrackList)
} }
@@ -277,15 +237,11 @@ func (m *MusicHandler) GetAllSoundtracksRandom(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/played [put] // @Router /music/played [put]
func (m *MusicHandler) PutPlayed(ctx *echo.Context) error { func (m *MusicHandler) PutPlayed(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
song, err := strconv.Atoi(ctx.QueryParam("song")) song, err := strconv.Atoi(ctx.QueryParam("song"))
if err != nil { if err != nil {
return ctx.JSON(http.StatusBadRequest, err.Error()) return ctx.JSON(http.StatusBadRequest, err.Error())
} }
logging.GetLogger().Info("Marking song as played", zap.Int("song_id", song)) logging.GetLogger().Info("Marking song as played", zap.Int("song_id", song))
backend.SetPlayed(song) backend.SetPlayed(song)
return ctx.NoContent(http.StatusOK) return ctx.NoContent(http.StatusOK)
} }
@@ -299,10 +255,6 @@ func (m *MusicHandler) PutPlayed(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/addQue [get] // @Router /music/addQue [get]
func (m *MusicHandler) AddLatestToQue(ctx *echo.Context) error { func (m *MusicHandler) AddLatestToQue(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
backend.AddLatestToQue() backend.AddLatestToQue()
return ctx.NoContent(http.StatusOK) return ctx.NoContent(http.StatusOK)
} }
@@ -316,10 +268,6 @@ func (m *MusicHandler) AddLatestToQue(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /music/addPlayed [get] // @Router /music/addPlayed [get]
func (m *MusicHandler) AddLatestPlayed(ctx *echo.Context) error { func (m *MusicHandler) AddLatestPlayed(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Info("Syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
backend.AddLatestPlayed() backend.AddLatestPlayed()
return ctx.NoContent(http.StatusOK) return ctx.NoContent(http.StatusOK)
} }
internal/server/routes.go
+33 -32
View File
@@ -50,8 +50,9 @@ func (s *Server) RegisterRoutes() http.Handler {
fileServer := http.FileServer(http.FS(web.Assets)) fileServer := http.FileServer(http.FS(web.Assets))
e.GET("/assets/*", echo.WrapHandler(fileServer)) e.GET("/assets/*", echo.WrapHandler(fileServer))
e.GET("/search", echo.WrapHandler(templ.Handler(web.HelloForm()))) e.GET("/search", echo.WrapHandler(templ.Handler(web.SearchForm())))
e.POST("/find", echo.WrapHandler(http.HandlerFunc(web.FindGameWebHandler))) e.POST("/find", echo.WrapHandler(http.HandlerFunc(web.FindSoundtrackWebHandler)))
e.POST("/findfuzzy", echo.WrapHandler(http.HandlerFunc(web.FindSoundtrackFuzzyWebHandler)))
e.Static("/", "/frontend") e.Static("/", "/frontend")
@@ -82,32 +83,32 @@ func (s *Server) RegisterRoutes() http.Handler {
sync := NewSyncHandler() sync := NewSyncHandler()
syncGroup := e.Group("/sync") syncGroup := e.Group("/sync")
syncGroup.GET("", deprecatedMiddleware(sync.SyncSoundtracksNewOnlyChanges)) syncGroup.GET("", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewOnlyChanges)))
syncGroup.GET("/progress", deprecatedMiddleware(sync.SyncProgress)) syncGroup.GET("/progress", deprecatedMiddleware(sync.SyncProgress))
syncGroup.GET("/new", deprecatedMiddleware(sync.SyncSoundtracksNewOnlyChanges)) syncGroup.GET("/new", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewOnlyChanges)))
syncGroup.GET("/full", deprecatedMiddleware(sync.SyncSoundtracksNewFull)) syncGroup.GET("/full", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewFull)))
syncGroup.GET("/new/full", deprecatedMiddleware(sync.SyncSoundtracksNewFull)) syncGroup.GET("/new/full", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewFull)))
syncGroup.GET("/quick", deprecatedMiddleware(sync.SyncSoundtracksNewOnlyChanges)) syncGroup.GET("/quick", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.SyncSoundtracksNewOnlyChanges)))
syncGroup.GET("/reset", deprecatedMiddleware(sync.ResetDB)) syncGroup.GET("/reset", deprecatedMiddleware(middleware.SyncCheckMiddleware(sync.ResetDB)))
music := NewMusicHandler() music := NewMusicHandler()
musicGroup := e.Group("/music") musicGroup := e.Group("/music")
musicGroup.GET("", deprecatedMiddleware(music.GetSong)) musicGroup.GET("", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetSong)))
musicGroup.GET("/soundTest", deprecatedMiddleware(music.GetSoundCheckSong)) musicGroup.GET("/soundTest", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetSoundCheckSong)))
musicGroup.GET("/reset", deprecatedMiddleware(music.ResetMusic)) musicGroup.GET("/reset", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.ResetMusic)))
musicGroup.GET("/rand", deprecatedMiddleware(music.GetRandomSong)) musicGroup.GET("/rand", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetRandomSong)))
musicGroup.GET("/rand/low", deprecatedMiddleware(music.GetRandomSongLowChance)) musicGroup.GET("/rand/low", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetRandomSongLowChance)))
musicGroup.GET("/rand/classic", deprecatedMiddleware(music.GetRandomSongClassic)) musicGroup.GET("/rand/classic", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetRandomSongClassic)))
musicGroup.GET("/info", deprecatedMiddleware(music.GetSongInfo)) musicGroup.GET("/info", deprecatedMiddleware(music.GetSongInfo))
musicGroup.GET("/list", deprecatedMiddleware(music.GetPlayedSongs)) musicGroup.GET("/list", deprecatedMiddleware(music.GetPlayedSongs))
musicGroup.GET("/next", deprecatedMiddleware(music.GetNextSong)) musicGroup.GET("/next", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetNextSong)))
musicGroup.GET("/previous", deprecatedMiddleware(music.GetPreviousSong)) musicGroup.GET("/previous", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetPreviousSong)))
musicGroup.GET("/all", deprecatedMiddleware(music.GetAllSoundtracksRandom)) musicGroup.GET("/all", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetAllSoundtracksRandom)))
musicGroup.GET("/all/order", deprecatedMiddleware(music.GetAllSoundtracks)) musicGroup.GET("/all/order", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetAllSoundtracks)))
musicGroup.GET("/all/random", deprecatedMiddleware(music.GetAllSoundtracksRandom)) musicGroup.GET("/all/random", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.GetAllSoundtracksRandom)))
musicGroup.PUT("/played", deprecatedMiddleware(music.PutPlayed)) musicGroup.PUT("/played", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.PutPlayed)))
musicGroup.GET("/addQue", deprecatedMiddleware(music.AddLatestToQue)) musicGroup.GET("/addQue", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.AddLatestToQue)))
musicGroup.GET("/addPlayed", deprecatedMiddleware(music.AddLatestPlayed)) musicGroup.GET("/addPlayed", deprecatedMiddleware(middleware.SyncCheckMiddleware(music.AddLatestPlayed)))
// ============================================ // ============================================
// API v1 Routes with Token Authentication // API v1 Routes with Token Authentication
@@ -136,20 +137,20 @@ func (s *Server) RegisterRoutes() http.Handler {
// Statistics API endpoints (protected by token auth) // Statistics API endpoints (protected by token auth)
statistics := s.statisticsHandler statistics := s.statisticsHandler
protectedV1.GET("/statistics/games/most-played", func(c *echo.Context) error { protectedV1.GET("/statistics/soundtracks/most-played", func(c *echo.Context) error {
return statistics.GetMostPlayedGames(c) return statistics.GetMostPlayedSoundtracks(c)
}) })
protectedV1.GET("/statistics/games/least-played", func(c *echo.Context) error { protectedV1.GET("/statistics/soundtracks/least-played", func(c *echo.Context) error {
return statistics.GetLeastPlayedGames(c) return statistics.GetLeastPlayedSoundtracks(c)
}) })
protectedV1.GET("/statistics/games/never-played", func(c *echo.Context) error { protectedV1.GET("/statistics/soundtracks/never-played", func(c *echo.Context) error {
return statistics.GetNeverPlayedGames(c) return statistics.GetNeverPlayedSoundtracks(c)
}) })
protectedV1.GET("/statistics/games/last-played", func(c *echo.Context) error { protectedV1.GET("/statistics/soundtracks/last-played", func(c *echo.Context) error {
return statistics.GetLastPlayedGames(c) return statistics.GetLastPlayedSoundtracks(c)
}) })
protectedV1.GET("/statistics/games/oldest-played", func(c *echo.Context) error { protectedV1.GET("/statistics/soundtracks/oldest-played", func(c *echo.Context) error {
return statistics.GetOldestPlayedGames(c) return statistics.GetOldestPlayedSoundtracks(c)
}) })
protectedV1.GET("/statistics/songs/most-played", func(c *echo.Context) error { protectedV1.GET("/statistics/songs/most-played", func(c *echo.Context) error {
return statistics.GetMostPlayedSongs(c) return statistics.GetMostPlayedSongs(c)
internal/server/statistics_handler.go
+62 -62
View File
@@ -23,20 +23,20 @@ func NewStatisticsHandler() *StatisticsHandler {
} }
} }
// GetMostPlayedGames returns top N most played games with songs // GetMostPlayedSoundtracks returns top N most played soundtracks with songs
// GET /api/v1/statistics/games/most-played // GET /api/v1/statistics/soundtracks/most-played
// //
// @Summary Get most played games // @Summary Get most played soundtracks
// @Description Returns the top N most played games with their songs // @Description Returns the top N most played soundtracks with their songs
// @Tags statistics // @Tags statistics
// @Accept json // @Accept json
// @Produce json // @Produce json
// @Param limit query int false "Number of results (default: 10)" // @Param limit query int false "Number of results (default: 10)"
// @Success 200 {array} backend.GameWithSongs // @Success 200 {array} backend.SoundtrackWithSongs
// @Failure 400 {object} map[string]string // @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string // @Failure 500 {object} map[string]string
// @Router /api/v1/statistics/games/most-played [get] // @Router /api/v1/statistics/soundtracks/most-played [get]
func (h *StatisticsHandler) GetMostPlayedGames(ctx *echo.Context) error { func (h *StatisticsHandler) GetMostPlayedSoundtracks(ctx *echo.Context) error {
limit := 10 // default limit := 10 // default
limitStr := ctx.QueryParam("limit") limitStr := ctx.QueryParam("limit")
if limitStr != "" { if limitStr != "" {
@@ -50,29 +50,29 @@ func (h *StatisticsHandler) GetMostPlayedGames(ctx *echo.Context) error {
limit = 100 limit = 100
} }
} }
games, err := h.statsBackend.GetMostPlayedGamesWithSongs(int32(limit)) soundtracks, err := h.statsBackend.GetMostPlayedSoundtracksWithSongs(int32(limit))
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to get most played games", zap.String("error", err.Error())) logging.GetLogger().Error("Failed to get most played soundtracks", zap.String("error", err.Error()))
return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"}) return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
} }
return ctx.JSON(http.StatusOK, games) return ctx.JSON(http.StatusOK, soundtracks)
} }
// GetLeastPlayedGames returns top N least played games with songs // GetLeastPlayedSoundtracks returns top N least played soundtracks with songs
// GET /api/v1/statistics/games/least-played // GET /api/v1/statistics/soundtracks/least-played
// //
// @Summary Get least played games // @Summary Get least played soundtracks
// @Description Returns the top N least played games with their songs // @Description Returns the top N least played soundtracks with their songs
// @Tags statistics // @Tags statistics
// @Accept json // @Accept json
// @Produce json // @Produce json
// @Param limit query int false "Number of results (default: 10)" // @Param limit query int false "Number of results (default: 10)"
// @Success 200 {array} backend.GameWithSongs // @Success 200 {array} backend.SoundtrackWithSongs
// @Failure 400 {object} map[string]string // @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string // @Failure 500 {object} map[string]string
// @Router /api/v1/statistics/games/least-played [get] // @Router /api/v1/statistics/soundtracks/least-played [get]
func (h *StatisticsHandler) GetLeastPlayedGames(ctx *echo.Context) error { func (h *StatisticsHandler) GetLeastPlayedSoundtracks(ctx *echo.Context) error {
limit := 10 limit := 10
limitStr := ctx.QueryParam("limit") limitStr := ctx.QueryParam("limit")
if limitStr != "" { if limitStr != "" {
@@ -85,20 +85,20 @@ func (h *StatisticsHandler) GetLeastPlayedGames(ctx *echo.Context) error {
limit = 100 limit = 100
} }
} }
games, err := h.statsBackend.GetLeastPlayedGamesWithSongs(int32(limit)) soundtracks, err := h.statsBackend.GetLeastPlayedSoundtracksWithSongs(int32(limit))
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to get least played games", zap.String("error", err.Error())) logging.GetLogger().Error("Failed to get least played soundtracks", zap.String("error", err.Error()))
return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"}) return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
} }
return ctx.JSON(http.StatusOK, games) return ctx.JSON(http.StatusOK, soundtracks)
} }
// GetMostPlayedSongs returns top N most played songs with game info // GetMostPlayedSongs returns top N most played songs with soundtrack info
// GET /api/v1/statistics/songs/most-played // GET /api/v1/statistics/songs/most-played
// //
// @Summary Get most played songs // @Summary Get most played songs
// @Description Returns the top N most played songs with their game info // @Description Returns the top N most played songs with their soundtrack info
// @Tags statistics // @Tags statistics
// @Accept json // @Accept json
// @Produce json // @Produce json
@@ -120,8 +120,8 @@ func (h *StatisticsHandler) GetMostPlayedSongs(ctx *echo.Context) error {
limit = 100 limit = 100
} }
} }
songs, err := h.statsBackend.GetMostPlayedSongsWithGame(int32(limit)) songs, err := h.statsBackend.GetMostPlayedSongsWithSoundtrack(int32(limit))
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to get most played songs", zap.String("error", err.Error())) logging.GetLogger().Error("Failed to get most played songs", zap.String("error", err.Error()))
return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"}) return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
@@ -129,11 +129,11 @@ func (h *StatisticsHandler) GetMostPlayedSongs(ctx *echo.Context) error {
return ctx.JSON(http.StatusOK, songs) return ctx.JSON(http.StatusOK, songs)
} }
// GetLeastPlayedSongs returns top N least played songs with game info // GetLeastPlayedSongs returns top N least played songs with soundtrack info
// GET /api/v1/statistics/songs/least-played // GET /api/v1/statistics/songs/least-played
// //
// @Summary Get least played songs // @Summary Get least played songs
// @Description Returns the top N least played songs with their game info // @Description Returns the top N least played songs with their soundtrack info
// @Tags statistics // @Tags statistics
// @Accept json // @Accept json
// @Produce json // @Produce json
@@ -155,8 +155,8 @@ func (h *StatisticsHandler) GetLeastPlayedSongs(ctx *echo.Context) error {
limit = 100 limit = 100
} }
} }
songs, err := h.statsBackend.GetLeastPlayedSongsWithGame(int32(limit)) songs, err := h.statsBackend.GetLeastPlayedSongsWithSoundtrack(int32(limit))
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to get least played songs", zap.String("error", err.Error())) logging.GetLogger().Error("Failed to get least played songs", zap.String("error", err.Error()))
return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"}) return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
@@ -164,40 +164,40 @@ func (h *StatisticsHandler) GetLeastPlayedSongs(ctx *echo.Context) error {
return ctx.JSON(http.StatusOK, songs) return ctx.JSON(http.StatusOK, songs)
} }
// GetNeverPlayedGames returns games that have never been played // GetNeverPlayedSoundtracks returns soundtracks that have never been played
// GET /api/v1/statistics/games/never-played // GET /api/v1/statistics/soundtracks/never-played
// //
// @Summary Get never played games // @Summary Get never played soundtracks
// @Description Returns all games that have never been played (times_played = 0) // @Description Returns all soundtracks that have never been played (times_played = 0)
// @Tags statistics // @Tags statistics
// @Accept json // @Accept json
// @Produce json // @Produce json
// @Success 200 {array} backend.GameWithSongs // @Success 200 {array} backend.SoundtrackWithSongs
// @Failure 500 {object} map[string]string // @Failure 500 {object} map[string]string
// @Router /api/v1/statistics/games/never-played [get] // @Router /api/v1/statistics/soundtracks/never-played [get]
func (h *StatisticsHandler) GetNeverPlayedGames(ctx *echo.Context) error { func (h *StatisticsHandler) GetNeverPlayedSoundtracks(ctx *echo.Context) error {
games, err := h.statsBackend.GetNeverPlayedGames() soundtracks, err := h.statsBackend.GetNeverPlayedSoundtracks()
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to get never played games", zap.String("error", err.Error())) logging.GetLogger().Error("Failed to get never played soundtracks", zap.String("error", err.Error()))
return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"}) return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
} }
return ctx.JSON(http.StatusOK, games) return ctx.JSON(http.StatusOK, soundtracks)
} }
// GetLastPlayedGames returns most recently played games // GetLastPlayedSoundtracks returns most recently played soundtracks
// GET /api/v1/statistics/games/last-played // GET /api/v1/statistics/soundtracks/last-played
// //
// @Summary Get last played games // @Summary Get last played soundtracks
// @Description Returns the most recently played games // @Description Returns the most recently played soundtracks
// @Tags statistics // @Tags statistics
// @Accept json // @Accept json
// @Produce json // @Produce json
// @Param limit query int false "Number of results (default: 10)" // @Param limit query int false "Number of results (default: 10)"
// @Success 200 {array} backend.GameWithSongs // @Success 200 {array} backend.SoundtrackWithSongs
// @Failure 400 {object} map[string]string // @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string // @Failure 500 {object} map[string]string
// @Router /api/v1/statistics/games/last-played [get] // @Router /api/v1/statistics/soundtracks/last-played [get]
func (h *StatisticsHandler) GetLastPlayedGames(ctx *echo.Context) error { func (h *StatisticsHandler) GetLastPlayedSoundtracks(ctx *echo.Context) error {
limit := 10 limit := 10
limitStr := ctx.QueryParam("limit") limitStr := ctx.QueryParam("limit")
if limitStr != "" { if limitStr != "" {
@@ -210,29 +210,29 @@ func (h *StatisticsHandler) GetLastPlayedGames(ctx *echo.Context) error {
limit = 100 limit = 100
} }
} }
games, err := h.statsBackend.GetLastPlayedGames(int32(limit)) soundtracks, err := h.statsBackend.GetLastPlayedSoundtracks(int32(limit))
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to get last played games", zap.String("error", err.Error())) logging.GetLogger().Error("Failed to get last played soundtracks", zap.String("error", err.Error()))
return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"}) return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
} }
return ctx.JSON(http.StatusOK, games) return ctx.JSON(http.StatusOK, soundtracks)
} }
// GetOldestPlayedGames returns least recently played games // GetOldestPlayedSoundtracks returns least recently played soundtracks
// GET /api/v1/statistics/games/oldest-played // GET /api/v1/statistics/soundtracks/oldest-played
// //
// @Summary Get oldest played games // @Summary Get oldest played soundtracks
// @Description Returns the least recently played games (that have been played at least once) // @Description Returns the least recently played soundtracks (that have been played at least once)
// @Tags statistics // @Tags statistics
// @Accept json // @Accept json
// @Produce json // @Produce json
// @Param limit query int false "Number of results (default: 10)" // @Param limit query int false "Number of results (default: 10)"
// @Success 200 {array} backend.GameWithSongs // @Success 200 {array} backend.SoundtrackWithSongs
// @Failure 400 {object} map[string]string // @Failure 400 {object} map[string]string
// @Failure 500 {object} map[string]string // @Failure 500 {object} map[string]string
// @Router /api/v1/statistics/games/oldest-played [get] // @Router /api/v1/statistics/soundtracks/oldest-played [get]
func (h *StatisticsHandler) GetOldestPlayedGames(ctx *echo.Context) error { func (h *StatisticsHandler) GetOldestPlayedSoundtracks(ctx *echo.Context) error {
limit := 10 limit := 10
limitStr := ctx.QueryParam("limit") limitStr := ctx.QueryParam("limit")
if limitStr != "" { if limitStr != "" {
@@ -245,13 +245,13 @@ func (h *StatisticsHandler) GetOldestPlayedGames(ctx *echo.Context) error {
limit = 100 limit = 100
} }
} }
games, err := h.statsBackend.GetOldestPlayedGames(int32(limit)) soundtracks, err := h.statsBackend.GetOldestPlayedSoundtracks(int32(limit))
if err != nil { if err != nil {
logging.GetLogger().Error("Failed to get oldest played games", zap.String("error", err.Error())) logging.GetLogger().Error("Failed to get oldest played soundtracks", zap.String("error", err.Error()))
return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"}) return ctx.JSON(http.StatusInternalServerError, map[string]string{"error": "Failed to get statistics"})
} }
return ctx.JSON(http.StatusOK, games) return ctx.JSON(http.StatusOK, soundtracks)
} }
// GetStatisticsSummary returns overall statistics // GetStatisticsSummary returns overall statistics
internal/server/statistics_handler_test.go
+2 -2
View File
@@ -91,8 +91,8 @@ func TestPartialMigrationThenSyncThenComplete(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
// After sync with /sync/new, only soundtracks matching filesystem remain // After sync with /sync/new, only soundtracks matching filesystem remain
// testMusic has 3 games // testMusic has 3 soundtracks
require.Equal(t, int64(3), summary.TotalGames) require.Equal(t, int64(3), summary.TotalSoundtracks)
} }
// insertTestData inserts 5 test soundtracks with songs into the database // insertTestData inserts 5 test soundtracks with songs into the database
internal/server/syncHandler.go
+6 -18
View File
@@ -36,7 +36,7 @@ func (s *SyncHandler) SyncProgress(ctx *echo.Context) error {
// SyncSoundtracksNewOnlyChanges godoc // SyncSoundtracksNewOnlyChanges godoc
// @Summary Sync soundtracks with only changes // @Summary Sync soundtracks with only changes
// @Description Starts syncing games with only new changes // @Description Starts syncing soundtracks with only new changes
// @Tags sync // @Tags sync
// @Accept json // @Accept json
// @Produce json // @Produce json
@@ -44,19 +44,15 @@ func (s *SyncHandler) SyncProgress(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /sync [get] // @Router /sync [get]
func (s *SyncHandler) SyncSoundtracksNewOnlyChanges(ctx *echo.Context) error { func (s *SyncHandler) SyncSoundtracksNewOnlyChanges(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Warn("Syncing is already in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
logging.GetLogger().Info("Starting sync with only changes") logging.GetLogger().Info("Starting sync with only changes")
backend.Syncing = true backend.Syncing = true
go backend.SyncSoundtracksNewOnlyChanges() go backend.SyncSoundtracksOnlyChanges()
return ctx.JSON(http.StatusOK, "Start syncing soundtracks") return ctx.JSON(http.StatusOK, "Start syncing soundtracks")
} }
// SyncSoundtracksNewFull godoc // SyncSoundtracksNewFull godoc
// @Summary Sync all games fully // @Summary Sync all soundtracks fully
// @Description Starts a full sync of all games // @Description Starts a full sync of all soundtracks
// @Tags sync // @Tags sync
// @Accept json // @Accept json
// @Produce json // @Produce json
@@ -64,19 +60,15 @@ func (s *SyncHandler) SyncSoundtracksNewOnlyChanges(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /sync/full [get] // @Router /sync/full [get]
func (s *SyncHandler) SyncSoundtracksNewFull(ctx *echo.Context) error { func (s *SyncHandler) SyncSoundtracksNewFull(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Warn("Syncing is already in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
logging.GetLogger().Info("Starting full sync") logging.GetLogger().Info("Starting full sync")
backend.Syncing = true backend.Syncing = true
go backend.SyncSoundtracksNewFull() go backend.SyncSoundtracksFull()
return ctx.JSON(http.StatusOK, "Start syncing soundtracks full") return ctx.JSON(http.StatusOK, "Start syncing soundtracks full")
} }
// ResetDB godoc // ResetDB godoc
// @Summary Reset soundtracks database // @Summary Reset soundtracks database
// @Description Resets the games database by deleting all games and songs // @Description Resets the soundtracks database by deleting all soundtracks and songs
// @Tags sync // @Tags sync
// @Accept json // @Accept json
// @Produce json // @Produce json
@@ -84,10 +76,6 @@ func (s *SyncHandler) SyncSoundtracksNewFull(ctx *echo.Context) error {
// @Failure 423 {string} string "Syncing is in progress" // @Failure 423 {string} string "Syncing is in progress"
// @Router /sync/reset [get] // @Router /sync/reset [get]
func (s *SyncHandler) ResetDB(ctx *echo.Context) error { func (s *SyncHandler) ResetDB(ctx *echo.Context) error {
if backend.Syncing {
logging.GetLogger().Warn("Cannot reset - syncing is in progress")
return ctx.JSON(http.StatusLocked, "Syncing is in progress")
}
logging.GetLogger().Info("Resetting soundtracks database") logging.GetLogger().Info("Resetting soundtracks database")
backend.ResetDB() backend.ResetDB()
return ctx.JSON(http.StatusOK, "Soundtracks and songs are deleted from the database") return ctx.JSON(http.StatusOK, "Soundtracks and songs are deleted from the database")
internal/server/sync_handler_test.go
+42 -42
View File
@@ -28,7 +28,7 @@ func waitForSyncCompletion(t *testing.T, e *echo.Echo, maxAttempts int) bool {
if err == nil && progress.Progress != "" { if err == nil && progress.Progress != "" {
// Successfully parsed as ProgressResponse with non-empty progress // Successfully parsed as ProgressResponse with non-empty progress
t.Logf("Sync progress: %s%%", progress.Progress) t.Logf("Sync progress: %s%%", progress.Progress)
if progress.Progress == "100" { if progress.Progress == "100" {
t.Log("Sync completed!") t.Log("Sync completed!")
// Wait for Syncing flag to be updated // Wait for Syncing flag to be updated
for j := 0; j < 50; j++ { for j := 0; j < 50; j++ {
@@ -61,7 +61,7 @@ func waitForSyncCompletion(t *testing.T, e *echo.Echo, maxAttempts int) bool {
return false return false
} }
// TestSyncPopulatesDatabase verifies that sync populates the database with games // TestSyncPopulatesDatabase verifies that sync populates the database with soundtracks
func TestSyncPopulatesDatabase(t *testing.T) { func TestSyncPopulatesDatabase(t *testing.T) {
db.TestSetupDB(t) db.TestSetupDB(t)
defer db.TestTearDownDB(t) defer db.TestTearDownDB(t)
@@ -74,12 +74,12 @@ func TestSyncPopulatesDatabase(t *testing.T) {
// Clear any existing data first // Clear any existing data first
db.TestClearDatabase(t) db.TestClearDatabase(t)
// Before sync - should have no games // Before sync - should have no soundtracks
repo := repository.New(backend.BackendPool()) repo := repository.New(backend.BackendPool())
gamesBefore, err := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracksBefore, err := repo.FindAllSoundtracks(backend.BackendCtx())
assert.NoError(t, err) assert.NoError(t, err)
beforeCount := len(gamesBefore) beforeCount := len(soundtracksBefore)
t.Logf("Games before sync: %d", beforeCount) t.Logf("Soundtracks before sync: %d", beforeCount)
assert.Equal(t, 0, beforeCount, "Database should be empty after clear") assert.Equal(t, 0, beforeCount, "Database should be empty after clear")
// Run sync // Run sync
@@ -91,14 +91,14 @@ func TestSyncPopulatesDatabase(t *testing.T) {
t.Error("Sync did not complete within timeout") t.Error("Sync did not complete within timeout")
} }
// After sync - should have games // After sync - should have soundtracks
gamesAfter, err := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracksAfter, err := repo.FindAllSoundtracks(backend.BackendCtx())
assert.NoError(t, err) assert.NoError(t, err)
afterCount := len(gamesAfter) afterCount := len(soundtracksAfter)
t.Logf("Games after sync: %d", afterCount) t.Logf("Soundtracks after sync: %d", afterCount)
// Should have more games than before (unless database was already populated) // Should have more soundtracks than before (unless database was already populated)
assert.True(t, afterCount > 0, "Database should have games after sync") assert.True(t, afterCount > 0, "Database should have soundtracks after sync")
} }
// TestSyncMakesDifference verifies that sync actually changes the database state // TestSyncMakesDifference verifies that sync actually changes the database state
@@ -111,11 +111,11 @@ func TestSyncMakesDifference(t *testing.T) {
// Clear any existing data first // Clear any existing data first
db.TestClearDatabase(t) db.TestClearDatabase(t)
// Before sync - should have no games // Before sync - should have no soundtracks
repo := repository.New(backend.BackendPool()) repo := repository.New(backend.BackendPool())
gamesBefore, err := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracksBefore, err := repo.FindAllSoundtracks(backend.BackendCtx())
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, 0, len(gamesBefore), "Should have no games before sync") assert.Equal(t, 0, len(soundtracksBefore), "Should have no soundtracks before sync")
// Run sync // Run sync
resp := MakeTestRequest(t, e, "GET", "/sync/full") resp := MakeTestRequest(t, e, "GET", "/sync/full")
@@ -126,10 +126,10 @@ func TestSyncMakesDifference(t *testing.T) {
t.Error("Sync did not complete within timeout") t.Error("Sync did not complete within timeout")
} }
// After sync - should have games // After sync - should have soundtracks
gamesAfter, err := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracksAfter, err := repo.FindAllSoundtracks(backend.BackendCtx())
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, len(gamesAfter) > 0, "Should have games after sync") assert.True(t, len(soundtracksAfter) > 0, "Should have soundtracks after sync")
} }
// TestSyncProgress verifies the sync progress endpoint // TestSyncProgress verifies the sync progress endpoint
@@ -183,8 +183,8 @@ func TestSyncProgress(t *testing.T) {
assert.True(t, foundComplete, "Should have seen completion") assert.True(t, foundComplete, "Should have seen completion")
} }
// TestSyncGamesNewOnlyChanges verifies the incremental sync endpoint // TestSyncSoundtracksNewOnlyChanges verifies the incremental sync endpoint
func TestSyncGamesNewOnlyChanges(t *testing.T) { func TestSyncSoundtracksNewOnlyChanges(t *testing.T) {
db.TestSetupDB(t) db.TestSetupDB(t)
defer db.TestTearDownDB(t) defer db.TestTearDownDB(t)
@@ -200,8 +200,8 @@ func TestSyncGamesNewOnlyChanges(t *testing.T) {
// Get initial count // Get initial count
repo := repository.New(backend.BackendPool()) repo := repository.New(backend.BackendPool())
gamesBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracksBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
beforeCount := len(gamesBefore) beforeCount := len(soundtracksBefore)
// Run incremental sync (should not change count if nothing changed) // Run incremental sync (should not change count if nothing changed)
resp := MakeTestRequest(t, e, "GET", "/sync/new") resp := MakeTestRequest(t, e, "GET", "/sync/new")
@@ -211,16 +211,16 @@ func TestSyncGamesNewOnlyChanges(t *testing.T) {
time.Sleep(2 * time.Second) time.Sleep(2 * time.Second)
// Count should be the same // Count should be the same
gamesAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracksAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
afterCount := len(gamesAfter) afterCount := len(soundtracksAfter)
// Note: This might not be exactly equal due to timing, but should be close // Note: This might not be exactly equal due to timing, but should be close
t.Logf("Games before incremental sync: %d, after: %d", beforeCount, afterCount) t.Logf("Soundtracks before incremental sync: %d, after: %d", beforeCount, afterCount)
} }
// TestResetGames verifies the reset endpoint clears the database // TestResetSoundtracks verifies the reset endpoint clears the database
// RUN THIS LAST // RUN THIS LAST
func TestResetGames(t *testing.T) { func TestResetSoundtracks(t *testing.T) {
db.TestSetupDB(t) db.TestSetupDB(t)
defer db.TestTearDownDB(t) defer db.TestTearDownDB(t)
@@ -228,8 +228,8 @@ func TestResetGames(t *testing.T) {
// First ensure we have data // First ensure we have data
repo := repository.New(backend.BackendPool()) repo := repository.New(backend.BackendPool())
gamesBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracksBefore, _ := repo.FindAllSoundtracks(backend.BackendCtx())
beforeCount := len(gamesBefore) beforeCount := len(soundtracksBefore)
if beforeCount == 0 { if beforeCount == 0 {
// Run sync to populate // Run sync to populate
@@ -238,12 +238,12 @@ func TestResetGames(t *testing.T) {
t.Error("Sync did not complete within timeout") t.Error("Sync did not complete within timeout")
return return
} }
gamesBefore, _ = repo.FindAllSoundtracks(backend.BackendCtx()) soundtracksBefore, _ = repo.FindAllSoundtracks(backend.BackendCtx())
beforeCount = len(gamesBefore) beforeCount = len(soundtracksBefore)
} }
t.Logf("Games before reset: %d", beforeCount) t.Logf("Soundtracks before reset: %d", beforeCount)
assert.True(t, beforeCount > 0, "Should have games to reset") assert.True(t, beforeCount > 0, "Should have soundtracks to reset")
// Call reset // Call reset
resp := MakeTestRequest(t, e, "GET", "/sync/reset") resp := MakeTestRequest(t, e, "GET", "/sync/reset")
@@ -253,16 +253,16 @@ func TestResetGames(t *testing.T) {
// Note: reset might take a moment to propagate // Note: reset might take a moment to propagate
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
gamesAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracksAfter, _ := repo.FindAllSoundtracks(backend.BackendCtx())
afterCount := len(gamesAfter) afterCount := len(soundtracksAfter)
t.Logf("Games after reset: %d", afterCount) t.Logf("Soundtracks after reset: %d", afterCount)
assert.Equal(t, 0, afterCount, "Database should be empty after reset") assert.Equal(t, 0, afterCount, "Database should be empty after reset")
} }
// TestSyncGamesNewFull verifies the full sync endpoint // TestSyncSoundtracksNewFull verifies the full sync endpoint
// RUN THIS LAST (before TestResetGames) // RUN THIS LAST (before TestResetSoundtracks)
func TestSyncGamesNewFull(t *testing.T) { func TestSyncSoundtracksNewFull(t *testing.T) {
db.TestSetupDB(t) db.TestSetupDB(t)
defer db.TestTearDownDB(t) defer db.TestTearDownDB(t)
@@ -282,8 +282,8 @@ func TestSyncGamesNewFull(t *testing.T) {
// Verify database is populated // Verify database is populated
repo := repository.New(backend.BackendPool()) repo := repository.New(backend.BackendPool())
games, err := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracks, err := repo.FindAllSoundtracks(backend.BackendCtx())
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, len(games) > 0, "Database should be populated after full sync") assert.True(t, len(soundtracks) > 0, "Database should be populated after full sync")
t.Logf("Full sync populated %d games", len(games)) t.Logf("Full sync populated %d soundtracks", len(soundtracks))
} }
internal/server/zz_music_handler_test.go
+18 -18
View File
@@ -16,12 +16,12 @@ import (
// ensureSyncRan ensures that sync has been run before testing music endpoints // ensureSyncRan ensures that sync has been run before testing music endpoints
func ensureSyncRan(t *testing.T, e *echo.Echo) { func ensureSyncRan(t *testing.T, e *echo.Echo) {
repo := repository.New(backend.BackendPool()) repo := repository.New(backend.BackendPool())
games, err := repo.FindAllSoundtracks(backend.BackendCtx()) soundtracks, err := repo.FindAllSoundtracks(backend.BackendCtx())
assert.NoError(t, err) assert.NoError(t, err)
if len(games) == 0 { if len(soundtracks) == 0 {
// Run sync // Run sync
t.Log("No games found, running sync first...") t.Log("No soundtracks found, running sync first...")
resp := MakeTestRequest(t, e, "GET", "/sync/full") resp := MakeTestRequest(t, e, "GET", "/sync/full")
assert.Equal(t, http.StatusOK, resp.Code) assert.Equal(t, http.StatusOK, resp.Code)
@@ -32,8 +32,8 @@ func ensureSyncRan(t *testing.T, e *echo.Echo) {
} }
} }
// TestGetAllGames verifies the /music/all/order endpoint // TestGetAllSoundtracks verifies the /music/all/order endpoint
func TestZGetAllGames(t *testing.T) { func TestZGetAllSoundtracks(t *testing.T) {
db.TestSetupDB(t) db.TestSetupDB(t)
defer db.TestTearDownDB(t) defer db.TestTearDownDB(t)
@@ -45,15 +45,15 @@ func TestZGetAllGames(t *testing.T) {
resp := MakeTestRequest(t, e, "GET", "/music/all/order") resp := MakeTestRequest(t, e, "GET", "/music/all/order")
assert.Equal(t, http.StatusOK, resp.Code) assert.Equal(t, http.StatusOK, resp.Code)
var games []string var soundtracks []string
err := json.Unmarshal(resp.Body.Bytes(), &games) err := json.Unmarshal(resp.Body.Bytes(), &soundtracks)
assert.NoError(t, err) assert.NoError(t, err)
assert.NotEmpty(t, games, "Should have games after sync") assert.NotEmpty(t, soundtracks, "Should have soundtracks after sync")
t.Logf("Found %d games", len(games)) t.Logf("Found %d soundtracks", len(soundtracks))
} }
// TestGetAllGamesRandom verifies the /music/all/random endpoint // TestGetAllSoundtracksRandom verifies the /music/all/random endpoint
func TestZGetAllGamesRandom(t *testing.T) { func TestZGetAllSoundtracksRandom(t *testing.T) {
db.TestSetupDB(t) db.TestSetupDB(t)
defer db.TestTearDownDB(t) defer db.TestTearDownDB(t)
@@ -65,17 +65,17 @@ func TestZGetAllGamesRandom(t *testing.T) {
resp := MakeTestRequest(t, e, "GET", "/music/all/random") resp := MakeTestRequest(t, e, "GET", "/music/all/random")
assert.Equal(t, http.StatusOK, resp.Code) assert.Equal(t, http.StatusOK, resp.Code)
var games []string var soundtracks []string
err := json.Unmarshal(resp.Body.Bytes(), &games) err := json.Unmarshal(resp.Body.Bytes(), &soundtracks)
assert.NoError(t, err) assert.NoError(t, err)
assert.NotEmpty(t, games, "Should have games after sync") assert.NotEmpty(t, soundtracks, "Should have soundtracks after sync")
// Verify it's shuffled (not in original order) // Verify it's shuffled (not in original order)
// We can't easily verify randomness, but we can check it's the same length // We can't easily verify randomness, but we can check it's the same length
resp2 := MakeTestRequest(t, e, "GET", "/music/all/order") resp2 := MakeTestRequest(t, e, "GET", "/music/all/order")
var gamesOrdered []string var soundtracksOrdered []string
json.Unmarshal(resp2.Body.Bytes(), &gamesOrdered) json.Unmarshal(resp2.Body.Bytes(), &soundtracksOrdered)
assert.Equal(t, len(games), len(gamesOrdered), "Random and ordered should have same count") assert.Equal(t, len(soundtracks), len(soundtracksOrdered), "Random and ordered should have same count")
} }
// TestGetRandomSong verifies the /music/rand endpoint // TestGetRandomSong verifies the /music/rand endpoint
@@ -153,7 +153,7 @@ func TestZGetSongInfo(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// Note: CurrentlyPlaying might be false if no song is currently set // Note: CurrentlyPlaying might be false if no song is currently set
// Just verify we got a valid response // Just verify we got a valid response
t.Logf("Song info: Game=%s, Song=%s", info.Game, info.Song) t.Logf("Song info: Soundtrack=%s, Song=%s", info.Soundtrack, info.Song)
} }
// TestGetPlayedSongs verifies the /music/list endpoint // TestGetPlayedSongs verifies the /music/list endpoint