Initial commit that merge both the front end and the API in the same repository

api/funkwhale_api/downloader/__init__.py

+
+from .downloader import download

api/funkwhale_api/downloader/downloader.py

+import os
+import requests
+import json
+from urllib.parse import quote_plus
+import youtube_dl
+from django.conf import settings
+import glob
+
+
+def download(
+        url,
+        target_directory=settings.MEDIA_ROOT,
+        name="%(id)s.%(ext)s",
+        bitrate=192):
+    target_path = os.path.join(target_directory, name)
+    ydl_opts = {
+        'quiet': True,
+        'outtmpl': target_path,
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'vorbis',
+        }],
+    }
+    _downloader = youtube_dl.YoutubeDL(ydl_opts)
+    info = _downloader.extract_info(url)
+    info['audio_file_path'] = target_path % {'id': info['id'], 'ext': 'ogg'}
+    return info

api/funkwhale_api/downloader/tests/test_downloader.py

+import os
+from test_plus.test import TestCase
+from .. import downloader
+from funkwhale_api.utils.tests import TMPDirTestCaseMixin
+
+
+class TestDownloader(TMPDirTestCaseMixin, TestCase):
+
+    def test_can_download_audio_from_youtube_url_to_vorbis(self):
+        data = downloader.download('https://www.youtube.com/watch?v=tPEE9ZwTmy0', target_directory=self.download_dir)
+        self.assertEqual(
+            data['audio_file_path'],
+            os.path.join(self.download_dir, 'tPEE9ZwTmy0.ogg'))
+        self.assertTrue(os.path.exists(data['audio_file_path']))

api/funkwhale_api/favorites/migrations/0001_initial.py

+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.utils.timezone
+from django.conf import settings
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0003_auto_20151222_2233'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='TrackFavorite',
+            fields=[
+                ('id', models.AutoField(serialize=False, auto_created=True, verbose_name='ID', primary_key=True)),
+                ('creation_date', models.DateTimeField(default=django.utils.timezone.now)),
+                ('track', models.ForeignKey(related_name='track_favorites', to='music.Track')),
+                ('user', models.ForeignKey(related_name='track_favorites', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'ordering': ('-creation_date',),
+            },
+        ),
+        migrations.AlterUniqueTogether(
+            name='trackfavorite',
+            unique_together=set([('track', 'user')]),
+        ),
+    ]

api/funkwhale_api/favorites/models.py

+from django.db import models
+from django.utils import timezone
+
+from funkwhale_api.music.models import Track
+
+class TrackFavorite(models.Model):
+    creation_date = models.DateTimeField(default=timezone.now)
+    user = models.ForeignKey('users.User', related_name='track_favorites')
+    track = models.ForeignKey(Track, related_name='track_favorites')
+
+    class Meta:
+        unique_together = ('track', 'user')
+        ordering = ('-creation_date',)
+
+    @classmethod
+    def add(cls, track, user):
+        favorite, created = cls.objects.get_or_create(user=user, track=track)
+        return favorite

api/funkwhale_api/favorites/serializers.py

+from rest_framework import serializers
+
+from funkwhale_api.music.serializers import TrackSerializerNested
+
+from . import models
+
+
+class UserTrackFavoriteSerializer(serializers.ModelSerializer):
+    # track = TrackSerializerNested(read_only=True)
+    class Meta:
+        model = models.TrackFavorite
+        fields = ('id', 'track', 'creation_date')

api/funkwhale_api/favorites/tests/test_favorites.py

