[release] Update project file for release 35

[videos] Fix lookup for ids for videos
[videos] Add youtube link to detail page
2025-11-17 16:35:09 -05:00 · 2025-11-17 16:34:38 -05:00 · 2025-11-17 16:30:40 -05:00 · 2025-11-17 16:25:46 -05:00 · 2025-11-17 16:11:31 -05:00 · 2025-11-17 16:00:10 -05:00
167 changed files with 6539 additions and 3512 deletions
--- a/PROJECT.org
+++ b/PROJECT.org
@ -1,6 +1,20 @@
 #+title: Vrobbler Project

 * Overview
+Vrobbler began humbly enough as a way to use Jellyfin's webhook to keep track of
+the shows and movies I was watching. More specifically, I broke my ankle a few
+days after Christmas in 2022 and spent the next four months very slowly
+recovering after surgical repair. So once I had the webhook working, and
+scrobbling videos, it was only a matter of time till I expaned it to mopidy to
+replicate LastFM. Then I added board games, books via KoReader, sports events,
+podcasts ... it just keeps going. Vrobbler is now a sort of Frankenstein's
+monster of scrobbling an entire life.
+
+I am still unconvinced I can keep this going, but being able to scrobble org
+tasks, Todoist tasks, web pages I've read and trails I've hiked has turned out
+to be sometimes cathartic and sometimes functional as I try to remember when I
+did a thing.
+
 * Features
 ** Beer
 *** Triggers
@ -70,7 +84,6 @@ fetching and simple saving.
 **** Bookmarklet
 *** Metadata sources
 **** Scraper
-* Release history
 * Chores
 ** DONE Document various vrobbler features :chore:personal:project:vrobbler:documentation:
 :PROPERTIES:
@ -79,85 +92,8 @@ fetching and simple saving.
 :LOGBOOK:
 CLOCK: [2025-07-09 Wed 09:55]--[2025-07-09 Wed 10:15] =>  0:20
 :END:
