def _check_team_video_locking(self, user, video_id, language_code):
"""Check whether the a team prevents the user from editing the subs.
Returns a dict appropriate for sending back if the user should be
prevented from editing them, or None if the user can safely edit.
"""
video = models.Video.objects.get(video_id=video_id)
check_result = can_add_version(user, video, language_code)
if check_result:
return None
else:
return {
"can_edit": False,
"locked_by": check_result.locked_by,
"message": check_result.message
}
def setup_tab(self, request, video, language, version):
team_video = video.get_team_video()
user_can_add_version = can_add_version(request.user, video,
language.language_code)
self['downloadable_formats'] = AVAILABLE_SUBTITLE_FORMATS_FOR_DISPLAY
self['edit_disabled'] = not user_can_add_version
# If there are tasks for this language, the user has to go through the
# tasks panel to edit things instead of doing it directly from here.
if user_can_add_version and video.get_team_video():
has_open_task = (Task.objects.incomplete().filter(
team_video=video.get_team_video(),
language=language.language_code).exists())
if has_open_task:
self['edit_disabled'] = True
self['must_use_tasks'] = True
if 'rollback_allowed' not in self:
self['rollback_allowed'] = self.calc_rollback_allowed(
request, version, language)
def user_can_edit_subtitles(self, user, language_code):
return can_add_version(user, self.video, language_code)
def subtitle_editor(request, video_id, language_code):
'''
Renders the subtitle-editor page, with all data neeeded for the UI
as a json object on the html document.
If the language does not exist, it will create one and lock it.
Also decides what source version should be shown initially (if
it is a translation).
'''
# FIXME: permissions
video = get_object_or_404(Video, video_id=video_id)
if (video.primary_audio_language_code
and SubtitleVersion.objects.extant().filter(
video=video,
language_code=video.primary_audio_language_code).exists()):
base_language = video.primary_audio_language_code
else:
base_language = None
try:
editing_language = video.newsubtitlelanguage_set.get(
language_code=language_code)
except SubtitleLanguage.DoesNotExist:
editing_language = SubtitleLanguage(video=video,
language_code=language_code)
if not editing_language.can_writelock(request.browser_id):
messages.error(request,
_("You can't edit this subtitle because it's locked"))
return redirect(video)
error_message = assign_task_for_editor(video, language_code, request.user)
if error_message:
messages.error(request, error_message)
return redirect(video)
task = get_task_for_editor(video, language_code)
check_result = can_add_version(request.user, video, language_code)
if not check_result:
messages.error(request, check_result.message)
return redirect(video)
editing_language.writelock(request.user, request.browser_id, save=True)
# if this language is a translation, show both
editing_version = 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:
translated_from_version = editing_language.\
get_translation_source_version(ignore_forking=True)
languages = video.newsubtitlelanguage_set.annotate(
num_versions=Count('subtitleversion'))
video_urls = []
for v in video.get_video_urls():
video_urls.append(v.url)
editor_data = {
'canSync':
bool(request.GET.get('canSync', True)),
'canAddAndRemove':
bool(request.GET.get('canAddAndRemove', True)),
# front end needs this to be able to set the correct
# api headers for saving subs
'authHeaders': {
'x-api-username': request.user.username,
'x-apikey': request.user.get_api_key()
},
'video': {
'id': video.video_id,
'title': video.title,
'description': video.description,
'primaryVideoURL': video.get_video_url(),
'videoURLs': video_urls,
'metadata': video.get_metadata(),
},
'editingVersion': {
'languageCode':
editing_language.language_code,
'versionNumber':
(editing_version.version_number if editing_version else None),
},
'baseLanguage':
base_language,
'languages': [
_language_data(lang, editing_version, translated_from_version,
base_language) for lang in languages
],
'languageCode':
request.LANGUAGE_CODE,
'oldEditorURL':
reverse('subtitles:old-editor',
kwargs={
'video_id': video.video_id,
'language_code': editing_language.language_code,
}),
'staticURL':
settings.STATIC_URL,
}
if task:
editor_data['task_id'] = task.id
editor_data['savedNotes'] = task.body
editor_data['task_needs_pane'] = task.get_type_display() in ('Review',
'Approve')
editor_data['team_slug'] = task.team.slug
editor_data['oldEditorURL'] += '?' + urlencode(
{
'mode': Task.TYPE_NAMES[task.type].lower(),
'task_id': task.id,
})
team_attributes = get_team_attributes_for_editor(video)
if team_attributes:
editor_data['teamAttributes'] = team_attributes
return render_to_response("subtitles/subtitle-editor.html", {
'video': video,
'DEBUG': settings.DEBUG,
'language': editing_language,
'other_languages': languages,
'version': editing_version,
'translated_from_version': translated_from_version,
'task': task,
'editor_data': json.dumps(editor_data, indent=4)
},
context_instance=RequestContext(request))
