def recent_update(self, days): current = datetime.utcnow() # from one week ago start_time = current - timedelta(days=days) session = SessionManager.Session() try: result = session.query(Episode, Bangumi).\ join(Bangumi).\ filter(Episode.delete_mark == None).\ filter(Episode.status == Episode.STATUS_DOWNLOADED).\ filter(Episode.update_time >= start_time).\ filter(Episode.update_time <= current).\ order_by(desc(Episode.update_time)) episode_list = [] for eps, bgm in result: episode = row2dict(eps, Episode) episode['thumbnail'] = utils.generate_thumbnail_link(eps, bgm) episode['bangumi'] = row2dict(bgm, Bangumi) episode['bangumi']['cover'] = utils.generate_cover_link(bgm) episode_list.append(episode) return json_resp({'data': episode_list}) finally: SessionManager.Session.remove()
def recent_update(self, days): current = datetime.now() # from one week ago start_time = current - timedelta(days=days) session = SessionManager.Session() try: result = session.query(Episode, Bangumi).\ join(Bangumi).\ filter(Episode.delete_mark == None).\ filter(Episode.status == Episode.STATUS_DOWNLOADED).\ filter(Episode.update_time >= start_time).\ filter(Episode.update_time <= current).\ order_by(desc(Episode.update_time)) episode_list = [] for eps, bgm in result: episode = row2dict(eps) episode['thumbnail'] = utils.generate_thumbnail_link(eps, bgm) episode['bangumi'] = row2dict(bgm) episode['bangumi']['cover'] = utils.generate_cover_link(bgm) episode_list.append(episode) return json_resp({'data': episode_list}) finally: SessionManager.Session.remove()
def list_bangumi(self, page, count, sort_field, sort_order, name, user_id, bangumi_type): try: session = SessionManager.Session() query_object = session.query(Bangumi).\ options(joinedload(Bangumi.cover_image)).\ filter(Bangumi.delete_mark == None) if bangumi_type != -1: query_object = query_object.filter( Bangumi.type == bangumi_type) if name is not None: name_pattern = '%{0}%'.format(name.encode('utf-8'), ) logger.debug(name_pattern) query_object = query_object.\ filter(or_(Bangumi.name.ilike(name_pattern), Bangumi.name_cn.ilike(name_pattern))) # count total rows total = session.query(func.count(Bangumi.id)).\ filter(or_(Bangumi.name.ilike(name_pattern), Bangumi.name_cn.ilike(name_pattern))).\ scalar() else: total = session.query(func.count(Bangumi.id)).scalar() if sort_order == 'desc': query_object = query_object.\ order_by(desc(getattr(Bangumi, sort_field))) else: query_object = query_object.\ order_by(asc(getattr(Bangumi, sort_field))) if count == -1: bangumi_list = query_object.all() else: offset = (page - 1) * count bangumi_list = query_object.offset(offset).limit(count).all() bangumi_id_list = [bgm.id for bgm in bangumi_list] favorites = session.query(Favorites).\ filter(Favorites.bangumi_id.in_(bangumi_id_list)).\ filter(Favorites.user_id == user_id).\ all() bangumi_dict_list = [] for bgm in bangumi_list: bangumi = row2dict(bgm) bangumi['cover'] = utils.generate_cover_link(bgm) utils.process_bangumi_dict(bgm, bangumi) for fav in favorites: if fav.bangumi_id == bgm.id: bangumi['favorite_status'] = fav.status bangumi_dict_list.append(bangumi) return json_resp({'data': bangumi_dict_list, 'total': total}) finally: SessionManager.Session.remove()
def list_bangumi(self, page, count, sort_field, sort_order, name, user_id, bangumi_type): try: session = SessionManager.Session() query_object = session.query(Bangumi).\ options(joinedload(Bangumi.cover_image)).\ filter(Bangumi.delete_mark == None) if bangumi_type != -1: query_object = query_object.filter(Bangumi.type == bangumi_type) if name is not None: name_pattern = '%{0}%'.format(name.encode('utf-8'),) logger.debug(name_pattern) query_object = query_object.\ filter(or_(Bangumi.name.ilike(name_pattern), Bangumi.name_cn.ilike(name_pattern))) # count total rows total = session.query(func.count(Bangumi.id)).\ filter(or_(Bangumi.name.ilike(name_pattern), Bangumi.name_cn.ilike(name_pattern))).\ scalar() else: total = session.query(func.count(Bangumi.id)).scalar() if sort_order == 'desc': query_object = query_object.\ order_by(desc(getattr(Bangumi, sort_field))) else: query_object = query_object.\ order_by(asc(getattr(Bangumi, sort_field))) if count == -1: bangumi_list = query_object.all() else: offset = (page - 1) * count bangumi_list = query_object.offset(offset).limit(count).all() bangumi_id_list = [bgm.id for bgm in bangumi_list] favorites = session.query(Favorites).\ filter(Favorites.bangumi_id.in_(bangumi_id_list)).\ filter(Favorites.user_id == user_id).\ all() bangumi_dict_list = [] for bgm in bangumi_list: bangumi = row2dict(bgm, Bangumi) bangumi['cover'] = utils.generate_cover_link(bgm) utils.process_bangumi_dict(bgm, bangumi) for fav in favorites: if fav.bangumi_id == bgm.id: bangumi['favorite_status'] = fav.status bangumi_dict_list.append(bangumi) return json_resp({'data': bangumi_dict_list, 'total': total}) finally: SessionManager.Session.remove()
def get_bangumi(self, id, user_id): try: session = SessionManager.Session() bangumi = session.query(Bangumi).\ options(joinedload(Bangumi.episodes).joinedload(Episode.thumbnail_image)).\ options(joinedload(Bangumi.cover_image)).\ filter(Bangumi.delete_mark == None).\ filter(Bangumi.id == id).\ one() favorite = session.query(Favorites).\ filter(Favorites.bangumi_id == id).\ filter(Favorites.user_id == user_id).\ first() watch_progress_list = session.query(WatchProgress).\ filter(WatchProgress.bangumi_id == bangumi.id).\ filter(WatchProgress.user_id == user_id).\ all() episodes = [] watch_progress_hash_table = {} for watch_progress in watch_progress_list: watch_progress_dict = row2dict(watch_progress) watch_progress_hash_table[ watch_progress.episode_id] = watch_progress_dict for episode in bangumi.episodes: if episode.delete_mark is not None: continue eps = row2dict(episode) eps['thumbnail'] = utils.generate_thumbnail_link( episode, bangumi) utils.process_episode_dict(episode, eps) if episode.id in watch_progress_hash_table: eps['watch_progress'] = watch_progress_hash_table[ episode.id] episodes.append(eps) bangumi_dict = row2dict(bangumi) if favorite is not None: bangumi_dict['favorite_status'] = favorite.status bangumi_dict['episodes'] = episodes bangumi_dict['cover'] = utils.generate_cover_link(bangumi) utils.process_bangumi_dict(bangumi, bangumi_dict) return json_resp({'data': bangumi_dict}) except NoResultFound: raise ClientError(ClientError.NOT_FOUND, 404) finally: SessionManager.Session.remove()
def get_bangumi(self, id, user_id): try: session = SessionManager.Session() bangumi = session.query(Bangumi).\ options(joinedload(Bangumi.episodes).joinedload(Episode.thumbnail_image)).\ options(joinedload(Bangumi.cover_image)).\ filter(Bangumi.delete_mark == None).\ filter(Bangumi.id == id).\ one() favorite = session.query(Favorites).\ filter(Favorites.bangumi_id == id).\ filter(Favorites.user_id == user_id).\ first() watch_progress_list = session.query(WatchProgress).\ filter(WatchProgress.bangumi_id == bangumi.id).\ filter(WatchProgress.user_id == user_id).\ all() episodes = [] watch_progress_hash_table = {} for watch_progress in watch_progress_list: watch_progress_dict = row2dict(watch_progress, WatchProgress) watch_progress_hash_table[watch_progress.episode_id] = watch_progress_dict for episode in bangumi.episodes: if episode.delete_mark is not None: continue eps = row2dict(episode, Episode) eps['thumbnail'] = utils.generate_thumbnail_link(episode, bangumi) utils.process_episode_dict(episode, eps) if episode.id in watch_progress_hash_table: eps['watch_progress'] = watch_progress_hash_table[episode.id] episodes.append(eps) bangumi_dict = row2dict(bangumi, Bangumi) if favorite is not None: bangumi_dict['favorite_status'] = favorite.status bangumi_dict['episodes'] = episodes bangumi_dict['cover'] = utils.generate_cover_link(bangumi) utils.process_bangumi_dict(bangumi, bangumi_dict) return json_resp({'data': bangumi_dict}) except NoResultFound: raise ClientError(ClientError.NOT_FOUND, 404) finally: SessionManager.Session.remove()
def list_bangumi(self, page, count, sort_field, sort_order, name, bangumi_type): try: session = SessionManager.Session() query_object = session.query(Bangumi).\ options(joinedload(Bangumi.cover_image)).\ options(joinedload(Bangumi.created_by)).\ options(joinedload(Bangumi.maintained_by)).\ filter(Bangumi.delete_mark == None) if bangumi_type != -1: query_object = query_object.filter( Bangumi.type == bangumi_type) if name is not None: name_pattern = '%{0}%'.format(name.encode('utf-8'), ) logger.debug(name_pattern) query_object = query_object.\ filter(or_(Bangumi.name.ilike(name_pattern), Bangumi.name_cn.ilike(name_pattern))) # count total rows total = session.query(func.count(Bangumi.id)).\ filter(or_(Bangumi.name.ilike(name_pattern), Bangumi.name_cn.ilike(name_pattern))).\ scalar() else: total = session.query(func.count(Bangumi.id)).scalar() if sort_order == 'desc': query_object = query_object.\ order_by(desc(getattr(Bangumi, sort_field))) else: query_object = query_object.\ order_by(asc(getattr(Bangumi, sort_field))) # we now support query all method by passing count = -1 if count == -1: bangumi_list = query_object.all() else: offset = (page - 1) * count bangumi_list = query_object.offset(offset).limit(count).all() bangumi_dict_list = [] for bgm in bangumi_list: bangumi = row2dict(bgm, Bangumi) bangumi['cover'] = utils.generate_cover_link(bgm) utils.process_bangumi_dict(bgm, bangumi) self.__process_user_obj_in_bangumi(bgm, bangumi) bangumi_dict_list.append(bangumi) return json_resp({'data': bangumi_dict_list, 'total': total}) # raise ClientError('something happened') finally: SessionManager.Session.remove()
def list_bangumi(self, page, count, sort_field, sort_order, name, bangumi_type): try: session = SessionManager.Session() query_object = session.query(Bangumi).\ options(joinedload(Bangumi.cover_image)).\ options(joinedload(Bangumi.created_by)).\ options(joinedload(Bangumi.maintained_by)).\ filter(Bangumi.delete_mark == None) if bangumi_type != -1: query_object = query_object.filter(Bangumi.type == bangumi_type) if name is not None: name_pattern = '%{0}%'.format(name.encode('utf-8'),) logger.debug(name_pattern) query_object = query_object.\ filter(or_(Bangumi.name.ilike(name_pattern), Bangumi.name_cn.ilike(name_pattern))) # count total rows total = session.query(func.count(Bangumi.id)).\ filter(or_(Bangumi.name.ilike(name_pattern), Bangumi.name_cn.ilike(name_pattern))).\ scalar() else: total = session.query(func.count(Bangumi.id)).scalar() if sort_order == 'desc': query_object = query_object.\ order_by(desc(getattr(Bangumi, sort_field))) else: query_object = query_object.\ order_by(asc(getattr(Bangumi, sort_field))) # we now support query all method by passing count = -1 if count == -1: bangumi_list = query_object.all() else: offset = (page - 1) * count bangumi_list = query_object.offset(offset).limit(count).all() bangumi_dict_list = [] for bgm in bangumi_list: bangumi = row2dict(bgm, Bangumi) bangumi['cover'] = utils.generate_cover_link(bgm) utils.process_bangumi_dict(bgm, bangumi) self.__process_user_obj_in_bangumi(bgm, bangumi) bangumi_dict_list.append(bangumi) return json_resp({'data': bangumi_dict_list, 'total': total}) # raise ClientError('something happened') finally: SessionManager.Session.remove()
def my_favorites(self, user_id, status=None): session = SessionManager.Session() try: q = session.query(Favorites, Bangumi).\ join(Bangumi).\ options(joinedload(Bangumi.cover_image)).\ filter(Bangumi.delete_mark == None).\ filter(Favorites.user_id == user_id) if status is None: result = q.all() else: result = q.filter(Favorites.status == status).all() bangumi_id_list = [bangumi.id for favorite, bangumi in result] # print 'bangumi_id_list length: %d' % len(bangumi_id_list) if len(bangumi_id_list) == 0: return json_resp({'data': [], 'status': 0}) # subquery for watch_progress watch_progress = session.query(WatchProgress.episode_id).\ filter(WatchProgress.user_id == user_id).\ filter(WatchProgress.bangumi_id.in_(bangumi_id_list)) episode_count = session.query(func.count(Episode.id), Episode.bangumi_id).\ filter(Episode.status == Episode.STATUS_DOWNLOADED).\ filter(Episode.bangumi_id.in_(bangumi_id_list)).\ filter(~Episode.id.in_(watch_progress)).\ group_by(Episode.bangumi_id).\ all() logger.debug(episode_count) bangumi_dict_list = [] for fav, bgm in result: bangumi_dict = row2dict(bgm) bangumi_dict['favorite_status'] = fav.status bangumi_dict['cover'] = utils.generate_cover_link(bangumi) utils.process_bangumi_dict(bgm, bangumi_dict) for unwatched_count, bangumi_id in episode_count: if bangumi_id == bgm.id: bangumi_dict['unwatched_count'] = unwatched_count break bangumi_dict_list.append(bangumi_dict) return json_resp({'data': bangumi_dict_list, 'status': 0}) finally: SessionManager.Session.remove()
def on_air_bangumi(self, user_id, type): session = SessionManager.Session() current_day = datetime.today() start_time = datetime(current_day.year, current_day.month, 1) if current_day.month == 12: next_year = current_day.year + 1 next_month = 1 else: next_year = current_day.year next_month = current_day.month + 1 end_time = datetime(next_year, next_month, 1) try: result = session.query(distinct(Episode.bangumi_id), Bangumi).\ join(Bangumi). \ options(joinedload(Bangumi.cover_image)).\ filter(Bangumi.delete_mark == None). \ filter(Bangumi.type == type).\ filter(Episode.airdate >= start_time).\ filter(Episode.airdate <= end_time). \ order_by(desc(getattr(Bangumi, 'air_date'))) bangumi_list = [] bangumi_id_list = [bangumi_id for bangumi_id, bangumi in result] if len(bangumi_id_list) == 0: return json_resp({'data': []}) favorites = session.query(Favorites).\ filter(Favorites.bangumi_id.in_(bangumi_id_list)).\ filter(Favorites.user_id == user_id).\ all() for bangumi_id, bangumi in result: bangumi_dict = row2dict(bangumi, Bangumi) bangumi_dict['cover'] = utils.generate_cover_link(bangumi) utils.process_bangumi_dict(bangumi, bangumi_dict) for fav in favorites: if fav.bangumi_id == bangumi_id: bangumi_dict['favorite_status'] = fav.status break bangumi_list.append(bangumi_dict) return json_resp({'data': bangumi_list}) finally: SessionManager.Session.remove()
def on_air_bangumi(self, user_id, type): session = SessionManager.Session() current_day = datetime.today() start_time = datetime(current_day.year, current_day.month, 1) if current_day.month == 12: next_year = current_day.year + 1 next_month = 1 else: next_year = current_day.year next_month = current_day.month + 1 end_time = datetime(next_year, next_month, 1) try: result = session.query(distinct(Episode.bangumi_id), Bangumi).\ join(Bangumi). \ options(joinedload(Bangumi.cover_image)).\ filter(Bangumi.delete_mark == None). \ filter(Bangumi.type == type).\ filter(Episode.airdate >= start_time).\ filter(Episode.airdate <= end_time). \ order_by(desc(getattr(Bangumi, 'air_date'))) bangumi_list = [] bangumi_id_list = [bangumi_id for bangumi_id, bangumi in result] if len(bangumi_id_list) == 0: return json_resp({'data': []}) favorites = session.query(Favorites).\ filter(Favorites.bangumi_id.in_(bangumi_id_list)).\ filter(Favorites.user_id == user_id).\ all() for bangumi_id, bangumi in result: bangumi_dict = row2dict(bangumi) bangumi_dict['cover'] = utils.generate_cover_link(bangumi) utils.process_bangumi_dict(bangumi, bangumi_dict) for fav in favorites: if fav.bangumi_id == bangumi_id: bangumi_dict['favorite_status'] = fav.status break bangumi_list.append(bangumi_dict) return json_resp({'data': bangumi_list}) finally: SessionManager.Session.remove()
def episode_detail(self, episode_id, user_id): session = SessionManager.Session() try: (episode, bangumi) = session.query(Episode, Bangumi).\ join(Bangumi).\ options(joinedload(Bangumi.cover_image)).\ options(joinedload(Episode.thumbnail_image)).\ filter(Episode.delete_mark == None).\ filter(Episode.id == episode_id).\ one() watch_progress = session.query(WatchProgress).\ filter(WatchProgress.episode_id == episode_id).\ filter(WatchProgress.user_id == user_id).\ first() episode_dict = row2dict(episode, Episode) episode_dict['bangumi'] = row2dict(bangumi, Bangumi) episode_dict['bangumi']['cover'] = utils.generate_cover_link( bangumi) utils.process_bangumi_dict(bangumi, episode_dict['bangumi']) episode_dict['thumbnail'] = utils.generate_thumbnail_link( episode, bangumi) utils.process_episode_dict(episode, episode_dict) if watch_progress is not None: episode_dict['watch_progress'] = row2dict( watch_progress, WatchProgress) if episode.status == Episode.STATUS_DOWNLOADED: episode_dict['video_files'] = [] video_file_list = session.query(VideoFile).filter( VideoFile.episode_id == episode_id).all() for video_file in video_file_list: if video_file.status != VideoFile.STATUS_DOWNLOADED: continue video_file_dict = row2dict(video_file, VideoFile) video_file_dict['url'] = utils.generate_video_link( str(bangumi.id), video_file.file_path) episode_dict['video_files'].append(video_file_dict) return json_resp(episode_dict) except NoResultFound: raise ClientError(ClientError.NOT_FOUND, 404) finally: SessionManager.Session.remove()
def episode_detail(self, episode_id, user_id): session = SessionManager.Session() try: (episode, bangumi) = session.query(Episode, Bangumi).\ join(Bangumi).\ options(joinedload(Bangumi.cover_image)).\ options(joinedload(Episode.thumbnail_image)).\ filter(Episode.delete_mark == None).\ filter(Episode.id == episode_id).\ one() watch_progress = session.query(WatchProgress).\ filter(WatchProgress.episode_id == episode_id).\ filter(WatchProgress.user_id == user_id).\ first() episode_dict = row2dict(episode, Episode) episode_dict['bangumi'] = row2dict(bangumi, Bangumi) episode_dict['bangumi']['cover'] = utils.generate_cover_link(bangumi) utils.process_bangumi_dict(bangumi, episode_dict['bangumi']) episode_dict['thumbnail'] = utils.generate_thumbnail_link(episode, bangumi) utils.process_episode_dict(episode, episode_dict) if watch_progress is not None: episode_dict['watch_progress'] = row2dict(watch_progress, WatchProgress) if episode.status == Episode.STATUS_DOWNLOADED: episode_dict['video_files'] = [] video_file_list = session.query(VideoFile).filter(VideoFile.episode_id == episode_id).all() for video_file in video_file_list: if video_file.status != VideoFile.STATUS_DOWNLOADED: continue video_file_dict = row2dict(video_file, VideoFile) video_file_dict['url'] = utils.generate_video_link(str(bangumi.id), video_file.file_path) episode_dict['video_files'].append(video_file_dict) return json_resp(episode_dict) except NoResultFound: raise ClientError(ClientError.NOT_FOUND, 404) finally: SessionManager.Session.remove()
def get_bangumi(self, id): try: session = SessionManager.Session() bangumi = session.query(Bangumi).\ options(joinedload(Bangumi.episodes).joinedload(Episode.thumbnail_image)).\ options(joinedload(Bangumi.cover_image)). \ options(joinedload(Bangumi.created_by)). \ options(joinedload(Bangumi.maintained_by)). \ filter(Bangumi.id == id).\ filter(Bangumi.delete_mark == None).\ one() episodes = [] for episode in bangumi.episodes: if episode.delete_mark is not None: continue eps = row2dict(episode, Episode) eps['thumbnail'] = utils.generate_thumbnail_link( episode, bangumi) utils.process_episode_dict(episode, eps) episodes.append(eps) bangumi_dict = row2dict(bangumi, Bangumi) bangumi_dict['episodes'] = episodes utils.process_bangumi_dict(bangumi, bangumi_dict) self.__process_user_obj_in_bangumi(bangumi, bangumi_dict) bangumi_dict['cover'] = utils.generate_cover_link(bangumi) return json_resp({'data': bangumi_dict}) except NoResultFound: raise ClientError(ClientError.NOT_FOUND, 404) except Exception as exception: raise exception finally: SessionManager.Session.remove()
def get_bangumi(self, id): try: session = SessionManager.Session() bangumi = session.query(Bangumi).\ options(joinedload(Bangumi.episodes).joinedload(Episode.thumbnail_image)).\ options(joinedload(Bangumi.cover_image)). \ options(joinedload(Bangumi.created_by)). \ options(joinedload(Bangumi.maintained_by)). \ filter(Bangumi.id == id).\ filter(Bangumi.delete_mark == None).\ one() episodes = [] for episode in bangumi.episodes: if episode.delete_mark is not None: continue eps = row2dict(episode, Episode) eps['thumbnail'] = utils.generate_thumbnail_link(episode, bangumi) utils.process_episode_dict(episode, eps) episodes.append(eps) bangumi_dict = row2dict(bangumi, Bangumi) bangumi_dict['episodes'] = episodes utils.process_bangumi_dict(bangumi, bangumi_dict) self.__process_user_obj_in_bangumi(bangumi, bangumi_dict) bangumi_dict['cover'] = utils.generate_cover_link(bangumi) return json_resp({'data': bangumi_dict}) except NoResultFound: raise ClientError(ClientError.NOT_FOUND, 404) except Exception as exception: raise exception finally: SessionManager.Session.remove()
def my_favorites(self, user_id, status=None): session = SessionManager.Session() try: q = session.query(Favorites, Bangumi).\ join(Bangumi).\ options(joinedload(Bangumi.cover_image)).\ filter(Bangumi.delete_mark == None).\ filter(Favorites.user_id == user_id) if status is not None: result = q.filter(Favorites.status == status).\ order_by(desc(Favorites.update_time)).all() else: result = q.order_by(desc(Favorites.update_time)).all() bangumi_id_list = [bangumi.id for favorite, bangumi in result] # print 'bangumi_id_list length: %d' % len(bangumi_id_list) if len(bangumi_id_list) == 0: return json_resp({'data': [], 'status': 0}) # query all episode for each favorite that was latest updated. latest_eps_update_time = session.query(func.max(Episode.update_time), Episode.bangumi_id).\ filter(Episode.status == Episode.STATUS_DOWNLOADED).\ filter(Episode.bangumi_id.in_(bangumi_id_list)).\ group_by(Episode.bangumi_id).\ all() # subquery for watch_progress watch_progress = session.query(WatchProgress.episode_id).\ filter(WatchProgress.user_id == user_id).\ filter(WatchProgress.bangumi_id.in_(bangumi_id_list)) episode_aggregation = session.query(func.count(Episode.id), Episode.bangumi_id).\ filter(Episode.status == Episode.STATUS_DOWNLOADED).\ filter(Episode.bangumi_id.in_(bangumi_id_list)).\ filter(~Episode.id.in_(watch_progress)).\ group_by(Episode.bangumi_id).\ all() bangumi_dict_list = [] for fav, bgm in result: bangumi_dict = row2dict(bgm, Bangumi) bangumi_dict['favorite_status'] = fav.status bangumi_dict['favorite_update_time'] = fav.update_time bangumi_dict['favorite_check_time'] = fav.check_time bangumi_dict['cover'] = utils.generate_cover_link(bangumi) utils.process_bangumi_dict(bgm, bangumi_dict) for unwatched_count, bangumi_id in episode_aggregation: if bangumi_id == bgm.id: bangumi_dict['unwatched_count'] = unwatched_count break for episode_time, bangumi_id in latest_eps_update_time: if bangumi_id == bgm.id: bangumi_dict['eps_update_time'] = episode_time bangumi_dict_list.append(bangumi_dict) return json_resp({'data': bangumi_dict_list, 'status': 0}) finally: SessionManager.Session.remove()