def get(self, show_id, session): """ Get episodes by show ID """ args = entity_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 descending = sort_order == 'desc' start = per_page * (page - 1) stop = start + per_page kwargs = { 'start': start, 'stop': stop, 'descending': descending, 'session': session } try: show = db.show_by_id(show_id, session=session) except NoResultFound: raise NotFoundError('show with ID %s not found' % show_id) total_items = db.show_episodes(show, count=True, session=session) if not total_items: return jsonify([]) episodes = [ episode.to_dict() for episode in db.show_episodes(show, **kwargs) ] total_pages = int(ceil(total_items / float(per_page))) if total_pages < page and total_pages != 0: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(episodes)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(episodes) # Add link header to response rsp.headers.extend(pagination) # Add series ID header rsp.headers.extend({'Series-ID': show_id}) return rsp
def get(self, session=None): """ List all rejected entries """ args = rejected_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 descending = sort_order == 'desc' # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page kwargs = { 'start': start, 'stop': stop, 'descending': descending, 'sort_by': sort_by, 'session': session, } total_items = db.get_rejected(session, count=True) if not total_items: return jsonify([]) failed_entries = [ rejected_entry_to_dict(reject) for reject in db.get_rejected(**kwargs) ] total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(failed_entries)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(failed_entries) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, session=None): """ List all failed entries """ args = failed_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] if sort_by == 'failure_time': sort_by = 'tof' # Handle max size limit if per_page > 100: per_page = 100 descending = sort_order == 'desc' # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page kwargs = { 'start': start, 'stop': stop, 'descending': descending, 'sort_by': sort_by, 'session': session } total_items = get_failures(session, count=True) if not total_items: return jsonify([]) failed_entries = [failed.to_dict() for failed in get_failures(**kwargs)] total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(failed_entries)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(failed_entries) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, list_id, session=None): """ Get entries by list ID """ try: list = el.get_list_by_id(list_id=list_id, session=session) except NoResultFound: raise NotFoundError('list_id %d does not exist' % list_id) args = entries_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page descending = sort_order == 'desc' kwargs = { 'start': start, 'stop': stop, 'list_id': list_id, 'order_by': sort_by, 'descending': descending, 'session': session } total_items = list.entries.count() if not total_items: return jsonify([]) log.debug('entry lists entries count is %d', total_items) entries = [entry.to_dict() for entry in el.get_entries_by_list_id(**kwargs)] # Total number of pages total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(len(entries), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify(entries) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, session=None): """ List of previously accepted entries """ args = history_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Hard limit results per page to 100 if per_page > 100: per_page = 100 # Filter param task = args['task'] # Build query query = session.query(db.History) if task: query = query.filter(db.History.task == task) total_items = query.count() if not total_items: return jsonify([]) total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) start = (page - 1) * per_page finish = start + per_page # Choose sorting order order = desc if sort_order == 'desc' else asc # Get items try: items = query.order_by(order(getattr(db.History, sort_by))).slice( start, finish) except AttributeError as e: raise BadRequest(str(e)) # Actual results in page actual_size = min(items.count(), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify([item.to_dict() for item in items]) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, list_id, session=None): """ Get entries by list ID """ try: list = db.get_list_by_id(list_id=list_id, session=session) except NoResultFound: raise NotFoundError('list_id %d does not exist' % list_id) args = entries_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page descending = sort_order == 'desc' kwargs = { 'start': start, 'stop': stop, 'list_id': list_id, 'order_by': sort_by, 'descending': descending, 'session': session, } total_items = list.entries.count() if not total_items: return jsonify([]) log.debug('entry lists entries count is %d', total_items) entries = [entry.to_dict() for entry in db.get_entries_by_list_id(**kwargs)] # Total number of pages total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(len(entries), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify(entries) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, show_id, session): """ Get episodes by show ID """ args = episode_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 descending = sort_order == 'desc' start = per_page * (page - 1) stop = start + per_page kwargs = { 'start': start, 'stop': stop, 'descending': descending, 'session': session } try: show = series.show_by_id(show_id, session=session) except NoResultFound: raise NotFoundError('show with ID %s not found' % show_id) total_items = series.show_episodes(show, count=True, session=session) if not total_items: return jsonify([]) episodes = [episode.to_dict() for episode in series.show_episodes(show, **kwargs)] total_pages = int(ceil(total_items / float(per_page))) if total_pages < page and total_pages != 0: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(episodes)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(episodes) # Add link header to response rsp.headers.extend(pagination) # Add series ID header rsp.headers.extend({'Series-ID': show_id}) return rsp
def get(self, session=None): """ List of previously accepted entries """ args = history_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Hard limit results per page to 100 if per_page > 100: per_page = 100 # Filter param task = args['task'] # Build query query = session.query(db.History) if task: query = query.filter(db.History.task == task) total_items = query.count() if not total_items: return jsonify([]) total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) start = (page - 1) * per_page finish = start + per_page # Choose sorting order order = desc if sort_order == 'desc' else asc # Get items try: items = query.order_by(order(getattr(db.History, sort_by))).slice(start, finish) except AttributeError as e: raise BadRequest(str(e)) # Actual results in page actual_size = min(items.count(), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify([item.to_dict() for item in items]) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, list_id, session=None): """ Get movies by list ID """ args = movies_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] start = per_page * (page - 1) stop = start + per_page descending = bool(sort_order == 'desc') kwargs = { 'start': start, 'stop': stop, 'list_id': list_id, 'order_by': sort_by, 'descending': descending, 'session': session } try: ml.get_list_by_id(list_id=list_id, session=session) except NoResultFound: raise NotFoundError('list_id %d does not exist' % list_id) total_items = ml.get_movies_by_list_id(count=True, **kwargs) if not total_items: return jsonify([]) movies = [ movie.to_dict() for movie in ml.get_movies_by_list_id(**kwargs) ] total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(len(movies), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify(movies) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, list_id, session=None): """ Get movies by list ID """ args = movies_parser.parse_args() # Pagination and sorting params page = args["page"] per_page = args["per_page"] sort_by = args["sort_by"] sort_order = args["order"] start = per_page * (page - 1) stop = start + per_page descending = sort_order == "desc" kwargs = { "start": start, "stop": stop, "list_id": list_id, "order_by": sort_by, "descending": descending, "session": session, } try: list = ml.get_list_by_id(list_id=list_id, session=session) except NoResultFound: raise NotFoundError("list_id %d does not exist" % list_id) total_items = list.movies.count() if not total_items: return jsonify([]) movies = [movie.to_dict() for movie in ml.get_movies_by_list_id(**kwargs)] total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError("page %s does not exist" % page) # Actual results in page actual_size = min(len(movies), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify(movies) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, list_id, session=None): """ Get movies by list ID """ args = movies_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] start = per_page * (page - 1) stop = start + per_page descending = bool(sort_order == 'desc') kwargs = { 'start': start, 'stop': stop, 'list_id': list_id, 'order_by': sort_by, 'descending': descending, 'session': session } try: ml.get_list_by_id(list_id=list_id, session=session) except NoResultFound: raise NotFoundError('list_id %d does not exist' % list_id) total_items = ml.get_movies_by_list_id(count=True, **kwargs) if not total_items: return jsonify([]) movies = [movie.to_dict() for movie in ml.get_movies_by_list_id(**kwargs)] total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(len(movies), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify(movies) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, session=None): """ Get list of registered plugins """ args = plugins_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page plugin_list = [] try: for plugin in get_plugins(phase=args['phase'], interface=args['interface']): p = plugin_to_dict(plugin) if args['include_schema']: p['schema'] = plugin.schema plugin_list.append(p) except ValueError as e: raise BadRequest(str(e)) total_items = len(plugin_list) sliced_list = plugin_list[start:stop] # Total number of pages total_pages = int(ceil(total_items / float(per_page))) if page > total_pages and total_pages != 0: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(sliced_list)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) rsp = jsonify(sliced_list) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, session=None): """List all pending entries""" args = pending_parser.parse_args() # Filter params task_name = args.get('task_name') approved = args.get('approved') # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 descending = sort_order == 'desc' # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page kwargs = { 'task_name': task_name, 'approved': approved, 'start': start, 'stop': stop, 'descending': descending, 'sort_by': sort_by, 'session': session, } total_items = session.query(db.PendingEntry).count() if not total_items: return jsonify([]) pending_entries = [pending.to_dict() for pending in db.list_pending_entries(**kwargs)] total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(pending_entries)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(pending_entries) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, show_id, ep_id, session): """ Get all episodes releases by show ID and episode ID """ try: series.show_by_id(show_id, session=session) except NoResultFound: raise NotFoundError('show with ID %s not found' % show_id) try: episode = series.episode_by_id(ep_id, session) except NoResultFound: raise NotFoundError('episode with ID %s not found' % ep_id) if not series.episode_in_show(show_id, ep_id): raise BadRequest('episode with id %s does not belong to show %s' % (ep_id, show_id)) args = release_list_parser.parse_args() # Filter params downloaded = args.get('downloaded') # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] descending = bool(sort_order == 'desc') # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page kwargs = { 'downloaded': downloaded, 'start': start, 'stop': stop, 'sort_by': sort_by, 'descending': descending, 'episode': episode, 'session': session } # Total number of releases total_items = series.get_releases(count=True, **kwargs) # Release items release_items = [ release.to_dict() for release in series.get_releases(**kwargs) ] # Total number of pages total_pages = int(ceil(total_items / float(per_page))) if total_pages < page and total_pages != 0: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(release_items)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(release_items) # Add link header to response rsp.headers.extend(pagination) # Add Series-ID and Episode-ID headers rsp.headers.extend({'Series-ID': show_id, 'Episode-ID': ep_id}) return rsp
def get(self, session=None): """ List existing shows """ args = series_list_parser.parse_args() # Filter params configured = args['in_config'] premieres = args['premieres'] status = args['status'] days = args['days'] # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 descending = bool(sort_order == 'desc') # Data params lookup = args.get('lookup') begin = args.get('begin') latest = args.get('latest') start = per_page * (page - 1) stop = start + per_page kwargs = { 'configured': configured, 'premieres': premieres, 'status': status, 'days': days, 'start': start, 'stop': stop, 'sort_by': sort_by, 'descending': descending, 'session': session } total_items = series.get_series_summary(count=True, **kwargs) if not total_items: return jsonify([]) series_list = [] for s in series.get_series_summary(**kwargs): series_object = series_details(s, begin, latest) series_list.append(series_object) # Total number of pages total_pages = int(ceil(total_items / float(per_page))) if total_pages < page and total_pages != 0: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(series_list)) # Do relevant lookups if lookup: api_client = APIClient() for endpoint in lookup: base_url = '/%s/series/' % endpoint for show in series_list: pos = series_list.index(show) series_list[pos].setdefault('lookup', {}) url = base_url + show['name'] + '/' result = api_client.get_endpoint(url) series_list[pos]['lookup'].update({endpoint: result}) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(series_list) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, show_id, ep_id, session): """ Get all episodes releases by show ID and episode ID """ try: series.show_by_id(show_id, session=session) except NoResultFound: raise NotFoundError("show with ID %s not found" % show_id) try: episode = series.episode_by_id(ep_id, session) except NoResultFound: raise NotFoundError("episode with ID %s not found" % ep_id) if not series.episode_in_show(show_id, ep_id): raise BadRequest("episode with id %s does not belong to show %s" % (ep_id, show_id)) args = release_list_parser.parse_args() # Filter params downloaded = args.get("downloaded") # Pagination and sorting params page = args["page"] per_page = args["per_page"] sort_by = args["sort_by"] sort_order = args["order"] descending = bool(sort_order == "desc") # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page kwargs = { "downloaded": downloaded, "start": start, "stop": stop, "sort_by": sort_by, "descending": descending, "episode": episode, "session": session, } # Total number of releases total_items = series.get_releases(count=True, **kwargs) # Release items release_items = [release.to_dict() for release in series.get_releases(**kwargs)] # Total number of pages total_pages = int(ceil(total_items / float(per_page))) if total_pages < page and total_pages != 0: raise NotFoundError("page %s does not exist" % page) # Actual results in page actual_size = min(per_page, len(release_items)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(release_items) # Add link header to response rsp.headers.extend(pagination) # Add Series-ID and Episode-ID headers rsp.headers.extend({"Series-ID": show_id, "Episode-ID": ep_id}) return rsp
def get(self, session): """ Search for seen entries """ args = seen_search_parser.parse_args() # Filter params value = args['value'] local = args['local'] # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 descending = sort_order == 'desc' # Unquotes and prepares value for DB lookup if value: value = unquote(value) value = '%{0}%'.format(value) start = per_page * (page - 1) stop = start + per_page kwargs = { 'value': value, 'status': local, 'stop': stop, 'start': start, 'order_by': sort_by, 'descending': descending, 'session': session, } total_items = db.search(count=True, **kwargs) if not total_items: return jsonify([]) raw_seen_entries_list = db.search(**kwargs).all() converted_seen_entry_list = [entry.to_dict() for entry in raw_seen_entries_list] # Total number of pages total_pages = int(ceil(total_items / float(per_page))) # Actual results in page actual_size = min(len(converted_seen_entry_list), per_page) # Invalid page request if page > total_pages and total_pages != 0: raise NotFoundError('page %s does not exist' % page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify(converted_seen_entry_list) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, session=None): """ List existing shows """ args = series_list_parser.parse_args() # Filter params configured = args["in_config"] premieres = args["premieres"] status = args["status"] days = args["days"] # Pagination and sorting params page = args["page"] per_page = args["per_page"] sort_by = args["sort_by"] sort_order = args["order"] # Handle max size limit if per_page > 100: per_page = 100 descending = bool(sort_order == "desc") # Data params lookup = args.get("lookup") begin = args.get("begin") latest = args.get("latest") start = per_page * (page - 1) stop = start + per_page kwargs = { "configured": configured, "premieres": premieres, "status": status, "days": days, "start": start, "stop": stop, "sort_by": sort_by, "descending": descending, "session": session, } total_items = series.get_series_summary(count=True, **kwargs) if not total_items: return jsonify([]) series_list = [] for s in series.get_series_summary(**kwargs): series_object = series_details(s, begin, latest) series_list.append(series_object) # Total number of pages total_pages = int(ceil(total_items / float(per_page))) if total_pages < page and total_pages != 0: raise NotFoundError("page %s does not exist" % page) # Actual results in page actual_size = min(per_page, len(series_list)) # Do relevant lookups if lookup: api_client = APIClient() for endpoint in lookup: base_url = "/%s/series/" % endpoint for show in series_list: pos = series_list.index(show) series_list[pos].setdefault("lookup", {}) url = base_url + show["name"] + "/" result = api_client.get_endpoint(url) series_list[pos]["lookup"].update({endpoint: result}) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(series_list) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, task_id, session=None): """Get task executions by ID""" try: task = session.query(StatusTask).filter(StatusTask.id == task_id).one() except NoResultFound: raise NotFoundError('task status with id %d not found' % task_id) args = executions_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Filter params succeeded = args.get('succeeded') produced = args.get('produced') start_date = args.get('start_date') end_date = args.get('end_date') if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page descending = sort_order == 'desc' kwargs = { 'start': start, 'stop': stop, 'task_id': task_id, 'order_by': sort_by, 'descending': descending, 'succeeded': succeeded, 'produced': produced, 'start_date': start_date, 'end_date': end_date, 'session': session } total_items = task.executions.count() if not total_items: return jsonify([]) executions = [e.to_dict() for e in get_executions_by_task_id(**kwargs)] total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(len(executions), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify(executions) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, session=None): """ List existing shows """ args = series_list_parser.parse_args() # Filter params configured = args['in_config'] premieres = args['premieres'] status = args['status'] days = args['days'] # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 descending = sort_order == 'desc' # Data params lookup = args.get('lookup') begin = args.get('begin') latest = args.get('latest') start = per_page * (page - 1) stop = start + per_page kwargs = { 'configured': configured, 'premieres': premieres, 'status': status, 'days': days, 'start': start, 'stop': stop, 'sort_by': sort_by, 'descending': descending, 'session': session } total_items = series.get_series_summary(count=True, **kwargs) if not total_items: return jsonify([]) series_list = [] for s in series.get_series_summary(**kwargs): series_object = series_details(s, begin, latest) series_list.append(series_object) # Total number of pages total_pages = int(ceil(total_items / float(per_page))) if total_pages < page and total_pages != 0: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(series_list)) # Do relevant lookups if lookup: api_client = APIClient() for endpoint in lookup: base_url = '/%s/series/' % endpoint for show in series_list: pos = series_list.index(show) series_list[pos].setdefault('lookup', {}) url = base_url + show['name'] + '/' result = api_client.get_endpoint(url) series_list[pos]['lookup'].update({endpoint: result}) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(series_list) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, task_id, session=None): """Get task executions by ID""" try: task = session.query( db.StatusTask).filter(db.StatusTask.id == task_id).one() except NoResultFound: raise NotFoundError('task status with id %d not found' % task_id) args = executions_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Filter params succeeded = args.get('succeeded') produced = args.get('produced') start_date = args.get('start_date') end_date = args.get('end_date') if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page descending = sort_order == 'desc' kwargs = { 'start': start, 'stop': stop, 'task_id': task_id, 'order_by': sort_by, 'descending': descending, 'succeeded': succeeded, 'produced': produced, 'start_date': start_date, 'end_date': end_date, 'session': session, } total_items = task.executions.count() if not total_items: return jsonify([]) executions = [ e.to_dict() for e in db.get_executions_by_task_id(**kwargs) ] total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(len(executions), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify(executions) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, session=None): """Get status tasks""" args = tasks_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Additional data include_execution = args.get('include_execution') if per_page > 100: log.debug('per_page is higher than max value of 100, setting 100') per_page = 100 start = per_page * (page - 1) stop = start + per_page descending = sort_order == 'desc' kwargs = { 'start': start, 'stop': stop, 'order_by': sort_by, 'descending': descending, 'session': session, } total_items = session.query(db.StatusTask).count() log.debug('db has a total of %s status tasks', total_items) if not total_items: return jsonify([]) db_status_tasks = db.get_status_tasks(**kwargs) total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(len(db_status_tasks), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) status_tasks = [] for task in db_status_tasks: st_task = task.to_dict() if include_execution: execution = task.executions.order_by( db.TaskExecution.start.desc()).first() st_task['last_execution'] = execution.to_dict( ) if execution else {} status_tasks.append(st_task) # Create response rsp = jsonify(status_tasks) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, session): """ Search for seen entries """ args = seen_search_parser.parse_args() # Filter params value = args['value'] local = args['local'] # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Handle max size limit if per_page > 100: per_page = 100 descending = sort_order == 'desc' # Unquotes and prepares value for DB lookup if value: value = unquote(value) value = '%{0}%'.format(value) start = per_page * (page - 1) stop = start + per_page kwargs = { 'value': value, 'status': local, 'stop': stop, 'start': start, 'order_by': sort_by, 'descending': descending, 'session': session, } total_items = db.search(count=True, **kwargs) if not total_items: return jsonify([]) raw_seen_entries_list = db.search(**kwargs).all() converted_seen_entry_list = [ entry.to_dict() for entry in raw_seen_entries_list ] # Total number of pages total_pages = int(ceil(total_items / float(per_page))) # Actual results in page actual_size = min(len(converted_seen_entry_list), per_page) # Invalid page request if page > total_pages and total_pages != 0: raise NotFoundError('page %s does not exist' % page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Create response rsp = jsonify(converted_seen_entry_list) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, session=None): """Get status tasks""" args = tasks_parser.parse_args() # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] # Additional data include_execution = args.get('include_execution') if per_page > 100: log.debug('per_page is higher than max value of 100, setting 100') per_page = 100 start = per_page * (page - 1) stop = start + per_page descending = sort_order == 'desc' kwargs = { 'start': start, 'stop': stop, 'order_by': sort_by, 'descending': descending, 'session': session } total_items = session.query(StatusTask).count() log.debug('db has a total of %s status tasks', total_items) if not total_items: return jsonify([]) db_status_tasks = get_status_tasks(**kwargs) total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(len(db_status_tasks), per_page) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) status_tasks = [] for task in db_status_tasks: st_task = task.to_dict() if include_execution: execution = task.executions.order_by(TaskExecution.start.desc()).first() st_task['last_execution'] = execution.to_dict() if execution else {} status_tasks.append(st_task) # Create response rsp = jsonify(status_tasks) # Add link header to response rsp.headers.extend(pagination) return rsp
def get(self, show_id, ep_id, session): """ Get all episodes releases by show ID and episode ID """ try: series.show_by_id(show_id, session=session) except NoResultFound: raise NotFoundError('show with ID %s not found' % show_id) try: episode = series.episode_by_id(ep_id, session) except NoResultFound: raise NotFoundError('episode with ID %s not found' % ep_id) if not series.episode_in_show(show_id, ep_id): raise BadRequest('episode with id %s does not belong to show %s' % (ep_id, show_id)) args = release_list_parser.parse_args() # Filter params downloaded = args.get('downloaded') # Pagination and sorting params page = args['page'] per_page = args['per_page'] sort_by = args['sort_by'] sort_order = args['order'] descending = sort_order == 'desc' # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page kwargs = { 'downloaded': downloaded, 'start': start, 'stop': stop, 'sort_by': sort_by, 'descending': descending, 'episode': episode, 'session': session } # Total number of releases total_items = series.get_releases(count=True, **kwargs) # Release items release_items = [release.to_dict() for release in series.get_releases(**kwargs)] # Total number of pages total_pages = int(ceil(total_items / float(per_page))) if total_pages < page and total_pages != 0: raise NotFoundError('page %s does not exist' % page) # Actual results in page actual_size = min(per_page, len(release_items)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(release_items) # Add link header to response rsp.headers.extend(pagination) # Add Series-ID and Episode-ID headers rsp.headers.extend({'Series-ID': show_id, 'Episode-ID': ep_id}) return rsp
def get(self, session=None): """List all pending entries""" args = pending_parser.parse_args() # Filter params task_name = args.get("task_name") approved = args.get("approved") # Pagination and sorting params page = args["page"] per_page = args["per_page"] sort_by = args["sort_by"] sort_order = args["order"] # Handle max size limit if per_page > 100: per_page = 100 descending = sort_order == "desc" # Handle max size limit if per_page > 100: per_page = 100 start = per_page * (page - 1) stop = start + per_page kwargs = { "task_name": task_name, "approved": approved, "start": start, "stop": stop, "descending": descending, "sort_by": sort_by, "session": session, } total_items = session.query(PendingEntry).count() if not total_items: return jsonify([]) pending_entries = [pending.to_dict() for pending in list_pending_entries(**kwargs)] total_pages = int(ceil(total_items / float(per_page))) if page > total_pages: raise NotFoundError("page %s does not exist" % page) # Actual results in page actual_size = min(per_page, len(pending_entries)) # Get pagination headers pagination = pagination_headers(total_pages, total_items, actual_size, request) # Created response rsp = jsonify(pending_entries) # Add link header to response rsp.headers.extend(pagination) return rsp