def read_one(self, public=False):
"""
Return one :term:`Activity`.
.. seealso::
:ref:`read-one`
Read one :term:`Activity` or one version of an :term:`Activity`.
By default, this is the latest visible version to the current
user. This means that logged in users can see their own pending
version and moderators of the current profile can see a pending
version as well. If you don't want to see a version pending,
consider using
:class:`lmkp.views.activities.ActivityView.read_one_public`
instead.
Args:
``public`` (bool): A boolean indicating to return only a
version visible to the public (eg. pending) or not.
Matchdict parameters:
``/activities/{output}/{uid}``
``output`` (str): If the output format is not valid, a 404
Response is returned.
The following output formats are supported:
``json``: Return the :term:`Activity` as JSON. All
versions visible to the current user are returned.
``geojson``: Return the :term:`Activity` as GeoJSON. A
version parameter is required.
``html``: Return the :term:`Activity` as HTML (eg. the
`Detail View`).
``form``: Returns the form to edit an existing
:term:`Activity`.
``compare``: Return the page to compare two versions of
the :term:`Activity`.
``review``: Return the page to review a pending version
of an :term:`Activity`.
``statistics``: Return a page with the areal statistics
of an :term:`Activity`.
``uid`` (str): An :term:`Activity` :term:`UID`.
Request parameters:
``translate`` (bool): Return translated values or not. This
is only valid for the output formats ``json`` or
``geojson``.
``v`` (int): Indicate a specific version to return. This is
only valid for the output formats ``geojson``, ``html`` and
``form``.
``inv`` (str): Only valid for output format ``form``.
Indicate an involvement of the form to return to after
creating a new :term:`Stakeholder`.
``ref`` (int) and ``new`` (int): Indicate specific versions.
This is only valid for the output formats ``compare`` and
``review``.
Returns:
``HTTPResponse``. Either a HTML or a JSON response.
"""
output_format = get_output_format(self.request)
uid = self.request.matchdict.get("uid", None)
if validate_uuid(uid) is not True:
raise HTTPNotFound()
if output_format == "json":
translate = self.request.params.get("translate", "true").lower() == "true"
item = activity_protocol.read_one(self.request, uid=uid, public=public, translate=translate)
return render_to_response("json", item, self.request)
elif output_format == "geojson":
# A version is required
version = self.request.params.get("v", None)
if version is None:
raise HTTPBadRequest("You must specify a version as parameter ?v=X")
translate = self.request.params.get("translate", "true").lower() == "true"
item = activity_protocol.read_one_geojson_by_version(self.request, uid, version, translate=translate)
return render_to_response("json", item, self.request)
elif output_format == "html":
version = self.request.params.get("v", None)
item = activity_protocol.read_one(self.request, uid=uid, public=public, translate=False)
for i in item.get("data", []):
item_version = i.get("version")
if version is None:
# If there was no version provided, show the first
# version visible to the user
version = str(item_version)
if str(item_version) == version:
template_values = self.get_base_template_values()
template_values.update(renderReadonlyForm(self.request, "activities", i))
template_values.update(
{
"uid": uid,
"shortuid": shorten_uuid(uid),
"version": version,
"site_key": comments_sitekey(self.request)["site_key"],
"comments_url": self.request.registry.settings["lmkp.comments_url"],
}
)
return render_to_response(
get_customized_template_path(self.request, "activities/details.mak"),
template_values,
self.request,
)
return HTTPNotFound()
elif output_format == "form":
is_logged_in, __ = get_user_privileges(self.request)
if not is_logged_in:
raise HTTPForbidden()
version = self.request.params.get("v", None)
item = activity_protocol.read_one(self.request, uid=uid, public=False, translate=False)
for i in item.get("data", []):
item_version = i.get("version")
if version is None:
# If there was no version provided, show the first
# version visible to the user
version = str(item_version)
if str(item_version) == version:
new_involvement = self.request.params.get("inv")
template_values = renderForm(self.request, "activities", itemJson=i, inv=new_involvement)
if isinstance(template_values, Response):
return template_values
template_values.update(self.get_base_template_values())
template_values.update({"uid": uid, "version": version})
return render_to_response(
get_customized_template_path(self.request, "activities/form.mak"), template_values, self.request
)
return HTTPNotFound()
elif output_format in ["review", "compare"]:
if output_format == "review":
# Only moderators can see the review page.
is_logged_in, is_moderator = get_user_privileges(self.request)
if not is_logged_in or not is_moderator:
raise HTTPForbidden()
review = ActivityReview(self.request)
is_review = output_format == "review"
available_versions = review._get_available_versions(Activity, uid, review=is_review)
recalculated = False
default_ref_version, default_new_version = review._get_valid_versions(Activity, uid)
try:
ref_version = int(self.request.params.get("ref"))
except:
ref_version = None
# For review or if no valid reference version is provided, use the
# default reference version.
if (
output_format == "review"
or ref_version is None
or ref_version not in [v.get("version") for v in available_versions]
):
ref_version = default_ref_version
try:
new_version = int(self.request.params.get("new"))
except:
new_version = None
# If no valid new version is provided, use the default new version.
if new_version is None or new_version not in [v.get("version") for v in available_versions]:
new_version = default_new_version
if output_format == "review":
# If the Items are to be reviewed, only the changes which were
# applied to the new_version are of interest
items, recalculated = review.get_comparison(Activity, uid, ref_version, new_version)
else:
# If the Items are to be compared, the versions as they are
# stored in the database are of interest, without any
# recalculation
items = [
activity_protocol.read_one_by_version(
self.request, uid, ref_version, geometry="full", translate=False
),
activity_protocol.read_one_by_version(
self.request, uid, new_version, geometry="full", translate=False
),
]
template_values = renderReadonlyCompareForm(
self.request, "activities", items[0], items[1], review=is_review
)
# Collect the metadata
ref_metadata = {}
new_metadata = {}
missing_keys = []
reviewable = False
if items[0] is not None:
ref_metadata = items[0].get_metadata(self.request)
if items[1] is not None:
new_metadata = items[1].get_metadata(self.request)
items[1].mark_complete(get_mandatory_keys(self.request, "a", False))
missing_keys = items[1]._missing_keys
localizer = get_localizer(self.request)
if localizer.locale_name != "en":
db_lang = Session.query(Language).filter(Language.locale == localizer.locale_name).first()
missing_keys = get_translated_db_keys(A_Key, missing_keys, db_lang)
missing_keys = [m[1] for m in missing_keys]
reviewable = (
len(missing_keys) == 0
and "reviewableMessage" in template_values
and template_values["reviewableMessage"] is None
)
if output_format == "review":
pending_versions = []
for v in sorted(available_versions, key=lambda v: v.get("version")):
if v.get("status") == 1:
pending_versions.append(v.get("version"))
template_values.update({"pendingVersions": pending_versions})
template_values.update(self.get_base_template_values())
template_values.update(
{
"identifier": uid,
"refVersion": ref_version,
"refMetadata": ref_metadata,
"newVersion": new_version,
"newMetadata": new_metadata,
"missingKeys": missing_keys,
"reviewable": reviewable,
"recalculated": recalculated,
}
)
if output_format == "review":
template = get_customized_template_path(self.request, "activities/review.mak")
else:
template = get_customized_template_path(self.request, "activities/compare.mak")
return render_to_response(template, template_values, self.request)
elif output_format == "formtest":
version = self.request.params.get("v", None)
# Test if an Item is valid according to the form configuration
items = activity_protocol.read_one(self.request, uid=uid, public=False, translate=False)
for i in item.get("data", []):
item_version = i.get("version")
if version is None:
# If there was no version provided, show the first
# version visible to the user
version = str(item_version)
if str(item_version) == version:
categorylist = getCategoryList(self.request, "activities")
return render_to_response("json", checkValidItemjson(categorylist, i), self.request)
return HTTPNotFound()
elif output_format == "statistics":
# Try to get the base URL to the web processing service which
# provides the areal statistics.
# If no web processing service is configured, it is assumed that
# the platform does not provide the areal statistics
try:
wps_host = self.request.registry.settings["lmkp.base_wps"]
except KeyError:
raise HTTPNotFound()
# Check if the spatial accuracy map is configured in the
# application .yml file
spatial_accuracy_map = get_spatial_accuracy_map(self.request)
if spatial_accuracy_map is None:
raise HTTPNotFound()
# Show the details of an Activity by rendering the form in readonly
# mode.
activities = activity_protocol.read_one(self.request, uid=uid, public=False, translate=False)
activity = activities["data"][0]
coords = activity["geometry"]["coordinates"]
for taggroup in activity["taggroups"]:
if taggroup["main_tag"]["key"] == "Spatial Accuracy":
spatial_accuracy = taggroup["main_tag"]["value"]
buffer = spatial_accuracy_map[spatial_accuracy]
wps_parameters = {
"ServiceProvider": "",
"metapath": "",
"Service": "WPS",
"Request": "Execute",
"Version": "1.0.0",
"Identifier": "BufferStatistics",
"DataInputs": "lon=%s;lat=%s;epsg=4326;buffer=%s" % (coords[0], coords[1], buffer),
"RawDataOutput": "bufferstatistics@mimeType=application/json",
}
if not wps_host.endswith("?"):
wps_host = "%s?" % wps_host
for k, v in wps_parameters.items():
wps_host = "%s%s=%s&" % (wps_host, k, v)
log.debug("Accessing: %s" % wps_host)
try:
handle = urllib.urlopen(wps_host)
except IOError:
return HTTPInternalServerError("Remote server not accessible.")
templateValues = json.loads(handle.read())
templateValues["uid"] = uid
templateValues["shortuid"] = uid.split("-")[0]
return render_to_response(
get_customized_template_path(self.request, "activities/statistics.mak"), templateValues, self.request
)
else:
raise HTTPNotFound()
def read_one(self, public=False):
"""
Return one :term:`Stakeholder`.
.. seealso::
:ref:`read-one`
Read one :term:`Stakeholder` or one version of a
:term:`Stakeholder`. By default, this is the latest visible
version to the current user. This means that logged in users can
see their own pending version and moderators of the current
profile can see a pending version as well. If you don't want to
see a version pending, consider using
:class:`lmkp.views.stakeholders.StakeholderView.read_one_public`
instead.
Args:
``public`` (bool): A boolean indicating to return only a
version visible to the public (eg. pending) or not.
Matchdict parameters:
``/stakeholders/{output}/{uid}``
``output`` (str): If the output format is not valid, a 404
Response is returned.
The following output formats are supported:
``json``: Return the :term:`Stakeholder` as JSON. All
versions visible to the current user are returned.
``html``: Return the :term:`Stakeholder` as HTML (eg.
the `Detail View`).
``form``: Returns the form to edit an existing
:term:`Stakeholder`.
``compare``: Return the page to compare two versions of
the :term:`Stakeholder`.
``review``: Return the page to review a pending version
of a :term:`Stakeholder`.
``uid`` (str): An :term:`Stakeholder` :term:`UID`.
Request parameters:
``translate`` (bool): Return translated values or not. This
is only valid for the output format ``json``.
``v`` (int): Indicate a specific version to return. This is
only valid for the output formats ``html`` and ``form``.
``camefrom`` (uid): Only valid for output format ``review``.
Indicate a :term:`Activity` to return to after reviewing the
:term:`Stakeholder`.
``ref`` (int) and ``new`` (int): Indicate specific versions.
This is only valid for the output formats ``compare`` and
``review``.
Returns:
``HTTPResponse``. Either a HTML or a JSON response.
"""
output_format = get_output_format(self.request)
uid = self.request.matchdict.get('uid', None)
if validate_uuid(uid) is not True:
raise HTTPNotFound()
if output_format == 'json':
translate = self.request.params.get(
'translate', 'true').lower() == 'true'
item = stakeholder_protocol.read_one(
self.request, uid=uid, public=public, translate=translate)
return render_to_response('json', item, self.request)
elif output_format == 'html':
version = self.request.params.get('v', None)
item = stakeholder_protocol.read_one(
self.request, uid=uid, public=public, translate=False)
for i in item.get('data', []):
item_version = i.get('version')
if version is None:
# If there was no version provided, show the first
# version visible to the user
version = str(item_version)
if str(item_version) == version:
template_values = self.get_base_template_values()
template_values.update(renderReadonlyForm(
self.request, 'stakeholders', i))
template_values.update({
'uid': uid,
'shortuid': shorten_uuid(uid),
'version': version,
'site_key': comments_sitekey(self.request)['site_key'],
'comments_url': self.request.registry.settings[
'lmkp.comments_url']
})
return render_to_response(
get_customized_template_path(
self.request, 'stakeholders/details.mak'),
template_values, self.request)
return HTTPNotFound()
elif output_format == 'form':
is_logged_in, __ = get_user_privileges(self.request)
if not is_logged_in:
raise HTTPForbidden()
version = self.request.params.get('v', None)
item = stakeholder_protocol.read_one(
self.request, uid=uid, public=False, translate=False)
for i in item.get('data', []):
item_version = i.get('version')
if version is None:
# If there was no version provided, show the first
# version visible to the user
version = str(item_version)
if str(item_version) == version:
template_values = renderForm(
self.request, 'stakeholders', itemJson=i)
if isinstance(template_values, Response):
return template_values
template_values.update(self.get_base_template_values())
return render_to_response(
get_customized_template_path(
self.request, 'stakeholders/form.mak'),
template_values, self.request)
return HTTPNotFound()
elif output_format in ['review', 'compare']:
if output_format == 'review':
# Only moderators can see the review page.
is_logged_in, is_moderator = get_user_privileges(self.request)
if not is_logged_in or not is_moderator:
raise HTTPForbidden()
review = StakeholderReview(self.request)
is_review = output_format == 'review'
available_versions = review._get_available_versions(
Stakeholder, uid, review=is_review)
recalculated = False
default_ref_version, default_new_version = review.\
_get_valid_versions(Stakeholder, uid)
try:
ref_version = int(self.request.params.get('ref'))
except:
ref_version = None
# For review or if no valid reference version is provided, use the
# default reference version.
if (output_format == 'review' or ref_version is None
or ref_version not in [
v.get('version') for v in available_versions]):
ref_version = default_ref_version
try:
new_version = int(self.request.params.get('new'))
except:
new_version = None
if new_version is None or new_version not in [
v.get('version') for v in available_versions]:
new_version = default_new_version
if output_format == 'review':
# If the Items are to be reviewed, only the changes which were
# applied to the new_version are of interest
items, recalculated = review.get_comparison(
Stakeholder, uid, ref_version, new_version)
else:
# If the Items are to be compared, the versions as they are
# stored in the database are of interest, without any
# recalculation
items = [
stakeholder_protocol.read_one_by_version(
self.request, uid, ref_version, translate=False
),
stakeholder_protocol.read_one_by_version(
self.request, uid, new_version, translate=False
)
]
template_values = renderReadonlyCompareForm(
self.request, 'stakeholders', items[0], items[1],
review=is_review)
# Collect the metadata
ref_metadata = {}
new_metadata = {}
missing_keys = []
reviewable = False
if items[0] is not None:
ref_metadata = items[0].get_metadata(self.request)
# Collect metadata and missing keys for the new version
if items[1] is not None:
new_metadata = items[1].get_metadata(self.request)
items[1].mark_complete(get_mandatory_keys(
self.request, 'sh', False))
missing_keys = items[1]._missing_keys
localizer = get_localizer(self.request)
if localizer.locale_name != 'en':
db_lang = Session.query(Language).filter(
Language.locale == localizer.locale_name).first()
missing_keys = get_translated_db_keys(
SH_Key, missing_keys, db_lang)
missing_keys = [m[1] for m in missing_keys]
reviewable = (len(missing_keys) == 0 and
'reviewableMessage' in template_values
and template_values['reviewableMessage'] is None)
if output_format == 'review':
pending_versions = []
for v in sorted(
available_versions, key=lambda v: v.get('version')):
if v.get('status') == 1:
pending_versions.append(v.get('version'))
template_values['pendingVersions'] = pending_versions
template_values.update(self.get_base_template_values())
template_values.update({
'identifier': uid,
'refVersion': ref_version,
'refMetadata': ref_metadata,
'newVersion': new_version,
'newMetadata': new_metadata,
'missingKeys': missing_keys,
'reviewable': reviewable,
'recalculated': recalculated,
'camefrom': self.request.params.get('camefrom', ''),
})
if output_format == 'review':
template = get_customized_template_path(
self.request, 'stakeholders/review.mak')
else:
template = get_customized_template_path(
self.request, 'stakeholders/compare.mak')
return render_to_response(template, template_values, self.request)
elif output_format == 'formtest':
version = self.request.params.get('v', None)
# Test if an Item is valid according to the form configuration
items = stakeholder_protocol.read_one(
self.request, uid=uid, public=False, translate=False)
for i in item.get('data', []):
item_version = i.get('version')
if version is None:
# If there was no version provided, show the first
# version visible to the user
version = str(item_version)
if str(item_version) == version:
categorylist = getCategoryList(
self.request, 'stakeholders')
return render_to_response(
'json', checkValidItemjson(categorylist, i),
self.request)
return HTTPNotFound()
else:
raise HTTPNotFound()
