vrobbler/vrobbler/apps/scrobbles/views.py

import calendar
import json
import logging
from datetime import datetime, timedelta

import pytz
from django.conf import settings
from django.contrib import messages
from django.contrib.auth.mixins import LoginRequiredMixin
from django.db.models import Q
from django.db.models.fields import timezone
from django.db.models.query import QuerySet
from django.http import FileResponse, HttpResponseRedirect, JsonResponse
from django.urls import reverse, reverse_lazy
from django.utils import timezone
from django.views.decorators.csrf import csrf_exempt
from django.views.generic import DetailView, FormView, TemplateView
from django.views.generic.edit import CreateView
from django.views.generic.list import ListView
from music.aggregators import live_charts, scrobble_counts, week_of_scrobbles
from rest_framework import status
from rest_framework.decorators import (
    api_view,
    parser_classes,
    permission_classes,
)
from rest_framework.parsers import MultiPartParser
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from scrobbles.api import serializers
from scrobbles.constants import (
    JELLYFIN_AUDIO_ITEM_TYPES,
    JELLYFIN_VIDEO_ITEM_TYPES,
)
from scrobbles.export import export_scrobbles
from scrobbles.forms import ExportScrobbleForm, ScrobbleForm
from scrobbles.models import (
    AudioScrobblerTSVImport,
    ChartRecord,
    KoReaderImport,
    LastFmImport,
    Scrobble,
)
from scrobbles.scrobblers import (
    jellyfin_scrobble_track,
    jellyfin_scrobble_video,
    manual_scrobble_book,
    manual_scrobble_event,
    manual_scrobble_video,
    manual_scrobble_video_game,
    mopidy_scrobble_podcast,
    mopidy_scrobble_track,
)
from scrobbles.tasks import (
    process_koreader_import,
    process_lastfm_import,
    process_tsv_import,
)
from sports.thesportsdb import lookup_event_from_thesportsdb
from videos.imdb import lookup_video_from_imdb
from videogames.howlongtobeat import lookup_game_from_hltb
from vrobbler.apps.books.openlibrary import lookup_book_from_openlibrary

logger = logging.getLogger(__name__)


class RecentScrobbleList(ListView):
    model = Scrobble

    def get_context_data(self, **kwargs):
        data = super().get_context_data(**kwargs)
        user = self.request.user
        if user.is_authenticated:
            completed_for_user = Scrobble.objects.filter(
                played_to_completion=True, user=user
            )
            data["video_scrobble_list"] = completed_for_user.filter(
                video__isnull=False
            ).order_by("-timestamp")[:15]

            data["podcast_scrobble_list"] = completed_for_user.filter(
                podcast_episode__isnull=False
            ).order_by("-timestamp")[:15]

            data["sport_scrobble_list"] = completed_for_user.filter(
                sport_event__isnull=False
            ).order_by("-timestamp")[:15]

            data["active_imports"] = AudioScrobblerTSVImport.objects.filter(
                processing_started__isnull=False,
                processed_finished__isnull=True,
                user=self.request.user,
            )

            limit = 14
            artist = {"user": user, "media_type": "Artist", "limit": limit}
            # This is weird. They don't display properly as QuerySets, so we cast to lists
            data["current_artist_charts"] = {
                "today": list(live_charts(**artist, chart_period="today")),
                "week": list(live_charts(**artist, chart_period="week")),
                "month": list(live_charts(**artist, chart_period="month")),
                "year": list(live_charts(**artist, chart_period="year")),
                "all": list(live_charts(**artist)),
            }

            track = {"user": user, "media_type": "Track", "limit": limit}
            data["current_track_charts"] = {
                "today": list(live_charts(**track, chart_period="today")),
                "week": list(live_charts(**track, chart_period="week")),
                "month": list(live_charts(**track, chart_period="month")),
                "year": list(live_charts(**track, chart_period="year")),
                "all": list(live_charts(**track)),
            }

        data["weekly_data"] = week_of_scrobbles(user=user)
        data["counts"] = scrobble_counts(user)
        data["imdb_form"] = ScrobbleForm
        data["export_form"] = ExportScrobbleForm
        return data

    def get_queryset(self):
        return Scrobble.objects.filter(
            track__isnull=False, in_progress=False
        ).order_by("-timestamp")[:15]


class ScrobbleImportListView(TemplateView):
    template_name = "scrobbles/import_list.html"

    def get_context_data(self, **kwargs):
        context_data = super().get_context_data(**kwargs)
        context_data["object_list"] = []

        context_data["tsv_imports"] = AudioScrobblerTSVImport.objects.filter(
            user=self.request.user,
        ).order_by("-processing_started")
        context_data["koreader_imports"] = KoReaderImport.objects.filter(
            user=self.request.user,
        ).order_by("-processing_started")
        context_data["lastfm_imports"] = LastFmImport.objects.filter(
            user=self.request.user,
        ).order_by("-processing_started")
        return context_data


