def test_fetch_and_save_when_existing_youtube(self):
x = Track.objects.all().count()
responses.add_callback(
responses.GET, 'https://www.googleapis.com/youtube/v3/videos',
callback=self.request_callback_youtube,
content_type='application/json',
)
Track.fetch_and_save_track(Track.SERVICES.youtube,
self.track_youtube.service_id,
self.establishment)
self.assertEqual(Track.objects.all().count(), x)
def test_fetch_and_save_when_existing_deezer(self):
x = Track.objects.all().count()
responses.add_callback(
responses.GET, ('http://api.deezer.com/track/%s' %
self.track.service_id),
callback=self.request_callback_deezer,
content_type='application/json',
)
Track.fetch_and_save_track(Track.SERVICES.deezer,
self.track.service_id, self.establishment)
self.assertEqual(Track.objects.all().count(), x)
def skip(self):
try:
current = Track.objects.get(now_playing=True,
establishment=self.establishment)
self.stop_track(current)
qs = Track.objects.filter(now_playing=False,
establishment=self.establishment
).exclude(id=current.id)
except Track.DoesNotExist:
current = None
qs = Track.objects.filter(establishment=self.establishment,
now_playing=False)
# use current to prevent skip to the same song
# get the first by vote
if current is not None:
track = Track.ordered_qs(establishment=self.establishment
).exclude(id=current.id).first()
else:
track = Track.ordered_qs(establishment=self.establishment
).first()
# get random
if not track:
new_qs = qs.filter(played_on_random=False)
if new_qs.exists():
qs = new_qs
else:
qs.update(played_on_random=False)
# select a track at random
last = qs.count() - 1
if last >= 0:
index = randint(0, last)
try:
track = qs[index]
except IndexError:
# on the very unlikely event of selecting an index that
# disappeared between the two queries we try selecting the
# first one.
track = qs.first()
if track:
with transaction.atomic():
# make sure we don't have a race condition and end up with
# two tracks now_playing
track.now_playing = True
track.played_on_random = True
track.save()
assert Track.objects.filter(now_playing=True,
establishment=self.establishment
).count() == 1
self.broadcast_track_changed(track)
return track
def mutate(self, info, title, description, url):
user = info.context.user
if user.is_anonymous:
raise Exception('Login to add track!')
track = Track(title=title,
description=description,
url=url,
traxx_user=user)
track.save()
return CreateTrack(track=track)
def skip(self):
try:
current = Track.objects.get(now_playing=True,
establishment=self.establishment)
self.stop_track(current)
qs = Track.objects.filter(
now_playing=False,
establishment=self.establishment).exclude(id=current.id)
except Track.DoesNotExist:
current = None
qs = Track.objects.filter(establishment=self.establishment,
now_playing=False)
# use current to prevent skip to the same song
# get the first by vote
if current is not None:
track = Track.ordered_qs(establishment=self.establishment).exclude(
id=current.id).first()
else:
track = Track.ordered_qs(establishment=self.establishment).first()
# get random
if not track:
new_qs = qs.filter(played_on_random=False)
if new_qs.exists():
qs = new_qs
else:
qs.update(played_on_random=False)
# select a track at random
last = qs.count() - 1
if last >= 0:
index = randint(0, last)
try:
track = qs[index]
except IndexError:
# on the very unlikely event of selecting an index that
# disappeared between the two queries we try selecting the
# first one.
track = qs.first()
if track:
with transaction.atomic():
# make sure we don't have a race condition and end up with
# two tracks now_playing
track.now_playing = True
track.played_on_random = True
track.save()
assert Track.objects.filter(
now_playing=True,
establishment=self.establishment).count() == 1
self.broadcast_track_changed(track)
return track
def save(self, request, commit=True):
super(TracksForm, self).save(commit=commit)
if commit:
tracks_on_album = Track.objects.filter(
album=self.instance).count() + 1
for file in self.cleaned_data['tracks']:
try:
file_path = file.temporary_file_path()
metadata = mutagen.File(file_path, easy=True)
if metadata and metadata.get('title'):
title = metadata.get('title')[0]
except:
title = "untitled"
try:
track = Track(audio=file,
title=title,
order=tracks_on_album,
album=self.instance)
track.full_clean()
track.set_upload_to_info(
username=self.instance.artist_profile.profile.user.
username,
track_type="albums",
album_title=self.instance.title)
tracks_on_album += 1
track.save()
except ValidationError as e:
messages.error(request, e.messages[0] + " : " + str(file))
return self.instance
def mutate(self, info, title, description, url):
user = info.context.user
if not user.is_authenticated:
raise GraphQLError("Not logged in")
track = Track(
title=title,
description=description,
url=url,
posted_by=user,
)
track.save()
return CreateTrack(track=track)
def build_track(self, activity):
'''
Generic track builder flow, from any activity
Will call methods from the proxy subclass of Track
'''
# Load existing activity
# or build a new one
created = False
activity_id = self.get_activity_id(activity)
activity_raw = json.dumps(activity)
try:
track = Track.objects.get(provider=self.NAME, provider_id=activity_id)
# Check the activity needs an update
# by comparing md5
track_file = track.get_file('raw')
if track_file and track_file.md5 == hashlib.md5(activity_raw).hexdigest():
logger.info("Existing %s activity %s did not change" % (self.NAME, activity_id))
return track, False
logger.info("Existing %s activity %s needs update" % (self.NAME, activity_id))
except Track.DoesNotExist, e:
track = Track(provider=self.NAME, provider_id=activity_id)
created = True
logger.info("Created %s activity %s" % (self.NAME, activity_id))
def test_fetch_and_save_when_new_youtube(self):
x = Track.objects.all().count()
responses.add_callback(
responses.GET, 'https://www.googleapis.com/youtube/v3/videos',
callback=self.request_callback_youtube,
content_type='application/json',
)
track = Track.fetch_and_save_track(Track.SERVICES.youtube, '223456',
self.establishment)
self.assertTrue(Track.objects.filter(id=track.id).exists())
self.assertEqual(Track.objects.all().count(), x + 1)
def test_fetch_and_save_when_new_deezer(self):
x = Track.objects.all().count()
responses.add_callback(
responses.GET, 'http://api.deezer.com/track/223456',
callback=self.request_callback_deezer,
content_type='application/json',
)
track = Track.fetch_and_save_track(Track.SERVICES.deezer, '223456',
self.establishment)
self.assertTrue(Track.objects.filter(id=track.id).exists())
self.assertEqual(Track.objects.all().count(), x + 1)
def handle(self, *args, **options):
for dir in options['dir_name']:
print("Importing", dir)
event = Event()
event.name = 'Próba ' + dir
event.date = parser.parse(dir)
event.save()
track_names = os.listdir('tracks/static/audio/' + dir)
for track_name in track_names:
track = Track()
track.name = track_name
track.path = dir + '/' + track_name
track.date = event.date
track.event = event
track.save()
def add_track(data, album):
try:
Track.objects.get(deezer_id=data.get('id'))
print(f'\tTrack "{data.get("title")}" already exists')
except Track.DoesNotExist:
track = Track(title=data.get('title'),
deezer_id=data.get('id'),
album=album)
track.preview = data.get('preview')
track.rank = data.get('rank')
track.release_date = album.release_date
track.save()
print(f'\tTrack "{data.get("title")}" has been created')
def create(self, request, *args, **kwargs):
service_id = self.kwargs['service_id']
service = self.kwargs['service']
try:
self.track = Track.fetch_and_save_track(service, service_id,
self.establishment)
Vote.objects.create(track=self.track, token=self.get_token())
except RequestException:
return Response(status=status.HTTP_503_SERVICE_UNAVAILABLE)
except ValueError as e:
return Response(status=status.HTTP_400_BAD_REQUEST, data=e.message)
serializer = TrackSerializer(self.track)
self.broadcast_list_changed()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def create(self, request, *args, **kwargs):
service_id = self.kwargs['service_id']
service = self.kwargs['service']
try:
self.track = Track.fetch_and_save_track(service, service_id,
self.establishment)
Vote.objects.create(track=self.track, token=self.get_token())
except RequestException:
return Response(
status=status.HTTP_503_SERVICE_UNAVAILABLE)
except ValueError as e:
return Response(
status=status.HTTP_400_BAD_REQUEST, data=e.message)
serializer = TrackSerializer(self.track)
self.broadcast_list_changed()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def track_list_serialize(self):
qs = Track.ordered_qs(establishment=self.establishment)
PlayList = namedtuple('PlayList', ['tracks', 'now_playing'])
return TrackListSerializer(PlayList(qs, self.get_now_playing()))
def create(self, validated_data):
establishment = self.context['establishment']
return Track.fetch_and_save_track(
establishment=establishment, service=validated_data['service'],
service_id=validated_data['service_id'])
from django.contrib import admin
from .models import Album
from tracks.models import Track
track=Track()
class AlbumAdmin(admin.ModelAdmin):
search_fields = ('title',)
list_display = ['title','track_titles']
def track_titles(self,obj):
names = [t.title for t in obj.track_set.all()]
return ", ".join(names)
track_titles.short_description = 'Track Titles'
admin.site.register(Album,AlbumAdmin)
def track_list_serialize(self):
qs = Track.ordered_qs(establishment=self.establishment)
PlayList = namedtuple('PlayList', ['tracks', 'now_playing'])
return TrackListSerializer(PlayList(qs, self.get_now_playing()))
