def search_users(self):
def _add_tracking(item, extra=None):
item["tracking_code"] = "user-search %d" % item["position"]
search_term = request.args.get("q", "").lower()
offset, limit = self.get_page()
if use_elasticsearch():
us = UserSearch()
us.set_paging(offset, limit)
if app.config.get("DOLLY"):
us.search_terms(search_term)
else:
us.add_text("username", search_term)
us.add_text("display_name", search_term)
items = us.users(add_tracking=_add_tracking)
return dict(users=dict(items=items, total=us.total))
users = User.query.filter(func.lower(User.username).like(search_term))
count = users.count()
items = []
for user in users.limit(limit).offset(offset):
items.append(
dict(
id=user.id,
username=user.username,
display_name=user.display_name,
avatar_thumbnail_url=user.avatar.url,
resource_url=user.resource_url,
)
)
return dict(users=dict(items=items, total=count))
def channel_list(self):
def add_tracking(channel, extra=None):
channel['tracking_code'] = ' '.join(filter(None, (
'channel-browse',
str(channel['position']),
category and 'cat-%s' % category,
extra)))
category = request.args.get('category')
get_channels = get_es_channels if use_elasticsearch() else get_db_channels
items, total = get_channels(self.get_locale(), self.get_page(),
category=category,
add_tracking=add_tracking)
return dict(channels=dict(items=items, total=total))
def complete_all_terms(self):
query = request.args.get("q", "")
if not query:
abort(400)
if app.config.get("DOLLY") and use_elasticsearch():
terms = SuggestionSearch().completion_suggestions(query)
result = json.dumps((query, [(t, 0) for t in terms], {}))
return Response("window.google.ac.h(%s)" % result, mimetype="text/javascript")
result = youtube.complete(query)
if len(query) >= 4:
try:
result = result.decode("utf8")
except UnicodeDecodeError:
result = result.decode("latin1")
terms = json.loads(result[result.index("(") + 1 : result.rindex(")")])
return self.complete_channel_terms(terms[1])
return Response(result, mimetype="text/javascript")
def search_channels(self):
if use_elasticsearch():
ch = ChannelSearch(self.get_locale())
offset, limit = self.get_page()
ch.set_paging(offset, limit)
ch.search_terms(request.args.get("q", ""))
ch.add_filter(filters.verified_channel_boost())
ch.add_filter(filters.negatively_boost_favourites())
if request.args.get("order") == "latest":
ch.date_sort("desc")
items, total = ch.channels(with_owners=True), ch.total
else:
# DB fallback
date_order = True if request.args.get("order") == "latest" else False
items, total = get_db_channels(
self.get_locale(), self.get_page(), query=request.args.get("q", ""), date_order=date_order
)
return dict(channels=dict(items=items, total=total))
def video_list(self):
if not use_elasticsearch():
data, total = get_local_videos(self.get_locale(), self.get_page(), star_order=True, **request.args)
return dict(videos=dict(items=data, total=total))
date_order = request.args.get('date_order')
if app.config.get('DOLLY'):
date_order = 'desc'
category = request.args.get('category')
if category:
try:
int(category)
except ValueError:
abort(400)
vs = VideoSearch(self.get_locale())
offset, limit = self.get_page()
vs.set_paging(offset, limit)
vs.filter_category(category)
if app.config.get('DOLLY'):
# Filter by tagged/added date
vs.add_filter(filters.date_tagged_sort())
vs.add_sort('_score', order='desc')
# exclude favs
f = pyes.TermFilter(field='is_favourite', value=False)
vs._exclusion_filters.append(f)
else:
vs.star_order_sort(request.args.get('star_order'))
vs.date_sort(date_order)
location = self.get_location()
if location:
vs.check_country_allowed(location)
videos = vs.videos(with_channels=True)
total = vs.total
return dict(videos={'items': videos}, total=total)
def after_model_change(self, form, model, is_created):
if use_elasticsearch():
instance_ids = [x[0] for x in models.VideoInstance.query.filter_by(video=model.id).values('id')]
# Force video instance updates when a video is changed in the admin
args = dict(extant=instance_ids) if model.visible else dict(deleted=instance_ids)
es_api.es_update_channel_videos(**args)
def after_model_change(self, form, model, is_created):
if use_elasticsearch():
es_video = es_api.ESVideo.inserter()
es_video.insert(model.id, model)
def test_visible_flag(self):
with self.app.test_client() as client:
self.app.test_request_context().push()
user = self.register_user()
user_token = self.token
if use_elasticsearch():
new_title = 'a new channel title'
new_description = 'this is a new description!'
r = self.post(
self.urls['channels'],
dict(
title=new_title,
description=new_description,
category=3,
cover=RockpackCoverArtData.comic_cover.cover,
public=True
),
token=self.token
)
owned_resource = r['resource_url']
params = dict(q='music', size=1)
if self.app.config.get('DOLLY'):
# XXX: Search isnt' going to work with ES off
# since we don't search over yt so attach
# a video manually
client.post(
owned_resource + 'videos/',
data=json.dumps([VideoInstanceData.video_instance1.id]),
content_type='application/json',
headers=[get_auth_header(user['id'])]
)
else:
videos = self.get(self.urls['video_search'], params=params)['videos']['items']
self.put(owned_resource + 'videos/', [videos[0]['id']], token=self.token)
self.wait_for_es()
resource = '{}/ws/{}/channels/{}/'.format(self.default_base_url, user['id'], r['id'])
new_ch = models.Channel.query.filter_by(owner=user['id']).filter(
models.Channel.title == new_title).one()
self.register_user()
user2_token = self.token
# Check user2 can see channel
channel = self.get(resource, token=user2_token)
self.assertEquals(channel['id'], r['id'])
# Hide channel from user2
ch = models.Channel.query.get(new_ch.id)
ch.visible = False
ch.save()
self.assertEquals(models.Channel.query.get(new_ch.id).visible, False)
self.wait_for_es()
# Owner should still be able to see channel
r = self.get(owned_resource, token=user_token)
self.assertEquals(channel['id'], r['id'])
# Channel should be hidden from user2
with self.assertRaises(Exception): # Why doesn't this catch AssertionError???
self.get(resource, token=user2_token)
import time
import unittest
import datetime
import pyes
import pytest
from mock import patch
from rockpack.mainsite.core.es import migration, use_elasticsearch
PATCH_ALIAS = PATCH_INDEX_PREFIX = 'test_index'
@pytest.mark.skipif(not use_elasticsearch(), reason="requires elasticsearch")
class MigrationTestCase(unittest.TestCase):
def setUp(self):
self.new_index = None
self.aliasing = migration.Aliasing('channel')
# override settings
self.aliasing.alias = PATCH_ALIAS
self.aliasing.mapping = {
"properties": {
"title": {
"type": "string",
"index": "not_analyzed"
}
}
}
self.aliasing.index_prefix = PATCH_INDEX_PREFIX