class BaseScrobbleImportDetailView(DetailView):
    slug_field = "uuid"
    template_name = "scrobbles/import_detail.html"

    def get_queryset(self):
        return super().get_queryset().filter(user=self.request.user)

    def get_context_data(self, **kwargs):
        context_data = super().get_context_data(**kwargs)
        title = "Generic Scrobble Import"
        if self.model == KoReaderImport:
            title = "KoReader Import"
        if self.model == AudioScrobblerTSVImport:
            title = "Audioscrobbler TSV Import"
        if self.model == LastFmImport:
            title = "LastFM Import"
        context_data["title"] = title
        return context_data


class ScrobbleKoReaderImportDetailView(BaseScrobbleImportDetailView):
    model = KoReaderImport


class ScrobbleTSVImportDetailView(BaseScrobbleImportDetailView):
    model = AudioScrobblerTSVImport


class ScrobbleLastFMImportDetailView(BaseScrobbleImportDetailView):
    model = LastFmImport


class ManualScrobbleView(FormView):
    form_class = ScrobbleForm
    template_name = "scrobbles/manual_form.html"

    def form_valid(self, form):

        item_id = form.cleaned_data.get("item_id")
        data_dict = None

        if "-v" in item_id or not data_dict:
            logger.debug(f"Looking for video game with ID {item_id}")
            data_dict = lookup_game_from_hltb(item_id.replace("-v", ""))
            if data_dict:
                manual_scrobble_video_game(data_dict, self.request.user.id)

        if "-b" in item_id and not data_dict:
            logger.debug(f"Looking for book with ID {item_id}")
            data_dict = lookup_book_from_openlibrary(item_id.replace("-b", ""))
            if data_dict:
                manual_scrobble_book(data_dict, self.request.user.id)

        if "-s" in item_id and not data_dict:
            logger.debug(f"Looking for sport event with ID {item_id}")
            data_dict = lookup_event_from_thesportsdb(item_id)
            if data_dict:
                manual_scrobble_event(data_dict, self.request.user.id)

        if "tt" in item_id:
            data_dict = lookup_video_from_imdb(item_id)
            if data_dict:
                manual_scrobble_video(data_dict, self.request.user.id)

        return HttpResponseRedirect(reverse("vrobbler-home"))


class JsonableResponseMixin:
    """
    Mixin to add JSON support to a form.
    Must be used with an object-based FormView (e.g. CreateView)
    """

    def form_invalid(self, form):
        response = super().form_invalid(form)
        if self.request.accepts("text/html"):
            return response
        else:
            return JsonResponse(form.errors, status=400)

    def form_valid(self, form):
        # We make sure to call the parent's form_valid() method because
        # it might do some processing (in the case of CreateView, it will
        # call form.save() for example).
        response = super().form_valid(form)
        if self.request.accepts("text/html"):
            return response
        else:
            data = {
                "pk": self.object.pk,
            }
            return JsonResponse(data)


class AudioScrobblerImportCreateView(
    LoginRequiredMixin, JsonableResponseMixin, CreateView
):
    model = AudioScrobblerTSVImport
    fields = ["tsv_file"]
    template_name = "scrobbles/upload_form.html"
    success_url = reverse_lazy("vrobbler-home")

    def form_valid(self, form):
        self.object = form.save(commit=False)
        self.object.user = self.request.user
        self.object.save()
        process_tsv_import.delay(self.object.id)
        return HttpResponseRedirect(self.get_success_url())


class KoReaderImportCreateView(
    LoginRequiredMixin, JsonableResponseMixin, CreateView
):
    model = KoReaderImport
    fields = ["sqlite_file"]
    template_name = "scrobbles/upload_form.html"
    success_url = reverse_lazy("vrobbler-home")

    def form_valid(self, form):
        self.object = form.save(commit=False)
        self.object.user = self.request.user
        self.object.save()
        process_koreader_import.delay(self.object.id)
        return HttpResponseRedirect(self.get_success_url())


@permission_classes([IsAuthenticated])
@api_view(["GET"])
def lastfm_import(request):
    lfm_import, created = LastFmImport.objects.get_or_create(
        user=request.user, processed_finished__isnull=True
    )

    process_lastfm_import.delay(lfm_import.id)

    success_url = reverse_lazy("vrobbler-home")
    return HttpResponseRedirect(success_url)