+import json
+from test_plus.test import TestCase
+from django.core.urlresolvers import reverse
+
+from funkwhale_api.music.models import Track, Artist
+from funkwhale_api.favorites.models import TrackFavorite
+from funkwhale_api.users.models import User
+
+class TestFavorites(TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.artist = Artist.objects.create(name='test')
+        self.track = Track.objects.create(title='test', artist=self.artist)
+        self.user = User.objects.create_user(username='test', email='test@test.com', password='test')
+
+    def test_user_can_add_favorite(self):
+        TrackFavorite.add(self.track, self.user)
+
+        favorite = TrackFavorite.objects.latest('id')
+        self.assertEqual(favorite.track, self.track)
+        self.assertEqual(favorite.user, self.user)
+
+    def test_user_can_get_his_favorites(self):
+        favorite = TrackFavorite.add(self.track, self.user)
+
+        url = reverse('api:favorites:tracks-list')
+        self.client.login(username=self.user.username, password='test')
+
+        response = self.client.get(url)
+
+        expected = [
+            {
+                'track': self.track.pk,
+                'id': favorite.id,
+                'creation_date': favorite.creation_date.isoformat().replace('+00:00', 'Z'),
+            }
+        ]
+        parsed_json = json.loads(response.content.decode('utf-8'))
+
+        self.assertEqual(expected, parsed_json['results'])
+
+    def test_user_can_add_favorite_via_api(self):
+        url = reverse('api:favorites:tracks-list')
+        self.client.login(username=self.user.username, password='test')
+        response = self.client.post(url, {'track': self.track.pk})
+
+        favorite = TrackFavorite.objects.latest('id')
+        expected = {
+            'track': self.track.pk,
+            'id': favorite.id,
+            'creation_date': favorite.creation_date.isoformat().replace('+00:00', 'Z'),
+        }
+        parsed_json = json.loads(response.content.decode('utf-8'))
+
+        self.assertEqual(expected, parsed_json)
+        self.assertEqual(favorite.track, self.track)
+        self.assertEqual(favorite.user, self.user)
+
+    def test_user_can_remove_favorite_via_api(self):
+        favorite = TrackFavorite.add(self.track, self.user)
+
+        url = reverse('api:favorites:tracks-detail', kwargs={'pk': favorite.pk})
+        self.client.login(username=self.user.username, password='test')
+        response = self.client.delete(url, {'track': self.track.pk})
+        self.assertEqual(response.status_code, 204)
+        self.assertEqual(TrackFavorite.objects.count(), 0)
+
+    def test_user_can_remove_favorite_via_api_using_track_id(self):
+        favorite = TrackFavorite.add(self.track, self.user)
+
+        url = reverse('api:favorites:tracks-remove')
+        self.client.login(username=self.user.username, password='test')
+        response = self.client.delete(
+            url, json.dumps({'track': self.track.pk}),
+            content_type='application/json'
+        )
+
+        self.assertEqual(response.status_code, 204)
+        self.assertEqual(TrackFavorite.objects.count(), 0)
+
+    from funkwhale_api.users.models import User
+
+    def test_can_restrict_api_views_to_authenticated_users(self):
+        urls = [
+            ('api:favorites:tracks-list', 'get'),
+        ]
+
+        for route_name, method in urls:
+            url = self.reverse(route_name)
+            with self.settings(API_AUTHENTICATION_REQUIRED=True):
+                response = getattr(self.client, method)(url)
+            self.assertEqual(response.status_code, 401)
+
+        self.client.login(username=self.user.username, password='test')
+
+        for route_name, method in urls:
+            url = self.reverse(route_name)
+            with self.settings(API_AUTHENTICATION_REQUIRED=False):
+                response = getattr(self.client, method)(url)
+            self.assertEqual(response.status_code, 200)
+
+    def test_can_filter_tracks_by_favorites(self):
+        favorite = TrackFavorite.add(self.track, self.user)
+
+        url = reverse('api:tracks-list')
+        self.client.login(username=self.user.username, password='test')
+
+        response = self.client.get(url, data={'favorites': True})
+
+        parsed_json = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(parsed_json['count'], 1)
+        self.assertEqual(parsed_json['results'][0]['id'], self.track.id)

api/funkwhale_api/favorites/urls.py

+from django.conf.urls import include, url
+from . import views
+
+from rest_framework import routers
+router = routers.SimpleRouter()
+router.register(r'tracks', views.TrackFavoriteViewSet, 'tracks')
+
+urlpatterns = router.urls

api/funkwhale_api/favorites/views.py

+from rest_framework import generics, mixins, viewsets
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework import pagination
+from rest_framework.decorators import list_route
+
+from funkwhale_api.music.models import Track
+from funkwhale_api.common.permissions import ConditionalAuthentication
+
+from . import models
+from . import serializers
+
+
+class CustomLimitPagination(pagination.PageNumberPagination):
+    page_size = 100
+    page_size_query_param = 'page_size'
+    max_page_size = 100
+
+
+class TrackFavoriteViewSet(mixins.CreateModelMixin,
+                           mixins.DestroyModelMixin,
+                           mixins.ListModelMixin,
+                           viewsets.GenericViewSet):
+
+    serializer_class = serializers.UserTrackFavoriteSerializer
+    queryset = (models.TrackFavorite.objects.all())
+    permission_classes = [ConditionalAuthentication]
+    pagination_class = CustomLimitPagination
+
+    def create(self, request, *args, **kwargs):
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        instance = self.perform_create(serializer)
+        serializer = self.get_serializer(instance=instance)
+        headers = self.get_success_headers(serializer.data)
+        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
+
+    def get_queryset(self):
+        return self.queryset.filter(user=self.request.user)
+
+    def perform_create(self, serializer):
+        track = Track.objects.get(pk=serializer.data['track'])
+        favorite = models.TrackFavorite.add(track=track, user=self.request.user)
+        return favorite
+
+    @list_route(methods=['delete'])
+    def remove(self, request, *args, **kwargs):
+        try:
+            pk = int(request.data['track'])
+            favorite = request.user.track_favorites.get(track__pk=pk)
+        except (AttributeError, ValueError, models.TrackFavorite.DoesNotExist):
+            return Response({}, status=400)
+        favorite.delete()
+        return Response([], status=status.HTTP_204_NO_CONTENT)

api/funkwhale_api/history/admin.py

+from django.contrib import admin
+
+from . import models
+
+@admin.register(models.Listening)
+class ListeningAdmin(admin.ModelAdmin):
+    list_display = ['track', 'end_date', 'user', 'session_key']
+    search_fields = ['track__name', 'user__username']

api/funkwhale_api/history/migrations/0001_initial.py

+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+from django.conf import settings
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('music', '0008_auto_20160529_1456'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Listening',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', primary_key=True, serialize=False, auto_created=True)),
+                ('end_date', models.DateTimeField(null=True, blank=True, default=django.utils.timezone.now)),
+                ('session_key', models.CharField(null=True, blank=True, max_length=100)),
+                ('track', models.ForeignKey(related_name='listenings', to='music.Track')),
+                ('user', models.ForeignKey(blank=True, null=True, related_name='listenings', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'ordering': ('-end_date',),
+            },
+        ),
+    ]

