Bump version to 0.4.0

Add hack to fix Mopidy progress
Update repeated attributes for scrobblable models
2023-01-12 16:11:50 -05:00 · 2023-01-12 16:07:53 -05:00 · 2023-01-12 16:05:47 -05:00 · 2023-01-12 16:05:29 -05:00 · 2023-01-12 15:42:05 -05:00 · 2023-01-12 14:12:10 -05:00
51 changed files with 2320 additions and 246 deletions
--- a/poetry.lock
+++ b/poetry.lock
@ -625,6 +625,14 @@ category = "dev"
 optional = false
 python-versions = ">=3.6"

+[[package]]
+name = "musicbrainzngs"
+version = "0.7.1"
+description = "Python bindings for the MusicBrainz NGS and the Cover Art Archive webservices"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
 [[package]]
 name = "mypy"
 version = "0.961"
@ -1369,7 +1377,7 @@ testing = ["flake8 (<5)", "func-timeout", "jaraco.functools", "jaraco.itertools"
 [metadata]
 lock-version = "1.1"
 python-versions = "^3.8"
-content-hash = "6105971e3adba942edffa16bd54f5822cdcabcd1e55dfecfc67410cf486a1a71"
+content-hash = "f8d6b69cfb8ac53b7e03533e8fede68d323363bd73b9c7902d958dc433b1210e"

 [metadata.files]
 amqp = [
@ -1719,6 +1727,10 @@ mccabe = [
    {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"},
    {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
 ]
+musicbrainzngs = [
+    {file = "musicbrainzngs-0.7.1-py2.py3-none-any.whl", hash = "sha256:e841a8f975104c0a72290b09f59326050194081a5ae62ee512f41915090e1a10"},
+    {file = "musicbrainzngs-0.7.1.tar.gz", hash = "sha256:ab1c0100fd0b305852e65f2ed4113c6de12e68afd55186987b8ed97e0f98e627"},
+]
 mypy = [
    {file = "mypy-0.961-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:697540876638ce349b01b6786bc6094ccdaba88af446a9abb967293ce6eaa2b0"},
    {file = "mypy-0.961-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b117650592e1782819829605a193360a08aa99f1fc23d1d71e1a75a142dc7e15"},
@ -1769,6 +1781,13 @@ pbr = [
    {file = "pbr-5.11.0.tar.gz", hash = "sha256:b97bc6695b2aff02144133c2e7399d5885223d42b7912ffaec2ca3898e673bfe"},
 ]
 pillow = [
+    {file = "Pillow-9.4.0-1-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1b4b4e9dda4f4e4c4e6896f93e84a8f0bcca3b059de9ddf67dac3c334b1195e1"},
+    {file = "Pillow-9.4.0-1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:fb5c1ad6bad98c57482236a21bf985ab0ef42bd51f7ad4e4538e89a997624e12"},
+    {file = "Pillow-9.4.0-1-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:f0caf4a5dcf610d96c3bd32932bfac8aee61c96e60481c2a0ea58da435e25acd"},
+    {file = "Pillow-9.4.0-1-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:3f4cc516e0b264c8d4ccd6b6cbc69a07c6d582d8337df79be1e15a5056b258c9"},
+    {file = "Pillow-9.4.0-1-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:b8c2f6eb0df979ee99433d8b3f6d193d9590f735cf12274c108bd954e30ca858"},
+    {file = "Pillow-9.4.0-1-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:b70756ec9417c34e097f987b4d8c510975216ad26ba6e57ccb53bc758f490dab"},
+    {file = "Pillow-9.4.0-1-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:43521ce2c4b865d385e78579a082b6ad1166ebed2b1a2293c3be1d68dd7ca3b9"},
    {file = "Pillow-9.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:2968c58feca624bb6c8502f9564dd187d0e1389964898f5e9e1fbc8533169157"},
    {file = "Pillow-9.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c5c1362c14aee73f50143d74389b2c158707b4abce2cb055b7ad37ce60738d47"},
    {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd752c5ff1b4a870b7661234694f24b1d2b9076b8bf337321a814c612665f343"},
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vrobbler"
-version = "0.1.4"
+version = "0.4.0"
 description = ""
 authors = ["Colin Powell <colin@unbl.ink>"]

@ -27,6 +27,7 @@ django-markdownify = "^0.9.1"
 gunicorn = "^20.1.0"
 django-simple-history = "^3.1.1"
 whitenoise = "^6.3.0"
+musicbrainzngs = "^0.7.1"

 [tool.poetry.dev-dependencies]
 Werkzeug = "2.0.3"
--- a/templates/base.html
+++ b/templates/base.html
@ -0,0 +1,25 @@
+<!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/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,35 @@
+from django.contrib import admin
+
+from music.models import Artist, Album, Track
+
+
+@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",)
--- a/vrobbler/apps/music/aggregators.py
+++ b/vrobbler/apps/music/aggregators.py
@ -0,0 +1,105 @@
+from django.db.models import Q, Count, Sum
+from typing import List, Optional
+from scrobbles.models import Scrobble
+from music.models import Track, Artist
+from videos.models import Video
+
+from django.utils import timezone
+from datetime import datetime, timedelta
+
+
+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():
+    finished_scrobbles_qs = Scrobble.objects.filter(in_progress=False)
+    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(media: str = 'tracks') -> dict[str, int]:
+    scrobble_day_dict = {}
+    media_filter = Q(track__isnull=False)
+
+    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')
+        if media == 'movies':
+            media_filter = Q(video__videotype=Video.VideoType.MOVIE)
+        if media == 'series':
+            media_filter = Q(video__videotype=Video.VideoType.TV_EPISODE)
+        scrobble_day_dict[day_of_week] = (
+            Scrobble.objects.filter(media_filter)
+            .filter(
+                timestamp__gte=start,
+                timestamp__lte=end,
+                in_progress=False,
+            )
+            .count()
+        )
+
+    return scrobble_day_dict
+
+
+def top_tracks(filter: str = "today", limit: int = 15) -> List["Track"]:
+    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.annotate(num_scrobbles=Count("scrobble", distinct=True))
+        .filter(time_filter)
+        .order_by("-num_scrobbles")[:limit]
+    )
+
+
+def top_artists(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.annotate(
+            num_scrobbles=Count("track__scrobble", distinct=True)
+        )
+        .filter(time_filter)
+        .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/init.py
+++ b/vrobbler/apps/music/migrations/init.py
--- a/vrobbler/apps/music/models.py
+++ b/vrobbler/apps/music/models.py
@ -0,0 +1,147 @@
+import logging
+from typing import Dict, Optional
+from uuid import uuid4
+
+import musicbrainzngs
+from django.apps.config import cached_property
+from django.core.files.base import ContentFile
+from django.db import models
+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}"
+
+
+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):
+        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:
+            self.year = mb_data['release']['date'][0:4]
+        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):
+        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)
+            self.save()
+        except musicbrainzngs.ResponseError:
+            logger.warning(f'No cover art found for {self.name}')
+
+    @property
+    def mb_link(self):
+        return f"https://musicbrainz.org/release/{self.musicbrainz_id}"
+
+
+class Track(ScrobblableMixin):
+    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, unique=True, **BNULL)
+
+    def __str__(self):
+        return f"{self.title} by {self.artist}"
+
+    @property
+    def mb_link(self):
+        return f"https://musicbrainz.org/recording/{self.musicbrainz_id}"
+
+    @cached_property
+    def scrobble_count(self):
+        return self.scrobble_set.filter(in_progress=False).count()
+
+    @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)
+        if artist_created:
+            logger.debug(f"Created new album {artist}")
+        else:
+            logger.debug(f"Found album {artist}")
+
+        album, album_created = Album.objects.get_or_create(**album_dict)
+        if album_created:
+            logger.debug(f"Created new album {album}")
+        else:
+            logger.debug(f"Found album {album}")
+        album.fix_metadata()
+        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)
+        if created:
+            logger.debug(f"Created new track: {track}")
+        else:
+            logger.debug(f"Found track {track}")
+
+        return track
--- 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,33 @@
+#!/usr/bin/env python3
+from django.contrib import admin
+from podcasts.models import Episode, Podcast, Producer
+
+
+@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",)
--- 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/init.py
+++ b/vrobbler/apps/podcasts/migrations/init.py
--- a/vrobbler/apps/podcasts/models.py
+++ b/vrobbler/apps/podcasts/models.py
@ -0,0 +1,85 @@
+import logging
+from typing import Dict, Optional
+from uuid import uuid4
+
+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):
+    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/scrobbles/admin.py
+++ b/vrobbler/apps/scrobbles/admin.py
@ -3,17 +3,33 @@ from django.contrib import admin
 from scrobbles.models import Scrobble