@csrf_exempt
@permission_classes([IsAuthenticated])
@api_view(["POST"])
def jellyfin_webhook(request):
    data_dict = request.data

    if (
        data_dict["NotificationType"] == "PlaybackProgress"
        and data_dict["ItemType"] == "Audio"
    ):
        return Response({}, status=status.HTTP_304_NOT_MODIFIED)

    # 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}")

    scrobble = None
    media_type = data_dict.get("ItemType", "")

    if media_type in JELLYFIN_AUDIO_ITEM_TYPES:
        scrobble = jellyfin_scrobble_track(data_dict, request.user.id)

    if media_type in JELLYFIN_VIDEO_ITEM_TYPES:
        scrobble = jellyfin_scrobble_video(data_dict, request.user.id)

    if not scrobble:
        return Response({}, status=status.HTTP_400_BAD_REQUEST)

    return Response({"scrobble_id": scrobble.id}, status=status.HTTP_200_OK)


@csrf_exempt
@permission_classes([IsAuthenticated])
@api_view(["POST"])
def mopidy_webhook(request):
    try:
        data_dict = json.loads(request.data)
    except TypeError:
        logger.warning("Received Mopidy data as dict, rather than a string")
        data_dict = request.data

    # For making things easier to build new input processors
    if getattr(settings, "DUMP_REQUEST_DATA", False):
        json_data = json.dumps(data_dict, indent=4)
        logger.debug(f"{json_data}")

    if "podcast" in data_dict.get("mopidy_uri"):
        scrobble = mopidy_scrobble_podcast(data_dict, request.user.id)
    else:
        scrobble = mopidy_scrobble_track(data_dict, request.user.id)

    if not scrobble:
        return Response({}, status=status.HTTP_400_BAD_REQUEST)

    return Response({"scrobble_id": scrobble.id}, status=status.HTTP_200_OK)


@csrf_exempt
@permission_classes([IsAuthenticated])
@api_view(["POST"])
@parser_classes([MultiPartParser])
def import_audioscrobbler_file(request):
    """Takes a TSV file in the Audioscrobbler format, saves it and processes the
    scrobbles.
    """
    scrobbles_created = []
    # tsv_file = request.FILES[0]

    file_serializer = serializers.AudioScrobblerTSVImportSerializer(
        data=request.data
    )
    if file_serializer.is_valid():
        import_file = file_serializer.save()
        return Response(
            {"scrobble_ids": scrobbles_created}, status=status.HTTP_200_OK
        )
    else:
        return Response(
            file_serializer.errors, status=status.HTTP_400_BAD_REQUEST
        )


@permission_classes([IsAuthenticated])
@api_view(["GET"])
def scrobble_finish(request, uuid):
    user = request.user
    success_url = reverse_lazy("vrobbler-home")

    if not user.is_authenticated:
        return HttpResponseRedirect(success_url)

    scrobble = Scrobble.objects.filter(user=user, uuid=uuid).first()
    if scrobble:
        scrobble.stop(force_finish=True)
        messages.add_message(
            request,
            messages.SUCCESS,
            f"Scrobble of {scrobble.media_obj} finished.",
        )
    else:
        messages.add_message(request, messages.ERROR, "Scrobble not found.")
    return HttpResponseRedirect(success_url)


@permission_classes([IsAuthenticated])
@api_view(["GET"])
def scrobble_cancel(request, uuid):
    user = request.user
    success_url = reverse_lazy("vrobbler-home")

    if not user.is_authenticated:
        return HttpResponseRedirect(success_url)

    scrobble = Scrobble.objects.filter(user=user, uuid=uuid).first()
    if scrobble:
        scrobble.cancel()
        messages.add_message(
            request,
            messages.SUCCESS,
            f"Scrobble of {scrobble.media_obj} cancelled.",
        )
    else:
        messages.add_message(request, messages.ERROR, "Scrobble not found.")
    return HttpResponseRedirect(success_url)


@permission_classes([IsAuthenticated])
@api_view(["GET"])
def export(request):
    format = request.GET.get("export_type", "csv")
    start = request.GET.get("start")
    end = request.GET.get("end")
    logger.debug(f"Exporting all scrobbles in format {format}")

    temp_file, extension = export_scrobbles(
        start_date=start, end_date=end, format=format
    )

    now = datetime.now()
    filename = f"vrobbler-export-{str(now)}.{extension}"
    response = FileResponse(open(temp_file, "rb"))
    response["Content-Disposition"] = f'attachment; filename="{filename}"'

    return response


