def succeed():
"""
"""
# Request all submitted values
profile_field = self.request.POST.get("profile")
username_field = self.request.POST.get("username")
firstname_field = self.request.POST.get("firstname")
lastname_field = self.request.POST.get("lastname")
password_field = self.request.POST.get("password")
email_field = self.request.POST.get("email")
# Get the selected profile
selected_profile = DBSession.query(Profile).filter(
Profile.code == profile_field).first()
# Get the initial user group
user_group = DBSession.query(Group).filter(
Group.name == "editors").first()
# Create an activation uuid
activation_uuid = str(uuid.uuid4())
# Create a new user
new_user = User(username_field,
password_field,
email_field,
firstname=firstname_field,
lastname=lastname_field,
activation_uuid=activation_uuid,
registration_timestamp=datetime.now())
# Set the user profile
new_user.profiles = [selected_profile]
new_user.groups = [user_group]
# Commit the new user
DBSession.add(new_user)
activation_dict = {
"firstname":
new_user.firstname,
"lastname":
new_user.lastname,
"activation_link":
"http://%s/users/activate?uuid=%s&username="******"%s" % (self.request.environ['HTTP_HOST'], activation_uuid,
new_user.username)
}
email_text = render(
get_customized_template_path(self.request,
'emails/account_activation.mak'),
activation_dict, self.request)
self._send_email([email_field], _(u"Activate your Account"),
email_text)
return render_to_response(
get_customized_template_path(self.request,
'users/registration_success.mak'),
{}, self.request)
def login(self):
"""
Login controller
"""
login_url = self.request.route_url('login')
referrer = self.request.path
if referrer == login_url:
# never use the login form itself as came_from
referrer = '/'
came_from = self.request.params.get('came_from', referrer)
login = ''
password = ''
# Prevent an empty header if /login is directly requested (should
# actually never happen)
headers = []
if 'form.submitted' in self.request.params:
login = self.request.params['login']
password = self.request.params['password']
if User.check_password(login, password):
log.debug('Login succeed')
headers = remember(self.request,
login,
max_age=timedelta(days=30).total_seconds())
else:
log.debug('Login failed')
headers = forget(self.request)
msg = _(u"Login failed! Please try again.")
return render_to_response(
get_customized_template_path(self.request,
'login_form.mak'), {
'came_from': came_from,
'warning': msg
}, self.request)
return HTTPFound(location=came_from, headers=headers)
def charts(self):
template_values = self.template_values
chart_type = self.request.matchdict.get('type', 'bars')
if chart_type == 'bars':
params = self.request.matchdict.get('params')
if params == ('sh', ):
template = 'barchart_sh'
else:
template = 'barchart_a'
elif chart_type == 'stackedbars':
template = 'stackedbarchart'
elif chart_type == 'map':
template = 'mapchart'
profiles = sorted(get_profiles(), key=lambda profile: profile[0])
profiles.append(('global', 'global'))
template_values.update({'profiles': profiles})
else:
return HTTPNotFound()
attr = self.request.params.get('attr', 0)
template_values.update({'attr': attr})
return render_to_response(
get_customized_template_path(self.request,
'charts/%s.mak' % template),
template_values, self.request)
def mako_renderer(tmpl_name, **kw):
"""
A helper function to use the mako rendering engine.
It seems to be necessary to locate the templates by using the asset
resolver.
"""
request = get_current_request()
# Redirect base form templates to customized templates
if tmpl_name in [
'form', 'readonly/form', 'customInvolvementMapping',
'readonly/customInvolvementMappingStakeholder',
'readonly/customInvolvementMappingActivity'
]:
resolver = lokpAssetResolver.resolve(
get_customized_template_path(request, 'form/%s.mak' % tmpl_name))
else:
resolver = lokpAssetResolver.resolve('templates/form/%s.mak' %
tmpl_name)
template = Template(filename=resolver.abspath())
# Add the request to the keywords so it is available in the templates.
kw['request'] = request
kw['_'] = _
return template.render(**kw)
def download(self):
"""
"""
return render_to_response(
get_customized_template_path(self.request, 'download_view.mak'), {
'profile': get_current_profile(self.request),
'locale': get_current_locale(self.request)
}, self.request)
def reset_form(self):
came_from = self.request.params.get('came_from', None)
return render_to_response(
get_customized_template_path(self.request,
'users/reset_password_form.mak'), {
'came_from': came_from,
"warning": None
}, self.request)
def approve(self):
"""
User moderation: approve newly activated users.
"""
# Get the URL parameters
user_uuid = self.request.params.get("user")
user_username = self.request.params.get("name")
# Try to the user, who must not yet be approved
user = DBSession.query(User).filter(
and_(User.uuid == user_uuid, User.username == user_username,
User.is_approved == False)).first()
# Raise a BadRequest if no user is found
if user is None:
raise HTTPBadRequest(
"User is already approved or does not exist in the database.")
# Set the is_approved attribute to TRUE
user.is_approved = True
conf_dict = {
"firstname": user.firstname,
"lastname": user.lastname,
"host": "http://%s" % self.request.environ['HTTP_HOST']
}
email_text = render(get_customized_template_path(
self.request, 'emails/account_approval_confirmation.mak'),
conf_dict,
request=self.request)
# Send the email
self._send_email([user.email], "Account confirmation on %s" %
"http://%s" % self.request.environ['HTTP_HOST'],
email_text)
# Return the username to the template
return render_to_response(
get_customized_template_path(self.request,
'users/approval_successful.mak'),
{'username': user_username}, self.request)
def download_customize(self, item_type):
"""
"""
item_type = validate_item_type(item_type)
if self.request.POST:
format = self.request.POST.get('format', 'csv')
involvements = self.request.POST.get('involvements', 'full')
attributes = self.request.POST.getall('attributes')
if format == 'csv':
header, rows = to_flat_table(self.request,
item_type,
involvements=involvements,
columns=attributes)
return render_to_response('csv', {
'header': header,
'rows': rows
}, self.request)
# Order matters: The first entry is the default value.
formats = [
('csv', 'CSV'),
]
attributes = []
for config_key in getCategoryList(self.request,
item_type).getAllKeys():
attributes.append(
(config_key.getName(), config_key.getTranslatedName()))
if item_type == 'a':
template = get_customized_template_path(self.request,
'activities/download.mak')
else:
template = get_customized_template_path(
self.request, 'stakeholders/download.mak')
template_values = {
'profile': get_current_profile(self.request),
'locale': get_current_locale(self.request),
'formats': formats,
'attributes': attributes
}
return render_to_response(template, template_values, self.request)
def partners_view(self):
"""
Returns the HTML page with the Partners.
:term:`Customized template` used: ``partners_view.mak``.
Returns:
``HTTPResponse``. A HTML response.
"""
return render_to_response(
get_customized_template_path(self.request, 'partners_view.mak'),
self.template_values, self.request)
def about_view(self):
"""
Returns the HTML page with the "about" information.
:term:`Customized template` used: ``about_view.mak``.
Returns:
``HTTPResponse``. A HTML response.
"""
return render_to_response(
get_customized_template_path(self.request, 'about_view.mak'),
self.template_values, self.request)
def map_view(self):
"""
Returns the HTML page with the main map, eg. the Map View.
:term:`Customized template` used: ``map_view.mak``.
Returns:
``HTTPResponse``. A HTML response.
"""
return render_to_response(
get_customized_template_path(self.request, 'map_view.mak'),
self.template_values, self.request)
def reset(self):
if self.request.params.get('came_from') is not None:
came_from = self.request.params.get('came_from')
else:
came_from = self.request.route_url('map_view')
# Make sure the user is not logged in
principals = effective_principals(self.request)
if "system.Authenticated" in principals:
return HTTPFound(location=came_from)
username = self.request.params.get("username")
user = DBSession.query(User).filter(User.username == username).first()
if user is None:
msg = _(u"No registered user found with this email address.")
return render_to_response(
get_customized_template_path(self.request,
'users/reset_password_form.mak'),
{
'came_from': came_from,
'warning': msg
}, self.request)
new_password = user.set_new_password()
body = render(
get_customized_template_path(self.request,
'emails/reset_password.mak'), {
'user': user.username,
'new_password': new_password
}, self.request)
self._send_email([user.email], _(u"Password reset"), body)
return render_to_response(
get_customized_template_path(self.request,
'users/reset_password_success.mak'),
{}, self.request)
def index(self):
"""
Returns the root HTML page. This is the landing page, where
users can for example select the profile before continuing to
the map view.
:term:`Customized template` used: ``landing_page.mak``.
Returns:
``HTTPResponse``. A HTML response.
"""
return render_to_response(
get_customized_template_path(self.request, 'landing_page.mak'),
self.template_values, self.request)
def read_byuser(request):
try:
output_format = request.matchdict['output']
except KeyError:
output_format = 'rss'
if output_format == 'rss':
template = 'changesets/byuser_rss.mak'
elif output_format == 'html':
template = 'changesets/byuser_html.mak'
else:
raise HTTPNotFound("Requested output format is not supported.")
templateValues = changeset_protocol.read_many_byuser(request)
return render_to_response(get_customized_template_path(request, template),
templateValues, request)
def login_form(self):
"""
Renders the simple login form
"""
# Prevent endless loops
if self.request.referer is not None \
and self.request.referer != self.request.route_url('reset_form') \
and not self.request.referer.startswith(
self.request.route_url('login_form')):
came_from = self.request.referer
else:
came_from = self.request.route_url('map_view')
# Make sure the user is not logged in
principals = effective_principals(self.request)
if "system.Authenticated" in principals:
return HTTPFound(location=came_from)
return render_to_response(
get_customized_template_path(self.request, 'login_form.mak'), {
'came_from': came_from,
'warning': None
}, self.request)
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 noat.
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,
# Temporarily disabled comments
'site_key': None,
# 'site_key': comments_sitekey(self.request)['site_key'],
# 'comments_url': self.request.registry.settings[
# 'lokp.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 = DBSession.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['lokp.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.request.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 renderReadonlyCompareForm(request,
itemType,
refFeature,
newFeature,
review=False):
"""
Return a rendered form used for comparison (for comparison or review
purposes).
"""
reviewableMessage = None
deform.Form.set_default_renderer(mako_renderer_compare)
configCategoryList = getCategoryList(request, itemType)
compareMode = 'review' if review is True else 'compare'
schema = addHiddenFields(colander.SchemaNode(colander.Mapping()), itemType)
for cat in configCategoryList.getCategories():
schema.add(cat.getForm(request, readonly=True, compare=compareMode))
schema.add(
colander.SchemaNode(colander.String(),
widget=deform.widget.HiddenWidget(),
name='geomchange',
title='',
missing=colander.null))
form = deform.Form(schema)
validComparison = True
refData = {}
if refFeature is not None:
refData = getFormdataFromItemjson(request,
refFeature.to_table(request),
itemType,
readOnly=True)
if refData == {}:
validComparison = False
newData = {}
if newFeature is not None:
newData = getFormdataFromItemjson(request,
newFeature.to_table(request),
itemType,
readOnly=True,
compareFeature=newFeature)
if newData == {}:
validComparison = False
if review is True and 'reviewable' in newData:
reviewable = newData['reviewable']
if reviewable == -2:
reviewableMessage = _(
'At least one of the involvements prevents automatic '
'revision. Please review these involvements separately.')
elif reviewable == -3:
reviewableMessage = _(
'This version contains changed involvements which prevent '
'automatic revision. Please review these involvements.')
elif reviewable < 0:
reviewableMessage = 'Something went wrong.'
if review is True and 'reviewable' not in newData and refFeature and \
newFeature and len(refFeature.get_involvements()) > \
len(newFeature.get_involvements()) and \
itemType == 'stakeholders':
# If the Stakeholder is to be deleted (no taggroups), do not show
# the warning and enable review
if len(newFeature.get_taggroups()) > 0:
reviewableMessage = _(
'At least one of the involvements prevents automatic '
'revision. Please review these involvements separately.')
if validComparison is False:
# If no formdata is available, it is very likely that the form has some
# errors. In this case show an error message.
url = None
routeName = 'activities_read_one_history' if itemType == 'activities' \
else 'stakeholders_read_one_history'
if refFeature is not None:
url = request.route_url(routeName,
output='html',
uid=refFeature.get_guid())
elif newFeature is not None:
url = request.route_url(routeName,
output='html',
uid=newFeature.get_guid())
errorMsg = render(
get_customized_template_path(
request, 'parts/messages/comparison_not_valid.mak'),
{'url': url}, request)
return {'error': errorMsg}
data = mergeFormdata(refData, newData)
geometry = None
if itemType == 'activities':
newGeometry = newFeature.get_geometry() if newFeature is not None \
else None
refGeometry = refFeature.get_geometry() if refFeature is not None \
else None
# get polygeon geometries from taggroups
newDealAreas = getTaggroupGeometriesCompare(newData)
refDealAreas = getTaggroupGeometriesCompare(refData)
geometry = json.dumps({
'ref': {
'geometry': refGeometry,
'dealAreas': json.dumps(refDealAreas)
},
'new': {
'geometry': newGeometry,
'dealAreas': json.dumps(newDealAreas)
},
})
# renders form; passes variables (readonly and geometry) to template
## TODO: in custom map mapping: pass params like this
html = form.render(data, readonly=True, geometry=geometry)
return {
'form': html,
'geometry': geometry,
'reviewableMessage': reviewableMessage,
}
def renderReadonlyForm(request, itemType, itemJson):
"""
Function to return a rendered form in readonly mode. The form is based on
the configuration.
"""
taggroup_count = len(itemJson.get('taggroups', []))
# Hack to avoid showing involvements of items to be deleted (with no
# taggroups)
if taggroup_count == 0:
itemJson['involvements'] = []
deform.Form.set_default_renderer(mako_renderer)
configCategoryList = getCategoryList(request, itemType)
schema = addHiddenFields(colander.SchemaNode(colander.Mapping()), itemType)
schema.add(
colander.SchemaNode(
colander.String(),
widget=deform.widget.TextInputWidget(template='hidden'),
name='statusId',
title='',
missing=colander.null))
for cat in sorted(configCategoryList.getCategories(),
key=lambda cat: cat.order):
schema.add(cat.getForm(request, readonly=True))
form = deform.Form(schema)
data = getFormdataFromItemjson(request, itemJson, itemType, readOnly=True)
if data == {}:
# If no formdata is available, it is very likely that the form has some
# errors. In this case show an error message.
errorList = checkValidItemjson(configCategoryList,
itemJson,
output='list')
if len(errorList) > 0:
url = None
routeName = 'activities_read_one_history' \
if itemType == 'activities' \
else 'stakeholders_read_one_history'
if 'id' in itemJson:
url = request.route_url(routeName,
output='html',
uid=itemJson['id'])
errorMsg = render(
get_customized_template_path(
request, 'parts/messages/item_requested_not_valid.mak'),
{'url': url}, request)
return {'form': errorMsg}
if 'category' in data and data['category'] is None:
data['category'] = 0
data['itemType'] = itemType
statusId = itemJson['status_id'] if 'status_id' in itemJson \
else colander.null
data['statusId'] = statusId
data['taggroup_count'] = taggroup_count
html = form.render(data, readonly=True)
geometry = json.dumps(
itemJson['geometry']) if 'geometry' in itemJson else None
# extract deal areas as polygons, contained in dictionary
dealAreas = getTaggroupGeometries(itemJson)
return {
'form': html,
'geometry': geometry,
'dealAreas': json.dumps(dealAreas)
}
def renderForm(request, itemType, **kwargs):
"""
Render the form for either Activity or Stakeholder
"""
# Get the kwargs
itemJson = kwargs.get('itemJson', None)
newInvolvement = kwargs.get('inv', None)
emptyTitle = _('Empty Form')
emptyText = _('You submitted an empty form or did not make any changes.')
errorTitle = _('Error')
# Activity or Stakeholder
if itemType == 'activities':
# The initial category of the form
formid = 'activityform'
otherItemType = 'stakeholders'
elif itemType == 'stakeholders':
# The initial category of the form
formid = 'stakeholderform'
otherItemType = 'activities'
else:
raise HTTPBadRequest(
'Unknown itemType (neither "activities" nor "stakeholders")')
session = request.session
oldCategory = None
log.debug('Session before processing the form: %s' % session)
# Use a different template rendering engine (mako instead of chameleon)
deform.Form.set_default_renderer(mako_renderer)
# Check if anything was submitted at all. If so, remember which category
# was the one submitted.
formSubmit = False
if request.POST != {}:
formSubmit = True
for p in request.POST:
if p == 'category':
oldCategory = request.POST[p]
break
# Get the configuration of the categories (as defined in the config yaml)
configCategoryList = getCategoryList(request, itemType)
# Determine which category to show. If reopening the form after creating a
# new Involvement, use the category of the Involvement. Else use the first
# category of the configuration.
if newInvolvement is not None:
newInvCat = configCategoryList.findCategoryByInvolvementName(
newInvolvement)
if newInvCat is not None:
newCategory = newInvCat.getId()
else:
newCategory = configCategoryList.getFirstCategoryId()
else:
newCategory = configCategoryList.getFirstCategoryId()
# Collect a list with id and names of all available categories which will
# be used to create the buttons based cat
categoryListButtons = []
for cat in sorted(configCategoryList.getCategories(),
key=lambda cat: cat.order):
displayName = (cat.getTranslation()
if cat.getTranslation() is not None else cat.getName())
categoryListButtons.append((cat.getId(), displayName))
captured = None
formHasErrors = False
# Some sort of data used for feedback. Can be Javascript or something else
feedbackData = None
# Handle form submission: This can also be just the "submission" of a
# single category which does not submit the item but stores the
# information of the submitted category in the session.
for p in request.POST:
if (not (p.startswith('step_') or p in ['submit', 'delete']
or p.startswith('createinvolvement_'))):
continue
createInvolvement = False
if p.startswith('createinvolvement_'):
# If the form was "submitted" because a new involvement is to be
# created, we need to remove the 'create_involvement' POST value,
# otherwise Deform cannot validate the form.
x = p.split('_')
createInvolvement = x[1]
request.POST.pop(p)
# Do a validation of the submitted form data. To do this, it is
# necessary to recreate a form with the same category that was
# submitted.
buttons = []
# Prepare a form with the submitted category
oldschema = addHiddenFields(colander.SchemaNode(colander.Mapping()),
itemType)
oldCat = configCategoryList.findCategoryById(oldCategory)
if oldCat is not None:
oldschema.add(oldCat.getForm(request))
showSessionCategories = None
if (itemJson is None or
(itemType in session and 'form' in session[itemType]
and 'id' in session[itemType]['form']
and session[itemType]['form']['id'] == itemJson['id'])):
showSessionCategories = itemType
buttons = getFormButtons(
request,
categoryListButtons,
oldCategory,
showSessionCategories=showSessionCategories)
# creates form?
form = deform.Form(oldschema, buttons=buttons, formid=formid)
if p == 'delete':
captured = {}
else:
try:
# Try to validate the form
captured = form.validate(
request.POST.items()) # captured contains input values
except deform.ValidationFailure as e:
# The submitted values contains errors. Render the same form
# again with error messages. It will be returned later.
html = e.render()
formHasErrors = True
if formHasErrors is False:
# The form is valid, store the captured data in the session.
log.debug('Data captured by the form: %s' % captured)
# If there is already some data in the session.
if itemType in session and 'form' in session[itemType]:
sessionItem = session[itemType][
'form'] # sessionItem contains values saved in session
if (captured.get('id') == sessionItem.get('id') and
captured.get('version') == sessionItem.get('version')
and oldCategory in captured):
# It is the same item as already in the session, add or
# overwrite the form data.
updatedCategory = captured[oldCategory]
sessionItem[oldCategory] = updatedCategory
log.debug('Updated session item: Category %s' %
oldCategory)
else:
# A different item is already in the session. It will be
# overwriten.
if 'category' in captured:
del (captured['category'])
session[itemType]['form'] = captured
log.debug('Replaced session item')
else:
# No data is in the session yet. Store the captured data
# there.
if 'category' in captured:
del (captured['category'])
if itemType not in session:
session[itemType] = {}
session[itemType][
'form'] = captured # write session data to form of itemType (can be activity etc.)
log.debug('Added session item')
if p.startswith('step_'):
# A button with a next category was clicked, set a new
# current category to show in the form
c = p.split('_')
newCategory = c[1]
if createInvolvement is not False:
# A new form is opened to create an Involvement. Store the
# current form information in the session (camefrom).
if itemType in session and 'camefrom' in session[itemType]:
# TODO
print("*************************")
print("*************************")
print("*************************")
print("there is already an activity in the session")
print("*************************")
print("*************************")
print("*************************")
itemId = '' if itemJson is None or 'id' not in itemJson \
else itemJson['id']
session[itemType]['camefrom'] = {
'id': itemId,
'timestamp': datetime.datetime.now(),
'inv': createInvolvement
}
if itemType == 'activities':
msg = render(
get_customized_template_path(
request, 'parts/messages/stakeholder_form_through_'
'involvement.mak'), {
'url':
request.route_url(
'activities_read_many',
output='form',
_query={'inv': createInvolvement})
}, request)
session.flash(msg)
url = request.route_url('stakeholders_read_many',
output='form')
else:
url = request.route_url('activities_read_many',
output='form')
# Redirect to the other form.
return HTTPFound(url)
if p in ['submit', 'delete']:
# The final submit button was clicked. Calculate the diff,
# delete the session data and redirect to a confirm page.
success = False
posted_formid = request.POST['__formid__']
if posted_formid not in ['activityform', 'stakeholderform']:
# TODO: Is this the correct way to return an error message?
feedbackMessage = '<span class="text-error">{}</span>: Unknown form'.format(
errorTitle)
return {
'form': feedbackMessage,
'css_links': [],
'js_links': [],
'js': None,
'success': False
}
if p == 'delete':
# The Item is to be deleted. Calculate the diff to delete
# all tags
diff = calculate_deletion_diff(request, itemType)
else:
if (itemType not in session
or 'form' not in session[itemType]):
# TODO: Is this the correct way to return an error
# message?
feedbackMessage = 'Session not active'
return {
'form': feedbackMessage,
'css_links': [],
'js_links': [],
'js': None,
'success': False
}
formdata = copy.copy(session[itemType]['form'])
log.debug('The complete formdata as in the session: %s' %
formdata)
# check
diff = formdataToDiff(request, formdata, itemType)
log.debug(
'The uncleaned diff to create/update the activity: %s' %
diff)
if diff is None:
# TODO: Is this the correct way to return an error message?
return {
'form':
'<h3 class="text-info">%s</h3><p>%s</p>' %
(emptyTitle, emptyText),
'css_links': [],
'js_links': [],
'js':
None,
'success':
False
}
# Create or update the Item
success, returnValues = doUpdate(request, itemType, diff)
if success is True:
# Clear the session
doClearFormSessionData(request, itemType, 'form')
if (otherItemType in session
and 'camefrom' in session[otherItemType]):
# The form was submitted "indirectly"
camefrom = session[otherItemType]['camefrom']
# Clear the camefrom flag
doClearFormSessionData(request, otherItemType,
'camefrom')
addToSession = addCreatedInvolvementToSession(
request, session, otherItemType, camefrom['inv'],
returnValues)
if addToSession is True:
msg = render(
get_customized_template_path(
request,
'parts/messages/stakeholder_created_'
'through_involvement.mak'), {}, request)
session.flash(msg, 'success')
# Route to the other form again.
if itemType == 'activities':
url = request.route_url(
'stakeholders_read_many',
output='form',
_query={'inv': camefrom['inv']})
else:
activity_id = camefrom.get('id')
if activity_id is not None and activity_id != '':
url = request.route_url(
'activities_read_one',
output='form',
uid=activity_id,
_query={'inv': camefrom['inv']})
else:
url = request.route_url(
'activities_read_many',
output='form',
_query={'inv': camefrom['inv']})
return HTTPFound(url)
else:
if itemType == 'activities':
feedbackMessage = render(
get_customized_template_path(
request, 'parts/messages/activity_created_'
'success.mak'),
{
'url':
request.route_url('activities_read_one',
output='html',
uid=returnValues['id'])
}, request)
else:
feedbackMessage = render(
get_customized_template_path(
request,
'parts/messages/stakeholder_created_'
'success.mak'),
{
'url':
request.route_url('stakeholders_read_one',
output='html',
uid=returnValues['id'])
}, request)
else:
feedbackMessage = '<h3 class="text-error">%s</h3>%s' % (
errorTitle, returnValues)
return {
'form': feedbackMessage,
'css_links': [],
'js_links': [],
'js': feedbackData,
'success': success
}
# END Post-request
if formHasErrors is False:
# If nothing was submitted or the captured form data was stored
# correctly, create a form with the (new) current category.
newschema = addHiddenFields(colander.SchemaNode(colander.Mapping()),
itemType)
newCat = configCategoryList.findCategoryById(newCategory)
if newCat is not None:
newschema.add(
newCat.getForm(request)) # send get request to config/form.py
showSessionCategories = None
if (itemJson is None
or (itemType in session and 'id' in session[itemType]
and session[itemType]['id'] == itemJson['id'])):
showSessionCategories = itemType
buttons = getFormButtons(request,
categoryListButtons,
newCategory,
showSessionCategories=showSessionCategories)
form = deform.Form(newschema, buttons=buttons, formid=formid)
# The form contains empty data by default
data = {'category': newCategory}
# Decide which data to show in the form
sessionItem = None
if itemType in session and 'form' in session[itemType]:
sessionItem = copy.copy(session[itemType]['form'])
if itemJson is not None and itemType not in session:
# An item was provided to show in the form (edit form) and no
# values are in the session yet.
# Simply show the data of the provided item in the form.
data = getFormdataFromItemjson(request, itemJson, itemType,
newCategory)
elif itemJson is not None and sessionItem is not None:
# An item was provided to show in the form (edit form) and there
# are some values in the session.
if (itemJson['id'] == sessionItem['id']
and itemJson['version'] == sessionItem['version']):
# The item in the session and the item provided are the same.
if str(newCategory) in sessionItem:
# The current category of the form is already in the
# session so we display this data.
sessionItem['category'] = newCategory
data = sessionItem
else:
# The current category of the form is not yet in the
# session so we use the data of the itemjson to populate
# the form.
data = getFormdataFromItemjson(request, itemJson, itemType,
newCategory)
if formSubmit is False and request.params.get('inv') is None:
# If the form is rendered for the first time, inform the
# user that session was used.
url = request.route_url('form_clear_session',
item=itemType,
attr='form',
_query={'url': request.url})
msg = render(
get_customized_template_path(
request,
'parts/messages/unsaved_data_same_form.mak'),
{'url': url}, request)
session.flash(msg)
else:
# The item in the session is not the same as the item provided.
# Use the itemjson to populate the form
data = getFormdataFromItemjson(request, itemJson, itemType,
newCategory)
# Inform the user that there is data in the session.
item_name = sessionItem['id'][:6] \
if sessionItem['id'] != colander.null else ''
if sessionItem['id'] != colander.null:
if itemType == 'activities':
item_url = request.route_url('activities_read_one',
output='form',
uid=sessionItem['id'])
elif itemType == 'stakeholders':
item_url = request.route_url('stakeholders_read_one',
output='form',
uid=sessionItem['id'])
else:
if itemType == 'activities':
item_url = request.route_url('activities_read_many',
output='form')
elif itemType == 'stakeholders':
item_url = request.route_url('stakeholders_read_many',
output='form')
msg = render(
get_customized_template_path(
request,
'parts/messages/unsaved_data_different_form.mak'), {
'url': item_url,
'name': item_name,
'type': itemType
}, request)
session.flash(msg)
elif itemJson is None and sessionItem is not None:
# No item was provided (create form) but some data was found in the
# session.
if (sessionItem['id'] != colander.null
and sessionItem['version'] != colander.null):
# The item in the session is not new. Show empty form data
# (already defined) and inform the user.
item_name = sessionItem['id'][:6] \
if sessionItem['id'] != colander.null \
else _('Unknown Item')
if sessionItem['id'] != colander.null:
if itemType == 'activities':
item_url = request.route_url('activities_read_one',
output='form',
uid=sessionItem['id'])
elif itemType == 'stakeholders':
item_url = request.route_url('stakeholders_read_one',
output='form',
uid=sessionItem['id'])
else:
if itemType == 'activities':
item_url = request.route_url('activities_read_many',
output='form')
elif itemType == 'stakeholders':
item_url = request.route_url('stakeholders_read_many',
output='form')
msg = render(
get_customized_template_path(
request,
'parts/messages/unsaved_data_different_form.mak'), {
'url': item_url,
'name': item_name,
'type': itemType
}, request)
session.flash(msg)
else:
# The item in the session is new.
# If the form is rendered for the first time, inform the
# user that session was used.
sessionItem['category'] = newCategory
data = sessionItem
if formSubmit is False and newInvolvement is None:
# Inform the user that data from the session is used.
url = request.route_url('form_clear_session',
item=itemType,
attr='form',
_query={'url': request.url})
msg = render(
get_customized_template_path(
request,
'parts/messages/unsaved_data_same_form.mak'),
{'url': url}, request)
session.flash(msg)
elif itemJson is not None:
# An item was provided to show in the form (edit form)
# Simply show the data of the provided item in the form.
data = getFormdataFromItemjson(request, itemJson, itemType,
newCategory)
else:
# No itemjson and no sessionitem, do nothing (empty data already
# defined above).
pass
# log.debug('Data used to populate the form: %s' % data)
html = form.render(data)
# If the current category contains involvements (eg. to add Stakeholders to
# an Activity), show a (initially empty) div which will contain the form
# for Stakeholders.
if str(newCategory) in configCategoryList.getInvolvementCategoryIds():
html += '<div id="stakeholderformcontainer"></div>'
# Add JS and CSS requirements (for widgets)
resources = form.get_widget_resources()
log.debug('Session after processing the form: %s' % session)
return {
'form': html,
'css_links': resources['css'],
'js_links': resources['js'],
'success': not formHasErrors
}
def history(self):
"""
Return the history of an :term:`Activity`.
Logged in users can see their own pending versions and
moderators of the current profile can see pending versions as
well.
By default, the versions are ordered with the most recent
changes being on top.
Matchdict parameters:
``/activities/history/{output}/{uid}``
``output`` (str): If the output format is not valid, a 404
Response is returned.
The following output formats are supported:
``html``: Return the history view as HTML.
``rss``: Return history view as RSS feed.
``uid`` (str): An :term:`Activity` :term:`UID`.
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()
__, is_moderator = get_user_privileges(self.request)
items, count = activity_protocol.read_one_history(self.request,
uid=uid)
active_version = None
for i in items:
if 'statusName' in i:
i['statusName'] = get_translated_status(
self.request, i['statusName'])
if i.get('statusId') == 2:
active_version = i.get('version')
template_values = self.get_base_template_values()
template_values.update({
'versions': items,
'count': count,
'activeVersion': active_version,
'isModerator': is_moderator
})
if output_format == 'html':
template = get_customized_template_path(self.request,
'activities/history.mak')
elif output_format == 'rss':
template = get_customized_template_path(
self.request, 'activities/history_rss.mak')
else:
raise HTTPNotFound()
return render_to_response(template, template_values, self.request)
def charts_overview(self):
return render_to_response(
get_customized_template_path(self.request, 'charts_view.mak'),
self.get_base_template_values(), self.request)
def read_selected(self):
"""
Return a rendered HTML string with the details of one or multiple
activities. Uses the protocol to query the data, extracts map details
keys (defined by "mapdetail: true" in the configuration YAML) and passes
it to the customized template for rendering.
:return: str.
"""
max_activities_visible = 3
uids_string = self.request.matchdict.get('uids', None)
uids = [
uid for uid in uids_string.split(',') if validate_uuid(uid) is True
]
if not uids:
raise HTTPNotFound()
activity_detail_keys = list(
getCategoryList(self.request, 'a').get_map_detail_keys())
stakeholder_detail_keys = list(
getCategoryList(self.request, 'sh').get_map_detail_keys())
activity_list = []
for uid in uids[:max_activities_visible]:
read_one = activity_protocol.read_one(self.request,
uid=uid,
public=False,
translate=False)
activity = read_one['data'][0]
activity_dict = {
'identifier': uid,
'short_identifier': shorten_uuid(uid),
}
for taggroup in activity.get('taggroups', []):
key = taggroup.get('main_tag', {}).get('key')
value = taggroup.get('main_tag', {}).get('value')
if key in activity_detail_keys:
if key not in activity_dict:
activity_dict[key] = []
activity_dict[key].append(value)
stakeholder_list = []
for stakeholder in activity.get('involvements', []):
stakeholder_dict = {}
for taggroup in stakeholder.get('data',
{}).get('taggroups', []):
key = taggroup.get('main_tag', {}).get('key')
value = taggroup.get('main_tag', {}).get('value')
if key in stakeholder_detail_keys:
if key not in stakeholder_dict:
stakeholder_dict[key] = []
stakeholder_dict[key].append(value)
if stakeholder_dict:
stakeholder_list.append(stakeholder_dict)
activity_list.append((activity_dict, stakeholder_list))
return render(
get_customized_template_path(
self.request, 'parts/items/activities_map_details.mak'),
{
'activity_list': activity_list,
'additional_activities': len(uids) - max_activities_visible,
}, self.request)
def getActiveFilters(request):
"""
Get the active filters of a request in a list.
The list contains another list for each active filter with
- [0]: the query string as provided in the parameter
- [1]: a clean text representation (translated) of the filter
"""
# Map the operators
operators = {
'like': '=',
'nlike': '!=',
'ilike': '=',
'eq': '=',
'ne': '!=',
'lt': '<',
'lte': '<=',
'gt': '>',
'gte': '>='
}
aList = getCategoryList(request, 'activities')
shList = getCategoryList(request, 'stakeholders')
# Extract query_strings from url
scheme, netloc, path, query_string, fragment = urllib.parse.urlsplit(
request.url)
queryparams = urllib.parse.parse_qs(query_string)
filters = []
for q in queryparams:
if q.startswith('a__') or q.startswith('sh__'):
queryparts = q.split('__')
if len(queryparts) != 3:
continue
if queryparts[0] == 'a':
itemName = render(
get_customized_template_path(request,
'parts/items/activity.mak'),
{}, request)
configList = aList
elif queryparts[0] == 'sh':
itemName = render(
get_customized_template_path(
request, 'parts/items/stakeholder.mak'), {}, request)
configList = shList
else:
continue
key = queryparts[1]
op = queryparts[2]
# Use translated key for display
displayKey = key
tag = configList.findTagByKeyName(key)
if tag is not None:
displayKey = tag.getKey().getTranslatedName()
for v in queryparams[q]:
# Use translated value for display
displayValue = v
if tag is not None:
valueObject = tag.findValueByName(v)
if valueObject is not None:
displayValue = valueObject.getTranslation()
q_string = '%s=%s' % (q, v)
q_display = (
'(%s) %s %s %s' %
(itemName, displayKey, operators[op], displayValue))
filters.append([q_string, q_display])
return filters
def account(self):
"""
Shows user account details to registered users.
"""
_ = self.request.translate
userid = authenticated_userid(self.request)
# Define a colander Schema for the self registration
class Schema(colander.Schema):
username = colander.SchemaNode(
colander.String(),
missing=None,
widget=deform.widget.TextInputWidget(
readonly=True,
readonly_template='readonly/customTextinputReadonly'),
title=_('Username'))
password = colander.SchemaNode(
colander.String(),
validator=colander.Length(min=5),
widget=deform.widget.CheckedPasswordWidget(size=20),
title=_('Password'))
firstname = colander.SchemaNode(colander.String(),
missing=None,
title=_('First Name'))
lastname = colander.SchemaNode(colander.String(),
missing=None,
title=_('Last Name'))
email = colander.SchemaNode(
colander.String(),
missing=None,
widget=deform.widget.TextInputWidget(
readonly=True,
readonly_template='readonly/customTextinputReadonly'),
title=_('Valid Email'),
)
schema = Schema()
deform.Form.set_default_renderer(mako_renderer)
form = deform.Form(
schema,
buttons=(deform.Button(title=_(u'Update'),
css_class='btn btn-primary'), ),
use_ajax=True)
# Get the user data
user = DBSession.query(User).filter(User.username == userid).first()
data = {
'username': user.username,
'firstname': user.firstname,
'lastname': user.lastname,
'email': user.email
}
def succeed():
# Request all submitted values
firstname_field = self.request.POST.get("firstname")
lastname_field = self.request.POST.get("lastname")
password_field = self.request.POST.get("password")
# Update user fields
user.firstname = firstname_field
user.lastname = lastname_field
if password_field is not None and password_field != '':
user.password = password_field
return Response('<div class="alert alert-success">%s</div>' %
_('Your user settings were updated.'))
ret = self._render_form(form, success=succeed, appstruct=data)
if not isinstance(ret, Response):
self._handle_parameters()
ret['profile'] = get_current_profile(self.request)
ret['locale'] = get_current_locale(self.request)
ret['username'] = user.username
return render_to_response(
get_customized_template_path(self.request,
'users/account_form.mak'), ret,
self.request)
return ret
def activate(self):
"""
"""
activation_uuid = self.request.params.get("uuid")
username = self.request.params.get("username")
if validate_uuid(activation_uuid) is False:
raise HTTPBadRequest('Invalid UUID')
# Get the user
user = DBSession.query(User).filter(
and_(User.activation_uuid == activation_uuid,
User.username == username, User.is_active == False)).first()
# Raise a BadRequest if no user is found
if user is None:
raise HTTPBadRequest('User not found or already active.')
# A timedelta of 48 hours equals 2 days
delta = timedelta(hours=48)
# Create a timezone info
tz = psycopg2.tz.FixedOffsetTimezone(offset=0, name="UTC")
# Check if the registration timestamp is not older than 48 hours
if (datetime.now(tz) - delta) > user.registration_timestamp:
raise HTTPBadRequest("Activation link has been expired.")
# Set the user active and set the activation uuid to NULL
user.is_active = True
user.activation_uuid = None
approval_dict = {
"username":
user.username,
"firstname":
user.firstname,
"lastname":
user.lastname,
"email":
user.email,
"profiles":
",".join([p.code for p in user.profiles]),
"approval_link":
"http://%s/users/approve?user=%s&name=%s" %
(self.request.environ['HTTP_HOST'], user.uuid, user.username)
}
# Send an email to all moderators of the profile in which the user
# registered.
email_text = render(get_customized_template_path(
self.request, 'emails/account_approval_request.mak'),
approval_dict,
request=self.request)
# Determine profile. Each user should only have one profile when
# registering!
profiles = [p.code for p in user.profiles]
if len(profiles) == 0:
profile = get_default_profile(self.request)
else:
profile = profiles[0]
# Find moderators of this profile
moderators = DBSession.query(User). \
join(users_groups). \
join(Group). \
join(users_profiles). \
join(Profile). \
filter(Group.name == 'moderators'). \
filter(Profile.code == profile)
# A list with email addresses the email is sent to
email_addresses = []
for m in moderators.all():
email_addresses.append(m.email)
if len(email_addresses) == 0:
# If no moderator, try to contact the administrators
for admin_user in DBSession.query(User).join(users_groups).join(
Group).filter(func.lower(Group.name) == 'administrators'):
email_addresses.append(admin_user.email)
log.debug(
"No moderator found for profile %s. Approval emails will be "
"sent to administrators: %s" % (profile, email_addresses))
else:
log.debug(
"Approval emails will be sent to moderators of %s profile: %s"
% (profile, email_addresses))
# Send the email
self._send_email(email_addresses,
"User %s requests approval" % user.username,
email_text)
return render_to_response(
get_customized_template_path(self.request,
'users/activation_successful.mak'),
{'username': user.username}, self.request)
def by_stakeholders(self, public=False):
"""
Return many :term:`Activities` based on :term:`Stakeholders`.
Based on the :term:`UIDs` of one or many :term:`Stakeholders`,
all :term:`Activities` in which the :term:`Stakeholder` is
involved are returned.
.. seealso::
:ref:`read-many`
For each :term:`Activity`, only one version is visible, always
the latest visible version to the current user. This means that
logged in users can see their own pending versions and
moderators of the current profile can see pending versions as
well. If you don't want to show pending versions, consider using
:class:`lmkp.views.activities.ActivityView.by_stakeholder_public`
instead.
By default, the :term:`Activities` are ordered with the
:term:`Activity` having the most recent change being on top.
Args:
``public`` (bool): A boolean indicating whether to return
only versions visible to the public (eg. pending) or not.
Matchdict parameters:
``/activities/bystakeholders/{output}/{uids}``
``output`` (str): If the output format is not valid, a 404
Response is returned.
The following output formats are supported:
``json``: Return the :term:`Activities` as JSON.
``html``: Return the :term:`Activities` as HTML (eg. the
`Grid View`)
``uids`` (str): A comma-separated list of
:term:`Stakeholder` :term:`UIDs`.
Request parameters:
``page`` (int): The page parameter is used to paginate
:term:`Items`. In combination with ``pagesize`` it defines
the offset.
``pagesize`` (int): The pagesize parameter defines how many
:term:`Items` are displayed at once. It is used in
combination with ``page`` to allow pagination.
``status`` (str): Use the status parameter to limit results
to displaying only versions with a certain :term:`status`.
Returns:
``HTTPResponse``. Either a HTML or a JSON response.
"""
output_format = get_output_format(self.request)
uids = self.request.matchdict.get('uids', '').split(',')
# Remove any invalid UIDs
for uid in uids:
if validate_uuid(uid) is not True:
uids.remove(uid)
if len(uids) == 0:
raise HTTPNotFound()
if output_format == 'json':
items = activity_protocol.read_many_by_stakeholders(self.request,
uids=uids,
public=public)
return render_to_response('json', items, self.request)
elif output_format == 'html':
page, page_size = get_page_parameters(self.request)
items = activity_protocol.read_many_by_stakeholders(
self.request,
uids=uids,
public=public,
limit=page_size,
offset=page_size * page - page_size)
# No spatial filter is used if the Activities are filtered
# by a Stakeholder
spatial_filter = None
status_filter = None
template_values = self.get_base_template_values()
template_values.update({
'data':
items['data'] if 'data' in items else [],
'total':
items['total'] if 'total' in items else 0,
'spatialfilter':
spatial_filter,
'invfilter':
uids,
'statusfilter':
status_filter,
'currentpage':
page,
'pagesize':
page_size,
'handle_query_string':
handle_query_string
})
return render_to_response(
get_customized_template_path(self.request,
'activities/grid.mak'),
template_values, self.request)
else:
raise HTTPNotFound()
def read_many(self, public=False):
"""
Handels both creation of form and reading form parameters
Return many :term:`Activities`.
.. seealso::
:ref:`read-many`
For each :term:`Activity`, only one version is visible, always
the latest visible version to the current user. This means that
logged in users can see their own pending versions and
moderators of the current profile can see pending versions as
well. If you don't want to show pending versions, consider using
:class:`lmkp.views.activities.ActivityView.read_many_public`
instead.
By default, the :term:`Activities` are ordered with the
:term:`Activity` having the most recent change being on top.
Args:
``public`` (bool): A boolean indicating whether to return
only versions visible to the public (eg. pending) or not.
Matchdict parameters:
``/activities/{output}``
``output`` (str): If the output format is not valid, a 404
Response is returned.
The following output formats are supported:
``json``: Return the :term:`Activities` as JSON.
``geojson``: Return the :term:`Activities` as GeoJSON.
``html``: Return the :term:`Activities` as HTML (eg. the
`Grid View`)
``form``: Returns the form to create a new
:term:`Activity`.
``download``: Returns the page to download
:term:`Activities`.
Request parameters:
``page`` (int): The page parameter is used to paginate
:term:`Items`. In combination with ``pagesize`` it defines
the offset.
``pagesize`` (int): The pagesize parameter defines how many
:term:`Items` are displayed at once. It is used in
combination with ``page`` to allow pagination.
``status`` (str): Use the status parameter to limit results
to displaying only versions with a certain :term:`status`.
Returns:
``HTTPResponse``. Either a HTML or a JSON response.
"""
output_format = get_output_format(self.request)
if output_format == 'json':
items = activity_protocol.read_many(self.request, public=public)
return render_to_response('json', items, self.request)
elif output_format == 'geojson':
items = activity_protocol.read_many_geojson(self.request,
public=public)
return render_to_response('json', items, self.request)
elif output_format == 'html':
page, page_size = get_page_parameters(self.request)
items = activity_protocol.read_many(self.request,
public=public,
limit=page_size,
offset=page_size * page -
page_size)
spatial_filter = 'profile' if get_bbox_parameters(
self.request)[0] == 'profile' else 'map'
status_filter = get_status_parameter(self.request)
__, is_moderator = get_user_privileges(self.request)
template_values = self.get_base_template_values()
template_values.update({
'data':
items['data'] if 'data' in items else [],
'total':
items['total'] if 'total' in items else 0,
'spatialfilter':
spatial_filter,
'invfilter':
None,
'statusfilter':
status_filter,
'currentpage':
page,
'pagesize':
page_size,
'is_moderator':
is_moderator,
'handle_query_string':
handle_query_string
})
return render_to_response(
get_customized_template_path(self.request,
'activities/grid.mak'),
template_values, self.request)
elif output_format == 'form':
is_logged_in, __ = get_user_privileges(self.request)
if not is_logged_in:
raise HTTPForbidden()
new_involvement = self.request.params.get('inv', None)
template_values = renderForm( # render form renders form AND handels parameters passed with post request
self.request,
'activities',
inv=new_involvement)
if isinstance(template_values, Response):
return template_values
template_values.update(self.get_base_template_values())
template_values.update({'uid': '-', 'version': 0})
return render_to_response(
get_customized_template_path(self.request,
'activities/form.mak'),
template_values, self.request)
elif output_format == 'download':
download_view = DownloadView(self.request)
return download_view.download_customize('activities')
else:
raise HTTPNotFound()
def register(self):
"""
Returns and process user self registration form.
"""
_ = self.request.translate
# Define a colander Schema for the self registration
class Schema(colander.Schema):
profile = colander.SchemaNode(
colander.String(),
widget=deform.widget.TextInputWidget(template='hidden'),
name='profile',
title='Profile',
default=get_current_profile(self.request),
missing=get_default_profile(self.request))
username = colander.SchemaNode(colander.String(),
validator=_user_already_exists,
title=_('Username'))
password = colander.SchemaNode(
colander.String(),
validator=colander.Length(min=5),
widget=deform.widget.CheckedPasswordWidget(size=20),
title=_('Password'))
firstname = colander.SchemaNode(colander.String(),
missing=str(u''),
title=_('First Name'))
lastname = colander.SchemaNode(colander.String(),
missing=str(u''),
title=_('Last Name'))
email = colander.SchemaNode(colander.String(),
default='',
title=_("Valid Email"),
validator=_is_valid_email)
schema = Schema()
deform.Form.set_default_renderer(mako_renderer)
buttons = [
deform.Button('submit', _('Submit'), css_class='btn btn-primary')
]
form = deform.Form(schema, buttons=buttons)
def succeed():
"""
"""
# Request all submitted values
profile_field = self.request.POST.get("profile")
username_field = self.request.POST.get("username")
firstname_field = self.request.POST.get("firstname")
lastname_field = self.request.POST.get("lastname")
password_field = self.request.POST.get("password")
email_field = self.request.POST.get("email")
# Get the selected profile
selected_profile = DBSession.query(Profile).filter(
Profile.code == profile_field).first()
# Get the initial user group
user_group = DBSession.query(Group).filter(
Group.name == "editors").first()
# Create an activation uuid
activation_uuid = str(uuid.uuid4())
# Create a new user
new_user = User(username_field,
password_field,
email_field,
firstname=firstname_field,
lastname=lastname_field,
activation_uuid=activation_uuid,
registration_timestamp=datetime.now())
# Set the user profile
new_user.profiles = [selected_profile]
new_user.groups = [user_group]
# Commit the new user
DBSession.add(new_user)
activation_dict = {
"firstname":
new_user.firstname,
"lastname":
new_user.lastname,
"activation_link":
"http://%s/users/activate?uuid=%s&username="******"%s" % (self.request.environ['HTTP_HOST'], activation_uuid,
new_user.username)
}
email_text = render(
get_customized_template_path(self.request,
'emails/account_activation.mak'),
activation_dict, self.request)
self._send_email([email_field], _(u"Activate your Account"),
email_text)
return render_to_response(
get_customized_template_path(self.request,
'users/registration_success.mak'),
{}, self.request)
ret = self._render_form(form, success=succeed)
# 'ret' is a Response object if the form was submitted with success. In
# this case, it is not possible to add any parameters to it.
if not isinstance(ret, Response):
self._handle_parameters()
ret['profile'] = get_current_profile(self.request)
ret['locale'] = get_current_locale(self.request)
# Render the return values
return render_to_response(
get_customized_template_path(self.request,
'users/registration_form.mak'),
ret, self.request)
return ret
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,
# Temporarily disabled comments
'site_key': None,
# '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 = DBSession.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()
