def test_filtering(self):
self.assertTrue(Video.objects.count())
for video in Video.objects.all():
video_changed_tasks.delay(video.pk)
reset_solr()
rpc = SearchApiClass()
rdata = RpcMultiValueDict(dict(q=u' ', video_lang='en'))
result = rpc.search(rdata, self.user, testing=True)['sqs']
self.assertTrue(len(result))
for video in VideoIndex.public():
if video.video_language == 'en':
self.assertTrue(
video.object in [item.object for item in result])
rdata = RpcMultiValueDict(dict(q=u' ', langs='en'))
result = rpc.search(rdata, self.user, testing=True)['sqs']
self.assertTrue(len(result))
for video in VideoIndex.public():
if video.languages and 'en' in video.languages:
self.assertTrue(
video.object in [item.object for item in result])
def index(request):
context = {
'popular_videos': VideoIndex.get_popular_videos("-today_views")[:VideoIndex.IN_ROW],
'featured_videos': VideoIndex.get_featured_videos()[:VideoIndex.IN_ROW],
}
return render_to_response('index.html', context,
context_instance=RequestContext(request))
def index(request):
context = widget.add_onsite_js_files({})
context['all_videos'] = Video.objects.count()
context['popular_videos'] = VideoIndex.get_popular_videos("-today_views")[:VideoIndex.IN_ROW]
context['featured_videos'] = VideoIndex.get_featured_videos()[:VideoIndex.IN_ROW]
return render_to_response('index.html', context,
context_instance=RequestContext(request))
def queryset_from_query(self):
q = self.data.get('q', '').strip()
if q:
qs = VideoIndex.public()
return (qs
.auto_query(q)
.filter_or(title=qs.query.clean(q)))
else:
return VideoIndex.public()
def watch_page(request):
context = {
'featured_videos': VideoIndex.get_featured_videos()[:VideoIndex.IN_ROW],
'popular_videos': VideoIndex.get_popular_videos()[:VideoIndex.IN_ROW],
'latest_videos': VideoIndex.get_latest_videos()[:VideoIndex.IN_ROW*3],
'popular_display_views': 'week'
}
return render_to_response('videos/watch.html', context,
context_instance=RequestContext(request))
def index(request):
context = widget.add_onsite_js_files({})
context['all_videos'] = Video.objects.count()
context['popular_videos'] = VideoIndex.get_popular_videos(
"-today_views")[:VideoIndex.IN_ROW]
context['featured_videos'] = VideoIndex.get_featured_videos()[:VideoIndex.
IN_ROW]
return render_to_response('index.html',
context,
context_instance=RequestContext(request))
def watch_page(request):
context = {
'featured_videos':
VideoIndex.get_featured_videos()[:VideoIndex.IN_ROW],
'popular_videos': VideoIndex.get_popular_videos()[:VideoIndex.IN_ROW],
'latest_videos':
VideoIndex.get_latest_videos()[:VideoIndex.IN_ROW * 3],
'popular_display_views': 'week'
}
return render_to_response('videos/watch.html',
context,
context_instance=RequestContext(request))
def index(request):
site = current_site(request)
if request.GET:
return HttpResponseRedirect(
site['BASE_URL'] + '%s#/?%s' %
(reverse('search:index'), urlencode(request.GET)))
return {'form': SearchForm(sqs=VideoIndex.public())}
def volunteer_page(request):
# Get the user comfort languages list
user_langs = get_user_languages_from_request(request)
relevant = VideoIndex.public().filter(video_language_exact__in=user_langs) \
.filter_or(languages_exact__in=user_langs) \
.order_by('-requests_count')
featured_videos = relevant.filter(
featured__gt=datetime.datetime(datetime.MINYEAR, 1, 1)) \
.order_by('-featured')[:5]
popular_videos = relevant.order_by('-week_views')[:5]
latest_videos = relevant.order_by('-edited')[:15]
requested_videos = relevant.filter(requests_exact__in=user_langs)[:5]
context = {
'featured_videos': featured_videos,
'popular_videos': popular_videos,
'latest_videos': latest_videos,
'requested_videos': requested_videos,
'user_langs': user_langs,
}
return render_to_response('videos/volunteer.html',
context,
context_instance=RequestContext(request))
def load_popular_videos(self, sort, request, user):
sort_types = {
'today': 'today_views',
'week': 'week_views',
'month': 'month_views',
'year': 'year_views',
'total': 'total_views'
}
if sort in sort_types:
display_views = sort
sort_field = sort_types[sort]
else:
display_views = 'week'
sort_field = 'week_views'
popular_videos = VideoIndex.get_popular_videos('-%s' % sort_field)[:VideoIndex.IN_ROW]
context = {
'display_views': display_views,
'video_list': popular_videos
}
content = render_to_string('videos/_watch_page.html', context, RequestContext(request))
return {
'content': content
}
def load_popular_videos(self, sort, request, user):
sort_types = {
'today': 'today_views',
'week': 'week_views',
'month': 'month_views',
'year': 'year_views',
'total': 'total_views'
}
if sort in sort_types:
display_views = sort
sort_field = sort_types[sort]
else:
display_views = 'week'
sort_field = 'week_views'
popular_videos = VideoIndex.get_popular_videos(
'-%s' % sort_field)[:VideoIndex.IN_ROW]
context = {
'display_views': display_views,
'video_list': popular_videos
}
content = render_to_string('videos/_watch_page.html', context,
RequestContext(request))
return {'content': content}
def search(self, rdata, user, testing=False):
sqs = VideoIndex.public()
rdata['q'] = rdata['q'] or u' '
q = rdata.get('q')
if q:
sqs = SearchForm.apply_query(q, sqs)
form = SearchForm(rdata, sqs=sqs)
else:
form = SearchForm(rdata)
if form.is_valid():
qs = form.search_qs(sqs)
else:
qs = VideoIndex.public().none()
#result = [item.object for item in qs]
#qs1 = Video.objects.filter(title__contains=rdata['q'])
#for o in qs1:
# if not o in result:
# print o.title
display_views = form.get_display_views()
output = render_page(rdata.get('page', 1),
qs,
20,
display_views=display_views)
output['sidebar'] = render_to_string('search/_sidebar.html',
dict(form=form, rdata=rdata))
# Assume we're currently indexing if the number of public
# indexed vids differs from the count of video objects by
# more than 1000
is_indexing = cache.get('is_indexing')
if is_indexing is None:
is_indexing = Video.objects.all().count() - VideoIndex.public(
).count() > 1000
cache.set('is_indexing', is_indexing, 300)
output['is_indexing'] = is_indexing
if testing:
output['sqs'] = qs
return output
def watch_page(request):
# Assume we're currently indexing if the number of public
# indexed vids differs from the count of video objects by
# more than 1000
is_indexing = cache.get('is_indexing')
if is_indexing is None:
is_indexing = Video.objects.all().count() - VideoIndex.public().count() > 1000
cache.set('is_indexing', is_indexing, 300)
context = {
'featured_videos': VideoIndex.get_featured_videos()[:VideoIndex.IN_ROW],
'latest_videos': VideoIndex.get_latest_videos()[:VideoIndex.IN_ROW*3],
'is_indexing': is_indexing
}
return render_to_response('videos/watch.html', context,
context_instance=RequestContext(request))
def test_search(self):
reset_solr()
sqs = VideoIndex.public()
qs = Video.objects.exclude(title='')
self.assertTrue(qs.count())
for video in qs:
result = SearchForm.apply_query(video.title, sqs)
self.assertTrue(video in [item.object for item in result])
def test_metadata_searchable(self):
version = pipeline.add_subtitles(self.video, 'en', None,
metadata={
'speaker-name': 'Santa',
'location': 'North Pole',
})
update_search_index.apply(args=(Video, self.video.pk))
test_utils.update_search_index.run_original()
qs = VideoIndex.public().filter(text='santa')
self.assertEquals([v.video_id for v in qs], [self.video.video_id])
def test_video_lang_filter(self):
# set up fake faceting info so that we can select english as the
# filter
test_utils.get_language_facet_counts.return_value = (
[('en', 10)], []
)
sqs = self.get_search_qs('foo', video_lang='en')
assert_search_querysets_equal(sqs,
VideoIndex.public()
.auto_query('foo')
.filter_or(title='foo')
.filter(video_language_exact='en'))
def load_popular_page(self, page, sort, request, user):
sort_types = {
'today': 'today_views',
'week' : 'week_views',
'month': 'month_views',
'year' : 'year_views',
'total': 'total_views'
}
sort_field = sort_types.get(sort, 'week_views')
sqs = VideoIndex.get_popular_videos('-%s' % sort_field)
return render_page(page, sqs, request=request, display_views=sort)
def load_popular_page(self, page, sort, request, user):
sort_types = {
'today': 'today_views',
'week': 'week_views',
'month': 'month_views',
'year': 'year_views',
'total': 'total_views'
}
sort_field = sort_types.get(sort, 'week_views')
sqs = VideoIndex.get_popular_videos('-%s' % sort_field)
return render_page(page, sqs, request=request, display_views=sort)
def test_search1(self):
for title in self.titles:
video = Video.objects.all()[0]
sqs = VideoIndex.public()
video.title = title
video.save()
reset_solr()
result = SearchForm.apply_query(video.title, sqs)
self.assertTrue(video in [item.object for item in result],
u"Failed to find video by title: %s" % title)
result = SearchForm.apply_query(u'BBC', sqs)
self.assertTrue(
video in [item.object for item in result],
u"Failed to find video by 'BBC' with title: %s" % title)
def save(self, *args, **kwargs):
obj = super(EditTeamVideoForm, self).save(*args, **kwargs)
video = obj.video
author = self.cleaned_data['author'].strip()
creation_date = VideoMetadata.date_to_string(
self.cleaned_data['creation_date'])
self._save_metadata(video, 'Author', author)
self._save_metadata(video, 'Creation Date', creation_date)
# store the uploaded thumb on the video itself
# TODO: simply remove the teamvideo.thumbnail image
if obj.thumbnail:
content = ContentFile(obj.thumbnail.read())
name = obj.thumbnail.url.split('/')[-1]
video.s3_thumbnail.save(name, content)
VideoIndex(Video).update_object(video)
def _search(self, rdata, user):
form = SearchForm(rdata)
output = render_page(rdata.get('page', 1), form.queryset(), 20)
output['sidebar'] = render_to_string('search/_sidebar.html', {
'form': form,
'rdata': rdata,
})
# Assume we're currently indexing if the number of public
# indexed vids differs from the count of video objects by
# more than 1000
is_indexing = cache.get('is_indexing')
if is_indexing is None:
is_indexing = Video.objects.all().count() - VideoIndex.public(
).count() > 1000
cache.set('is_indexing', is_indexing, 300)
output['is_indexing'] = is_indexing
return output
def test_facet_choices(self):
video_lang_facet_info = [
('en', 10),
('fr', 20),
]
language_facet_info = [
('en', 10),
('es', 7),
]
test_utils.get_language_facet_counts.return_value = (
video_lang_facet_info, language_facet_info
)
form = SearchForm(RpcMultiValueDict(dict(q='foo')))
# we should always list the blank choice first, then the languages
# with facet info, in descending order
self.check_choices(form.fields['video_lang'], ['', 'fr', 'en'])
self.check_choices(form.fields['langs'], ['', 'en', 'es'])
# check that get_language_facet_counts() was presented with the
# correct query
self.check_get_language_facet_counts_query(VideoIndex.public()
.auto_query('foo')
.filter_or(title='foo'))
def test_facet_choices_empty_query(self):
form = SearchForm(RpcMultiValueDict(dict(q='')))
# If we don't have a query, we should use the all videos
self.check_get_language_facet_counts_query(VideoIndex.public())
def test_language_only(self):
assert_search_querysets_equal(self.get_search_qs('', video_lang='en'),
VideoIndex.public()
.filter(video_language_exact='en'))
def test_simple_query(self):
assert_search_querysets_equal(self.get_search_qs('foo'),
VideoIndex.public()
.auto_query('foo')
.filter_or(title='foo'))
def load_latest_page(self, page, request, user):
sqs = VideoIndex.public().order_by('-created')
return render_page(page, sqs, request=request)
def load_featured_page(self, page, request, user):
sqs = VideoIndex.get_featured_videos()
return render_page(page, sqs, request=request)
def _in_solr(self, video):
return video.video_id in [x.video_id for x in VideoIndex.public()]
def test_empty_query(self):
assert_search_querysets_equal(self.get_search_qs(''),
VideoIndex.public().none())
def empty_queryset(self):
return VideoIndex.public().none()
def load_featured_page(self, page, request, user):
sqs = VideoIndex.get_featured_videos()
return render_page(page, sqs, request=request)
def test_clean_input(self):
assert_search_querysets_equal(self.get_search_qs('foo?'),
VideoIndex.public()
.auto_query('foo?')
.filter_or(title='foo\\?'))
