Bump version to 0.8.3

Fix user timezones in scrobbler files
Bump version to 0.8.2
2023-02-06 23:30:14 -05:00 · 2023-02-06 23:28:57 -05:00 · 2023-02-06 19:32:15 -05:00 · 2023-02-06 19:31:25 -05:00 · 2023-02-06 19:30:58 -05:00 · 2023-02-06 17:54:48 -05:00
121 changed files with 7600 additions and 460 deletions
--- a/.coveragerc
+++ b/.coveragerc
@ -0,0 +1,7 @@
+[run]
+omit=
+  vrobbler/wsgi.py
+  vrobbler/asgi.py
+  vrobbler/cli.py
+  *admin.py
+  migrations/*
--- a/.drone.yml
+++ b/.drone.yml
@ -8,15 +8,15 @@ name: run_tests

 steps:
  # Run tests against Python/Flask engine backend (with pytest)
-  - name: django_tests
+  - name: pytest with coverage
    image: python:3.10.4
    commands:
      # Install dependencies
-      - cp vrobbler.conf.example vrobbler.conf
+      - cp vrobbler.conf.test vrobbler.conf
      - pip install poetry
      - poetry install
      # Start with a fresh database (which is already running as a service from Drone)
-      - poetry run python manage.py test
+      - poetry run pytest --cov-report term:skip-covered --cov=vrobbler tests
    environment:
      VROBBLER_DATABASE_URL: sqlite:///test.db
    volumes:
--- a/.gitignore
+++ b/.gitignore
@ -1,4 +1,5 @@
 db.sqlite3
 vrobbler.conf
-/media/
-/dist/
+media/
+dist/
+.coverage
--- a/README.org
+++ b/README.org
@ -1,4 +1,7 @@
-#+title: Readme
+Vrobbler
+========
+
+[![Build Status](https://ci.unbl.ink/api/badges/secstate/vrobbler/status.svg?ref=refs/heads/main)](https://ci.unbl.ink/secstate/vrobbler)

 Vrobbler is a pretty simple Django-powered web app for scrobbling video plays from you favorite Jellyfin installation.

--- a/envrc.sample
+++ b/envrc.sample
@ -0,0 +1,4 @@
+export ENV_PATH=$(poetry env info --path)
+source "${ENV_PATH}/bin/activate"
+
+export PYPI_PASSWORD="$(pass personal/apikey/pypi)"
--- a/poetry.lock
+++ b/poetry.lock
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vrobbler"
-version = "0.1.5"
+version = "0.8.3"
 description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]

@ -16,7 +16,7 @@ djangorestframework = "^3.13.1"
 Markdown = "^3.3.6"
 django-filter = "^21.1"
 Pillow = "^9.0.1"
-psycopg2 = {version = "^2.9.3", extras = ["production"]}
+psycopg2 = "^2.9.3"
 dj-database-url = "^0.5.0"
 django-mathfilters = "^1.0.0"
 django-allauth = "^0.50.0"
@ -27,24 +27,37 @@ django-markdownify = "^0.9.1"
 gunicorn = "^20.1.0"
 django-simple-history = "^3.1.1"
 whitenoise = "^6.3.0"
+musicbrainzngs = "^0.7.1"
+cinemagoer = "^2022.12.27"
+pysportsdb = "^0.1.0"
+django-cachalot = "^2.5.2"
+pytz = "^2022.7.1"
+django-redis = "^5.2.0"

 [tool.poetry.dev-dependencies]
 Werkzeug = "2.0.3"
 black = "^22.3"
-freezegun = "^1.2"
+coverage = "^7.0.5"
 mypy = "^0.961"
 pytest = "^7.1"
 pytest-black = "^0.3.12"
 pytest-cov = "^3.0"
+pytest-django = "^4.5.2"
 pytest-flake8 = "^1.1"
 pytest-isort = "^3.0"
 pytest-runner = "^6.0"
 pytest-selenium = "^2.0.1"
+time-machine = "^2.9.0"
 types-pytz = "^2022.1"
 types-requests = "^2.27"
-types-freezegun = "^1.1"
 bandit = "^1.7.4"

+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+testpaths = ["tests"]
+DJANGO_SETTINGS_MODULE='vrobbler.settings'
+
 [tool.black]
 line-length = 79
 skip-string-normalization = true
--- a/templates/base.html
+++ b/templates/base.html
@ -1,25 +0,0 @@
-<!doctype html>
-<html class="no-js" lang="">
-    <head>
-        <meta charset="utf-8">
-        <meta http-equiv="x-ua-compatible" content="ie=edge">
-        <title>Untitled</title>
-        <meta name="description" content="">
-        <meta name="viewport" content="width=device-width, initial-scale=1">
-
-        <link rel="apple-touch-icon" href="/apple-touch-icon.png">
-        <!-- Place favicon.ico in the root directory -->
-
-    </head>
-    <body>
-        <!--[if lt IE 8]>
-            <p class="browserupgrade">
-            You are using an <strong>outdated</strong> browser. Please
-            <a href="http://browsehappy.com/">upgrade your browser</a> to improve
-            your experience.
-            </p>
-        <![endif]-->
-
-
-    </body>
-</html>
--- a/tests/scrobbles_tests/init.py
+++ b/tests/scrobbles_tests/init.py
--- a/tests/scrobbles_tests/initpy
+++ b/tests/scrobbles_tests/initpy
--- a/tests/scrobbles_tests/conftest.py
+++ b/tests/scrobbles_tests/conftest.py
@ -0,0 +1,84 @@
+import json
+import pytest
+
+from scrobbles.models import Scrobble
+from rest_framework.authtoken.models import Token
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+
+class MopidyRequest:
+    name = "Same in the End"
+    artist = "Sublime"
+    album = "Sublime"
+    track_number = 4
+    run_time_ticks = 156604
+    run_time = "156"
+    playback_time_ticks = 15045
+    musicbrainz_track_id = "54214d63-5adf-4909-87cd-c65c37a6d558"
+    musicbrainz_album_id = "03b864cd-7761-314c-a892-05a89ddff00d"
+    musicbrainz_artist_id = "95f5b748-d370-47fe-85bd-0af2dc450bc0"
+    mopidy_uri = "local:track:Sublime%20-%20Sublime/Disc%201%20-%2004%20-%20Same%20in%20the%20End.mp3"
+    status = "resumed"
+
+    def __init__(self, **kwargs):
+        self.request_data = {
+            "name": kwargs.get('name', self.name),
+            "artist": kwargs.get("artist", self.artist),
+            "album": kwargs.get("album", self.album),
+            "track_number": int(kwargs.get("track_number", self.track_number)),
+            "run_time_ticks": int(
+                kwargs.get("run_time_ticks", self.run_time_ticks)
+            ),
+            "run_time": int(kwargs.get("run_time", self.run_time)),
+            "playback_time_ticks": int(
+                kwargs.get("playback_time_ticks", self.playback_time_ticks)
+            ),
+            "musicbrainz_track_id": kwargs.get(
+                "musicbrainz_track_id", self.musicbrainz_track_id
+            ),
+            "musicbrainz_album_id": kwargs.get(
+                "musicbrainz_album_id", self.musicbrainz_album_id
+            ),
+            "musicbrainz_artist_id": kwargs.get(
+                "musicbrainz_artist_id", self.musicbrainz_artist_id
+            ),
+            "mopidy_uri": kwargs.get("mopidy_uri", self.mopidy_uri),
+            "status": kwargs.get("status", self.status),
+        }
+
+    def __eq__(self, other):
+        for key in self.request_data.keys():
+            if self.request_data[key] != getattr(self, key):
+                return False
+        return True
+
+    @property
+    def request_json(self):
+        return json.dumps(self.request_data)
+
+
+@pytest.fixture
+def valid_auth_token():
+    user = User.objects.create(email='test@exmaple.com')
+    return Token.objects.create(user=user).key
+
+
+@pytest.fixture
+def mopidy_track_request_data():
+    return MopidyRequest().request_json
+
+
+@pytest.fixture
+def mopidy_track_diff_album_request_data(**kwargs):
+    mb_album_id = "0c56c457-afe1-4679-baab-759ba8dd2a58"
+    return MopidyRequest(
+        album="Gold", musicbrainz_album_id=mb_album_id
+    ).request_json
+
+
+@pytest.fixture
+def mopidy_podcast_request_data():
+    mopidy_uri = "local:podcast:Up%20First/2022-01-01%20Up%20First.mp3"
+    return MopidyRequest(mopidy_uri=mopidy_uri).request_json
--- a/tests/scrobbles_tests/test_aggregators.py
+++ b/tests/scrobbles_tests/test_aggregators.py
@ -0,0 +1,107 @@
+from datetime import datetime, timedelta
+
+import pytest
+import time_machine
+from django.contrib.auth import get_user_model
+from django.urls import reverse
+from django.utils import timezone
+from music.aggregators import (
+    scrobble_counts,
+    top_artists,
+    top_tracks,
+    week_of_scrobbles,
+)
+from profiles.models import UserProfile
+from scrobbles.models import Scrobble
+
+
+def build_scrobbles(client, request_data, num=7, spacing=2):
+    url = reverse('scrobbles:mopidy-websocket')
+    user = get_user_model().objects.create(username='Test User')
+    UserProfile.objects.create(user=user, timezone='US/Eastern')
+    for i in range(num):
+        client.post(url, request_data, content_type='application/json')
+        s = Scrobble.objects.last()
+        s.user = user
+        s.timestamp = timezone.now() - timedelta(days=i * spacing)
+        s.played_to_completion = True
+        s.save()
+
+
+@pytest.mark.django_db
+@time_machine.travel(datetime(2022, 3, 4, 1, 24))
+def test_scrobble_counts_data(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data)
+    user = get_user_model().objects.first()
+    count_dict = scrobble_counts(user)
+    assert count_dict == {
+        'alltime': 7,
+        'month': 2,
+        'today': 1,
+        'week': 3,
+        'year': 7,
+    }
+
+
+@pytest.mark.django_db
+def test_week_of_scrobbles_data(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    week = week_of_scrobbles(user)
+    assert list(week.values()) == [1, 1, 1, 1, 1, 1, 1]
+
+
+@pytest.mark.django_db
+def test_top_tracks_by_day(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = top_tracks(user)
+    assert tops[0].title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_top_tracks_by_week(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = top_tracks(user, filter='week')
+    assert tops[0].title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_top_tracks_by_month(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = top_tracks(user, filter='month')
+    assert tops[0].title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_top_tracks_by_year(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = top_tracks(user, filter='year')
+    assert tops[0].title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_top__artists_by_week(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = top_artists(user, filter='week')
+    assert tops[0].name == "Sublime"
+
+
+@pytest.mark.django_db
+def test_top__artists_by_month(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = top_artists(user, filter='month')
+    assert tops[0].name == "Sublime"
+
+
+@pytest.mark.django_db
+def test_top__artists_by_year(client, mopidy_track_request_data):
+    build_scrobbles(client, mopidy_track_request_data, 7, 1)
+    user = get_user_model().objects.first()
+    tops = top_artists(user, filter='year')
+    assert tops[0].name == "Sublime"
--- a/tests/scrobbles_tests/test_imdb.py
+++ b/tests/scrobbles_tests/test_imdb.py
@ -0,0 +1,12 @@
+import pytest
+import imdb
+from mock import patch
+
+from vrobbler.apps.scrobbles.imdb import lookup_video_from_imdb
+
+
+def test_lookup_imdb_bad_id(caplog):
+    data = lookup_video_from_imdb('3409324')
+    assert data is None
+    assert caplog.records[0].levelname == "WARNING"
+    assert caplog.records[0].msg == "IMDB ID should begin with 'tt' 3409324"
--- a/tests/scrobbles_tests/test_views.py
+++ b/tests/scrobbles_tests/test_views.py
@ -0,0 +1,100 @@
+import json
+import pytest
+
+from django.urls import reverse
+
+from scrobbles.models import Scrobble
+from music.models import Track
+from podcasts.models import Episode
+
+
+@pytest.mark.django_db
+def test_get_not_allowed_from_mopidy(client, valid_auth_token):
+    url = reverse('scrobbles:mopidy-websocket')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.get(url, headers=headers)
+    assert response.status_code == 405
+
+
+@pytest.mark.django_db
+def test_bad_mopidy_request_data(client, valid_auth_token):
+    url = reverse('scrobbles:mopidy-websocket')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.post(url, headers)
+    assert response.status_code == 400
+    assert (
+        response.data['detail']
+        == 'JSON parse error - Expecting value: line 1 column 1 (char 0)'
+    )
+
+
+@pytest.mark.django_db
+def test_scrobble_mopidy_track(
+    client, mopidy_track_request_data, valid_auth_token
+):
+    url = reverse('scrobbles:mopidy-websocket')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.post(
+        url,
+        mopidy_track_request_data,
+        content_type='application/json',
+        headers=headers,
+    )
+    assert response.status_code == 200
+    assert response.data == {'scrobble_id': 1}
+
+    scrobble = Scrobble.objects.get(id=1)
+    assert scrobble.media_obj.__class__ == Track
+    assert scrobble.media_obj.title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_scrobble_mopidy_same_track_different_album(
+    client,
+    mopidy_track_request_data,
+    mopidy_track_diff_album_request_data,
+    valid_auth_token,
+):
+    url = reverse('scrobbles:mopidy-websocket')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.post(
+        url,
+        mopidy_track_request_data,
+        content_type='application/json',
+        headers=headers,
+    )
+    assert response.status_code == 200
+    assert response.data == {'scrobble_id': 1}
+    scrobble = Scrobble.objects.get(id=1)
+    assert scrobble.media_obj.album.name == "Sublime"
+
+    response = client.post(
+        url,
+        mopidy_track_diff_album_request_data,
+        content_type='application/json',
+    )
+
+    scrobble = Scrobble.objects.get(id=2)
+    assert scrobble.media_obj.__class__ == Track
+    assert scrobble.media_obj.album.name == "Gold"
+    assert scrobble.media_obj.title == "Same in the End"
+
+
+@pytest.mark.django_db
+def test_scrobble_mopidy_podcast(
+    client, mopidy_podcast_request_data, valid_auth_token
+):
+    url = reverse('scrobbles:mopidy-websocket')
+    headers = {'Authorization': f'Token {valid_auth_token}'}
+    response = client.post(
+        url,
+        mopidy_podcast_request_data,
+        content_type='application/json',
+        headers=headers,
+    )
+    assert response.status_code == 200
+    assert response.data == {'scrobble_id': 1}
+
+    scrobble = Scrobble.objects.get(id=1)
+    assert scrobble.media_obj.__class__ == Episode
+    assert scrobble.media_obj.title == "Up First"
--- a/todos.org
+++ b/todos.org
@ -0,0 +1,380 @@
+#+title: TODOs
+
+A fun way to keep track of things in the project to fix or improve.
+
+* DONE [#A] Fix fetching artwork without release group :bug:
+CLOSED: [2023-01-29 Sun 14:27]
+
+When we get artwork from Musicbrianz, and it's not found, we should check for
+release groups as well. This will stop issues with missing artwork because of
+obscure MB release matches.
+
+* DONE [#A] Fix Jellyfin music scrobbling N+1 past 90 completion percent :bug:
+CLOSED: [2023-01-30 Mon 18:31]
+:LOGBOOK:
+CLOCK: [2023-01-30 Mon 18:00]--[2023-01-30 Mon 18:31] =>  0:31
+:END:
+
+If we play music from Jellyfin and the track reaches 90% completion, the
+scrobbling goes crazy and starts creating new scrobbles with every update.
+
+The cause is pretty simple, but the solution is hard. We want to mark a scrobble
+as complete for the following conditions:
+
+- Play stopped and percent played beyond 90%
+- Play completely finished
+
+But if we keep listening beyond 90, we should basically ignore updates (or just
+update the existing scrobble)
+* DONE [#A] Add support for Audioscrobbler tab-separated file uploads :improvement:
+CLOSED: [2023-02-03 Fri 16:52]
+
+An example of the format:
+#+begin_src csv
+,
+#AUDIOSCROBBLER/1.1
+#TZ/UNKNOWN
+#CLIENT/Rockbox sansaclipplus $Revision$
+75 Dollar Bill	I Was Real	I Was Real	4	1015	S	1740494944	64ff5f53-d187-4512-827e-7606c69e66ff
+75 Dollar Bill	I Was Real	I Was Real	4	1015	S	1740494990	64ff5f53-d187-4512-827e-7606c69e66ff
+311	311	Down	1	173	S	1740495003	00476c23-fd9e-464b-9b27-a62d69f3d4f4
+311	311	Down	1	173	L	1740495049	00476c23-fd9e-464b-9b27-a62d69f3d4f4
+311	311	Down	1	173	L	1740495113	00476c23-fd9e-464b-9b27-a62d69f3d4f4
+311	311	Random	2	187	S	1740495190	530c09f3-46fe-4d90-b11f-7b63bcb4b373
+311	311	Random	2	187	L	1740495194	530c09f3-46fe-4d90-b11f-7b63bcb4b373
+311	311	Jackolantern’s Weather	3	204	L	1740495382	cc3b2dec-5d99-47ea-8930-20bf258be4ea
+311	311	All Mixed Up	4	182	L	1740495586	980a78b5-5bdd-4f50-9e3a-e13261e2817b
+311	311	Hive	5	179	L	1740495768	18f6dc98-d3a2-4f81-b967-97359d14c68c
+311	311	Guns (Are for Pussies)	6	137	L	1740495948	5e97ed9f-c8cc-4282-9cbe-f8e17aee5128
+311	311	Misdirected Hostility	7	179	S	1740496085	61ff2c1a-fc9c-44c3-8da1-5e50a44245af
+,
+#+end_src
+* TODO [#A] Add ability to manually scrobble albums or tracks from MB :improvement:
+
+Given a UUID from musicbrainz, we should be able to scrobble an album or
+individual track.
+
+* TODO [#A] Add django-storage to store files on S3 :improvement:
+* TODO [#B] Adjust cancel/finish task to use javascript to submit :improvement:
+* TODO [#B] Implement a detail view for TV shows :improvement:
+* TODO [#B] Implement a detail view for Moviews :improvement:
+* TODO [#B] Allow scrobbling music without MB IDs by grabbing them before scrobble :improvement:
+
+This would allow a few nice flows. One, you'd be able to record the play of an
+entire album by just dropping the muscibrainz_id in. This could be helpful for
+offline listening. It would also mean bad metadata from mopidy would not break
+scrobbling.
+* TODO [#C] Implement keeping track of week/month/year chart-toppers :improvement:
+:LOGBOOK:
+CLOCK: [2023-01-30 Mon 16:30]--[2023-01-30 Mon 18:00] =>  1:30
+:END:
+
+Maloja does this cool thing where artists and tracks get recorded as the top
+track of a given week, month or year. They get gold, silver or bronze stars for
+their place in the time period.
+
+I could see this being implemented as a separate Chart table which gets
+populated at the end of a time period and has a start and end date that defines
+a period, along with a one, two, three instance.
+
+Of course, it could also be a data model without a table, where it runs some fun
+calculations, stores it's values in Redis as a long-term lookup table and just
+has to re-populate when the server restarts.
+* TODO [#C] Move to using more robust mopidy-webhooks pacakge form pypi :improvement:
+** Example payloads from mopidy-webhooks
+*** Podcast playback ended
+#+begin_src json
+{
+    "type": "event",
+    "event": "track_playback_ended",
+    "data": {
+        "tl_track": {
+            "__model__": "TlTrack",
+            "tlid": 13,
+            "track": {
+                "__model__": "Track",
+                "uri": "file:///var/lib/mopidy/media/podcasts/The%20Prince/2022-09-28-Wolf-warriors.mp3",
+                "name": "Wolf warriors",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "name": "The Economist"
+                    }
+                ],
+                "album": {
+                    "__model__": "Album",
+                    "name": "The Prince",
+                    "date": "2022"
+                },
+                "genre": "Blues",
+                "date": "2022",
+                "length": 2437778,
+                "bitrate": 127988
+            }
+        },
+        "time_position": 3290
+    }
+}
+#+end_src
+*** Podcast playback state changes
+#+begin_src json
+{
+    "type": "event",
+    "event": "playback_state_changed",
+    "data": {
+        "old_state": "paused",
+        "new_state": "playing"
+    }
+}
+#+end_src
+
+#+begin_src json
+{
+    "type": "event",
+    "event": "playback_state_changed",
+    "data": {
+        "old_state": "stopped",
+        "new_state": "playing"
+    }
+}
+#+end_src
+*** Podcast playback started
+#+begin_src json
+{
+    "type": "event",
+    "event": "track_playback_started",
+    "data": {
+        "tl_track": {
+            "__model__": "TlTrack",
+            "tlid": 13,
+            "track": {
+                "__model__": "Track",
+                "uri": "file:///var/lib/mopidy/media/podcasts/The%20Prince/2022-09-28-Wolf-warriors.mp3",
+                "name": "Wolf warriors",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "name": "The Economist"
+                    }
+                ],
+                "album": {
+                    "__model__": "Album",
+                    "name": "The Prince",
+                    "date": "2022"
+                },
+                "genre": "Blues",
+                "date": "2022",
+                "length": 2437778,
+                "bitrate": 127988
+            }
+        }
+    }
+}
+#+end_src
+*** Podcast playback paused
+#+begin_src  json
+{
+    "type": "status",
+    "data": {
+        "state": "paused",
+        "current_track": {
+            "__model__": "Track",
+            "uri": "file:///var/lib/mopidy/media/podcasts/The%20Prince/2022-09-28-Wolf-warriors.mp3",
+            "name": "Wolf warriors",
+            "artists": [
+                {
+                    "__model__": "Artist",
+                    "name": "The Economist"
+                }
+            ],
+            "album": {
+                "__model__": "Album",
+                "name": "The Prince",
+                "date": "2022"
+            },
+            "genre": "Blues",
+            "date": "2022",
+            "length": 2437778,
+            "bitrate": 127988
+        },
+        "time_position": 2350
+    }
+}
+
+#+end_src
+*** Track playback started
+#+begin_src json
+{
+    "type": "event",
+    "event": "track_playback_started",
+    "data": {
+        "tl_track": {
+            "__model__": "TlTrack",
+            "tlid": 14,
+            "track": {
+                "__model__": "Track",
+                "uri": "local:track:Various%20Artists%20-%202008%20-%20Twilight%20OST/01-muse-supermassive_black_hole.mp3",
+                "name": "Supermassive Black Hole",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:250dd6551b66a58a6b4897aa697f200c",
+                        "name": "Muse",
+                        "musicbrainz_id": "9c9f1380-2516-4fc9-a3e6-f9f61941d090"
+                    }
+                ],
+                "album": {
+                    "__model__": "Album",
+                    "uri": "local:album:md5:455343d54cdd89cb5a3b5ad537ea99d0",
+                    "name": "Twilight: Original Motion Picture Soundtrack",
+                    "artists": [
+                        {
+                            "__model__": "Artist",
+                            "uri": "local:artist:md5:54e4db2d5624f80b0cc290346e696756",
+                            "name": "Various Artists",
+                            "musicbrainz_id": "89ad4ac3-39f7-470e-963a-56509c546377"
+                        }
+                    ],
+                    "num_tracks": 12,
+                    "num_discs": 1,
+                    "date": "2008-11-04",
+                    "musicbrainz_id": "b4889eaf-d9f4-434c-a68d-69227b12b6a4"
+                },
+                "composers": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:4d49cbca0b347e0a89047bb019d2779d",
+                        "name": "Matt Bellamy"
+                    }
+                ],
+                "genre": "Rock",
+                "track_no": 1,
+                "disc_no": 1,
+                "date": "2008-11-04",
+                "length": 211121,
+                "musicbrainz_id": "ff1e3e1a-f6e8-4692-b426-355880383bb6",
+                "last_modified": 1672712949510
+            }
+        }
+    }
+}
+#+end_src
+*** Track playback in progress
+#+begin_src json
+{
+    "type": "status",
+    "data": {
+        "state": "playing",
+        "current_track": {
+            "__model__": "Track",
+            "uri": "local:track:Various%20Artists%20-%202008%20-%20Twilight%20OST/01-muse-supermassive_black_hole.mp3",
+            "name": "Supermassive Black Hole",
+            "artists": [
+                {
+                    "__model__": "Artist",
+                    "uri": "local:artist:md5:250dd6551b66a58a6b4897aa697f200c",
+                    "name": "Muse",
+                    "musicbrainz_id": "9c9f1380-2516-4fc9-a3e6-f9f61941d090"
+                }
+            ],
+            "album": {
+                "__model__": "Album",
+                "uri": "local:album:md5:455343d54cdd89cb5a3b5ad537ea99d0",
+                "name": "Twilight: Original Motion Picture Soundtrack",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:54e4db2d5624f80b0cc290346e696756",
+                        "name": "Various Artists",
+                        "musicbrainz_id": "89ad4ac3-39f7-470e-963a-56509c546377"
+                    }
+                ],
+                "num_tracks": 12,
+                "num_discs": 1,
+                "date": "2008-11-04",
+                "musicbrainz_id": "b4889eaf-d9f4-434c-a68d-69227b12b6a4"
+            },
+            "composers": [
+                {
+                    "__model__": "Artist",
+                    "uri": "local:artist:md5:4d49cbca0b347e0a89047bb019d2779d",
+                    "name": "Matt Bellamy"
+                }
+            ],
+            "genre": "Rock",
+            "track_no": 1,
+            "disc_no": 1,
+            "date": "2008-11-04",
+            "length": 211121,
+            "musicbrainz_id": "ff1e3e1a-f6e8-4692-b426-355880383bb6",
+            "last_modified": 1672712949510
+        },
+        "time_position": 17031
+    }
+}
+#+end_src
+*** Track event playback paused
+#+begin_src json
+{
+    "type": "event",
+    "event": "track_playback_paused",
+    "data": {
+        "tl_track": {
+            "__model__": "TlTrack",
+            "tlid": 14,
+            "track": {
+                "__model__": "Track",
+                "uri": "local:track:Various%20Artists%20-%202008%20-%20Twilight%20OST/01-muse-supermassive_black_hole.mp3",
+                "name": "Supermassive Black Hole",
+                "artists": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:250dd6551b66a58a6b4897aa697f200c",
+                        "name": "Muse",
+                        "musicbrainz_id": "9c9f1380-2516-4fc9-a3e6-f9f61941d090"
+                    }
+                ],
+                "album": {
+                    "__model__": "Album",
+                    "uri": "local:album:md5:455343d54cdd89cb5a3b5ad537ea99d0",
+                    "name": "Twilight: Original Motion Picture Soundtrack",
+                    "artists": [
+                        {
+                            "__model__": "Artist",
+                            "uri": "local:artist:md5:54e4db2d5624f80b0cc290346e696756",
+                            "name": "Various Artists",
+                            "musicbrainz_id": "89ad4ac3-39f7-470e-963a-56509c546377"
+                        }
+                    ],
+                    "num_tracks": 12,
+                    "num_discs": 1,
+                    "date": "2008-11-04",
+                    "musicbrainz_id": "b4889eaf-d9f4-434c-a68d-69227b12b6a4"
+                },
+                "composers": [
+                    {
+                        "__model__": "Artist",
+                        "uri": "local:artist:md5:4d49cbca0b347e0a89047bb019d2779d",
+                        "name": "Matt Bellamy"
+                    }
+                ],
+                "genre": "Rock",
+                "track_no": 1,
+                "disc_no": 1,
+                "date": "2008-11-04",
+                "length": 211121,
+                "musicbrainz_id": "ff1e3e1a-f6e8-4692-b426-355880383bb6",
+                "last_modified": 1672712949510
+            }
+        },
+        "time_position": 67578
+    }
+}
+#+end_src
+* TODO [#C] Consider a purge command for duplicated and stuck in-progress scrobbles :improvement:
+* TODO Figure out how to add to web-scrobbler :imropvement:
+
+An example:
+https://github.com/web-scrobbler/web-scrobbler/blob/master/src/core/background/scrobbler/maloja-scrobbler.js
+
+* TODO When updating musicbrainz IDs, clear and run fetch artwrok :improvement:
--- a/vrobbler.conf.test
+++ b/vrobbler.conf.test
@ -0,0 +1,8 @@
+# Local configuration for Emus
+
+VROBBLER_DUMP_REQUEST_DATA=True
+VROBBLER_LOG_TO_CONSOLE=True
+VROBBLER_DEBUG=True
+VROBBLER_LOG_LEVEL="DEBUG"
+VROBBLER_MEDIA_ROOT = "/tmp/media/"
+VROBBLER_KEEP_DETAILED_SCROBBLE_LOGS=True
--- a/vrobbler/apps/music/init.py
+++ b/vrobbler/apps/music/init.py
--- a/vrobbler/apps/music/admin.py
+++ b/vrobbler/apps/music/admin.py
@ -0,0 +1,40 @@
+from django.contrib import admin
+
+from music.models import Artist, Album, Track
+
+from scrobbles.admin import ScrobbleInline
+
+
+@admin.register(Album)
+class AlbumAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name", "year", "musicbrainz_id")
+    list_filter = ("year",)
+    ordering = ("name",)
+    filter_horizontal = [
+        'artists',
+    ]
+
+
+@admin.register(Artist)
+class ArtistAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name", "musicbrainz_id")
+    ordering = ("name",)
+
+
+@admin.register(Track)
+class TrackAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = (
+        "title",
+        "album",
+        "artist",
+        "run_time",
+        "musicbrainz_id",
+    )
+    list_filter = ("album", "artist")
+    ordering = ("-created",)
+    inlines = [
+        ScrobbleInline,
+    ]
--- a/vrobbler/apps/music/aggregators.py
+++ b/vrobbler/apps/music/aggregators.py
@ -0,0 +1,151 @@
+from datetime import datetime, timedelta
+from typing import List, Optional
+
+import pytz
+from django.db.models import Count, Q, Sum
+from django.utils import timezone
+from music.models import Artist, Track
+from scrobbles.models import Scrobble
+from videos.models import Video
+from vrobbler.apps.profiles.utils import now_user_timezone
+
+NOW = timezone.now()
+START_OF_TODAY = datetime.combine(NOW.date(), datetime.min.time(), NOW.tzinfo)
+STARTING_DAY_OF_CURRENT_WEEK = NOW.date() - timedelta(
+    days=NOW.today().isoweekday() % 7
+)
+STARTING_DAY_OF_CURRENT_MONTH = NOW.date().replace(day=1)
+STARTING_DAY_OF_CURRENT_YEAR = NOW.date().replace(month=1, day=1)
+
+
+def scrobble_counts(user=None):
+
+    now = timezone.now()
+    user_filter = Q()
+    if user and user.is_authenticated:
+        now = now_user_timezone(user.profile)
+        user_filter = Q(user=user)
+
+    start_of_today = datetime.combine(
+        now.date(), datetime.min.time(), now.tzinfo
+    )
+    starting_day_of_current_week = now.date() - timedelta(
+        days=now.today().isoweekday() % 7
+    )
+    starting_day_of_current_month = now.date().replace(day=1)
+    starting_day_of_current_year = now.date().replace(month=1, day=1)
+
+    finished_scrobbles_qs = Scrobble.objects.filter(
+        user_filter, played_to_completion=True
+    )
+    data = {}
+    data['today'] = finished_scrobbles_qs.filter(
+        timestamp__gte=start_of_today
+    ).count()
+    data['week'] = finished_scrobbles_qs.filter(
+        timestamp__gte=starting_day_of_current_week
+    ).count()
+    data['month'] = finished_scrobbles_qs.filter(
+        timestamp__gte=starting_day_of_current_month
+    ).count()
+    data['year'] = finished_scrobbles_qs.filter(
+        timestamp__gte=starting_day_of_current_year
+    ).count()
+    data['alltime'] = finished_scrobbles_qs.count()
+    return data
+
+
+def week_of_scrobbles(user=None, media: str = 'tracks') -> dict[str, int]:
+
+    now = timezone.now()
+    user_filter = Q()
+    if user and user.is_authenticated:
+        now = now_user_timezone(user.profile)
+        user_filter = Q(user=user)
+
+    start_of_today = datetime.combine(
+        now.date(), datetime.min.time(), now.tzinfo
+    )
+
+    scrobble_day_dict = {}
+    base_qs = Scrobble.objects.filter(user_filter, played_to_completion=True)
+
+    media_filter = Q(track__isnull=False)
+    if media == 'movies':
+        media_filter = Q(video__video_type=Video.VideoType.MOVIE)
+    if media == 'series':
+        media_filter = Q(video__video_type=Video.VideoType.TV_EPISODE)
+
+    for day in range(6, -1, -1):
+        start = start_of_today - timedelta(days=day)
+        end = datetime.combine(start, datetime.max.time(), now.tzinfo)
+        day_of_week = start.strftime('%A')
+
+        scrobble_day_dict[day_of_week] = base_qs.filter(
+            media_filter,
+            timestamp__gte=start,
+            timestamp__lte=end,
+            played_to_completion=True,
+        ).count()
+
+    return scrobble_day_dict
+
+
+def top_tracks(
+    user: "User", filter: str = "today", limit: int = 15
+) -> List["Track"]:
+
+    now = timezone.now()
+    if user.is_authenticated:
+        now = now_user_timezone(user.profile)
+
+    start_of_today = datetime.combine(
+        now.date(), datetime.min.time(), now.tzinfo
+    )
+    starting_day_of_current_week = now.date() - timedelta(
+        days=now.today().isoweekday() % 7
+    )
+    starting_day_of_current_month = now.date().replace(day=1)
+    starting_day_of_current_year = now.date().replace(month=1, day=1)
+
+    time_filter = Q(scrobble__timestamp__gte=start_of_today)
+    if filter == "week":
+        time_filter = Q(scrobble__timestamp__gte=starting_day_of_current_week)
+    if filter == "month":
+        time_filter = Q(scrobble__timestamp__gte=starting_day_of_current_month)
+    if filter == "year":
+        time_filter = Q(scrobble__timestamp__gte=starting_day_of_current_year)
+
+    return (
+        Track.objects.filter(time_filter)
+        .annotate(num_scrobbles=Count("scrobble", distinct=True))
+        .order_by("-num_scrobbles")[:limit]
+    )
+
+
+def top_artists(
+    user: "User", filter: str = "today", limit: int = 15
+) -> List["Artist"]:
+    time_filter = Q(track__scrobble__timestamp__gte=START_OF_TODAY)
+    if filter == "week":
+        time_filter = Q(
+            track__scrobble__timestamp__gte=STARTING_DAY_OF_CURRENT_WEEK
+        )
+    if filter == "month":
+        time_filter = Q(
+            track__scrobble__timestamp__gte=STARTING_DAY_OF_CURRENT_MONTH
+        )
+    if filter == "year":
+        time_filter = Q(
+            track__scrobble__timestamp__gte=STARTING_DAY_OF_CURRENT_YEAR
+        )
+
+    return (
+        Artist.objects.filter(time_filter)
+        .annotate(num_scrobbles=Count("track__scrobble", distinct=True))
+        .order_by("-num_scrobbles")[:limit]
+    )
+
+
+def artist_scrobble_count(artist_id: int, filter: str = "today") -> int:
+    return Scrobble.objects.filter(track__artist=artist_id).count()
--- a/vrobbler/apps/music/apps.py
+++ b/vrobbler/apps/music/apps.py
@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class MusicConfig(AppConfig):
+    name = 'music'
--- a/vrobbler/apps/music/constants.py
+++ b/vrobbler/apps/music/constants.py
@ -0,0 +1,16 @@
+JELLYFIN_POST_KEYS = {
+    'ITEM_TYPE': 'ItemType',
+    'RUN_TIME_TICKS': 'RunTimeTicks',
+    'RUN_TIME': 'RunTime',
+    'TITLE': 'Name',
+    'TIMESTAMP': 'UtcTimestamp',
+    'YEAR': 'Year',
+    'PLAYBACK_POSITION_TICKS': 'PlaybackPositionTicks',
+    'PLAYBACK_POSITION': 'PlaybackPosition',
+    'ARTIST_MB_ID': 'Provider_musicbrainzartist',
+    'ALBUM_MB_ID': 'Provider_musicbrainzalbum',
+    'RELEASEGROUP_MB_ID': 'Provider_musicbrainzreleasegroup',
+    'TRACK_MB_ID': 'Provider_musicbrainztrack',
+    'ALBUM_NAME': 'Album',
+    'ARTIST_NAME': 'Artist',
+}
--- a/vrobbler/apps/music/context_processors.py
+++ b/vrobbler/apps/music/context_processors.py
@ -0,0 +1,8 @@
+from music.models import Artist, Album
+
+
+def music_lists(request):
+    return {
+        "artist_list": Artist.objects.all(),
+        "album_list": Album.objects.all(),
+    }
--- a/vrobbler/apps/music/migrations/0001_initial.py
+++ b/vrobbler/apps/music/migrations/0001_initial.py
@ -0,0 +1,156 @@
+# Generated by Django 4.1.5 on 2023-01-07 19:37
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name='Album',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                ('year', models.IntegerField()),
+                (
+                    'musicbrainz_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'musicbrainz_releasegroup_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'musicbrainz_albumartist_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Artist',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'musicbrainz_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Track',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                (
+                    'title',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'musicbrainz_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'run_time',
+                    models.CharField(blank=True, max_length=8, null=True),
+                ),
+                (
+                    'run_time_ticks',
+                    models.PositiveBigIntegerField(blank=True, null=True),
+                ),
+                (
+                    'album',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='music.album',
+                    ),
+                ),
+                (
+                    'artist',
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='music.artist',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0002_alter_album_year.py
+++ b/vrobbler/apps/music/migrations/0002_alter_album_year.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-01-08 01:25
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='album',
+            name='year',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0003_album_uuid_artist_uuid_track_uuid.py
+++ b/vrobbler/apps/music/migrations/0003_album_uuid_artist_uuid_track_uuid.py
@ -0,0 +1,35 @@
+# Generated by Django 4.1.5 on 2023-01-08 21:31
+
+from django.db import migrations, models
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0002_alter_album_year'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='album',
+            name='uuid',
+            field=models.UUIDField(
+                blank=True, default=uuid.uuid4, editable=False, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name='artist',
+            name='uuid',
+            field=models.UUIDField(
+                blank=True, default=uuid.uuid4, editable=False, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name='track',
+            name='uuid',
+            field=models.UUIDField(
+                blank=True, default=uuid.uuid4, editable=False, null=True
+            ),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0004_alter_artist_options_alter_album_musicbrainz_id_and_more.py
+++ b/vrobbler/apps/music/migrations/0004_alter_artist_options_alter_album_musicbrainz_id_and_more.py
@ -0,0 +1,35 @@
+# Generated by Django 4.1.5 on 2023-01-11 03:13
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0003_album_uuid_artist_uuid_track_uuid'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='artist',
+            options={},
+        ),
+        migrations.AlterField(
+            model_name='album',
+            name='musicbrainz_id',
+            field=models.CharField(
+                blank=True, max_length=255, null=True, unique=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name='track',
+            name='musicbrainz_id',
+            field=models.CharField(
+                blank=True, max_length=255, null=True, unique=True
+            ),
+        ),
+        migrations.AlterUniqueTogether(
+            name='artist',
+            unique_together={('name', 'musicbrainz_id')},
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0005_album_cover_image.py
+++ b/vrobbler/apps/music/migrations/0005_album_cover_image.py
@ -0,0 +1,23 @@
+# Generated by Django 4.1.5 on 2023-01-12 04:22
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        (
+            'music',
+            '0004_alter_artist_options_alter_album_musicbrainz_id_and_more',
+        ),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='album',
+            name='cover_image',
+            field=models.ImageField(
+                blank=True, null=True, upload_to='albums/'
+            ),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0006_album_artists.py
+++ b/vrobbler/apps/music/migrations/0006_album_artists.py
@ -0,0 +1,20 @@
+# Generated by Django 4.1.5 on 2023-01-12 05:04
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0005_album_cover_image'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='album',
+            name='artists',
+            field=models.ManyToManyField(
+                blank=True, null=True, to='music.artist'
+            ),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0007_alter_album_artists.py
+++ b/vrobbler/apps/music/migrations/0007_alter_album_artists.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-01-12 17:17
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0006_album_artists'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='album',
+            name='artists',
+            field=models.ManyToManyField(to='music.artist'),
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0008_alter_track_options.py
+++ b/vrobbler/apps/music/migrations/0008_alter_track_options.py
@ -0,0 +1,17 @@
+# Generated by Django 4.1.5 on 2023-01-13 01:47
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0007_alter_album_artists'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='track',
+            options={},
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/0009_alter_track_musicbrainz_id_and_more.py
+++ b/vrobbler/apps/music/migrations/0009_alter_track_musicbrainz_id_and_more.py
@ -0,0 +1,22 @@
+# Generated by Django 4.1.5 on 2023-01-19 20:03
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0008_alter_track_options'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='track',
+            name='musicbrainz_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AlterUniqueTogether(
+            name='track',
+            unique_together={('album', 'musicbrainz_id')},
+        ),
+    ]
--- a/vrobbler/apps/music/migrations/init.py
+++ b/vrobbler/apps/music/migrations/init.py
--- a/vrobbler/apps/music/models.py
+++ b/vrobbler/apps/music/models.py
@ -0,0 +1,197 @@
+import logging
+from typing import Dict, Optional
+from uuid import uuid4
+
+import musicbrainzngs
+from django.conf import settings
+from django.core.files.base import ContentFile
+from django.db import models
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+from django_extensions.db.models import TimeStampedModel
+from scrobbles.mixins import ScrobblableMixin
+
+logger = logging.getLogger(__name__)
+BNULL = {"blank": True, "null": True}
+
+
+class Artist(TimeStampedModel):
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+    name = models.CharField(max_length=255)
+    musicbrainz_id = models.CharField(max_length=255, **BNULL)
+
+    class Meta:
+        unique_together = [['name', 'musicbrainz_id']]
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def mb_link(self):
+        return f"https://musicbrainz.org/artist/{self.musicbrainz_id}"
+
+    def get_absolute_url(self):
+        return reverse('music:artist_detail', kwargs={'slug': self.uuid})
+
+    def scrobbles(self):
+        from scrobbles.models import Scrobble
+
+        return Scrobble.objects.filter(
+            track__in=self.track_set.all()
+        ).order_by('-timestamp')
+
+    @property
+    def tracks(self):
+        return (
+            self.track_set.all()
+            .annotate(scrobble_count=models.Count('scrobble'))
+            .order_by('-scrobble_count')
+        )
+
+    def charts(self):
+        from scrobbles.models import ChartRecord
+
+        return ChartRecord.objects.filter(track__artist=self).order_by('-year')
+
+
+class Album(TimeStampedModel):
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+    name = models.CharField(max_length=255)
+    artists = models.ManyToManyField(Artist)
+    year = models.IntegerField(**BNULL)
+    musicbrainz_id = models.CharField(max_length=255, unique=True, **BNULL)
+    musicbrainz_releasegroup_id = models.CharField(max_length=255, **BNULL)
+    musicbrainz_albumartist_id = models.CharField(max_length=255, **BNULL)
+    cover_image = models.ImageField(upload_to="albums/", **BNULL)
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def primary_artist(self):
+        return self.artists.first()
+
+    def fix_metadata(self):
+        if not self.musicbrainz_albumartist_id or not self.year:
+            musicbrainzngs.set_useragent('vrobbler', '0.3.0')
+            mb_data = musicbrainzngs.get_release_by_id(
+                self.musicbrainz_id, includes=['artists']
+            )
+            if not self.musicbrainz_albumartist_id:
+                self.musicbrainz_albumartist_id = mb_data['release'][
+                    'artist-credit'
+                ][0]['artist']['id']
+            if not self.year:
+                try:
+                    self.year = mb_data['release']['date'][0:4]
+                except KeyError:
+                    pass
+                except IndexError:
+                    pass
+
+            self.save(update_fields=['musicbrainz_albumartist_id', 'year'])
+
+            new_artist = Artist.objects.filter(
+                musicbrainz_id=self.musicbrainz_albumartist_id
+            ).first()
+            if self.musicbrainz_albumartist_id and new_artist:
+                self.artists.add(new_artist)
+            if not new_artist:
+                for t in self.track_set.all():
+                    self.artists.add(t.artist)
+
+    def fetch_artwork(self, force=False):
+        if not self.cover_image and not force:
+            if self.musicbrainz_id:
+                try:
+                    img_data = musicbrainzngs.get_image_front(
+                        self.musicbrainz_id
+                    )
+                    name = f"{self.name}_{self.uuid}.jpg"
+                    self.cover_image = ContentFile(img_data, name=name)
+                    logger.info(f'Setting image to {name}')
+                except musicbrainzngs.ResponseError:
+                    logger.warning(
+                        f'No cover art found for {self.name} by release'
+                    )
+
+            if not self.cover_image and self.musicbrainz_releasegroup_id:
+                try:
+                    img_data = musicbrainzngs.get_release_group_image_front(
+                        self.musicbrainz_releasegroup_id
+                    )
+                    name = f"{self.name}_{self.uuid}.jpg"
+                    self.cover_image = ContentFile(img_data, name=name)
+                    logger.info(f'Setting image to {name}')
+                except musicbrainzngs.ResponseError:
+                    logger.warning(
+                        f'No cover art found for {self.name} by release group'
+                    )
+            if not self.cover_image:
+                logger.debug(
+                    f"No cover art found for release or release group for {self.name}, setting to default"
+                )
+                # TODO Get a placeholder image in here
+                self.cover_image = 'default-image-replace-me'
+            self.save()
+
+    @property
+    def mb_link(self):
+        return f"https://musicbrainz.org/release/{self.musicbrainz_id}"
+
+
+class Track(ScrobblableMixin):
+    COMPLETION_PERCENT = getattr(settings, 'MUSIC_COMPLETION_PERCENT', 90)
+
+    class Opinion(models.IntegerChoices):
+        DOWN = -1, 'Thumbs down'
+        NEUTRAL = 0, 'No opinion'
+        UP = 1, 'Thumbs up'
+
+    artist = models.ForeignKey(Artist, on_delete=models.DO_NOTHING)
+    album = models.ForeignKey(Album, on_delete=models.DO_NOTHING, **BNULL)
+    musicbrainz_id = models.CharField(max_length=255, **BNULL)
+
+    class Meta:
+        unique_together = [['album', 'musicbrainz_id']]
+
+    def __str__(self):
+        return f"{self.title} by {self.artist}"
+
+    def get_absolute_url(self):
+        return reverse('music:track_detail', kwargs={'slug': self.uuid})
+
+    @property
+    def mb_link(self):
+        return f"https://musicbrainz.org/recording/{self.musicbrainz_id}"
+
+    @classmethod
+    def find_or_create(
+        cls, artist_dict: Dict, album_dict: Dict, track_dict: Dict
+    ) -> Optional["Track"]:
+        """Given a data dict from Jellyfin, does the heavy lifting of looking up
+        the video and, if need, TV Series, creating both if they don't yet
+        exist.
+
+        """
+        if not artist_dict.get('name') or not artist_dict.get(
+            'musicbrainz_id'
+        ):
+            logger.warning(
+                f"No artist or artist musicbrainz ID found in message from source, not scrobbling"
+            )
+            return
+
+        artist, artist_created = Artist.objects.get_or_create(**artist_dict)
+        album, album_created = Album.objects.get_or_create(**album_dict)
+
+        album.fix_metadata()
+        if not album.cover_image:
+            album.fetch_artwork()
+
+        track_dict['album_id'] = getattr(album, "id", None)
+        track_dict['artist_id'] = artist.id
+
+        track, created = cls.objects.get_or_create(**track_dict)
+
+        return track
--- a/vrobbler/apps/music/urls.py
+++ b/vrobbler/apps/music/urls.py
@ -0,0 +1,21 @@
+from django.urls import path
+from music import views
+
+app_name = 'music'
+
+
+urlpatterns = [
+    path('albums/', views.AlbumListView.as_view(), name='albums_list'),
+    path("tracks/", views.TrackListView.as_view(), name='tracks_list'),
+    path(
+        'tracks/<slug:slug>/',
+        views.TrackDetailView.as_view(),
+        name='track_detail',
+    ),
+    path('artists/', views.ArtistListView.as_view(), name='artist_list'),
+    path(
+        'artists/<slug:slug>/',
+        views.ArtistDetailView.as_view(),
+        name='artist_detail',
+    ),
+]
--- a/vrobbler/apps/music/views.py
+++ b/vrobbler/apps/music/views.py
@ -0,0 +1,33 @@
+from django.views import generic
+from music.models import Track, Artist, Album
+from scrobbles.stats import get_scrobble_count_qs
+
+
+class TrackListView(generic.ListView):
+    model = Track
+
+    def get_queryset(self):
+        return get_scrobble_count_qs(user=self.request.user).order_by(
+            "-scrobble_count"
+        )
+
+
+class TrackDetailView(generic.DetailView):
+    model = Track
+    slug_field = 'uuid'
+
+
+class ArtistListView(generic.ListView):
+    model = Artist
+
+    def get_queryset(self):
+        return super().get_queryset().order_by("name")
+
+
+class ArtistDetailView(generic.DetailView):
+    model = Artist
+    slug_field = 'uuid'
+
+
+class AlbumListView(generic.ListView):
+    model = Album
--- a/vrobbler/apps/podcasts/init.py
+++ b/vrobbler/apps/podcasts/init.py
--- a/vrobbler/apps/podcasts/admin.py
+++ b/vrobbler/apps/podcasts/admin.py
@ -0,0 +1,36 @@
+from django.contrib import admin
+from podcasts.models import Episode, Podcast, Producer
+from scrobbles.admin import ScrobbleInline
+
+
+@admin.register(Producer)
+class ProducerAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name",)
+    ordering = ("name",)
+
+
+@admin.register(Podcast)
+class PodcastAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = (
+        "name",
+        "producer",
+        "active",
+    )
+    ordering = ("name",)
+
+
+@admin.register(Episode)
+class EpisodeAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = (
+        "title",
+        "podcast",
+        "run_time",
+    )
+    list_filter = ("podcast",)
+    ordering = ("-created",)
+    inlines = [
+        ScrobbleInline,
+    ]
--- a/vrobbler/apps/podcasts/apps.py
+++ b/vrobbler/apps/podcasts/apps.py
@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class PodcastsConfig(AppConfig):
+    name = 'podcasts'
--- a/vrobbler/apps/podcasts/migrations/0001_initial.py
+++ b/vrobbler/apps/podcasts/migrations/0001_initial.py
@ -0,0 +1,158 @@
+# Generated by Django 4.1.5 on 2023-01-12 17:18
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name='Producer',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Podcast',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                ('active', models.BooleanField(default=True)),
+                ('url', models.URLField(blank=True, null=True)),
+                (
+                    'producer',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='podcasts.producer',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Episode',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('title', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                (
+                    'mopidy_uri',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'podcast',
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='podcasts.producer',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/0002_episode_run_time_episode_run_time_ticks_and_more.py
+++ b/vrobbler/apps/podcasts/migrations/0002_episode_run_time_episode_run_time_ticks_and_more.py
@ -0,0 +1,32 @@
+# Generated by Django 4.1.5 on 2023-01-12 17:48
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='episode',
+            name='run_time',
+            field=models.CharField(blank=True, max_length=8, null=True),
+        ),
+        migrations.AddField(
+            model_name='episode',
+            name='run_time_ticks',
+            field=models.PositiveBigIntegerField(blank=True, null=True),
+        ),
+        migrations.AlterField(
+            model_name='episode',
+            name='podcast',
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='podcasts.podcast',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/0003_episode_pub_date.py
+++ b/vrobbler/apps/podcasts/migrations/0003_episode_pub_date.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-01-12 18:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0002_episode_run_time_episode_run_time_ticks_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='episode',
+            name='pub_date',
+            field=models.DateField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/0004_episode_number.py
+++ b/vrobbler/apps/podcasts/migrations/0004_episode_number.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-01-12 18:32
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0003_episode_pub_date'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='episode',
+            name='number',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/0005_alter_episode_options_alter_episode_title.py
+++ b/vrobbler/apps/podcasts/migrations/0005_alter_episode_options_alter_episode_title.py
@ -0,0 +1,22 @@
+# Generated by Django 4.1.5 on 2023-01-13 01:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0004_episode_number'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='episode',
+            options={},
+        ),
+        migrations.AlterField(
+            model_name='episode',
+            name='title',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+    ]
--- a/vrobbler/apps/podcasts/migrations/init.py
+++ b/vrobbler/apps/podcasts/migrations/init.py
--- a/vrobbler/apps/podcasts/models.py
+++ b/vrobbler/apps/podcasts/models.py
@ -0,0 +1,88 @@
+import logging
+from typing import Dict, Optional
+from uuid import uuid4
+
+from django.conf import settings
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from django_extensions.db.models import TimeStampedModel
+
+from vrobbler.apps.scrobbles.mixins import ScrobblableMixin
+
+logger = logging.getLogger(__name__)
+BNULL = {"blank": True, "null": True}
+
+
+class Producer(TimeStampedModel):
+    name = models.CharField(max_length=255)
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+
+    def __str__(self):
+        return f"{self.name}"
+
+
+class Podcast(TimeStampedModel):
+    name = models.CharField(max_length=255)
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+    producer = models.ForeignKey(
+        Producer, on_delete=models.DO_NOTHING, **BNULL
+    )
+    active = models.BooleanField(default=True)
+    url = models.URLField(**BNULL)
+
+    def __str__(self):
+        return f"{self.name}"
+
+
+class Episode(ScrobblableMixin):
+    COMPLETION_PERCENT = getattr(settings, 'PODCAST_COMPLETION_PERCENT', 90)
+
+    podcast = models.ForeignKey(Podcast, on_delete=models.DO_NOTHING)
+    number = models.IntegerField(**BNULL)
+    pub_date = models.DateField(**BNULL)
+    mopidy_uri = models.CharField(max_length=255, **BNULL)
+
+    def __str__(self):
+        return f"{self.title}"
+
+    @classmethod
+    def find_or_create(
+        cls, podcast_dict: Dict, producer_dict: Dict, episode_dict: Dict
+    ) -> Optional["Episode"]:
+        """Given a data dict from Mopidy, finds or creates a podcast and
+        producer before saving the epsiode so it can be scrobbled.
+
+        """
+        if not podcast_dict.get('name'):
+            logger.warning(f"No name from source for podcast, not scrobbling")
+            return
+
+        producer = None
+        if producer_dict.get('name'):
+            producer, producer_created = Producer.objects.get_or_create(
+                **producer_dict
+            )
+            if producer_created:
+                logger.debug(f"Created new producer {producer}")
+            else:
+                logger.debug(f"Found producer {producer}")
+
+        if producer:
+            podcast_dict["producer_id"] = producer.id
+        podcast, podcast_created = Podcast.objects.get_or_create(
+            **podcast_dict
+        )
+        if podcast_created:
+            logger.debug(f"Created new podcast {podcast}")
+        else:
+            logger.debug(f"Found podcast {podcast}")
+
+        episode_dict['podcast_id'] = podcast.id
+
+        episode, created = cls.objects.get_or_create(**episode_dict)
+        if created:
+            logger.debug(f"Created new episode: {episode}")
+        else:
+            logger.debug(f"Found episode {episode}")
+
+        return episode
--- a/vrobbler/apps/profiles/init.py
+++ b/vrobbler/apps/profiles/init.py
--- a/vrobbler/apps/profiles/admin.py
+++ b/vrobbler/apps/profiles/admin.py
@ -0,0 +1,9 @@
+from django.contrib import admin
+
+from profiles.models import UserProfile
+
+
+@admin.register(UserProfile)
+class UserProfileAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    ordering = ("-created",)
--- a/vrobbler/apps/profiles/constants.py
+++ b/vrobbler/apps/profiles/constants.py
@ -0,0 +1,17 @@
+from datetime import datetime
+
+import pytz
+
+ALL_TIMEZONE_CHOICES = tuple(zip(pytz.all_timezones, pytz.all_timezones))
+COMMON_TIMEZONE_CHOICES = tuple(
+    zip(pytz.common_timezones, pytz.common_timezones)
+)
+PRETTY_TIMEZONE_CHOICES = []
+
+for tz in pytz.common_timezones:
+    now = datetime.now(pytz.timezone(tz))
+    ofs = now.strftime("%z")
+    PRETTY_TIMEZONE_CHOICES.append((int(ofs), tz, "(GMT%s) %s" % (ofs, tz)))
+PRETTY_TIMEZONE_CHOICES.sort()
+for i in range(len(PRETTY_TIMEZONE_CHOICES)):
+    PRETTY_TIMEZONE_CHOICES[i] = PRETTY_TIMEZONE_CHOICES[i][1:]
--- a/vrobbler/apps/profiles/migrations/0001_initial.py
+++ b/vrobbler/apps/profiles/migrations/0001_initial.py
--- a/vrobbler/apps/profiles/migrations/init.py
+++ b/vrobbler/apps/profiles/migrations/init.py
--- a/vrobbler/apps/profiles/models.py
+++ b/vrobbler/apps/profiles/models.py
@ -0,0 +1,24 @@
+import pytz
+
+from django.contrib.auth import get_user_model
+from django.db import models
+from django_extensions.db.models import TimeStampedModel
+from profiles.constants import PRETTY_TIMEZONE_CHOICES
+
+User = get_user_model()
+
+
+class UserProfile(TimeStampedModel):
+    user = models.OneToOneField(
+        User, on_delete=models.CASCADE, related_name="profile"
+    )
+    timezone = models.CharField(
+        max_length=255, choices=PRETTY_TIMEZONE_CHOICES
+    )
+
+    def __str__(self):
+        return f"User profile for {self.user}"
+
+    @property
+    def tzinfo(self):
+        return pytz.timezone(self.timezone)
--- a/vrobbler/apps/profiles/signals.py
+++ b/vrobbler/apps/profiles/signals.py
@ -0,0 +1,13 @@
+from django.contrib.auth import get_user_model
+from django.db.models.base import post_save
+from django.dispatch import receiver
+
+from profiles.models import UserProfile
+
+User = get_user_model()
+
+
+@receiver(post_save, sender=User)
+def create_profile(sender, instance, created, **kwargs):
+    if created:
+        UserProfile.objects.create(user=instance)
--- a/vrobbler/apps/profiles/utils.py
+++ b/vrobbler/apps/profiles/utils.py
@ -0,0 +1,33 @@
+import datetime
+
+import pytz
+from django.conf import settings
+from django.utils import timezone
+
+
+# need to translate to a non-naive timezone, even if timezone == settings.TIME_ZONE, so we can compare two dates
+def to_user_timezone(date, profile):
+    timezone = profile.timezone if profile.timezone else settings.TIME_ZONE
+    return date.replace(tzinfo=pytz.timezone(settings.TIME_ZONE)).astimezone(
+        pytz.timezone(timezone)
+    )
+
+
+def to_system_timezone(date, profile):
+    timezone = profile.timezone if profile.timezone else settings.TIME_ZONE
+    return date.replace(tzinfo=pytz.timezone(timezone)).astimezone(
+        pytz.timezone(settings.TIME_ZONE)
+    )
+
+
+def now_user_timezone(profile):
+    timezone.activate(pytz.timezone(profile.timezone))
+    return timezone.localtime(timezone.now())
+
+
+def now_system_timezone():
+    return (
+        datetime.datetime.now()
+        .replace(tzinfo=pytz.timezone(settings.TIME_ZONE))
+        .astimezone(pytz.timezone(settings.TIME_ZONE))
+    )
--- a/vrobbler/apps/scrobbles/admin.py
+++ b/vrobbler/apps/scrobbles/admin.py
@ -1,19 +1,58 @@
 from django.contrib import admin

-from scrobbles.models import Scrobble
+from scrobbles.models import AudioScrobblerTSVImport, Scrobble


+class ScrobbleInline(admin.TabularInline):
+    model = Scrobble
+    extra = 0
+    raw_id_fields = ('video', 'podcast_episode', 'track')
+    exclude = ('source_id', 'scrobble_log')
+
+
+@admin.register(AudioScrobblerTSVImport)
+class AudioScrobblerTSVImportAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("uuid", "created", "process_count", "tsv_file")
+    ordering = ("-created",)
+
+
+@admin.register(Scrobble)
 class ScrobbleAdmin(admin.ModelAdmin):
    date_hierarchy = "timestamp"
    list_display = (
-        "video",
        "timestamp",
+        "media_name",
+        "media_type",
+        "playback_percent",
        "source",
-        "playback_position",
        "in_progress",
+        "is_paused",
+        "played_to_completion",
    )
-    list_filter = ("video",)
+    raw_id_fields = ('video', 'podcast_episode', 'track', 'sport_event')
+    list_filter = ("is_paused", "in_progress", "source", "track__artist")
    ordering = ("-timestamp",)

+    def media_name(self, obj):
+        if obj.video:
+            return obj.video
+        if obj.track:
+            return obj.track
+        if obj.podcast_episode:
+            return obj.podcast_episode
+        if obj.sport_event:
+            return obj.sport_event

-admin.site.register(Scrobble, ScrobbleAdmin)
+    def media_type(self, obj):
+        if obj.video:
+            return "Video"
+        if obj.track:
+            return "Track"
+        if obj.podcast_episode:
+            return "Podcast"
+        if obj.sport_event:
+            return "Sport Event"
+
+    def playback_percent(self, obj):
+        return obj.percent_played
--- a/vrobbler/apps/scrobbles/constants.py
+++ b/vrobbler/apps/scrobbles/constants.py
@ -0,0 +1,2 @@
+JELLYFIN_VIDEO_ITEM_TYPES = ["Episode", "Movie"]
+JELLYFIN_AUDIO_ITEM_TYPES = ["Audio"]
--- a/vrobbler/apps/scrobbles/export.py
+++ b/vrobbler/apps/scrobbles/export.py
@ -0,0 +1,67 @@
+import csv
+import tempfile
+from scrobbles.models import Scrobble
+
+from django.db.models import Q
+
+
+def export_scrobbles(start_date=None, end_date=None, format="AS"):
+    start_query = Q()
+    end_query = Q()
+    if start_date:
+        start_query = Q(timestamp__gte=start_date)
+    if start_date:
+        end_query = Q(timestamp__lte=end_date)
+
+    scrobble_qs = Scrobble.objects.filter(
+        start_query, end_query, track__isnull=False
+    )
+    headers = []
+    extension = 'tsv'
+    delimiter = '\t'
+
+    if format == "as":
+        headers = [
+            ['#AUDIOSCROBBLER/1.1'],
+            ['#TZ/UTC'],
+            ['#CLIENT/Vrobbler 1.0.0'],
+        ]
+
+    if format == "csv":
+        delimiter = ','
+        extension = 'csv'
+        headers = [
+            [
+                "artists",
+                "album",
+                "title",
+                "track_number",
+                "run_time",
+                "rating",
+                "timestamp",
+                "musicbrainz_id",
+            ]
+        ]
+
+    with tempfile.NamedTemporaryFile(mode='w', delete=False) as outfile:
+        writer = csv.writer(outfile, delimiter=delimiter)
+        for row in headers:
+            writer.writerow(row)
+
+        for scrobble in scrobble_qs:
+            track = scrobble.track
+            track_number = 0  # TODO Add track number
+            track_rating = "S"  # TODO implement ratings?
+            track_artist = track.artist or track.album.primary_artist
+            row = [
+                track_artist,
+                track.album.name,
+                track.title,
+                track_number,
+                track.run_time,
+                track_rating,
+                scrobble.timestamp.strftime('%s'),
+                track.musicbrainz_id,
+            ]
+            writer.writerow(row)
+        return outfile.name, extension
--- a/vrobbler/apps/scrobbles/forms.py
+++ b/vrobbler/apps/scrobbles/forms.py
@ -0,0 +1,25 @@
+from django import forms
+
+
+class ExportScrobbleForm(forms.Form):
+    """Provide options for downloading scrobbles"""
+
+    EXPORT_TYPES = (
+        ('as', 'Audioscrobbler'),
+        ('csv', 'CSV'),
+        ('html', 'HTML'),
+    )
+    export_type = forms.ChoiceField(choices=EXPORT_TYPES)
+
+
+class ScrobbleForm(forms.Form):
+    item_id = forms.CharField(
+        label="",
+        widget=forms.TextInput(
+            attrs={
+                'class': "form-control form-control-dark w-100",
+                'placeholder': "Scrobble something (IMDB ID, String, TVDB ID ...)",
+                'aria-label': "Scrobble something",
+            }
+        ),
+    )
--- a/vrobbler/apps/scrobbles/imdb.py
+++ b/vrobbler/apps/scrobbles/imdb.py
@ -0,0 +1,61 @@
+import logging
+from django.utils import timezone
+
+from imdb import Cinemagoer
+
+imdb_client = Cinemagoer()
+
+logger = logging.getLogger(__name__)
+
+
+def lookup_video_from_imdb(imdb_id: str) -> dict:
+
+    if 'tt' not in imdb_id:
+        logger.warning(f"IMDB ID should begin with 'tt' {imdb_id}")
+        return
+
+    lookup_id = imdb_id.strip('tt')
+    media = imdb_client.get_movie(lookup_id)
+
+    run_time_seconds = 60 * 60
+    runtimes = media.get("runtimes")
+    if runtimes:
+        run_time_seconds = int(runtimes[0]) * 60
+
+    # Ticks otherwise known as miliseconds
+    run_time_ticks = run_time_seconds * 1000 * 1000
+
+    item_type = "Movie"
+    if media.get('series title'):
+        item_type = "Episode"
+
+    try:
+        plot = media.get('plot')[0]
+    except TypeError:
+        plot = ""
+    except IndexError:
+        plot = ""
+
+    logger.debug(f"Received data from IMDB: {media.__dict__}")
+    # Build a rough approximation of a Jellyfin data response
+    data_dict = {
+        "ItemType": item_type,
+        "Name": media.get('title'),
+        "Overview": plot,
+        "Tagline": media.get('tagline'),
+        "Year": media.get('year'),
+        "Provider_imdb": imdb_id,
+        "RunTime": run_time_seconds,
+        "RunTimeTicks": run_time_ticks,
+        "SeriesName": media.get('series title'),
+        "EpisodeNumber": media.get('episode'),
+        "SeasonNumber": media.get('season'),
+        "PlaybackPositionTicks": 1,
+        "PlaybackPosition": 1,
+        "UtcTimestamp": timezone.now().strftime('%Y-%m-%d %H:%M:%S.%f%z'),
+        "IsPaused": False,
+        "PlayedToCompletion": False,
+    }
+    logger.debug(f"Parsed data from IMDB data: {data_dict}")
+
+    return data_dict
--- a/vrobbler/apps/scrobbles/migrations/0006_scrobble_track_alter_scrobble_video.py
+++ b/vrobbler/apps/scrobbles/migrations/0006_scrobble_track_alter_scrobble_video.py
@ -0,0 +1,36 @@
+# Generated by Django 4.1.5 on 2023-01-07 20:03
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0001_initial'),
+        ('videos', '0003_alter_video_run_time_ticks'),
+        ('scrobbles', '0005_alter_scrobble_playback_position_ticks'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='scrobble',
+            name='track',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='music.track',
+            ),
+        ),
+        migrations.AlterField(
+            model_name='scrobble',
+            name='video',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='videos.video',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0007_scrobble_podcast_episode.py
+++ b/vrobbler/apps/scrobbles/migrations/0007_scrobble_podcast_episode.py
@ -0,0 +1,25 @@
+# Generated by Django 4.1.5 on 2023-01-12 17:48
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('podcasts', '0002_episode_run_time_episode_run_time_ticks_and_more'),
+        ('scrobbles', '0006_scrobble_track_alter_scrobble_video'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='scrobble',
+            name='podcast_episode',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='podcasts.episode',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0008_scrobble_sport_event.py
+++ b/vrobbler/apps/scrobbles/migrations/0008_scrobble_sport_event.py
@ -0,0 +1,25 @@
+# Generated by Django 4.1.5 on 2023-01-14 21:23
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sports', '0002_rename_start_utc_sportevent_start'),
+        ('scrobbles', '0007_scrobble_podcast_episode'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='scrobble',
+            name='sport_event',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='sports.sportevent',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0009_scrobble_uuid.py
+++ b/vrobbler/apps/scrobbles/migrations/0009_scrobble_uuid.py
@ -0,0 +1,35 @@
+# Generated by Django 4.1.5 on 2023-01-20 18:40
+
+from uuid import uuid4
+from django.db import migrations, models
+
+
+def generate_uuids(apps, schema_editor):
+    """Force uuid generation for old scrobbles"""
+    Scrobble = apps.get_model('scrobbles', 'Scrobble')
+    for scrobble in Scrobble.objects.all():
+        if not scrobble.uuid:
+            scrobble.uuid = uuid4()
+            scrobble.save(update_fields=['uuid'])
+
+
+def reverse_generate_uuids(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0008_scrobble_sport_event'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='scrobble',
+            name='uuid',
+            field=models.UUIDField(blank=True, editable=False, null=True),
+        ),
+        migrations.RunPython(
+            code=generate_uuids, reverse_code=reverse_generate_uuids
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0010_chartrecord.py
+++ b/vrobbler/apps/scrobbles/migrations/0010_chartrecord.py
@ -0,0 +1,88 @@
+# Generated by Django 4.1.5 on 2023-01-30 17:01
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0009_alter_track_musicbrainz_id_and_more'),
+        ('videos', '0006_alter_video_year'),
+        ('scrobbles', '0009_scrobble_uuid'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ChartRecord',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('rank', models.IntegerField()),
+                ('year', models.IntegerField(default=2023)),
+                ('month', models.IntegerField(blank=True, null=True)),
+                ('week', models.IntegerField(blank=True, null=True)),
+                ('day', models.IntegerField(blank=True, null=True)),
+                (
+                    'artist',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='music.artist',
+                    ),
+                ),
+                (
+                    'series',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='videos.series',
+                    ),
+                ),
+                (
+                    'track',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='music.track',
+                    ),
+                ),
+                (
+                    'video',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='videos.video',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0011_chartrecord_user.py
+++ b/vrobbler/apps/scrobbles/migrations/0011_chartrecord_user.py
@ -0,0 +1,26 @@
+# Generated by Django 4.1.5 on 2023-01-30 17:44
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('scrobbles', '0010_chartrecord'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='chartrecord',
+            name='user',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0012_audioscrobblertsvimport.py
+++ b/vrobbler/apps/scrobbles/migrations/0012_audioscrobblertsvimport.py
@ -0,0 +1,52 @@
+# Generated by Django 4.1.5 on 2023-02-03 19:50
+
+from django.db import migrations, models
+import django_extensions.db.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0011_chartrecord_user'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AudioScrobblerTSVImport',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                (
+                    'tsv_file',
+                    models.FileField(
+                        blank=True,
+                        null=True,
+                        upload_to='audioscrobbler-uploads/%Y/%m-%d/',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0013_audioscrobblertsvimport_processed_on.py
+++ b/vrobbler/apps/scrobbles/migrations/0013_audioscrobblertsvimport_processed_on.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-02-03 20:20
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0012_audioscrobblertsvimport'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='processed_on',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0014_audioscrobblertsvimport_process_log.py
+++ b/vrobbler/apps/scrobbles/migrations/0014_audioscrobblertsvimport_process_log.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-02-03 22:53
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0013_audioscrobblertsvimport_processed_on'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='process_log',
+            field=models.TextField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0015_audioscrobblertsvimport_uuid_and_more.py
+++ b/vrobbler/apps/scrobbles/migrations/0015_audioscrobblertsvimport_uuid_and_more.py
@ -0,0 +1,29 @@
+# Generated by Django 4.1.5 on 2023-02-03 23:36
+
+from django.db import migrations, models
+import scrobbles.models
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0014_audioscrobblertsvimport_process_log'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='uuid',
+            field=models.UUIDField(default=uuid.uuid4, editable=False),
+        ),
+        migrations.AlterField(
+            model_name='audioscrobblertsvimport',
+            name='tsv_file',
+            field=models.FileField(
+                blank=True,
+                null=True,
+                upload_to=scrobbles.models.AudioScrobblerTSVImport.get_path,
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0016_audioscrobblertsvimport_process_count.py
+++ b/vrobbler/apps/scrobbles/migrations/0016_audioscrobblertsvimport_process_count.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-02-03 23:44
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('scrobbles', '0015_audioscrobblertsvimport_uuid_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='process_count',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/migrations/0017_audioscrobblertsvimport_user.py
+++ b/vrobbler/apps/scrobbles/migrations/0017_audioscrobblertsvimport_user.py
@ -0,0 +1,26 @@
+# Generated by Django 4.1.5 on 2023-02-07 00:07
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('scrobbles', '0016_audioscrobblertsvimport_process_count'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='audioscrobblertsvimport',
+            name='user',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to=settings.AUTH_USER_MODEL,
+            ),
+        ),
+    ]
--- a/vrobbler/apps/scrobbles/mixins.py
+++ b/vrobbler/apps/scrobbles/mixins.py
@ -0,0 +1,19 @@
+from uuid import uuid4
+
+from django.db import models
+from django_extensions.db.models import TimeStampedModel
+
+BNULL = {"blank": True, "null": True}
+
+
+class ScrobblableMixin(TimeStampedModel):
+    SECONDS_TO_STALE = 1600
+
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+    title = models.CharField(max_length=255, **BNULL)
+    run_time = models.CharField(max_length=8, **BNULL)
+    run_time_ticks = models.PositiveBigIntegerField(**BNULL)
+    # thumbs = models.IntegerField(default=Opinion.NEUTRAL, choices=Opinion.choices)
+
+    class Meta:
+        abstract = True
--- a/vrobbler/apps/scrobbles/models.py
+++ b/vrobbler/apps/scrobbles/models.py
@ -1,15 +1,169 @@
+import calendar
+import logging
+from uuid import uuid4
+
 from django.contrib.auth import get_user_model
 from django.db import models
+from django.utils import timezone
 from django_extensions.db.models import TimeStampedModel
+from music.models import Artist, Track
+from podcasts.models import Episode
+from scrobbles.utils import check_scrobble_for_finish
+from sports.models import SportEvent
+from videos.models import Series, Video
+from vrobbler.apps.profiles.utils import now_user_timezone

-from videos.models import Video
-
+logger = logging.getLogger(__name__)
 User = get_user_model()
 BNULL = {"blank": True, "null": True}


+class AudioScrobblerTSVImport(TimeStampedModel):
+    def get_path(instance, filename):
+        extension = filename.split('.')[-1]
+        uuid = instance.uuid
+        return f'audioscrobbler-uploads/{uuid}.{extension}'
+
+    user = models.ForeignKey(User, on_delete=models.DO_NOTHING, **BNULL)
+    uuid = models.UUIDField(editable=False, default=uuid4)
+    tsv_file = models.FileField(upload_to=get_path, **BNULL)
+    processed_on = models.DateTimeField(**BNULL)
+    process_log = models.TextField(**BNULL)
+    process_count = models.IntegerField(**BNULL)
+
+    def __str__(self):
+        if self.tsv_file:
+            return f"Audioscrobbler TSV upload: {self.tsv_file.path}"
+        return f"Audioscrobbler TSV upload {self.id}"
+
+    def save(self, **kwargs):
+        """On save, attempt to import the TSV file"""
+        super().save(**kwargs)
+        self.process()
+        return
+
+    def process(self, force=False):
+        from scrobbles.tsv import process_audioscrobbler_tsv_file
+
+        if self.processed_on and not force:
+            logger.info(f"{self} already processed on {self.processed_on}")
+            return
+
+        tz = None
+        if self.user:
+            tz = self.user.profile.tzinfo
+        scrobbles = process_audioscrobbler_tsv_file(
+            self.tsv_file.path, user_tz=tz
+        )
+        if scrobbles:
+            self.process_log = f"Created {len(scrobbles)} scrobbles"
+            for scrobble in scrobbles:
+                scrobble_str = f"{scrobble.id}\t{scrobble.timestamp}\t{scrobble.track.title}"
+                self.process_log += f"\n{scrobble_str}"
+            self.process_count = len(scrobbles)
+        else:
+            self.process_log = f"Created no new scrobbles"
+            self.process_count = 0
+
+        self.processed_on = timezone.now()
+        self.save(
+            update_fields=['processed_on', 'process_count', 'process_log']
+        )
+
+    def undo(self, dryrun=True):
+        from scrobbles.tsv import undo_audioscrobbler_tsv_import
+
+        undo_audioscrobbler_tsv_import(self.process_log, dryrun)
+
+
+class ChartRecord(TimeStampedModel):
+    """Sort of like a materialized view for what we could dynamically generate,
+    but would kill the DB as it gets larger. Collects time-based records
+    generated by a cron-like archival job
+
+    1972 by Josh Rouse - #3 in 2023, January
+
+    """
+
+    user = models.ForeignKey(User, on_delete=models.DO_NOTHING, **BNULL)
+    rank = models.IntegerField()
+    year = models.IntegerField(default=timezone.now().year)
+    month = models.IntegerField(**BNULL)
+    week = models.IntegerField(**BNULL)
+    day = models.IntegerField(**BNULL)
+    video = models.ForeignKey(Video, on_delete=models.DO_NOTHING, **BNULL)
+    series = models.ForeignKey(Series, on_delete=models.DO_NOTHING, **BNULL)
+    artist = models.ForeignKey(Artist, on_delete=models.DO_NOTHING, **BNULL)
+    track = models.ForeignKey(Track, on_delete=models.DO_NOTHING, **BNULL)
+
+    @property
+    def media_obj(self):
+        media_obj = None
+        if self.video:
+            media_obj = self.video
+        if self.track:
+            media_obj = self.track
+        return media_obj
+
+    @property
+    def month_str(self) -> str:
+        month_str = ""
+        if self.month:
+            month_str = calendar.month_name[self.month]
+        return month_str
+
+    @property
+    def day_str(self) -> str:
+        day_str = ""
+        if self.day:
+            day_str = str(self.day)
+        return day_str
+
+    @property
+    def week_str(self) -> str:
+        week_str = ""
+        if self.week:
+            week_str = str(self.week)
+        return "Week " + week_str
+
+    @property
+    def period(self) -> str:
+        period = str(self.year)
+        if self.month:
+            period = " ".join([self.month_str, period])
+        if self.week:
+            period = " ".join([self.week_str, period])
+        if self.day:
+            period = " ".join([self.day_str, period])
+        return period
+
+    @property
+    def period_type(self) -> str:
+        period = 'year'
+        if self.month:
+            period = 'month'
+        if self.week:
+            period = 'week'
+        if self.day:
+            period = 'day'
+        return period
+
+    def __str__(self):
+        return f"#{self.rank} in {self.period} - {self.media_obj}"
+
+
 class Scrobble(TimeStampedModel):
-    video = models.ForeignKey(Video, on_delete=models.DO_NOTHING)
+    """A scrobble tracks played media items by a user."""
+
+    uuid = models.UUIDField(editable=False, **BNULL)
+    video = models.ForeignKey(Video, on_delete=models.DO_NOTHING, **BNULL)
+    track = models.ForeignKey(Track, on_delete=models.DO_NOTHING, **BNULL)
+    podcast_episode = models.ForeignKey(
+        Episode, on_delete=models.DO_NOTHING, **BNULL
+    )
+    sport_event = models.ForeignKey(
+        SportEvent, on_delete=models.DO_NOTHING, **BNULL
+    )
    user = models.ForeignKey(
        User, blank=True, null=True, on_delete=models.DO_NOTHING
    )
@ -23,11 +177,189 @@ class Scrobble(TimeStampedModel):
    in_progress = models.BooleanField(default=True)
    scrobble_log = models.TextField(**BNULL)

+    def save(self, *args, **kwargs):
+        if not self.uuid:
+            self.uuid = uuid4()
+
+        return super(Scrobble, self).save(*args, **kwargs)
+
+    @property
+    def status(self) -> str:
+        if self.is_paused:
+            return 'paused'
+        if self.played_to_completion:
+            return 'finished'
+        if self.in_progress:
+            return 'in-progress'
+        return 'zombie'
+
+    @property
+    def is_stale(self) -> bool:
+        """Mark scrobble as stale if it's been more than an hour since it was updated"""
+        is_stale = False
+        now = timezone.now()
+        seconds_since_last_update = (now - self.modified).seconds
+        if seconds_since_last_update >= self.media_obj.SECONDS_TO_STALE:
+            is_stale = True
+        return is_stale
+
    @property
    def percent_played(self) -> int:
-        return int(
-            (self.playback_position_ticks / self.video.run_time_ticks) * 100
-        )
+        if not self.media_obj.run_time_ticks:
+            return 100
+
+        if not self.playback_position_ticks and self.played_to_completion:
+            return 100
+
+        playback_ticks = self.playback_position_ticks
+        if not playback_ticks:
+            playback_ticks = (timezone.now() - self.timestamp).seconds * 1000
+
+        percent = int((playback_ticks / self.media_obj.run_time_ticks) * 100)
+        if percent > 100:
+            percent = 100
+        return percent
+
+    @property
+    def can_be_updated(self) -> bool:
+        updatable = True
+        if self.percent_played > 100:
+            logger.info(f"No - 100% played - {self.id} - {self.source}")
+            updatable = False
+        if self.is_stale:
+            logger.info(f"No - stale - {self.id} - {self.source}")
+            updatable = False
+        return updatable
+
+    @property
+    def media_obj(self):
+        media_obj = None
+        if self.video:
+            media_obj = self.video
+        if self.track:
+            media_obj = self.track
+        if self.podcast_episode:
+            media_obj = self.podcast_episode
+        if self.sport_event:
+            media_obj = self.sport_event
+        return media_obj

    def __str__(self):
-        return f"Scrobble of {self.video} {self.timestamp.year}-{self.timestamp.month}"
+        timestamp = self.timestamp.strftime('%Y-%m-%d')
+        return f"Scrobble of {self.media_obj} ({timestamp})"
+
+    @classmethod
+    def create_or_update(
+        cls, media, user_id: int, scrobble_data: dict
+    ) -> "Scrobble":
+
+        if media.__class__.__name__ == 'Track':
+            media_query = models.Q(track=media)
+            scrobble_data['track_id'] = media.id
+        if media.__class__.__name__ == 'Video':
+            media_query = models.Q(video=media)
+            scrobble_data['video_id'] = media.id
+        if media.__class__.__name__ == 'Episode':
+            media_query = models.Q(podcast_episode=media)
+            scrobble_data['podcast_episode_id'] = media.id
+        if media.__class__.__name__ == 'SportEvent':
+            media_query = models.Q(sport_event=media)
+            scrobble_data['sport_event_id'] = media.id
+
+        scrobble = (
+            cls.objects.filter(
+                media_query,
+                user_id=user_id,
+            )
+            .order_by('-modified')
+            .first()
+        )
+        if scrobble and scrobble.can_be_updated:
+            logger.info(
+                f"Updating {scrobble.id}",
+                {"scrobble_data": scrobble_data, "media": media},
+            )
+            return scrobble.update(scrobble_data)
+
+        source = scrobble_data['source']
+        logger.info(
+            f"Creating for {media.id} - {source}",
+            {"scrobble_data": scrobble_data, "media": media},
+        )
+        # If creating a new scrobble, we don't need status
+        scrobble_data.pop('mopidy_status', None)
+        scrobble_data.pop('jellyfin_status', None)
+        return cls.create(scrobble_data)
+
+    def update(self, scrobble_data: dict) -> "Scrobble":
+        # Status is a field we get from Mopidy, which refuses to poll us
+        scrobble_status = scrobble_data.pop('mopidy_status', None)
+        if not scrobble_status:
+            scrobble_status = scrobble_data.pop('jellyfin_status', None)
+
+        if self.percent_played < 100:
+            # Only worry about ticks if we haven't gotten to the end
+            self.update_ticks(scrobble_data)
+
+        # On stop, stop progress and send it to the check for completion
+        if scrobble_status == "stopped":
+            self.stop()
+        # On pause, set is_paused and stop scrobbling
+        if scrobble_status == "paused":
+            self.pause()
+        if scrobble_status == "resumed":
+            self.resume()
+
+        for key, value in scrobble_data.items():
+            setattr(self, key, value)
+        self.save()
+        return self
+
+    @classmethod
+    def create(
+        cls,
+        scrobble_data: dict,
+    ) -> "Scrobble":
+        scrobble_data['scrobble_log'] = ""
+        scrobble = cls.objects.create(
+            **scrobble_data,
+        )
+        return scrobble
+
+    def stop(self, force_finish=False) -> None:
+        if not self.in_progress:
+            return
+        self.in_progress = False
+        self.save(update_fields=['in_progress'])
+        logger.info(f"{self.id} - {self.source}")
+        check_scrobble_for_finish(self, force_finish)
+
+    def pause(self) -> None:
+        if self.is_paused:
+            logger.warning(f"{self.id} - already paused - {self.source}")
+            return
+        self.is_paused = True
+        self.save(update_fields=["is_paused"])
+        logger.info(f"{self.id} - pausing - {self.source}")
+        check_scrobble_for_finish(self)
+
+    def resume(self) -> None:
+        if self.is_paused or not self.in_progress:
+            self.is_paused = False
+            self.in_progress = True
+            logger.info(f"{self.id} - resuming - {self.source}")
+            return self.save(update_fields=["is_paused", "in_progress"])
+
+    def cancel(self) -> None:
+        check_scrobble_for_finish(self, force_finish=True)
+        self.delete()
+
+    def update_ticks(self, data) -> None:
+        self.playback_position_ticks = data.get("playback_position_ticks")
+        self.playback_position = data.get("playback_position")
+        logger.info(
+            f"{self.id} - {self.playback_position_ticks} - {self.source}"
+        )
+        self.save(
+            update_fields=['playback_position_ticks', 'playback_position']
+        )
--- a/vrobbler/apps/scrobbles/scrobblers.py
+++ b/vrobbler/apps/scrobbles/scrobblers.py
@ -0,0 +1,217 @@
+import logging
+from typing import Optional
+
+from dateutil.parser import parse
+from django.utils import timezone
+from music.constants import JELLYFIN_POST_KEYS
+from music.models import Track
+from podcasts.models import Episode
+from scrobbles.models import Scrobble
+from scrobbles.utils import convert_to_seconds, parse_mopidy_uri
+from videos.models import Video
+from sports.models import SportEvent
+
+logger = logging.getLogger(__name__)
+
+
+def mopidy_scrobble_podcast(
+    data_dict: dict, user_id: Optional[int]
+) -> Scrobble:
+    mopidy_uri = data_dict.get("mopidy_uri", "")
+    parsed_data = parse_mopidy_uri(mopidy_uri)
+
+    producer_dict = {"name": data_dict.get("artist")}
+
+    podcast_name = data_dict.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_ticks": data_dict.get("run_time_ticks"),
+        "run_time": data_dict.get("run_time"),
+        "number": parsed_data.get("episode_num"),
+        "pub_date": parsed_data.get("pub_date"),
+        "mopidy_uri": mopidy_uri,
+    }
+
+    episode = Episode.find_or_create(podcast_dict, producer_dict, episode_dict)
+
+    # Now we run off a scrobble
+    mopidy_data = {
+        "user_id": user_id,
+        "timestamp": timezone.now(),
+        "playback_position_ticks": data_dict.get("playback_time_ticks"),
+        "source": "Mopidy",
+        "mopidy_status": data_dict.get("status"),
+    }
+
+    scrobble = None
+    if episode:
+        scrobble = Scrobble.create_or_update(episode, user_id, mopidy_data)
+    return scrobble
+
+
+def mopidy_scrobble_track(
+    data_dict: dict, user_id: Optional[int]
+) -> Optional[Scrobble]:
+    artist_dict = {
+        "name": data_dict.get("artist", None),
+        "musicbrainz_id": data_dict.get("musicbrainz_artist_id", None),
+    }
+
+    album_dict = {
+        "name": data_dict.get("album"),
+        "musicbrainz_id": data_dict.get("musicbrainz_album_id"),
+    }
+
+    track_dict = {
+        "title": data_dict.get("name"),
+        "run_time_ticks": data_dict.get("run_time_ticks"),
+        "run_time": data_dict.get("run_time"),
+    }
+
+    track = Track.find_or_create(artist_dict, album_dict, track_dict)
+
+    # Now we run off a scrobble
+    mopidy_data = {
+        "user_id": user_id,
+        "timestamp": timezone.now(),
+        "playback_position_ticks": data_dict.get("playback_time_ticks"),
+        "source": "Mopidy",
+        "mopidy_status": data_dict.get("status"),
+    }
+
+    # Jellyfin MB ids suck, so always overwrite with Mopidy if they're offering
+    track.musicbrainz_id = data_dict.get("musicbrainz_track_id")
+    track.save()
+
+    scrobble = Scrobble.create_or_update(track, user_id, mopidy_data)
+
+    return scrobble
+
+
+def build_scrobble_dict(data_dict: dict, user_id: int) -> dict:
+    jellyfin_status = "resumed"
+    if data_dict.get("IsPaused"):
+        jellyfin_status = "paused"
+    elif data_dict.get("NotificationType") == 'PlaybackStop':
+        jellyfin_status = "stopped"
+
+    playback_ticks = data_dict.get("PlaybackPositionTicks", "")
+    if playback_ticks:
+        playback_ticks = playback_ticks // 10000
+
+    return {
+        "user_id": user_id,
+        "timestamp": parse(data_dict.get("UtcTimestamp")),
+        "playback_position_ticks": playback_ticks,
+        "playback_position": data_dict.get("PlaybackPosition", ""),
+        "source": data_dict.get("ClientName", "Vrobbler"),
+        "source_id": data_dict.get('MediaSourceId'),
+        "jellyfin_status": jellyfin_status,
+    }
+
+
+def jellyfin_scrobble_track(
+    data_dict: dict, user_id: Optional[int]
+) -> Optional[Scrobble]:
+
+    if not data_dict.get("Provider_musicbrainztrack", None):
+        # TODO we should be able to look up tracks via MB rather than error out
+        logger.error(
+            "No MBrainz Track ID received. This is likely because all metadata is bad, not scrobbling"
+        )
+        return
+
+    null_position_on_progress = (
+        data_dict.get("PlaybackPosition") == "00:00:00"
+        and data_dict.get("NotificationType") == "PlaybackProgress"
+    )
+
+    # Jellyfin has some race conditions with it's webhooks, these hacks fix some of them
+    if not data_dict.get("PlaybackPositionTicks") or null_position_on_progress:
+        logger.error("No playback position tick from Jellyfin, aborting")
+        return
+
+    artist_dict = {
+        'name': data_dict.get(JELLYFIN_POST_KEYS["ARTIST_NAME"], None),
+        'musicbrainz_id': data_dict.get(
+            JELLYFIN_POST_KEYS["ARTIST_MB_ID"], None
+        ),
+    }
+
+    album_dict = {
+        "name": data_dict.get(JELLYFIN_POST_KEYS["ALBUM_NAME"], None),
+        "musicbrainz_id": data_dict.get(JELLYFIN_POST_KEYS['ALBUM_MB_ID']),
+    }
+
+    # Convert ticks from Jellyfin from microseconds to nanoseconds
+    # Ain't nobody got time for nanoseconds
+    track_dict = {
+        "title": data_dict.get("Name", ""),
+        "run_time_ticks": data_dict.get(
+            JELLYFIN_POST_KEYS["RUN_TIME_TICKS"], None
+        )
+        // 10000,
+        "run_time": convert_to_seconds(
+            data_dict.get(JELLYFIN_POST_KEYS["RUN_TIME"], None)
+        ),
+    }
+    track = Track.find_or_create(artist_dict, album_dict, track_dict)
+
+    # Prefer Mopidy MD IDs to Jellyfin, so skip if we already have one
+    if not track.musicbrainz_id:
+        track.musicbrainz_id = data_dict.get(
+            JELLYFIN_POST_KEYS["TRACK_MB_ID"], None
+        )
+        track.save()
+
+    scrobble_dict = build_scrobble_dict(data_dict, user_id)
+
+    # A hack to make Jellyfin work more like Mopidy for music tracks
+    scrobble_dict["playback_position_ticks"] = 0
+    scrobble_dict["playback_position"] = ""
+
+    return Scrobble.create_or_update(track, user_id, scrobble_dict)
+
+
+def jellyfin_scrobble_video(data_dict: dict, user_id: Optional[int]):
+    if not data_dict.get("Provider_imdb", None):
+        logger.error(
+            "No IMDB ID received. This is likely because all metadata is bad, not scrobbling"
+        )
+        return
+    video = Video.find_or_create(data_dict)
+
+    scrobble_dict = build_scrobble_dict(data_dict, user_id)
+
+    return Scrobble.create_or_update(video, user_id, scrobble_dict)
+
+
+def manual_scrobble_video(data_dict: dict, user_id: Optional[int]):
+    if not data_dict.get("Provider_imdb", None):
+        logger.error(
+            "No IMDB ID received. This is likely because all metadata is bad, not scrobbling"
+        )
+        return
+    video = Video.find_or_create(data_dict)
+
+    scrobble_dict = build_scrobble_dict(data_dict, user_id)
+
+    return Scrobble.create_or_update(video, user_id, scrobble_dict)
+
+
+def manual_scrobble_event(data_dict: dict, user_id: Optional[int]):
+    if not data_dict.get("Provider_thesportsdb", None):
+        logger.error(
+            "No TheSportsDB ID received. This is likely because all metadata is bad, not scrobbling"
+        )
+        return
+    event = SportEvent.find_or_create(data_dict)
+
+    scrobble_dict = build_scrobble_dict(data_dict, user_id)
+
+    return Scrobble.create_or_update(event, user_id, scrobble_dict)
--- a/vrobbler/apps/scrobbles/serializers.py
+++ b/vrobbler/apps/scrobbles/serializers.py
@ -1,5 +1,11 @@
 from rest_framework import serializers
-from scrobbles.models import Scrobble
+from scrobbles.models import Scrobble, AudioScrobblerTSVImport
+
+
+class AudioScrobblerTSVImportSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = AudioScrobblerTSVImport
+        fields = ('tsv_file',)


 class ScrobbleSerializer(serializers.ModelSerializer):
--- a/vrobbler/apps/scrobbles/stats.py
+++ b/vrobbler/apps/scrobbles/stats.py
@ -0,0 +1,115 @@
+import calendar
+import logging
+from datetime import datetime, timedelta
+from typing import Optional
+
+import pytz
+from django.apps import apps
+from django.conf import settings
+from django.db.models import Count, Q
+
+
+logger = logging.getLogger(__name__)
+
+
+def get_start_end_dates_by_week(year, week, tz):
+    d = datetime(year, 1, 1, tzinfo=tz)
+    if d.weekday() <= 3:
+        d = d - timedelta(d.weekday())
+    else:
+        d = d + timedelta(7 - d.weekday())
+    dlt = timedelta(days=(week - 1) * 7)
+    return d + dlt, d + dlt + timedelta(days=6)
+
+
+def get_scrobble_count_qs(
+    year: Optional[int] = None,
+    month: Optional[int] = None,
+    week: Optional[int] = None,
+    day: Optional[int] = None,
+    user=None,
+    model_str="Track",
+) -> dict[str, int]:
+
+    tz = settings.TIME_ZONE
+    if user and user.is_authenticated:
+        tz = pytz.timezone(user.profile.timezone)
+
+    data_model = apps.get_model(app_label='music', model_name='Track')
+    if model_str == "Video":
+        data_model = apps.get_model(app_label='videos', model_name='Video')
+    if model_str == "SportEvent":
+        data_model = apps.get_model(
+            app_label='sports', model_name='SportEvent'
+        )
+
+    base_qs = data_model.objects.filter(
+        scrobble__user=user,
+        scrobble__played_to_completion=True,
+    )
+
+    # Returna all media items with scrobble count annotated
+    if not year:
+        return base_qs.annotate(scrobble_count=Count("scrobble")).order_by(
+            "-scrobble_count"
+        )
+
+    start = datetime(year, 1, 1, tzinfo=tz)
+    end = datetime(year, 12, 31, tzinfo=tz)
+    if month:
+        end_day = calendar.monthrange(year, month)[1]
+        start = datetime(year, month, 1, tzinfo=tz)
+        end = datetime(year, month, end_day, tzinfo=tz)
+    elif week:
+        start, end = get_start_end_dates_by_week(year, week, tz)
+    elif day and month:
+        start = datetime(year, month, day, 0, 0, tzinfo=tz)
+        end = datetime(year, month, day, 23, 59, tzinfo=tz)
+    elif day and not month:
+        logger.warning('Day provided with month, defaulting ot all-time')
+
+    date_filter = Q(
+        scrobble__timestamp__gte=start, scrobble__timestamp__lte=end
+    )
+
+    return (
+        base_qs.annotate(
+            scrobble_count=Count("scrobble", filter=Q(date_filter))
+        )
+        .filter(date_filter)
+        .order_by("-scrobble_count")
+    )
+
+
+def build_charts(
+    year: Optional[int] = None,
+    month: Optional[int] = None,
+    week: Optional[int] = None,
+    day: Optional[int] = None,
+    user=None,
+    model_str="Track",
+):
+    ChartRecord = apps.get_model(
+        app_label='scrobbles', model_name='ChartRecord'
+    )
+    results = get_scrobble_count_qs(year, month, week, day, user, model_str)
+    unique_counts = list(set([result.scrobble_count for result in results]))
+    unique_counts.sort(reverse=True)
+    ranks = {}
+    for rank, count in enumerate(unique_counts, start=1):
+        ranks[count] = rank
+
+    chart_records = []
+    for result in results:
+        chart_record = {
+            'year': year,
+            'week': week,
+            'month': month,
+            'day': day,
+            'user': user,
+        }
+        chart_record['rank'] = ranks[result.scrobble_count]
+        if model_str == 'Track':
+            chart_record['track'] = result
+        chart_records.append(ChartRecord(**chart_record))
+    ChartRecord.objects.bulk_create(chart_records, ignore_conflicts=True)
--- a/vrobbler/apps/scrobbles/thesportsdb.py
+++ b/vrobbler/apps/scrobbles/thesportsdb.py
@ -0,0 +1,51 @@
+import logging
+
+from dateutil.parser import parse
+from django.conf import settings
+from django.utils import timezone
+from pysportsdb import TheSportsDbClient
+from sports.models import Sport
+
+logger = logging.getLogger(__name__)
+
+API_KEY = getattr(settings, "THESPORTSDB_API_KEY", "2")
+client = TheSportsDbClient(api_key=API_KEY)
+
+
+def lookup_event_from_thesportsdb(event_id: str) -> dict:
+
+    event = client.lookup_event(event_id)['events'][0]
+    if not event or type(event) != dict:
+        return {}
+    league = {}  # client.lookup_league(league_id=event.get('idLeague'))
+    event_type = "Game"
+    sport, _created = Sport.objects.get_or_create(
+        thesportsdb_id=event.get('strSport')
+    )
+
+    data_dict = {
+        "ItemType": sport.default_event_type,
+        "Name": event.get('strEvent'),
+        "AltName": event.get('strEventAlternate'),
+        "Start": parse(event.get('strTimestamp')),
+        "Provider_thesportsdb": event.get('idEvent'),
+        "RunTime": sport.default_event_run_time,
+        "RunTimeTicks": sport.default_event_run_time_ticks,
+        "Sport": event.get('strSport'),
+        "Season": event.get('strSeason'),
+        "LeagueId": event.get('idLeague'),
+        "LeagueName": event.get('strLeague'),
+        "HomeTeamId": event.get('idHomeTeam'),
+        "HomeTeamName": event.get('strHomeTeam'),
+        "AwayTeamId": event.get('idAwayTeam'),
+        "AwayTeamName": event.get('strAwayTeam'),
+        "RoundId": event.get('intRound'),
+        "PlaybackPositionTicks": None,
+        "PlaybackPosition": None,
+        "UtcTimestamp": timezone.now().strftime('%Y-%m-%d %H:%M:%S.%f%z'),
+        "IsPaused": False,
+        "PlayedToCompletion": False,
+        "Source": "Vrobbler",
+    }
+
+    return data_dict
--- a/vrobbler/apps/scrobbles/tsv.py
+++ b/vrobbler/apps/scrobbles/tsv.py
@ -0,0 +1,122 @@
+import csv
+import logging
+from datetime import datetime
+
+import pytz
+from music.models import Album, Artist, Track
+from scrobbles.models import Scrobble
+
+logger = logging.getLogger(__name__)
+
+
+def process_audioscrobbler_tsv_file(file_path, user_tz=None):
+    """Takes a path to a file of TSV data and imports it as past scrobbles"""
+    new_scrobbles = []
+    if not user_tz:
+        user_tz = pytz.utc
+
+    with open(file_path) as infile:
+        source = 'Audioscrobbler File'
+        rows = csv.reader(infile, delimiter="\t")
+
+        source_id = ""
+        for row_num, row in enumerate(rows):
+            if row_num in [0, 1, 2]:
+                source_id += row[0] + "\n"
+                continue
+            if len(row) > 8:
+                logger.warning(
+                    'Improper row length during Audioscrobbler import',
+                    extra={'row': row},
+                )
+                continue
+            artist, artist_created = Artist.objects.get_or_create(name=row[0])
+            if artist_created:
+                logger.debug(f"Created artist {artist}")
+            else:
+                logger.debug(f"Found artist {artist}")
+
+            album = None
+            album_created = False
+            albums = Album.objects.filter(name=row[1])
+            if albums.count() == 1:
+                album = albums.first()
+            else:
+                for potential_album in albums:
+                    if artist in album.artist_set.all():
+                        album = potential_album
+            if not album:
+                album_created = True
+                album = Album.objects.create(name=row[1])
+                album.save()
+                album.artists.add(artist)
+
+            if album_created:
+                logger.debug(f"Created album {album}")
+            else:
+                logger.debug(f"Found album {album}")
+
+            track, track_created = Track.objects.get_or_create(
+                title=row[2],
+                artist=artist,
+                album=album,
+            )
+
+            if track_created:
+                logger.debug(f"Created track {track}")
+            else:
+                logger.debug(f"Found track {track}")
+
+            if track_created:
+                track.musicbrainz_id = row[7]
+                track.save()
+
+            timestamp = (
+                datetime.utcfromtimestamp(int(row[6]))
+                .replace(tzinfo=user_tz)
+                .astimezone(pytz.utc)
+            )
+            source = 'Audioscrobbler File'
+
+            new_scrobble = Scrobble(
+                timestamp=timestamp,
+                source=source,
+                source_id=source_id,
+                track=track,
+                played_to_completion=True,
+                in_progress=False,
+            )
+            existing = Scrobble.objects.filter(
+                timestamp=timestamp, track=track
+            ).first()
+            if existing:
+                logger.debug(f"Skipping existing scrobble {new_scrobble}")
+                continue
+            logger.debug(f"Queued scrobble {new_scrobble} for creation")
+            new_scrobbles.append(new_scrobble)
+
+        created = Scrobble.objects.bulk_create(new_scrobbles)
+        logger.info(
+            f"Created {len(created)} scrobbles",
+            extra={'created_scrobbles': created},
+        )
+        return created
+
+
+def undo_audioscrobbler_tsv_import(process_log, dryrun=True):
+    """Accepts the log from a TSV import and removes the scrobbles"""
+    if not process_log:
+        logger.warning("No lines in process log found to undo")
+        return
+
+    for line_num, line in enumerate(process_log.split('\n')):
+        if line_num == 0:
+            continue
+        scrobble_id = line.split("\t")[0]
+        scrobble = Scrobble.objects.filter(id=scrobble_id).first()
+        if not scrobble:
+            logger.warning(f"Could not find scrobble {scrobble_id} to undo")
+            continue
+        logger.info(f"Removing scrobble {scrobble_id}")
+        if not dryrun:
+            scrobble.delete()
--- a/vrobbler/apps/scrobbles/urls.py
+++ b/vrobbler/apps/scrobbles/urls.py
@ -4,6 +4,15 @@ from scrobbles import views
 app_name = 'scrobbles'

 urlpatterns = [
-    path('', views.scrobble_endpoint, name='scrobble-list'),
+    path('', views.scrobble_endpoint, name='api-list'),
+    path('finish/<slug:uuid>', views.scrobble_finish, name='finish'),
+    path('cancel/<slug:uuid>', views.scrobble_cancel, name='cancel'),
+    path(
+        'upload/',
+        views.AudioScrobblerImportCreateView.as_view(),
+        name='audioscrobbler-file-upload',
+    ),
    path('jellyfin/', views.jellyfin_websocket, name='jellyfin-websocket'),
+    path('mopidy/', views.mopidy_websocket, name='mopidy-websocket'),
+    path('export/', views.export, name='export'),
 ]
--- a/vrobbler/apps/scrobbles/utils.py
+++ b/vrobbler/apps/scrobbles/utils.py
@ -0,0 +1,105 @@
+import logging
+from urllib.parse import unquote
+
+from dateutil.parser import ParserError, parse
+from django.conf import settings
+
+logger = logging.getLogger(__name__)
+
+
+def convert_to_seconds(run_time: str) -> int:
+    """Jellyfin sends run time as 00:00:00 string. We want the run time to
+    actually be in seconds so we'll convert it"
+
+    This is actually deprecated, as we now convert to seconds before saving.
+    But for older videos, we'll leave this here.
+    """
+    if ":" in str(run_time):
+        run_time_list = run_time.split(":")
+        hours = int(run_time_list[0])
+        minutes = int(run_time_list[1])
+        seconds = int(run_time_list[2])
+        run_time = (((hours * 60) + minutes) * 60) + seconds
+    return int(run_time)
+
+
+def parse_mopidy_uri(uri: str) -> dict:
+    logger.debug(f"Parsing URI: {uri}")
+    parsed_uri = uri.split('/')
+
+    episode_str = unquote(parsed_uri.pop(-1).strip(".mp3"))
+    podcast_str = unquote(parsed_uri.pop(-1))
+    possible_date_str = episode_str[0:10]
+
+    try:
+        pub_date = parse(possible_date_str)
+    except ParserError:
+        pub_date = ""
+    logger.debug(f"Found pub date {pub_date} from Mopidy URI")
+
+    try:
+        if pub_date:
+            episode_num = int(episode_str.split('-')[3])
+        else:
+            episode_num = int(episode_str.split('-')[0])
+    except IndexError:
+        episode_num = None
+    except ValueError:
+        episode_num = None
+    logger.debug(f"Found episode num {episode_num} from Mopidy URI")
+
+    if pub_date:
+        episode_str = episode_str.strip(episode_str[:11])
+
+    if type(episode_num) is int:
+        episode_num_gap = len(str(episode_num)) + 1
+        episode_str = episode_str.strip(episode_str[:episode_num_gap])
+
+    episode_str = episode_str.replace('-', ' ')
+    logger.debug(f"Found episode name {episode_str} from Mopidy URI")
+
+    return {
+        'episode_filename': episode_str,
+        'episode_num': episode_num,
+        'podcast_name': podcast_str,
+        'pub_date': pub_date,
+    }
+
+
+def check_scrobble_for_finish(
+    scrobble: "Scrobble", force_to_100=False, force_finish=False
+) -> None:
+    completion_percent = scrobble.media_obj.COMPLETION_PERCENT
+
+    if scrobble.percent_played >= completion_percent or force_finish:
+        logger.info(f"{scrobble.id} {completion_percent} met, finishing")
+
+        if (
+            scrobble.playback_position_ticks
+            and scrobble.media_obj.run_time_ticks
+            and force_to_100
+        ):
+            scrobble.playback_position_ticks = (
+                scrobble.media_obj.run_time_ticks
+            )
+            logger.info(
+                f"{scrobble.playback_position_ticks} set to {scrobble.media_obj.run_time_ticks}"
+            )
+
+        scrobble.in_progress = False
+        scrobble.is_paused = False
+        scrobble.played_to_completion = True
+
+        scrobble.save(
+            update_fields=[
+                "in_progress",
+                "is_paused",
+                "played_to_completion",
+                'playback_position_ticks',
+            ]
+        )
+
+    if scrobble.percent_played % 5 == 0:
+        if getattr(settings, "KEEP_DETAILED_SCROBBLE_LOGS", False):
+            scrobble.scrobble_log += f"\n{str(scrobble.timestamp)} - {scrobble.playback_position} - {str(scrobble.playback_position_ticks)} - {str(scrobble.percent_played)}%"
+            scrobble.save(update_fields=['scrobble_log'])
--- a/vrobbler/apps/scrobbles/views.py
+++ b/vrobbler/apps/scrobbles/views.py
@ -1,56 +1,179 @@
 import json
 import logging
-from datetime import datetime, timedelta
+from datetime import datetime

-from dateutil.parser import parse
+import pytz
 from django.conf import settings
+from django.contrib.auth.mixins import LoginRequiredMixin
 from django.db.models.fields import timezone
+from django.http import FileResponse, HttpResponseRedirect, JsonResponse
+from django.urls import reverse, reverse_lazy
+from django.utils import timezone
 from django.views.decorators.csrf import csrf_exempt
+from django.views.generic import FormView
+from django.views.generic.edit import CreateView
 from django.views.generic.list import ListView
 from rest_framework import status
-from rest_framework.decorators import api_view
+from rest_framework.decorators import (
+    api_view,
+    parser_classes,
+    permission_classes,
+)
+from rest_framework.parsers import MultiPartParser
+from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
+from scrobbles.constants import (
+    JELLYFIN_AUDIO_ITEM_TYPES,
+    JELLYFIN_VIDEO_ITEM_TYPES,
+)
+from scrobbles.forms import ExportScrobbleForm, ScrobbleForm
+from scrobbles.imdb import lookup_video_from_imdb
+from scrobbles.models import AudioScrobblerTSVImport, Scrobble
+from scrobbles.scrobblers import (
+    jellyfin_scrobble_track,
+    jellyfin_scrobble_video,
+    manual_scrobble_event,
+    manual_scrobble_video,
+    mopidy_scrobble_podcast,
+    mopidy_scrobble_track,
+)
+from scrobbles.serializers import (
+    AudioScrobblerTSVImportSerializer,
+    ScrobbleSerializer,
+)
+from scrobbles.thesportsdb import lookup_event_from_thesportsdb

-from scrobbles.models import Scrobble
-from scrobbles.serializers import ScrobbleSerializer
-from videos.models import Series, Video
-from vrobbler.settings import DELETE_STALE_SCROBBLES
-from django.utils import timezone
+from vrobbler.apps.music.aggregators import (
+    scrobble_counts,
+    top_artists,
+    top_tracks,
+    week_of_scrobbles,
+)
+from vrobbler.apps.scrobbles.export import export_scrobbles

 logger = logging.getLogger(__name__)

-TRUTHY_VALUES = [
-    'true',
-    '1',
-    't',
-    'y',
-    'yes',
-    'yeah',
-    'yup',
-    'certainly',
-    'uh-huh',
-]
-

 class RecentScrobbleList(ListView):
    model = Scrobble

    def get_context_data(self, **kwargs):
        data = super().get_context_data(**kwargs)
+        user = self.request.user
        now = timezone.now()
-        last_ten_minutes = timezone.now() - timedelta(minutes=10)
-        # Find scrobbles from the last 10 minutes
-        data['now_playing_list'] = Scrobble.objects.filter(
-            in_progress=True,
-            timestamp__gte=last_ten_minutes,
-            timestamp__lte=now,
-        )
+        if user.is_authenticated:
+            if user.profile:
+                timezone.activate(pytz.timezone(user.profile.timezone))
+                now = timezone.localtime(timezone.now())
+            data['now_playing_list'] = Scrobble.objects.filter(
+                in_progress=True,
+                is_paused=False,
+                timestamp__lte=now,
+                user=user,
+            )
+
+            completed_for_user = Scrobble.objects.filter(
+                played_to_completion=True, user=user
+            )
+            data['video_scrobble_list'] = completed_for_user.filter(
+                video__isnull=False
+            ).order_by('-timestamp')[:15]
+
+            data['podcast_scrobble_list'] = completed_for_user.filter(
+                podcast_episode__isnull=False
+            ).order_by('-timestamp')[:15]
+
+            data['sport_scrobble_list'] = completed_for_user.filter(
+                sport_event__isnull=False
+            ).order_by('-timestamp')[:15]
+
+            # data['top_daily_tracks'] = top_tracks()
+            data['top_weekly_tracks'] = top_tracks(user, filter='week')
+            data['top_monthly_tracks'] = top_tracks(user, filter='month')
+
+            # data['top_daily_artists'] = top_artists()
+            data['top_weekly_artists'] = top_artists(user, filter='week')
+            data['top_monthly_artists'] = top_artists(user, filter='month')
+
+        data["weekly_data"] = week_of_scrobbles(user=user)
+
+        data['counts'] = scrobble_counts(user)
+        data['imdb_form'] = ScrobbleForm
+        data['export_form'] = ExportScrobbleForm
        return data

    def get_queryset(self):
-        return Scrobble.objects.filter(in_progress=False).order_by(
-            '-timestamp'
-        )
+        return Scrobble.objects.filter(
+            track__isnull=False, in_progress=False
+        ).order_by('-timestamp')[:15]
+
+
+class ManualScrobbleView(FormView):
+    form_class = ScrobbleForm
+    template_name = 'scrobbles/manual_form.html'
+
+    def form_valid(self, form):
+
+        item_id = form.cleaned_data.get('item_id')
+        data_dict = None
+        if 'tt' in item_id:
+            data_dict = lookup_video_from_imdb(
+                form.cleaned_data.get('item_id')
+            )
+            if data_dict:
+                manual_scrobble_video(data_dict, self.request.user.id)
+
+        if not data_dict:
+            logger.debug(f"Looking for sport event with ID {item_id}")
+            data_dict = lookup_event_from_thesportsdb(
+                form.cleaned_data.get('item_id')
+            )
+            if data_dict:
+                manual_scrobble_event(data_dict, self.request.user.id)
+
+        return HttpResponseRedirect(reverse("vrobbler-home"))
+
+
+class JsonableResponseMixin:
+    """
+    Mixin to add JSON support to a form.
+    Must be used with an object-based FormView (e.g. CreateView)
+    """
+
+    def form_invalid(self, form):
+        response = super().form_invalid(form)
+        if self.request.accepts('text/html'):
+            return response
+        else:
+            return JsonResponse(form.errors, status=400)
+
+    def form_valid(self, form):
+        # We make sure to call the parent's form_valid() method because
+        # it might do some processing (in the case of CreateView, it will
+        # call form.save() for example).
+        response = super().form_valid(form)
+        if self.request.accepts('text/html'):
+            return response
+        else:
+            data = {
+                'pk': self.object.pk,
+            }
+            return JsonResponse(data)
+
+
+class AudioScrobblerImportCreateView(
+    LoginRequiredMixin, JsonableResponseMixin, CreateView
+):
+    model = AudioScrobblerTSVImport
+    fields = ['tsv_file']
+    template_name = 'scrobbles/upload_form.html'
+    success_url = reverse_lazy('vrobbler-home')
+
+    def form_valid(self, form):
+        self.object = form.save(commit=False)
+        self.object.user = self.request.user
+        self.object.save()
+        return HttpResponseRedirect(self.get_success_url())


@csrf_exempt
@ -63,125 +186,136 @@ def scrobble_endpoint(request):


@csrf_exempt
+@permission_classes([IsAuthenticated])
@api_view(['POST'])
 def jellyfin_websocket(request):
    data_dict = request.data
-    media_type = data_dict["ItemType"]
-    imdb_id = data_dict.get("Provider_imdb", None)
-    if not imdb_id:
-        logger.error(
-            "No IMDB ID received. This is likely because all metadata is bad, not scrobbling"
-        )
-        return Response({}, status=status.HTTP_400_BAD_REQUEST)
-    # Check if it's a TV Episode
-    video_dict = {
-        "title": data_dict.get("Name", ""),
-        "imdb_id": imdb_id,
-        "video_type": Video.VideoType.MOVIE,
-        "year": data_dict.get("Year", ""),
-    }
-    if media_type == 'Episode':
-        series_name = data_dict["SeriesName"]
-        series, series_created = Series.objects.get_or_create(name=series_name)

-        video_dict['video_type'] = Video.VideoType.TV_EPISODE
-        video_dict["tv_series_id"] = series.id
-        video_dict["episode_number"] = data_dict.get("EpisodeNumber", "")
-        video_dict["season_number"] = data_dict.get("SeasonNumber", "")
-        video_dict["tvdb_id"] = data_dict.get("Provider_tvdb", None)
-        video_dict["tvrage_id"] = data_dict.get("Provider_tvrage", None)
-
-    video, video_created = Video.objects.get_or_create(**video_dict)
-
-    if video_created:
-        video.overview = data_dict["Overview"]
-        video.tagline = data_dict["Tagline"]
-        video.run_time_ticks = data_dict["RunTimeTicks"]
-        video.run_time = data_dict["RunTime"]
-        video.save()
-
-    # Now we run off a scrobble
-    timestamp = parse(data_dict["UtcTimestamp"])
-    scrobble_dict = {
-        'video_id': video.id,
-        'user_id': request.user.id,
-        'in_progress': True,
-    }
-
-    existing_scrobble = (
-        Scrobble.objects.filter(video=video, user_id=request.user.id)
-        .order_by('-modified')
-        .first()
-    )
-
-    minutes_from_now = timezone.now() + timedelta(minutes=15)
-    a_day_from_now = timezone.now() + timedelta(days=1)
-
-    existing_finished_scrobble = (
-        existing_scrobble
-        and not existing_scrobble.in_progress
-        and existing_scrobble.modified < minutes_from_now
-    )
-    existing_in_progress_scrobble = (
-        existing_scrobble
-        and existing_scrobble.in_progress
-        and existing_scrobble.modified > a_day_from_now
-    )
-    delete_stale_scrobbles = getattr(settings, "DELETE_STALE_SCROBBLES", True)
-
-    if existing_finished_scrobble:
-        logger.info(
-            'Found a scrobble for this video less than 15 minutes ago, holding off scrobbling again'
-        )
-        return Response(video_dict, status=status.HTTP_204_NO_CONTENT)
-
-    # Check if found in progress scrobble is more than a day old
-    if existing_in_progress_scrobble:
-        logger.info(
-            'Found a scrobble for this video more than a day old, creating a new scrobble'
-        )
-        scrobble = existing_in_progress_scrobble
-        scrobble_created = False
-    else:
-        if existing_in_progress_scrobble and delete_stale_scrobbles:
-            existing_in_progress_scrobble.delete()
-        scrobble, scrobble_created = Scrobble.objects.get_or_create(
-            **scrobble_dict
-        )
-
-    if scrobble_created:
-        # If we newly created this, capture the client we're watching from
-        scrobble.source = data_dict['ClientName']
-        scrobble.source_id = data_dict['MediaSourceId']
-        scrobble.scrobble_log = ""
-
-    # Update a found scrobble with new position and timestamp
-    scrobble.playback_position_ticks = data_dict["PlaybackPositionTicks"]
-    scrobble.playback_position = data_dict["PlaybackPosition"]
-    scrobble.timestamp = parse(data_dict["UtcTimestamp"])
-    scrobble.is_paused = data_dict["IsPaused"] in TRUTHY_VALUES
-    scrobble.save(
-        update_fields=[
-            'playback_position_ticks',
-            'playback_position',
-            'timestamp',
-            'is_paused',
-        ]
-    )
-
-    # If we hit our completion threshold, save it and get ready
-    # to scrobble again if we re-watch this.
-    if scrobble.percent_played >= getattr(
-        settings, "PERCENT_FOR_COMPLETION", 95
+    if (
+        data_dict['NotificationType'] == 'PlaybackProgress'
+        and data_dict['ItemType'] == 'Audio'
    ):
-        scrobble.in_progress = False
-        scrobble.playback_position_ticks = video.run_time_ticks
-        scrobble.save()
+        return Response({}, status=status.HTTP_304_NOT_MODIFIED)

-    if scrobble.percent_played % 5 == 0:
-        if getattr(settings, "KEEP_DETAILED_SCROBBLE_LOGS", False):
-            scrobble.scrobble_log += f"\n{str(scrobble.timestamp)} - {scrobble.playback_position} - {str(scrobble.playback_position_ticks)} - {str(scrobble.percent_played)}%"
-            scrobble.save(update_fields=['scrobble_log'])
-        logger.debug(f"You are {scrobble.percent_played}% through {video}")
+    # For making things easier to build new input processors
+    if getattr(settings, "DUMP_REQUEST_DATA", False):
+        json_data = json.dumps(data_dict, indent=4)
+        logger.debug(f"{json_data}")

-    return Response(video_dict, status=status.HTTP_201_CREATED)
+    scrobble = None
+    media_type = data_dict.get("ItemType", "")
+
+    if media_type in JELLYFIN_AUDIO_ITEM_TYPES:
+        scrobble = jellyfin_scrobble_track(data_dict, request.user.id)
+
+    if media_type in JELLYFIN_VIDEO_ITEM_TYPES:
+        scrobble = jellyfin_scrobble_video(data_dict, request.user.id)
+
+    if not scrobble:
+        return Response({}, status=status.HTTP_400_BAD_REQUEST)
+
+    return Response({'scrobble_id': scrobble.id}, status=status.HTTP_200_OK)
+
+
+@csrf_exempt
+@permission_classes([IsAuthenticated])
+@api_view(['POST'])
+def mopidy_websocket(request):
+    try:
+        data_dict = json.loads(request.data)
+    except TypeError:
+        logger.warning('Received Mopidy data as dict, rather than a string')
+        data_dict = request.data
+
+    # For making things easier to build new input processors
+    if getattr(settings, "DUMP_REQUEST_DATA", False):
+        json_data = json.dumps(data_dict, indent=4)
+        logger.debug(f"{json_data}")
+
+    if 'podcast' in data_dict.get('mopidy_uri'):
+        scrobble = mopidy_scrobble_podcast(data_dict, request.user.id)
+    else:
+        scrobble = mopidy_scrobble_track(data_dict, request.user.id)
+
+    if not scrobble:
+        return Response({}, status=status.HTTP_400_BAD_REQUEST)
+
+    return Response({'scrobble_id': scrobble.id}, status=status.HTTP_200_OK)
+
+
+@csrf_exempt
+@permission_classes([IsAuthenticated])
+@api_view(['POST'])
+@parser_classes([MultiPartParser])
+def import_audioscrobbler_file(request):
+    """Takes a TSV file in the Audioscrobbler format, saves it and processes the
+    scrobbles.
+    """
+    scrobbles_created = []
+    # tsv_file = request.FILES[0]
+
+    file_serializer = AudioScrobblerTSVImportSerializer(data=request.data)
+    if file_serializer.is_valid():
+        import_file = file_serializer.save()
+        return Response(
+            {'scrobble_ids': scrobbles_created}, status=status.HTTP_200_OK
+        )
+    else:
+        return Response(
+            file_serializer.errors, status=status.HTTP_400_BAD_REQUEST
+        )
+
+
+@csrf_exempt
+@permission_classes([IsAuthenticated])
+@api_view(['GET'])
+def scrobble_finish(request, uuid):
+    user = request.user
+    if not user.is_authenticated:
+        return Response({}, status=status.HTTP_403_FORBIDDEN)
+
+    scrobble = Scrobble.objects.filter(user=user, uuid=uuid).first()
+    if not scrobble:
+        return Response({}, status=status.HTTP_404_NOT_FOUND)
+    scrobble.stop(force_finish=True)
+    return Response(
+        {'id': scrobble.id, 'status': scrobble.status},
+        status=status.HTTP_200_OK,
+    )
+
+
+@csrf_exempt
+@permission_classes([IsAuthenticated])
+@api_view(['GET'])
+def scrobble_cancel(request, uuid):
+    user = request.user
+    if not user.is_authenticated:
+        return Response({}, status=status.HTTP_403_FORBIDDEN)
+
+    scrobble = Scrobble.objects.filter(user=user, uuid=uuid).first()
+    if not scrobble:
+        return Response({}, status=status.HTTP_404_NOT_FOUND)
+    scrobble.cancel()
+    return Response(
+        {'id': scrobble.id, 'status': 'cancelled'}, status=status.HTTP_200_OK
+    )
+
+
+@permission_classes([IsAuthenticated])
+@api_view(['GET'])
+def export(request):
+    format = request.GET.get('export_type', 'csv')
+    start = request.GET.get('start')
+    end = request.GET.get('end')
+    logger.debug(f"Exporting all scrobbles in format {format}")
+
+    temp_file, extension = export_scrobbles(
+        start_date=start, end_date=end, format=format
+    )
+
+    now = datetime.now()
+    filename = f"vrobbler-export-{str(now)}.{extension}"
+    response = FileResponse(open(temp_file, 'rb'))
+    response["Content-Disposition"] = f'attachment; filename="{filename}"'
+
+    return response
--- a/vrobbler/apps/sports/init.py
+++ b/vrobbler/apps/sports/init.py
--- a/vrobbler/apps/sports/admin.py
+++ b/vrobbler/apps/sports/admin.py
@ -0,0 +1,77 @@
+from django.contrib import admin
+
+from sports.models import (
+    League,
+    Player,
+    Round,
+    Season,
+    Sport,
+    SportEvent,
+    Team,
+)
+
+from scrobbles.admin import ScrobbleInline
+
+
+@admin.register(Sport)
+class SportAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    ordering = ("name",)
+
+
+@admin.register(League)
+class LeagueAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name", "abbreviation_str")
+    ordering = ("name",)
+
+
+@admin.register(Player)
+class PlayerAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name", "league", "team")
+    ordering = ("name",)
+
+
+@admin.register(Season)
+class SeasonAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name", "league")
+    ordering = ("name",)
+
+
+@admin.register(Round)
+class RoundAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name", "season")
+    ordering = ("name",)
+
+
+@admin.register(Team)
+class TeamAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = ("name", "league")
+    ordering = ("name",)
+
+
+@admin.register(SportEvent)
+class SportEventAdmin(admin.ModelAdmin):
+    date_hierarchy = "created"
+    list_display = (
+        "title",
+        "event_type",
+        "start",
+        "comp_str",
+        "round",
+    )
+    list_filter = ("round__season", "home_team", "away_team")
+    ordering = ("-created",)
+    inlines = [
+        ScrobbleInline,
+    ]
+
+    def comp_str(self, obj):
+        if obj.home_team:
+            return f'{obj.away_team} @ {obj.home_team}'
+        if obj.player_one:
+            return f'{obj.player_one} v {obj.player_two}'
--- a/vrobbler/apps/sports/apps.py
+++ b/vrobbler/apps/sports/apps.py
@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class SportsConfig(AppConfig):
+    name = "sports"
--- a/vrobbler/apps/sports/migrations/0001_initial.py
+++ b/vrobbler/apps/sports/migrations/0001_initial.py
@ -0,0 +1,214 @@
+# Generated by Django 4.1.5 on 2023-01-14 21:14
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name='League',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                (
+                    'logo',
+                    models.ImageField(
+                        blank=True, null=True, upload_to='sports/league-logos/'
+                    ),
+                ),
+                (
+                    'abbreviation_str',
+                    models.CharField(blank=True, max_length=10, null=True),
+                ),
+                ('thesportsdb_id', models.IntegerField(blank=True, null=True)),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Team',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                ('thesportsdb_id', models.IntegerField(blank=True, null=True)),
+                (
+                    'league',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='sports.league',
+                    ),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='SportEvent',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                (
+                    'title',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'run_time',
+                    models.CharField(blank=True, max_length=8, null=True),
+                ),
+                (
+                    'run_time_ticks',
+                    models.PositiveBigIntegerField(blank=True, null=True),
+                ),
+                (
+                    'event_type',
+                    models.CharField(
+                        choices=[
+                            ('UK', 'Unknown'),
+                            ('GA', 'Game'),
+                            ('MA', 'Match'),
+                            ('ME', 'Meet'),
+                        ],
+                        default='UK',
+                        max_length=2,
+                    ),
+                ),
+                ('start_utc', models.DateTimeField(blank=True, null=True)),
+                (
+                    'season',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'away_team',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        related_name='away_event_set',
+                        to='sports.team',
+                    ),
+                ),
+                (
+                    'home_team',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        related_name='home_event_set',
+                        to='sports.team',
+                    ),
+                ),
+                (
+                    'league',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='sports.league',
+                    ),
+                ),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+    ]
--- a/vrobbler/apps/sports/migrations/0002_rename_start_utc_sportevent_start.py
+++ b/vrobbler/apps/sports/migrations/0002_rename_start_utc_sportevent_start.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-01-14 21:17
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sports', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='sportevent',
+            old_name='start_utc',
+            new_name='start',
+        ),
+    ]
--- a/vrobbler/apps/sports/migrations/0003_sport_league_sport.py
+++ b/vrobbler/apps/sports/migrations/0003_sport_league_sport.py
@ -0,0 +1,71 @@
+# Generated by Django 4.1.5 on 2023-01-21 04:21
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sports', '0002_rename_start_utc_sportevent_start'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Sport',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                ('thesportsdb_id', models.IntegerField(blank=True, null=True)),
+                (
+                    'default_event_run_time',
+                    models.IntegerField(blank=True, null=True),
+                ),
+            ],
+            options={
+                'get_latest_by': 'modified',
+                'abstract': False,
+            },
+        ),
+        migrations.AddField(
+            model_name='league',
+            name='sport',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='sports.sport',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/sports/migrations/0004_alter_league_options_alter_sport_options_and_more.py
+++ b/vrobbler/apps/sports/migrations/0004_alter_league_options_alter_sport_options_and_more.py
@ -0,0 +1,254 @@
+# Generated by Django 4.1.5 on 2023-01-22 20:20
+
+from django.db import migrations, models
+import django.db.models.deletion
+import django_extensions.db.fields
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sports', '0003_sport_league_sport'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='league',
+            options={},
+        ),
+        migrations.AlterModelOptions(
+            name='sport',
+            options={},
+        ),
+        migrations.AlterModelOptions(
+            name='team',
+            options={},
+        ),
+        migrations.RemoveField(
+            model_name='sportevent',
+            name='league',
+        ),
+        migrations.AlterField(
+            model_name='league',
+            name='thesportsdb_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AlterField(
+            model_name='sport',
+            name='thesportsdb_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AlterField(
+            model_name='team',
+            name='thesportsdb_id',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.CreateModel(
+            name='Season',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                (
+                    'thesportsdb_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'league',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='sports.league',
+                    ),
+                ),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Round',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                (
+                    'thesportsdb_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'season',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='sports.season',
+                    ),
+                ),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Player',
+            fields=[
+                (
+                    'id',
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name='ID',
+                    ),
+                ),
+                (
+                    'created',
+                    django_extensions.db.fields.CreationDateTimeField(
+                        auto_now_add=True, verbose_name='created'
+                    ),
+                ),
+                (
+                    'modified',
+                    django_extensions.db.fields.ModificationDateTimeField(
+                        auto_now=True, verbose_name='modified'
+                    ),
+                ),
+                ('name', models.CharField(max_length=255)),
+                (
+                    'uuid',
+                    models.UUIDField(
+                        blank=True,
+                        default=uuid.uuid4,
+                        editable=False,
+                        null=True,
+                    ),
+                ),
+                (
+                    'thesportsdb_id',
+                    models.CharField(blank=True, max_length=255, null=True),
+                ),
+                (
+                    'league',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='sports.league',
+                    ),
+                ),
+                (
+                    'team',
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.DO_NOTHING,
+                        to='sports.team',
+                    ),
+                ),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.AddField(
+            model_name='sportevent',
+            name='player_one',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name='player_one_set',
+                to='sports.player',
+            ),
+        ),
+        migrations.AddField(
+            model_name='sportevent',
+            name='player_two',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name='player_two_set',
+                to='sports.player',
+            ),
+        ),
+        migrations.AddField(
+            model_name='sportevent',
+            name='round',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='sports.round',
+            ),
+        ),
+        migrations.AlterField(
+            model_name='sportevent',
+            name='season',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                to='sports.season',
+            ),
+        ),
+    ]
--- a/vrobbler/apps/sports/migrations/0005_remove_sportevent_season.py
+++ b/vrobbler/apps/sports/migrations/0005_remove_sportevent_season.py
@ -0,0 +1,17 @@
+# Generated by Django 4.1.5 on 2023-01-22 20:34
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sports', '0004_alter_league_options_alter_sport_options_and_more'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='sportevent',
+            name='season',
+        ),
+    ]
--- a/vrobbler/apps/sports/migrations/0006_alter_sportevent_event_type.py
+++ b/vrobbler/apps/sports/migrations/0006_alter_sportevent_event_type.py
@ -0,0 +1,22 @@
+# Generated by Django 4.1.5 on 2023-01-22 21:48
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sports', '0005_remove_sportevent_season'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='sportevent',
+            name='event_type',
+            field=models.CharField(
+                choices=[('UK', 'Unknown'), ('GA', 'Game'), ('MA', 'Match')],
+                default='UK',
+                max_length=2,
+            ),
+        ),
+    ]
--- a/vrobbler/apps/sports/migrations/0007_sport_default_event_type.py
+++ b/vrobbler/apps/sports/migrations/0007_sport_default_event_type.py
@ -0,0 +1,22 @@
+# Generated by Django 4.1.5 on 2023-01-22 22:11
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sports', '0006_alter_sportevent_event_type'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='sport',
+            name='default_event_type',
+            field=models.CharField(
+                choices=[('UK', 'Unknown'), ('GA', 'Game'), ('MA', 'Match')],
+                default='UK',
+                max_length=2,
+            ),
+        ),
+    ]
--- a/vrobbler/apps/sports/migrations/init.py
+++ b/vrobbler/apps/sports/migrations/init.py
--- a/vrobbler/apps/sports/models.py
+++ b/vrobbler/apps/sports/models.py
@ -0,0 +1,228 @@
+import logging
+from typing import Dict
+from uuid import uuid4
+
+from django.conf import settings
+from django.db import models
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+from django_extensions.db.models import TimeStampedModel
+from sqlalchemy import update
+from scrobbles.mixins import ScrobblableMixin
+from vrobbler.apps.sports.utils import (
+    get_players_from_event,
+    get_round_name_from_event,
+)
+
+logger = logging.getLogger(__name__)
+BNULL = {"blank": True, "null": True}
+
+
+class SportEventType(models.TextChoices):
+    UNKNOWN = 'UK', _('Unknown')
+    GAME = 'GA', _('Game')
+    MATCH = 'MA', _('Match')
+
+
+class TheSportsDbMixin(TimeStampedModel):
+    name = models.CharField(max_length=255)
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
+    thesportsdb_id = models.CharField(max_length=255, **BNULL)
+
+    class Meta:
+        abstract = True
+
+    def __str__(self):
+        return self.name
+
+
+class Sport(TheSportsDbMixin):
+    default_event_run_time = models.IntegerField(**BNULL)
+    default_event_type = models.CharField(
+        max_length=2,
+        choices=SportEventType.choices,
+        default=SportEventType.UNKNOWN,
+    )
+
+    # TODO Add these to the default run_time for Football
+    # run_time_seconds = 11700
+    # run_time_ticks = run_time_seconds * 1000
+    @property
+    def default_event_run_time_ticks(self):
+        default_run_time = getattr(
+            settings, 'DEFAULT_EVENT_RUNTIME_SECONDS', 14400
+        )
+        if self.default_event_run_time:
+            default_run_time = self.default_event_run_time
+        return default_run_time * 1000
+
+
+class League(TheSportsDbMixin):
+    logo = models.ImageField(upload_to="sports/league-logos/", **BNULL)
+    abbreviation_str = models.CharField(max_length=10, **BNULL)
+    sport = models.ForeignKey(Sport, on_delete=models.DO_NOTHING, **BNULL)
+
+    @property
+    def abbreviation(self):
+        return self.abbreviation_str
+
+
+class Season(TheSportsDbMixin):
+    league = models.ForeignKey(League, on_delete=models.DO_NOTHING, **BNULL)
+
+    def __str__(self):
+        return f'{self.name} season of {self.league}'
+
+
+class Team(TheSportsDbMixin):
+    league = models.ForeignKey(League, on_delete=models.DO_NOTHING, **BNULL)
+
+
+class Player(TheSportsDbMixin):
+    league = models.ForeignKey(League, on_delete=models.DO_NOTHING, **BNULL)
+    team = models.ForeignKey(Team, on_delete=models.DO_NOTHING, **BNULL)
+
+
+class Round(TheSportsDbMixin):
+    season = models.ForeignKey(Season, on_delete=models.DO_NOTHING, **BNULL)
+
+    def __str__(self):
+        return f'{self.name} of {self.season}'
+
+
+class SportEvent(ScrobblableMixin):
+    COMPLETION_PERCENT = getattr(settings, 'SPORT_COMPLETION_PERCENT', 90)
+
+    event_type = models.CharField(
+        max_length=2,
+        choices=SportEventType.choices,
+        default=SportEventType.UNKNOWN,
+    )
+    round = models.ForeignKey(Round, on_delete=models.DO_NOTHING, **BNULL)
+    start = models.DateTimeField(**BNULL)
+    home_team = models.ForeignKey(
+        Team,
+        on_delete=models.DO_NOTHING,
+        related_name='home_event_set',
+        **BNULL,
+    )
+    away_team = models.ForeignKey(
+        Team,
+        on_delete=models.DO_NOTHING,
+        related_name='away_event_set',
+        **BNULL,
+    )
+    player_one = models.ForeignKey(
+        Player,
+        on_delete=models.DO_NOTHING,
+        related_name='player_one_set',
+        **BNULL,
+    )
+    player_two = models.ForeignKey(
+        Player,
+        on_delete=models.DO_NOTHING,
+        related_name='player_two_set',
+        **BNULL,
+    )
+
+    def __str__(self):
+        return f"{self.start.date()} - {self.round} - {self.home_team} v {self.away_team}"
+
+    def get_absolute_url(self):
+        return reverse("sports:event_detail", kwargs={'slug': self.uuid})
+
+    @classmethod
+    def find_or_create(cls, data_dict: Dict) -> "Event":
+        """Given a data dict from Jellyfin, does the heavy lifting of looking up
+        the video and, if need, TV Series, creating both if they don't yet
+        exist.
+
+        """
+        # Find or create our Sport
+        sid = data_dict.get("Sport")
+        sport, s_created = Sport.objects.get_or_create(thesportsdb_id=sid)
+        if s_created:
+            sport.name = sid
+            sport.save(update_fields=['name'])
+
+        # Find or create our League
+        lid = data_dict.get("LeagueId")
+        league, l_created = League.objects.get_or_create(
+            thesportsdb_id=lid, sport=sport
+        )
+        if l_created:
+            league.sport = sport
+            league.name = data_dict.get("LeagueName", "")
+            league.save(update_fields=['sport', 'name'])
+
+        # Find or create our Season
+        seid = data_dict.get('Season')
+        season, se_created = Season.objects.get_or_create(
+            thesportsdb_id=seid, league=league
+        )
+        if se_created:
+            season.name = seid
+            season.save(update_fields=['name'])
+
+        # Find or create our Round
+        rid = data_dict.get('RoundId')
+        round, r_created = Round.objects.get_or_create(
+            thesportsdb_id=rid, season=season
+        )
+        if r_created:
+            round.season = season
+            round.save(update_fields=['season'])
+
+        # Set some special data for Tennis
+        player_one = None
+        player_two = None
+        if data_dict.get('Sport') == 'Tennis':
+            event_name = data_dict.get('Name', '')
+            if not round.name:
+                round.name = get_round_name_from_event(event_name)
+                round.save(update_fields=['name'])
+
+            players_list = get_players_from_event(event_name)
+            player_one = Player.objects.filter(
+                name__icontains=players_list[0]
+            ).first()
+            if not player_one:
+                player_one = Player.objects.create(name=players_list[0])
+            player_two = Player.objects.filter(
+                name__icontains=players_list[1]
+            ).first()
+            if not player_two:
+                player_two = Player.objects.create(name=players_list[1])
+
+        home_team = None
+        away_team = None
+        if data_dict.get("HomeTeamName"):
+            home_team_dict = {
+                "name": data_dict.get("HomeTeamName", ""),
+                "thesportsdb_id": data_dict.get("HomeTeamId", ""),
+                "league": league,
+            }
+            home_team, _created = Team.objects.get_or_create(**home_team_dict)
+
+            away_team_dict = {
+                "name": data_dict.get("AwayTeamName", ""),
+                "thesportsdb_id": data_dict.get("AwayTeamId", ""),
+                "league": league,
+            }
+            away_team, _created = Team.objects.get_or_create(**away_team_dict)
+
+        event_dict = {
+            "title": data_dict.get("Name"),
+            "event_type": sport.default_event_type,
+            "home_team": home_team,
+            "away_team": away_team,
+            "player_one": player_one,
+            "player_two": player_two,
+            "start": data_dict['Start'],
+            "round": round,
+            "run_time_ticks": data_dict.get("RunTimeTicks"),
+            "run_time": data_dict.get("RunTime", ""),
+        }
+        event, _created = cls.objects.get_or_create(**event_dict)
+
+        return event
--- a/vrobbler/apps/sports/utils.py
+++ b/vrobbler/apps/sports/utils.py
@ -0,0 +1,11 @@
+def get_round_name_from_event(event: str) -> str:
+    return ' '.join(event.split(' ')[:2])
+
+
+def get_players_from_event(event: str) -> list[str]:
+    players = []
+    event_name = get_round_name_from_event(event)
+    players_list = event.split(event_name)[1:][0].split('vs')
+    players.append(players_list[0].strip())
+    players.append(players_list[1].strip())
+    return players
--- a/vrobbler/apps/videos/admin.py
+++ b/vrobbler/apps/videos/admin.py
@ -1,16 +1,20 @@
 from django.contrib import admin
-
+from scrobbles.models import Scrobble
 from videos.models import Series, Video
+from scrobbles.admin import ScrobbleInline


+@admin.register(Series)
 class SeriesAdmin(admin.ModelAdmin):
    date_hierarchy = "created"
    list_display = ("name", "tagline")
    ordering = ("-created",)


+@admin.register(Video)
 class VideoAdmin(admin.ModelAdmin):
    date_hierarchy = "created"
+    raw_id_fields = ('tv_series',)
    list_display = (
        "title",
        "video_type",
@ -22,7 +26,6 @@ class VideoAdmin(admin.ModelAdmin):
    )
    list_filter = ("year", "tv_series", "video_type")
    ordering = ("-created",)
-
-
-admin.site.register(Series, SeriesAdmin)
-admin.site.register(Video, VideoAdmin)
+    inlines = [
+        ScrobbleInline,
+    ]
--- a/vrobbler/apps/videos/context_processors.py
+++ b/vrobbler/apps/videos/context_processors.py
@ -0,0 +1,8 @@
+from videos.models import Video, Series
+
+
+def video_lists(request):
+    return {
+        "movie_list": Video.objects.filter(video_type=Video.VideoType.MOVIE),
+        "series_list": Series.objects.all(),
+    }
--- a/vrobbler/apps/videos/migrations/0004_series_uuid_video_uuid.py
+++ b/vrobbler/apps/videos/migrations/0004_series_uuid_video_uuid.py
@ -0,0 +1,28 @@
+# Generated by Django 4.1.5 on 2023-01-08 21:31
+
+from django.db import migrations, models
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('videos', '0003_alter_video_run_time_ticks'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='series',
+            name='uuid',
+            field=models.UUIDField(
+                blank=True, default=uuid.uuid4, editable=False, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name='video',
+            name='uuid',
+            field=models.UUIDField(
+                blank=True, default=uuid.uuid4, editable=False, null=True
+            ),
+        ),
+    ]
--- a/vrobbler/apps/videos/migrations/0005_alter_video_options_alter_video_unique_together.py
+++ b/vrobbler/apps/videos/migrations/0005_alter_video_options_alter_video_unique_together.py
@ -0,0 +1,21 @@
+# Generated by Django 4.1.5 on 2023-01-11 03:23
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('videos', '0004_series_uuid_video_uuid'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='video',
+            options={},
+        ),
+        migrations.AlterUniqueTogether(
+            name='video',
+            unique_together={('title', 'imdb_id')},
+        ),
+    ]
--- a/vrobbler/apps/videos/migrations/0006_alter_video_year.py
+++ b/vrobbler/apps/videos/migrations/0006_alter_video_year.py
@ -0,0 +1,18 @@
+# Generated by Django 4.1.5 on 2023-01-13 01:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('videos', '0005_alter_video_options_alter_video_unique_together'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='video',
+            name='year',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]
--- a/vrobbler/apps/videos/models.py
+++ b/vrobbler/apps/videos/models.py
@ -1,40 +1,54 @@
-from django.db import models
-from django_extensions.db.models import TimeStampedModel
-from django.utils.translation import gettext_lazy as _
+import logging
+from typing import Dict
+from uuid import uuid4

+from django.conf import settings
+from django.db import models
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+from django_extensions.db.models import TimeStampedModel
+from scrobbles.utils import convert_to_seconds
+from scrobbles.mixins import ScrobblableMixin
+
+logger = logging.getLogger(__name__)
 BNULL = {"blank": True, "null": True}


 class Series(TimeStampedModel):
+    uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
    name = models.CharField(max_length=255)
    overview = models.TextField(**BNULL)
    tagline = models.TextField(**BNULL)
+    # tvdb_id = models.CharField(max_length=20, **BNULL)
+    # imdb_id = models.CharField(max_length=20, **BNULL)

    def __str__(self):
        return self.name

+    def imdb_link(self):
+        return f"https://www.imdb.com/title/{self.imdb_id}"
+
    class Meta:
        verbose_name_plural = "series"


-class Video(TimeStampedModel):
+class Video(ScrobblableMixin):
+    COMPLETION_PERCENT = getattr(settings, 'VIDEO_COMPLETION_PERCENT', 90)
+    SECONDS_TO_STALE = getattr(settings, 'VIDEO_SECONDS_TO_STALE', 14400)
+
    class VideoType(models.TextChoices):
        UNKNOWN = 'U', _('Unknown')
        TV_EPISODE = 'E', _('TV Episode')
        MOVIE = 'M', _('Movie')

-    # General fields
    video_type = models.CharField(
        max_length=1,
        choices=VideoType.choices,
        default=VideoType.UNKNOWN,
    )
-    title = models.CharField(max_length=255, **BNULL)
    overview = models.TextField(**BNULL)
    tagline = models.TextField(**BNULL)
-    run_time = models.CharField(max_length=8, **BNULL)
-    run_time_ticks = models.PositiveBigIntegerField(**BNULL)
-    year = models.IntegerField()
+    year = models.IntegerField(**BNULL)

    # TV show specific fields
    tv_series = models.ForeignKey(Series, on_delete=models.DO_NOTHING, **BNULL)
@ -44,9 +58,66 @@ class Video(TimeStampedModel):
    imdb_id = models.CharField(max_length=20, **BNULL)
    tvrage_id = models.CharField(max_length=20, **BNULL)

-    # Metadata fields from TMDB
+    class Meta:
+        unique_together = [['title', 'imdb_id']]

    def __str__(self):
        if self.video_type == self.VideoType.TV_EPISODE:
            return f"{self.tv_series} - Season {self.season_number}, Episode {self.episode_number}"
        return self.title
+
+    def get_absolute_url(self):
+        return reverse("videos:video_detail", kwargs={'slug': self.uuid})
+
+    @property
+    def imdb_link(self):
+        return f"https://www.imdb.com/title/{self.imdb_id}"
+
+    @classmethod
+    def find_or_create(cls, data_dict: Dict) -> "Video":
+        """Given a data dict from Jellyfin, does the heavy lifting of looking up
+        the video and, if need, TV Series, creating both if they don't yet
+        exist.
+
+        """
+        video_dict = {
+            "title": data_dict.get("Name", ""),
+            "imdb_id": data_dict.get("Provider_imdb", None),
+            "video_type": Video.VideoType.MOVIE,
+        }
+
+        series = None
+        if data_dict.get("ItemType", "") == "Episode":
+            series_name = data_dict.get("SeriesName", "")
+            series, series_created = Series.objects.get_or_create(
+                name=series_name
+            )
+            video_dict['video_type'] = Video.VideoType.TV_EPISODE
+
+        video, created = cls.objects.get_or_create(**video_dict)
+
+        run_time_ticks = data_dict.get("RunTimeTicks", None)
+        if run_time_ticks:
+            run_time_ticks = run_time_ticks // 10000
+
+        video_extra_dict = {
+            "year": data_dict.get("Year", ""),
+            "overview": data_dict.get("Overview", None),
+            "tagline": data_dict.get("Tagline", None),
+            "run_time_ticks": run_time_ticks,
+            "run_time": convert_to_seconds(data_dict.get("RunTime", "")),
+            "tvdb_id": data_dict.get("Provider_tvdb", None),
+            "tvrage_id": data_dict.get("Provider_tvrage", None),
+            "episode_number": data_dict.get("EpisodeNumber", None),
+            "season_number": data_dict.get("SeasonNumber", None),
+        }
+
+        if series:
+            video_extra_dict["tv_series_id"] = series.id
+
+        if not video.run_time_ticks:
+            for key, value in video_extra_dict.items():
+                setattr(video, key, value)
+            video.save()
+
+        return video
--- a/vrobbler/apps/videos/urls.py
+++ b/vrobbler/apps/videos/urls.py
@ -0,0 +1,21 @@
+from django.urls import path
+from videos import views
+
+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(
+        'series/<slug:slug>/',
+        views.SeriesDetailView.as_view(),
+        name='series_detail',
+    ),
+    path(
+        'video/<slug:slug>/',
+        views.VideoDetailView.as_view(),
+        name='video_detail',
+    ),
+]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Colin Powell	837e1280bd	Bump version to 0.8.3	2023-02-06 23:30:14 -05:00
Colin Powell	8f9c825903	Fix user timezones in scrobbler files	2023-02-06 23:28:57 -05:00
Colin Powell	541073aae3	Bump version to 0.8.2	2023-02-06 19:32:15 -05:00
Colin Powell	b63ec6b15f	Fix bug in export when artist does not exist	2023-02-06 19:31:25 -05:00
Colin Powell	117157e3ae	Fix audioscrobbler import bug Issue was not having a user so we couldn't set a timezone. All fixed now	2023-02-06 19:30:58 -05:00
Colin Powell	0c10e78d5e	Fix bug in unified scrobbler for podcasts	2023-02-06 17:54:48 -05:00
Colin Powell	6b7359707b	Bump version to 0.8.1	2023-02-06 01:12:33 -05:00
Colin Powell	e0295cbd56	Fix jellyfin edge case scrobbling mess Finally get to resolve scrobbling music from Jellyfin. This may lead to other issues, in fact now videos seem to sometimes create duplicate scrobbles. But music can be scrobbled now from Jellyfin web or Finamp successfully.	2023-02-06 00:22:10 -05:00
Colin Powell	5271cfaea4	Create sport if it doesn't exist yet	2023-02-06 00:19:47 -05:00
Colin Powell	0370b64351	Fix exporting only tracks by default	2023-02-06 00:19:07 -05:00
Colin Powell	9ec31ba0f5	Remove noisy debug logging	2023-02-05 01:59:24 -05:00
Colin Powell	a9de298057	Put import and export behind auth	2023-02-05 01:58:19 -05:00
Colin Powell	9d303b1b94	Add exporting and importing scrobbles	2023-02-04 17:08:01 -05:00
Colin Powell	4c434aeb7c	Bump version to 0.8.0	2023-02-03 19:00:32 -05:00
Colin Powell	64d9cac09c	Update importing to include some logging	2023-02-03 18:59:48 -05:00
Colin Powell	c21d6a96fe	Fix unused imports in imdb module	2023-02-03 16:53:03 -05:00
Colin Powell	e392477dc7	Add import of Audioscrobbler files Here we add a model for holding Audioscrobbler imports and some code to process the tab-separated files we get from Rockbox.	2023-02-03 16:45:31 -05:00
Colin Powell	12087460f6	Irritating that poetry can't handle prod deps well	2023-01-31 10:44:39 -05:00
Colin Powell	4b4fbf4777	Bump version to 0.7.5	2023-01-31 10:41:40 -05:00
Colin Powell	ca57eabf87	Another attempt to fix the Jellyfin issue This time, we simplify the progress updates, aggressively mark tracks as 100 played if they are marked played_to_completion, and implement a hack for Jellyfin spamming us with progress updates less than a second apart.	2023-01-31 10:28:54 -05:00
Colin Powell	6fc51d9296	Fix resurrecting past tracks This may also be hack, but I think that if the playback position ticks are automatically jumped to the run time ticks of the media object, it should stop the resurrection of past scrobbles, because they will be appropriately marked as being 100 played when the scrobble is finished. The only weirdness here is that "in progress" scrobbles will suddenly complete once the media type's threshold is met (90, 95 percent, whatever). But it should be better than overwriting old scrobbles.	2023-01-30 23:18:42 -05:00
Colin Powell	6e582e25e3	Bump version to 0.7.4	2023-01-30 18:32:31 -05:00
Colin Powell	eed344ae46	Add the beginnings of charts This commit adds a lot of files, but most of them have no impact on any other code. The thrust here is to start creating chart pages showing which tracks and artists were most played for various time periods. Lots still not working, but we're getting there.	2023-01-30 18:29:18 -05:00
Colin Powell	41570dc2f9	Fix duplicate Jellyfin music scrobbling bug Solution is identical to what we were already doing with videos. When looking for existing scrobbles, don't filter by completion, but just check if the scrobble was played to completion. This does create another irritating situation where old scrobbles from days, months or even years ago that were not played to completion will be resurrected and made current here. But that's way less annoying than having spam scrobbles at the end of every track.	2023-01-30 18:25:27 -05:00
Colin Powell	24c3f5b4d8	Bump version to 0.7.3	2023-01-29 14:41:05 -05:00
Colin Powell	703dc3c181	Add a sample envrc file	2023-01-29 14:32:25 -05:00
Colin Powell	93550c5734	Allow looking up artwork by release group Historically we'd just fail if the specific MB release did not have artwork, but this is silly. If the release itself does not have artwork, we should also check the release group failing.	2023-01-29 14:31:31 -05:00
Colin Powell	951fa225bb	Add todos and get them updated	2023-01-29 14:31:12 -05:00
Colin Powell	2e7470688d	Update TODOs and fix tests	2023-01-24 16:44:11 -05:00
Colin Powell	8ac938bd12	Should probably avoid bug fixing under hydrocodone	2023-01-24 15:25:19 -05:00
Colin Powell	160f15a101	Add cover art to latest listening	2023-01-24 15:24:41 -05:00
Colin Powell	b6e0607aab	Fix jellyfin video scrobbles for real	2023-01-24 02:41:48 -05:00
Colin Powell	bbbcfca04f	Add a rudimentary todo doc	2023-01-23 12:01:26 -05:00
Colin Powell	ace0d1d9fe	Bump version to 0.7.2 - Add django-redis to deps - Use django-redis to fix cachalot issue	2023-01-22 18:36:56 -05:00
Colin Powell	b0fb62bdb9	Upgrade to django-redis for cachalot	2023-01-22 18:36:36 -05:00
Colin Powell	7796ff5786	Bump version to 0.7.1	2023-01-22 18:34:23 -05:00
Colin Powell	2285c5bfd6	Fix bug in jellyfin scrobbler	2023-01-22 18:34:02 -05:00
Colin Powell	132d63bb5d	Bump version to 0.7.0	2023-01-22 18:29:29 -05:00
Colin Powell	49bf57dd58	Copmletely rejigger sports to accomodate tennis	2023-01-22 18:27:33 -05:00
Colin Powell	506de848d7	Pull client name from Jellyfin if provided	2023-01-21 23:57:25 -05:00
Colin Powell	d05256f249	Add authorization and per-user scrobbling The webhook endpoints now require a token before it will accept a scrobble. That auth then provides the user to assign the scrobble to.	2023-01-21 23:41:35 -05:00
Colin Powell	646c7ab99c	Add ability to cancel and finish manual scrobbles	2023-01-20 14:03:23 -05:00
Colin Powell	7fc3705455	Fix a bug in IMDB lookups for episodes	2023-01-20 13:23:23 -05:00
Colin Powell	cbe4abfb5f	First tests for imdb module	2023-01-20 13:02:32 -05:00
Colin Powell	13bdc201f0	Add more hacky tests	2023-01-20 00:09:45 -05:00
Colin Powell	4f5ea7cd25	Fix aggregator tests to use users and time-machine	2023-01-20 00:01:34 -05:00
Colin Powell	b3b3b28b92	Add tests for top_tracks	2023-01-19 23:52:01 -05:00
Colin Powell	9ed3d034cf	Fix shadowed test function	2023-01-19 21:52:23 -05:00
Colin Powell	8e4a41a279	Update gitignore file	2023-01-19 20:49:16 -05:00
Colin Powell	0cdde59de4	Add aggregator tests	2023-01-19 20:49:01 -05:00
Colin Powell	65e713e43e	Remove some files from coverage	2023-01-19 15:37:47 -05:00
Colin Powell	0d95f8fee8	Fix bug in unique tracks on different albums	2023-01-19 15:20:26 -05:00
Colin Powell	6712e38689	Update drone badge to use main branch	2023-01-19 14:53:06 -05:00
Colin Powell	4ed5fde672	Update coverage map	2023-01-19 14:52:16 -05:00
Colin Powell	1c5f721723	Fix coverage argument	2023-01-19 14:48:33 -05:00
Colin Powell	39547c6e5c	Add a test conf file	2023-01-19 14:47:54 -05:00
Colin Powell	7447a97117	Add coverage run to drone	2023-01-19 14:44:51 -05:00
Colin Powell	6aa933d13d	Fix bad test imports	2023-01-19 14:41:02 -05:00
Colin Powell	3bb73ae4be	Add init files to tests	2023-01-19 14:34:10 -05:00
Colin Powell	a57269b09a	Run pytest with drone	2023-01-19 14:30:04 -05:00
Colin Powell	68423488ff	Start adding tests	2023-01-19 14:29:25 -05:00
Colin Powell	e75c22d583	Add timezone support and an authenticated view	2023-01-18 00:39:12 -05:00
Colin Powell	a0af0bce05	Add user profile with a timezone	2023-01-17 22:20:00 -05:00
Colin Powell	fd984d7460	Replace weekly artists with monthly	2023-01-17 17:23:13 -05:00
Colin Powell	065fc98a87	Fix bug in Jellyfin scrobbling We need to have a default value when we pop off a dictionary, and we need to clear both mopidy and jellyfin status before we look a scrobble up. We may also want simplify status so we don't have mopidy and jellyfin cruft.	2023-01-17 16:38:17 -05:00
Colin Powell	6db5a00917	Fix caching issue with fixed 5 minute timeout	2023-01-17 13:33:21 -05:00
Colin Powell	734aa6073b	Add cachalot to help fix slow views	2023-01-17 13:09:43 -05:00
Colin Powell	77362d3207	Fix scrobble spam from Jellyfin The issue here was that we update a Jellyfin scrobble to be complete when it hits a certain threshold of percentage played (90) and then we stop finding that scrobble while the video finishes playing. This happens over and over again, so once a video reaches 90 percent played we get dozens more scrobbles for each update as the video finishes playing. This is a crude fix, for the spam, as we'll end up "resuming" videos that are stopped at 95 percent. So we need some way to mark the scrobble as complete. I think forcing the percent to 100 on finish might work.	2023-01-17 11:41:48 -05:00
Colin Powell	9d4db65b3c	Remove whitenoise compression storage	2023-01-17 00:13:28 -05:00
Colin Powell	e850d46539	Clean up gitignore a little	2023-01-17 00:11:14 -05:00
Colin Powell	907ef802bc	Bump version to 0.6.2 Releases * Fix for double scrobbling * Fix error messages * Fix bug in IMDB lookup when runtime is missing * Fix filter order with annotations for top tracks and artists * Fix error in completion percentage issues	2023-01-17 00:05:54 -05:00
Colin Powell	d700b581a1	Fix filter order with annotations We were getting all artists of all time, not just for the time period	2023-01-17 00:02:20 -05:00
Colin Powell	7605c672f6	Fix str rep for scrobbles	2023-01-16 23:54:19 -05:00
Colin Powell	8d1df806d7	Fix IMDB fetch when runtimes are not present	2023-01-16 23:46:04 -05:00
Colin Powell	0f562b7c58	Fix resume bug, stop trying to avoid resuming Turns out trying to not resume in-progress Scrobbles is super painful. Maybe I'll come up with a better idea later, but for now, I'd rather just resurrect old paused scrobbles of past tracks, rather than completely mess up all other aspects of scrobbling.	2023-01-16 23:44:49 -05:00
Colin Powell	fe53b68714	Fix silly error message	2023-01-16 20:40:02 -05:00
Colin Powell	7e2915850f	Fix double scrobbling for real	2023-01-16 20:39:27 -05:00
Colin Powell	90687a6b43	Fix complicated completion percentage	2023-01-16 19:36:10 -05:00
Colin Powell	07cfb03eb6	Fix really irritating double scrobble bug	2023-01-16 19:34:40 -05:00
Colin Powell	58be8d26a0	Bump version to 0.6.1	2023-01-16 17:53:14 -05:00
Colin Powell	0fede269b1	Fix checking for completion percentages	2023-01-16 17:52:07 -05:00
Colin Powell	6cdcf4ff6f	Fix Mopidy resuming messing things up	2023-01-16 16:12:01 -05:00
Colin Powell	0634b94368	Fix how we calcualte resuming a scrobble	2023-01-16 13:43:14 -05:00
Colin Powell	0ab7c563cf	Fix favicon static files and logging	2023-01-15 19:06:54 -05:00
Colin Powell	363a132df2	Bump version to 0.6.0	2023-01-15 02:42:14 -05:00
Colin Powell	c484905d11	Add manual scrobbling by TheSportsDB ID	2023-01-15 02:41:36 -05:00
Colin Powell	0378dfe6eb	Add drone badge	2023-01-15 01:45:35 -05:00
Colin Powell	c39443e35b	Bump versoin to 0.5.1	2023-01-15 01:43:36 -05:00
Colin Powell	bb3dfdf7ba	Fix small debug log error	2023-01-15 01:42:46 -05:00
Colin Powell	fdfb8a635e	Add monthly tracks to homepage	2023-01-15 01:40:41 -05:00
Colin Powell	290e6dc8d9	Fixing flow for mopidy scrobble	2023-01-15 01:20:18 -05:00
Colin Powell	499546503c	Fix README to use markdown	2023-01-14 16:46:46 -05:00
Colin Powell	bd3a381346	Add sports as a preliminary scobble type	2023-01-14 16:42:48 -05:00
Colin Powell	e206a7fbf3	Fix display of TV episode and season on homepage	2023-01-14 10:37:38 -05:00
Colin Powell	6313da9868	Work towards unifiying manual scrobbling	2023-01-13 17:56:44 -05:00
Colin Powell	f7c69a6763	Bump version to 0.5.0	2023-01-13 17:15:33 -05:00
Colin Powell	ab88fcb9a7	Fix lookup bug in track year	2023-01-13 17:15:13 -05:00
Colin Powell	1d868d3075	Add manual scrobble to main page	2023-01-13 17:12:50 -05:00
Colin Powell	5b07c70ca2	Add scrobble inlines to admin classes	2023-01-13 17:06:29 -05:00
Colin Powell	9607fb2d1e	Make way for more manual scrobbling options ... Next stop, sports games!	2023-01-13 16:52:45 -05:00
Colin Powell	e6cf126f5c	Add rudimentary manual scrobbling	2023-01-13 16:47:06 -05:00
Colin Powell	eeee6eea4e	Fix seconds calculator	2023-01-13 14:26:25 -05:00
Colin Powell	1f26931215	Fix Now playing widget	2023-01-13 00:14:50 -05:00
Colin Powell	610ec63cbd	Fix bug in non-series video not scrobbling THe season and episode numbers need to be None, not an empty string.	2023-01-13 00:01:34 -05:00
Colin Powell	72fded4097	Bump version to 0.4.3	2023-01-12 23:51:58 -05:00
Colin Powell	d5eea53a01	Actually fix bug in loading extra video meta	2023-01-12 23:51:10 -05:00
Colin Powell	a49eb31276	Add podcasts to template list	2023-01-12 23:50:57 -05:00
Colin Powell	c1e1160db3	Bump version to 0.4.2	2023-01-12 23:39:11 -05:00
Colin Powell	0e17831724	Fix bug in load extra video info	2023-01-12 23:38:34 -05:00
Colin Powell	045fad8552	Remove errant base template	2023-01-12 22:59:29 -05:00
Colin Powell	a09c6d6b92	Bump version to 0.4.1	2023-01-12 21:34:17 -05:00
Colin Powell	3f8b29f5ee	Dramatically simplify the scrobblig code	2023-01-12 21:33:45 -05:00
Colin Powell	507b3aaaf2	Bump version to 0.4.0	2023-01-12 16:11:50 -05:00
Colin Powell	879357473a	Add hack to fix Mopidy progress	2023-01-12 16:07:53 -05:00
Colin Powell	cc7d267494	Update repeated attributes for scrobblable models	2023-01-12 16:05:47 -05:00
Colin Powell	685c99d023	Fix proper scrobbling of podcasts	2023-01-12 16:05:29 -05:00
Colin Powell	69f596039d	Add better property for multiple media types This adds a fun helper method on Scrobble instances to get whatever the type should be based on media_obj	2023-01-12 15:42:05 -05:00
Colin Powell	cf55c9b464	Fix parsing of podcast episode titles	2023-01-12 14:12:10 -05:00
Colin Powell	8517212d0e	Add podcasts as new media type	2023-01-12 13:56:56 -05:00
Colin Powell	f435e60b80	Add very rudimentary fetching of art and metadata from MB	2023-01-12 11:10:25 -05:00
Colin Powell	b51b189cd4	Fix sidebar to be accurate	2023-01-11 11:58:56 -05:00
Colin Powell	2a20d1212b	Bump version to 0.3.0	2023-01-11 11:56:12 -05:00
Colin Powell	83b6ba9cc3	Add tabs and clean up main page	2023-01-11 11:55:44 -05:00
Colin Powell	4f0d5ad7f4	Bump version to 0.2.2	2023-01-10 23:48:21 -05:00
Colin Powell	2b81b28bff	Fix bug with duplicate Jellyfin scrobbles	2023-01-10 23:47:26 -05:00
Colin Powell	d0c88ce271	Bump version to 0.2.1	2023-01-10 16:14:33 -05:00
Colin Powell	f8c9df3b9a	Fix artist aggregation so it works	2023-01-10 16:13:52 -05:00
Colin Powell	8b61dab1bc	Fix aggregator and blacken things up	2023-01-10 15:21:12 -05:00
Colin Powell	3655cd7934	Bump version to 0.2.0	2023-01-10 14:41:56 -05:00
Colin Powell	602d1e0ddb	Add better frontend, the first of many!	2023-01-10 14:40:59 -05:00
Colin Powell	457828e04d	Fix silly bug in classmethods for Scrobbles	2023-01-10 14:40:09 -05:00
Colin Powell	49889ae297	Bump version to 0.1.9	2023-01-09 17:49:46 -05:00
Colin Powell	4d573bc934	Fix bug where video scrobbles never start	2023-01-09 17:49:11 -05:00
Colin Powell	bdd0f19161	Add start of a rating model for tracks	2023-01-09 11:20:37 -05:00
Colin Powell	cc0c573c51	Bump version to 0.1.8	2023-01-09 00:31:46 -05:00
Colin Powell	28bd9ad504	Start filling out content urls	2023-01-09 00:29:55 -05:00
Colin Powell	657b194dc7	Fix small typo in debug logs	2023-01-08 23:10:24 -05:00
Colin Powell	27ffd35826	Fix bug with Jellyfin mbrainz IDs being poor Turns out Jellyfin uses a really esoteric form of Musicbrainz ID for tracks. Instead of using the recording ID, it uses the specific hash for a given version of a recording. A noble effrot to be specific, but we'd much rather use Mopidy's recording ID when it's available. Thus, we'll use Jellyfin's ID if that's all we have, but if we scrobble the same track from Mopidy, overwrite the value.	2023-01-08 23:08:36 -05:00
Colin Powell	da64cb2b6f	Use logical filters for scrobble admin No need to filter by video, but in progress and source are pretty handy.	2023-01-08 23:00:34 -05:00
Colin Powell	09e96a55d4	First try at fixing bad MD data from Jellyfin	2023-01-08 19:44:41 -05:00
Colin Powell	e4027402ed	Add scrobble count property to tracks	2023-01-08 19:44:07 -05:00
Colin Powell	4dc1599633	Add uuid fields for slugs at some point	2023-01-08 16:51:50 -05:00
Colin Powell	71a8a19491	Add context processors for base template	2023-01-08 16:49:13 -05:00
Colin Powell	1ec4333856	Add fallback duration tracking for Mopidy Unlike Jellyfin, Mopidy's webhook only gives us a start and stopped call to determine when a track should be scrobbled. This means we don't have continous updating of playback ticks. This commit adds a fallback when ticks are not there to use the track duration and time since the scrobble was created. That said, this is not perfect. If you pause the track and start again, the progress will get very out of whack. But thankfully, Mopidy only sends us audio, and it's rare that audio tracks are paused repeatedly and started again before finishing a scrobble. So hopefully this shouldn't happen very often.	2023-01-08 14:09:18 -05:00
Colin Powell	f98fe4635c	Clean up display of last scrobbles	2023-01-08 14:08:57 -05:00
Colin Powell	c3b48099bf	Bump version to 0.1.7	2023-01-08 02:52:12 -05:00
Colin Powell	1476fe37ca	Auth is jamming up the works right now	2023-01-08 02:51:35 -05:00
Colin Powell	842378e812	Need to load JSON data	2023-01-08 02:50:54 -05:00
Colin Powell	07ad6005c8	Add rudimentary support for mopidy-webhooks	2023-01-08 00:26:24 -05:00
Colin Powell	638be0b56a	Refactor scrobbling code and add Music If you send Track data from the Jellyfin Webhook plugin, we'll do the right thing with it. Lots more to do to clean this up, but it also involved moduralizing the code for scrobbling so it's a little simpler to understand what's going on.	2023-01-07 19:34:11 -05:00
Colin Powell	9c0d85c5d2	Bump version to 0.1.6	2023-01-06 16:26:22 -05:00
Colin Powell	1b58ea4538	Fix max-height bug on dl for in progress scrobble	2023-01-06 16:24:00 -05:00