MarietjeDjango/marietje/stats/utils.py

from datetime import datetime, timedelta

from django.core.cache import caches
from django.conf import settings
from django.db.models import Count, Q, Sum
from django.utils import timezone

from queues.models import PlaylistSong
from songs.models import Song
from marietje.models import User


CACHE_TTL = 2 * 24 * 3600

def recache_stats():
    new_stats = compute_stats()
    caches['default'].delete('stats')
    caches['default'].set('stats', new_stats, CACHE_TTL)
    return new_stats


def recache_user_stats():
    users = User.objects.exclude(
        Q(id=None)
        | Q(id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values('id')
    for user in users:
        new_stats = user_stats(user['id'])
        cacheloc = 'userstats_{}'.format(user['id'])
        caches['userstats'].delete(cacheloc)
        caches['userstats'].set(cacheloc, new_stats, CACHE_TTL)
    return new_stats


def best_uploaders_list(requests_uploader, most_requested_uploaders):
    for requests in requests_uploader:
        a = len(most_requested_uploaders)
        b = 0
        while b <= a:
            if b == a:
                adding_list_item(most_requested_uploaders, requests)
            elif requests[
                    'song__user__id'] == most_requested_uploaders[b]['id']:
                if requests['song__user__name'] == requests['user__name']:
                    most_requested_uploaders[b][
                        'own_total'] = requests['total']
                else:
                    most_requested_uploaders[b]['total'] += requests['total']
                break
            b += 1


def adding_list_item(most_requested_list, requests):
    # adds a single item to the best_uploaders list
    most_requested_list.append({
        'id': requests['song__user__id'],
        'name': requests['song__user__name'],
        'total': 0,
        'own_total': 0
    })
    if requests['song__user__id'] == requests['user__id']:
        most_requested_list[-1]['own_total'] = requests['total']
    else:
        most_requested_list[-1]['total'] = requests['total']


def compute_stats():
    # We want to grab the time now, because otherwise we would be reporting a minute too late
    last_updated = datetime.now()
    stats = {}

    stats['total_uploads'] = Song.objects.filter(deleted=False).exclude(
        user_id=None).count()

    stats['upload_stats'] = Song.objects.filter(deleted=False).exclude(
        user_id=None).values(
            'user__id', 'user__name').annotate(total=Count('id')).order_by(
                '-total', 'user__name')[:settings.STATS_TOP_COUNT]

    stats['total_requests'] = PlaylistSong.objects.filter(state=2).exclude(
        Q(user_id=None)
        | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).count()

    stats['request_stats'] = PlaylistSong.objects.filter(state=2).exclude(
        Q(user_id=None)
        | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values(
            'user__id', 'user__name').annotate(total=Count('id')).order_by(
                '-total', 'user__name')[:settings.STATS_TOP_COUNT]

    stats['unique_request_stats'] = PlaylistSong.objects.filter(state=2).exclude(
        Q(user_id=None)
        | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values(
            'user__id', 'user__name').annotate(
                total_requests=Count('id', distinct=True),
                unique_requests=Count('song__id', distinct=True)).order_by(
                    '-unique_requests')[:settings.STATS_TOP_COUNT]

    stats['total_unique_requests'] = PlaylistSong.objects.filter(state=2).exclude(
        Q(user_id=None)
        | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).aggregate(
            total=Count('song__id', distinct=True))

    stats['most_played_songs'] = PlaylistSong.objects.filter(state=2).exclude(
        Q(user_id=None)
        | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values(
            'song__artist',
            'song__title').annotate(total=Count('id')).order_by(
                '-total', 'song__artist')[:settings.STATS_TOP_COUNT]

    stats['most_played_artists'] = PlaylistSong.objects.filter(state=2).exclude(
        Q(user_id=None)
        | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values(
            'song__artist').annotate(total=Count('song__artist')).order_by(
                '-total', 'song__artist')[:settings.STATS_TOP_COUNT]

    stats['most_played_songs_14_days'] = PlaylistSong.objects.filter(
        state=2, played_at__gte=timezone.now() -
        timedelta(days=14)).exclude(user_id=None).values(
            'song__artist',
            'song__title').annotate(total=Count('id')).order_by(
                '-total', 'song__artist')[:settings.STATS_TOP_COUNT]

    stats['time_requested'] = PlaylistSong.objects.filter(state=2).exclude(
        Q(user_id=None)
        | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values(
            'user__id', 'user__name').annotate(
                total=Sum('song__duration'),
                avg_dur=Sum('song__duration') /
                Count('id')).order_by('-total')[:settings.STATS_TOP_COUNT]

    stats['total_time_requested'] = PlaylistSong.objects.all().filter(state=2).exclude(
        Q(user_id=None)
        | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).aggregate(
            total=Sum('song__duration'))

    total_time_overall = sum(x['avg_dur'] for x in list(stats['time_requested']))
    total_average = total_time_overall / len(stats['time_requested'])
    avg_dur_min, avg_dur_sec = divmod(total_average, 60)
    total_average = '{:.0f} minutes and {:.0f} seconds'.format(
        avg_dur_min, avg_dur_sec)

    requests_uploader = PlaylistSong.objects.filter(state=2).exclude(
        Q(user_id=None)
        | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values(
            'song__user__id', 'song__user__name', 'user__name',
            'user__id').annotate(total=Count('song__user__name'))

    most_requested_uploaders = []
    best_uploaders_list(list(requests_uploader), most_requested_uploaders)
    most_requested_uploaders = sorted(most_requested_uploaders, key=lambda x: x['total'], reverse=True)[:settings.STATS_TOP_COUNT]
    for time in list(stats['time_requested']):
        # converts total time and average time in respectively days and minutes, seconds
        time['duration'] = str(round(time['total'] / 86400, 2)) + ' days'
        avg_dur_min, avg_dur_sec = divmod(time['avg_dur'], 60)
        if avg_dur_sec < 10:
            avg_dur_sec = '0' + str(avg_dur_sec)
        time['avg_dur'] = '{}:{}'.format(avg_dur_min, avg_dur_sec)

    # Convert requested time to days
    time_requested = list(stats['time_requested'])
    for tr in time_requested:
        tr['duration'] = "{:5.2f} days".format(tr['total'] / 86400)

    return {
        'last_updated': last_updated,
        'total_uploads': "{0:,.0f}".format(stats['total_uploads']),
        'total_uploads_perc': stats['total_uploads'],
        'upload_stats': list(stats['upload_stats']),
        'total_requests': "{0:,.0f}".format(stats['total_requests']),
        'total_requests_perc': stats['total_requests'],
        'request_stats': list(stats['request_stats']),
        'unique_request_stats': list(stats['unique_request_stats']),
        'total_unique_requests': "{0:,.0f}".format(stats['total_unique_requests']['total']),
        'most_played_songs': list(stats['most_played_songs']),
        'most_played_artists': list(stats['most_played_artists']),
        'most_played_songs_14_days': list(stats['most_played_songs_14_days']),
        'time_requested': stats['time_requested'],
        'total_time_requested': str(round(float(
            stats['total_time_requested']['total']) / 86400, 2)) + ' days',
        'stats_top_count': settings.STATS_TOP_COUNT,
        'most_requested_uploaders': list(most_requested_uploaders),
        'total_average': total_average,
    }


def user_stats(request):
    last_updated = datetime.now()

    total_uploads = Song.objects.filter(
        user__id=request, deleted=False).count()

    total_requests = PlaylistSong.objects.filter(
        user__id=request, state=2).count()

    unique_requests = PlaylistSong.objects.filter(
        user__id=request, state=2,
        song_id__isnull=False).values('song_id').distinct().count()

    most_played_songs = PlaylistSong.objects.filter(
        user__id=request, state=2).exclude(
            Q(user_id=None)
            | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values(
                'song__artist',
                'song__title').annotate(total=Count('id')).order_by(
                    '-total', 'song__artist',
                    'song__title')[:settings.STATS_TOP_COUNT]

    most_played_artists = PlaylistSong.objects.filter(
        user__id=request, state=2,
        song_id__isnull=False).values('song__artist').annotate(
            total=Count('song__artist')).order_by(
                '-total', 'song__artist')[:settings.STATS_TOP_COUNT]

    most_played_uploaders = PlaylistSong.objects.filter(
        user__id=request, state=2).exclude(
            Q(user_id=None)
            | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values(
                'song__user__id', 'song__user__name').annotate(
                    total=Count('song__user__id')).order_by(
                        '-total')[:settings.STATS_TOP_COUNT]

    biggest_fans = PlaylistSong.objects.filter(
        state=2, song_id__in=Song.objects.filter(user__id=request)).exclude(
            Q(user_id=None)
            | Q(user_id__in=settings.STATS_REQUEST_IGNORE_USER_IDS)).values(
                'user__id', 'user__name').annotate(
                    total=Count('user__id')).order_by(
                        '-total')[:settings.STATS_TOP_COUNT]

    most_played_uploads = PlaylistSong.objects.filter(
        state=2, song_id__in=Song.objects.filter(user__id=request)).exclude(
            user__id=None).values('song__artist', 'song__title').annotate(
                total=Count('id', filter=~Q(user__id=request)),
                user_total=Count('id', filter=Q(user__id=request))).order_by(
                    '-total', 'song__artist', 'song__title')

    most_played_uploaded_artists = PlaylistSong.objects.filter(
        state=2, song_id__in=Song.objects.filter(user__id=request)).exclude(
            user__id=None).values('song__artist').annotate(total=Count(
                'song__artist', filter=~Q(user__id=request)), user_total=Count(
                    'id', filter=Q(user__id=request))).order_by(
                        '-total', 'song__artist')

    most_played = list(most_played_uploads)
    total_played = {}
    total_played['uploads'] = 0
    total_played['user_uploads'] = 0
    for x in most_played:
        total_played['uploads'] += x['total']
        total_played['user_uploads'] += x['user_total']
    most_played_uploads_list = sorted(most_played_uploads, key=lambda x: (x['song__artist'], x['song__title']))
    most_played_uploads_list = sorted(most_played_uploads_list, key=lambda x: x["total"], reverse=True)[:settings.STATS_TOP_COUNT]
    most_played_uploaded_artists = sorted(list(most_played_uploaded_artists), key=lambda x: x["total"], reverse=True)[:settings.STATS_TOP_COUNT]
    return {
        'last_updated': last_updated,
        'total_uploads': total_uploads,
        'total_requests': total_requests,
        'unique_requests': unique_requests,
        'most_played_songs': list(most_played_songs),
        'most_played_artists': list(most_played_artists),
        'most_played_uploaders': list(most_played_uploaders),
        'most_played_uploads': most_played_uploads_list,
        'most_played_uploaded_artists': most_played_uploaded_artists,
        'stats_top_count': settings.STATS_TOP_COUNT,
        'total_played_uploads': total_played['uploads'],
        'total_played_user_uploads': total_played['user_uploads'],
        'biggest_fans': list(biggest_fans),
    }