[release] Bump to version 52.2

- Fix bug in recomputing long play seconds taking forever

PROJECT.org

@@ -88,8 +88,8 @@ fetching and simple saving.
 *** Metadata sources
 **** Scraper
 
-* Backlog [0/15] :vrobbler:project:personal:
-** TODO [#C] Create small utility to clean up tracks scrobbled with wonky playback times :vrobbler:personal:bug:music:scrobbles:
+* Backlog [0/20] :vrobbler:project:personal:
+** TODO [#C] Create small utility to clean up tracks scrobbled with wonky playback times :bug:music:scrobbles:
 :PROPERTIES:
 :ID:       702462cf-d54b-48c6-8a7c-78b8de751deb
 :END:
@@ -387,11 +387,11 @@ fetching and simple saving.
     }
 }
 #+end_src
-** TODO [#C] User should be able to enable auto trail tracking via  amail reader with Garmin LiveTrack URLs :vrobbler:trails:project:feature:personal:
+** TODO [#C] Allow auto trail tracking via email with Garmin LiveTrack URLs :trails:feature:
 :PROPERTIES:
 :ID:       133bcf71-078f-4efa-a029-1eae4b4d146d
 :END:
-** TODO [#C] Fix exporting so it works reliably :exporting:project:feature:
+** TODO [#C] Fix exporting so it works reliably :exporting:feature:
 
 *** Description
 
@@ -405,8 +405,7 @@ placed in the media directory:
 And this should all be done in a celery task that is just kicked off by the
 "Export" button on the frontend
 
-
-** TODO [#B] Add AllTrails as a source for Trail data :vrobbler:trails:feature:personal:project:
+** TODO [#B] Add AllTrails as a source for Trail data :trails:feature:
 :PROPERTIES:
 :ID:       39313362-cdfe-46e7-bbd4-9139a65c0b3c
 :END:
@@ -416,7 +415,7 @@ Pretty clear, I would love to make trails more useful. Historically I wasn't
 hiking a lot, which made the source for this a bit silly. But it's clear that
 AllTrails is the best source, though having TrailForks is nice to.
 
-** TODO [#B] Add `garmin_activity_id` to the TrailLogData class :trails:feature:personal:project:
+** TODO [#B] Add `garmin_activity_id` to the TrailLogData class :trails:feature:
 :PROPERTIES:
 :ID:       5a4fb0f8-0555-40ec-b06f-93c26bd686f4
 :END:
@@ -440,18 +439,297 @@ added.
 They should also probably support markdown formatting and that should be
 displayed in the template.
 
-** TODO [#B] Add CSV endpoint for book scrobbles that LibraryThing can ingest :personal:project:books:feature:export:
+** TODO [#B] Add CSV endpoint for book scrobbles that LibraryThing can ingest :books:feature:export:
 https://app.todoist.com/app/task/add-a-csv-endpoint-for-users-book-reads-that-library-thing-can-ingest-6X7QPMRp265xMXqg#comment-6X7QrXq6gJjMP4hg
-** TODO [#B] Scrape ComicBookRoundUp ratings for comic book metadata :vrobbler:books:feature:comicbook:personal:project:
+** TODO [#B] Make IMAP and WebDAV configurable :webdav:feature:imap:importers:
+:PROPERTIES:
+:ID:       b1426d92-2feb-4d15-9738-d5b7b0594f96
+:END:
 
-- Note taken on [2025-09-25 Thu 10:51]
+*** Description
+
+Currently we have webdav able to import post types of file-based incoming data,
+usually in the form of CSVs but also gpx files, bgstats json files, and
+audioscrobbler TSV files.
+
+What if the user could specify via their profile (settings) which imports they
+wanted to use IMAP for and which ones they wanted to use WebDAV for.
+
+Then we'd have two celery tasks that would be kicked off periodically via
+celerybeat, one for IMAP imports every 12 minutes and one for WebDAV every 3
+minutes. Both would be responsible for checking if a user has an configured
+imports of their type, check if an import needs to run, and dispatch the
+needed import celery task. This is how the WebDAV celery task currently works.
+
+This would also be an opporunity to clean up the code around WebDAV imports
+and make them more re-usable for other import services.
+
+** TODO [#A] Add an exception list of artists as a constant that are exempted from splitting :music:artists:metadata:
+:PROPERTIES:
+:ID:       fd86a11a-73ec-470d-b5e3-2d90ba9137c8
+:END:
+
+*** Description
+
+Certain artists like "Simon & Garfunkel" are actually one artist. While we don't want to mess with splitting up
+tracks into featured artists, we should have a "LITERAL_ARTIST_TITLES" constant that can have exceptions like
+this put into it and then we stop trying to pull the artist apart when we run into it.
+
+** TODO [#A] Before enriching anything, trust the POST data :feature:scrobbles:metadata:
+:PROPERTIES:
+:ID:       db6b05f8-09f4-49f5-9838-fbacc9fe9cd0
+:END:
+
+*** Description
+
+Both Jellyfin and Mopidy provide a decent amount of metadata when they POST to our webhooks.
+
+In most cases, we should be able to trust this data to created music tracks or videos rather
+than going to third-party services to enrich. Thus, for tracks and videos we should search in
+the local database for imdb_id or musicbrainz_id for the specific content and, if found, not
+enrich further.
+
+If not found, tracks and videos from mopidy and jellyfin should be created as completely as
+possible using only the POST data from the webhooks, tagged the scrobble with "webhook-metadata-only"
+and start the scrobble. A separate celery task should be kicked off to enrich the track or video
+async with the POST data stored in the log["raw_data"] and used by the celery enrichment task
+to go try to enrich the media instance.  Should this enrichment fail, tag the scrobble as "enrichment-failed"
+log a warning and move on.
+
+** TODO [#B] Allow browing a user's favorited media :favorites:feature:
+:PROPERTIES:
+:ID:       5c2cf004-d01f-4576-9bbb-974235e7408a
+:END:
+
+*** Description
+
+We should have a global view `/favorites/` that shows the logged in users's
+favorited media objects.
 
-  As an example https://comicbookroundup.com/comic-books/reviews/humanoids-publishing/the-history-of-science-fiction
 ** TODO [#B] Find page numbers for comic books from ComicVine :feature:books:
 :PROPERTIES:
 :ID:       79f867c3-1288-4143-b6bf-2a452983ee9f
 :END:
-** TODO [#B] Fix koreader scrobble imports to use DST properly :bug:books:imports:
+** TODO [#C] Implement loguru into project :feature:loguru:logging:
+:PROPERTIES:
+:ID:       efcd0c0a-db81-4518-9c23-5505d59e8ef5
+:END:
+
+*** Description
+
+Would be great to formalize how we log so we can search for errors and such more
+easily. And our exposure to PII is really low at this point in the project,
+so we can probably use backtrace=True and diagnose=True to help us root cause
+bugs faster.
+
+** TODO [#B] Add a /trends/ page that shows trends based on scrobble data :feature:trends:scrobbles:
+
+*** Description
+
+This project is a bit invovled. But we should add a top level URL `trends` that shows
+various trends as defined either in a static settings file, or dynamically via a database table.
+
+Examples of trends:
+
+- How often does the user:
+  + watch sports while doing a task?
+  + do a task while watching a video?
+  * how often do I do 
+  
+- trail_scrobble__average_heartrate per trail 
+- ...
+
+** TODO [#B] Scrape ComicBookRoundUp ratings for comic book metadata :books:feature:comicbook:
+:PROPERTIES:
+:ID:       b3cc57ca-3d2c-468d-ab7c-c47f1120309b
+:END:
+
+*** Description
+As an example https://comicbookroundup.com/comic-books/reviews/humanoids-publishing/the-history-of-science-fiction
+
+** TODO [#C] Make podcast date format configurable in settings :podcasts:configuration:
+:PROPERTIES:
+:ID:       b01a94f8-328f-41ed-a62e-8b99c755b82d
+:END:
+
+*** Description
+
+=PODCAST_DATE_FORMAT= is hardcoded to ="YYYY-MM-DD"=. Should be in Django settings or environment variables for deploy-specific configuration.
+
+File: ~vrobbler/apps/podcasts/utils.py~ (line 13)
+
+** TODO [#C] Extract zombie scrobble query into custom manager :refactoring:manager:
+:PROPERTIES:
+:ID:       79c874e1-ca6f-4bce-9259-e3eebdca8a41
+:END:
+
+*** Description
+The zombie scrobble cleanup query lives in a utility function. Should be a
+custom model manager method (e.g. =Scrobble.objects.zombies()=).
+
+File: ~vrobbler/apps/scrobbles/utils.py~ (line 204)
+
+** TODO [#C] Allow profile to set start of week :profiles:configuration:
+:PROPERTIES:
+:ID:       0449279a-9550-430e-be0c-816df7273080
+:END:
+
+*** Description
+=start_of_week()= and =end_of_week()= use Monday as default. Should be a user
+profile setting for different cultural week start conventions.
+
+File: ~vrobbler/apps/profiles/utils.py~ (lines 39, 44)
+
+** TODO [#C] Add constants for data dictionary keys (multiple files) :refactoring:constants:
+:PROPERTIES:
+:ID:       d4415f9b-620a-4be7-925d-fa71c02ba1d1
+:END:
+
+*** Description
+Multiple files use magic string literals for dict keys. Should be extracted to
+named constants for maintainability.
+
+- Files:
+  - ~vrobbler/apps/locations/models.py~ (line 63) -- ="lat"=, ="lon"= etc.
+  - ~vrobbler/apps/webpages/models.py~ (line 290) -- ="url"=
+  - ~vrobbler/apps/scrobbles/importers/tsv.py~ (line 55) -- ="S"= completion status
+
+* Version 52.2 [1/1]
+** DONE [#A] Fix bug in recomputing long play seconds taking forever :bug:longplay:commands:
+:PROPERTIES:
+:ID:       0a813cf9-17fb-dbd7-b5a7-7410d9bd4d8c
+:END:
+
+* Version 52.1 [1/1]
+** DONE [#C] Show time per scrobble in long play lists and total time playing :templates:longplay:scrobbles:
+:PROPERTIES:
+:ID:       b3d16230-8ec5-46db-b166-59e98d0ee06c
+:END:
+
+*** Description
+
+Long play time should be show in the table of scrobbles on a media detail page.
+The total time spent in a long play that's either no completed yet or completed
+should be displayed as well. If completed, the date finished should be shown as
+well.
+
+
+* Version 52.0 [5/5]
+** DONE [#B] Allow marking media as long play complete from detail page :templates:scrobbles:longplay:
+:PROPERTIES:
+:ID:       2c314768-be97-9b10-d13c-9cfd0f38a64e
+:END:
+** DONE [#A] Fix how long play scrobbles are tracked :scrobbles:longplay:serial:
+:PROPERTIES:
+:ID:       908b0493-cabf-40c1-825f-cd59a8ad0f7a
+:END:
+
+*** Description
+
+Currently we have this idea of "long_play" scrobbles but there's a lot missing
+to tie it together.
+
+What we'd prefer is that when a new scrobble is added for a media_type that
+`is_long_play` the most recent scrobble finished is added as the
+`last_serial_scrobble` to the log data. But all the other long play stuff exsits
+as data model fields. We should add `long_play_last_scrobble` as a FK to this
+scrobble when creating a new longplay scrobble.
+
+Additionally, `long_play_seconds` we should have a recompute management command
+to walk backward from `long_play_last_scrobble` until a `long_play_complete`
+scrobble is found (exclusive) and save the time.
+
+We should also ony use `long_play_complete` field on the scrobble ... some
+logdatas have a similar field, but we should make sure that we always use the
+model field to determine if a long play is finished.
+
+This should include a command to clean up long play data to consolidate around
+the `long_play_complete` field.
+
+
+** DONE [#B] Paginate or limite scrobbles on media admin pages :admin:scrobbles:media:
+:PROPERTIES:
+:ID:       f02e487b-d7ed-4834-838a-303560f2ad3b
+:END:
+
+** DONE [#B] Clean up books admin :admin:books:bug:
+:PROPERTIES:
+:ID:       7539bee6-0a52-26f6-ebc6-5554ac49a716
+:END:
+** DONE [#B] Clean up favorites admin :admin:favorites:scrobbles:
+:PROPERTIES:
+:ID:       f2be0c69-1bf8-b5a3-5269-9c8ea873361d
+:END:
+
+
+*** Description
+
+Some FK lookups in admin should be raw_id_fields.
+
+
+
+* Version 51.4 [1/1]
+** DONE [#A] Clean up metadata comicbook enrichment :bug:comics:books:metadata:
+:PROPERTIES:
+:ID:       cd875450-7117-78ca-8be4-9c8b73037dba
+:END:
+
+*** Description
+
+Still getting wonky results with some comicbooks. Would be nice to be able to
+tag a Book as a comicbook, and also gather volume information. I also noticed
+that some books that are found in OL never get their comicvine_id populated. We
+should make sure we always have comicvine_ids if available.
+
+
+* Version 51.3 [1/1]
+** DONE [#A] Improve speed of index and chart pages :bug:scrobbles:perf:
+:PROPERTIES:
+:ID:       031a23f8-7c02-4926-9884-6654ceca16c2
+:END:
+
+*** Description
+
+Over the last few releases, the home page and charts pages have gotten really
+slow.
+
+We should look into what's causing the slowness and maybe do more agressive
+query optimization or caching.
+
+
+* Version 51.2 [2/2]
+** DONE [#A] Fix bug where last page of book gets separate scrobble :bug:books:importers:koreader:
+:PROPERTIES:
+:ID:       e13e0b4c-461e-e5a9-c685-b972f4e262e5
+:END:
+
+*** Description
+
+The new KoReader code is working great to import books with the correct timezone
+and what-not. But it has a weird artifact of creating one extra scrobble for the
+last page read. Need to button that up.
+
+** DONE [#B] Fix metadata scraping for books :books:metadata:
+:PROPERTIES:
+:ID:       ea416a69-a8a8-4d05-b7d4-0a3470820e34
+:END:
+
+
+* Version 51.1 [1/1]
+** DONE [#A] Fix scrobbling comic books :books:scrobbles:bug:
+:PROPERTIES:
+:ID:       8dfbff19-3fa4-f3b8-21c7-7a416498000c
+:END:
+
+*** Description
+
+At some point logdata and log got confused, and now when you try
+to scrobble a comic book, it just throws errors. We should look
+into where the confusion happened and fix it.
+
+
+* Version 51.0 [3/3]
+** DONE [#B] Fix koreader scrobble imports to use DST properly :bug:books:imports:
 :PROPERTIES:
 :ID:       79758cba-a440-48b6-a637-efb88827acf2
 :END:
@@ -477,80 +755,145 @@ whatever time KoReader reports, we need to know, given the date and the user
 profile's historic timezone, how many hours to adjust the KoReader time to get
 to GMT to save it in the database.
 
-** TODO [#B] Make IMAP and WebDAV configurable :webdav:feature:imap:importers:
+** DONE [#A] Fix book scrobbles where page_data is a list :bug:books:scrobbles:
 :PROPERTIES:
-:ID:       b1426d92-2feb-4d15-9738-d5b7b0594f96
+:ID:       35b323fa-ccc0-4009-b227-8a0f12bbd469
 :END:
 
 *** Description
 
-Currently we have webdav able to import post types of file-based incoming data,
-usually in the form of CSVs but also gpx files, bgstats json files, and
-audioscrobbler TSV files.
+Comic scrobbling is currently kind of janky. Most of the problems boil down to them
+storing saved page data in a list of dicts rather than a dict keyed off of the page number that
+was read.
 
-What if the user could specify via their profile (settings) which imports they
-wanted to use IMAP for and which ones they wanted to use WebDAV for.
+We need to adjust comic scrobbling to use a dict of pages keyed off the page number, and also
+write a migration script that runs as a data migration to update any book scrobbles that may
+have page_data as a list.
 
-Then we'd have two celery tasks that would be kicked off periodically via
-celerybeat, one for IMAP imports every 12 minutes and one for WebDAV every 3
-minutes. Both would be responsible for checking if a user has an configured
-imports of their type, check if an import needs to run, and dispatch the
-needed import celery task. This is how the WebDAV celery task currently works.
+*** Example data
+#+begin_src python
+{"notes": null, "page_end": 27, "page_data": [{"notes": null, "end_ts": 1771815895, "duration": 14, "start_ts": 1771815881, "description": null, "page_number": "1"}, {"notes": null, "end_ts": 1771815908, "duration": 13, "start_ts": 1771815895, "description": null, "page_number": "1"}, {"notes": null, "end_ts": 1771815913, "duration": 5, "start_ts": 1771815908, "description": null, "page_number": "2"}, {"notes": null, "end_ts": 1771815933, "duration": 20, "start_ts": 1771815913, "description": null, "page_number": "3"}, {"notes": null, "end_ts": 1771815945, "duration": 12, "start_ts": 1771815933, "description": null, "page_number": "4"}, {"notes": null, "end_ts": 1771815983, "duration": 38, "start_ts": 1771815945, "description": null, "page_number": "5"}, {"notes": null, "end_ts": 1771816007, "duration": 24, "start_ts": 1771815983, "description": null, "page_number": "6"}, {"notes": null, "end_ts": 1771816011, "duration": 4, "start_ts": 1771816007, "description": null, "page_number": "7"}, {"notes": null, "end_ts": 1771816013, "duration": 2, "start_ts": 1771816011, "description": null, "page_number": "8"}, {"notes": null, "end_ts": 1771816052, "duration": 39, "start_ts": 1771816013, "description": null, "page_number": "7"}, {"notes": null, "end_ts": 1771816127, "duration": 75, "start_ts": 1771816052, "description": null, "page_number": "8"}, {"notes": null, "end_ts": 1771816134, "duration": 7, "start_ts": 1771816127, "description": null, "page_number": "9"}, {"notes": null, "end_ts": 1771816196, "duration": 62, "start_ts": 1771816134, "description": null, "page_number": "10"}, {"notes": null, "end_ts": 1771816262, "duration": 66, "start_ts": 1771816196, "description": null, "page_number": "11"}, {"notes": null, "end_ts": 1771816293, "duration": 31, "start_ts": 1771816262, "description": null, "page_number": "12"}, {"notes": null, "end_ts": 1771816322, "duration": 29, "start_ts": 1771816293, "description": null, "page_number": "13"}, {"notes": null, "end_ts": 1771816330, "duration": 8, "start_ts": 1771816322, "description": null, "page_number": "14"}, {"notes": null, "end_ts": 1771816368, "duration": 38, "start_ts": 1771816330, "description": null, "page_number": "15"}, {"notes": null, "end_ts": 1771816388, "duration": 20, "start_ts": 1771816368, "description": null, "page_number": "16"}, {"notes": null, "end_ts": 1771816482, "duration": 94, "start_ts": 1771816388, "description": null, "page_number": "17"}, {"notes": null, "end_ts": 1771816550, "duration": 68, "start_ts": 1771816482, "description": null, "page_number": "18"}, {"notes": null, "end_ts": 1771816567, "duration": 17, "start_ts": 1771816550, "description": null, "page_number": "19"}, {"notes": null, "end_ts": 1771816586, "duration": 19, "start_ts": 1771816567, "description": null, "page_number": "20"}, {"notes": null, "end_ts": 1771816597, "duration": 11, "start_ts": 1771816586, "description": null, "page_number": "21"}, {"notes": null, "end_ts": 1771816616, "duration": 19, "start_ts": 1771816597, "description": null, "page_number": "22"}, {"notes": null, "end_ts": 1771816640, "duration": 24, "start_ts": 1771816616, "description": null, "page_number": "23"}, {"notes": null, "end_ts": 1771816690, "duration": 50, "start_ts": 1771816640, "description": null, "page_number": "24"}, {"notes": null, "end_ts": 1771816702, "duration": 12, "start_ts": 1771816690, "description": null, "page_number": "25"}, {"notes": null, "end_ts": 1771816823, "duration": 121, "start_ts": 1771816702, "description": null, "page_number": "26"}, {"notes": null, "end_ts": null, "duration": null, "start_ts": 1771816823, "description": null, "page_number": "27"}], "page_start": 1, "pages_read": 27, "resume_url": null, "description": null, "koreader_hash": null, "long_play_complete": false}
 
-This would also be an opporunity to clean up the code around WebDAV imports
-and make them more re-usable for other import services.
-
-
-** TODO [#A] Add an exception list of artists as a constant that are exempted from splitting :music:artists:metadata:
+#+end_src
+** DONE [#A] Lichess imports do not set default visbility :boardgames:bug:importers:lichess:
 :PROPERTIES:
-:ID:       fd86a11a-73ec-470d-b5e3-2d90ba9137c8
+:ID:       a78f7c72-a20a-8db2-cde0-d92a731d4fba
+:END:
+
+* Version 50.2 [2/2]
+** DONE [#B] Koreader imports only import single-page scrobbles the next day :bug:books:importers:
+:PROPERTIES:
+:ID:       b50141fd-cda6-4a3a-afd3-cd8499e7523e
 :END:
 
 *** Description
 
-Certain artists like "Simon & Garfunkel" are actually one artist. While we don't want to mess with splitting up
-tracks into featured artists, we should have a "LITERAL_ARTIST_TITLES" constant that can have exceptions like
-this put into it and then we stop trying to pull the artist apart when we run into it.
+When you read a single page in a book in Koreader and try to import it, the scrobble is only
+created the day after, not on the day of the reading.
 
-
-** TODO [#A] Before enriching anything, trust the POST data :feature:scrobbles:metadata:
+** DONE [#A] Fix bugs in celery tasks causing imports to fail :bug:celery:tasks:
 :PROPERTIES:
-:ID:       db6b05f8-09f4-49f5-9838-fbacc9fe9cd0
+:ID:       d1171cb0-6413-44b8-a68a-019a4d2fb285
 :END:
 
 *** Description
 
-Both Jellyfin and Mopidy provide a decent amount of metadata when they POST to our webhooks.
+Seems like all celery tasks are failing for different reasons except the chart
+updates.
 
-In most cases, we should be able to trust this data to created music tracks or videos rather
-than going to third-party services to enrich. Thus, for tracks and videos we should search in
-the local database for imdb_id or musicbrainz_id for the specific content and, if found, not
-enrich further.
+*** Errors
+****  scrobbles.tasks.send_notification_for_in_progress
+#+begin_src bash
+KeyError: 'track'
 
-If not found, tracks and videos from mopidy and jellyfin should be created as completely as
-possible using only the POST data from the webhooks, tagged the scrobble with "webhook-metadata-only"
-and start the scrobble. A separate celery task should be kicked off to enrich the track or video
-async with the POST data stored in the log["raw_data"] and used by the celery enrichment task
-to go try to enrich the media instance.  Should this enrichment fail, tag the scrobble as "enrichment-failed"
-log a warning and move on.
+During handling of the above exception, another exception occurred:
 
-** TODO [#A] Allow updating all a user's scrobble visibility at once :scrobbles:sharing:feature:
+Traceback (most recent call last):
+File "/usr/local/lib/python3.11/site-packages/django/db/backends/utils.py", line 89, in _execute
+return self.cursor.execute(sql, params)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+psycopg2.errors.UndefinedColumn: column music_track.artist_id does not exist
+LINE 1: ..."."title", "music_track"."base_run_time_seconds", "music_tra...
+^
+HINT: Perhaps you meant to reference the column "music_track.artist_fk_id".
+#+end_src
+
+**** scrobbles.tasks.import_from_webdav_all_users
+#+begin_src bash
+File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/scrobbles/importers/webdav.py", line 166, in scan_webdav_for_koreader
+if last_import and last_import.webdav_etag and remote_etag:
+^^^^^^^^^^^^^^^^^^^^^^^
+AttributeError: 'KoReaderImport' object has no attribute 'webdav_etag'
+#+end_src
+
+**** scrobbles.tasks.process_bgstats_import
+#+begin_src bash
+
+Traceback (most recent call last):
+File "/usr/local/lib/python3.11/site-packages/django/db/backends/utils.py", line 89, in _execute
+return self.cursor.execute(sql, params)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+psycopg2.errors.NotNullViolation: null value in column "visibility" of relation "scrobbles_scrobble" violates not-null constraint
+DETAIL: Failing row contains (374463, 2026-06-11 13:27:06.528319+00, 2026-06-11 13:27:06.52834+00, 2026-06-11 13:17:34+00, 180, f, f, BG Stats, 1, null, t, {"players": [{"new": false, "win": false, "rank": 0, "role": "",..., null, null, null, 8e73ceec-b731-4623-9637-712bbf9f76ce, null, null, null, null, , null, BoardGame, 324, null, null, America/New_York, null, null, , null, null, , null, null, null, null, null, null, null, null, null, null, null).
+#+end_src
+
+* Version 50.1 [1/1]
+** DONE [#B] Fix bug in charts where only #1 is displayed :charts:templates:
+:PROPERTIES:
+:ID:       7136dffb-e6b7-184b-48ac-bb09bae0b0f0
+:END:
+
+* Version 50.0 [2/2]
+** DONE [#A] Allow updating all a user's scrobble visibility at once :scrobbles:sharing:feature:
 :PROPERTIES:
 :ID:       9ed2ec65-bf69-4300-965c-6a7d3ef7ea03
 :END:
 
 *** Description
 
-We now have the ability to share or unshare scrobbles and create private links. We should add a toggle
-in the user's settings that will bulk make all their scrobbles public or private, so that a user
-can either share everything, or lock their account down.
+We now have the ability to share or unshare scrobbles and create private links.
+We should add a toggle in the user's settings that will bulk make all their
+scrobbles public or private, so that a user can either share everything, or lock
+their account down.
 
 This should not affect scrobbles that are  in the "Shared" visibility state.
 
+And users should be able to also control whether all scrobbles of a specific
+type are shared or not. Maybe this could be a JSONField in profile that contains
+a media_type key with a visibility type for a value, and if it's not present,
+sharing defaults to private?
+
 Additionally, users's should have links in their settings to see what scrobbles
 are either public, shared or private. Probably this could be done with a
 ?visbility=<> filter on the /scrobbles/ page.
+
+*** Changes
+
+- Added `media_type_visibility` JSONField to UserProfile (migration 0038)
+- Created `BulkVisibilityView` at `/settings/visibility/` with:
+  - Radio toggle to make all non-shared scrobbles Public or Private
+  - Per-media-type dropdown for each of the 20 media types (inherit/public/shared/private)
+- Created `BulkVisibilityForm` with dynamic media_type fields
+- Created `profiles/visibility_settings.html` template with visibility stats + filter links
+- Added link from main settings page to visibility settings
+- Added `?visibility=` filter support to `ScrobbleListView` (public/shared/private)
+- Added filter indicator to `scrobble_all_list.html`
+- Updated `Scrobble.create()` to check `user.profile.media_type_visibility` for media-type-specific defaults before falling back to PRIVATE
+
+
          
+** DONE [#A] Replace columsn of Top Artists, Tracks and Series with Maloja widget :templates:charts:
+:PROPERTIES:
+:ID:       3946afb1-932c-46fe-a188-f4c9add1a491
+:END:
+
+
+*** Description
+
+The tables are fine, but Maloja widgets are better. We should drop the top track table, add top albums
+and replace top artists and top tv series with the Maloja style widgets.
+
+
 * Version 49.1 [1/1]
 ** DONE [#A] Fix bug with missing default visbility for scrobbles :bug:scrobbles:sharing:
 :PROPERTIES:

data/play-example.json

@@ -0,0 +1,96 @@
+{
+    "about": "This is a Play file that can be read by Board Game Stats. If you see this text, try to use a share, export or open-in function to open it with Board Game Stats.",
+    "players": [
+        {
+            "uuid": "31f8b92e-11d8-4162-88b1-fd9c79eea249",
+            "id": 2,
+            "name": "Colin Powell",
+            "isAnonymous": false,
+            "modificationDate": "2025-10-18 08:32:40",
+            "metaData": "{\"isNpc\":0,\"playerAvatar\":{\"image\":\"AnnikaHeller_Capybara.webp\",\"shape\":[1,1,1,1],\"color\":[0.6,0.20000000298023224,0.9803921580314636]}}"
+        },
+        {
+            "uuid": "dd2d1881-84ab-474c-a6b2-3045d034dc40",
+            "id": 3,
+            "name": "Silas Sewell",
+            "isAnonymous": false,
+            "modificationDate": "2026-01-18 12:27:12",
+            "metaData": "{\"isNpc\":0,\"playerAvatar\":{\"image\":\"RoryMuldoon_07.webp\",\"shape\":[1,1,1,1],\"color\":[0,0,0.1835034190722739]}}"
+        }
+    ],
+    "locations": [
+        {
+            "uuid": "14f7389c-767f-4725-9b35-906c407b293c",
+            "id": 3,
+            "name": "Timberwyck Farm",
+            "modificationDate": "2025-07-01 18:03:38"
+        }
+    ],
+    "games": [
+        {
+            "uuid": "9e431cdd-b325-4061-a875-d415d46342c0",
+            "id": 1046,
+            "name": "Sweet Takes",
+            "modificationDate": "2026-04-11 16:25:35",
+            "cooperative": false,
+            "highestWins": true,
+            "noPoints": false,
+            "usesTeams": false,
+            "urlThumb": "https://cf.geekdo-images.com/l4HILZn5iLbceQeDph4G5A__small/img/gmGqlmwe9fniqYpniGwhg5RUgVQ=/fit-in/200x150/filters:strip_icc()/pic8784202.jpg",
+            "urlImage": "https://cf.geekdo-images.com/l4HILZn5iLbceQeDph4G5A__original/img/b4IU8WIEWRpacbXp0FHG9HfFRpw=/0x0/filters:format(jpeg)/pic8784202.jpg",
+            "bggName": "Sweet Takes",
+            "bggYear": 2023,
+            "bggId": 407581,
+            "designers": "Hisashi Hayashi",
+            "isBaseGame": 1,
+            "isExpansion": 0,
+            "rating": 67,
+            "minPlayerCount": 2,
+            "maxPlayerCount": 5,
+            "minPlayTime": 15,
+            "maxPlayTime": 15,
+            "minAge": 8
+        }
+    ],
+    "plays": [
+        {
+            "uuid": "7b2fd583-e8f2-40fe-9565-90178390b87e",
+            "modificationDate": "2026-04-16 20:18:03",
+            "entryDate": "2026-04-16 20:13:33",
+            "playDate": "2026-04-16 20:13:33",
+            "usesTeams": false,
+            "durationMin": 4,
+            "ignored": false,
+            "manualWinner": false,
+            "rounds": 0,
+            "locationRefId": 3,
+            "gameRefId": 1046,
+            "board": "",
+            "scoringSetting": 1,
+            "metaData": "{\"playerRefId\":2,\"playGameBggVersion\":\"{\\\"versionId\\\":0,\\\"versionName\\\":\\\"\\\",\\\"imageUrl\\\":\\\"https:\\\\\\/\\\\\\/cf.geekdo-images.com\\\\\\/l4HILZn5iLbceQeDph4G5A__small\\\\\\/img\\\\\\/gmGqlmwe9fniqYpniGwhg5RUgVQ=\\\\\\/fit-in\\\\\\/200x150\\\\\\/filters:strip_icc()\\\\\\/pic8784202.jpg\\\",\\\"thumbUrl\\\":\\\"https:\\\\\\/\\\\\\/cf.geekdo-images.com\\\\\\/l4HILZn5iLbceQeDph4G5A__small\\\\\\/img\\\\\\/gmGqlmwe9fniqYpniGwhg5RUgVQ=\\\\\\/fit-in\\\\\\/200x150\\\\\\/filters:strip_icc()\\\\\\/pic8784202.jpg\\\",\\\"yearPublished\\\":0}\",\"playUsedGameCopy\":2}",
+            "playerScores": [
+                {
+                    "score": "27",
+                    "winner": false,
+                    "newPlayer": false,
+                    "startPlayer": false,
+                    "playerRefId": 2,
+                    "role": "",
+                    "rank": 0,
+                    "seatOrder": 0
+                },
+                {
+                    "score": "36",
+                    "winner": true,
+                    "newPlayer": true,
+                    "startPlayer": false,
+                    "playerRefId": 3,
+                    "rank": 0,
+                    "seatOrder": 0
+                }
+            ],
+            "expansionPlays": []
+        }
+    ],
+    "userInfo": { "meRefId": 2 }
+}

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vrobbler"
-version = "49.1"
+version = "52.2"
 description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]
 

vrobbler/apps/beers/admin.py

@@ -27,6 +27,7 @@ class BeerAdmin(admin.ModelAdmin):
         "uuid",
         "title",
     )
+    raw_id_fields = ("styles", "producer")
     ordering = ("-created",)
     search_fields = ("title",)
     inlines = [

vrobbler/apps/birds/admin.py

@@ -27,4 +27,5 @@ class BirdingLocationAdmin(admin.ModelAdmin):
 class BirdingCSVImportAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     list_display = ("uuid", "process_count", "processed_finished", "processing_started", "error_log")
+    raw_id_fields = ("user",)
     ordering = ("-created",)

vrobbler/apps/boardgames/admin.py

@@ -38,6 +38,7 @@ class BoardGameLocationAdmin(admin.ModelAdmin):
         "uuid",
         "geo_location",
     )
+    raw_id_fields = ("geo_location",)
     ordering = ("-created",)
 
 
@@ -49,6 +50,7 @@ class BoardGameAdmin(admin.ModelAdmin):
         "title",
         "published_year",
     )
+    raw_id_fields = ("publisher", "publishers", "designers", "expansion_for_boardgame")
     search_fields = ("title",)
     ordering = ("-created",)
     inlines = [

vrobbler/apps/boardgames/sources/lichess.py

@@ -103,6 +103,7 @@ def import_chess_games_for_user_id(user_id: int, commit: bool = False) -> dict:
             "source": "Lichess",
             "timezone": user.profile.timezone,
             "log": log_data,
+            "visibility": "private",
         }
         if commit:
             Scrobble.objects.create(**scrobble_dict)

vrobbler/apps/books/admin.py

@@ -27,6 +27,7 @@ class BookAdmin(admin.ModelAdmin):
         "first_publish_year",
         "pages",
     )
+    raw_id_fields = ("authors",)
     search_fields = ("name",)
     ordering = ("-created",)
     inlines = [
@@ -34,11 +35,11 @@ class BookAdmin(admin.ModelAdmin):
     ]
 
     def issue_or_volume(self, obj):
-        return obj.issue_number or obj.volume_number
+        return obj.subtitle
 
 
 @admin.register(Paper)
-class BookAdmin(admin.ModelAdmin):
+class PaperAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     list_display = (
         "title",
@@ -47,6 +48,7 @@ class BookAdmin(admin.ModelAdmin):
         "first_publish_year",
         "pages",
     )
+    raw_id_fields = ("authors",)
     search_fields = ("name",)
     ordering = ("-created",)
     inlines = [

vrobbler/apps/books/koreader.py

@@ -1,9 +1,8 @@
 import logging
 import re
 import sqlite3
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from enum import Enum
-from zoneinfo import ZoneInfo
 
 import requests
 from books.constants import BOOKS_TITLES_TO_IGNORE
@@ -174,7 +173,7 @@ def build_book_map(rows) -> dict:
     return book_id_map
 
 
-def build_page_data(page_rows: list, book_map: dict, user_tz=None) -> dict:
+def build_page_data(page_rows: list, book_map: dict) -> dict:
     """Given rows of page data from KoReader, parse each row and build
     scrobbles for our user, loading the page data into the page_data
     field on the scrobble instance.
@@ -187,18 +186,20 @@ def build_page_data(page_rows: list, book_map: dict, user_tz=None) -> dict:
             book_ids_not_found.append(koreader_book_id)
             continue
 
-        if "pages" not in book_map[koreader_book_id].keys():
-            book_map[koreader_book_id]["pages"] = {}
+        book_map[koreader_book_id].setdefault("pages", [])
 
         page_number = page_row[KoReaderPageStatColumn.PAGE.value]
         duration = page_row[KoReaderPageStatColumn.DURATION.value]
         start_ts = page_row[KoReaderPageStatColumn.START_TIME.value]
 
-        book_map[koreader_book_id]["pages"][page_number] = {
-            "duration": duration,
-            "start_ts": start_ts,
-            "end_ts": start_ts + duration,
-        }
+        book_map[koreader_book_id]["pages"].append(
+            {
+                "page_number": page_number,
+                "duration": duration,
+                "start_ts": start_ts,
+                "end_ts": start_ts + duration,
+            }
+        )
     if book_ids_not_found:
         logger.info(f"Found pages for books not in file: {set(book_ids_not_found)}")
     return book_map
@@ -216,7 +217,6 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
             pages_not_found.append(book_id)
             continue
 
-        should_create_scrobble = False
         scrobble_page_data = {}
         playback_position_seconds = 0
         prev_page_stats = {}
@@ -225,11 +225,12 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
         pages_processed = 0
         total_pages_read = len(book_map[koreader_book_id]["pages"])
         ordered_pages = sorted(
-            book_map[koreader_book_id]["pages"].items(),
-            key=lambda x: x[1]["start_ts"],
+            book_map[koreader_book_id]["pages"],
+            key=lambda x: x["start_ts"],
         )
 
-        for cur_page_number, stats in ordered_pages:
+        for stats in ordered_pages:
+            page_number = stats["page_number"]
             pages_processed += 1
 
             seconds_from_last_page = 0
@@ -243,46 +244,52 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
             )
 
             end_of_reading = pages_processed == total_pages_read
-            big_jump_to_this_page = (cur_page_number - last_page_number) > 10
+            big_jump_to_this_page = (page_number - last_page_number) > 10
             is_session_gap = seconds_from_last_page > SESSION_GAP_SECONDS
-            if (is_session_gap and not big_jump_to_this_page) or end_of_reading:
-                should_create_scrobble = True
+            should_create_scrobble = (
+                is_session_gap and not big_jump_to_this_page
+            ) or end_of_reading
+
+            # Always accumulate the current page first
+            scrobble_page_data[page_number] = stats
 
             if should_create_scrobble:
+                # For end-of-reading, the current page is already accumulated
+                # and belongs in this scrobble. For a session gap, remove the
+                # current page from this scrobble — it starts a new session.
+                if is_session_gap and not end_of_reading:
+                    del scrobble_page_data[page_number]
+
                 scrobble_page_data = dict(
                     sorted(
                         scrobble_page_data.items(),
                         key=lambda x: x[1]["start_ts"],
                     )
                 )
-                try:
-                    first_page = scrobble_page_data.get(
-                        list(scrobble_page_data.keys())[0]
-                    )
-                    last_page = scrobble_page_data.get(
-                        list(scrobble_page_data.keys())[-1]
-                    )
-                except IndexError:
+
+                if not scrobble_page_data:
                     logger.error(
                         "Could not process book, no page data found",
                         extra={"scrobble_page_data": scrobble_page_data},
                     )
                     continue
 
+                first_page = next(iter(scrobble_page_data.values()))
+                last_page = scrobble_page_data[
+                    list(scrobble_page_data.keys())[-1]
+                ]
+
                 timestamp = user.profile.get_timestamp_with_tz(
-                    datetime.fromtimestamp(int(first_page.get("start_ts")))
+                    datetime.fromtimestamp(
+                        int(first_page.get("start_ts"))
+                    )
                 )
                 stop_timestamp = user.profile.get_timestamp_with_tz(
-                    datetime.fromtimestamp(int(last_page.get("end_ts")))
+                    datetime.fromtimestamp(
+                        int(last_page.get("end_ts"))
+                    )
                 )
 
-                # Adjust for Daylight Saving Time
-                # if timestamp.dst() == timedelta(
-                #    0
-                # ) or stop_timestamp.dst() == timedelta(0):
-                #    timestamp = timestamp - timedelta(hours=1)
-                #    stop_timestamp = stop_timestamp - timedelta(hours=1)
-
                 scrobble = Scrobble.objects.filter(
                     timestamp=timestamp,
                     book_id=book_id,
@@ -291,7 +298,7 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
 
                 if not scrobble:
                     logger.info(
-                        f"Queueing scrobble for {book_id}, page {cur_page_number}"
+                        f"Queueing scrobble for {book_id}, page {page_number}"
                     )
                     log_data = {
                         "koreader_hash": book_dict.get("hash"),
@@ -318,16 +325,18 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
                             timezone=tz,
                         )
                     )
-                # Then start over
-                should_create_scrobble = False
+                # Then start over for the next session
                 playback_position_seconds = 0
                 scrobble_page_data = {}
 
-            # We accumulate pages for the scrobble until we should create a new one
-            scrobble_page_data[cur_page_number] = stats
+                # For session gaps, re-add the current page as the
+                # beginning of the next session's accumulation
+                if is_session_gap and not end_of_reading:
+                    scrobble_page_data[page_number] = stats
 
-            last_page_number = cur_page_number
+            last_page_number = page_number
             prev_page_stats = stats
+
     if pages_not_found:
         logger.info(f"Pages not found for books: {set(pages_not_found)}")
     return scrobbles_to_create
@@ -335,13 +344,16 @@ def build_scrobbles_from_book_map(book_map: dict, user: "User") -> list["Scrobbl
 
 def fix_long_play_stats_for_scrobbles(scrobbles: list) -> None:
     """Given a list of scrobbles, update pages read, long play seconds and check
-    for media completion"""
+    for media completion.
+
+    Uses the long_play_last_scrobble FK chain to accumulate time.
+    Consider using the recompute_long_play_seconds management command instead.
+    """
 
     for scrobble in scrobbles:
-        # But if there's a next scrobble, set pages read to their starting page
-        if scrobble.previous and not scrobble.previous.long_play_complete:
+        if scrobble.long_play_last_scrobble and not scrobble.long_play_last_scrobble.long_play_complete:
             scrobble.long_play_seconds = scrobble.playback_position_seconds + (
-                scrobble.previous.long_play_seconds or 0
+                scrobble.long_play_last_scrobble.long_play_seconds or 0
             )
         else:
             scrobble.long_play_seconds = scrobble.playback_position_seconds
@@ -357,9 +369,6 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
 
     new_scrobbles = []
     user = User.objects.filter(id=user_id).first()
-    tz = ZoneInfo("UTC")
-    if user:
-        tz = user.profile.tzinfo
 
     is_os_file = "https://" not in file_path
     if is_os_file:
@@ -375,7 +384,6 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
         book_map = build_page_data(
             cur.execute("SELECT * from page_stat_data ORDER BY id_book, start_time"),
             book_map,
-            tz,
         )
         new_scrobbles = build_scrobbles_from_book_map(book_map, user)
     else:
@@ -392,7 +400,7 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
             _sqlite_bytes(file_path), max_buffer_size=1_048_576
         ):
             if table_name == "page_stat_data":
-                book_map = build_page_data(rows, book_map, tz)
+                book_map = build_page_data(rows, book_map)
                 new_scrobbles = build_scrobbles_from_book_map(book_map, user)
 
     logger.info(f"Creating {len(new_scrobbles)} new scrobbles")

vrobbler/apps/books/management/commands/cleanup_book_metadata.py

@@ -0,0 +1,301 @@
+import logging
+import time
+
+from django.core.management.base import BaseCommand
+from django.db import transaction
+
+from books.constants import READCOMICSONLINE_URL
+
+logger = logging.getLogger(__name__)
+
+MISSING_ALL = [
+    "cover",
+    "summary",
+    "isbn",
+    "pages",
+    "language",
+    "publisher",
+    "publish_year",
+]
+
+MISSING_GROUPS = {
+    "cover": lambda b: not bool(b.cover),
+    "summary": lambda b: not b.summary,
+    "isbn": lambda b: not b.isbn_13 and not b.isbn_10,
+    "pages": lambda b: b.pages is None,
+    "language": lambda b: not b.language,
+    "publisher": lambda b: not b.publisher,
+    "publish_year": lambda b: b.first_publish_year is None,
+}
+
+
+def _book_matches(book, flags):
+    if not flags:
+        return False
+    for flag in flags:
+        fn = MISSING_GROUPS.get(flag)
+        if fn and fn(book):
+            return True
+    return False
+
+
+class Command(BaseCommand):
+    help = "Backfill missing metadata on books from Google Books, OpenLibrary, and ComicVine"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--commit",
+            action="store_true",
+            help="Commit changes to the database",
+        )
+        parser.add_argument(
+            "--batch-size",
+            type=int,
+            default=100,
+            help="Number of books to process per batch (default: 100)",
+        )
+        parser.add_argument(
+            "--sleep",
+            type=float,
+            default=0.5,
+            help="Seconds to sleep between API calls (default: 0.5)",
+        )
+        for flag in MISSING_ALL:
+            parser.add_argument(
+                f"--missing-{flag}",
+                dest="missing_flags",
+                action="append_const",
+                const=flag,
+                help=f"Process books missing {flag}",
+            )
+        parser.add_argument(
+            "--comics-only",
+            action="store_true",
+            help="Only process books with a readcomicsonline.ru URL",
+        )
+        parser.add_argument(
+            "--all",
+            action="store_true",
+            dest="all_missing",
+            help="Process books missing any metadata field",
+        )
+
+    def handle(self, *args, **options):
+        from books.models import Book
+
+        commit = options["commit"]
+        batch_size = options["batch_size"]
+        sleep_secs = options["sleep"]
+        flags = options.get("missing_flags") or []
+        comics_only = options["comics_only"]
+        all_missing = options["all_missing"]
+
+        if all_missing:
+            flags = MISSING_ALL
+
+        if not flags and not comics_only:
+            self.stdout.write(
+                "No filters specified. Use --all, --missing-*, or --comics-only."
+            )
+            return
+
+        qs = Book.objects.all()
+        if comics_only:
+            qs = qs.filter(readcomics_url__isnull=False)
+
+        if flags:
+            qs = [b for b in qs.iterator() if _book_matches(b, flags)]
+        else:
+            qs = list(qs)
+
+        total = len(qs)
+        self.stdout.write(f"Found {total} books to process")
+
+        if not commit:
+            self.stdout.write(
+                "Dry run — no API calls will be made. Use --commit to run lookups."
+            )
+            return
+
+        enriched = 0
+        skipped = 0
+        stats = {
+            "cover_fixed": 0,
+            "summary_fixed": 0,
+            "isbn_fixed": 0,
+            "pages_fixed": 0,
+            "language_fixed": 0,
+            "publisher_fixed": 0,
+            "publish_year_fixed": 0,
+        }
+
+        for batch_num, offset in enumerate(range(0, len(qs), batch_size)):
+            batch = qs[offset : offset + batch_size]
+            for book in batch:
+                result = self._enrich_book(book, sleep_secs)
+                if result:
+                    enriched += 1
+                    for key in stats:
+                        if result.get(key):
+                            stats[key] += 1
+                else:
+                    skipped += 1
+
+            self.stdout.write(
+                f"  Batch {batch_num + 1}: {offset + len(batch)}/{total} — "
+                f"enriched: {enriched}, skipped: {skipped}"
+            )
+
+        self.stdout.write(
+            f"\nResults (commit={commit}):\n"
+            f"  Books enriched: {enriched}\n"
+            f"  Books skipped:  {skipped}\n"
+            f"  Covers fixed:   {stats['cover_fixed']}\n"
+            f"  Summaries fixed:{stats['summary_fixed']}\n"
+            f"  ISBNs fixed:    {stats['isbn_fixed']}\n"
+            f"  Pages fixed:    {stats['pages_fixed']}\n"
+            f"  Languages fixed:{stats['language_fixed']}\n"
+            f"  Publishers fixed:{stats['publisher_fixed']}\n"
+            f"  Publish yrs fixed: {stats['publish_year_fixed']}"
+        )
+
+    def _enrich_book(self, book, sleep_secs):
+        from books.sources.comicvine import (
+            lookup_comic_from_comicvine,
+            lookup_issue_by_comicvine_id,
+        )
+        from books.sources.google import lookup_book_from_google
+        from books.sources.openlibrary import lookup_book_from_openlibrary as lookup_book_from_ol
+
+        title = book.original_title or book.title
+        author_name = book.author.name if book.author else None
+        book_dict = {}
+
+        cv_data = None
+        if book.comicvine_id:
+            cv_data = lookup_issue_by_comicvine_id(str(book.comicvine_id))
+        if not cv_data:
+            cv_data = lookup_comic_from_comicvine(title)
+        if cv_data:
+            book_dict.update(cv_data)
+
+        ol_data = lookup_book_from_ol(title, author=author_name)
+        time.sleep(sleep_secs)
+        google_data = lookup_book_from_google(title)
+
+        if ol_data:
+            for k, v in ol_data.items():
+                book_dict.setdefault(k, v)
+
+        if google_data:
+            for k, v in google_data.items():
+                if v:
+                    book_dict.setdefault(k, v)
+
+        if not book_dict:
+            return None
+
+        changed = self._apply(book, book_dict, title)
+        return changed
+
+    def _apply(self, book, data, title):
+        changed = {
+            "cover_fixed": False,
+            "summary_fixed": False,
+            "isbn_fixed": False,
+            "pages_fixed": False,
+            "language_fixed": False,
+            "publisher_fixed": False,
+            "publish_year_fixed": False,
+        }
+
+        update_fields = []
+
+        cover_url = data.pop("cover_url", "")
+
+        if data.get("summary") and not book.summary:
+            book.summary = data["summary"]
+            update_fields.append("summary")
+            changed["summary_fixed"] = True
+
+        if data.get("isbn_13") and not book.isbn_13:
+            book.isbn_13 = data["isbn_13"]
+            update_fields.append("isbn_13")
+            changed["isbn_fixed"] = True
+
+        if data.get("isbn_10") and not book.isbn_10:
+            book.isbn_10 = data["isbn_10"]
+            update_fields.append("isbn_10")
+            changed["isbn_fixed"] = True
+
+        if data.get("pages") and book.pages is None:
+            book.pages = data["pages"]
+            update_fields.append("pages")
+            changed["pages_fixed"] = True
+
+        if data.get("language") and not book.language:
+            book.language = data["language"]
+            update_fields.append("language")
+            changed["language_fixed"] = True
+
+        if data.get("publisher") and not book.publisher:
+            book.publisher = data["publisher"]
+            update_fields.append("publisher")
+            changed["publisher_fixed"] = True
+
+        if data.get("first_publish_year") and book.first_publish_year is None:
+            book.first_publish_year = data["first_publish_year"]
+            update_fields.append("first_publish_year")
+            changed["publish_year_fixed"] = True
+
+        if data.get("openlibrary_id") and not book.openlibrary_id:
+            book.openlibrary_id = data["openlibrary_id"]
+            update_fields.append("openlibrary_id")
+
+        if data.get("comicvine_id") and not book.comicvine_id:
+            book.comicvine_id = data["comicvine_id"]
+            update_fields.append("comicvine_id")
+
+        if data.get("issue_number") and book.issue_number is None:
+            book.issue_number = data["issue_number"]
+            update_fields.append("issue_number")
+
+        if data.get("volume_number") and book.volume_number is None:
+            book.volume_number = data["volume_number"]
+            update_fields.append("volume_number")
+
+        if data.get("volume") and not book.volume:
+            book.volume = data["volume"]
+            update_fields.append("volume")
+
+        if data.get("volume_comicvine_id") and not book.volume_comicvine_id:
+            book.volume_comicvine_id = data["volume_comicvine_id"]
+            update_fields.append("volume_comicvine_id")
+
+        if update_fields:
+            book.save(update_fields=update_fields)
+            self.stdout.write(f"  [ENRICHED] {book} — {', '.join(update_fields)}")
+
+        if cover_url and not book.cover:
+            book.save_image_from_url(cover_url)
+            if book.cover:
+                changed["cover_fixed"] = True
+                self.stdout.write(f"  [COVER] {book} — cover saved from source")
+
+        genres = data.pop("genres", data.pop("generes", []))
+        if genres:
+            existing = set(book.genre.names())
+            new_genres = [g for g in genres if g not in existing]
+            if new_genres:
+                book.genre.add(*new_genres)
+                self.stdout.write(f"  [GENRES] {book} — added {len(new_genres)} genres")
+
+        tags = data.pop("tags", [])
+        if tags:
+            existing_tags = set(book.tags.names())
+            new_tags = [t for t in tags if t not in existing_tags]
+            if new_tags:
+                book.tags.add(*new_tags)
+                self.stdout.write(f"  [TAGS] {book} — added {', '.join(new_tags)}")
+
+        return changed if any(changed.values()) else None

vrobbler/apps/books/management/commands/merge_koreader_scrobbles.py

@@ -0,0 +1,130 @@
+import logging
+
+from datetime import timedelta
+
+from django.core.management.base import BaseCommand
+from django.db import transaction
+
+from books.koreader import SESSION_GAP_SECONDS, fix_long_play_stats_for_scrobbles
+
+logger = logging.getLogger(__name__)
+SESSION_GAP = timedelta(seconds=SESSION_GAP_SECONDS)
+
+
+def _page_data_keys(pages):
+    return sorted(int(k) for k in (pages or {}))
+
+
+class Command(BaseCommand):
+    help = "Merge orphaned 1-page KOReader scrobbles into the preceding scrobble"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--commit",
+            action="store_true",
+            help="Commit changes to the database",
+        )
+
+    def handle(self, *args, **options):
+        from scrobbles.models import Scrobble
+
+        commit = options["commit"]
+
+        qs = Scrobble.objects.filter(
+            media_type="Book", source="KOReader"
+        ).order_by("book_id", "timestamp")
+
+        if not qs.exists():
+            self.stdout.write("No KOReader book scrobbles found.")
+            return
+
+        merged = 0
+        affected_books = set()
+
+        # Group by book_id manually since we're iterating in order
+        book_scrobbles = {}
+        for s in qs:
+            book_scrobbles.setdefault(s.book_id, []).append(s)
+
+        if not commit:
+            self.stdout.write("Dry run — no changes will be saved. Use --commit to apply.")
+
+        for book_id, scrobbles in book_scrobbles.items():
+            batch_merged = 0
+            i = 0
+            while i < len(scrobbles) - 1:
+                current = scrobbles[i]
+                orphan = scrobbles[i + 1]
+
+                orphan_pages = orphan.logdata.page_data if orphan.logdata else {}
+                orphan_keys = _page_data_keys(orphan_pages)
+                if len(orphan_keys) != 1:
+                    i += 1
+                    continue
+
+                current_pages = current.logdata.page_data if current.logdata else {}
+                current_keys = _page_data_keys(current_pages)
+                if not current_keys:
+                    i += 1
+                    continue
+
+                orphan_page_num = orphan_keys[0]
+                current_last_page = current_keys[-1]
+
+                if orphan_page_num != current_last_page + 1:
+                    i += 1
+                    continue
+
+                # Check that the orphan is close enough in time
+                gap = orphan.timestamp - current.stop_timestamp
+                if gap > SESSION_GAP:
+                    i += 1
+                    continue
+
+                # Merge orphan into current
+                current_pages[str(orphan_page_num)] = orphan_pages[str(orphan_page_num)]
+                current.log["page_data"] = current_pages
+                current.log["pages_read"] = len(current_pages)
+                current.stop_timestamp = orphan.stop_timestamp
+                current.playback_position_seconds += orphan.playback_position_seconds
+
+                affected_books.add(book_id)
+
+                if commit:
+                    with transaction.atomic():
+                        current.save(
+                            update_fields=[
+                                "log",
+                                "stop_timestamp",
+                                "playback_position_seconds",
+                            ]
+                        )
+                        orphan.delete()
+
+                merged += 1
+                batch_merged += 1
+                scrobbles.pop(i + 1)
+
+            if batch_merged:
+                self.stdout.write(
+                    f"  Book {book_id}: merged {batch_merged} orphan scrobble(s)"
+                )
+
+        self.stdout.write(f"\nTotal orphans merged: {merged}")
+
+        if commit and affected_books:
+            self.stdout.write("Recalculating long_play_stats for affected books...")
+            for book_id in affected_books:
+                scrobbles_to_fix = (
+                    Scrobble.objects.filter(book_id=book_id, source="KOReader")
+                    .order_by("timestamp")
+                )
+                fix_long_play_stats_for_scrobbles(list(scrobbles_to_fix))
+
+            self.stdout.write(f"Fixed stats for {len(affected_books)} books.")
+
+        if not commit:
+            self.stdout.write(
+                f"\nWould merge {merged} orphan scrobble(s) across "
+                f"{len(affected_books)} book(s)."
+            )

vrobbler/apps/books/migrations/0037_book_volume_book_volume_comicvine_id.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.29 on 2026-06-15 16:09
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("books", "0036_alter_book_genre_alter_paper_genre"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="book",
+            name="volume",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name="book",
+            name="volume_comicvine_id",
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]

vrobbler/apps/books/models.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Optional
 from uuid import uuid4
+from zoneinfo import ZoneInfo
 
 import requests
 from books.constants import MediaSourceTag, READCOMICSONLINE_URL
@@ -19,6 +20,7 @@ from books.openlibrary import (
 from books.sources.comicvine import (
     ComicVineClient,
     lookup_comic_from_comicvine,
+    lookup_issue_by_comicvine_id,
 )
 from books.sources.google import lookup_book_from_google
 from books.sources.openlibrary import (
@@ -71,7 +73,7 @@ class BookLogData(BaseLogData, LongPlayLogData):
     _excluded_fields = {"koreader_hash", "page_data"}
 
     def avg_seconds_per_page(self):
-        if self.page_data:
+        if self.page_data and isinstance(self.page_data, dict):
             total_duration = 0
             for page_num, stats in self.page_data.items():
                 total_duration += stats.get("duration", 0)
@@ -149,6 +151,8 @@ class Book(LongPlayScrobblableMixin):
     first_sentence = models.TextField(**BNULL)
     # ComicVine
     comicvine_id = models.CharField(max_length=255, **BNULL)
+    volume = models.CharField(max_length=255, **BNULL)
+    volume_comicvine_id = models.CharField(max_length=255, **BNULL)
     readcomics_url = models.CharField(max_length=255, **BNULL)
     next_readcomics_url = models.CharField(max_length=255, **BNULL)
     issue_number = models.IntegerField(**BNULL)
@@ -173,6 +177,9 @@ class Book(LongPlayScrobblableMixin):
     genre = TaggableManager(through=ObjectWithGenres, blank=True, verbose_name="Genre")
 
     def __str__(self) -> str:
+        if not self.subtitle:
+            return self.title
+
         return f"{self.title} - {self.subtitle}"
 
     def save(self, *args, **kwargs):
@@ -184,12 +191,18 @@ class Book(LongPlayScrobblableMixin):
 
     @property
     def subtitle(self):
-        subtitle = self.author
+        subtitle_parts = []
+        if self.author:
+            subtitle_parts.append(self.author.name)
         if self.issue_number and "Issue" not in str(self.title):
-            subtitle += " - Issue {self.issue_number}"
+            subtitle_parts.append(f"Issue {self.issue_number}")
         if self.volume_number and "Volume" not in str(self.title):
-            subtitle += " - Volume {self.volume_number}"
-        return subtitle
+            subtitle_parts.append(f"Volume {self.volume_number}")
+        if len(subtitle_parts) > 1:
+            return " / ".join(subtitle_parts)
+        if len(subtitle_parts) == 1:
+            return subtitle_parts[0]
+        return ""
 
     @property
     def strings(self) -> ScrobblableConstants:
@@ -219,36 +232,24 @@ class Book(LongPlayScrobblableMixin):
     ) -> "Book":
         book, created = cls.objects.get_or_create(title=title)
 
-        if not created:
+        if not created and not overwrite:
             return book
 
         book_dict = lookup_comic_from_comicvine(title)
+        if not book_dict:
+            return book
 
-        if created or overwrite:
-            author_list = []
-            author_dicts = book_dict.pop("author_dicts")
-            if author_dicts:
-                for author_dict in author_dicts:
-                    if author_dict.get("authorId"):
-                        author, a_created = Author.objects.get_or_create(
-                            semantic_id=author_dict.get("authorId")
-                        )
-                        author_list.append(author)
-                        if a_created:
-                            author.name = author_dict.get("name")
-                            author.save()
-                            # TODO enrich author?
-                            ...
+        tags = book_dict.pop("tags", [])
+        genres = book_dict.pop("genres", book_dict.pop("generes", []))
 
-            for k, v in book_dict.items():
-                setattr(book, k, v)
-            book.save()
+        for k, v in book_dict.items():
+            setattr(book, k, v)
+        book.save()
 
-            if author_list:
-                book.authors.add(*author_list)
-            genres = book_dict.pop("genres", [])
-            if genres:
-                book.genre.add(*genres)
+        if genres:
+            book.genre.add(*genres)
+        if tags:
+            book.tags.add(*tags)
         return book
 
     @classmethod
@@ -282,24 +283,43 @@ class Book(LongPlayScrobblableMixin):
 
         book_dict = None
         source_tag = None
+        tried_comicvine = False
         if READCOMICSONLINE_URL in url:
             book_dict = lookup_comic_from_comicvine(title)
+            tried_comicvine = True
             if book_dict:
                 source_tag = MediaSourceTag.COMICVINE
-            book_dict["readcomics_url"] = get_comic_issue_url(url)
-            book_dict["next_readcomics_url"] = next_url_if_exists(
-                book_dict["readcomics_url"]
-            )
+                book_dict["readcomics_url"] = get_comic_issue_url(url)
+                book_dict["next_readcomics_url"] = next_url_if_exists(
+                    book_dict["readcomics_url"]
+                )
 
         if not book_dict:
-            book_dict = lookup_book_from_ol(title, author=author)
-            if book_dict:
+            book_dict = {}
+            ol_data = lookup_book_from_ol(title, author=author)
+            google_data = lookup_book_from_google(title)
+
+            if ol_data:
+                book_dict.update(ol_data)
                 source_tag = MediaSourceTag.OPENLIBRARY
 
-        if not book_dict:
-            book_dict = lookup_book_from_google(title)
-            if book_dict:
+            if google_data:
+                for k, v in google_data.items():
+                    if v:
+                        book_dict.setdefault(k, v)
                 source_tag = MediaSourceTag.GOOGLE_BOOKS
+                if ol_data and ol_data.get("cover_url"):
+                    book_dict["cover_url"] = ol_data["cover_url"]
+
+        # Always try ComicVine as a fallback — it may recognize books that
+        # OL/Google don't flag as comics
+        if not tried_comicvine:
+            cv_data = lookup_comic_from_comicvine(title)
+            if cv_data:
+                for k, v in cv_data.items():
+                    if v:
+                        book_dict.setdefault(k, v)
+                source_tag = MediaSourceTag.COMICVINE
 
         if not book_dict:
             logger.warning(
@@ -311,6 +331,7 @@ class Book(LongPlayScrobblableMixin):
         authors = book_dict.pop("authors", [])
         cover_url = book_dict.pop("cover_url", "")
         genres = book_dict.pop("genres", book_dict.pop("generes", []))
+        tags = book_dict.pop("tags", [])
 
         if authors:
             for author_str in authors:
@@ -330,6 +351,8 @@ class Book(LongPlayScrobblableMixin):
             book.save_image_from_url(cover_url)
             if genres:
                 book.genre.add(*genres)
+            if tags:
+                book.tags.add(*tags)
             book.authors.add(*author_list)
             if source_tag:
                 book.tags.add(source_tag.value)
@@ -367,9 +390,14 @@ class Book(LongPlayScrobblableMixin):
                     data = lookup_comic_from_locg(str(self.title))
 
             if not data and COMICVINE_API_KEY:
-                logger.warn(f"Checking ComicVine for {self.title}")
-                cv_client = ComicVineClient(api_key=COMICVINE_API_KEY)
-                data = lookup_comic_from_comicvine(str(self.title))
+                if self.comicvine_id:
+                    logger.warn(
+                        f"Checking ComicVine by ID for {self.title}"
+                    )
+                    data = lookup_issue_by_comicvine_id(str(self.comicvine_id))
+                if not data:
+                    logger.warn(f"Checking ComicVine for {self.title}")
+                    data = lookup_comic_from_comicvine(str(self.title))
 
             if not data:
                 logger.warn(f"Book not found in any sources: {self.title}")
@@ -407,10 +435,10 @@ class Book(LongPlayScrobblableMixin):
                 )
                 data.pop("pages")
 
-            # Pop this, so we can look it up later
+            # Pop these so they don't get passed to update()
             cover_url = data.pop("cover_url", "")
-
             subject_key_list = data.pop("subject_key_list", [])
+            tags = data.pop("tags", [])
 
             # Fun trick for updating all fields at once
             Book.objects.filter(pk=self.id).update(**data)
@@ -418,6 +446,8 @@ class Book(LongPlayScrobblableMixin):
 
             if subject_key_list:
                 self.genre.add(*subject_key_list)
+            if tags:
+                self.tags.add(*tags)
 
             if cover_url:
                 r = requests.get(cover_url)
@@ -463,8 +493,11 @@ class Book(LongPlayScrobblableMixin):
             if scrobble.logdata.page_data:
                 for page, data in scrobble.logdata.page_data.items():
                     if convert_timestamps:
-                        data["start_ts"] = datetime.fromtimestamp(data["start_ts"])
-                        data["end_ts"] = datetime.fromtimestamp(data["end_ts"])
+                        tz = None
+                        if scrobble.timezone:
+                            tz = ZoneInfo(scrobble.timezone)
+                        data["start_ts"] = datetime.fromtimestamp(data["start_ts"], tz=tz)
+                        data["end_ts"] = datetime.fromtimestamp(data["end_ts"], tz=tz)
                     pages[page] = data
         sorted_pages = OrderedDict(
             sorted(pages.items(), key=lambda x: x[1]["start_ts"])

vrobbler/apps/books/sources/comicvine.py

@@ -17,8 +17,10 @@ class ComicVineClient(object):
     account on https://comicvine.gamespot.com/ in order to obtain an API key.
     """
 
-    # All API requests made by this client will be made to this URL.
-    API_URL = "https://www.comicvine.com/api/search/"
+    # All API requests made by this client will be made to these URLs.
+    API_URL = "https://comicvine.gamespot.com/api/search/"
+    ISSUE_API_URL = "https://comicvine.gamespot.com/api/issue/4000-{issue_id}/"
+    VOLUME_API_URL = "https://comicvine.gamespot.com/api/volume/4050-{volume_id}/"
 
     # A valid User-Agent header must be set in order for our API requests to
     # be accepted, otherwise our request will be rejected with a
@@ -41,15 +43,12 @@ class ComicVineClient(object):
         "volume",
     }
 
-    def __init__(self, api_key, expire_after=300):
+    def __init__(self, api_key):
         """
-        Store the API key in a class variable, and install the requests cache,
-        configuring it using the ``expire_after`` parameter.
+        Store the API key in a class variable.
 
         :param api_key: Your personal ComicVine API key.
         :type  api_key: str
-        :param expire_after: The number of seconds to retain an entry in cache.
-        :type  expire_after: int or None
         """
 
         self.api_key = api_key
@@ -109,14 +108,17 @@ class ComicVineClient(object):
         :rtype:  dict
         """
 
-        return {
+        params = {
             "api_key": self.api_key,
             "format": "json",
             "limit": min(10, limit),  # hard limit of 10
             "offset": max(0, offset),  # cannot provide negative offset
             "query": query,
-            "resources": self._validate_resources(resources),
         }
+        validated = self._validate_resources(resources)
+        if validated:
+            params["resources"] = validated
+        return params
 
     def _validate_resources(self, resources):
         """
@@ -141,33 +143,35 @@ class ComicVineClient(object):
     def _query_api(self, params):
         """
         Query the ComicVine API's ``search`` resource, providing the required
-        headers and parameters with the request. Optionally allow the caller
-        of the function to disable the request cache.
+        headers and parameters with the request.
 
         If an error occurs during the request, handle it accordingly. Upon
         success, return the JSON from the response.
 
         :param params: Parameters to include with the request.
         :type  params: dict
-        :param use_cache: Toggle the use of requests_cache.
-        :type  use_cache: bool
 
         :return: The JSON contained in the response.
         :rtype:  dict
         """
 
-        # Since we're performing the identical action regardless of whether
-        # or not the request cache is to be used, store the procedure in a
-        # local function to avoid repetition.
-        def __httpget():
-            response = requests.get(self.API_URL, headers=self.HEADERS, params=params)
+        response = requests.get(self.API_URL, headers=self.HEADERS, params=params)
 
-            if not response.ok:
-                self._handle_http_error(response)
+        if not response.ok:
+            self._handle_http_error(response)
 
-            return response.json()
+        json_data = response.json()
 
-        return __httpget()
+        if json_data.get("status_code") != 1:
+            error_msg = json_data.get("error", "Unknown ComicVine API error")
+            logger.error(
+                "ComicVine API returned status_code %s: %s",
+                json_data.get("status_code"),
+                error_msg,
+            )
+            return {}
+
+        return json_data
 
     def _handle_http_error(self, response):
         """
@@ -195,15 +199,81 @@ class ComicVineClient(object):
 
         raise exception(message)
 
+    def get_issue(self, issue_id: str) -> dict:
+        """
+        Fetch a single issue by its ComicVine ID directly from the issue detail
+        endpoint, which returns richer data than the search endpoint.
+
+        :param issue_id: The ComicVine numeric ID for the issue (e.g. "538480")
+        :type  issue_id: str
+
+        :return: The full JSON response for the issue, or empty dict on failure.
+        :rtype:  dict
+        """
+        params = {
+            "api_key": self.api_key,
+            "format": "json",
+        }
+        url = self.ISSUE_API_URL.format(issue_id=issue_id)
+        response = requests.get(url, headers=self.HEADERS, params=params)
+
+        if not response.ok:
+            self._handle_http_error(response)
+
+        json_data = response.json()
+
+        if json_data.get("status_code") != 1:
+            error_msg = json_data.get("error", "Unknown ComicVine API error")
+            logger.error(
+                "ComicVine API returned status_code %s: %s",
+                json_data.get("status_code"),
+                error_msg,
+            )
+            return {}
+
+        return json_data.get("results", {})
+
+    def get_volume(self, volume_id: str) -> dict:
+        """
+        Fetch a single volume by its ComicVine ID from the volume detail
+        endpoint. Used to get publisher info and other volume-level metadata.
+
+        :param volume_id: The ComicVine numeric ID for the volume (e.g. "91273")
+        :type  volume_id: str
+
+        :return: The full JSON response for the volume, or empty dict on failure.
+        :rtype:  dict
+        """
+        params = {
+            "api_key": self.api_key,
+            "format": "json",
+        }
+        url = self.VOLUME_API_URL.format(volume_id=volume_id)
+        response = requests.get(url, headers=self.HEADERS, params=params)
+
+        if not response.ok:
+            self._handle_http_error(response)
+
+        json_data = response.json()
+
+        if json_data.get("status_code") != 1:
+            error_msg = json_data.get("error", "Unknown ComicVine API error")
+            logger.error(
+                "ComicVine API returned status_code %s: %s",
+                json_data.get("status_code"),
+                error_msg,
+            )
+            return {}
+
+        return json_data.get("results", {})
+
 
 def lookup_comic_from_comicvine(title: str) -> dict:
     original_title = title
 
     issue_number = None
-    volume_nubmer = None
     resource_type = "issue"
     if "Issue " in title:
-        resource_type = "issue"
         issue_number = title.split("Issue ")[1]
     volume_number = None
     if "Volume " in title:
@@ -215,48 +285,136 @@ def lookup_comic_from_comicvine(title: str) -> dict:
         logger.warning("No ComicVine API key configured, not looking anything up")
         return {}
 
-    client = ComicVineClient(api_key=getattr(settings, "COMICVINE_API_KEY", None))
+    client = ComicVineClient(api_key=api_key)
 
-    raw_results = client.search(title).get("results")
-    results = [r for r in raw_results if r.get("resource_type") == resource_type]
+    raw_results = client.search(title)
+    if not raw_results:
+        return {}
+    results = raw_results.get("results", [])
+    results = [r for r in results if r.get("resource_type") == resource_type]
     if not results:
         logger.warning("No comic found on ComicVine")
         return {}
 
     found_result = None
     for result in results:
-        if result.get("issue_number") == str(issue_number):
+        if issue_number is not None and result.get("issue_number") == str(issue_number):
             found_result = result
             break
-        if result.get("volume_number") == str(volume_number):
+        if volume_number is not None and result.get("volume_number") == str(volume_number):
             found_result = result
             break
 
     if not found_result:
         found_result = results[0]
 
-    logger.info("ComicVine results", extra={"results": results})
+    data_dict = _build_data_dict_from_issue(found_result, original_title)
+    _enrich_with_volume_data(client, data_dict)
+    return data_dict
 
-    if not found_result:
-        logger.warning("No matches found on ComicVine")
+
+def lookup_issue_by_comicvine_id(comicvine_id: str) -> dict:
+    """
+    Look up an issue directly by its ComicVine ID using the issue detail
+    endpoint. Returns richer data than the search-based lookup.
+
+    :param comicvine_id: The ComicVine numeric ID for the issue (e.g. "538480")
+    :type  comicvine_id: str
+
+    :return: A dict of extracted book metadata, or empty dict on failure.
+    :rtype:  dict
+    """
+    if not comicvine_id:
         return {}
 
-    title = found_result.get("name")
+    api_key = getattr(settings, "COMICVINE_API_KEY", "")
+    if not api_key:
+        logger.warning("No ComicVine API key configured, not looking anything up")
+        return {}
 
-    if found_result.get("volume"):
-        title = found_result.get("volume").get("name")
+    client = ComicVineClient(api_key=api_key)
+    issue_data = client.get_issue(comicvine_id)
+    if not issue_data:
+        logger.warning("No issue found on ComicVine for ID %s", comicvine_id)
+        return {}
+
+    data_dict = _build_data_dict_from_issue(issue_data, issue_data.get("name", ""))
+    _enrich_with_volume_data(client, data_dict)
+    return data_dict
+
+
+def _build_data_dict_from_issue(issue_data: dict, original_title: str = "") -> dict:
+    """
+    Build a book metadata dict from a ComicVine issue resource (either from
+    search results or issue detail endpoint). Both return the same shape of
+    issue data.
+
+    :param issue_data: The issue resource dict from ComicVine.
+    :param original_title: The original search term, if any.
+
+    :return: A dict of extracted book metadata.
+    :rtype:  dict
+    """
+    title = issue_data.get("name")
+    if issue_data.get("volume"):
+        title = issue_data.get("volume").get("name")
+
+    cover_url = None
+    if issue_data.get("image"):
+        cover_url = issue_data["image"].get("original_url")
+
+    volume_name = None
+    volume_cv_id = None
+    publisher_name = None
+    volume_data = issue_data.get("volume")
+    if volume_data:
+        volume_name = volume_data.get("name")
+        volume_cv_id = volume_data.get("id")
+        publisher_data = volume_data.get("publisher")
+        if publisher_data:
+            publisher_name = publisher_data.get("name")
 
     data_dict = {
         "title": title,
         "original_title": original_title,
-        "issue_number": found_result.get("issue_number"),
-        "volume_number": found_result.get("volume_number"),
-        "cover_url": found_result.get("image").get("original_url"),
-        "comicvine_id": found_result.get("id"),
-        "comicvine_data": found_result,
-        "summary": found_result.get("description"),
-        "publish_date": found_result.get("cover_date"),
-        "first_publish_year": found_result.get("cover_date", "")[:4],
+        "issue_number": issue_data.get("issue_number"),
+        "volume_number": issue_data.get("volume_number"),
+        "volume": volume_name,
+        "volume_comicvine_id": volume_cv_id,
+        "publisher": publisher_name,
+        "cover_url": cover_url,
+        "comicvine_id": issue_data.get("id"),
+        "summary": issue_data.get("description"),
+        "publish_date": issue_data.get("cover_date"),
+        "first_publish_year": (issue_data.get("cover_date") or "")[:4],
+        "tags": ["comicbook"],
     }
 
     return data_dict
+
+
+def _enrich_with_volume_data(client: ComicVineClient, data_dict: dict) -> None:
+    """
+    Follow-up a successful issue lookup by fetching the volume detail and
+    filling in publisher and other volume-level metadata that the issue
+    endpoint doesn't provide.
+
+    :param client: An initialised ComicVineClient instance.
+    :param data_dict: The data dict from an issue lookup (mutated in place).
+    """
+    volume_cv_id = data_dict.get("volume_comicvine_id")
+    if not volume_cv_id:
+        return
+
+    volume_data = client.get_volume(str(volume_cv_id))
+    if not volume_data:
+        return
+
+    publisher_data = volume_data.get("publisher")
+    if publisher_data:
+        publisher_name = publisher_data.get("name")
+        if publisher_name and not data_dict.get("publisher"):
+            data_dict["publisher"] = publisher_name
+
+    if not data_dict.get("volume"):
+        data_dict["volume"] = volume_data.get("name")

vrobbler/apps/books/sources/google.py

@@ -26,8 +26,6 @@ def lookup_book_from_google(title: str) -> dict:
     if not google_result:
         return {}
 
-    publish_date = pendulum.parse(google_result.get("publishedDate"))
-
     isbn_13 = ""
     isbn_10 = ""
     for ident in google_result.get("industryIdentifiers", []):
@@ -35,25 +33,25 @@ def lookup_book_from_google(title: str) -> dict:
             isbn_13 = ident.get("identifier")
         if ident.get("type") == "ISBN_10":
             isbn_10 = ident.get("identifier")
-    # TODO this may lead to issues with the first get if Google changes our title
-    # book_metadata.title = google_result.get("title")
-    # if google_result.get("subtitle"):
-    #    book_metadata["title"] = ": ".join(
-    #        [google_result.get("title"), google_result.get("subtitle")]
-    #    )
-    # book_dict["subtitle"] = google_result.get("subtitle")
     book_dict["authors"] = google_result.get("authors")
     book_dict["publisher"] = google_result.get("publisher")
-    book_dict["first_publish_year"] = publish_date.year
     book_dict["pages"] = google_result.get("pageCount")
     book_dict["isbn_13"] = isbn_13
     book_dict["isbn_10"] = isbn_10
-    book_dict["publish_date"] = google_result.get("publishedDate")
-    if len(book_dict["publish_date"]) == 4:
-        book_dict["publish_date"] = f"{book_dict['publish_date']}-1-1"
     book_dict["language"] = google_result.get("language")
     book_dict["summary"] = google_result.get("description")
     book_dict["genres"] = google_result.get("categories")
+
+    raw_date = google_result.get("publishedDate")
+    if raw_date:
+        try:
+            publish_date = pendulum.parse(raw_date)
+            book_dict["first_publish_year"] = publish_date.year
+        except Exception:
+            pass
+        book_dict["publish_date"] = raw_date
+        if len(raw_date) == 4:
+            book_dict["publish_date"] = f"{raw_date}-1-1"
     book_dict["cover_url"] = (
         google_result.get("imageLinks", {})
         .get("thumbnail", "")

vrobbler/apps/books/tests/conftest.py

@@ -32,8 +32,6 @@ class KoReaderBookRows:
     DEFAULT_STR = "N/A"
     DEFAULT_INT = 0
     DEFAULT_TIME = 1703800469
-    BOOK_ROWS = []
-    PAGE_STATS_ROWS = []
 
     def _gen_random_row(self, i):
         wiggle = random.randrange(15)
@@ -110,6 +108,8 @@ class KoReaderBookRows:
                     end_session = True
 
     def __init__(self, book_count=0, **kwargs):
+        self.BOOK_ROWS = []
+        self.PAGE_STATS_ROWS = []
         self._generate_random_book_rows(book_count)
         self._generate_custom_book_row(**kwargs)
         self._generate_random_page_stats_rows()

vrobbler/apps/books/tests/test_koreader.py

@@ -44,7 +44,10 @@ def test_build_scrobbles_from_pages(get_mock, koreader_rows, demo_user, valid_re
     book_map = build_page_data(koreader_rows.PAGE_STATS_ROWS, book_map)
 
     scrobbles = build_scrobbles_from_book_map(book_map, demo_user)
-    # Corresponds to number of sessions per book ( 20 pages per session, 120 +/- 15 pages read )
+    # The test data generator adds the session-gap 3600s AFTER the trigger page
+    # (not before), so the first session includes 21 pages (1-21), and each
+    # subsequent session has 20 until the last. The last page is now included
+    # in the final scrobble instead of being orphaned.
     expected_scrobbles = 6 * len(book_map.keys())
     assert len(scrobbles) == expected_scrobbles
     assert len(scrobbles[0].logdata.page_data.keys()) == 21
@@ -52,7 +55,7 @@ def test_build_scrobbles_from_pages(get_mock, koreader_rows, demo_user, valid_re
     assert len(scrobbles[2].logdata.page_data.keys()) == 20
     assert len(scrobbles[3].logdata.page_data.keys()) == 20
     assert len(scrobbles[4].logdata.page_data.keys()) == 20
-    assert len(scrobbles[5].logdata.page_data.keys()) == 18
+    assert len(scrobbles[5].logdata.page_data.keys()) == 19
 
 
 def test_get_author_str_from_row():

vrobbler/apps/charts/migrations/0002_chartrecord_charts_char_user_id_1adcde_idx_and_more.py

@@ -0,0 +1,146 @@
+# Generated by Django 4.2.29 on 2026-06-12 16:09
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("charts", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "album", "rank"],
+                name="charts_char_user_id_1adcde_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "track", "rank"],
+                name="charts_char_user_id_d18aab_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "video", "rank"],
+                name="charts_char_user_id_de9f0a_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "board_game", "rank"],
+                name="charts_char_user_id_d5d58f_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "book", "rank"],
+                name="charts_char_user_id_e877cf_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "food", "rank"],
+                name="charts_char_user_id_a0ad71_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "podcast", "rank"],
+                name="charts_char_user_id_846b80_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "trail", "rank"],
+                name="charts_char_user_id_54feba_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "week", "album", "rank"],
+                name="charts_char_user_id_a3dc49_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "week", "track", "rank"],
+                name="charts_char_user_id_4b01ab_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "week", "video", "rank"],
+                name="charts_char_user_id_2ac9d2_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "week", "board_game", "rank"],
+                name="charts_char_user_id_ba968a_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "week", "book", "rank"],
+                name="charts_char_user_id_e66751_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "week", "food", "rank"],
+                name="charts_char_user_id_d23f06_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "week", "podcast", "rank"],
+                name="charts_char_user_id_be8122_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "week", "trail", "rank"],
+                name="charts_char_user_id_b94ea9_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "day", "artist", "rank"],
+                name="charts_char_user_id_406e0e_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "day", "album", "rank"],
+                name="charts_char_user_id_322b0d_idx",
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="chartrecord",
+            index=models.Index(
+                fields=["user", "year", "month", "day", "tv_series", "rank"],
+                name="charts_char_user_id_aa44b7_idx",
+            ),
+        ),
+    ]

vrobbler/apps/charts/models.py

@@ -60,10 +60,29 @@ class ChartRecord(TimeStampedModel):
             models.Index(fields=["user", "year", "geo_location", "rank"]),
             models.Index(fields=["user", "year", "food", "rank"]),
             models.Index(fields=["user", "year", "book", "rank"]),
-            models.Index(fields=["user", "year", "week", "artist", "rank"]),
-            models.Index(fields=["user", "year", "week", "tv_series", "rank"]),
             models.Index(fields=["user", "year", "month", "artist", "rank"]),
+            models.Index(fields=["user", "year", "month", "album", "rank"]),
+            models.Index(fields=["user", "year", "month", "track", "rank"]),
             models.Index(fields=["user", "year", "month", "tv_series", "rank"]),
+            models.Index(fields=["user", "year", "month", "video", "rank"]),
+            models.Index(fields=["user", "year", "month", "board_game", "rank"]),
+            models.Index(fields=["user", "year", "month", "book", "rank"]),
+            models.Index(fields=["user", "year", "month", "food", "rank"]),
+            models.Index(fields=["user", "year", "month", "podcast", "rank"]),
+            models.Index(fields=["user", "year", "month", "trail", "rank"]),
+            models.Index(fields=["user", "year", "week", "artist", "rank"]),
+            models.Index(fields=["user", "year", "week", "album", "rank"]),
+            models.Index(fields=["user", "year", "week", "track", "rank"]),
+            models.Index(fields=["user", "year", "week", "tv_series", "rank"]),
+            models.Index(fields=["user", "year", "week", "video", "rank"]),
+            models.Index(fields=["user", "year", "week", "board_game", "rank"]),
+            models.Index(fields=["user", "year", "week", "book", "rank"]),
+            models.Index(fields=["user", "year", "week", "food", "rank"]),
+            models.Index(fields=["user", "year", "week", "podcast", "rank"]),
+            models.Index(fields=["user", "year", "week", "trail", "rank"]),
+            models.Index(fields=["user", "year", "month", "day", "artist", "rank"]),
+            models.Index(fields=["user", "year", "month", "day", "album", "rank"]),
+            models.Index(fields=["user", "year", "month", "day", "tv_series", "rank"]),
         ]
 
     @property

vrobbler/apps/charts/templatetags/chart_tags.py

@@ -7,7 +7,10 @@ register = template.Library()
 def get_item(dictionary, key):
     if isinstance(dictionary, dict):
         return dictionary.get(key)
-    return None
+    try:
+        return dictionary[int(key)]
+    except (IndexError, KeyError, TypeError, ValueError):
+        return None
 
 
 @register.filter

vrobbler/apps/charts/views.py

@@ -114,108 +114,106 @@ class ChartRecordView(TemplateView):
         context["current_week"] = current_week
         context["current_day"] = current_day
 
-        if chart_type == "maloja":
-            context["chart_keys"] = {
-                "today": "Today",
-                "week": "This Week",
-                "month": "This Month",
-                "year": "This Year",
-                "all": "All Time",
-            }
+        context["chart_keys"] = {
+            "today": "Today",
+            "week": "This Week",
+            "month": "This Month",
+            "year": "This Year",
+            "all": "All Time",
+        }
 
-            context["maloja_charts"] = {
-                "artist": {
-                    "today": list(
-                        self.get_charts_for_period(
-                            user,
-                            "artist",
-                            year=current_year,
-                            month=current_month,
-                            day=current_day,
-                        )
-                    ),
-                    "week": list(
-                        self.get_charts_for_period(
-                            user,
-                            "artist",
-                            year=current_year,
-                            week=current_week,
-                        )
-                    ),
-                    "month": list(
-                        self.get_charts_for_period(
-                            user,
-                            "artist",
-                            year=current_year,
-                            month=current_month,
-                        )
-                    ),
-                    "year": list(
-                        self.get_charts_for_period(user, "artist", year=current_year)
-                    ),
-                    "all": list(self.get_charts_for_period(user, "artist")),
-                },
-                "track": {
-                    "today": list(
-                        self.get_charts_for_period(
-                            user,
-                            "track",
-                            year=current_year,
-                            month=current_month,
-                            day=current_day,
-                        )
-                    ),
-                    "week": list(
-                        self.get_charts_for_period(
-                            user, "track", year=current_year, week=current_week
-                        )
-                    ),
-                    "month": list(
-                        self.get_charts_for_period(
-                            user,
-                            "track",
-                            year=current_year,
-                            month=current_month,
-                        )
-                    ),
-                    "year": list(
-                        self.get_charts_for_period(user, "track", year=current_year)
-                    ),
-                    "all": list(self.get_charts_for_period(user, "track")),
-                },
-                "tv_series": {
-                    "today": list(
-                        self.get_charts_for_period(
-                            user,
-                            "tv_series",
-                            year=current_year,
-                            month=current_month,
-                            day=current_day,
-                        )
-                    ),
-                    "week": list(
-                        self.get_charts_for_period(
-                            user,
-                            "tv_series",
-                            year=current_year,
-                            week=current_week,
-                        )
-                    ),
-                    "month": list(
-                        self.get_charts_for_period(
-                            user,
-                            "tv_series",
-                            year=current_year,
-                            month=current_month,
-                        )
-                    ),
-                    "year": list(
-                        self.get_charts_for_period(user, "tv_series", year=current_year)
-                    ),
-                    "all": list(self.get_charts_for_period(user, "tv_series")),
-                },
-            }
-            return context
+        context["maloja_charts"] = {
+            "artist": {
+                "today": list(
+                    self.get_charts_for_period(
+                        user,
+                        "artist",
+                        year=current_year,
+                        month=current_month,
+                        day=current_day,
+                    )
+                ),
+                "week": list(
+                    self.get_charts_for_period(
+                        user,
+                        "artist",
+                        year=current_year,
+                        week=current_week,
+                    )
+                ),
+                "month": list(
+                    self.get_charts_for_period(
+                        user,
+                        "artist",
+                        year=current_year,
+                        month=current_month,
+                    )
+                ),
+                "year": list(
+                    self.get_charts_for_period(user, "artist", year=current_year)
+                ),
+                "all": list(self.get_charts_for_period(user, "artist")),
+            },
+            "album": {
+                "today": list(
+                    self.get_charts_for_period(
+                        user,
+                        "album",
+                        year=current_year,
+                        month=current_month,
+                        day=current_day,
+                    )
+                ),
+                "week": list(
+                    self.get_charts_for_period(
+                        user, "album", year=current_year, week=current_week
+                    )
+                ),
+                "month": list(
+                    self.get_charts_for_period(
+                        user,
+                        "album",
+                        year=current_year,
+                        month=current_month,
+                    )
+                ),
+                "year": list(
+                    self.get_charts_for_period(user, "album", year=current_year)
+                ),
+                "all": list(self.get_charts_for_period(user, "album")),
+            },
+            "tv_series": {
+                "today": list(
+                    self.get_charts_for_period(
+                        user,
+                        "tv_series",
+                        year=current_year,
+                        month=current_month,
+                        day=current_day,
+                    )
+                ),
+                "week": list(
+                    self.get_charts_for_period(
+                        user,
+                        "tv_series",
+                        year=current_year,
+                        week=current_week,
+                    )
+                ),
+                "month": list(
+                    self.get_charts_for_period(
+                        user,
+                        "tv_series",
+                        year=current_year,
+                        month=current_month,
+                    )
+                ),
+                "year": list(
+                    self.get_charts_for_period(user, "tv_series", year=current_year)
+                ),
+                "all": list(self.get_charts_for_period(user, "tv_series")),
+            },
+        }
 
         if not date_param:
             context["period"] = "current"
@@ -440,12 +438,14 @@ class ChartRecordView(TemplateView):
         return context
 
     def get_available_years(self, user):
-        return list(
-            ChartRecord.objects.filter(user=user)
-            .values_list("year", flat=True)
-            .distinct()
-            .order_by("-year")
-        )
+        if not hasattr(self, "_available_years"):
+            self._available_years = list(
+                ChartRecord.objects.filter(user=user)
+                .values_list("year", flat=True)
+                .distinct()
+                .order_by("-year")
+            )
+        return self._available_years
 
     def get_period_type(self):
         date_param = self.request.GET.get("date")

vrobbler/apps/foods/admin.py

@@ -21,6 +21,7 @@ class FoodAdmin(admin.ModelAdmin):
         "uuid",
         "title",
     )
+    raw_id_fields = ("category",)
     ordering = ("-created",)
     search_fields = ("title",)
     inlines = [

vrobbler/apps/people/admin.py

@@ -6,6 +6,7 @@ from people.models import Person, PersonScrobble
 class PersonAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     list_display = ("name", "bgg_username", "bgstats_id")
+    raw_id_fields = ("user", "created_by")
     ordering = ("-created",)
     search_fields = ("name",)
 

vrobbler/apps/podcasts/admin.py

@@ -18,6 +18,7 @@ class PodcastAdmin(admin.ModelAdmin):
         "producer",
         "active",
     )
+    raw_id_fields = ("producer",)
     ordering = ("name",)
 
 
@@ -28,6 +29,7 @@ class PodcastEpisodeAdmin(admin.ModelAdmin):
         "title",
         "podcast",
     )
+    raw_id_fields = ("podcast",)
     list_filter = ("podcast",)
     ordering = ("-created",)
     inlines = [

vrobbler/apps/profiles/admin.py

@@ -6,6 +6,7 @@ from profiles.models import UserProfile
 @admin.register(UserProfile)
 class UserProfileAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
+    raw_id_fields = ("user",)
     ordering = ("-created",)
     readonly_fields = ("timezone_change_log",)
     exclude = (

vrobbler/apps/profiles/forms.py

@@ -1,6 +1,8 @@
 from django import forms
 
 from profiles.models import UserProfile
+from scrobbles.constants import Visibility
+from scrobbles.models import Scrobble
 
 
 class UserProfileForm(forms.ModelForm):
@@ -45,3 +47,51 @@ class UserProfileForm(forms.ModelForm):
             "archivebox_password": forms.PasswordInput(render_value=True),
             "webdav_pass": forms.PasswordInput(render_value=True),
         }
+
+
+MEDIA_TYPE_LABELS = {
+    mt.value: mt.label for mt in Scrobble.MediaType
+}
+
+INHERIT = ""
+
+
+class BulkVisibilityForm(forms.Form):
+    bulk_action = forms.ChoiceField(
+        choices=[
+            (Visibility.PUBLIC, "Public"),
+            (Visibility.PRIVATE, "Private"),
+        ],
+        widget=forms.RadioSelect,
+        required=False,
+        label="Set all non-shared scrobbles to",
+    )
+
+    def __init__(self, *args, **kwargs):
+        self.profile = kwargs.pop("profile")
+        super().__init__(*args, **kwargs)
+        media_types = Scrobble.MediaType.values
+        choices = [
+            (Visibility.PUBLIC, "Public"),
+            (Visibility.SHARED, "Shared"),
+            (Visibility.PRIVATE, "Private"),
+        ]
+        existing_overrides = self.profile.media_type_visibility or {}
+        for mt in sorted(media_types):
+            label = MEDIA_TYPE_LABELS.get(mt, mt)
+            self.fields[f"media_type_{mt}"] = forms.ChoiceField(
+                choices=choices,
+                required=False,
+                label=label,
+                initial=existing_overrides.get(mt, Visibility.PRIVATE),
+            )
+
+    def clean(self):
+        cleaned = super().clean()
+        overrides = {}
+        for mt in Scrobble.MediaType.values:
+            val = cleaned.get(f"media_type_{mt}")
+            if val:
+                overrides[mt] = val
+        cleaned["media_type_visibility"] = overrides
+        return cleaned

vrobbler/apps/profiles/migrations/0038_userprofile_media_type_visibility.py

@@ -0,0 +1,20 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("profiles", "0037_alter_userprofile_default_scrobble_visibility"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="media_type_visibility",
+            field=models.JSONField(
+                blank=True,
+                default=dict,
+                help_text='Per-media-type visibility overrides, e.g. {"Video": "public", "Track": "private"}',
+            ),
+        ),
+    ]

vrobbler/apps/profiles/models.py

@@ -90,6 +90,12 @@ class UserProfile(TimeStampedModel):
         default="private",
     )
 
+    media_type_visibility = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Per-media-type visibility overrides, e.g. {\"Video\": \"public\", \"Track\": \"private\"}",
+    )
+
     home_scrobble_limit = models.IntegerField(default=20)
 
     weigh_in_units = models.CharField(
@@ -134,6 +140,11 @@ class UserProfile(TimeStampedModel):
         return history
 
     def get_timestamp_with_tz(self, timestamp):
+        from django.conf import settings
+
+        server_tz = ZoneInfo(settings.TIME_ZONE)
+        ref_dt = timestamp if timestamp.tzinfo is not None else timestamp.replace(tzinfo=server_tz)
+
         timezone = self.tzinfo
         if self.timezone_change_log:
             change_list = self.historic_timezone_changes
@@ -144,13 +155,13 @@ class UserProfile(TimeStampedModel):
                     end = None
 
                 if end:
-                    if start <= timestamp.replace(tzinfo=end.timezone) <= end:
+                    if start <= ref_dt <= end:
                         timezone = start.timezone
                 else:
-                    if start <= timestamp.replace(tzinfo=start.timezone):
+                    if start <= ref_dt:
                         timezone = start.timezone
 
-        return timestamp.replace(tzinfo=timezone)
+        return ref_dt.astimezone(timezone)
 
     def adjust_timezone_of_scrobbles(self, commit=False):
         current_dt = None

vrobbler/apps/profiles/urls.py

@@ -6,4 +6,9 @@ app_name = "profiles"
 
 urlpatterns = [
     path("settings/", views.ProfileFormView.as_view(), name="profile_settings"),
+    path(
+        "settings/visibility/",
+        views.BulkVisibilityView.as_view(),
+        name="bulk_visibility",
+    ),
 ]

vrobbler/apps/profiles/views.py

@@ -1,8 +1,12 @@
+from django.contrib import messages
 from django.contrib.auth.mixins import LoginRequiredMixin
+from django.db.models import Count, Q
 from django.http.response import HttpResponseBadRequest
 from django.urls import reverse_lazy
 from django.views.generic import FormView
-from profiles.forms import UserProfileForm
+from profiles.forms import BulkVisibilityForm, UserProfileForm
+from scrobbles.constants import Visibility
+from scrobbles.models import Scrobble
 from tasks.todoist import generate_todoist_oauth_url
 
 
@@ -30,3 +34,46 @@ class ProfileFormView(LoginRequiredMixin, FormView):
         context["profile"] = self.request.user.profile
         context["todoist_oauth_url"] = generate_todoist_oauth_url(self.request.user.id)
         return context
+
+
+class BulkVisibilityView(LoginRequiredMixin, FormView):
+    template_name = "profiles/visibility_settings.html"
+    form_class = BulkVisibilityForm
+    success_url = reverse_lazy("profiles:bulk_visibility")
+
+    def get_form_kwargs(self):
+        kwargs = super().get_form_kwargs()
+        kwargs["profile"] = self.request.user.profile
+        return kwargs
+
+    def form_valid(self, form):
+        request = self.request
+        profile = request.user.profile
+
+        bulk_action = form.cleaned_data.get("bulk_action")
+        if bulk_action:
+            qs = Scrobble.objects.filter(
+                user=request.user,
+            ).exclude(visibility=Visibility.SHARED)
+            total = qs.count()
+            qs.update(visibility=bulk_action)
+            messages.success(
+                request,
+                f"Updated {total} scrobble(s) to {bulk_action}.",
+            )
+
+        profile.media_type_visibility = form.cleaned_data["media_type_visibility"]
+        profile.save(update_fields=["media_type_visibility"])
+        messages.success(request, "Per-media-type visibility overrides saved.")
+        return super().form_valid(form)
+
+    def get_context_data(self, **kwargs):
+        ctx = super().get_context_data(**kwargs)
+        profile = self.request.user.profile
+        qs = Scrobble.objects.filter(user=self.request.user)
+        ctx["scrobble_count"] = qs.count()
+        ctx["visibility_counts"] = qs.values("visibility").annotate(
+            count=Count("id")
+        )
+        ctx["profile"] = profile
+        return ctx

vrobbler/apps/puzzles/admin.py

@@ -21,6 +21,7 @@ class PuzzleAdmin(admin.ModelAdmin):
         "uuid",
         "title",
     )
+    raw_id_fields = ("manufacturer",)
     ordering = ("-created",)
     search_fields = ("title",)
     inlines = [

vrobbler/apps/scrobbles/admin.py

@@ -19,35 +19,11 @@ from scrobbles.mixins import Genre
 class ScrobbleInline(admin.TabularInline):
     model = Scrobble
     extra = 0
-    raw_id_fields = (
-        "video",
-        "channel",
-        "podcast_episode",
-        "track",
-        "video_game",
-        "book",
-        "paper",
-        "sport_event",
-        "food",
-        "board_game",
-        "geo_location",
-        "task",
-        "puzzle",
-        "mood",
-        "brick_set",
-        "trail",
-        "beer",
-        "web_page",
-        "life_event",
-        "birding_location",
-        "user",
-    )
-    exclude = (
-        "scrobble_log",
-        "timezone",
-        "videogame_save_data",
-        "screenshot",
-    )
+    per_page = 15
+    ordering = ("-timestamp",)
+    show_change_link = True
+    fields = ("timestamp", "media_type", "source", "in_progress")
+    readonly_fields = fields
 
 
 class ImportBaseAdmin(admin.ModelAdmin):
@@ -121,7 +97,9 @@ class ScrobbleAdmin(admin.ModelAdmin):
         "user",
     )
     raw_id_fields = (
+        "user",
         "video",
+        "channel",
         "podcast_episode",
         "track",
         "sport_event",
@@ -140,6 +118,7 @@ class ScrobbleAdmin(admin.ModelAdmin):
         "web_page",
         "life_event",
         "birding_location",
+        "long_play_last_scrobble",
     )
     list_filter = (
         "is_paused",
@@ -152,6 +131,7 @@ class ScrobbleAdmin(admin.ModelAdmin):
         "user",
     )
     ordering = ("-timestamp",)
+    readonly_fields = ("share_token_version", "share_view_count")
 
     def media_name(self, obj):
         return obj.media_obj
@@ -178,14 +158,19 @@ class FavoriteMediaAdmin(admin.ModelAdmin):
     list_filter = ("media_type", "sent_to_mopidy", "user")
     date_hierarchy = "created"
     raw_id_fields = (
+        "user",
         "video",
+        "channel",
         "track",
         "podcast_episode",
         "sport_event",
         "book",
+        "paper",
         "video_game",
         "board_game",
         "geo_location",
+        "puzzle",
+        "food",
         "task",
         "mood",
         "brick_set",

vrobbler/apps/scrobbles/dataclasses.py

@@ -207,7 +207,7 @@ class BaseLogData(JSONDataclass):
 
 @dataclass
 class LongPlayLogData(JSONDataclass):
-    long_play_complete: bool = False
+    pass
 
 
 @dataclass

vrobbler/apps/scrobbles/importers/webdav.py

@@ -153,7 +153,7 @@ def scan_webdav_for_koreader(
     )
 
     if update_etag_only:
-        if last_import and remote_etag:
+        if last_import and remote_etag and hasattr(last_import, "webdav_etag"):
             last_import.webdav_etag = remote_etag
             last_import.save(update_fields=["webdav_etag"])
             logger.info(
@@ -163,7 +163,7 @@ def scan_webdav_for_koreader(
             )
         return 0
 
-    if last_import and last_import.webdav_etag and remote_etag:
+    if last_import and getattr(last_import, "webdav_etag", None) and remote_etag:
         if last_import.webdav_etag == remote_etag:
             logger.info(
                 "koreader stats file unchanged (ETag match)",

vrobbler/apps/scrobbles/management/commands/recompute_long_play_seconds.py

@@ -0,0 +1,174 @@
+from django.core.management.base import BaseCommand
+from django.db import connection
+
+from scrobbles.constants import LONG_PLAY_MEDIA
+from scrobbles.models import Scrobble
+
+BATCH_SIZE = 1000
+
+
+class Command(BaseCommand):
+    help = (
+        "Backfill long_play_last_scrobble FK chains, then recompute "
+        "long_play_seconds by walking forward through scrobbles in "
+        "timestamp order with a running accumulator."
+    )
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show what would be changed without making changes",
+        )
+        parser.add_argument(
+            "--media-type",
+            type=str,
+            help="Only process a specific media type (e.g., Book, VideoGame)",
+        )
+
+    def handle(self, *args, **options):
+        dry_run = options["dry_run"]
+        media_type = options.get("media_type")
+
+        media_types = list(LONG_PLAY_MEDIA.values())
+        if media_type:
+            if media_type not in media_types:
+                self.stdout.write(
+                    self.style.ERROR(
+                        f"Invalid media type '{media_type}'. "
+                        f"Valid: {', '.join(media_types)}"
+                    )
+                )
+                return
+            media_types = [media_type]
+
+        # Step 1: backfill long_play_last_scrobble
+        self.stdout.write("Step 1: Backfilling long_play_last_scrobble chains...")
+        total_backfilled = 0
+        for mt in media_types:
+            n = self._backfill_chain(mt, dry_run)
+            total_backfilled += n
+            self.stdout.write(f"  {mt}: {n} scrobbles linked")
+
+        if dry_run:
+            self.stdout.write(
+                self.style.WARNING(
+                    f"Would backfill {total_backfilled} scrobbles total. "
+                    "Run without --dry-run to apply."
+                )
+            )
+        else:
+            self.stdout.write(
+                self.style.SUCCESS(f"Backfilled {total_backfilled} scrobbles")
+            )
+
+        # Step 2: recompute long_play_seconds
+        self.stdout.write(
+            "\nStep 2: Recomputing long_play_seconds in timestamp order..."
+        )
+
+        total_updated = 0
+        for mt in media_types:
+            n = self._recompute_for_media_type(mt, dry_run)
+            total_updated += n
+            self.stdout.write(f"  {mt}: {n} scrobbles updated")
+
+        if dry_run:
+            self.stdout.write(
+                self.style.WARNING(
+                    f"Dry run: would update {total_updated} scrobbles total. "
+                    "Use without --dry-run to apply."
+                )
+            )
+        else:
+            self.stdout.write(
+                self.style.SUCCESS(f"Updated {total_updated} scrobbles")
+            )
+
+    def _recompute_for_media_type(self, media_type: str, dry_run: bool) -> int:
+        """Process scrobbles for a single media type in timestamp order with a
+        running accumulator, avoiding O(n2) FK chain walks."""
+        fk = _media_type_to_fk(media_type)
+        fk_id = f"{fk}_id"
+
+        scrobbles = Scrobble.objects.filter(
+            media_type=media_type,
+            **{f"{fk}__isnull": False},
+            playback_position_seconds__isnull=False,
+        ).order_by(fk_id, "user_id", "timestamp")
+
+        total = scrobbles.count()
+        if not total:
+            return 0
+
+        updated = 0
+        batch = []
+        last_key = None
+        running_total = 0
+
+        for scrobble in scrobbles.iterator():
+            key = (getattr(scrobble, fk_id), scrobble.user_id)
+
+            if key != last_key:
+                running_total = 0
+                last_key = key
+
+            running_total += scrobble.playback_position_seconds or 0
+
+            if scrobble.long_play_seconds != running_total:
+                updated += 1
+                if not dry_run:
+                    scrobble.long_play_seconds = running_total
+                    batch.append(scrobble)
+                    if len(batch) >= BATCH_SIZE:
+                        Scrobble.objects.bulk_update(batch, ["long_play_seconds"])
+                        batch = []
+
+            if scrobble.long_play_complete:
+                running_total = 0
+
+        if batch:
+            Scrobble.objects.bulk_update(batch, ["long_play_seconds"])
+
+        return updated
+
+    def _backfill_chain(self, media_type: str, dry_run: bool) -> int:
+        """Set long_play_last_scrobble on each scrobble to the previous
+        scrobble for the same media+user using a single UPDATE with a
+        correlated subquery."""
+        fk = _media_type_to_fk(media_type)
+        table = Scrobble._meta.db_table
+
+        if dry_run:
+            with connection.cursor() as cursor:
+                cursor.execute(
+                    f"SELECT COUNT(*) FROM {table} "
+                    f"WHERE long_play_last_scrobble_id IS NULL "
+                    f"AND {fk}_id IS NOT NULL"
+                )
+                return cursor.fetchone()[0]
+
+        with connection.cursor() as cursor:
+            cursor.execute(
+                f"UPDATE {table} "
+                f"SET long_play_last_scrobble_id = ("
+                f"  SELECT id FROM {table} AS prev "
+                f"  WHERE prev.{fk}_id = {table}.{fk}_id "
+                f"    AND prev.user_id = {table}.user_id "
+                f"    AND prev.timestamp < {table}.timestamp "
+                f"  ORDER BY prev.timestamp DESC LIMIT 1"
+                f") "
+                f"WHERE long_play_last_scrobble_id IS NULL "
+                f"AND {fk}_id IS NOT NULL"
+            )
+            return cursor.rowcount
+
+
+def _media_type_to_fk(media_type):
+    mapping = {
+        "VideoGame": "video_game",
+        "Book": "book",
+        "BrickSet": "brick_set",
+        "Task": "task",
+    }
+    return mapping.get(media_type)

vrobbler/apps/scrobbles/migrations/0096_convert_book_page_data_to_dict.py

@@ -0,0 +1,35 @@
+from django.db import migrations
+
+
+def convert_page_data_to_dict(apps, schema_editor):
+    Scrobble = apps.get_model("scrobbles", "Scrobble")
+    for scrobble in Scrobble.objects.filter(media_type="Book").exclude(
+        log__page_data=None
+    ):
+        page_data = scrobble.log.get("page_data")
+        if isinstance(page_data, list):
+            new_page_data = {}
+            for entry in page_data:
+                page_num = entry.get("page_number")
+                if page_num is not None:
+                    try:
+                        page_num = int(page_num)
+                    except (ValueError, TypeError):
+                        continue
+                    new_page_data[page_num] = entry
+            scrobble.log["page_data"] = new_page_data
+            scrobble.save(update_fields=["log"])
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("scrobbles", "0095_backfill_null_visibility"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            convert_page_data_to_dict,
+            reverse_code=migrations.RunPython.noop,
+        ),
+    ]

vrobbler/apps/scrobbles/migrations/0097_scrobble_scrobbles_s_user_id_d367a7_idx.py

@@ -0,0 +1,19 @@
+# Generated by Django 4.2.29 on 2026-06-12 16:09
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("scrobbles", "0096_convert_book_page_data_to_dict"),
+    ]
+
+    operations = [
+        migrations.AddIndex(
+            model_name="scrobble",
+            index=models.Index(
+                fields=["user", "-timestamp"], name="scrobbles_s_user_id_d367a7_idx"
+            ),
+        ),
+    ]

vrobbler/apps/scrobbles/migrations/0098_scrobble_long_play_last_scrobble.py

@@ -0,0 +1,25 @@
+# Generated by Django 4.2.29 on 2026-06-15 17:48
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("scrobbles", "0097_scrobble_scrobbles_s_user_id_d367a7_idx"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="scrobble",
+            name="long_play_last_scrobble",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="next_long_play_scrobbles",
+                to="scrobbles.scrobble",
+            ),
+        ),
+    ]

vrobbler/apps/scrobbles/mixins.py

@@ -165,23 +165,18 @@ class LongPlayScrobblableMixin(ScrobblableMixin):
         return reverse("scrobbles:longplay-finish", kwargs={"uuid": self.uuid})
 
     def first_long_play_scrobble_for_user(self, user) -> Optional["Scrobble"]:
-        return (
-            get_scrobbles_for_media(self, user)
-            .filter(
-                log__long_play_complete=False,
-                log__serial_scrobble_id__isnull=True,
-            )
-            .order_by("timestamp")
-            .first()
-        )
+        last = self.last_long_play_scrobble_for_user(user)
+        if not last:
+            return None
+        current = last
+        while current.long_play_last_scrobble and not current.long_play_last_scrobble.long_play_complete:
+            current = current.long_play_last_scrobble
+        return current
 
     def last_long_play_scrobble_for_user(self, user) -> Optional["Scrobble"]:
         return (
             get_scrobbles_for_media(self, user)
-            .filter(
-                log__long_play_complete=False,
-                log__serial_scrobble_id__isnull=False,
-            )
-            .order_by("timestamp")
-            .last()
+            .filter(long_play_complete=False)
+            .order_by("-timestamp")
+            .first()
         )

vrobbler/apps/scrobbles/models.py

@@ -225,7 +225,9 @@ class KoReaderImport(BaseFileImportMixin):
 
         self.mark_started()
         try:
-            scrobbles = process_koreader_sqlite_file(self.upload_file_path, self.user.id)
+            scrobbles = process_koreader_sqlite_file(
+                self.upload_file_path, self.user.id
+            )
             self.record_log(scrobbles)
         except Exception as e:
             self.record_error(f"Import failed: {e}")
@@ -272,7 +274,9 @@ class AudioScrobblerTSVImport(BaseFileImportMixin):
 
         self.mark_started()
         try:
-            scrobbles = import_audioscrobbler_tsv_file(self.upload_file_path, self.user.id)
+            scrobbles = import_audioscrobbler_tsv_file(
+                self.upload_file_path, self.user.id
+            )
             self.record_log(scrobbles)
         except Exception as e:
             self.record_error(f"Import failed: {e}")
@@ -608,6 +612,30 @@ class EBirdCSVImport(BaseFileImportMixin):
             self.mark_finished()
 
 
+TYPE_FK_PREFETCHES: dict[str, tuple[str, ...]] = {
+    "Video": ("video",),
+    "Track": ("track", "track__artist_fk"),
+    "PodcastEpisode": ("podcast_episode", "podcast_episode__podcast"),
+    "SportEvent": ("sport_event",),
+    "Book": ("book",),
+    "Paper": ("paper",),
+    "VideoGame": ("video_game",),
+    "BoardGame": ("board_game",),
+    "GeoLocation": ("geo_location",),
+    "Trail": ("trail",),
+    "Beer": ("beer",),
+    "Puzzle": ("puzzle",),
+    "Food": ("food",),
+    "Task": ("task",),
+    "WebPage": ("web_page",),
+    "LifeEvent": ("life_event",),
+    "Mood": ("mood",),
+    "BrickSet": ("brick_set",),
+    "Channel": ("channel",),
+    "BirdingLocation": ("birding_location",),
+}
+
+
 class ScrobbleQuerySet(models.QuerySet):
     def with_related(self):
         return self.select_related("user").prefetch_related(
@@ -634,6 +662,13 @@ class ScrobbleQuerySet(models.QuerySet):
             "birding_location",
         )
 
+    def with_related_for_types(self, media_types: list[str]):
+        prefetches = []
+        for t in media_types:
+            if t in TYPE_FK_PREFETCHES:
+                prefetches.extend(TYPE_FK_PREFETCHES[t])
+        return self.select_related("user").prefetch_related(*prefetches)
+
 
 class ShareViewLog(TimeStampedModel):
     scrobble = models.ForeignKey(
@@ -760,6 +795,12 @@ class Scrobble(TimeStampedModel):
     )
     long_play_seconds = models.BigIntegerField(**BNULL)
     long_play_complete = models.BooleanField(**BNULL)
+    long_play_last_scrobble = models.ForeignKey(
+        "self",
+        **BNULL,
+        on_delete=models.SET_NULL,
+        related_name="next_long_play_scrobbles",
+    )
 
     class Meta:
         indexes = [
@@ -774,6 +815,7 @@ class Scrobble(TimeStampedModel):
                     "is_paused",
                 ]
             ),
+            models.Index(fields=["user", "-timestamp"]),
         ]
 
     @classmethod
@@ -806,11 +848,14 @@ class Scrobble(TimeStampedModel):
     @classmethod
     def as_dict_by_type(cls, scrobble_qs: models.QuerySet) -> dict:
         scrobbles_by_type = defaultdict(list)
-        scrobbles = (
-            scrobble_qs.with_related()
-            if hasattr(scrobble_qs, "with_related")
-            else scrobble_qs
-        )
+
+        if hasattr(scrobble_qs, "with_related"):
+            media_types_present = list(
+                scrobble_qs.values_list("media_type", flat=True).distinct()
+            )
+            scrobbles = scrobble_qs.with_related_for_types(media_types_present)
+        else:
+            scrobbles = scrobble_qs
 
         for scrobble in scrobbles:
             scrobbles_by_type[scrobble.media_type].append(scrobble)
@@ -825,7 +870,7 @@ class Scrobble(TimeStampedModel):
 
         # Remove any locations without titles
         if "GeoLocation" in scrobbles_by_type.keys():
-            for loc_scrobble in scrobbles_by_type["GeoLocation"]:
+            for loc_scrobble in list(scrobbles_by_type["GeoLocation"]):
                 if not loc_scrobble.media_obj.title:
                     scrobbles_by_type["GeoLocation"].remove(loc_scrobble)
                     scrobbles_by_type["GeoLocation_count"] -= 1
@@ -936,6 +981,8 @@ class Scrobble(TimeStampedModel):
             logdata_cls = logdata.BaseLogData
 
         log_dict = self.log
+        if isinstance(log_dict, logdata.BaseLogData):
+            log_dict = log_dict.asdict
         if isinstance(self.log, str):
             # There's nothing stopping django from saving a string in a JSONField :(
             logger.warning(
@@ -1141,8 +1188,8 @@ class Scrobble(TimeStampedModel):
 
         if self.is_long_play:
             long_play_secs = 0
-            if self.previous and not self.previous.long_play_complete:
-                long_play_secs = self.previous.long_play_seconds or 0
+            if self.long_play_last_scrobble and not self.long_play_last_scrobble.long_play_complete:
+                long_play_secs = self.long_play_last_scrobble.long_play_seconds or 0
             percent = int(((playback_seconds + long_play_secs) / run_time_secs) * 100)
 
         return percent
@@ -1412,20 +1459,18 @@ class Scrobble(TimeStampedModel):
                 or scrobble_data["playback_status"] == "stopped"
             ):
                 if read_log_page:
-                    page_list = scrobble.log.get("page_data", [])
-                    if page_list:
-                        for page in page_list:
+                    page_data = scrobble.log.get("page_data", {})
+                    if page_data:
+                        for page_num, page in page_data.items():
                             if not page.get("end_ts", None):
                                 page["end_ts"] = int(timezone.now().timestamp())
                                 page["duration"] = page["end_ts"] - page.get("start_ts")
 
-                    page_list.append(
-                        BookPageLogData(
-                            page_number=read_log_page,
-                            start_ts=int(timezone.now().timestamp()),
-                        )
+                    page_data[read_log_page] = BookPageLogData(
+                        page_number=read_log_page,
+                        start_ts=int(timezone.now().timestamp()),
                     )
-                    scrobble.log["page_data"] = page_list
+                    scrobble.log["page_data"] = page_data
                     scrobble.save(update_fields=["log"])
                 elif "log" in scrobble_data.keys() and scrobble.log:
                     scrobble_data["log"] = scrobble.log | scrobble_data["log"]
@@ -1436,13 +1481,13 @@ class Scrobble(TimeStampedModel):
 
         if read_log_page:
             scrobble_data["log"] = BookLogData(
-                page_data=[
-                    BookPageLogData(
+                page_data={
+                    read_log_page: BookPageLogData(
                         page_number=read_log_page,
                         start_ts=int(timezone.now().timestamp()),
                     )
-                ]
-            )
+                }
+            ).asdict
 
         logger.info(
             f"[scrobbling] creating new scrobble",
@@ -1457,9 +1502,27 @@ class Scrobble(TimeStampedModel):
             "calories", None
         ):
             if media.calories:
-                scrobble_data["log"] = FoodLogData(calories=media.calories)
+                scrobble_data["log"] = FoodLogData(calories=media.calories).asdict
+
+        if mtype not in LONG_PLAY_MEDIA.values():
+            scrobble_data.pop("long_play_complete", None)
 
         scrobble = cls.create(scrobble_data)
+
+        if mtype in LONG_PLAY_MEDIA.values():
+            last_finished = (
+                cls.objects.filter(
+                    models.Q(**{key: media}),
+                    user_id=user_id,
+                    timestamp__lt=scrobble.timestamp,
+                )
+                .order_by("-timestamp")
+                .first()
+            )
+            if last_finished:
+                scrobble.long_play_last_scrobble = last_finished
+                scrobble.save(update_fields=["long_play_last_scrobble"])
+
         return scrobble
 
     @classmethod
@@ -1613,7 +1676,17 @@ class Scrobble(TimeStampedModel):
         scrobble_data: dict,
     ) -> "Scrobble":
         if "visibility" not in scrobble_data:
-            scrobble_data["visibility"] = Visibility.PRIVATE
+            user = scrobble_data.get("user")
+            media_type = scrobble_data.get("media_type")
+            override = None
+            if user and media_type:
+                try:
+                    profile = user.profile
+                    overrides = profile.media_type_visibility or {}
+                    override = overrides.get(media_type)
+                except user.__class__.profile.RelatedObjectDoesNotExist:
+                    pass
+            scrobble_data["visibility"] = override or Visibility.PRIVATE
         scrobble = cls.objects.create(**scrobble_data)
         if not (
             scrobble.media_type == cls.MediaType.GEO_LOCATION
@@ -1708,8 +1781,8 @@ class Scrobble(TimeStampedModel):
 
         # Set our playback seconds, and calc long play seconds
         self.playback_position_seconds = seconds_elapsed
-        if self.previous:
-            past_seconds = self.previous.long_play_seconds or 0
+        if self.long_play_last_scrobble:
+            past_seconds = self.long_play_last_scrobble.long_play_seconds or 0
 
         self.long_play_seconds = past_seconds + seconds_elapsed
 
@@ -1770,33 +1843,27 @@ class Scrobble(TimeStampedModel):
         return False
 
     def calculate_reading_stats(self, commit=True):
-        page_data = self.log.get("page_data")
+        page_data = self.logdata.page_data
 
         if page_data:
-            # --- Sort safely by numeric page_number ---
-            def safe_page_number(entry):
-                try:
-                    return int(getattr("page_number", entry), 0)
-                except (ValueError, TypeError):
-                    return float("inf")
-
             if isinstance(page_data, dict):
-                logger.warning("Page data is dict, migrate koreader data")
-                return
+                valid_pages = sorted(int(k) for k in page_data.keys())
+                if valid_pages:
+                    self.log["page_start"] = min(valid_pages)
+                    self.log["page_end"] = max(valid_pages)
+                    self.log["pages_read"] = len(set(valid_pages))
+            elif isinstance(page_data, list):
+                valid_pages = []
+                for page in page_data:
+                    try:
+                        valid_pages.append(int(page["page_number"]))
+                    except (ValueError, TypeError):
+                        continue
 
-            page_data.sort(key=safe_page_number)
-
-            valid_pages = []
-            for page in page_data:
-                try:
-                    valid_pages.append(int(page["page_number"]))
-                except (ValueError, TypeError):
-                    continue
-
-            if valid_pages:
-                self.log["page_start"] = min(valid_pages)
-                self.log["page_end"] = max(valid_pages)
-                self.log["pages_read"] = len(set(valid_pages))
+                if valid_pages:
+                    self.log["page_start"] = min(valid_pages)
+                    self.log["page_end"] = max(valid_pages)
+                    self.log["pages_read"] = len(set(valid_pages))
         else:
             page_start = self.log.get("page_start")
             page_end = self.log.get("page_end")
@@ -1836,9 +1903,7 @@ class FavoriteMedia(TimeStampedModel):
     birding_location = models.ForeignKey(
         BirdingLocation, on_delete=models.CASCADE, **BNULL
     )
-    media_type = models.CharField(
-        max_length=20, choices=Scrobble.MediaType.choices
-    )
+    media_type = models.CharField(max_length=20, choices=Scrobble.MediaType.choices)
     sent_to_mopidy = models.BooleanField(default=False)
 
     class Meta:

vrobbler/apps/scrobbles/scrobblers.py

@@ -357,10 +357,7 @@ def manual_scrobble_book(
 
     if action == "stop":
         if url:
-            if isinstance(scrobble.log, "BookLogData"):
-                scrobble.log.resume_url = next_url_if_exists(url)
-            else:
-                scrobble.log["resume_url"] = next_url_if_exists(url)
+            scrobble.log["resume_url"] = next_url_if_exists(url)
             scrobble.save(update_fields=["log"])
         scrobble.stop(force_finish=True)
 
@@ -540,6 +537,7 @@ def email_scrobble_board_game(
             "playback_position_seconds": duration_seconds,
             "source": "BG Stats",
             "log": log_data,
+            "visibility": "private",
         }
 
         scrobble = None
@@ -1152,7 +1150,7 @@ def web_scrobbler_scrobble_video_or_song(
     artist_name = data_dict.get("artist")
     track_name = data_dict.get("track")
     tracks = Track.objects.filter(
-        artist__name=data_dict.get("artist"), title=data_dict.get("track")
+        artist_fk__name=data_dict.get("artist"), title=data_dict.get("track")
     )
     if tracks.count() > 1:
         logger.warning(

vrobbler/apps/scrobbles/views.py

@@ -206,6 +206,19 @@ class ScrobbleableDetailView(ChartContextMixin, DetailView):
         context_data["scrobbles"] = page_obj.object_list
         context_data["is_paginated"] = paginator.num_pages > 1
 
+        media = self.object
+        if hasattr(media, "is_long_play_media") and media.is_long_play_media():
+            qs = media.scrobble_set.filter(user=self.request.user)
+            completed = qs.filter(long_play_complete=True).order_by("-timestamp").first()
+            if completed and completed.long_play_seconds:
+                context_data["long_play_total_seconds"] = completed.long_play_seconds
+                context_data["long_play_finished_date"] = completed.timestamp
+            else:
+                latest_finished = qs.filter(played_to_completion=True).order_by("-timestamp").first()
+                if latest_finished and latest_finished.long_play_seconds:
+                    context_data["long_play_total_seconds"] = latest_finished.long_play_seconds
+                context_data["long_play_finished_date"] = None
+
         return context_data
 
 
@@ -371,6 +384,9 @@ class ScrobbleListView(LoginRequiredMixin, ListView):
                 qs = qs.filter(id__in=matching_ids).distinct()
         else:
             tag_list = []
+        visibility_param = self.request.GET.get("visibility", "")
+        if visibility_param in ("public", "shared", "private"):
+            qs = qs.filter(visibility=visibility_param)
         self.tag_list = tag_list
         self._full_queryset = qs
         return qs
@@ -906,6 +922,28 @@ def scrobble_longplay_finish(request, uuid):
     if not user.is_authenticated:
         return HttpResponseRedirect(success_url)
 
+    # Try scrobble UUID first
+    scrobble = Scrobble.objects.filter(uuid=uuid, user=user).first()
+    if scrobble:
+        if scrobble.long_play_complete == True:
+            scrobble.long_play_complete = None
+            scrobble.save(update_fields=["long_play_complete"])
+            messages.add_message(
+                request,
+                messages.INFO,
+                f"Long play of {scrobble.media_obj} marked as not complete.",
+            )
+        else:
+            scrobble.long_play_complete = True
+            scrobble.save(update_fields=["long_play_complete"])
+            messages.add_message(
+                request,
+                messages.SUCCESS,
+                f"Long play of {scrobble.media_obj} finished.",
+            )
+        return HttpResponseRedirect(success_url)
+
+    # Fall back to media UUID (existing behavior)
     media_obj = None
     for app, model in LONG_PLAY_MEDIA.items():
         media_model = apps.get_model(app_label=app, model_name=model)
@@ -914,10 +952,21 @@ def scrobble_longplay_finish(request, uuid):
             break
 
     if not media_obj:
-        return
+        messages.add_message(
+            request, messages.ERROR, f"Media with uuid {uuid} not found."
+        )
+        return HttpResponseRedirect(success_url)
 
     last_scrobble = media_obj.last_long_play_scrobble_for_user(user)
-    if last_scrobble and last_scrobble.long_play_complete == False:
+    if last_scrobble and last_scrobble.long_play_complete == True:
+        last_scrobble.long_play_complete = None
+        last_scrobble.save(update_fields=["long_play_complete"])
+        messages.add_message(
+            request,
+            messages.INFO,
+            f"Long play of {media_obj} marked as not complete.",
+        )
+    elif last_scrobble:
         last_scrobble.long_play_complete = True
         last_scrobble.save(update_fields=["long_play_complete"])
         messages.add_message(
@@ -1261,6 +1310,24 @@ class ScrobbleDetailView(DetailView):
         else:
             context["has_mopidy_uri"] = False
 
+        if self.object.is_long_play and fk_field:
+            all_scrobbles = Scrobble.objects.filter(
+                user=user, **{fk_field: media_obj}
+            )
+            completed = all_scrobbles.filter(
+                long_play_complete=True
+            ).order_by("-timestamp").first()
+            if completed and completed.long_play_seconds:
+                context["long_play_total_seconds"] = completed.long_play_seconds
+                context["long_play_finished_date"] = completed.timestamp
+            else:
+                latest_finished = all_scrobbles.filter(
+                    played_to_completion=True
+                ).order_by("-timestamp").first()
+                if latest_finished and latest_finished.long_play_seconds:
+                    context["long_play_total_seconds"] = latest_finished.long_play_seconds
+                context["long_play_finished_date"] = None
+
         return context
 
 

vrobbler/apps/sports/admin.py

@@ -23,6 +23,7 @@ class SportAdmin(admin.ModelAdmin):
 class LeagueAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     list_display = ("name", "abbreviation_str")
+    raw_id_fields = ("sport",)
     ordering = ("name",)
 
 
@@ -30,6 +31,7 @@ class LeagueAdmin(admin.ModelAdmin):
 class PlayerAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     list_display = ("name", "league", "team")
+    raw_id_fields = ("league", "team")
     ordering = ("name",)
 
 
@@ -37,6 +39,7 @@ class PlayerAdmin(admin.ModelAdmin):
 class SeasonAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     list_display = ("name", "league")
+    raw_id_fields = ("league",)
     ordering = ("name",)
 
 
@@ -44,6 +47,7 @@ class SeasonAdmin(admin.ModelAdmin):
 class RoundAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     list_display = ("name", "season")
+    raw_id_fields = ("season",)
     ordering = ("name",)
 
 
@@ -51,6 +55,7 @@ class RoundAdmin(admin.ModelAdmin):
 class TeamAdmin(admin.ModelAdmin):
     date_hierarchy = "created"
     list_display = ("name", "league")
+    raw_id_fields = ("league",)
     ordering = ("name",)
 
 
@@ -63,6 +68,7 @@ class SportEventAdmin(admin.ModelAdmin):
         "event_type",
         "comp_str",
     )
+    raw_id_fields = ("league", "teams", "players", "round")
     list_filter = ("league", "event_type")
     ordering = ("-created",)
     inlines = [

vrobbler/apps/videogames/admin.py

@@ -26,6 +26,7 @@ class GameAdmin(admin.ModelAdmin):
         "main_story_time",
         "release_year",
     )
+    raw_id_fields = ("platforms",)
     search_fields = (
         "title",
         "alternative_name",

vrobbler/settings.py

@@ -145,7 +145,7 @@ CELERY_BEAT_SCHEDULE = {
     },
     "import-from-webdav": {
         "task": "scrobbles.tasks.import_from_webdav_all_users",
-        "schedule": crontab(minute="*/3"),
+        "schedule": crontab(minute="*/2"),
     },
     # Deprecated: BG Stats files now picked up from WebDAV var/bgstats/
     # "import-from-imap": {

vrobbler/templates/_longplay_scrobblable_list.html

@@ -6,23 +6,29 @@
         <tr>
             <th scope="col">Latest</th>
             <th scope="col">Title</th>
+            <th scope="col">Time</th>
             <th scope="col">Scrobbles</th>
             <th scope="col">Complete</th>
             <th scope="col">Start</th>
+            <th scope="col">Finish</th>
         </tr>
     </thead>
     <tbody>
         {% for obj in object_list %}
         {% if obj.title %}
+        {% with last=obj.scrobble_set.last %}
         <tr>
-            <td><a href="{{obj.scrobble_set.last.get_absolute_url}}">{{obj.scrobble_set.last.local_timestamp}}
+            <td><a href="{{last.get_absolute_url}}">{{last.local_timestamp}}
             <td><a href="{{obj.get_absolute_url}}">{{obj}}</a></td>
             {% if request.user.is_authenticated %}
+            <td>{% if last.long_play_seconds %}{{ last.long_play_seconds|natural_duration }}{% elif last.elapsed_time %}{{ last.elapsed_time|natural_duration }}{% endif %}</td>
             <td>{{obj.scrobble_count}}</td>
-            <td>{% if obj.scrobble_set.last.logdata.long_play_complete == True %}Yes{% endif %}</td>
+            <td>{% if obj.scrobble_set.last.long_play_complete == True %}Yes{% else %}No{% endif %}</td>
             <td><a type="button" class="btn btn-sm btn-primary" href="{{obj.start_url}}">Scrobble</a></td>
+            <td><a type="button" class="btn btn-sm btn-warning" href="{{obj.get_longplay_finish_url}}">Finish</a></td>
             {% endif %}
         </tr>
+        {% endwith %}
         {% endif %}
         {% endfor %}
     </tbody>

vrobbler/templates/base_list.html

@@ -15,6 +15,7 @@
               <a href="{% url 'charts:charts-home' %}" class="btn btn-sm btn-outline-secondary">Charts</a>
             </div>
             {% endif %}
+            {% block grid_view_button %}
             <div class="btn-group me-2">
                 {% if view == 'grid' %}
                 <button type="button" class="btn btn-sm btn-outline-secondary"><a href="?{% urlreplace view='list' %}">List View</a>
@@ -22,6 +23,7 @@
                 <button type="button" class="btn btn-sm btn-outline-secondary"><a href="?{% urlreplace view='grid' %}">Grid View</a>
                 {% endif %}
             </div>
+            {% endblock %}
             {% block charts_button %}{% endblock %}
         </div>
     </div>

vrobbler/templates/books/book_detail.html

@@ -33,7 +33,11 @@
     <p><a href="{{object.next_readcomics_url}}">Read next issue</a></p>
     {% endif %}
 
-    <p>{{scrobbles.count}} scrobbles</p>
+    <p>
+        {{scrobbles.count}} scrobbles
+        {% if long_play_total_seconds %} | Total time: {{ long_play_total_seconds|natural_duration }}{% endif %}
+        {% if long_play_finished_date %} | Finished: {{ long_play_finished_date|date:"M d, Y" }}{% endif %}
+    </p>
 
     <p><a href="{{object.resume_start_url}}">Resume reading</a></p>
 </div>
@@ -61,7 +65,7 @@
                     {% for scrobble in scrobbles.all|dictsortreversed:"timestamp" %}
                     <tr>
                         <td><a href="{{scrobble.get_absolute_url}}">{{scrobble.local_timestamp}}</a></td>
-                        <td>{% if scrobble.logdata.long_play_complete == True %}Yes{% endif %}</td>
+                        <td>{% if scrobble.long_play_complete == True %}Yes <small><a href="{% url 'scrobbles:longplay-finish' uuid=scrobble.uuid %}">(not complete?)</a></small>{% else %}<a href="{% url 'scrobbles:longplay-finish' uuid=scrobble.uuid %}">No</a>{% endif %}</td>
                         <td>{% if scrobble.in_progress %}Now reading{% else %}{{scrobble.session_pages_read}}{% endif %}</td>
                         <td>{% for author in scrobble.book.authors.all %}<a href="{{author.get_absolute_url}}">{{author}}</a>{% if not forloop.last %}, {% endif %}{% endfor %}</td>
                     </tr>

vrobbler/templates/bricksets/brickset_detail.html

@@ -26,7 +26,11 @@
     </div>
 </div>
 <div class="row">
-    <p>{{scrobbles.count}} scrobbles</p>
+    <p>
+        {{scrobbles.count}} scrobbles
+        {% if long_play_total_seconds %} | Total time: {{ long_play_total_seconds|natural_duration }}{% endif %}
+        {% if long_play_finished_date %} | Finished: {{ long_play_finished_date|date:"M d, Y" }}{% endif %}
+    </p>
 </div>
 <div class="row">
     <div class="col-md">
@@ -44,7 +48,7 @@
                     {% for scrobble in scrobbles.all|dictsortreversed:"timestamp" %}
                     <tr>
                         <td><a href="{{scrobble.get_absolute_url}}">{{scrobble.local_timestamp}}</a></td>
-                        <td>{% if scrobble.logdata.long_play_complete == True %}Yes{% endif %}</td>
+                        <td>{% if scrobble.long_play_complete == True %}Yes <small><a href="{% url 'scrobbles:longplay-finish' uuid=scrobble.uuid %}">(not complete?)</a></small>{% else %}<a href="{% url 'scrobbles:longplay-finish' uuid=scrobble.uuid %}">No</a>{% endif %}</td>
                         <td>{% if scrobble.in_progress %}Now reading{% else %}{{scrobble.session_pages_read}}{% endif %}</td>
                     </tr>
                     {% endfor %}

vrobbler/templates/charts/chart_index.html

@@ -1,4 +1,5 @@
 {% extends "base_list.html" %}
+{% load static %}
 
 {% block title %}Charts{% if period_str %} - {{ period_str }}{% endif %}{% endblock %}
 
@@ -12,11 +13,46 @@
     .nav-tabs {
         cursor: pointer;
     }
+    .image-wrapper {
+        contain: content;
+    }
+    .image-wrapper :hover {
+        background: rgba(0,0,0,0.3);
+    }
+    .caption {
+        position: fixed;
+        top: 5px;
+        left: 5px;
+        padding: 3px;
+        font-size: 90%;
+        color: white;
+        background: rgba(0,0,0,0.4);
+    }
+    .caption-medium {
+        position: fixed;
+        top: 5px;
+        left: 5px;
+        padding: 3px;
+        font-size: 75%;
+        color: white;
+        background: rgba(0,0,0,0.4);
+    }
+    .caption-small {
+        position: fixed;
+        top: 5px;
+        left: 5px;
+        padding: 3px;
+        font-size: 60%;
+        color: white;
+        background: rgba(0,0,0,0.4);
+    }
 </style>
 {% endblock %}
 
 {% block lists %}
 
+{% block grid_view_button %}{% endblock %}
+
 <div class="row mb-3">
     <div class="col-12">
         <a href="{% url 'charts:spotify-tracks' %}" class="btn btn-sm btn-outline-secondary">🎵 Spotify Tracks</a>
@@ -24,10 +60,6 @@
     </div>
 </div>
 
-{% if chart_type == "maloja" %}
-{% include "scrobbles/_top_charts.html" %}
-{% else %}
-
 <div class="row">
     <div class="col-12">
         <div class="btn-group mb-3" role="group">
@@ -88,43 +120,9 @@
 </div>
 {% endif %}
 
+{% include "scrobbles/_top_charts.html" %}
+
 <div class="row">
-    {% if charts.artist %}
-    <div class="col-md-6 col-lg-4 chart-section">
-        <h3>🎤 Top Artists</h3>
-        <ul class="list-group">
-            {% for chart in charts.artist|slice:":20" %}
-            <li class="list-group-item d-flex justify-content-between align-items-center">
-                <span class="me-2"><strong>#{{chart.rank}}</strong></span>
-                <a href="{{chart.artist.get_absolute_url}}">{{chart.artist.name}}</a>
-                <span class="badge bg-primary rounded-pill">{{chart.count}}</span>
-            </li>
-            {% endfor %}
-            <li class="list-group-item">
-                <a href="{% url 'charts:chart-detail' 'artist' %}">View all &raquo;</a>
-            </li>
-        </ul>
-    </div>
-    {% endif %}
-
-    {% if charts.album %}
-    <div class="col-md-6 col-lg-4 chart-section">
-        <h3>💿 Top Albums</h3>
-        <ul class="list-group">
-            {% for chart in charts.album|slice:":20" %}
-            <li class="list-group-item d-flex justify-content-between align-items-center">
-                <span class="me-2"><strong>#{{chart.rank}}</strong></span>
-                <a href="{{chart.album.get_absolute_url}}">{{chart.album.name}}</a>
-                <span class="badge bg-primary rounded-pill">{{chart.count}}</span>
-            </li>
-            {% endfor %}
-            <li class="list-group-item">
-                <a href="{% url 'charts:chart-detail' 'album' %}">View all &raquo;</a>
-            </li>
-        </ul>
-    </div>
-    {% endif %}
-
     {% if charts.track %}
     <div class="col-md-6 col-lg-4 chart-section">
         <h3>🎵 Top Tracks</h3>
@@ -143,24 +141,6 @@
     </div>
     {% endif %}
 
-    {% if charts.tv_series %}
-    <div class="col-md-6 col-lg-4 chart-section">
-        <h3>📺 Top TV Series</h3>
-        <ul class="list-group">
-            {% for chart in charts.tv_series|slice:":20" %}
-            <li class="list-group-item d-flex justify-content-between align-items-center">
-                <span class="me-2"><strong>#{{chart.rank}}</strong></span>
-                <a href="{{chart.tv_series.get_absolute_url}}">{{chart.tv_series.name}}</a>
-                <span class="badge bg-primary rounded-pill">{{chart.count}}</span>
-            </li>
-            {% endfor %}
-            <li class="list-group-item">
-                <a href="{% url 'charts:chart-detail' 'tv_series' %}">View all &raquo;</a>
-            </li>
-        </ul>
-    </div>
-    {% endif %}
-
     {% if charts.video %}
     <div class="col-md-6 col-lg-4 chart-section">
         <h3>🎬 Top Videos</h3>
@@ -314,6 +294,4 @@
 </div>
 {% endif %}
 
-{% endif %}
-
 {% endblock %}

vrobbler/templates/profiles/settings_form.html

@@ -106,6 +106,7 @@
 {% block title %}Settings{% endblock %}
 {% block details %}
 <p class="settings-link"><a href="{% url 'people:person_form' %}">Manage People</a></p>
+<p class="settings-link"><a href="{% url 'profiles:bulk_visibility' %}">Scrobble Visibility Settings</a></p>
 <form method="post" class="settings-form">{% csrf_token %}
     {% for field in form %}
         {% if field.name == "enable_public_widgets" %}

vrobbler/templates/profiles/visibility_settings.html

@@ -0,0 +1,117 @@
+{% extends "base_detail.html" %}
+
+{% block title %}Scrobble Visibility Settings{% endblock %}
+
+{% block head_extra %}
+<style>
+.vis-form {
+    max-width: 700px;
+}
+.vis-form h3 {
+    margin-top: 24px;
+    margin-bottom: 12px;
+}
+.vis-form h4 {
+    margin-top: 20px;
+    margin-bottom: 8px;
+    font-size: 1.1rem;
+}
+.vis-form label {
+    font-weight: 600;
+    margin-right: 12px;
+}
+.vis-form .bulk-radio-group {
+    margin: 8px 0 16px 0;
+}
+.vis-form .bulk-radio-group label {
+    font-weight: normal;
+    display: block;
+    margin: 4px 0;
+}
+.vis-form .media-type-row {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    margin: 6px 0;
+    padding: 4px 8px;
+    border-radius: 4px;
+}
+.vis-form .media-type-row:nth-child(even) {
+    background: #f8f9fa;
+}
+.vis-form .media-type-row label {
+    font-weight: normal;
+    min-width: 130px;
+}
+.vis-form select {
+    padding: 4px 8px;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+}
+.vis-form input[type="submit"] {
+    margin-top: 20px;
+    padding: 10px 24px;
+    background: #007bff;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 14px;
+}
+.vis-form input[type="submit"]:hover {
+    background: #0056b3;
+}
+.vis-stats {
+    margin: 16px 0;
+    padding: 12px;
+    background: #f8f9fa;
+    border-radius: 4px;
+}
+.vis-stats strong {
+    display: block;
+    margin-bottom: 6px;
+}
+.vis-stats ul {
+    margin: 0;
+    padding-left: 18px;
+}
+</style>
+{% endblock %}
+
+{% block details %}
+<p><a href="{% url 'profiles:profile_settings' %}">&laquo; Back to settings</a></p>
+
+<div class="vis-stats">
+    <strong>Current scrobble visibility ({{ scrobble_count }} total)</strong>
+    <ul>
+        {% for item in visibility_counts %}
+        <li><a href="{% url 'scrobbles:scrobble-list' %}?visibility={{ item.visibility }}">{{ item.visibility|title }}</a>: {{ item.count }}</li>
+        {% endfor %}
+    </ul>
+</div>
+
+<form method="post" class="vis-form">{% csrf_token %}
+    <h3>Bulk Update</h3>
+    <p>Choose a visibility to apply to all scrobbles that are <strong>not</strong> currently "Shared".</p>
+    <div class="bulk-radio-group">
+        {% for radio in form.bulk_action %}
+        <label>{{ radio.tag }} {{ radio.choice_label }}</label>
+        {% endfor %}
+    </div>
+
+    <details>
+        <summary><h3 style="display:inline">Per-Media-Type Defaults</h3></summary>
+        <p>Override default visibility for new scrobbles of specific types.</p>
+        {% for field in form %}
+            {% if field.name != "bulk_action" %}
+            <div class="media-type-row">
+                <label for="{{ field.id_for_label }}">{{ field.label }}</label>
+                {{ field }}
+            </div>
+            {% endif %}
+        {% endfor %}
+    </details>
+
+    <input type="submit" value="Save Visibility Settings">
+</form>
+{% endblock %}

vrobbler/templates/scrobbles/_top_charts.html

@@ -76,44 +76,44 @@
 </div>
 
 <div class="row">
-    <h2>🎵 Top Tracks</h2>
-    <ul class="nav nav-tabs" id="trackTab" role="tablist">
+    <h2>💿 Top Albums</h2>
+    <ul class="nav nav-tabs" id="albumTab" role="tablist">
         {% for key, name in chart_keys.items %}
         <li class="nav-item" role="presentation">
             <button class="nav-link {% if forloop.counter == 2 %}active{% endif %}"
-                    id="track-{{key}}-tab" data-bs-toggle="tab" data-bs-target="#track-{{key}}"
+                    id="album-{{key}}-tab" data-bs-toggle="tab" data-bs-target="#album-{{key}}"
                     type="button" role="tab">{{name}}</button>
         </li>
         {% endfor %}
     </ul>
 
-    <div class="tab-content" id="trackTabContent" class="maloja-chart">
+    <div class="tab-content" id="albumTabContent" class="maloja-chart">
         {% for key, name in chart_keys.items %}
-        {% with maloja_charts.track|get_item:key as tracks %}
-        <div class="tab-pane fade {% if forloop.counter == 2 %}show active{% endif %}" id="track-{{key}}" role="tabpanel">
-            {% if tracks.0 %}
+        {% with maloja_charts.album|get_item:key as albums %}
+        <div class="tab-pane fade {% if forloop.counter == 2 %}show active{% endif %}" id="album-{{key}}" role="tabpanel">
+            {% if albums.0 %}
             <div style="display:block">
                 <div style="float:left;">
                     <div class="image-wrapper" style="display:flex; flex-wrap: wrap; margin:0">
-                        <div class="caption">#1 {{tracks.0.track.title}}</div>
-                        {% if tracks.0.track.album.cover_image %}
-                        <a href="{{tracks.0.track.get_absolute_url}}"><img src="{{tracks.0.track.album.cover_image_medium.url}}" width="300px"></a>
+                        <div class="caption">#1 {{albums.0.album.title}}</div>
+                        {% if albums.0.album.cover_image %}
+                        <a href="{{albums.0.album.get_absolute_url}}"><img src="{{albums.0.album.cover_image_medium.url}}" width="300px"></a>
                         {% else %}
-                        <a href="{{tracks.0.track.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="300px"></a>
+                        <a href="{{albums.0.album.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="300px"></a>
                         {% endif %}
                     </div>
                 </div>
                 <div style="float:left; width:300px;">
                     <div style="display:flex; flex-wrap: wrap;">
                         {% for i in "2345" %}
-                        {% with tracks|get_item:forloop.counter as track %}
-                        {% if track %}
+                        {% with albums|get_item:forloop.counter as album %}
+                        {% if album %}
                         <div class="image-wrapper" style="width:50%">
-                            <div class="caption-medium">#{{forloop.counter|add:1}} {{track.track.title}}</div>
-                            {% if track.track.album.cover_image %}
-                            <a href="{{track.track.get_absolute_url}}"><img src="{{track.track.album.cover_image_medium.url}}" width="150px"></a>
+                            <div class="caption-medium">#{{forloop.counter|add:1}} {{album.album.title}}</div>
+                            {% if album.album.cover_image %}
+                            <a href="{{album.album.get_absolute_url}}"><img src="{{album.album.cover_image_medium.url}}" width="150px"></a>
                             {% else %}
-                            <a href="{{track.track.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="150px"></a>
+                            <a href="{{album.album.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="150px"></a>
                             {% endif %}
                         </div>
                         {% endif %}
@@ -124,14 +124,14 @@
                 <div style="float:left; width:300px;">
                     <div style="display:flex; flex-wrap: wrap;">
                         {% for i in "67891011121314" %}
-                        {% with tracks|get_item:forloop.counter|add:5 as track %}
-                        {% if track %}
+                        {% with albums|get_item:forloop.counter|add:5 as album %}
+                        {% if album %}
                         <div class="image-wrapper" style="width:33%">
-                            <div class="caption-small">#{{forloop.counter|add:6}} {{track.track.title}}</div>
-                            {% if track.track.album.cover_image %}
-                            <a href="{{track.track.get_absolute_url}}"><img src="{{track.track.album.cover_image_medium.url}}" width="100px"></a>
+                            <div class="caption-small">#{{forloop.counter|add:6}} {{album.album.title}}</div>
+                            {% if album.album.cover_image %}
+                            <a href="{{album.album.get_absolute_url}}"><img src="{{album.album.cover_image_medium.url}}" width="100px"></a>
                             {% else %}
-                            <a href="{{track.track.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="100px"></a>
+                            <a href="{{album.album.get_absolute_url}}"><img src="{% static 'images/not-found.jpg' %}" width="100px"></a>
                             {% endif %}
                         </div>
                         {% endif %}

vrobbler/templates/scrobbles/scrobble_all_list.html

@@ -13,6 +13,9 @@
             <p class="text-muted small mb-0">Total time: {{ total_time_seconds|natural_duration }}</p>
             {% endif %}
             {% endif %}
+            {% if request.GET.visibility %}
+            <h6 class="text-muted">Filter: {{ request.GET.visibility|title }} scrobbles only</h6>
+            {% endif %}
         </div>
     </div>
 

vrobbler/templates/scrobbles/scrobble_detail.html

@@ -264,7 +264,13 @@
 
 <h2 class="mt-4">All scrobbles of this {{ object.media_type|lower }}</h2>
 {% if related_scrobbles %}
-<p class="text-muted">{{ related_scrobbles.paginator.count }} scrobble{{ related_scrobbles.paginator.count|pluralize }}</p>
+<p class="text-muted">
+    {{ related_scrobbles.paginator.count }} scrobble{{ related_scrobbles.paginator.count|pluralize }}
+    {% if object.is_long_play and long_play_total_seconds %}
+    | Total time: {{ long_play_total_seconds|natural_duration }}
+    {% if long_play_finished_date %} | Finished: {{ long_play_finished_date|date:"M d, Y" }}{% endif %}
+    {% endif %}
+</p>
 <table class="table table-striped table-sm">
     <thead>
         <tr>
@@ -281,7 +287,11 @@
                 {% if scrobble.media_type == "Task" and scrobble.logdata.title %}{{ scrobble.media_obj.title }}: {{ scrobble.logdata.title }}{% else %}{{ scrobble.media_obj.title|default:scrobble.media_obj }}{% endif %}
             </td>
             <td>
-                {% if scrobble.playback_position_seconds %}{{ scrobble.playback_position_seconds|natural_duration }}{% endif %}
+                {% if scrobble.is_long_play and scrobble.long_play_seconds %}
+                    {{ scrobble.playback_position_seconds|natural_duration }} ({{ scrobble.long_play_seconds|natural_duration }} total)
+                {% elif scrobble.playback_position_seconds %}
+                    {{ scrobble.playback_position_seconds|natural_duration }}
+                {% endif %}
             </td>
         </tr>
         {% endfor %}

vrobbler/templates/tasks/task_detail.html

@@ -50,7 +50,11 @@
 {% endif %}
 
 <div class="row">
-    <p>{{scrobbles.count}} scrobbles</p>
+    <p>
+        {{scrobbles.count}} scrobbles
+        {% if long_play_total_seconds %} | Total time: {{ long_play_total_seconds|natural_duration }}{% endif %}
+        {% if long_play_finished_date %} | Finished: {{ long_play_finished_date|date:"M d, Y" }}{% endif %}
+    </p>
     <p>
         <a href="{{object.start_url}}">Play again</a>
     </p>
@@ -67,6 +71,7 @@
                         <th scope="col">Title</th>
                         <th scope="col">Notes</th>
                         <th scope="col">Source</th>
+                        <th scope="col">Completed</th>
                     </tr>
                 </thead>
                 <tbody>
@@ -76,6 +81,7 @@
                         <td><a href="{{scrobble.get_media_source_url}}">{{scrobble.logdata.title}}</a></td>
                         <td>{{scrobble.logdata.notes_as_str}}</td>
                         <td>{{scrobble.source}}</td>
+                        <td>{% if scrobble.long_play_complete == True %}Yes <small><a href="{% url 'scrobbles:longplay-finish' uuid=scrobble.uuid %}">(not complete?)</a></small>{% else %}<a href="{% url 'scrobbles:longplay-finish' uuid=scrobble.uuid %}">No</a>{% endif %}</td>
                     </tr>
                     {% endfor %}
                 </tbody>

vrobbler/templates/tasks/task_list.html

@@ -26,7 +26,7 @@
 {% block lists %}
 <div class="row">
   <div class="col-md">
-    <div class="table-responsive">{% include "_scrobblable_list.html" %}</div>
+    <div class="table-responsive">{% include "_longplay_scrobblable_list.html" %}</div>
   </div>
 </div>
 {% endblock %}

vrobbler/templates/videogames/videogame_detail.html

@@ -59,7 +59,11 @@
     </div>
 </div>
 <div class="row">
-    <p>{{scrobbles.count}} scrobbles</p>
+    <p>
+        {{scrobbles.count}} scrobbles
+        {% if long_play_total_seconds %} | Total time: {{ long_play_total_seconds|natural_duration }}{% endif %}
+        {% if long_play_finished_date %} | Finished: {{ long_play_finished_date|date:"M d, Y" }}{% endif %}
+    </p>
     <p>
         <a href="">Play again</a>
     </p>
@@ -83,7 +87,7 @@
                     <tr>
 
                         <td><a href="{{scrobble.get_absolute_url}}">{{scrobble.local_timestamp}}</a></td>
-                        <td>{% if scrobble.long_play_complete == True %}Yes{% else %}Not yet{% endif %}</td>
+                        <td>{% if scrobble.long_play_complete == True %}Yes <small><a href="{% url 'scrobbles:longplay-finish' uuid=scrobble.uuid %}">(not complete?)</a></small>{% else %}<a href="{% url 'scrobbles:longplay-finish' uuid=scrobble.uuid %}">Not yet</a>{% endif %}</td>
                         <td>{% if scrobble.in_progress %}Now playing{% else %}{{scrobble.playback_position_seconds|natural_duration}}{% endif %}</td>
                         <td>{% for platform in scrobble.video_game.platforms.all %}<a href="{{platform.get_absolute_url}}">{{platform}}</a>{% if not forloop.last %}, {% endif %}{% endfor %}</td>
                         <td>{% if scrobble.videogame_save_data %}<a href="{{scrobble.videogame_save_data.url}}">Save data</a>{% else %}Not yet{% endif %}</td>

vrobbler/templates/videogames/videogame_list.html

@@ -16,7 +16,7 @@
 
     <div class="col-md">
         <div class="table-responsive">
-            {% include "_scrobblable_list.html" %}
+            {% include "_longplay_scrobblable_list.html" %}
         </div>
     </div>
 </div>