+@admin.register(Scrobble)
 class ScrobbleAdmin(admin.ModelAdmin):
    date_hierarchy = "timestamp"
    list_display = (
-        "video",
        "timestamp",
+        "media_name",
+        "media_type",
        "source",
        "playback_position",
        "in_progress",
+        "is_paused",
    )
-    list_filter = ("video",)
+    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

-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"
--- a/vrobbler/apps/scrobbles/constants.py
+++ b/vrobbler/apps/scrobbles/constants.py
@ -0,0 +1,3 @@
+#!/usr/bin/env python3
+JELLYFIN_VIDEO_ITEM_TYPES = ["Episode", "Movie"]
+JELLYFIN_AUDIO_ITEM_TYPES = ["Audio"]
--- 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/mixins.py
+++ b/vrobbler/apps/scrobbles/mixins.py
@ -0,0 +1,17 @@
+from uuid import uuid4
+
+from django.db import models
+from django_extensions.db.models import TimeStampedModel
+
+BNULL = {"blank": True, "null": True}
+
+
+class ScrobblableMixin(TimeStampedModel):
+    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,32 @@
+import logging
+from datetime import timedelta
+from typing import Optional
+
+from django.conf import settings
 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 Track
+from podcasts.models import Episode
+from scrobbles.utils import check_scrobble_for_finish
 from videos.models import Video

+logger = logging.getLogger(__name__)
 User = get_user_model()
 BNULL = {"blank": True, "null": True}
+VIDEO_BACKOFF = getattr(settings, 'VIDEO_BACKOFF_MINUTES')
+TRACK_BACKOFF = getattr(settings, 'MUSIC_BACKOFF_SECONDS')
+VIDEO_WAIT_PERIOD = getattr(settings, 'VIDEO_WAIT_PERIOD_DAYS')
+TRACK_WAIT_PERIOD = getattr(settings, 'MUSIC_WAIT_PERIOD_MINUTES')


 class Scrobble(TimeStampedModel):
-    video = models.ForeignKey(Video, on_delete=models.DO_NOTHING)
+    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
+    )
    user = models.ForeignKey(
        User, blank=True, null=True, on_delete=models.DO_NOTHING
    )
@ -25,9 +42,213 @@ class Scrobble(TimeStampedModel):

    @property
    def percent_played(self) -> int:
-        return int(
-            (self.playback_position_ticks / self.video.run_time_ticks) * 100
-        )
+        if (
+            self.playback_position_ticks
+            and self.media_obj.run_time_ticks
+            and source != 'Mopidy'
+        ):
+            return int(
+                (self.playback_position_ticks / self.media_obj.run_time_ticks)
+                * 100
+            )
+        # If we don't have media_obj.run_time_ticks, let's guess from created time
+        now = timezone.now()
+        playback_duration = (now - self.created).seconds
+        if playback_duration and self.media_obj.run_time:
+            return int(
+                (playback_duration / int(self.media_obj.run_time)) * 100
+            )
+
+        return 0
+
+    def is_stale(self, backoff, wait_period) -> bool:
+        scrobble_is_stale = self.in_progress and self.modified > wait_period
+
+        # Check if found in progress scrobble is more than a day old
+        if scrobble_is_stale:
+            logger.info(
+                'Found a in-progress scrobble for this item more than a day old, creating a new scrobble'
+            )
+            delete_stale_scrobbles = getattr(
+                settings, "DELETE_STALE_SCROBBLES", True
+            )
+
+            if delete_stale_scrobbles:
+                logger.info(
+                    'Deleting {scrobble} that has been in-progress too long'
+                )
+                self.delete()
+
+        return scrobble_is_stale
+
+    @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
+        return media_obj

    def __str__(self):
