def display_report(report, format):
report = CadorsReport.query.get_or_404(report)
if format == 'atom':
reports = process_report_atom([report])
feed_timestamp = generate(report.last_updated, accept_naive=True)
response = make_response(
render_template('feed.xml',
reports=reports,
feed_timestamp=feed_timestamp))
response.mimetype = "application/atom+xml"
elif format == 'json':
response = make_response(json.dumps(
{'report': report},
indent=None if request.is_xhr else 2,
default=json_default))
response.mimetype = "application/json"
elif format == 'html':
response = make_response(
render_template('single_report.html',
report=report))
elif format == 'kml':
response = make_response(render_template('kml.xml', report=report))
response.mimetype = "application/vnd.google-earth.kml+xml"
response.last_modified = report.last_updated
return prepare_response(response, 43200)
def display_categories():
categories = ReportCategory.query
categories = categories.add_column(
select(
[func.count()],
category_map.c.category_id == \
ReportCategory.category_id).select_from(
category_map).label('report_count'))
categories = categories.order_by('report_count DESC',
ReportCategory.text.asc()).all()
response = make_response(render_template('category_list.html',
categories=categories))
return prepare_response(response, 3600)
def do_input(year, month, day):
try:
ts = datetime(year, month, day)
except ValueError:
abort(400)
daily_report = DailyReport.query.filter(
DailyReport.report_date == ts).first_or_404()
filename = "report-%04d%02d%02d.html" % (year, month, day)
response = make_response(unicode(daily_report.report_html,
'utf-8'))
response.mimetype = 'text/html'
response.headers['Content-disposition'] = "attachment; filename=%s" % (filename)
return prepare_response(response, 43200)
def daily_reports_list(page):
query = DailyReport.query
query = query.add_column(
select(
[func.count()],
report_map.c.daily_report_id == \
DailyReport.daily_report_id).select_from(
report_map).label('report_count'))
pagination = query.paginate(page)
response = make_response(render_template('daily_report_list.html',
daily_reports=pagination.items,
pagination=pagination))
return prepare_response(response, 3600)
def search_location():
latitude = request.args['latitude']
longitude = request.args['longitude']
radius = int(request.args['radius'])
primary = True if (request.args['primary'] == 'primary') else False
page = int(request.args.get('page', '1'))
format = request.args.get('format', 'html')
radius_m = radius * 1000
wkt = "POINT(%s %s)" % (longitude, latitude)
location = WKTSpatialElement(wkt)
loc = sql.cast(LocationBase.location, Geography)
q_loc = sql.cast(location, Geography)
query = CadorsReport.query.join(LocationRef).join(LocationBase).filter(
functions.within_distance(loc, q_loc, radius_m))
if primary:
query = query.filter(LocationRef.primary == True)
if format == 'html':
query = query.add_column(functions.distance(loc, q_loc).label('distance'))
query = query.add_column(
func.ST_Azimuth(location,
LocationBase.location.RAW) * (180/func.pi()))
query = query.add_column(LocationBase.name)
query = query.order_by('distance ASC',
CadorsReport.timestamp.desc())
pagination = query.paginate(page)
response = make_response(
render_template('sr_loc.html',
reports=pagination.items, pagination=pagination,
get_direction=get_direction, radius=radius,
latitude=latitude, longitude=longitude))
return prepare_response(response, 300)
else:
pagination = query.paginate(page)
title = "Events within %s km of %s, %s" % (radius, latitude,
longitude)
return render_list(pagination, title, format)
def daily_report_full(year, month, day):
try:
ts = datetime(year, month, day)
except ValueError:
abort(400)
daily_report = DailyReport.query.filter(
DailyReport.report_date == ts).first_or_404()
reports = CadorsReport.query.with_parent(daily_report)
report_date = daily_report.report_date.strftime("%Y-%m-%d")
title = "Report details for %s" % (report_date)
if 'type' in request.args:
report_type = request.args['type']
reports = reports.filter(
CadorsReport.occurrence_type==report_type)
title = "%s reports for %s" % (report_type, report_date)
if 'region' in request.args:
region = request.args['region']
reports = reports.filter(
CadorsReport.region==region)
title = "Reports in %s for %s" % (region, report_date)
reports = reports.all()
response = make_response(
render_template('daily_report_full.html',
daily_report=daily_report,
reports=reports,
title=title))
response.last_modified = daily_report.last_updated
return prepare_response(response, 43200)
def search_text():
terms = request.args['q']
page = int(request.args.get('page', '1'))
format = request.args.get('format', 'html')
query = CadorsReport.query.filter(
'cadors_report.narrative_agg_idx_col @@ plainto_tsquery(:terms)')
query = query.params(terms=terms)
query = query.order_by(
'ts_rank_cd(narrative_agg_idx_col, plainto_tsquery(:terms)) DESC',
CadorsReport.timestamp.desc())
if format == 'html':
query = query.add_column(
func.ts_headline('pg_catalog.english',
CadorsReport.narrative_agg,
func.plainto_tsquery(terms),
'''MaxFragments=2,
MinWords=15,
MaxWords=20,
FragmentDelimiter=|||,
StartSel="<b>",
StopSel = "</b>"''',
type_=types.Unicode))
pagination = query.paginate(page)
response = make_response(
render_template('sr_text.html', reports=pagination.items,
pagination=pagination, terms=terms))
return prepare_response(response, 300)
else:
pagination = query.paginate(page)
title = "Results for '%s'" % (terms)
return render_list(pagination, title, format)
def do_daily_report(year, month, day, format):
try:
ts = datetime(year, month, day)
except ValueError:
abort(400)
daily_report = DailyReport.query.filter(
DailyReport.report_date == ts).first_or_404()
navlinks = make_navlinks(daily_report)
if format == 'atom':
reports = process_report_atom(daily_report.reports)
feed_timestamp = generate(daily_report.last_updated, accept_naive=True)
title = "Daily Report for %s" % ts.strftime("%Y-%m-%d")
first=navlinks['first'].link(format='atom', _external=True)
prev=navlinks['prev'].link(format='atom', _external=True) \
if navlinks['prev'] is not None else None
next=navlinks['next'].link(format='atom', _external=True) \
if navlinks['next'] is not None else None
last=navlinks['last'].link(format='atom', _external=True)
response = make_response(
render_template('feed.xml',
feed_timestamp=feed_timestamp,
reports=reports,
title=title,
first=first, next=next, prev=prev, last=last))
response.mimetype = "application/atom+xml"
elif format == 'html':
occurrence_type = CadorsReport.occurrence_type
type_count = func.count(CadorsReport.region)
types = db.session.query(occurrence_type, type_count).group_by(
occurrence_type).with_parent(
daily_report).order_by(type_count.desc()).all()
region = CadorsReport.region
region_count = func.count(CadorsReport.region)
regions = db.session.query(region, region_count).group_by(
region).with_parent(
daily_report).order_by(region_count.desc()).all()
response = make_response(
render_template('daily_report.html',
daily_report=daily_report,
reports=daily_report.reports,
types=types,
regions=regions,
**navlinks))
elif format == 'json':
response = make_response(json.dumps(
{'reports': daily_report.reports},
indent=None if request.is_xhr else 2,
default=json_default))
response.mimetype = "application/json"
response.last_modified = daily_report.last_updated
return prepare_response(response, 43200)
