def test_other_languages_changes(self):
v = self._new_version()
l = SubtitleLanguage(video=self.video, language='ru', is_original=False)
l.save()
self._new_version(l)
alarms.check_other_languages_changes(v, ignore_statistic=True)
self.assertEquals(len(mail.outbox), 1)
def test_other_languages_changes(self):
v = self._new_version()
l = SubtitleLanguage(video=self.video, language='ru', is_original=False)
l.save()
self._new_version(l)
alarms.check_other_languages_changes(v, ignore_statistic=True)
self.assertEquals(len(mail.outbox), 1)
def _find_appropriate_language(self, video, language_code):
language = video.subtitle_language(language_code)
if not language:
language = SubtitleLanguage(
video=video, is_original=False, is_forked=True)
language.language = language_code
language.save()
return language
def test_update_lp_for_sl(self):
tv = TeamVideo.objects.get(id=2)
sl = SubtitleLanguage(
language='en',
is_original=True,
is_forked=False,
is_complete=True,
video=tv.video)
sl.save()
dl = SubtitleLanguage(
language='es',
is_original=False,
is_forked=False,
percent_done=40,
standard_language=sl,
video=tv.video)
dl.save()
tv = TeamVideo.objects.get(id=2)
dl = SubtitleLanguage.objects.get(id=dl.id)
dl.percent_done = 50
dl.save()
lps = tv.searchable_language_pairs()
self.assertEquals(len(settings.ALL_LANGUAGES) * 2 - 3, len(lps))
for lp in lps:
match = LANGUAGEPAIR_RE.match(lp)
if match.group(1) == 'en':
if match.group(2) == 'es':
self.assertEquals("M", match.group(3))
else:
self.assertEquals("0", match.group(3))
elif match.group(1) == 'es':
self.assertEquals("0", match.group(3))
def test_update_tvlp_for_sl(self):
tv = TeamVideo.objects.get(id=2)
sl = SubtitleLanguage(
language='en',
is_original=True,
is_forked=False,
is_complete=True,
video=tv.video)
sl.save()
dl = SubtitleLanguage(
language='es',
is_original=False,
is_forked=False,
percent_done=40,
standard_language=sl,
video=tv.video)
dl.save()
tv = TeamVideo.objects.get(id=2)
tv.update_team_video_language_pairs()
dl = SubtitleLanguage.objects.get(id=dl.id)
dl.percent_done = 50
dl.save()
tv.update_team_video_language_pairs_for_sl(dl)
tvlps = self._tvlp_query_set(tv)
self.assertEquals(len(settings.ALL_LANGUAGES) * 2 - 2, len(tvlps))
for tvlp in tvlps:
if tvlp.language_0 == 'en':
if tvlp.language_1 == 'es':
self.assertEquals(50, tvlp.percent_complete)
else:
self.assertEquals(0, tvlp.percent_complete)
elif tvlp.language_0 == 'es':
self.assertEquals(0, tvlp.percent_complete)
def test_update_tvlp_with_dep(self):
tv = TeamVideo.objects.get(id=2)
sl = SubtitleLanguage(
language='en',
is_original=True,
is_forked=False,
is_complete=True,
video=tv.video)
sl.save()
dl = SubtitleLanguage(
language='es',
is_original=False,
is_forked=False,
percent_done=40,
standard_language=sl,
video=tv.video)
dl.save()
tv = TeamVideo.objects.get(id=2)
tv.update_team_video_language_pairs()
tvlps = self._tvlp_query_set(tv)
self.assertEquals(len(settings.ALL_LANGUAGES) * 2 - 2, len(tvlps))
for tvlp in tvlps:
if tvlp.language_0 == 'en':
if tvlp.language_1 == 'es':
self.assertEquals(40, tvlp.percent_complete)
else:
self.assertEquals(0, tvlp.percent_complete)
elif tvlp.language_0 == 'es':
self.assertEquals(0, tvlp.percent_complete)
def test_update_lp_with_dep(self):
tv = TeamVideo.objects.get(id=2)
sl = SubtitleLanguage(language='en',
is_original=True,
is_forked=False,
is_complete=True,
video=tv.video)
sl.save()
dl = SubtitleLanguage(language='es',
is_original=False,
is_forked=False,
percent_done=40,
standard_language=sl,
video=tv.video)
dl.save()
tv = TeamVideo.objects.get(id=2)
lps = tv.searchable_language_pairs()
self.assertEquals(len(settings.ALL_LANGUAGES) * 2 - 3, len(lps))
for lp in lps:
match = LANGUAGEPAIR_RE.match(lp)
if match.group(1) == 'en':
if match.group(2) == 'es':
self.assertEquals('M', match.group(3))
else:
self.assertEquals('0', match.group(3))
elif match.group(1) == 'es':
self.assertEquals('0', match.group(3))
def save_subtitles(self, parser):
video = self.cleaned_data['video']
key = str(uuid4()).replace('-', '')
video._make_writelock(self.user, key)
video.save()
if not video.has_original_language():
self._save_original_language(
video, self.cleaned_data['video_language'])
language = video.subtitle_language(self.cleaned_data['language'])
if not language:
language = SubtitleLanguage(video=video, is_original=False, is_forked=True)
language.language = self.cleaned_data['language']
language.save()
try:
old_version = language.subtitleversion_set.all()[:1].get()
version_no = old_version.version_no + 1
except ObjectDoesNotExist:
old_version = None
version_no = 0
if not self.is_version_same(old_version, parser):
version = SubtitleVersion(
language=language, version_no=version_no,
datetime_started=datetime.now(), user=self.user,
note=u'Uploaded', is_forked=True, time_change=1, text_change=1)
version.save()
ids = []
for i, item in enumerate(parser):
id = int(random.random()*10e12)
while id in ids:
id = int(random.random()*10e12)
ids.append(id)
caption = Subtitle(**item)
caption.version = version
caption.subtitle_id = str(id)
caption.subtitle_order = i+1
caption.save()
version.save()
version.update_percent_done()
language.update_complete_state()
language.save()
if language.is_original:
video.update_complete_state()
video.release_writelock()
video.save()
return language
def test_update_tvlp_no_dependent(self):
tv = TeamVideo.objects.get(id=2)
tv.update_team_video_language_pairs()
# this video starts with no languages.
self.assertEquals(0, self._tvlp_query_set(tv).count())
sl = SubtitleLanguage(
language='en',
is_original=True,
is_forked=False,
is_complete=False,
video=tv.video)
sl.save()
tv = TeamVideo.objects.get(id=2)
tv.update_team_video_language_pairs()
# the language is not complete, so it's not a good source for translations.
self.assertEquals(0, self._tvlp_query_set(tv).count())
sl = tv.video.subtitle_language('en')
sl.is_complete = True
sl.save()
tv = TeamVideo.objects.get(id=2)
tv.update_team_video_language_pairs()
# complete, so now every language can be translated from this one.
tvlps = self._tvlp_query_set(tv)
self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(tvlps))
for tvlp in tvlps:
self.assertEquals(0, tvlp.percent_complete)
def test_request_language_handler(self):
'''
Test the signal handler which sets the requesters as language
followers when a new (requested) language is created.
'''
subrequest = self._create_requests(self.langs[2:3])[0]
# Test if the user automatically starts following
# a language if there is a pending request
original = self.video.subtitle_language()
newlang = SubtitleLanguage(video=self.video,
language=subrequest.language,
is_original=False,
is_forked=False,
standard_language=original)
newlang.save()
self.assertEqual(self.user, newlang.followers.all()[0])
# Test if subtitle request is marked as done
newlang.is_complete = True
newlang.save()
subrequest = SubtitleRequest.objects.get(pk=subrequest.pk)
self.assertEqual(subrequest.done, True)
def test_update_tvl(self):
tv = TeamVideo.objects.get(id=2)
sl = SubtitleLanguage(
language='en',
is_original=True,
is_forked=False,
is_complete=False,
video=tv.video)
sl.save()
tmodels.TeamVideoLanguage.update(tv)
tvls = tmodels.TeamVideoLanguage.objects.filter(team_video=tv)
self.assertEquals(len(settings.ALL_LANGUAGES), len(tvls))
for tvl in tvls:
self.assertFalse(tvl.is_complete)
self.assertEquals(0, tvl.percent_done)
sl = SubtitleLanguage.objects.get(id=sl.id)
sl.is_complete = True
sl.save()
tv = TeamVideo.objects.get(id=2)
tmodels.TeamVideoLanguage.update(tv)
tvls = tmodels.TeamVideoLanguage.objects.filter(team_video=tv)
self.assertEquals(len(settings.ALL_LANGUAGES), len(tvls))
for tvl in tvls:
if tvl.language != 'en':
self.assertFalse(tvl.is_complete)
else:
self.assertTrue(tvl.is_complete)
self.assertEquals(0, tvl.percent_done)
def save(self):
subtitles = self.cleaned_data["subtitles"]
video = self.cleaned_data["video"]
key = str(uuid4()).replace("-", "")
video._make_writelock(self.user, key)
video.save()
language = video.subtitle_language()
if not language:
language = SubtitleLanguage(video=video, is_original=True, is_complete=True)
language.save()
latest_captions = language.latest_version()
if latest_captions is None:
version_no = 0
else:
version_no = latest_captions.version_no + 1
version = SubtitleVersion(
language=language, version_no=version_no, datetime_started=datetime.now(), user=self.user, note=u"Uploaded"
)
version.save()
text = subtitles.read()
parser = self._get_parser(subtitles.name)(force_unicode(text, chardet.detect(text)["encoding"]))
ids = []
for i, item in enumerate(parser):
id = int(random.random() * 10e12)
while id in ids:
id = int(random.random() * 10e12)
ids.append(id)
caption = Subtitle(**item)
caption.version = version
caption.subtitle_id = str(id)
caption.sub_order = i + 1
caption.save()
version.finished = True
version.save()
video.release_writelock()
video.save()
def test_languages_mark_incomplete(self):
'''
Test if already completed subtitles are marked as incomplete on a
subtitle request
'''
langs = self.langs[3:]
original = self.video.subtitle_language()
lang = SubtitleLanguage(video=self.video,
language=langs[0],
is_original=False,
is_forked=False,
is_complete=True,
standard_language=original)
lang.save()
self._create_requests(langs)[0]
lang = SubtitleLanguage.objects.get(pk=lang.pk)
self.assertEqual(False, lang.is_complete)
def test_languages_mark_incomplete(self):
'''
Test if already completed subtitles are marked as incomplete on a
subtitle request
'''
langs = self.langs[3:]
original = self.video.subtitle_language()
lang = SubtitleLanguage(
video=self.video,
language=langs[0],
is_original=False,
is_forked=False,
is_complete=True,
standard_language=original)
lang.save()
self._create_requests(langs)[0]
lang = SubtitleLanguage.objects.get(pk=lang.pk)
self.assertEqual(False, lang.is_complete)
def test_request_language_handler(self):
'''
Test the signal handler which sets the requesters as language
followers when a new (requested) language is created.
'''
subrequest = self._create_requests(self.langs[2:3])[0]
# Test if the user automatically starts following
# a language if there is a pending request
original = self.video.subtitle_language()
newlang = SubtitleLanguage(
video=self.video,
language=subrequest.language,
is_original=False,
is_forked=False,
standard_language=original)
newlang.save()
self.assertEqual(self.user, newlang.followers.all()[0])
# Test if subtitle request is marked as done
newlang.is_complete = True
newlang.save()
subrequest = SubtitleRequest.objects.get(pk=subrequest.pk)
self.assertEqual(subrequest.done, True)
def _save_original_language(self, video, video_language):
original_language = video.subtitle_language()
if original_language:
if original_language.language:
try:
language_exists = video.subtitlelanguage_set.exclude(pk=original_language.pk) \
.get(language=video_language)
original_language.is_original = False
original_language.save()
language_exists.is_original = True
language_exists.save()
except ObjectDoesNotExist:
original_language.language = video_language
original_language.save()
else:
try:
language_exists = video.subtitlelanguage_set.exclude(pk=original_language.pk) \
.get(language=video_language)
latest_version = original_language.latest_version()
if latest_version:
last_no = latest_version.version_no
else:
last_no = 0
for version in language_exists.subtitleversion_set.all():
version.language = original_language
last_no += 1
version.version_no = last_no
version.save()
language_exists.delete()
except ObjectDoesNotExist:
pass
original_language.language = video_language
original_language.save()
else:
#original_language always exists, but...
try:
language_exists = video.subtitlelanguage_set.get(
language=video_language)
language_exists.is_original = True
language_exists.save()
except ObjectDoesNotExist:
original_language = SubtitleLanguage()
original_language.language = video_language
original_language.is_original = True
original_language.video = video
original_language.save()
def test_moderated_subs_reject_one(self):
url = reverse("teams:detail", kwargs={"slug": self.team.slug})
response = self.client.get(url)
add_moderation(self.video, self.team, self.user)
self._login(is_moderator=True)
self.client.get("\en\faq")
lang = self.video.subtitle_language()
[ self._make_subs(lang, 5) for x in xrange(0, 3)]
self.assertEquals(self.team.get_pending_moderation().count(), 3)
lang = SubtitleLanguage(video=self.video, language="pt", title="a")
lang.save()
[ self._make_subs(lang, 5) for x in xrange(0, 3)]
self.assertEquals(self.team.get_pending_moderation().count(), 6)
versions = self.team.get_pending_moderation()
version = versions[0]
url = reverse("moderation:revision-approve", kwargs={
"team_id":self.team.id,
"version_id":version.pk})
response = self.client.post(url, {},follow=True)
self.assertEquals(response.status_code, 200)
self.assertEquals(self.team.get_pending_moderation().count(), 5)
version = SubtitleVersion.objects.get(pk=version.pk)
self.assertEquals(version.moderation_status,APPROVED)
def _create_trans(video, latest_version=None, lang_code=None, forked=False):
translation = SubtitleLanguage()
translation.video = video
translation.language = lang_code
translation.is_original = False
translation.is_forked = forked
if not forked:
translation.standard_language = video.subtitle_language()
translation.save()
v = SubtitleVersion()
v.language = translation
if latest_version:
v.version_no = latest_version.version_no + 1
else:
v.version_no = 1
v.datetime_started = datetime.now()
v.save()
if latest_version is not None:
for s in latest_version.subtitle_set.all():
s.duplicate_for(v).save()
return translation
def test_update_sl(self):
tv = TeamVideo.objects.get(id=2)
sublang = SubtitleLanguage(language='en',
is_original=True,
is_forked=False,
is_complete=False,
video=tv.video)
sublang.save()
sls = tv.searchable_languages()
self.assertEquals(len(settings.ALL_LANGUAGES), len(sls))
sublang = SubtitleLanguage.objects.get(id=sublang.id)
sublang.is_complete = True
sublang.save()
tv = TeamVideo.objects.get(id=2)
sls = tv.searchable_languages()
self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(sls))
def _save_original_language(self, video, video_language):
original_language = video.subtitle_language()
if original_language:
if original_language.language:
try:
language_exists = video.subtitlelanguage_set.exclude(pk=original_language.pk) \
.get(language=video_language)
original_language.is_original = False
original_language.save()
language_exists.is_original = True
language_exists.save()
except ObjectDoesNotExist:
original_language.language = video_language
original_language.save()
else:
try:
language_exists = video.subtitlelanguage_set.exclude(pk=original_language.pk) \
.get(language=video_language)
latest_version = original_language.latest_version()
if latest_version:
last_no = latest_version.version_no
else:
last_no = 0
for version in language_exists.subtitleversion_set.all():
version.language = original_language
last_no += 1
version.version_no = last_no
version.save()
language_exists.delete()
except ObjectDoesNotExist:
pass
original_language.language = video_language
original_language.save()
else:
#original_language always exists, but...
try:
language_exists = video.subtitlelanguage_set.get(language=video_language)
language_exists.is_original = True
language_exists.save()
except ObjectDoesNotExist:
original_language = SubtitleLanguage()
original_language.language = video_language
original_language.is_original = True
original_language.video = video
original_language.save()
def test_moderated_subs_pending_count(self):
add_moderation(self.video, self.team, self.user)
lang = self.video.subtitle_language()
[ self._make_subs(lang, 5) for x in xrange(0, 3)]
self.assertEquals(self.team.get_pending_moderation().count(), 3)
lang = SubtitleLanguage(video=self.video, language="pt", title="a")
lang.save()
[ self._make_subs(lang, 5) for x in xrange(0, 3)]
self.assertEquals(self.team.get_pending_moderation().count(), 6)
# make sure pending count is for only one team
tv = TeamVideo.objects.exclude(team=self.team).filter(video__moderated_by__isnull=True)[0]
o, c = TeamMember.objects.get_or_create(user=self.auth_user, team=tv.team)
o.role=TeamMember.ROLE_MANAGER
o.save()
new_team = tv.team
add_moderation(tv.video, tv.team, self.auth_user)
lang = SubtitleLanguage(video=tv.video, language="pt", title="a")
lang.save()
[ self._make_subs(lang, 5) for x in xrange(0, 3)]
self.assertEquals(self.team.get_pending_moderation().count(), 6)
self.assertEquals(tv.team.get_pending_moderation().count(), 3)
def legacy_history(request, video, lang=None):
"""
In the old days we allowed only one translation per video.
Therefore video urls looked like /vfjdh2/en/
Now that this constraint is removed we need to redirect old urls
to the new view, that needs
"""
try:
language = video.subtitle_language(lang)
if language is None:
raise SubtitleLanguage.DoesNotExist("No such language")
except SubtitleLanguage.DoesNotExist:
raise Http404()
return HttpResponseRedirect(
reverse("videos:translation_history",
kwargs={
'video_id': video.video_id,
'lang_id': language.pk,
'lang': language.language,
}))
def setUp(self):
self.video = Video.objects.all()[:1].get()
self.original_language = self.video.subtitle_language()
latest_version = self.original_language.latest_version()
translation = SubtitleLanguage()
translation.video = self.video
translation.language = 'uk'
translation.is_original = False
translation.is_forked = False
translation.save()
self.translation = translation
v = SubtitleVersion()
v.language = translation
v.datetime_started = datetime.now()
v.save()
self.translation_version = v
for s in latest_version.subtitle_set.all():
s.duplicate_for(v).save()
def _import_video(self, video_url, videoid, title, description, thumbnail,
videosrt):
videoid_match = VIDEOID_RE.search(videoid)
videoid = videoid_match.group(1)
video_type = YoutubeVideoType(
'http://www.youtube.com/watch?v={0}'.format(videoid))
try:
video_url_obj = VideoUrl.objects.get(
url=video_type.convert_to_video_url())
video = video_url_obj.video
except ObjectDoesNotExist:
video_url_obj = None
video = Video()
video.youtube_videoid = videoid
video.title = title
video.description = description
if video_type.entry.media.duration:
video.duration = int(video_type.entry.media.duration.seconds)
video.thumbnail = thumbnail
video.save()
Action.create_video_handler(video)
if videosrt:
self._import_srt(video, videosrt)
else:
SubtitleLanguage(video=video,
language='en',
is_original=True,
is_forked=True).save()
if not video_url_obj:
video_url_obj = VideoUrl(videoid=videoid,
url=video_type.convert_to_video_url(),
type=video_type.abbreviation,
original=True,
primary=True,
video=video)
video_url_obj.save()
self._save_alternate_url(video, video_url)
def forwards(self, orm):
if db.dry_run:
return
try:
from videos.models import Video, SubtitleLanguage
except ImportError:
return
try:
Video.widget_views_counter.r.ping()
except ConnectionError:
if settings.DEBUG:
return
raise Exception('Redis server is unavailable. You can ignore this migration with: python manage.py migrate videos 0068 --fake, but all statistic data will be lost.')
for obj in orm.Video.objects.all():
Video.subtitles_fetched_counter(obj.video_id).val = obj.subtitles_fetched_count
Video.widget_views_counter(obj.video_id).val = obj.widget_views_count
for obj in orm.SubtitleLanguage.objects.all():
SubtitleLanguage.subtitles_fetched_counter(obj.pk).val = obj.subtitles_fetched_count
def test_update_sl(self):
tv = TeamVideo.objects.get(id=2)
sublang = SubtitleLanguage(
language='en',
is_original=True,
is_forked=False,
is_complete=False,
video=tv.video)
sublang.save()
sls = tv.searchable_languages()
self.assertEquals(len(settings.ALL_LANGUAGES), len(sls))
sublang = SubtitleLanguage.objects.get(id=sublang.id)
sublang.is_complete = True
sublang.save()
tv = TeamVideo.objects.get(id=2)
sls = tv.searchable_languages()
self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(sls))
def test_update_lp_no_dependent(self):
tv = TeamVideo.objects.get(id=2)
# this video starts with no languages.
self.assertEquals(0, len(tv.searchable_language_pairs()))
sl = SubtitleLanguage(language='en',
is_original=True,
is_forked=False,
is_complete=False,
video=tv.video)
sl.save()
tv = TeamVideo.objects.get(id=2)
self.assertEquals(0, len(tv.searchable_language_pairs()))
sl = tv.video.subtitle_language('en')
sl.is_complete = True
sl.save()
tv = TeamVideo.objects.get(id=2)
lps = tv.searchable_language_pairs()
self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(lps))
# we expect each string to end in "_0" to indicate zero completion.
for lp in lps:
self.assertEquals("0", LANGUAGEPAIR_RE.match(lp).group(3))
def setUp(self):
self.video = Video.objects.all()[:1].get()
self.original_language = self.video.subtitle_language()
latest_version = self.original_language.latest_version()
translation = SubtitleLanguage()
translation.video = self.video
translation.language = 'uk'
translation.is_original = False
translation.is_forked = False
translation.save()
self.translation = translation
v = SubtitleVersion()
v.language = translation
v.datetime_started = datetime.now()
v.save()
self.translation_version = v
for s in latest_version.subtitle_set.all():
s.duplicate_for(v).save()
def test_update_lp_no_dependent(self):
tv = TeamVideo.objects.get(id=2)
# this video starts with no languages.
self.assertEquals(0, len(tv.searchable_language_pairs()))
sl = SubtitleLanguage(
language='en',
is_original=True,
is_forked=False,
is_complete=False,
video=tv.video)
sl.save()
tv = TeamVideo.objects.get(id=2)
self.assertEquals(0, len(tv.searchable_language_pairs()))
sl = tv.video.subtitle_language('en')
sl.is_complete = True
sl.save()
tv = TeamVideo.objects.get(id=2)
lps = tv.searchable_language_pairs()
self.assertEquals(len(settings.ALL_LANGUAGES) - 1, len(lps))
# we expect each string to end in "_0" to indicate zero completion.
for lp in lps:
self.assertEquals("0", LANGUAGEPAIR_RE.match(lp).group(3))
def save_subtitles(self, parser):
video = self.cleaned_data['video']
key = str(uuid4()).replace('-', '')
video._make_writelock(self.user, key)
video.save()
if not video.has_original_language():
self._save_original_language(video,
self.cleaned_data['video_language'])
language = video.subtitle_language(self.cleaned_data['language'])
if not language:
language = SubtitleLanguage(video=video,
is_original=False,
is_forked=True)
language.language = self.cleaned_data['language']
language.save()
try:
old_version = language.subtitleversion_set.all()[:1].get()
version_no = old_version.version_no + 1
except ObjectDoesNotExist:
old_version = None
version_no = 0
if not self.is_version_same(old_version, parser):
version = SubtitleVersion(language=language,
version_no=version_no,
datetime_started=datetime.now(),
user=self.user,
note=u'Uploaded',
is_forked=True,
time_change=1,
text_change=1)
version.save()
ids = []
for i, item in enumerate(parser):
id = int(random.random() * 10e12)
while id in ids:
id = int(random.random() * 10e12)
ids.append(id)
caption = Subtitle(**item)
caption.version = version
caption.subtitle_id = str(id)
caption.subtitle_order = i + 1
caption.save()
version.save()
version.update_percent_done()
language.update_complete_state()
language.save()
if language.is_original:
video.update_complete_state()
video.release_writelock()
video.save()
return language
def test_moderated_subs_approve_one(self):
video = Video.objects.get(pk=4)
tv = TeamVideo(video=video, team=self.team,added_by=self.user)
tv.save()
url = reverse("teams:detail", kwargs={"slug": self.team.slug})
response = self.client.get(url)
add_moderation(video, self.team, self.user)
self._login(is_moderator=True)
self.client.get("\en\faq")
lang = video.subtitle_language()
[ self._make_subs(lang, 5) for x in xrange(0, 3)]
self.assertEquals(self.team.get_pending_moderation().count(), 3)
lang = SubtitleLanguage(video=video, language="pt", title="a", standard_language=lang)
lang.save()
[ self._make_subs(lang, 5) for x in xrange(0, 3)]
# we can see the unmoderated sub on the website,
response = self.client.get(reverse("videos:translation_history", kwargs={
'video_id':video.video_id,
'lang':lang.language,
'lang_id':lang.id
}))
versions = SubtitleVersion.objects.filter(language=lang)
latest_version = lang.latest_version(public_only=False) #lang.subtitleversion_set.all()[0]
subs = response.context['last_version'].subtitle_set.all()
self.assertEquals(latest_version, response.context['last_version'])
self.assertTrue(subs[0].subtitle_text.startswith("vno:2 Sub 0 "))
self.assertTrue(len(subs))
self.assertEquals(self.team.get_pending_moderation().count(), 6)
versions = self.team.get_pending_moderation()
version = versions[0]
# after moderation it should not be visible on the widget
subs = self._call_rpc_method("fetch_subtitles", lang.video.video_id, lang.pk)
self.assertFalse(subs)
url = reverse("moderation:revision-approve", kwargs={
"team_id":self.team.id,
"version_id":version.pk} )
response = self.client.post(url, {},follow=True, HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(response.status_code, 200)
data = json.loads(response.content)
self.assertTrue(data["success"])
self.team = refresh_obj(self.team)
self.assertEquals(self.team.get_pending_moderation().count(), 5)
version = SubtitleVersion.objects.get(pk=version.pk)
self.assertEquals(version.moderation_status,APPROVED)
response = self.client.get(reverse("videos:translation_history", kwargs={
'video_id':video.video_id,
'lang':lang.language,
'lang_id':lang.id
}))
sub_1 = response.context['last_version'].subtitle_set.all()
self.assertTrue(len(sub_1))
widget_res = self._call_rpc_method("fetch_subtitles", version.video.video_id, version.language.pk)
self.assertTrue(widget_res)
self.assertTrue(widget_res["subtitles"])
sub = widget_res["subtitles"][0]
self.assertTrue(sub["text"].startswith("vno:2 Sub 0 "))
def test_subtitle_language_save(self):
self.assertEqual(self.video.complete_date, None)
self.assertEqual(self.video.subtitlelanguage_set.count(), 1)
self.language.is_complete = True
self.language.save()
self.video = Video.objects.get(pk=self.video.pk)
self.assertNotEqual(self.video.complete_date, None)
self.language.is_complete = False
self.language.save()
self.video = Video.objects.get(pk=self.video.pk)
self.assertEqual(self.video.complete_date, None)
#add one more SubtitleLanguage
l = SubtitleLanguage(video=self.video)
l.is_original = False
l.is_complete = True
l.save()
self.video = Video.objects.get(pk=self.video.pk)
self.assertNotEqual(self.video.complete_date, None)
self.language.is_complete = True
self.language.save()
self.video = Video.objects.get(pk=self.video.pk)
self.assertNotEqual(self.video.complete_date, None)
l.is_complete = False
l.save()
self.video = Video.objects.get(pk=self.video.pk)
self.assertNotEqual(self.video.complete_date, None)
self.language.is_complete = False
self.language.save()
self.video = Video.objects.get(pk=self.video.pk)
self.assertEqual(self.video.complete_date, None)
self.language.is_complete = True
self.language.save()
self.video = Video.objects.get(pk=self.video.pk)
self.assertNotEqual(self.video.complete_date, None)
l.is_complete = True
l.save()
self.video = Video.objects.get(pk=self.video.pk)
self.assertNotEqual(self.video.complete_date, None)
self.language.delete()
self.video = Video.objects.get(pk=self.video.pk)
self.assertNotEqual(self.video.complete_date, None)
l.delete()
self.video = Video.objects.get(pk=self.video.pk)
self.assertEqual(self.video.complete_date, None)
