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):
""" 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
