def most_viewed_recipes():
"""Sorting recipes based on views"""
filter_recipes = mongo.db.recipes.find({
"views": {
"$gt": -1
}
}).sort([("views", -1)])
page, per_page, offset = get_page_args(page_parameter='page',
per_page_parameter='per_page')
total_filter_recipes = filter_recipes.count()
recipes_fetched = filter_recipes.skip(
(page - 1) * ITEMS_PER_PAGE).limit(ITEMS_PER_PAGE)
pagination = Pagination(page=page,
per_page=ITEMS_PER_PAGE,
total=total_filter_recipes,
record_name='Recipes')
return render_template("orderingrecipes.html",
recipes=recipes_fetched,
cuisines=mongo.db.cuisines.find(),
allergens=mongo.db.allergens.find(),
page=page,
per_page=per_page,
pagination=pagination,
filter_text="MOST VIEWED")
def fw_state(state, sorting_key='_id', sorting_order="DESCENDING"):
if sorting_order == "ASCENDING":
sort_order = 1
elif sorting_order == "DESCENDING":
sort_order = -1
else:
raise RuntimeError()
current_sorting_key = sorting_key
current_sorting_order = sorting_order
db = app.lp.fireworks
q = {} if state == "total" else {"state": state}
q = _addq_FW(q)
fw_count = app.lp.get_fw_ids(query=q, count_only=True)
try:
page = int(request.args.get('page', 1))
except ValueError:
page = 1
rows = list(db.find(q, projection=["fw_id", "name", "created_on", "updated_on"]).sort(
[(sorting_key, sort_order)]).skip(
(page - 1) * PER_PAGE).limit(PER_PAGE))
pagination = Pagination(page=page, total=fw_count, record_name='fireworks',
per_page=PER_PAGE)
return render_template('fw_state.html', **locals())
def courseUpdate():
# 执行爬虫函数，获取更新的课程
# docrawler()
allcourses = [] # 存放课程名、学校名、专业名和课程详情
newcourse = newCourse.query.all()
# 获取更新的课程
for i in newcourse:
course = Course.query.filter(i.CID == Course.CID).first()
majors = Majors.query.filter(course.MID == Majors.MID).all()
for j in majors:
allcourses.append({
'cid': course.CID,
'name': course.Cname,
'school': j.Sname,
'major': j.Mname,
'info': course.Cinfo
})
user_id = session.get('user_id')
id = 0
if user_id:
id = user_id
total = len(allcourses)
PER_PAGE = 10 # 每页列表行数
page = request.args.get(get_page_parameter(), type=int,
default=1) # 获取页码，默认为第一页
start = (page - 1) * PER_PAGE # 每一页开始位置
end = start + PER_PAGE # 每一页结束位置
pagination = Pagination(bs_version=3, page=page,
total=total) # Bootstrap的版本，默认为3
courses = allcourses[start:end] # 进行切片处理
context = {'pagination': pagination, 'courses': courses, 'id': id}
return render_template('course.html', user_id=user_id, **context)
def node_logs(node_id, page=1):
node = Node.query.filter(Node.id == node_id).first_or_404()
status_logs = StatusLog.query.filter_by(node=node)
status_logs = get_paginate_options(
request,
StatusLog, ('line', 'message', 'severity', 'filename'),
existing_query=status_logs,
page=page,
max_pp=50,
default_sort='desc')
pagination = Pagination(page=page,
per_page=status_logs.per_page,
total=status_logs.total,
alignment='center',
show_single_page=False,
record_name='status logs',
bs_version=3)
return render_template('logs.html',
node=node,
status_logs=status_logs.items,
pagination=pagination)
def page(table, p):
try:
model = get_model_by_tablename(table)
columns = get_columns(model)
# pagination
total_count = len(session.query(model).all())
pagination = Pagination(page=p, total=total_count, per_page=records_num, bs_version='4', href='{}',
alignment='center')
if p == 1:
data = session.query(model).order_by(model.index).limit(records_num)
elif 1 < p < pagination.total_pages + 1:
data = session.query(model).order_by(model.index).limit(records_num).offset(records_num * (p - 1))
else:
return redirect(url_for('page', table=table, p=1))
context = {
'table': table,
'data': data,
'columns': columns,
'pagination': pagination
}
return render_template('table.html', **context)
except Exception as e:
logger.error('Error occurred. Details: {}'.format(e))
abort(500)
def get_equipment():
shop = mongo.db.equipment
offset = int(
request.args.get('offset')) if request.args.get('offset') else 1
limit = int(request.args.get('limit')) if request.args.get('offset') else 8
page = int(request.args.get('page', 2))
total = mongo.db.equipment.count()
per_page = limit
pagination = get_pagination(
page=page,
per_page=per_page, #results per page
total=total, #total number of results
format_total=True, #format total. example 1,024
format_number=True, #turn on format flag
record_name='repositories', #provide context
)
starting_id = shop.find().sort('_id', pymongo.ASCENDING)
last_id = starting_id[offset]['_id']
equipment = shop.find({
'_id': {
'$gte': last_id
}
}).sort('item_name', pymongo.ASCENDING).limit(limit)
next_url = '/equipment?limit=' + str(limit) + '&offset=' + str(offset +
limit)
prev_url = '/equipment?limit=' + str(limit) + '&offset=' + str(offset -
limit)
pagination = Pagination(page=page, limit=limit)
#return jsonify ({'result': output, 'prev_url': '', 'next_url': ''})
return render_template('equipment.html',
equipment=equipment,
pagination=pagination)
def get_page(search_d):
form = SearchForm()
form.c_project.choices = [('','')]+[(a.project,a.project) for a in AllProject.query.all()]
search_d = eval(search_d)
if search_d['genre']=='':
search_d['genre']="A类,B类,C类"
all_search_cus = Customer.query.order_by(Customer.pink_time.desc()).filter(
Customer.c_name.like('%'+search_d['c_name']+'%') if search_d['c_name'] is not '' else "",
Customer.phone.like('%'+search_d['phone'].strip()+'%') if search_d['phone'] is not '' else "",
Customer.project.like('%'+search_d['project']+'%') if search_d['project'] is not '' else "",
Customer.genre.in_(search_d['genre'].split(',')) if search_d['genre'] is not '' else "",
Customer.date_time.like('%'+search_d['date_time']+'%') if search_d['date_time'] is not '' else "",
Customer.sale_name==current_user.username
)
per_page = 10
page = request.args.get(get_page_parameter(), type=int, default=1)
start = (page-1)*per_page
end = start+per_page
search_cus = all_search_cus.slice(start,end)
biaoji_l = []
for search in search_cus:
comments = Comment.query.filter_by(c_name_id=search.id)
if comments.first():
for comment in comments:
if ReadComment.query.filter_by(user=current_user.username,comment_id = comment.id).first() == None:
biaoji = '未读'
break
else:
biaoji = '已读'
biaoji_l.append(biaoji)
else:
biaoji = '无评价'
biaoji_l.append(biaoji)
time_l,school_l,time_zj = last_time(search_cus)
pagination = Pagination(bs_version=3,page=page, total=all_search_cus.count())
return render_template('search.html',search_cus = search_cus,form = form,username=current_user.username,search_d = search_d,pagination = pagination,biaoji_l = biaoji_l,time_l = time_l)
def recherche():
"""
Route permettant d'afficher les articles correspondants au mot rentré par l'utilisateur
:return: template recherche.html
:rtype: template
"""
# récupération du mot clef rentré par l'utilisateur avec la méthode get afin d'éviter un if trop long
motclef = request.args.get("keyword", None)
# initialisation du resultat en une liste vide (afin d'avoir une liste vide comme résultat par défaut)
resultats= []
# vérification de l'existence d'un mot clef
if motclef:
# récupération sous la forme d'une liste de tout les articles pour lesquels le mot clef est contenu dans
# l'attribut texte, trié par date de parution
resultats= Article.query.filter(Article.article_texte.like("%{}%".format(motclef))).order_by(
Article.article_numJournal.asc()).all()
#création de la pagination
page, per_page, offset = get_page_args(page_parameter='page',
per_page_parameter='per_page')
pagination_resultats = get_index(resultats, offset=offset, per_page=per_page)
pagination = Pagination(page=page, per_page=per_page, total=len(resultats))
return render_template("pages/recherche.html", resultats=pagination_resultats, page=page, per_page=per_page,
pagination=pagination)
def view_invoices():
try:
page = int(request.args.get('page', 1))
except ValueError:
page = 1
if session['account_type'] == 'company':
invoices = Invoice.query.filter_by(owner_id=current_user.id).all()
title = 'View Invoices'
elif session['account_type'] == 'admin':
invoices = Invoice.query.filter_by(broker_id=None).all()
title = 'Assign Broker'
elif session['account_type'] == 'broker':
invoices = Broker.query.filter_by(id=current_user.id).first().invoices
invoices = list(filter(lambda inv: inv.processed == False or (
inv.processed == True and inv.manual_processing == True), invoices))
title = 'Process Invoices'
if len(invoices)==0:
flash('No new uploaded invoices!', 'danger')
return redirect(url_for('home'))
else:
i = (page-1)*2
li_items = invoices[i:i+2]
pagination = Pagination(page=page, per_page=2, total=len(invoices), record_name='items', css_framework='bootstrap4')
return render_template('view_invoices.html', title=title, userdetail=current_user, image_files=li_items,pagination=pagination)
def topchef():
page = request.args.get(get_page_parameter(), type=int, default=1)
results = []
results = db.session.query(
Recipe, Author, Ingredient,
Cuisine).join(Author).join(Ingredient).join(Cuisine).order_by(
Recipe.recipe_rating.desc()).all()
print(results)
#ordered_results = result_
page_size = len(results)
offset = (page - 1) * TOP_CHEF_PER_PAGE
pagination_results = get_results(offset, TOP_CHEF_PER_PAGE, results)
pagination = Pagination(page=page,
per_page=TOP_CHEF_PER_PAGE,
total=page_size,
css_framework='bootstrap3')
return render_template('topchef.html',
results=pagination_results,
page=page,
per_page=TOP_CHEF_PER_PAGE,
pagination=pagination)
def lieux():
"""
Route permettant l'affichage d'un index de lieux présentant tous les lieux mentionnés,, leurs occurences et un lien
vers chacun de ces articles.
:return: template index_lieu.html
:rtype: template
"""
# récupération de la table d'association articleHasLieu ainsi que les articles et lieux qui lui sont associé
association_Article_Lieu = db.session.query(articleHasLieu, Article, Lieu).join(Article).join(Lieu).all()
# on obtient une liste de tuple que l'on va restructurer pour former un dictionnaire ayant pour clé un lieu et
# pour valeurs tous les articles correspondants
index_lieu_article = {key: [v[2] for v in val] for key, val in
groupby(sorted(association_Article_Lieu, key=lambda ele: ele[1]), key=lambda ele: ele[3])}
# transformation du dictionnaire en liste de dictionnaire
index_lieu_article = [{k: v} for (k, v) in index_lieu_article.items()]
# création de la pagination
page, per_page, offset = get_page_args(page_parameter='page',
per_page_parameter='per_page')
# récupération de la portion de la liste concernant la page à afficher
pagination_index = get_index(index_lieu_article, offset=offset, per_page=per_page)
# définition de la pagination
pagination = Pagination(page=page, per_page=per_page, total=len(index_lieu_article))
return render_template("pages/index_lieu.html", list=index_lieu_article, page=page, per_page=per_page,
pagination=pagination)
def search():
# 从输入框中获取数据，数据默认为空
keyword = request.args.get('keyword', '')
if keyword == '':
# 如果输入框的内容为空则跳过不做处理
pass
page = request.args.get(get_page_parameter(), type = int, default = 1)
start = (page-1)*8
end = start + 8
category = request.args.get('category', 'post')
# 判断用户要在哪个指定区域查询(支持模糊搜索)
if category == 'user':
resultlist = FrontUser.query.whoosh_search(keyword, like=True).order_by(FrontUser.join_time.desc()).slice(start, end)
total = FrontUser.query.whoosh_search(keyword, like=True).count()
elif category == 'area':
resultlist = Area.query.whoosh_search(keyword, like=True).order_by(Area.number.desc()).slice(start, end)
total = Area.query.whoosh_search(keyword, like=True).count()
else:
resultlist = Post.query.whoosh_search(keyword, like=True).order_by(Post.create_time.desc()).slice(start, end)
total = Post.query.whoosh_search(keyword, like=True).count()
pagination = Pagination(bs_version=3, page=page, total = total, outer_window=0, inner_window=2)
return render_template('frontstage/front_search.html', resultlist=resultlist, keyword=keyword, total=total, category=category, pagination=pagination)
def profile_reviews():
# set flask paginate parameters for generating pages
page, per_page, offset = get_page_args(
page_parameter='page', per_page_parameter='per_page')
per_page = 3
offset = (page - 1) * per_page
# create a user variable to use when
# searching for the users mongodb reviews
user = session["user"]
# find a total game count for pagination purposes
total = mongo.db.games.find({"created_by": user}).count()
# create a list of games
findGames = mongo.db.games.find({"created_by": user}).sort("_id", -1)
# paginate the games
paginatedGames = findGames[offset: offset + per_page]
# create pagination variable for flask paginate
pagination = Pagination(page=page, per_page=per_page, total=total)
# render template and pass through all the relevant variables
return render_template('profile_reviews.html',
games=paginatedGames,
page=page,
per_page=per_page,
pagination=pagination,
)
def fighters():
search = False
page, per_page, offset = get_page_args()
fighters = db['fighters'] #select collection
heading = 'POUND FOR POUND'
visitors = get_visit_count()
fighter_list = fighters.find({}, {
"_id": 0,
"name": 1,
"striking": 1,
"grappling": 1
}).skip((page - 1) * per_page).limit(per_page)
pagination = Pagination(page=page,
per_page=10,
offset=offset,
total=fighter_list.count(),
search=search,
record_name='fighters')
return render_template('index.html',
fighters=fighter_list,
t=title,
h=heading,
pagination=pagination,
visitors=visitors)
def node_view(nid):
n = Node.query.filter_by(id=nid, deleted=False).first_or_404()
node_title = n.title
per_page = current_app.config['PER_PAGE']
page = int(request.args.get('page', 1))
offset = (page - 1) * per_page
topics_all = Topic.query.filter_by(node_id=nid, deleted=False).order_by(
Topic.time_created.desc()).limit(per_page + offset)
topics = topics_all[offset:offset + per_page]
pagination = Pagination(page=page,
total=Topic.query.filter_by(node_id=nid,
deleted=False).count(),
per_page=per_page,
record_name='topics',
CSS_FRAMEWORK='bootstrap',
bs_version=3)
return render_template('voice/node_view.html',
topics=topics,
title=gettext('Node view'),
post_list_title=gettext("Node ") + node_title +
gettext("'s topics"),
pagination=pagination)
return render_template('voice/node_view.html')
def all_sandwich():
page, per_page, offset = get_page_args(page_parameter='page',
per_page_parameter='per_page')
# per_page = 8
# offset = page * per_page
total = mongo.db.sandwiches.find().count()
sandwiches = mongo.db.sandwiches.find()
sandwich_pagination = sandwiches[offset:offset + per_page]
print(sandwich_pagination)
pagination = Pagination(page=page,
per_page=per_page,
total=total,
css_framework='bootstrap4')
return render_template('all_sandwich.html',
sandwiches=sandwiches,
page=page,
per_page=per_page,
sandwich_pagination=sandwich_pagination,
pagination=pagination)
def hot():
""" Show the hottest topics recently.
Sort the topic by reply_count, if have same reply_count, then sort by click.
"""
per_page = current_app.config['PER_PAGE']
page = int(request.args.get('page', 1))
offset = (page - 1) * per_page
topics_all = Topic.query.filter_by(deleted=False).order_by(
Topic.reply_count.desc(), Topic.click.desc()).limit(per_page + offset)
topics = topics_all[offset:offset + per_page]
pagination = Pagination(page=page,
total=Topic.query.filter_by(deleted=False).count(),
per_page=per_page,
record_name='topics',
CSS_FRAMEWORK='bootstrap',
bs_version=3)
return render_template('voice/index.html',
topics=topics,
title=gettext('Hottest Topics'),
post_list_title=gettext('Hottest Topics'),
pagination=pagination)
def todos_POST():
# create a paginator to redirect the user to the last page after a todo has been added
page, per_page, offset = get_page_args(page_parameter='page',
per_page_parameter='per_page')
todos = Todo.query.filter(Todo.user_id == current_user.get_id()).offset(
offset).limit(offset + per_page).all()
pagination = Pagination(page=page,
total=get_todos_count(current_user.get_id()),
per_page=per_page)
form = CreateTodoForm(request.form)
if form.validate_on_submit():
todo = Todo(current_user.get_id(), form.description.data)
db_session.add(todo)
db_session.commit()
flash('Todo successfully created!', 'success')
return redirect('/todo?page=%s' % pagination.total_pages)
return render_template('todos.html',
form=form,
todos=todos,
page=page,
pagination=pagination)
def listCustomer():
try:
# Pagination
search = False
q = request.args.get('q')
if q:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
per_page = 20
startat = page * per_page
if startat <= per_page:
startat = 0
count = exeReq("SELECT count(*) FROM user WHERE grp = 'customer';")
count = re.sub("[^0-9]", "","{}".format(count))
pagination = Pagination(page=page, total=int(count), search=search, record_name='list', css_framework='foundation', per_page=per_page)
# Get data
list = exeReq("SELECT login, email, grp FROM user WHERE grp = 'customer';")
wEvent('/html/v1.0/customer/list','exeReq','Get list','OK')
return render_template('listCustomer.html', list = list, maps = getMaps(), pagination=pagination)
except Exception as e:
wEvent('/html/v1.0/customer/list','exeReq','Get list','KO')
return 'List error'
def recipes(page):
conn = psycopg2.connect(
"dbname='db_plant' user='******' host='db' password='******'")
page = request.args.get(get_page_parameter(), type=int, default=int(page))
cur2 = conn.cursor()
cur2.execute('SELECT * FROM recipe')
rows = cur2.rowcount
if (page == 1):
cur = conn.cursor()
cur.execute(
'SELECT * FROM recipe LIMIT {limit} offset {offset}'.format(
limit=10, offset=0))
data = cur.fetchall()
else:
cur = conn.cursor()
cur.execute(
'SELECT * FROM recipe LIMIT {limit} offset {offset}'.format(
limit=10, offset=(5 * int(page))))
data = cur.fetchall()
pagination = Pagination(page=page,
total=rows,
css_framework='bootstrap4',
record_name='plants')
return render_template('recettes.html', plants=data, pagination=pagination)
def lang():
form = LangHandleForm()
dump = Language.dump()
if form.validate_on_submit():
selected = request.form.getlist("selected_lang")
if form.submit_add.data:
return redirect(url_for("lang.save"))
if form.submit_edit.data:
if len(selected) != 1:
flash("Invalid edited items. Allowed only one selected item")
else:
for lng in dump:
if lng.filang_id == int(selected[0]):
session["to_edit"] = {
"filang_id": lng.filang_id,
"fslang_iso639_1": lng.fslang_iso639_1,
"fslang_desc": lng.fslang_desc,
}
return redirect(url_for("lang.update"))
elif form.submit_delete.data:
Language.delete(tuple(selected))
return redirect(url_for("lang.lang"))
search = False
q = request.args.get('q')
if q:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
pagination = Pagination(page=page,
css_framework="foundation",
per_page=25,
total=len(dump),
search=search)
return render_template("lang/overview.html",
render_lst=dump,
pagination=pagination,
form=form)
def update_logos_multiple():
if request.method == "POST":
if request.form.get("choose_box", None) == 'Choose an Option':
flash("PLEASE CHOOSE A COMPANY TO LABEL")
else:
responses = insert_logos_multiple(request.form)
if responses:
# Insert in database
for response in responses:
new_logo = LogosMapper()
new_logo.company = response['company']
new_logo.id = response['id']
new_logo.image_path = response['path']
new_logo.image_vector = response['vector']
db.session.add(new_logo)
db.session.commit()
_unlabeled_images = list()
for folder in os.listdir(_UNLABELED_LOGOS):
folder_path = os.path.join(_UNLABELED_LOGOS, folder)
for image in os.listdir(folder_path):
_unlabeled_images.append(os.path.join(folder, image))
per_page_parameter = 12
page = request.args.get(get_page_parameter(), type=int, default=1)
images = _unlabeled_images[(page - 1) * per_page_parameter:page *
per_page_parameter]
pagination = Pagination(page=page,
total=len(_unlabeled_images),
per_page_parameter=per_page_parameter,
record_name='Logos',
css_framework='bootstrap4')
return render_template("dashboard_list_logos_multiple.html",
mapper=Company.json(),
images=images,
images_folder=_UNLABELED_LOGOS,
pagination=pagination)
def search():
qval = request.args.get('q')
page = request.args.get('page', 1, type=int)
print(qval, request.get_json(), request.data, request.args)
res = None
pagination = None
if qval:
res = _get_search(qval, page)
if res:
res = json.loads(res)['response']
total, per_page = res['record_count'], 20
href = ''.join(['/en/search?q=', qval, '&num=20&page={0}'])
if total > per_page:
pagination = Pagination(page=page,
per_page=per_page,
href=href,
bs_version=4,
total=total,
record_name='users')
return render_template('index.html',
qval=qval or '',
res=res,
locale=get_locale(),
pagination=pagination)
def edit_companies():
form = TeamsMapper()
if 'reset_previous' in request.form:
company = {'reset_previous': request.form['reset_previous']}
_ = reset_previous(company)
elif 'delete' in request.form:
company = {'name': request.form['delete']}
_ = delete_item(company)
elif form.validate():
_ = change_links_all(request.form)
page = request.args.get(get_page_parameter(), type=int, default=1)
companies = Company.get_page(int(page), page_limit=10)
pagination = Pagination(page=page,
total=Company.count(),
per_page_parameter=10,
search=False,
record_name='Company',
css_framework='bootstrap4')
return render_template("dashboard_edit_companies.html",
form=form,
companies=companies,
pagination=pagination)
def index(self):
"""Get the list of analyses.
.. :quickref: Analysis; Get the list of analyses
Response is paginated and will only contain 25 results. The most recent
analyses appear first.
:query page: page number.
:type page: int
:>json list analyses: list of analyses (see :http:get:`/analyses/(id)` for details on the format of an analysis).
"""
page = int(request.args.get('page', 1))
analyses = current_user.analyses.find().sort(
'_id', DESCENDING).limit(PER_PAGE).skip((page - 1) * PER_PAGE)
pagination = Pagination(page=page,
per_page=PER_PAGE,
total=analyses.count(),
css_framework='bootstrap3')
analyses = {'analyses': clean_analyses(list(analyses))}
for analysis in analyses['analyses']:
file = current_user.files.find_one({'_id': analysis['file']})
analysis['file'] = clean_files(file)
if 'analyst' in analysis:
analyst = store.users.find_one({'_id': analysis['analyst']})
analysis['analyst'] = clean_users(analyst)
return render(analyses,
'analyses/index.html',
ctx={
'data': analyses,
'pagination': pagination
})
def display_even_integers_to_n(number):
is_non_negative: bool = non_negative_integer(number)
if not is_non_negative:
return render_template("non_negative_integer.html", number=number)
numbers: list = list(range(2, number + 1, 2))
page, per_page, offset = get_page_args(page_parameter='page',
per_page_parameter='per_page')
if (page is None) or (page > len(numbers) / 10 + 1) or page <= 0:
abort(400)
pagination = Pagination(page=page,
per_page=per_page,
total=len(numbers),
css_framework='bootstrap4')
digit_list = get_pagination_digits_list(digit_list=numbers,
offset=offset,
per_page=per_page)
return render_template(
"display_integers.html",
title="Display Even Integers 1 to {}".format(number),
numbers=digit_list,
page=page,
per_page=per_page,
pagination=pagination,
)
def wf_state(state, sorting_key='_id', sorting_order="DESCENDING"):
if sorting_order == "ASCENDING":
sort_order = 1
elif sorting_order == "DESCENDING":
sort_order = -1
else:
raise RuntimeError()
current_sorting_key = sorting_key
current_sorting_order = sorting_order
db = app.lp.workflows
q = {} if state == "total" else {"state": state}
q = _addq_WF(q)
wf_count = app.lp.get_wf_ids(query=q, count_only=True)
try:
page = int(request.args.get('page', 1))
except ValueError:
page = 1
rows = list(db.find(q).sort([(sorting_key, sort_order)]).skip(
(page - 1) * PER_PAGE).limit(PER_PAGE))
for r in rows:
r["fw_id"] = r["nodes"][0]
pagination = Pagination(page=page, total=wf_count, record_name='workflows',
per_page=PER_PAGE)
return render_template('wf_state.html', **locals())
def qs_subject():
page = request.args.get(get_page_parameter(), type=int, default=1)
start = (page - 1) * 10
end = start + 10
t = request.args.get('t',type=int,default=2021)
s = request.args.get('s',type=str,default='science')
qs_sub = None
total = None
if s == 'science':
if t:
for i in range(2016,2022):
if t == i:
qs_sub = Qs_science_rank.query.filter_by(time=t).slice(start, end)
total = Qs_science_rank.query.filter_by(time=t).count()
elif s == 'accounting':
if t:
for i in range(2016,2022):
if t == i:
qs_sub = Qs_accounting_rank.query.filter_by(time=t).slice(start, end)
total = Qs_science_rank.query.filter_by(time=t).count()
elif s == 'enginnering':
if t:
for i in range(2016,2022):
if t == i:
qs_sub = Qs_engineering_rank.query.filter_by(time=t).slice(start, end)
total = Qs_science_rank.query.filter_by(time=t).count()
elif s == 'technology':
if t:
for i in range(2016,2022):
if t == i:
qs_sub = Qs_technology_rank.query.filter_by(time=t).slice(start, end)
total = Qs_science_rank.query.filter_by(time=t).count()
pagination = Pagination(bs_version=4, page=page, total=total, outer_window=0, inner_window=2)
return render_template('qs_rank.html',qs_sub=qs_sub,t=t,s=s,pagination=pagination)
def calc(self):
""" calculate values for skip, etc. """
self.maxPage = int((self.total + self.perPage - 1)/self.perPage)
if self.maxPage < 1: self.maxPage = 1
if self.page < 1: self.page = 1
if self.page > self.maxPage: self.page = self.maxPage
self.skip = (self.page-1)*self.perPage
self.fromIx = self.skip + 1
self.toIx = self.skip + self.perPage
if self.toIx > self.total: self.toIx = self.total
self.numShow = self.toIx - self.fromIx + 1
self.info = "Displaying rows %d-%d of %d." % (
self.fromIx, self.toIx, self.total)
self.flaskPag = Pagination(
page=self.page,
css_framework="bootstrap3",
link_size=self.perPage,
show_single_page=self.showSinglePage,
per_page=self.perPage,
total=self.total)
self.links = self.flaskPag.links
def user_recipes():
"""Display only user specific recipes"""
if not 'user_name' in session:
return redirect('/login')
else:
#https://gist.github.com/Faizanq/a4d07f1a9624bdf6d3ddd9d4d6cc1b2d
page, per_page, offset = get_page_args(page_parameter='page',
per_page_parameter='per_page')
user_recipes_filtered = mongo.db.recipes.find(
{"user_name": session['user_name']})
total = user_recipes_filtered.count()
my_recipes_fetched = user_recipes_filtered.sort([
('upvotes', DESCENDING)
]).skip((page - 1) * ITEMS_PER_PAGE).limit(ITEMS_PER_PAGE)
pagination = Pagination(page=page,
per_page=ITEMS_PER_PAGE,
total=total,
record_name='Recipes')
return render_template('userrecipes.html',
recipes=my_recipes_fetched,
username=session['user_name'],
page=page,
per_page=per_page,
pagination=pagination)
