[releases] Fix comic books scrobbling, mostly

[books] Fix comic scrobbles overrwriting one another
Fix bug where title not found
2025-10-20 17:17:18 -04:00 · 2025-10-20 17:15:54 -04:00 · 2025-10-20 17:02:52 -04:00 · 2025-10-20 17:02:34 -04:00 · 2025-10-20 16:12:01 -04:00 · 2025-10-20 16:11:20 -04:00
98 changed files with 2347 additions and 803 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,72 +92,8 @@ fetching and simple saving.
 :LOGBOOK:
 CLOCK: [2025-07-09 Wed 09:55]--[2025-07-09 Wed 10:15] =>  0:20
 :END:
-* Backlog [7/28]
-** 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 [3/27]
+** 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
@ -443,7 +392,221 @@ 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:
-* Version 18.4
+** 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] Add youtube link in place of IMDB on video detail page :vrobbler:feature:videos:personal:project:
+** 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] Add classmethod for metadata fetching to tracks :vrobbler:feature:music:personal:project:
+:PROPERTIES:
+:ID:       bc4b45e5-4c65-13c5-ab7b-1937d3fbf5c2
+:END:
+
+** TODO [#A] Tasks from org-mode should properly update notes and leave them out of the body :vrobbler:bug:tasks:
+** TODO [#A] Fix 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] 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.
+* 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
@ -456,12 +619,12 @@ https://codepen.io/oliviale/pen/QYqybo
 - 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
+* 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
+* 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
@ -582,7 +745,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
@ -645,7 +808,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
@ -750,7 +913,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
@ -1602,6 +1602,21 @@ files = [
 [package.extras]
 devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"]

+[[package]]
+name = "feedparser"
+version = "6.0.12"
+description = "Universal feed parser, handles RSS 0.9x, RSS 1.0, RSS 2.0, CDF, Atom 0.3, and Atom 1.0 feeds"
+optional = false
+python-versions = ">=3.6"
+groups = ["main"]
+files = [
+    {file = "feedparser-6.0.12-py3-none-any.whl", hash = "sha256:6bbff10f5a52662c00a2e3f86a38928c37c48f77b3c511aedcd51de933549324"},
+    {file = "feedparser-6.0.12.tar.gz", hash = "sha256:64f76ce90ae3e8ef5d1ede0f8d3b50ce26bcce71dd8ae5e82b1cd2d4a5f94228"},
+]
+
+[package.dependencies]
+sgmllib3k = "*"
+
 [[package]]
 name = "filelock"
 version = "3.18.0"
@ -4403,6 +4418,17 @@ enabler = ["pytest-enabler (>=2.2)"]
 test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21) ; python_version >= \"3.9\" and sys_platform != \"cygwin\"", "jaraco.envs (>=2.2)", "jaraco.path (>=3.7.2)", "jaraco.test (>=5.5)", "packaging (>=24.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf ; sys_platform != \"cygwin\"", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"]
 type = ["importlib_metadata (>=7.0.2) ; python_version < \"3.10\"", "jaraco.develop (>=7.21) ; sys_platform != \"cygwin\"", "mypy (==1.14.*)", "pytest-mypy"]

+[[package]]
+name = "sgmllib3k"
+version = "1.0.0"
+description = "Py3k port of sgmllib."
+optional = false
+python-versions = "*"
+groups = ["main"]
+files = [
+    {file = "sgmllib3k-1.0.0.tar.gz", hash = "sha256:7868fb1c8bfa764c1ac563d3cf369c381d1325d36124933a726f29fcdaa812e9"},
+]
+
 [[package]]
 name = "shellingham"
 version = "1.5.4"
@ -4730,6 +4756,20 @@ webencodings = ">=0.4"
 doc = ["sphinx", "sphinx_rtd_theme"]
 test = ["pytest", "ruff"]

+[[package]]
+name = "titlecase"
+version = "2.4.1"
+description = "Python Port of John Gruber's titlecase.pl"
+optional = false
+python-versions = ">=3.7"
+groups = ["main"]
+files = [
+    {file = "titlecase-2.4.1.tar.gz", hash = "sha256:7d83a277ccbbda11a2944e78a63e5ccaf3d32f828c594312e4862f9a07f635f5"},
+]
+
+[package.extras]
+regex = ["regex (>=2020.4.4)"]
+
 [[package]]
 name = "tld"
 version = "0.13"
@ -5499,4 +5539,4 @@ cffi = ["cffi (>=1.11)"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.9,<3.12"
-content-hash = "3a483aefea0a3afebf187b17b7df72a158788024ca8121b512b39567fb5ec8ca"
+content-hash = "2e297ef6f8c524840a381ad793946c87b601d81afd569e882fe58120a5f84626"
--- a/pyproject.toml
+++ b/pyproject.toml
@ -56,6 +56,8 @@ 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"

 [tool.poetry.group.test]
 optional = true
--- 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"}
+            ],
        },
    )

@ -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/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/bgg.py
+++ b/vrobbler/apps/boardgames/bgg.py
@ -119,8 +119,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 +151,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/models.py
+++ b/vrobbler/apps/boardgames/models.py
@ -1,8 +1,11 @@
+from functools import cached_property
 import logging
+from dataclasses import dataclass
 from datetime import datetime
 from typing import Optional
 from uuid import uuid4

+from django import forms
 import requests
 from boardgames.bgg import lookup_boardgame_from_bgg
 from django.conf import settings
@ -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)
--- 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()

@ -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/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__)
@ -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)

                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/models.py
+++ b/vrobbler/apps/books/models.py
@ -1,6 +1,8 @@
 from collections import OrderedDict
+from dataclasses import dataclass
 import logging
-from datetime import timedelta, datetime
+from datetime import datetime
+from typing import Optional
 from uuid import uuid4

 import requests
@ -20,12 +22,11 @@ from scrobbles.mixins import (
    LongPlayScrobblableMixin,
    ObjectWithGenres,
    ScrobblableConstants,
-    ScrobblableMixin,
 )
 from scrobbles.utils import get_scrobbles_for_media
 from taggit.managers import TaggableManager
 from thefuzz import fuzz
