class UserController(BaseController):
"""Provides operations for user page actions"""
_user_service = None
_dataset_service = None
def __init__(self,
user_service=UserService(),
dataset_service=DatasetService(),
account_request_service=AccountRequestService()):
"""
Constructor for the user controller, takes in any services required
:param user_service: User service to use within the controller
:param dataset_service: dataset service
:param account_request_service: accoun requests service
:return: nothing
"""
super(UserController, self).__init__(user_service)
self._dataset_service = dataset_service
self._model_run_service = ModelRunService()
self._account_request_service = account_request_service
def index(self):
"""Allow admin-user to see all users of the system. If user is non-admin, redirect to page not found.
"""
if self.current_user is not None and self.current_user.is_admin():
c.all_users = self._user_service.get_all_users()
user_map = {}
for user in c.all_users:
user_map[user.id] = user
user.storage_in_mb = 0
user.published_storage_in_mb = 0
c.storage_total_used_in_gb = 0
for user_id, status, storage_mb in self._model_run_service.get_storage_used():
c.storage_total_used_in_gb += int(storage_mb)
if status == constants.MODEL_RUN_STATUS_PUBLISHED or status == constants.MODEL_RUN_STATUS_PUBLIC:
user_map[user_id].published_storage_in_mb += int(storage_mb)
else:
user_map[user_id].storage_in_mb += int(storage_mb)
c.storage_total_used_in_gb = utils.convert_mb_to_gb_and_round(c.storage_total_used_in_gb)
c.core_user = None
for user in c.all_users:
if user.username == constants.CORE_USERNAME:
c.core_user = user
user.quota_status = ''
percentage = round(utils.convert_mb_to_gb_and_round(user.storage_in_mb)
/ user.storage_quota_in_gb * 100.0, 1)
if percentage >= constants.QUOTA_ABSOLUTE_LIMIT_PERCENT:
user.quota_status = 'error'
elif percentage >= constants.QUOTA_WARNING_LIMIT_PERCENT:
user.quota_status = 'warning'
c.core_user.quota_status = 'info'
c.total_storage_percent_used = c.storage_total_used_in_gb / c.core_user.storage_quota_in_gb * 100.0
c.bar_class = helpers.get_progress_bar_class_name(c.total_storage_percent_used)
return render('user/list_of_users.html')
else:
return render('not_found.html')
def create(self):
"""Create a new user
"""
if not self.current_user.access_level == constants.USER_ACCESS_LEVEL_ADMIN:
return render('not_found.html')
if not request.POST:
return render('new_user.html')
schema = CreateUserForm()
c.form_errors = {}
if request.POST:
try:
c.form_result = schema.to_python(request.params)
except formencode.Invalid, error:
c.form_result = error.value
c.form_errors = error.error_dict or {}
user_email = str(c.form_result.get('email'))
# Username of the user will be set as the user's email address
# Generate an error if the email address (and hence username) is already taken
if self._user_service.get_user_by_email_address(user_email):
c.form_errors = dict(c.form_errors.items() + {
'email': 'Email address is already taken - please choose another.'
}.items())
if c.form_errors:
html = render('new_user.html')
return htmlfill.render(html,
defaults=c.form_result,
errors=c.form_errors,
prefix_error=False,
auto_error_formatter=BaseController.error_formatter)
else:
# By default a user will be an external user
self._user_service.create(c.form_result.get('user_name'),
c.form_result.get('first_name'),
c.form_result.get('last_name'),
user_email,
constants.USER_ACCESS_LEVEL_ADMIN if c.form_result.get('is_admin')
else constants.USER_ACCESS_LEVEL_CEH)
return redirect(url(controller="user"))
