예제 #1
0
def send_tour_reminder_text(tour):
    to_person = tour.guide

    allow_texting = core_utils.get_setting('Allow Texting to Info Center')
    info_center_name = core_utils.get_setting('Info Center Director Name')
    info_center_phone = core_utils.get_setting('Info Center Phone Number')

    context = {'tour': tour, 'allow_texting': allow_texting, 'info_center_name': info_center_name, 'info_center_phone': info_center_phone}
    core_utils.send_text(unicode(to_person.phone), 'texts/tour_reminder.txt', context)
예제 #2
0
def send_tour_reminder_email(tour):
    from_email = get_email_by_position('Tour Coordinator (Primary)', 'Tour Coordinator')
    to_person = tour.guide
    to_emails = ['{} <{}>'.format(to_person.full_name, to_person.email)]
    subject = 'Tour Tomorrow at {}'.format(tour.time_local().strftime('%-I:%M %p'))

    allow_texting = core_utils.get_setting('Allow Texting to Info Center')
    info_center_name = core_utils.get_setting('Info Center Director Name')
    info_center_phone = core_utils.get_setting('Info Center Phone Number')

    context = {'tour': tour, 'allow_texting': allow_texting, 'info_center_name': info_center_name, 'info_center_phone': info_center_phone}
    core_utils.send_email(subject, to_emails, from_email, 'email/tour_reminder.txt', 'email/tour_reminder.html', context)
예제 #3
0
    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():
            max_requests = get_setting('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)
예제 #4
0
def get_email_by_position(*positions):
    """
    Return email of first person at position, falls back on fallback email address.
    """
    person = get_person_by_position(*positions)
    fallback = get_setting('Fallback Email Address')
    return '{} {} <{}>'.format(person.first_name, person.last_name, person.email) if person is not None else fallback
예제 #5
0
 def wait_total(self, adjusted_ratio=0.0):
     '''
     Default length in seconds before a song can be played again. This is
     based on the replay ratio set in the application settings.
     '''
     total_ratio = get_setting('replay_ratio') + adjusted_ratio
     wait = self.playlist_length() * Decimal(total_ratio)
     wait = wait.quantize(Decimal('.01'), rounding=ROUND_UP)
     return timedelta(seconds=float(wait))
예제 #6
0
def get_email_by_position(*positions):
    """
    Return email of first person at position, falls back on fallback email address.
    """
    person = get_person_by_position(*positions)
    fallback = get_setting('Fallback Email Address')
    return '{} {} <{}>'.format(
        person.first_name, person.last_name,
        person.email) if person is not None else fallback
예제 #7
0
    def get_date_when_requestable(self, last_play=None):
        '''
        Datetime when a song can be requested again.
        '''
        last = self.last_played if last_play is None else last_play

        if self._is_song() and self._is_available():
            if last:
                # Check if we have enough ratings to change ratio
                min_ratings = get_setting('min_ratings_for_variance')
                if self.rating_set.count() >= min_ratings:
                    rate_ratio = get_setting('rating_variance_ratio')

                    # -((average - 1)/(highest_rating - 1)) * rating_ratio
                    base = -((self._average_rating() - 1) / 4) * rate_ratio
                    adjusted_ratio = float(base + (rate_ratio * 0.5))
                else:
                    adjusted_ratio = float(0.0)

                return last + Song.music.wait_total(adjusted_ratio)
            return timezone.now()
        return None
예제 #8
0
    def shifts_required_num(self, semester=None, year=None):
        year, semester = core_utils.parse_year_semester(year, semester)

        # start with default
        shifts_required = core_utils.get_default_num_shifts(semester=semester, year=year)

        # check for override
        try:
            overridden_reqs = self.overridden_requirements.get(semester=semester, year=year)
            shifts_required = overridden_reqs.shifts_required
        except OverrideRequirement.DoesNotExist:
            pass

        # get number of missed shifts
        num_missed = self.shifts.semester(semester=semester, year=year).filter(missed=True).count()
        num_extra = num_missed * core_utils.get_setting('Missed Shift Penalty')

        return shifts_required + num_extra
예제 #9
0
    def retrieve(self, request):
        dj_profile = RadioProfile.objects.get(user__is_dj=True)

        limit = get_setting('songs_per_jingle')
        played_songs = SongRequest.music.get_played_requests(limit)
        if [j for j in played_songs if j.song.is_jingle]:
            if not SongRequest.music.unplayed().exists():
                random_song = Song.music.get_random_requestable_song()
                next_play = SongRequest.objects.create(profile=dj_profile,
                                                       song=random_song)
            else:
                next_play = SongRequest.music.next_request()
        else:
            random_jingle = Song.music.get_random_jingle()
            next_play = SongRequest.objects.create(profile=dj_profile,
                                                   song=random_jingle)

        next_play.queued_at = timezone.now()
        next_play.save(update_fields=['queued_at'])

        serializer = GetRequestSerializer(next_play, many=False)
        return Response(serializer.data)
예제 #10
0
 def has_reached_request_max(self):
     self_requests = SongRequest.music.unplayed().filter(profile=self)
     max_requests = get_setting('max_song_requests')
     return self_requests.count() >= max_requests