class ChartRecordView(TemplateView):
    template_name = "scrobbles/chart_index.html"

    @staticmethod
    def get_media_filter(media_type: str = "") -> Q:
        filters = {
            "Track": Q(track__isnull=False),
            "Artist": Q(artist__isnull=False),
            "Series": Q(series__isnull=False),
            "Video": Q(video__isnull=False),
            "": Q(),
        }
        return filters[media_type]

    def get_chart_records(self, media_type: str = "", **kwargs):
        media_filter = self.get_media_filter(media_type)
        charts = ChartRecord.objects.filter(
            media_filter, user=self.request.user, **kwargs
        ).order_by("rank")

        if charts.count() == 0:
            ChartRecord.build(
                user=self.request.user, model_str=media_type, **kwargs
            )
            charts = ChartRecord.objects.filter(
                media_filter, user=self.request.user, **kwargs
            ).order_by("rank")
        return charts

    def get_chart(
        self, period: str = "all_time", limit=15, media: str = ""
    ) -> QuerySet:
        now = timezone.now()
        params = {}
        params["media_type"] = media
        if period == "today":
            params["day"] = now.day
            params["month"] = now.month
            params["year"] = now.year
        if period == "week":
            params["week"] = now.ioscalendar()[1]
            params["year"] = now.year
        if period == "month":
            params["month"] = now.month
            params["year"] = now.year
        if period == "year":
            params["year"] = now.year
        return self.get_chart_records(**params)[:limit]

    def get_context_data(self, **kwargs):
        context_data = super().get_context_data(**kwargs)
        date = self.request.GET.get("date")
        media_type = self.request.GET.get("media", "Track")
        user = self.request.user
        params = {}
        context_data["artist_charts"] = {}

        if not date:
            limit = 20
            artist_params = {"user": user, "media_type": "Artist"}
            context_data["current_artist_charts"] = {
                "today": live_charts(
                    **artist_params, chart_period="today", limit=limit
                ),
                "week": live_charts(
                    **artist_params, chart_period="week", limit=limit
                ),
                "month": live_charts(
                    **artist_params, chart_period="month", limit=limit
                ),
                "year": live_charts(
                    **artist_params, chart_period="year", limit=limit
                ),
                "all": live_charts(**artist_params, limit=limit),
            }

            track_params = {"user": user, "media_type": "Track"}
            context_data["current_track_charts"] = {
                "today": live_charts(
                    **track_params, chart_period="today", limit=limit
                ),
                "week": live_charts(
                    **track_params, chart_period="week", limit=limit
                ),
                "month": live_charts(
                    **track_params, chart_period="month", limit=limit
                ),
                "year": live_charts(
                    **track_params, chart_period="year", limit=limit
                ),
                "all": live_charts(**track_params, limit=limit),
            }
            return context_data

        # Date provided, lookup past charts, returning nothing if it's now or in the future.
        now = timezone.now()
        year = now.year
        params = {"year": year}
        name = f"Chart for {year}"

        date_params = date.split("-")
        year = int(date_params[0])
        in_progress = False
        if len(date_params) == 2:
            if "W" in date_params[1]:
                week = int(date_params[1].strip('W"'))
                params["week"] = week
                start = datetime.strptime(date + "-1", "%Y-W%W-%w").replace(
                    tzinfo=pytz.utc
                )
                end = start + timedelta(days=6)
                in_progress = start <= now <= end
                as_str = start.strftime("Week of %B %d, %Y")
                name = f"Chart for {as_str}"
            else:
                month = int(date_params[1])
                params["month"] = month
                month_str = calendar.month_name[month]
                name = f"Chart for {month_str} {year}"
                in_progress = now.month == month and now.year == year
        if len(date_params) == 3:
            month = int(date_params[1])
            day = int(date_params[2])
            params["month"] = month
            params["day"] = day
            month_str = calendar.month_name[month]
            name = f"Chart for {month_str} {day}, {year}"
            in_progress = (
                now.month == month and now.year == year and now.day == day
            )

        media_filter = self.get_media_filter("Track")
        track_charts = ChartRecord.objects.filter(
            media_filter, user=self.request.user, **params
        ).order_by("rank")
        media_filter = self.get_media_filter("Artist")
        artist_charts = ChartRecord.objects.filter(
            media_filter, user=self.request.user, **params
        ).order_by("rank")

        if track_charts.count() == 0 and not in_progress:
            ChartRecord.build(
                user=self.request.user, model_str="Track", **params
            )
            media_filter = self.get_media_filter("Track")
            track_charts = ChartRecord.objects.filter(
                media_filter, user=self.request.user, **params
            ).order_by("rank")
        if artist_charts.count() == 0 and not in_progress:
            ChartRecord.build(
                user=self.request.user, model_str="Artist", **params
            )
            media_filter = self.get_media_filter("Artist")
            artist_charts = ChartRecord.objects.filter(
                media_filter, user=self.request.user, **params
            ).order_by("rank")

        context_data["media_type"] = media_type
        context_data["track_charts"] = track_charts
        context_data["artist_charts"] = artist_charts
        context_data["name"] = " ".join(["Top", media_type, "for", name])
        context_data["in_progress"] = in_progress
        return context_data