Skip to content
Snippets Groups Projects
models.py 4.95 KiB
Newer Older
  • Learn to ignore specific revisions
  • from django.conf import settings
    
    from rest_framework import exceptions
    
    
    from funkwhale_api.common import fields
    
    from funkwhale_api.common import preferences
    
    class PlaylistQuerySet(models.QuerySet):
        def with_tracks_count(self):
            return self.annotate(
                _tracks_count=models.Count('playlist_tracks'))
    
    
    
    class Playlist(models.Model):
        name = models.CharField(max_length=50)
    
        user = models.ForeignKey(
            'users.User', related_name="playlists", on_delete=models.CASCADE)
    
        creation_date = models.DateTimeField(default=timezone.now)
    
        modification_date = models.DateTimeField(
            auto_now=True)
    
        privacy_level = fields.get_privacy_field()
    
        objects = PlaylistQuerySet.as_manager()
    
    
        @transaction.atomic
        def insert(self, plt, index=None):
            """
            Given a PlaylistTrack, insert it at the correct index in the playlist,
            and update other tracks index if necessary.
            """
            old_index = plt.index
            move = old_index is not None
            if index is not None and index == old_index:
                # moving at same position, just skip
                return index
    
            existing = self.playlist_tracks.select_for_update()
            if move:
                existing = existing.exclude(pk=plt.pk)
            total = existing.filter(index__isnull=False).count()
    
            if index is None:
                # we simply increment the last track index by 1
                index = total
    
                raise exceptions.ValidationError('Index is not continuous')
    
                raise exceptions.ValidationError('Index must be zero or positive')
    
    
            if move:
                # we remove the index temporarily, to avoid integrity errors
                plt.index = None
                plt.save(update_fields=['index'])
                if index > old_index:
                    # new index is higher than current, we decrement previous tracks
                    to_update = existing.filter(
                        index__gt=old_index, index__lte=index)
                    to_update.update(index=models.F('index') - 1)
                if index < old_index:
                    # new index is lower than current, we increment next tracks
    
                    to_update = existing.filter(index__lt=old_index, index__gte=index)
    
                    to_update.update(index=models.F('index') + 1)
            else:
                to_update = existing.filter(index__gte=index)
                to_update.update(index=models.F('index') + 1)
    
            plt.index = index
            plt.save(update_fields=['index'])
    
            self.save(update_fields=['modification_date'])
    
        def remove(self, index):
            existing = self.playlist_tracks.select_for_update()
    
            self.save(update_fields=['modification_date'])
    
            to_update = existing.filter(index__gt=index)
            return to_update.update(index=models.F('index') - 1)
    
    
        @transaction.atomic
        def insert_many(self, tracks):
            existing = self.playlist_tracks.select_for_update()
            now = timezone.now()
            total = existing.filter(index__isnull=False).count()
    
            max_tracks = preferences.get('playlists__max_tracks')
            if existing.count() + len(tracks) > max_tracks:
    
                raise exceptions.ValidationError(
                    'Playlist would reach the maximum of {} tracks'.format(
    
            self.save(update_fields=['modification_date'])
            start = total
            plts = [
                PlaylistTrack(
                    creation_date=now, playlist=self, track=track, index=start+i)
                for i, track in enumerate(tracks)
            ]
            return PlaylistTrack.objects.bulk_create(plts)
    
    
    class PlaylistTrackQuerySet(models.QuerySet):
        def for_nested_serialization(self):
            return (self.select_related()
                        .select_related('track__album__artist')
                        .prefetch_related(
                            'track__tags',
                            'track__files',
                            'track__artist__albums__tracks__tags'))
    
    
        track = models.ForeignKey(
            'music.Track',
            related_name='playlist_tracks',
            on_delete=models.CASCADE)
    
        index = models.PositiveIntegerField(null=True, blank=True)
    
        playlist = models.ForeignKey(
            Playlist, related_name='playlist_tracks', on_delete=models.CASCADE)
    
        creation_date = models.DateTimeField(default=timezone.now)
    
        objects = PlaylistTrackQuerySet.as_manager()
    
    
            ordering = ('-playlist', 'index')
            unique_together = ('playlist', 'index')
    
    
        def delete(self, *args, **kwargs):
            playlist = self.playlist
            index = self.index
            update_indexes = kwargs.pop('update_indexes', False)
            r = super().delete(*args, **kwargs)
            if index is not None and update_indexes:
                playlist.remove(index)
            return r