def steep_category_edit(steep_category_id=None):
if not edit_is_allowed():
return flask.render_template(
'steep_category_edit.html', **{
'user_id': get_user_id(),
'steep_category_id': steep_category_id,
})
app = flask.current_app
session = database.session
referenced = False
if steep_category_id is None:
steep_categories_row = None
else:
steep_categories_row = database.get_or_404('steep_categories',
steep_category_id)
steep_category_schema = schema.SteepCategoriesSchema.from_flat(
steep_categories_row)
referenced = is_referenced(table='steep_categories',
row_id=steep_category_id)
if flask.request.method == 'POST':
form_data = dict(
schema.SteepCategoriesSchema.from_defaults().flatten())
form_data.update(flask.request.form.to_dict())
steep_category_schema = schema.SteepCategoriesSchema.from_flat(
form_data)
if steep_category_schema.validate():
if steep_categories_row is None:
steep_categories_row = session['steep_categories'].new()
steep_categories_row.update(steep_category_schema.flatten())
session.save(steep_categories_row)
session.commit()
flask.flash('Geographical coverage saved', 'success')
location = flask.url_for('lists.steep_category_view',
steep_category_id=steep_categories_row.id)
return flask.redirect(location)
else:
flask.flash(u'Errors in trends information', 'error')
else:
if steep_category_id:
steep_category_schema = schema.SteepCategoriesSchema.from_flat(
steep_categories_row)
else:
steep_category_schema = schema.SteepCategoriesSchema()
return flask.render_template(
'steep_category_edit.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_edit.html')),
'steep_category_schema': steep_category_schema,
'steep_category_id': steep_category_id,
'referenced': referenced,
})
def geo_scale_view(geo_scale_id):
app = flask.current_app
geo_scales_row = database.get_or_404('geo_scales', geo_scale_id)
geo_scale = schema.GeographicalScalesSchema.from_flat(geo_scales_row)
return flask.render_template(
'geo_scale_view.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_view.html')),
'geo_scale': geo_scale,
'geo_scale_id': geo_scale_id,
})
def source_view(source_id):
app = flask.current_app
sources_row = database.get_or_404('sources', source_id)
source = schema.SourcesSchema.from_flat(sources_row)
return flask.render_template(
'source_view.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_view.html')),
'source': source,
'source_id': source_id,
})
def interlink_view(interlink_id):
app = flask.current_app
interlinks_row = database.get_or_404('interlinks', interlink_id)
interlink = schema.InterlinksSchema.from_flat(interlinks_row)
return flask.render_template(
'interlink_view.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_view.html')),
'interlink': interlink,
'interlink_id': interlink_id,
})
def gmt_view(gmt_id):
app = flask.current_app
gmts_row = database.get_or_404('gmts', gmt_id)
gmt = schema.GMTsSchema.from_flat(gmts_row)
return flask.render_template(
'gmt_view.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_view.html')),
'gmt': gmt,
'gmt_id': gmt_id,
})
def photo(staff_id):
session = database.get_session()
staff_row = database.get_or_404("staff", staff_id)
try:
db_file = session.get_db_file(int(staff_row["photo"]))
except KeyError:
flask.abort(404)
return flask.Response(''.join(db_file.iter_data()), # TODO stream response
mimetype="application/octet-stream")
def timeline_view(timeline_id):
app = flask.current_app
timelines_row = database.get_or_404('timelines', timeline_id)
timeline = schema.TimelinesSchema.from_flat(timelines_row)
return flask.render_template(
'timeline_view.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_view.html')),
'timeline': timeline,
'timeline_id': timeline_id,
})
def trend_view(trend_id):
app = flask.current_app
trends_row = database.get_or_404('trends', trend_id)
trend = schema.TrendsSchema.from_flat(trends_row)
return flask.render_template(
'trend_view.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_view.html')),
'trend': trend,
'trend_id': trend_id,
})
def gmt_edit(gmt_id=None):
if not edit_is_allowed():
return flask.render_template(
'gmt_edit.html', **{
'user_id': get_user_id(),
'gmt_id': gmt_id,
})
app = flask.current_app
session = database.session
referenced = False
if gmt_id is None:
gmts_row = None
else:
gmts_row = database.get_or_404('gmts', gmt_id)
gmt_schema = schema.GMT.from_flat(gmts_row)
referenced = is_referenced(table='gmts', row_id=gmt_id)
if flask.request.method == 'POST':
form_data = dict(schema.GMTsSchema.from_defaults().flatten())
form_data.update(flask.request.form.to_dict())
gmt_schema = schema.GMTsSchema.from_flat(form_data)
if gmt_schema.validate():
if gmts_row is None:
gmts_row = session['gmts'].new()
gmts_row.update(gmt_schema.flatten())
session.save(gmts_row)
session.commit()
flask.flash('GMT saved', 'success')
location = flask.url_for('flis.gmt_view', gmt_id=gmts_row.id)
return flask.redirect(location)
else:
flask.flash(u'Errors in GMT information', 'error')
else:
if gmt_id:
gmt_schema = schema.GMTsSchema.from_flat(gmts_row)
else:
gmt_schema = schema.GMTsSchema()
return flask.render_template(
'gmt_edit.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_edit.html')),
'gmt_schema': gmt_schema,
'gmt_id': gmt_id,
'referenced': referenced,
})
def thematic_category_view(thematic_category_id):
app = flask.current_app
thematic_categories_row = database.get_or_404('thematic_categories',
thematic_category_id)
thematic_category = schema.ThematicCategoriesSchema.from_flat(
thematic_categories_row)
return flask.render_template(
'thematic_category_view.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_view.html')),
'thematic_category': thematic_category,
'thematic_category_id': thematic_category_id,
})
def steep_category_view(steep_category_id):
app = flask.current_app
steep_categories_row = database.get_or_404('steep_categories',
steep_category_id)
steep_category = schema.SteepCategoriesSchema.from_flat(
steep_categories_row)
return flask.render_template(
'steep_category_view.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_view.html')),
'steep_category': steep_category,
'steep_category_id': steep_category_id,
})
def indicator_delete(indicator_id):
if not edit_is_allowed():
return flask.render_template(
'indicator_edit.html', **{
'user_id': get_user_id(),
'indicator_id': indicator_id,
})
session = database.session
indicators_row = database.get_or_404('indicators', indicator_id)
_delete_file(indicators_row)
session['indicators'].delete(indicator_id)
session.commit()
return flask.redirect(flask.url_for('lists.indicators_listing'))
def interlink_edit(interlink_id=None):
if not edit_is_allowed():
return flask.render_template(
'interlink_edit.html', **{
'user_id': get_user_id(),
'interlink_id': interlink_id,
})
app = flask.current_app
session = database.session
if interlink_id is None:
interlinks_row = None
else:
interlinks_row = database.get_or_404('interlinks', interlink_id)
interlink_schema = schema.Interlink.from_flat(interlinks_row)
if flask.request.method == 'POST':
form_data = dict(schema.InterlinksSchema.from_defaults().flatten())
form_data.update(flask.request.form.to_dict())
interlink_schema = schema.InterlinksSchema.from_flat(form_data)
if interlink_schema.validate():
if interlinks_row is None:
interlinks_row = session['interlinks'].new()
interlinks_row.update(interlink_schema.flatten())
session.save(interlinks_row)
session.commit()
flask.flash('Interlink saved', 'success')
location = flask.url_for('flis.interlink_view',
interlink_id=interlinks_row.id)
return flask.redirect(location)
else:
flask.flash(u'Errors in Interlink information', 'error')
else:
if interlink_id:
interlink_schema = schema.InterlinksSchema.from_flat(
interlinks_row)
else:
interlink_schema = schema.InterlinksSchema()
return flask.render_template(
'interlink_edit.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_edit.html')),
'interlink_schema': interlink_schema,
'interlink_id': interlink_id,
})
def document_file_delete(meeting_id, document_id, lang):
meeting = sugar.get_object_or_404(models.Meeting, id=meeting_id)
response = {'status': 'success'}
document_row = database.get_or_404('document', document_id)
document_schema = schema.DocumentSchema.from_flat(document_row)
file_id = int(document_schema['doc_id'][lang].value)
document_schema['doc_id'][lang].set(None)
document_schema['filename'][lang].set(None)
document_row.clear()
document_row.update(document_schema.flatten())
session = database.get_session()
session.del_db_file(file_id)
session.save(document_row)
session.commit()
return flask.json.dumps(response)
def remove_photo(staff_id):
staff_row = database.get_or_404("staff", staff_id)
response = {}
photo = staff_row.get("photo", "")
if photo and photo.isdigit():
session = database.get_session()
session.del_db_file(int(staff_row["photo"]))
del staff_row["photo"]
session.save(staff_row)
session.commit()
response["status"] = "success"
else:
response["status"] = "error"
response["message"] = "Staff member doesn't have a photo"
return flask.json.dumps(response)
def resend_mail(mail_id):
app = flask.current_app
sent_mail = database.get_or_404('mail_log', mail_id)
sent_mail_schema = schema.MailSchema.from_flat(sent_mail)
if flask.request.method == 'POST':
mail = Mail(app)
meeting = schema.Meeting.get_or_404(sent_mail['meeting_id'])
msg = Message(sent_mail['mail_subject'],
sender=meeting['info']['admin_email'],
recipients=[m.value for m in sent_mail_schema['to']],
cc=[m.value for m in sent_mail_schema['cc']],
body=sent_mail['mail_message'])
mail.send(msg)
if app.config['MAIL_SUPPRESS_SEND']:
flask.flash(u'This is a demo, no real email was sent', 'info')
else:
flask.flash('Email resent.', 'success')
return flask.redirect(flask.url_for('meeting.view_mail_log',
meeting_id=sent_mail['meeting_id'],
mail_log_id=mail_id))
def edit_photo(staff_id):
response = {"status": "error"}
photo_file = flask.request.files["photo"]
if photo_file.filename != u'':
session = database.get_session()
db_file = session.get_db_file()
db_file.save_from(photo_file)
staff_row = database.get_or_404("staff", staff_id)
staff_row["photo"] = str(db_file.id)
session.save(staff_row)
session.commit()
response["status"] = "success"
response["url"] = flask.url_for("staff.photo", staff_id=staff_id)
else:
response["error"] = "Please select a photo"
return flask.json.dumps(response)
def view_mail_log(meeting_id, mail_log_id):
app = flask.current_app
mail_log_row = database.get_or_404('mail_log', mail_log_id)
meeting = sugar.get_object_or_404(models.Meeting, id=meeting_id)
if mail_log_row.get('type') == 'bulk_mail':
mail_log = schema.BulkMailLog.from_flat(mail_log_row)
mail_schema = schema.BulkMailSchema.from_flat(mail_log_row)
lang = mail_log['mail']['to']
mail_log['mail']['to'] = 'All %s speakers' % refdata.language.get(lang)
else:
mail_log = schema.MailLog.from_flat(mail_log_row)
mail_schema = schema.MailSchema.from_flat(mail_log_row)
return {
'mk': sugar.MarkupGenerator(
app.jinja_env.get_template('widgets/widgets_view_mail.html')
),
'meeting': meeting,
'mail_schema': mail_schema,
'mail_log': mail_log,
'mail_type': mail_log_row.get('type')
}
def has_file(self):
assert self.id is not None
indicator_row = database.get_or_404("indicators", self.id)
return bool(indicator_row.get("file_id", ""))
def edit_document(meeting_id, document_id=None):
app = flask.current_app
session = database.get_session()
meeting = sugar.get_object_or_404(models.Meeting, id=meeting_id)
page_info = {}
if document_id:
document_row = database.get_or_404('document', document_id)
document = schema.Document.from_flat(document_row)
page_info['title'] = 'Edit %s' % document['name']
else:
document_row = None
document = None
page_info['title'] = 'Add document'
if flask.request.method == 'POST':
doc = flask.request.files['file']
form_dict = flask.request.form.to_dict()
form_data = dict(schema.DocumentSchema.from_defaults().flatten())
form_data.update(form_dict)
lang = form_dict['language']
form_data['meeting_id'] = meeting.id
form_data['date'] = str(date.today())
# old files should be kept
db_file = session.get_db_file()
if document_row:
form_data['doc_id_E'] = document_row['doc_id_E']
form_data['doc_id_F'] = document_row['doc_id_F']
form_data['doc_id_S'] = document_row['doc_id_S']
form_data['filename_E'] = document_row['filename_E']
form_data['filename_F'] = document_row['filename_F']
form_data['filename_S'] = document_row['filename_S']
if doc.filename:
form_data['doc_id_%s' % lang] = db_file.id
form_data['filename_%s' % lang] = doc.filename
document_schema = schema.DocumentSchema.from_flat(form_data)
if document_schema.validate():
db_file.save_from(doc)
if document_row is None:
document_row = database.new('document')
document_row.update(document_schema.flatten())
session.save(document_row)
session.commit()
flask.flash('Document saved', 'success')
location = flask.url_for('meeting.documents',
meeting_id=meeting.id)
return flask.redirect(location)
else:
flask.flash(u'Errors in document information', 'error')
else:
if document_id:
document_schema = schema.DocumentSchema.from_flat(document_row)
else:
document_schema = schema.DocumentSchema()
return {
'mk': sugar.MarkupGenerator(
app.jinja_env.get_template('widgets/widgets_documents.html')
),
'meeting': meeting,
'document': document,
'document_schema': document_schema,
'document_id': document_id,
'page_info': page_info,
}
def indicator_edit(indicator_id=None):
if not edit_is_allowed():
return flask.render_template(
'indicator_edit.html', **{
'user_id': get_user_id(),
'indicator_id': indicator_id,
})
app = flask.current_app
session = database.session
referenced = False
if indicator_id is None:
indicators_row = None
else:
indicators_row = database.get_or_404('indicators', indicator_id)
indicator_schema = schema.IndicatorsSchema.from_flat(indicators_row)
referenced = is_referenced(table='indicators', row_id=indicator_id)
if flask.request.method == 'POST':
form_data = dict(schema.IndicatorsSchema.from_defaults().flatten())
form_data.update(flask.request.form.to_dict())
uploaded_file = flask.request.files['file']
file_error = None
if uploaded_file.filename != u'':
mb_limit = flask.current_app.config.get('FILE_SIZE_LIMIT_MB')
limit = mb_limit * MByte
try:
_save_file(form_data, uploaded_file, limit)
if indicators_row:
try:
_delete_file(indicators_row)
except IndicatorMissingFile:
pass
except FileSizeLimitExceeded:
file_error = 'File size limit exceeded (%d MB)' % mb_limit
indicator_schema = schema.IndicatorsSchema.from_flat(form_data)
if indicator_schema.validate() and not file_error:
if indicators_row is None:
indicators_row = session['indicators'].new()
indicators_row.update(indicator_schema.flatten())
session.save(indicators_row)
session.commit()
flask.flash('Indicator saved', 'success')
location = flask.url_for('lists.indicator_view',
indicator_id=indicators_row.id)
return flask.redirect(location)
else:
flask.flash(u'Errors in indicators information', 'error')
if file_error:
indicator_schema['file_id'].valid = False
indicator_schema['file_id'].errors.append(file_error)
else:
if indicator_id:
indicator_schema = schema.IndicatorsSchema.from_flat(
indicators_row)
else:
indicator_schema = schema.IndicatorsSchema()
if indicators_row:
indicator = schema.Indicator.from_flat(indicators_row)
else:
indicator = None
return flask.render_template(
'indicator_edit.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets_edit.html')),
'indicator_schema': indicator_schema,
'indicator': indicator,
'indicator_id': indicator_id,
'referenced': referenced,
})
