137 lines
5.5 KiB
Python
137 lines
5.5 KiB
Python
from django.conf import settings
|
|
from django.core.validators import (MaxLengthValidator, MinValueValidator,
|
|
MaxValueValidator)
|
|
from django.db import models
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
from dynamic_preferences.registries import global_preferences_registry
|
|
|
|
from core.behaviors import Disableable, Timestampable
|
|
from radio.models import Song
|
|
from .exceptions import MakeRequestError
|
|
from .managers import RequestManager
|
|
|
|
|
|
radio_settings = global_preferences_registry.manager()
|
|
|
|
|
|
class RadioProfile(Disableable, Timestampable, models.Model):
|
|
user = models.OneToOneField(settings.AUTH_USER_MODEL,
|
|
on_delete=models.CASCADE,
|
|
related_name='profile',
|
|
null=True,
|
|
blank=True)
|
|
favorites = models.ManyToManyField(Song, related_name='favorited_by')
|
|
ratings = models.ManyToManyField(Song,
|
|
related_name='ratings',
|
|
through='Rating')
|
|
song_requests = models.ManyToManyField(Song,
|
|
related_name='request_history',
|
|
through='SongRequest')
|
|
|
|
def disable(self, reason=''):
|
|
super().disable(reason)
|
|
user = self.user
|
|
user.is_active = False
|
|
user.save(update_fields=['is_active'])
|
|
|
|
def enable(self):
|
|
super().enable()
|
|
user = self.user
|
|
user.is_active = True
|
|
user.save(update_fields=['is_active'])
|
|
|
|
def has_reached_request_max(self):
|
|
self_requests = SongRequest.music.unplayed().filter(profile=self)
|
|
max_requests = radio_settings['general__max_song_requests']
|
|
return self_requests.count() >= max_requests
|
|
|
|
def can_request(self):
|
|
if not self.disabled:
|
|
return self.user.is_staff or not self.has_reached_request_max()
|
|
return False
|
|
|
|
def make_request(self, song_requested):
|
|
if isinstance(song_requested, int):
|
|
try:
|
|
song = Song.objects.get(pk=song_requested)
|
|
except Song.DoesNotExist:
|
|
raise MakeRequestError('Song does not exist.')
|
|
else:
|
|
song = song_requested
|
|
|
|
if self.disabled:
|
|
raise MakeRequestError('User is currently disabled.')
|
|
|
|
if self.has_reached_request_max() and not self.user.is_staff:
|
|
max_requests = radio_settings['general__max_song_requests']
|
|
message = 'User has reached the maximum request limit ({}).'
|
|
raise MakeRequestError(message.format(max_requests))
|
|
|
|
if song.is_jingle and not self.user.is_staff:
|
|
raise MakeRequestError('Users cannot request a jingle.')
|
|
|
|
if song.is_song and not self.user.is_staff and not song.is_requestable:
|
|
if not song.is_available:
|
|
raise MakeRequestError('Song not available at this time.')
|
|
|
|
if song.is_playable:
|
|
raise MakeRequestError('Song is already in request queue.')
|
|
|
|
play_again = song.get_date_when_requestable().isoformat(' ',
|
|
'seconds')
|
|
message = ('Song has been played recently and cannot be requested '
|
|
'again until {}')
|
|
raise MakeRequestError(message.format(play_again))
|
|
|
|
SongRequest.objects.create(profile=self, song=song)
|
|
|
|
def __str__(self):
|
|
return "{}'s profile".format(self.user.get_username())
|
|
|
|
|
|
class Rating(Timestampable, models.Model):
|
|
profile = models.ForeignKey(RadioProfile,
|
|
on_delete=models.CASCADE,
|
|
related_name='rating_profile')
|
|
song = models.ForeignKey(Song, on_delete=models.CASCADE)
|
|
value = models.PositiveIntegerField(_('song rating'),
|
|
validators=[MinValueValidator(1),
|
|
MaxValueValidator(5)])
|
|
|
|
def __str__(self):
|
|
return "{} - {}'s Rating: {}".format(self.song.title,
|
|
self.profile.user.get_username(),
|
|
self.value)
|
|
|
|
|
|
class SongRequest(Timestampable, models.Model):
|
|
profile = models.ForeignKey(RadioProfile,
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
blank=True,
|
|
related_name='request_profile')
|
|
song = models.ForeignKey(Song,
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
blank=True)
|
|
queued_at = models.DateTimeField(_('song queued at'),
|
|
default=None,
|
|
blank=True,
|
|
null=True)
|
|
played_at = models.DateTimeField(_('song played at'),
|
|
default=None,
|
|
blank=True,
|
|
null=True)
|
|
|
|
objects = models.Manager()
|
|
music = RequestManager()
|
|
|
|
class Meta:
|
|
ordering = ['-queued_at', '-created_date', ]
|
|
|
|
def __str__(self):
|
|
req_user = self.profile.user.get_username()
|
|
return "{} - Requested by {} at {}".format(self.song.title,
|
|
req_user,
|
|
self.created_date)
|