def is_fan(self, user_id, show_id):
with new_session() as session:
q = session.query(models.Show_fan.show_id).filter(
models.Show_fan.user_id == user_id,
models.Show_fan.show_id == show_id,
).first()
return True if q else False
def shows(self, user_id):
with new_session() as session:
now_ = datetime.utcnow()
episodes = session.query(
models.Episode_watched.show_id.label('show_id'),
func.max(models.Episode_watched.episode_number).label('episode_number'),
).filter(
models.Episode_watched.user_id == user_id,
models.Show_fan.user_id == models.Episode_watched.user_id,
models.Show_fan.show_id == models.Episode_watched.show_id,
models.Episode_watched.times > 0,
).group_by(models.Episode_watched.show_id).subquery()
p = session.query(models.Show, models.Episode).filter(
models.Show.id == episodes.c.show_id,
models.Episode.show_id == models.Show.id,
models.Episode.number == episodes.c.episode_number+1,
models.Episode.air_date <= now_.date(),
).order_by(
desc(models.Episode.air_date),
models.Episode.show_id,
).paginate(page=self.page, per_page=self.per_page)
p.records = [{
'show': r.Show.serialize(),
'episode': r.Episode.serialize()
} for r in p.records]
return p
def new(cls, user_id, name, redirect_uri, level):
'''
:param user_id: int
creator of the app
:param name: str
:param redirect_uri: str
:param level: int
1: read
2: write
3: system
:returns: `App()`
'''
with new_session() as session:
app = models.App(
user_id=user_id,
name=name,
client_id=random_key(),
client_secret=random_key(),
redirect_uri=redirect_uri,
level=level,
created=datetime.utcnow(),
)
session.add(app)
session.commit()
return cls._format_from_query(app)
def shows(self, user_id):
with new_session() as session:
now_ = datetime.utcnow()
episodes = session.query(
models.Episode.show_id.label('show_id'),
func.min(models.Episode.number).label('episode_number'),
).filter(
models.Show_fan.user_id == user_id,
models.Episode.show_id == models.Show_fan.show_id,
models.Episode.air_date > (now_-timedelta(days=7)).date(),
func.addtime(
models.Episode.air_date,
func.ifnull(models.Episode.air_time, '00:00:00'),
) < datetime.utcnow(),
).group_by(models.Episode.show_id).subquery()
p = session.query(models.Show, models.Episode).filter(
models.Show.id == episodes.c.show_id,
models.Episode.show_id == models.Show.id,
models.Episode.number == episodes.c.episode_number,
).order_by(
desc(models.Episode.air_date),
models.Episode.show_id,
).paginate(page=self.page, per_page=self.per_page)
p.records = [{
'show': r.Show.serialize(),
'episode': r.Episode.serialize()
} for r in p.records]
return p
def query_episodes(self, user_id):
with new_session() as session:
r = session.query(
sa.func.sum(models.Episode_watched.times).label('episodes_watched'),
sa.func.sum(
models.Episode_watched.times * \
sa.func.ifnull(
models.Episode.runtime,
models.Show.runtime,
)
).label('episodes_watched_minutes'),
).filter(
models.Episode_watched.user_id == user_id,
models.Episode.show_id == models.Episode_watched.show_id,
models.Episode.number == models.Episode_watched.episode_number,
models.Show.id == models.Episode_watched.show_id,
).first()
d = {
'episodes_watched': 0,
'episodes_watched_minutes': 0,
}
if not r:
return d
d['episodes_watched'] = int(r.episodes_watched) if r.episodes_watched else 0
d['episodes_watched_minutes'] = int(r.episodes_watched_minutes) if r.episodes_watched else 0
return d
def login(self, user_level=0, app_level=constants.LEVEL_GOD):
if self.current_user:
return
with new_session() as session:
user = models.User(
name='testuser',
email='*****@*****.**',
level=user_level,
)
session.add(user)
session.flush()
self.current_user = utils.dotdict(user.serialize())
app = models.App(
user_id=user.id,
name='testbase app',
redirect_uri='',
level=app_level,
)
session.flush()
self.current_app = utils.dotdict(app.serialize())
access_token = models.Token(
user_id=user.id,
user_level=user_level,
app_id=app.id,
)
session.add(access_token)
session.commit()
self.access_token = access_token.token
def get_episode(self, show_id):
with new_session() as session:
eps = session.query(
models.Episode,
models.Episode_watched,
).filter(
models.Episode_watched.user_id == self.current_user.id,
models.Episode_watched.show_id == show_id,
models.Episode.show_id == models.Episode_watched.show_id,
models.Episode.number == models.Episode_watched.episode_number,
).order_by(
sa.desc(models.Episode_watched.watched_at),
sa.desc(models.Episode_watched.episode_number),
).limit(2).all()
if not eps:
return
e = eps[0]
if len(eps) == 1:
if eps[0].Episode_watched.position > 0:
return
else:
if eps[0].Episode_watched.position > 0:
e = eps[1]
episode = e.Episode.serialize()
episode['user_watched'] = e.Episode_watched.serialize()
return episode
def reset(self):
data = self.validate()
with new_session() as session:
r = session.query(models.Reset_password.user_id).filter(
models.Reset_password.key == data['key'],
models.Reset_password.expires >= datetime.utcnow(),
).first()
if not r:
raise exceptions.Forbidden('Invalid reset key')
session.query(models.Reset_password).filter(
models.Reset_password.user_id == r.user_id,
).delete()
user_id = r.user_id
models.User.change_password(
user_id=user_id,
new_password=data['new_password'],
session=session,
)
tokens = session.query(models.Token).filter(
models.Token.user_id == user_id,
sa.or_(
models.Token.expires >= datetime.utcnow(),
models.Token.expires == None,
)
).all()
for token in tokens:
if token.token == self.access_token:
continue
session.delete(token)
session.commit()
def grant_type_password(self):
data = self.validate(schemas.Token_type_password)
app = models.App.by_client_id(data['client_id'])
if not app:
raise exceptions.OAuth_unknown_client_id_exception(
data['client_id']
)
if app['level'] != constants.LEVEL_GOD:
raise exceptions.OAuth_unauthorized_grant_type_level_request_exception(
constants.LEVEL_GOD, app['level']
)
user = models.User.login(
email_or_username=data['email'],
password=data['password'],
)
if not user:
raise exceptions.Wrong_email_or_password_exception()
with new_session() as session:
token = models.Token(
app_id=app['id'],
user_level=user['level'],
user_id=user['id'],
)
session.add(token)
session.commit()
return token.token
def _delete(self, image_id):
with new_session() as session:
image = session.query(Image).get(image_id)
if not image:
raise exceptions.Image_unknown()
session.delete(image)
session.commit()
def create_reset_url(self, user_id):
with new_session() as session:
r = models.Reset_password(
user_id=user_id,
)
session.add(r)
session.commit()
return config['web']['url'] + '/reset-password/{}'.format(r.key)
def get_users(self):
username = self.get_argument('username')
with new_session() as session:
user = session.query(models.User).filter(
models.User.name == username,
).first()
if user:
return [self.user_wrapper(user.serialize())]
return []
def unfan(self, user_id, show_id):
with new_session() as session:
fan = session.query(models.Show_fan).filter(
models.Show_fan.user_id == user_id,
models.Show_fan.show_id == show_id,
).first()
if fan:
session.delete(fan)
session.commit()
def _put(self, image_id):
data = self.validate(schemas.Image_optional)
with new_session() as session:
image = session.query(Image).get(image_id)
if not image:
raise exceptions.Image_unknown()
self.update_model(image, data)
session.commit()
return image.serialize()
def _post(self, relation_id):
data = self.validate(schemas.Image_required)
with new_session() as session:
image = Image()
image.relation_type = self.relation_type
image.relation_id = relation_id
session.add(image)
self.update_model(image, data)
session.commit()
return image.serialize()
def fan_of(self, user_id):
with new_session() as session:
pagination = session.query(models.Show).filter(
models.Show_fan.user_id == user_id,
models.Show_fan.show_id == models.Show.id,
).order_by(
sa.desc(models.Show_fan.created_at),
sa.desc(models.Show_fan.show_id),
).paginate(page=self.page, per_page=self.per_page)
return pagination
def fan(self, user_id, show_id):
with new_session() as session:
if session.query(models.Show_fan).get((show_id, user_id)):
return
fan = models.Show_fan(
user_id=user_id,
show_id=show_id,
)
session.add(fan)
session.commit()
def new_app(self, name, user_id, level, redirect_uri=''):
with new_session() as session:
app = models.App(
name=name,
user_id=user_id,
level=level,
redirect_uri='',
)
session.add(app)
session.commit()
return utils.dotdict(app.serialize())
def new_user(self, name, email, level, password=''):
with new_session() as session:
user = models.User(
name=name,
email=email,
password=password,
level=level,
)
session.add(user)
session.commit()
return utils.dotdict(user.serialize())
def get_token(self):
with new_session() as session:
token = models.Token(
app_id=None,
user_id=self.current_user.id,
user_level=constants.LEVEL_PROGRESS,
expires=datetime.utcnow()+timedelta(days=1),
)
session.add(token)
session.commit()
return token.token
def _put(self, show_id):
data = self.validate()
with new_session() as session:
d = models.User_show_subtitle_lang(
user_id=self.current_user.id,
show_id=show_id,
subtitle_lang=data.get('subtitle_lang', None),
audio_lang=data.get('audio_lang', None),
)
session.merge(d)
session.commit()
def query_fan_of(self, user_id):
with new_session() as session:
r = session.query(
sa.func.count(models.Show_fan.show_id).label('user_fan_of'),
).filter(
models.Show_fan.user_id == user_id,
).first()
if not r:
return {'fan_of': 0}
return {
'fan_of': r.user_fan_of or 0,
}
def update(self, show_id=None, overwrite=False):
self.request.body = self.validate(schemas.Show_schema)
with new_session() as session:
show = session.query(models.Show).get(show_id)
if not show:
raise exceptions.Not_found('unknown show')
self._update(
session,
show,
overwrite=overwrite,
)
session.commit()
return show.serialize()
def rebuild_tag_relations_relations(self):
from seplis.api.base.tag import User_tag_relation
with new_session() as session:
with database.redis.pipeline() as pipe:
for rel in session.query(models.Tag_relation).yield_per(10000):
User_tag_relation.cache(
pipe=pipe,
user_id=rel.user_id,
tag_id=rel.tag_id,
tag_type=rel.type,
relation_id=rel.relation_id,
)
pipe.execute()
def _patch(self, show_id):
data = self.validate()
with new_session() as session:
d = models.User_show_subtitle_lang(
user_id=self.current_user.id,
show_id=show_id,
)
if 'subtitle_lang' in data:
d.subtitle_lang = data['subtitle_lang']
if 'audio_lang' in data:
d.audio_lang = data['audio_lang']
session.merge(d)
session.commit()
def append_is_fan(self, shows, user_id=None):
if not user_id:
self.is_logged_in()
user_id = self.current_user.id
with new_session() as session:
rows = session.query(models.Show_fan.show_id).filter(
models.Show_fan.user_id == user_id,
).all()
if not rows:
return
show_ids = set([r.show_id for r in rows])
for show in shows:
show['is_fan'] = show['id'] in show_ids
def get_by_client_id(cls, client_id):
'''
:param client_id: str
:returns: `App()`
'''
with new_session() as session:
app = session.query(
models.App,
).filter(
models.App.client_id == client_id,
).first()
return cls._format_from_query(app)
def _post(self):
self.request.body = self.validate(schemas.Show_schema)
with new_session() as session:
show = models.Show()
session.add(show)
session.flush()
self._update(
show=show,
overwrite=False,
session=session,
)
session.commit()
return show.serialize()
def get(cls, id_):
'''
:param id_: int
:returns: `App()`
'''
with new_session() as session:
app = session.query(
models.App,
).filter(
models.App.id == id_,
).first()
return cls._format_from_query(app)
def test_add_image(self):
self.login(constants.LEVEL_EDIT_SHOW)
response = self.post('/1/shows/1/images', {
'external_name': 'Test',
'external_id': '1',
'source_title': 'Test',
'source_url': 'http://example.net',
'type': constants.IMAGE_TYPE_POSTER,
})
self.assertEqual(response.code, 200, response.body)
image = utils.json_loads(response.body)
# we need to fake that an image has been uploaded
with new_session() as session:
session.query(models.Image).filter(
models.Image.id == image['id'],
).update({
'hash': '17fb3ee9dac3969819af794c1fd11fbd0e02ca3d0e86b9f0c0365f13fa27d225'
})
session.commit()
response = self.post('/1/shows', {
'title': 'test show',
'status': 1,
'poster_image_id': image['id']
})
self.assertEqual(response.code, 201, response.body)
show = utils.json_loads(response.body)
self.assertEqual(show['poster_image']['id'], image['id'])
# when retrieving the show the poster image must be there.
response = self.get('/1/shows/{}'.format(show['id']))
self.assertEqual(response.code, 200)
show = utils.json_loads(response.body)
self.assertEqual(show['poster_image']['id'], image['id'])
# remove the image
response = self.put('/1/shows/{}'.format(show['id']), {
'poster_image_id': None
})
self.assertEqual(response.code, 200)
show = utils.json_loads(response.body)
self.assertEqual(show['poster_image'], None)
# add the image again
response = self.put('/1/shows/{}'.format(show['id']), {
'poster_image_id': image['id']
})
self.assertEqual(response.code, 200)
show = utils.json_loads(response.body)
self.assertEqual(show['poster_image']['id'], image['id'])
def _put(self, show_id, from_, to):
data = self.validate(Handler.__schema__)
times = data.get('times', 1)
episode = None
with new_session() as session:
episodes = session.query(models.Episode.number).filter(
models.Episode.show_id == show_id,
models.Episode.number >= from_,
models.Episode.number <= to,
).order_by(asc(models.Episode.number)).all()
if not episodes:
return
for episode in episodes:
set_watched(
session=session,
user_id=self.current_user.id,
show_id=show_id,
episode_number=episode.number,
times=times,
)
session.commit()
def query_shows_finished(self, user_id):
with new_session() as session:
r = session.execute(sa.sql.text('''
SELECT
COUNT(total_episodes) AS shows_finished
FROM
(SELECT
COUNT(ew.episode_number), s.total_episodes
FROM
shows s, episodes_watched ew
WHERE
ew.user_id = :user_id AND s.id = ew.show_id
GROUP BY ew.show_id
HAVING COUNT(ew.episode_number) = s.total_episodes) AS a;
'''), {'user_id': user_id}).fetchone()
if not r:
return 0
return {
'shows_finished': r['shows_finished'] if r else 0
}
def change_password(self, user_id):
data = self.validate()
if not models.User.login(int(user_id), data['password']):
raise exceptions.Wrong_email_or_password_exception()
with new_session() as session:
models.User.change_password(
user_id=user_id,
new_password=data['new_password'],
session=session,
)
tokens = session.query(models.Token).filter(
models.Token.user_id == user_id,
or_(
models.Token.expires >= datetime.utcnow(),
models.Token.expires == None,
)).all()
for token in tokens:
if token.token == self.access_token:
continue
session.delete(token)
session.commit()
def _get(self, server_id):
with new_session() as session:
users = session.query(models.User).filter(
models.Play_server.id == server_id,
models.Play_server.user_id == self.current_user.id,
models.Play_access.play_server_id == models.Play_server.id,
models.User.id == models.Play_access.user_id,
).order_by(models.User.name).paginate(
page=self.page,
per_page=self.per_page,
)
print(users.records)
a = []
for u in users.records:
a.append({
'name': u.name,
'id': u.id,
'fan_of': u.fan_of,
'created_at': u.created_at,
})
users.records = a
return users
def set(cls, tag_type, tag_name, user_id, relation_id):
'''
:param tag_type: str
:param tag_name: str
:param user_id: int
:param relation_id: int
:returns: `Tag()`
'''
tag = Tag.get_by_name(
type_=tag_type,
name=tag_name,
)
if not tag:
tag = Tag.new(
type_=tag_type,
name=tag_name,
)
with database.redis.pipeline() as pipe:
cls.cache(
pipe=pipe,
user_id=user_id,
tag_id=tag.id,
tag_type=tag.type,
relation_id=relation_id,
)
response = pipe.execute()
result = response[0]
if result == 1:
with new_session() as session:
tag_relation = models.Tag_relation(
user_id=user_id,
type=tag_type,
relation_id=relation_id,
tag_id=tag.id,
)
session.merge(tag_relation)
session.commit()
return tag
def test_add_image(self):
self.login(constants.LEVEL_EDIT_SHOW)
response = self.post(
'/1/shows/1/images', {
'external_name': 'Test',
'external_id': '1',
'source_title': 'Test',
'source_url': 'http://example.net',
'type': constants.IMAGE_TYPE_POSTER,
})
self.assertEqual(response.code, 200)
image = utils.json_loads(response.body)
# we need to fake that an image has been uploaded
with new_session() as session:
session.query(models.Image).filter(
models.Image.id == image['id'],
).update({
'hash':
'17fb3ee9dac3969819af794c1fd11fbd0e02ca3d0e86b9f0c0365f13fa27d225'
})
session.commit()
response = self.post('/1/shows', {
'title': 'test show',
'status': 1,
'poster_image_id': image['id']
})
self.assertEqual(response.code, 201, response.body)
show = utils.json_loads(response.body)
self.assertEqual(show['poster_image']['id'], image['id'])
# remove the image
response = self.put('/1/shows/{}'.format(show['id']),
{'poster_image_id': None})
self.assertEqual(response.code, 200)
show = utils.json_loads(response.body)
self.assertEqual(show['poster_image'], None)
def _get(self, show_id, number):
with new_session() as session:
p = session.query(models.Play_server).filter(
models.Play_access.user_id == self.current_user.id,
models.Play_server.id == models.Play_access.play_server_id,
).options(sa.orm.undefer_group('secret')).all()
playids = []
for s in p:
playids.append({
'play_id':
web.create_signed_value(
secret=s.secret,
name='play_id',
value=utils.json_dumps({
'show_id': int(show_id),
'number': int(number),
}),
version=2,
),
'play_url':
s.url,
})
return playids
def new(cls, name, email, password=None, level=0, pipe=None):
'''
:param name: str
:param email: email
:param password: str
pbkdf2_sha256 encrypted!
:param level: int
:returns: `User()`
'''
with new_session() as session:
user = models.User(
name=name,
email=email,
password=password,
created=datetime.utcnow(),
level=level,
)
session.add(user)
session.commit()
user = cls._format_from_query(user)
user.cache(pipe=pipe)
user.cache_default_stat_fields(pipe=pipe)
return user
def shows(self, user_id):
with new_session() as session:
episodes = session.query(
models.Episode.show_id.label('show_id'),
func.min(models.Episode.number).label('episode_number'),
).filter(
models.Show_fan.user_id == user_id,
models.Episode.show_id == models.Show_fan.show_id,
models.Episode.air_datetime > datetime.utcnow(),
).group_by(models.Episode.show_id).subquery()
p = session.query(models.Show, models.Episode).filter(
models.Show.id == episodes.c.show_id,
models.Episode.show_id == models.Show.id,
models.Episode.number == episodes.c.episode_number,
).order_by(
models.Episode.air_datetime,
models.Episode.show_id,
).paginate(page=self.page, per_page=self.per_page)
p.records = [{
'show': r.Show.serialize(),
'episode': r.Episode.serialize()
} for r in p.records]
return p
def grant_type_password(self):
data = self.validate(schemas.Token_type_password)
app = models.App.by_client_id(data['client_id'])
if not app:
raise exceptions.OAuth_unknown_client_id_exception(
data['client_id'])
if app['level'] != constants.LEVEL_GOD:
raise exceptions.OAuth_unauthorized_grant_type_level_request_exception(
constants.LEVEL_GOD, app['level'])
user = models.User.login(
email_or_username=data['email'],
password=data['password'],
)
if not user:
raise exceptions.Wrong_email_or_password_exception()
with new_session() as session:
token = models.Token(
app_id=app['id'],
user_level=user['level'],
user_id=user['id'],
)
session.add(token)
session.commit()
return token.token
def rebuild_episodes():
with new_session() as session:
for item in session.query(Episode).yield_per(10000):
item.to_elasticsearch()
session.commit()
def rebuild_apps():
with new_session() as session:
for item in session.query(App).yield_per(10000):
item.cache()
session.commit()
def get_genres(self):
with new_session() as session:
r = session.query(models.Genre).order_by(models.Genre.genre).all()
return [g.genre for g in r]
def test(self):
self.login()
with new_session() as session:
show = models.Show(
title='Test show',
runtime=30,
total_episodes=3,
)
session.add(show)
session.flush()
show2 = models.Show(
title='Test show 2',
runtime=30,
total_episodes=1,
)
session.add(show2)
session.flush()
episode1 = models.Episode(show_id=show.id, number=1)
session.add(episode1)
episode2 = models.Episode(show_id=show.id, number=2)
session.add(episode2)
episode3 = models.Episode(show_id=show.id, number=3, runtime=40)
session.add(episode3)
episode4 = models.Episode(show_id=show2.id, number=4)
session.add(episode4)
session.commit()
show = show.serialize()
show2 = show2.serialize()
episode1 = episode1.serialize()
episode2 = episode2.serialize()
episode3 = episode3.serialize()
episode4 = episode4.serialize()
response = self.get('/1/users/{}/show-stats'.format(
self.current_user.id))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['fan_of'], 0)
self.assertEqual(data['episodes_watched'], 0)
self.assertEqual(data['episodes_watched_minutes'], 0)
self.assertEqual(data['shows_finished'], 0)
# Follow
self.put('/1/users/{}/shows-following/{}'.format(
self.current_user.id,
show['id'],
))
response = self.get('/1/users/{}/show-stats'.format(
self.current_user.id))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['fan_of'], 1)
# watched time
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show['id'], 1))
self.assertEqual(response.code, 200)
response = self.get('/1/users/{}/show-stats'.format(
self.current_user.id))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 1, data)
self.assertEqual(data['episodes_watched_minutes'], 30, data)
self.assertEqual(data['shows_finished'], 0)
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show['id'], 1))
self.assertEqual(response.code, 200)
response = self.get('/1/users/{}/show-stats'.format(
self.current_user.id))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 2, data)
self.assertEqual(data['episodes_watched_minutes'], 60, data)
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show['id'], 2))
self.assertEqual(response.code, 200)
response = self.get('/1/users/{}/show-stats'.format(
self.current_user.id))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 3, data)
self.assertEqual(data['episodes_watched_minutes'], 90, data)
self.assertEqual(data['shows_finished'], 0)
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show['id'], 3))
self.assertEqual(response.code, 200)
response = self.get('/1/users/{}/show-stats'.format(
self.current_user.id))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 4, data)
self.assertEqual(data['episodes_watched_minutes'], 130, data)
self.assertEqual(data['shows_watched'], 1, data)
self.assertEqual(data['shows_finished'], 1)
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show2['id'], 4))
self.assertEqual(response.code, 200)
response = self.get('/1/users/{}/show-stats'.format(
self.current_user.id))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 5, data)
self.assertEqual(data['episodes_watched_minutes'], 160, data)
self.assertEqual(data['shows_watched'], 2, data)
self.assertEqual(data['shows_finished'], 2, data)
def rebuild_user_show_subtitle_lang():
with new_session() as session:
for item in session.query(User_show_subtitle_lang).yield_per(10000):
item.cache()
session.commit()
def rebuild_tags(self):
from seplis.api.base.tag import Tag
with new_session() as session:
for tag in session.query(models.Tag).yield_per(10000):
tag = Tag._format_from_query(tag)
tag.cache()
def test_search_title(self):
self.login(constants.LEVEL_EDIT_SHOW)
response = self.post('/1/shows', {
'title': 'This is a test show',
'alternative_titles': [
'kurt 1',
]
})
self.assertEqual(response.code, 201, response.body)
show = utils.json_loads(response.body)
self.refresh_es()
# Test that lowercase does not matter
response = self.get('/1/shows', {'q': 'this'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 1)
# Test that both title and alternative_titles is searched in
response = self.get('/1/shows', {'q': 'kurt'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 1)
# Test ascii folding
response = self.get('/1/shows', {'q': 'kùrt'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 1)
# Test apostrophe
response = self.post(
'/1/shows', {
'title': 'DC\'s legend of something',
'alternative_titles': [
'DC’s kurt',
]
})
self.assertEqual(response.code, 201, response.body)
show2 = utils.json_loads(response.body)
self.refresh_es()
response = self.get('/1/shows', {'q': 'dc\'s'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 1, data)
self.assertEqual(data[0]['id'], show2['id'])
response = self.get('/1/shows', {'q': 'dc’s'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 1, data)
self.assertEqual(data[0]['id'], show2['id'])
response = self.get('/1/shows', {'q': 'dcs'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 1, data)
response = self.get('/1/shows', {'q': '"dcs kurt"'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 1, data)
response = self.get('/1/shows', {'q': '"dc’s kurt"'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(data[0]['id'], show2['id'])
response = self.get('/1/shows', {'q': 'dc'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 0, data)
# Test dotted search
response = self.get('/1/shows', {'q': 'dcs.legend.of.something'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 1, data)
self.assertEqual(data[0]['id'], show2['id'])
# Test score
# Searching for "dcs legend of something" should not return
# "Test DC's legend of something" as the first result
response = self.post('/1/shows', {
'title': 'Test DCs legend of something',
})
self.assertEqual(response.code, 201, response.body)
show3 = utils.json_loads(response.body)
response = self.post('/1/shows', {
'title': 'legend',
})
self.assertEqual(response.code, 201, response.body)
show3 = utils.json_loads(response.body)
self.refresh_es()
response = self.get('/1/shows', {'title': 'dc\'s legend of something'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 2, data)
self.assertEqual(data[0]['id'], show2['id'], data)
# Test the walking dead
with new_session() as session:
session.query(models.Show).delete()
session.commit()
response = self.post('/1/shows', {
'title': 'The Walking Dead',
'premiered': '2010-10-31',
})
self.assertEqual(response.code, 201, response.body)
response = self.post('/1/shows', {
'title': 'Fear the Walking Dead',
'premiered': '2015-08-23',
})
self.assertEqual(response.code, 201, response.body)
self.refresh_es()
response = self.get('/1/shows', {'title': 'The Walking Dead'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 2, data)
self.assertEqual(data[0]['title'], 'The Walking Dead')
# Test `&` and `and`
response = self.post('/1/shows', {
'title': 'Test & Test',
'premiered': '2010-10-31',
})
self.assertEqual(response.code, 201, response.body)
self.refresh_es()
response = self.get('/1/shows', {'title': 'Test and Test'})
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(len(data), 1, data)
def rebuild_users():
with new_session() as session:
for item in session.query(User).yield_per(10000):
item.cache()
item.cache_user_default_stats()
session.commit()
def test(self):
self.login(constants.LEVEL_PROGRESS)
# Create a show and 2 episodes
with new_session() as session:
show = models.Show()
session.add(show)
session.flush()
episode1 = models.Episode(show_id=show.id, number=1)
session.add(episode1)
episode2 = models.Episode(show_id=show.id, number=2)
session.add(episode2)
session.commit()
show_id = show.id
# Test no watched episodes
response = self.get(
'/1/shows/{}/episodes/last-watched'.format(show_id))
self.assertEqual(response.code, 204, response.body)
self.assertEqual(response.body, b'')
# set episode 1 as watching
response = self.put(
'/1/shows/{}/episodes/{}/position'.format(show_id, 1),
{'position': 200})
self.assertEqual(response.code, 204)
# Since we have not completed the first episode
# and it's the only episode we have watched the result
# should be empty
response = self.get(
'/1/shows/{}/episodes/last-watched'.format(show_id))
self.assertEqual(response.code, 204, response.body)
self.assertEqual(response.body, b'')
# Start watching episode 2.
# Episode 1 should now be the latest watched even though it
# is not completed.
response = self.put(
'/1/shows/{}/episodes/{}/position'.format(show_id, 2),
{'position': 202})
self.assertEqual(response.code, 204)
response = self.get(
'/1/shows/{}/episodes/last-watched'.format(show_id))
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(data['number'], 1)
self.assertEqual(data['user_watched']['position'], 200)
self.assertEqual(data['user_watched']['times'], 0)
# Set episode 2 as completed.
# Episode 2 should now be the last watched
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show_id, 2))
self.assertEqual(response.code, 200)
response = self.get(
'/1/shows/{}/episodes/last-watched'.format(show_id))
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(data['number'], 2)
self.assertEqual(data['user_watched']['position'], 0)
self.assertEqual(data['user_watched']['times'], 1)
# set episode 1 as watched
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show_id, 1))
# unwatch episode 2
response = self.put(
'/1/shows/{}/episodes/{}/watched'.format(show_id, 2), {
'times': -1,
})
self.assertEqual(response.code, 204)
# episode 1 should now be the last watched
response = self.get(
'/1/shows/{}/episodes/last-watched'.format(show_id))
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(data['number'], 1)
# watch episode 2 twice
response = self.put(
'/1/shows/{}/episodes/{}/watched'.format(show_id, 2), {
'times': 2,
})
self.assertEqual(response.code, 200)
response = self.get(
'/1/shows/{}/episodes/last-watched'.format(show_id))
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(data['number'], 2)
self.assertEqual(data['user_watched']['position'], 0)
def rebuild_externals():
with new_session() as session:
for item in session.query(Show_external).yield_per(10000):
item.cache()
session.commit()
def episode_to_watch(self, user_id, show_id):
"""Returns which episode to watch for a show.
* Return episode 1 if the user has not watched any episodes.
* If the user is watching an episode and it is not completed
return that one.
* If the latest episode watched by the user is completed
return the latest + 1.
If the next episode does not exist or the show has no
episodes the result will be `None`.
:returns: episode dict with "user_watched" field.
{
"number": 1,
"title": "asd",
"user_watched": {
"times": 1,
"position": 100,
}
}
"""
with new_session() as session:
ew = session.query(
models.Episode_watched.episode_number,
models.Episode_watched.position,
).filter(
models.Episode_watching.user_id == user_id,
models.Episode_watching.show_id == show_id,
models.Episode_watched.show_id == models.Episode_watching.show_id,
models.Episode_watched.user_id == models.Episode_watching.user_id,
models.Episode_watched.episode_number ==\
models.Episode_watching.episode_number,
).first()
episode_number = 1
if ew:
episode_number = ew.episode_number
if ew.position == 0:
episode_number += 1
e = session.query(
models.Episode,
models.Episode_watched,
).filter(
models.Episode.show_id == show_id,
models.Episode.number == episode_number,
).outerjoin(
(models.Episode_watched, and_(
models.Episode_watched.user_id == user_id,
models.Episode_watched.show_id == models.Episode.show_id,
models.Episode_watched.episode_number == models.Episode.number,
))
).first()
if not e:
return
episode = e.Episode.serialize()
episode['user_watched'] = None
if e.Episode_watched:
episode['user_watched'] = e.Episode_watched.serialize()
return episode
def rebuild_shows():
with new_session() as session:
for item in session.query(Show).yield_per(10000):
item.to_elasticsearch()
session.commit()
def _delete(self, show_id):
with new_session() as session:
show = session.query(models.Show).get(show_id)
session.delete(show)
session.commit()
def test(self):
self.login()
with new_session() as session:
show = models.Show(
title='Test show',
runtime=30,
)
session.add(show)
session.flush()
episode1 = models.Episode(show_id=show.id, number=1)
session.add(episode1)
episode2 = models.Episode(show_id=show.id, number=2)
session.add(episode2)
episode3 = models.Episode(show_id=show.id, number=3, runtime=40)
session.add(episode3)
session.commit()
show = show.serialize()
episode1 = episode1.serialize()
episode2 = episode2.serialize()
episode3 = episode3.serialize()
response = self.get('/1/shows/{}/user-stats'.format(show['id']))
self.assertEqual(response.code, 200, response.body)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 0)
self.assertEqual(data['episodes_watched_minutes'], 0)
# watched time
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show['id'], 1))
self.assertEqual(response.code, 200)
response = self.get('/1/shows/{}/user-stats'.format(show['id']))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 1, data)
self.assertEqual(data['episodes_watched_minutes'], 30, data)
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show['id'], 1))
self.assertEqual(response.code, 200)
response = self.get('/1/shows/{}/user-stats'.format(show['id']))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 2, data)
self.assertEqual(data['episodes_watched_minutes'], 60, data)
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show['id'], 2))
self.assertEqual(response.code, 200)
response = self.get('/1/shows/{}/user-stats'.format(show['id']))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 3, data)
self.assertEqual(data['episodes_watched_minutes'], 90, data)
response = self.put('/1/shows/{}/episodes/{}/watched'.format(
show['id'], 3))
self.assertEqual(response.code, 200)
response = self.get('/1/shows/{}/user-stats'.format(show['id']))
self.assertEqual(response.code, 200)
data = utils.json_loads(response.body)
self.assertEqual(data['episodes_watched'], 4, data)
self.assertEqual(data['episodes_watched_minutes'], 130, data)