-        return f"Scrobble of {self.video} {self.timestamp.year}-{self.timestamp.month}"
+        return f"Scrobble of {self.media_obj} {self.timestamp.year}-{self.timestamp.month}"
+
+    @classmethod
+    def create_or_update_for_video(
+        cls, video: "Video", user_id: int, jellyfin_data: dict
+    ) -> "Scrobble":
+        jellyfin_data['video_id'] = video.id
+        logger.debug(
+            f"Creating or updating scrobble for video {video} with data {jellyfin_data}"
+        )
+        scrobble = (
+            cls.objects.filter(video=video, user_id=user_id)
+            .order_by('-modified')
+            .first()
+        )
+
+        # Backoff is how long until we consider this a new scrobble
+        backoff = timezone.now() + timedelta(minutes=VIDEO_BACKOFF)
+        wait_period = timezone.now() + timedelta(days=VIDEO_WAIT_PERIOD)
+
+        return cls.update_or_create(
+            scrobble, backoff, wait_period, jellyfin_data
+        )
+
+    @classmethod
+    def create_or_update_for_track(
+        cls, track: "Track", user_id: int, scrobble_data: dict
+    ) -> "Scrobble":
+        scrobble_data['track_id'] = track.id
+        scrobble = (
+            cls.objects.filter(track=track, user_id=user_id)
+            .order_by('-modified')
+            .first()
+        )
+        logger.debug(
+            f"Found existing scrobble for track {track}, updating",
+            {"scrobble_data": scrobble_data},
+        )
+
+        backoff = timezone.now() + timedelta(seconds=TRACK_BACKOFF)
+        wait_period = timezone.now() + timedelta(minutes=TRACK_WAIT_PERIOD)
+
+        return cls.update_or_create(
+            scrobble, backoff, wait_period, scrobble_data
+        )
+
+    @classmethod
+    def create_or_update_for_podcast_episode(
+        cls, episode: "Episode", user_id: int, scrobble_data: dict
+    ) -> "Scrobble":
+        scrobble_data['podcast_episode_id'] = episode.id
+        scrobble = (
+            cls.objects.filter(podcast_episode=episode, user_id=user_id)
+            .order_by('-modified')
+            .first()
+        )
+        logger.debug(
+            f"Found existing scrobble for podcast {episode}, updating",
+            {"scrobble_data": scrobble_data},
+        )
+
+        backoff = timezone.now() + timedelta(seconds=TRACK_BACKOFF)
+        wait_period = timezone.now() + timedelta(minutes=TRACK_WAIT_PERIOD)
+
+        return cls.update_or_create(
+            scrobble, backoff, wait_period, scrobble_data
+        )
+
+    @classmethod
+    def update_or_create(
+        cls,
+        scrobble: Optional["Scrobble"],
+        backoff,
+        wait_period,
+        scrobble_data: dict,
+    ) -> Optional["Scrobble"]:
+
+        # Status is a field we get from Mopidy, which refuses to poll us
+        mopidy_status = scrobble_data.pop('status', None)
+        scrobble_is_stale = False
+
+        if scrobble:
+            logger.debug(f"Updating scrobble ticks")
+            scrobble.playback_position_ticks = scrobble_data.get(
+                "playback_position_ticks"
+            )
+            scrobble.save(update_fields=['playback_position_ticks'])
+
+        if mopidy_status == "stopped":
+            logger.info(f"Mopidy sent a message to stop {scrobble}")
+            if not scrobble:
+                logger.warning(
+                    'Mopidy sent us a stopped message, without ever starting'
+                )
+                return
+
+            # Mopidy finished a play, scrobble away
+            scrobble.in_progress = False
+            scrobble.played_to_completion = True
+            scrobble.save(
+                update_fields=['in_progress', 'played_to_completion']
+            )
+            return scrobble
+
+        if mopidy_status == "paused":
+            logger.info(f"Mopidy sent a message to pause {scrobble}")
+            if not scrobble:
+                logger.info("Message to pause while not started, ignoring")
+                return
+            if scrobble.is_paused:
+                logger.info("Message to pause while paused, ignoring")
+                return
+
+            # Mopidy finished a play, scrobble away
+            scrobble.is_paused = True
+            scrobble.save(update_fields=["is_paused"])
+            scrobble = check_scrobble_for_finish(scrobble)
+            return scrobble
+
+        if mopidy_status == "resumed":
+            logger.info(f"Mopidy sent a message to resume {scrobble}")
+            if not scrobble:
+                logger.info("Message to resume while not started, ignoring")
+                return
+            if not scrobble.is_paused:
+                logger.info("Message to resume while not paused, resuming")
+            # Mopidy finished a play, scrobble away
+            scrobble.is_paused = False
+            scrobble.save(update_fields=["is_paused"])
+            return scrobble
+
+        if scrobble and not mopidy_status:
+            scrobble_is_finished = (
+                not scrobble.in_progress and scrobble.modified < backoff
+            )
+            if scrobble_is_finished:
+                logger.info(
+                    'Found a very recent scrobble for this item, holding off scrobbling again'
+                )
+                return
+
+            scrobble_is_stale = scrobble.is_stale(backoff, wait_period)
+
+        if (not scrobble or scrobble_is_stale) or mopidy_status:
+            # If we default this to "" we can probably remove this
+            scrobble_data['scrobble_log'] = ""
+            scrobble = cls.objects.create(
+                **scrobble_data,
+            )
+        else:
+            for key, value in scrobble_data.items():
+                setattr(scrobble, key, value)
+            scrobble.save()
+
+        # If we hit our completion threshold, save it and get ready
+        # to scrobble again if we re-watch this.
+        scrobble = check_scrobble_for_finish(scrobble)
+
+        return scrobble
--- a/vrobbler/apps/scrobbles/scrobblers.py
+++ b/vrobbler/apps/scrobbles/scrobblers.py
@ -0,0 +1,93 @@
+import logging
+from typing import Optional
+
+from django.utils import timezone
+from music.models import Track
+from podcasts.models import Episode
+from scrobbles.models import Scrobble
+from scrobbles.utils import parse_mopidy_uri
+
+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",
+        "status": data_dict.get("status"),
+    }
+
+    scrobble = None
+    if episode:
+        scrobble = Scrobble.create_or_update_for_podcast_episode(
+            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",
+        "status": data_dict.get("status"),
+    }
+
+    scrobble = None
+    if track:
+        # 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_for_track(
+            track, user_id, mopidy_data
+        )
+    return scrobble
--- a/vrobbler/apps/scrobbles/urls.py
+++ b/vrobbler/apps/scrobbles/urls.py
@ -6,4 +6,5 @@ app_name = 'scrobbles'
 urlpatterns = [
    path('', views.scrobble_endpoint, name='scrobble-list'),
    path('jellyfin/', views.jellyfin_websocket, name='jellyfin-websocket'),
+    path('mopidy/', views.mopidy_websocket, name='mopidy-websocket'),
 ]
