def index():
"""The route handler for the homepage.
Returns:
A rendered html template for the homepage
"""
recent_venues = (Venue.query.order_by(db.desc(
Venue.created_at)).limit(9).all())
recent_artists = (Artist.query.order_by(db.desc(
Artist.created_at)).limit(9).all())
recently_listed = []
while len(recently_listed) < 9 and (len(recent_artists) > 0
or len(recent_venues) > 0):
if (len(recent_venues) > 0
and recent_venues[0].created_at > recent_artists[0].created_at
or len(recent_artists) == 0):
recent_venues[0].type = "Venue"
recently_listed.append(recent_venues.pop(0))
else:
recent_artists[0].type = "Artist"
recently_listed.append(recent_artists.pop(0))
print(recently_listed)
return render_template("pages/home.html", recently_listed=recently_listed)
def getposts(basequery=None, sticky=False):
if basequery is None:
basequery = JobPost.query
query = basequery.filter(
JobPost.status.in_([POSTSTATUS.CONFIRMED, POSTSTATUS.REVIEWED])).filter(
JobPost.datetime > datetime.utcnow() - agelimit)
if sticky:
query = query.order_by(db.desc(JobPost.sticky))
return query.order_by(db.desc(JobPost.datetime))
def ranked_followers(username: str, rank_by: str,
value: str) -> List[Follower]:
"""
Rank followers based on specified criteria using db queries. Return a list
of ranked followers' user id and their screen names who have not already
been sent a DM.
params:
username(str) - username of follower to rank for
rank_by(str) - criteria to rank by
value(str) - value to search for. only used for location
and description filter
returns:
list of followers ranked accordingly
"""
ranking = RANK_BY.get(rank_by, None)
user = User.query.filter_by(username=username).first()
followers_dm_not_sent = (db.session.query(Follower).filter_by(
user_id=user.id, dm_sent=False).all())
if user.followers and not len(followers_dm_not_sent):
raise Exception("DMs have been sent to all followers already :(")
if ranking:
return (db.session.query(Follower).filter_by(
user_id=user.id, dm_sent=False).order_by(db.desc(**ranking)).all())
else:
return (db.session.query(Follower).filter(
Follower.user_id == user.id,
getattr(Follower, rank_by).like("%{}%".format(value)),
Follower.dm_sent == False,
).all())
def lostcardGetAll():
t = {}
try:
lostcard = Lostcard.query.order_by(
db.desc('tableid')).filter_by(showflag=1).all()
length = Lostcard.query.filter_by(showflag=1).count()
db.session.close()
if length != 0:
tt = {}
t['data'] = []
t['status'] = 'true'
for i in range(length):
tt = {}
tt['tableid'] = lostcard[i].tableid
tt['name'] = lostcard[i].name
tt['id'] = lostcard[i].id
tt['description'] = lostcard[i].description
tt['contact'] = lostcard[i].contact
tt['type'] = lostcard[i].type
tt['submitid'] = lostcard[i].submitid
tt['date'] = lostcard[i].date
t['data'].append(tt)
else:
t['status'] = 'true'
t['description'] = 'no data in db'
except:
t['status'] = 'false'
return json.dumps(t, ensure_ascii=False)
def profile(user_id):
user = User.query.get(user_id)
if user == None:
return redirect('/')
paginate = Image.query.filter_by(user_id=user_id).order_by(
db.desc(Image.id)).paginate(page=1, per_page=3, error_out=False)
return render_template('profile.html',
user=user,
images=paginate.items,
has_next=paginate.has_next)
def system_log():
u = require_token()
ss = Syslog.query.order_by(db.desc('timestamp')).limit(100).all()
return {
'start_time': app.config['START_TIME'],
'salt': look(app.config['SALT']),
'tmp_token': tmp_token(),
'data' : list(map(map_syslog, ss))
}
def index():
cookie_str = request.cookies.get(COOKIE_NAME)
user={}
if cookie_str:
user = cookie2user(cookie_str)
num=db.session.query(db.func.count('*')).select_from(Blog).scalar()
page_num = request.args.get('page')
if not page_num:
page_num = '1'
page = Page(num,int(page_num))
blogs = Blog.query.order_by(db.desc(Blog.created_at)).offset(page.offset).limit(page.limit).all()
return render_template('blogs.html', blogs=blogs, user=user, page=page)
def api_reprints():
num=db.session.query(db.func.count('*')).select_from(Reprint).scalar()
page_num = request.args.get('page')
if not page_num:
page_num = '1'
page = Page(num,int(page_num))
reprints = Reprint.query.order_by(db.desc(Reprint.created_at)).offset(page.offset).limit(page.limit).all()
a = []
for reprint in reprints:
a.append(reprint.to_dict())
r=jsonify({'reprints':a, 'page':page.to_dict()})
r.content_type = 'application/json;charset=utf-8'
return r
def get_popular_drinks():
trans = db.session.query(Transaction.drink_id,
func.count(
Transaction.id).label('total')).group_by(
Transaction.drink_id).order_by(
db.desc('total')).limit(5).all()
output_formatted = []
for t in trans:
data = {}
data['sales'] = t[1]
data['drink_id'] = t[0]
output_formatted.append(data)
return jsonify({'success': True, 'toplist': output_formatted})
def api_get_users():
num=db.session.query(db.func.count('*')).select_from(User).scalar()
page_num = request.args.get('page')
if not page_num:
page_num = '1'
page = Page(num,int(page_num))
users = User.query.order_by(db.desc(User.created_at)).offset(page.offset).limit(page.limit).all()
a = []
for user in users:
user.passwd='******'
a.append(user.to_dict())
r=jsonify({'users':a,'page':page.to_dict()})
r.content_type = 'application/json;charset=utf-8'
return r
def shows():
data = []
shows_listed = db.session.query(Show).order_by(db.desc(Show.start_time))
for show in shows_listed:
data.append({
"artist_id": show.artist_id,
"artist_name": show.artist.name,
"artist_image_link": show.artist.image_link,
"start_time": str(show.start_time),
"venue_id": show.venue_id,
"venue_name": show.venue.name
})
return render_template('pages/shows.html', shows=data)
def get_blog(ID):
cookie_str = request.cookies.get(COOKIE_NAME)
user = {}
if cookie_str:
user = cookie2user(cookie_str)
blog = Blog.query.filter(Blog.id==ID).first()
comments = Comment.query.order_by(db.desc(Comment.created_at)).filter(Comment.blog_id==ID).all()
for c in comments:
c.html_content = text2html(c.content)
blog.html_content = text2html(blog.content)
if blog:
return render_template('blog.html', blog=blog, comments=comments, user=user)
else:
return redirect(url_for('index'))
def getallposts(order_by=None, desc=False, start=None, limit=None):
if order_by is None:
order_by = JobPost.datetime
filt = JobPost.query.filter(JobPost.status.in_([POSTSTATUS.CONFIRMED, POSTSTATUS.REVIEWED]))
count = filt.count()
if desc:
filt = filt.order_by(db.desc(order_by))
else:
filt = filt.order_by(order_by)
if start is not None:
filt = filt.offset(start)
if limit is not None:
filt = filt.limit(limit)
return count, filt
def shows():
# displays list of shows at /shows
data = []
shows = Show.query.order_by(db.desc(Show.start_time)).all()
for show in shows:
data.append({
"venue_id": show.venue.id,
"venue_name": show.venue.name,
"artist_id": show.artist.id,
"artist_name": show.artist.name,
"artist_image_link": show.artist.image_link,
"start_time": str(show.start_time)
})
return render_template('pages/shows.html', shows=data)
def get(self, page=1, per_page=20, tags='', keyword='', keyword_column=''):
page = max(page, 1)
tags = to_str_list(tags)
# print('papers get', page, per_page, tags, keyword, keyword_column)
q = Paper.query
if len(tags):
q = q.join(PaperHasTag).filter(PaperHasTag.tag_name.in_(tags))
if len(keyword) and len(keyword_column):
if keyword_column in Paper._dict_fields:
attr = getattr(Paper, keyword_column)
q = q.filter(attr.like('%{}%'.format(keyword)))
pagi = q.order_by(db.desc(Paper.published)).paginate(page=page,
per_page=per_page)
dic = make_pagnination_info_dict(pagi)
return dic
def shows():
shows = Show.query.order_by(db.desc(Show.start_time))
data = []
for show in shows:
data.append({
"venue_id": show.venue_id,
"venue_name": show.venue.name,
"artist_id": show.artist_id,
"artist_name": show.artist.name,
"artist_image_link": show.artist.image_link,
"start_time": format_datetime(str(show.start_time))
})
return render_template('pages/shows.html', shows=data)
def _get_token(self, token=None):
if token is not None:
return token
user_id = session.get('user_id')
latestToken = UserSPAccess.query\
.filter(UserSPAccess.user_id == user_id)\
.filter(UserSPAccess.sp_class_name == self.get_service_name())\
.order_by(db.desc(UserSPAccess.id))\
.first()
if latestToken is None:
return None
return (latestToken.token, latestToken.secret)
def search():
u = require_token()
page = get_num(request.args.get('page'))
pagesize = max(get_num(request.args.get('pagesize')), 200)
keywords = request.args.get('keywords')
pids = [tr.pid for tr in TagRecord.query.filter_by(tag=keywords).order_by(db.desc('pid')).paginate(page, pagesize).items]
data = [ map_post(Post.query.get(pid), u.name)
for pid in pids if Post.query.get(pid) and not Post.query.get(pid).deleted
]
return {
'code': 0,
'count': len(data),
'data': data
}
def get_list():
u = require_token()
p = get_num(request.args.get('p'))
posts = Post.query.filter_by(deleted=False)
if 'no_cw' in request.args:
posts = posts.filter_by(cw=None)
posts = posts.order_by(db.desc('comment_timestamp')) if 'by_c' in request.args else posts.order_by(db.desc('id'))
posts = posts.paginate(p, PER_PAGE)
data =list(map(map_post, posts.items, [u.name] * len(posts.items)))
return {
'code': 0,
'tmp_token': tmp_token(),
'count': len(data),
'data': data
}
def shows():
# displays list of shows at /shows
# TODO: replace with real venues data.
# num_shows should be aggregated based on number of upcoming shows per venue.
shows = Show.query.order_by(db.desc(Show.datetime))
data = []
for show in shows:
data.append({
"venue_id": show.venue_id,
"venue_name": show.venue.name,
"artist_id": show.artist_id,
"artist_name": show.artist.name,
"artist_image_link": show.artist.image_link,
"start_time": format_datetime(str(show.datetime))
})
return render_template('pages/shows.html', shows=data)
def getResult4():
result = Result.query.order_by(db.desc(Result.ts))
resultlist = []
for res in result:
data = {
'name': res.name,
'result': res.testresult,
'reqmethod': res.reqmethod,
'rspcode': res.rspcode,
'url': res.reqpath,
'reqhead': res.reqhead,
'reqbody': res.reqbody,
'rsphead': res.rsphead,
'rspbody': res.rspbody,
'reason': res.diff,
'time': res.ts
}
resultlist.append(data)
resp = jsonify(resultlist)
return resp
def getResult(resp=None):
# result = Result.query.all()
result = Result.query.order_by(db.desc(Result.ts))
resultlist = []
for res in result:
data = {
'name': res.name,
'result': res.testresult,
'reqmethod': res.reqmethod,
'rspcode': res.rspcode,
'url': res.reqpath,
'reqhead': res.reqhead,
'reqbody': res.reqbody,
'rsphead': res.rsphead,
'rspbody': res.rspbody,
'reason': res.diff,
'time': res.ts
}
resultlist.append(data)
return render_template("result.html", resp = resultlist)
def user_ads(user_id):
rooms = Room.query.filter_by(user_id=user_id).order_by(db.desc("created_at")).all()
# FIXME: Use a different template, later (can be very similar...)
return render_template("index.html", rooms=rooms)
def get(self):
return Todo.query.order_by(Todo.done, db.desc(Todo.date)).all()
def index():
images = Image.query.order_by(db.desc(Image.id)).limit(10).all()
return render_template('index.html', images=images)
def index():
data = Venue.query.order_by(db.desc(Venue.id)).limit(10).all()
data_ = Artist.query.order_by(db.desc(Artist.id)).limit(10).all()
return render_template('pages/home.html', data=data, data_=data_)
def show_log(page):
pagination = AssetLog.query.order_by(
db.desc(AssetLog.time)).paginate(page, 15)
return render_template('show_log.html', pagination=pagination)
def index():
venues = Venue.query.order_by(db.desc(Venue.created_date)).limit(10).all()
artists = Artist.query.order_by(db.desc(Artist.created_date)).limit(10).all()
return render_template('pages/home.html', venues=venues, artists=artists)
def get(self, page=1, per_page=20):
pagi = Log.query.order_by(db.desc(Log.id)).paginate(page=page, per_page=per_page)
dic = make_pagnination_info_dict(pagi)
return dic
def getposts(basequery=None):
if basequery is None:
basequery = JobPost.query
return basequery.filter(
JobPost.status.in_([POSTSTATUS.CONFIRMED, POSTSTATUS.REVIEWED])).filter(
JobPost.datetime > datetime.utcnow() - agelimit).order_by(db.desc(JobPost.datetime))
