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)