def test_view_widgets(self):
# this test 3 valued widgets where valid values are 'yes', 'no' or '-'
# '-' is shown when no value given
client = self.app.test_client()
with self.app.test_request_context():
session = database.get_session()
row = database.ReportRow()
row.update(self.report_data)
session.save(row)
session.commit()
view_response = client.get('/reports/%s/' % row.id)
# clone self.report_data dict
data = dict(self.report_data)
del data[u'details_publisher']
with self.app.test_request_context():
session = database.get_session()
row.update(data)
session.save(row)
session.commit()
# no value given, look for '-'
label = 'Published by'
value = '-'
self.assertTrue(
common.search_label_value(label, value, view_response.data))
def test_delete(self):
client = self.app.test_client()
with self.app.test_request_context():
session = database.get_session()
row = database.ReportRow(name="v323x,3240543#%")
session.save(row)
session.commit()
post_response = client.post("reports/%s/delete/" % row.id)
list_response = client.get('/reports/')
self.assertFalse("v323x,3240543#%" in list_response.data)
self.assertIn("Report deleted.", list_response.data)
def test_update(self):
#NOTE this tests both report and seris
client = self.app.test_client()
with self.app.test_request_context():
session = database.get_session()
row = database.ReportRow()
row.update(self.report_data)
session.save(row)
session.commit()
# clone self.report_data dict
data = dict(self.report_data)
#add additional info
data.update({u'format_no_of_pages': u'2303445'})
#update existing info
data.update({u'header_uploader': u'Jerry Seinfeld'})
#remove info
del data[u'links_reference_global_level']
edit_response = client.post('/reports/%s/edit/' % row.id,
data=data,
follow_redirects=True)
# checking correct flash message
self.assertIn("Report saved.", edit_response.data)
# checking additional info
self.assertIn("2303445", edit_response.data)
# checking existing info update
self.assertIn("Jerry Seinfeld", edit_response.data)
# checking now if the checkbox has changed to No
label = "Global-level SOER.+s?"
value = 'No'
self.assertTrue(
common.search_label_value(label, value, edit_response.data))
def import_seris():
"""
Imported fields:
u'details_original_name'
u'format_availability_url'
'details_translated_in_0'
u'details_publisher'
'header_country_0'
u'format_date_of_last_update'
u'details_english_name'
u'format_report_type'
'details_original_language_0'
u'short_description'
"""
from seris_old import SERIS_DATA
from schema import _load_json
countries_mapping = _load_json("refdata/seris_old_countries_mapping.json")
countries_list = _load_json("refdata/countries_list.json")
countries = [pair[0] for pair in countries_list]
imported = 0
skipped = 0
for country, reports in SERIS_DATA.items():
if country == 'eea' or countries_mapping[country] in countries:
for form_data in reports:
report_row = database.ReportRow()
seris_review_row = database.SerisReviewRow()
session = database.get_session()
for k, v in form_data.items():
if v is None:
del (form_data[k])
found = False
for count in range(0, 100):
header_country = form_data.get('header_country_%s' % count)
if header_country not in countries:
if header_country:
del (form_data['header_country_%s' % count])
else:
found = True
if not found:
if country == 'eea':
print(
'Skipped report %s from eea: '
'countries not in scope' %
form_data.get('details_original_name'))
skipped += 1
continue
else:
form_data['header_country_0'] = countries_mapping[
country]
if country == 'eea':
form_data['header_region_0'] = (
'European Environment Agency')
if form_data.get('category') == 'National portal':
form_data['format_report_type'] = 'portal (dynamic source)'
try:
int(form_data.get('format_date_of_publication'))
except ValueError:
print 'Report %s in country %s - invalid year "%s"' % (
form_data.get('details_original_name'), country,
form_data.get('format_date_of_publication'))
except TypeError:
pass
report_schema = schema.ReportSchema.from_flat(form_data)
seris_review_schema = schema.SerisReviewSchema.from_flat(
form_data)
report_row.update(report_schema.flatten())
uploader = 'Imported from SERIS 1'
report_row['header_uploader'] = uploader
report_row['header_upload_date'] = '01 Jan 1999, 00:00'
session.save(report_row)
seris_review_schema['report_id'].set(report_row.id)
# Review part
seris_review_row.clear()
seris_review_row.update(seris_review_schema.flatten())
session.save(seris_review_row)
imported += 1
session.commit()
print '%s reports imported' % imported
print '%s reports skipped' % skipped
def report_edit(report_id=None):
country = flask.request.args.get('country')
if not country:
country = flask.request.form.get('country')
if country == u'None':
country = None
region = flask.request.args.get('region')
if not region:
region = flask.request.form.get('region')
if region == u'None':
region = None
if report_id is None:
report_row = database.ReportRow()
seris_review_row = database.SerisReviewRow()
else:
report_row = database.get_report_or_404(report_id)
reviews_list = database.get_seris_reviews_list(report_id)
if reviews_list:
# TODO to be changed when there will be more than one seris
seris_review_row = reviews_list[0]
else:
seris_review_row = database.SerisReviewRow()
if flask.request.method == 'POST':
session = database.get_session()
form_data = {}
form_data.update(schema.ReportSchema.from_defaults().flatten())
form_data.update(schema.SerisReviewSchema.from_defaults().flatten())
form_data.update(flask.request.form.to_dict())
_expand_lists(form_data, [
'header_region', 'header_country', 'header_subregion',
'details_translated_in', 'details_original_language',
'links_target_audience'
])
report_schema = schema.ReportSchema.from_flat(form_data)
seris_review_schema = schema.SerisReviewSchema.from_flat(form_data)
file_upload.handle_request(session, report_schema, report_row)
if report_schema.validate():
report_row.clear()
report_row.update(report_schema.flatten())
session.save(report_row)
# TODO create filter to display data without losing information
if report_row['format_report_type'] == 'report (static source)':
report_row['format_date_of_last_update'] = ''
report_row['format_freq_of_upd'] = ''
report_row['format_size'] = ''
if report_row['format_report_type'] == 'portals (dynamic source)':
report_row['format_date_of_publication'] = ''
report_row['format_freq_of_pub'] = ''
report_row['format_no_of_pages'] = ''
if report_row['format_availability_paper_or_web'] == 'paper only':
report_row['format_availability_registration_required'] = ''
report_row['format_availability_url'] = ''
if report_row['format_availability_paper_or_web'] in [
'web only', 'web and print'
]:
if not report_row['format_availability_registration_required']:
report_row['format_availability_costs'] = 'free'
uploader = getattr(flask.g, 'user_id', None)
if not uploader:
uploader = 'Developer'
report_row['header_uploader'] = uploader
now = datetime.datetime.now()
report_row['header_upload_date'] = now.strftime('%d %b %Y, %H:%M')
session.save(report_row)
seris_review_schema['report_id'].set(report_row.id)
if seris_review_schema.validate():
seris_review_row.clear()
seris_review_row.update(seris_review_schema.flatten())
if seris_review_row['structure_indicator_based'] == 'No':
seris_review_row['structure_indicators_estimation'] = ''
seris_review_row[
'structure_indicators_usage_to_compare_countries'] = ''
seris_review_row[
'structure_indicators_usage_to_compare_subnational'] = ''
seris_review_row[
'structure_indicators_usage_to_compare_eea'] = ''
seris_review_row[
'structure_indicators_usage_to_compare_global'] = ''
seris_review_row[
'structure_indicators_usage_to_assess_progress'] = ''
seris_review_row[
'structure_indicators_usage_to_evaluate'] = ''
seris_review_row[
'structure_indicators_usage_evaluation_method'] = ''
elif not seris_review_row[
'structure_indicators_usage_to_evaluate']:
seris_review_row[
'structure_indicators_usage_evaluation_method'] = ''
session.save(seris_review_row)
session.commit()
flask.flash("Report saved.", "success")
url = flask.url_for('views.report_view',
report_id=report_row.id)
title = report_row['details_original_name']
if report_id is None:
action = 'added'
else:
action = 'edited'
if not flask.current_app.config.get('SKIP_EDIT_AUTHORIZATION',
False):
contributor_name = '%s %s' % (getattr(
flask.g,
'user_first_name'), getattr(flask.g, 'user_last_name'))
contributor_profile = (
'http://www.eionet.europa.eu/directory/user?uid=%s' %
uploader)
send_notification_mail('%s%s' % (flask.request.host, url),
title, action, contributor_profile,
contributor_name, uploader)
if country:
url = url + '?country=' + country
if region:
url = url + '?region=' + region
return flask.redirect(url)
session.rollback()
flask.flash(
"There were some errors in the submitted form. "
"Please review look further down for the error messages.", "error")
else:
report_schema = schema.ReportSchema()
seris_review_schema = schema.SerisReviewSchema()
if report_id is not None:
report_schema = schema.ReportSchema.from_flat(report_row)
seris_review_schema = schema.SerisReviewSchema.from_flat(
seris_review_row)
app = flask.current_app
return flask.render_template(
'report-edit.html', **{
'mk':
MarkupGenerator(app.jinja_env.get_template('widgets-edit.html')),
'report_id': report_id,
'report_schema': report_schema,
'seris_review_schema': seris_review_schema,
'country': country,
'region': region,
})