def dispatch_request(self):
if not current_user.is_authenticated():
raise PermissionDenied
period = request.args.get('period') or get_default_period()
period_obj = Dataset.query.get(period)
history = self.get_history(period)
return render_template(
self.template,
history=history,
subject_name=self.subject_name,
summary_endpoint=self.summary_endpoint,
period=period_obj,
)
def dispatch_request(self):
if not current_user.is_authenticated:
raise PermissionDenied
period = request.args.get('period') or get_default_period()
period_obj = Dataset.query.get(period)
history = self.get_history(period)
return render_template(
self.template,
history=history,
subject_name=self.subject_name,
summary_endpoint=self.summary_endpoint,
period=period_obj,
)
def get_default_values(self):
period = request.args.get('period') or get_default_period()
subject = request.args.get('subject')
region = request.args.get('region')
if consultation_ended() and (etc_perm.can() or admin_perm.can()):
best = (
self.model_manual_cls.query
.filter_by(
dataset_id=period,
subject=subject,
region=region,
decision='OK',
)
.first()
)
if best:
return best.__dict__
best = (
self.model_auto_cls.query
.filter_by(dataset_id=period, subject=subject, region=region)
.join(
EtcDicMethod,
self.model_auto_cls.assessment_method == EtcDicMethod.method
)
).all()
cmpf = (
lambda x, y:
-1 if x.assessment_method == '00' else cmp(x.order, y.order)
)
best.sort(cmp=cmpf)
values = {}
for f in all_fields(self.manual_form_cls()):
attr = f.name
for ass in filter(lambda a: getattr(a, attr, None), best):
if attr not in EXCLUDE_FIELDS:
values[attr] = split_semicolon(attr, getattr(ass, attr))
if attr in CONC_METHODS:
method = getattr(ass, 'assessment_method')
values[CONC_METHODS[attr]] = method
break
# Special case: conclusion_assessment_prev
prev_lu = (
self.prev_lu_cls.query
.filter_by(subject=subject, region=region, dataset_id=period)
.first()
)
if prev_lu:
values['conclusion_assessment_prev'] = prev_lu.conclusion_assessment
return values
def get_default_values(self):
period = request.args.get('period') or get_default_period()
subject = request.args.get('subject')
region = request.args.get('region')
if consultation_ended() and (etc_perm.can() or admin_perm.can()):
best = (self.model_manual_cls.query.filter_by(
dataset_id=period,
subject=subject,
region=region,
decision='OK',
).first())
if best:
return best.__dict__
best = (self.model_auto_cls.query.filter_by(
dataset_id=period, subject=subject, region=region).join(
EtcDicMethod,
self.model_auto_cls.assessment_method == EtcDicMethod.method)
).all()
cmpf = (lambda x, y: -1
if x.assessment_method == '00' else cmp(x.order, y.order))
best.sort(cmp=cmpf)
values = {}
# for f in all_fields(self.manual_form_cls()):
# attr = f.name
# for ass in filter(lambda a: getattr(a, attr, None), best):
# if attr not in EXCLUDE_FIELDS:
# values[attr] = split_semicolon(attr, getattr(ass, attr))
# if attr in CONC_METHODS:
# method = getattr(ass, 'assessment_method')
# values[CONC_METHODS[attr]] = method
# break
# Special case: conclusion_assessment_prev
prev_lu = (self.prev_lu_cls.query.filter_by(subject=subject,
region=region,
dataset_id=period).first())
if prev_lu:
if period == '3':
values[
'conclusion_assessment_prev'] = prev_lu.conclusion_assessment
if period == '5':
values[
'conclusion_assessment_prev'] = prev_lu.conclusion_assessment_prev
values[
'conclusion_assessment_trend_prev'] = prev_lu.conclusion_assessment_trend_prev
values['backcasted_2007'] = prev_lu.backcasted_2007
return values
def dispatch_request(self):
period = request.args.get('period') or get_default_period()
group = request.args.get('group')
country = request.args.get('country')
region = request.args.get('region')
self.objects = []
self.setup_objects_and_data(period, group, country, region)
countries = self.get_countries(period)
regions = self.get_regions_by_country(period, country)
report_filter_form = ReportFilterForm(
MultiDict(
dict(period=period,
group=group,
country=country,
region=region)))
report_filter_form.group.choices = self.get_groups(period)
report_filter_form.country.choices = countries
report_filter_form.region.choices = regions
countries_map = dict(countries)
regions_map = dict(regions)
period_query = Dataset.query.get(period)
period_name = period_query.name if period_query else ''
current_selection = self.get_current_selection(
period_name, group, countries_map.get(country, country),
regions_map.get(region, region))
context = self.get_context()
context.update({
'objects': self.objects,
'current_selection': current_selection,
'report_filter_form': report_filter_form,
'region': region,
'country': country,
'show_report_headers': True,
'dataset': period_query,
'generate_map_url': generate_map_url,
})
return render_template(self.template_name, **context)
def dispatch_request(self):
period = request.args.get('period') or get_default_period()
group = request.args.get('group')
country = request.args.get('country')
region = request.args.get('region')
self.objects = []
self.setup_objects_and_data(period, group, country, region)
countries = self.get_countries(period)
regions = self.get_regions_by_country(period, country)
report_filter_form = ReportFilterForm(
MultiDict(dict(period=period, group=group, country=country,
region=region))
)
report_filter_form.group.choices = self.get_groups(period)
report_filter_form.country.choices = countries
report_filter_form.region.choices = regions
countries_map = dict(countries)
regions_map = dict(regions)
period_query = Dataset.query.get(period)
period_name = period_query.name if period_query else ''
current_selection = self.get_current_selection(
period_name, group,
countries_map.get(country, country),
regions_map.get(region, region)
)
context = self.get_context()
context.update({
'objects': self.objects,
'current_selection': current_selection,
'report_filter_form': report_filter_form,
'region': region,
'country': country,
'show_report_headers': True,
'dataset': period_query,
'generate_map_url': generate_map_url,
})
return render_template(self.template_name, **context)
def dispatch_request(self, period_param=None, group_param=None):
period = period_param or request.args.get('period') or get_default_period()
group = group_param or request.args.get('group')
conclusion = request.args.get('conclusion') or DEFAULT_CONCLUSION
assessor = request.args.get('assessor')
extra = request.args.get('extra') or ''
progress_filter_form = ProgressFilterForm(
MultiDict(dict(period=period, group=group, conclusion=conclusion,
assessor=assessor, extra=extra))
)
progress_filter_form.group.choices = self.get_groups(period)
progress_filter_form.conclusion.choices = self.get_conclusions()
progress_filter_form.assessor.choices = (
self.get_assessors(period, group)
)
period_query = Dataset.query.get(period)
period_name = period_query.name if period_query else ''
regions = (
EtcDicBiogeoreg.query
.with_entities(EtcDicBiogeoreg.reg_code)
.filter_by(dataset_id=period)
.order_by(EtcDicBiogeoreg.order)
)
current_selection = self.get_current_selection(
period_name, group, conclusion)
self.DECISION_DETAILS = self.get_decision_details()
self.METHOD_DETAILS = self.get_method_details()
presence = self.get_presence(period)
data_dict = self.setup_objects_and_data(period, group, conclusion,
assessor)
comment_counts = self.get_comment_counts(period)
ret_dict = {}
for subject, region in data_dict.iteritems():
ret_dict[subject] = {}
for region, cell_options in region.iteritems():
presence_info = presence.get(subject, {}).get(region, {})
cell = self.process_cell(
subject, region, cell_options, conclusion, presence_info,
comment_counts,
)
ret_dict[subject][region] = cell
context = self.get_context()
context.update({
'progress_filter_form': progress_filter_form,
'current_selection': current_selection,
'period_name': period_name,
'group': group,
'conclusion': conclusion,
'subjects': self.subjects_by_group(period, group),
'regions': regions.all(),
'objects': ret_dict,
'dataset': period_query,
'summary_endpoint': self.summary_endpoint,
'extra': extra,
})
return render_template(self.template_name, **context)
def species_config_xml():
dataset_id = get_default_period()
region = flask.request.args.get('region', '')
species = flask.request.args.get('species', '')
species_name = base64.urlsafe_b64decode(species.encode('ascii'))
user = flask.g.get('user')
roles = [r.name for r in user.roles] if user and user.id else []
if region == '':
rows = (models.db.session.query(
models.EtcDataSpeciesRegion.region).distinct().filter_by(
assesment_speciesname=species_name).filter(
models.EtcDataSpeciesRegion.dataset_id ==
dataset_id).order_by(models.EtcDataSpeciesRegion.region))
region = '/%s/' % '|'.join(['^%s' % rec[0] for rec in rows])
else:
region = "/^%s/" % region
results = (models.db.session.query(
models.EtcDataSpeciesRegion.eu_country_code,
models.EtcDataSpeciesRegion.code,
models.EtcDataSpeciesRegion.conclusion_assessment,
models.EtcDataSpeciesRegion.region).filter(
models.EtcDataSpeciesRegion.region.in_(region[1:-1].replace(
'^', '').split('|'))
).filter(models.EtcDataSpeciesRegion.dataset_id == dataset_id).filter(
models.EtcDataSpeciesRegion.assesment_speciesname == species_name))
assesment_speciesname = urllib.quote(species_name)
countries_style = []
countries = []
species_code = ''
def background_colour(value):
colors = [
'#70a800', '#e69800', '#e69800', '#e69800', '#d62b00', '#d62b00',
'#d62b00', '#b4b4b4', '#FFFFFF'
]
assessments = ['FV', 'U1', 'U1-', 'U1+', 'U2', 'U2-', 'U2+', 'XX', '']
RGBS = dict(zip(assessments, [x for x in colors]))
colour = RGBS.get(value, '')
if colour:
return colour[1:]
else:
return ''
def get_coordinates(region="/MED/",
qstring="/FR|RO|IT/",
url="http://merlin.eea.europa.eu/cgi-bin/art17wsQ?%s"):
""" open url and sort coordinates """
params = urllib.urlencode({
'mode': 'ITEMNQUERY',
'LAYER': 'Europe_BIOGEO_MERGE30Jan',
'qlayer': 'Europe_BIOGEO_MERGE30Jan',
'qitem': 'Country',
'rg': region,
'qstring': qstring
})
f = urllib.urlopen(url % params)
line = f.readline()
minx, miny, maxx, maxy = line.split()
for line in f.readlines():
cur_minx, cur_miny, cur_maxx, cur_maxy = line.split()
minx = min(minx, cur_minx)
maxx = max(maxx, cur_maxx)
miny = min(miny, cur_miny)
maxy = max(maxy, cur_maxy)
return [minx, miny, maxx, maxy]
for res in results:
if res.eu_country_code == 'UK':
country = 'GB'
else:
if res.eu_country_code == 'EL':
country = 'GR'
else:
country = res.eu_country_code
species_code = res.code
countries.append(country)
countries_style.append('l=%s%s|%s' %
(country, res.region,
background_colour(res.conclusion_assessment)))
qstring = "/%s/" % '|'.join(countries)
#extent = get_coordinates(region, qstring)
extent = [2635945.400202, 1385857.104555, 6084637.867846, 5307244.006638]
rows = (models.db.session.query(
models.t_restricted_species.c.eu_country_code, ).filter(
models.t_restricted_species.c.assesment_speciesname == species_name
).filter(models.t_restricted_species.c.ext_dataset_id == dataset_id))
restricted_species_list = [r[0] for r in rows]
restricted = not ((species_name.lower() not in restricted_species_list)
or 'admin' in roles or 'nat' in roles)
body = flask.render_template(
'maps/config-species.xml',
restricted=restricted,
extent=','.join(str(v) for v in extent),
assessment_speciesname=assesment_speciesname,
countries_style=Markup('&'.join(escape(s) for s in countries_style)),
region=region,
)
return flask.Response(body, content_type='text/xml')
def habitats_config_xml():
dataset_id = get_default_period()
def select_habitat_regions(habitatcode):
"""
SELECT DISTINCT
etc_data_habitattype_regions.region
FROM
etc_data_habitattype_regions
WHERE <dtml-sqltest name="habitatcode" column="etc_data_habitattype_regions.habitatcode" type=string>
"""
return (models.db.session.query(
models.EtcDataHabitattypeRegion.region, ).distinct().filter_by(
dataset_id=dataset_id).filter_by(habitatcode=habitatcode))
def getRegions(habitat):
regions = [
'^%s' % rec.region
for rec in select_habitat_regions(habitatcode=habitat)
]
return '|'.join(regions)
def select_habitat_countries(region_list, habitatcode):
"""
SELECT
eu_country_code,
code,
conclusion_assessment,
region
FROM
etc_data_habitattype_regions
WHERE <dtml-sqltest region type="string" multiple="multiple">
AND <dtml-sqltest habitatcode type=string>
"""
return (models.db.session.query(
models.EtcDataHabitattypeRegion.eu_country_code,
models.EtcDataHabitattypeRegion.code,
models.EtcDataHabitattypeRegion.conclusion_assessment,
models.EtcDataHabitattypeRegion.region,
).filter(
models.EtcDataHabitattypeRegion.region.in_(region_list)).filter_by(
habitatcode=habitatcode).filter_by(dataset_id=dataset_id))
def background_colour(value):
colors = ('#9CB34D', '#D16E43', '#D16E43', '#D16E43', '#C22C15',
'#C22C15', '#C22C15', '#6F6C66', '#FFFFFF')
assessments = ('FV', 'U1', 'U1-', 'U1+', 'U2', 'U2-', 'U2+', 'XX', '')
RGBS = dict(zip(assessments, [x for x in colors]))
colour = RGBS.get(value, '')
if colour:
return colour[1:]
else:
return ''
region = flask.request.args.get('region', '')
habitat = flask.request.args.get('habitat', '')
if region == '':
region = '/%s/' % getRegions(habitat)
else:
region = "/^%s/" % region
results = select_habitat_countries(region_list=region[1:-1].replace(
'^', '').split('|'),
habitatcode=habitat)
countries_style = []
countries = []
habitat_code = ''
for res in results:
if res.eu_country_code == 'UK':
country = 'GB'
else:
if res.eu_country_code == 'EL':
country = 'GR'
else:
country = res.eu_country_code
habitat_code = res.code
countries.append(country)
countries_style.append('l=%s%s|%s' %
(country, res.region,
background_colour(res.conclusion_assessment)))
qstring = "/%s/" % '|'.join(countries)
#extent = get_coordinates(region, qstring)
extent = [2635945.400202, 1385857.104555, 6084637.867846, 5307244.006638]
body = flask.render_template(
'maps/config-habitats.xml',
extent=','.join(str(v) for v in extent),
habitat_code=habitat_code,
countries_style=Markup('&'.join(escape(s) for s in countries_style)),
region=region,
)
return flask.Response(body, content_type='text/xml')
def species_config_xml():
dataset_id = get_default_period()
region = flask.request.args.get('region', '')
species = flask.request.args.get('species', '')
species_name = base64.urlsafe_b64decode(species.encode('ascii'))
user = flask.g.get('user')
roles = [r.name for r in user.roles] if user and user.id else []
if region == '':
rows = (
models.db.session.query(
models.EtcDataSpeciesRegion.region
)
.distinct()
.filter_by(assesment_speciesname=species_name)
.filter(models.EtcDataSpeciesRegion.dataset_id == dataset_id)
.order_by(models.EtcDataSpeciesRegion.region)
)
region = '/%s/' % '|'.join(['^%s' % rec[0] for rec in rows])
else:
region = "/^%s/" % region
results = (
models.db.session.query(
models.EtcDataSpeciesRegion.eu_country_code,
models.EtcDataSpeciesRegion.code,
models.EtcDataSpeciesRegion.conclusion_assessment,
models.EtcDataSpeciesRegion.region
)
.filter(
models.EtcDataSpeciesRegion.region.in_(
region[1:-1].replace('^', '').split('|'))
)
.filter(models.EtcDataSpeciesRegion.dataset_id == dataset_id)
.filter(models.EtcDataSpeciesRegion.assesment_speciesname
== species_name)
)
assesment_speciesname=urllib.quote(species_name)
countries_style = []
countries = []
species_code = ''
def background_colour(value):
colors = ['#70a800','#e69800','#e69800','#e69800','#d62b00',
'#d62b00','#d62b00','#b4b4b4','#FFFFFF']
assessments = ['FV','U1','U1-','U1+','U2','U2-','U2+','XX','']
RGBS = dict(zip(assessments, [x for x in colors]))
colour = RGBS.get(value,'')
if colour:
return colour[1:]
else:
return ''
def get_coordinates(region="/MED/", qstring="/FR|RO|IT/",
url="http://merlin.eea.europa.eu/cgi-bin/art17wsQ?%s"):
""" open url and sort coordinates """
params = urllib.urlencode({
'mode':'ITEMNQUERY',
'LAYER': 'Europe_BIOGEO_MERGE30Jan',
'qlayer': 'Europe_BIOGEO_MERGE30Jan',
'qitem': 'Country',
'rg': region,
'qstring': qstring})
f = urllib.urlopen(url % params)
line = f.readline()
minx, miny, maxx, maxy = line.split()
for line in f.readlines():
cur_minx, cur_miny, cur_maxx, cur_maxy = line.split()
minx = min(minx, cur_minx)
maxx = max(maxx, cur_maxx)
miny = min(miny, cur_miny)
maxy = max(maxy, cur_maxy)
return [minx, miny, maxx, maxy]
for res in results:
if res.eu_country_code == 'UK':
country = 'GB'
else:
if res.eu_country_code == 'EL':
country = 'GR'
else:
country = res.eu_country_code
species_code = res.code
countries.append(country)
countries_style.append('l=%s%s|%s' % (country, res.region, background_colour(res.conclusion_assessment)))
qstring="/%s/" % '|'.join(countries)
#extent = get_coordinates(region, qstring)
extent = [2635945.400202,1385857.104555,6084637.867846,5307244.006638]
rows = (
models.db.session.query(
models.t_restricted_species.c.eu_country_code,
)
.filter(models.t_restricted_species.c.assesment_speciesname
== species_name)
.filter(models.t_restricted_species.c.ext_dataset_id == dataset_id)
)
restricted_species_list = [r[0] for r in rows]
restricted = not (
(species_name.lower() not in restricted_species_list)
or 'admin' in roles
or 'nat' in roles
)
body = flask.render_template('maps/config-species.xml',
restricted=restricted,
extent=','.join(str(v) for v in extent),
assessment_speciesname=assesment_speciesname,
countries_style=Markup('&'.join(
escape(s) for s in countries_style)),
region=region,
)
return flask.Response(body, content_type='text/xml')
def habitats_config_xml():
dataset_id = get_default_period()
def select_habitat_regions(habitatcode):
"""
SELECT DISTINCT
etc_data_habitattype_regions.region
FROM
etc_data_habitattype_regions
WHERE <dtml-sqltest name="habitatcode" column="etc_data_habitattype_regions.habitatcode" type=string>
"""
return (
models.db.session.query(
models.EtcDataHabitattypeRegion.region,
)
.distinct()
.filter_by(dataset_id=dataset_id)
.filter_by(habitatcode=habitatcode)
)
def getRegions(habitat):
regions = ['^%s' % rec.region for rec in
select_habitat_regions(habitatcode=habitat)]
return '|'.join(regions)
def select_habitat_countries(region_list, habitatcode):
"""
SELECT
eu_country_code,
code,
conclusion_assessment,
region
FROM
etc_data_habitattype_regions
WHERE <dtml-sqltest region type="string" multiple="multiple">
AND <dtml-sqltest habitatcode type=string>
"""
return (
models.db.session.query(
models.EtcDataHabitattypeRegion.eu_country_code,
models.EtcDataHabitattypeRegion.code,
models.EtcDataHabitattypeRegion.conclusion_assessment,
models.EtcDataHabitattypeRegion.region,
)
.filter(models.EtcDataHabitattypeRegion.region.in_(region_list))
.filter_by(habitatcode=habitatcode)
.filter_by(dataset_id=dataset_id)
)
def background_colour(value):
colors = ('#9CB34D', '#D16E43', '#D16E43', '#D16E43', '#C22C15',
'#C22C15', '#C22C15', '#6F6C66', '#FFFFFF')
assessments = ('FV', 'U1', 'U1-', 'U1+', 'U2', 'U2-', 'U2+', 'XX', '')
RGBS = dict(zip(assessments, [x for x in colors]))
colour = RGBS.get(value, '')
if colour:
return colour[1:]
else:
return ''
region = flask.request.args.get('region', '')
habitat = flask.request.args.get('habitat', '')
if region == '':
region = '/%s/' % getRegions(habitat)
else:
region = "/^%s/" % region
results = select_habitat_countries(
region_list=region[1:-1].replace('^', '').split('|'),
habitatcode=habitat)
countries_style = []
countries = []
habitat_code = ''
for res in results:
if res.eu_country_code == 'UK':
country = 'GB'
else:
if res.eu_country_code == 'EL':
country = 'GR'
else:
country = res.eu_country_code
habitat_code = res.code
countries.append(country)
countries_style.append('l=%s%s|%s' % (
country,
res.region,
background_colour(res.conclusion_assessment)))
qstring="/%s/" % '|'.join(countries)
#extent = get_coordinates(region, qstring)
extent = [2635945.400202,1385857.104555,6084637.867846,5307244.006638]
body = flask.render_template('maps/config-habitats.xml',
extent=','.join(str(v) for v in extent),
habitat_code=habitat_code,
countries_style=Markup('&'.join(
escape(s) for s in countries_style)),
region=region,
)
return flask.Response(body, content_type='text/xml')
def dispatch_request(self):
period = request.args.get('period') or get_default_period()
subject = request.args.get('subject')
group = request.args.get('group')
region = request.args.get('region')
action = request.args.get('action')
rowid = request.args.get('rowid')
fresh_new_record = False
self.objects = []
self.restricted_countries = []
self.auto_objects = []
self.manual_objects = []
self.setup_objects_and_data(period, subject, region)
group = group or self.get_group_for_subject(subject)
regions = self.get_regions(period, subject)
summary_filter_form = SummaryFilterForm(
MultiDict(
dict(period=period,
group=group,
subject=subject,
region=region)))
summary_filter_form.group.choices = self.get_groups(period)
summary_filter_form.subject.choices = self.get_subjects(period, group)
summary_filter_form.region.choices = regions
manual_form, manual_assessment = self.get_manual_form(
request.form,
period=period,
action=action,
)
manual_form.region.choices = self.get_regions(period, subject, True)
if period != '4':
manual_form.region.choices = manual_form.region.choices[1:]
if not request.form.get('region'):
manual_form.region.process_data(region or manual_form.region.data)
if hasattr(manual_form, 'MS'):
manual_form.kwargs = dict(subject=subject, period=period)
manual_form.MS.choices = self.get_user_MS(subject, region, period)
if request.method == 'POST':
home_url = url_for(self.summary_endpoint,
period=period,
subject=subject,
region=region)
if manual_form.validate(subject=subject, period=period):
if not can_touch(manual_assessment):
raise PermissionDenied()
if not manual_assessment:
manual_assessment = self.model_manual_cls(subject=subject)
manual_form.populate_obj(manual_assessment)
manual_assessment.last_update = datetime.now().strftime(
DATE_FORMAT)
if EU_ASSESSMENT_MODE:
user = RegisteredUser.query.filter_by(
id='test_for_eu_assessment').first()
if not user:
user = RegisteredUser(
id='test_for_eu_assessment',
name='Test_for_eu_assessment',
account_date=datetime.now())
db.session.add(user)
db.session.commit()
manual_assessment.user_id = user.id
else:
manual_assessment.user_id = current_user.id
manual_assessment.dataset_id = period
db.session.flush()
db.session.add(manual_assessment)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
flash('A record with the same keys exist. Cannot add',
'error')
else:
flash('Conclusion added successfully')
fresh_new_record = manual_assessment
manual_assessment = None
else:
manual_form.populate_obj(manual_assessment)
manual_assessment.last_update = datetime.now().strftime(
DATE_FORMAT)
db.session.add(manual_assessment)
db.session.commit()
flash('Conclusion edited successfully')
if rowid:
home_url += '#man-row-' + rowid
return redirect(home_url)
else:
flash('Please correct the errors below and try again.')
self.dataset = Dataset.query.get(period)
period_name = self.dataset.name if self.dataset else ''
current_selection = self.get_current_selection(period_name, group,
subject, region, period)
annexes = self.get_annexes(subject, period)
default_ms = DEFAULT_MS if not nat_perm.can() else current_user.MS
context = self.get_context()
context.update({
'objects':
self.objects,
'auto_objects':
self.auto_objects,
'manual_objects':
self.filter_conclusions(self.manual_objects),
'restricted_countries':
self.restricted_countries,
'regions':
regions,
'summary_filter_form':
summary_filter_form,
'manual_form':
manual_form,
'manual_assessment':
manual_assessment,
'edit_ref':
must_edit_ref(manual_assessment),
'current_selection':
current_selection,
'annexes':
annexes,
'group':
group,
'subject':
subject,
'region':
region,
'period_name':
period_name,
'dataset':
self.dataset,
'default_ms':
default_ms,
'fresh_new_record':
fresh_new_record,
})
return render_template(self.template_name, **context)
def dispatch_request(self):
period = request.args.get('period') or get_default_period()
subject = request.args.get('subject')
group = request.args.get('group')
region = request.args.get('region')
action = request.args.get('action')
rowid = request.args.get('rowid')
fresh_new_record = False
self.objects = []
self.restricted_countries = []
self.auto_objects = []
self.manual_objects = []
self.setup_objects_and_data(period, subject, region)
group = group or self.get_group_for_subject(subject)
regions = self.get_regions(period, subject)
summary_filter_form = SummaryFilterForm(
MultiDict(dict(period=period, group=group, subject=subject,
region=region)
)
)
summary_filter_form.group.choices = self.get_groups(period)
summary_filter_form.subject.choices = self.get_subjects(period, group)
summary_filter_form.region.choices = regions
manual_form, manual_assessment = self.get_manual_form(
request.form, period=period, action=action,
)
manual_form.region.choices = self.get_regions(period, subject, True)
if period != '4':
manual_form.region.choices = manual_form.region.choices[1:]
if not request.form.get('region'):
manual_form.region.process_data(region or manual_form.region.data)
if hasattr(manual_form, 'MS'):
manual_form.kwargs = dict(subject=subject, period=period)
manual_form.MS.choices = self.get_user_MS(subject, region, period)
if request.method == 'POST':
home_url = url_for(self.summary_endpoint, period=period,
subject=subject, region=region)
if manual_form.validate(subject=subject, period=period):
if not can_touch(manual_assessment):
raise PermissionDenied()
if not manual_assessment:
manual_assessment = self.model_manual_cls(subject=subject)
manual_form.populate_obj(manual_assessment)
manual_assessment.last_update = datetime.now().strftime(DATE_FORMAT)
if EU_ASSESSMENT_MODE:
user = RegisteredUser.query.filter_by(
id='test_for_eu_assessment').first()
if not user:
user = RegisteredUser(id='test_for_eu_assessment',
name='Test_for_eu_assessment',
account_date=datetime.now())
db.session.add(user)
db.session.commit()
manual_assessment.user_id = user.id
else:
manual_assessment.user_id = current_user.id
manual_assessment.dataset_id = period
db.session.flush()
db.session.add(manual_assessment)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
flash('A record with the same keys exist. Cannot add',
'error')
else:
flash('Conclusion added successfully')
fresh_new_record = manual_assessment
manual_assessment = None
else:
manual_form.populate_obj(manual_assessment)
manual_assessment.last_update = datetime.now().strftime(DATE_FORMAT)
db.session.add(manual_assessment)
db.session.commit()
flash('Conclusion edited successfully')
if rowid:
home_url += '#man-row-' + rowid
return redirect(home_url)
else:
flash('Please correct the errors below and try again.')
self.dataset = Dataset.query.get(period)
period_name = self.dataset.name if self.dataset else ''
current_selection = self.get_current_selection(
period_name, group, subject, region, period)
annexes = self.get_annexes(subject, period)
default_ms = DEFAULT_MS if not nat_perm.can() else current_user.MS
context = self.get_context()
context.update({
'objects': self.objects,
'auto_objects': self.auto_objects,
'manual_objects': self.filter_conclusions(self.manual_objects),
'restricted_countries': self.restricted_countries,
'regions': regions,
'summary_filter_form': summary_filter_form,
'manual_form': manual_form,
'manual_assessment': manual_assessment,
'edit_ref': must_edit_ref(manual_assessment),
'current_selection': current_selection,
'annexes': annexes,
'group': group,
'subject': subject,
'region': region,
'period_name': period_name,
'dataset': self.dataset,
'default_ms': default_ms,
'fresh_new_record': fresh_new_record,
})
return render_template(self.template_name, **context)
def dispatch_request(self, period_param=None, group_param=None):
period = period_param or request.args.get('period') or get_default_period()
group = group_param or request.args.get('group')
conclusion = request.args.get('conclusion') or DEFAULT_CONCLUSION
assessor = request.args.get('assessor')
extra = request.args.get('extra') or ''
progress_filter_form = ProgressFilterForm(
MultiDict(dict(period=period, group=group, conclusion=conclusion,
assessor=assessor, extra=extra))
)
progress_filter_form.group.choices = self.get_groups(period)
progress_filter_form.conclusion.choices = self.get_conclusions()
progress_filter_form.assessor.choices = (
self.get_assessors(period, group)
)
period_query = Dataset.query.get(period)
period_name = period_query.name if period_query else ''
regions = (
EtcDicBiogeoreg.query
.with_entities(EtcDicBiogeoreg.reg_code)
.filter_by(dataset_id=period)
.order_by(EtcDicBiogeoreg.order)
)
current_selection = self.get_current_selection(
period_name, group, conclusion)
self.DECISION_DETAILS = self.get_decision_details()
self.METHOD_DETAILS = self.get_method_details()
presence = self.get_presence(period)
data_dict = self.setup_objects_and_data(period, group, conclusion,
assessor)
comment_counts = self.get_comment_counts(period)
ret_dict = {}
for subject, region in data_dict.iteritems():
ret_dict[subject] = {}
for region, cell_options in region.iteritems():
presence_info = presence.get(subject, {}).get(region, {})
cell = self.process_cell(
subject, region, cell_options, conclusion, presence_info,
comment_counts,
)
ret_dict[subject][region] = cell
context = self.get_context()
context.update({
'progress_filter_form': progress_filter_form,
'current_selection': current_selection,
'period_name': period_name,
'group': group,
'conclusion': conclusion,
'subjects': self.subjects_by_group(period, group),
'regions': regions.all(),
'objects': ret_dict,
'dataset': period_query,
'summary_endpoint': self.summary_endpoint,
'extra': extra,
})
return render_template(self.template_name, **context)
