+99

cmd/handlers.go

··· 8 8 "strconv" 9 9 10 10 "github.com/teal-fm/piper/db" 11 11 + "github.com/teal-fm/piper/models" 11 12 "github.com/teal-fm/piper/service/musicbrainz" 12 13 "github.com/teal-fm/piper/service/spotify" 13 14 "github.com/teal-fm/piper/session" ··· 421 422 jsonResponse(w, http.StatusOK, map[string]string{"message": "Last.fm username unlinked successfully"}) 422 423 } 423 424 } 425 425 + 426 426 + // apiSubmitListensHandler handles ListenBrainz-compatible submissions 427 427 + func apiSubmitListensHandler(database *db.DB) http.HandlerFunc { 428 428 + return func(w http.ResponseWriter, r *http.Request) { 429 429 + userID, authenticated := session.GetUserID(r.Context()) 430 430 + if !authenticated { 431 431 + jsonResponse(w, http.StatusUnauthorized, map[string]string{"error": "Unauthorized"}) 432 432 + return 433 433 + } 434 434 + 435 435 + if r.Method != http.MethodPost { 436 436 + jsonResponse(w, http.StatusMethodNotAllowed, map[string]string{"error": "Method not allowed"}) 437 437 + return 438 438 + } 439 439 + 440 440 + // Parse the ListenBrainz submission 441 441 + var submission models.ListenBrainzSubmission 442 442 + if err := json.NewDecoder(r.Body).Decode(&submission); err != nil { 443 443 + log.Printf("apiSubmitListensHandler: Error decoding submission for user %d: %v", userID, err) 444 444 + jsonResponse(w, http.StatusBadRequest, map[string]string{"error": "Invalid JSON format"}) 445 445 + return 446 446 + } 447 447 + 448 448 + // Validate listen_type 449 449 + validListenTypes := map[string]bool{ 450 450 + "single": true, 451 451 + "import": true, 452 452 + "playing_now": true, 453 453 + } 454 454 + if !validListenTypes[submission.ListenType] { 455 455 + jsonResponse(w, http.StatusBadRequest, map[string]string{ 456 456 + "error": "Invalid listen_type. Must be 'single', 'import', or 'playing_now'", 457 457 + }) 458 458 + return 459 459 + } 460 460 + 461 461 + // Validate payload 462 462 + if len(submission.Payload) == 0 { 463 463 + jsonResponse(w, http.StatusBadRequest, map[string]string{"error": "Payload cannot be empty"}) 464 464 + return 465 465 + } 466 466 + 467 467 + // Process each listen in the payload 468 468 + var processedTracks []models.Track 469 469 + var errors []string 470 470 + 471 471 + for i, listen := range submission.Payload { 472 472 + // Validate required fields 473 473 + if listen.TrackMetadata.ArtistName == "" { 474 474 + errors = append(errors, fmt.Sprintf("payload[%d]: artist_name is required", i)) 475 475 + continue 476 476 + } 477 477 + if listen.TrackMetadata.TrackName == "" { 478 478 + errors = append(errors, fmt.Sprintf("payload[%d]: track_name is required", i)) 479 479 + continue 480 480 + } 481 481 + 482 482 + // Convert to internal Track format 483 483 + track := listen.ConvertToTrack(userID) 484 484 + 485 485 + // For 'playing_now' type, we might want to handle differently 486 486 + // For now, treat all the same but could add temporary storage later 487 487 + if submission.ListenType == "playing_now" { 488 488 + log.Printf("Received playing_now listen for user %d: %s - %s", userID, track.Artist[0].Name, track.Name) 489 489 + // Could store in a separate playing_now table or just log 490 490 + continue 491 491 + } 492 492 + 493 493 + // Store the track 494 494 + if _, err := database.SaveTrack(userID, &track); err != nil { 495 495 + log.Printf("apiSubmitListensHandler: Error saving track for user %d: %v", userID, err) 496 496 + errors = append(errors, fmt.Sprintf("payload[%d]: failed to save track", i)) 497 497 + continue 498 498 + } 499 499 + 500 500 + processedTracks = append(processedTracks, track) 501 501 + } 502 502 + 503 503 + // Prepare response 504 504 + response := map[string]interface{}{ 505 505 + "status": "ok", 506 506 + "processed": len(processedTracks), 507 507 + } 508 508 + 509 509 + if len(errors) > 0 { 510 510 + response["errors"] = errors 511 511 + if len(processedTracks) == 0 { 512 512 + jsonResponse(w, http.StatusBadRequest, response) 513 513 + return 514 514 + } 515 515 + } 516 516 + 517 517 + log.Printf("Successfully processed %d ListenBrainz submissions for user %d (type: %s)", 518 518 + len(processedTracks), userID, submission.ListenType) 519 519 + 520 520 + jsonResponse(w, http.StatusOK, response) 521 521 + } 522 522 + }

+539

cmd/listenbrainz_test.go

