def _external_user_password(self, id):
"""
Code for password resets for an external user
:param id: user id
:return:html to render
"""
c.password_one = ""
c.password_two = ""
can_reset_password = self._valid_user_and_uuid(id)
if can_reset_password == 'OK':
if request.method == 'POST':
try:
self._user_service.reset_password(
c.user.id,
request.params.getone('password_one'),
request.params.getone('password_two'))
helpers.success_flash("Password Reset Successful")
redirect(url(controller='account', action='login'))
except ServiceException as ex:
helpers.error_flash("Password not reset because %s" % ex.message)
return render("user/forgotten_password_external.html")
else:
return render("user/forgotten_password_external.html")
elif can_reset_password == 'EXPIRED':
self._user_service.set_forgot_password(c.user.id, send_email=True)
return render("user/expired_forgotten_password_external.html")
else:
return render("user/invalid_forgotten_password_external.html")
def submit(self):
"""
Page to submit the model un
"""
model_run = None
try:
model_run = \
self._model_run_service.get_model_being_created_with_non_default_parameter_values(self.current_user)
except NoResultFound:
helpers.error_flash(u"You must create a model run before submitting the model run")
redirect(url(controller='model_run', action='create'))
if not request.POST:
self._user_service.set_current_model_run_creation_action(self.current_user, "submit")
summmary_helper = SummaryControllerHelper(model_run_service=self._model_run_service)
summmary_helper.add_summary_fields_to_context(model_run, c, self.current_user)
else:
self._model_run_controller_helper.check_user_quota(self.current_user)
if request.params.getone('submit') == u'Submit':
status, message = self._model_run_service.submit_model_run(self.current_user)
if status.name == constants.MODEL_RUN_STATUS_SUBMITTED:
helpers.success_flash(message)
else:
helpers.error_flash(message)
redirect(url(controller='model_run', action='index'))
else:
redirect(url(controller='model_run', action='output'))
return render('model_run/submit.html')
def make_public(self, id):
"""
Controller allowing existing model runs to be made public
:param id: ID of model run to make public
:return: redirect to the page you came from
"""
if not request.method == 'POST':
helpers.error_flash("Making a model run public must be a post")
redirect(url(controller='model_run', action='index'))
helpers.success_flash("Model run has been made public")
self._model_run_service.make_public_model(self.current_user, id)
redirect_back_to_came_from_for_model_run(id, request.params)
def pre_create(self):
"""
Controller for directing the creation of a new run
If user is over quota redirects to index with error
If model created redirects to last viewed page otherwise redirects to create page
"""
self._model_run_controller_helper.check_user_quota(self.current_user)
model = self._model_run_service.get_model_run_being_created_or_default(self.current_user)
if self.current_user.model_run_creation_action and model.id is not None:
helpers.success_flash("Continuing with the creation of your model run")
redirect(url(controller='model_run', action=self.current_user.model_run_creation_action))
helpers.success_flash("Creating a new model run")
redirect(url(controller='model_run', action='create'))
def delete(self, id):
"""
Action to delete a model run for a user or admin
:param id: the id of the model to delete
:return: redirect to catalgue with flash message
"""
if not request.method == 'POST':
helpers.error_flash("Model run deletion must be a post")
redirect(url(controller='model_run', action='index'))
try:
model_run_name = self._model_run_service.delete_run_model(int(id), self.current_user)
helpers.success_flash("Model run %s deleted" % model_run_name)
except ValueError:
helpers.error_flash("Model run id not a number can not delete it")
except NoResultFound:
helpers.error_flash("Model run can not be deleted, it does not exist")
except ModelPublished:
helpers.error_flash("The model run you are trying to delete has been published. "
"Only admins can delete published model runs.")
except ServiceException, ex:
helpers.error_flash("Model run can not be deleted: {}".format(ex.message))
log.exception("Problem deleting model run %s" % id)
def requests(self, id):
"""
List the account requests for approval
:param id: id to accept or reject or None on get
:return: nothing
"""
if self.current_user is None or not self.current_user.is_admin():
return render('not_found.html')
if not request.method == 'POST':
c.account_requests = self._account_request_service.get_account_requests()
return render('user/requests.html')
else:
if id is None:
helpers.error_flash("Request not accepted or rejected. No id included with reject or accept")
try:
action = request.params.getone('action')
if action == u'accept':
self._account_request_service.accept_account_request(id)
helpers.success_flash("User account created and user emailed.")
elif action == u'reject':
reason_for_rejection = request.params.getone('reason')
if len(reason_for_rejection.strip()) == 0:
helpers.error_flash(
"Request not rejected: A reason must be given to the user for why they are being rejected")
else:
self._account_request_service.reject_account_request(id, reason_for_rejection)
helpers.success_flash("User account request has been rejected and an email has been sent.")
elif action == u'ignore':
self._account_request_service.ignore_account_request(id)
helpers.success_flash(
"User account request ignored; no user account created and user has not been emailed.")
else:
raise KeyError()
except KeyError:
helpers.error_flash("Request not accepted or rejected. No action included with reject or accept")
except NoResultFound:
helpers.error_flash("Request could not be found, no action taken")
except ClientException as ex:
log.exception("Trouble accepting account request because of CROWD")
helpers.error_flash(
"User account could not be created, there is a problem with CROWD: %s" % ex.message)
except ServiceException as ex:
log.exception("Trouble accepting or rejecting account request because of a service error")
helpers.error_flash("User account could not be created %s" % ex.message)
return redirect(url(controller="user", action="requests"))
def driving_data(self):
"""
Select a driving data set
"""
driving_data_controller_helper = DrivingDataControllerHelper()
model_run = None
try:
model_run = \
self._model_run_service.get_model_being_created_with_non_default_parameter_values(self.current_user)
except NoResultFound:
helpers.error_flash(u"You must create a model run before you can choose a driving data set")
redirect(url(controller='model_run', action='create'))
driving_datasets = self._dataset_service.get_driving_datasets(self.current_user)
user_upload_ds_id = self._dataset_service.get_id_for_user_upload_driving_dataset()
errors = {}
c.driving_datasets = driving_datasets
c.user_upload_ds_id = user_upload_ds_id
c.driving_data_rows = model_run.driving_data_rows
if not request.POST:
self._user_service.set_current_model_run_creation_action(self.current_user, "driving_data")
values = driving_data_controller_helper.create_values_dict_from_database(model_run)
if len(driving_datasets) == 0:
abort_with_error("There are no driving datasets available - cannot create a new model run")
# If the chosen driving dataset value is None, set it to the first in the list
if values['driving_dataset'] is None:
values['driving_dataset'] = driving_datasets[0].id
c.errors = errors
html = render('model_run/driving_data.html')
return htmlfill.render(
html,
defaults=values,
errors=errors,
auto_error_formatter=BaseController.error_formatter)
else:
# This is a post
values = dict(request.params)
# Get the action to perform and remove it from the dictionary
action = values['submit']
del values['submit']
old_driving_dataset = None
if model_run.driving_dataset_id is not None:
old_driving_dataset = find_by_id(driving_datasets, model_run.driving_dataset_id)
if action == u'Upload':
# This is a request to to upload a driving data file
try:
driving_data_controller_helper.save_uploaded_driving_data(values, errors,
self._model_run_service,
old_driving_dataset,
self.current_user)
if len(errors) == 0:
# Reload the current page
helpers.success_flash("Your driving data file has been successfully uploaded.")
redirect(url(controller='model_run', action='driving_data'))
return
else:
c.errors = errors
helpers.error_flash("Errors were present in the upload information: please check below.")
html = render('model_run/driving_data.html')
return htmlfill.render(
html,
defaults=values,
errors=errors,
auto_error_formatter=BaseController.error_formatter)
except ServiceException as e:
helpers.error_flash(e.message)
redirect(url(controller='model_run', action='driving_data'))
elif action == u'Download':
# This is a request to to download driving data
try:
file_generator = driving_data_controller_helper.download_driving_data(values, errors, response)
if len(errors) > 0:
c.errors = errors
helpers.error_flash("Errors were present in the download information: please check below.")
return htmlfill.render(
render('model_run/driving_data.html'),
defaults=values,
errors=errors,
auto_error_formatter=BaseController.error_formatter)
# This will stream the file to the browser without loading it all in memory
# BUT only if the .ini file does not have 'debug=true' enabled
return file_generator
except (DapClientException, ServiceException) as e:
helpers.error_flash("Couldn't download data: %s." % e.message)
redirect(url(controller='model_run', action='driving_data'))
else:
try:
driving_dataset = find_by_id(driving_datasets, int(values['driving_dataset']))
except (KeyNotFound, KeyError):
errors['driving_dataset'] = 'Driving data not recognised'
html = render('model_run/driving_data.html')
return htmlfill.render(
html,
defaults=values,
errors=errors,
auto_error_formatter=BaseController.error_formatter)
# If the new selected driving dataset is NOT a user uploaded dataset:
if driving_dataset.id != user_upload_ds_id:
# If the previous driving dataset was a user uploaded driving dataset we need to create an uploaded
# driving dataset so that the parameters are removed:
if old_driving_dataset is not None:
if old_driving_dataset.id == user_upload_ds_id:
old_driving_dataset = driving_data_controller_helper. \
_create_uploaded_driving_dataset(None, None, None, None, self._model_run_service)
self._model_run_service.save_driving_dataset_for_new_model(
driving_dataset,
old_driving_dataset,
self.current_user)
else:
# If the selected driving dataset is the user uploaded dataset we can't proceed if the driving
# data has not already been uploaded:
if not model_run.driving_data_rows:
errors['driving-file'] = 'You must upload a driving data file'
c.errors = errors
html = render('model_run/driving_data.html')
return htmlfill.render(
html,
defaults=values,
errors=errors,
auto_error_formatter=BaseController.error_formatter)
# If the chosen ds_id is 'upload' and they have already uploaded data then we need do nothing
self._model_run_controller_helper.check_user_quota(self.current_user)
if action == u'Next':
redirect(url(controller='model_run', action='extents'))
else:
redirect(url(controller='model_run', action='create'))
