def get_object(self):
video = self.get_video()
workflow = workflows.get_workflow(video)
language_code = self.kwargs['language_code']
if not workflow.user_can_view_video(self.request.user):
raise PermissionDenied()
version_number = self.request.query_params.get('version_number')
if version_number is None:
version_number = self.request.query_params.get('version')
if version_number is not None:
version = video.newsubtitleversion_set.get(
language_code=language_code,
version_number=version_number)
else:
language = video.subtitle_language(language_code)
if language is None:
raise Http404
version = language.get_public_tip()
if version is None:
raise Http404
if version.is_deleted():
raise Http404
if (not version.is_public() and
not workflow.user_can_view_private_subtitles(self.request.user,
language_code)):
raise PermissionDenied()
return version
def get(self, request, video_id, language_code):
self.video = get_object_or_404(Video, video_id=video_id)
self.team_video = self.video.get_team_video()
self.language_code = language_code
self.user = request.user
self.calc_base_language()
self.calc_editing_language()
self.workflow = get_workflow(self.video)
if (not self.check_can_edit() or not self.check_can_writelock()
or not self.assign_task_for_editor()):
if 'team' in self.request.GET:
qs = '?{}'.format(urlencode({'team':
self.request.GET['team']}))
return redirect(self.video.get_absolute_url() + qs)
return redirect(self.video)
self.editing_language.writelock(self.user, save=True)
self.editing_version = self.editing_language.get_tip(public=False)
# we ignore forking because even if it *is* a fork, we still want to
# show the user the rererence languages:
self.translated_from_version = self.editing_language.\
get_translation_source_version(ignore_forking=True)
self.languages = self.video.newsubtitlelanguage_set.annotate(
num_versions=Count('subtitleversion'))
editor_data = self.get_editor_data()
self.experimental = 'experimental' in request.GET
context = {
'title':
self.get_title(),
'video':
self.video,
'DEBUG':
settings.DEBUG,
'language':
self.editing_language,
'other_languages':
self.languages,
'version':
self.editing_version,
'translated_from_version':
self.translated_from_version,
'experimental':
self.experimental,
'upload_subtitles_form':
SubtitlesUploadForm(
request.user,
self.video,
initial={'language_code': self.editing_language.language_code},
allow_all_languages=True),
}
self.handle_task(context, editor_data)
context['editor_data'] = json.dumps(editor_data, indent=4)
if self.experimental:
return render(request, "experimental-editor/editor.html", context)
else:
return render(request, "editor/editor.html", context)
def create(self, request, *args, **kwargs):
video = self.get_video()
workflow = workflows.get_workflow(video)
if not workflow.user_can_edit_subtitles(
self.request.user, self.kwargs['language_code']):
raise PermissionDenied()
videos.tasks.video_changed_tasks.delay(video.pk)
return super(SubtitlesView, self).create(request, *args, **kwargs)
def get(self, request, video_id, language_code, format=None):
video = get_object_or_404(Video, video_id=video_id)
workflow = workflows.get_workflow(video)
if not workflow.user_can_edit_subtitles(request.user, language_code):
raise PermissionDenied()
action_list = workflow.get_actions(request.user, language_code)
serializer = ActionsSerializer(action_list, many=True)
return Response(serializer.data)
def test_publish_action(self):
# test the publish action by itself
pipeline.add_subtitles(self.video, 'en', SubtitleSetFactory())
self.subtitles_published_handler.reset_mock()
workflow = workflows.get_workflow(self.video)
workflow.perform_action(self.user, 'en', 'publish')
self.subtitles_published_handler.assert_called_with(
signal=mock.ANY,
sender=self.video.subtitle_language('en'),
version=None)
def post(self, request, video_id, language_code, format=None):
try:
action = request.DATA['action']
except KeyError:
return Response('no action', status=status.HTTP_400_BAD_REQUEST)
video = get_object_or_404(Video, video_id=video_id)
workflow = workflows.get_workflow(video)
try:
workflow.perform_action(request.user, language_code, action)
except (ActionError, LookupError), e:
return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs):
video = self.get_video()
workflow = workflows.get_workflow(video)
if not workflow.user_can_edit_subtitles(self.request.user,
self.kwargs['language_code']):
raise PermissionDenied()
try:
version = super(SubtitlesView,
self).create(request, *args, **kwargs)
except (ActionError, LookupError), e:
return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
def get(self, request, video_id, language_code):
self.video = get_object_or_404(Video, video_id=video_id)
self.team_video = self.video.get_team_video()
self.language_code = language_code
self.user = request.user
self.calc_base_language()
self.calc_editing_language()
self.workflow = get_workflow(self.video)
if (not self.check_can_edit() or not self.check_can_writelock()
or not self.assign_task_for_editor()):
return redirect(self.video)
self.editing_language.writelock(self.user,
self.request.browser_id,
save=True)
self.editing_version = self.editing_language.get_tip(public=False)
# we ignore forking because even if it *is* a fork, we still want to
# show the user the rererence languages:
self.translated_from_version = self.editing_language.\
get_translation_source_version(ignore_forking=True)
self.languages = self.video.newsubtitlelanguage_set.annotate(
num_versions=Count('subtitleversion'))
editor_data = self.get_editor_data()
context = {
'title':
self.get_title(),
'video':
self.video,
'DEBUG':
settings.DEBUG,
'language':
self.editing_language,
'other_languages':
self.languages,
'version':
self.editing_version,
'translated_from_version':
self.translated_from_version,
'GOOGLE_ANALYTICS_ADDITIONS':
self.get_analytics_additions(),
'upload_subtitles_form':
SubtitlesUploadForm(
request.user,
self.video,
initial={'language_code': self.editing_language.language_code},
allow_all_languages=True),
}
self.handle_task(context, editor_data)
context['editor_data'] = json.dumps(editor_data, indent=4)
return render(request, "editor/editor.html", context)
def delete(self, request, *args, **kwargs):
language_code = kwargs['language_code']
video = self.get_video()
workflow = workflows.get_workflow(video)
if not workflow.user_can_delete_subtitles(self.request.user,
language_code):
raise PermissionDenied()
request.data.pop('duration', None)
subtitle_language = video.subtitle_language(language_code)
subtitle_language.nuke_language()
videos.tasks.video_changed_tasks.delay(video.pk)
return Response(status=status.HTTP_204_NO_CONTENT)
def create(self, request, *args, **kwargs):
video = self.get_video()
workflow = workflows.get_workflow(video)
if not workflow.user_can_edit_subtitles(self.request.user, self.kwargs['language_code']) or \
not user_can_access_subtitles_format(self.request.user, self.request.data.get('sub_format', None)):
raise PermissionDenied()
if not workflow.user_can_set_video_duration(self.request.user):
request.data.pop('duration', None)
try:
version = super(SubtitlesView,
self).create(request, *args, **kwargs)
except (ActionError, LookupError), e:
return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
def _calc_action_for_add_subtitles(video, language_code, author, complete,
action_name):
# complete and action do similar things. In _add_subtitles _add_subtitles
# we only want to deal with action, not complete. this
if action_name and complete is not None:
raise ValueError("Both action and complete set")
workflow = workflows.get_workflow(video)
if action_name:
return workflow.lookup_action(author, language_code, action_name)
else:
return workflow.action_for_add_subtitles(author, language_code,
complete)
def post(self, request, video_id, language_code, format=None):
try:
action = request.data['action']
except KeyError:
return Response('no action', status=status.HTTP_400_BAD_REQUEST)
video = get_object_or_404(Video, video_id=video_id)
workflow = workflows.get_workflow(video)
if not workflow.user_can_edit_subtitles(request.user, language_code):
raise PermissionDenied()
language = video.subtitle_language(language_code)
if language is None or language.get_tip() is None:
return Response('No subtitles', status=status.HTTP_400_BAD_REQUEST)
try:
workflow.perform_action(request.user, language_code, action)
except (ActionError, LookupError), e:
return Response(str(e), status=status.HTTP_400_BAD_REQUEST)
def get_editor_notes(self, **kwargs):
video = get_object_or_404(Video, video_id=kwargs['video_id'])
workflow = workflows.get_workflow(video)
return workflow.get_editor_notes(kwargs['language_code'])
def get(self, request, video_id, language_code, format=None):
video = get_object_or_404(Video, video_id=video_id)
workflow = workflows.get_workflow(video)
action_list = workflow.get_actions(request.user, language_code)
serializer = ActionsSerializer(action_list, many=True)
return Response(serializer.data)
def user_can_edit_subtitles(user, video, language_code):
if user.is_staff:
return True
workflow = workflows.get_workflow(video)
return workflow.user_can_edit_subtitles(user, language_code)
def test_workflow_returns_task_team_editor_notes(self):
workflow = workflows.get_workflow(self.video)
editor_notes = workflow.get_editor_notes('en')
assert_is_instance(editor_notes, TaskTeamEditorNotes)
