def posts():
page = request.args.get(get_page_parameter(), type=int, default=1)
start = (page - 1) * config.PER_PAGE
end = start + config.PER_PAGE
posts = None
total = 0
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
posts = query_obj.slice(start, end)
total = query_obj.count()
pagination = Pagination(bs_version=3,
page=page,
total=total,
outer_window=0,
inner_window=1)
context = {'post_list': posts, 'pagination': pagination}
return render_template('cms/cms_posts.html', **context)
def list_endpoints():
page = request.args.get(get_page_parameter(), type=int, default=1)
endpoints = JsonMethods.get_endpoints(page=page)
total = JsonMethods.get_endpoints_count().get('count')
pagination = Pagination(page=page,
per_page=Globals.ITEM_PER_PAGE,
total=total,
record_name='endpoints',
css_framework='bootstrap4')
edit_endpoint_form = EditEndpointForm()
add_field_form = AddFieldForm()
return render_template('endpoints_listing.html',
endpoints=endpoints,
pagination=pagination,
edit_endpoint_form=edit_endpoint_form,
add_field_form=add_field_form)
def Email_Membros():
SITE_ROOT = os.path.realpath(os.path.dirname(__file__))
json_url = os.path.join(SITE_ROOT, 'json_files', 'Email_Membros.json')
json_data = json.load(open(json_url))
df = pd.DataFrame(json_data) # todos os dados
df = df[[
'Nome do Membro', 'Cargo (a)', 'Lotação (b)', 'E-mail Institucional'
]]
page = request.args.get(get_page_parameter(), type=int, default=1)
PER_PAGE = 5
pagination = Pagination(bs_version=4,
page=page,
per_page=PER_PAGE,
total=len(df),
record_name='df')
form = ConsultaAno()
if form.validate_on_submit():
ano = form.ano.data
df = pd.DataFrame(json_data) # todos os dados
df = df[[
'Nome do Membro', 'Cargo (a)', 'Lotação (b)',
'E-mail Institucional'
]] # dados filtrados
return render_template('main_planejamento.html',
tables=df[(page - 1) * PER_PAGE:page *
PER_PAGE].to_html(
classes='table table-fluid',
table_id="myTable"),
titles='E-mail funcional dos membros',
form=form,
pagination=pagination)
return render_template('main_planejamento.html',
tables=df[(page - 1) * PER_PAGE:page *
PER_PAGE].to_html(
classes='table table-fluid',
table_id="myTable"),
titles='E-mail funcional dos membros',
form=form,
pagination=pagination)
### -----------------------------------------------------------------------------------------------------------------------------------
def index():
board_id = request.args.get('bd', type=int, default=None)
# print('board_id: {}'.format(board_id))
banners = BannerModel.query.filter().limit(4)
boards = BoardModel.query.filter().all()
# posts = PostModel.query.filter().all()
page = request.args.get(get_page_parameter(), type=int, default=1)
sort = request.args.get('st', type=int, default=1)
start = (page - 1) * config.PER_PAGE
end = start + config.PER_PAGE
total = 0
query_obj = None
if sort == 1:
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 2:
query_obj = db.session.query(PostModel).outerjoin(
HighlightPost).order_by(HighlightPost.create_time.desc(),
PostModel.create_time.desc())
elif sort == 3:
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 4:
query_obj = db.session.query(PostModel).outerjoin(Comment).group_by(
PostModel).order_by(
func.count(Comment.id).desc(), PostModel.create_time.desc())
if board_id:
query_obj = query_obj.filter(PostModel.board_id == board_id)
# posts = PostModel.query.slice(start, end)
posts = query_obj.slice(start, end)
total = query_obj.count()
else:
posts = query_obj.slice(start, end)
total = query_obj.count()
# pagination = Pagination(bs_version=3, page=page, total=PostModel.query.count(), outer_window=0, inner_window=1)
current_sort = sort
pagination = Pagination(bs_version=3,
page=page,
total=total,
outer_window=0,
inner_window=1)
# context = {'pagination': pagination}
return render_template('front/front_index.html',
banners=banners,
boards=boards,
posts=posts,
pagination=pagination,
current_sort=current_sort,
current_board=board_id)
def log_page():
"""View log"""
try:
search = False
q = request.args.get('q')
if q:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
rev = []
length = 0
log_text = ""
with open("log/pow_log.txt", "r") as custom_log:
lines = custom_log.readlines()
lines.reverse()
length = (len(lines) // 100) + 1
if lines:
for x, line in enumerate(lines):
if page == 1:
if x <= 100:
log_text += line.replace('\n', '<br>')
else:
line_a = (100 * (page - 1))
line_b = (page * 100)
if x >= line_a and x <= line_b:
log_text += line.replace('\n', '<br>')
if length != 0:
pagination = Pagination(page=page,
total=length,
search=search,
record_name='Logging information',
css_framework='foundation',
per_page=1)
return render_template('admin/log_page.html',
log_text=log_text,
sidebar_info=SidebarInfo(),
header_nav_info=HeaderNavbarInfo(),
pagination=pagination)
except Exception as e:
print(e)
print("Exception occurred loading this page")
return render_template('admin/log_page.html',
sidebar_info=SidebarInfo(),
header_nav_info=HeaderNavbarInfo())
pass
def get_page(search_d,choices_name):
form = ZyPinkSearchForm()
pink = User.query.filter_by(username = current_user.username).first()
if (pink.school == '' and pink.group == ''):
sales = User.query.filter(User.flag.contains('0'))
elif (pink.group == '' and pink.school !=''):
school = pink.school.split(',')
sales = User.query.filter(User.flag.contains('0'),User.school.in_(school))
elif (pink.group != '' and pink.school != ''):
school = pink.school.split(',')
sales = User.query.filter(User.flag.contains('0'),User.school.in_(school),User.group == pink.group)
school = pink.school.split(',')
form.school.choices = [('','')]+[(a,a) for a in school]
form.c_project.choices = [('','')]+[(a.project,a.project) for a in AllProject.query.all()]
form.sale_name.choices = [('','')]+[(a.username,a.username) for a in sales]
search_d = eval(search_d)
if search_d['genre']=='':
search_d['genre']="已成交,A类,B类,C类,放弃"
sale_name_l=[]
if search_d['sale_name']==['']:
if search_d['school']!='':
for a in sales:
if a.school==search_d['school']:
sale_name_l.append(a.username)
else:
for a in sales:
sale_name_l.append(a.username)
search_d['sale_name'] = sale_name_l
else:
for a in sales:
sale_name_l.append(a.username)
all_search_cus = Customer.query.order_by(Customer.id.desc()).filter(Customer.sale_name.in_(search_d['sale_name']) if search_d['sale_name'] is not '' else "",
Customer.c_name.like('%'+search_d['c_name']+'%') if search_d['c_name'] is not '' else "",
Customer.phone.like('%'+search_d['phone']+'%') 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 "")
per_page = 10
page = request.args.get(get_page_parameter(), type=int, default=1)
start = (page-1)*per_page
end = start+per_page
search_res = all_search_cus.slice(start,end)
time_l,time_ruku,school_l = last_time(search_res)
pagination = Pagination(bs_version=3,page=page, total=all_search_cus.count())
return render_template('zy_pink_search.html',school_l=school_l,search_res = search_res,form = form,username=current_user.username,search_d = search_d,pagination = pagination,time_l = time_l,time_ruku=time_ruku,sale_name_l=sale_name_l,choices_name=choices_name)
def actor_detail(name):
actor = db.actors.find_one({'name': name, 'type': 'actor'})
if not actor:
msg = '数据库中没有演员"{}"的信息!'.format(name)
flash(msg)
return redirect(request.referrer)
# 获取人物关系
relations = actor.get('relations')
new_relations = []
for relation in relations:
person = db.actors.find_one({'name': relation[0]})
if not person:
continue
new_relation = (person, relation[1])
new_relations.append(new_relation)
# 获取当前作品页码
page = request.args.get(get_page_parameter(), type=int, default=1)
# 获取作品列表
# 每页显示几个
per_page = 20
start = (page - 1) * per_page
end = page * per_page
movies = db.movies.find({'actor_list': name})[start:end]
pagination = Pagination(
css_framework='bootstrap4',
page=page,
total=db.movies.count_documents({'actor_list': name}),
per_page=per_page,
record_name='movies',
anchor='movies',
)
show_movie = False
referer_url = request.referrer
if referer_url:
referer_name = referer_url.split('/')[-1].split('?')[0]
request_name = request.url.split('/')[-1].split('?')[0]
if referer_name == quote(request_name):
show_movie = True
return render_template('actor_detail.html',
actor=actor,
relations=new_relations,
movies=movies,
pagination=pagination,
show_movie=show_movie)
def index():
board_id = request.args.get("bd", type=int, default=None)
banners = BannerModel.query.order_by(BannerModel.priority.desc()).limit(4)
boards = BoardModel.query.all()
page = request.args.get(get_page_parameter(), type=int, default=1)
sort = request.args.get("st", type=int, default=1)
start = (page - 1) * config.PER_PAGE
end = start + config.PER_PAGE
posts = None
total = 0
query_obj = None
if sort == 1:
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 2:
# 按照加精的时间倒叙排序
query_obj = db.session.query(PostModel).outerjoin(
HighlightPostModel).order_by(HighlightPostModel.create_time.desc(),
PostModel.create_time.desc())
elif sort == 3:
# 按照点赞的数量排序
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 4:
query_obj = db.session.query(PostModel).outerjoin(
CommentModel).group_by(PostModel.id).order_by(
func.count(CommentModel.id).desc(),
PostModel.create_time.desc())
if board_id:
query_obj1 = query_obj.filter(PostModel.board_id == board_id)
posts = query_obj1.slice(start, end)
total = query_obj1.count()
else:
posts = query_obj.slice(start, end)
total = query_obj.count()
pagination = Pagination(bs_version=3,
page=page,
total=total,
outer_window=0,
inner_window=2)
context = {
"banners": banners,
"boards": boards,
"posts": posts,
"pagination": pagination,
"current_board": board_id,
'current_sort': sort
}
return render_template("front/front_index.html", **context)
def index():
board_id = request.args.get('bd', type=int, default=None)
page = request.args.get(get_page_parameter(), type=int, default=1)
sort = request.args.get('st', type=int, default=1)
banners = BannerModel.query.order_by(BannerModel.priority.desc()).limit(4)
boards = BoardModel.query.all()
start = (page - 1) * config.PER_PAGE
end = start + config.PER_PAGE
posts = None
total = 0
query_obj = None
if sort == 1:
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 2:
query_obj = db.session.query(PostModel).outerjoin(HighLight).order_by(
HighLight.create_time.desc(), PostModel.create_time.desc())
elif sort == 3:
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 4:
query_obj = db.session.query(PostModel).outerjoin(
CommentModel).group_by(PostModel.id).order_by(
func.count(CommentModel.id).desc(),
PostModel.create_time.desc())
if board_id:
query_obj = query_obj.filter(PostModel.board_id == board_id)
posts = query_obj.slice(start, end)
total = query_obj.count()
else:
posts = query_obj.slice(start, end)
total = query_obj.count()
pagination = Pagination(bs_version=3,
page=page,
total=total,
outer_window=0,
inner_window=2)
context = {
'banners': banners,
'boards': boards,
'posts': posts,
'pagination': pagination,
'current_board': board_id,
'current_sort': sort
}
return render_template('front/front_index.html', **context)
def index():
banners = BannerModel.query.order_by(BannerModel.priority.desc()).limit(4)
boards = Board.query.all()
#/?page=xxx
page = request.args.get(get_page_parameter(), type=int, default=1)
start = (page - 1) * config.POSTS_PER_PAGE
end = start + config.POSTS_PER_PAGE
query = None
classification = request.args.get("classification", type=int, default=0)
if classification == 0:
#按照创建时间新的帖子在前面
query = Post.query.order_by(Post.create_time.desc())
elif classification == 1:
#按照精华帖子创建时间排序，如果不是精华帖子，则按照帖子创建时间排序, outerjoin默认是left join
query = db.session.query(Post).outerjoin(HighLightPost).order_by(
HighLightPost.create_time.desc(), Post.create_time.desc())
elif classification == 2:
#TODO 按照点赞数
query = Post.query.order_by(Post.create_time.desc())
else:
#按照评论数排序
query = db.session.query(Post).outerjoin(Comment).group_by(
Post.id).order_by(
func.count(Comment.id).desc(), Post.create_time.desc())
board_id = request.args.get("board_id", type=int, default=None)
if board_id:
query_base = query.filter(Post.board_id == board_id)
pagination = Pagination(page=page,
total=query_base.count(),
bs_version=3)
posts = query_base.slice(start, end)
else:
pagination = Pagination(page=page, total=query.count(), bs_version=3)
posts = query.slice(start, end)
context = {
'banners': banners,
'boards': boards,
'posts': posts,
'pagination': pagination,
'current_board': board_id,
'current_classification': classification
}
return render_template('forum/index.html', **context)
def index():
q = request.args.get("q")
board_id = request.args.get("bd", type=int, default=None)
banners = BannerModel.query.order_by(BannerModel.priority.desc()).limit(5)
boards = BoardModel.query.all()
sort = request.args.get("st", type=int, default=1)
# posts = PostModel.query.all()
page = request.args.get(get_page_parameter(),type=int, default=1)
start = (page-1)*config.PER_PAGE
end = start + config.PER_PAGE
query_obj = None
if sort == 1:
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 2:
# 按照加精的时间倒序排序
query_obj = db.session.query(PostModel).outerjoin(HighlightPostModel).order_by(HighlightPostModel.create_time.desc(), PostModel.create_time.desc())
elif sort == 3:
# 按照点赞的数量排序
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 4:
# 按照评论的数量排序
query_obj = db.session.query(PostModel).outerjoin(CommentModel).group_by(PostModel.id).order_by(
func.count(CommentModel.id).desc(), PostModel.create_time.desc())
if q:
posts = PostModel.query.filter(or_(PostModel.title.contains(q))).order_by('-create_time').slice(start, end)
total = query_obj.filter(or_(PostModel.title.contains(q))).count()
else:
if board_id:
query_obj = query_obj.filter(board_id == board_id)
posts = query_obj.slice(start, end)
total = query_obj.count()
else:
posts = query_obj.slice(start, end)
total = query_obj.count()
pagination = Pagination(bs_version=3, page=page, total=total, outer_window=0, inner_window=2)
context = {
'banners': banners,
'boards': boards,
'posts': posts,
'pagination': pagination,
'current_board': board_id,
'current_sort': sort
}
return render_template('front/front_index.html', **context)
def index(self):
"""Get index page."""
form = forms.ImageUploadForm()
if form.file.data:
print('resize:{}'.format(form.resize.data))
with NamedTemporaryFile() as temp, NamedTemporaryFile() as thumb_temp:
form.file.data.save(temp.name)
posted_img = get_posted_image(
img_path=temp.name, resize=form.resize.data, thumb_path=thumb_temp.name)
place = [x[1] for x in form.place.choices if x[0] == int(form.place.data)][0]
url, im_place = iqdb_url_dict[place]
query = posted_img.imagematchrelationship_set \
.select().join(ImageMatch) \
.where(ImageMatch.search_place == im_place)
if not query.exists():
try:
posted_img_path = temp.name if not form.resize.data else thumb_temp.name
result_page = get_page_result(image=posted_img_path, url=url)
except requests.exceptions.ConnectionError as e:
current_app.logger.error(str(e))
flash('Connection error.')
return redirect(request.url)
list(ImageMatch.get_or_create_from_page(
page=result_page, image=posted_img, place=im_place))
return redirect(url_for('matchview.match_sha256', checksum=posted_img.checksum))
page = request.args.get(get_page_parameter(), type=int, default=1)
item_per_page = 10
entries = (
ImageModel.select()
.distinct()
.join(ImageMatchRelationship)
.where(ImageMatchRelationship.image)
.order_by(ImageModel.id.desc())
)
pagination = Pagination(
page=page, total=entries.count(), per_page=item_per_page, bs_version=3)
paginated_entries = entries.paginate(page, item_per_page)
if not entries.exists() and page != 1:
abort(404)
# pagination = Pagination(page, item_per_page, entries.count())
return self.render(
'iqdb_tagger/index.html',
entries=paginated_entries,
pagination=pagination,
form=form
)
def index():
form = PostForm()
if form.validate_on_submit():
if current_user.is_authenticated:#如果登录
#获取当前用户
u = current_user._get_current_object()
p = Posts(content=form.content.data,user=u)
db.session.add(p)
return redirect(url_for('main.index'))
else:
flash("请先登录")
return redirect(url_for('users.login'))
#调取所有发表的博客
# posts = Posts.query.filter_by(rid=0).all()
#www.baidu.com?page=1
#接收用户 url传递过来的 page参数
# page = request.args.get('page',1,type=int)
# pagination = Posts.query.filter_by(rid=0).order_by(Posts.timestamp.desc()).paginate(page,per_page=5,error_out=False)
# posts = pagination.items
#
#
# return render_template('main/index.html',form=form,posts=posts,pagination=pagination)
page = request.args.get(get_page_parameter(),default=1,type=int)
start = (page-1)* current_app.config['PAGE_NUM']
end = start+current_app.config['PAGE_NUM']
posts = Posts.query.slice(start,end)
pagination=Pagination(page=page,total=Posts.query.count(),inner_window=2,outer_window=3,bs_version=3)
# 0 3
# 3 6
context = {
'form':form,
'posts':posts,
'pagination':pagination
}
return render_template('main/index.html',**context)
# @main.route('/token/',methods=['GET','POST'])
# def token():
# s = Serializer(current_app.config['SECRET_KEY'],expires_in=3600)
# return s.dumps({'id':666})
#
# @main.route('/check/',methods=['GET','POST'])
# def check():
# t = 'eyJhbGciOiJIUzUxMiIsImlhdCI6MTU0NzUzNzQ2OCwiZXhwIjoxNTQ3NTQxMDY4fQ.eyJpZCI6NjY2fQ.oVWgGFIS9ew0pZrzqk-5RetoUSBuPeimbMN4E7R1hveFhC3BAQlOSy-IH-0lBH7GnkaDvf2fasAMKmFCci4HiA'
# s = Serializer(current_app.config['SECRET_KEY'])
# data = s.loads(t)
# return str(data['id'])
def cook_book(query = None, sort = None):
categories = mongo.db.categories.find()
tags = mongo.db.tags.find()
allergens = mongo.db.allergens.find()
user = mongo.db.user.find_one({"username": session["username"]})
cook_book = user["cook_book"]
total = len(cook_book)
for i in range(len(cook_book)):
cook_book[i] = ObjectId(cook_book[i])
if query == "None" :
# If value of query doesn't change, return all reslults as user has just visited the site.
recipes = mongo.db.recipes.find({"_id": {"$in": cook_book}})
else:
# Convert query to dict by first changing it from unicode to str, then to dict using ast.literal_eval()
# Use variable in the find query.
# Add cook_book to dict to search recipe id's
query = str(query)
dict_query = ast.literal_eval(query)
dict_query["_id"] = {"$in": cook_book}
recipes = mongo.db.recipes.find(dict_query)
# These lines of code will sort the recipes depending on what the user picks.
if sort == "most_views":
recipes.sort([("views", -1)])
elif sort == "least_views":
recipes.sort([("views", 1)])
elif sort == "best_rated":
recipes.sort([("up_down_votes", -1)])
elif sort == "worst_rated":
recipes.sort([("up_down_votes", 1)])
count = recipes.count()
search = False
q = request.args.get('q')
if q:
search = True
# Pagination using flask-paginate
page = request.args.get(get_page_parameter(), type=int, default=1)
pagination = Pagination(page=page, per_page= 6, total=count, search=search, record_name="recipes")
return render_template("cook-book.html", recipes = get_records(recipes, 6, request.args.get(get_page_parameter(), type=int, default=1)),
count = count, total = total, pagination = pagination, sort = sort, query = query, categories = categories, tags = tags, allergens = allergens)
def index():
##前端点击链接，给后台返回，板块的id,设置的排序sort,
#后台根据得到的bd,st来查询数据，并且把，获取到的值也传给前端，这样子，循环形成整体
board_id = request.args.get('bd', type=int, default=None)
page = request.args.get(get_page_parameter(), type=int, default=1)
sort = request.args.get("st", type=int, default=1)
banners = Banner.query.order_by(Banner.weight_url.desc()).all()
boards = BoardModel.query.all()
start = (page - 1) * config.PAGE_SIZE
end = start + config.PAGE_SIZE
posts = None
total = 0
query_obj = None
if sort == 1:
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 2:
# 按照加精时间倒叙,没加精的，按照时间倒叙
query_obj = db.session.query(PostModel).outerjoin(
HighlightPostModel).order_by(HighlightPostModel.crete_time.desc(),
PostModel.create_time.desc())
elif sort == 3:
query_obj = PostModel.query.order_by(PostModel.create_time.desc())
elif sort == 4:
# 查询帖子，并加入评论，用帖子id分组，进行数量的排序，
query_obj = db.session.query(PostModel).outerjoin(
CommentModel).group_by(PostModel.id).order_by(
func.count(CommentModel.id).desc(),
PostModel.create_time.desc())
if board_id:
query_obj = query_obj.filter(PostModel.board_id == board_id)
posts = query_obj.slice(start, end)
total = query_obj.count()
else:
posts = query_obj.slice(
start, end) # 注意不能加.all() .order_by(PostModel.create_time.desc())
total = query_obj.count()
pagination = Pagination(bs_version=4, page=page, total=total)
content = {
'banners': banners,
'boards': boards,
'posts': posts,
'pagination': pagination,
'current_board': board_id,
'current_sort': sort
}
return render_template('front/front_index.html', **content)
def search_v1():
raw_query = request.args.get('flavor')
page = request.args.get(get_page_parameter(), type=int, default=1)
pagination = None
if not raw_query:
q_flavor = ""
teas = []
output_message = ""
else:
q_flavor = ", ".join(
[flavor.title().strip() for flavor in raw_query.split(",")])
flavor_query = " OR ".join([
"teas.flavors LIKE '%" + flavor.title().strip() + "%'"
for flavor in raw_query.split(",")
])
raw_teas = Tea.query.filter(flavor_query).order_by(
Tea.ratingValue.desc())
if HITS_RANK and raw_teas.count() > 0:
# print "Found {} teas".format(raw_teas.count())
hits_ranked_tea_id = hits_rank(
[tea.steepsterID for tea in raw_teas.all()])
# print "Found {} teas after HITS algo".format(len(hits_ranked_tea_id))
if hits_ranked_tea_id:
# https://stackoverflow.com/questions/29326297/sqlalchemy-filter-by-field-in-list-but-keep-original-order
from sqlalchemy.sql.expression import case
ordering = case(
{id: index
for index, id in enumerate(hits_ranked_tea_id)},
value=Tea.steepsterID)
raw_teas = Tea.query.filter(
Tea.steepsterID.in_(hits_ranked_tea_id)).order_by(ordering)
total = raw_teas.count()
teas = raw_teas.offset((page - 1) * 10).limit(10)
pagination = Pagination(page=page,
total=total,
per_page=10,
bs_version=4,
record_name="teas")
return render_template('search_v1.html',
name=project_name,
netid=net_id,
query=q_flavor,
teas=teas,
pagination=pagination,
version=request.args.get('version'))
def book_review(book_id):
# Declare empty string to be used for average rating
rating_list = []
# Find reviews based on book id
get_review = mongo.db.review.find({'book_id': book_id})
# Iterates through review rating values and appends to string as integer
for i in get_review:
rating_list.append(int(i['rating']))
try:
# If reviews exist, calculate average rating to 1 decimal place
avg_rating = format(sum(rating_list) / len(rating_list), '.1f')
except ZeroDivisionError:
# Else, set the value to 0 as a string
avg_rating = '0'
search = False
x = request.args.get('x')
if x:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
reviews = mongo.db.review.find({'book_id': book_id})
pagination = Pagination(page=page,
total=reviews.count(),
search=search,
record_name=reviews)
# Declare page variables
the_book = mongo.db.books.find_one({'_id': ObjectId(book_id)})
all_genre = mongo.db.genre.find()
no_of_docs = mongo.db.review.count_documents({'book_id': book_id})
# Set avergage rating field with whatever is returned
mongo.db.books.update({'_id': ObjectId(book_id)},
{'$set': {
'rating': avg_rating
}})
return render_template('book-review.html',
book=the_book,
recent=the_book,
genre=all_genre,
review=reviews,
average=avg_rating,
review_amount=no_of_docs,
pagination=pagination)
def QuadroDemonstrativo():
SITE_ROOT = os.path.realpath(os.path.dirname(__file__))
json_url = os.path.join(SITE_ROOT, 'json_files',
'QuadroDemonstrativo.json')
json_data = json.load(open(json_url))
df = pd.DataFrame(json_data) #todos os dados
df = df[[
'Objetivos (a)', 'Ação', 'Indicador (b)', 'Meta (c) 2016-2019',
'Resultado alcançado até o momento (d) 2018',
'Resultado alcançado em 2019 (d)', 'Documento (e)', 'Obs'
]] #dados filtrados
#Paginação: https://pythonhosted.org/Flask-paginate/ e #https://stackoverflow.com/questions/34952501/flask-pagination-links-improperly-formatted
page = request.args.get(get_page_parameter(), type=int, default=1)
PER_PAGE = 5
pagination = Pagination(bs_version=4,
page=page,
per_page=PER_PAGE,
total=len(df),
record_name='df')
form = ConsultaAno()
if form.validate_on_submit():
ano = form.ano.data
df = pd.DataFrame(json_data) #todos os dados
df = df[[
'Objetivos (a)', 'Ação', 'Indicador (b)', 'Meta (c) 2016-2019',
'Resultado alcançado até o momento (d) 2018',
'Resultado alcançado em 2019 (d)', 'Documento (e)', 'Obs'
]] #dados filtrados
return render_template('main_planejamento.html',
tables=df[(page - 1) * PER_PAGE:page *
PER_PAGE].to_html(
classes='table table-fluid',
table_id="myTable"),
titles='Quadro Demostrativo',
form=form,
pagination=pagination)
return render_template('main_planejamento.html',
tables=df[(page - 1) * PER_PAGE:page *
PER_PAGE].to_html(
classes='table table-fluid',
table_id="myTable"),
titles='Quadro Demostrativo',
form=form,
pagination=pagination)
def index_10():
bookList = []
per_page = 10
con = sqlite3.connect("ZongHeng24hour.db")
cur = con.cursor()
sql = "SELECT * FROM ZongHeng24hour"
data = cur.execute(sql)
for i in data:
bookList.append(i)
total = len(bookList)
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)
book = bookList[start:end]
context = {'pagination': pagination, 'book': book}
return render_template('24hour.html', **context)
def listings():
""" recipes on the page to show 3 """
per_page = 3
page = request.args.get(get_page_parameter(), type=int, default=1)
recipe = mongo.db.recipes.find().sort("timestamp", -1)
"""pagination for users to flip through different recipes"""
pagination = Pagination(page=page,
total=recipe.count(),
per_page=per_page,
search=False,
record_name='recipes',
css_framework='bootstrap4',
alignment='center')
recipe_page = recipe.skip((page - 1) * per_page).limit(per_page)
return render_template("listings.html",
recipe=recipe_page,
pagination=pagination)
def users_list():
page = request.args.get(get_page_parameter(), type=int, default=1)
qs = request.args.get("sname", type=str)
rec = request.args.get("records", type=int)
if not rec:
rec = 10
total = db.count_all()
if qs:
users = db.find(qs)
return render_template('users.html', users=users)
start = page * rec - rec
users = db.pagination(start, rec)
pagination = Pagination(page=page,
total=total[0],
per_page=rec,
record_name='users')
return render_template('users.html', users=users, pagination=pagination)
def query():
res = execute_query(request.args)
page = request.args.get(get_page_parameter(), type=int, default=1)
pagination = Pagination(page=page,
found=len(res),
total=get_total_papers(),
record_name='papers',
format_total=True,
format_number=True,
search=True,
bs_version=4)
res = list(res)[(int(page) * 10 - 10):(int(page) * 10)]
return render_template('index.html',
data=res,
properties=get_properties(),
query=request.args.get('q'),
pagination=pagination)
def get_recipes():
per_page = 8
page = request.args.get(get_page_parameter(), type=int, default=1)
recipes = mongo.db.recipes.find()
pagination = Pagination(page=page,
total=recipes.count(),
per_page=per_page,
search=False,
record_name='recipes',
css_framework='bootstrap4',
alignment='center')
recipe_page = recipes.skip((page - 1) * per_page).limit(per_page)
return render_template('recipes.html',
recipe=recipe_page,
pagination=pagination,
recipes=mongo.db.recipes.find(),
styles=mongo.db.recipe_style.find())
def show_users():
page = request.args.get(get_page_parameter(), type=int, default=1)
# Stupidly easy but otherwise sqlalchemy will work weird
offset = page - 1
offset = offset * 10
total_users = db_session.query(db.User).count()
users = db_session.query(db.User).order_by(
db.User.name.asc()).limit(10).offset(offset)
pagination = Pagination(page=page,
total=total_users,
record_name='users',
css_framework='bootstrap3')
return render_template("users_list.html",
users=users,
pagination=pagination)
def all_books():
# Flask pagination
search = False
x = request.args.get('x')
if x:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
books = mongo.db.books.find()
pagination = Pagination(page=page,
total=books.count(),
search=search,
record_name=books)
return render_template('all-books.html',
books=books,
pagination=pagination)
def profile_page(username):
'''Define user profile page route'''
# Define per page posts number
per_page = 6
# Define page arg
page = request.args.get(get_page_parameter(), type=int, default=1)
# Get user from the database
profile = get_user_from_username(username)
# Get user ID from database
profile_id = profile["_id"]
# Get profile username
profile_username = profile["username"]
# Get user's blog
profile_blog = get_blog_from_user_id(profile_id)
# Get users posts from database
get_profile_posts_pagination = get_users_posts(profile_id).skip(
(page - 1) * per_page).limit(per_page)
# Handle sorting if value is X sort by Y
if request.form.get('sort') == "1":
profile_posts = get_profile_posts_pagination.sort("last_updated", -1)
if request.form.get('sort') == "2":
profile_posts = get_profile_posts_pagination.sort("last_updated", 1)
if request.form.get('sort') == "3":
profile_posts = get_profile_posts_pagination.sort("title", 1)
if request.form.get('sort') == "4":
profile_posts = get_profile_posts_pagination.sort("title", -1)
if request.form.get('sort') == "5":
profile_posts = get_profile_posts_pagination.sort("views", -1)
if request.form.get('sort') is None:
profile_posts = get_profile_posts_pagination
sorting_value = request.form.get('sort')
# Get current user
current_user = session.get("user")
# Define pagination
pagination = Pagination(page=page,
per_page=per_page,
total=profile_posts.count(),
record_name='posts')
return render_template('profile.html',
profile=profile,
profile_posts=profile_posts,
profile_blog=profile_blog,
pagination=pagination,
profile_username=profile_username,
current_user=current_user,
sorting_value=sorting_value)
def feed_news(id):
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
article_boards = db.session.query(ArticleBoard.board_id,
Article.url).join(Article).all()
boards = (Board.query.filter(Board.user_id == g.user.id).all())
if request.method == 'GET':
feed = Feed.query.get_or_404(id)
feed_name = feed.name
source_feeds = feed.source_feeds
domains = ""
if len(source_feeds) > 0:
for source_feed in source_feeds:
res = get_tld(source_feed.sources.url, as_object=True)
domains += res.fld + ','
domains = domains[:-1]
page = request.args.get(get_page_parameter(), type=int, default=1)
try:
news = news_domains(domains, page)
except:
return render_template('404.html')
pagination = Pagination(page=page, per_page=per_page, total=total)
return render_template('news/feeds.html',
feed_id=id,
news=news,
boards=boards,
feed_name=feed_name,
article_boards=article_boards,
pagination=pagination)
else:
flash("Please Add source in Feed", "danger")
return redirect('/sources')
if request.method == 'POST':
data = request.json
update_articles(data)
return jsonify(message="added")
def posts():
page = request.args.get(get_page_parameter(), type=int, default=1)
start = (page - 1) * 10
end = start + 10
posts = PostModel.query.order_by(PostModel.create_time.desc()).slice(
start, end)
total = PostModel.query.count()
print(page, "and和", total)
pagination = Pagination(bs_version=3,
page=page,
total=total,
outer_window=1,
inner_window=2)
print(pagination.links)
context = {'posts': posts, 'pagination': pagination}
return render_template('cms/cms_posts.html', **context)
def cases():
search = False
q = request.args.get('q')
if q:
search = True
# Only logged in users can access bank profile
if session.get('username') == None:
return redirect(url_for('home'))
else:
cur, db, engine = connection2()
form = ViewCasesForm()
search_form = SearchForm()
per_page = 4
page = request.args.get(get_page_parameter(), type=int, default=1)
offset = (page - 1) * per_page
query = "SELECT * FROM SMI_DB.ClientCase "
cur.execute(query)
total = cur.fetchall()
cur.execute("SELECT * FROM SMI_DB.ClientCase ORDER BY caseID DESC LIMIT %s OFFSET %s", (per_page, offset))
cases = cur.fetchall()
if search_form.search_submit.data and search_form.validate_on_submit():
return redirect((url_for('searchResult', id=search_form.search.data, form2=search_form)))
if form.validate_on_submit():
#id = form.hidden.data
#id = request.form.get('case_submit')
id = request.form['caseView']
#id2 = request.form['caseDownload']
print(id)
return redirect((url_for('case' , id = id)))
pagination = Pagination(page=page,per_page = per_page, total= len(total) ,offset = offset , search=search, record_name='cases' , css_framework='bootstrap3')
# 'page' is the default name of the page parameter, it can be customized
# e.g. Pagination(page_parameter='p', ...)
# or set PAGE_PARAMETER in config file
# also likes page_parameter, you can customize for per_page_parameter
# you can set PER_PAGE_PARAMETER in config file
# e.g. Pagination(per_page_parameter='pp')
#, pagination=pagination
return render_template("cases.html", cases = cases, form=form ,form2 = search_form , pagination=pagination ,css_framework='foundation', caseId = 0)
def search_flyname():
query = request.args.get('search')
results = mongo.db.fly.find({'name': {"$regex": query,
"$options": 'i'}}).sort('name')
results_number = results.count()
per_page = 8
page = request.args.get(get_page_parameter(), type=int, default=1)
fly = mongo.db.fly.find()
pagination = Pagination(page=page, total=fly.count(),
per_page=per_page,
search=False, record_name='Flies',
css_framework='bootstrap4', alignment='center')
fly_page = fly.skip((page - 1) * per_page).limit(per_page)
return render_template('searchflyname.html',
results_number=results_number,
results=fly_page,
pagination=pagination)
def vegan_recipes():
search = False
q = request.args.get('q')
if q:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
recipes=mongo.db.recipes.find({"is_vegan": "on"}).sort("upvotes", -1).skip((page - 1) * per_page).limit(per_page)
pagination = Pagination(page=page, per_page=per_page, total=recipes.count(), search=search, record_name='recipes', bs_version=4)
return render_template('recipes.html',
recipes=recipes,
pagination=pagination
)
def get_recipes():
search = False
q = request.args.get('q')
if q:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
recipes = mongo.db.recipes.find().sort("recipe_title", 1).skip((page - 1) * per_page).limit(per_page)
pagination = Pagination(page=page, per_page=per_page, total=recipes.count(), search=search, record_name='recipes', css_framework="bootstrap", bs_version=4)
return render_template('recipes.html',
recipes=recipes,
pagination=pagination
)
def lots():
search = False
q = request.args.get('q')
if q:
search = True
page = request.args.get(get_page_parameter(), type=int, default=1)
lots = Lot.query.order_by(Lot.created_at.desc())
pagination_lots = Lot.query.order_by(Lot.created_at.desc()).paginate(
page, app.config['PER_PAGE'], search)
pagination = Pagination(page=page, per_page=app.config['PER_PAGE'],
total=lots.count(), css_framework=app.config['CSS_FRAMEWORK'],
search=search, record_name='lots')
return render_template('lots.html', title='Lots', lots=pagination_lots.items,
pagination=pagination)
def posts():
q = request.args.get('q')
page = request.args.get(get_page_parameter(), type=int, default=1)
start = (page-1)*config.PER_PAGE
end = start + config.PER_PAGE
# if q:
# posts = PostModel.query.filter(or_(PostModel.title.contains(q))).order_by('-create_time')
# else:
if q:
posts = PostModel.query.filter(or_(PostModel.title.contains(q))).order_by('-create_time').slice(start, end)
total = PostModel.query.filter(or_(PostModel.title.contains(q))).count()
else:
posts = PostModel.query.slice(start, end)
total = PostModel.query.count()
pagination = Pagination(bs_version=3, page=page, total=total, outer_window=0, inner_window=2)
content = {
'posts': posts,
'pagination': pagination,
}
return render_template('cms/cms_posts.html', **content)
def bookmarks():
"""Bookmarks."""
res = None
bukudb = getattr(flask.g, 'bukudb', BukuDb())
page = request.args.get(get_page_parameter(), type=int, default=1)
per_page = request.args.get(
get_per_page_parameter(),
type=int,
default=int(
current_app.config.get('BUKUSERVER_PER_PAGE', views.DEFAULT_PER_PAGE))
)
url_render_mode = current_app.config['BUKUSERVER_URL_RENDER_MODE']
create_bookmarks_form = forms.BookmarkForm()
if request.method == 'GET':
all_bookmarks = bukudb.get_rec_all()
result = {
'bookmarks': []
}
for bookmark in all_bookmarks:
result_bookmark = {
'url': bookmark[1],
'title': bookmark[2],
'tags': list([_f for _f in bookmark[3].split(',') if _f]),
'description': bookmark[4]
}
if not request.path.startswith('/api/'):
result_bookmark['id'] = bookmark[0]
result['bookmarks'].append(result_bookmark)
if request.path.startswith('/api/'):
res = jsonify(result)
else:
if request.args.getlist('tag'):
tags = request.args.getlist('tag')
result['bookmarks'] = [
x for x in result['bookmarks']
if set(tags).issubset(set(x['tags']))
]
current_app.logger.debug('total bookmarks:{}'.format(len(result['bookmarks'])))
current_app.logger.debug('per page:{}'.format(per_page))
pagination_total = len(result['bookmarks'])
bms = list(views.chunks(result['bookmarks'], per_page))
try:
result['bookmarks'] = bms[page-1]
except IndexError as err:
current_app.logger.debug('{}:{}, result bookmarks:{}, page:{}'.format(
type(err), err, len(result['bookmarks']), page
))
pagination = Pagination(
page=page, total=pagination_total, per_page=per_page,
search=False, record_name='bookmarks', bs_version=3
)
res = render_template(
'bukuserver/bookmarks.html',
result=result,
pagination=pagination,
search_bookmarks_form=forms.SearchBookmarksForm(),
create_bookmarks_form=create_bookmarks_form,
url_render_mode=url_render_mode,
)
elif request.method == 'POST':
url_data = create_bookmarks_form.url.data
result_flag = bukudb.add_rec(
url_data,
create_bookmarks_form.title.data,
create_bookmarks_form.tags.data,
create_bookmarks_form.description.data
)
if request.path.startswith('/api/'):
res = [
jsonify(response.response_template['success']), status.HTTP_200_OK,
{'ContentType': 'application/json'}
] if result_flag != -1 else [
jsonify(response.response_template['failure']), status.HTTP_400_BAD_REQUEST,
{'ContentType': 'application/json'}
]
else:
bm_text = '[<a href="{0}">{0}</a>]'.format(url_data)
if result_flag != -1:
flash(Markup('Success creating bookmark {}.'.format(bm_text)), 'success')
else:
flash(Markup('Failed creating bookmark {}.'.format(bm_text)), 'danger')
return redirect(url_for('bookmarks-html'))
elif request.method == 'DELETE':
result_flag = bukudb.cleardb()
res = [
jsonify(response.response_template['success']), status.HTTP_200_OK,
{'ContentType': 'application/json'}
] if result_flag else [
jsonify(response.response_template['failure']), status.HTTP_400_BAD_REQUEST,
{'ContentType': 'application/json'}
]
return res
def search_bookmarks():
arg_obj = request.form if request.method == 'DELETE' else request.args
search_bookmarks_form = forms.SearchBookmarksForm(request.args)
is_api_request_path = request.path.startswith('/api/')
if is_api_request_path:
keywords = arg_obj.getlist('keywords')
all_keywords = arg_obj.get('all_keywords')
deep = arg_obj.get('deep')
regex = arg_obj.get('regex')
# api request is more strict
all_keywords = False if all_keywords is None else all_keywords
deep = False if deep is None else deep
regex = False if regex is None else regex
all_keywords = \
all_keywords if type(all_keywords) == bool else all_keywords.lower() == 'true'
deep = \
deep if type(deep) == bool else deep.lower() == 'true'
regex = \
regex if type(regex) == bool else regex.lower() == 'true'
else:
keywords = search_bookmarks_form.keywords.data
all_keywords = search_bookmarks_form.all_keywords.data
deep = search_bookmarks_form.deep.data
regex = search_bookmarks_form.regex.data
result = {'bookmarks': []}
bukudb = getattr(flask.g, 'bukudb', BukuDb())
found_bookmarks = bukudb.searchdb(keywords, all_keywords, deep, regex)
found_bookmarks = [] if found_bookmarks is None else found_bookmarks
page = request.args.get(get_page_parameter(), type=int, default=1)
per_page = request.args.get(
get_per_page_parameter(),
type=int,
default=int(
current_app.config.get('BUKUSERVER_PER_PAGE', views.DEFAULT_PER_PAGE))
)
res = None
if request.method == 'GET':
if bookmarks is not None:
for bookmark in found_bookmarks:
result_bookmark = {
'id': bookmark[0],
'url': bookmark[1],
'title': bookmark[2],
'tags': list([_f for _f in bookmark[3].split(',') if _f]),
'description': bookmark[4]
}
result['bookmarks'].append(result_bookmark)
current_app.logger.debug('total bookmarks:{}'.format(len(result['bookmarks'])))
if is_api_request_path:
res = jsonify(result)
else:
pagination_total = len(result['bookmarks'])
bms = list(views.chunks(result['bookmarks'], per_page))
try:
result['bookmarks'] = bms[page-1]
except IndexError as err:
current_app.logger.debug('{}:{}, result bookmarks:{}, page:{}'.format(
type(err), err, len(result['bookmarks']), page
))
pagination = Pagination(
page=page, total=pagination_total, per_page=per_page,
search=False, record_name='bookmarks', bs_version=3
)
res = render_template(
'bukuserver/bookmarks.html',
result=result, pagination=pagination,
search_bookmarks_form=search_bookmarks_form,
create_bookmarks_form=forms.BookmarkForm(),
)
elif request.method == 'DELETE':
if found_bookmarks is not None:
for bookmark in found_bookmarks:
result_flag = bukudb.delete_rec(bookmark[0])
if result_flag is False:
res = jsonify(response.response_template['failure']), status.HTTP_400_BAD_REQUEST, {'ContentType': 'application/json'}
if res is None:
res = jsonify(response.response_template['success']), status.HTTP_200_OK, {'ContentType': 'application/json'}
return res
