def _get_podcast_config_mock(cls):
podcast_config = PodcastConfiguration()
podcast_config.url_source = ''
podcast_config.start_delay = 20
podcast_config.end_delay = 10
podcast_config.next_events = 48
return podcast_config
def test_submit_recorder(self):
self._login()
podcast_data = {
'programme_id': self.recorder_programme.id,
'date': '2015-01-02 15-00-00',
'file_name': 'show.mp3',
'mime_type': 'audio/mp3',
'length': 0,
'duration': 666,
}
response = self.client.get(
'/api/1/submit_recorder/',
podcast_data,
HTTP_AUTHORIZATION='Token {token}'.format(token=PodcastConfiguration.get_global().recorder_token)
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
episode = Episode.objects.get(
issue_date=pytz.utc.localize(datetime.datetime(2015, 1, 2, 14, 0, 0)),
programme=self.recorder_programme
)
expected_info = {
'url': PodcastConfiguration.get_global().url_source + podcast_data['file_name'],
'duration': self.recorder_programme._runtime,
'mime_type': 'audio/mp3',
'length': 0,
'episode': episode
}
self.assertEqual(
expected_info,
{_key: getattr(episode.podcast, _key) for _key in list(expected_info.keys())}
)
def save(self, *args, **kwargs):
if not self.url and self.podcast_file:
from radioco.apps.global_settings.models import PodcastConfiguration
podcast_config = PodcastConfiguration.get_global()
self.url = podcast_config.url_source.rstrip(
'/') + self.podcast_file.url
super(Podcast, self).save(*args, **kwargs)
def test_recording_schedules(self):
self._login()
self.assertEqual(Episode.objects.count(), 1)
response = self.client.get(
'/api/1/recording_schedules/',
{
'start': '2015-01-01 00:00:00',
'next_hours': 24 + 15
},
HTTP_AUTHORIZATION='Token {token}'.format(token=PodcastConfiguration.get_global().recorder_token)
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Episode.objects.count(), 2)
self.assertEqual(
json.loads(response.content),
[
{
'id': self.recorder_programme.id, 'issue_date': '2015-01-01 15-00-00', 'start': '2015-01-01 15-00-20',
'duration': '3570', 'genre': 'News & Politics',
'title': 'Episode 2x1', 'programme_name': 'recorder-me', 'author': 'Recorder me',
'album': 'Season 2', 'track': 1
},
{
'id': self.recorder_programme.id, 'issue_date': '2015-01-02 15-00-00', 'start': '2015-01-02 15-00-20',
'duration': '3570', 'genre': 'News & Politics',
'title': None, 'programme_name': 'recorder-me', 'author': 'Recorder me',
'album': 'Season 3', 'track': 1
},
]
)
def submit_recorder(request):
podcast_config = PodcastConfiguration.get_global()
default_tz = timezone.get_default_timezone()
programme_id = int(request.GET.get('programme_id'))
programme = get_object_or_404(Programme, id=programme_id)
date = default_tz.localize(datetime.datetime.strptime(request.GET.get('date'), '%Y-%m-%d %H-%M-%S'))
file_name = request.GET.get('file_name')
mime_type = request.GET.get('mime_type')
length = int(request.GET.get('length'))
url = podcast_config.url_source + file_name
try:
episode = Episode.objects.select_related('programme').get(issue_date=date, programme=programme)
except Episode.DoesNotExist:
# This shouldn't happen, we are creating episodes when the recorder ask for programmes to record
episode = Episode.objects.create_episode(date, programme)
duration = episode.programme._runtime
try:
# Podcast can exist but it should have the same values
# DECISION: overwrite values
podcast = Podcast.objects.get(episode=episode)
podcast.url = url
podcast.mime_type = mime_type
podcast.length = length
podcast.duration = duration
podcast.save()
except Podcast.DoesNotExist:
Podcast.objects.create(episode=episode, url=url, mime_type=mime_type, length=length, duration=duration)
return HttpResponse()
def recording_schedules(request):
podcast_config = PodcastConfiguration.get_global()
default_tz = timezone.get_default_timezone()
start = default_tz.localize(datetime.datetime.strptime(request.GET.get('start'), '%Y-%m-%d %H:%M:%S'))
next_hours = int(request.GET.get("next_hours") or podcast_config.next_events)
json_list = []
next_transmissions = Transmission.between(
start, start + datetime.timedelta(hours=next_hours),
schedules=Schedule.objects.filter(calendar__is_active=True, type='L')
)
for transmission in next_transmissions:
try:
episode = Episode.objects.get(issue_date=transmission.start, programme=transmission.programme)
except Episode.DoesNotExist:
episode = Episode.objects.create_episode(transmission.start, transmission.programme)
issue_date = transform_dt_to_default_tz(transmission.start)
start_dt = issue_date + datetime.timedelta(seconds=podcast_config.start_delay)
duration = transmission.schedule.runtime.seconds - podcast_config.start_delay - podcast_config.end_delay
json_entry = {
'id': transmission.programme.id, 'issue_date': issue_date.strftime('%Y-%m-%d %H-%M-%S'),
'start': start_dt.strftime('%Y-%m-%d %H-%M-%S'), 'duration': str(duration),
'genre': transmission.programme.get_category_display(), 'programme_name': transmission.programme.slug,
'title': episode.title, 'author': transmission.programme.name, 'album': _('Season') + ' ' + str(episode.season),
'track': episode.number_in_season
}
json_list.append(json_entry)
return HttpResponse(json.dumps(json_list), content_type='application/json')
def _get_podcast_config_mock(cls):
podcast_config = PodcastConfiguration()
podcast_config.url_source = u''
podcast_config.start_delay = 20
podcast_config.end_delay = 10
podcast_config.next_events = 48
return podcast_config
def test_submit_recorder(self):
self._login()
podcast_data = {
'programme_id': self.recorder_programme.id,
'date': '2015-01-02 15-00-00',
'file_name': 'show.mp3',
'mime_type': 'audio/mp3',
'length': 0,
'duration': 666,
}
response = self.client.get(
'/api/1/submit_recorder/',
podcast_data,
HTTP_AUTHORIZATION='Token {token}'.format(
token=PodcastConfiguration.get_global().recorder_token))
self.assertEqual(response.status_code, status.HTTP_200_OK)
episode = Episode.objects.get(issue_date=pytz.utc.localize(
datetime.datetime(2015, 1, 2, 14, 0, 0)),
programme=self.recorder_programme)
expected_info = {
'url':
PodcastConfiguration.get_global().url_source +
podcast_data['file_name'],
'duration':
self.recorder_programme._runtime,
'mime_type':
'audio/mp3',
'length':
0,
'episode':
episode
}
self.assertEqual(
expected_info, {
_key: getattr(episode.podcast, _key)
for _key in list(expected_info.keys())
})
def test_recording_schedules(self):
self._login()
self.assertEquals(Episode.objects.count(), 1)
response = self.client.get(
u'/api/1/recording_schedules/', {
u'start': u'2015-01-01 00:00:00',
u'next_hours': 24 + 15
},
HTTP_AUTHORIZATION='Token {token}'.format(
token=PodcastConfiguration.get_global().recorder_token))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(Episode.objects.count(), 2)
self.assertEquals(json.loads(response.content), [
{
u'id': self.recorder_programme.id,
u'issue_date': u'2015-01-01 15-00-00',
u'start': u'2015-01-01 15-00-20',
u'duration': u'3570',
u'genre': u'News & Politics',
u'title': u'Episode 2x1',
u'programme_name': u'recorder-me',
u'author': u'Recorder me',
u'album': u'Season 2',
u'track': 1
},
{
u'id': self.recorder_programme.id,
u'issue_date': u'2015-01-02 15-00-00',
u'start': u'2015-01-02 15-00-20',
u'duration': u'3570',
u'genre': u'News & Politics',
u'title': None,
u'programme_name': u'recorder-me',
u'author': u'Recorder me',
u'album': u'Season 3',
u'track': 1
},
])