api/funkwhale_api/history/models.py

+from django.utils import timezone
+from django.db import models
+from django.core.exceptions import ValidationError
+
+from funkwhale_api.music.models import Track
+
+
+class Listening(models.Model):
+    end_date = models.DateTimeField(default=timezone.now, null=True, blank=True)
+    track = models.ForeignKey(Track, related_name="listenings")
+    user = models.ForeignKey('users.User', related_name="listenings", null=True, blank=True)
+    session_key = models.CharField(max_length=100, null=True, blank=True)
+
+    class Meta:
+        ordering = ('-end_date',)
+
+    def save(self, **kwargs):
+        if not self.user and not self.session_key:
+            raise ValidationError('Cannot have both session_key and user empty for listening')
+
+        super().save(**kwargs)

api/funkwhale_api/history/serializers.py

+from rest_framework import serializers
+
+from funkwhale_api.music.serializers import TrackSerializerNested
+from . import models
+
+
+class ListeningSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = models.Listening
+        fields = ('id', 'user', 'session_key', 'track', 'end_date')
+
+
+    def create(self, validated_data):
+        if self.context.get('user'):
+            validated_data['user'] = self.context.get('user')
+        else:
+            validated_data['session_key'] = self.context['session_key']
+
+        return super().create(validated_data)