def check_archived_song_accessible(self, key):
archived_song = ArchivedSong.objects.get(id=key)
location = song_utils.path_from_url(archived_song.url)
downloader = None
if not location:
downloader = Downloader(self.musiq, archived_song.url)
downloader.check()
# the downloader raised no error, the song is accessible
return downloader
def get_archived_song_location(self, key, downloader, ip):
archived_song = ArchivedSong.objects.get(id=key)
location = song_utils.path_from_url(archived_song.url)
if location is None:
location = downloader.fetch(archived_song.url)
ArchivedSong.objects.filter(id=key).update(counter=F('counter') + 1)
if self.musiq.base.settings.logging_enabled:
RequestLog.objects.create(song=archived_song, address=ip)
return location
def check_new_song_accessible(self, search_text):
# collapse whitespaces
search_text = ' '.join(search_text.split())
# if the search text is a url that is already in the database and the song is cached offline, we don't need an online downloader
downloader = None
queryset = ArchivedSong.objects.filter(url=search_text)
if queryset.count() == 1:
song = queryset.get()
location = song_utils.path_from_url(song.url)
if location is not None:
downloader = OfflineDownloader(location)
# if the song was not found offline, we use the online downloader
if downloader is None:
downloader = Downloader(self.musiq, search_text)
downloader.check()
# the downloader raised no error, the song is accessible
return downloader
def get_suggestions(self, request):
terms = request.GET['term'].split()
remaining_songs = ArchivedQuery.objects.select_related('song') \
.values('song__id', 'song__title', 'song__url', 'song__artist', 'song__counter', 'query')
for term in terms:
remaining_songs = remaining_songs.filter(
Q(song__title__icontains=term)
| Q(song__artist__icontains=term) | Q(query__icontains=term))
remaining_songs = remaining_songs \
.values('song__id', 'song__title', 'song__url', 'song__artist', 'song__counter') \
.distinct() \
.order_by('-song__counter') \
[:20]
results = []
for song in remaining_songs:
if song_utils.path_from_url(song['song__url']) is not None:
cached = True
else:
cached = False
# don't suggest online songs when we don't have internet
if not self.musiq.base.settings.has_internet:
if not cached:
continue
result_dict = {
'key':
song['song__id'],
'value':
song_utils.displayname(song['song__artist'],
song['song__title']),
'counter':
song['song__counter'],
'type':
'cached' if cached else 'online',
}
results.append(result_dict)
return HttpResponse(json.dumps(results))
def _loop(self):
while True:
catch_up = None
if models.CurrentSong.objects.exists():
# recover interrupted song from database
current_song = models.CurrentSong.objects.get()
# continue with the current song (approximately) where we last left
duration = song_utils.get_duration(current_song.location)
catch_up = (timezone.now() -
current_song.created).total_seconds()
else:
self.queue_semaphore.acquire()
# select the next song depending on settings
if self.musiq.base.settings.voting_system:
with transaction.atomic():
song = self.queue.all().order_by('-votes', 'index')[0]
song_id = song.id
self.queue.remove(song.id)
elif self.shuffle:
index = random.randint(
0,
models.QueuedSong.objects.count() - 1)
song_id = models.QueuedSong.objects.all()[index].id
song = self.queue.remove(song_id)
else:
# move the first song in the queue into the current song
song_id, song = self.queue.dequeue()
if song is None:
# either the semaphore didn't match up with the actual count of songs in the queue or a race condition occured
self.musiq.base.logger.info('dequeued on empty list')
continue
location = song_utils.path_from_url(song.url)
current_song = models.CurrentSong.objects.create(
queue_key=song_id,
votes=song.votes,
url=song.url,
artist=song.artist,
title=song.title,
duration=song.duration,
location=location)
try:
archived_song = models.ArchivedSong.objects.get(
url=current_song.url)
if self.musiq.base.settings.voting_system:
votes = current_song.votes
else:
votes = None
if self.musiq.base.settings.logging_enabled:
models.PlayLog.objects.create(song=archived_song,
votes=votes)
except (models.ArchivedSong.DoesNotExist,
models.ArchivedSong.MultipleObjectsReturned):
pass
self.musiq.update_state()
with self.mpd_command(important=True):
self.player.add('file://' + current_song.location)
self.player.play()
if catch_up is not None:
self.player.seekcur(catch_up)
self.musiq.update_state()
self._wait_until_song_end()
with self.mpd_command(important=True):
try:
self.player.delete(0)
except mpd.base.CommandError:
# catch Bad song index if there is no song
pass
current_song.delete()
if self.repeat:
self.queue.enqueue(current_song.location)
self.queue_semaphore.release()
else:
# the song left the queue, we can delete big downloads
song_utils.decide_deletion(current_song.location)
self.musiq.update_state()
if self.musiq.base.user_manager.partymode_enabled(
) and random.random() < self.musiq.base.settings.alarm_probability:
self.alarm_playing.set()
self.musiq.base.lights.alarm_started()
with self.mpd_command(important=True):
self.player.add('file://' + os.path.join(
settings.BASE_DIR, 'config/sounds/alarm.mp3'))
self.player.play()
self._wait_until_song_end()
self.musiq.base.lights.alarm_stopped()
with self.mpd_command(important=True):
self.player.delete(0)
self.alarm_playing.clear()
def get_suggestions(self, request):
terms = request.GET['term'].split()
suggest_playlist = request.GET['playlist'] == 'true'
results = []
if suggest_playlist:
remaining_playlists = ArchivedPlaylist.objects.prefetch_related(
'queries')
# exclude radios from suggestions
remaining_playlists = remaining_playlists.exclude(
list_id__startswith='RD').exclude(list_id__contains='&list=RD')
for term in terms:
remaining_playlists = remaining_playlists.filter(
Q(title__icontains=term)
| Q(queries__query__icontains=term))
remaining_playlists = remaining_playlists \
.values('id', 'title', 'counter') \
.distinct() \
.order_by('-counter') \
[:20]
for playlist in remaining_playlists:
cached = False
result_dict = {
'key': playlist['id'],
'value': playlist['title'],
'counter': playlist['counter'],
'type': 'cached' if cached else 'online',
}
results.append(result_dict)
else:
remaining_songs = ArchivedSong.objects.prefetch_related('queries')
for term in terms:
remaining_songs = remaining_songs.filter(
Q(title__icontains=term) | Q(artist__icontains=term)
| Q(queries__query__icontains=term))
remaining_songs = remaining_songs \
.values('id', 'title', 'url', 'artist', 'counter') \
.distinct() \
.order_by('-counter') \
[:20]
for song in remaining_songs:
if song_utils.path_from_url(song['url']) is not None:
cached = True
else:
cached = False
# don't suggest online songs when we don't have internet
if not self.musiq.base.settings.has_internet:
if not cached:
continue
result_dict = {
'key': song['id'],
'value': song_utils.displayname(song['artist'],
song['title']),
'counter': song['counter'],
'type': 'cached' if cached else 'online',
}
results.append(result_dict)
return HttpResponse(json.dumps(results))