def regain_lock(self, request, session_pk):
language = SubtitlingSession.objects.get(pk=session_pk).language
if not language.can_writelock(request.user):
return {'response': 'unlockable'}
else:
language.writelock(request.user)
video_cache.writelock_add_lang(language.video.video_id,
language.language_code)
return {'response': 'ok'}
def regain_lock(self, request, session_pk):
language = SubtitlingSession.objects.get(pk=session_pk).language
if not language.can_writelock(request):
return {"response": "unlockable"}
else:
language.writelock(request)
language.save()
video_cache.writelock_add_lang(language.video.video_id, language.language)
return {"response": "ok"}
def start_editing(self,
request,
video_id,
language_code,
subtitle_language_pk=None,
base_language_pk=None,
original_language_code=None):
"""Called by subtitling widget when subtitling or translation
is to commence on a video.
"""
# TODO: remove whenever blank SubtitleLanguages become illegal.
self._fix_blank_original(video_id)
if language_code == original_language_code:
base_language_pk = None
base_language = None
if base_language_pk is not None:
base_language = models.SubtitleLanguage.objects.get(
pk=base_language_pk)
language, can_edit = self._get_language_for_editing(
request, video_id, language_code, subtitle_language_pk,
base_language)
if not can_edit:
return {
"can_edit": False,
"locked_by": language.writelock_owner_name
}
session = self._make_subtitling_session(request, language,
base_language)
version_for_subs = language.version()
if not version_for_subs:
version_for_subs = self._create_version_from_session(session)
version_no = 0
else:
version_no = version_for_subs.version_no + 1
subtitles = self._subtitles_dict(version_for_subs, version_no,
base_language_pk is None)
return_dict = {
"can_edit": True,
"session_pk": session.pk,
"subtitles": subtitles
}
if base_language:
return_dict['original_subtitles'] = \
self._subtitles_dict(base_language.latest_version())
if original_language_code:
self._save_original_language(video_id, original_language_code)
video_cache.writelock_add_lang(video_id, language.language)
return return_dict
def start_editing(self, request, video_id,
language_code,
subtitle_language_pk=None,
base_language_pk=None,
original_language_code=None):
"""Called by subtitling widget when subtitling or translation
is to commence on a video.
"""
# TODO: remove whenever blank SubtitleLanguages become illegal.
self._fix_blank_original(video_id)
if language_code == original_language_code:
base_language_pk = None
base_language = None
if base_language_pk is not None:
base_language = models.SubtitleLanguage.objects.get(
pk=base_language_pk)
language, can_edit = self._get_language_for_editing(
request, video_id, language_code,
subtitle_language_pk, base_language)
if not can_edit:
return { "can_edit": False,
"locked_by" : language.writelock_owner_name }
session = self._make_subtitling_session(
request, language, base_language)
version_for_subs = language.version()
if not version_for_subs:
version_for_subs = self._create_version_from_session(session)
version_no = 0
else:
version_no = version_for_subs.version_no + 1
subtitles = self._subtitles_dict(
version_for_subs, version_no, base_language_pk is None)
return_dict = { "can_edit" : True,
"session_pk" : session.pk,
"subtitles" : subtitles }
if base_language:
return_dict['original_subtitles'] = \
self._subtitles_dict(base_language.latest_version())
if original_language_code:
self._save_original_language(video_id, original_language_code)
video_cache.writelock_add_lang(video_id, language.language)
return return_dict
def start_editing(self,
request,
video_id,
language_code,
subtitle_language_pk=None,
base_language_code=None,
original_language_code=None,
mode=None):
"""Called by subtitling widget when subtitling or translation is to commence on a video.
Does a lot of things, some of which should probably be split out into
other functions.
"""
# TODO: remove whenever blank SubtitleLanguages become illegal.
# Find the subtitle language we'll be editing (if available).
language, locked = self._get_language_for_editing(
request, video_id, language_code, subtitle_language_pk,
base_language_code)
if locked:
return locked
version = language.get_tip(public=False)
# Ensure that the user is not blocked from editing this video by team
# permissions.
locked = self._check_team_video_locking(request.user, video_id,
language_code)
if locked:
return locked
# just lock the video *after* we verify if team moderation happened
language.writelock(request.user)
language.save()
# Create the subtitling session and subtitle version for these edits.
# we determine that a it's a translation if:
# - the front end specifically said to translate from (base_language_code)
# - The language has another source in it's lineage and it is not marked as forking
translated_from_code = None
translated_from = None
if base_language_code:
translated_from_code = base_language_code
elif language.is_forked == False:
translated_from_code = language.get_translation_source_language_code(
)
if translated_from_code:
translated_from = language.video.subtitle_language(
translated_from_code)
session = self._make_subtitling_session(request, language,
translated_from_code, video_id)
version_for_subs, version_number = self._get_version_to_edit(
language, session)
args = {'session': session}
if version_for_subs:
args['version'] = version_for_subs
session.parent = version_for_subs
session.save()
else:
args['language'] = language
subtitles = self._subtitles_dict(**args)
# this is basically how it worked before. don't ask.
subtitles['forked'] = base_language_code is None
return_dict = {
"can_edit": True,
"session_pk": session.pk,
"timing_mode": self.get_timing_mode(language, request.user),
"subtitles": subtitles
}
# If this is a translation, include the subtitles it's based on in the response.
if translated_from:
version = translated_from.get_tip(public=True)
if not version:
return {
"can_edit":
False,
"locked_by":
"",
"message":
"You cannot translate from a version that is incomplete"
}
original_subtitles = self._subtitles_dict(version=version)
return_dict['original_subtitles'] = original_subtitles
# If we know the original language code for this video, make sure it's
# saved and there's a SubtitleLanguage for it in the database.
#
# Remember: the "original language" is the language of the video, NOT
# the language these subs are a translation of (if any).
if original_language_code:
self._save_original_language(video_id, original_language_code)
# Writelock this language for this video before we successfully return.
video_cache.writelock_add_lang(video_id, language.language_code)
return return_dict
def start_editing(self,
request,
video_id,
language_code,
subtitle_language_pk=None,
base_language_pk=None,
original_language_code=None,
mode=None):
"""Called by subtitling widget when subtitling or translation is to commence on a video.
Does a lot of things, some of which should probably be split out into
other functions.
"""
# TODO: remove whenever blank SubtitleLanguages become illegal.
self._fix_blank_original(video_id)
# Find the subtitle language to use as a base for these edits, if any.
base_language, base_language_pk = self._get_base_language(
language_code, original_language_code, base_language_pk)
# Find the subtitle language we'll be editing (if available).
language, locked = self._get_language_for_editing(
request, video_id, language_code, subtitle_language_pk,
base_language)
if locked:
return locked
# Ensure that the user is not blocked from editing this video by team
# permissions.
locked = self._check_team_video_locking(
request.user, video_id, language_code, bool(base_language_pk),
mode, bool(language.version(public_only=False)))
if locked:
return locked
# just lock the video *after* we verify if team moderation happened
language.writelock(request)
language.save()
# Create the subtitling session and subtitle version for these edits.
session = self._make_subtitling_session(request, language,
base_language)
version_for_subs, version_no = self._get_version_to_edit(
language, session)
subtitles = self._subtitles_dict(version_for_subs, version_no,
base_language_pk is None)
return_dict = {
"can_edit": True,
"session_pk": session.pk,
"subtitles": subtitles
}
# If this is a translation, include the subtitles it's based on in the response.
if base_language:
original_subtitles = self._subtitles_dict(
base_language.latest_version())
return_dict['original_subtitles'] = original_subtitles
# If we know the original language code for this video, make sure it's
# saved and there's a SubtitleLanguage for it in the database.
#
# Remember: the "original language" is the language of the video, NOT
# the language these subs are a translation of (if any).
if original_language_code:
self._save_original_language(video_id, original_language_code)
# Writelock this language for this video before we successfully return.
video_cache.writelock_add_lang(video_id, language.language)
return return_dict
