def details():
pagelimit = current_user.ngs_per_page
page = request.args.get('page', 1, type=int)
table = request.args.get('table', '', str)
id = request.args.get('id')
target = models_table_name_dictionary.get(table, None)
if table == 'analysis':
return redirect(url_for('ngs.analysis', id=id))
if not target: abort(404)
try:
if table == 'sequence_round':
id = id[1:-1].split(',')
id = tuple(int(i) for i in id)
else:
id = int(id)
except:
abort(404)
entry = target.query.get(id)
if not entry: abort(404)
if table == 'selection':
query_result = Rounds.query.filter_by(selection_id=id).order_by(
Rounds.id.desc()).paginate(page, pagelimit, False)
elif table == 'round':
query_result = SeqRound.query.filter_by(rounds_id=id).order_by(
SeqRound.count.desc()).paginate(page, pagelimit, False)
if table in ['selection', 'round']:
next_url = url_for(
'ngs.details',
table=table,
id=id,
page=query_result.next_num,
) if query_result.has_next else None
prev_url = url_for(
'ngs.details',
table=table,
id=id,
page=query_result.prev_num,
) if query_result.has_prev else None
totalpages = query_result.total
start, end = pagination_gaps(page, totalpages, pagelimit)
page_url = [(i, url_for('ngs.details', table=table, page=i, id=id))
for i in range(start, end + 1)]
return render_template('ngs/details.html',
title=f'{entry.name}-Details',
entry=entry,
table=table,
query_result=query_result,
next_url=next_url,
prev_url=prev_url,
active=page,
page_url=page_url)
return render_template('ngs/details.html',
title=f'{entry.name}-Details',
entry=entry,
table=table)
def user_follow_slides():
ppt_id = request.args.get('id', 0)
pagelimit = current_user.slide_per_page
thumbnail = current_user.thumbnail
page = request.args.get('page', 1, type=int)
if ppt_id:
slides_id = current_user.follow_ppt_update().get(str(ppt_id), [])
if not slides_id:
return redirect(url_for('ppt.index', table='slide', id=ppt_id))
else:
slides_id = [
i for k in current_user.follow_ppt_update().values() for i in k
]
entries = Slide.query.filter(Slide.id.in_(slides_id)).order_by(
Slide.date.desc(), Slide.page.desc()).paginate(page, pagelimit, False)
totalpages = entries.total
start, end = pagination_gaps(page, totalpages, pagelimit, gap=15)
next_url = url_for(
'ppt.user_follow_slides',
page=entries.next_num,
) if entries.has_next else None
prev_url = url_for(
'ppt.user_follow_slides',
page=entries.prev_num,
) if entries.has_prev else None
page_url = [(i, url_for(
'ppt.user_follow_slides',
page=i,
)) for i in range(start, end + 1)]
return render_template('ppt/slide_comparison.html',
title='PPT Updates',
entries=entries.items,
next_url=next_url,
prev_url=prev_url,
tags_list=Slide.tags_list(),
page_url=page_url,
active=page,
backurl=request.referrer,
mode="follow_ppt",
ppt_id=ppt_id,
thumbnail=thumbnail)
def ppt_search_handler(query, field, ppt, date_from=None, date_to=None):
"""
in the order of:
query string, search field, ppt list
test, ['all'], ['all','tag'], ['all']
string, ['9'], ['all', 'title', 'body'], ['15', '16']
"""
page = request.args.get('page', 1, int)
pagelimit = current_user.slide_per_page
thumbnail = current_user.thumbnail
kwargs = {}
for k in request.args:
kwargs[k] = (request.args.getlist(k))
date_from = date_from or datetime(2010, 1, 1)
date_to = date_to or datetime.now()
kwargs.pop('page', None)
entries, total = Slide.search_in_id(query, field, ppt, date_from, date_to,
page, pagelimit)
start, end = pagination_gaps(page, total, pagelimit)
next_url = url_for('main.search', page=page +
1, **kwargs) if total > page * pagelimit else None
prev_url = url_for('main.search', page=page -
1, **kwargs) if page > 1 else None
page_url = [(i, url_for('main.search', page=i, **kwargs))
for i in range(start, end + 1)]
tags_list = Slide.tags_list()
return render_template('ppt/index.html',
title='Slide Search result',
entries=entries,
thumbnail=thumbnail,
next_url=next_url,
prev_url=prev_url,
table='slide',
nextcontent=None,
tags_list=tags_list,
page_url=page_url,
active=page,
id=id)
def bookmarked():
pagelimit = current_user.slide_per_page
thumbnail = current_user.thumbnail
page = request.args.get('page', 1, type=int)
when = [(j, i) for i, j in enumerate(current_user.bookmarked_ppt)]
if when:
entries = Slide.query.filter(Slide.id.in_(
current_user.bookmarked_ppt)).order_by(
db.case(when,
value=Slide.id)).paginate(page, pagelimit, False)
else:
entries = Slide.query.filter_by(id=None).paginate(
page, pagelimit, False)
totalpages = entries.total
start, end = pagination_gaps(page, totalpages, pagelimit, gap=15)
next_url = url_for(
'ppt.bookmarked',
page=entries.next_num,
) if entries.has_next else None
prev_url = url_for(
'ppt.bookmarked',
page=entries.prev_num,
) if entries.has_prev else None
page_url = [(i, url_for(
'ppt.bookmarked',
page=i,
)) for i in range(start, end + 1)]
return render_template('ppt/slide_comparison.html',
title='PPT-Bookmark',
entries=entries.items,
next_url=next_url,
prev_url=prev_url,
tags_list=Slide.tags_list(),
page_url=page_url,
active=page,
backurl=request.referrer,
mode="bookmarked_ppt",
thumbnail=thumbnail)
def browse():
pagelimit = current_user.ngs_per_page
table = request.args.get('table')
id = request.args.get('id', 0, type=int)
page = request.args.get('page', 1, type=int)
target = models_table_name_dictionary.get(table, None)
if target:
if id:
if table == 'round':
entries = target.query.filter_by(selection_id=id).order_by(
target.id.desc()).paginate(page, pagelimit, False)
elif table == 'sequence_round':
entries = target.query.filter_by(rounds_id=id).order_by(
target.count.desc()).paginate(page, pagelimit, False)
# entries = [SequenceDisplay(i.sequence,i.count,i.count/rd.totalread,rd.round_name) for i in r]
else:
entries = target.query.order_by(target.id.desc()).paginate(
page, pagelimit, False)
else:
if table == 'sequence_round':
sequences = db.session.query(Sequence.id).filter(
db.and_(Sequence.note.isnot(None),
Sequence.note != '')).subquery()
maxcounts = db.session.query(
SeqRound.sequence_id,
func.max(SeqRound.count).label('count')).filter(
SeqRound.sequence_id.in_(sequences)).group_by(
SeqRound.sequence_id).subquery()
entries = SeqRound.query.join(
Sequence, SeqRound.sequence_id == Sequence.id).filter(
SeqRound.sequence_id == maxcounts.c.sequence_id,
SeqRound.count == maxcounts.c.count).order_by(
Sequence.date.desc()).paginate(
page, pagelimit, False)
else:
entries = target.query.order_by(target.id.desc()).paginate(
page, pagelimit, False)
nextcontent = {
'round': 'sequence_round',
'selection': 'round'
}.get(table)
kwargs = {}
if id: kwargs.update(id=id)
totalpages = entries.total
start, end = pagination_gaps(page, totalpages, pagelimit)
next_url = url_for(
'ngs.browse', table=table, page=entries.next_num, **
kwargs) if entries.has_next else None
prev_url = url_for(
'ngs.browse', table=table, page=entries.prev_num, **
kwargs) if entries.has_prev else None
page_url = [(i, url_for('ngs.browse', table=table, page=i, **kwargs))
for i in range(start, end + 1)]
return render_template('ngs/browse.html',
title='NGS ' + (table.capitalize() or ' '),
entries=entries.items,
next_url=next_url,
prev_url=prev_url,
table=table,
nextcontent=nextcontent,
page_url=page_url,
active=page)
return render_template('ngs/browse.html',
title='NGS',
entries=[],
table='')
def index():
"""
main browsing page
"""
pagelimit = current_user.slide_per_page
thumbnail = current_user.thumbnail
table = request.args.get('table', None)
if not table:
return redirect(url_for('ppt.index', table='project'))
id = request.args.get('id', 0, type=int)
page = request.args.get('page', 1, type=int)
target = models_table_name_dictionary.get(table, None)
tag = request.args.get('tag', None)
if table == 'tags' and tag == None:
return render_template(
'ppt/index.html',
title=(table.upper() or ' ') + '-View',
table=table,
entries=Slide.tags_list(500, True),
)
author = request.args.get('author', None)
if table == 'authors' and author == None:
return render_template(
'ppt/index.html',
title=(table.upper() or ' ') + '-View',
table=table,
entries=Slide.authors_list(),
)
if table in ['trash', 'tags', 'authors']:
target = Slide
tags_list = Slide.tags_list()
if target:
if id:
if table == 'ppt':
entries = target.query.filter_by(project_id=id).order_by(
target.date.desc()).paginate(page, pagelimit, False)
elif table == 'slide':
entries = target.query.filter_by(ppt_id=id).order_by(
target.date.desc(),
target.page.desc()).paginate(page, pagelimit, False)
else:
entries = target.query.order_by(target.date.desc()).paginate(
page, pagelimit, False)
else:
if table == 'trash':
entries = target.query.filter_by(ppt_id=None).order_by(
target.date.desc(),
target.page.desc()).paginate(page, pagelimit, False)
elif table == 'tags':
table = 'slide'
entries = target.query.filter(
target.tag.contains(tag)).order_by(
target.date.desc(),
target.page.desc()).paginate(page, pagelimit, False)
elif table == 'authors':
table = 'slide'
author = None if author == 'Anonymous' else author
entries = target.query.filter(
target.author == author).order_by(
target.date.desc(),
target.page.desc()).paginate(page, pagelimit, False)
elif table == 'slide':
entries = target.query.filter(target.ppt_id != None).order_by(
target.date.desc(),
target.page.desc()).paginate(page, pagelimit, False)
else:
entries = target.query.order_by(target.date.desc()).paginate(
page, pagelimit, False)
nextcontent = {'ppt': 'slide', 'project': 'ppt'}.get(table)
kwargs = {}
if id:
kwargs.update(id=id)
totalpages = entries.total
start, end = pagination_gaps(page, totalpages, pagelimit, gap=15)
next_url = url_for(
'ppt.index', table=table, page=entries.next_num, **
kwargs) if entries.has_next else None
prev_url = url_for(
'ppt.index', table=table, page=entries.prev_num, **
kwargs) if entries.has_prev else None
page_url = [(i, url_for('ppt.index', table=table, page=i, **kwargs))
for i in range(start, end + 1)]
return render_template('ppt/index.html',
title=(table.upper() or ' ') + '-View',
entries=entries.items,
next_url=next_url,
prev_url=prev_url,
table=table,
nextcontent=nextcontent,
tags_list=tags_list,
page_url=page_url,
active=page,
id=id,
thumbnail=thumbnail)
return render_template('ppt/index.html',
title=(table.upper() or ' ') + '-View',
table=table,
tags_list=tags_list,
thumbnail=thumbnail)
def ngs_serach_handler(form):
pagelimit = current_user.ngs_per_page
table = form.search_field.data
target = models_table_name_dictionary.get(table)
method = form.search_method.data
page = request.args.get('page', 1, int)
kwargs = dict(request.args)
kwargs.pop('page', None)
nextcontent = {'round': 'sequence_round', 'selection': 'round'}.get(table)
seqdict = dict(primer='sequence',
known_sequence='rep_seq',
sequence='aptamer_seq')
if method == 'text':
if table == 'sequence':
table = 'sequence_round'
sequences = db.session.query(Sequence.id).filter(
Sequence.note.contains(form.q.data)).subquery()
maxcounts = db.session.query(
SeqRound.sequence_id,
func.max(SeqRound.count).label('count')).filter(
SeqRound.sequence_id.in_(sequences)).group_by(
SeqRound.sequence_id).subquery()
result = SeqRound.query.join(
Sequence, SeqRound.sequence_id == Sequence.id).filter(
SeqRound.sequence_id == maxcounts.c.sequence_id,
SeqRound.count == maxcounts.c.count).order_by(
Sequence.date.desc())
result = result.paginate(page, pagelimit, False)
total = result.total
entries = result.items
# subqry = db.session.query(func.max(sr.count)).filter(sr.sequence_id.in_([1,2,3,4,5]))
# sr.query.filter(sr.sequence.in_([1,2,3,4,5],sr.count==subqry)).all()
# subq=db.session.query(sr.sequence_id,func.max(sr.count).label('count')).filter(sr.sequence_id.in_([1,2,3,4,5])).group_by(sr.sequence_id).subquery()
# sr.query.filter(sr.sequence_id==subq.c.sequence_id,sr.count==subq.c.count).all()
else:
entries, total = target.search(form.q.data, page, pagelimit)
elif method == 'name':
q = form.q.data
if table == 'sequence':
table = 'sequence_round'
try:
seqid = convert_string_to_id(q)
except:
seqid = 0
result = SeqRound.query.filter(
SeqRound.sequence_id == seqid).order_by(SeqRound.count.desc())
else:
namedict = dict(analysis="name",
known_sequence='sequence_name',
selection='selection_name',
round='round_name',
primer='name',
ngs_sample_group='name')
result = target.query.filter(
getattr(target, namedict[table]).contains(q)).order_by(
target.id.desc())
result = result.paginate(page, pagelimit, False)
total = result.total
entries = result.items
elif method == 'sequence':
seq = form.q.data
if not validate_sequence(seq):
flash('Sequence not valid. Only ATCG is allowed.', 'warning')
return redirect(request.referrer)
revseq = reverse_comp(seq)
seqdict = dict(primer='sequence',
known_sequence='rep_seq',
sequence='aptamer_seq')
stmt = or_(
getattr(target, seqdict[table]).contains(seq),
getattr(target, seqdict[table]).contains(revseq))
if table == 'sequence':
table = 'sequence_round'
result = SeqRound.query.filter(
SeqRound.sequence_id.in_(
db.session.query(target.id).filter(stmt))).order_by(
SeqRound.count.desc())
else:
result = target.query.filter(stmt).order_by(target.id.desc())
result = result.paginate(page, pagelimit, False)
total = result.total
entries = result.items
elif method == 'distance':
seq = form.q.data
if not validate_sequence(seq):
flash('Sequence not valid. Only ATCG is allowed.', 'warning')
return redirect(request.referrer)
taskid = current_user.launch_search(seq, table)
target = models_table_name_dictionary.get(table)
total = target.query.count()
# render a template to display progress bar with task id, after done display result page.
return render_template('ngs/task_progress.html',
task_id=taskid,
table=table,
total=total)
start, end = pagination_gaps(page, total, pagelimit)
next_url = url_for('main.search', page=page +
1, **kwargs) if total > page * pagelimit else None
prev_url = url_for('main.search', page=page -
1, **kwargs) if page > 1 else None
page_url = [(i, url_for('main.search', page=i, **kwargs))
for i in range(start, end + 1)]
return render_template('ngs/browse.html',
title='Search Result',
table=table,
nextcontent=nextcontent,
entries=entries,
next_url=next_url,
prev_url=prev_url,
page_url=page_url,
active=page)