--- a/vrobbler/apps/scrobbles/utils.py
+++ b/vrobbler/apps/scrobbles/utils.py
@ -0,0 +1,91 @@
+import logging
+from typing import Any
+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"""
+    if ":" in run_time:
+        run_time_list = run_time.split(":")
+        run_time = (int(run_time_list[1]) * 60) + int(run_time_list[2])
+    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") -> None:
+    completion_percent = getattr(settings, "MUSIC_COMPLETION_PERCENT", 90)
+    if scrobble.podcast_episode:
+        completion_percent = getattr(
+            settings, "PODCAST_COMPLETION_PERCENT", 25
+        )
+    logger.debug(f"Completion set to {completion_percent}")
+
+    if scrobble.percent_played >= completion_percent:
+        logger.debug(
+            f"{scrobble} meets completion goal of {completion_percent}, finishing"
+        )
+        scrobble.in_progress = False
+        scrobble.is_paused = False
+        scrobble.playback_position_ticks = scrobble.media_obj.run_time_ticks
+        scrobble.save(
+            update_fields=[
+                "in_progress",
+                "is_paused",
+                "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'])
+
+    return scrobble
--- a/vrobbler/apps/scrobbles/views.py
+++ b/vrobbler/apps/scrobbles/views.py
@ -5,17 +5,29 @@ from datetime import datetime, timedelta
 from dateutil.parser import parse
 from django.conf import settings
 from django.db.models.fields import timezone
+from django.utils import timezone
 from django.views.decorators.csrf import csrf_exempt
 from django.views.generic.list import ListView
+from music.constants import JELLYFIN_POST_KEYS as KEYS
+from music.models import Track
 from rest_framework import status
 from rest_framework.decorators import api_view
 from rest_framework.response import Response
-
+from scrobbles.constants import (
+    JELLYFIN_AUDIO_ITEM_TYPES,
+    JELLYFIN_VIDEO_ITEM_TYPES,
+)
 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 scrobbles.utils import convert_to_seconds
+from videos.models import Video
+from vrobbler.apps.music.aggregators import (
+    scrobble_counts,
+    top_artists,
+    top_tracks,
+    week_of_scrobbles,
+)
+from scrobbles.scrobblers import mopidy_scrobble_podcast, mopidy_scrobble_track

 logger = logging.getLogger(__name__)

@ -38,19 +50,33 @@ class RecentScrobbleList(ListView):
    def get_context_data(self, **kwargs):
        data = super().get_context_data(**kwargs)
        now = timezone.now()
-        last_ten_minutes = timezone.now() - timedelta(minutes=10)
+        last_eight_minutes = timezone.now() - timedelta(minutes=8)
        # Find scrobbles from the last 10 minutes
        data['now_playing_list'] = Scrobble.objects.filter(
            in_progress=True,
-            timestamp__gte=last_ten_minutes,
+            is_paused=False,
+            timestamp__gte=last_eight_minutes,
            timestamp__lte=now,
        )
+        data['video_scrobble_list'] = Scrobble.objects.filter(
+            video__isnull=False, in_progress=False
+        ).order_by('-timestamp')[:10]
+        data['top_daily_tracks'] = top_tracks()
+        data['top_weekly_tracks'] = top_tracks(filter='week')
+        data['top_monthly_tracks'] = top_tracks(filter='month')
+
+        data['top_daily_artists'] = top_artists()
+        data['top_weekly_artists'] = top_artists(filter='week')
+        data['top_monthly_artists'] = top_artists(filter='month')
+
+        data["weekly_data"] = week_of_scrobbles()
+        data['counts'] = scrobble_counts()
        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]


@csrf_exempt
@ -66,122 +92,112 @@ def scrobble_endpoint(request):
@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)
+    # 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}")

-    video, video_created = Video.objects.get_or_create(**video_dict)
+    media_type = data_dict.get("ItemType", "")

-    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()
+    track = None
+    video = None
+    if media_type in JELLYFIN_AUDIO_ITEM_TYPES:
+        if not data_dict.get("Provider_musicbrainztrack", None):
+            logger.error(
+                "No MBrainz Track ID received. This is likely because all metadata is bad, not scrobbling"
+            )
+            return Response({}, status=status.HTTP_400_BAD_REQUEST)
+
+        artist_dict = {
+            'name': data_dict.get(KEYS["ARTIST_NAME"], None),
+            'musicbrainz_id': data_dict.get(KEYS["ARTIST_MB_ID"], None),
+        }
+
+        album_dict = {
+            "name": data_dict.get(KEYS["ALBUM_NAME"], None),
+            "year": data_dict.get(KEYS["YEAR"], ""),
+            "musicbrainz_id": data_dict.get(KEYS['ALBUM_MB_ID']),
+            "musicbrainz_releasegroup_id": data_dict.get(
+                KEYS["RELEASEGROUP_MB_ID"]
+            ),
+            "musicbrainz_albumartist_id": data_dict.get(KEYS["ARTIST_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(KEYS["RUN_TIME_TICKS"], None)
+            // 10000,
+            "run_time": convert_to_seconds(
+                data_dict.get(KEYS["RUN_TIME"], None)
+            ),
+        }
+        track = Track.find_or_create(artist_dict, album_dict, track_dict)
+
+    if media_type in JELLYFIN_VIDEO_ITEM_TYPES:
+        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 Response({}, status=status.HTTP_400_BAD_REQUEST)
+        video = Video.find_or_create(data_dict)

    # 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,
+    jellyfin_data = {
+        "user_id": request.user.id,
+        "timestamp": parse(data_dict.get("UtcTimestamp")),
+        "playback_position_ticks": data_dict.get("PlaybackPositionTicks")
+        // 10000,
+        "playback_position": convert_to_seconds(
+            data_dict.get("PlaybackPosition")
+        ),
+        "source": "Jellyfin",
+        "source_id": data_dict.get('MediaSourceId'),
+        "is_paused": data_dict.get("IsPaused") in TRUTHY_VALUES,
    }

-    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'
+    scrobble = None
+    if video:
+        scrobble = Scrobble.create_or_update_for_video(
+            video, request.user.id, jellyfin_data
        )
-        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'
+    if track:
+        # Prefer Mopidy MD IDs to Jellyfin, so skip if we already have one
+        if not track.musicbrainz_id:
+            track.musicbrainz_id = data_dict.get(KEYS["TRACK_MB_ID"], None)
+            track.save()
+        scrobble = Scrobble.create_or_update_for_track(
+            track, request.user.id, jellyfin_data
        )
-        scrobble = existing_in_progress_scrobble
-        scrobble_created = False
+
+    if not scrobble:
+        return Response({}, status=status.HTTP_400_BAD_REQUEST)
+
+    return Response(
+        {'scrobble_id': scrobble.id}, status=status.HTTP_201_CREATED
+    )
+
+
+@csrf_exempt
+@api_view(['POST'])
+def mopidy_websocket(request):
+    data_dict = json.loads(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:
-        if existing_in_progress_scrobble and delete_stale_scrobbles:
-            existing_in_progress_scrobble.delete()
-        scrobble, scrobble_created = Scrobble.objects.get_or_create(
-            **scrobble_dict
-        )
+        scrobble = mopidy_scrobble_track(data_dict, request.user.id)

-    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 = ""
+    if not scrobble:
+        return Response({}, status=status.HTTP_400_BAD_REQUEST)

-    # 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',
-        ]
+    return Response(
+        {'scrobble_id': scrobble.id}, status=status.HTTP_201_CREATED
    )
-
-    # 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
-    ):
-        scrobble.in_progress = False
-        scrobble.playback_position_ticks = video.run_time_ticks
-        scrobble.save()
-
-    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}")
-
-    return Response(video_dict, status=status.HTTP_201_CREATED)
--- 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/models.py
+++ b/vrobbler/apps/videos/models.py
@ -1,39 +1,49 @@
-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.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):
    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()

    # TV show specific fields
@ -44,9 +54,60 @@ 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,
+            "year": data_dict.get("Year", ""),
+            "overview": data_dict.get("Overview", None),
+            "tagline": data_dict.get("Tagline", None),
+            "run_time_ticks": data_dict.get("RunTimeTicks", 0) // 10000,
+            "run_time": convert_to_seconds(data_dict.get("RunTime", "")),
+        }
+
+        if data_dict.get("ItemType", "") == "Episode":
+            series_name = data_dict.get("SeriesName", "")
+            series, series_created = Series.objects.get_or_create(
+                name=series_name
+            )
+            if series_created:
+                logger.debug(f"Created new series {series}")
+            else:
+                logger.debug(f"Found series {series}")
+            video_dict['video_type'] = Video.VideoType.TV_EPISODE
+            video_dict["tv_series_id"] = series.id
+            video_dict["tvdb_id"] = data_dict.get("Provider_tvdb", None)
+            video_dict["tvrage_id"] = data_dict.get("Provider_tvrage", None)
+            video_dict["episode_number"] = data_dict.get("EpisodeNumber", "")
+            video_dict["season_number"] = data_dict.get("SeasonNumber", "")
+
+        video, created = cls.objects.get_or_create(**video_dict)
+
+        if created:
+            logger.debug(f"Created new video: {video}")
+        else:
+            logger.debug(f"Found video {video}")
+
+        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 = 'scrobbles'
+
+
+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/vrobbler/apps/videos/views.py
+++ b/vrobbler/apps/videos/views.py
@ -0,0 +1,25 @@
+from django.views import generic
+from videos.models import Series, Video
+
+# class VideoIndexView():
+
+
+class MovieListView(generic.ListView):
+    model = Video
+
+    def get_queryset(self):
+        return Video.objects.filter(video_type=Video.VideoType.MOVIE)
+
+
+class SeriesListView(generic.ListView):
+    model = Series
+
+
+class SeriesDetailView(generic.DetailView):
+    model = Series
+    slug_field = 'uuid'
+
+
+class VideoDetailView(generic.DetailView):
+    model = Video
+    slug_field = 'uuid'
--- a/vrobbler/cli.py
+++ b/vrobbler/cli.py
@ -6,15 +6,18 @@ from os import environ as env

 if not 'DJANGO_SETTINGS_MODULE' in env:
    from vrobbler import settings
+
    env.setdefault('DJANGO_SETTINGS_MODULE', settings.__name__)


 import django
+
 django.setup()

 # this line must be after django.setup() for logging configure
 logger = logging.getLogger('vrobbler')

+
 def main():
    # to get configured settings
    from django.conf import settings
--- a/vrobbler/settings.py
+++ b/vrobbler/settings.py
@ -37,8 +37,27 @@ KEEP_DETAILED_SCROBBLE_LOGS = os.getenv(
    "VROBBLER_KEEP_DETAILED_SCROBBLE_LOGS", False
 )

+PODCAST_COMPLETION_PERCENT = os.getenv(
+    "VROBBLER_PODCAST_COMPLETION_PERCENT", 25
+)
+MUSIC_COMPLETION_PERCENT = os.getenv("VROBBLER_MUSIC_COMPLETION_PERCENT", 90)
+
+# Should we cull old in-progress scrobbles that are beyond the wait period for resuming?
 DELETE_STALE_SCROBBLES = os.getenv("VROBBLER_DELETE_STALE_SCROBBLES", True)

+# Used to dump data coming from srobbling sources, helpful for building new inputs
+DUMP_REQUEST_DATA = os.getenv("VROBBLER_DUMP_REQUEST_DATA", False)
+
+VIDEO_BACKOFF_MINUTES = os.getenv("VROBBLER_VIDEO_BACKOFF_MINUTES", 15)
+MUSIC_BACKOFF_SECONDS = os.getenv("VROBBLER_VIDEO_BACKOFF_SECONDS", 5)
+
+# If you stop waching or listening to a track, how long should we wait before we
+# give up on the old scrobble and start a new one? This could also be considered
+# a "continue in progress scrobble" time period. So if you pause the media and
+# start again, should it be a new scrobble.
+VIDEO_WAIT_PERIOD_DAYS = os.getenv("VROBBLER_VIDEO_WAIT_PERIOD_DAYS", 1)
+MUSIC_WAIT_PERIOD_MINUTES = os.getenv("VROBBLER_VIDEO_BACKOFF_MINUTES", 1)
+
 TMDB_API_KEY = os.getenv("VROBBLER_TMDB_API_KEY", "")

 DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
@ -65,14 +84,18 @@ INSTALLED_APPS = [
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "django.contrib.sites",
+    "django.contrib.humanize",
    "django_filters",
    "django_extensions",
    'rest_framework.authtoken',
    "scrobbles",
    "videos",
+    "music",
+    "podcasts",
    "rest_framework",
    "allauth",
    "allauth.account",
+    "allauth.socialaccount",
    "django_celery_results",
 ]

@ -103,6 +126,8 @@ TEMPLATES = [
                "django.template.context_processors.request",
                "django.contrib.auth.context_processors.auth",
                "django.contrib.messages.context_processors.messages",
+                "videos.context_processors.video_lists",
+                "music.context_processors.music_lists",
            ],
        },
    },
@ -144,8 +169,8 @@ AUTHENTICATION_BACKENDS = [
 REST_FRAMEWORK = {
    "DEFAULT_PERMISSION_CLASSES": ("rest_framework.permissions.AllowAny",),
    'DEFAULT_AUTHENTICATION_CLASSES': [
-        'rest_framework.authentication.BasicAuthentication',
-        'rest_framework.authentication.TokenAuthentication',
+        #'rest_framework.authentication.BasicAuthentication',
+        #'rest_framework.authentication.TokenAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ],
    "DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.PageNumberPagination",
--- a/vrobbler/templates/base.html
+++ b/vrobbler/templates/base.html
@ -1,27 +1,26 @@
 {% load static %}
+{% load humanize %}
 <!doctype html>
 <html class="no-js" lang="">
    <head>
-        <title>{% block page_title %}Welcome{% endblock %} | Vrobbler &raquo; For video scrobbling</title>
+        <title>{% block page_title %}Scrobble all the things{% endblock %} @ Vrobbler</title>
        <meta charset="utf-8">
        <meta http-equiv="x-ua-compatible" content="ie=edge">
        <meta name="description" content="">
        <meta name="viewport" content="width=device-width, initial-scale=1">
-        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.0.0/dist/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+        <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
+        <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
        <script src="https://code.jquery.com/jquery-3.3.1.js" integrity="sha256-2Kok7MbOyxpgUVvAk/HJ2jigOSYS2auK4Pfzbm7uH60=" crossorigin="anonymous"></script>
-        <script src="https://cdn.jsdelivr.net/npm/bootstrap@4.0.0/dist/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.10/clipboard.min.js"></script>
-
        <style type="text/css">
        dl {
            display: flex;
            flex-flow: column wrap;
-            max-height: 6em;
            border: 1px solid #777;
        }
        dt {
            padding: 2px 4px;
-            background: #777;
+            background: #000;
            color: #fff;
        }
        dd {
@ -30,99 +29,286 @@
            min-height: 3em;
            border-right: 1px solid #777;
        }
-        #library-update-status { margin-right:10px; }
-        .card img { width:18em; padding: 1em; }
-        .card-block { padding: 1em 0 1em 0; }
-        .system-badge { padding: 1em; font-size: normal; }
-        .updating { color:#aaa; margin-right: 8px; }
-        .high { color: green; }
-        .medium { color: #aaa;}
-        .low { color: red; }
-        .card {
-            height: auto;
-            display: flex;
+        .latest-scrobble {
+            width: 50%;
        }
-        .card-columns{
-            display: grid;
-            overflow: hidden;
-            grid-template-columns: repeat(2, 1fr);
-            grid-auto-rows: 1fr;
-            grid-column-gap: 20px;
-            grid-row-gap: 10px;
+
+        .progress-bar {
+            width: 100%;
+            background-color: #e0e0e0;
+            padding: 3px;
+            border-radius: 3px;
+            box-shadow: inset 0 1px 3px rgba(0, 0, 0, .2);
        }
-        {% for system in game_systems %}
-        .{{system.retropie_slug}} { background: #{{system.get_color}}; }
-        {% endfor %}
+
+        .progress-bar-fill {
+            display: block;
+            height: 22px;
+            background-color: #659cef;
+            border-radius: 3px;
+            transition: width 500ms ease-in-out;
+        }
+        .bd-placeholder-img {
+            font-size: 1.125rem;
+            text-anchor: middle;
+            -webkit-user-select: none;
+            -moz-user-select: none;
+            user-select: none;
+        }
+
+        @media (min-width: 768px) {
+            .bd-placeholder-img-lg {
+            font-size: 3.5rem;
+            }
+        }
+        body {
+        font-size: .875rem;
+        }
+
+        .feather {
+        width: 16px;
+        height: 16px;
+        vertical-align: text-bottom;
+        }
+
+        /*
+        * Sidebar
+        */
+
+        .sidebar {
+        position: fixed;
+        top: 0;
+        /* rtl:raw:
+        right: 0;
+        */
+        bottom: 0;
+        /* rtl:remove */
+        left: 0;
+        z-index: 100; /* Behind the navbar */
+        padding: 48px 0 0; /* Height of navbar */
+        box-shadow: inset -1px 0 0 rgba(0, 0, 0, .1);
+        }
+
+        @media (max-width: 767.98px) {
+        .sidebar {
+            top: 5rem;
+        }
+        }
+
+        .sidebar-sticky {
+        position: relative;
+        top: 0;
+        height: calc(100vh - 48px);
+        padding-top: .5rem;
+        overflow-x: hidden;
+        overflow-y: auto; /* Scrollable contents if viewport is shorter than content. */
+        }
+
+        .sidebar .nav-link {
+        font-weight: 500;
+        color: #333;
+        }
+
+        .sidebar .nav-link .feather {
+        margin-right: 4px;
+        color: #727272;
+        }
+
+        .sidebar .nav-link.active {
+        color: #2470dc;
+        }
+
+        .sidebar .nav-link:hover .feather,
+        .sidebar .nav-link.active .feather {
+        color: inherit;
+        }
+
+        .sidebar-heading {
+        font-size: .75rem;
+        text-transform: uppercase;
+        }
+
+        /*
+        * Navbar
+        */
+
+        .navbar-brand {
+        padding-top: .75rem;
+        padding-bottom: .75rem;
+        font-size: 1rem;
+        background-color: rgba(0, 0, 0, .25);
+        box-shadow: inset -1px 0 0 rgba(0, 0, 0, .25);
+        }
+
+        .navbar .navbar-toggler {
+        top: .25rem;
+        right: 1rem;
+        }
+
+        .navbar .form-control {
+        padding: .75rem 1rem;
+        border-width: 0;
+        border-radius: 0;
+        }
+
+        .form-control-dark {
+        color: #fff;
+        background-color: rgba(255, 255, 255, .1);
+        border-color: rgba(255, 255, 255, .1);
+        }
+
+        .form-control-dark:focus {
+        border-color: transparent;
+        box-shadow: 0 0 0 3px rgba(255, 255, 255, .25);
+        }
+
        </style>
        {% block head_extra %}{% endblock %}

        <link rel="apple-touch-icon" href="/apple-touch-icon.png">
        <!-- Place favicon.ico in the root directory -->
-
-        <script>
-        function checkUpdate(){
-            $.get('/library/update/status/', function(data) {
-                $('#library-update-status').html("");
-                console.log('Checking for task');
-                setTimeout(checkUpdate,5000);
-            });
-        }
-        </script>
-
    </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]-->
-        <div class="container">
-            <nav class="navbar navbar-expand-lg navbar-light bg-light">
-            <a class="navbar-brand" href="#">Vrobbler</a>
-            <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
+        <header class="navbar navbar-dark sticky-top bg-dark flex-md-nowrap p-0 shadow">
+            <a class="navbar-brand col-md-3 col-lg-2 me-0 px-3" href="#">Vrobbler</a>
+            <button class="navbar-toggler position-absolute d-md-none collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#sidebarMenu" aria-controls="sidebarMenu" aria-expanded="false" aria-label="Toggle navigation">
                <span class="navbar-toggler-icon"></span>
            </button>
-
-            <div class="collapse navbar-collapse" id="navbarSupportedContent">
-                <ul class="navbar-nav mr-auto">
-                <li class="nav-item">
-                    <a class="nav-link" href="{% url 'home' %}">Recent<span class="sr-only"></span></a>
-                </li>
-                <li class="nav-item dropdown">
-                    <a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Movies</a>
-                    <div class="dropdown-menu" aria-labelledby="navbarDropdown">
-                        <a class="dropdown-item" href="{ url "games:gamesystem_list" %}">All</a>
-                        {% for system in game_systems %}
-                        <a class="dropdown-item" href="{{system.get_absolute_url}}">{{system.name}} ({{system.game_set.count}})</a>
-                        {% endfor %}
-                    </div>
-                </li>
-                <li class="nav-item dropdown">
-                    <a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Shows</a>
-                    <div class="dropdown-menu" aria-labelledby="navbarDropdown">
-                        <a class="dropdown-item" href="{ url "games:gamecollection_list" %}">All</a>
-                        {% for collection in game_collections %}
-                        <a class="dropdown-item" href="{{collection.get_absolute_url}}">{{collection.name}} ({{collection.games.count}})</a>
-                        {% endfor %}
-                    </div>
-                </li>
-                </ul>
+            <input class="form-control form-control-dark w-100" type="text" placeholder="Search" aria-label="Search">
+            <div class="navbar-nav">
+                <div class="nav-item text-nowrap">
+                {% if user.is_authenticated %}
+                <a class="nav-link px-3" href="{% url "account_logout" %}">Sign out</a>
+                {% else %}
+                <a class="nav-link px-3" href="{% url "account_login" %}">Sign in</a>
+                {% endif %}
+                </div>
            </div>
-            {% if request.user.is_authenticated %}
-            <a class="nav-link" href="{% url 'account_logout' %}">Logout<span class="sr-only"></span></a>
-            {% else %}
-            <a class="nav-link" href="{% url 'account_login' %}">Login<span class="sr-only"></span></a>
-            {% endif %}
-            </nav>
+        </header>

-            <h1>{% block title %}{% endblock %}</h1>
+        <div class="container-fluid">
+            <div class="row">
+                <nav id="sidebarMenu" class="col-md-3 col-lg-2 d-md-block bg-light sidebar collapse">
+                    <div class="position-sticky pt-3">
+                        {% if now_playing_list %}
+                        <ul style="padding-right:10px;">
+                            <b>Now playing</b>
+                            {% for scrobble in now_playing_list %}
+                            <div>
+                                {{scrobble.media_obj.title}}<br/>
+                                {% if scrobble.track %}<em>{{scrobble.track.artist}}</em><br/>{% endif %}
+                                {% if scrobble.podcast_episode%}<em>{{scrobble.podcast_episode.podcast}}</em><br/>{% endif %}
+                                <small>{{scrobble.created|naturaltime}}<br/>
+                                    from {{scrobble.source}}</small>
+                                <div class="progress-bar" style="margin-right:5px;">
+                                    <span class="progress-bar-fill" style="width: {{scrobble.percent_played}}%;"></span>
+                                </div>
+                            </div>
+                            <hr/>
+                            {% endfor %}
+                        </ul>
+                        {% endif %}
+
+
+                        <ul class="nav flex-column">
+                            <li class="nav-item">
+                                <a class="nav-link active" aria-current="page" href="#">
+                                <span data-feather="music"></span>
+                                Dashboard
+                                </a>
+                            </li>
+                            <li class="nav-item">
+                                <a class="nav-link" aria-current="page" href="/tracks/">
+                                <span data-feather="music"></span>
+                                Tracks
+                                </a>
+                            </li>
+                            <li class="nav-item">
+                                <a class="nav-link" href="/artists/">
+                                <span data-feather="user"></span>
+                                Artists
+                                </a>
+                            </li>
+                            <li class="nav-item">
+                                <a class="nav-link" href="/movies/">
+                                <span data-feather="film"></span>
+                                Movies
+                                </a>
+                            </li>
+                            <li class="nav-item">
+                                <a class="nav-link" href="/series/">
+                                <span data-feather="tv"></span>
+                                Series
+                                </a>
+                            </li>
+                            {% if user.is_authenticated %}
+                            <li class="nav-item">
+                                <a class="nav-link" href="/admin/">
+                                <span data-feather="key"></span>
+                                Admin
+                                </a>
+                            </li>
+                            {% endif %}
+                        </ul>
+                        {% block extra_nav %}
+                        {% endblock %}
+
+                    </div>
+                </nav>

-            <div>
                {% block content %}
                {% endblock %}
            </div>
        </div>
+        {% block extra_js %}
+        <script src="https://cdn.jsdelivr.net/npm/feather-icons@4.28.0/dist/feather.min.js" integrity="sha384-uO3SXW5IuS1ZpFPKugNNWqTZRRglnUJK6UAZ/gxOX80nxEkN9NcGZTftn6RzhGWE" crossorigin="anonymous"></script><script src="https://cdn.jsdelivr.net/npm/chart.js@2.9.4/dist/Chart.min.js" integrity="sha384-zNy6FEbO50N+Cg5wap8IKA4M/ZnLJgzc6w2NqACZaK0u0FXfOWRRJOnQtpZun8ha" crossorigin="anonymous"></script>
+        <script><!-- comment ------------------------------------------------->
+            /* globals Chart:false, feather:false */
+            (function () {
+            'use strict'
+
+            feather.replace({ 'aria-hidden': 'true' })
+
+            // Graphs
+            var ctx = document.getElementById('myChart')
+            // eslint-disable-next-line no-unused-vars
+            var myChart = new Chart(ctx, {
+                type: 'line',
+                data: {
+                  labels: [
+                      {% for day in weekly_data.keys %}
+                      "{{day}}"{% if not forloop.last %},{% endif %}
+                      {% endfor %}
+                  ],
+                  datasets: [{
+                      data: [
+                      {% for count in weekly_data.values %}
+                      {{count}}{% if not forloop.last %},{% endif %}
+                      {% endfor %}
+                      ],
+                      lineTension: 0,
+                      backgroundColor: 'transparent',
+                      borderColor: '#007bf0',
+                      borderWidth: 4,
+                      pointBackgroundColor: '#007bff'
+                  }]
+                },
+                options: {
+                  scales: {
+                      yAxes: [{
+                      ticks: {
+                          beginAtZero: false
+                      }
+                      }]
+                  },
+                  legend: {
+                      display: false
+                  }
+                }
+            })
+            })()
+
+        </script>
+        {% endblock %}
    </body>
 </html>
--- a/vrobbler/templates/scrobbles/scrobble_list.html
+++ b/vrobbler/templates/scrobbles/scrobble_list.html
@ -1,20 +1,151 @@
 {% extends "base.html" %}
+{% load humanize %}

-{% block title %}{% endblock %}

 {% block content %}
-    {% if now_playing_list %}
-    <h2>Now playing</h2>
-    <ul>
-        {% for scrobble in now_playing_list %}
-        <li>{{scrobble.timestamp|date:"D, M j Y"}}: <a href="https://www.imdb.com/title/{{scrobble.video.imdb_id}}">{{scrobble.video}}</a></li>
-        {% endfor %}
-    </ul>
-    {% endif %}
-    <h2>Last scrobbles</h2>
-    <ul>
-        {% for scrobble in object_list %}
-        <li>{{scrobble.timestamp|date:"D, M j Y"}}: <a href="https://www.imdb.com/title/{{scrobble.video.imdb_id}}">{{scrobble.video}}</a></li>
-        {% endfor %}
-    </ul>
+<main class="col-md-4 ms-sm-auto col-lg-10 px-md-4">
+    <div class="d-flex justify-content-between flex-wrap flex-md-nowrap align-items-center pt-3 pb-2 mb-3 border-bottom">
+        <h1 class="h2">Dashboard</h1>
+        <div class="btn-toolbar mb-2 mb-md-0">
+        <div class="btn-group me-2">
+            <button type="button" class="btn btn-sm btn-outline-secondary">Share</button>
+            <button type="button" class="btn btn-sm btn-outline-secondary">Export</button>
+        </div>
+        <button type="button" class="btn btn-sm btn-outline-secondary dropdown-toggle">
+            <span data-feather="calendar"></span>
+            This week
+        </button>
+        </div>
+    </div>
+
+    <canvas class="my-4 w-100" id="myChart" width="900" height="220"></canvas>
+
+    <div class="container">
+
+        <div class="row">
+            <p>Today <b>{{counts.today}}</b> | This Week <b>{{counts.week}}</b> | This Month <b>{{counts.month}}</b> | This Year <b>{{counts.year}}</b> | All Time <b>{{counts.alltime}}</b></p>
+        </div>
+        <div class="row">
+            <div class="col-md">
+                <ul class="nav nav-tabs" id="myTab" role="tablist">
+                    <li class="nav-item" role="presentation">
+                        <button class="nav-link active" id="home-tab" data-bs-toggle="tab" data-bs-target="#artists-week" type="button" role="tab" aria-controls="home" aria-selected="true">Weekly Artists</button>
+                    </li>
+                    <li class="nav-item" role="presentation">
+                        <button class="nav-link" id="profile-tab" data-bs-toggle="tab" data-bs-target="#tracks-week" type="button" role="tab" aria-controls="profile" aria-selected="false">Weekly Tracks</button>
+                    </li>
+                </ul>
+
+                <div class="tab-content" id="myTabContent">
+                    <div class="tab-pane fade show" id="artists-week" role="tabpanel" aria-labelledby="artists-week-tab">
+                        <h2>Top artists this week</h2>
+                        <div class="table-responsive">
+                            <table class="table table-striped table-sm">
+                            <thead>
+                                <tr>
+                                    <th scope="col">#</th>
+                                    <th scope="col">Artist</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {% for artist in top_weekly_artists %}
+                                <tr>
+                                    <td>{{artist.num_scrobbles}}</td>
+                                    <td>{{artist.name}}</td>
+                                </tr>
+                                {% endfor %}
+                            </tbody>
+                            </table>
+                        </div>
+                    </div>
+
+                    <div class="tab-pane fade show active" id="tracks-week" role="tabpanel" aria-labelledby="tracks-week-tab">
+                        <h2>Top tracks this week</h2>
+                        <div class="table-responsive">
+                            <table class="table table-striped table-sm">
+                            <thead>
+                                <tr>
+                                    <th scope="col">#</th>
+                                    <th scope="col">Track</th>
+                                    <th scope="col">Artist</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {% for track in top_weekly_tracks %}
+                                <tr>
+                                    <td>{{track.num_scrobbles}}</td>
+                                    <td>{{track.title}}</td>
+                                    <td>{{track.artist.name}}</td>
+                                </tr>
+                                {% endfor %}
+                            </tbody>
+                            </table>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        <div class="col-md">
+            <ul class="nav nav-tabs" id="myTab" role="tablist">
+                <li class="nav-item" role="presentation">
+                    <button class="nav-link active" id="home-tab" data-bs-toggle="tab" data-bs-target="#latest-listened" type="button" role="tab" aria-controls="home" aria-selected="true">Latest Listened</button>
+                </li>
+                <li class="nav-item" role="presentation">
+                    <button class="nav-link" id="profile-tab" data-bs-toggle="tab" data-bs-target="#latest-watched" type="button" role="tab" aria-controls="profile" aria-selected="false">Latest Watched</button>
+                </li>
+            </ul>
+
+            <div class="tab-content" id="myTabContent2">
+                <div class="tab-pane fade show active" id="latest-listened" role="tabpanel" aria-labelledby="latest-listened-tab">
+                    <h2>Latest listened</h2>
+                    <div class="table-responsive">
+                        <table class="table table-striped table-sm">
+                        <thead>
+                            <tr>
+                            <th scope="col">Time</th>
+                            <th scope="col">Track</th>
+                            <th scope="col">Artist</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for scrobble in object_list %}
+                            <tr>
+                                <td>{{scrobble.timestamp|naturaltime}}</td>
+                                <td>{{scrobble.track.title}}</td>
+                                <td>{{scrobble.track.artist.name}}</td>
+                            </tr>
+                            {% endfor %}
+                        </tbody>
+                        </table>
+                    </div>
+                </div>
+
+                <div class="tab-pane fade show" id="latest-watched" role="tabpanel" aria-labelledby="latest-watched-tab">
+                    <h2>Latest watched</h2>
+                    <div class="table-responsive">
+                        <table class="table table-striped table-sm">
+                        <thead>
+                            <tr>
+                            <th scope="col">Time</th>
+                            <th scope="col">Title</th>
+                            <th scope="col">Series</th>
+                            <th scope="col">Source</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for scrobble in video_scrobble_list %}
+                            <tr>
+                                <td>{{scrobble.timestamp|naturaltime}}</td>
+                                <td>{% if scrobble.video.tv_series %}E{{scrobble.video.season_number}}S{{scrobble.video.season_number}} -{% endif %} {{scrobble.video.title}}</td>
+                                <td>{% if scrobble.video.tv_series %}{{scrobble.video.tv_series}}{% endif %}</td>
+                                <td>{{scrobble.source}}</td>
+                            </tr>
+                            {% endfor %}
+                        </tbody>
+                        </table>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</main>
 {% endblock %}
--- a/vrobbler/templates/videos/movie_list.html
+++ b/vrobbler/templates/videos/movie_list.html
@ -0,0 +1,12 @@
+{% extends "base.html" %}
+
+{% block content %}
+
+    <h2>Movies</h2>
+
+    <ul>
+        {% for movie in object_list %}
+        <li>{{movie}}</li>
+        {% endfor %}
+    </ul>
+{% endblock %}
--- a/vrobbler/templates/videos/video_detail.html
+++ b/vrobbler/templates/videos/video_detail.html
@ -0,0 +1,14 @@
+{% extends "base.html" %}
+
+{% block title %}Videos{% endblock %}
+
+{% block content %}
+    {{object}}
+
+    {% for scrobble in object.scrobble_set.all %}
+    <ul>
+        <li>{{scrobble}}</li>
+    </ul>
+
+    {% endfor %}
+{% endblock %}
--- a/vrobbler/templates/videos/video_list.html
+++ b/vrobbler/templates/videos/video_list.html
@ -0,0 +1,13 @@
+{% extends "base.html" %}
+
+{% block title %}Movies{% endblock %}
+{% block content %}
+    {% for movie in object_list %}
+    <dl>
+        <dt>{{movie}}</dt>
+        {% for scrobble in movie.scrobble_set.all %}
+        <dd>{{scrobble}}</dd>
+        {% endfor %}
+    </dl>
+    {% endfor %}
+{% endblock %}
--- a/vrobbler/urls.py
+++ b/vrobbler/urls.py
@ -2,20 +2,11 @@ from django.conf import settings
 from django.conf.urls.static import static
 from django.contrib import admin
 from django.urls import include, path
-from scrobbles.views import RecentScrobbleList
-from scrobbles import urls as scrobble_urls
-
-# from scrobbles.api.views import ScrobbleViewSet
-# from media_types.api.views import (
-#    ShowViewSet,
-#    MovieViewSet,
-# )
 from rest_framework import routers
+from scrobbles.views import RecentScrobbleList
+from videos import urls as video_urls

-# router = routers.DefaultRouter()
-# router.register(r"scrobbles", ScrobbleViewSet)
-# router.register(r"shows", ShowViewSet)
-# router.register(r"movies", MovieViewSet)
+from scrobbles import urls as scrobble_urls

 urlpatterns = [
    path("admin/", admin.site.urls),
@ -24,6 +15,7 @@ urlpatterns = [
    # path("movies/", include(movies, namespace="movies")),
    # path("shows/", include(shows, namespace="shows")),
    path("api/v1/scrobbles/", include(scrobble_urls, namespace="scrobbles")),
+    path("", include(video_urls, namespace="videos")),
    path("", RecentScrobbleList.as_view(), name="home"),
 ]
Author	SHA1	Message	Date
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
Colin Powell	b318bc0da9	Bump version to 0.1.5	2023-01-06 16:19:06 -05:00
Colin Powell	fe39118b55	Add a progress bar to in progress scrobble	2023-01-06 16:17:42 -05:00