def index(self):
"""
Default controller providing access to the catalogue of user model runs
:return: Rendered catalogue page
"""
# all non-created runs for the user
c.user = self.current_user
c.model_runs = [model
for model in self._model_run_service.get_models_for_user(self.current_user)
if model.status.name != constants.MODEL_RUN_STATUS_CREATED]
total_user_storage = 0
for model in c.model_runs:
if model.status.name != constants.MODEL_RUN_STATUS_PUBLISHED and \
model.status.name != constants.MODEL_RUN_STATUS_PUBLIC:
if model.storage_in_mb is not None:
total_user_storage += model.storage_in_mb
c.storage_total_used_in_gb = utils.convert_mb_to_gb_and_round(total_user_storage)
c.storage_percent_used = round(c.storage_total_used_in_gb / c.user.storage_quota_in_gb * 100.0, 0)
c.bar_class = helpers.get_progress_bar_class_name(c.storage_percent_used)
c.showing = "mine"
c.user_has_model_run_being_created = \
self._model_run_service.get_user_has_model_run_being_created(self.current_user)
return render("model_run/catalogue.html")
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 test_GIVEN_null_storage_WHEN_list_THEN_returns_current_storages_corectly_added_up(self):
user = self.login(access_level=constants.USER_ACCESS_LEVEL_ADMIN)
self.create_run_model(None, "test1", user, constants.MODEL_RUN_STATUS_PUBLISHED)
response = self.app.get(
url=url(controller='user', action=''),
expect_errors=True
)
assert_that(response.normal_body, contains_string(str(utils.convert_mb_to_gb_and_round(0))))
def test_GIVEN_multiple_runs_some_published_some_public_WHEN_list_THEN_returns_current_storages_corectly_added_up(self):
user = self.login(access_level=constants.USER_ACCESS_LEVEL_ADMIN)
failed_storage1 = 90000
self.create_run_model(failed_storage1, "test", user, constants.MODEL_RUN_STATUS_FAILED)
failed_storage2 = 30000
self.create_run_model(failed_storage2, "tes2", user, constants.MODEL_RUN_STATUS_UNKNOWN)
pub_storage1 = 80000
self.create_run_model(pub_storage1, "test3", user, constants.MODEL_RUN_STATUS_PUBLISHED)
pub_storage2 = 100000
self.create_run_model(pub_storage2, "test4", user, constants.MODEL_RUN_STATUS_PUBLISHED)
pub_storage3 = 110000
self.create_run_model(pub_storage3, "test5", user, constants.MODEL_RUN_STATUS_PUBLIC)
response = self.app.get(
url=url(controller='user', action=''),
expect_errors=True
)
assert_that(response.normal_body, contains_string(str(utils.convert_mb_to_gb_and_round(failed_storage1 + failed_storage2))))
assert_that(response.normal_body, contains_string(str(utils.convert_mb_to_gb_and_round(pub_storage1 + pub_storage2 + pub_storage3))))
assert_that(response.normal_body, contains_string(str(utils.convert_mb_to_gb_and_round((pub_storage1 + pub_storage2 + pub_storage3 + failed_storage1 + failed_storage2)))))
def _find_storage_use(self):
"""
Find the total storage use
:return: tuple of quota, total used, percent used
"""
with self.readonly_scope() as session:
core_user = session.query(User).filter(User.username == constants.CORE_USERNAME).one()
storage_total_used_in_gb = 0
for user_id, status, storage_mb in self._model_run_service.get_storage_used():
if storage_mb is not None:
storage_total_used_in_gb += int(storage_mb)
storage_total_used_in_gb = utils.convert_mb_to_gb_and_round(storage_total_used_in_gb)
total_storage_percent_used = storage_total_used_in_gb / core_user.storage_quota_in_gb * 100.0
return core_user.storage_quota_in_gb, storage_total_used_in_gb, total_storage_percent_used
def check_user_quota(self, current_user):
"""
Check that the user can create a new model run
:param current_user: the current user
:return: the model run being created
"""
total = 0
for user_id, status_name, storage_in_mb in self._model_run_service.get_storage_used(current_user):
if status_name != constants.MODEL_RUN_STATUS_PUBLISHED and status_name != constants.MODEL_RUN_STATUS_PUBLIC:
total += storage_in_mb
total_in_gb = utils.convert_mb_to_gb_and_round(total)
storage_percent_used = round(total_in_gb / current_user.storage_quota_in_gb * 100.0, 0)
if storage_percent_used >= constants.QUOTA_ABSOLUTE_LIMIT_PERCENT:
helpers.error_flash(constants.ERROR_MESSAGE_QUOTA_EXCEEDED)
redirect(url(controller="model_run", action="index"))
