def runs_view(page):
"""
The runs view page
Returns:
a rendered runs view template
"""
run_type = request.args.get("run_type")
run_status = request.args.get("run_status")
num_pending = model.Run.query.filter_by(finished_execing_time=None).count()
if run_type == "submissions":
run_query = model.Run.query.filter_by(is_submission=True)
elif run_type == "tests":
run_query = model.Run.query.filter_by(is_submission=False)
else:
run_query = model.Run.query
if run_status == "judged":
run_query = run_query.filter(
model.Run.finished_execing_time is not None)
elif run_status == "pending":
run_query = run_query.filter_by(finished_execing_time=None)
runs = util.paginate(run_query.order_by(model.Run.submit_time.desc()),
page, 30)
return render_template(
"runs/view.html",
runs=runs,
run_type=run_type,
run_status=run_status,
num_pending=num_pending,
)
def questions(page_number):
if request.args.get('ordering'):
order_by, order_direction = request.args.get('ordering').split('-')
else:
order_by, order_direction = 'created', 'DESC'
text_search = request.args.get('text_search') or ''
tag_search = request.args.get('tag_choice_id') or ''
if request.args.get('questions_per_page'):
questions_per_page = int(request.args.get('questions_per_page'))
else:
questions_per_page = 5
questions = db_handler.get_questions(order_by=order_by,
order_direction=order_direction,
text_search=text_search,
tag_search=tag_search)
page_numbers = range(1, math.ceil(len(questions) / questions_per_page) + 1)
questions = paginate(questions, page_number, questions_per_page)
existing_tags = db_handler.get_existing_tags()
return render_template(
'questions.html',
questions=questions,
ordering=request.args.get('ordering') or 'created-DESC',
text_search=text_search,
tag_search=tag_search,
page_number=int(page_number),
page_numbers=page_numbers,
questions_per_page=questions_per_page,
query_string=request.query_string.decode("utf-8"),
existing_tags=existing_tags,
)
def delete_history(self, max_id=None, full=False):
if full:
self.client(DeleteHistoryRequest(self._peer, max_id or 2147483647))
else:
for m in paginate(
self.client.iter_messages(self._peer, limit=10000), 100):
self.client.delete_messages(self._peer, m)
def contests_view(page):
"""
The contest view page
Returns:
a rendered contest view template
"""
contests = util.paginate(model.Contest.query, page, 30)
return render_template("contests/view.html", contests=contests)
def languages_view(page):
"""
The language view page
Returns:
a rendered language view template
"""
languages = util.paginate(model.Language.query, page, 30)
return render_template("language/view.html", languages=languages)
def problems_view(page):
"""
The problem view page
Returns:
a rendered problem view template
"""
problems = util.paginate(model.Problem.query, page, 30)
return render_template("problems/view.html", problems=problems)
def configurations_view(page):
"""
The config view page
Returns:
a rendered config view template
"""
config_query = model.Configuration.query
configs = util.paginate(
config_query.order_by(model.Configuration.category.asc()), page, 30
)
return render_template("configurations/view.html", configs=configs)
def users_view(page):
"""
The user view page
Returns:
a rendered user view template
"""
user_search = request.args.get("search")
user_role = request.args.get("user_role")
users_query = model.User.query
if user_search:
term = "%" + user_search + "%"
users_query = users_query.filter(
or_(model.User.name.ilike(term), model.User.username.ilike(term)))
if user_role and user_role != "all":
users_query = users_query.join(
model.User.user_roles).filter(model.UserRole.name == user_role)
users_pagination = util.paginate(users_query, page, 30)
users = users_pagination.items
metrics = {}
for user in users:
user_metrics = {}
run_query = model.Run.query.filter_by(user_id=user.id)
user_metrics["num_runs"] = run_query.count()
user_metrics["last_run"] = run_query.order_by(
model.Run.submit_time.desc()).limit(1).first()
metrics[user.id] = user_metrics
return render_template(
"users/view.html",
users_pagination=users_pagination,
users=users,
metrics=metrics,
user_role=user_role,
search=user_search,
)
def f(*args, **kw):
# check kw's
kw = validate_kw(kw, requires)
# optionally connect to the api
api = opt_connect(**kw)
# add defautls to kw's
kw = dict(kw.items() + default.items())
# if were not paginating simply
# run the function
if not kw['paginate']:
tweets = catch_err(func, api, **kw)
else:
tweets = paginate(func, api, **kw)
# optionally run concurrent
if kw['concurrent']:
return concurrent_yield(parse_tweet, tweets, **kw)
else:
return (parse_tweet(t) for t in tweets)
def f(*args, **kw):
# check kw's
kw = validate_kw(kw, requires)
# optionally connect to the api
api = opt_connect(**kw)
# add defautls to kw's
kw = dict(kw.items() + default.items())
# if were not paginating simply
# run the function
if not kw['paginate']:
tweets = catch_err(func, api, **kw)
else:
tweets = paginate(func, api, **kw)
# optionally run concurrent
if kw['concurrent']:
return concurrent_yield(parse_tweet, tweets, **kw)
else:
return (parse_tweet(t) for t in tweets)
def dashboard():
dashboard_template = jinja_env.get_template('dashboard.html')
# sort by date
date_order = request.args.get('date_order', 'desc', type=str)
# pagination
page = request.args.get('page', 1, type=int)
per_page = request.args.get('per_page', 10, type=int)
per_page = min(per_page, 50)
# filters
device = request.args.get('device', None, type=str)
confirm = request.args.get('confirm', None, type=int)
dicom_avai = request.args.get('dicom_avai', 0, type=int)
n_chambers = request.args.get('n_chambers', None, type=str)
# load stat data
overview, by_date_and_user = dicom_service.stat.stat_on_folder()
for row in overview:
if row['nchamber'] in ['LABEL', '-1']:
row['nchamber'] = None
device_list = list(set([x['device'] for x in overview]))
extract_url_and_filename(overview)
if dicom_avai:
overview = list(filter(lambda x: x['gif_url'] is not None, overview))
if device:
overview = list(filter(lambda x: x['device'] == device, overview))
if n_chambers == '-1':
overview = list(filter(lambda x: x['nchamber'] is None, overview))
elif n_chambers:
overview = list(filter(lambda x: x['nchamber'] == n_chambers,
overview))
if confirm is not None:
check_file_confirmation(overview)
overview = list(filter(lambda x: x['confirm'] == confirm, overview))
# sort and paginate
overview.sort(key=lambda x: x['date'], reverse=(date_order == 'desc'))
by_date_and_user.sort(key=lambda x: x['date'],
reverse=(date_order == 'desc'))
overview, current_page, pages = util.paginate(overview, page, per_page)
if confirm is None:
check_file_confirmation(overview)
return dashboard_template.render({
'data': (overview, by_date_and_user),
'selectable_data':
dict({
'devices': device_list,
}),
'filters':
dict({
'device': device,
'confirm': confirm,
'dicom_avai': dicom_avai,
'n_chambers': n_chambers,
}),
'pagination':
dict({
'current_page': current_page,
'per_page': per_page,
'pages': pages,
}),
'show_details':
request.args.get('show_details', False, type=bool),
'date_order':
date_order,
})
