def rollback(request, version):
is_writelocked = version.subtitle_language.is_writelocked
if not user_can_edit_subtitles(request.user, version.video,
version.subtitle_language.language_code):
messages.error(
request,
_(u"You don't have permission to rollback "
"this language"))
elif is_writelocked:
messages.error(
request,
u'Can not rollback now, because someone is editing subtitles.')
elif not version.next_version():
messages.error(request,
message=u'Can not rollback to the last version')
else:
messages.success(request, message=u'Rollback successful')
version = rollback_to(version.video,
version.subtitle_language.language_code,
version_number=version.version_number,
rollback_author=request.user)
video_changed_tasks.delay(version.video.id, version.id)
return redirect(version.subtitle_language.get_absolute_url() +
'#revisions')
return redirect(version)
def setup_tab(self, request, video, language, version):
team_video = video.get_team_video()
user_can_edit = user_can_edit_subtitles(request.user, video,
language.language_code)
public_langs = (
video.newsubtitlelanguage_set.having_public_versions().count())
downloadable_formats = AVAILABLE_SUBTITLE_FORMATS_FOR_DISPLAY
downloadable_formats_set = set(downloadable_formats)
for format in SubtitleFormatList.for_staff():
if user_can_access_subtitles_format(request.user, format):
downloadable_formats_set.add(format)
downloadable_formats = list(downloadable_formats_set)
self['downloadable_formats'] = downloadable_formats
self['edit_disabled'] = not user_can_edit
self['show_download_all'] = public_langs > 1
# 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_edit 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, video, version, language)
def diffing(request, first_version, second_pk):
language = first_version.subtitle_language
second_version = get_object_or_404(SubtitleVersion.objects.extant(),
pk=second_pk,
subtitle_language=language)
if first_version.video != second_version.video:
# this is either a bad bug, or someone evil
raise "Revisions for diff videos"
if first_version.pk < second_version.pk:
# this is just stupid Instead of first, second meaning
# chronological order (first cames before second)
# it means the opposite, so make sure the first version
# has a larger version no than the second
first_version, second_version = second_version, first_version
video = first_version.subtitle_language.video
diff_data = diff_subs(first_version.get_subtitles(),
second_version.get_subtitles(),
mappings=HTMLGenerator.MAPPINGS)
team_video = video.get_team_video()
first_version_previous = first_version.previous_version()
first_version_next = first_version.next_version()
second_version_previous = second_version.previous_version()
second_version_next = second_version.next_version()
context = {
'video':
video,
'diff_data':
diff_data,
'language':
language,
'first_version':
first_version,
'second_version':
second_version,
'latest_version':
language.get_tip(),
'first_version_previous':
first_version_previous if
(first_version_previous != second_version) else None,
'first_version_next':
first_version_next,
'second_version_previous':
second_version_previous,
'second_version_next':
second_version_next if
(second_version_next != first_version) else None,
'rollback_allowed':
user_can_edit_subtitles(request.user, video, language.language_code),
'width':
video_size["small"]["width"],
'height':
video_size["small"]["height"],
'video_url':
video.get_video_url(),
}
return render(request, 'videos/diffing.html', context)
def rollback(request, version):
# Normally, we only accept POST methods, but the old template code uses
# GET, so we allow that too.
if should_use_old_view(request) or request.method == 'POST':
is_writelocked = version.subtitle_language.is_writelocked
if not user_can_edit_subtitles(
request.user, version.video,
version.subtitle_language.language_code):
messages.error(
request,
_(u"You don't have permission to rollback "
"this language"))
elif is_writelocked:
messages.error(
request,
u'Can not rollback now, because someone is editing subtitles.')
elif not version.next_version():
messages.error(request,
message=u'Can not rollback to the last version')
else:
messages.success(request, message=u'Rollback successful')
version = rollback_to(version.video,
version.subtitle_language.language_code,
version_number=version.version_number,
rollback_author=request.user)
video_changed_tasks.delay(version.video.id, version.id)
return redirect(version.subtitle_language.get_absolute_url() +
'#revisions')
return redirect(version)
def calc_rollback_allowed(self, request, video, version, language):
if version and version.next_version():
return user_can_edit_subtitles(request.user, video,
language.language_code)
else:
return False