··· 1 1 + package main 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "context" 6 6 + "encoding/json" 7 7 + "net/http" 8 8 + "net/http/httptest" 9 9 + "testing" 10 10 + "time" 11 11 + 12 12 + "github.com/teal-fm/piper/db" 13 13 + "github.com/teal-fm/piper/models" 14 14 + "github.com/teal-fm/piper/session" 15 15 + ) 16 16 + 17 17 + func setupTestDB(t *testing.T) *db.DB { 18 18 + // Use in-memory SQLite database for testing 19 19 + database, err := db.New(":memory:") 20 20 + if err != nil { 21 21 + t.Fatalf("Failed to create test database: %v", err) 22 22 + } 23 23 + 24 24 + if err := database.Initialize(); err != nil { 25 25 + t.Fatalf("Failed to initialize test database: %v", err) 26 26 + } 27 27 + 28 28 + return database 29 29 + } 30 30 + 31 31 + func createTestUser(t *testing.T, database *db.DB) (int64, string) { 32 32 + // Create a test user 33 33 + user := &models.User{ 34 34 + Email: func() *string { s := "test@example.com"; return &s }(), 35 35 + ATProtoDID: func() *string { s := "did:test:user"; return &s }(), 36 36 + } 37 37 + 38 38 + userID, err := database.CreateUser(user) 39 39 + if err != nil { 40 40 + t.Fatalf("Failed to create test user: %v", err) 41 41 + } 42 42 + 43 43 + // Create API key for the user 44 44 + sessionManager := session.NewSessionManager(database) 45 45 + apiKeyObj, err := sessionManager.CreateAPIKey(userID, "test-key", 30) // 30 days validity 46 46 + if err != nil { 47 47 + t.Fatalf("Failed to create API key: %v", err) 48 48 + } 49 49 + 50 50 + return userID, apiKeyObj.ID 51 51 + } 52 52 + 53 53 + // Helper to create context with user ID (simulating auth middleware) 54 54 + func withUserContext(ctx context.Context, userID int64) context.Context { 55 55 + return session.WithUserID(ctx, userID) 56 56 + } 57 57 + 58 58 + func TestListenBrainzSubmission_Success(t *testing.T) { 59 59 + database := setupTestDB(t) 60 60 + defer database.Close() 61 61 + 62 62 + userID, apiKey := createTestUser(t, database) 63 63 + 64 64 + // Create test submission 65 65 + submission := models.ListenBrainzSubmission{ 66 66 + ListenType: "single", 67 67 + Payload: []models.ListenBrainzPayload{ 68 68 + { 69 69 + ListenedAt: func() *int64 { i := int64(1704067200); return &i }(), 70 70 + TrackMetadata: models.ListenBrainzTrackMetadata{ 71 71 + ArtistName: "Daft Punk", 72 72 + TrackName: "One More Time", 73 73 + ReleaseName: func() *string { s := "Discovery"; return &s }(), 74 74 + AdditionalInfo: &models.ListenBrainzAdditionalInfo{ 75 75 + RecordingMBID: func() *string { s := "98255a8c-017a-4bc7-8dd6-1fa36124572b"; return &s }(), 76 76 + ArtistMBIDs: []string{"db92a151-1ac2-438b-bc43-b82e149ddd50"}, 77 77 + ReleaseMBID: func() *string { s := "bf9e91ea-8029-4a04-a26a-224e00a83266"; return &s }(), 78 78 + DurationMs: func() *int64 { i := int64(320000); return &i }(), 79 79 + SpotifyID: func() *string { s := "4PTG3Z6ehGkBFwjybzWkR8"; return &s }(), 80 80 + ISRC: func() *string { s := "GBARL0600925"; return &s }(), 81 81 + }, 82 82 + }, 83 83 + }, 84 84 + }, 85 85 + } 86 86 + 87 87 + jsonData, err := json.Marshal(submission) 88 88 + if err != nil { 89 89 + t.Fatalf("Failed to marshal submission: %v", err) 90 90 + } 91 91 + 92 92 + // Create request 93 93 + req := httptest.NewRequest(http.MethodPost, "/1/submit-listens", bytes.NewReader(jsonData)) 94 94 + req.Header.Set("Content-Type", "application/json") 95 95 + req.Header.Set("Authorization", "Token "+apiKey) 96 96 + 97 97 + // Add user context (simulating authentication middleware) 98 98 + ctx := withUserContext(req.Context(), userID) 99 99 + req = req.WithContext(ctx) 100 100 + 101 101 + // Create response recorder 102 102 + rr := httptest.NewRecorder() 103 103 + 104 104 + // Call handler 105 105 + handler := apiSubmitListensHandler(database) 106 106 + handler(rr, req) 107 107 + 108 108 + // Check response 109 109 + if rr.Code != http.StatusOK { 110 110 + t.Errorf("Expected status %d, got %d. Body: %s", http.StatusOK, rr.Code, rr.Body.String()) 111 111 + } 112 112 + 113 113 + // Parse response 114 114 + var response map[string]interface{} 115 115 + if err := json.Unmarshal(rr.Body.Bytes(), &response); err != nil { 116 116 + t.Fatalf("Failed to parse response: %v", err) 117 117 + } 118 118 + 119 119 + // Verify response 120 120 + if response["status"] != "ok" { 121 121 + t.Errorf("Expected status 'ok', got %v", response["status"]) 122 122 + } 123 123 + 124 124 + processed, ok := response["processed"].(float64) 125 125 + if !ok || processed != 1 { 126 126 + t.Errorf("Expected processed count 1, got %v", response["processed"]) 127 127 + } 128 128 + 129 129 + // Verify data was saved to database 130 130 + tracks, err := database.GetRecentTracks(userID, 10) 131 131 + if err != nil { 132 132 + t.Fatalf("Failed to get tracks from database: %v", err) 133 133 + } 134 134 + 135 135 + if len(tracks) != 1 { 136 136 + t.Fatalf("Expected 1 track in database, got %d", len(tracks)) 137 137 + } 138 138 + 139 139 + track := tracks[0] 140 140 + if track.Name != "One More Time" { 141 141 + t.Errorf("Expected track name 'One More Time', got %s", track.Name) 142 142 + } 143 143 + if len(track.Artist) == 0 || track.Artist[0].Name != "Daft Punk" { 144 144 + t.Errorf("Expected artist 'Daft Punk', got %v", track.Artist) 145 145 + } 146 146 + if track.Album != "Discovery" { 147 147 + t.Errorf("Expected album 'Discovery', got %s", track.Album) 148 148 + } 149 149 + if track.RecordingMBID == nil || *track.RecordingMBID != "98255a8c-017a-4bc7-8dd6-1fa36124572b" { 150 150 + t.Errorf("Expected recording MBID to be set correctly") 151 151 + } 152 152 + if track.DurationMs != 320000 { 153 153 + t.Errorf("Expected duration 320000ms, got %d", track.DurationMs) 154 154 + } 155 155 + } 156 156 + 157 157 + func TestListenBrainzSubmission_MinimalPayload(t *testing.T) { 158 158 + database := setupTestDB(t) 159 159 + defer database.Close() 160 160 + 161 161 + userID, apiKey := createTestUser(t, database) 162 162 + 163 163 + // Create minimal submission (only required fields) 164 164 + submission := models.ListenBrainzSubmission{ 165 165 + ListenType: "single", 166 166 + Payload: []models.ListenBrainzPayload{ 167 167 + { 168 168 + TrackMetadata: models.ListenBrainzTrackMetadata{ 169 169 + ArtistName: "The Beatles", 170 170 + TrackName: "Hey Jude", 171 171 + }, 172 172 + }, 173 173 + }, 174 174 + } 175 175 + 176 176 + jsonData, err := json.Marshal(submission) 177 177 + if err != nil { 178 178 + t.Fatalf("Failed to marshal submission: %v", err) 179 179 + } 180 180 + 181 181 + req := httptest.NewRequest(http.MethodPost, "/1/submit-listens", bytes.NewReader(jsonData)) 182 182 + req.Header.Set("Content-Type", "application/json") 183 183 + req.Header.Set("Authorization", "Token "+apiKey) 184 184 + 185 185 + ctx := withUserContext(req.Context(), userID) 186 186 + req = req.WithContext(ctx) 187 187 + 188 188 + rr := httptest.NewRecorder() 189 189 + handler := apiSubmitListensHandler(database) 190 190 + handler(rr, req) 191 191 + 192 192 + if rr.Code != http.StatusOK { 193 193 + t.Errorf("Expected status %d, got %d. Body: %s", http.StatusOK, rr.Code, rr.Body.String()) 194 194 + } 195 195 + 196 196 + // Verify track was saved 197 197 + tracks, err := database.GetRecentTracks(userID, 10) 198 198 + if err != nil { 199 199 + t.Fatalf("Failed to get tracks from database: %v", err) 200 200 + } 201 201 + 202 202 + if len(tracks) != 1 { 203 203 + t.Fatalf("Expected 1 track in database, got %d", len(tracks)) 204 204 + } 205 205 + 206 206 + track := tracks[0] 207 207 + if track.Name != "Hey Jude" { 208 208 + t.Errorf("Expected track name 'Hey Jude', got %s", track.Name) 209 209 + } 210 210 + if len(track.Artist) == 0 || track.Artist[0].Name != "The Beatles" { 211 211 + t.Errorf("Expected artist 'The Beatles', got %v", track.Artist) 212 212 + } 213 213 + // Timestamp should be set to current time if not provided 214 214 + if track.Timestamp.IsZero() { 215 215 + t.Error("Expected timestamp to be set") 216 216 + } 217 217 + } 218 218 + 219 219 + func TestListenBrainzSubmission_BulkImport(t *testing.T) { 220 220 + database := setupTestDB(t) 221 221 + defer database.Close() 222 222 + 223 223 + userID, apiKey := createTestUser(t, database) 224 224 + 225 225 + // Create bulk submission 226 226 + submission := models.ListenBrainzSubmission{ 227 227 + ListenType: "import", 228 228 + Payload: []models.ListenBrainzPayload{ 229 229 + { 230 230 + ListenedAt: func() *int64 { i := int64(1704067200); return &i }(), 231 231 + TrackMetadata: models.ListenBrainzTrackMetadata{ 232 232 + ArtistName: "Track One Artist", 233 233 + TrackName: "Track One", 234 234 + }, 235 235 + }, 236 236 + { 237 237 + ListenedAt: func() *int64 { i := int64(1704067300); return &i }(), 238 238 + TrackMetadata: models.ListenBrainzTrackMetadata{ 239 239 + ArtistName: "Track Two Artist", 240 240 + TrackName: "Track Two", 241 241 + }, 242 242 + }, 243 243 + { 244 244 + ListenedAt: func() *int64 { i := int64(1704067400); return &i }(), 245 245 + TrackMetadata: models.ListenBrainzTrackMetadata{ 246 246 + ArtistName: "Track Three Artist", 247 247 + TrackName: "Track Three", 248 248 + }, 249 249 + }, 250 250 + }, 251 251 + } 252 252 + 253 253 + jsonData, err := json.Marshal(submission) 254 254 + if err != nil { 255 255 + t.Fatalf("Failed to marshal submission: %v", err) 256 256 + } 257 257 + 258 258 + req := httptest.NewRequest(http.MethodPost, "/1/submit-listens", bytes.NewReader(jsonData)) 259 259 + req.Header.Set("Content-Type", "application/json") 260 260 + req.Header.Set("Authorization", "Token "+apiKey) 261 261 + 262 262 + ctx := withUserContext(req.Context(), userID) 263 263 + req = req.WithContext(ctx) 264 264 + 265 265 + rr := httptest.NewRecorder() 266 266 + handler := apiSubmitListensHandler(database) 267 267 + handler(rr, req) 268 268 + 269 269 + if rr.Code != http.StatusOK { 270 270 + t.Errorf("Expected status %d, got %d. Body: %s", http.StatusOK, rr.Code, rr.Body.String()) 271 271 + } 272 272 + 273 273 + // Parse response 274 274 + var response map[string]interface{} 275 275 + if err := json.Unmarshal(rr.Body.Bytes(), &response); err != nil { 276 276 + t.Fatalf("Failed to parse response: %v", err) 277 277 + } 278 278 + 279 279 + processed, ok := response["processed"].(float64) 280 280 + if !ok || processed != 3 { 281 281 + t.Errorf("Expected processed count 3, got %v", response["processed"]) 282 282 + } 283 283 + 284 284 + // Verify all tracks were saved 285 285 + tracks, err := database.GetRecentTracks(userID, 10) 286 286 + if err != nil { 287 287 + t.Fatalf("Failed to get tracks from database: %v", err) 288 288 + } 289 289 + 290 290 + if len(tracks) != 3 { 291 291 + t.Fatalf("Expected 3 tracks in database, got %d", len(tracks)) 292 292 + } 293 293 + } 294 294 + 295 295 + func TestListenBrainzSubmission_PlayingNow(t *testing.T) { 296 296 + database := setupTestDB(t) 297 297 + defer database.Close() 298 298 + 299 299 + userID, apiKey := createTestUser(t, database) 300 300 + 301 301 + // Create playing_now submission 302 302 + submission := models.ListenBrainzSubmission{ 303 303 + ListenType: "playing_now", 304 304 + Payload: []models.ListenBrainzPayload{ 305 305 + { 306 306 + TrackMetadata: models.ListenBrainzTrackMetadata{ 307 307 + ArtistName: "Current Artist", 308 308 + TrackName: "Currently Playing", 309 309 + }, 310 310 + }, 311 311 + }, 312 312 + } 313 313 + 314 314 + jsonData, err := json.Marshal(submission) 315 315 + if err != nil { 316 316 + t.Fatalf("Failed to marshal submission: %v", err) 317 317 + } 318 318 + 319 319 + req := httptest.NewRequest(http.MethodPost, "/1/submit-listens", bytes.NewReader(jsonData)) 320 320 + req.Header.Set("Content-Type", "application/json") 321 321 + req.Header.Set("Authorization", "Token "+apiKey) 322 322 + 323 323 + ctx := withUserContext(req.Context(), userID) 324 324 + req = req.WithContext(ctx) 325 325 + 326 326 + rr := httptest.NewRecorder() 327 327 + handler := apiSubmitListensHandler(database) 328 328 + handler(rr, req) 329 329 + 330 330 + if rr.Code != http.StatusOK { 331 331 + t.Errorf("Expected status %d, got %d. Body: %s", http.StatusOK, rr.Code, rr.Body.String()) 332 332 + } 333 333 + 334 334 + // playing_now tracks should not be permanently stored 335 335 + tracks, err := database.GetRecentTracks(userID, 10) 336 336 + if err != nil { 337 337 + t.Fatalf("Failed to get tracks from database: %v", err) 338 338 + } 339 339 + 340 340 + if len(tracks) != 0 { 341 341 + t.Errorf("Expected 0 tracks in database for playing_now, got %d", len(tracks)) 342 342 + } 343 343 + } 344 344 + 345 345 + func TestListenBrainzSubmission_ValidationErrors(t *testing.T) { 346 346 + database := setupTestDB(t) 347 347 + defer database.Close() 348 348 + 349 349 + userID, apiKey := createTestUser(t, database) 350 350 + 351 351 + testCases := []struct { 352 352 + name string 353 353 + submission models.ListenBrainzSubmission 354 354 + expectedStatus int 355 355 + expectedError string 356 356 + }{ 357 357 + { 358 358 + name: "invalid_listen_type", 359 359 + submission: models.ListenBrainzSubmission{ 360 360 + ListenType: "invalid", 361 361 + Payload: []models.ListenBrainzPayload{}, 362 362 + }, 363 363 + expectedStatus: http.StatusBadRequest, 364 364 + expectedError: "Invalid listen_type", 365 365 + }, 366 366 + { 367 367 + name: "empty_payload", 368 368 + submission: models.ListenBrainzSubmission{ 369 369 + ListenType: "single", 370 370 + Payload: []models.ListenBrainzPayload{}, 371 371 + }, 372 372 + expectedStatus: http.StatusBadRequest, 373 373 + expectedError: "Payload cannot be empty", 374 374 + }, 375 375 + { 376 376 + name: "missing_artist_name", 377 377 + submission: models.ListenBrainzSubmission{ 378 378 + ListenType: "single", 379 379 + Payload: []models.ListenBrainzPayload{ 380 380 + { 381 381 + TrackMetadata: models.ListenBrainzTrackMetadata{ 382 382 + TrackName: "Track Without Artist", 383 383 + }, 384 384 + }, 385 385 + }, 386 386 + }, 387 387 + expectedStatus: http.StatusBadRequest, 388 388 + expectedError: "artist_name is required", 389 389 + }, 390 390 + { 391 391 + name: "missing_track_name", 392 392 + submission: models.ListenBrainzSubmission{ 393 393 + ListenType: "single", 394 394 + Payload: []models.ListenBrainzPayload{ 395 395 + { 396 396 + TrackMetadata: models.ListenBrainzTrackMetadata{ 397 397 + ArtistName: "Artist Without Track", 398 398 + }, 399 399 + }, 400 400 + }, 401 401 + }, 402 402 + expectedStatus: http.StatusBadRequest, 403 403 + expectedError: "track_name is required", 404 404 + }, 405 405 + } 406 406 + 407 407 + for _, tc := range testCases { 408 408 + t.Run(tc.name, func(t *testing.T) { 409 409 + jsonData, err := json.Marshal(tc.submission) 410 410 + if err != nil { 411 411 + t.Fatalf("Failed to marshal submission: %v", err) 412 412 + } 413 413 + 414 414 + req := httptest.NewRequest(http.MethodPost, "/1/submit-listens", bytes.NewReader(jsonData)) 415 415 + req.Header.Set("Content-Type", "application/json") 416 416 + req.Header.Set("Authorization", "Token "+apiKey) 417 417 + 418 418 + ctx := withUserContext(req.Context(), userID) 419 419 + req = req.WithContext(ctx) 420 420 + 421 421 + rr := httptest.NewRecorder() 422 422 + handler := apiSubmitListensHandler(database) 423 423 + handler(rr, req) 424 424 + 425 425 + if rr.Code != tc.expectedStatus { 426 426 + t.Errorf("Expected status %d, got %d. Body: %s", tc.expectedStatus, rr.Code, rr.Body.String()) 427 427 + } 428 428 + 429 429 + if tc.expectedError != "" { 430 430 + body := rr.Body.String() 431 431 + if !bytes.Contains([]byte(body), []byte(tc.expectedError)) { 432 432 + t.Errorf("Expected error containing '%s', got: %s", tc.expectedError, body) 433 433 + } 434 434 + } 435 435 + }) 436 436 + } 437 437 + } 438 438 + 439 439 + func TestListenBrainzSubmission_Unauthorized(t *testing.T) { 440 440 + database := setupTestDB(t) 441 441 + defer database.Close() 442 442 + 443 443 + submission := models.ListenBrainzSubmission{ 444 444 + ListenType: "single", 445 445 + Payload: []models.ListenBrainzPayload{ 446 446 + { 447 447 + TrackMetadata: models.ListenBrainzTrackMetadata{ 448 448 + ArtistName: "Test Artist", 449 449 + TrackName: "Test Track", 450 450 + }, 451 451 + }, 452 452 + }, 453 453 + } 454 454 + 455 455 + jsonData, err := json.Marshal(submission) 456 456 + if err != nil { 457 457 + t.Fatalf("Failed to marshal submission: %v", err) 458 458 + } 459 459 + 460 460 + req := httptest.NewRequest(http.MethodPost, "/1/submit-listens", bytes.NewReader(jsonData)) 461 461 + req.Header.Set("Content-Type", "application/json") 462 462 + // No Authorization header 463 463 + 464 464 + rr := httptest.NewRecorder() 465 465 + handler := apiSubmitListensHandler(database) 466 466 + handler(rr, req) 467 467 + 468 468 + if rr.Code != http.StatusUnauthorized { 469 469 + t.Errorf("Expected status %d, got %d", http.StatusUnauthorized, rr.Code) 470 470 + } 471 471 + } 472 472 + 473 473 + func TestListenBrainzDataConversion(t *testing.T) { 474 474 + // Test the conversion logic directly 475 475 + payload := models.ListenBrainzPayload{ 476 476 + ListenedAt: func() *int64 { i := int64(1704067200); return &i }(), 477 477 + TrackMetadata: models.ListenBrainzTrackMetadata{ 478 478 + ArtistName: "Test Artist", 479 479 + TrackName: "Test Track", 480 480 + ReleaseName: func() *string { s := "Test Album"; return &s }(), 481 481 + AdditionalInfo: &models.ListenBrainzAdditionalInfo{ 482 482 + RecordingMBID: func() *string { s := "test-recording-mbid"; return &s }(), 483 483 + ArtistMBIDs: []string{"test-artist-mbid-1", "test-artist-mbid-2"}, 484 484 + ReleaseMBID: func() *string { s := "test-release-mbid"; return &s }(), 485 485 + DurationMs: func() *int64 { i := int64(240000); return &i }(), 486 486 + SpotifyID: func() *string { s := "test-spotify-id"; return &s }(), 487 487 + ISRC: func() *string { s := "TEST1234567"; return &s }(), 488 488 + }, 489 489 + }, 490 490 + } 491 491 + 492 492 + track := payload.ConvertToTrack(123) 493 493 + 494 494 + // Verify conversion 495 495 + if track.Name != "Test Track" { 496 496 + t.Errorf("Expected track name 'Test Track', got %s", track.Name) 497 497 + } 498 498 + if track.Album != "Test Album" { 499 499 + t.Errorf("Expected album 'Test Album', got %s", track.Album) 500 500 + } 501 501 + if track.RecordingMBID == nil || *track.RecordingMBID != "test-recording-mbid" { 502 502 + t.Errorf("Recording MBID not set correctly") 503 503 + } 504 504 + if track.ReleaseMBID == nil || *track.ReleaseMBID != "test-release-mbid" { 505 505 + t.Errorf("Release MBID not set correctly") 506 506 + } 507 507 + if track.DurationMs != 240000 { 508 508 + t.Errorf("Expected duration 240000ms, got %d", track.DurationMs) 509 509 + } 510 510 + if track.ISRC != "TEST1234567" { 511 511 + t.Errorf("Expected ISRC 'TEST1234567', got %s", track.ISRC) 512 512 + } 513 513 + if track.URL != "https://open.spotify.com/track/test-spotify-id" { 514 514 + t.Errorf("Expected Spotify URL to be constructed correctly, got %s", track.URL) 515 515 + } 516 516 + if track.ServiceBaseUrl != "spotify" { 517 517 + t.Errorf("Expected service 'spotify', got %s", track.ServiceBaseUrl) 518 518 + } 519 519 + 520 520 + expectedTime := time.Unix(1704067200, 0) 521 521 + if !track.Timestamp.Equal(expectedTime) { 522 522 + t.Errorf("Expected timestamp %v, got %v", expectedTime, track.Timestamp) 523 523 + } 524 524 + 525 525 + if !track.HasStamped { 526 526 + t.Error("Expected HasStamped to be true for external submissions") 527 527 + } 528 528 + 529 529 + // Check artists 530 530 + if len(track.Artist) != 2 { 531 531 + t.Errorf("Expected 2 artists, got %d", len(track.Artist)) 532 532 + } 533 533 + if track.Artist[0].MBID == nil || *track.Artist[0].MBID != "test-artist-mbid-1" { 534 534 + t.Errorf("First artist MBID not set correctly") 535 535 + } 536 536 + if track.Artist[1].MBID == nil || *track.Artist[1].MBID != "test-artist-mbid-2" { 537 537 + t.Errorf("Second artist MBID not set correctly") 538 538 + } 539 539 + }

+22 -17

cmd/main.go

··· 3 3 import ( 4 4 "encoding/json" 5 5 "fmt" 6 6 - "github.com/teal-fm/piper/service/lastfm" 7 6 "log" 8 7 "net/http" 9 8 "os" 10 9 "time" 10 10 + 11 11 + "github.com/teal-fm/piper/service/lastfm" 12 12 + "github.com/teal-fm/piper/service/playingnow" 11 13 12 14 "github.com/spf13/viper" 13 15 "github.com/teal-fm/piper/config" ··· 21 23 ) 22 24 23 25 type application struct { 24 24 - database *db.DB 25 25 - sessionManager *session.SessionManager 26 26 - oauthManager *oauth.OAuthServiceManager 27 27 - spotifyService *spotify.SpotifyService 28 28 - apiKeyService *apikeyService.Service 29 29 - mbService *musicbrainz.MusicBrainzService 30 30 - atprotoService *atproto.ATprotoAuthService 26 26 + database *db.DB 27 27 + sessionManager *session.SessionManager 28 28 + oauthManager *oauth.OAuthServiceManager 29 29 + spotifyService *spotify.SpotifyService 30 30 + apiKeyService *apikeyService.Service 31 31 + mbService *musicbrainz.MusicBrainzService 32 32 + atprotoService *atproto.ATprotoAuthService 33 33 + playingNowService *playingnow.PlayingNowService 31 34 } 32 35 33 36 // JSON API handlers ··· 73 76 } 74 77 75 78 mbService := musicbrainz.NewMusicBrainzService(database) 76 76 - spotifyService := spotify.NewSpotifyService(database, atprotoService, mbService) 77 77 - lastfmService := lastfm.NewLastFMService(database, viper.GetString("lastfm.api_key"), mbService, atprotoService) 79 79 + playingNowService := playingnow.NewPlayingNowService(database, atprotoService) 80 80 + spotifyService := spotify.NewSpotifyService(database, atprotoService, mbService, playingNowService) 81 81 + lastfmService := lastfm.NewLastFMService(database, viper.GetString("lastfm.api_key"), mbService, atprotoService, playingNowService) 78 82 79 83 sessionManager := session.NewSessionManager(database) 80 84 oauthManager := oauth.NewOAuthServiceManager(sessionManager) ··· 93 97 apiKeyService := apikeyService.NewAPIKeyService(database, sessionManager) 94 98 95 99 app := &application{ 96 96 - database: database, 97 97 - sessionManager: sessionManager, 98 98 - oauthManager: oauthManager, 99 99 - apiKeyService: apiKeyService, 100 100 - mbService: mbService, 101 101 - spotifyService: spotifyService, 102 102 - atprotoService: atprotoService, 100 100 + database: database, 101 101 + sessionManager: sessionManager, 102 102 + oauthManager: oauthManager, 103 103 + apiKeyService: apiKeyService, 104 104 + mbService: mbService, 105 105 + spotifyService: spotifyService, 106 106 + atprotoService: atprotoService, 107 107 + playingNowService: playingNowService, 103 108 } 104 109 105 110 trackerInterval := time.Duration(viper.GetInt("tracker.interval")) * time.Second

+3

cmd/routes.go

··· 36 36 mux.HandleFunc("/api/v1/history", session.WithAPIAuth(apiTrackHistory(app.spotifyService), app.sessionManager)) // Spotify History 37 37 mux.HandleFunc("/api/v1/musicbrainz/search", apiMusicBrainzSearch(app.mbService)) // MusicBrainz (public?) 38 38 39 39 + // ListenBrainz-compatible endpoint 40 40 + mux.HandleFunc("/1/submit-listens", session.WithAPIAuth(apiSubmitListensHandler(app.database), app.sessionManager)) 41 41 + 39 42 serverUrlRoot := viper.GetString("server.root_url") 40 43 atpClientId := viper.GetString("atproto.client_id") 41 44 atpCallbackUrl := viper.GetString("atproto.callback_url")

+122

models/listenbrainz.go

··· 1 1 + package models 2 2 + 3 3 + import "time" 4 4 + 5 5 + // ListenBrainzSubmission represents the top-level submission format 6 6 + type ListenBrainzSubmission struct { 7 7 + ListenType string `json:"listen_type"` 8 8 + Payload []ListenBrainzPayload `json:"payload"` 9 9 + } 10 10 + 11 11 + // ListenBrainzPayload represents individual listen data 12 12 + type ListenBrainzPayload struct { 13 13 + ListenedAt *int64 `json:"listened_at,omitempty"` 14 14 + TrackMetadata ListenBrainzTrackMetadata `json:"track_metadata"` 15 15 + } 16 16 + 17 17 + // ListenBrainzTrackMetadata contains the track information 18 18 + type ListenBrainzTrackMetadata struct { 19 19 + ArtistName string `json:"artist_name"` 20 20 + TrackName string `json:"track_name"` 21 21 + ReleaseName *string `json:"release_name,omitempty"` 22 22 + AdditionalInfo *ListenBrainzAdditionalInfo `json:"additional_info,omitempty"` 23 23 + } 24 24 + 25 25 + // ListenBrainzAdditionalInfo contains optional metadata 26 26 + type ListenBrainzAdditionalInfo struct { 27 27 + MediaPlayer *string `json:"media_player,omitempty"` 28 28 + SubmissionClient *string `json:"submission_client,omitempty"` 29 29 + SubmissionClientVersion *string `json:"submission_client_version,omitempty"` 30 30 + RecordingMBID *string `json:"recording_mbid,omitempty"` 31 31 + ArtistMBIDs []string `json:"artist_mbids,omitempty"` 32 32 + ReleaseMBID *string `json:"release_mbid,omitempty"` 33 33 + ReleaseGroupMBID *string `json:"release_group_mbid,omitempty"` 34 34 + TrackMBID *string `json:"track_mbid,omitempty"` 35 35 + WorkMBIDs []string `json:"work_mbids,omitempty"` 36 36 + Tags []string `json:"tags,omitempty"` 37 37 + DurationMs *int64 `json:"duration_ms,omitempty"` 38 38 + SpotifyID *string `json:"spotify_id,omitempty"` 39 39 + ISRC *string `json:"isrc,omitempty"` 40 40 + TrackNumber *int `json:"tracknumber,omitempty"` 41 41 + DiscNumber *int `json:"discnumber,omitempty"` 42 42 + MusicService *string `json:"music_service,omitempty"` 43 43 + MusicServiceName *string `json:"music_service_name,omitempty"` 44 44 + OriginURL *string `json:"origin_url,omitempty"` 45 45 + LastFMTrackURL *string `json:"lastfm_track_url,omitempty"` 46 46 + YoutubeID *string `json:"youtube_id,omitempty"` 47 47 + } 48 48 + 49 49 + // ConvertToTrack converts ListenBrainz format to internal Track format 50 50 + func (lbp *ListenBrainzPayload) ConvertToTrack(userID int64) Track { 51 51 + track := Track{ 52 52 + Name: lbp.TrackMetadata.TrackName, 53 53 + Artist: []Artist{{Name: lbp.TrackMetadata.ArtistName}}, 54 54 + } 55 55 + 56 56 + // Set timestamp 57 57 + if lbp.ListenedAt != nil { 58 58 + track.Timestamp = time.Unix(*lbp.ListenedAt, 0) 59 59 + } else { 60 60 + track.Timestamp = time.Now() 61 61 + } 62 62 + 63 63 + // Set album/release name 64 64 + if lbp.TrackMetadata.ReleaseName != nil { 65 65 + track.Album = *lbp.TrackMetadata.ReleaseName 66 66 + } 67 67 + 68 68 + // Handle additional info if present 69 69 + if info := lbp.TrackMetadata.AdditionalInfo; info != nil { 70 70 + // Set MBIDs 71 71 + if info.RecordingMBID != nil { 72 72 + track.RecordingMBID = info.RecordingMBID 73 73 + } 74 74 + if info.ReleaseMBID != nil { 75 75 + track.ReleaseMBID = info.ReleaseMBID 76 76 + } 77 77 + 78 78 + // Set duration 79 79 + if info.DurationMs != nil { 80 80 + track.DurationMs = *info.DurationMs 81 81 + } 82 82 + 83 83 + // Set ISRC 84 84 + if info.ISRC != nil { 85 85 + track.ISRC = *info.ISRC 86 86 + } 87 87 + 88 88 + // Handle multiple artists from MBIDs 89 89 + if len(info.ArtistMBIDs) > 0 { 90 90 + artists := make([]Artist, len(info.ArtistMBIDs)) 91 91 + for i, mbid := range info.ArtistMBIDs { 92 92 + artists[i] = Artist{ 93 93 + Name: lbp.TrackMetadata.ArtistName, // Use main artist name 94 94 + MBID: &mbid, 95 95 + } 96 96 + } 97 97 + track.Artist = artists 98 98 + } 99 99 + 100 100 + // Set service information 101 101 + if info.MusicService != nil { 102 102 + track.ServiceBaseUrl = *info.MusicService 103 103 + } 104 104 + if info.OriginURL != nil { 105 105 + track.URL = *info.OriginURL 106 106 + } 107 107 + if info.SpotifyID != nil { 108 108 + track.URL = "https://open.spotify.com/track/" + *info.SpotifyID 109 109 + track.ServiceBaseUrl = "spotify" 110 110 + } 111 111 + } 112 112 + 113 113 + // Default service if not set 114 114 + if track.ServiceBaseUrl == "" { 115 115 + track.ServiceBaseUrl = "listenbrainz" 116 116 + } 117 117 + 118 118 + // Mark as stamped since it came from external submission 119 119 + track.HasStamped = true 120 120 + 121 121 + return track 122 122 + }

+60 -1

service/lastfm/lastfm.go

··· 39 39 Usernames []string 40 40 musicBrainzService *musicbrainz.MusicBrainzService 41 41 atprotoService *atprotoauth.ATprotoAuthService 42 42 + playingNowService interface { 43 43 + PublishPlayingNow(ctx context.Context, userID int64, track *models.Track) error 44 44 + ClearPlayingNow(ctx context.Context, userID int64) error 45 45 + } 42 46 lastSeenNowPlaying map[string]Track 43 47 mu sync.Mutex 44 48 logger *log.Logger 45 49 } 46 50 47 47 - func NewLastFMService(db *db.DB, apiKey string, musicBrainzService *musicbrainz.MusicBrainzService, atprotoService *atprotoauth.ATprotoAuthService) *LastFMService { 51 51 + func NewLastFMService(db *db.DB, apiKey string, musicBrainzService *musicbrainz.MusicBrainzService, atprotoService *atprotoauth.ATprotoAuthService, playingNowService interface { 52 52 + PublishPlayingNow(ctx context.Context, userID int64, track *models.Track) error 53 53 + ClearPlayingNow(ctx context.Context, userID int64) error 54 54 + }) *LastFMService { 48 55 logger := log.New(os.Stdout, "lastfm: ", log.LstdFlags|log.Lmsgprefix) 49 56 50 57 return &LastFMService{ ··· 58 65 Usernames: make([]string, 0), 59 66 atprotoService: atprotoService, 60 67 musicBrainzService: musicBrainzService, 68 68 + playingNowService: playingNowService, 61 69 lastSeenNowPlaying: make(map[string]Track), 62 70 mu: sync.Mutex{}, 63 71 logger: logger, ··· 303 311 l.logger.Printf("current track does not match last seen track for %s", username) 304 312 // aha! we record this! 305 313 l.lastSeenNowPlaying[username] = nowPlayingTrack 314 314 + 315 315 + // Publish playing now status 316 316 + if l.playingNowService != nil { 317 317 + // Convert Last.fm track to models.Track format 318 318 + piperTrack := l.convertLastFMTrackToModelsTrack(nowPlayingTrack) 319 319 + if err := l.playingNowService.PublishPlayingNow(ctx, user.ID, piperTrack); err != nil { 320 320 + l.logger.Printf("Error publishing playing now for user %s: %v", username, err) 321 321 + } 322 322 + } 306 323 } 307 324 l.mu.Unlock() 325 325 + } else { 326 326 + // No now playing track - clear playing now status 327 327 + if l.playingNowService != nil { 328 328 + if err := l.playingNowService.ClearPlayingNow(ctx, user.ID); err != nil { 329 329 + l.logger.Printf("Error clearing playing now for user %s: %v", username, err) 330 330 + } 331 331 + } 308 332 } 309 333 310 334 // find last non-now-playing track ··· 467 491 468 492 return nil 469 493 } 494 494 + 495 495 + // convertLastFMTrackToModelsTrack converts a Last.fm Track to models.Track format 496 496 + func (l *LastFMService) convertLastFMTrackToModelsTrack(track Track) *models.Track { 497 497 + // Create artist array 498 498 + artists := []models.Artist{ 499 499 + { 500 500 + Name: track.Artist.Text, 501 501 + // Note: Last.fm doesn't provide MBID in now playing, would need separate lookup 502 502 + }, 503 503 + } 504 504 + 505 505 + // Set timestamp to current time for now playing 506 506 + timestamp := time.Now() 507 507 + 508 508 + piperTrack := &models.Track{ 509 509 + Name: track.Name, 510 510 + Artist: artists, 511 511 + Album: track.Album.Text, // Album is a struct with Text field 512 512 + Timestamp: timestamp, 513 513 + ServiceBaseUrl: "lastfm", 514 514 + HasStamped: false, // Playing now tracks aren't stamped yet 515 515 + } 516 516 + 517 517 + // Add URL if available 518 518 + if track.URL != "" { 519 519 + piperTrack.URL = track.URL 520 520 + } 521 521 + 522 522 + // Try to extract MBID if available (Last.fm sometimes provides this) 523 523 + if track.MBID != "" { // MBID is capitalized 524 524 + piperTrack.RecordingMBID = &track.MBID 525 525 + } 526 526 + 527 527 + return piperTrack 528 528 + }

+286

service/playingnow/playingnow.go

··· 1 1 + package playingnow 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "fmt" 6 6 + "log" 7 7 + "os" 8 8 + "strconv" 9 9 + "time" 10 10 + 11 11 + "github.com/bluesky-social/indigo/api/atproto" 12 12 + lexutil "github.com/bluesky-social/indigo/lex/util" 13 13 + "github.com/bluesky-social/indigo/xrpc" 14 14 + oauth "github.com/haileyok/atproto-oauth-golang" 15 15 + "github.com/spf13/viper" 16 16 + "github.com/teal-fm/piper/api/teal" 17 17 + "github.com/teal-fm/piper/db" 18 18 + "github.com/teal-fm/piper/models" 19 19 + atprotoauth "github.com/teal-fm/piper/oauth/atproto" 20 20 + ) 21 21 + 22 22 + // PlayingNowService handles publishing current playing status to ATProto 23 23 + type PlayingNowService struct { 24 24 + db *db.DB 25 25 + atprotoService *atprotoauth.ATprotoAuthService 26 26 + logger *log.Logger 27 27 + } 28 28 + 29 29 + // NewPlayingNowService creates a new playing now service 30 30 + func NewPlayingNowService(database *db.DB, atprotoService *atprotoauth.ATprotoAuthService) *PlayingNowService { 31 31 + logger := log.New(os.Stdout, "playingnow: ", log.LstdFlags|log.Lmsgprefix) 32 32 + 33 33 + return &PlayingNowService{ 34 34 + db: database, 35 35 + atprotoService: atprotoService, 36 36 + logger: logger, 37 37 + } 38 38 + } 39 39 + 40 40 + // PublishPlayingNow publishes a currently playing track as actor status 41 41 + func (p *PlayingNowService) PublishPlayingNow(ctx context.Context, userID int64, track *models.Track) error { 42 42 + // Get user information to find their DID 43 43 + user, err := p.db.GetUserByID(userID) 44 44 + if err != nil { 45 45 + return fmt.Errorf("failed to get user: %w", err) 46 46 + } 47 47 + 48 48 + if user.ATProtoDID == nil { 49 49 + p.logger.Printf("User %d has no ATProto DID, skipping playing now", userID) 50 50 + return nil 51 51 + } 52 52 + 53 53 + did := *user.ATProtoDID 54 54 + 55 55 + // Get ATProto client 56 56 + client, err := p.atprotoService.GetATProtoClient() 57 57 + if err != nil || client == nil { 58 58 + return fmt.Errorf("failed to get ATProto client: %w", err) 59 59 + } 60 60 + 61 61 + xrpcClient := p.atprotoService.GetXrpcClient() 62 62 + if xrpcClient == nil { 63 63 + return fmt.Errorf("xrpc client is not available") 64 64 + } 65 65 + 66 66 + // Get user session 67 67 + sess, err := p.db.GetAtprotoSession(did, ctx, *client) 68 68 + if err != nil { 69 69 + return fmt.Errorf("couldn't get Atproto session for DID %s: %w", did, err) 70 70 + } 71 71 + 72 72 + // Convert track to PlayView format 73 73 + playView, err := p.trackToPlayView(track) 74 74 + if err != nil { 75 75 + return fmt.Errorf("failed to convert track to PlayView: %w", err) 76 76 + } 77 77 + 78 78 + // Create actor status record 79 79 + now := time.Now() 80 80 + expiry := now.Add(10 * time.Minute) // Default 10 minutes as mentioned in schema 81 81 + 82 82 + status := &teal.AlphaActorStatus{ 83 83 + LexiconTypeID: "fm.teal.alpha.actor.status", 84 84 + Time: strconv.FormatInt(now.Unix(), 10), 85 85 + Expiry: func() *string { s := strconv.FormatInt(expiry.Unix(), 10); return &s }(), 86 86 + Item: playView, 87 87 + } 88 88 + 89 89 + var swapRecord *string 90 90 + authArgs := db.AtpSessionToAuthArgs(sess) 91 91 + 92 92 + swapRecord, err = p.getStatusSwapRecord(ctx, xrpcClient, sess, authArgs) 93 93 + if err != nil { 94 94 + return err 95 95 + } 96 96 + 97 97 + // Create the record input 98 98 + input := atproto.RepoPutRecord_Input{ 99 99 + Collection: "fm.teal.alpha.actor.status", 100 100 + Repo: sess.DID, 101 101 + Rkey: "self", // Use "self" as the record key for current status 102 102 + Record: &lexutil.LexiconTypeDecoder{Val: status}, 103 103 + SwapRecord: swapRecord, 104 104 + } 105 105 + 106 106 + // Submit to PDS 107 107 + var out atproto.RepoPutRecord_Output 108 108 + if err := xrpcClient.Do(ctx, authArgs, xrpc.Procedure, "application/json", "com.atproto.repo.putRecord", nil, input, &out); err != nil { 109 109 + p.logger.Printf("Error creating playing now status for DID %s: %v", did, err) 110 110 + return fmt.Errorf("failed to create playing now status for DID %s: %w", did, err) 111 111 + } 112 112 + 113 113 + p.logger.Printf("Successfully published playing now status for user %d (DID: %s): %s - %s", 114 114 + userID, did, track.Artist[0].Name, track.Name) 115 115 + 116 116 + return nil 117 117 + } 118 118 + 119 119 + // ClearPlayingNow removes the current playing status by setting an expired status 120 120 + func (p *PlayingNowService) ClearPlayingNow(ctx context.Context, userID int64) error { 121 121 + // Get user information 122 122 + user, err := p.db.GetUserByID(userID) 123 123 + if err != nil { 124 124 + return fmt.Errorf("failed to get user: %w", err) 125 125 + } 126 126 + 127 127 + if user.ATProtoDID == nil { 128 128 + p.logger.Printf("User %d has no ATProto DID, skipping clear playing now", userID) 129 129 + return nil 130 130 + } 131 131 + 132 132 + did := *user.ATProtoDID 133 133 + 134 134 + // Get ATProto clients 135 135 + client, err := p.atprotoService.GetATProtoClient() 136 136 + if err != nil || client == nil { 137 137 + return fmt.Errorf("failed to get ATProto client: %w", err) 138 138 + } 139 139 + 140 140 + xrpcClient := p.atprotoService.GetXrpcClient() 141 141 + if xrpcClient == nil { 142 142 + return fmt.Errorf("xrpc client is not available") 143 143 + } 144 144 + 145 145 + // Get user session 146 146 + sess, err := p.db.GetAtprotoSession(did, ctx, *client) 147 147 + if err != nil { 148 148 + return fmt.Errorf("couldn't get Atproto session for DID %s: %w", did, err) 149 149 + } 150 150 + 151 151 + // Create an expired status (essentially clearing it) 152 152 + now := time.Now() 153 153 + expiredTime := now.Add(-1 * time.Minute) // Set expiry to 1 minute ago 154 154 + 155 155 + // Create empty play view 156 156 + emptyPlayView := &teal.AlphaFeedDefs_PlayView{ 157 157 + TrackName: "", // Empty track indicates no current playing 158 158 + Artists: []*teal.AlphaFeedDefs_Artist{}, 159 159 + } 160 160 + 161 161 + status := &teal.AlphaActorStatus{ 162 162 + LexiconTypeID: "fm.teal.alpha.actor.status", 163 163 + Time: strconv.FormatInt(now.Unix(), 10), 164 164 + Expiry: func() *string { s := strconv.FormatInt(expiredTime.Unix(), 10); return &s }(), 165 165 + Item: emptyPlayView, 166 166 + } 167 167 + 168 168 + authArgs := db.AtpSessionToAuthArgs(sess) 169 169 + 170 170 + var swapRecord *string 171 171 + swapRecord, err = p.getStatusSwapRecord(ctx, xrpcClient, sess, authArgs) 172 172 + if err != nil { 173 173 + return err 174 174 + } 175 175 + 176 176 + // Update the record 177 177 + input := atproto.RepoPutRecord_Input{ 178 178 + Collection: "fm.teal.alpha.actor.status", 179 179 + Repo: sess.DID, 180 180 + Rkey: "self", 181 181 + Record: &lexutil.LexiconTypeDecoder{Val: status}, 182 182 + SwapRecord: swapRecord, 183 183 + } 184 184 + 185 185 + var out atproto.RepoPutRecord_Output 186 186 + if err := xrpcClient.Do(ctx, authArgs, xrpc.Procedure, "application/json", "com.atproto.repo.putRecord", nil, input, &out); err != nil { 187 187 + p.logger.Printf("Error clearing playing now status for DID %s: %v", did, err) 188 188 + return fmt.Errorf("failed to clear playing now status for DID %s: %w", did, err) 189 189 + } 190 190 + 191 191 + p.logger.Printf("Successfully cleared playing now status for user %d (DID: %s)", userID, did) 192 192 + return nil 193 193 + } 194 194 + 195 195 + // trackToPlayView converts a models.Track to teal.AlphaFeedDefs_PlayView 196 196 + func (p *PlayingNowService) trackToPlayView(track *models.Track) (*teal.AlphaFeedDefs_PlayView, error) { 197 197 + if track.Name == "" { 198 198 + return nil, fmt.Errorf("track name cannot be empty") 199 199 + } 200 200 + 201 201 + // Convert artists 202 202 + artists := make([]*teal.AlphaFeedDefs_Artist, 0, len(track.Artist)) 203 203 + for _, a := range track.Artist { 204 204 + artist := &teal.AlphaFeedDefs_Artist{ 205 205 + ArtistName: a.Name, 206 206 + ArtistMbId: a.MBID, 207 207 + } 208 208 + artists = append(artists, artist) 209 209 + } 210 210 + 211 211 + // Prepare optional fields 212 212 + var durationPtr *int64 213 213 + if track.DurationMs > 0 { 214 214 + durationSeconds := track.DurationMs / 1000 215 215 + durationPtr = &durationSeconds 216 216 + } 217 217 + 218 218 + var playedTimeStr *string 219 219 + if !track.Timestamp.IsZero() { 220 220 + timeStr := track.Timestamp.Format(time.RFC3339) 221 221 + playedTimeStr = &timeStr 222 222 + } 223 223 + 224 224 + var isrcPtr *string 225 225 + if track.ISRC != "" { 226 226 + isrcPtr = &track.ISRC 227 227 + } 228 228 + 229 229 + var originUrlPtr *string 230 230 + if track.URL != "" { 231 231 + originUrlPtr = &track.URL 232 232 + } 233 233 + 234 234 + var servicePtr *string 235 235 + if track.ServiceBaseUrl != "" { 236 236 + servicePtr = &track.ServiceBaseUrl 237 237 + } 238 238 + 239 239 + var releaseNamePtr *string 240 240 + if track.Album != "" { 241 241 + releaseNamePtr = &track.Album 242 242 + } 243 243 + 244 244 + // Get submission client agent 245 245 + submissionAgent := viper.GetString("app.submission_agent") 246 246 + if submissionAgent == "" { 247 247 + submissionAgent = "piper/v0.0.1" 248 248 + } 249 249 + 250 250 + playView := &teal.AlphaFeedDefs_PlayView{ 251 251 + TrackName: track.Name, 252 252 + Artists: artists, 253 253 + Duration: durationPtr, 254 254 + PlayedTime: playedTimeStr, 255 255 + RecordingMbId: track.RecordingMBID, 256 256 + ReleaseMbId: track.ReleaseMBID, 257 257 + ReleaseName: releaseNamePtr, 258 258 + Isrc: isrcPtr, 259 259 + OriginUrl: originUrlPtr, 260 260 + MusicServiceBaseDomain: servicePtr, 261 261 + SubmissionClientAgent: &submissionAgent, 262 262 + } 263 263 + 264 264 + return playView, nil 265 265 + } 266 266 + 267 267 + // getStatusSwapRecord retrieves the current swap record (CID) for the actor status record. 268 268 + // Returns (nil, nil) if the record does not exist yet. 269 269 + func (p *PlayingNowService) getStatusSwapRecord(ctx context.Context, xrpcClient *oauth.XrpcClient, sess *models.ATprotoAuthSession, authArgs *oauth.XrpcAuthedRequestArgs) (*string, error) { 270 270 + getOutput := atproto.RepoGetRecord_Output{} 271 271 + if err := xrpcClient.Do(ctx, authArgs, xrpc.Query, "application/json", "com.atproto.repo.getRecord", map[string]any{ 272 272 + "repo": sess.DID, 273 273 + "collection": "fm.teal.alpha.actor.status", 274 274 + "rkey": "self", 275 275 + }, nil, &getOutput); err != nil { 276 276 + xErr, ok := err.(*xrpc.Error) 277 277 + if !ok { 278 278 + return nil, fmt.Errorf("could not get record: %w", err) 279 279 + } 280 280 + if xErr.StatusCode != 400 { // 400 means not found in this API 281 281 + return nil, fmt.Errorf("could not get record: %w", err) 282 282 + } 283 283 + return nil, nil 284 284 + } 285 285 + return getOutput.Cid, nil 286 286 + }

+144

service/playingnow/playingnow_test.go

··· 1 1 + package playingnow 2 2 + 3 3 + import ( 4 4 + "testing" 5 5 + "time" 6 6 + 7 7 + "github.com/teal-fm/piper/db" 8 8 + "github.com/teal-fm/piper/models" 9 9 + ) 10 10 + 11 11 + func TestTrackToPlayView(t *testing.T) { 12 12 + // Create a mock playing now service (we'll test the conversion logic) 13 13 + database, err := db.New(":memory:") 14 14 + if err != nil { 15 15 + t.Fatalf("Failed to create test database: %v", err) 16 16 + } 17 17 + defer database.Close() 18 18 + 19 19 + if err := database.Initialize(); err != nil { 20 20 + t.Fatalf("Failed to initialize test database: %v", err) 21 21 + } 22 22 + 23 23 + // Mock ATProto service (we'll just test the conversion, not the actual submission) 24 24 + service := &PlayingNowService{ 25 25 + db: database, 26 26 + logger: nil, // We'll skip logging in tests 27 27 + } 28 28 + 29 29 + // Create a test track 30 30 + track := &models.Track{ 31 31 + Name: "Test Track", 32 32 + Artist: []models.Artist{ 33 33 + { 34 34 + Name: "Test Artist", 35 35 + MBID: func() *string { s := "test-artist-mbid"; return &s }(), 36 36 + }, 37 37 + }, 38 38 + Album: "Test Album", 39 39 + DurationMs: 240000, // 4 minutes 40 40 + Timestamp: time.Now(), 41 41 + ServiceBaseUrl: "spotify", 42 42 + URL: "https://open.spotify.com/track/test", 43 43 + RecordingMBID: func() *string { s := "test-recording-mbid"; return &s }(), 44 44 + ReleaseMBID: func() *string { s := "test-release-mbid"; return &s }(), 45 45 + ISRC: "TEST1234567", 46 46 + } 47 47 + 48 48 + // Test the conversion 49 49 + playView, err := service.trackToPlayView(track) 50 50 + if err != nil { 51 51 + t.Fatalf("Failed to convert track to PlayView: %v", err) 52 52 + } 53 53 + 54 54 + // Verify the conversion 55 55 + if playView.TrackName != "Test Track" { 56 56 + t.Errorf("Expected track name 'Test Track', got %s", playView.TrackName) 57 57 + } 58 58 + 59 59 + if len(playView.Artists) != 1 { 60 60 + t.Errorf("Expected 1 artist, got %d", len(playView.Artists)) 61 61 + } else { 62 62 + if playView.Artists[0].ArtistName != "Test Artist" { 63 63 + t.Errorf("Expected artist name 'Test Artist', got %s", playView.Artists[0].ArtistName) 64 64 + } 65 65 + if playView.Artists[0].ArtistMbId == nil || *playView.Artists[0].ArtistMbId != "test-artist-mbid" { 66 66 + t.Errorf("Artist MBID not set correctly") 67 67 + } 68 68 + } 69 69 + 70 70 + if playView.ReleaseName == nil || *playView.ReleaseName != "Test Album" { 71 71 + t.Errorf("Release name not set correctly") 72 72 + } 73 73 + 74 74 + if playView.Duration == nil || *playView.Duration != 240 { 75 75 + t.Errorf("Expected duration 240 seconds, got %v", playView.Duration) 76 76 + } 77 77 + 78 78 + if playView.RecordingMbId == nil || *playView.RecordingMbId != "test-recording-mbid" { 79 79 + t.Errorf("Recording MBID not set correctly") 80 80 + } 81 81 + 82 82 + if playView.ReleaseMbId == nil || *playView.ReleaseMbId != "test-release-mbid" { 83 83 + t.Errorf("Release MBID not set correctly") 84 84 + } 85 85 + 86 86 + if playView.Isrc == nil || *playView.Isrc != "TEST1234567" { 87 87 + t.Errorf("ISRC not set correctly") 88 88 + } 89 89 + 90 90 + if playView.OriginUrl == nil || *playView.OriginUrl != "https://open.spotify.com/track/test" { 91 91 + t.Errorf("Origin URL not set correctly") 92 92 + } 93 93 + 94 94 + if playView.MusicServiceBaseDomain == nil || *playView.MusicServiceBaseDomain != "spotify" { 95 95 + t.Errorf("Music service not set correctly") 96 96 + } 97 97 + } 98 98 + 99 99 + func TestTrackToPlayViewEmptyTrack(t *testing.T) { 100 100 + service := &PlayingNowService{} 101 101 + 102 102 + // Test with empty track name (should fail) 103 103 + track := &models.Track{ 104 104 + Name: "", // Empty name should cause error 105 105 + Artist: []models.Artist{{Name: "Test Artist"}}, 106 106 + } 107 107 + 108 108 + _, err := service.trackToPlayView(track) 109 109 + if err == nil { 110 110 + t.Error("Expected error for empty track name, got nil") 111 111 + } 112 112 + } 113 113 + 114 114 + func TestTrackToPlayViewMinimal(t *testing.T) { 115 115 + service := &PlayingNowService{} 116 116 + 117 117 + // Test with minimal track data 118 118 + track := &models.Track{ 119 119 + Name: "Minimal Track", 120 120 + Artist: []models.Artist{{Name: "Minimal Artist"}}, 121 121 + } 122 122 + 123 123 + playView, err := service.trackToPlayView(track) 124 124 + if err != nil { 125 125 + t.Fatalf("Failed to convert minimal track: %v", err) 126 126 + } 127 127 + 128 128 + if playView.TrackName != "Minimal Track" { 129 129 + t.Errorf("Expected track name 'Minimal Track', got %s", playView.TrackName) 130 130 + } 131 131 + 132 132 + if len(playView.Artists) != 1 || playView.Artists[0].ArtistName != "Minimal Artist" { 133 133 + t.Errorf("Artist not set correctly") 134 134 + } 135 135 + 136 136 + // Optional fields should be nil for minimal track 137 137 + if playView.Duration != nil { 138 138 + t.Errorf("Expected duration to be nil for minimal track") 139 139 + } 140 140 + 141 141 + if playView.ReleaseName != nil { 142 142 + t.Errorf("Expected release name to be nil for minimal track") 143 143 + } 144 144 + }

+62 -19

service/spotify/spotify.go

··· 29 29 ) 30 30 31 31 type SpotifyService struct { 32 32 - DB *db.DB 33 33 - atprotoService *atprotoauth.ATprotoAuthService // Added field 34 34 - mb *musicbrainz.MusicBrainzService // Added field 35 35 - userTracks map[int64]*models.Track 36 36 - userTokens map[int64]string 37 37 - mu sync.RWMutex 38 38 - logger *log.Logger 32 32 + DB *db.DB 33 33 + atprotoService *atprotoauth.ATprotoAuthService // Added field 34 34 + mb *musicbrainz.MusicBrainzService // Added field 35 35 + playingNowService interface { 36 36 + PublishPlayingNow(ctx context.Context, userID int64, track *models.Track) error 37 37 + ClearPlayingNow(ctx context.Context, userID int64) error 38 38 + } // Added field for playing now service 39 39 + userTracks map[int64]*models.Track 40 40 + userTokens map[int64]string 41 41 + mu sync.RWMutex 42 42 + logger *log.Logger 39 43 } 40 44 41 41 - func NewSpotifyService(database *db.DB, atprotoService *atprotoauth.ATprotoAuthService, musicBrainzService *musicbrainz.MusicBrainzService) *SpotifyService { 45 45 + func NewSpotifyService(database *db.DB, atprotoService *atprotoauth.ATprotoAuthService, musicBrainzService *musicbrainz.MusicBrainzService, playingNowService interface { 46 46 + PublishPlayingNow(ctx context.Context, userID int64, track *models.Track) error 47 47 + ClearPlayingNow(ctx context.Context, userID int64) error 48 48 + }) *SpotifyService { 42 49 logger := log.New(os.Stdout, "spotify: ", log.LstdFlags|log.Lmsgprefix) 43 50 44 51 return &SpotifyService{ 45 45 - DB: database, 46 46 - atprotoService: atprotoService, 47 47 - mb: musicBrainzService, 48 48 - userTracks: make(map[int64]*models.Track), 49 49 - userTokens: make(map[int64]string), 50 50 - logger: logger, 52 52 + DB: database, 53 53 + atprotoService: atprotoService, 54 54 + mb: musicBrainzService, 55 55 + playingNowService: playingNowService, 56 56 + userTracks: make(map[int64]*models.Track), 57 57 + userTokens: make(map[int64]string), 58 58 + logger: logger, 51 59 } 52 60 } 53 61 ··· 530 538 } `json:"external_urls"` 531 539 DurationMs int `json:"duration_ms"` 532 540 } `json:"item"` 533 533 - ProgressMS int `json:"progress_ms"` 541 541 + ProgressMS int `json:"progress_ms"` 542 542 + IsPlaying bool `json:"is_playing"` 534 543 } 535 544 536 545 err = json.Unmarshal(bodyBytes, &response) // Use bodyBytes here 537 546 if err != nil { 538 547 return nil, fmt.Errorf("failed to unmarshal spotify response: %w", err) 539 548 } 540 540 - 549 549 + if response.IsPlaying == false { 550 550 + return nil, nil 551 551 + } 541 552 var artists []models.Artist 542 553 for _, artist := range response.Item.Artists { 543 554 artists = append(artists, models.Artist{ ··· 585 596 } 586 597 587 598 if track == nil { 599 599 + // No track currently playing - clear playing now status 600 600 + if s.playingNowService != nil { 601 601 + if err := s.playingNowService.ClearPlayingNow(ctx, userID); err != nil { 602 602 + s.logger.Printf("Error clearing playing now for user %d: %v", userID, err) 603 603 + } 604 604 + } 588 605 continue 589 606 } 590 607 ··· 614 631 615 632 // just log when we stamp tracks 616 633 if isNewTrack && isLastTrackStamped && !currentTrack.HasStamped { 617 617 - s.logger.Printf("User %d stamped (previous) track: %s by %s", userID, currentTrack.Name, currentTrack.Artist) 634 634 + artistName := "Unknown Artist" 635 635 + if len(currentTrack.Artist) > 0 { 636 636 + artistName = currentTrack.Artist[0].Name 637 637 + } 638 638 + s.logger.Printf("User %d stamped (previous) track: %s by %s", userID, currentTrack.Name, artistName) 618 639 currentTrack.HasStamped = true 619 640 if currentTrack.PlayID != 0 { 620 641 s.DB.UpdateTrack(currentTrack.PlayID, currentTrack) ··· 624 645 } 625 646 626 647 if isStamped && currentTrack != nil && !currentTrack.HasStamped { 627 627 - s.logger.Printf("User %d stamped track: %s by %s", userID, track.Name, track.Artist) 648 648 + artistName := "Unknown Artist" 649 649 + if len(track.Artist) > 0 { 650 650 + artistName = track.Artist[0].Name 651 651 + } 652 652 + s.logger.Printf("User %d stamped track: %s by %s", userID, track.Name, artistName) 628 653 track.HasStamped = true 629 654 // if currenttrack has a playid and the last track is the same as the current track 630 655 if !isNewTrack && currentTrack.PlayID != 0 { ··· 635 660 s.userTracks[userID] = track 636 661 s.mu.Unlock() 637 662 663 663 + // Update playing now status since track progress changed 664 664 + if s.playingNowService != nil { 665 665 + if err := s.playingNowService.PublishPlayingNow(ctx, userID, track); err != nil { 666 666 + s.logger.Printf("Error updating playing now for user %d: %v", userID, err) 667 667 + } 668 668 + } 669 669 + 638 670 s.logger.Printf("Updated!") 639 671 } 640 672 } ··· 652 684 s.userTracks[userID] = track 653 685 s.mu.Unlock() 654 686 687 687 + // Publish playing now status 688 688 + if s.playingNowService != nil { 689 689 + if err := s.playingNowService.PublishPlayingNow(ctx, userID, track); err != nil { 690 690 + s.logger.Printf("Error publishing playing now for user %d: %v", userID, err) 691 691 + } 692 692 + } 693 693 + 655 694 // Submit to ATProto PDS 656 695 // The 'track' variable is *models.Track and has been saved to DB, PlayID is populated. 657 696 dbUser, errUser := s.DB.GetUserByID(userID) // Fetch user by their internal ID ··· 693 732 } 694 733 // End of PDS submission block 695 734 696 696 - s.logger.Printf("User %d is listening to: %s by %s", userID, track.Name, track.Artist) 735 735 + artistName := "Unknown Artist" 736 736 + if len(track.Artist) > 0 { 737 737 + artistName = track.Artist[0].Name 738 738 + } 739 739 + s.logger.Printf("User %d is listening to: %s by %s", userID, track.Name, artistName) 697 740 } 698 741 } 699 742 }