-from vrobbler.apps.books.comicvine import (
+from vrobbler.apps.books.sources.comicvine import (
    ComicVineClient,
    lookup_comic_from_comicvine,
 )
@ -35,9 +36,9 @@ from vrobbler.apps.books.locg import (
    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 books.sources.google import lookup_book_from_google
+from books.sources.semantic import lookup_paper_from_semantic
+from scrobbles.dataclasses import BaseLogData, LongPlayLogData

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

@ -46,6 +47,33 @@ 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
+
+    _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 +135,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 +146,11 @@ 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)
+    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(
@ -161,7 +195,46 @@ 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 and not overwrite and not force_new:
+            book, created = cls.objects.get_or_create(original_title=title)
+            logger.info("Found comic by original title, use force_new=True to override")
+            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, 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,
@ -173,21 +246,25 @@ class Book(LongPlayScrobblableMixin):
        # TODO use either a Google Books id identifier or author name like for tracks
        book, created = cls.objects.get_or_create(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)
+        if not book_dict or book_dict.get("isbn_10"):
+            book_dict = lookup_comic_from_comicvine(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 +290,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"
--- 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,71 @@ 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
+    ]
+    print(results)
+    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:
+        print("checking ", result.get("issue_number"), " to ", str(issue_number))
+        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,
    }

    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["run_time_seconds"] = 3600
+    if book_dict.get("pages"):
+        book_dict["run_time_seconds"] = book_dict.get("pages", 10) * getattr(
+            settings, "AVERAGE_PAGE_READING_SECONDS", 60
+        )

    return book_dict
--- a/vrobbler/apps/books/utils.py
+++ b/vrobbler/apps/books/utils.py
@ -0,0 +1,21 @@
+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
--- 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/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/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/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/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/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/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.

@ -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:
--- 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/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,
-        mopidy_uri: str = "",
-        producer_name: str = "",
+        episode_num: int = 0,
        run_time_seconds: int = 1800,
+        mopidy_uri: str = "",
+        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={
+                "run_time_seconds": 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["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/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
@ -56,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)

@ -115,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,15 +59,15 @@ 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 06:00:00"
+    europe = "2023-10-15 06:00:00"
    europe_end = "2023-12-16 12:00:00"
    europe_tz = "Europe/Paris"

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

    camp = "2024-08-04 17:00:00"
@ -78,6 +78,8 @@ def one_off_fix_colins_profile(profile):
    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/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,8 @@ PLAY_AGAIN_MEDIA = {
    "bricksets": "BrickSet",
    "trails": "Trail",
    "beers": "Beer",
+    "foods": "Food",
+    "locations": "GeoLocation",
 }

 MEDIA_END_PADDING_SECONDS = {
@ -35,6 +37,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 +53,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,9 +50,10 @@ class LastFM:
                enrich=True,
            )

-            timestamp = self.vrobbler_user.profile.get_timestamp_with_tz(
+            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
            )
@ -65,7 +66,7 @@ class LastFM:
                played_to_completion=True,
                in_progress=False,
                media_type=Scrobble.MediaType.TRACK,
-                timezone=timestamp.tzinfo.name,
+                timezone=tz_timestamp.tzinfo.name,
            )
            # Vrobbler scrobbles on finish, LastFM scrobbles on start
            seconds_eariler = timestamp - timedelta(seconds=20)
--- 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
@ -65,6 +65,10 @@ class ScrobblableMixin(TimeStampedModel):
    class Meta:
        abstract = True

+    @classmethod
+    def is_long_play_media(cls) -> bool:
+        return False
+
    def scrobble_for_user(
        self,
        user_id,
@ -111,9 +115,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 +140,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
@ -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
@ -1088,6 +1131,8 @@ class Scrobble(TimeStampedModel):
        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 = (
@ -1111,7 +1156,7 @@ class Scrobble(TimeStampedModel):
            )
            return scrobble

-        if not skip_in_progress_check:
+        if not skip_in_progress_check or read_log_page:
            logger.info(
                f"[create_or_update] check for existing scrobble to update ",
                extra={
@ -1127,15 +1172,35 @@ class Scrobble(TimeStampedModel):
            # 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 "log" in scrobble_data.keys() and scrobble.log:
+                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()))])
+
        logger.info(
            f"[scrobbling] creating new scrobble",
            extra={
@ -1302,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:
@ -1328,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={
@ -1423,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
@ -26,7 +28,7 @@ from scrobbles.constants import (
    SCROBBLE_CONTENT_URLS,
 )
 from scrobbles.models import Scrobble
-from scrobbles.notifications import NtfyNotification
+from scrobbles.notifications import ScrobbleNtfyNotification
 from scrobbles.utils import convert_to_seconds, extract_domain
 from sports.models import SportEvent
 from sports.thesportsdb import lookup_event_from_thesportsdb
@ -56,18 +58,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", ""),
@ -262,13 +257,41 @@ def manual_scrobble_video_game(
 def manual_scrobble_book(
    title: str, user_id: int, action: Optional[str] = None
 ):
-    book = Book.find_or_create(title)
+    log = {}
+    source = "Vrobbler"
+    page = None
+
+    if READCOMICSONLINE_URL in 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, enrich=True)

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

@ -282,7 +305,13 @@ 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":
+        scrobble.stop(force_finish=True)
+
+    return scrobble


 def manual_scrobble_board_game(
@ -368,7 +397,7 @@ def email_scrobble_board_game(
        enriched_game = find_and_enrich_board_game_data(game)
        if game.get("isBaseGame"):
            base_games[game.get("id")] = enriched_game
-        elif game.get("isExpansion"):
+        if game.get("isExpansion"):
            expansions[game.get("id")] = enriched_game

    locations = {}
@ -411,7 +440,7 @@ def email_scrobble_board_game(
                    except IndexError:
                        second = 0

-            log_data["details"] = play_dict.get("comments")
+            log_data["notes"] = [play_dict.get("comments")]
        log_data["expansion_ids"] = []
        try:
            base_game = base_games[play_dict.get("gameRefId")]
@ -505,7 +534,7 @@ def email_scrobble_board_game(
        scrobble.played_to_completion = True
        scrobble.save()
        scrobbles_created.append(scrobble)
-        NtfyNotification(scrobble).send()
+        ScrobbleNtfyNotification(scrobble).send()

    return scrobbles_created

@ -539,6 +568,8 @@ 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)

@ -587,9 +618,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",
@ -615,7 +646,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,
@ -657,8 +688,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,
@ -686,8 +721,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:
@ -736,18 +771,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__orgmode_id=orgmode_id,
        log__source="orgmode",
        task=task,
    ).last()
@ -756,7 +791,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
@ -765,7 +800,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
@ -775,7 +810,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)
@ -786,11 +821,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,
@ -865,8 +906,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


--- 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,26 @@
 import hashlib
 import logging
 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 +28,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()

@ -318,7 +328,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
@ -332,3 +355,56 @@ 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)
+
+    qs = base_scrobble_qs(user_id).filter(day=date)
+    agg = qs.aggregate(total_calories=models.Sum("calories_int"))
+
+    return agg["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}
--- a/vrobbler/apps/scrobbles/views.py
+++ b/vrobbler/apps/scrobbles/views.py
@ -2,23 +2,27 @@ import calendar
 import json
 import logging
 from datetime import datetime, timedelta
-from dateutil.relativedelta import relativedelta

 import pendulum
 import pytz
+from dateutil.relativedelta import relativedelta
 from django.apps import apps
 from django.contrib import messages
 from django.contrib.auth.mixins import LoginRequiredMixin
-from django.db.models import Count, Q
+from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator
+from django.db.models import Count, Max, Q
 from django.db.models.query import QuerySet
 from django.http import FileResponse, HttpResponseRedirect, JsonResponse
+from django.shortcuts import redirect
 from django.urls import reverse_lazy
 from django.utils import timezone
 from django.views.decorators.csrf import csrf_exempt
 from django.views.generic import DetailView, FormView, TemplateView
 from django.views.generic.edit import CreateView
 from django.views.generic.list import ListView
+from moods.models import Mood
 from music.aggregators import live_charts, scrobble_counts, week_of_scrobbles
+from pendulum.parsing.exceptions import ParserError
 from rest_framework import status
 from rest_framework.decorators import (
    api_view,
@ -51,6 +55,7 @@ from scrobbles.tasks import (
    process_tsv_import,
 )
 from scrobbles.utils import (
+    get_daily_calories_for_user_by_day,
    get_long_plays_completed,
    get_long_plays_in_progress,
 )
@ -64,15 +69,22 @@ class ScrobbleableListView(ListView):

    def get_queryset(self):
        queryset = super().get_queryset()
+        if self.model == Mood:
+            return queryset
+
+        user_filter = Q()
        if not self.request.user.is_anonymous:
-            queryset = queryset.annotate(
-                scrobble_count=Count("scrobble"),
-                filter=Q(scrobble__user=self.request.user),
-            ).order_by("-scrobble_count")
-        else:
-            queryset = queryset.annotate(
-                scrobble_count=Count("scrobble")
-            ).order_by("-scrobble_count")
+            user_filter = Q(scrobble__user=self.request.user)
+
+        queryset = (
+            queryset.filter(user_filter)
+            .annotate(
+                scrobble_count=Count("scrobble", distinct=True),
+                last_scrobble=Max("scrobble__timestamp"),
+            )
+            .filter(scrobble_count__gt=0)
+            .order_by("-last_scrobble")
+        )
        return queryset


@ -80,13 +92,30 @@ class ScrobbleableDetailView(DetailView):
    model = None
    slug_field = "uuid"

+    paginate_by = 200  # You can set this to whatever page size you want
+
    def get_context_data(self, **kwargs):
        context_data = super().get_context_data(**kwargs)
-        context_data["scrobbles"] = list()
+        scrobbles = []
        if not self.request.user.is_anonymous:
-            context_data["scrobbles"] = self.object.scrobble_set.filter(
+            scrobbles = self.object.scrobble_set.filter(
                user=self.request.user
-            )
+            ).order_by("-timestamp")
+
+        paginator = Paginator(scrobbles, self.paginate_by)
+        page_number = self.request.GET.get("page")
+
+        try:
+            page_obj = paginator.page(page_number)
+        except PageNotAnInteger:
+            page_obj = paginator.page(1)
+        except EmptyPage:
+            page_obj = paginator.page(paginator.num_pages)
+
+        context_data["page_obj"] = page_obj
+        context_data["scrobbles"] = page_obj.object_list
+        context_data["is_paginated"] = paginator.num_pages > 1
+
        return context_data


@ -118,7 +147,7 @@ class RecentScrobbleList(ListView):
            if date_str:
                try:
                    date = pendulum.parse(date_str)
-                except:
+                except ParserError:
                    pass
            if date_str:
                if date_str == "this_week" or "-W" in date_str:
@ -201,7 +230,8 @@ class RecentScrobbleList(ListView):
                processed_finished__isnull=True,
                user=self.request.user,
            )
-            data["counts"] = [] #scrobble_counts(user)
+            data["counts"] = []  # scrobble_counts(user)
+            data["daily_calories"] = get_daily_calories_for_user_by_day(self.request.user.id, date)
        else:
            data["weekly_data"] = week_of_scrobbles()
            data["counts"] = scrobble_counts()
@ -595,9 +625,9 @@ def scrobble_start(request, uuid):

    if (
        user.profile.redirect_to_webpage
-        and media_obj.__class__.__name__ == Scrobble.MediaType.WEBPAGE
+        and (media_obj.__class__.__name__ == Scrobble.MediaType.WEBPAGE or media_obj.__class__.__name__ == Scrobble.MediaType.BOOK)
    ):
-        logger.info(f"Redirecting to {media_obj} detail apge")
+        logger.info(f"Redirecting to {media_obj} detail page")
        return HttpResponseRedirect(media_obj.url)

    return HttpResponseRedirect(success_url)
@ -904,3 +934,60 @@ class ScrobbleStatusView(LoginRequiredMixin, TemplateView):
        ).first()

        return data
+
+
+class ScrobbleDetailView(DetailView):
+    model = Scrobble
+    slug_field = "uuid"
+    slug_url_kwarg = "uuid"
+
+    def get_form_class(self):
+        return self.object.media_obj.logdata_cls().form()
+
+    def get_form(self):
+        FormClass = self.get_form_class()
+
+        log = self.object.log or {}
+        initial_notes = log.get("notes", [])
+        if isinstance(initial_notes, list):
+            notes_str = "\n".join(initial_notes)
+            notes_str_fixed = notes_str.encode("utf-8").decode(
+                "unicode_escape"
+            )
+            log["notes"] = notes_str_fixed
+
+        return FormClass(initial=log)
+
+    def post(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        FormClass = self.get_form_class()
+        form = FormClass(request.POST)
+
+        if form.is_valid():
+            data = form.cleaned_data.copy()
+
+            for field_name, field in form.fields.items():
+                if field.disabled:
+                    original_value = (self.object.log or {}).get(field_name)
+                    data[field_name] = original_value
+
+            if data.get("with_people_ids", False):
+                data["with_people_ids"] = [
+                    p.id for p in data["with_people_ids"]
+                ]
+
+            if data.get("platform_id", False):
+                data["platform_id"] = data["platform_id"].id
+
+            self.object.log = data
+            self.object.save(update_fields=["log"])
+            return redirect(self.object.get_absolute_url())
+
+        context = self.get_context_data(log_form=form)
+        return self.render_to_response(context)
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        if "log_form" not in context:
+            context["log_form"] = self.get_form()
+        return context
--- a/vrobbler/apps/tasks/models.py
+++ b/vrobbler/apps/tasks/models.py
@ -1,11 +1,10 @@
 from dataclasses import dataclass
-from datetime import datetime
 from typing import Optional

 from django.apps import apps
 from django.db import models
 from django.urls import reverse
-from scrobbles.dataclasses import JSONDataclass
+from scrobbles.dataclasses import BaseLogData
 from scrobbles.mixins import LongPlayScrobblableMixin, ScrobblableConstants

 BNULL = {"blank": True, "null": True}
@ -14,14 +13,41 @@ TODOIST_TASK_URL = "https://app.todoist.com/app/task/{id}"


@dataclass
-class TaskLogData(JSONDataclass):
-    description: Optional[str] = None
+class TaskLogData(BaseLogData):
    title: Optional[str] = None
-    project: Optional[str] = None
+    labels: Optional[list[str]] = None
+
+    orgmode_id: Optional[str] = None
+    orgmode_state: Optional[str] = None
+    orgmode_properties: Optional[dict] = None
+    orgmode_drawers: Optional[list] = None
+    orgmode_timestamps: Optional[list] = None
+
    todoist_id: Optional[str] = None
-    todoist_event: Optional[str] = None
-    todoist_type: Optional[str] = None
-    notes: Optional[dict] = None
+    todoist_project_id: Optional[str] = None
+
+    _excluded_fields = {
+        "labels",
+        "orgmode_id",
+        "orgmode_state",
+        "orgmode_properties",
+        "orgmode_drawers",
+        "orgmode_timestamps",
+        "todoist_id",
+        "todoist_project_id",
+    }
+
+    def notes_as_str(self) -> str:
+        """Return formatted notes with line breaks and no keys"""
+        note_block = ""
+        if isinstance(self.notes, list):
+            note_block = "</br>".join(self.notes)
+
+        # DEPRECATED ... we don't store notes in dicts anymore
+        if isinstance(self.notes, dict):
+            for id, content in self.notes.items():
+                note_block += content + "</br>"
+        return note_block


 class Task(LongPlayScrobblableMixin):
@ -42,9 +68,9 @@ class Task(LongPlayScrobblableMixin):
    def strings(self) -> ScrobblableConstants:
        return ScrobblableConstants(verb="Doing", tags="memo")

-    # @property
-    # def logdata_cls(self):
-    #    return TaskLogData
+    @property
+    def logdata_cls(self):
+        return TaskLogData

    def source_url_for_user(self, user_id) -> str:
        url = ""
@ -56,7 +82,7 @@ class Task(LongPlayScrobblableMixin):

    def subtitle_for_user(self, user_id):
        scrobble = self.scrobbles(user_id).first()
-        return scrobble.logdata.description or ""
+        return scrobble.logdata.title or ""

    @classmethod
    def find_or_create(cls, title: str) -> "Task":
--- a/vrobbler/apps/tasks/utils.py
+++ b/vrobbler/apps/tasks/utils.py
@ -1,22 +1,106 @@
 import logging
+from datetime import timedelta

 from django.conf import settings
+from scrobbles.models import Scrobble

 logger = logging.getLogger(__name__)

-def get_title_from_labels(labels: list[str], user_context_labels: list[str] = []) -> str:
+
+def get_title_from_labels(
+    labels: list[str], user_context_labels: list[str] = []
+) -> str:
    title = "Unknown"
-    task_context_labels: list = user_context_labels or settings.DEFAULT_TASK_CONTEXT_TAG_LIST
    for label in labels:
-        # TODO We may also want to take a user list of labels instead
        label = label.capitalize()
-        if label in task_context_labels:
+        if label in user_context_labels:
            title = label
            continue

    if title == "Unknown":
        logger.warning(
            "Missing a configured title context for task",
-            extra={"labels": labels, "task_context_labels": task_context_labels},
+            extra={
+                "labels": labels,
+                "user_context_labels": user_context_labels,
+            },
        )
    return title
+
+
+def convert_old_orgmode_log_to_new(commit=False):
+    scrobbles = Scrobble.objects.filter(
+        source="Org-mode", log__has_key="drawers"
+    )
+    for scrobble in scrobbles:
+        scrobble.log["title"] = scrobble.log.pop("description")
+        scrobble.log["description"] = scrobble.log.pop("details")
+
+        scrobble.log["orgmode_body"] = scrobble.log.pop("body")
+        scrobble.log["orgmode_state"] = scrobble.log.pop("state")
+        scrobble.log["orgmode_properties"] = scrobble.log.pop("properties")
+        scrobble.log["orgmode_drawers"] = scrobble.log.pop("drawers")
+        scrobble.log["orgmode_timestamps"] = scrobble.log.pop("timestamps")
+        scrobble.log["orgmode_id"] = scrobble.log.pop("source_id")
+
+        if commit:
+            scrobble.save(update_fields=["log"])
+    print(f"Updated {scrobbles.count()} orgmode tasks logs")
+
+
+def convert_old_todoist_log_to_new(commit=False):
+    scrobbles = Scrobble.objects.filter(
+        source="Todoist", log__has_key="todoist_type"
+    )
+    for scrobble in scrobbles:
+        scrobble.log["title"] = scrobble.log.pop("description")
+        scrobble.log["description"] = scrobble.log.pop("details")
+        scrobble.log["todoist_id"] = scrobble.log.pop("source_id")
+        scrobble.log["labels"] = scrobble.log.pop("todoist_label_list")
+
+        scrobble.log.pop("todoist_type")
+        scrobble.log.pop("todoist_event")
+
+        print(f"Updating scrobble {scrobble.id}")
+        if commit:
+            scrobble.save(update_fields=["log"])
+    print(f"Updated {scrobbles.count()} todoist tasks logs")
+
+
+def convert_notes_to_dict(commit=False):
+    scrobbles = Scrobble.objects.filter(log__notes__isnull=False)
+    count = 0
+    for scrobble in scrobbles:
+        if isinstance(scrobble.log, str):
+            print(f"Converting {scrobble} string note to dict")
+            if scrobble.log.get("notes") == "":
+                scrobble.log.pop("notes")
+            key = str(int(scrobble.timestamp.timestamp()))
+            notes = scrobble.log.pop("notes")
+            scrobble.log = {}
+            scrobble.log["notes"] = {key: notes}
+            count += 1
+
+        if isinstance(scrobble.log.get("notes"), list):
+            note_list = scrobble.log.pop("notes")
+            if all(isinstance(item, dict) for item in note_list):
+                scrobble.log["notes"] = [
+                    value for d in note_list for value in d.values()
+                ]
+            count += 1
+        if commit:
+            scrobble.save(update_fields=["log"])
+    print(f"Updated {count} todoist tasks scrobbles")
+
+
+def convert_old_boardgame_log_to_new(commit=False):
+    scrobbles = Scrobble.objects.filter(
+        board_game__isnull=False, log__has_key="notes"
+    )
+    for scrobble in scrobbles:
+        if isinstance(scrobble.log.get("notes"), str):
+            scrobble.log["notes"] = [scrobble.log.pop("notes")]
+
+        if commit:
+            scrobble.save(update_fields=["log"])
+    print(f"Updated {scrobbles.count()} board game scrobbles")
--- a/vrobbler/apps/trails/models.py
+++ b/vrobbler/apps/trails/models.py
@ -1,14 +1,23 @@
-from django.utils.translation import gettext_lazy as _
+from dataclasses import dataclass
+from typing import Optional
+
 from django.apps import apps
 from django.db import models
 from django.urls import reverse
-from scrobbles.dataclasses import TrailLogData
-from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin
+from django.utils.translation import gettext_lazy as _
 from locations.models import GeoLocation
+from scrobbles.dataclasses import BaseLogData, WithPeopleLogData
+from scrobbles.mixins import ScrobblableConstants, ScrobblableMixin

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


+@dataclass
+class TrailLogData(BaseLogData, WithPeopleLogData):
+    effort: Optional[str] = None
+    difficulty: Optional[str] = None
+
+
 class Trail(ScrobblableMixin):
    class PrincipalType(models.TextChoices):
        WOODS = "WOODS"
--- a/vrobbler/apps/videogames/models.py
+++ b/vrobbler/apps/videogames/models.py
@ -1,6 +1,9 @@
+from dataclasses import dataclass
 import logging
+from typing import Optional
 from uuid import uuid4

+from django import forms
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.db import models
@ -8,7 +11,11 @@ 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 VideoGameLogData
+from scrobbles.dataclasses import (
+    BaseLogData,
+    LongPlayLogData,
+    WithPeopleLogData,
+)
 from scrobbles.mixins import LongPlayScrobblableMixin, ScrobblableConstants
 from scrobbles.utils import get_scrobbles_for_media
 from videogames.igdb import lookup_game_id_from_gdb
@ -18,6 +25,29 @@ BNULL = {"blank": True, "null": True}
 User = get_user_model()


+@dataclass
+class VideoGameLogData(BaseLogData, LongPlayLogData, WithPeopleLogData):
+    platform_id: Optional[int] = None
+    emulated: Optional[bool] = False
+    emulator: Optional[str] = None
+
+    @property
+    def platform(self):
+        if not self.platform_id:
+            return
+        return VideoGamePlatform.objects.filter(id=self.platform_id).first()
+
+    @classmethod
+    def override_fields(cls) -> dict:
+        return {
+            "platform_id": forms.ModelChoiceField(
+                queryset=VideoGamePlatform.objects.all(),
+                required=False,
+                widget=forms.Select(),
+            )
+        }
+
+
 class VideoGamePlatform(TimeStampedModel):
    name = models.CharField(max_length=255)
    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
--- a/vrobbler/apps/videogames/views.py
+++ b/vrobbler/apps/videogames/views.py
@ -1,17 +1,21 @@
-from django.views import generic
 from videogames.models import VideoGame, VideoGamePlatform
+from scrobbles.views import (
+    ScrobbleImportListView,
+    ScrobbleableDetailView,
+    ScrobbleableListView,
+)


-class VideoGameListView(generic.ListView):
+class VideoGameListView(ScrobbleableListView):
    model = VideoGame
-    paginate_by = 20
+    paginate_by = 40


-class VideoGameDetailView(generic.DetailView):
+class VideoGameDetailView(ScrobbleableDetailView):
    model = VideoGame
    slug_field = "uuid"


-class VideoGamePlatformDetailView(generic.DetailView):
+class VideoGamePlatformDetailView(ScrobbleableDetailView):
    model = VideoGamePlatform
    slug_field = "uuid"
--- a/vrobbler/apps/videos/models.py
+++ b/vrobbler/apps/videos/models.py
@ -1,3 +1,4 @@
+from dataclasses import dataclass
 import logging
 from typing import Optional
 from uuid import uuid4
@ -22,6 +23,7 @@ from videos.metadata import VideoMetadata
 from videos.sources.imdb import lookup_video_from_imdb
 from videos.sources.tmdb import lookup_video_from_tmdb
 from videos.sources.youtube import lookup_video_from_youtube
+from vrobbler.apps.scrobbles.dataclasses import BaseLogData, WithPeopleLogData

 YOUTUBE_VIDEO_URL = "https://www.youtube.com/watch?v="
 YOUTUBE_CHANNEL_URL = "https://www.youtube.com/channel/"
@ -31,6 +33,11 @@ logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}


+@dataclass
+class VideoLogData(BaseLogData, WithPeopleLogData):
+    rating: Optional[int] = None
+
+
 class Channel(TimeStampedModel):
    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
    name = models.CharField(max_length=255)
@ -243,6 +250,10 @@ class Video(ScrobblableMixin):
    def get_absolute_url(self):
        return reverse("videos:video_detail", kwargs={"slug": self.uuid})

+    @property
+    def logdata_cls(self):
+        return VideoLogData
+
    @property
    def subtitle(self):
        if self.tv_series:
--- a/vrobbler/apps/videos/urls.py
+++ b/vrobbler/apps/videos/urls.py
@ -5,7 +5,6 @@ app_name = "videos"


 urlpatterns = [
-    # path('', views.scrobble_endpoint, name='scrobble-list'),
    path("movies/", views.MovieListView.as_view(), name="movie_list"),
    path("series/", views.SeriesListView.as_view(), name="series_list"),
    path(
@ -13,6 +12,7 @@ urlpatterns = [
        views.SeriesDetailView.as_view(),
        name="series_detail",
    ),
+    path('videos/', views.VideoListView.as_view(), name='video_list'),
    path(
        "video/<slug:slug>/",
        views.VideoDetailView.as_view(),
--- a/vrobbler/apps/webpages/models.py
+++ b/vrobbler/apps/webpages/models.py
@ -67,10 +67,10 @@ class WebPage(ScrobblableMixin):
            self.save(update_fields=["extract"])

    def get_absolute_url(self):
-        return reverse("webpages:webpage-detail", kwargs={"slug": self.uuid})
+        return reverse("webpages:webpage_detail", kwargs={"slug": self.uuid})

    def get_read_url(self):
-        return reverse("webpages:webpage-read", kwargs={"slug": self.uuid})
+        return reverse("webpages:webpage_read", kwargs={"slug": self.uuid})

    @property
    def estimated_time_to_read_in_seconds(self):
--- a/vrobbler/apps/webpages/urls.py
+++ b/vrobbler/apps/webpages/urls.py
@ -5,15 +5,15 @@ app_name = "webpages"


 urlpatterns = [
-    path("webpages/", views.WebPageListView.as_view(), name="webpage-list"),
+    path("webpages/", views.WebPageListView.as_view(), name="webpage_list"),
    path(
        "webpages/<slug:slug>/",
        views.WebPageDetailView.as_view(),
-        name="webpage-detail",
+        name="webpage_detail",
    ),
    path(
        "webpage/<slug:slug>/read/",
        views.WebPageReadView.as_view(),
-        name="webpage-read",
+        name="webpage_read",
    ),
 ]
--- a/vrobbler/apps/webpages/views.py
+++ b/vrobbler/apps/webpages/views.py
@ -32,7 +32,7 @@ class WebPageReadView(
        if latest_scrobble.played_to_completion:
            redirect(
                reverse(
-                    "webpages:webpage-detail", kwargs={"slug": webpage.uuid}
+                    "webpages:webpage_detail", kwargs={"slug": webpage.uuid}
                )
            )
        return super().get(*args, **kwargs)
--- a/vrobbler/templates/_scrobblable_list.html
+++ b/vrobbler/templates/_scrobblable_list.html
@ -1,8 +1,10 @@
 {% load urlreplace %}
+{% load naturalduration %}

 <table class="table table-striped table-sm">
    <thead>
        <tr>
+            <th scope="col">Latest</th>
            <th scope="col">Title</th>
            <th scope="col">Scrobbles</th>
            <th scope="col">Start</th>
@ -10,13 +12,16 @@
    </thead>
    <tbody>
        {% for obj in object_list %}
+        {% if obj.title %}
        <tr>
+            <td><a href="{{obj.scrobble_set.last.get_absolute_url}}">{{obj.scrobble_set.last.local_timestamp}}
            <td><a href="{{obj.get_absolute_url}}">{{obj}}</a></td>
            {% if request.user.is_authenticated %}
            <td>{{obj.scrobble_count}}</td>
            <td><a type="button" class="btn btn-sm btn-primary" href="{{obj.start_url}}">Scrobble</a></td>
            {% endif %}
        </tr>
+        {% endif %}
        {% endfor %}
    </tbody>
 </table>
--- a/vrobbler/templates/base.html
+++ b/vrobbler/templates/base.html
@ -175,7 +175,7 @@
    </head>
    <body>
        <header class="navbar navbar-dark sticky-top bg-dark flex-md-nowrap p-0 shadow">
-            <a class="navbar-brand col-md-3 col-lg-2 me-0 px-3" href="#">Vrobbler</a>
+            <a class="navbar-brand col-md-3 col-lg-2 me-0 px-3" href="/">Vrobbler</a>
            <button class="navbar-toggler position-absolute d-md-none collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#sidebarMenu" aria-controls="sidebarMenu" aria-expanded="false" aria-label="Toggle navigation">
                <span class="navbar-toggler-icon"></span>
            </button>
@ -208,85 +208,8 @@
                        {% endfor %}
                        </ul>
                        {% endif %}
-                        <ul class="nav flex-column">
-                            <li class="nav-item">
-                                <a class="nav-link active" aria-current="page" href="/">
-                                <span data-feather="music"></span>
-                                Dashboard
-                                </a>
-                            </li>
-                            {% if user.is_authenticated %}
-                            <li class="nav-item">
-                                <a class="nav-link" aria-current="page" href="/charts/">
-                                <span data-feather="bar-chart"></span>
-                                Charts
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" aria-current="page" href="/locations/">
-                                <span data-feather="map"></span>
-                                Locations
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" href="/long-plays/">
-                                <span data-feather="playv"></span>
-                                Long plays
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" href="/moods/">
-                                <span data-feather="smiley"></span>
-                                Moods
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" href="/books/">
-                                <span data-feather="book"></span>
-                                Books
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" href="/video-games/">
-                                <span data-feather="video"></span>
-                                Video games
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" href="/board-games/">
-                                <span data-feather="board"></span>
-                                Board games
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" href="/trails/">
-                                <span data-feather="trail"></span>
-                                Trails
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" href="/beers/">
-                                <span data-feather="beer"></span>
-                                Beers
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" href="/imports/">
-                                <span data-feather="log"></span>
-                                Imports
-                                </a>
-                            </li>
-                            <li class="nav-item">
-                                <a class="nav-link" href="/admin/">
-                                <span data-feather="key"></span>
-                                Admin
-                                </a>
-                            </li>
-                            {% endif %}
-                        </ul>
                        {% block extra_nav %}
                        {% endblock %}
-                        <hr/>

                        {% if now_playing_list and user.is_authenticated %}
                        <ul>
@ -296,7 +219,7 @@
                                {% if scrobble.media_obj.primary_image_url %}<div style="float:left;padding-right:10px;padding-bottom:10px;"><img src="{{scrobble.media_obj.primary_image_url}}" /></div>{% endif %}
                                <p><a href="{{scrobble.media_obj.get_absolute_url}}">{{scrobble.media_obj.title}}</a></p>
                                {% if scrobble.media_obj.subtitle %}<p><em><a href="{{scrobble.media_obj.subtitle.get_absolute_url}}">{{scrobble.media_obj.subtitle}}</a></em></p>{% endif %}
-                                {% if scrobble.logdata %}{% if scrobble.logdata.description %}<p><em>{{scrobble.logdata.description}}</em></p>{% endif %}{% endif %}
+                                {% if scrobble.logdata %}{% if scrobble.logdata.title%}<p><em>{{scrobble.logdata.title}}</em></p>{% endif %}{% endif %}
                                <p><small>{{scrobble.local_timestamp|naturaltime}} from {{scrobble.source}}</small></p>
                                <div class="progress-bar" style="margin-right:5px;">
                                    <span class="progress-bar-fill" style="width: {{scrobble.percent_played}}%;"></span>
@ -329,5 +252,21 @@
        </div>

        {% block extra_js %}{% endblock %}
+        <script>
+        (() => {
+        'use strict'
+        const forms = document.querySelectorAll('.needs-validation')
+        Array.from(forms).forEach(form => {
+            form.addEventListener('submit', event => {
+            if (!form.checkValidity()) {
+                event.preventDefault()
+                event.stopPropagation()
+            }
+            form.classList.add('was-validated')
+            }, false)
+        })
+        })()
+        </script>
+
    </body>
 </html>
--- a/vrobbler/templates/beers/beer_detail.html
+++ b/vrobbler/templates/beers/beer_detail.html
@ -39,7 +39,7 @@
    </div>
 </div>
 <div class="row">
-    <p>{{object.scrobble_set.count}} scrobbles</p>
+    <p>{{scrobbles.count}} scrobbles</p>
    <p>
        <a href="{{object.start_url}}">Drink again</a>
    </p>
@ -55,9 +55,9 @@
                    </tr>
                </thead>
                <tbody>
-                    {% for scrobble in object.scrobble_set.all|dictsortreversed:"timestamp" %}
+                    {% for scrobble in scrobbles.all|dictsortreversed:"timestamp" %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
+                        <td><a href="{{scrobble.get_absolute_url}}">{{scrobble.local_timestamp}}</a></td>
                    </tr>
                    {% endfor %}
                </tbody>
--- a/vrobbler/templates/boardgames/boardgame_detail.html
+++ b/vrobbler/templates/boardgames/boardgame_detail.html
@ -42,7 +42,7 @@
    </div>
 </div>
 <div class="row">
-    <p>{{object.scrobble_set.count}} scrobbles</p>
+    <p>{{scrobbles.count}} scrobbles</p>
    <p>
        <a href="{{object.start_url}}">Play again</a>
    </p>
@ -55,21 +55,41 @@
                <thead>
                    <tr>
                        <th scope="col">Date</th>
-                        <th scope="col">Publisher</th>
-                        <th scope="col">Screenshot</th>
+                        <th scope="col">Location</th>
+                        <th scope="col">Players</th>
                    </tr>
                </thead>
                <tbody>
-                    {% for scrobble in object.scrobble_set.all|dictsortreversed:"timestamp" %}
+                    {% for scrobble in scrobbles.all|dictsortreversed:"timestamp" %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
-                        <td>{{scrobble.media_obj.publisher}}</td>
-                        <td>{% if scrobble.screenshot%}<img src="{{scrobble.screenshot.url}}" width=250 />{% endif %}</td>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
+                        <td>{{scrobble.logdata.location }}</td>
+                        <td>{% if scrobble.logdata.player_log %}{{scrobble.logdata.player_log}}{% else %}No data{% endif %}</td>
                    </tr>
                    {% endfor %}
                </tbody>
            </table>
        </div>
    </div>
+
+    {% if is_paginated %}
+    <div class="pagination">
+        {% if page_obj.has_previous %}
+        <a href="?page={{ page_obj.previous_page_number }}">&laquo; Previous</a>
+        {% endif %}
+
+        {% for num in page_obj.paginator.page_range %}
+        {% if num == page_obj.number %}
+            <strong>{{ num }}</strong>
+        {% else %}
+            <a href="?page={{ num }}">{{ num }}</a>
+        {% endif %}
+        {% endfor %}
+
+        {% if page_obj.has_next %}
+        <a href="?page={{ page_obj.next_page_number }}">Next &raquo;</a>
+        {% endif %}
+    </div>
+    {% endif %}
 </div>
 {% endblock %}
--- a/vrobbler/templates/books/book_detail.html
+++ b/vrobbler/templates/books/book_detail.html
@ -26,15 +26,7 @@
    </div>
 </div>
 <div class="row">
-    <p>{{object.scrobble_set.count}} scrobbles</p>
-    <p>Read {{object.scrobble_set.last.book_pages_read}} pages{% if object.scrobble_set.last.long_play_complete %} and completed{% else %}{% endif %}</p>
-    <p>
-        {% if object.scrobble_set.last.long_play_complete == True %}
-        <a href="">Read again</a>
-        {% else %}
-        <a href="">Resume reading</a>
-        {% endif %}
-    </p>
+    <p>{{scrobbles.count}} scrobbles</p>
 </div>
 <div class="row">
    <div class="col-md">
@ -50,10 +42,10 @@
                    </tr>
                </thead>
                <tbody>
-                    {% for scrobble in object.scrobble_set.all|dictsortreversed:"timestamp" %}
+                    {% for scrobble in scrobbles.all|dictsortreversed:"timestamp" %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
-                        <td>{% if scrobble.long_play_complete == True %}Yes{% endif %}</td>
+                        <td><a href="{{scrobble.get_absolute_url}}">{{scrobble.local_timestamp}}</a></td>
+                        <td>{% if scrobble.logdata.long_play_complete == True %}Yes{% endif %}</td>
                        <td>{% if scrobble.in_progress %}Now reading{% else %}{{scrobble.session_pages_read}}{% endif %}</td>
                        <td>{% for author in scrobble.book.authors.all %}<a href="{{author.get_absolute_url}}">{{author}}</a>{% if not forloop.last %}, {% endif %}{% endfor %}</td>
                    </tr>
--- a/vrobbler/templates/bricksets/brickset_detail.html
+++ b/vrobbler/templates/bricksets/brickset_detail.html
@ -0,0 +1,56 @@
+{% extends "base_list.html" %}
+{% load mathfilters %}
+{% load static %}
+{% load naturalduration %}
+
+{% block title %}{{object.title}}{% endblock %}
+
+{% block lists %}
+
+<div class="row">
+
+    {% if object.cover%}
+    <p style="float:left; width:402px; padding:0; border: 1px solid #ccc">
+        <img src="{{object.cover.url}}" width=400 />
+    </p>
+    {% endif %}
+    <div style="float:left; width:600px; margin-left:10px; ">
+        {% if object.summary %}
+        <p>{{object.summary|safe|linebreaks|truncatewords:160}}</p>
+        <hr />
+        {% endif %}
+        <p style="float:right;">
+            <a href="{{object.openlibrary_link}}"><img src="{% static " images/openlibrary-logo.png" %}" width=35></a>
+            <a href="{{object.amazon_link}}"><img src="{% static " images/amazon-logo.png" %}" width=35></a>
+        </p>
+    </div>
+</div>
+<div class="row">
+    <p>{{scrobbles.count}} scrobbles</p>
+</div>
+<div class="row">
+    <div class="col-md">
+        <h3>Last scrobbles</h3>
+        <div class="table-responsive">
+            <table class="table table-striped table-sm">
+                <thead>
+                    <tr>
+                        <th scope="col">Date</th>
+                        <th scope="col">Completed</th>
+                        <th scope="col">Time</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for scrobble in scrobbles.all|dictsortreversed:"timestamp" %}
+                    <tr>
+                        <td><a href="{{scrobble.get_absolute_url}}">{{scrobble.local_timestamp}}</a></td>
+                        <td>{% if scrobble.logdata.long_play_complete == True %}Yes{% endif %}</td>
+                        <td>{% if scrobble.in_progress %}Now reading{% else %}{{scrobble.session_pages_read}}{% endif %}</td>
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+    </div>
+</div>
+{% endblock %}
--- a/vrobbler/templates/bricksets/brickset_list.html
+++ b/vrobbler/templates/bricksets/brickset_list.html
@ -0,0 +1,23 @@
+{% extends "base_list.html" %}
+
+{% block title %}Brick Sets{% endblock %}
+
+{% block head_extra %}
+<style>
+ dl { width: 210px; float:left; margin-right: 10px; }
+ dt a { color:white; text-decoration: none; font-size:smaller; }
+ img { height:200px; width: 200px; object-fit: cover; }
+ dd .right { float:right; }
+</style>
+{% endblock  %}
+
+{% block lists %}
+<div class="row">
+
+    <div class="col-md">
+        <div class="table-responsive">
+            {% include "_scrobblable_list.html" %}
+        </div>
+    </div>
+</div>
+{% endblock %}
--- a/vrobbler/templates/foods/food_detail.html
+++ b/vrobbler/templates/foods/food_detail.html
@ -0,0 +1,37 @@
+{% extends "base_list.html" %}
+{% load static %}
+
+{% block title %}{{object.title}}{% endblock %}
+
+{% block lists %}
+<div class="row webpage">
+    <div class="webpage-metadata">
+      <p>{{object.description}}</p>
+    </div>
+</div>
+<div class="row">
+    <div class="col-md">
+        <h3>Last scrobbles</h3>
+        <div class="table-responsive">
+            <table class="table table-striped table-sm">
+            <thead>
+                <tr>
+                    <th scope="col">Date</th>
+                    <th scope="col">Calories</th>
+                    <th scope="col">Notes</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for scrobble in scrobbles.all %}
+                <tr>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
+                        <td>{% if scrobble.logdata.calories %}{{scrobble.logdata.calories}}{% else %}{{scrobble.media_obj.calories}}{% endif %}</td>
+                        <td>{% for note in scrobble.logdata.notes %}{{note}}{% if not forloop.last %}; {% endif%}{% endfor %}
+                </tr>
+                {% endfor %}
+            </tbody>
+            </table>
+        </div>
+    </div>
+</div>
+{% endblock %}
--- a/vrobbler/templates/foods/food_list.html
+++ b/vrobbler/templates/foods/food_list.html
@ -0,0 +1,23 @@
+{% extends "base_list.html" %}
+
+{% block title %}Foods{% endblock %}
+
+{% block head_extra %}
+<style>
+ dl { width: 210px; float:left; margin-right: 10px; }
+ dt a { color:white; text-decoration: none; font-size:smaller; }
+ img { height:200px; width: 200px; object-fit: cover; }
+ dd .right { float:right; }
+</style>
+{% endblock  %}
+
+{% block lists %}
+<div class="row">
+
+    <div class="col-md">
+        <div class="table-responsive">
+            {% include "_scrobblable_list.html" %}
+        </div>
+    </div>
+</div>
+{% endblock %}
--- a/vrobbler/templates/locations/geolocation_detail.html
+++ b/vrobbler/templates/locations/geolocation_detail.html
@ -48,7 +48,7 @@
    </div>
 </div>
 <div class="row">
-    <p>{{object.scrobble_set.count}} scrobbles</p>
+    <p>{{scrobbles.count}} scrobbles</p>
 <div class="row">
    <div class="col-md">
        <h3>Last scrobbles</h3>
@ -57,12 +57,16 @@
                <thead>
                    <tr>
                        <th scope="col">Date</th>
+                        <th scope="col">With</th>
+                        <th scope="col">Notes</th>
                    </tr>
                </thead>
                <tbody>
                    {% for scrobble in object.scrobble_set.all|dictsortreversed:"timestamp" %}
                    <tr>
-                        <td>{{scrobble.local_timestamp|naturaltime}}</td>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
+                        <td>{% for person in scrobble.logdata.with_people%}{{person}}{% if not forloop.last %}, {% endif%}{% endfor %}</td>
+                        <td>{% for note in scrobble.logdata.notes %}{{note}}{% if not forloop.last %}; {% endif%}{% endfor %}
                    </tr>
                    {% endfor %}
                </tbody>
--- a/vrobbler/templates/locations/geolocation_list.html
+++ b/vrobbler/templates/locations/geolocation_list.html
@ -67,13 +67,7 @@
                    </tr>
                </thead>
                <tbody>
-                    {% for location in object_list %}
-                    <tr>
-                        <td>{{location.scrobble_set.count}}</td>
-                        <td>{{location.title}}</td>
-                        <td><a href="{{location.get_absolute_url}}">{{location.lat}}x{{location.lon}}</a></td>
-                    </tr>
-                    {% endfor %}
+                    {% include "_scrobblable_list.html" %}
                </tbody>
            </table>
        </div>
--- a/vrobbler/templates/moods/mood_detail.html
+++ b/vrobbler/templates/moods/mood_detail.html
@ -26,9 +26,9 @@
                </tr>
            </thead>
            <tbody>
-                {% for scrobble in object.scrobble_set.all %}
+                {% for scrobble in scrobbles.all %}
                <tr>
-                    <td>{{scrobble.local_timestamp}}</td>
+                    <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                </tr>
                {% endfor %}
            </tbody>
--- a/vrobbler/templates/music/album_detail.html
+++ b/vrobbler/templates/music/album_detail.html
@ -82,7 +82,7 @@
            <tbody>
                {% for scrobble in object.scrobbles %}
                <tr>
-                    <td>{{scrobble.local_timestamp}}</td>
+                    <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                    <td><a href="{{scrobble.track.get_absolute_url}}">{{scrobble.track.title}}</a></td>
                    <td><a href="{{scrobble.track.artist.get_absolute_url}}">{{scrobble.track.artist.name}}</a></td>
                </tr>
--- a/vrobbler/templates/music/artist_detail.html
+++ b/vrobbler/templates/music/artist_detail.html
@ -83,7 +83,7 @@
            <tbody>
                {% for scrobble in object.scrobbles %}
                <tr>
-                    <td>{{scrobble.local_timestamp}}</td>
+                    <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                    <td><a href="{{scrobble.track.get_absolute_url}}">{{scrobble.track.title}}</a></td>
                    <td><a href="{{scrobble.track.primary_album.get_absolute_url}}">{{scrobble.track.primary_album.name}}</a></td>
                </tr>
--- a/vrobbler/templates/music/track_detail.html
+++ b/vrobbler/templates/music/track_detail.html
@ -9,7 +9,7 @@
    {% endif %}
 </div>
 <div class="row">
-    <p>{{object.scrobble_set.count}} scrobbles</p>
+    <p>{{scrobbles.count}} scrobbles</p>
    {% if charts %}
    <p>{% for chart in charts %}<em><a href="{{chart.link}}">{{chart}}</a></em>{% if forloop.last %}{% else %} | {% endif %}{% endfor %}</p>
    {% endif %}
@ -26,9 +26,9 @@
                    </tr>
                </thead>
                <tbody>
-                    {% for scrobble in object.scrobble_set.all %}
+                    {% for scrobble in scrobbles.all %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                        <td><a href="{{scrobble.track.get_absolute_url}}">{{scrobble.track.title}}</a></td>
                        <td><a href="{{scrobble.track.primary_album.get_absolute_url}}">{{scrobble.track.primary_album}}</a></td>
                        <td><a href="{{scrobble.track.artist.get_absolute_url}}">{{scrobble.track.artist}}</a></td>
--- a/vrobbler/templates/music/track_list.html
+++ b/vrobbler/templates/music/track_list.html
@ -20,40 +20,7 @@
    <hr />

    <div class="col-md">
-        <div class="table-responsive">
-            <table class="table table-striped table-sm">
-            <thead>
-                <tr>
-                    <th scope="col">Scrobbles</th>
-                    <th scope="col">Track</th>
-                    <th scope="col">Artist</th>
-                </tr>
-            </thead>
-            <tbody>
-                {% for track in object_list %}
-                <tr>
-                    <td>{{track.scrobble_set.count}}</td>
-                    <td><a href="{{track.get_absolute_url}}">{{track}}</a></td>
-                    <td><a href="{{track.artist.get_absolute_url}}">{{track.artist}}</a></td>
-                </tr>
-                {% endfor %}
-            </tbody>
-            </table>
-        </div>
-    </div>
-
-    <div class="pagination" style="margin-bottom:50px;">
-        <span class="page-links">
-            {% if page_obj.has_previous %}
-                <a href="?page={{ page_obj.previous_page_number }}">previous</a>
-            {% endif %}
-                <span class="page-current">
-                    Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}
-                </span>
-            {% if page_obj.has_next %}
-                <a href="?page={{ page_obj.next_page_number }}">next</a>
-            {% endif %}
-        </span>
+        <div class="table-responsive">{% include "_scrobblable_list.html" %}</div>
    </div>
 </div>
 {% endblock %}
--- a/vrobbler/templates/podcasts/podcast_detail.html
+++ b/vrobbler/templates/podcasts/podcast_detail.html
@ -45,7 +45,7 @@
                <tbody>
                    {% for scrobble in scrobbles.all %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                        <td>{{scrobble.podcast_episode}}</td>
                    </tr>
                    {% endfor %}
--- a/vrobbler/templates/podcasts/podcast_list.html
+++ b/vrobbler/templates/podcasts/podcast_list.html
@ -1,5 +1,6 @@
 {% extends "base_list.html" %}

+{% block title %}Podcasts{% endblock %}
 {% block lists %}
 <div class="row">
    <div class="col-md">
@ -7,20 +8,19 @@
            <table class="table table-striped table-sm">
                <thead>
                    <tr>
-                        <th scope="col">Series</th>
                        <th scope="col">Episode</th>
+                        <th scope="col">Podcast</th>
                        <th scope="col">Scrobbles</th>
-                        <th scope="col">All time</th>
                    </tr>
                </thead>
                <tbody>
-                    {% for obj in object_list %}
-                    {% for episode in obj.episode_set.all %}
+                    {% for obj in object_list.all %}
+                        {{obj.episodes}}
+                    {% for episode in obj.podcastepisode_set.all %}
                    <tr>
                        <td><a href="{{episode.get_absolute_url}}">{{episode}}</a></td>
                        <td><a href="{{obj.get_absolute_url}}">{{obj}}</a></td>
                        <td>{{episode.scrobble_set.count}}</td>
-                        <td></td>
                    </tr>
                    {% endfor %}
                    {% endfor %}
--- a/vrobbler/templates/puzzles/puzzle_detail.html
+++ b/vrobbler/templates/puzzles/puzzle_detail.html
@ -0,0 +1,68 @@
+{% extends "base_list.html" %}
+{% load mathfilters %}
+{% load static %}
+{% load naturalduration %}
+
+{% block title %}{{object.title}}{% endblock %}
+
+{% block head_extra %}
+<style>
+    .cover img {
+        width: 250px;
+    }
+
+    .cover {
+        float: left;
+        width: 252px;
+        padding: 0;
+    }
+
+    .summary {
+        float: left;
+        width: 600px;
+        margin-left: 10px;
+    }
+</style>
+{% endblock %}
+
+{% block lists %}
+
+<div class="row">
+    <div class="summary">
+        {% if object.description%}
+        <p>{{object.description|safe|linebreaks|truncatewords:160}}</p>
+        <hr />
+        {% endif %}
+        <p style="float:right;">
+            <a href="{{object.untappd_link}}"><img src="{% static "images/untappd-logo.png" %}" width=35></a>
+        </p>
+    </div>
+</div>
+<div class="row">
+    <p>{{scrobbles.count}} scrobbles</p>
+    <p>
+        <a href="{{object.start_url}}">Drink again</a>
+    </p>
+</div>
+<div class="row">
+    <div class="col-md">
+        <h3>Last scrobbles</h3>
+        <div class="table-responsive">
+            <table class="table table-striped table-sm">
+                <thead>
+                    <tr>
+                        <th scope="col">Date</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {% for scrobble in scrobbles.all|dictsortreversed:"timestamp" %}
+                    <tr>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+    </div>
+</div>
+{% endblock %}
--- a/vrobbler/templates/puzzles/puzzle_list.html
+++ b/vrobbler/templates/puzzles/puzzle_list.html
@ -0,0 +1,23 @@
+{% extends "base_list.html" %}
+
+{% block title %}Puzzles{% endblock %}
+
+{% block head_extra %}
+<style>
+ dl { width: 210px; float:left; margin-right: 10px; }
+ dt a { color:white; text-decoration: none; font-size:smaller; }
+ img { height:200px; width: 200px; object-fit: cover; }
+ dd .right { float:right; }
+</style>
+{% endblock  %}
+
+{% block lists %}
+<div class="row">
+
+    <div class="col-md">
+        <div class="table-responsive">
+            {% include "_scrobblable_list.html" %}
+        </div>
+    </div>
+</div>
+{% endblock %}
--- a/vrobbler/templates/scrobbles/_last_scrobbles.html
+++ b/vrobbler/templates/scrobbles/_last_scrobbles.html
@ -7,83 +7,142 @@
 </div>
 <div class="row">
    <div class="col-md">
+        <h3><a href="{% url 'music:tracks_list' %}">Tracks</a></h3>
        {% if Track %}
-        <h2>Music</h2>
        {% with scrobbles=Track count=Track_count time=Track_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No tracks today</p>
        {% endif %}
+
+        <h3><a href="{% url 'foods:food_list' %}">Food</a></h3>
+        {% if Food %}
+        {% with scrobbles=Food count=Food_count time=Food_time %}
+        {% include "scrobbles/_scrobble_table.html" %}
+        {% endwith %}
+        {% else %}
+        <p>No food today</p>
+        {% endif %}
+
+        <h3><a href="{% url 'moods:mood_list' %}">Moods</a></h3>
+        {% if Mood %}
+        {% with scrobbles=Mood count=Mood_count time=Mood_time %}
+        {% include "scrobbles/_scrobble_table.html" %}
+        {% endwith %}
+        {% else %}
+        <p>No moods felt today </p>
+        {% endif %}
+
    </div>
    <div class="col-md">

+        <h3><a href="{% url 'tasks:task_list' %}">Tasks</a></h3>
        {% if Task %}
-        <h2>Latest tasks</h2>
        {% with scrobbles=Task count=Task_count time=Task_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No tasks today</p>
        {% endif %}

+        <h3><a href="{% url 'videos:video_list' %}">Videos</a></h3>
        {% if Video %}
-        <h2>Videos</h2>
        {% with scrobbles=Video count=Video_count time=Video_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No videos today</p>
        {% endif %}

+        <h3><a href="{% url 'webpages:webpage_list' %}">Web pages</a></h3>
        {% if WebPage %}
-        <h4>Web pages</h4>
        {% with scrobbles=WebPage count=WebPage_count time=WebPage_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else%}
+        <p>No web page read today</p>
        {% endif %}

+        <h3><a href="{% url 'sports:event_list' %}">Sport events</a></h3>
        {% if SportEvent %}
-        <h2>Sports</h2>
        {% with scrobbles=SportEvent count=SportEvent_count time=SportEvent_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No sports today</p>
        {% endif %}

+        <h3><a href="{% url 'podcasts:podcast_list' %}">Podcasts</a></h3>
        {% if PodcastEpisode %}
-        <h2>Latest podcasts</h2>
        {% with scrobbles=PodcastEpisode count=PodcastEpisode_count time=PodcastEpisode_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No podcasts today</p>
        {% endif %}

+        <h3><a href="{% url "videogames:videogame_list" %}">Video games</a></h3>
        {% if VideoGame %}
-        <h4>Video games</h4>
        {% with scrobbles=VideoGame count=VideoGame_count time=VideoGame_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No video games today</p>
        {% endif %}

+        <h3><a href="{% url "boardgames:boardgame_list" %}">Board games</a></h3>
        {% if BoardGame %}
-        <h4>Board games</h4>
        {% with scrobbles=BoardGame count=BoardGame_count time=BoardGame_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No board games today</p>
        {% endif %}

+        <h3><a href="{% url 'beers:beer_list' %}">Beers</a></h3>
        {% if Beer %}
-        <h4>Beers</h4>
        {% with scrobbles=Beer count=Beer_count time=Beer_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No beer today</p>
        {% endif %}

+        <h3><a href="{% url 'bricksets:brickset_list' %}">Brick sets</a></h3>
        {% if BrickSet %}
-        <h4>Brick sets</h4>
        {% with scrobbles=BrickSet count=BrickSet_count time=BrickSet_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No brick sets today</p>
        {% endif %}

+        <h3><a href="{% url 'puzzles:puzzle_list' %}">Puzzles</a></h3>
+        {% if Puzzle %}
+        {% with scrobbles=Puzzle count=Puzzle_count time=Puzzle_time %}
+        {% include "scrobbles/_scrobble_table.html" %}
+        {% endwith %}
+        {% else %}
+        <p>No puzzles today</p>
+        {% endif %}
+
+        <h3><a href="{% url 'books:book_list' %}">Books</a></h3>
        {% if Book %}
-        <h4>Books</h4>
        {% with scrobbles=Book count=Book_count time=Book_time %}
        {% include "scrobbles/_scrobble_table.html" %}
        {% endwith %}
+        {% else %}
+        <p>No books read today</p>
+        {% endif %}
+
+        <h3><a href="{% url 'locations:geolocation_list' %}">Locations</a></h3>
+        {% if GeoLocation %}
+        {% with scrobbles=GeoLocation count=GeoLocation_count time=GeoLocation_time %}
+        {% include "scrobbles/_scrobble_table.html" %}
+        {% endwith %}
+        {% else %}
+        <p>No locations visited today</p>
        {% endif %}

    </div>
--- a/vrobbler/templates/scrobbles/_row.html
+++ b/vrobbler/templates/scrobbles/_row.html
@ -1,10 +1,10 @@
 {% load humanize %}
 {% load naturalduration %}
 <tr {% if scrobble.in_progress %}class="in-progress"{% endif %}>
-    <td>{% if scrobble.in_progress %}{{scrobble.media_obj.strings.verb}} now | <a class="right" href="{% url "scrobbles:finish" scrobble.uuid %}">Finish</a>{% else %}{{scrobble.local_timestamp|naturaltime}}{% endif %}</td>
+    <td>{% if scrobble.in_progress %}<a href="{{scrobble.get_absolute_url}}">{{scrobble.media_obj.strings.verb}} now</a> | <a class="right" href="{% url "scrobbles:finish" scrobble.uuid %}">Finish</a>{% else %}<a href="{{scrobble.get_absolute_url}}">{{scrobble.local_timestamp|naturaltime}}</a>{% endif %}</td>
    <td>
        {% if scrobble.media_type == "Task" %}
-        <p><em><a href="{{scrobble.media_obj.get_absolute_url}}">{{scrobble.media_obj.title|truncatechars_html:45}} - {% if scrobble.logdata %}{% if scrobble.logdata.description %}{{scrobble.logdata.description}}{% endif %}{% endif %}</a></em></p>
+        <p><em><a href="{{scrobble.media_obj.get_absolute_url}}">{{scrobble.media_obj.title|truncatechars_html:45}} - {% if scrobble.logdata %}{% if scrobble.logdata.title%}{{scrobble.logdata.title}}{% endif %}{% endif %}</a></em></p>
        {% else %}
        <a href="{{scrobble.media_obj.get_absolute_url}}">{{scrobble.media_obj|truncatechars_html:45}}</a>
        {% endif %}
--- a/vrobbler/templates/scrobbles/_scrobble_table.html
+++ b/vrobbler/templates/scrobbles/_scrobble_table.html
@ -4,7 +4,7 @@
 <div class="tab-pane fade show" id="latest-beers" role="tabpanel"
    aria-labelledby="latest-beers-tab">
    <div class="table-responsive">
-        {{count}} scrobble {% if time %}| {{time|natural_duration}}{% endif %}
+        {{count}} scrobble {% if time %}| {{time|natural_duration}}{% endif %}{% if daily_calories %}| {{daily_calories}} calories{% endif %}
        <table class="table table-striped table-sm">
            <thead>
                <tr>
--- a/vrobbler/templates/scrobbles/scrobble_detail.html
+++ b/vrobbler/templates/scrobbles/scrobble_detail.html
@ -0,0 +1,40 @@
+{% extends "base_list.html" %}
+{% load form_tags %}
+{% load mathfilters %}
+{% load static %}
+
+{% block title %}{{object.name}}{% endblock %}
+
+{% block lists %}
+
+<div class="row">
+
+<h1>{{ object.media_obj }} - {{object.media_type}}</h1>
+
+<!-- Your existing detail page content -->
+{% if object.logdata.avg_seconds_per_page %}
+<p>Rate: {{object.logdata.avg_seconds_per_page}}s per page</p>
+{% endif %}
+
+<h2>Edit Log</h2>
+<form method="post" class="needs-validation" novalidate>
+  {% csrf_token %}
+  {% for field in log_form %}
+    <div class="mb-3">
+      <label for="{{ field.id_for_label }}" class="form-label">{{ field.label }}</label>
+      {{ field|add_class:"form-control" }}
+      {% if field.help_text %}
+        <div class="form-text">{{ field.help_text }}</div>
+      {% endif %}
+      {% for error in field.errors %}
+        <div class="invalid-feedback d-block">{{ error }}</div>
+      {% endfor %}
+    </div>
+  {% endfor %}
+
+  <button type="submit" class="btn btn-primary">Save</button>
+</form>
+
+</div>
+
+{% endblock %}
--- a/vrobbler/templates/scrobbles/scrobble_list.html
+++ b/vrobbler/templates/scrobbles/scrobble_list.html
@ -56,6 +56,14 @@
        <h1 class="h2">{% if date %}{{date|naturaltime}}{% else %}{{title}}{% endif %}</h1>
        <div class="btn-toolbar mb-2 mb-md-0">
            {% if user.is_authenticated %}
+            <div class="btn-group me-2">
+                <form action="/admin/" method="get">
+                    <button type="submit" class="btn btn-sm btn-outline-secondary">
+                        <span data-feather="key"></span>
+                        Admin
+                    </button>
+                </form>
+            </div>
            <div class="btn-group me-2">
                {% if user.profile.lastfm_username and not user.profile.lastfm_auto_import %}
                <form action="{% url 'scrobbles:lastfm-import' %}" method="get">
--- a/vrobbler/templates/sports/sportevent_detail.html
+++ b/vrobbler/templates/sports/sportevent_detail.html
@ -18,9 +18,9 @@
                    </tr>
                </thead>
                <tbody>
-                    {% for scrobble in object.scrobble_set.all %}
+                    {% for scrobble in scrobbles.all %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                        <td>{{scrobble.media_obj.round.season.name}}</td>
                        <td>{{scrobble.media_obj.round.season.league}}</td>
                    </tr>
--- a/vrobbler/templates/tasks/task_detail.html
+++ b/vrobbler/templates/tasks/task_detail.html
@ -22,6 +22,7 @@
        width: 600px;
        margin-left: 10px;
    }
+    .pagination a { padding: 0 5px 0 5px; }
 </style>
 {% endblock %}

@ -39,7 +40,7 @@
    </div>
 </div>
 <div class="row">
-    <p>{{object.scrobble_set.count}} scrobbles</p>
+    <p>{{scrobbles.count}} scrobbles</p>
    <p>
        <a href="{{object.start_url}}">Play again</a>
    </p>
@ -47,27 +48,49 @@
 <div class="row">
    <div class="col-md">
        <h3>Last scrobbles</h3>
+
        <div class="table-responsive">
            <table class="table table-striped table-sm">
                <thead>
                    <tr>
                        <th scope="col">Date</th>
-                        <th scope="col">Description</th>
+                        <th scope="col">Title</th>
+                        <th scope="col">Notes</th>
                        <th scope="col">Source</th>
                    </tr>
                </thead>
                <tbody>
-                    {% for scrobble in object.scrobble_set.all|dictsortreversed:"timestamp" %}
+                    {% for scrobble in scrobbles.all|dictsortreversed:"timestamp" %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
-                        <td><a href="{{scrobble.get_media_source_url}}">{{scrobble.logdata.description}}</a></td>
+                        <td><a href="{{scrobble.get_absolute_url}}">{{scrobble.local_timestamp}}</a></td>
+                        <td><a href="{{scrobble.get_media_source_url}}">{{scrobble.logdata.title}}</a></td>
+                        <td>{{scrobble.logdata.notes_as_str|safe}}</td>
                        <td>{{scrobble.source}}</td>
-                        <td>{{scrobble.log.notes}}</td>
                    </tr>
                    {% endfor %}
                </tbody>
            </table>
        </div>
    </div>
+
+    {% if is_paginated %}
+    <div class="pagination">
+        {% if page_obj.has_previous %}
+        <a href="?page={{ page_obj.previous_page_number }}">&laquo; Previous</a>
+        {% endif %}
+
+        {% for num in page_obj.paginator.page_range %}
+        {% if num == page_obj.number %}
+            <strong>{{ num }}</strong>
+        {% else %}
+            <a href="?page={{ num }}">{{ num }}</a>
+        {% endif %}
+        {% endfor %}
+
+        {% if page_obj.has_next %}
+        <a href="?page={{ page_obj.next_page_number }}">Next &raquo;</a>
+        {% endif %}
+    </div>
+    {% endif %}
 </div>
 {% endblock %}
--- a/vrobbler/templates/trails/trail_detail.html
+++ b/vrobbler/templates/trails/trail_detail.html
@ -57,7 +57,7 @@
                <tbody>
                    {% for scrobble in object.scrobble_set.all|dictsortreversed:"timestamp" %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                    </tr>
                    {% endfor %}
                </tbody>
--- a/vrobbler/templates/videogames/videogame_detail.html
+++ b/vrobbler/templates/videogames/videogame_detail.html
@ -59,16 +59,9 @@
    </div>
 </div>
 <div class="row">
-    <p>{{object.scrobble_set.count}} scrobbles</p>
-    {% if object.scrobble_set.last.long_play_seconds %}
-    <p>{{object.scrobble_set.last.long_play_seconds|natural_duration}}{% if object.scrobble_set.last.long_play_complete %} and completed{% else %} spent playing{% endif %}</p>
-    {% endif  %}
+    <p>{{scrobbles.count}} scrobbles</p>
    <p>
-        {% if object.scrobble_set.last.long_play_complete == True %}
        <a href="">Play again</a>
-        {% else %}
-        <a href="{{object.start_url}}">Resume playing</a>
-        {% endif %}
    </p>
 </div>
 <div class="row">
@ -86,9 +79,10 @@
                    </tr>
                </thead>
                <tbody>
-                    {% for scrobble in object.scrobble_set.all|dictsortreversed:"timestamp" %}
+                    {% for scrobble in scrobbles.all|dictsortreversed:"timestamp" %}
                    <tr>
-                        <td>{{scrobble.local-timestamp}}</td>
+
+                        <td><a href="{{scrobble.get_absolute_url}}">{{scrobble.local_timestamp}}</a></td>
                        <td>{% if scrobble.long_play_complete == True %}Yes{% else %}Not yet{% endif %}</td>
                        <td>{% if scrobble.in_progress %}Now playing{% else %}{{scrobble.playback_position_seconds|natural_duration}}{% endif %}</td>
                        <td>{% for platform in scrobble.video_game.platforms.all %}<a href="{{platform.get_absolute_url}}">{{platform}}</a>{% if not forloop.last %}, {% endif %}{% endfor %}</td>
--- a/vrobbler/templates/videos/movie_list.html
+++ b/vrobbler/templates/videos/movie_list.html
@ -1,28 +1,32 @@
 {% extends "base_list.html" %}
+{% block title %}Movies{% endblock %}
+{% block head_extra %}
+<style>
+  dl {
+    width: 210px;
+    float: left;
+    margin-right: 10px;
+  }
+  dt a {
+    color: white;
+    text-decoration: none;
+    font-size: smaller;
+  }
+  img {
+    height: 200px;
+    width: 200px;
+    object-fit: cover;
+  }
+  dd .right {
+    float: right;
+  }
+</style>
+{% endblock %}

 {% block lists %}
 <div class="row">
-    <div class="col-md">
-        <div class="table-responsive">
-            <table class="table table-striped table-sm">
-                <thead>
-                    <tr>
-                        <th scope="col">Title</th>
-                        <th scope="col">Scrobbles</th>
-                        <th scope="col">All time</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    {% for obj in object_list %}
-                    <tr>
-                        <td><a href="{{obj.get_absolute_url}}">{{obj}}</a></td>
-                        <td>{{obj.scrobble_set.count}}</td>
-                        <td></td>
-                    </tr>
-                    {% endfor %}
-                </tbody>
-            </table>
-        </div>
-    </div>
+  <div class="col-md">
+    <div class="table-responsive">{% include "_scrobblable_list.html" %}</div>
+  </div>
 </div>
-{% endblock %}
+{% endblock %}
--- a/vrobbler/templates/videos/series_detail.html
+++ b/vrobbler/templates/videos/series_detail.html
@ -60,7 +60,7 @@
                <tbody>
                    {% for scrobble in scrobbles %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                        <td><a href="{{scrobble.media_obj.get_absolute_url}}">{{scrobble.media_obj.title}}</a></td>
                        <td>{{scrobble.media_obj.season_number}}</td>
                        <td>{{scrobble.media_obj.episode_number}}</td>
--- a/vrobbler/templates/videos/series_list.html
+++ b/vrobbler/templates/videos/series_list.html
@ -1,32 +1,32 @@
 {% extends "base_list.html" %}
+{% block title %}Series{% endblock %}
+{% block head_extra %}
+<style>
+  dl {
+    width: 210px;
+    float: left;
+    margin-right: 10px;
+  }
+  dt a {
+    color: white;
+    text-decoration: none;
+    font-size: smaller;
+  }
+  img {
+    height: 200px;
+    width: 200px;
+    object-fit: cover;
+  }
+  dd .right {
+    float: right;
+  }
+</style>
+{% endblock %}

 {% block lists %}
 <div class="row">
-    <div class="col-md">
-        <div class="table-responsive">
-            <table class="table table-striped table-sm">
-                <thead>
-                    <tr>
-                        <th scope="col">Series</th>
-                        <th scope="col">Episode</th>
-                        <th scope="col">Scrobbles</th>
-                        <th scope="col">All time</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    {% for obj in object_list %}
-                    {% for video in obj.video_set.all %}
-                    <tr>
-                        <td><a href="{{video.get_absolute_url}}">{{video}}</a></td>
-                        <td><a href="{{obj.get_absolute_url}}">{{obj}}</a></td>
-                        <td>{{video.scrobble_set.count}}</td>
-                        <td></td>
-                    </tr>
-                    {% endfor %}
-                    {% endfor %}
-                </tbody>
-            </table>
-        </div>
-    </div>
+  <div class="col-md">
+    <div class="table-responsive">{% include "_scrobblable_list.html" %}</div>
+  </div>
 </div>
-{% endblock %}
+{% endblock %}
--- a/vrobbler/templates/videos/video_detail.html
+++ b/vrobbler/templates/videos/video_detail.html
@ -85,9 +85,9 @@ dd {
                    </tr>
                </thead>
                <tbody>
-                    {% for scrobble in object.scrobble_set.all %}
+                    {% for scrobble in scrobbles.all %}
                    <tr>
-                        <td>{{scrobble.local_timestamp}}</td>
+                        <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
                    </tr>
                    {% endfor %}
                </tbody>
--- a/vrobbler/templates/videos/video_list.html
+++ b/vrobbler/templates/videos/video_list.html
@ -0,0 +1,32 @@
+{% extends "base_list.html" %}
+{% block title %}Videos{% endblock %}
+{% block head_extra %}
+<style>
+  dl {
+    width: 210px;
+    float: left;
+    margin-right: 10px;
+  }
+  dt a {
+    color: white;
+    text-decoration: none;
+    font-size: smaller;
+  }
+  img {
+    height: 200px;
+    width: 200px;
+    object-fit: cover;
+  }
+  dd .right {
+    float: right;
+  }
+</style>
+{% endblock %}
+
+{% block lists %}
+<div class="row">
+  <div class="col-md">
+    <div class="table-responsive">{% include "_scrobblable_list.html" %}</div>
+  </div>
+</div>
+{% endblock %}
--- a/vrobbler/templates/webpages/webpage_detail.html
+++ b/vrobbler/templates/webpages/webpage_detail.html
@ -48,12 +48,14 @@
            <thead>
                <tr>
                    <th scope="col">Date</th>
+                    <th scope="col">Notes</th>
                </tr>
            </thead>
            <tbody>
-                {% for scrobble in object.scrobble_set.all %}
+                {% for scrobble in scrobbles.all %}
                <tr>
-                    <td>{{scrobble.local_timestamp}}</td>
+                    <td><a href={{scrobble.get_absolute_url}}>{{scrobble.local_timestamp}}</a></td>
+                    <td>{% for note in scrobble.logdata.notes %}{{note}}{% if not forloop.last %}; {% endif%}{% endfor %}
                </tr>
                {% endfor %}
            </tbody>
--- a/vrobbler/urls.py
+++ b/vrobbler/urls.py
@ -40,11 +40,13 @@ from vrobbler.apps.profiles import urls as profiles_urls
 from vrobbler.apps.trails import urls as trails_urls
 from vrobbler.apps.beers import urls as beers_urls
 from vrobbler.apps.foods import urls as foods_urls
+from vrobbler.apps.puzzles import urls as puzzles_urls
 from vrobbler.apps.videogames import urls as videogame_urls
 from vrobbler.apps.videos import urls as video_urls
 from vrobbler.apps.videos.api.views import SeriesViewSet, VideoViewSet
 from vrobbler.apps.webpages import urls as webpages_urls
-#from vrobbler.apps.modern_ui import urls as modern_ui_urls
+
+# from vrobbler.apps.modern_ui import urls as modern_ui_urls

 router = routers.DefaultRouter()
 router.register(r"scrobbles", ScrobbleViewSet)
@ -73,7 +75,7 @@ urlpatterns = [
    path("admin/", admin.site.urls),
    path("accounts/", include("allauth.urls")),
    path("o/", include(oauth2_urls)),
-    #path("modern_ui/", include(modern_ui_urls, namespace="modern_ui")),
+    # path("modern_ui/", include(modern_ui_urls, namespace="modern_ui")),
    path("", include(music_urls, namespace="music")),
    path("", include(book_urls, namespace="books")),
    path("", include(video_urls, namespace="videos")),
@ -85,6 +87,7 @@ urlpatterns = [
    path("", include(trails_urls, namespace="trails")),
    path("", include(beers_urls, namespace="beers")),
    path("", include(foods_urls, namespace="foods")),
+    path("", include(puzzles_urls, namespace="puzzles")),
    path("", include(tasks_urls, namespace="tasks")),
    path("", include(webpages_urls, namespace="webpages")),
    path("", include(podcast_urls, namespace="podcasts")),
Author	SHA1	Message	Date
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