feat: add per-user moods as generated playlists
CI / chart (push) Successful in 2s
CI / chart-push (push) Successful in 2s
CI / test (push) Successful in 1m41s
CI / image (push) Successful in 3m11s

Add private server-managed playlist moods with curated seeds and related
library fill. Moods are created or promoted from existing playlists in the
web UI, refresh lazily after their TTL, and are marked stale after a scan.

Symfonium stars pin the active mood: opening a mood restores its context,
and a starred song becomes a permanent seed. Without an active session the
song is pinned to every mood that already contains it.

Includes the V4 migration, custom mood endpoints, management UI, tests and
smoke coverage. Bump the chart to 0.1.4.
This commit is contained in:
TapTap committed 2026-11-14 12:52:25 +00:00
1 parent e08d993e35
commit 28bfdd9d00
25 files changed
+2039 -14

No files matched your search

+99 -5
View File
@@ -141,7 +141,8 @@ Build a lightweight, self-hosted **OpenSubsonic-compatible music server** in **K
4. **Two content types, never mixed:** *music* and *long-form* (audiobooks, podcasts, lectures) live in **separate music folders**. Clients see and select them independently. 4. **Two content types, never mixed:** *music* and *long-form* (audiobooks, podcasts, lectures) live in **separate music folders**. Clients see and select them independently.
5. **Multi-user:** users are defined outside the database (config + HashiCorp Vault). Music roots are assigned per user, long-form is shared. Stars, ratings, play counts, bookmarks and playlists are per user. 5. **Multi-user:** users are defined outside the database (config + HashiCorp Vault). Music roots are assigned per user, long-form is shared. Stars, ratings, play counts, bookmarks and playlists are per user.
6. **Transcoding:** optional on-the-fly MP3 transcoding with `maxBitRate` and `timeOffset` support. 6. **Transcoding:** optional on-the-fly MP3 transcoding with `maxBitRate` and `timeOffset` support.
7. **Extensibility:** clean separation between scanner, database layer and HTTP API so a downloader and a discovery/recommendation engine can be added later. 7. **Moods:** per-user private playlists generated from curated seeds and related library music. Symfonium likes pin songs to the active mood.
8. **Extensibility:** clean separation between scanner, database layer and HTTP API so a downloader and a discovery/recommendation engine can be added later.
### Explicit non-goals (MVP) ### Explicit non-goals (MVP)
@@ -152,6 +153,7 @@ Build a lightweight, self-hosted **OpenSubsonic-compatible music server** in **K
- User-management API (users come from config/Vault). - User-management API (users come from config/Vault).
- TLS inside the app (terminated by the k3s ingress). - TLS inside the app (terminated by the k3s ingress).
- Automatic filesystem watching (scans are manual or on boot when the DB is empty). - Automatic filesystem watching (scans are manual or on boot when the DB is empty).
- Downloading or streaming YT Music inside the app (future phase; recommendations are metadata-only until then).
- Backups (documented manual procedure only). - Backups (documented manual procedure only).
### Roles ### Roles
@@ -198,12 +200,18 @@ src/main/kotlin/win/taptap/musicmanager/
| |-- LibraryRepository.kt # Visibility-scoped browsing, feeds, genres, search | |-- LibraryRepository.kt # Visibility-scoped browsing, feeds, genres, search
| |-- UserStateRepository.kt # Play counts, stars, ratings, bookmarks | |-- UserStateRepository.kt # Play counts, stars, ratings, bookmarks
| |-- PlaylistRepository.kt # Playlist CRUD and visibility | |-- PlaylistRepository.kt # Playlist CRUD and visibility
| |-- MoodRepository.kt # Mood settings, seeds, pinned recommendations
| |-- MediaRepository.kt # Scanner persistence and aggregate rebuilds | |-- MediaRepository.kt # Scanner persistence and aggregate rebuilds
| `-- migrations/ # Flyway SQL (V1__init.sql, ...) | `-- migrations/ # Flyway SQL (V1__init.sql, ...)
|-- scanner/ |-- scanner/
| |-- MediaScanner.kt # Recursive scan, delta updates, orphan cleanup | |-- MediaScanner.kt # Recursive scan, delta updates, orphan cleanup
| |-- Mp3TagExtractor.kt # jaudiotagger wrapper (tags, path fallback, duration, bitrate) | |-- Mp3TagExtractor.kt # jaudiotagger wrapper (tags, path fallback, duration, bitrate)
| `-- CoverArtService.kt # Cover extraction from tags/folders, disk cache, resizing | `-- CoverArtService.kt # Cover extraction from tags/folders, disk cache, resizing
|-- mood/
| |-- MoodMixService.kt # Seed + related-library mix generation
| |-- MoodService.kt # TTL refresh and per-mood generation locking
| |-- MoodSessionTracker.kt # Active mood for Symfonium star pinning
| `-- MoodPins.kt # star/unstar -> mood seed translation
|-- subsonic/ |-- subsonic/
| |-- SubsonicAuth.kt # Token (u, t, s) and password (p, enc:) auth | |-- SubsonicAuth.kt # Token (u, t, s) and password (p, enc:) auth
| |-- SubsonicResponse.kt # JSON envelope & error codes | |-- SubsonicResponse.kt # JSON envelope & error codes
@@ -217,7 +225,8 @@ src/main/kotlin/win/taptap/musicmanager/
| |-- BrowsingRoutes.kt # indexes, artists, album, song, search3, lists, genres | |-- BrowsingRoutes.kt # indexes, artists, album, song, search3, lists, genres
| |-- MediaRoutes.kt # stream, download, getCoverArt, lyrics | |-- MediaRoutes.kt # stream, download, getCoverArt, lyrics
| |-- InteractionRoutes.kt # scrobble, star/unstar, setRating, getStarred2 | |-- InteractionRoutes.kt # scrobble, star/unstar, setRating, getStarred2
| `-- PlaylistRoutes.kt # playlists and playlist songs | |-- PlaylistRoutes.kt # playlists and playlist songs
| `-- MoodRoutes.kt # custom mood management endpoints
|-- transcoding/ |-- transcoding/
| `-- FfmpegTranscoder.kt # MP3 transcoding with maxBitRate and timeOffset | `-- FfmpegTranscoder.kt # MP3 transcoding with maxBitRate and timeOffset
`-- util/ `-- util/
@@ -438,6 +447,7 @@ CREATE TABLE playlists (
name TEXT NOT NULL, name TEXT NOT NULL,
comment TEXT, comment TEXT,
is_public BOOLEAN NOT NULL DEFAULT 1, is_public BOOLEAN NOT NULL DEFAULT 1,
kind TEXT NOT NULL DEFAULT 'user' CHECK (kind IN ('user', 'mood')),
created_at TEXT NOT NULL, created_at TEXT NOT NULL,
changed_at TEXT NOT NULL changed_at TEXT NOT NULL
); );
@@ -448,6 +458,45 @@ CREATE TABLE playlist_songs (
position INTEGER NOT NULL, position INTEGER NOT NULL,
PRIMARY KEY (playlist_id, position) PRIMARY KEY (playlist_id, position)
); );
-- Moods are private playlists with generation settings. The current mix lives
-- in playlist_songs; these tables hold the anchors and future YT candidates.
CREATE TABLE moods (
playlist_id TEXT PRIMARY KEY REFERENCES playlists(id) ON DELETE CASCADE,
query TEXT,
genres TEXT NOT NULL DEFAULT '[]',
target_size INTEGER NOT NULL DEFAULT 50,
yt_slots INTEGER NOT NULL DEFAULT 0,
expand_related BOOLEAN NOT NULL DEFAULT 1,
refresh_hours INTEGER NOT NULL DEFAULT 24,
generated_at TEXT,
generation INTEGER NOT NULL DEFAULT 0,
last_error TEXT
);
CREATE TABLE mood_seeds (
playlist_id TEXT NOT NULL REFERENCES moods(playlist_id) ON DELETE CASCADE,
song_id TEXT NOT NULL REFERENCES songs(id) ON DELETE CASCADE,
origin TEXT NOT NULL DEFAULT 'manual'
CHECK (origin IN ('manual', 'promoted', 'star', 'yt_like')),
added_at TEXT NOT NULL,
PRIMARY KEY (playlist_id, song_id)
);
CREATE TABLE mood_recommendations (
playlist_id TEXT NOT NULL REFERENCES moods(playlist_id) ON DELETE CASCADE,
video_id TEXT NOT NULL,
title TEXT NOT NULL,
artist TEXT NOT NULL,
duration INTEGER,
state TEXT NOT NULL DEFAULT 'new'
CHECK (state IN ('new', 'liked', 'rejected', 'downloaded')),
matched_song_id TEXT REFERENCES songs(id) ON DELETE SET NULL,
times_added INTEGER NOT NULL DEFAULT 0,
first_seen TEXT NOT NULL,
last_seen TEXT NOT NULL,
PRIMARY KEY (playlist_id, video_id)
);
``` ```
Required indexes: Required indexes:
@@ -457,6 +506,7 @@ Required indexes:
- `album_artists(artist_id)`, `song_artists(artist_id)` - `album_artists(artist_id)`, `song_artists(artist_id)`
- `user_song_state(user_name, starred_at)`, `user_stars(user_name, item_type)` - `user_song_state(user_name, starred_at)`, `user_stars(user_name, item_type)`
- `playlist_songs(song_id)`, `playlists(owner)` - `playlist_songs(song_id)`, `playlists(owner)`
- `mood_seeds(song_id)`, `mood_recommendations(matched_song_id)`
All timestamps are ISO 8601 in UTC. All timestamps are ISO 8601 in UTC.
@@ -604,6 +654,46 @@ For every `/rest/*` call (except an optional health check):
No `createUser` / `updateUser` / `deleteUser` endpoints: config/Vault is the source of truth. No `createUser` / `updateUser` / `deleteUser` endpoints: config/Vault is the source of truth.
### 7.7 Moods (custom, for Symfonium)
OpenSubsonic has no mood entity, so a mood is a **private server-managed playlist**. The playlist ID and name stay stable, so Symfonium keeps its reference. Management lives in the built-in `/ui` page under **Moods**.
Custom endpoints use the normal Subsonic auth and JSON envelope:
- `getMoods`: list the caller's moods.
- `getMood(id)`: settings plus `seed` and `entry` song lists.
- `createMood(name, query, genre, songId, targetSize, ytSlots, expandRelated, refreshHours)`: creates a private playlist and generates the first mix.
- `updateMood(id, ...)`: updates settings, marks the mix stale and regenerates.
- `deleteMood(id)`: deletes the playlist and all mood data.
- `refreshMood(id)`: synchronous regeneration.
- `promotePlaylistToMood(playlistId, ...)`: keeps the same playlist ID and name; its current songs become `promoted` seeds.
- `addMoodSeed(id, songId)` / `removeMoodSeed(id, songId)`: manual anchors.
Generation rules:
- Only the owner's **music** folders are used. Shared long-form folders never enter a mood.
- Every seed is always included; if there are more seeds than `targetSize`, all seeds are kept.
- With `expandRelated`, remaining slots are filled from matching genres/artists and, if needed, other visible music.
- `ytSlots` is reserved for the YT Music recommendation phase.
- A scan marks all moods stale. `getPlaylist` regenerates stale moods in the background; `refreshMood` forces it immediately.
Liking in Symfonium:
- Symfonium's heart calls `star`.
- If a mood was opened within the last four hours, the starred song becomes a permanent `star` seed of that mood, even if it was not in the mix.
- Without an active mood, the song is pinned to every mood that already contains it.
- `unstar` removes only `star` seeds; manual and promoted seeds stay.
- `updatePlaylist` and `createPlaylist(playlistId=...)` reject song edits on mood playlists with error 50; renaming is still allowed.
Symfonium has no built-in weekly sync interval. Automatic sync runs on app start and when it detects server changes. For a deterministic refresh, schedule the Symfonium broadcast API with Tasker/MacroDroid/Automate:
```text
Action: app.symfonium.api.MEDIA_SYNC
Package: app.symfonik.music.player
Class: app.symfonium.remote.api.ApiReceiver
Extra: PROVIDER_ID = <provider id from Settings -> Providers>
```
--- ---
## 8. Scanner ## 8. Scanner
@@ -720,7 +810,7 @@ registry remains private.
Versions published by CI: Versions published by CI:
- `main`: `<chart version>-sha.<commit>`, for example `0.1.3-sha.<commit>` - `main`: `<chart version>-sha.<commit>`, for example `0.1.4-sha.<commit>`
- `v*` tag: the tag without the leading `v`, for example `v0.2.0` -> `0.2.0` - `v*` tag: the tag without the leading `v`, for example `v0.2.0` -> `0.2.0`
Use it with Helm: Use it with Helm:
@@ -735,7 +825,7 @@ helm search repo taptap/audiomanager
Install a published chart: Install a published chart:
```bash ```bash
VERSION="0.1.3-sha.<commit>" VERSION="0.1.4-sha.<commit>"
helm upgrade --install audiomanager taptap/audiomanager \ helm upgrade --install audiomanager taptap/audiomanager \
--version "$VERSION" \ --version "$VERSION" \
--namespace audiomanager \ --namespace audiomanager \
@@ -751,7 +841,7 @@ helmCharts:
releaseName: audiomanager releaseName: audiomanager
namespace: audiomanager namespace: audiomanager
repo: https://gitea.tap-tap.win/TapTap/Charts/raw/branch/main repo: https://gitea.tap-tap.win/TapTap/Charts/raw/branch/main
version: 0.1.3-sha.<commit> version: 0.1.4-sha.<commit>
valuesFile: values.yaml valuesFile: values.yaml
``` ```
@@ -825,6 +915,8 @@ Verify each step with `./gradlew test` and/or `curl`:
- [x] 6. **Interaction & playlists:** `getAlbumList2`, `getRandomSongs`, `getStarred2`, `search3`, `scrobble`, `star`/`unstar`, `setRating`, bookmarks, playlists. - [x] 6. **Interaction & playlists:** `getAlbumList2`, `getRandomSongs`, `getStarred2`, `search3`, `scrobble`, `star`/`unstar`, `setRating`, bookmarks, playlists.
- [x] 7. **Packaging:** multi-stage Dockerfile (with ffmpeg), Helm chart, Gitea Actions workflow. - [x] 7. **Packaging:** multi-stage Dockerfile (with ffmpeg), Helm chart, Gitea Actions workflow.
- [x] 8. **Tests:** integration suite as described above, plus a `curl` smoke script. - [x] 8. **Tests:** integration suite as described above, plus a `curl` smoke script.
- [x] 9. **Moods:** `V4__moods.sql`, `MoodRepository`, `MoodMixService`, `MoodService`, `MoodRoutes`, mood UI, Symfonium star pinning, and route tests.
- [ ] 10. **YT recommendations:** yt-dlp discovery, mood recommendation UI, liked/wishlist candidates, and the optional downloader.
--- ---
@@ -838,3 +930,5 @@ Verify each step with `./gradlew test` and/or `curl`:
6. **No XML:** clients that insist on XML are unsupported. 6. **No XML:** clients that insist on XML are unsupported.
7. **No user-management API:** user changes are applied on restart after the Vault secret/config is updated. 7. **No user-management API:** user changes are applied on restart after the Vault secret/config is updated.
8. **Backups** are manual and documented; no backup endpoint. 8. **Backups** are manual and documented; no backup endpoint.
9. **YT Music recommendations** are the next phase. `mood_recommendations` and `yt_slots` are already in the schema; generation currently falls back to library music.
10. **Mood playlists are fixed queues in Symfonium.** For fresh contents, let the lazy TTL refresh run and sync the client (Tasker recipe above).
+1 -1
View File
@@ -2,5 +2,5 @@ apiVersion: v2
name: audiomanager name: audiomanager
description: Self-hosted OpenSubsonic music server description: Self-hosted OpenSubsonic music server
type: application type: application
version: 0.1.3 version: 0.1.4
appVersion: "0.1.0" appVersion: "0.1.0"
+13
View File
@@ -194,6 +194,19 @@ else
check "deletePlaylist" "/rest/deletePlaylist.view?$AUTH&id=$PLAYLIST_ID" check "deletePlaylist" "/rest/deletePlaylist.view?$AUTH&id=$PLAYLIST_ID"
fi fi
MOOD_JSON="$(curl -s "$BASE/rest/createMood.view?$AUTH&name=Smoke%20Mood&songId=$SONG_ID&targetSize=5")"
MOOD_ID="$(printf '%s' "$MOOD_JSON" | python3 -c 'import json,sys; print(json.load(sys.stdin)["subsonic-response"]["mood"]["id"])' 2>/dev/null || true)"
if [[ -z "$MOOD_ID" ]]; then
fail "createMood" "$(printf '%s' "$MOOD_JSON" | head -c 300)"
else
pass "createMood"
check "getMoods" "/rest/getMoods.view?$AUTH"
check "getMood" "/rest/getMood.view?$AUTH&id=$MOOD_ID"
check "getPlaylist (mood)" "/rest/getPlaylist.view?$AUTH&id=$MOOD_ID"
check "refreshMood" "/rest/refreshMood.view?$AUTH&id=$MOOD_ID"
check "deleteMood" "/rest/deleteMood.view?$AUTH&id=$MOOD_ID"
fi
check "savePlayQueue" "/rest/savePlayQueue.view?$AUTH&id=$SONG_ID&position=0" check "savePlayQueue" "/rest/savePlayQueue.view?$AUTH&id=$SONG_ID&position=0"
check "getPlayQueue" "/rest/getPlayQueue.view?$AUTH" check "getPlayQueue" "/rest/getPlayQueue.view?$AUTH"
check "savePlayQueueByIndex" "/rest/savePlayQueueByIndex.view?$AUTH&id=$SONG_ID&currentIndex=0&position=0" check "savePlayQueueByIndex" "/rest/savePlayQueueByIndex.view?$AUTH&id=$SONG_ID&currentIndex=0&position=0"
@@ -30,6 +30,8 @@ import win.taptap.musicmanager.config.UsersConfig
import win.taptap.musicmanager.db.ConfigRepository import win.taptap.musicmanager.db.ConfigRepository
import win.taptap.musicmanager.db.DatabaseFactory import win.taptap.musicmanager.db.DatabaseFactory
import win.taptap.musicmanager.db.MediaRepository import win.taptap.musicmanager.db.MediaRepository
import win.taptap.musicmanager.db.MoodRepository
import win.taptap.musicmanager.mood.MoodService
import win.taptap.musicmanager.scanner.CoverArtService import win.taptap.musicmanager.scanner.CoverArtService
import win.taptap.musicmanager.scanner.MediaScanner import win.taptap.musicmanager.scanner.MediaScanner
import win.taptap.musicmanager.subsonic.respondSubsonicError import win.taptap.musicmanager.subsonic.respondSubsonicError
@@ -51,7 +53,12 @@ fun main() {
val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.IO) val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
val coverArtService = CoverArtService(config.dataDir) val coverArtService = CoverArtService(config.dataDir)
val transcoder = FfmpegTranscoder(config.ffmpegPath) val transcoder = FfmpegTranscoder(config.ffmpegPath)
val scanner = MediaScanner(library, coverArtService) val moodService = MoodService(applicationScope)
val scanner = MediaScanner(
library = library,
coverArtService = coverArtService,
onScanFinished = { MoodRepository.markAllStale() },
)
if (MediaRepository.countSongs() == 0L) { if (MediaRepository.countSongs() == 0L) {
log.info("Song table is empty, starting initial library scan") log.info("Song table is empty, starting initial library scan")
scanner.start(applicationScope) scanner.start(applicationScope)
@@ -98,6 +105,7 @@ fun main() {
library = library, library = library,
coverArtService = coverArtService, coverArtService = coverArtService,
transcoder = transcoder, transcoder = transcoder,
moodService = moodService,
startScan = { scanner.start(applicationScope) }, startScan = { scanner.start(applicationScope) },
scanStatus = { scanner.status() }, scanStatus = { scanner.status() },
) )
@@ -9,6 +9,7 @@ import org.jetbrains.exposed.sql.SortOrder
import org.jetbrains.exposed.sql.Transaction import org.jetbrains.exposed.sql.Transaction
import org.jetbrains.exposed.sql.and import org.jetbrains.exposed.sql.and
import org.jetbrains.exposed.sql.lowerCase import org.jetbrains.exposed.sql.lowerCase
import org.jetbrains.exposed.sql.or
import org.jetbrains.exposed.sql.selectAll import org.jetbrains.exposed.sql.selectAll
import org.jetbrains.exposed.sql.transactions.transaction import org.jetbrains.exposed.sql.transactions.transaction
import org.jetbrains.exposed.sql.union import org.jetbrains.exposed.sql.union
@@ -404,6 +405,59 @@ object LibraryRepository {
enrichSongs(rows, userName) enrichSongs(rows, userName)
} }
/** Bulk genre lookup used by mood generation to avoid one query per seed genre. */
fun songsByGenres(
genres: Collection<String>,
limit: Int,
folderIds: Set<Int>,
userName: String,
): List<SongRecord> = read {
if (genres.isEmpty() || folderIds.isEmpty()) return@read emptyList()
val normalized = genres.map { it.lowercase() }.distinct()
val songIds = SongGenresTable
.select(SongGenresTable.songId)
.where { SongGenresTable.genre.lowerCase() inList normalized }
val rows = SongsTable.selectAll()
.where {
(SongsTable.id inSubQuery songIds) and
(SongsTable.folderId inList folderIds)
}
.limit(limit)
.toList()
enrichSongs(rows, userName)
}
/** Songs by track artist or album artist, used as related-mood candidates. */
fun songsByArtists(
artistIds: Collection<String>,
limit: Int,
folderIds: Set<Int>,
userName: String,
): List<SongRecord> = read {
if (artistIds.isEmpty() || folderIds.isEmpty()) return@read emptyList()
val ids = artistIds.toList()
val songArtists = SongArtistsTable
.select(SongArtistsTable.songId)
.where { SongArtistsTable.artistId inList ids }
val albumArtists = AlbumArtistsTable
.select(AlbumArtistsTable.albumId)
.where { AlbumArtistsTable.artistId inList ids }
val rows = SongsTable.selectAll()
.where {
(SongsTable.folderId inList folderIds) and
((SongsTable.id inSubQuery songArtists) or (SongsTable.albumId inSubQuery albumArtists))
}
.limit(limit)
.toList()
enrichSongs(rows, userName)
}
fun starred(userName: String, folderIds: Set<Int>): StarredRecords = read { fun starred(userName: String, folderIds: Set<Int>): StarredRecords = read {
if (folderIds.isEmpty()) { if (folderIds.isEmpty()) {
return@read StarredRecords(emptyList(), emptyList(), emptyList()) return@read StarredRecords(emptyList(), emptyList(), emptyList())
@@ -0,0 +1,413 @@
package win.taptap.musicmanager.db
import java.time.Instant
import kotlinx.serialization.builtins.ListSerializer
import kotlinx.serialization.builtins.serializer
import kotlinx.serialization.json.Json
import org.jetbrains.exposed.sql.JoinType
import org.jetbrains.exposed.sql.Op
import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
import org.jetbrains.exposed.sql.ResultRow
import org.jetbrains.exposed.sql.SortOrder
import org.jetbrains.exposed.sql.and
import org.jetbrains.exposed.sql.deleteWhere
import org.jetbrains.exposed.sql.insert
import org.jetbrains.exposed.sql.selectAll
import org.jetbrains.exposed.sql.transactions.transaction
import org.jetbrains.exposed.sql.update
data class MoodRecord(
val playlistId: String,
val owner: String,
val name: String,
val comment: String?,
val query: String?,
val genres: List<String>,
val targetSize: Int,
val ytSlots: Int,
val expandRelated: Boolean,
val refreshHours: Int,
val generatedAt: String?,
val generation: Int,
val lastError: String?,
val created: String,
val changed: String,
val songCount: Int,
val duration: Int,
val seedCount: Int,
)
data class MoodSeedRecord(
val songId: String,
val origin: String,
val addedAt: String,
)
/**
* Moods are private playlists with generation settings. The playlist row remains
* the client-visible object; this repository owns the settings, seeds and the
* materialized mix in `playlist_songs`.
*/
object MoodRepository {
private val genreSerializer = ListSerializer(String.serializer())
fun list(userName: String): List<MoodRecord> = transaction {
PlaylistsTable
.join(MoodsTable, JoinType.INNER, PlaylistsTable.id, MoodsTable.playlistId)
.selectAll()
.where {
(PlaylistsTable.owner eq userName) and
(PlaylistsTable.kind eq "mood")
}
.orderBy(PlaylistsTable.changedAt to SortOrder.DESC)
.map { moodRecord(it) }
}
fun get(playlistId: String, userName: String): MoodRecord? = transaction {
val row = PlaylistsTable
.join(MoodsTable, JoinType.INNER, PlaylistsTable.id, MoodsTable.playlistId)
.selectAll()
.where {
(PlaylistsTable.id eq playlistId) and
(PlaylistsTable.owner eq userName) and
(PlaylistsTable.kind eq "mood")
}
.singleOrNull()
row?.let { moodRecord(it) }
}
fun create(
userName: String,
name: String,
comment: String?,
query: String?,
genres: List<String>,
targetSize: Int,
ytSlots: Int,
expandRelated: Boolean,
refreshHours: Int,
seedSongIds: List<String>,
): MoodRecord {
val playlist = PlaylistRepository.create(
userName = userName,
name = name,
songIds = emptyList(),
isPublic = false,
kind = "mood",
)
try {
transaction {
insertSettings(
playlistId = playlist.id,
query = query,
genres = genres,
targetSize = targetSize,
ytSlots = ytSlots,
expandRelated = expandRelated,
refreshHours = refreshHours,
)
insertSeeds(playlist.id, seedSongIds, "manual")
}
} catch (t: Throwable) {
PlaylistRepository.delete(playlist.id, userName)
throw t
}
return get(playlist.id, userName)
?: error("Mood ${playlist.id} was not persisted")
}
/** Converts an existing owned playlist into a mood while keeping its ID. */
fun promote(
userName: String,
playlistId: String,
query: String?,
genres: List<String>,
targetSize: Int,
ytSlots: Int,
expandRelated: Boolean,
refreshHours: Int,
musicFolderIds: Set<Int>,
): MoodRecord? {
val playlist = PlaylistRepository.get(playlistId, userName) ?: return null
if (playlist.owner != userName || playlist.kind != "user") return null
val seedIds = transaction {
PlaylistRepository.songIds(playlistId).filter { songId ->
SongsTable
.select(SongsTable.folderId)
.where { SongsTable.id eq songId }
.singleOrNull()
?.get(SongsTable.folderId) in musicFolderIds
}
}
PlaylistRepository.setKind(playlistId, "mood", false)
try {
transaction {
insertSettings(
playlistId = playlistId,
query = query,
genres = genres,
targetSize = targetSize,
ytSlots = ytSlots,
expandRelated = expandRelated,
refreshHours = refreshHours,
)
insertSeeds(playlistId, seedIds, "promoted")
}
} catch (t: Throwable) {
PlaylistRepository.setKind(playlistId, "user", playlist.isPublic)
throw t
}
return get(playlistId, userName)
}
fun update(
playlistId: String,
userName: String,
name: String,
comment: String?,
query: String?,
genres: List<String>,
targetSize: Int,
ytSlots: Int,
expandRelated: Boolean,
refreshHours: Int,
): Boolean = transaction {
val exists = PlaylistsTable.selectAll()
.where {
(PlaylistsTable.id eq playlistId) and
(PlaylistsTable.owner eq userName) and
(PlaylistsTable.kind eq "mood")
}
.any()
if (!exists) return@transaction false
PlaylistsTable.update({ PlaylistsTable.id eq playlistId }) {
it[PlaylistsTable.name] = name
it[PlaylistsTable.comment] = comment
it[changedAt] = Instant.now().toString()
}
MoodsTable.update({ MoodsTable.playlistId eq playlistId }) {
it[MoodsTable.query] = query
it[MoodsTable.genres] = encodeGenres(genres)
it[MoodsTable.targetSize] = targetSize.coerceIn(1, 500)
it[MoodsTable.ytSlots] = ytSlots.coerceIn(0, 500)
it[MoodsTable.expandRelated] = expandRelated
it[MoodsTable.refreshHours] = refreshHours.coerceIn(1, 720)
it[generatedAt] = null
}
true
}
fun delete(playlistId: String, userName: String): Boolean =
PlaylistRepository.delete(playlistId, userName)
fun seedSongIds(playlistId: String, origin: String? = null): List<String> = transaction {
val condition = if (origin == null) {
MoodSeedsTable.playlistId eq playlistId
} else {
(MoodSeedsTable.playlistId eq playlistId) and (MoodSeedsTable.origin eq origin)
}
MoodSeedsTable.selectAll()
.where(condition)
.orderBy(
MoodSeedsTable.addedAt to SortOrder.ASC,
MoodSeedsTable.songId to SortOrder.ASC,
)
.map { it[MoodSeedsTable.songId] }
}
fun seeds(playlistId: String): List<MoodSeedRecord> = transaction {
MoodSeedsTable.selectAll()
.where { MoodSeedsTable.playlistId eq playlistId }
.orderBy(
MoodSeedsTable.addedAt to SortOrder.ASC,
MoodSeedsTable.songId to SortOrder.ASC,
)
.map {
MoodSeedRecord(
songId = it[MoodSeedsTable.songId],
origin = it[MoodSeedsTable.origin],
addedAt = it[MoodSeedsTable.addedAt],
)
}
}
/** Returns true when the seed was newly inserted. */
fun addSeed(
playlistId: String,
userName: String,
songId: String,
origin: String,
): Boolean = transaction {
if (get(playlistId, userName) == null) return@transaction false
val exists = MoodSeedsTable.selectAll()
.where {
(MoodSeedsTable.playlistId eq playlistId) and
(MoodSeedsTable.songId eq songId)
}
.any()
if (exists) return@transaction false
MoodSeedsTable.insert {
it[MoodSeedsTable.playlistId] = playlistId
it[MoodSeedsTable.songId] = songId
it[MoodSeedsTable.origin] = origin
it[addedAt] = Instant.now().toString()
}
true
}
fun removeSeed(
playlistId: String,
userName: String,
songId: String,
origin: String? = null,
): Boolean = transaction {
if (get(playlistId, userName) == null) return@transaction false
val condition = if (origin == null) {
(MoodSeedsTable.playlistId eq playlistId) and (MoodSeedsTable.songId eq songId)
} else {
(MoodSeedsTable.playlistId eq playlistId) and
(MoodSeedsTable.songId eq songId) and
(MoodSeedsTable.origin eq origin)
}
MoodSeedsTable.deleteWhere { condition } > 0
}
/** Mood playlists that currently contain [songId], for context-free star pinning. */
fun moodsContainingSong(userName: String, songId: String): List<String> = transaction {
PlaylistsTable
.join(MoodsTable, JoinType.INNER, PlaylistsTable.id, MoodsTable.playlistId)
.join(PlaylistSongsTable, JoinType.INNER, PlaylistsTable.id, PlaylistSongsTable.playlistId)
.select(PlaylistsTable.id)
.where {
(PlaylistsTable.owner eq userName) and
(PlaylistsTable.kind eq "mood") and
(PlaylistSongsTable.songId eq songId)
}
.map { it[PlaylistsTable.id] }
.distinct()
}
fun markGenerated(playlistId: String, generation: Int, error: String?) {
transaction {
MoodsTable.update({ MoodsTable.playlistId eq playlistId }) {
it[generatedAt] = Instant.now().toString()
it[MoodsTable.generation] = generation
it[lastError] = error
}
}
}
fun markStale(playlistId: String) {
transaction {
MoodsTable.update({ MoodsTable.playlistId eq playlistId }) {
it[generatedAt] = null
}
}
}
/** Records a failed generation without claiming the mood is fresh. */
fun markError(playlistId: String, message: String) {
transaction {
MoodsTable.update({ MoodsTable.playlistId eq playlistId }) {
it[lastError] = message.take(1000)
it[generatedAt] = null
}
}
}
fun markAllStale() {
transaction {
MoodsTable.update({ Op.TRUE }) {
it[generatedAt] = null
}
}
}
private fun insertSettings(
playlistId: String,
query: String?,
genres: List<String>,
targetSize: Int,
ytSlots: Int,
expandRelated: Boolean,
refreshHours: Int,
) {
MoodsTable.insert {
it[MoodsTable.playlistId] = playlistId
it[MoodsTable.query] = query?.trim()?.takeIf(String::isNotEmpty)
it[MoodsTable.genres] = encodeGenres(genres)
it[MoodsTable.targetSize] = targetSize.coerceIn(1, 500)
it[MoodsTable.ytSlots] = ytSlots.coerceIn(0, 500)
it[MoodsTable.expandRelated] = expandRelated
it[MoodsTable.refreshHours] = refreshHours.coerceIn(1, 720)
}
}
private fun insertSeeds(playlistId: String, songIds: List<String>, origin: String) {
val now = Instant.now().toString()
songIds.distinct().forEach { songId ->
MoodSeedsTable.insert {
it[MoodSeedsTable.playlistId] = playlistId
it[MoodSeedsTable.songId] = songId
it[MoodSeedsTable.origin] = origin
it[addedAt] = now
}
}
}
private fun moodRecord(row: ResultRow): MoodRecord {
val id = row[PlaylistsTable.id]
val songs = PlaylistSongsTable
.join(SongsTable, JoinType.INNER, PlaylistSongsTable.songId, SongsTable.id)
.select(SongsTable.duration)
.where { PlaylistSongsTable.playlistId eq id }
.toList()
val seedCount = MoodSeedsTable
.selectAll()
.where { MoodSeedsTable.playlistId eq id }
.count()
.toInt()
return MoodRecord(
playlistId = id,
owner = row[PlaylistsTable.owner],
name = row[PlaylistsTable.name],
comment = row[PlaylistsTable.comment],
query = row[MoodsTable.query],
genres = decodeGenres(row[MoodsTable.genres]),
targetSize = row[MoodsTable.targetSize],
ytSlots = row[MoodsTable.ytSlots],
expandRelated = row[MoodsTable.expandRelated],
refreshHours = row[MoodsTable.refreshHours],
generatedAt = row[MoodsTable.generatedAt],
generation = row[MoodsTable.generation],
lastError = row[MoodsTable.lastError],
created = row[PlaylistsTable.createdAt],
changed = row[PlaylistsTable.changedAt],
songCount = songs.size,
duration = songs.sumOf { it[SongsTable.duration] },
seedCount = seedCount,
)
}
private fun encodeGenres(genres: List<String>): String =
Json.encodeToString(
genreSerializer,
genres.map { it.trim() }.filter { it.isNotEmpty() }.distinct().take(20),
)
private fun decodeGenres(value: String): List<String> =
runCatching { Json.decodeFromString(genreSerializer, value) }.getOrDefault(emptyList())
}
@@ -17,6 +17,7 @@ data class PlaylistRecord(
val comment: String?, val comment: String?,
val owner: String, val owner: String,
val isPublic: Boolean, val isPublic: Boolean,
val kind: String,
val songCount: Int, val songCount: Int,
val duration: Int, val duration: Int,
val created: String, val created: String,
@@ -54,7 +55,13 @@ object PlaylistRepository {
.map { it[PlaylistSongsTable.songId] } .map { it[PlaylistSongsTable.songId] }
} }
fun create(userName: String, name: String, songIds: List<String>): PlaylistRecord = transaction { fun create(
userName: String,
name: String,
songIds: List<String>,
isPublic: Boolean = true,
kind: String = "user",
): PlaylistRecord = transaction {
val now = Instant.now().toString() val now = Instant.now().toString()
val id = IdGenerator.playlistId(userName, name, now) val id = IdGenerator.playlistId(userName, name, now)
@@ -62,7 +69,8 @@ object PlaylistRepository {
it[PlaylistsTable.id] = id it[PlaylistsTable.id] = id
it[owner] = userName it[owner] = userName
it[PlaylistsTable.name] = name it[PlaylistsTable.name] = name
it[isPublic] = true it[PlaylistsTable.isPublic] = isPublic
it[PlaylistsTable.kind] = kind
it[createdAt] = now it[createdAt] = now
it[changedAt] = now it[changedAt] = now
} }
@@ -71,6 +79,15 @@ object PlaylistRepository {
playlistRecord(id, PlaylistsTable.selectAll().where { PlaylistsTable.id eq id }.single()) playlistRecord(id, PlaylistsTable.selectAll().where { PlaylistsTable.id eq id }.single())
} }
/** Promotion keeps the playlist ID stable so Symfonium keeps its reference. */
fun setKind(playlistId: String, kind: String, isPublic: Boolean): Boolean = transaction {
PlaylistsTable.update({ PlaylistsTable.id eq playlistId }) {
it[PlaylistsTable.kind] = kind
it[PlaylistsTable.isPublic] = isPublic
it[changedAt] = Instant.now().toString()
} > 0
}
fun replaceSongs(playlistId: String, songIds: List<String>, userName: String): Boolean = transaction { fun replaceSongs(playlistId: String, songIds: List<String>, userName: String): Boolean = transaction {
val row = PlaylistsTable.selectAll() val row = PlaylistsTable.selectAll()
.where { PlaylistsTable.id eq playlistId } .where { PlaylistsTable.id eq playlistId }
@@ -164,6 +181,7 @@ object PlaylistRepository {
comment = row[PlaylistsTable.comment], comment = row[PlaylistsTable.comment],
owner = row[PlaylistsTable.owner], owner = row[PlaylistsTable.owner],
isPublic = row[PlaylistsTable.isPublic], isPublic = row[PlaylistsTable.isPublic],
kind = row[PlaylistsTable.kind],
songCount = songs.size, songCount = songs.size,
duration = songs.sumOf { it[SongsTable.duration] }, duration = songs.sumOf { it[SongsTable.duration] },
created = row[PlaylistsTable.createdAt], created = row[PlaylistsTable.createdAt],
@@ -139,6 +139,7 @@ object PlaylistsTable : Table("playlists") {
val name = text("name") val name = text("name")
val comment = text("comment").nullable() val comment = text("comment").nullable()
val isPublic = bool("is_public").default(true) val isPublic = bool("is_public").default(true)
val kind = varchar("kind", 16).default("user")
val createdAt = varchar("created_at", 40) val createdAt = varchar("created_at", 40)
val changedAt = varchar("changed_at", 40) val changedAt = varchar("changed_at", 40)
@@ -152,3 +153,46 @@ object PlaylistSongsTable : Table("playlist_songs") {
override val primaryKey = PrimaryKey(playlistId, position) override val primaryKey = PrimaryKey(playlistId, position)
} }
object MoodsTable : Table("moods") {
val playlistId = reference("playlist_id", PlaylistsTable.id, onDelete = ReferenceOption.CASCADE)
val query = text("query").nullable()
val genres = text("genres").default("[]")
val targetSize = integer("target_size").default(50)
val ytSlots = integer("yt_slots").default(0)
val expandRelated = bool("expand_related").default(true)
val refreshHours = integer("refresh_hours").default(24)
val generatedAt = varchar("generated_at", 40).nullable()
val generation = integer("generation").default(0)
val lastError = text("last_error").nullable()
override val primaryKey = PrimaryKey(playlistId)
}
object MoodSeedsTable : Table("mood_seeds") {
val playlistId = reference("playlist_id", MoodsTable.playlistId, onDelete = ReferenceOption.CASCADE)
val songId = reference("song_id", SongsTable.id, onDelete = ReferenceOption.CASCADE)
val origin = varchar("origin", 16).default("manual")
val addedAt = varchar("added_at", 40)
override val primaryKey = PrimaryKey(playlistId, songId)
}
object MoodRecommendationsTable : Table("mood_recommendations") {
val playlistId = reference("playlist_id", MoodsTable.playlistId, onDelete = ReferenceOption.CASCADE)
val videoId = varchar("video_id", 64)
val title = text("title")
val artist = text("artist")
val duration = integer("duration").nullable()
val state = varchar("state", 16).default("new")
val matchedSongId = reference(
"matched_song_id",
SongsTable.id,
onDelete = ReferenceOption.SET_NULL,
).nullable()
val timesAdded = integer("times_added").default(0)
val firstSeen = varchar("first_seen", 40)
val lastSeen = varchar("last_seen", 40)
override val primaryKey = PrimaryKey(playlistId, videoId)
}
@@ -0,0 +1,145 @@
package win.taptap.musicmanager.mood
import kotlin.math.max
import kotlin.math.min
import kotlin.random.Random
import org.slf4j.LoggerFactory
import win.taptap.musicmanager.config.FolderType
import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.UserAccount
import win.taptap.musicmanager.db.LibraryRepository
import win.taptap.musicmanager.db.MoodRecord
import win.taptap.musicmanager.db.MoodRepository
import win.taptap.musicmanager.db.PlaylistRepository
import win.taptap.musicmanager.db.SongRecord
data class MoodGenerationStats(
val seedCount: Int,
val relatedCount: Int,
val totalCount: Int,
val targetSize: Int,
)
/**
* Builds the materialized mood playlist.
*
* Phase 1 has no YT source: the mix is the curated seeds plus related music from
* the owner's own music folders. `yt_slots` is stored but only used once the
* recommendation phase lands.
*/
class MoodMixService {
private val log = LoggerFactory.getLogger(MoodMixService::class.java)
fun generate(mood: MoodRecord, user: UserAccount, library: LibraryConfig): MoodGenerationStats {
val folders = musicFolderIds(user, library)
val seedIds = MoodRepository.seedSongIds(mood.playlistId)
val seeds = LibraryRepository.songsByIds(seedIds, folders, user.name)
val seedGenres = (seeds.flatMap { it.genres } + mood.genres)
.distinctBy { it.lowercase() }
val seedArtistIds = seeds.mapNotNull { it.artistId }.distinct()
val seedAlbumIds = seeds.map { it.albumId }.toSet()
val query = mood.query?.trim()?.takeIf { it.isNotEmpty() }
val related = LinkedHashMap<String, SongRecord>()
if (mood.expandRelated) {
if (seedGenres.isNotEmpty()) {
LibraryRepository.songsByGenres(seedGenres, RELATED_LIMIT, folders, user.name)
.forEach { related[it.id] = it }
}
if (seedArtistIds.isNotEmpty()) {
LibraryRepository.songsByArtists(seedArtistIds, RELATED_LIMIT, folders, user.name)
.forEach { related[it.id] = it }
}
if (query != null) {
LibraryRepository.searchSongs(query, RELATED_LIMIT, 0, folders, user.name)
.forEach { related[it.id] = it }
}
}
val seedIdSet = seeds.map { it.id }.toSet()
related.keys.removeAll(seedIdSet)
val random = Random(mood.playlistId.hashCode().toLong() * 31 + mood.generation)
val ranked = related.values
.shuffled(random)
.sortedByDescending { song ->
score(song, seedGenres, seedArtistIds, seedAlbumIds, query)
}
val target = max(mood.targetSize, seeds.size).coerceIn(1, MAX_TARGET)
val selected = LinkedHashMap<String, SongRecord>()
seeds.forEach { selected[it.id] = it }
ranked.forEach { song ->
if (selected.size < target) selected[song.id] = song
}
// Keep the playlist useful when a mood has only a few seeds or a narrow genre.
val hasSignal = seeds.isNotEmpty() || seedGenres.isNotEmpty() || query != null
if (mood.expandRelated && hasSignal && selected.size < target) {
val fillers = LibraryRepository.randomSongs(
size = (target - selected.size) * 3,
genre = null,
fromYear = null,
toYear = null,
folderIds = folders,
userName = user.name,
)
fillers.forEach { song ->
if (selected.size < target) selected.putIfAbsent(song.id, song)
}
}
PlaylistRepository.replaceSongs(mood.playlistId, selected.keys.toList(), user.name)
MoodRepository.markGenerated(mood.playlistId, mood.generation + 1, null)
val stats = MoodGenerationStats(
seedCount = seeds.size,
relatedCount = selected.size - seeds.size,
totalCount = selected.size,
targetSize = target,
)
log.info(
"Mood {} generated: {} seeds, {} related, {} total (target {})",
mood.name,
stats.seedCount,
stats.relatedCount,
stats.totalCount,
stats.targetSize,
)
return stats
}
private fun score(
song: SongRecord,
seedGenres: List<String>,
seedArtistIds: List<String>,
seedAlbumIds: Set<String>,
query: String?,
): Double {
var score = 0.0
if (song.artistId != null && song.artistId in seedArtistIds) score += 6.0
if (song.albumId in seedAlbumIds) score += 3.0
score += song.genres.count { candidate ->
seedGenres.any { it.equals(candidate, ignoreCase = true) }
} * 2.0
if (song.starredAt != null) score += 1.0
score += min(song.playCount, 20) * 0.05
if (query != null && song.title.contains(query, ignoreCase = true)) score += 2.0
return score
}
/** Long-form folders are deliberately excluded, even when the user can see them. */
private fun musicFolderIds(user: UserAccount, library: LibraryConfig): Set<Int> =
library.folders
.asSequence()
.filter { it.type == FolderType.MUSIC && it.id in user.folders }
.map { it.id }
.toSet()
private companion object {
const val RELATED_LIMIT = 500
const val MAX_TARGET = 500
}
}
@@ -0,0 +1,38 @@
package win.taptap.musicmanager.mood
import win.taptap.musicmanager.db.MoodRepository
/**
* Translates a Symfonium star into a permanent mood seed.
*
* If a mood session is active, the like belongs to that mood, even when the song
* is not in the current mix. Otherwise the song is pinned to every mood that
* already contains it, which is a no-op for rotation except that it becomes an
* anchor. Manual and promoted seeds are never removed by an unstar.
*/
object MoodPins {
fun onStar(userName: String, songId: String) {
targets(userName, songId).forEach { playlistId ->
if (MoodRepository.addSeed(playlistId, userName, songId, "star")) {
MoodRepository.markStale(playlistId)
}
}
}
fun onUnstar(userName: String, songId: String) {
targets(userName, songId).forEach { playlistId ->
if (MoodRepository.removeSeed(playlistId, userName, songId, origin = "star")) {
MoodRepository.markStale(playlistId)
}
}
}
private fun targets(userName: String, songId: String): List<String> {
val active = MoodSessionTracker.active(userName)
if (active != null && MoodRepository.get(active, userName) != null) {
return listOf(active)
}
return MoodRepository.moodsContainingSong(userName, songId)
}
}
@@ -0,0 +1,66 @@
package win.taptap.musicmanager.mood
import java.time.Instant
import java.util.concurrent.ConcurrentHashMap
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import org.slf4j.LoggerFactory
import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.UserAccount
import win.taptap.musicmanager.db.MoodRecord
import win.taptap.musicmanager.db.MoodRepository
/**
* Owns stale checks and serializes generation per mood. Background refreshes keep
* `getPlaylist` fast; an explicit refresh is synchronous for the management UI.
*/
class MoodService(
private val scope: CoroutineScope,
private val mixService: MoodMixService = MoodMixService(),
) {
private val log = LoggerFactory.getLogger(MoodService::class.java)
private val locks = ConcurrentHashMap<String, Any>()
private val running = ConcurrentHashMap.newKeySet<String>()
fun isStale(mood: MoodRecord): Boolean {
val generated = mood.generatedAt?.let { runCatching { Instant.parse(it) }.getOrNull() }
?: return true
return generated.plusSeconds(mood.refreshHours * 3600L).isBefore(Instant.now())
}
/** Starts one background generation when the mix is older than its TTL. */
fun refreshIfStale(mood: MoodRecord, user: UserAccount, library: LibraryConfig) {
if (!isStale(mood)) return
if (!running.add(mood.playlistId)) return
scope.launch {
try {
generateLocked(mood.playlistId, user, library)
} catch (t: Throwable) {
log.error("Background mood refresh failed for ${mood.name}", t)
} finally {
running.remove(mood.playlistId)
}
}
}
/** Synchronous generation used by create, update, seed changes and refreshMood. */
fun refreshNow(mood: MoodRecord, user: UserAccount, library: LibraryConfig): MoodGenerationStats =
generateLocked(mood.playlistId, user, library)
private fun generateLocked(
playlistId: String,
user: UserAccount,
library: LibraryConfig,
): MoodGenerationStats = synchronized(locks.computeIfAbsent(playlistId) { Any() }) {
val mood = MoodRepository.get(playlistId, user.name)
?: error("Mood not found: $playlistId")
try {
mixService.generate(mood, user, library)
} catch (t: Throwable) {
MoodRepository.markError(playlistId, t.message ?: t::class.simpleName.orEmpty())
throw t
}
}
}
@@ -0,0 +1,45 @@
package win.taptap.musicmanager.mood
import java.time.Duration
import java.time.Instant
import java.util.concurrent.ConcurrentHashMap
/**
* Symfonium's star request does not carry the playlist it was invoked from.
* Opening a mood marks it active, so a like can be attributed to that mood.
* The fallback in [MoodPins] handles queued/offline stars without a session.
*/
object MoodSessionTracker {
private val ttl: Duration = Duration.ofHours(4)
private val sessions = ConcurrentHashMap<String, Session>()
private data class Session(val playlistId: String, val seenAt: Instant)
fun activate(userName: String, playlistId: String) {
sessions[userName] = Session(playlistId, Instant.now())
}
fun clear(userName: String) {
sessions.remove(userName)
}
fun touch(userName: String) {
sessions.computeIfPresent(userName) { _, session ->
if (session.seenAt.plus(ttl).isBefore(Instant.now())) {
null
} else {
session.copy(seenAt = Instant.now())
}
}
}
fun active(userName: String): String? {
val session = sessions[userName] ?: return null
if (session.seenAt.plus(ttl).isBefore(Instant.now())) {
sessions.remove(userName)
return null
}
return session.playlistId
}
}
@@ -21,6 +21,7 @@ class MediaScanner(
private val coverArtService: CoverArtService, private val coverArtService: CoverArtService,
private val tagExtractor: Mp3TagExtractor = Mp3TagExtractor(), private val tagExtractor: Mp3TagExtractor = Mp3TagExtractor(),
private val repository: MediaRepository = MediaRepository, private val repository: MediaRepository = MediaRepository,
private val onScanFinished: (ScanStatus) -> Unit = {},
) { ) {
private val log = LoggerFactory.getLogger(MediaScanner::class.java) private val log = LoggerFactory.getLogger(MediaScanner::class.java)
@@ -73,6 +74,8 @@ class MediaScanner(
val finalStatus = ScanStatus(scanning = false, count = count, error = error) val finalStatus = ScanStatus(scanning = false, count = count, error = error)
status.set(finalStatus) status.set(finalStatus)
log.info("Library scan finished: {} files, error={}", count, error) log.info("Library scan finished: {} files, error={}", count, error)
runCatching { onScanFinished(finalStatus) }
.onFailure { log.warn("Scan completion hook failed", it) }
return finalStatus return finalStatus
} }
@@ -10,6 +10,7 @@ import kotlinx.serialization.json.put
import win.taptap.musicmanager.db.AlbumRecord import win.taptap.musicmanager.db.AlbumRecord
import win.taptap.musicmanager.db.ArtistRecord import win.taptap.musicmanager.db.ArtistRecord
import win.taptap.musicmanager.db.GenreRecord import win.taptap.musicmanager.db.GenreRecord
import win.taptap.musicmanager.db.MoodRecord
import win.taptap.musicmanager.db.PlaylistRecord import win.taptap.musicmanager.db.PlaylistRecord
import win.taptap.musicmanager.db.SongRecord import win.taptap.musicmanager.db.SongRecord
import win.taptap.musicmanager.util.IdGenerator import win.taptap.musicmanager.util.IdGenerator
@@ -123,6 +124,38 @@ fun playlistJson(playlist: PlaylistRecord, songs: List<SongRecord>? = null): Jso
} }
} }
fun moodJson(
mood: MoodRecord,
seeds: List<SongRecord>? = null,
songs: List<SongRecord>? = null,
): JsonObject = buildJsonObject {
put("id", mood.playlistId)
put("name", mood.name)
mood.comment?.let { put("comment", it) }
mood.query?.let { put("query", it) }
put("genres", stringArray(mood.genres))
put("targetSize", mood.targetSize)
put("ytSlots", mood.ytSlots)
put("expandRelated", mood.expandRelated)
put("refreshHours", mood.refreshHours)
mood.generatedAt?.let { put("generatedAt", it) }
put("generation", mood.generation)
mood.lastError?.let { put("lastError", it) }
put("seedCount", mood.seedCount)
put("songCount", mood.songCount)
put("duration", mood.duration)
put("created", mood.created)
put("changed", mood.changed)
put("owner", mood.owner)
seeds?.let { list ->
put("seed", buildJsonArray { list.forEach { add(songJson(it)) } })
}
songs?.let { list ->
put("entry", buildJsonArray { list.forEach { add(songJson(it)) } })
}
}
fun genreJson(genre: GenreRecord): JsonObject = buildJsonObject { fun genreJson(genre: GenreRecord): JsonObject = buildJsonObject {
put("value", genre.value) put("value", genre.value)
put("songCount", genre.songCount) put("songCount", genre.songCount)
@@ -9,6 +9,8 @@ import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.UsersConfig import win.taptap.musicmanager.config.UsersConfig
import win.taptap.musicmanager.db.LibraryRepository import win.taptap.musicmanager.db.LibraryRepository
import win.taptap.musicmanager.db.UserStateRepository import win.taptap.musicmanager.db.UserStateRepository
import win.taptap.musicmanager.mood.MoodPins
import win.taptap.musicmanager.mood.MoodSessionTracker
import win.taptap.musicmanager.subsonic.models.songJson import win.taptap.musicmanager.subsonic.models.songJson
import win.taptap.musicmanager.subsonic.respondSubsonic import win.taptap.musicmanager.subsonic.respondSubsonic
import win.taptap.musicmanager.subsonic.respondSubsonicError import win.taptap.musicmanager.subsonic.respondSubsonicError
@@ -34,6 +36,7 @@ fun Route.interactionRoutes(users: UsersConfig, library: LibraryConfig) {
} }
UserStateRepository.scrobble(user.name, id, submission) UserStateRepository.scrobble(user.name, id, submission)
} }
MoodSessionTracker.touch(user.name)
call.respondSubsonic() call.respondSubsonic()
} }
@@ -56,7 +59,10 @@ fun Route.interactionRoutes(users: UsersConfig, library: LibraryConfig) {
return@subsonicEndpoint return@subsonicEndpoint
} }
songIds.forEach { UserStateRepository.starSong(user.name, it) } songIds.forEach { songId ->
UserStateRepository.starSong(user.name, songId)
if (songId.startsWith("sg-")) MoodPins.onStar(user.name, songId)
}
albumIds.forEach { UserStateRepository.starItem(user.name, "album", it) } albumIds.forEach { UserStateRepository.starItem(user.name, "album", it) }
artistIds.forEach { UserStateRepository.starItem(user.name, "artist", it) } artistIds.forEach { UserStateRepository.starItem(user.name, "artist", it) }
@@ -81,7 +87,10 @@ fun Route.interactionRoutes(users: UsersConfig, library: LibraryConfig) {
return@subsonicEndpoint return@subsonicEndpoint
} }
songIds.forEach { UserStateRepository.unstarSong(user.name, it) } songIds.forEach { songId ->
UserStateRepository.unstarSong(user.name, songId)
if (songId.startsWith("sg-")) MoodPins.onUnstar(user.name, songId)
}
albumIds.forEach { UserStateRepository.unstarItem(user.name, "album", it) } albumIds.forEach { UserStateRepository.unstarItem(user.name, "album", it) }
artistIds.forEach { UserStateRepository.unstarItem(user.name, "artist", it) } artistIds.forEach { UserStateRepository.unstarItem(user.name, "artist", it) }
@@ -14,6 +14,7 @@ import org.slf4j.LoggerFactory
import win.taptap.musicmanager.config.LibraryConfig import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.UsersConfig import win.taptap.musicmanager.config.UsersConfig
import win.taptap.musicmanager.db.LibraryRepository import win.taptap.musicmanager.db.LibraryRepository
import win.taptap.musicmanager.mood.MoodSessionTracker
import win.taptap.musicmanager.scanner.CoverArtService import win.taptap.musicmanager.scanner.CoverArtService
import win.taptap.musicmanager.subsonic.respondSubsonicError import win.taptap.musicmanager.subsonic.respondSubsonicError
import win.taptap.musicmanager.transcoding.FfmpegTranscoder import win.taptap.musicmanager.transcoding.FfmpegTranscoder
@@ -61,6 +62,7 @@ fun Route.mediaRoutes(
call.respondSubsonicError(70, "Song not found") call.respondSubsonicError(70, "Song not found")
return@subsonicEndpoint return@subsonicEndpoint
} }
MoodSessionTracker.touch(user.name)
if (!transcoder.shouldTranscode(resolved.song.bitRate, maxBitRate, format, offset)) { if (!transcoder.shouldTranscode(resolved.song.bitRate, maxBitRate, format, offset)) {
call.respondFile(resolved.file.toFile()) call.respondFile(resolved.file.toFile())
@@ -0,0 +1,265 @@
package win.taptap.musicmanager.subsonic.routes
import io.ktor.server.application.ApplicationCall
import io.ktor.server.routing.Route
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.add
import kotlinx.serialization.json.buildJsonArray
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put
import org.slf4j.LoggerFactory
import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.UserAccount
import win.taptap.musicmanager.config.UsersConfig
import win.taptap.musicmanager.db.LibraryRepository
import win.taptap.musicmanager.db.MoodRecord
import win.taptap.musicmanager.db.MoodRepository
import win.taptap.musicmanager.db.PlaylistRepository
import win.taptap.musicmanager.mood.MoodService
import win.taptap.musicmanager.subsonic.models.moodJson
import win.taptap.musicmanager.subsonic.respondSubsonic
import win.taptap.musicmanager.subsonic.respondSubsonicError
private val log = LoggerFactory.getLogger("win.taptap.musicmanager.MoodRoutes")
/**
* Mood management endpoints. These are custom OpenSubsonic endpoints used by the
* built-in web UI; Symfonium only sees the resulting playlists.
*/
fun Route.moodRoutes(
users: UsersConfig,
library: LibraryConfig,
moodService: MoodService,
) {
subsonicEndpoint(users, "/getMoods") { call, user ->
val moods = MoodRepository.list(user.name)
call.respondSubsonic(
buildJsonObject {
put("moods", buildJsonObject {
put("mood", buildJsonArray { moods.forEach { add(moodJson(it)) } })
})
},
)
}
subsonicEndpoint(users, "/getMood") { call, user ->
val mood = call.requireMood(user) ?: return@subsonicEndpoint
call.respondSubsonic(buildJsonObject { put("mood", detail(mood, user, library)) })
}
subsonicEndpoint(users, "/createMood") { call, user ->
val parameters = call.subsonicParams()
val name = parameters["name"]?.trim()?.takeIf { it.isNotEmpty() }
if (name == null) {
call.respondSubsonicError(10, "Required parameter is missing: name")
return@subsonicEndpoint
}
val folders = user.musicFolderIds(library)
val seedIds = parameters.getAll("songId").orEmpty()
.filter { it.isNotBlank() }
.filter { LibraryRepository.song(it, folders, user.name) != null }
.distinct()
val mood = MoodRepository.create(
userName = user.name,
name = name.take(200),
comment = parameters["comment"]?.trim()?.takeIf { it.isNotEmpty() },
query = parameters["query"]?.trim()?.takeIf { it.isNotEmpty() },
genres = genres(parameters),
targetSize = intParam(parameters["targetSize"], 50, 1, 500),
ytSlots = intParam(parameters["ytSlots"], 0, 0, 500),
expandRelated = boolParam(parameters["expandRelated"], true),
refreshHours = intParam(parameters["refreshHours"], 24, 1, 720),
seedSongIds = seedIds,
)
regenerate(moodService, mood, user, library)
call.respondSubsonic(buildJsonObject { put("mood", detail(refreshed(mood), user, library)) })
}
subsonicEndpoint(users, "/updateMood") { call, user ->
val mood = call.requireMood(user) ?: return@subsonicEndpoint
val parameters = call.subsonicParams()
val name = parameters["name"]?.trim()?.takeIf { it.isNotEmpty() } ?: mood.name
val comment = if (parameters.contains("comment")) {
parameters["comment"]?.trim()?.takeIf { it.isNotEmpty() }
} else {
mood.comment
}
val query = if (parameters.contains("query")) {
parameters["query"]?.trim()?.takeIf { it.isNotEmpty() }
} else {
mood.query
}
val genres = if (parameters.contains("genre") || parameters.contains("genres")) {
genres(parameters)
} else {
mood.genres
}
val updated = MoodRepository.update(
playlistId = mood.playlistId,
userName = user.name,
name = name.take(200),
comment = comment,
query = query,
genres = genres,
targetSize = intParam(parameters["targetSize"], mood.targetSize, 1, 500),
ytSlots = intParam(parameters["ytSlots"], mood.ytSlots, 0, 500),
expandRelated = boolParam(parameters["expandRelated"], mood.expandRelated),
refreshHours = intParam(parameters["refreshHours"], mood.refreshHours, 1, 720),
)
if (!updated) {
call.respondSubsonicError(70, "Mood not found")
return@subsonicEndpoint
}
val refreshedMood = MoodRepository.get(mood.playlistId, user.name) ?: mood
regenerate(moodService, refreshedMood, user, library)
call.respondSubsonic(
buildJsonObject {
put("mood", detail(refreshed(refreshedMood), user, library))
},
)
}
subsonicEndpoint(users, "/deleteMood") { call, user ->
val mood = call.requireMood(user) ?: return@subsonicEndpoint
MoodRepository.delete(mood.playlistId, user.name)
call.respondSubsonic()
}
subsonicEndpoint(users, "/refreshMood") { call, user ->
val mood = call.requireMood(user) ?: return@subsonicEndpoint
regenerate(moodService, mood, user, library)
call.respondSubsonic(buildJsonObject { put("mood", detail(refreshed(mood), user, library)) })
}
subsonicEndpoint(users, "/promotePlaylistToMood") { call, user ->
val parameters = call.subsonicParams()
val playlistId = parameters["playlistId"]
if (playlistId.isNullOrBlank()) {
call.respondSubsonicError(10, "Required parameter is missing: playlistId")
return@subsonicEndpoint
}
val mood = MoodRepository.promote(
userName = user.name,
playlistId = playlistId,
query = parameters["query"]?.trim()?.takeIf { it.isNotEmpty() },
genres = genres(parameters),
targetSize = intParam(parameters["targetSize"], 50, 1, 500),
ytSlots = intParam(parameters["ytSlots"], 0, 0, 500),
expandRelated = boolParam(parameters["expandRelated"], true),
refreshHours = intParam(parameters["refreshHours"], 24, 1, 720),
musicFolderIds = user.musicFolderIds(library),
)
if (mood == null) {
call.respondSubsonicError(70, "Playlist not found")
return@subsonicEndpoint
}
regenerate(moodService, mood, user, library)
call.respondSubsonic(buildJsonObject { put("mood", detail(refreshed(mood), user, library)) })
}
subsonicEndpoint(users, "/addMoodSeed") { call, user ->
val mood = call.requireMood(user) ?: return@subsonicEndpoint
val parameters = call.subsonicParams()
val songId = parameters["songId"]
if (songId.isNullOrBlank()) {
call.respondSubsonicError(10, "Required parameter is missing: songId")
return@subsonicEndpoint
}
val folders = user.musicFolderIds(library)
if (LibraryRepository.song(songId, folders, user.name) == null) {
call.respondSubsonicError(70, "Song not found")
return@subsonicEndpoint
}
MoodRepository.addSeed(mood.playlistId, user.name, songId, "manual")
regenerate(moodService, mood, user, library)
call.respondSubsonic(buildJsonObject { put("mood", detail(refreshed(mood), user, library)) })
}
subsonicEndpoint(users, "/removeMoodSeed") { call, user ->
val mood = call.requireMood(user) ?: return@subsonicEndpoint
val songId = call.subsonicParams()["songId"]
if (songId.isNullOrBlank()) {
call.respondSubsonicError(10, "Required parameter is missing: songId")
return@subsonicEndpoint
}
MoodRepository.removeSeed(mood.playlistId, user.name, songId)
regenerate(moodService, mood, user, library)
call.respondSubsonic(buildJsonObject { put("mood", detail(refreshed(mood), user, library)) })
}
}
private fun ApplicationCall.moodId(): String? = subsonicParams()["id"]?.takeIf { it.isNotBlank() }
private suspend fun ApplicationCall.requireMood(
user: UserAccount,
): MoodRecord? {
val id = moodId()
if (id == null) {
respondSubsonicError(10, "Required parameter is missing: id")
return null
}
val mood = MoodRepository.get(id, user.name)
if (mood == null) {
respondSubsonicError(70, "Mood not found")
return null
}
return mood
}
private fun detail(mood: MoodRecord, user: UserAccount, library: LibraryConfig): JsonObject {
val folders = user.musicFolderIds(library)
val seedIds = MoodRepository.seedSongIds(mood.playlistId)
val seeds = LibraryRepository.songsByIds(seedIds, folders, user.name)
val entryIds = PlaylistRepository.songIds(mood.playlistId)
val entries = LibraryRepository.songsByIds(entryIds, folders, user.name)
return moodJson(mood, seeds = seeds, songs = entries)
}
private fun refreshed(mood: MoodRecord): MoodRecord =
MoodRepository.get(mood.playlistId, mood.owner) ?: mood
private fun regenerate(
moodService: MoodService,
mood: MoodRecord,
user: UserAccount,
library: LibraryConfig,
) {
// A generation failure is recorded on the mood; management actions still succeed.
runCatching {
moodService.refreshNow(mood, user, library)
}.onFailure {
log.warn("Mood generation failed for ${mood.name}", it)
}
}
private fun genres(parameters: io.ktor.http.Parameters): List<String> =
(parameters.getAll("genre").orEmpty() +
parameters["genres"].orEmpty().split(','))
.map { it.trim() }
.filter { it.isNotEmpty() }
.distinct()
.take(20)
private fun intParam(raw: String?, default: Int, minimum: Int, maximum: Int): Int =
(raw?.toIntOrNull() ?: default).coerceIn(minimum, maximum)
private fun boolParam(raw: String?, default: Boolean): Boolean = when (raw?.lowercase()) {
null -> default
"true", "1", "yes", "on" -> true
"false", "0", "no", "off" -> false
else -> default
}
@@ -8,13 +8,16 @@ import kotlinx.serialization.json.put
import win.taptap.musicmanager.config.LibraryConfig import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.UsersConfig import win.taptap.musicmanager.config.UsersConfig
import win.taptap.musicmanager.db.LibraryRepository import win.taptap.musicmanager.db.LibraryRepository
import win.taptap.musicmanager.db.MoodRepository
import win.taptap.musicmanager.db.PlaylistRepository import win.taptap.musicmanager.db.PlaylistRepository
import win.taptap.musicmanager.mood.MoodService
import win.taptap.musicmanager.mood.MoodSessionTracker
import win.taptap.musicmanager.subsonic.models.playlistJson import win.taptap.musicmanager.subsonic.models.playlistJson
import win.taptap.musicmanager.subsonic.respondSubsonic import win.taptap.musicmanager.subsonic.respondSubsonic
import win.taptap.musicmanager.subsonic.respondSubsonicError import win.taptap.musicmanager.subsonic.respondSubsonicError
/** Playlist CRUD. Visibility: owned playlists plus all public playlists. */ /** Playlist CRUD. Visibility: owned playlists plus all public playlists. */
fun Route.playlistRoutes(users: UsersConfig, library: LibraryConfig) { fun Route.playlistRoutes(users: UsersConfig, library: LibraryConfig, moodService: MoodService) {
subsonicEndpoint(users, "/getPlaylists") { call, user -> subsonicEndpoint(users, "/getPlaylists") { call, user ->
val playlists = PlaylistRepository.visibleTo(user.name) val playlists = PlaylistRepository.visibleTo(user.name)
@@ -41,7 +44,20 @@ fun Route.playlistRoutes(users: UsersConfig, library: LibraryConfig) {
return@subsonicEndpoint return@subsonicEndpoint
} }
val folders = user.visibleFolderIds(library) if (playlist.kind == "mood") {
MoodSessionTracker.activate(user.name, playlist.id)
MoodRepository.get(playlist.id, user.name)?.let { mood ->
moodService.refreshIfStale(mood, user, library)
}
} else {
MoodSessionTracker.clear(user.name)
}
val folders = if (playlist.kind == "mood") {
user.musicFolderIds(library)
} else {
user.visibleFolderIds(library)
}
val songs = LibraryRepository.songsByIds(PlaylistRepository.songIds(id), folders, user.name) val songs = LibraryRepository.songsByIds(PlaylistRepository.songIds(id), folders, user.name)
call.respondSubsonic(buildJsonObject { put("playlist", playlistJson(playlist, songs)) }) call.respondSubsonic(buildJsonObject { put("playlist", playlistJson(playlist, songs)) })
@@ -65,6 +81,10 @@ fun Route.playlistRoutes(users: UsersConfig, library: LibraryConfig) {
call.respondSubsonicError(50, "Not authorized") call.respondSubsonicError(50, "Not authorized")
return@subsonicEndpoint return@subsonicEndpoint
} }
if (existing.kind == "mood") {
call.respondSubsonicError(50, "Mood playlists are generated by the server")
return@subsonicEndpoint
}
val newName = parameters["name"]?.takeIf { it.isNotBlank() } val newName = parameters["name"]?.takeIf { it.isNotBlank() }
PlaylistRepository.update( PlaylistRepository.update(
@@ -119,6 +139,15 @@ fun Route.playlistRoutes(users: UsersConfig, library: LibraryConfig) {
.mapNotNull { it.toIntOrNull() } .mapNotNull { it.toIntOrNull() }
.filter { it >= 0 } .filter { it >= 0 }
if (existing.kind == "mood" &&
(parameters.getAll("songIdToAdd").orEmpty().any { it.isNotBlank() } ||
removeIndices.isNotEmpty() ||
parameters.contains("public"))
) {
call.respondSubsonicError(50, "Mood playlists are generated by the server")
return@subsonicEndpoint
}
val updated = PlaylistRepository.update( val updated = PlaylistRepository.update(
playlistId = playlistId, playlistId = playlistId,
userName = user.name, userName = user.name,
@@ -154,6 +183,7 @@ fun Route.playlistRoutes(users: UsersConfig, library: LibraryConfig) {
} }
PlaylistRepository.delete(playlistId, user.name) PlaylistRepository.delete(playlistId, user.name)
MoodSessionTracker.clear(user.name)
call.respondSubsonic() call.respondSubsonic()
} }
} }
@@ -8,6 +8,7 @@ import io.ktor.server.request.contentType
import io.ktor.server.request.httpMethod import io.ktor.server.request.httpMethod
import io.ktor.server.request.receiveParameters import io.ktor.server.request.receiveParameters
import io.ktor.util.AttributeKey import io.ktor.util.AttributeKey
import win.taptap.musicmanager.config.FolderType
import win.taptap.musicmanager.config.LibraryConfig import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.UserAccount import win.taptap.musicmanager.config.UserAccount
@@ -24,6 +25,14 @@ fun UserAccount.effectiveFolderIds(library: LibraryConfig, musicFolderId: String
return if (requested in visible) setOf(requested) else emptySet() return if (requested in visible) setOf(requested) else emptySet()
} }
/** Music-only roots. Moods never draw from shared long-form folders. */
fun UserAccount.musicFolderIds(library: LibraryConfig): Set<Int> =
library.folders
.asSequence()
.filter { it.type == FolderType.MUSIC && it.id in folders }
.map { it.id }
.toSet()
/** Parameters captured during authentication, so POST bodies are only read once. */ /** Parameters captured during authentication, so POST bodies are only read once. */
fun ApplicationCall.subsonicParams(): Parameters = fun ApplicationCall.subsonicParams(): Parameters =
attributes.getOrNull(SubsonicParametersKey) ?: request.queryParameters attributes.getOrNull(SubsonicParametersKey) ?: request.queryParameters
@@ -4,6 +4,7 @@ import io.ktor.server.routing.Route
import io.ktor.server.routing.route import io.ktor.server.routing.route
import win.taptap.musicmanager.config.LibraryConfig import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.UsersConfig import win.taptap.musicmanager.config.UsersConfig
import win.taptap.musicmanager.mood.MoodService
import win.taptap.musicmanager.scanner.CoverArtService import win.taptap.musicmanager.scanner.CoverArtService
import win.taptap.musicmanager.scanner.ScanStatus import win.taptap.musicmanager.scanner.ScanStatus
import win.taptap.musicmanager.transcoding.FfmpegTranscoder import win.taptap.musicmanager.transcoding.FfmpegTranscoder
@@ -14,6 +15,7 @@ fun Route.subsonicRoutes(
library: LibraryConfig, library: LibraryConfig,
coverArtService: CoverArtService, coverArtService: CoverArtService,
transcoder: FfmpegTranscoder, transcoder: FfmpegTranscoder,
moodService: MoodService,
startScan: () -> Boolean, startScan: () -> Boolean,
scanStatus: () -> ScanStatus, scanStatus: () -> ScanStatus,
) { ) {
@@ -22,7 +24,8 @@ fun Route.subsonicRoutes(
browsingRoutes(users, library) browsingRoutes(users, library)
mediaRoutes(users, library, coverArtService, transcoder) mediaRoutes(users, library, coverArtService, transcoder)
interactionRoutes(users, library) interactionRoutes(users, library)
playlistRoutes(users, library) playlistRoutes(users, library, moodService)
moodRoutes(users, library, moodService)
playQueueRoutes(users, library) playQueueRoutes(users, library)
} }
} }
@@ -0,0 +1,47 @@
-- Moods are private, server-managed playlists. The playlist stays the
-- Symfonium-visible object; this table holds the generation settings.
ALTER TABLE playlists ADD COLUMN kind TEXT NOT NULL DEFAULT 'user'
CHECK (kind IN ('user', 'mood'));
CREATE TABLE moods (
playlist_id TEXT PRIMARY KEY REFERENCES playlists(id) ON DELETE CASCADE,
query TEXT,
genres TEXT NOT NULL DEFAULT '[]',
target_size INTEGER NOT NULL DEFAULT 50,
yt_slots INTEGER NOT NULL DEFAULT 0,
expand_related BOOLEAN NOT NULL DEFAULT 1,
refresh_hours INTEGER NOT NULL DEFAULT 24,
generated_at TEXT,
generation INTEGER NOT NULL DEFAULT 0,
last_error TEXT
);
-- Manual, promoted and liked songs are permanent anchors for the mood.
CREATE TABLE mood_seeds (
playlist_id TEXT NOT NULL REFERENCES moods(playlist_id) ON DELETE CASCADE,
song_id TEXT NOT NULL REFERENCES songs(id) ON DELETE CASCADE,
origin TEXT NOT NULL DEFAULT 'manual'
CHECK (origin IN ('manual', 'promoted', 'star', 'yt_like')),
added_at TEXT NOT NULL,
PRIMARY KEY (playlist_id, song_id)
);
-- YT Music candidates. The downloader and recommendation UI land in a later
-- phase; the table is created now so generation does not need a migration.
CREATE TABLE mood_recommendations (
playlist_id TEXT NOT NULL REFERENCES moods(playlist_id) ON DELETE CASCADE,
video_id TEXT NOT NULL,
title TEXT NOT NULL,
artist TEXT NOT NULL,
duration INTEGER,
state TEXT NOT NULL DEFAULT 'new'
CHECK (state IN ('new', 'liked', 'rejected', 'downloaded')),
matched_song_id TEXT REFERENCES songs(id) ON DELETE SET NULL,
times_added INTEGER NOT NULL DEFAULT 0,
first_seen TEXT NOT NULL,
last_seen TEXT NOT NULL,
PRIMARY KEY (playlist_id, video_id)
);
CREATE INDEX idx_mood_seeds_song ON mood_seeds (song_id);
CREATE INDEX idx_mood_recommendations_song ON mood_recommendations (matched_song_id);
+268
View File
@@ -44,12 +44,17 @@
#status.error { color:#ff7b72; } #status.error { color:#ff7b72; }
#crumb { cursor:pointer; color:var(--accent); } #crumb { cursor:pointer; color:var(--accent); }
.hidden { display:none !important; } .hidden { display:none !important; }
form label { display:grid; gap:5px; font-size:13px; color:var(--muted); }
form label.row { display:flex; gap:8px; align-items:center; color:var(--text); }
form input[type=checkbox] { width:auto; }
.error { color:#ff7b72; }
</style> </style>
</head> </head>
<body> <body>
<header id="topbar" class="hidden"> <header id="topbar" class="hidden">
<h1>MusicManager</h1> <h1>MusicManager</h1>
<button class="ghost" id="homeBtn">Albums</button> <button class="ghost" id="homeBtn">Albums</button>
<button class="ghost" id="moodsBtn">Moods</button>
<input id="search" placeholder="Search" style="width:220px"> <input id="search" placeholder="Search" style="width:220px">
<select id="folder"></select> <select id="folder"></select>
<span class="spacer"></span> <span class="spacer"></span>
@@ -261,6 +266,268 @@ async function search() {
} }
} }
function formatWhen(value) {
if (!value) return 'never';
const date = new Date(value);
return Number.isNaN(date.getTime()) ? value : date.toLocaleString();
}
async function showMoods() {
$('app').dataset.moodId = '';
setStatus('Loading moods...');
try {
const moods = (await api('getMoods')).moods?.mood || [];
$('title').textContent = 'Moods';
$('content').innerHTML = `
<div class="row" style="margin-top:12px">
<button class="primary" id="newMoodBtn">New mood</button>
<button id="promoteMoodBtn">Promote playlist</button>
</div>
${moods.length ? `<table>
<thead><tr><th>Name</th><th>Seeds</th><th>Songs</th><th>Refreshed</th><th></th></tr></thead>
<tbody>${moods.map(moodRow).join('')}</tbody>
</table>` : '<p class="muted">No moods yet. Create one or promote an existing playlist.</p>'}`;
$('newMoodBtn').onclick = showCreateMood;
$('promoteMoodBtn').onclick = showPromoteMood;
setStatus(`${moods.length} moods`);
} catch (error) {
setStatus(error.message, true);
}
}
function moodRow(mood) {
return `<tr>
<td><strong>${esc(mood.name)}</strong>${mood.lastError ? ' <span class="error">(generation error)</span>' : ''}</td>
<td>${esc(mood.seedCount)}</td>
<td>${esc(mood.songCount)}</td>
<td class="muted">${esc(formatWhen(mood.generatedAt))}</td>
<td class="row" style="justify-content:flex-end">
<button data-mood-open="${esc(mood.id)}">Open</button>
<button data-mood-refresh="${esc(mood.id)}">Refresh</button>
<button data-mood-delete="${esc(mood.id)}">Delete</button>
</td>
</tr>`;
}
function showCreateMood() {
$('app').dataset.moodId = '';
$('title').innerHTML = '<span id="crumb">Moods</span> / New mood';
$('content').innerHTML = `
<form id="moodForm" style="max-width:560px;margin-top:14px;display:grid;gap:10px">
<label>Name<input name="name" required placeholder="Focus"></label>
<label>Query (optional)<input name="query" placeholder="ambient focus"></label>
<label>Genres (comma separated)<input name="genres" placeholder="Ambient, Electronic"></label>
<label>Target size<input name="targetSize" type="number" min="1" max="500" value="50"></label>
<label>Refresh hours<input name="refreshHours" type="number" min="1" max="720" value="24"></label>
<label class="row"><input name="expandRelated" type="checkbox" checked> Fill with related library songs</label>
<div class="row"><button class="primary" type="submit">Create mood</button></div>
</form>`;
$('crumb').onclick = showMoods;
$('moodForm').onsubmit = async (event) => {
event.preventDefault();
const form = new FormData(event.target);
try {
const mood = (await api('createMood', {
name: form.get('name'),
query: form.get('query') || '',
genres: form.get('genres') || '',
targetSize: form.get('targetSize'),
refreshHours: form.get('refreshHours'),
expandRelated: form.get('expandRelated') ? 'true' : 'false',
})).mood;
await showMood(mood.id);
} catch (error) {
setStatus(error.message, true);
}
};
}
async function showPromoteMood() {
setStatus('Loading playlists...');
try {
const [playlistsPayload, moodsPayload] = await Promise.all([api('getPlaylists'), api('getMoods')]);
const playlists = playlistsPayload.playlists?.playlist || [];
const moodIds = new Set((moodsPayload.moods?.mood || []).map((mood) => mood.id));
const owned = playlists.filter((playlist) => playlist.owner === state.user && !moodIds.has(playlist.id));
$('title').innerHTML = '<span id="crumb">Moods</span> / Promote playlist';
$('content').innerHTML = owned.length ? `
<p class="muted">The playlist ID and name stay the same. Its current songs become permanent seeds.</p>
<form id="promoteForm" style="max-width:560px;display:grid;gap:10px">
<label>Playlist<select name="playlistId">${owned.map((playlist) =>
`<option value="${esc(playlist.id)}">${esc(playlist.name)} (${esc(playlist.songCount)})</option>`).join('')}</select></label>
<label>Query (optional)<input name="query"></label>
<label>Target size<input name="targetSize" type="number" min="1" max="500" value="50"></label>
<label>Refresh hours<input name="refreshHours" type="number" min="1" max="720" value="24"></label>
<label class="row"><input name="expandRelated" type="checkbox" checked> Fill with related library songs</label>
<div class="row"><button class="primary" type="submit">Promote</button></div>
</form>` : '<p class="muted">No owned playlists found.</p>';
if ($('crumb')) $('crumb').onclick = showMoods;
if ($('promoteForm')) $('promoteForm').onsubmit = async (event) => {
event.preventDefault();
const form = new FormData(event.target);
try {
const mood = (await api('promotePlaylistToMood', {
playlistId: form.get('playlistId'),
query: form.get('query') || '',
targetSize: form.get('targetSize'),
refreshHours: form.get('refreshHours'),
expandRelated: form.get('expandRelated') ? 'true' : 'false',
})).mood;
await showMood(mood.id);
} catch (error) {
setStatus(error.message, true);
}
};
setStatus(`${owned.length} playlists`);
} catch (error) {
setStatus(error.message, true);
}
}
async function showMood(id) {
setStatus('Loading mood...');
try {
const mood = (await api('getMood', { id })).mood;
const seeds = mood.seed || [];
const entries = mood.entry || [];
$('title').innerHTML = `<span id="crumb">Moods</span> / ${esc(mood.name)}`;
$('content').innerHTML = `
<div class="row" style="margin-top:12px">
<span class="muted">${esc(mood.seedCount)} seeds · ${esc(mood.songCount)} songs · refreshed ${esc(formatWhen(mood.generatedAt))}</span>
<span class="spacer" style="flex:1"></span>
<button id="moodRefresh">Refresh now</button>
<button id="moodDelete">Delete mood</button>
</div>
${mood.lastError ? `<p class="error">${esc(mood.lastError)}</p>` : ''}
<form id="moodSettings" style="max-width:560px;margin-top:14px;display:grid;gap:10px">
<label>Name<input name="name" required value="${esc(mood.name)}"></label>
<label>Query (optional)<input name="query" value="${esc(mood.query || '')}"></label>
<label>Genres (comma separated)<input name="genres" value="${esc((mood.genres || []).join(', '))}"></label>
<label>Target size<input name="targetSize" type="number" min="1" max="500" value="${esc(mood.targetSize)}"></label>
<label>YT slots (reserved)<input name="ytSlots" type="number" min="0" max="500" value="${esc(mood.ytSlots)}"></label>
<label>Refresh hours<input name="refreshHours" type="number" min="1" max="720" value="${esc(mood.refreshHours)}"></label>
<label class="row"><input name="expandRelated" type="checkbox" ${mood.expandRelated ? 'checked' : ''}> Fill with related library songs</label>
<div class="row"><button class="primary" type="submit">Save settings</button></div>
</form>
<h3>Seeds</h3>
${seeds.length ? `<table><tbody>${seeds.map((song) => `
<tr><td>${esc(song.title)}</td><td class="muted">${esc(song.artist || '')}</td>
<td style="text-align:right"><button data-seed-remove="${esc(song.id)}">Remove</button></td></tr>`).join('')}</tbody></table>`
: '<p class="muted">No seeds yet. Add songs below or promote a playlist.</p>'}
<h3>Add seed</h3>
<div class="row">
<input id="seedSearch" placeholder="Search library" style="min-width:260px">
<button id="seedSearchBtn">Search</button>
</div>
<div id="seedResults"></div>
<h3>Current mix</h3>
${entries.length ? `<table><tbody>${entries.map(songRow).join('')}</tbody></table>` : '<p class="muted">The mix is empty.</p>'}`;
$('app').dataset.moodId = id;
$('crumb').onclick = showMoods;
$('moodRefresh').onclick = async () => {
try {
await api('refreshMood', { id });
await showMood(id);
} catch (error) { setStatus(error.message, true); }
};
$('moodDelete').onclick = async () => {
if (!confirm(`Delete mood "${mood.name}"?`)) return;
try {
await api('deleteMood', { id });
await showMoods();
} catch (error) { setStatus(error.message, true); }
};
$('moodSettings').onsubmit = async (event) => {
event.preventDefault();
const form = new FormData(event.target);
try {
await api('updateMood', {
id,
name: form.get('name'),
query: form.get('query') || '',
genres: form.get('genres') || '',
targetSize: form.get('targetSize'),
ytSlots: form.get('ytSlots'),
refreshHours: form.get('refreshHours'),
expandRelated: form.get('expandRelated') ? 'true' : 'false',
});
await showMood(id);
} catch (error) { setStatus(error.message, true); }
};
$('seedSearchBtn').onclick = () => searchSeeds(id, seeds);
$('seedSearch').addEventListener('keydown', (event) => {
if (event.key === 'Enter') { event.preventDefault(); searchSeeds(id, seeds); }
});
setStatus(`${seeds.length} seeds, ${entries.length} songs`);
} catch (error) {
setStatus(error.message, true);
}
}
async function searchSeeds(moodId, seeds) {
const query = $('seedSearch').value.trim();
if (!query) return;
setStatus('Searching...');
try {
const result = (await api('search3', { query, songCount: '30', albumCount: '0', artistCount: '0' })).searchResult3 || {};
const seedIds = new Set(seeds.map((song) => song.id));
const songs = (result.song || []).filter((song) => !seedIds.has(song.id));
$('seedResults').innerHTML = songs.length
? `<table><tbody>${songs.map((song) => `
<tr><td>${esc(song.title)}</td><td class="muted">${esc(song.artist || '')}</td>
<td style="text-align:right"><button data-seed-add="${esc(song.id)}">Add</button></td></tr>`).join('')}</tbody></table>`
: '<p class="muted">No matching songs, or all are already seeds.</p>';
setStatus(`${songs.length} results`);
} catch (error) {
setStatus(error.message, true);
}
}
document.addEventListener('click', (event) => {
const open = event.target.closest('[data-mood-open]');
if (open) { showMood(open.dataset.moodOpen); return; }
const refresh = event.target.closest('[data-mood-refresh]');
if (refresh) {
api('refreshMood', { id: refresh.dataset.moodRefresh })
.then(() => showMoods())
.catch((error) => setStatus(error.message, true));
return;
}
const remove = event.target.closest('[data-mood-delete]');
if (remove) {
const id = remove.dataset.moodDelete;
if (!confirm('Delete this mood?')) return;
api('deleteMood', { id })
.then(() => showMoods())
.catch((error) => setStatus(error.message, true));
return;
}
const addSeed = event.target.closest('[data-seed-add]');
if (addSeed) {
const moodId = addSeed.closest('main').dataset.moodId;
if (!moodId) return;
api('addMoodSeed', { id: moodId, songId: addSeed.dataset.seedAdd })
.then(() => showMood(moodId))
.catch((error) => setStatus(error.message, true));
return;
}
const removeSeed = event.target.closest('[data-seed-remove]');
if (removeSeed) {
const moodId = removeSeed.closest('main').dataset.moodId;
if (!moodId) return;
api('removeMoodSeed', { id: moodId, songId: removeSeed.dataset.seedRemove })
.then(() => showMood(moodId))
.catch((error) => setStatus(error.message, true));
}
});
function formatDuration(seconds) { function formatDuration(seconds) {
const total = Math.max(0, Math.floor(seconds || 0)); const total = Math.max(0, Math.floor(seconds || 0));
return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, '0')}`; return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, '0')}`;
@@ -291,6 +558,7 @@ document.addEventListener('click', (event) => {
$('loginBtn').onclick = login; $('loginBtn').onclick = login;
$('password').addEventListener('keydown', (event) => { if (event.key === 'Enter') login(); }); $('password').addEventListener('keydown', (event) => { if (event.key === 'Enter') login(); });
$('homeBtn').onclick = showAlbums; $('homeBtn').onclick = showAlbums;
$('moodsBtn').onclick = showMoods;
$('logout').onclick = logout; $('logout').onclick = logout;
$('search').addEventListener('keydown', (event) => { if (event.key === 'Enter') search(); }); $('search').addEventListener('keydown', (event) => { if (event.key === 'Enter') search(); });
$('folder').onchange = () => { state.folderId = $('folder').value; showAlbums(); }; $('folder').onchange = () => { state.folderId = $('folder').value; showAlbums(); };
@@ -20,6 +20,8 @@ import io.ktor.server.testing.testApplication
import java.nio.file.Files import java.nio.file.Files
import java.nio.file.Path import java.nio.file.Path
import java.time.Instant import java.time.Instant
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.serialization.json.Json import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.int import kotlinx.serialization.json.int
@@ -50,6 +52,7 @@ import win.taptap.musicmanager.db.MediaRepository
import win.taptap.musicmanager.db.SongArtistsTable import win.taptap.musicmanager.db.SongArtistsTable
import win.taptap.musicmanager.db.SongGenresTable import win.taptap.musicmanager.db.SongGenresTable
import win.taptap.musicmanager.db.SongsTable import win.taptap.musicmanager.db.SongsTable
import win.taptap.musicmanager.mood.MoodService
import win.taptap.musicmanager.scanner.CoverArtService import win.taptap.musicmanager.scanner.CoverArtService
import win.taptap.musicmanager.scanner.ScanStatus import win.taptap.musicmanager.scanner.ScanStatus
import win.taptap.musicmanager.subsonic.routes.subsonicRoutes import win.taptap.musicmanager.subsonic.routes.subsonicRoutes
@@ -448,6 +451,7 @@ class BrowsingRoutesTest {
library = seed.library, library = seed.library,
coverArtService = seed.coverArt, coverArtService = seed.coverArt,
transcoder = FfmpegTranscoder("ffmpeg"), transcoder = FfmpegTranscoder("ffmpeg"),
moodService = MoodService(CoroutineScope(Dispatchers.Unconfined)),
startScan = { false }, startScan = { false },
scanStatus = { ScanStatus(false, 0) }, scanStatus = { ScanStatus(false, 0) },
) )
@@ -0,0 +1,410 @@
package win.taptap.musicmanager.subsonic
import io.ktor.client.HttpClient
import io.ktor.client.request.get
import io.ktor.client.statement.bodyAsText
import io.ktor.serialization.kotlinx.json.json
import io.ktor.server.application.install
import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
import io.ktor.server.plugins.partialcontent.PartialContent
import io.ktor.server.routing.routing
import io.ktor.server.testing.ApplicationTestBuilder
import io.ktor.server.testing.testApplication
import java.nio.file.Files
import java.nio.file.Path
import java.time.Instant
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.int
import kotlinx.serialization.json.jsonArray
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
import org.jetbrains.exposed.sql.insert
import org.jetbrains.exposed.sql.insertIgnore
import org.jetbrains.exposed.sql.transactions.transaction
import org.junit.jupiter.api.io.TempDir
import win.taptap.musicmanager.config.AppConfig
import win.taptap.musicmanager.config.FolderType
import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.MusicFolder
import win.taptap.musicmanager.config.UserAccount
import win.taptap.musicmanager.config.UsersConfig
import win.taptap.musicmanager.db.AlbumArtistsTable
import win.taptap.musicmanager.db.AlbumsTable
import win.taptap.musicmanager.db.ArtistsTable
import win.taptap.musicmanager.db.ConfigRepository
import win.taptap.musicmanager.db.DatabaseFactory
import win.taptap.musicmanager.db.DatabaseHandle
import win.taptap.musicmanager.db.SongArtistsTable
import win.taptap.musicmanager.db.SongGenresTable
import win.taptap.musicmanager.db.SongsTable
import win.taptap.musicmanager.mood.MoodService
import win.taptap.musicmanager.mood.MoodSessionTracker
import win.taptap.musicmanager.scanner.CoverArtService
import win.taptap.musicmanager.scanner.ScanStatus
import win.taptap.musicmanager.subsonic.routes.subsonicRoutes
import win.taptap.musicmanager.transcoding.FfmpegTranscoder
import win.taptap.musicmanager.util.IdGenerator
class MoodRoutesTest {
@TempDir
lateinit var tempDir: Path
@Test
fun `creating a mood generates a private music-only playlist`() {
clearSessions()
seededContext().use { seed ->
testApplication {
setupApp(seed)
val auth = credentials("alice", "alice-pw")
val mood = client.createMood(auth, "Focus", listOf(seed.aliceAmbient1), target = 10)
val id = mood.string("id")
assertEquals(1, mood.int("seedCount"))
assertTrue(mood.string("generatedAt").isNotBlank())
val entries = mood.ids("entry")
assertTrue(seed.aliceAmbient1 in entries)
assertTrue(seed.aliceAmbient2 in entries)
assertFalse(seed.bobSong in entries)
assertFalse(seed.longformSong in entries)
// A long-form song is not a valid mood seed and must not enter the mix.
val bookish = client.createMood(auth, "Bookish", listOf(seed.longformSong), target = 5)
assertEquals(0, bookish.int("seedCount"))
assertEquals(0, bookish.ids("entry").size)
val playlist = parseBody(
client.get("/rest/getPlaylist?$auth&id=$id").bodyAsText(),
)["playlist"]!!.jsonObject
assertEquals("Focus", playlist.string("name"))
assertEquals(entries.size, playlist["entry"]!!.jsonArray.size)
val bobAuth = credentials("bob", "bob-pw")
val bobMoods = parseBody(client.get("/rest/getMoods?$bobAuth").bodyAsText())["moods"]!!.jsonObject
assertEquals(0, bobMoods["mood"]?.jsonArray?.size ?: 0)
val denied = parseBody(client.get("/rest/getPlaylist?$bobAuth&id=$id").bodyAsText())
assertEquals(70, denied["error"]!!.jsonObject["code"]!!.jsonPrimitive.int)
}
}
}
@Test
fun `promoting a playlist keeps its id and rejects song edits`() {
clearSessions()
seededContext().use { seed ->
testApplication {
setupApp(seed)
val auth = credentials("alice", "alice-pw")
val playlist = parseBody(
client.get(
"/rest/createPlaylist?$auth&name=Road&songId=${seed.aliceAmbient1}&songId=${seed.aliceAmbient2}",
).bodyAsText(),
)["playlist"]!!.jsonObject
val id = playlist.string("id")
val promoted = parseBody(
client.get("/rest/promotePlaylistToMood?$auth&playlistId=$id&targetSize=10").bodyAsText(),
)["mood"]!!.jsonObject
assertEquals(id, promoted.string("id"))
assertEquals(2, promoted.int("seedCount"))
assertEquals(2, promoted.ids("seed").size)
assertTrue(seed.aliceAmbient1 in promoted.ids("entry"))
val edit = parseBody(
client.get(
"/rest/updatePlaylist?$auth&playlistId=$id&songIdToAdd=${seed.aliceRock}",
).bodyAsText(),
)
assertEquals(50, edit["error"]!!.jsonObject["code"]!!.jsonPrimitive.int)
val bobAuth = credentials("bob", "bob-pw")
val denied = parseBody(client.get("/rest/getPlaylist?$bobAuth&id=$id").bodyAsText())
assertEquals(70, denied["error"]!!.jsonObject["code"]!!.jsonPrimitive.int)
}
}
}
@Test
fun `star pins to the active mood and unstar removes only star seeds`() {
clearSessions()
seededContext().use { seed ->
testApplication {
setupApp(seed)
val auth = credentials("alice", "alice-pw")
val mood = client.createMood(
auth,
"Pinned",
listOf(seed.aliceAmbient1),
target = 10,
expandRelated = false,
)
val id = mood.string("id")
// Opening the mood makes it active.
client.get("/rest/getPlaylist?$auth&id=$id").bodyAsText()
val star = parseBody(client.get("/rest/star?$auth&id=${seed.aliceAmbient2}").bodyAsText())
assertEquals("ok", star.string("status"))
val afterStar = parseBody(client.get("/rest/getMood?$auth&id=$id").bodyAsText())["mood"]!!.jsonObject
assertEquals(2, afterStar.int("seedCount"))
assertTrue(seed.aliceAmbient2 in afterStar.ids("seed"))
assertTrue(seed.aliceAmbient1 in afterStar.ids("seed"))
val refreshed = parseBody(client.get("/rest/refreshMood?$auth&id=$id").bodyAsText())["mood"]!!.jsonObject
assertTrue(seed.aliceAmbient2 in refreshed.ids("entry"))
parseBody(client.get("/rest/unstar?$auth&id=${seed.aliceAmbient2}").bodyAsText())
val afterUnstar = parseBody(client.get("/rest/getMood?$auth&id=$id").bodyAsText())["mood"]!!.jsonObject
assertEquals(1, afterUnstar.int("seedCount"))
assertTrue(seed.aliceAmbient1 in afterUnstar.ids("seed"))
assertFalse(seed.aliceAmbient2 in afterUnstar.ids("seed"))
}
}
}
@Test
fun `star without a session pins moods that already contain the song`() {
clearSessions()
seededContext().use { seed ->
testApplication {
setupApp(seed)
val auth = credentials("alice", "alice-pw")
val mood = client.createMood(auth, "Related", listOf(seed.aliceAmbient1), target = 10)
val id = mood.string("id")
assertTrue(seed.aliceAmbient2 in mood.ids("entry"))
// No getPlaylist call: there is no active mood session.
parseBody(client.get("/rest/star?$auth&id=${seed.aliceAmbient2}").bodyAsText())
val afterStar = parseBody(client.get("/rest/getMood?$auth&id=$id").bodyAsText())["mood"]!!.jsonObject
assertEquals(2, afterStar.int("seedCount"))
assertTrue(seed.aliceAmbient2 in afterStar.ids("seed"))
}
}
}
private fun ApplicationTestBuilder.setupApp(seed: Seed) {
application {
install(ContentNegotiation) {
json(Json { ignoreUnknownKeys = true; encodeDefaults = true })
}
install(PartialContent)
routing {
subsonicRoutes(
users = seed.users,
library = seed.library,
coverArtService = seed.coverArt,
transcoder = FfmpegTranscoder("ffmpeg"),
moodService = MoodService(CoroutineScope(Dispatchers.Unconfined)),
startScan = { false },
scanStatus = { ScanStatus(false, 0) },
)
}
}
}
private fun seededContext(): Seed {
val musicA = Files.createDirectories(tempDir.resolve("music-a"))
val musicB = Files.createDirectories(tempDir.resolve("music-b"))
val longform = Files.createDirectories(tempDir.resolve("longform"))
val library = LibraryConfig(
listOf(
MusicFolder(1, "Alice Music", FolderType.MUSIC, musicA),
MusicFolder(2, "Bob Music", FolderType.MUSIC, musicB),
MusicFolder(10, "Long-form", FolderType.LONGFORM, longform),
),
)
val users = UsersConfig(
listOf(
UserAccount("alice", "alice-pw", admin = true, folders = setOf(1)),
UserAccount("bob", "bob-pw", admin = false, folders = setOf(2)),
),
)
val db = DatabaseFactory.connect(
AppConfig(
port = 8080,
dataDir = tempDir.resolve("data"),
libraryConfigPath = tempDir.resolve("library.yaml"),
usersFile = tempDir.resolve("users.yaml"),
ffmpegPath = "ffmpeg",
),
)
ConfigRepository.sync(library, users)
val aliceAmbient1 = seedSong(
db, 1, "Alpha", "Focus One", "Deep Work",
"Alpha/Focus One/01.mp3", "Ambient", musicA,
)
val aliceAmbient2 = seedSong(
db, 1, "Beta", "Focus Two", "Soft Light",
"Beta/Focus Two/01.mp3", "Ambient", musicA,
)
val aliceRock = seedSong(
db, 1, "Gamma", "Loud", "Noise",
"Gamma/Loud/01.mp3", "Rock", musicA,
)
val aliceAmbient3 = seedSong(
db, 1, "Alpha", "Focus One", "Second Wind",
"Alpha/Focus One/02.mp3", "Ambient", musicA,
)
val bobSong = seedSong(
db, 2, "Bob Artist", "Bob Album", "Bob Song",
"Bob Artist/Bob Album/01.mp3", "Ambient", musicB,
)
val longformSong = seedSong(
db, 10, "Long Narrator", "Long Book", "Chapter One",
"Long Narrator/Long Book/01.mp3", "Ambient", longform,
)
return Seed(
db = db,
library = library,
users = users,
coverArt = CoverArtService(tempDir.resolve("data")),
aliceAmbient1 = aliceAmbient1,
aliceAmbient2 = aliceAmbient2,
aliceRock = aliceRock,
aliceAmbient3 = aliceAmbient3,
bobSong = bobSong,
longformSong = longformSong,
)
}
private fun seedSong(
db: DatabaseHandle,
folderId: Int,
artistName: String,
albumName: String,
title: String,
relativePath: String,
genre: String,
root: Path,
): String {
val file = root.resolve(relativePath)
Files.createDirectories(file.parent)
Files.write(file, "ID3-fake-audio".toByteArray())
val artistId = IdGenerator.artistId(artistName)
val albumId = IdGenerator.albumId(artistName, albumName)
val songId = IdGenerator.songId(folderId, relativePath)
val now = Instant.now().toString()
transaction(db.database) {
ArtistsTable.insertIgnore {
it[id] = artistId
it[name] = artistName
it[sortName] = artistName
it[searchText] = IdGenerator.normalize(artistName)
}
AlbumsTable.insertIgnore {
it[id] = albumId
it[name] = albumName
it[year] = 2026
it[createdAt] = now
it[searchText] = IdGenerator.normalize("$albumName $artistName")
}
AlbumArtistsTable.insertIgnore {
it[this.albumId] = albumId
it[this.artistId] = artistId
it[position] = 0
}
SongsTable.insert {
it[id] = songId
it[this.albumId] = albumId
it[this.folderId] = folderId
it[this.title] = title
it[displayArtist] = artistName
it[this.albumName] = albumName
it[trackNumber] = 1
it[discNumber] = 1
it[year] = 2026
it[duration] = 120
it[bitRate] = 128
it[size] = Files.size(file)
it[suffix] = "mp3"
it[contentType] = "audio/mpeg"
it[this.relativePath] = relativePath
it[fileMtime] = 0
it[createdAt] = now
it[searchText] = IdGenerator.normalize("$title $artistName $albumName $artistName")
}
SongArtistsTable.insert {
it[this.songId] = songId
it[this.artistId] = artistId
it[position] = 0
}
SongGenresTable.insert {
it[this.songId] = songId
it[this.genre] = genre
}
}
return songId
}
private suspend fun HttpClient.createMood(
auth: String,
name: String,
seeds: List<String>,
target: Int,
expandRelated: Boolean = true,
): JsonObject {
val seedParams = seeds.joinToString("") { "&songId=$it" }
val body = get(
"/rest/createMood?$auth&name=$name$seedParams&targetSize=$target&expandRelated=$expandRelated",
).bodyAsText()
return parseBody(body)["mood"]!!.jsonObject
}
private fun clearSessions() {
MoodSessionTracker.clear("alice")
MoodSessionTracker.clear("bob")
}
private fun credentials(user: String, password: String): String {
val salt = "test-salt"
return "u=$user&t=${SubsonicAuthenticator.md5Hex(password + salt)}&s=$salt"
}
private fun parseBody(body: String): JsonObject =
Json.parseToJsonElement(body).jsonObject["subsonic-response"]!!.jsonObject
private fun JsonObject.string(name: String): String =
this[name]!!.jsonPrimitive.content
private fun JsonObject.int(name: String): Int =
this[name]!!.jsonPrimitive.int
private fun JsonObject.ids(name: String): List<String> =
this[name]!!.jsonArray.map { it.jsonObject["id"]!!.jsonPrimitive.content }
private data class Seed(
val db: DatabaseHandle,
val library: LibraryConfig,
val users: UsersConfig,
val coverArt: CoverArtService,
val aliceAmbient1: String,
val aliceAmbient2: String,
val aliceRock: String,
val aliceAmbient3: String,
val bobSong: String,
val longformSong: String,
) : AutoCloseable {
override fun close() = db.close()
}
}
@@ -9,6 +9,8 @@ import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
import io.ktor.server.routing.routing import io.ktor.server.routing.routing
import io.ktor.server.testing.ApplicationTestBuilder import io.ktor.server.testing.ApplicationTestBuilder
import io.ktor.server.testing.testApplication import io.ktor.server.testing.testApplication
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.serialization.json.Json import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.int import kotlinx.serialization.json.int
@@ -25,6 +27,7 @@ import win.taptap.musicmanager.config.LibraryConfig
import win.taptap.musicmanager.config.MusicFolder import win.taptap.musicmanager.config.MusicFolder
import win.taptap.musicmanager.config.UserAccount import win.taptap.musicmanager.config.UserAccount
import win.taptap.musicmanager.config.UsersConfig import win.taptap.musicmanager.config.UsersConfig
import win.taptap.musicmanager.mood.MoodService
import win.taptap.musicmanager.scanner.CoverArtService import win.taptap.musicmanager.scanner.CoverArtService
import win.taptap.musicmanager.scanner.ScanStatus import win.taptap.musicmanager.scanner.ScanStatus
import win.taptap.musicmanager.subsonic.routes.subsonicRoutes import win.taptap.musicmanager.subsonic.routes.subsonicRoutes
@@ -180,6 +183,7 @@ class SystemRoutesTest {
), ),
coverArtService = CoverArtService(tempDir.resolve("data")), coverArtService = CoverArtService(tempDir.resolve("data")),
transcoder = FfmpegTranscoder("ffmpeg"), transcoder = FfmpegTranscoder("ffmpeg"),
moodService = MoodService(CoroutineScope(Dispatchers.Unconfined)),
startScan = startScan, startScan = startScan,
scanStatus = scanStatus, scanStatus = scanStatus,
) )