-* Backlog [4/27]
-** STRT Only create a LastFM import if there are files to import :vrobbler:feature:lastfm:importers:project:personal:
-:PROPERTIES:
-:ID:       7a1456af-c5f1-6385-b34f-0be24a6b65b0
-:END:
- Note taken on [2025-07-20 Sun 16:21]
-
-  This thing is kicking my butt. As it stands it works, but the scrobbles are not assigned to the tracks properly.
-** TODO Add timezone awarness to IMAP importer :personal:project:vrobbler:feature:importer:imap:timezones:
-** DONE Track timezone changes for profiles :vrobbler:feature:profiles:personal:project:
-:PROPERTIES:
-:ID:       89ec867f-29fd-82f1-be17-b49dddc30c78
-:END:
-[2025-07-11 14:23]
-** TODO [#A] Add classmethod for metadata fetching to tracks :vrobbler:feature:music:personal:project:
-:PROPERTIES:
-:ID:       bc4b45e5-4c65-13c5-ab7b-1937d3fbf5c2
-:END:
-:LOGBOOK:
-CLOCK: [2025-07-09 Wed 10:15]
-:END:
-
-** TODO Look in comments for a timestamp for start from BG stats if the time is missing :vrobbler:feature:boardgames:project:personal:
-** TODO Add importer class for IMAP imports :vrobbler:feature:imap:importers:project:personal:
-** TODO Add youtube link in place of IMDB on video detail page :vrobbler:feature:videos:personal:project:
-** TODO [#A] Tasks from org-mode should properly update notes and leave them out of the body :vrobbler:bug:tasks:
-** TODO [#A] Fix small bug in views for TV series where next episode is now None :vrobbler:bug:personal:videos:
-
-#+begin_src python
-ERROR    django.request:241 log_response Internal Server Error: /series/c24100d1-da45-4abe-86bf-27cfce9b1f89/
-Traceback (most recent call last):
-  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/exception.py", line 55, in inner
-    response = get_response(request)
-               ^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/base.py", line 197, in _get_response
-    response = wrapped_callback(request, *callback_args, **callback_kwargs)
-               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/views/generic/base.py", line 104, in view
-    return self.dispatch(request, *args, **kwargs)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/contrib/auth/mixins.py", line 73, in dispatch
-    return super().dispatch(request, *args, **kwargs)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/views/generic/base.py", line 143, in dispatch
-    return handler(request, *args, **kwargs)
-           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/django/views/generic/detail.py", line 109, in get
-    context = self.get_context_data(object=self.object)
-              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/videos/views.py", line 33, in get_context_data
-    context_data["next_episode_id"] = "tt" + next_episode_id
-                                      ~~~~~^~~~~~~~~~~~~~~~~
-TypeError: can only concatenate str (not "NoneType") to str
-#+end_src
-
-** TODO [#A] Send periodic check notifications for board games and beer that ask if you're still scrobbling :vrobbler:personal:project:beers:boardgames:notifications:feature:
-** TODO [#A] Fix raw text webpage title not truncating to 254 chars :vrobbler:personal:bug:webpages:
-** TODO [#A] Fix koreader scrobble imports to use DST properly :vrobbler:personal:bug:books:imports:
-The page data has the canonical date something was read in it, but it seems to be an hour off. I traced this back to being off during DST, so we just need the importer to be aware of whether a user is using DST or not and roll back an hour for part of the year.
-
-Also, we'd need to adjust any old scrobbles that took place with DST off to roll them back by an hour.
-** TODO [#A] Create small utility to clean up tracks scrobbled with wonky playback times :vrobbler:personal:bug:music:scrobbles:
-** TODO [#B] Add AllTrails as a source for Trail data :vrobbler:trails:feature:personal:project:
-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 TrailMetadataLog class :vrobbler:trails:feature:personal:project:
-Would be nice to have some loose connection to the actual event in my Garmin profile.
-** TODO [#B] Explore a way to add metadata editing to scrobbles after saving :vrobbler:spike:scrobbling:personal:project:
-Could be as simple as a JSON form on the scrobble detail page (do I have have one of those yet?).
-** TODO [#B] Explore a good way to show notes and descriptions from scrobbles to users :personal:project:scrobbling:vrobbler:spike:
-** TODO [#B] Add webdav syncing to retroarch imports :vrobbler:videogames:webdav:feature:project:personal:
-** TODO [#B] Add CSV endpoint for book scrobbles that LibraryThing can ingest :personal:project: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 [#C] Fix bug where podcast scrobbling creates duplicate Podcast :project:vrobbler:scrobbling:podcasts:bug:personal:
-Rather than pick up an existing Podcast using the podcast title in the mopidy
-file name, Vrobbler creates a new podcast with no enriched data. Not a big deal
-for my use as the volume of podcasts I listen to makes manual fixes easy. But
-it's annoying.
+* Backlog [2/25]
+** TODO [#C] Create small utility to clean up tracks scrobbled with wonky playback times :vrobbler:personal:bug:music:scrobbles:
 ** TODO [#C] Move to using more robust mopidy-webhooks pacakge form pypi :utility:improvement:
 :PROPERTIES:
 :ID:       ab31fdc3-359c-1b1d-6b9d-546b476021ba
@ -456,6 +392,304 @@ it's annoying.
 ** TODO [#C] Allow users to see tasks on calendar view :vrobbler:personal:project:templates:feature:
 https://codepen.io/oliviale/pen/QYqybo
 ** TODO [#C] Come up with a possible flow using WebDAV and super-productivity for tasks :personal:feature:project:vrobbler:tasks:
+** TODO [#B] Add importer class for IMAP imports :vrobbler:feature:imap:importers:project:personal:
+** TODO [#B] Clean up follow up notifications for board games and beer that ask if you're still scrobbling :vrobbler:personal:project:beers:boardgames:notifications:feature:
+
+- Note taken on [2025-09-30 Tue 09:32]
+
+  I added this feature in a very rough way, but now we should add "Action"
+  headers so that we can either Finish or Cancel the associated scrobble:
+
+  https://docs.ntfy.sh/publish/#send-http-request
+
+** TODO [#B] Add AllTrails as a source for Trail data :vrobbler:trails:feature:personal:project:
+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 TrailMetadataLog class :vrobbler:trails:feature:personal:project:
+Would be nice to have some loose connection to the actual event in my Garmin profile.
+** TODO [#B] Explore a way to add metadata editing to scrobbles after saving :vrobbler:spike:scrobbling:personal:project:
+Could be as simple as a JSON form on the scrobble detail page (do I have have one of those yet?).
+** TODO [#B] Explore a good way to show notes and descriptions from scrobbles to users :personal:project:scrobbling:vrobbler:spike:
+** TODO [#B] Add webdav syncing to retroarch imports :vrobbler:videogames:webdav:feature:project:personal:
+** TODO [#B] Add CSV endpoint for book scrobbles that LibraryThing can ingest :personal:project: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] Fix PuzzleLogData has no attribute form :vrobbler:puzzles:personal:project:logdata:
+** TODO [#B] Scrape ComicBookRoundUp ratings for comic book metadata :vrobbler:books:feature:comicbook:personal:project:
+
+- Note taken on [2025-09-25 Thu 10:51]
+
+  As an example https://comicbookroundup.com/comic-books/reviews/humanoids-publishing/the-history-of-science-fiction
+** TODO [#B] Add PuzzleLogData class with with_people and completed :vrobbler:feature:puzzles:logdata:personal:project:
+** TODO [#A] Tasks from org-mode should properly update notes and leave them out of the body :vrobbler:bug:tasks:
+** TODO [#A] Fix koreader scrobble imports to use DST properly :vrobbler:personal:bug:books:imports:
+
+- Note taken on [2025-09-25 Thu 10:37] \\
+
+  This may already be fixed ... need to check.
+
+- Note taken on [2025-02-25 12:34] \\
+
+  The page data has the canonical date something was read in it, but it seems
+  to be an hour off. I traced this back to being off during DST, so we just need
+  the importer to be aware of whether a user is using DST or not and roll back
+  an hour for part of the year. Also, we'd need to adjust any old scrobbles that
+  took place with DST off to roll them back by an hour.
+
+** TODO [#A] Allow scrobbling from the Food list page's start links :vrobbler:bug:food:scrobbling:personal:project:
+https://life.lab.unbl.ink/scrobble/e39779c8-62a5-46a6-bdef-fb7662810dc6/start/
+** TODO [#A] Puzzles (and all longplays) should have a "Completed?" column on their detail page :vrobbler:bug:puzzles:personal:project:
+** TODO [#A] Fix raw text webpage title not truncating to 254 chars :vrobbler:personal:bug:webpages:
+
+- Note taken on [2025-09-30 Tue 09:33]
+
+  This may have already been resolved ... need to just confirm it.
+** TODO [#A] Find page numbers for comic books from ComicVine :vrobbler:feature:books:personal:project:
+* Version 35.0 [3/3]
+** DONE [#B] Add youtube link in place of IMDB on video detail page :vrobbler:feature:videos:personal:project:
+:PROPERTIES:
+:ID:       84064bd6-2258-a4de-f048-b131db9465c9
+:END:
+** DONE [#B] Add missing API lookups to resolve broken scrobbles endpoint :vrobbler:feature:api:scrobbles:personal:project:
+:PROPERTIES:
+:ID:       0f668a54-f587-3b17-353e-3a56969d3a82
+:END:
+** DONE [#A] IMDB lookups are not working :vrobbler:bug:videos:personal:project:
+:PROPERTIES:
+:ID:       d1ba1ca1-509b-13a9-1307-b2dc94a2eafe
+:END:
+* Version 34.0 [4/4]
+** DONE [#A] Use bgg-api for BoardGameGeek lookups :vrobbler:feature:boardgames:personal:project:
+:PROPERTIES:
+:ID:       738abb5a-c796-b16b-fe10-6e5639a0e10d
+:END:
+** DONE [#A] Add classmethod for metadata fetching to tracks :vrobbler:feature:music:personal:project:
+:PROPERTIES:
+:ID:       bc4b45e5-4c65-13c5-ab7b-1937d3fbf5c2
+:END:
+
+- Note taken on [2025-10-29 Wed 21:44]
+
+  Beyond a classmethod (which I think we have now), we need to update the flow of how we look up tracks.
+
+  It's a hot mess right now where Various Artists walks over the actual artist, and we often hit MB when we don't have to.
+
+** DONE [#A] Fix views for TV series where next episode is now None :vrobbler:bug:personal:videos:
+:PROPERTIES:
+:ID:       d7014ac4-cda6-0802-2cdf-8f66c6389fea
+:END:
+
+#+begin_src python
+ERROR    django.request:241 log_response Internal Server Error: /series/c24100d1-da45-4abe-86bf-27cfce9b1f89/
+Traceback (most recent call last):
+  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/exception.py", line 55, in inner
+    response = get_response(request)
+               ^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/core/handlers/base.py", line 197, in _get_response
+    response = wrapped_callback(request, *callback_args, **callback_kwargs)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/views/generic/base.py", line 104, in view
+    return self.dispatch(request, *args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/contrib/auth/mixins.py", line 73, in dispatch
+    return super().dispatch(request, *args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/views/generic/base.py", line 143, in dispatch
+    return handler(request, *args, **kwargs)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/django/views/generic/detail.py", line 109, in get
+    context = self.get_context_data(object=self.object)
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/usr/local/lib/python3.11/site-packages/vrobbler/apps/videos/views.py", line 33, in get_context_data
+    context_data["next_episode_id"] = "tt" + next_episode_id
+                                      ~~~~~^~~~~~~~~~~~~~~~~
+TypeError: can only concatenate str (not "NoneType") to str
+#+end_src
+
+** DONE [#A] Emacs tasks are duplicating rather than updating :vrobbler:bug:tasks:emacs:personal:project:
+:PROPERTIES:
+:ID:       e93efc25-7ce9-8ef2-662e-0a19dd0b29c9
+:END:
+
+- Note taken on [2025-10-29 Wed 16:38]
+
+  Turns out I was misusing `orgmode` for the source of tasks when it shoulda been `Org-mode`
+
+  A good lesson in using constants for things.
+
+* Version 33.0 [3/3]
+** DONE [#A] Fix bug where scrobble is_stale only uses seconds not total_seconds :vrobbler:bug:scrobbles:personal:project:
+:PROPERTIES:
+:ID:       7f6070ac-4f67-011d-ebd5-f3dc47da46ed
+:END:
+** DONE [#B] Fix duplicatged Read next issue for Comic books :vrobbler:bug:books:personal:project:
+:PROPERTIES:
+:ID:       97943040-1f03-b0b7-b0aa-123a783e4f7b
+:END:
+** DONE [#A] Add API authentication to BGG calls :vrobbler:bug:boardgames:personal:project:
+:PROPERTIES:
+:ID:       4955cc34-0882-50db-92f7-f36a95bf57a4
+:END:
+<2025-10-28 Tue>
+* Version 32.0 [2/2]
+** DONE [#B] Save path to reading source on book scrobbles and show it on the detail page :vrobbler:feature:books:personal:project:
+:PROPERTIES:
+:ID:       f1ef3945-e6e4-66c1-b72e-3cede7a0f84a
+:END:
+** DONE [#B] Move comic resume URL to next page and check if it exists :vrobbler:feature:books:personal:project:
+:PROPERTIES:
+:ID:       9fe09567-11a3-7083-53c7-07458a9591d0
+:END:
+* Version 31.0 [3/3]
+** DONE [#A] Stop comic book webpage scrobbles from overwriting old scrobbles :vrobbler:personal:bug:books:scrobbling:
+:PROPERTIES:
+:ID:       4b2ec068-a281-a88b-c31d-6248d6eb0aa0
+:END:
+** DONE [#A] Add page calculation to manually scrobbled books :vrobbler:personal:feature:books:scrobbling:
+:PROPERTIES:
+:ID:       b2e313b3-5c35-57e7-8933-627535baf34b
+:END:
+** DONE [#A] Fix bug in scrobbling comics where google fails :vrobbler:personal:bug:books:scrobbling:
+:PROPERTIES:
+:ID:       9a870c05-6d20-0803-d35d-c03fbe1d0ee1
+:END:
+* Version 30.0 [3/3]
+** DONE [#A] Fix readcomicsonline browsing to update pages :vrobbler:books:feature:comicbook:personal:project:scrobbling:
+:PROPERTIES:
+:ID:       981b215a-6473-5fc7-d4cc-51b3eddec4c3
+:END:
+** DONE [#B] Redirect webpages back to the original page when starting or stopping :vrobbler:project:webpages:bug:
+:PROPERTIES:
+:ID:       6183d03a-452b-51d5-cceb-5bfeada947aa
+:END:
+
+** DONE [#B] Fix ComicVine as source for comic book metadata :vrobbler:books:feature:comicbook:personal:project:scrobbling:
+:PROPERTIES:
+:ID:       d22cec3f-117f-f203-33a5-efbefa8a5cee
+:END:
+* Version 29.0 [1/1]
+** DONE HOTFIX podcast lookups, final
+* Version 28.0 [1/1]
+** DONE HOTFIX podcast lookups
+* Version 27.0 [3/3]
+** DONE [#A] Fix bug where podcast scrobbling creates duplicate Podcast :project:vrobbler:scrobbling:podcasts:bug:personal:
+:PROPERTIES:
+:ID:       7377ef6c-5fa7-9e4e-9080-f9810a76118c
+:END:
+
+Rather than pick up an existing Podcast using the podcast title in the mopidy
+file name, Vrobbler creates a new podcast with no enriched data. Not a big deal
+for my use as the volume of podcasts I listen to makes manual fixes easy. But
+it's annoying.
+
+** DONE [#A] Allow reading comic books from readcomicsoline.ru :vrobbler:books:feature:comicbook:personal:project:scrobbling:
+:PROPERTIES:
+:ID:       7c7e9ecc-b675-68c3-764f-ef771ce5d88f
+:END:
+
+- Note taken on [2025-09-25 Thu 10:52]
+
+  Things to consider are whether we scrobble the issue on one page, send it to
+  archivebox? (yes), and how best to enrich the data
+
+** DONE [#A] Add RSS feed lookups to podcasts :vrobbler:personal:feature:podcasts:
+:PROPERTIES:
+:ID:       d60645b0-7578-97c1-0278-05bd9de4269c
+:END:
+
+- Note taken on [2025-10-14 Tue 10:08]
+
+  Turns out the Podcast plugin for mopidy does a pretty good job of showing the
+  latest file without having to scroll the bottom using only Muse to not parse
+  the podcast title name. BUT, now we're getting urls like this:
+
+  https://nsf.libsyn.com/rss#77e01251-cb20-4609-b577-d48e985d2e7b
+
+  This is great, because there's more context there, but it has to read out of
+  the RSS feed. We should add a check in the podcast util to sniff out the file
+  referenced in the # in that url and populate the info from there. This should
+  actually be much more reliable than the current state of the podcast lookup
+  which depends on the file to be name properly.
+
+* Version 26.0 [3/3]
+** DONE Clean up templates for scrobble details :vrobbler:personal:bug:templates:
+:PROPERTIES:
+:ID:       43dc1e02-c110-5b49-0ac7-4c4f7656d1aa
+:END:
+** DONE Add named locations visited to dashboard :vrobbler:personal:feature:locations:templates:
+:PROPERTIES:
+:ID:       ebc365a1-cef4-f75d-569f-c24b072ef5a4
+:END:
+** DONE Add moods to dashboard :vrobbler:moods:feature:templates:personal:
+:PROPERTIES:
+:ID:       c03a38ce-b337-f4fa-adba-aee08d4329f5
+:END:
+* Version 25.0 [3/3]
+** DONE Add basic food templates and fix urls :food:vrobbler:personal:project:bug:urls:
+:PROPERTIES:
+:ID:       3de3459e-8e7e-abba-e068-b919a819d3e3
+:END:
+** DONE [#C] Fix how elapsed time is calculated :vrobbler:personal:project:scrobbles:bug:
+:PROPERTIES:
+:ID:       cff58fc4-06ac-8016-4eae-130b51e3c9b7
+:END:
+** DONE Fix templates for videos and dashboard links :personal:feature:project:vrobbler:templates:
+:PROPERTIES:
+:ID:       7debfbaf-cdd8-f49b-57ff-804bfe7c9236
+:END:
+* Version 24.0 [2/2]
+** DONE Clean up logdata for various media :personal:feature:project:vrobbler:logdata:
+:PROPERTIES:
+:ID:       d5cce807-1f45-ef19-45a4-9f7069fa2a93
+:END:
+** DONE Removed sidebar and add links to headers :personal:feature:templates:scrobbles:
+:PROPERTIES:
+:ID:       1a1c0aa6-0313-c8be-1676-5d6adddef0a4
+:END:
+
+* Version 23.0 [3/3]
+** DONE Add dynamic forms for LogData classes :personal:feature:vrobbler:project:forms:logdata:
+:PROPERTIES:
+:ID:       0db889a1-f262-fba2-7fed-ed99eded1c88
+:END:
+** DONE Look in comments for a timestamp for start from BG stats if the time is missing :vrobbler:feature:boardgames:project:personal:
+** DONE Fix long play scrobbles to provide better data :vrobbler:feature:scrobbles:longplay:personal:project:
+:PROPERTIES:
+:ID:       99f6bd77-dc8f-6ed1-0321-32a52c944264
+:END:
+* Version 19.0 [1/1]
+** DONE Add periodic check for mood :vrobbler:feature:moods:personal:project:
+:PROPERTIES:
+:ID:       55404488-c69f-0dd5-838e-1d1e15c873eb
+:END:
+* Version 18.7 [1/1]
+** DONE Use the timezone history log to fix old Scrobbles that fall into those timezone blocks :vrobbler:chore:scrobbles:project:personal:
+:PROPERTIES:
+:ID:       9d055ac1-584b-20c8-7ad9-9ce36b329dc7
+:END:
+* Version 18.4 [2/2]
+** DONE Track timezone changes for profiles :vrobbler:feature:profiles:personal:project:
+:PROPERTIES:
+:ID:       89ec867f-29fd-82f1-be17-b49dddc30c78
+:END:
+[2025-07-11 14:23]
+** DONE Only create a LastFM import if there are files to import :vrobbler:feature:lastfm:importers:project:personal:
+:PROPERTIES:
+:ID:       7a1456af-c5f1-6385-b34f-0be24a6b65b0
+:END:
+- Note taken on [2025-07-20 Sun 16:21]
+
+  This thing is kicking my butt. As it stands it works, but the scrobbles are not assigned to the tracks properly.
+* Version 18.3 [1/1]
+** DONE Add timezone awarness to IMAP importer :personal:project:vrobbler:feature:importer:imap:timezones:
+:PROPERTIES:
+:ID:       05837b7c-96aa-6190-3678-e2ae7c7cac75
+:END:
+* Version 18 [4/4]
+** DONE Condense tracks of the same title by the same artist with multiple albums :vrobbler:feature:music:project:personal:
+:PROPERTIES:
+:ID:       b39fcec8-59fd-eab0-5809-b8144c7d2708
+:END:
 ** DONE Import from BG stats a "learning" log field when "Learning to play" is in the comment :vrobbler:feature:boardgames:project:personal:
 :PROPERTIES:
 :ID:       fda59fab-4349-e99e-54c6-9f1392a1c474
@ -572,7 +806,7 @@ https://codepen.io/oliviale/pen/QYqybo
 :PROPERTIES:
 :ID:       23f485e3-988c-6198-c79d-91fdf92f001c
 :END:
-* Version 17.0
+* Version 17.0 [6/6]
 ** DONE [#A] Fix bug in new task label lookup for Emacs/Org-mode :vrobbler:bug:tasks:
 :PROPERTIES:
 :ID:       683fb109-dfc4-85e4-80f0-ea618434f61e
@ -635,7 +869,7 @@ Not sure if the problem is in my Emacs hook sending or Vrobbler itself.
 :PROPERTIES:
 :ID:       df58f8d0-fa4a-2037-c7d7-e5388c239042
 :END:
-* Version 0.16.0
+* Version 0.16.0 [19/19]
 ** DONE [#A] Jellyfin, bandcamp tracks from Mopidy create duplicate music tracks :bug:scrobbling:music:
 :PROPERTIES:
 :ID:       670e8634-49b5-dce9-1684-14f2ffb797f1
@ -740,7 +974,7 @@ out using that.
 ** DONE Fix bug in Jellyfin scrobbles that spam more scrobbles after completion :scrobbling:videos:bug:
 This was fixed a while ago, but there's a new manifested bug. Going to create a
 separate bug tracking ticket for that.
-* Version 0.11.4
+* Version 0.11.4 [9/9]
 ** DONE Add rudimentary video game scrobbling :improvement:content:videogames:
 CLOSED: [2023-03-07 Tue 11:11]
 ** DONE Add ability to scrobble from KOReader statistics files :improvement:books:content:
--- a/data/moods.json
+++ b/data/moods.json
--- a/poetry.lock
+++ b/poetry.lock
--- a/pyproject.toml
+++ b/pyproject.toml
@ -5,7 +5,7 @@ description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]

 [tool.poetry.dependencies]
-python = ">=3.9,<3.12"
+python = ">=3.11,<3.14"
 Django = "^4.0.3"
 django-extensions = "^3.1.5"
 python-dateutil = "^2.8.2"
@ -16,8 +16,8 @@ httpx = "<=0.27.2"
 djangorestframework = "^3.13.1"
 Markdown = "^3.3.6"
 django-filter = "^21.1"
-Pillow = "^9.0.1"
-psycopg2 = "^2.9.3"
+Pillow = "^10.0.0"
+psycopg2 = "2.9.10"
 dj-database-url = "^0.5.0"
 django-mathfilters = "^1.0.0"
 django-allauth = "^0.50.0"
@ -28,7 +28,7 @@ django-markdownify = "^0.9.1"
 gunicorn = "^20.1.0"
 django-simple-history = "^3.1.1"
 musicbrainzngs = "^0.7.1"
-cinemagoer = "^2022.12.27"
+cinemagoerng = {git = "https://github.com/cinemagoer/cinemagoerng"}
 pysportsdb = "^0.1.0"
 pytz = "^2022.7.1"
 django-redis = "^5.2.0"
@ -41,11 +41,11 @@ beautifulsoup4 = "^4.11.2"
 django-storages = "^1.13.2"
 stream-sqlite = "^0.0.41"
 ipython = "^8.14.0"
-pendulum = "^2.1.2"
+pendulum = "^3"
 trafilatura = "^1.6.3"
 django-imagekit = "^5.0.0"
 thefuzz = "^0.22.1"
-dataclass-wizard = "0.22.0"
+dataclass-wizard = "^0.35.0"
 webdavclient3 = "^3.14.6"
 boto3 = "^1.35.37"
 urllib3 = "<2"
@ -56,6 +56,9 @@ poetry-bumpversion = "^0.3.3"
 orgparse = "^0.4.20250520"
 tmdbv3api = "^1.9.0"
 themoviedb = "^1.0.2"
+feedparser = "^6.0.12"
+titlecase = "^2.4.1"
+bgg-api = "^1.1.13"

 [tool.poetry.group.test]
 optional = true
--- a/tests/boardgames_tests/test_bgg.py
+++ b/tests/boardgames_tests/test_bgg.py
@ -1,3 +1,4 @@
+import pytest
 from boardgames.bgg import (
    take_first,
    lookup_boardgame_id_from_bgg,
@ -5,12 +6,14 @@ from boardgames.bgg import (
 )


+@pytest.mark.skip(reason="Deprecated library")
 def test_take_first():
    assert take_first([]) == ""

    assert take_first(["a", "b"]) == "a"


+@pytest.mark.skip(reason="Deprecated library")
 def test_lookup_boardgame_id_from_bgg():
    bgg_id = lookup_boardgame_id_from_bgg("Cosmic Encounter")
    assert bgg_id == "15"
@ -19,6 +22,7 @@ def test_lookup_boardgame_id_from_bgg():
    assert bgg_id == None


+@pytest.mark.skip(reason="Deprecated library")
 def test_lookup_boardgame_from_bgg():
    bgg_result = lookup_boardgame_from_bgg(15)
    assert bgg_result.get("bggeek_id") == 15
--- a/tests/scrobbles_tests/conftest.py
+++ b/tests/scrobbles_tests/conftest.py
@ -7,23 +7,24 @@ from rest_framework.authtoken.models import Token
 from boardgames.models import BoardGame
 from music.models import Track, Artist
 from scrobbles.models import Scrobble
+from people.models import Person

 User = get_user_model()


@pytest.fixture
 def boardgame_scrobble():
-    user = User.objects.create(
-        email="test@exmaple.com", first_name="Test", last_name="User"
-    )
+    first = Person.objects.create(name="First Player")
+    second = Person.objects.create(name="Second Player")
    return Scrobble.objects.create(
        board_game=BoardGame.objects.create(title="Test Board Game"),
        media_type="BoardGame",
        played_to_completion=True,
        log={
            "players": [
-                {"user_id": user.id, "win": True, "score": 30, "color": "Blue"}
-            ]
+                {"person_id": first.id, "win": True, "score": 30, "color": "Blue"},
+                {"person_id": second.id, "win": False, "score": 28, "color": "Red"}
+            ],
        },
    )

@ -33,7 +34,7 @@ def test_track():
    Track.objects.create(
        title="Emotion",
        artist=Artist.objects.create(name="Carly Rae Jepsen"),
-        run_time_seconds=60,
+        base_run_time_seconds=60,
    )


@ -114,6 +115,12 @@ def mopidy_podcast_request_data():
        mopidy_uri=mopidy_uri, artist="NPR", album="Up First"
    ).request_json

+@pytest.fixture
+def mopidy_podcast_https_request_data():
+    mopidy_uri = "podcast+https://feeds.npr.org/510318/podcast.xml#85b9c4c4-ae09-43d9-8853-31ccf43f68e6"
+    return MopidyRequest(
+        mopidy_uri=mopidy_uri, artist="NPR", album="Up First"
+    ).request_json

 class JellyfinTrackRequest:
    name = "Emotion"
--- a/tests/scrobbles_tests/test_metadata.py
+++ b/tests/scrobbles_tests/test_metadata.py
@ -1,16 +1,15 @@
 import pytest

-from scrobbles.dataclasses import BoardGameLogData, BoardGameScoreLogData
+#from scrobbles.dataclasses import BoardGameLogData, BoardGameScoreLogData


+@pytest.mark.skip("Need to get local tests running working again")
@pytest.mark.django_db
 def test_boardgame_log_data(boardgame_scrobble):
-    assert not boardgame_scrobble.geo_location
    assert boardgame_scrobble.logdata == BoardGameLogData(
        players=[
            BoardGameScoreLogData(
-                user_id=1,
-                name_str="",
+                person_id=1,
                bgg_username="",
                color="Blue",
                character=None,
@ -18,10 +17,24 @@ def test_boardgame_log_data(boardgame_scrobble):
                score=30,
                win=True,
                new=None,
-            )
+                rank=None,
+                seat_order=None,
+                role=None
+            ),
+            BoardGameScoreLogData(
+                person_id=2,
+                bgg_username="",
+                color="Red",
+                character=None,
+                team=None,
+                score=28,
+                win=False,
+                new=None,
+                rank=None,
+                seat_order=None,
+                role=None
+            ),
        ],
-        location=None,
-        geo_location_id=None,
        difficulty=None,
        solo=None,
        two_handed=None,
--- a/vrobbler/apps/beers/api/init.py
+++ b/vrobbler/apps/beers/api/init.py
--- a/vrobbler/apps/beers/api/serializers.py
+++ b/vrobbler/apps/beers/api/serializers.py
@ -0,0 +1,18 @@
+from rest_framework import serializers
+from beers.models import Beer, BeerProducer, BeerStyle
+
+
+class BeerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Beer
+        fields = "__all__"
+        
+class BeerProducerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = BeerProducer
+        fields = "__all__"
+
+class BeerStyleSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = BeerStyle
+        fields = "__all__"
--- a/vrobbler/apps/beers/api/views.py
+++ b/vrobbler/apps/beers/api/views.py
@ -0,0 +1,19 @@
+from rest_framework import permissions, viewsets
+from beers.api import serializers
+from beers import models
+
+
+class BeerViewSet(viewsets.ModelViewSet):
+    queryset = models.Beer.objects.all().order_by("-created")
+    serializer_class = serializers.BeerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+class BeerProducerViewSet(viewsets.ModelViewSet):
+    queryset = models.BeerProducer.objects.all().order_by("-created")
+    serializer_class = serializers.BeerProducerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+class BeerStyleViewSet(viewsets.ModelViewSet):
+    queryset = models.BeerStyle.objects.all().order_by("-created")
+    serializer_class = serializers.BeerStyleSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/beers/migrations/0006_remove_beer_run_time_seconds_and_more.py
+++ b/vrobbler/apps/beers/migrations/0006_remove_beer_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('beers', '0005_alter_beer_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='beer',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='beer',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='beer',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/beers/models.py
+++ b/vrobbler/apps/beers/models.py
@ -1,18 +1,25 @@
+from dataclasses import dataclass
+from typing import Optional
 from uuid import uuid4

-from beers.untappd import get_beer_from_untappd_id, get_rating_from_soup
+from beers.untappd import get_beer_from_untappd_id
 from django.apps import apps
 from django.db import models
 from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
-from scrobbles.dataclasses import BeerLogData
+from scrobbles.dataclasses import BaseLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin

 BNULL = {"blank": True, "null": True}


+@dataclass
+class BeerLogData(BaseLogData):
+    rating: Optional[str] = None
+
+
 class BeerStyle(TimeStampedModel):
    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
    name = models.CharField(max_length=255)
--- a/vrobbler/apps/boardgames/api/serializers.py
+++ b/vrobbler/apps/boardgames/api/serializers.py
@ -0,0 +1,22 @@
+from boardgames import models
+from rest_framework import serializers
+
+class BoardGameDesignerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.BoardGameDesigner
+        fields = "__all__"
+
+class BoardGamePublisherSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.BoardGamePublisher
+        fields = "__all__"
+
+class BoardGameLocationSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.BoardGameLocation
+        fields = "__all__"
+
+class BoardGameSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.BoardGame
+        fields = "__all__"
--- a/vrobbler/apps/boardgames/api/views.py
+++ b/vrobbler/apps/boardgames/api/views.py
@ -0,0 +1,28 @@
+from rest_framework import permissions, viewsets
+
+from boardgames.api import serializers
+from boardgames import models
+
+
+class BoardGameDesignerViewSet(viewsets.ModelViewSet):
+    queryset = models.BoardGameDesigner.objects.all().order_by("-created")
+    serializer_class = serializers.BoardGameDesignerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class BoardGamePublisherViewSet(viewsets.ModelViewSet):
+    queryset = models.BoardGamePublisher.objects.all().order_by("-created")
+    serializer_class = serializers.BoardGamePublisherSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class BoardGameLocationViewSet(viewsets.ModelViewSet):
+    queryset = models.BoardGameLocation.objects.all().order_by("-created")
+    serializer_class = serializers.BoardGameLocationSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class BoardGameViewSet(viewsets.ModelViewSet):
+    queryset = models.BoardGame.objects.all().order_by("-created")
+    serializer_class = serializers.BoardGameSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/boardgames/bgg.py
+++ b/vrobbler/apps/boardgames/bgg.py
@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Optional
 import requests
 from bs4 import BeautifulSoup
 from django.contrib.auth import get_user_model
+from django.conf import settings

 User = get_user_model()
 if TYPE_CHECKING:
@ -17,6 +18,8 @@ SEARCH_ID_URL = (
    "https://boardgamegeek.com/xmlapi/search?search={query}&exact=1"
 )
 GAME_ID_URL = "https://boardgamegeek.com/xmlapi/boardgame/{id}"
+BGG_ACCESS_TOKEN = getattr(settings, "BGG_ACCESS_TOKEN", "")
+BASE_HEADERS = {"User-Agent": "Vrobbler 31.0", "Authorization": f"Bearer {BGG_ACCESS_TOKEN}"}


 def take_first(thing: Optional[list]) -> str:
@ -37,10 +40,9 @@ def take_first(thing: Optional[list]) -> str:

 def lookup_boardgame_id_from_bgg(title: str) -> Optional[int]:
    soup = None
-    headers = {"User-Agent": "Vrobbler 0.11.12"}
    game_id = None
    url = SEARCH_ID_URL.format(query=title)
-    r = requests.get(url, headers=headers)
+    r = requests.get(url, headers=BASE_HEADERS)
    if r.status_code == 200:
        soup = BeautifulSoup(r.text, "xml")

@ -57,7 +59,6 @@ def lookup_boardgame_id_from_bgg(title: str) -> Optional[int]:
 def lookup_boardgame_from_bgg(lookup_id: str) -> dict:
    soup = None
    game_dict = {}
-    headers = {"User-Agent": "Vrobbler 0.11.12"}

    title = ""
    bgg_id = None
@ -73,7 +74,7 @@ def lookup_boardgame_from_bgg(lookup_id: str) -> dict:
        bgg_id = lookup_boardgame_id_from_bgg(title)

    url = GAME_ID_URL.format(id=bgg_id)
-    r = requests.get(url, headers=headers)
+    r = requests.get(url, headers=BASE_HEADERS)
    if r.status_code == 200:
        soup = BeautifulSoup(r.text, "xml")

@ -109,7 +110,8 @@ def push_scrobble_to_bgg(scrobble: "Scrobble", user: User) -> Optional[bool]:
    login_payload = {
        "credentials": {"username": bgg_username, "password": bgg_password}
    }
-    headers = {"content-type": "application/json"}
+    headers = BASE_HEADERS
+    headers["content-type"] = "application/json"

    # TODO Look up past plays for scrobble.media_obj.bggeek_id, and make sure we haven't scrobbled this before

@ -119,8 +121,6 @@ def push_scrobble_to_bgg(scrobble: "Scrobble", user: User) -> Optional[bool]:
            data=json.dumps(login_payload),
            headers=headers,
        )
-        print(p)
-
        players = []
        if scrobble.log:
            for player in scrobble.log.get("players"):
@ -153,4 +153,3 @@ def push_scrobble_to_bgg(scrobble: "Scrobble", user: User) -> Optional[bool]:
            data=json.dumps(play_payload),
            headers=headers,
        )
-        print(r)
--- a/vrobbler/apps/boardgames/migrations/0008_boardgamedesigner_and_more.py
+++ b/vrobbler/apps/boardgames/migrations/0008_boardgamedesigner_and_more.py
@ -140,7 +140,7 @@ class Migration(migrations.Migration):
                        null=True,
                    ),
                ),
-                ("bgstats_id", models.IntegerField(blank=True, null=True)),
+                ("bgstats_id", models.UUIDField(blank=True, null=True)),
                ("description", models.TextField(blank=True, null=True)),
                (
                    "geo_location",
--- a/vrobbler/apps/boardgames/migrations/0010_alter_boardgamelocation_bgstats_id.py
+++ b/vrobbler/apps/boardgames/migrations/0010_alter_boardgamelocation_bgstats_id.py
@ -1,18 +0,0 @@
-# Generated by Django 4.2.19 on 2025-07-03 02:25
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("boardgames", "0009_alter_boardgame_cooperative_and_more"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="boardgamelocation",
-            name="bgstats_id",
-            field=models.UUIDField(blank=True, null=True),
-        ),
-    ]
--- a/vrobbler/apps/boardgames/migrations/0010_boardgame_published_year.py
+++ b/vrobbler/apps/boardgames/migrations/0010_boardgame_published_year.py
@ -6,7 +6,7 @@ from django.db import migrations, models
 class Migration(migrations.Migration):

    dependencies = [
-        ("boardgames", "0010_alter_boardgamelocation_bgstats_id"),
+        ("boardgames", "0009_alter_boardgame_cooperative_and_more"),
    ]

    operations = [
--- a/vrobbler/apps/boardgames/migrations/0011_remove_boardgame_run_time_seconds_and_more.py
+++ b/vrobbler/apps/boardgames/migrations/0011_remove_boardgame_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boardgames', '0010_boardgame_published_year'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='boardgame',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='boardgame',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='boardgame',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/boardgames/migrations/0012_boardgame_bgg_rank.py
+++ b/vrobbler/apps/boardgames/migrations/0012_boardgame_bgg_rank.py
@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-11-03 04:34
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boardgames', '0011_remove_boardgame_run_time_seconds_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='boardgame',
+            name='bgg_rank',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/boardgames/migrations/0013_boardgame_publishers.py
+++ b/vrobbler/apps/boardgames/migrations/0013_boardgame_publishers.py
@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-11-03 04:41
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boardgames', '0012_boardgame_bgg_rank'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='boardgame',
+            name='publishers',
+            field=models.ManyToManyField(related_name='board_games', to='boardgames.boardgamepublisher'),
+        ),
+    ]
--- a/vrobbler/apps/boardgames/models.py
+++ b/vrobbler/apps/boardgames/models.py
@ -1,10 +1,13 @@
+from functools import cached_property
 import logging
+from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Any
 from uuid import uuid4

+from django import forms
 import requests
-from boardgames.bgg import lookup_boardgame_from_bgg
+from boardgames.sources.bgg import lookup_boardgame_from_bgg
 from django.conf import settings
 from django.core.files.base import ContentFile
 from django.db import models
@ -12,14 +15,115 @@ from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
-from scrobbles.dataclasses import BoardGameLogData
-from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
 from locations.models import GeoLocation
+from people.models import Person
+from scrobbles.dataclasses import BaseLogData, LongPlayLogData
+from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin

 logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}


+@dataclass
+class BoardGameScoreLogData(BaseLogData):
+    person_id: Optional[int] = None
+    bgg_username: Optional[str] = None
+    color: Optional[str] = None
+    character: Optional[str] = None
+    team: Optional[str] = None
+    score: Optional[int] = None
+    win: Optional[bool] = None
+    new: Optional[bool] = None
+    rank: Optional[int] = None
+    seat_order: Optional[int] = None
+    role: Optional[str] = None
+    rank: Optional[int] = None
+    seat_order: Optional[int] = None
+    role: Optional[str] = None
+    lichess_username: Optional[str] = None
+
+    @property
+    def person(self) -> Optional[Person]:
+        return Person.objects.filter(id=self.person_id).first()
+
+    @property
+    def name(self) -> str:
+        name = ""
+        if self.person:
+            name = self.person.name
+        return name
+
+    def __str__(self) -> str:
+        out = self.name
+        if self.score:
+            out += f" {self.score}"
+        if self.color:
+            out += f" ({self.color})"
+        if self.win:
+            out += f" [W]"
+        return out
+
+
+@dataclass
+class BoardGameLogData(BaseLogData, LongPlayLogData):
+    players: Optional[list[BoardGameScoreLogData]] = None
+    location_id: Optional[int] = None
+    difficulty: Optional[int] = None
+    solo: Optional[bool] = None
+    two_handed: Optional[bool] = None
+    expansion_ids: Optional[int] = None
+    moves: Optional[list] = None
+    rated: Optional[str] = None
+    speed: Optional[str] = None
+    variant: Optional[str] = None
+    lichess_id: Optional[int] = None
+    board: Optional[str] = None
+    rounds: Optional[int] = None
+    details: Optional[str] = None
+
+    _excluded_fields = {
+        "lichess_id",
+        "speed",
+        "rated",
+        "moves",
+        "variant",
+    }
+
+    @cached_property
+    def location(self):
+        if not self.location_id:
+            return
+        return BoardGameLocation.objects.filter(id=self.location_id).first()
+
+    @cached_property
+    def player_log(self) -> str:
+        if self.players:
+            return ", ".join(
+                [
+                    BoardGameScoreLogData(**player).__str__()
+                    for player in self.players
+                ]
+            )
+        return ""
+
+    @classmethod
+    def override_fields(cls) -> dict:
+        fields = {}
+        for base in cls.mro()[1:]:
+            if hasattr(base, "override_fields"):
+                base_fields = base.override_fields()
+                fields.update(base_fields)
+        custom_fields = {
+            "location_id": forms.ModelChoiceField(
+                queryset=BoardGameLocation.objects.all(),
+                required=False,
+                widget=forms.Select(),
+            )
+        }
+        fields.update(custom_fields)
+        return fields
+
+
 class BoardGamePublisher(TimeStampedModel):
    name = models.CharField(max_length=255)
    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
@ -87,6 +191,10 @@ class BoardGame(ScrobblableMixin):
    publisher = models.ForeignKey(
        BoardGamePublisher, **BNULL, on_delete=models.DO_NOTHING
    )
+    publishers = models.ManyToManyField(
+        BoardGamePublisher,
+        related_name="board_games",
+    )
    designers = models.ManyToManyField(
        BoardGameDesigner,
        related_name="board_games",
@ -120,6 +228,7 @@ class BoardGame(ScrobblableMixin):
        options={"quality": 75},
    )
    rating = models.FloatField(**BNULL)
+    bgg_rank = models.IntegerField(**BNULL)
    max_players = models.PositiveSmallIntegerField(**BNULL)
    min_players = models.PositiveSmallIntegerField(**BNULL)
    published_date = models.DateField(**BNULL)
@ -197,29 +306,58 @@ class BoardGame(ScrobblableMixin):

            # Go get cover image if the URL is present
            if cover_url and not self.cover:
-                headers = {"User-Agent": "Vrobbler 0.11.12"}
-                r = requests.get(cover_url, headers=headers)
-                logger.debug(r.status_code)
-                if r.status_code == 200:
-                    fname = f"{self.title}_cover_{self.uuid}.jpg"
-                    self.cover.save(fname, ContentFile(r.content), save=True)
-                    logger.debug("Loaded cover image from BGGeek")
+                self.save_image_from_url(cover_url)
+
+    def save_image_from_url(self, url):
+        headers = {"User-Agent": "Vrobbler 0.11.12"}
+        r = requests.get(url, headers=headers)
+        if r.status_code == 200:
+            fname = f"{self.title}_cover_{self.uuid}.jpg"
+            self.cover.save(fname, ContentFile(r.content), save=True)

    @classmethod
    def find_or_create(
-        cls, lookup_id: str, data: Optional[dict] = {}
-    ) -> Optional["BoardGame"]:
+        cls, lookup_id: str, data: dict[str, Any] = {}
+    ) -> "BoardGame":
        """Given a Lookup ID (either BGG or BGA ID), return a board game object"""
-        boardgame = cls.objects.filter(bggeek_id=lookup_id).first()
+        game = cls.objects.filter(bggeek_id=lookup_id).first()

-        if not data or not boardgame:
-            data = lookup_boardgame_from_bgg(lookup_id)
+        if game:
+            logger.info("Board game exists in database.", extra={"lookup_id": lookup_id, "data": data})
+            return game

-        if data and not boardgame:
-            boardgame, created = cls.objects.get_or_create(
-                title=data["title"], bggeek_id=lookup_id
-            )
-            if created:
-                boardgame.fix_metadata(data=data)
+        bgg_data = lookup_boardgame_from_bgg(data.get("name"))

-        return boardgame
+        mechanics = bgg_data.pop("mechanics", [])
+        designers = bgg_data.pop("designers", [])
+        categories = bgg_data.pop("categories", [])
+        publishers = bgg_data.pop("publishers", [])
+        cover_url = bgg_data.pop("cover_url")
+
+        game = cls.objects.create(
+            **bgg_data
+        )
+
+        game.save_image_from_url(cover_url)
+        game.cooperative = data.get("cooperative", False)
+        game.highest_wins = data.get("highestWins", True)
+        game.no_points = data.get("noPoints", False)
+        game.uses_teams = data.get("useTeams", False)
+        game.bgstats_id = data.get("uuid", None)
+        game.save()
+
+        if designers:
+            for designer_name in designers:
+                designer, created = BoardGameDesigner.objects.get_or_create(
+                    name=designer_name
+                )
+                game.designers.add(designer.id)
+
+        if publishers:
+            for name in publishers:
+                publisher, _ = BoardGamePublisher.objects.get_or_create(
+                    name=name
+                )
+                game.publishers.add(publisher)
+
+        return game
--- a/vrobbler/apps/boardgames/sources/bgg.py
+++ b/vrobbler/apps/boardgames/sources/bgg.py
@ -0,0 +1,29 @@
+from typing import Any
+from boardgamegeek import BGGClient
+
+from django.conf import settings
+
+def lookup_boardgame_from_bgg(title: str) -> dict[str, Any]:
+    game_dict = {"title": title}
+
+    bgg = BGGClient(access_token=settings.BGG_ACCESS_TOKEN)
+
+    game = bgg.game(title)
+
+    if game:
+        game_dict["description"] = game.description
+        game_dict["published_year"] = game.yearpublished
+        game_dict["cover_url"] = game.image
+        game_dict["min_players"] = game.minplayers
+        game_dict["max_players"] = game.maxplayers
+        game_dict["recommended_age"] = game.minage
+        game_dict["rating"] = game.rating_average
+        game_dict["bgg_rank"] = game.bgg_rank
+        game_dict["base_run_time_seconds"] = int(game.playingtime) * 60 if game.playingtime else None
+
+        game_dict["mechanics"] = game.mechanics
+        game_dict["categories"] = game.categories
+        game_dict["designers"] = game.designers
+        game_dict["publishers"] = game.publishers
+
+    return game_dict
--- a/vrobbler/apps/boardgames/sources/lichess.py
+++ b/vrobbler/apps/boardgames/sources/lichess.py
@ -3,7 +3,7 @@ from boardgames.models import BoardGame
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from scrobbles.models import Scrobble
-from scrobbles.notifications import NtfyNotification
+from scrobbles.notifications import ScrobbleNtfyNotification

 User = get_user_model()

@ -18,9 +18,9 @@ def import_chess_games_for_user_id(user_id: int, commit: bool = False) -> dict:
    for game_dict in games:
        chess, created = BoardGame.objects.get_or_create(title="Chess")
        if created:
-            chess.run_time_seconds = 1800
+            chess.base_run_time_seconds = 1800
            chess.bggeek_id = 171
-            chess.save(update_fields=["run_time_seconds", "bggeek_id"])
+            chess.save(update_fields=["base_run_time_seconds", "bggeek_id"])
        scrobble = Scrobble.objects.filter(
            user_id=user.id,
            timestamp=game_dict.get("createdAt"),
@ -124,5 +124,5 @@ def import_chess_games_for_all_users():
    if scrobbles_to_create:
        created = Scrobble.objects.bulk_create(scrobbles_to_create)
        for scrobble in created:
-            NtfyNotification(scrobble).send()
+            ScrobbleNtfyNotification(scrobble).send()
    return scrobbles_to_create
--- a/vrobbler/apps/books/admin.py
+++ b/vrobbler/apps/books/admin.py
@ -21,7 +21,8 @@ class BookAdmin(admin.ModelAdmin):
    date_hierarchy = "created"
    list_display = (
        "title",
-        "subtitle",
+        "author",
+        "issue_or_volume",
        "isbn_13",
        "first_publish_year",
        "pages",
@ -32,6 +33,9 @@ class BookAdmin(admin.ModelAdmin):
        ScrobbleInline,
    ]

+    def issue_or_volume(self, obj):
+        return obj.issue_number or obj.volume_number
+

@admin.register(Paper)
 class BookAdmin(admin.ModelAdmin):
--- a/vrobbler/apps/books/api/views.py
+++ b/vrobbler/apps/books/api/views.py
@ -1,19 +1,16 @@
 from rest_framework import permissions, viewsets

-from books.api.serializers import (
-    AuthorSerializer,
-    BookSerializer,
-)
-from books.models import Author, Book
+from books.api import serializers
+from books import models


 class AuthorViewSet(viewsets.ModelViewSet):
-    queryset = Author.objects.all().order_by("-created")
-    serializer_class = AuthorSerializer
+    queryset = models.Author.objects.all().order_by("-created")
+    serializer_class = serializers.AuthorSerializer
    permission_classes = [permissions.IsAuthenticated]


 class BookViewSet(viewsets.ModelViewSet):
-    queryset = Book.objects.all().order_by("-created")
-    serializer_class = BookSerializer
+    queryset = models.Book.objects.all().order_by("-created")
+    serializer_class = serializers.BookSerializer
    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/books/constants.py
+++ b/vrobbler/apps/books/constants.py
@ -5,3 +5,5 @@ BOOKS_TITLES_TO_IGNORE = [
    "zb2rhkSwygt9vjkAEBj7tP5KVgFqejJqsJ2W3bYsrgiiKK8XL",
    "zb2rhchGpo7P27mofV9hYjT63d9ZaQnbQ6LSfzmkvsYzvARif",
 ]
+
+READCOMICSONLINE_URL = "https://readcomicsonline.ru"
--- a/vrobbler/apps/books/koreader.py
+++ b/vrobbler/apps/books/koreader.py
@ -3,16 +3,14 @@ import re
 import sqlite3
 from datetime import datetime, timedelta
 from enum import Enum
-
-import pendulum
 from zoneinfo import ZoneInfo
+
 import requests
 from books.constants import BOOKS_TITLES_TO_IGNORE
 from django.apps import apps
 from django.contrib.auth import get_user_model
+from scrobbles.notifications import ScrobbleNtfyNotification
 from stream_sqlite import stream_sqlite
-from scrobbles.notifications import NtfyNotification
-from vrobbler.apps.profiles.utils import one_off_fix_colins_profile
 from webdav.client import get_webdav_client

 logger = logging.getLogger(__name__)
@ -116,7 +114,7 @@ def create_book_from_row(row: list):
                "raw_row_data": clean_row,
            }
        },
-        run_time_seconds=run_time,
+        base_run_time_seconds=run_time,
    )
    # TODO Move these to async processes after importing
    # book.fix_metadata()
@ -287,17 +285,12 @@ def build_scrobbles_from_book_map(
                    datetime.fromtimestamp(int(last_page.get("end_ts")))
                )

-                if user.id == 1 and not user.profile.timezone_change_log:
-                    one_off_fix_colins_profile(user.profile)
-
                # 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)
-                else:
-                    print("In DST! ", timestamp)
+                #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,
@ -414,7 +407,7 @@ def process_koreader_sqlite_file(file_path, user_id) -> list:
    if new_scrobbles:
        created = Scrobble.objects.bulk_create(new_scrobbles)
        if created:
-            NtfyNotification(created[-1]).send()
+            ScrobbleNtfyNotification(created[-1]).send()
        fix_long_play_stats_for_scrobbles(created)
        logger.info(
            f"Created {len(created)} scrobbles",
--- a/vrobbler/apps/books/migrations/0029_book_comicvine_id_book_issue_number_and_more.py
+++ b/vrobbler/apps/books/migrations/0029_book_comicvine_id_book_issue_number_and_more.py
@ -0,0 +1,33 @@
+# Generated by Django 4.2.19 on 2025-10-20 18:35
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('books', '0028_delete_page'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='book',
+            name='comicvine_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='book',
+            name='issue_number',
+            field=models.IntegerField(blank=True, max_length=5, null=True),
+        ),
+        migrations.AddField(
+            model_name='book',
+            name='original_title',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='book',
+            name='volume_number',
+            field=models.IntegerField(blank=True, max_length=5, null=True),
+        ),
+    ]
--- a/vrobbler/apps/books/migrations/0030_book_readcomics_url.py
+++ b/vrobbler/apps/books/migrations/0030_book_readcomics_url.py
@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-10-22 16:29
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('books', '0029_book_comicvine_id_book_issue_number_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='book',
+            name='readcomics_url',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]
--- a/vrobbler/apps/books/migrations/0031_book_next_readcomics_url.py
+++ b/vrobbler/apps/books/migrations/0031_book_next_readcomics_url.py
@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-10-22 17:42
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('books', '0030_book_readcomics_url'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='book',
+            name='next_readcomics_url',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]
--- a/vrobbler/apps/books/migrations/0032_remove_book_run_time_seconds_and_more.py
+++ b/vrobbler/apps/books/migrations/0032_remove_book_run_time_seconds_and_more.py
@ -0,0 +1,39 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('books', '0031_book_next_readcomics_url'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='book',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='book',
+            name='run_time_ticks',
+        ),
+        migrations.RemoveField(
+            model_name='paper',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='paper',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='book',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='paper',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/books/models.py
+++ b/vrobbler/apps/books/models.py
@ -1,13 +1,19 @@
-from collections import OrderedDict
 import logging
-from datetime import timedelta, datetime
+from collections import OrderedDict
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
 from uuid import uuid4

 import requests
+from books.constants import READCOMICSONLINE_URL
 from books.openlibrary import (
    lookup_author_from_openlibrary,
    lookup_book_from_openlibrary,
 )
+from books.sources.google import lookup_book_from_google
+from books.sources.semantic import lookup_paper_from_semantic
+from books.utils import get_comic_issue_url
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.files.base import ContentFile
@ -16,28 +22,25 @@ from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
+from scrobbles.dataclasses import BaseLogData, LongPlayLogData
 from scrobbles.mixins import (
    LongPlayScrobblableMixin,
    ObjectWithGenres,
    ScrobblableConstants,
-    ScrobblableMixin,
 )
-from scrobbles.utils import get_scrobbles_for_media
+from scrobbles.utils import get_scrobbles_for_media, next_url_if_exists
 from taggit.managers import TaggableManager
 from thefuzz import fuzz
-from vrobbler.apps.books.comicvine import (
-    ComicVineClient,
-    lookup_comic_from_comicvine,
-)

 from vrobbler.apps.books.locg import (
    lookup_comic_by_locg_slug,
    lookup_comic_from_locg,
    lookup_comic_writer_by_locg_slug,
 )
-from vrobbler.apps.books.sources.google import lookup_book_from_google
-from vrobbler.apps.books.sources.semantic import lookup_paper_from_semantic
-from vrobbler.apps.scrobbles.dataclasses import BookLogData
+from vrobbler.apps.books.sources.comicvine import (
+    ComicVineClient,
+    lookup_comic_from_comicvine,
+)

 COMICVINE_API_KEY = getattr(settings, "COMICVINE_API_KEY", "")

@ -46,6 +49,34 @@ User = get_user_model()
 BNULL = {"blank": True, "null": True}


+@dataclass
+class BookPageLogData(BaseLogData):
+    page_number: Optional[int] = None
+    end_ts: Optional[int] = None
+    start_ts: Optional[int] = None
+    duration: Optional[int] = None
+
+
+@dataclass
+class BookLogData(BaseLogData, LongPlayLogData):
+    koreader_hash: Optional[str] = None
+    page_data: Optional[dict[int, BookPageLogData]] = None
+    pages_read: Optional[int] = None
+    page_start: Optional[int] = None
+    page_end: Optional[int] = None
+    resume_url: Optional[str] = None
+
+    _excluded_fields = {"koreader_hash", "page_data"}
+
+    def avg_seconds_per_page(self):
+        if self.page_data:
+            total_duration = 0
+            for page_num, stats in self.page_data.items():
+                total_duration += stats.get("duration", 0)
+            if total_duration:
+                return int(total_duration / len(self.page_data))
+
+
 class Author(TimeStampedModel):
    name = models.CharField(max_length=255)
    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
@ -107,6 +138,7 @@ class Book(LongPlayScrobblableMixin):
    )

    title = models.CharField(max_length=255)
+    original_title = models.CharField(max_length=255, **BNULL)
    authors = models.ManyToManyField(Author, blank=True)
    koreader_data_by_hash = models.JSONField(**BNULL)
    isbn_13 = models.CharField(max_length=255, **BNULL)
@ -117,6 +149,13 @@ class Book(LongPlayScrobblableMixin):
    publish_date = models.DateField(**BNULL)
    publisher = models.CharField(max_length=255, **BNULL)
    first_sentence = models.TextField(**BNULL)
+    # ComicVine
+    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(max_length=5, **BNULL)
+    volume_number = models.IntegerField(max_length=5, **BNULL)
+    # OpenLibrary
    openlibrary_id = models.CharField(max_length=255, **BNULL)
    cover = models.ImageField(upload_to="books/covers/", **BNULL)
    cover_small = ImageSpecField(
@ -135,7 +174,11 @@ class Book(LongPlayScrobblableMixin):

    genre = TaggableManager(through=ObjectWithGenres)

-    def __str__(self):
+    def __str__(self) -> str:
+        if self.issue_number and "Issue" not in str(self.title):
+            return f"{self.title} - Issue {self.issue_number}"
+        if self.volume_number and "Volume" not in str(self.title):
+            return f"{self.title} - Volume {self.volume_number}"
        return f"{self.title}"

    @property
@ -161,7 +204,45 @@ class Book(LongPlayScrobblableMixin):
        return reverse("books:book_detail", kwargs={"slug": self.uuid})

    @classmethod
-    def find_or_create(cls, title: str, enrich: bool = False, commit: bool = True):
+    def get_from_comicvine(cls, title: str, overwrite: bool = False, force_new: bool =False) -> "Book":
+        book, created = cls.objects.get_or_create(title=title)
+
+        if not created:
+            return book
+
+        book_dict = lookup_comic_from_comicvine(title)
+
+        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?
+                            ...
+
+            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)
+        return book
+
+    @classmethod
+    def find_or_create(
+            cls, title: str, url: str = "", enrich: bool = False, commit: bool = True
+    ):
        """Given a title, get a Book instance.

        If the book is not already in our database, or overwrite is True,
@ -171,23 +252,35 @@ class Book(LongPlayScrobblableMixin):
        like to batch create, use commit=False and you'll get an unsaved but enriched
        instance back which you can then save at your convenience."""
        # TODO use either a Google Books id identifier or author name like for tracks
-        book, created = cls.objects.get_or_create(title=title)
+        book, created = cls.objects.get_or_create(original_title=title)
        if not created:
-            logger.info("Found exact match for book by title", extra={"title": title})
+            logger.info(
+                "Found exact match for book by title", extra={"title": title}
+            )

        if not enrich:
-            logger.info("Found book by title, but not enriching", extra={"title": title})
+            logger.info(
+                "Found book by title, but not enriching",
+                extra={"title": title},
+            )
            return book

-        book_dict = lookup_book_from_google(title)
+        book_dict = None
+        if READCOMICSONLINE_URL in url:
+            book_dict = lookup_comic_from_comicvine(title)
+            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_google(title)
+
+        if not book_dict:
+            logger.warning("No book found in any source, using data as is", extra={"title": title})

        author_list = []
-        authors = book_dict.pop("authors")
-        cover_url = book_dict.pop("cover_url")
-        try:
-            genres = book_dict.pop("generes")
-        except:
-            genres = []
+        authors = book_dict.pop("authors", [])
+        cover_url = book_dict.pop("cover_url", "")
+        genres = book_dict.pop("generes", [])

        if authors:
            for author_str in authors:
@ -213,7 +306,7 @@ class Book(LongPlayScrobblableMixin):
        return book

    def save_image_from_url(self, url: str, force_update: bool = False):
-        if not self.cover or (force_update and url):
+        if url and (not self.cover or force_update):
            r = requests.get(url)
            if r.status_code == 200:
                fname = f"{self.title}_{self.uuid}.jpg"
@ -309,7 +402,7 @@ class Book(LongPlayScrobblableMixin):
                    self.cover.save(fname, ContentFile(r.content), save=True)

            if self.pages:
-                self.run_time_seconds = int(self.pages) * int(
+                self.base_run_time_seconds = int(self.pages) * int(
                    self.AVG_PAGE_READING_SECONDS
                )

--- a/vrobbler/apps/books/sources/comicvine.py
+++ b/vrobbler/apps/books/sources/comicvine.py
@ -3,7 +3,6 @@ ComicVine API Information & Documentation:
 https://comicvine.gamespot.com/api/
 https://comicvine.gamespot.com/api/documentation
 """
-import json
 import logging
 from django.conf import settings

@ -200,34 +199,72 @@ class ComicVineClient(object):


 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:
+        resource_type = "volume"
+        volume_number = title.split("Volume ")[1]
+
    api_key = getattr(settings, "COMICVINE_API_KEY", "")
    if not api_key:
-        logger.warn("No ComicVine API key configured, not looking anything up")
+        logger.warning("No ComicVine API key configured, not looking anything up")
        return {}

    client = ComicVineClient(
        api_key=getattr(settings, "COMICVINE_API_KEY", None)
    )
-    result = [
-        r
-        for r in client.search(title).get("results")
-        if r.get("resource_type") == "volume"
-    ][0]

-    if "volume" not in result.keys():
-        logger.warn("No result found on ComicVine", extra={"title": title})
+    raw_results = client.search(title).get("results")
+    results = [
+        r
+        for r in raw_results
+        if r.get("resource_type") == resource_type
+    ]
+    if not results:
+        logger.warning("No comic found on ComicVine")
        return {}

-    title = " ".join([result.get("volume").get("name"), result.get("name)")])
+    found_result = None
+    for result in results:
+        if result.get("issue_number") == str(issue_number):
+            found_result = result
+            break
+        if 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})
+
+    if not found_result:
+        logger.warning("No matches found on ComicVine")
+        return {}
+
+    title = found_result.get("name")
+
+    if found_result.get("volume"):
+        title = found_result.get("volume").get("name")
+
    data_dict = {
        "title": title,
-        "cover_url": result.get("image").get("original_url"),
-        "comicvine_data": {
-            "id": result.get("id"),
-            "site_detail_url": result.get("site_detail_url"),
-            "description": result.get("description"),
-            "image": result.get("image").get("original_url"),
-        },
+        "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]
    }

    return data_dict
--- a/vrobbler/apps/books/sources/google.py
+++ b/vrobbler/apps/books/sources/google.py
@ -29,6 +29,9 @@ def lookup_book_from_google(title: str) -> dict:
    google_result = (
        json.loads(response.content).get("items", [{}])[0].get("volumeInfo")
    )
+    if not google_result:
+        return {}
+
    publish_date = pendulum.parse(google_result.get("publishedDate"))

    isbn_13 = ""
@ -59,13 +62,15 @@ def lookup_book_from_google(title: str) -> dict:
    book_dict["genres"] = google_result.get("categories")
    book_dict["cover_url"] = (
        google_result.get("imageLinks", {})
-        .get("thumbnail")
+        .get("thumbnail", "")
        .replace("zoom=1", "zoom=15")
        .replace("&edge=curl", "")
    )

-    book_dict["run_time_seconds"] = book_dict.get("pages", 10) * getattr(
-        settings, "AVERAGE_PAGE_READING_SECONDS", 60
-    )
+    book_dict["base_run_time_seconds"] = 3600
+    if book_dict.get("pages"):
+        book_dict["base_run_time_seconds"] = book_dict.get("pages", 10) * getattr(
+            settings, "AVERAGE_PAGE_READING_SECONDS", 60
+        )

    return book_dict
--- a/vrobbler/apps/books/sources/semantic.py
+++ b/vrobbler/apps/books/sources/semantic.py
@ -67,7 +67,7 @@ def lookup_paper_from_semantic(title: str) -> dict:
    paper_dict["openaccess_pdf_url"] = result.get("openAccessPdf", {}).get(
        "url"
    )
-    paper_dict["run_time_seconds"] = paper_dict.get("pages", 10) * getattr(
+    paper_dict["base_run_time_seconds"] = paper_dict.get("pages", 10) * getattr(
        settings, "AVERAGE_PAGE_READING_SECONDS", 60
    )
    paper_dict["author_dicts"] = result.get("authors")
--- a/vrobbler/apps/books/utils.py
+++ b/vrobbler/apps/books/utils.py
@ -0,0 +1,59 @@
+import re
+from urllib.parse import urlparse, urlunparse
+
+from titlecase import titlecase
+
+
+def parse_readcomicsonline_uri(uri: str) -> tuple:
+    try:
+        path = uri.split("comic/")[1]
+    except IndexError:
+        return "", "", ""
+
+    parts = path.split('/')
+    title = ""
+    volume = 1
+    page = 1
+    if len(parts) == 2:
+        title = titlecase(parts[0].replace("-", " "))
+        volume = parts[1]
+    if len(parts) == 3:
+        title = titlecase(parts[0].replace("-", " "))
+        volume = parts[1]
+        page = parts[2]
+
+    return title, volume, page
+
+
+def get_comic_issue_url(url: str) -> str:
+    parsed = urlparse(url)
+    parts = [p for p in parsed.path.strip('/').split('/') if p]
+
+    # Find the index of "comic"
+    try:
+        comic_index = parts.index("comic")
+    except ValueError:
+        raise ValueError("URL does not contain '/comic/' segment")
+
+    # Extract title (next part after 'comic')
+    if len(parts) <= comic_index + 1:
+        raise ValueError("No comic title found after '/comic/'")
+    title = parts[comic_index + 1]
+
+    # Look for the first numeric segment after the title
+    number = None
+    for segment in parts[comic_index + 2:]:
+        if segment.isdigit():
+            number = segment
+            break
+
+    # Build normalized path
+    new_parts = ["comic", title]
+    if number:
+        new_parts.append(number)
+
+    normalized_path = "/" + "/".join(new_parts)
+
+    # Rebuild full URL (same scheme and host)
+    simplified_url = urlunparse(parsed._replace(path=normalized_path, query='', fragment=''))
+    return simplified_url
--- a/vrobbler/apps/bricksets/api/init.py
+++ b/vrobbler/apps/bricksets/api/init.py
--- a/vrobbler/apps/bricksets/api/serializers.py
+++ b/vrobbler/apps/bricksets/api/serializers.py
@ -0,0 +1,8 @@
+from rest_framework import serializers
+from bricksets.models import BrickSet
+
+
+class BrickSetSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = BrickSet
+        fields = "__all__"
--- a/vrobbler/apps/bricksets/api/views.py
+++ b/vrobbler/apps/bricksets/api/views.py
@ -0,0 +1,9 @@
+from rest_framework import permissions, viewsets
+from bricksets.api.serializers import BrickSetSerializer
+from bricksets.models import BrickSet
+
+
+class BrickSetViewSet(viewsets.ModelViewSet):
+    queryset = BrickSet.objects.all().order_by("-created")
+    serializer_class = BrickSetSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/bricksets/migrations/0003_remove_brickset_run_time_seconds_and_more.py
+++ b/vrobbler/apps/bricksets/migrations/0003_remove_brickset_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bricksets', '0002_alter_brickset_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='brickset',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='brickset',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='brickset',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/bricksets/models.py
+++ b/vrobbler/apps/bricksets/models.py
@ -1,15 +1,25 @@
-from django.apps import apps
+from dataclasses import dataclass
+
 from django.db import models
 from django.urls import reverse
-from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
-from scrobbles.dataclasses import BrickSetLogData
 from scrobbles.mixins import LongPlayScrobblableMixin

+from vrobbler.apps.scrobbles.dataclasses import (
+    BaseLogData,
+    LongPlayLogData,
+    WithPeopleLogData,
+)
+
 BNULL = {"blank": True, "null": True}


+@dataclass
+class BrickSetLogData(BaseLogData, WithPeopleLogData, LongPlayLogData):
+    pass
+
+
 class BrickSet(LongPlayScrobblableMixin):
    """"""

--- a/vrobbler/apps/foods/api/init.py
+++ b/vrobbler/apps/foods/api/init.py
--- a/vrobbler/apps/foods/api/serializers.py
+++ b/vrobbler/apps/foods/api/serializers.py
@ -0,0 +1,14 @@
+from rest_framework import serializers
+from foods import models
+
+
+class FoodCategorySerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.FoodCategory
+        fields = "__all__"
+
+
+class FoodSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Food
+        fields = "__all__"
--- a/vrobbler/apps/foods/api/views.py
+++ b/vrobbler/apps/foods/api/views.py
@ -0,0 +1,21 @@
+from rest_framework import permissions, viewsets
+from foods.api.serializers import (
+    FoodSerializer,
+    FoodCategorySerializer,
+)
+from foods.models import (
+    FoodCategory,
+    Food,
+)
+
+
+class FoodCategoryViewSet(viewsets.ModelViewSet):
+    queryset = FoodCategory.objects.all().order_by("-created")
+    serializer_class = FoodCategorySerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class FoodViewSet(viewsets.ModelViewSet):
+    queryset = Food.objects.all().order_by("-created")
+    serializer_class = FoodSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/foods/migrations/0003_food_calories.py
+++ b/vrobbler/apps/foods/migrations/0003_food_calories.py
@ -0,0 +1,18 @@
+# Generated by Django 4.2.19 on 2025-09-11 13:35
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('foods', '0002_alter_food_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='food',
+            name='calories',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/foods/migrations/0004_remove_food_run_time_seconds_and_more.py
+++ b/vrobbler/apps/foods/migrations/0004_remove_food_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('foods', '0003_food_calories'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='food',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='food',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='food',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/foods/models.py
+++ b/vrobbler/apps/foods/models.py
@ -1,3 +1,5 @@
+from dataclasses import dataclass
+from typing import Optional
 from uuid import uuid4

 from django.apps import apps
@ -6,12 +8,19 @@ from django.urls import reverse
 from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
-from scrobbles.dataclasses import FoodLogData
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin

 BNULL = {"blank": True, "null": True}


+@dataclass
+class FoodLogData(BaseLogData, WithPeopleLogData):
+    calories: Optional[int] = None
+    meal: Optional[str] = None
+    rating: Optional[str] = None
+
+
 class FoodCategory(TimeStampedModel):
    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
    name = models.CharField(max_length=255)
@ -40,6 +49,7 @@ class FoodCategory(TimeStampedModel):

 class Food(ScrobblableMixin):
    description = models.TextField(**BNULL)
+    calories = models.IntegerField(**BNULL)
    allrecipe_image = models.ImageField(upload_to="food/recipe/", **BNULL)
    allrecipe_image_small = ImageSpecField(
        source="allrecipe_image",
@ -64,7 +74,8 @@ class Food(ScrobblableMixin):

    @property
    def subtitle(self):
-        return self.category.name
+        if self.category:
+            return self.category.name

    @property
    def strings(self) -> ScrobblableConstants:
--- a/vrobbler/apps/lifeevents/api/serializers.py
+++ b/vrobbler/apps/lifeevents/api/serializers.py
@ -0,0 +1,8 @@
+from lifeevents.models import LifeEvent
+from rest_framework import serializers
+
+
+class LifeEventSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = LifeEvent
+        fields = "__all__"
--- a/vrobbler/apps/lifeevents/api/views.py
+++ b/vrobbler/apps/lifeevents/api/views.py
@ -0,0 +1,10 @@
+from rest_framework import permissions, viewsets
+
+from lifeevents.api import serializers
+from lifeevents import models
+
+
+class LifeEventViewSet(viewsets.ModelViewSet):
+    queryset = models.LifeEvent.objects.all().order_by("-created")
+    serializer_class = serializers.LifeEventSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/lifeevents/migrations/0003_remove_lifeevent_run_time_seconds_and_more.py
+++ b/vrobbler/apps/lifeevents/migrations/0003_remove_lifeevent_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('lifeevents', '0002_alter_lifeevent_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='lifeevent',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='lifeevent',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='lifeevent',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/lifeevents/models.py
+++ b/vrobbler/apps/lifeevents/models.py
@ -1,12 +1,18 @@
+from dataclasses import dataclass
 from django.apps import apps
 from django.db import models
 from django.urls import reverse
-from scrobbles.dataclasses import LifeEventLogData
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin

 BNULL = {"blank": True, "null": True}


+@dataclass
+class LifeEventLogData(BaseLogData, WithPeopleLogData):
+    pass
+
+
 class LifeEvent(ScrobblableMixin):
    description = models.TextField(**BNULL)

--- a/vrobbler/apps/locations/api/serializers.py
+++ b/vrobbler/apps/locations/api/serializers.py
@ -0,0 +1,8 @@
+from locations import models
+from rest_framework import serializers
+
+
+class GeoLocationSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.GeoLocation
+        fields = "__all__"
--- a/vrobbler/apps/locations/api/views.py
+++ b/vrobbler/apps/locations/api/views.py
@ -0,0 +1,9 @@
+from rest_framework import permissions, viewsets
+
+from locations.api import serializers
+from locations import models
+
+class GeoLocationViewSet(viewsets.ModelViewSet):
+    queryset = models.GeoLocation.objects.all().order_by("-created")
+    serializer_class = serializers.GeoLocationSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/locations/migrations/0008_remove_geolocation_run_time_seconds_and_more.py
+++ b/vrobbler/apps/locations/migrations/0008_remove_geolocation_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('locations', '0007_alter_geolocation_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='geolocation',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='geolocation',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='geolocation',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/locations/models.py
+++ b/vrobbler/apps/locations/models.py
@ -1,11 +1,13 @@
-from decimal import Decimal, getcontext
 import logging
+from dataclasses import dataclass
+from decimal import Decimal
 from typing import Dict

-from django.contrib.auth import get_user_model
 from django.conf import settings
+from django.contrib.auth import get_user_model
 from django.db import models
 from django.urls import reverse
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin

 logger = logging.getLogger(__name__)
@ -15,6 +17,9 @@ User = get_user_model()
 GEOLOC_ACCURACY = int(getattr(settings, "GEOLOC_ACCURACY", 4))
 GEOLOC_PROXIMITY = Decimal(getattr(settings, "GEOLOC_PROXIMITY", "0.0001"))

+@dataclass
+class GeoLocationLogData(BaseLogData, WithPeopleLogData):
+    pass

 class GeoLocation(ScrobblableMixin):
    COMPLETION_PERCENT = getattr(settings, "LOCATION_COMPLETION_PERCENT", 100)
@ -36,9 +41,13 @@ class GeoLocation(ScrobblableMixin):

    def get_absolute_url(self):
        return reverse(
-            "locations:geo_location_detail", kwargs={"slug": self.uuid}
+            "locations:geolocation_detail", kwargs={"slug": self.uuid}
        )

+    @property
+    def logdata_cls(self):
+        return GeoLocationLogData
+
    @classmethod
    def find_or_create(cls, data_dict: Dict) -> "GeoLocation":
        """Given a data dict from GPSLogger, does the heavy lifting of looking up
--- a/vrobbler/apps/locations/urls.py
+++ b/vrobbler/apps/locations/urls.py
@ -8,11 +8,11 @@ urlpatterns = [
    path(
        "locations/",
        views.GeoLocationListView.as_view(),
-        name="geo_locations_list",
+        name="geolocation_list",
    ),
    path(
        "locations/<slug:slug>/",
        views.GeoLocationDetailView.as_view(),
-        name="geo_location_detail",
+        name="geolocation_detail",
    ),
 ]
--- a/vrobbler/apps/moods/api/init.py
+++ b/vrobbler/apps/moods/api/init.py
--- a/vrobbler/apps/moods/api/serializers.py
+++ b/vrobbler/apps/moods/api/serializers.py
@ -0,0 +1,8 @@
+from rest_framework import serializers
+from moods.models import Mood
+
+
+class MoodSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Mood
+        fields = "__all__"
--- a/vrobbler/apps/moods/api/views.py
+++ b/vrobbler/apps/moods/api/views.py
@ -0,0 +1,9 @@
+from rest_framework import permissions, viewsets
+from moods.api.serializers import MoodSerializer
+from moods.models import Mood
+
+
+class MoodViewSet(viewsets.ModelViewSet):
+    queryset = Mood.objects.all().order_by("-created")
+    serializer_class = MoodSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/moods/fixtures/moods.json
+++ b/vrobbler/apps/moods/fixtures/moods.json
--- a/vrobbler/apps/moods/migrations/0004_remove_mood_run_time_seconds_and_more.py
+++ b/vrobbler/apps/moods/migrations/0004_remove_mood_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('moods', '0003_alter_mood_run_time_seconds'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='mood',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='mood',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='mood',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/moods/models.py
+++ b/vrobbler/apps/moods/models.py
@ -1,19 +1,25 @@
 import logging
+from dataclasses import dataclass
+from typing import Optional

 from django.contrib.auth import get_user_model
 from django.db import models
 from django.urls import reverse
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
+from scrobbles.dataclasses import BaseLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin

-from vrobbler.apps.scrobbles.dataclasses import MoodLogData
-
 logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}
 User = get_user_model()


+@dataclass
+class MoodLogData(BaseLogData):
+    reasons: Optional[str] = None
+
+
 class Mood(ScrobblableMixin):
    description = models.TextField(**BNULL)
    image = models.ImageField(upload_to="moods/", **BNULL)
@ -36,7 +42,7 @@ class Mood(ScrobblableMixin):
        return str(self.uuid)

    def get_absolute_url(self):
-        return reverse("moods:mood-detail", kwargs={"slug": self.uuid})
+        return reverse("moods:mood_detail", kwargs={"slug": self.uuid})

    @property
    def subtitle(self) -> str:
--- a/vrobbler/apps/moods/urls.py
+++ b/vrobbler/apps/moods/urls.py
@ -5,10 +5,10 @@ app_name = "moods"


 urlpatterns = [
-    path("moods/", views.MoodListView.as_view(), name="mood-list"),
+    path("moods/", views.MoodListView.as_view(), name="mood_list"),
    path(
        "moods/<slug:slug>/",
        views.MoodDetailView.as_view(),
-        name="mood-detail",
+        name="mood_detail",
    ),
 ]
--- a/vrobbler/apps/music/migrations/0028_alter_track_albums.py
+++ b/vrobbler/apps/music/migrations/0028_alter_track_albums.py
@ -0,0 +1,20 @@
+# Generated by Django 4.2.19 on 2025-07-25 14:41
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("music", "0027_track_albums"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="track",
+            name="albums",
+            field=models.ManyToManyField(
+                related_name="tracks", to="music.album"
+            ),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0029_remove_track_run_time_seconds_and_more.py
+++ b/vrobbler/apps/music/migrations/0029_remove_track_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0028_alter_track_albums'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='track',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='track',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='track',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/music/models.py
+++ b/vrobbler/apps/music/models.py
@ -1,5 +1,6 @@
 import logging
-from typing import Dict, Optional
+from dataclasses import dataclass
+from typing import Optional
 from uuid import uuid4

 import musicbrainzngs
@ -15,24 +16,26 @@ from imagekit.processors import ResizeToFit
 from music.allmusic import get_allmusic_slug, scrape_data_from_allmusic
 from music.bandcamp import get_bandcamp_slug
 from music.musicbrainz import (
-    get_album_metadata,
    get_album_metadata_with_artist,
-    get_artist_metadata_extended,
    get_recording_mbid_exact,
    get_track_metadata_with_artist,
-    lookup_album_dict_from_mb,
-    lookup_album_from_mb,
-    lookup_track_from_mb,
-    lookup_artist_from_mb,
 )
 from music.theaudiodb import lookup_album_from_tadb, lookup_artist_from_tadb
 from music.utils import clean_artist_name
+from scrobbles.dataclasses import BaseLogData
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin

 logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}


+@dataclass
+class TrackLogData(BaseLogData):
+    mopidy_source: Optional[str] = None
+    rockbox_info: Optional[str] = None
+    rating: Optional[int] = None
+
+
 class Artist(TimeStampedModel):
    """Represents a music artist.

@ -229,7 +232,7 @@ class Artist(TimeStampedModel):
            alt_name = found_name

        artist = cls.objects.filter(
-            name=name, musicbrainz_id=musicbrainz_id
+            name=found_name, musicbrainz_id=musicbrainz_id
        ).first()
        if not artist:
            artist = cls.objects.create(
@ -529,13 +532,15 @@ class Album(TimeStampedModel):
            logger.info(
                f"Could not find album {name} with artist {artist.name} on musicbrainz"
            )
-            album, created = Album.objects.get_or_create(
-                name=name,
-            )
-            if created:
-                # album.fix_metadata()
-                # album.fetch_artwork()
-                ...
+            album = Album.objects.filter(name=name).first()
+            if not album:
+                album, created = Album.objects.get_or_create(
+                    name=name,
+                )
+                if created:
+                    # album.fix_metadata()
+                    # album.fetch_artwork()
+                    ...
            return album

        if not artist:
@ -568,7 +573,7 @@ class Album(TimeStampedModel):
            alt_name = name

        album = Album.objects.filter(
-            name=found_name, musicbrainz_id=album_dict.get("mbid")
+            musicbrainz_id=album_dict.get("mbid")
        ).first()

        if not album:
@ -605,6 +610,9 @@ class Track(ScrobblableMixin):
    def __str__(self):
        return f"{self.title} by {self.artist}"

+    def logdata_cls(self):
+        return TrackLogData
+
    @property
    def primary_album(self):
        if self.album:
@ -669,7 +677,7 @@ class Track(ScrobblableMixin):

        lookup_keys = {"title": title, "artist": artist}
        if run_time_seconds:
-            lookup_keys["run_time_seconds"] = run_time_seconds
+            lookup_keys["base_run_time_seconds"] = run_time_seconds
        logger.info(f"Looking up track using: {lookup_keys}")
        track = cls.objects.filter(**lookup_keys).first()
        if track:
@ -691,7 +699,7 @@ class Track(ScrobblableMixin):
        if album:
            track.albums.add(album)

-        if enrich or not track.run_time_seconds:
+        if enrich or not track.base_run_time_seconds:
            logger.info(
                f"Enriching track {track}",
                extra={
@ -707,7 +715,7 @@ class Track(ScrobblableMixin):
            except Exception:
                print("No musicbrainz result found, cannot enrich")
                return track
-            track.run_time_seconds = run_time_seconds or int(length / 1000)
+            track.base_run_time_seconds = run_time_seconds or int(length / 1000)
            track.musicbrainz_id = mbid
            if commit:
                track.save()
--- a/vrobbler/apps/music/utils.py
+++ b/vrobbler/apps/music/utils.py
@ -10,11 +10,11 @@ logger = logging.getLogger(__name__)
 def clean_artist_name(name: str) -> str:
    """Remove featured names from artist string."""
    if " feat. " in name.lower():
-        name = re.split("feat.", name, flags=re.IGNORECASE)[0].strip()
+        name = re.split(" feat. ", name, flags=re.IGNORECASE)[0].strip()
    if " w. " in name.lower():
-        name = re.split("feat.", name, flags=re.IGNORECASE)[0].strip()
+        name = re.split(" w. ", name, flags=re.IGNORECASE)[0].strip()
    if " featuring " in name.lower():
-        name = re.split("featuring", name, flags=re.IGNORECASE)[0].strip()
+        name = re.split(" featuring ", name, flags=re.IGNORECASE)[0].strip()
    # if " & " in name.lower() and "of the wand" not in name.lower():
    #    name = re.split("&", name, flags=re.IGNORECASE)[0].strip()

--- a/vrobbler/apps/people/models.py
+++ b/vrobbler/apps/people/models.py
@ -15,3 +15,6 @@ class Person(TimeStampedModel):
    bgg_username = models.CharField(max_length=100, **BNULL)
    lichess_username = models.CharField(max_length=100, **BNULL)
    bio = models.TextField(**BNULL)
+
+    def __str__(self):
+        return self.name
--- a/vrobbler/apps/podcasts/api/serializers.py
+++ b/vrobbler/apps/podcasts/api/serializers.py
@ -0,0 +1,17 @@
+from podcasts import models
+from rest_framework import serializers
+
+class ProducerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Producer
+        fields = "__all__"
+
+class PodcastEpisodeSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.PodcastEpisode
+        fields = "__all__"
+
+class PodcastSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Podcast
+        fields = "__all__"
--- a/vrobbler/apps/podcasts/api/views.py
+++ b/vrobbler/apps/podcasts/api/views.py
@ -0,0 +1,20 @@
+from rest_framework import permissions, viewsets
+
+from podcasts.api import serializers
+from podcasts import models
+
+
+class ProducerViewSet(viewsets.ModelViewSet):
+    queryset = models.Producer.objects.all().order_by("-created")
+    serializer_class = serializers.ProducerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+class PodcastViewSet(viewsets.ModelViewSet):
+    queryset = models.Podcast.objects.all().order_by("-created")
+    serializer_class = serializers.PodcastSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+class PodcastEpisodeViewSet(viewsets.ModelViewSet):
+    queryset = models.PodcastEpisode.objects.all().order_by("-created")
+    serializer_class = serializers.PodcastEpisodeSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/podcasts/migrations/0018_remove_podcastepisode_run_time_seconds_and_more.py
+++ b/vrobbler/apps/podcasts/migrations/0018_remove_podcastepisode_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0017_podcast_podcastindex_id'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='podcastepisode',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='podcastepisode',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='podcastepisode',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/podcasts/models.py
+++ b/vrobbler/apps/podcasts/models.py
@ -143,43 +143,46 @@ class PodcastEpisode(ScrobblableMixin):
    def find_or_create(
        cls,
        title: str,
-        podcast_name: str,
        pub_date: str,
-        number: int = 0,
+        episode_num: int = 0,
+        base_run_time_seconds: int = 2400,
        mopidy_uri: str = "",
-        producer_name: str = "",
-        run_time_seconds: int = 1800,
+        podcast_name: str = "",
+        podcast_producer: str = "",
+        podcast_description: str = "",
        enrich: bool = True,
    ) -> "PodcastEpisode":
        """Given a data dict from Mopidy, finds or creates a podcast and
        producer before saving the epsiode so it can be scrobbled.

        """
+        log_context={"mopidy_uri": mopidy_uri, "media_type": "Podcast"}
        producer = None
-        if producer_name:
-            producer = Producer.find_or_create(producer_name)
+        if podcast_producer:
+            producer = Producer.find_or_create(podcast_producer)

-        podcast = Podcast.objects.filter(
-            name__iexact=podcast_name,
-        ).first()
-        if not podcast:
-            podcast = Podcast.objects.create(
-                name=podcast_name, producer=producer
-            )
-            if enrich:
-                podcast.fix_metadata()
+        podcast, created = Podcast.objects.get_or_create(name=podcast_name, defaults={"description": podcast_description})
+        log_context["podcast_id"] = podcast.id
+        log_context["podcast_name"] = podcast.name
+        if created:
+            logger.info("Created new podcast", extra=log_context)
+        if enrich and created:
+            logger.info("Enriching new podcast", extra=log_context)
+            podcast.fix_metadata()

-        episode = cls.objects.filter(
-            title__iexact=title, podcast=podcast
-        ).first()
-        if not episode:
-            episode = cls.objects.create(
-                title=title,
-                podcast=podcast,
-                run_time_seconds=run_time_seconds,
-                number=number,
-                pub_date=pub_date,
-                mopidy_uri=mopidy_uri,
-            )
+        episode, created = cls.objects.get_or_create(
+            title=title,
+            podcast=podcast,
+            defaults={
+                "base_run_time_seconds": base_run_time_seconds,
+                "number": episode_num,
+                "pub_date": pub_date,
+                "mopidy_uri": mopidy_uri,
+            }
+        )
+        if created:
+            log_context["episode_id"] = episode.id
+            log_context["episode_title"] = episode.title
+            logger.info("Created new podcast episode", extra=log_context)

        return episode
--- a/vrobbler/apps/podcasts/utils.py
+++ b/vrobbler/apps/podcasts/utils.py
@ -1,7 +1,10 @@
 import logging
 import os
+from typing import Any
 from urllib.parse import unquote

+import feedparser
+import requests
 from dateutil.parser import ParserError, parse
 from podcasts.models import PodcastEpisode

@ -10,26 +13,95 @@ logger = logging.getLogger(__name__)
 # TODO This should be configurable in settings or per deploy
 PODCAST_DATE_FORMAT = "YYYY-MM-DD"

+def parse_duration(d):
+    if not d:
+        return None
+    if d.isdigit():
+        return int(d)
+    parts = [int(p) for p in d.split(":")]
+    while len(parts) < 3:
+        parts.insert(0, 0)
+    h, m, s = parts
+    return h * 3600 + m * 60 + s
+
+def fetch_metadata_from_rss(uri: str) -> dict[str, Any]:
+    log_context = {"mopidy_uri": uri, "media_type": "Podcast"}
+    podcast_data: dict[str, Any] = {}
+
+    rss_url = uri.split("#")[0].split("podcast+")[1]
+    target_guid = uri.split("#")[1]
+
+    log_context["rss_url"] = rss_url
+    log_context["target_guid"] = target_guid
+
+    try:
+        resp = requests.get(rss_url, timeout=10)
+        feed = feedparser.parse(resp.text)
+    except IndexError:
+        logger.warning("Tried to parse uri as RSS feed, but no target found", extra=log_context)
+        return podcast_data
+
+    podcast_publisher = getattr(feed.feed, "itunes_publisher", "")
+    try:
+        podcast_owner = feed.feed.itunes_owner.get("name") if isinstance(feed.feed.itunes_owner, dict) else feed.feed.itunes_owner
+        podcast_other = feed.feed.get("managingeditor") or feed.feed.get("copyright")
+    except AttributeError:
+        podcast_owner = None
+        podcast_other = None
+
+    podcast_data = {
+        "podcast_name": getattr(feed.feed, "title", ""),
+        # "podcast_description": getattr(feed.feed, "description", ""),
+        # "podcast_link": getattr(feed.feed, "link", ""),
+        "podcast_producer": podcast_publisher or podcast_owner or podcast_other
+    }
+
+    for entry in feed.entries:
+        if entry.get("guid") == target_guid:
+            logger.info("🎧 Episode found in RSS feed", extra=log_context)
+            podcast_data["title"] = entry.title
+            podcast_data["episode_num"] = int(entry.get("itunes_episode", 0))
+            podcast_data["pub_date"] = parse(entry.get("published", None))
+            podcast_data["base_run_time_seconds"] = parse_duration(entry.get("itunes_duration", None))
+            # podcast_data["description"] = entry.get("description", None)
+            # podcast_data["episode_url"] = entry.enclosures[0].href if entry.get("enclosures") else None
+            return podcast_data
+    else:
+        logger.info("Episode not found in RSS feed.")
+
+
+def parse_mopidy_uri(uri: str) -> dict[str, Any]:
+    podcast_data: dict[str, Any] = {}

-def parse_mopidy_uri(uri: str) -> dict:
    logger.debug(f"Parsing URI: {uri}")
+    if "podcast+https" in uri:
+        return fetch_metadata_from_rss(uri)
+
+
    parsed_uri = os.path.splitext(unquote(uri))[0].split("/")

+    podcast_data = {
+        "title": parsed_uri[-1],
+        "episode_num": None,
+        "podcast_name": parsed_uri[-2].strip(),
+        "pub_date": None,
+    }
+
+
    episode_str = parsed_uri[-1]
-    podcast_name = parsed_uri[-2].strip()
    episode_num = None
    episode_num_pad = 0

    try:
        # Without episode numbers the date will lead
-        pub_date = parse(episode_str[0:10])
+        podcast_data["pub_date"] = parse(episode_str[0:10])
    except ParserError:
-        episode_num = int(episode_str.split("-")[0])
-        episode_num_pad = len(str(episode_num)) + 1
+        podcast_data["episode_num"] = int(episode_str.split("-")[0])
+        episode_num_pad = len(str(podcast_data["episode_num"])) + 1

        try:
            # Beacuse we have epsiode numbers on
-            pub_date = parse(
+            podcast_data["pub_date"] = parse(
                episode_str[
                    episode_num_pad : len(PODCAST_DATE_FORMAT)
                    + episode_num_pad
@ -39,41 +111,19 @@ def parse_mopidy_uri(uri: str) -> dict:
            pub_date = ""

    gap_to_strip = 0
-    if pub_date:
+    if podcast_data["pub_date"]:
        gap_to_strip += len(PODCAST_DATE_FORMAT)
-    if episode_num:
+    if podcast_data["episode_num"]:
        gap_to_strip += episode_num_pad

-    episode_name = episode_str[gap_to_strip:].replace("-", " ").strip()
+    podcast_data["title"] = episode_str[gap_to_strip:].replace("-", " ").strip()

-    return {
-        "episode_filename": episode_name,
-        "episode_num": episode_num,
-        "podcast_name": podcast_name,
-        "pub_date": pub_date,
-    }
+    return podcast_data


 def get_or_create_podcast(post_data: dict) -> PodcastEpisode:
+    logger.info("Looking up podcast", extra={"post_data": post_data, "media_type": "Podcast"})
    mopidy_uri = post_data.get("mopidy_uri", "")
    parsed_data = parse_mopidy_uri(mopidy_uri)

-    producer_dict = {"name": post_data.get("artist")}
-
-    podcast_name = post_data.get("album")
-    if not podcast_name:
-        podcast_name = parsed_data.get("podcast_name")
-    podcast_dict = {"name": podcast_name}
-
-    episode_name = parsed_data.get("episode_filename")
-    episode_dict = {
-        "title": episode_name,
-        "run_time_seconds": post_data.get("run_time"),
-        "number": parsed_data.get("episode_num"),
-        "pub_date": parsed_data.get("pub_date"),
-        "mopidy_uri": mopidy_uri,
-    }
-
-    return PodcastEpisode.find_or_create(
-        podcast_dict, producer_dict, episode_dict
-    )
+    return PodcastEpisode.find_or_create(**parsed_data)
--- a/vrobbler/apps/podcasts/views.py
+++ b/vrobbler/apps/podcasts/views.py
@ -1,6 +1,7 @@
 from django.views import generic
 from podcasts.models import Podcast

+from scrobbles.views import ScrobbleableListView, ScrobbleableDetailView

 class PodcastListView(generic.ListView):
    model = Podcast
--- a/vrobbler/apps/profiles/admin.py
+++ b/vrobbler/apps/profiles/admin.py
@ -7,6 +7,7 @@ from profiles.models import UserProfile
 class UserProfileAdmin(admin.ModelAdmin):
    date_hierarchy = "created"
    ordering = ("-created",)
+    readonly_fields = ("timezone_change_log",)
    exclude = (
        "twitch_token",
        "twitch_client_secret",
--- a/vrobbler/apps/profiles/migrations/0027_userprofile_mood_checkin_enabled_and_more.py
+++ b/vrobbler/apps/profiles/migrations/0027_userprofile_mood_checkin_enabled_and_more.py
@ -0,0 +1,23 @@
+# Generated by Django 4.2.19 on 2025-07-30 22:27
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('profiles', '0026_userprofile_timezone_change_log'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='mood_checkin_enabled',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name='userprofile',
+            name='mood_checkin_frequency',
+            field=models.CharField(default='hourly', max_length=20),
+        ),
+    ]
--- a/vrobbler/apps/profiles/models.py
+++ b/vrobbler/apps/profiles/models.py
@ -1,6 +1,5 @@
 from zoneinfo import ZoneInfo
 import pendulum
-from datetime import datetime
 from django.utils import timezone
 import logging
 from django.conf import settings
@ -16,6 +15,7 @@ BNULL = {"blank": True, "null": True}

 logger = logging.getLogger(__name__)

+
 class UserProfile(TimeStampedModel):
    user = models.OneToOneField(
        User, on_delete=models.CASCADE, related_name="profile"
@ -55,6 +55,9 @@ class UserProfile(TimeStampedModel):
    imap_pass = EncryptedField(**BNULL)
    imap_auto_import = models.BooleanField(default=False)

+    mood_checkin_enabled = models.BooleanField(default=False)
+    mood_checkin_frequency = models.CharField(max_length=20, default="hourly")
+
    ntfy_url = models.CharField(max_length=255, **BNULL)
    ntfy_enabled = models.BooleanField(default=False)

@ -72,7 +75,10 @@ class UserProfile(TimeStampedModel):
            old_instance = UserProfile.objects.get(pk=self.pk)
            is_timezone_change = self.timezone != old_instance.timezone
            if is_timezone_change:
-                logger.info("Updating timezone changelog for user", extra={"profile_id": self.id})
+                logger.info(
+                    "Updating timezone changelog for user",
+                    extra={"profile_id": self.id},
+                )
                previous_changes = old_instance.timezone_change_log
                now = timezone.now().replace(microsecond=0)
                new_log = f"{self.timezone} - {now}"
@ -98,7 +104,7 @@ class UserProfile(TimeStampedModel):
            change_list = self.historic_timezone_changes
            for idx, start in enumerate(change_list):
                try:
-                    end = change_list[idx+1]
+                    end = change_list[idx + 1]
                except IndexError:
                    end = None

@ -111,14 +117,34 @@ class UserProfile(TimeStampedModel):

        return timestamp.replace(tzinfo=timezone)

+    def adjust_timezone_of_scrobbles(self, commit=False):
+        current_dt = None
+        scrobbles_to_change_qs_list = []
+        for boundry_dt in self.historic_timezone_changes:
+            if current_dt and boundry_dt:
+                logger.info(
+                    f"Checking for scrobbles between {current_dt} and {boundry_dt} to update to {current_dt.tzinfo.name}"
+                )
+                scrobbles = self.user.scrobble_set.filter(
+                    timestamp__gte=current_dt,
+                    timestamp__lt=boundry_dt,
+                ).exclude(timezone=current_dt.tzinfo.name)
+                scrobbles_to_change_qs_list.append(scrobbles)
+                logger.info(
+                    f"Updating {scrobbles.count()} scrobble timezones to {current_dt.tzinfo.name}"
+                )
+                if commit:
+                    scrobbles.update(timezone=current_dt.tzinfo.name)
+
+            current_dt = boundry_dt
+        return scrobbles_to_change_qs_list
+
    @cached_property
    def task_context_tags(self) -> list[str]:
-        tag_list = [
-            t.strip().capitalize()
-            for t in self.task_context_tags_str.split(",")
-        ]
-
-        if not tag_list:
-            tag_list = settings.DEFAULT_TASK_CONTEXT_TAG_LIST
+        tag_list = settings.DEFAULT_TASK_CONTEXT_TAGS
+        tags = ""
+        if self.task_context_tags_str:
+            tags = self.task_context_tags_str
+            tag_list = [t.strip().capitalize() for t in tags.split(",")]

        return tag_list
--- a/vrobbler/apps/profiles/utils.py
+++ b/vrobbler/apps/profiles/utils.py
@ -59,25 +59,27 @@ def start_of_year(dt, profile) -> datetime:
    return start_of_day(dt, profile).replace(month=1, day=1)


-def one_off_fix_colins_profile(profile):
+def fix_profile_historic_timezones(profile):
    home_tz = "America/New_York"

-    europe = "2022-10-15"
+    europe = "2023-10-15 06:00:00"
+    europe_end = "2023-12-16 12:00:00"
    europe_tz = "Europe/Paris"
-    europe_end = "2023-12-15"

-    washington = "2023-04-28"
+    washington = "2024-04-28 06:00:00"
+    washington_end = "2024-05-04 12:00:00"
    washington_tz = "America/Los_Angeles"
-    washington_end = "2023-05-04"

-    camp = "2024-08-04"
-    camp_end = "2024-08-10"
+    camp = "2024-08-04 17:00:00"
+    camp_end = "2024-08-10 12:00:00"
    camp_tz = "America/Halifax"

-    summer = "2025-07-09 12:00:00"
-    summer_end = "2025-07-13 20:30:00"
+    summer = "2025-07-09 06:00:00"
+    summer_end = "2025-07-11 23:30:00"
    summer_tz = "America/Los_Angeles"

+    profile.timezone_change_log = None
+
    profile.timezone_change_log = ""
    profile.timezone_change_log += f"{europe_tz} - {pendulum.parse(europe)}\n"
    profile.timezone_change_log += (
--- a/vrobbler/apps/puzzles/api/serializers.py
+++ b/vrobbler/apps/puzzles/api/serializers.py
@ -0,0 +1,12 @@
+from puzzles import models
+from rest_framework import serializers
+
+class PuzzleManufacturerSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.PuzzleManufacturer
+        fields = "__all__"
+
+class PuzzleSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = models.Puzzle
+        fields = "__all__"
--- a/vrobbler/apps/puzzles/api/views.py
+++ b/vrobbler/apps/puzzles/api/views.py
@ -0,0 +1,15 @@
+from rest_framework import permissions, viewsets
+
+from puzzles.api import serializers
+from puzzles import models
+
+class PuzzleManufacturerViewSet(viewsets.ModelViewSet):
+    queryset = models.PuzzleManufacturer.objects.all().order_by("-created")
+    serializer_class = serializers.PuzzleManufacturerSerializer
+    permission_classes = [permissions.IsAuthenticated]
+
+
+class PuzzleViewSet(viewsets.ModelViewSet):
+    queryset = models.Puzzle.objects.all().order_by("-created")
+    serializer_class = serializers.PuzzleSerializer
+    permission_classes = [permissions.IsAuthenticated]
--- a/vrobbler/apps/puzzles/migrations/0004_remove_puzzle_run_time_seconds_and_more.py
+++ b/vrobbler/apps/puzzles/migrations/0004_remove_puzzle_run_time_seconds_and_more.py
@ -0,0 +1,26 @@
+# Generated by Django 4.2.19 on 2025-10-30 01:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('puzzles', '0003_rename_igdb_id_puzzle_ipdb_id_and_more'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='puzzle',
+            name='run_time_seconds',
+        ),
+        migrations.RemoveField(
+            model_name='puzzle',
+            name='run_time_ticks',
+        ),
+        migrations.AddField(
+            model_name='puzzle',
+            name='base_run_time_seconds',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/puzzles/models.py
+++ b/vrobbler/apps/puzzles/models.py
@ -1,3 +1,5 @@
+from dataclasses import dataclass
+from typing import Optional
 from uuid import uuid4

 import requests
@ -9,12 +11,19 @@ from django_extensions.db.models import TimeStampedModel
 from imagekit.models import ImageSpecField
 from imagekit.processors import ResizeToFit
 from puzzles.sources import ipdb
-from scrobbles.dataclasses import PuzzleLogData
+from scrobbles.dataclasses import JSONDataclass
 from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin

 BNULL = {"blank": True, "null": True}


+@dataclass
+class PuzzleLogData(JSONDataclass):
+    with_people: Optional[int] = None
+    rating: Optional[str] = None
+    notes: Optional[str] = None
+
+
 class PuzzleManufacturer(TimeStampedModel):
    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
    name = models.CharField(max_length=255)
@ -58,6 +67,10 @@ class Puzzle(ScrobblableMixin):
    def __str__(self):
        return f"{self.title} ({self.pieces_count}) by {self.manufacturer}"

+    @property
+    def logdata_cls(self):
+        return PuzzleLogData
+
    @property
    def subtitle(self):
        return self.manufacturer.name
--- a/vrobbler/apps/scrobbles/admin.py
+++ b/vrobbler/apps/scrobbles/admin.py
@ -102,7 +102,7 @@ class ChartRecordAdmin(admin.ModelAdmin):

@admin.register(Scrobble)
 class ScrobbleAdmin(admin.ModelAdmin):
-    # date_hierarchy = "timestamp"
+    date_hierarchy = "timestamp"
    list_display = (
        "timestamp",
        "media_name",
@ -112,6 +112,7 @@ class ScrobbleAdmin(admin.ModelAdmin):
        "in_progress",
        "is_paused",
        "played_to_completion",
+        "user",
    )
    raw_id_fields = (
        "video",
@ -140,6 +141,7 @@ class ScrobbleAdmin(admin.ModelAdmin):
        "long_play_complete",
        "source",
        "timezone",
+        "user",
    )
    ordering = ("-timestamp",)

@ -148,3 +150,7 @@ class ScrobbleAdmin(admin.ModelAdmin):

    def playback_percent(self, obj):
        return obj.percent_played
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request).exclude(timestamp__year=None)
+        return qs
--- a/vrobbler/apps/scrobbles/constants.py
+++ b/vrobbler/apps/scrobbles/constants.py
@ -18,6 +18,9 @@ PLAY_AGAIN_MEDIA = {
    "bricksets": "BrickSet",
    "trails": "Trail",
    "beers": "Beer",
+    "foods": "Food",
+    "locations": "GeoLocation",
+    "videos": "Video",
 }

 MEDIA_END_PADDING_SECONDS = {
@ -35,6 +38,7 @@ SCROBBLE_CONTENT_URLS = {
    "-t": ["https://app.todoist.com/app/task/{id}"],
    "-p": ["https://www.ipdb.plus/IPDb/puzzle.php?id="],
    "-l": ["https://brickset.com/sets/"],
+    "-c": ["https://readcomicsonline.ru"],
 }

 EXCLUDE_FROM_NOW_PLAYING = ("GeoLocation",)
@ -50,6 +54,7 @@ MANUAL_SCROBBLE_FNS = {
    "-t": "manual_scrobble_task",
    "-p": "manual_scrobble_puzzle",
    "-l": "manual_scrobble_brickset",
+    "-c": "manual_scrobble_book",
 }


--- a/vrobbler/apps/scrobbles/dataclasses.py
+++ b/vrobbler/apps/scrobbles/dataclasses.py
@ -1,12 +1,12 @@
-from functools import cached_property
-import inspect
 import json
 from dataclasses import asdict, dataclass
 from typing import Optional

 from dataclass_wizard import JSONWizard
+from django import forms
 from django.contrib.auth import get_user_model
-from locations.models import GeoLocation
+from people.models import Person
+from scrobbles.forms import form_from_dataclass

 User = get_user_model()

@ -32,190 +32,54 @@ class JSONDataclass(JSONWizard):


@dataclass
-class ScrobbleLogData(JSONDataclass):
+class BaseLogData(JSONDataclass):
    description: Optional[str] = None
+    notes: Optional[list[str]] = None
+
+    _excluded_fields = {}
+
+    @classmethod
+    def form(cls):
+        return form_from_dataclass(cls)
+
+    @classmethod
+    def override_fields(cls) -> dict:
+        return {}


+@dataclass
 class LongPlayLogData(JSONDataclass):
-    serial_scrobble_id: Optional[int]
    long_play_complete: bool = False


-class WithOthersLogData(JSONDataclass):
-    with_user_ids: Optional[list[int]] = None
-    with_names_str: Optional[list[str]] = None
+@dataclass
+class WithPeopleLogData(JSONDataclass):
+    with_people_ids: Optional[list[int]] = None

    @property
-    def with_names(self) -> list[str]:
-        with_names = []
-        if self.with_user_ids:
-            with_names += [u.full_name for u in self.with_users if u]
-        if self.with_names_str:
-            with_names += [u for u in self.with_names_str]
-        return with_names
+    def with_people(self) -> list["Person"]:
+        from people.models import Person

-    @property
-    def with_users(self) -> list[User]:
-        with_users = []
-        if self.with_user_ids:
-            with_users = [
-                User.objects.filter(id=i).first() for i in self.with_user_ids
-            ]
-        return with_users
+        if not self.with_people_ids:
+            return []
+        return [
+            Person.objects.filter(id=pid).first()
+            for pid in self.with_people_ids
+        ]

-
-@dataclass
-class BoardGameScoreLogData(JSONDataclass):
-    user_id: Optional[int] = None
-    name_str: str = ""
-    bgg_username: str = ""
-    color: Optional[str] = None
-    character: Optional[str] = None
-    team: Optional[str] = None
-    score: Optional[int] = None
-    win: Optional[bool] = None
-    new: Optional[bool] = None
-
-    @property
-    def user(self) -> Optional[User]:
-        user = None
-        if self.user_id:
-            user = User.objects.filter(id=self.user_id).first()
-        return user
-
-    @property
-    def name(self) -> str:
-        name = self.name_str
-        if self.user_id:
-            name = self.user.first_name
-        return name
-
-    def __str__(self) -> str:
-        out = self.name
-        if self.score:
-            out += f" {self.score}"
-        if self.color:
-            out += f" ({self.color})"
-        if self.win:
-            out += f" [W]"
-        return out
-
-
-@dataclass
-class BoardGameLogData(LongPlayLogData):
-    serial_scrobble_id: Optional[int] = None
-    long_play_complete: Optional[bool] = None
-    players: Optional[list[BoardGameScoreLogData]] = None
-    location: Optional[str] = None
-    geo_location_id: Optional[int] = None
-    difficulty: Optional[int] = None
-    solo: Optional[bool] = None
-    two_handed: Optional[bool] = None
-
-    @cached_property
-    def geo_location(self) -> Optional[GeoLocation]:
-        if self.geo_location_id:
-            return GeoLocation.objects.filter(id=self.geo_location_id).first()
-
-
-@dataclass
-class BookPageLogData(JSONDataclass):
-    page_number: Optional[int] = None
-    end_ts: Optional[int] = None
-    start_ts: Optional[int] = None
-    duration: Optional[int] = None
-
-
-@dataclass
-class BookLogData(LongPlayLogData):
-    long_play_complete: Optional[bool] = None
-    koreader_hash: Optional[str] = None
-    page_data: Optional[dict[int, BookPageLogData]] = None
-    pages_read: Optional[int] = None
-    page_start: Optional[int] = None
-    page_end: Optional[int] = None
-    serial_scrobble_id: Optional[int] = None
-    details: Optional[str] = None
-
-
-@dataclass
-class LifeEventLogData(WithOthersLogData):
-    with_user_ids: Optional[list[int]] = None
-    with_names_str: Optional[list[str]] = None
-    location: Optional[str] = None
-    geo_location_id: Optional[int] = None
-    details: Optional[str] = None
-
-    def geo_location(self):
-        return GeoLocation.objects.filter(id=self.geo_location_id).first()
-
-
-@dataclass
-class MoodLogData(JSONDataclass):
-    reasons: Optional[str] = None
-
-
-@dataclass
-class VideoLogData(JSONDataclass):
-    title: str
-    video_type: str
-    run_time_seconds: int
-    kind: str
-    year: Optional[int]
-    episode_number: Optional[int] = None
-    source_url: Optional[str] = None
-    imdbID: Optional[str] = None
-    season_number: Optional[int] = None
-    cover_url: Optional[str] = None
-    next_imdb_id: Optional[int] = None
-    tv_series_id: Optional[str] = None
-
-
-@dataclass
-class VideoGameLogData(LongPlayLogData):
-    serial_scrobble_id: Optional[int] = None
-    long_play_complete: Optional[bool] = False
-    console: Optional[str] = None
-    emulated: Optional[bool] = False
-    emulator: Optional[str] = None
-
-
-@dataclass
-class BrickSetLogData(LongPlayLogData, WithOthersLogData):
-    serial_scrobble_id: Optional[int]
-    long_play_complete: bool = False
-    with_user_ids: Optional[list[int]] = None
-    with_names_str: Optional[list[str]] = None
-
-
-@dataclass
-class TrailLogData(WithOthersLogData):
-    with_user_ids: Optional[list[int]] = None
-    with_names_str: Optional[list[str]] = None
-    details: Optional[str] = None
-    effort: Optional[str] = None
-    difficulty: Optional[str] = None
-
-
-@dataclass
-class BeerLogData(WithOthersLogData):
-    with_user_ids: Optional[list[int]] = None
-    with_names_str: Optional[list[str]] = None
-    details: Optional[str] = None
-    rating: Optional[str] = None
-    notes: Optional[str] = None
-
-
-@dataclass
-class FoodLogData(JSONDataclass):
-    meal: Optional[str] = None
-    details: Optional[str] = None
-    rating: Optional[str] = None
-    notes: Optional[str] = None
-
-
-@dataclass
-class PuzzleLogData(JSONDataclass):
-    with_others: Optional[str] = None
-    rating: Optional[str] = None
-    notes: Optional[str] = None
+    @classmethod
+    def override_fields(cls) -> dict:
+        fields = {}
+        for base in cls.mro()[1:]:
+            if hasattr(base, "override_fields"):
+                base_fields = base.override_fields()
+                fields.update(base_fields)
+        custom_fields = {
+            "with_people_ids": forms.ModelMultipleChoiceField(
+                queryset=Person.objects.all(),
+                required=False,
+                widget=forms.SelectMultiple(attrs={"size": 10}),
+            )
+        }
+        fields.update(custom_fields)
+        return fields
--- a/vrobbler/apps/scrobbles/forms.py
+++ b/vrobbler/apps/scrobbles/forms.py
@ -1,3 +1,6 @@
+from dataclasses import fields
+from typing import Union, get_args, get_origin
+
 from django import forms


@ -23,3 +26,87 @@ class ScrobbleForm(forms.Form):
            }
        ),
    )
+
+
+# Mapping of types to Django form field classes
+TYPE_FIELD_MAP = {
+    int: forms.IntegerField,
+    float: forms.FloatField,
+    bool: forms.BooleanField,
+    str: forms.CharField,
+    dict: forms.JSONField,
+    list: forms.JSONField,
+}
+
+# Optional: type-to-widget mapping
+TYPE_WIDGET_MAP = {
+    str: forms.TextInput(attrs={"size": 80}),
+    dict: forms.Textarea(attrs={"rows": 10, "cols": 80}),
+    list: forms.Textarea(attrs={"rows": 6, "cols": 80}),
+    bool: forms.CheckboxInput(),
+}
+
+
+def django_form_field_from_type(field_type, required=True):
+    origin = get_origin(field_type)
+
+    # Handle Optional / Union
+    if origin is Union:
+        args = get_args(field_type)
+        if type(None) in args:
+            required = False
+            non_none_type = [arg for arg in args if arg is not type(None)][0]
+            return django_form_field_from_type(
+                non_none_type, required=required
+            )
+
+    # Determine actual type
+    base_type = origin if origin else field_type
+    field_class = TYPE_FIELD_MAP.get(base_type, forms.CharField)
+    widget = TYPE_WIDGET_MAP.get(base_type)
+
+    return (
+        field_class(required=required, widget=widget)
+        if widget
+        else field_class(required=required)
+    )
+
+
+def form_from_dataclass(dataclass):
+    form_fields = {}
+    override_fields = {}
+    for klass in dataclass.mro():
+        if hasattr(klass, "override_fields"):
+            print(klass, ": ", klass.override_fields())
+            override_fields.update(klass.override_fields())
+    print("overrides: ", override_fields)
+    for f in fields(dataclass):
+        print(f)
+        if f.name in override_fields:
+            form_fields[f.name] = override_fields[f.name]
+            continue
+
+        required = f.default is None and f.default_factory is None
+        form_fields[f.name] = django_form_field_from_type(
+            f.type, required=required
+        )
+
+        if f.name in dataclass._excluded_fields:
+            form_fields[f.name].disabled = True
+
+    form_cls = type(f"{dataclass.__name__}Form", (forms.Form,), form_fields)
+
+    if "notes" in form_cls.base_fields:
+        form_cls.base_fields["notes"] = forms.CharField(
+            required=False,
+            widget=forms.Textarea(attrs={"rows": 4}),
+        )
+
+        def clean_notes(self):
+            notes_str = self.cleaned_data.get("notes", "")
+            return [
+                line.strip() for line in notes_str.splitlines() if line.strip()
+            ]
+
+        form_cls.clean_notes = clean_notes
+    return form_cls
--- a/vrobbler/apps/scrobbles/importers/lastfm.py
+++ b/vrobbler/apps/scrobbles/importers/lastfm.py
@ -50,20 +50,23 @@ class LastFM:
                enrich=True,
            )

-            timezone = settings.TIME_ZONE
-            if self.vrobbler_user.profile:
-                timezone = self.vrobbler_user.profile.timezone
-
+            tz_timestamp = self.vrobbler_user.profile.get_timestamp_with_tz(
+                lfm_scrobble.get("timestamp")
+            )
            timestamp = lfm_scrobble.get("timestamp")
+            stop_timestamp = timestamp + timedelta(
+                seconds=track.run_time_seconds
+            )
            new_scrobble = Scrobble(
                user=self.vrobbler_user,
                timestamp=timestamp,
+                stop_timestamp=stop_timestamp,
                source=source,
                track=track,
-                timezone=timezone,
                played_to_completion=True,
                in_progress=False,
                media_type=Scrobble.MediaType.TRACK,
+                timezone=tz_timestamp.tzinfo.name,
            )
            # Vrobbler scrobbles on finish, LastFM scrobbles on start
            seconds_eariler = timestamp - timedelta(seconds=20)
@ -91,7 +94,7 @@ class LastFM:
        )
        return created

-    def get_last_scrobbles(self, time_from=None, time_to=None):
+    def get_last_scrobbles(self, time_from=None, time_to=None, check=False):
        """Given a user, Last.fm api key, and secret key, grab a list of scrobbled
        tracks"""
        lfm_params = {}
@ -107,6 +110,9 @@ class LastFM:
        found_scrobbles = self.user.get_recent_tracks(**lfm_params)
        # TOOD spin this out into a celery task over certain threshold of found scrobbles?

+        if check and found_scrobbles:
+            return True
+
        for scrobble in found_scrobbles:
            logger.info(f"Processing {scrobble}")
            run_time = None
--- a/vrobbler/apps/scrobbles/importers/tsv.py
+++ b/vrobbler/apps/scrobbles/importers/tsv.py
@ -2,6 +2,7 @@ import codecs
 import csv
 import logging
 from datetime import datetime, timedelta
+from zoneinfo import ZoneInfo

 import requests
 from django.contrib.auth import get_user_model
@ -61,10 +62,10 @@ def import_audioscrobbler_tsv_file(file_path, user_id):
                },
            )
            continue
-
-        timestamp = user.profile.get_timestamp_with_tz(
-            datetime.fromtimestamp(int(row[AsTsvColumn["TIMESTAMP"].value]))
-        )
+        timestamp = datetime.fromtimestamp(
+            int(row[AsTsvColumn["TIMESTAMP"].value])
+        ).astimezone(ZoneInfo("UTC"))
+        timestamp = user.profile.get_timestamp_with_tz(timestamp)
        stop_timestamp = timestamp + timedelta(seconds=track.run_time_seconds)

        new_scrobble = Scrobble(
--- a/vrobbler/apps/scrobbles/importers/webdav.py
+++ b/vrobbler/apps/scrobbles/importers/webdav.py
@ -1,9 +1,11 @@
+import logging
+
 from books.koreader import fetch_file_from_webdav
 from profiles.models import UserProfile
 from scrobbles.models import KoReaderImport
 from scrobbles.tasks import process_koreader_import
+from scrobbles.utils import get_file_md5_hash
 from webdav.client import get_webdav_client
-import logging

 logger = logging.getLogger(__name__)

@ -11,7 +13,7 @@ logger = logging.getLogger(__name__)
 def import_from_webdav_for_all_users(restart=False):
    """Grab a list of all users with WebDAV enabled and kickoff imports for them"""

-    # LastFmImport = apps.get_model("scrobbles", "LastFMImport")
+    # WebDavImport = apps.get_model("scrobbles", "WebDavImport")
    webdav_enabled_user_ids = UserProfile.objects.filter(
        webdav_url__isnull=False,
        webdav_user__isnull=False,
@ -42,7 +44,7 @@ def import_from_webdav_for_all_users(restart=False):
                KoReaderImport.objects.filter(
                    user_id=user_id, processed_finished__isnull=False
                )
-                .order_by("Processed_finished")
+                .order_by("processed_finished")
                .last()
            )

--- a/vrobbler/apps/scrobbles/management/commands/convert_task_log_data.py
+++ b/vrobbler/apps/scrobbles/management/commands/convert_task_log_data.py
@ -0,0 +1,27 @@
+from django.core.management.base import BaseCommand
+from vrobbler.apps.tasks.utils import (
+    convert_notes_to_dict,
+    convert_old_boardgame_log_to_new,
+    convert_old_orgmode_log_to_new,
+    convert_old_todoist_log_to_new,
+)
+
+
+class Command(BaseCommand):
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--commit",
+            action="store_true",
+            help="Commit changes",
+        )
+
+    def handle(self, *args, **options):
+        commit = False
+        if options["commit"]:
+            commit = True
+        else:
+            print("No changes will be saved, use --commit to save")
+        convert_old_orgmode_log_to_new(commit)
+        convert_old_todoist_log_to_new(commit)
+        convert_notes_to_dict(commit)
+        convert_old_boardgame_log_to_new(commit)
--- a/vrobbler/apps/scrobbles/management/commands/send_mood_checkin.py
+++ b/vrobbler/apps/scrobbles/management/commands/send_mood_checkin.py
@ -0,0 +1,10 @@
+from django.core.management.base import BaseCommand
+from vrobbler.apps.scrobbles.utils import (
+    send_mood_checkin_reminders
+)
+
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        sent_count = send_mood_checkin_reminders()
+        print(f"Sent {sent_count} mood check-in notifications")
--- a/vrobbler/apps/scrobbles/mixins.py
+++ b/vrobbler/apps/scrobbles/mixins.py
@ -57,14 +57,24 @@ class ScrobblableMixin(TimeStampedModel):

    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
    title = models.CharField(max_length=255, **BNULL)
-    run_time_seconds = models.IntegerField(default=900)
-    run_time_ticks = models.PositiveBigIntegerField(**BNULL)
+    base_run_time_seconds = models.IntegerField(**BNULL)

    genre = TaggableManager(through=ObjectWithGenres, blank=True)

    class Meta:
        abstract = True

+    @property
+    def run_time_seconds(self) -> int:
+        run_time = 900
+        if self.base_run_time_seconds:
+            run_time = self.base_run_time_seconds
+        return run_time
+
+    @classmethod
+    def is_long_play_media(cls) -> bool:
+        return False
+
    def scrobble_for_user(
        self,
        user_id,
@ -89,7 +99,7 @@ class ScrobblableMixin(TimeStampedModel):
            "[scrobble_for_user] called",
            extra={
                "id": self.id,
-                "media_type": self.__class__,
+                "media_type": self.__class__.__name__,
                "user_id": user_id,
                "scrobble_data": scrobble_data,
            },
@ -111,9 +121,9 @@ class ScrobblableMixin(TimeStampedModel):

    @property
    def logdata_cls(self) -> None:
-        from scrobbles.dataclasses import ScrobbleLogData
+        from scrobbles.dataclasses import BaseLogData

-        return ScrobbleLogData
+        return BaseLogData

    @property
    def subtitle(self) -> str:
@ -136,6 +146,15 @@ class LongPlayScrobblableMixin(ScrobblableMixin):
    class Meta:
        abstract = True

+    @classmethod
+    def is_long_play_media(cls) -> bool:
+        return True
+
+    def is_complete(self) -> bool:
+        if self.log:
+            return bool(self.log.get("long_play_complete", None))
+        return False
+
    def get_longplay_finish_url(self):
        return reverse("scrobbles:longplay-finish", kwargs={"uuid": self.uuid})

--- a/vrobbler/apps/scrobbles/models.py
+++ b/vrobbler/apps/scrobbles/models.py
@ -12,8 +12,9 @@ import pytz
 from beers.models import Beer
 from boardgames.models import BoardGame
 from books.koreader import process_koreader_sqlite_file
-from books.models import Book, Paper
+from books.models import Book, Paper, BookPageLogData, BookLogData
 from bricksets.models import BrickSet
+from dataclass_wizard.errors import ParseError
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.files import File
@ -33,6 +34,7 @@ from profiles.utils import (
    end_of_day,
    end_of_month,
    end_of_week,
+    fix_profile_historic_timezones,
    start_of_day,
    start_of_month,
    start_of_week,
@ -41,7 +43,7 @@ from puzzles.models import Puzzle
 from scrobbles import dataclasses as logdata
 from scrobbles.constants import LONG_PLAY_MEDIA, MEDIA_END_PADDING_SECONDS
 from scrobbles.importers.lastfm import LastFM
-from scrobbles.notifications import NtfyNotification
+from scrobbles.notifications import ScrobbleNtfyNotification
 from scrobbles.stats import build_charts
 from scrobbles.utils import get_file_md5_hash, media_class_to_foreign_key
 from sports.models import SportEvent
@ -205,6 +207,9 @@ class KoReaderImport(BaseFileImportMixin):

    def process(self, force=False):

+        if self.user.id == 1:
+            fix_profile_historic_timezones(self.user.profile)
+
        if self.processed_finished and not force:
            logger.info(
                f"{self} already processed on {self.processed_finished}"
@ -250,6 +255,9 @@ class AudioScrobblerTSVImport(BaseFileImportMixin):
    def process(self, force=False):
        from scrobbles.importers.tsv import import_audioscrobbler_tsv_file

+        if self.user.id == 1:
+            fix_profile_historic_timezones(self.user.profile)
+
        if self.processed_finished and not force:
            logger.info(
                f"{self} already processed on {self.processed_finished}"
@ -280,6 +288,10 @@ class LastFmImport(BaseFileImportMixin):

    def process(self, import_all=False):
        """Import scrobbles found on LastFM"""
+
+        if self.user.id == 1:
+            fix_profile_historic_timezones(self.user.profile)
+
        if self.processed_finished:
            logger.info(
                f"{self} already processed on {self.processed_finished}"
@ -327,6 +339,9 @@ class RetroarchImport(BaseFileImportMixin):

    def process(self, import_all=False, force=False):
        """Import scrobbles found on Retroarch"""
+        if self.user.id == 1:
+            fix_profile_historic_timezones(self.user.profile)
+
        if self.processed_finished and not force:
            logger.info(
                f"{self} already processed on {self.processed_finished}"
@ -640,6 +655,13 @@ class Scrobble(TimeStampedModel):
                (scrobble.elapsed_time)
            )

+        # Remove any locations without titles
+        if "GeoLocation" in scrobbles_by_type.keys():
+            for loc_scrobble in scrobbles_by_type["GeoLocation"]:
+                if not loc_scrobble.media_obj.title:
+                    scrobbles_by_type["GeoLocation"].remove(loc_scrobble)
+                    scrobbles_by_type["GeoLocation_count"] -= 1
+
        return scrobbles_by_type

    @classmethod
@ -682,6 +704,12 @@ class Scrobble(TimeStampedModel):

        return super(Scrobble, self).save(*args, **kwargs)

+    def get_absolute_url(self):
+        if not self.uuid:
+            self.uuid = uuid4()
+            self.save()
+        return reverse("scrobbles:detail", kwargs={"uuid": self.uuid})
+
    def push_to_archivebox(self):
        pushable_media = hasattr(
            self.media_obj, "push_to_archivebox"
@ -704,11 +732,11 @@ class Scrobble(TimeStampedModel):
                )

    @property
-    def logdata(self) -> Optional[logdata.JSONDataclass]:
+    def logdata(self) -> Optional[logdata.BaseLogData]:
        if self.media_obj:
            logdata_cls = self.media_obj.logdata_cls
        else:
-            logdata_cls = logdata.ScrobbleLogData
+            logdata_cls = logdata.BaseLogData

        log_dict = self.log
        if isinstance(self.log, str):
@ -722,7 +750,20 @@ class Scrobble(TimeStampedModel):
        if not log_dict:
            log_dict = {}

-        return logdata_cls.from_dict(log_dict)
+        try:
+            return logdata_cls(**log_dict)
+        except ParseError as e:
+            logger.warning(
+                "Could not parse log data",
+                extra={
+                    "log_dict": log_dict,
+                    "scrobble_id": self.id,
+                    "error": e,
+                },
+            )
+            return logdata_cls()
+        except TypeError as e:
+            return logdata_cls()

    def redirect_url(self, user_id) -> str:
        user = User.objects.filter(id=user_id).first()
@ -734,7 +775,7 @@ class Scrobble(TimeStampedModel):
            and user.profile.redirect_to_webpage
        ):
            logger.info(f"Redirecting to {self.media_obj.url}")
-            redirect_url = self.media_obj.get_read_url()
+            redirect_url = self.media_obj.url

        if (
            self.media_type == self.MediaType.VIDEO
@ -781,7 +822,7 @@ class Scrobble(TimeStampedModel):
        """
        is_stale = False
        now = timezone.now()
-        seconds_since_last_update = (now - self.modified).seconds
+        seconds_since_last_update = (now - self.modified).total_seconds()
        if seconds_since_last_update >= self.media_obj.SECONDS_TO_STALE:
            is_stale = True
        return is_stale
@ -858,8 +899,9 @@ class Scrobble(TimeStampedModel):
        if self.played_to_completion:
            if self.playback_position_seconds:
                return self.playback_position_seconds
-            if self.media_obj.run_time_seconds:
+            if self.media_obj and self.media_obj.run_time_seconds:
                return self.media_obj.run_time_seconds
+
        return (timezone.now() - self.timestamp).seconds

    @property
@ -949,7 +991,7 @@ class Scrobble(TimeStampedModel):

    @property
    def can_be_updated(self) -> bool:
-        if self.media_obj.__class__.__name__ in LONG_PLAY_MEDIA.values():
+        if self.media_obj.__class__.__name__ in LONG_PLAY_MEDIA.values() and self.source != "readcomicsonline.ru":
            logger.info(
                "[scrobbling] cannot be updated, long play media",
                extra={
@ -1036,11 +1078,12 @@ class Scrobble(TimeStampedModel):
            media_obj = self.puzzle
        if self.task:
            media_obj = self.task
+        if self.food:
+            media_obj = self.food
        return media_obj

    def __str__(self):
-        timestamp = self.timestamp.strftime("%Y-%m-%d")
-        return f"Scrobble of {self.media_obj} ({timestamp})"
+        return f"Scrobble of {self.media_obj} ({self.timestamp})"

    def calc_reading_duration(self) -> int:
        duration = 0
@ -1087,6 +1130,9 @@ class Scrobble(TimeStampedModel):
        key = media_class_to_foreign_key(media.__class__.__name__)
        media_query = models.Q(**{key: media})
        scrobble_data[key + "_id"] = media.id
+        skip_in_progress_check = kwargs.get("skip_in_progress_check", False)
+        read_log_page = kwargs.get("read_log_page", None)
+

        # Find our last scrobble of this media item (track, video, etc)
        scrobble = (
@ -1110,27 +1156,51 @@ class Scrobble(TimeStampedModel):
            )
            return scrobble

-        logger.info(
-            f"[create_or_update] check for existing scrobble to update ",
-            extra={
-                "scrobble_id": scrobble.id if scrobble else None,
-                "media_type": mtype,
-                "media_id": media.id,
-                "scrobble_data": scrobble_data,
-            },
-        )
-        scrobble_data["playback_status"] = scrobble_data.pop("status", None)
-        # If it's marked as stopped, send it through our update mechanism, which will complete it
-        if scrobble and (
-            scrobble.can_be_updated
-            or scrobble_data["playback_status"] == "stopped"
-        ):
-            if "log" in scrobble_data.keys() and scrobble.log:
-                scrobble_data["log"] = scrobble.log | scrobble_data["log"]
-            return scrobble.update(scrobble_data)
+        if not skip_in_progress_check or read_log_page:
+            logger.info(
+                f"[create_or_update] check for existing scrobble to update ",
+                extra={
+                    "scrobble_id": scrobble.id if scrobble else None,
+                    "media_type": mtype,
+                    "media_id": media.id,
+                    "scrobble_data": scrobble_data,
+                },
+            )
+            scrobble_data["playback_status"] = scrobble_data.pop(
+                "status", None
+            )
+            # If it's marked as stopped, send it through our update mechanism, which will complete it
+            if scrobble and (
+                scrobble.can_be_updated
+                or (read_log_page and scrobble.can_be_updated)
+                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:
+                            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())
+                        )
+                    )
+                    scrobble.log["page_data"] = page_list
+                    scrobble.save(update_fields=["log"])
+                elif "log" in scrobble_data.keys() and scrobble.log:
+                    scrobble_data["log"] = scrobble.log | scrobble_data["log"]
+                return scrobble.update(scrobble_data)
+
+            # Discard status before creating
+            scrobble_data.pop("playback_status")
+
+        if read_log_page:
+            scrobble_data["log"] = BookLogData(page_data=[BookPageLogData(page_number=read_log_page, start_ts=int(timezone.now().timestamp()))])

-        # Discard status before creating
-        scrobble_data.pop("playback_status")
        logger.info(
            f"[scrobbling] creating new scrobble",
            extra={
@ -1297,7 +1367,7 @@ class Scrobble(TimeStampedModel):
        scrobble_data: dict,
    ) -> "Scrobble":
        scrobble = cls.objects.create(**scrobble_data)
-        NtfyNotification(scrobble).send()
+        ScrobbleNtfyNotification(scrobble).send()
        return scrobble

    def stop(self, timestamp=None, force_finish=False) -> None:
@ -1323,6 +1393,9 @@ class Scrobble(TimeStampedModel):
        if class_name in LONG_PLAY_MEDIA.values():
            self.finish_long_play()

+        if class_name == "Book":
+            self.calculate_reading_stats()
+
        logger.info(
            f"[scrobbling] stopped",
            extra={
@ -1418,3 +1491,40 @@ class Scrobble(TimeStampedModel):
            beyond_completion = False

        return beyond_completion
+
+    def calculate_reading_stats(self, commit=True):
+        # --- 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")  # push invalid entries to the end
+
+        page_data = self.log.get("page_data")
+
+        if not page_data:
+            logger.warning("No page data found to calculate")
+            return
+
+        if isinstance(page_data, dict):
+            logger.warning("Page data is dict, migrate koreader data")
+            return
+
+        page_data.sort(key=safe_page_number)
+
+        # --- Extract valid numeric page numbers ---
+        valid_pages = []
+        for page in page_data:
+            try:
+                valid_pages.append(int(page["page_number"]))
+            except (ValueError, TypeError):
+                continue
+
+        # --- Compute stats ---
+        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 commit:
+                self.save(update_fields=["log"])
--- a/vrobbler/apps/scrobbles/notifications.py
+++ b/vrobbler/apps/scrobbles/notifications.py
@ -3,13 +3,26 @@ import requests

 from django.conf import settings
 from django.contrib.sites.models import Site
+from django.urls import reverse

-class Notification(ABC):
-    scrobble: "Scrobble"
+class BasicNtfyNotification(ABC):
    ntfy_headers: dict = {}
    ntfy_url: str = ""
    title: str = ""

+    def __init__(self, profile: "UserProfile"):
+        self.profile = profile.user
+        protocol = "http" if settings.DEBUG else "https"
+        domain = Site.objects.get_current().domain
+        self.url_tmpl = f'{protocol}://{domain}' + '{path}'
+
+    @abstractmethod
+    def send(self) -> None:
+        pass
+
+class ScrobbleNotification(BasicNtfyNotification):
+    scrobble: "Scrobble"
+
    def __init__(self, scrobble: "Scrobble"):
        self.scrobble = scrobble
        self.user = scrobble.user
@ -19,13 +32,12 @@ class Notification(ABC):
        self.url_tmpl = f'{protocol}://{domain}' + '{path}'


-
    @abstractmethod
    def send(self) -> None:
        pass


-class NtfyNotification(Notification):
+class ScrobbleNtfyNotification(ScrobbleNotification):
    def __init__(self, scrobble, **kwargs):
        super().__init__(scrobble)
        self.ntfy_str: str = f"{self.scrobble.media_obj}"
@ -35,8 +47,8 @@ class NtfyNotification(Notification):
            self.click_url = self.url_tmpl.format(path=self.scrobble.finish_url)
            self.title = "Finish " + self.media_obj.strings.verb.lower() + "?"

-        if self.scrobble.log and isinstance(self.scrobble.log, dict) and self.scrobble.log.get("description"):
-            self.ntfy_str += f" - {self.scrobble.log.get('description')}"
+        if self.scrobble.log and isinstance(self.scrobble.log, dict) and self.scrobble.log.get("title"):
+            self.ntfy_str += f" - {self.scrobble.log.get('title')}"

    def send(self):
        if (
@ -55,3 +67,27 @@ class NtfyNotification(Notification):
                    "Click": self.click_url,
                },
            )
+
+class MoodNtfyNotification(BasicNtfyNotification):
+    def __init__(self, profile, **kwargs):
+        super().__init__(profile)
+        self.ntfy_str: str = "Would you like to check in about your mood?"
+        self.click_url = self.url_tmpl.format(path=reverse("moods:mood_list"))
+        self.title = "Mood Check-in!"
+
+    def send(self):
+        if (
+            self.profile
+            and self.profile.ntfy_enabled
+            and self.profile.ntfy_url
+        ):
+            requests.post(
+                self.profile.ntfy_url,
+                data=self.ntfy_str.encode(encoding="utf-8"),
+                headers={
+                    "Title": self.title,
+                    "Priority": "high",
+                    "Tags": "smiley, check",
+                    "Click": self.click_url,
+                },
+            )
--- a/vrobbler/apps/scrobbles/scrobblers.py
+++ b/vrobbler/apps/scrobbles/scrobblers.py
@ -7,7 +7,9 @@ import pendulum
 import pytz
 from beers.models import Beer
 from boardgames.models import BoardGame, BoardGameDesigner, BoardGameLocation
-from books.models import Book
+from books.constants import READCOMICSONLINE_URL
+from books.models import Book, BookLogData, BookPageLogData
+from books.utils import parse_readcomicsonline_uri
 from bricksets.models import BrickSet
 from dateutil.parser import parse
 from django.utils import timezone
@ -18,6 +20,7 @@ from music.models import Track
 from people.models import Person
 from podcasts.models import PodcastEpisode
 from podcasts.utils import parse_mopidy_uri
+from profiles.models import UserProfile
 from puzzles.models import Puzzle
 from scrobbles.constants import (
    JELLYFIN_AUDIO_ITEM_TYPES,
@ -25,7 +28,13 @@ from scrobbles.constants import (
    SCROBBLE_CONTENT_URLS,
 )
 from scrobbles.models import Scrobble
-from scrobbles.utils import convert_to_seconds, extract_domain
+from scrobbles.notifications import ScrobbleNtfyNotification
+from scrobbles.utils import (
+    convert_to_seconds,
+    extract_domain,
+    remove_last_part,
+    next_url_if_exists,
+)
 from sports.models import SportEvent
 from sports.thesportsdb import lookup_event_from_thesportsdb
 from tasks.models import Task
@ -54,18 +63,11 @@ def mopidy_scrobble_media(post_data: dict, user_id: int) -> Scrobble:

    if media_type == Scrobble.MediaType.PODCAST_EPISODE:
        parsed_data = parse_mopidy_uri(post_data.get("mopidy_uri", ""))
-        podcast_name = post_data.get(
-            "album", parsed_data.get("podcast_name", "")
-        )
+        if not parsed_data:
+            logger.warning("Tried to scrobble podcast but no uri found", extra={"post_data": post_data})
+            return Scrobble()

-        media_obj = PodcastEpisode.find_or_create(
-            title=parsed_data.get("episode_filename", ""),
-            podcast_name=podcast_name,
-            producer_name=post_data.get("artist", ""),
-            number=parsed_data.get("episode_num", ""),
-            pub_date=parsed_data.get("pub_date", ""),
-            mopidy_uri=post_data.get("mopidy_uri", ""),
-        )
+        media_obj = PodcastEpisode.find_or_create(**parsed_data)
    else:
        media_obj = Track.find_or_create(
            title=post_data.get("name", ""),
@ -165,7 +167,7 @@ def web_scrobbler_scrobble_media(


 def manual_scrobble_video(
-    video_id: str, user_id: int, action: Optional[str] = None
+        video_id: str, user_id: int, source: str = "IMDb", action: Optional[str] = None
 ):
    if "tt" in video_id:
        video = Video.get_from_imdb_id(video_id)
@ -174,7 +176,6 @@ def manual_scrobble_video(
        video = Video.get_from_youtube_id(video_id)

    # When manually scrobbling, try finding a source from the series
-    source = "Vrobbler"
    if video.tv_series:
        source = video.tv_series.preferred_source
    scrobble_dict = {
@ -203,7 +204,7 @@ def manual_scrobble_video(


 def manual_scrobble_event(
-    thesportsdb_id: str, user_id: int, action: Optional[str] = None
+    thesportsdb_id: str, user_id: int, source: str = "TheSportsDB", action: Optional[str] = None
 ):
    data_dict = lookup_event_from_thesportsdb(thesportsdb_id)

@ -218,7 +219,7 @@ def manual_scrobble_event(


 def manual_scrobble_video_game(
-    hltb_id: str, user_id: int, action: Optional[str] = None
+    hltb_id: str, user_id: int, source: str = "HLTB", action: Optional[str] = None
 ):
    game = VideoGame.objects.filter(hltb_id=hltb_id).first()
    if not game:
@ -240,7 +241,7 @@ def manual_scrobble_video_game(
        "user_id": user_id,
        "timestamp": timezone.now(),
        "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
        "long_play_complete": False,
    }

@ -258,15 +259,44 @@ def manual_scrobble_video_game(


 def manual_scrobble_book(
-    title: str, user_id: int, action: Optional[str] = None
+    title: str, user_id: int, source: str = "Google Books", action: Optional[str] = None
 ):
-    book = Book.find_or_create(title)
+    log = {}
+    page = None
+    url = ""
+
+    if READCOMICSONLINE_URL in title:
+        url = title
+        title, volume, page = parse_readcomicsonline_uri(title)
+        if not title:
+            logger.info(
+                "[scrobblers] manual book scrobble request failed",
+                extra={
+                    "title": title,
+                    "user_id": user_id,
+                    "media_type": Scrobble.MediaType.BOOK,
+                },
+            )
+            return
+
+        title = f"{title} - Issue {volume}"
+
+        if not page:
+            page = 1
+
+        logger.info("[scrobblers] Book page included in scrobble, should update!")
+
+        source = READCOMICSONLINE_URL.replace("https://", "")
+
+    # TODO: Check for scrobble of this book already and if so, update the page count
+
+    book = Book.find_or_create(title, url=url, enrich=True)

    scrobble_dict = {
        "user_id": user_id,
        "timestamp": timezone.now(),
        "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
        "long_play_complete": False,
    }

@ -280,11 +310,23 @@ def manual_scrobble_book(
        },
    )

-    return Scrobble.create_or_update(book, user_id, scrobble_dict)
+
+    scrobble = Scrobble.create_or_update(book, user_id, scrobble_dict, read_log_page=page)
+
+    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.save(update_fields=["log"])
+        scrobble.stop(force_finish=True)
+
+    return scrobble


 def manual_scrobble_board_game(
-    bggeek_id: str, user_id: int, action: Optional[str] = None
+    bggeek_id: str, user_id: int, source: str = "BGG", action: Optional[str] = None
 ) -> Scrobble | None:
    boardgame = BoardGame.find_or_create(bggeek_id)

@ -296,7 +338,7 @@ def manual_scrobble_board_game(
        "user_id": user_id,
        "timestamp": timezone.now(),
        "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
    }
    logger.info(
        "[vrobbler-scrobble] board game scrobble request received",
@ -311,29 +353,6 @@ def manual_scrobble_board_game(
    return Scrobble.create_or_update(boardgame, user_id, scrobble_dict)


-def find_and_enrich_board_game_data(game_dict: dict) -> BoardGame | None:
-    """TODO Move this to a utility somewhere"""
-    game = BoardGame.find_or_create(game_dict.get("bggId"))
-
-    if game:
-        game.cooperative = game_dict.get("cooperative", False)
-        game.highest_wins = game_dict.get("highestWins", True)
-        game.no_points = game_dict.get("noPoints", False)
-        game.uses_teams = game_dict.get("useTeams", False)
-        game.bgstats_id = game_dict.get("uuid", None)
-        if not game.rating:
-            game.rating = game_dict.get("rating") / 10
-        game.save()
-
-        if game_dict.get("designers"):
-            for designer_name in game_dict.get("designers", "").split(", "):
-                designer, created = BoardGameDesigner.objects.get_or_create(
-                    name=designer_name
-                )
-                game.designers.add(designer.id)
-    return game
-
-
 def email_scrobble_board_game(
    bgstat_data: dict[str, Any], user_id: int
 ) -> list[Scrobble]:
@ -363,11 +382,11 @@ def email_scrobble_board_game(
    log_data = {}
    for game in game_list:
        logger.info(f"Finding and enriching {game.get('name')}")
-        enriched_game = find_and_enrich_board_game_data(game)
+        game_obj = BoardGame.find_or_create(game.get("bggId"), data=game)
        if game.get("isBaseGame"):
-            base_games[game.get("id")] = enriched_game
-        elif game.get("isExpansion"):
-            expansions[game.get("id")] = enriched_game
+            base_games[game.get("id")] = game_obj
+        if game.get("isExpansion"):
+            expansions[game.get("id")] = game_obj

    locations = {}
    for location_dict in bgstat_data.get("locations", []):
@ -390,11 +409,26 @@ def email_scrobble_board_game(
        locations[location_dict.get("id")] = location

    scrobbles_created = []
+    second = 0
    for play_dict in bgstat_data.get("plays", []):
+        hour = None
+        minute = None
+        second = None
        if "comments" in play_dict.keys():
-            if "Learning to play" in play_dict.get("comments"):
-                log_data["learning"] = True
-            log_data["details"] = play_dict.get("comments")
+            for line in play_dict.get("comments", "").split("\n"):
+                if "Learning to play" in line:
+                    log_data["learning"] = True
+                if "Start time:" in line:
+                    start_time = line.split(": ")[1]
+                    pieces = start_time.split(":")
+                    hour = int(pieces[0])
+                    minute = int(pieces[1])
+                    try:
+                        second = int(pieces[2])
+                    except IndexError:
+                        second = 0
+
+            log_data["notes"] = [play_dict.get("comments")]
        log_data["expansion_ids"] = []
        try:
            base_game = base_games[play_dict.get("gameRefId")]
@ -402,7 +436,6 @@ def email_scrobble_board_game(
            try:
                base_game = expansions[play_dict.get("gameRefId")]
            except KeyError:
-                print(play_dict)
                logger.info(
                    "Skipping scrobble of play, can't find game",
                    extra={"play_dict": play_dict},
@ -440,41 +473,62 @@ def email_scrobble_board_game(
                }
            )

-        start = parse(play_dict.get("playDate"))
+        timestamp = parse(play_dict.get("playDate"))
+        if hour and minute:
+            logger.info(f"Scrobble playDate has manual start time {timestamp}")
+            timestamp = timestamp.replace(
+                hour=hour, minute=minute, second=second or 0
+            )
+            logger.info(f"Update to {timestamp}")
+
+        profile = UserProfile.objects.filter(user_id=user_id).first()
+        timestamp = profile.get_timestamp_with_tz(timestamp)
+
        if play_dict.get("durationMin") > 0:
            duration_seconds = play_dict.get("durationMin") * 60
        else:
            duration_seconds = base_game.run_time_seconds
-        stop = start + timedelta(seconds=duration_seconds)
+        stop_timestamp = timestamp + timedelta(seconds=duration_seconds)
+
+        logger.info(f"Creating scrobble for {base_game} at {timestamp}")
        scrobble_dict = {
            "user_id": user_id,
-            "timestamp": start,
+            "timestamp": timestamp,
            "playback_position_seconds": duration_seconds,
            "source": "BG Stats",
            "log": log_data,
        }

-        scrobble = Scrobble.objects.filter(
-            board_game=base_game, user_id=user_id, timestamp=start
-        ).first()
+        scrobble = None
+        if timestamp.year > 2023:
+            logger.info(
+                "Scrobbles older than 2024 likely have no time associated just create it"
+            )
+            scrobble = Scrobble.objects.filter(
+                board_game=base_game, user_id=user_id, timestamp=timestamp
+            ).first()
        if scrobble:
            logger.info(
                "Scrobble already exists, skipping",
                extra={"scrobble_dict": scrobble_dict, "user_id": user_id},
            )
            continue
-        scrobble = Scrobble.create_or_update(base_game, user_id, scrobble_dict)
-        scrobble.stop_timestamp = stop
+        scrobble = Scrobble.create_or_update(
+            base_game, user_id, scrobble_dict, skip_in_progress_check=True
+        )
+        scrobble.timezone = timestamp.tzinfo.name
+        scrobble.stop_timestamp = stop_timestamp
        scrobble.in_progress = False
        scrobble.played_to_completion = True
        scrobble.save()
        scrobbles_created.append(scrobble)
+        ScrobbleNtfyNotification(scrobble).send()

    return scrobbles_created


 def manual_scrobble_from_url(
-    url: str, user_id: int, action: Optional[str] = None
+        url: str, user_id: int, source: str = "Vrobbler", action: Optional[str] = None
 ) -> Scrobble:
    """We have scrobblable media URLs, and then any other webpages that
    we want to scrobble as a media type in and of itself. This checks whether
@ -502,11 +556,13 @@ def manual_scrobble_from_url(

    if content_key == "-i" and "v=" in url:
        item_id = url.split("v=")[1].split("&")[0]
+    elif content_key == "-c" and "comics" in url:
+        item_id = url
    elif content_key == "-i" and "title/tt" in url:
        item_id = "tt" + str(item_id)

    scrobble_fn = MANUAL_SCROBBLE_FNS[content_key]
-    return eval(scrobble_fn)(item_id, user_id, action=action)
+    return eval(scrobble_fn)(item_id, user_id, source=source, action=action)


 def todoist_scrobble_task_finish(
@ -550,9 +606,9 @@ def todoist_scrobble_update_task(
        )
        return

-    existing_notes = scrobble.log.get("notes", {})
-    existing_notes[todoist_note.get("todoist_id")] = todoist_note.get("notes")
-    scrobble.log["notes"] = existing_notes
+    if not scrobble.log.get("notes"):
+        scrobble.log["notes"] = []
+    scrobble.log["notes"].append(todoist_note.get("notes"))
    scrobble.save(update_fields=["log"])
    logger.info(
        "[todoist_scrobble_update_task] todoist note added",
@ -578,7 +634,7 @@ def todoist_scrobble_task(
    )
    task = Task.find_or_create(title)

-    timestamp = pendulum.parse(todoist_task.get("updated_at", timezone.now()))
+    timestamp = pendulum.parse(todoist_task.pop("updated_at", timezone.now()))
    in_progress_scrobble = Scrobble.objects.filter(
        user_id=user_id,
        in_progress=True,
@ -620,8 +676,12 @@ def todoist_scrobble_task(
        )
        return todoist_scrobble_task_finish(todoist_task, user_id, timestamp)

-    # Default to create new scrobble "if not in_progress_scrobble and in_progress_in_todoist"
-    # TODO Should use updated_at from TOdoist, but parsing isn't working
+    todoist_task["title"] = todoist_task.pop("description")
+    todoist_task["description"] = todoist_task.pop("details")
+    todoist_task["labels"] = todoist_task.pop("todoist_label_list", [])
+    todoist_task.pop("todoist_type")
+    todoist_task.pop("todoist_event")
+
    scrobble_dict = {
        "user_id": user_id,
        "timestamp": timestamp,
@ -649,8 +709,8 @@ def emacs_scrobble_update_task(
    scrobble = Scrobble.objects.filter(
        in_progress=True,
        user_id=user_id,
-        log__source_id=emacs_id,
-        log__source="orgmode",
+        log__orgmode_id=emacs_id,
+        source="Org-mode",
    ).first()

    if not scrobble:
@ -699,19 +759,18 @@ def emacs_scrobble_task(
    stopped: bool = False,
    user_context_list: list[str] = [],
 ) -> Scrobble | None:
-    source_id = task_data.get("source_id")
+    orgmode_id = task_data.get("source_id")
    title = get_title_from_labels(
        task_data.get("labels", []), user_context_list
    )

    task = Task.find_or_create(title)

-    timestamp = pendulum.parse(task_data.get("updated_at", timezone.now()))
+    timestamp = pendulum.parse(task_data.pop("updated_at", timezone.now()))
    in_progress_scrobble = Scrobble.objects.filter(
        user_id=user_id,
        in_progress=True,
-        log__source_id=source_id,
-        log__source="orgmode",
+        log__orgmode_id=orgmode_id,
        task=task,
    ).last()

@ -719,7 +778,7 @@ def emacs_scrobble_task(
        logger.info(
            "[emacs_scrobble_task] cannot stop already stopped task",
            extra={
-                "emacs_id": source_id,
+                "orgmode_id": orgmode_id,
            },
        )
        return
@ -728,7 +787,7 @@ def emacs_scrobble_task(
        logger.info(
            "[emacs_scrobble_task] cannot start already started task",
            extra={
-                "emacs_id": source_id,
+                "ormode_id": orgmode_id,
            },
        )
        return in_progress_scrobble
@ -738,7 +797,7 @@ def emacs_scrobble_task(
        logger.info(
            "[emacs_scrobble_task] finishing",
            extra={
-                "emacs_id": source_id,
+                "orgmode_id": orgmode_id,
            },
        )
        in_progress_scrobble.stop(timestamp=timestamp, force_finish=True)
@ -749,11 +808,17 @@ def emacs_scrobble_task(

    notes = task_data.pop("notes")
    if notes:
-        task_data["notes"] = []
-        for note in notes:
-            task_data["notes"].append(
-                {note.get("timestamp"): note.get("content")}
-            )
+        task_data["notes"] = [note.get("content") for note in notes]
+    task_data["title"] = task_data.pop("description")
+    task_data["description"] = task_data.pop("body")
+    task_data["labels"] = task_data.pop("labels")
+
+    task_data["orgmode_id"] = task_data.pop("source_id")
+    task_data["orgmode_state"] = task_data.pop("state")
+    task_data["orgmode_properties"] = task_data.pop("properties")
+    task_data["orgmode_drawers"] = task_data.pop("drawers")
+    task_data["orgmode_timestamps"] = task_data.pop("timestamps")
+    task_data.pop("source")

    scrobble_dict = {
        "user_id": user_id,
@ -776,9 +841,10 @@ def emacs_scrobble_task(
    return scrobble


-def manual_scrobble_task(url: str, user_id: int, action: Optional[str] = None):
+def manual_scrobble_task(url: str, user_id: int, source: str = "Vrobbler", action: Optional[str] = None):
    source_id = re.findall(r"\d+", url)[0]

+    description = ""
    if "todoist" in url:
        source = "Todoist"
        title = "Generic Todoist task"
@ -807,7 +873,7 @@ def manual_scrobble_task(url: str, user_id: int, action: Optional[str] = None):


 def manual_scrobble_webpage(
-    url: str, user_id: int, action: Optional[str] = None
+        url: str, user_id: int, source: str = "Bookmarklet", action: Optional[str] = None
 ):
    webpage = WebPage.find_or_create({"url": url})

@ -815,7 +881,7 @@ def manual_scrobble_webpage(
        "user_id": user_id,
        "timestamp": timezone.now(),
        "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
    }
    logger.info(
        "[vrobbler-scrobble] webpage scrobble request received",
@ -828,8 +894,13 @@ def manual_scrobble_webpage(
    )

    scrobble = Scrobble.create_or_update(webpage, user_id, scrobble_dict)
-    # possibly async this?
-    scrobble.push_to_archivebox()
+
+    if action == "stop":
+        scrobble.stop(force_finish=True)
+    else:
+        # possibly async this?
+        scrobble.push_to_archivebox()
+
    return scrobble


@ -929,7 +1000,7 @@ def web_scrobbler_scrobble_video_or_song(


 def manual_scrobble_beer(
-    untappd_id: str, user_id: int, action: Optional[str] = None
+        untappd_id: str, user_id: int, source: str = "Untappd", action: Optional[str] = None
 ):
    beer = Beer.find_or_create(untappd_id)

@ -941,7 +1012,7 @@ def manual_scrobble_beer(
        "user_id": user_id,
        "timestamp": timezone.now(),
        "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
    }
    logger.info(
        "[vrobbler-scrobble] beer scrobble request received",
@ -958,7 +1029,7 @@ def manual_scrobble_beer(


 def manual_scrobble_puzzle(
-    ipdb_id: str, user_id: int, action: Optional[str] = None
+        ipdb_id: str, user_id: int, source: str = "IPDb", action: Optional[str] = None
 ):
    puzzle = Puzzle.find_or_create(ipdb_id)

@ -970,7 +1041,7 @@ def manual_scrobble_puzzle(
        "user_id": user_id,
        "timestamp": timezone.now(),
        "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
    }
    logger.info(
        "[vrobbler-scrobble] puzzle scrobble request received",
@ -987,7 +1058,7 @@ def manual_scrobble_puzzle(


 def manual_scrobble_brickset(
-    brickset_id: str, user_id: int, action: Optional[str] = None
+        brickset_id: str, user_id: int, source: str = "BrickSet", action: Optional[str] = None
 ):
    brickset = BrickSet.find_or_create(brickset_id)

@ -999,7 +1070,7 @@ def manual_scrobble_brickset(
        "user_id": user_id,
        "timestamp": timezone.now(),
        "playback_position_seconds": 0,
-        "source": "Vrobbler",
+        "source": source,
        "log": {"serial_scrobble_id": ""},
    }
    logger.info(
--- a/vrobbler/apps/scrobbles/static/images/youtube_logo.png
+++ b/vrobbler/apps/scrobbles/static/images/youtube_logo.png
--- a/vrobbler/apps/scrobbles/templatetags/form_tags.py
+++ b/vrobbler/apps/scrobbles/templatetags/form_tags.py
@ -0,0 +1,11 @@
+from django import template
+
+register = template.Library()
+
+
+@register.filter(name="add_class")
+def add_class(field, css_class):
+    # If the widget is CheckboxInput, skip adding 'form-control'
+    if field.field.widget.__class__.__name__ == "CheckboxInput":
+        return field.as_widget()
+    return field.as_widget(attrs={"class": css_class})
--- a/vrobbler/apps/scrobbles/urls.py
+++ b/vrobbler/apps/scrobbles/urls.py
@ -95,6 +95,11 @@ urlpatterns = [
        views.ScrobbleLongPlaysView.as_view(),
        name="long-plays",
    ),
+    path(
+        "scrobble/<slug:uuid>/",
+        views.ScrobbleDetailView.as_view(),
+        name="detail",
+    ),
    path("scrobble/<slug:uuid>/start/", views.scrobble_start, name="start"),
    path("scrobble/<slug:uuid>/finish/", views.scrobble_finish, name="finish"),
    path("scrobble/<slug:uuid>/cancel/", views.scrobble_cancel, name="cancel"),
--- a/vrobbler/apps/scrobbles/utils.py
+++ b/vrobbler/apps/scrobbles/utils.py
@ -1,19 +1,27 @@
 import hashlib
 import logging
+import requests
 import re
-from datetime import datetime, timedelta
+from datetime import date, datetime, timedelta
+from typing import TYPE_CHECKING, Optional
 from urllib.parse import urlparse
 from zoneinfo import ZoneInfo

+import pendulum
 import pytz
 from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.db import models
+from django.db.models.fields.json import KeyTextTransform
+from django.db.models.functions import Cast, TruncDate
 from django.utils import timezone
 from profiles.models import UserProfile
 from profiles.utils import now_user_timezone
 from scrobbles.constants import LONG_PLAY_MEDIA
-from scrobbles.notifications import NtfyNotification
+from scrobbles.notifications import (
+    MoodNtfyNotification,
+    ScrobbleNtfyNotification,
+)
 from scrobbles.tasks import (
    process_koreader_import,
    process_lastfm_import,
@ -21,6 +29,9 @@ from scrobbles.tasks import (
 )
 from webdav.client import get_webdav_client

+if TYPE_CHECKING:
+    from scrobbles.models import Scrobble
+
 logger = logging.getLogger(__name__)
 User = get_user_model()

@ -114,6 +125,8 @@ def get_long_plays_completed(user: User) -> list:

 def import_lastfm_for_all_users(restart=False):
    """Grab a list of all users with LastFM enabled and kickoff imports for them"""
+    from scrobbles.importers.lastfm import LastFM
+
    LastFmImport = apps.get_model("scrobbles", "LastFMImport")
    lastfm_enabled_user_ids = UserProfile.objects.filter(
        lastfm_username__isnull=False,
@ -124,6 +137,31 @@ def import_lastfm_for_all_users(restart=False):
    lastfm_import_count = 0

    for user_id in lastfm_enabled_user_ids:
+
+        lfm_import = LastFmImport.objects.filter(
+            user_id=user_id, processed_finished__isnull=False
+        ).last()
+        if lfm_import:
+            last_processed = lfm_import.processed_finished
+        else:
+            logger.info(
+                f"Not resuming failed LastFM import {lfm_import.id} for user {user_id}, use restart=True to restart"
+                "No existing LastFM import, we should start a monthly parsing of lastFm for this user going back to 2002"
+            )
+            continue
+
+        lfm_client = LastFM(
+            user=get_user_model().objects.filter(id=user_id).first()
+        )
+
+        has_scrobbles = lfm_client.get_last_scrobbles(
+            time_from=last_processed, check=True
+        )
+
+        if not has_scrobbles:
+            logger.info("No new scrobbles to import from LastFM")
+            continue
+
        lfm_import, created = LastFmImport.objects.get_or_create(
            user_id=user_id, processed_finished__isnull=True
        )
@ -291,7 +329,20 @@ def send_stop_notifications_for_in_progress_scrobbles() -> int:
        ).seconds

        if elapsed_scrobble_seconds > scrobble.media_obj.run_time_seconds:
-            NtfyNotification(scrobble, end=True).send()
+            ScrobbleNtfyNotification(scrobble, end=True).send()
+            notifications_sent += 1
+
+    return notifications_sent
+
+def send_mood_checkin_reminders() -> int:
+    """Get all profiles with mood check-ins enabled and checkin!"""
+    from profiles.models import UserProfile
+
+    now = timezone.now()
+    notifications_sent = 0
+    for profile in UserProfile.objects.filter(mood_checkin_enabled=True):
+        if profile.mood_checkin_frequency == "hourly" and now.minute == 0:
+            MoodNtfyNotification(profile).send()
            notifications_sent += 1

    return notifications_sent
@ -305,3 +356,98 @@ def extract_domain(url):
        + parsed_url.netloc.split(".")[-1]
    )
    return domain
+
+def fix_playback_position_seconds(*scrobbles: "Scrobble", commit=True) -> list["Scrobble"]:
+    updated_scrobbles = list()
+    for scrobble in scrobbles:
+        if not scrobble.media_obj:
+            logger.info(f"No media object found for scrobble {scrobble.id}, cannot update elapsed time")
+            continue
+
+        if scrobble.media_type == "Track" and scrobble.media_obj.run_time_seconds:
+            too_long = scrobble.playback_position_seconds > scrobble.media_obj.run_time_seconds
+            zero = scrobble.playback_position_seconds == 0
+            null = not scrobble.playback_position_seconds
+            if too_long or zero or null:
+                scrobble.playback_position_seconds = scrobble.media_obj.run_time_seconds
+                updated_scrobbles.append(scrobble)
+                if commit:
+                    scrobble.save(update_fields=["playback_position_seconds"])
+
+    return updated_scrobbles
+
+
+def base_scrobble_qs(user_id: int) -> models.QuerySet:
+    """Base queryset with calories extracted as integer and day annotated."""
+    from scrobbles.models import Scrobble
+
+    return (
+        Scrobble.objects
+        .annotate(day=TruncDate("timestamp"))
+        .annotate(calories_int=Cast(KeyTextTransform("calories", "log"), models.IntegerField()))
+        .filter(calories_int__isnull=False, user_id=user_id)
+    )
+
+def get_daily_calories_for_user_by_day(user_id: int, date: date| str) -> int:
+    """Return total calories for a user on a specific day."""
+
+    if isinstance(date, str):
+        date = pendulum.parse(date)
+
+    try:
+        qs = base_scrobble_qs(user_id).filter(day=date)
+        agg = qs.aggregate(total_calories=models.Sum("calories_int"))
+    except AttributeError as e:
+        logger.warning(f"Can't generate calorie total: {e}")
+        agg = {}
+
+    return agg.get("total_calories") or 0
+
+def get_daily_calorie_dict_for_user(user_id: int) -> dict[date, int]:
+    """Return {day: total_calories} for all days with scrobbles, in one query."""
+    qs = (
+        base_scrobble_qs(user_id)
+        .values("day")
+        .annotate(total_calories=models.Sum("calories_int"))
+        .order_by("day")
+    )
+
+    return {entry["day"]: entry["total_calories"] for entry in qs}
+
+def remove_last_part(url: str) -> str:
+    url = url.rstrip('/')
+    if '/' not in url:
+        return url
+    return url.rsplit('/', 1)[0]
+
+def next_url_if_exists(url: str) -> str:
+    # Normalize (remove trailing slash)
+    url = url.rstrip('/')
+
+    # Find last number in the URL path
+    match = re.search(r'(\d+)(?:/?$)', url)
+    if not match:
+        logger.info("No numeric segment found in the URL", extra={"url": url})
+        return ""
+
+    number = int(match.group(1))
+    new_number = number + 1
+
+    # Replace only the last occurrence of that number
+    new_url = re.sub(rf'{number}(?:/?$)', f'{new_number}/', url + '/', 1)
+
+    # Check if the new URL exists
+    try:
+        resp = requests.head(new_url, allow_redirects=True, timeout=5)
+        if resp.status_code == 200:
+            return new_url
+        else:
+            # Fallback: some sites may not support HEAD well — try GET
+            resp = requests.get(new_url, timeout=5)
+            if resp.status_code == 200:
+                return new_url
+    except requests.RequestException:
+        pass
+
+    # If it doesn’t exist
+    return ""
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Colin Powell	cd5dc25642	[release] Update project file for release 35	2025-11-17 16:35:09 -05:00
Colin Powell	9c2355978e	[videos] Fix lookup for ids for videos	2025-11-17 16:34:38 -05:00
Colin Powell	4b9b785e50	[videos] Add youtube link to detail page	2025-11-17 16:30:40 -05:00
Colin Powell	050b2b9d77	[videos] Fix imdb lookups with new library	2025-11-17 16:25:46 -05:00
Colin Powell	d12cca304f	[api] Missed a few api endpoints	2025-11-17 16:11:31 -05:00
Colin Powell	8603bbd5cb	[api] Add many missing API endpoints	2025-11-17 16:00:10 -05:00
Colin Powell	749e74a54c	[scrobbles] Fix missed run_time_seconds cleanup	2025-11-05 09:58:48 -05:00
Colin Powell	7b3692ef7b	[books] Think I had DST logic messed up	2025-11-05 09:58:48 -05:00
Colin Powell	c49f6a1740	[scrobbles] Clean up various sources	2025-11-03 08:49:53 -05:00
Colin Powell	1d813e4643	[food] Fix error in calorie aggregation	2025-11-03 00:15:09 -05:00
Colin Powell	5e0a429d81	[project] Cut version 34	2025-11-02 23:52:48 -05:00
Colin Powell	d928d266b9	[videos] Add video to play again media	2025-11-02 23:52:26 -05:00
Colin Powell	b4dbbb4211	[boardgames] Deprecate failing tests	2025-11-02 23:45:34 -05:00
Colin Powell	dcb5260cfc	[boardgames] Tighten up boardgame lookups	2025-11-02 23:43:19 -05:00
Colin Powell	a8747dfe77	Update all the places we need base_run_time_seconds now	2025-11-02 21:18:52 -05:00
Colin Powell	a474b5df48	[scrobbles] Refactor run time sec to be blank by default	2025-10-29 21:54:18 -04:00
Colin Powell	082979bea6	[logs] Fix class name for scrobble_for_user	2025-10-29 19:56:55 -04:00
Colin Powell	1275186d86	[videos] Fix next episode error	2025-10-29 19:45:50 -04:00
Colin Powell	cd60ac6387	[tasks] Fix emacs not updating or completing	2025-10-29 17:12:48 -04:00
Colin Powell	bdfbd3e5c0	[project] Update task list with version 33	2025-10-28 14:57:07 -04:00
Colin Powell	dff63f325f	[scrobbles] Fix calorie aggregation bug	2025-10-28 14:56:30 -04:00
Colin Powell	2b634e3b7e	[scrobbles] Fix look up of old scrobbles by total seconds	2025-10-28 14:41:52 -04:00
Colin Powell	723d739405	[books] Clean up resume URLs	2025-10-28 14:41:16 -04:00
Colin Powell	e62a07af37	[boardgames] Add auth to BGG API call	2025-10-28 14:38:36 -04:00
Colin Powell	f86c3b2935	[project] Bump version to 32	2025-10-22 14:20:03 -04:00
Colin Powell	050add8543	[books] Add utility urls to model and scrobbles	2025-10-22 14:18:01 -04:00
Colin Powell	8faf0296a6	[project] Finish book resume link task	2025-10-22 12:18:40 -04:00
Colin Powell	f209f3b107	[books] Set restart and resume urls on comic book scrobbles	2025-10-22 12:18:08 -04:00
Colin Powell	b233b60ae0	[books] Add bookmark_url to logdata	2025-10-22 01:00:25 -04:00
Colin Powell	e1d4a7c5a4	[books] Fix looking up comic by original title	2025-10-20 22:47:32 -04:00
Colin Powell	59e8339e94	[releases] Fix comic books scrobbling, mostly	2025-10-20 17:17:18 -04:00
Colin Powell	9277db97e5	[books] Fix comic scrobbles overrwriting one another	2025-10-20 17:15:54 -04:00
Colin Powell	e755dc6641	Fix bug where title not found	2025-10-20 17:02:52 -04:00
Colin Powell	782f5c15d6	[books] Calc stats and dont die when title not found	2025-10-20 17:02:34 -04:00
Colin Powell	2f4fae7d02	[books] Short circut google lookup if it fails	2025-10-20 16:12:01 -04:00
Colin Powell	4b7c5aa58d	[books] Fix bad lookups for creating books	2025-10-20 16:11:20 -04:00
Colin Powell	d4f82f2d6f	[releases] Adding comic reading	2025-10-20 15:51:07 -04:00
Colin Powell	106d25c20f	[webpages] Redirect back to the page	2025-10-20 15:46:28 -04:00
Colin Powell	d77caa2783	[scrobblers] Allow stopping reading comics	2025-10-20 15:46:10 -04:00
Colin Powell	b5bfad73ef	[books] Allow comic scrobbling to update per page	2025-10-20 15:41:02 -04:00
Colin Powell	274b2704ed	[scrobbles] Clean up type in logs	2025-10-20 14:55:27 -04:00
Colin Powell	80fcb6c002	[books] Clean up google searches	2025-10-20 14:54:53 -04:00
Colin Powell	c6f3c90006	[releases] Catching up project with actual releases	2025-10-14 12:29:45 -04:00
Colin Powell	387dee7d37	[podcasts] Hotfix looking up podcast data from feed URLS	2025-10-14 12:28:17 -04:00
Colin Powell	188e899357	[podcasts] Fix podcast data	2025-10-14 11:55:22 -04:00
Colin Powell	30b005fa46	[scrobbles] Stop any scrobble when stop is called	2025-10-14 11:51:33 -04:00
Colin Powell	72f739ee5a	[podcasts] Try to clean up lookups	2025-10-14 11:45:47 -04:00
Colin Powell	56ee14512d	[podcasts] Actually test new lookup method	2025-10-14 11:30:57 -04:00
Colin Powell	8c947d35dd	[release] Bump version to 27.0	2025-10-14 11:18:05 -04:00
Colin Powell	61bab1f734	[podcasts] Clean up lookup and creation	2025-10-14 11:17:20 -04:00
Colin Powell	42ce6df9bd	[templates] Small fix to obj title missing	2025-10-14 10:58:54 -04:00
Colin Powell	cbd46df4bc	[scrobbles] Add Food and Geolocation to long play & manual comics	2025-10-14 10:58:31 -04:00
Colin Powell	e7203cdb9b	[podcasts] Add parsing of RSS feed urls	2025-10-14 10:55:09 -04:00
Colin Powell	7246adfeb6	[project] Update and reorganize todos	2025-09-30 09:36:03 -04:00
Colin Powell	a5606951c5	[templates] Fix missing Beer placeholder	2025-09-23 00:43:49 -04:00
Colin Powell	0b4537b7ed	[food] Add calories per day	2025-09-16 15:28:28 -04:00
Colin Powell	6306390f82	[release] 26	2025-09-11 18:58:48 -04:00
Colin Powell	350d3ceb14	[templates] Move moods around	2025-09-11 18:56:34 -04:00
Colin Powell	a1ff82bfec	[templates] Cleaning up templates and datalog forms	2025-09-11 18:55:45 -04:00
Colin Powell	92c0c668b3	[locations] Add locations to dashboard	2025-09-11 18:29:28 -04:00
Colin Powell	3b77feda45	[templates] Add links to scrobbles Ultimately these should probably be templated	2025-09-11 18:03:35 -04:00
Colin Powell	45c402f8c1	[music] Fix bug in generating log data form	2025-09-11 17:57:17 -04:00
Colin Powell	90a1398438	[foods] Adjust fields on food data log	2025-09-11 10:44:48 -04:00
Colin Powell	c7a81802ac	[release] 25.0	2025-09-11 09:45:02 -04:00
Colin Powell	a9a8678ac0	[project] Update toods	2025-09-11 09:43:23 -04:00
Colin Powell	cbf0583871	[foods] Add calories to food model	2025-09-11 09:41:22 -04:00
Colin Powell	5cac1fe109	[templates] Fix food templates and such	2025-09-11 09:41:12 -04:00
Colin Powell	6782ed312d	[templates] Add food to homepage	2025-09-11 09:33:34 -04:00
Colin Powell	fda505ea4e	[scrobbles] Fix calc of elapsed time	2025-09-11 09:33:29 -04:00
Colin Powell	8db111f66f	[food] Fix lookup for food object	2025-09-11 09:27:32 -04:00
Colin Powell	ee1cae496a	[music] Back and forth ... let us not use album name	2025-09-11 09:08:14 -04:00
Colin Powell	9403c68184	[videos] Fix small bug in views	2025-09-11 09:06:07 -04:00
Colin Powell	96030f4a99	[boardgames] Fix expansion checking	2025-09-11 09:05:50 -04:00
Colin Powell	a8c3925af4	[project] Check off another task	2025-08-20 11:40:18 -04:00
Colin Powell	a2f507a976	[videos] Wire up generic video list view	2025-08-20 11:39:27 -04:00
Colin Powell	7a7edc6e47	[templates] Fix some bugs and clean up list views	2025-08-20 11:27:10 -04:00
Colin Powell	af6c39fb85	[templates] Clean up task titles	2025-08-19 12:37:26 -04:00
Colin Powell	36cfdd6f6c	[release] 24.0	2025-08-19 00:57:52 -04:00
Colin Powell	b11d87af75	[logdata] Janky fix to people and platform ids	2025-08-19 00:46:08 -04:00
Colin Powell	1cf50209a4	[bricksets] Add templates	2025-08-18 20:41:16 -04:00
Colin Powell	8a5486fb2c	[templates] Remove sidebar, add dashboard links	2025-08-18 20:28:43 -04:00
Colin Powell	135d6e65fa	[templates] Make vrobbler to go home page	2025-08-17 20:23:02 -04:00
Colin Powell	965f2dd41b	[tasks] Use title, not description	2025-08-17 20:21:08 -04:00
Colin Powell	1a1de02843	[release] 23	2025-08-17 12:41:10 -04:00
Colin Powell	a1868e7b2c	[project] Updating TODOs	2025-08-17 12:38:27 -04:00
Colin Powell	52494651bf	[scrobbles] Add dynamic forms for LogData classes	2025-08-17 12:38:11 -04:00
Colin Powell	1093aa2376	[music] Fix getting album when duplicated name	2025-08-06 12:40:10 -04:00
Colin Powell	d1f04c15a9	[music] Fix breaking on w.	2025-08-06 11:03:40 -04:00
Colin Powell	fd3487c225	[tasks] A few little clean ups	2025-08-06 10:59:32 -04:00
Colin Powell	df91526b0c	[videogames] Fix showing platform in logdata	2025-08-05 10:18:10 -04:00
Colin Powell	70f103db6f	[boardgames] Remove print statements	2025-08-05 02:04:17 -04:00
Colin Powell	b0b32821e3	[scrobbles] Clean up todoist logs too	2025-08-05 02:04:07 -04:00
Colin Powell	278cab32ea	[scrobbles] Start cleaning up logdata	2025-08-05 02:01:31 -04:00
Colin Powell	06e075553a	[scrobbles] CLean up some dataclasses	2025-08-05 01:56:20 -04:00
Colin Powell	833368c8d7	[profiles] Clean up default task lookup	2025-08-05 01:56:03 -04:00
Colin Powell	f70bab30d0	[scrobbles] Log errors when parsing fails	2025-08-05 00:13:44 -04:00
Colin Powell	f230af89eb	[videogames] Add scrobbles to views	2025-08-05 00:13:08 -04:00
Colin Powell	bbc27209ab	[templates] Clean up long play nonsense for video games	2025-08-05 00:12:47 -04:00
Colin Powell	b7638c648a	[templates] Fix video game detail page	2025-08-04 19:57:06 -04:00
Colin Powell	c8926cf887	[scrobbles] Fix bug in mixin import	2025-08-03 11:33:44 -04:00
Colin Powell	b8dd3ee258	[tests] Shim to fix broken import	2025-08-03 11:13:23 -04:00
Colin Powell	dc965687c2	[puzzles] Add puzzles to homepage	2025-08-03 02:01:29 -04:00
Colin Powell	ebc66bbf64	[puzzles] Add templates	2025-08-03 02:00:26 -04:00
Colin Powell	d04db0ecb5	[scrobbles] Fix dataclass parsing and add puzzles to urls	2025-08-03 01:59:56 -04:00
Colin Powell	fc72b23b11	[music] Fix timezones for TSV imports	2025-08-02 23:35:22 -04:00
Colin Powell	a681b4d63b	[notifications] Fix a few typos	2025-07-30 18:34:22 -04:00
Colin Powell	c452ac24e0	[notifications] Send mood check-in	2025-07-30 18:30:18 -04:00
Colin Powell	ae889bff7d	[tasks] Fix bug in note str method	2025-07-30 17:50:59 -04:00
Colin Powell	99dc86dc27	[moods] Fix mood list view	2025-07-30 16:05:48 -04:00
Colin Powell	8eefcb8290	[tasks] Fix emacs metadata	2025-07-30 16:05:34 -04:00
Colin Powell	ad0f9a54d0	[tasks] Fix dataclass models	2025-07-30 15:46:18 -04:00
Colin Powell	1531b77b5c	[tests] Fix metadata test	2025-07-30 13:59:11 -04:00
Colin Powell	9437fdba60	[scrobbles] Fix log data parsing for tasks and boardgames Add pagination to task and board game detail pages	2025-07-30 11:37:57 -04:00
Colin Powell	a7551ef162	[music] Weird hack to get timezone for LFM scrobbles Last.fm seems to send timestamps for scrobbles with a timezone of UTC but the actual timezone is already localized. But that means we can't extract the timezone we want, even though the timestamp is already in the right timezone for storage.	2025-07-28 10:52:02 -04:00
Colin Powell	c20204a6ea	[music] Turns out lastfm already has our timeszone	2025-07-28 09:14:25 -04:00
Colin Powell	685de842ea	[views] Fix showing only a users scrobbles	2025-07-26 21:31:44 -04:00
Colin Powell	7d13967708	[scrobbles] Fix admin filtering	2025-07-26 20:57:23 -04:00
Colin Powell	109697a746	[project] Bump version	2025-07-26 10:19:34 -04:00
Colin Powell	dde28f4aff	[importers] Fix setting timezones before all imports	2025-07-26 10:18:43 -04:00
Colin Powell	2f6ed3770f	[books] Fix bad import after moving webdav to importers	2025-07-26 01:49:37 -04:00
Colin Powell	e3d1cfb838	[books] Fix webdav importer	2025-07-25 23:40:39 -04:00
Colin Powell	1821ac0d7b	[project] Update tasks	2025-07-25 22:55:33 -04:00
Colin Powell	4eb8289e55	[scrobbles] LastFM only creates import if there are imports	2025-07-25 22:53:31 -04:00
Colin Powell	66e805542c	[scrobbles] Add notification to board game imports	2025-07-25 21:28:08 -04:00
Colin Powell	f91b127a2c	[scrobbles] Allow skipping checks for existing scrobbles	2025-07-25 17:36:19 -04:00
Colin Powell	b2077678e2	[music] Fix timezones on lastfm imports	2025-07-25 17:35:56 -04:00
Colin Powell	5427198185	[profiles] Just black	2025-07-25 17:35:10 -04:00
Colin Powell	2bdba14cd6	[boardgames] Fix import from imap for timezones	2025-07-25 17:34:57 -04:00
Colin Powell	95d8c4e4d6	[profiles] Clean up timezone stuff	2025-07-25 17:33:59 -04:00
Colin Powell	6ab7745151	[music] Use found name to look it up	2025-07-25 10:50:00 -04:00
Colin Powell	8b062a6c1d	[music] Add tracks migration	2025-07-25 10:44:06 -04:00
Colin Powell	cd48e7a402	[boardgames] Fix migration path	2025-07-25 10:40:53 -04:00