engineering/unrhodecode
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

core: run ruff format

Browse source
This commit is contained in:
RhodeCode Admin 2025-01-13 17:47:37 +01:00
parent 7130effb58
commit 166db21812
821 changed files with 82905 additions and 84121 deletions
Download patch file Download diff file Expand all files Collapse all files

5
rhodecode/apps/admin/views/artifacts.py
View file

@ -25,14 +25,13 @@ log = logging.getLogger(__name__)
class AdminArtifactsView(BaseAppView, DataGridAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
return c
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def artifacts(self):
c = self.load_default_context()
c.active = 'artifacts'
c.active = "artifacts"
return self._get_template_context(c)

35
rhodecode/apps/admin/views/audit_logs.py
View file

@ -31,22 +31,19 @@ log = logging.getLogger(__name__)
class AdminAuditLogsView(BaseAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
return c
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def admin_audit_logs(self):
c = self.load_default_context()
users_log = UserLog.query()\
.options(joinedload(UserLog.user))\
.options(joinedload(UserLog.repository))
users_log = UserLog.query().options(joinedload(UserLog.user)).options(joinedload(UserLog.repository))
# FILTERING
c.search_term = self.request.GET.get('filter')
c.search_term = self.request.GET.get("filter")
try:
users_log = user_log_filter(users_log, c.search_term)
except Exception:
@ -55,30 +52,30 @@ class AdminAuditLogsView(BaseAppView):
users_log = users_log.order_by(UserLog.action_date.desc())
p = safe_int(self.request.GET.get('page', 1), 1)
p = safe_int(self.request.GET.get("page", 1), 1)
def url_generator(page_num):
query_params = {
'page': page_num
}
query_params = {"page": page_num}
if c.search_term:
query_params['filter'] = c.search_term
query_params["filter"] = c.search_term
return self.request.current_route_path(_query=query_params)
c.audit_logs = SqlPage(users_log, page=p, items_per_page=10,
url_maker=url_generator)
c.audit_logs = SqlPage(users_log, page=p, items_per_page=10, url_maker=url_generator)
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def admin_audit_log_entry(self):
c = self.load_default_context()
audit_log_id = self.request.matchdict['audit_log_id']
audit_log_id = self.request.matchdict["audit_log_id"]
c.audit_log_entry = UserLog.query()\
.options(joinedload(UserLog.user))\
.options(joinedload(UserLog.repository))\
.filter(UserLog.user_log_id == audit_log_id).scalar()
c.audit_log_entry = (
UserLog.query()
.options(joinedload(UserLog.user))
.options(joinedload(UserLog.repository))
.filter(UserLog.user_log_id == audit_log_id)
.scalar()
)
if not c.audit_log_entry:
raise HTTPNotFound()

5
rhodecode/apps/admin/views/automation.py
View file

@ -25,14 +25,13 @@ log = logging.getLogger(__name__)
class AdminAutomationView(BaseAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
return c
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def automation(self):
c = self.load_default_context()
c.active = 'automation'
c.active = "automation"
return self._get_template_context(c)

39
rhodecode/apps/admin/views/defaults.py
View file

@ -26,8 +26,7 @@ from pyramid.renderers import render
from pyramid.response import Response
from rhodecode.apps._base import BaseAppView
from rhodecode.lib.auth import (
LoginRequired, HasPermissionAllDecorator, CSRFRequired)
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, CSRFRequired
from rhodecode.lib import helpers as h
from rhodecode.model.forms import DefaultsForm
from rhodecode.model.meta import Session
@ -38,37 +37,29 @@ log = logging.getLogger(__name__)
class AdminDefaultSettingsView(BaseAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
return c
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def defaults_repository_show(self):
c = self.load_default_context()
c.backends = BACKENDS.keys()
c.active = 'repositories'
c.active = "repositories"
defaults = SettingsModel().get_default_repo_settings()
data = render(
'rhodecode:templates/admin/defaults/defaults.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=defaults,
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/defaults/defaults.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=defaults, encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def defaults_repository_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'repositories'
c.active = "repositories"
form = DefaultsForm(self.request.translate)()
try:
@ -77,25 +68,23 @@ class AdminDefaultSettingsView(BaseAppView):
setting = SettingsModel().create_or_update_setting(k, v)
Session().add(setting)
Session().commit()
h.flash(_('Default settings updated successfully'),
category='success')
h.flash(_("Default settings updated successfully"), category="success")
except formencode.Invalid as errors:
data = render(
'rhodecode:templates/admin/defaults/defaults.mako',
self._get_template_context(c), self.request)
"rhodecode:templates/admin/defaults/defaults.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=errors.value,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
except Exception:
log.exception('Exception in update action')
h.flash(_('Error occurred during update of default values'),
category='error')
log.exception("Exception in update action")
h.flash(_("Error occurred during update of default values"), category="error")
raise HTTPFound(h.route_path('admin_defaults_repositories'))
raise HTTPFound(h.route_path("admin_defaults_repositories"))

72
rhodecode/apps/admin/views/exception_tracker.py
View file

@ -23,8 +23,7 @@ from pyramid.httpexceptions import HTTPFound
from rhodecode.apps._base import BaseAppView
from rhodecode.apps._base.navigation import navigation_list
from rhodecode.lib import helpers as h
from rhodecode.lib.auth import (
LoginRequired, HasPermissionAllDecorator, CSRFRequired)
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, CSRFRequired
from rhodecode.lib.utils2 import time_to_utcdatetime, safe_int
from rhodecode.lib import exc_tracking
@ -41,10 +40,10 @@ class ExceptionsTrackerView(BaseAppView):
exc_store_path = exc_tracking.get_exc_store()
count = 0
for fname in os.listdir(exc_store_path):
parts = fname.split('_', 2)
parts = fname.split("_", 2)
if not len(parts) == 3:
continue
count +=1
count += 1
return count
def get_all_exceptions(self, read_metadata=False, limit=None, type_filter=None):
@ -53,20 +52,24 @@ class ExceptionsTrackerView(BaseAppView):
def key_sorter(val):
try:
return val.split('_')[-1]
return val.split("_")[-1]
except Exception:
return 0
for fname in reversed(sorted(os.listdir(exc_store_path), key=key_sorter)):
parts = fname.split('_', 2)
parts = fname.split("_", 2)
if not len(parts) == 3:
continue
exc_id, app_type, exc_timestamp = parts
exc = {'exc_id': exc_id, 'app_type': app_type, 'exc_type': 'unknown',
'exc_utc_date': '', 'exc_timestamp': exc_timestamp}
exc = {
"exc_id": exc_id,
"app_type": app_type,
"exc_type": "unknown",
"exc_utc_date": "",
"exc_timestamp": exc_timestamp,
}
if read_metadata:
full_path = os.path.join(exc_store_path, fname)
@ -74,16 +77,16 @@ class ExceptionsTrackerView(BaseAppView):
continue
try:
# we can read our metadata
with open(full_path, 'rb') as f:
with open(full_path, "rb") as f:
exc_metadata = exc_tracking.exc_unserialize(f.read())
exc.update(exc_metadata)
except Exception:
log.exception(f'Failed to read exc data from:{full_path}')
log.exception(f"Failed to read exc data from:{full_path}")
pass
# convert our timestamp to a date obj, for nicer representation
exc['exc_utc_date'] = time_to_utcdatetime(exc['exc_timestamp'])
exc["exc_utc_date"] = time_to_utcdatetime(exc["exc_timestamp"])
type_present = exc.get('exc_type')
type_present = exc.get("exc_type")
if type_filter:
if type_present and type_present == type_filter:
exception_list.append(exc)
@ -95,65 +98,64 @@ class ExceptionsTrackerView(BaseAppView):
return exception_list
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def browse_exceptions(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'exceptions_browse'
c.limit = safe_int(self.request.GET.get('limit')) or 50
c.type_filter = self.request.GET.get('type_filter')
c.active = "exceptions_browse"
c.limit = safe_int(self.request.GET.get("limit")) or 50
c.type_filter = self.request.GET.get("type_filter")
c.next_limit = c.limit + 50
c.exception_list = self.get_all_exceptions(
read_metadata=True, limit=c.limit, type_filter=c.type_filter)
c.exception_list = self.get_all_exceptions(read_metadata=True, limit=c.limit, type_filter=c.type_filter)
c.exception_list_count = self.count_all_exceptions()
c.exception_store_dir = exc_tracking.get_exc_store()
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def exception_show(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'exceptions'
c.exception_id = self.request.matchdict['exception_id']
c.active = "exceptions"
c.exception_id = self.request.matchdict["exception_id"]
c.traceback = exc_tracking.read_exception(c.exception_id, prefix=None)
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def exception_delete_all(self):
_ = self.request.translate
c = self.load_default_context()
type_filter = self.request.POST.get('type_filter')
type_filter = self.request.POST.get("type_filter")
c.active = 'exceptions'
c.active = "exceptions"
all_exc = self.get_all_exceptions(read_metadata=bool(type_filter), type_filter=type_filter)
exc_count = 0
for exc in all_exc:
if type_filter:
if exc.get('exc_type') == type_filter:
exc_tracking.delete_exception(exc['exc_id'], prefix=None)
if exc.get("exc_type") == type_filter:
exc_tracking.delete_exception(exc["exc_id"], prefix=None)
exc_count += 1
else:
exc_tracking.delete_exception(exc['exc_id'], prefix=None)
exc_tracking.delete_exception(exc["exc_id"], prefix=None)
exc_count += 1
h.flash(_('Removed {} Exceptions').format(exc_count), category='success')
raise HTTPFound(h.route_path('admin_settings_exception_tracker'))
h.flash(_("Removed {} Exceptions").format(exc_count), category="success")
raise HTTPFound(h.route_path("admin_settings_exception_tracker"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def exception_delete(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'exceptions'
c.exception_id = self.request.matchdict['exception_id']
c.active = "exceptions"
c.exception_id = self.request.matchdict["exception_id"]
exc_tracking.delete_exception(c.exception_id, prefix=None)
h.flash(_('Removed Exception {}').format(c.exception_id), category='success')
raise HTTPFound(h.route_path('admin_settings_exception_tracker'))
h.flash(_("Removed Exception {}").format(c.exception_id), category="success")
raise HTTPFound(h.route_path("admin_settings_exception_tracker"))

14
rhodecode/apps/admin/views/main_views.py
View file

@ -22,7 +22,7 @@ from pyramid.httpexceptions import HTTPFound, HTTPNotFound
from rhodecode.apps._base import BaseAppView
from rhodecode.lib import helpers as h
from rhodecode.lib.auth import (LoginRequired, NotAnonymous, HasRepoPermissionAny)
from rhodecode.lib.auth import LoginRequired, NotAnonymous, HasRepoPermissionAny
from rhodecode.model.db import PullRequest
@ -38,7 +38,7 @@ class AdminMainView(BaseAppView):
@NotAnonymous()
def admin_main(self):
c = self.load_default_context()
c.active = 'admin'
c.active = "admin"
if not (c.is_super_admin or c.is_delegated_admin):
raise HTTPNotFound()
@ -52,19 +52,15 @@ class AdminMainView(BaseAppView):
pull_request_id: id of pull requests in the system
"""
pull_request = PullRequest.get_or_404(
self.request.matchdict['pull_request_id'])
pull_request = PullRequest.get_or_404(self.request.matchdict["pull_request_id"])
pull_request_id = pull_request.pull_request_id
repo_name = pull_request.target_repo.repo_name
# NOTE(marcink):
# check permissions so we don't redirect to repo that we don't have access to
# exposing it's name
target_repo_perm = HasRepoPermissionAny(
'repository.read', 'repository.write', 'repository.admin')(repo_name)
target_repo_perm = HasRepoPermissionAny("repository.read", "repository.write", "repository.admin")(repo_name)
if not target_repo_perm:
raise HTTPNotFound()
raise HTTPFound(
h.route_path('pullrequest_show', repo_name=repo_name,
pull_request_id=pull_request_id))
raise HTTPFound(h.route_path("pullrequest_show", repo_name=repo_name, pull_request_id=pull_request_id))

10
rhodecode/apps/admin/views/open_source_licenses.py
View file

@ -21,24 +21,22 @@ import logging
from rhodecode.apps._base import BaseAppView
from rhodecode.apps._base.navigation import navigation_list
from rhodecode.lib.auth import (LoginRequired, HasPermissionAllDecorator)
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
from rhodecode.lib.utils import read_opensource_licenses
log = logging.getLogger(__name__)
class OpenSourceLicensesAdminSettingsView(BaseAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
return c
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def open_source_licenses(self):
c = self.load_default_context()
c.active = 'open_source'
c.active = "open_source"
c.navlist = navigation_list(self.request)
c.opensource_licenses = sorted(
read_opensource_licenses(), key=lambda d: d["name"])
c.opensource_licenses = sorted(read_opensource_licenses(), key=lambda d: d["name"])
return self._get_template_context(c)

268
rhodecode/apps/admin/views/permissions.py
View file

@ -32,13 +32,10 @@ from rhodecode.apps.ssh_support.events import SshKeyFileChangeEvent
from rhodecode import events
from rhodecode.lib import helpers as h
from rhodecode.lib.auth import (
LoginRequired, HasPermissionAllDecorator, CSRFRequired)
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, CSRFRequired
from rhodecode.lib.utils2 import aslist, safe_str
from rhodecode.model.db import (
or_, coalesce, User, UserIpMap, UserSshKeys)
from rhodecode.model.forms import (
ApplicationPermissionsForm, ObjectPermissionsForm, UserPermissionsForm)
from rhodecode.model.db import or_, coalesce, User, UserIpMap, UserSshKeys
from rhodecode.model.forms import ApplicationPermissionsForm, ObjectPermissionsForm, UserPermissionsForm
from rhodecode.model.meta import Session
from rhodecode.model.permission import PermissionModel
from rhodecode.model.settings import SettingsModel
@ -50,122 +47,109 @@ log = logging.getLogger(__name__)
class AdminPermissionsView(BaseAppView, DataGridAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
PermissionModel().set_global_permission_choices(
c, gettext_translator=self.request.translate)
PermissionModel().set_global_permission_choices(c, gettext_translator=self.request.translate)
return c
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def permissions_application(self):
c = self.load_default_context()
c.active = 'application'
c.active = "application"
c.user = User.get_default_user(refresh=True)
app_settings = c.rc_config
defaults = {
'anonymous': c.user.active,
'default_register_message': app_settings.get(
'rhodecode_register_message')
"anonymous": c.user.active,
"default_register_message": app_settings.get("rhodecode_register_message"),
}
defaults.update(c.user.get_default_perms())
data = render('rhodecode:templates/admin/permissions/permissions.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=defaults,
encoding="UTF-8",
force_defaults=False
data = render(
"rhodecode:templates/admin/permissions/permissions.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(data, defaults=defaults, encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def permissions_application_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'application'
c.active = "application"
_form = ApplicationPermissionsForm(
self.request.translate,
[x[0] for x in c.register_choices],
[x[0] for x in c.password_reset_choices],
[x[0] for x in c.extern_activate_choices])()
[x[0] for x in c.extern_activate_choices],
)()
try:
form_result = _form.to_python(dict(self.request.POST))
form_result.update({'perm_user_name': User.DEFAULT_USER})
form_result.update({"perm_user_name": User.DEFAULT_USER})
PermissionModel().update_application_permissions(form_result)
settings = [
('register_message', 'default_register_message'),
("register_message", "default_register_message"),
]
for setting, form_key in settings:
sett = SettingsModel().create_or_update_setting(
setting, form_result[form_key])
sett = SettingsModel().create_or_update_setting(setting, form_result[form_key])
Session().add(sett)
Session().commit()
h.flash(_('Application permissions updated successfully'),
category='success')
h.flash(_("Application permissions updated successfully"), category="success")
except formencode.Invalid as errors:
defaults = errors.value
data = render(
'rhodecode:templates/admin/permissions/permissions.mako',
self._get_template_context(c), self.request)
"rhodecode:templates/admin/permissions/permissions.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=defaults,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
except Exception:
log.exception("Exception during update of permissions")
h.flash(_('Error occurred during update of permissions'),
category='error')
h.flash(_("Error occurred during update of permissions"), category="error")
affected_user_ids = [User.get_default_user_id()]
PermissionModel().trigger_permission_flush(affected_user_ids)
raise HTTPFound(h.route_path('admin_permissions_application'))
raise HTTPFound(h.route_path("admin_permissions_application"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def permissions_objects(self):
c = self.load_default_context()
c.active = 'objects'
c.active = "objects"
c.user = User.get_default_user(refresh=True)
defaults = {}
defaults.update(c.user.get_default_perms())
data = render(
'rhodecode:templates/admin/permissions/permissions.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=defaults,
encoding="UTF-8",
force_defaults=False
"rhodecode:templates/admin/permissions/permissions.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(data, defaults=defaults, encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def permissions_objects_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'objects'
c.active = "objects"
_form = ObjectPermissionsForm(
self.request.translate,
@ -176,87 +160,75 @@ class AdminPermissionsView(BaseAppView, DataGridAppView):
try:
form_result = _form.to_python(dict(self.request.POST))
form_result.update({'perm_user_name': User.DEFAULT_USER})
form_result.update({"perm_user_name": User.DEFAULT_USER})
PermissionModel().update_object_permissions(form_result)
Session().commit()
h.flash(_('Object permissions updated successfully'),
category='success')
h.flash(_("Object permissions updated successfully"), category="success")
except formencode.Invalid as errors:
defaults = errors.value
data = render(
'rhodecode:templates/admin/permissions/permissions.mako',
self._get_template_context(c), self.request)
"rhodecode:templates/admin/permissions/permissions.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=defaults,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
except Exception:
log.exception("Exception during update of permissions")
h.flash(_('Error occurred during update of permissions'),
category='error')
h.flash(_("Error occurred during update of permissions"), category="error")
affected_user_ids = [User.get_default_user_id()]
PermissionModel().trigger_permission_flush(affected_user_ids)
raise HTTPFound(h.route_path('admin_permissions_object'))
raise HTTPFound(h.route_path("admin_permissions_object"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def permissions_branch(self):
c = self.load_default_context()
c.active = 'branch'
c.active = "branch"
c.user = User.get_default_user(refresh=True)
defaults = {}
defaults.update(c.user.get_default_perms())
data = render(
'rhodecode:templates/admin/permissions/permissions.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=defaults,
encoding="UTF-8",
force_defaults=False
"rhodecode:templates/admin/permissions/permissions.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(data, defaults=defaults, encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def permissions_global(self):
c = self.load_default_context()
c.active = 'global'
c.active = "global"
c.user = User.get_default_user(refresh=True)
defaults = {}
defaults.update(c.user.get_default_perms())
data = render(
'rhodecode:templates/admin/permissions/permissions.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=defaults,
encoding="UTF-8",
force_defaults=False
"rhodecode:templates/admin/permissions/permissions.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(data, defaults=defaults, encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def permissions_global_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'global'
c.active = "global"
_form = UserPermissionsForm(
self.request.translate,
@ -265,71 +237,69 @@ class AdminPermissionsView(BaseAppView, DataGridAppView):
[x[0] for x in c.repo_group_create_choices],
[x[0] for x in c.user_group_create_choices],
[x[0] for x in c.fork_choices],
[x[0] for x in c.inherit_default_permission_choices])()
[x[0] for x in c.inherit_default_permission_choices],
)()
try:
form_result = _form.to_python(dict(self.request.POST))
form_result.update({'perm_user_name': User.DEFAULT_USER})
form_result.update({"perm_user_name": User.DEFAULT_USER})
PermissionModel().update_user_permissions(form_result)
Session().commit()
h.flash(_('Global permissions updated successfully'),
category='success')
h.flash(_("Global permissions updated successfully"), category="success")
except formencode.Invalid as errors:
defaults = errors.value
data = render(
'rhodecode:templates/admin/permissions/permissions.mako',
self._get_template_context(c), self.request)
"rhodecode:templates/admin/permissions/permissions.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=defaults,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
except Exception:
log.exception("Exception during update of permissions")
h.flash(_('Error occurred during update of permissions'),
category='error')
h.flash(_("Error occurred during update of permissions"), category="error")
affected_user_ids = [User.get_default_user_id()]
PermissionModel().trigger_permission_flush(affected_user_ids)
raise HTTPFound(h.route_path('admin_permissions_global'))
raise HTTPFound(h.route_path("admin_permissions_global"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def permissions_ips(self):
c = self.load_default_context()
c.active = 'ips'
c.active = "ips"
c.user = User.get_default_user(refresh=True)
c.user_ip_map = (
UserIpMap.query().filter(UserIpMap.user == c.user).all())
c.user_ip_map = UserIpMap.query().filter(UserIpMap.user == c.user).all()
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def permissions_overview(self):
c = self.load_default_context()
c.active = 'perms'
c.active = "perms"
c.user = User.get_default_user(refresh=True)
c.perm_user = c.user.AuthUser()
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def auth_token_access(self):
from rhodecode import CONFIG
c = self.load_default_context()
c.active = 'auth_token_access'
c.active = "auth_token_access"
c.user = User.get_default_user(refresh=True)
c.perm_user = c.user.AuthUser()
@ -337,39 +307,36 @@ class AdminPermissionsView(BaseAppView, DataGridAppView):
mapper = self.request.registry.queryUtility(IRoutesMapper)
c.view_data = []
_argument_prog = re.compile(r'\{(.*?)\}|:\((.*)\)')
_argument_prog = re.compile(r"\{(.*?)\}|:\((.*)\)")
introspector = self.request.registry.introspector
view_intr = {}
for view_data in introspector.get_category('views'):
intr = view_data['introspectable']
for view_data in introspector.get_category("views"):
intr = view_data["introspectable"]
if 'route_name' in intr and intr['attr']:
view_intr[intr['route_name']] = '{}:{}'.format(
str(intr['derived_callable'].__name__), intr['attr']
)
if "route_name" in intr and intr["attr"]:
view_intr[intr["route_name"]] = "{}:{}".format(str(intr["derived_callable"].__name__), intr["attr"])
c.whitelist_key = 'api_access_controllers_whitelist'
c.whitelist_file = CONFIG.get('__file__')
whitelist_views = aslist(
CONFIG.get(c.whitelist_key), sep=',')
c.whitelist_key = "api_access_controllers_whitelist"
c.whitelist_file = CONFIG.get("__file__")
whitelist_views = aslist(CONFIG.get(c.whitelist_key), sep=",")
for route_info in mapper.get_routes():
if not route_info.name.startswith('__'):
if not route_info.name.startswith("__"):
routepath = route_info.pattern
def replace(matchobj):
if matchobj.group(1):
return "{%s}" % matchobj.group(1).split(':')[0]
return "{%s}" % matchobj.group(1).split(":")[0]
else:
return "{%s}" % matchobj.group(2)
routepath = _argument_prog.sub(replace, routepath)
if not routepath.startswith('/'):
routepath = '/' + routepath
if not routepath.startswith("/"):
routepath = "/" + routepath
view_fqn = view_intr.get(route_info.name, 'NOT AVAILABLE')
view_fqn = view_intr.get(route_info.name, "NOT AVAILABLE")
active = view_fqn in whitelist_views
c.view_data.append((route_info.name, view_fqn, routepath, active))
@ -377,55 +344,51 @@ class AdminPermissionsView(BaseAppView, DataGridAppView):
return self._get_template_context(c)
def ssh_enabled(self):
return self.request.registry.settings.get(
'ssh.generate_authorized_keyfile')
return self.request.registry.settings.get("ssh.generate_authorized_keyfile")
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def ssh_keys(self):
c = self.load_default_context()
c.active = 'ssh_keys'
c.active = "ssh_keys"
c.ssh_enabled = self.ssh_enabled()
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def ssh_keys_data(self):
_ = self.request.translate
self.load_default_context()
column_map = {
'fingerprint': 'ssh_key_fingerprint',
'username': User.username
}
column_map = {"fingerprint": "ssh_key_fingerprint", "username": User.username}
draw, start, limit = self._extract_chunk(self.request)
search_q, order_by, order_dir = self._extract_ordering(
self.request, column_map=column_map)
search_q, order_by, order_dir = self._extract_ordering(self.request, column_map=column_map)
ssh_keys_data_total_count = UserSshKeys.query()\
.count()
ssh_keys_data_total_count = UserSshKeys.query().count()
# json generate
base_q = UserSshKeys.query().join(UserSshKeys.user)
if search_q:
like_expression = f'%{safe_str(search_q)}%'
base_q = base_q.filter(or_(
User.username.ilike(like_expression),
UserSshKeys.ssh_key_fingerprint.ilike(like_expression),
))
like_expression = f"%{safe_str(search_q)}%"
base_q = base_q.filter(
or_(
User.username.ilike(like_expression),
UserSshKeys.ssh_key_fingerprint.ilike(like_expression),
)
)
users_data_total_filtered_count = base_q.count()
sort_col = self._get_order_col(order_by, UserSshKeys)
if sort_col:
if order_dir == 'asc':
if order_dir == "asc":
# handle null values properly to order by NULL last
if order_by in ['created_on']:
if order_by in ["created_on"]:
sort_col = coalesce(sort_col, datetime.date.max)
sort_col = sort_col.asc()
else:
# handle null values properly to order by NULL last
if order_by in ['created_on']:
if order_by in ["created_on"]:
sort_col = coalesce(sort_col, datetime.date.min)
sort_col = sort_col.desc()
@ -436,42 +399,39 @@ class AdminPermissionsView(BaseAppView, DataGridAppView):
ssh_keys_data = []
for ssh_key in ssh_keys:
ssh_keys_data.append({
"username": h.gravatar_with_user(self.request, ssh_key.user.username),
"fingerprint": ssh_key.ssh_key_fingerprint,
"description": ssh_key.description,
"created_on": h.format_date(ssh_key.created_on),
"accessed_on": h.format_date(ssh_key.accessed_on),
"action": h.link_to(
_('Edit'), h.route_path('edit_user_ssh_keys',
user_id=ssh_key.user.user_id))
})
ssh_keys_data.append(
{
"username": h.gravatar_with_user(self.request, ssh_key.user.username),
"fingerprint": ssh_key.ssh_key_fingerprint,
"description": ssh_key.description,
"created_on": h.format_date(ssh_key.created_on),
"accessed_on": h.format_date(ssh_key.accessed_on),
"action": h.link_to(_("Edit"), h.route_path("edit_user_ssh_keys", user_id=ssh_key.user.user_id)),
}
)
data = ({
'draw': draw,
'data': ssh_keys_data,
'recordsTotal': ssh_keys_data_total_count,
'recordsFiltered': users_data_total_filtered_count,
})
data = {
"draw": draw,
"data": ssh_keys_data,
"recordsTotal": ssh_keys_data_total_count,
"recordsFiltered": users_data_total_filtered_count,
}
return data
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def ssh_keys_update(self):
_ = self.request.translate
self.load_default_context()
ssh_enabled = self.ssh_enabled()
key_file = self.request.registry.settings.get(
'ssh.authorized_keys_file_path')
key_file = self.request.registry.settings.get("ssh.authorized_keys_file_path")
if ssh_enabled:
events.trigger(SshKeyFileChangeEvent(), self.request.registry)
h.flash(_('Updated SSH keys file: {}').format(key_file),
category='success')
h.flash(_("Updated SSH keys file: {}").format(key_file), category="success")
else:
h.flash(_('SSH key support is disabled in .ini file'),
category='warning')
h.flash(_("SSH key support is disabled in .ini file"), category="warning")
raise HTTPFound(h.route_path('admin_permissions_ssh_keys'))
raise HTTPFound(h.route_path("admin_permissions_ssh_keys"))

76
rhodecode/apps/admin/views/process_management.py
View file

@ -25,8 +25,7 @@ import signal
from rhodecode.apps._base import BaseAppView
from rhodecode.apps._base.navigation import navigation_list
from rhodecode.lib import system_info
from rhodecode.lib.auth import (
LoginRequired, HasPermissionAllDecorator, CSRFRequired)
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, CSRFRequired
from rhodecode.lib.utils2 import safe_int, StrictAttributeDict
log = logging.getLogger(__name__)
@ -40,30 +39,29 @@ class AdminProcessManagementView(BaseAppView):
def _format_proc(self, proc, with_children=False):
try:
mem = proc.memory_info()
proc_formatted = StrictAttributeDict({
'pid': proc.pid,
'name': proc.name(),
'mem_rss': mem.rss,
'mem_vms': mem.vms,
'cpu_percent': proc.cpu_percent(interval=0.1),
'create_time': proc.create_time(),
'cmd': ' '.join(proc.cmdline()),
})
proc_formatted = StrictAttributeDict(
{
"pid": proc.pid,
"name": proc.name(),
"mem_rss": mem.rss,
"mem_vms": mem.vms,
"cpu_percent": proc.cpu_percent(interval=0.1),
"create_time": proc.create_time(),
"cmd": " ".join(proc.cmdline()),
}
)
if with_children:
proc_formatted.update({
'children': [self._format_proc(x)
for x in proc.children(recursive=True)]
})
proc_formatted.update({"children": [self._format_proc(x) for x in proc.children(recursive=True)]})
except Exception:
log.exception('Failed to load proc')
log.exception("Failed to load proc")
proc_formatted = None
return proc_formatted
def get_processes(self):
proc_list = []
for p in psutil.process_iter():
if 'gunicorn' in p.name():
if "gunicorn" in p.name():
proc = self._format_proc(p, with_children=True)
if proc:
proc_list.append(proc)
@ -73,27 +71,27 @@ class AdminProcessManagementView(BaseAppView):
def get_workers(self):
workers = None
try:
rc_config = system_info.rhodecode_config().value['config']
workers = rc_config['server:main'].get('workers')
rc_config = system_info.rhodecode_config().value["config"]
workers = rc_config["server:main"].get("workers")
except Exception:
pass
return workers or '?'
return workers or "?"
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def process_management(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'process_management'
c.active = "process_management"
c.navlist = navigation_list(self.request)
c.gunicorn_processes = self.get_processes()
c.gunicorn_workers = self.get_workers()
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def process_management_data(self):
_ = self.request.translate
c = self.load_default_context()
@ -101,10 +99,10 @@ class AdminProcessManagementView(BaseAppView):
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def process_management_signal(self):
pids = self.request.json.get('pids', [])
pids = self.request.json.get("pids", [])
result = []
def on_terminate(proc):
@ -122,7 +120,7 @@ class AdminProcessManagementView(BaseAppView):
children = proc.children(recursive=True)
if children:
log.warning('Wont kill Master Process')
log.warning("Wont kill Master Process")
else:
procs.append(proc)
@ -130,39 +128,39 @@ class AdminProcessManagementView(BaseAppView):
try:
p.terminate()
except psutil.AccessDenied as e:
log.warning(f'Access denied: {e}')
log.warning(f"Access denied: {e}")
gone, alive = psutil.wait_procs(procs, timeout=10, callback=on_terminate)
for p in alive:
try:
p.kill()
except psutil.AccessDenied as e:
log.warning(f'Access denied: {e}')
log.warning(f"Access denied: {e}")
return {'result': result}
return {"result": result}
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def process_management_master_signal(self):
pid_data = self.request.json.get('pid_data', {})
pid = safe_int(pid_data['pid'])
action = pid_data['action']
pid_data = self.request.json.get("pid_data", {})
pid = safe_int(pid_data["pid"])
action = pid_data["action"]
if pid:
try:
proc = psutil.Process(pid)
except psutil.NoSuchProcess:
return {'result': 'failure_no_such_process'}
return {"result": "failure_no_such_process"}
children = proc.children(recursive=True)
if children:
# master process
if action == '+' and len(children) <= 20:
if action == "+" and len(children) <= 20:
proc.send_signal(signal.SIGTTIN)
elif action == '-' and len(children) >= 2:
elif action == "-" and len(children) >= 2:
proc.send_signal(signal.SIGTTOU)
else:
return {'result': 'failure_wrong_action'}
return {'result': 'success'}
return {"result": "failure_wrong_action"}
return {"result": "success"}
return {'result': 'failure_not_master'}
return {"result": "failure_not_master"}

214
rhodecode/apps/admin/views/repo_groups.py
View file

@ -31,23 +31,19 @@ from sqlalchemy.orm import aliased
from rhodecode import events
from rhodecode.apps._base import BaseAppView, DataGridAppView
from rhodecode.lib.auth import (
LoginRequired, CSRFRequired, NotAnonymous,
HasPermissionAny, HasRepoGroupPermissionAny)
from rhodecode.lib.auth import LoginRequired, CSRFRequired, NotAnonymous, HasPermissionAny, HasRepoGroupPermissionAny
from rhodecode.lib import helpers as h, audit_logger
from rhodecode.lib.str_utils import safe_int, safe_str
from rhodecode.model.forms import RepoGroupForm
from rhodecode.model.permission import PermissionModel
from rhodecode.model.repo_group import RepoGroupModel
from rhodecode.model.scm import RepoGroupList
from rhodecode.model.db import (
or_, count, func, in_filter_generator, Session, RepoGroup, User, Repository)
from rhodecode.model.db import or_, count, func, in_filter_generator, Session, RepoGroup, User, Repository
log = logging.getLogger(__name__)
class AdminRepoGroupsView(BaseAppView, DataGridAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
@ -63,17 +59,14 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
# override the choices for this form, we need to filter choices
# and display only those we have ADMIN right
groups_with_admin_rights = RepoGroupList(
RepoGroup.query().all(),
perm_set=['group.admin'], extra_kwargs=dict(user=self._rhodecode_user))
c.repo_groups = RepoGroup.groups_choices(
groups=groups_with_admin_rights,
show_empty_group=allow_empty_group)
RepoGroup.query().all(), perm_set=["group.admin"], extra_kwargs=dict(user=self._rhodecode_user)
)
c.repo_groups = RepoGroup.groups_choices(groups=groups_with_admin_rights, show_empty_group=allow_empty_group)
c.personal_repo_group = self._rhodecode_user.personal_repo_group
def _can_create_repo_group(self, parent_group_id=None):
is_admin = HasPermissionAny('hg.admin')('group create controller')
create_repo_group = HasPermissionAny(
'hg.repogroup.create.true')('group create controller')
is_admin = HasPermissionAny("hg.admin")("group create controller")
create_repo_group = HasPermissionAny("hg.repogroup.create.true")("group create controller")
if is_admin or (create_repo_group and not parent_group_id):
# we're global admin, or we have global repo group create
# permission
@ -83,8 +76,7 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
# we check the permission if we can write to parent group
group = RepoGroup.get(parent_group_id)
group_name = group.group_name if group else None
if HasRepoGroupPermissionAny('group.admin')(
group_name, 'check if user is an admin of group'):
if HasRepoGroupPermissionAny("group.admin")(group_name, "check if user is an admin of group"):
# we're an admin of passed in group, we're ok.
return True
else:
@ -105,85 +97,90 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
def repo_group_list_data(self):
self.load_default_context()
column_map = {
'name': 'group_name_hash',
'desc': 'group_description',
'last_change': 'updated_on',
'top_level_repos': 'repos_total',
'owner': 'user_username',
"name": "group_name_hash",
"desc": "group_description",
"last_change": "updated_on",
"top_level_repos": "repos_total",
"owner": "user_username",
}
draw, start, limit = self._extract_chunk(self.request)
search_q, order_by, order_dir = self._extract_ordering(
self.request, column_map=column_map)
search_q, order_by, order_dir = self._extract_ordering(self.request, column_map=column_map)
_render = self.request.get_partial_renderer(
'rhodecode:templates/data_table/_dt_elements.mako')
_render = self.request.get_partial_renderer("rhodecode:templates/data_table/_dt_elements.mako")
c = _render.get_call_context()
def quick_menu(repo_group_name):
return _render('quick_repo_group_menu', repo_group_name)
return _render("quick_repo_group_menu", repo_group_name)
def repo_group_lnk(repo_group_name):
return _render('repo_group_name', repo_group_name)
return _render("repo_group_name", repo_group_name)
def last_change(last_change):
if isinstance(last_change, datetime.datetime) and not last_change.tzinfo:
ts = time.time()
utc_offset = (datetime.datetime.fromtimestamp(ts)
- datetime.datetime.utcfromtimestamp(ts)).total_seconds()
utc_offset = (
datetime.datetime.fromtimestamp(ts) - datetime.datetime.utcfromtimestamp(ts)
).total_seconds()
last_change = last_change + datetime.timedelta(seconds=utc_offset)
return _render("last_change", last_change)
def desc(desc, personal):
return _render(
'repo_group_desc', desc, personal, c.visual.stylify_metatags)
return _render("repo_group_desc", desc, personal, c.visual.stylify_metatags)
def repo_group_actions(repo_group_id, repo_group_name, gr_count):
return _render(
'repo_group_actions', repo_group_id, repo_group_name, gr_count)
return _render("repo_group_actions", repo_group_id, repo_group_name, gr_count)
def user_profile(username):
return _render('user_profile', username)
return _render("user_profile", username)
_perms = ['group.admin']
_perms = ["group.admin"]
allowed_ids = [-1] + self._rhodecode_user.repo_group_acl_ids_from_stack(_perms)
repo_groups_data_total_count = RepoGroup.query()\
.filter(or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(RepoGroup.group_id, allowed_ids)
)) \
repo_groups_data_total_count = (
RepoGroup.query()
.filter(
or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(RepoGroup.group_id, allowed_ids)
)
)
.count()
)
repo_groups_data_total_inactive_count = RepoGroup.query()\
.filter(RepoGroup.group_id.in_(allowed_ids))\
.count()
repo_groups_data_total_inactive_count = RepoGroup.query().filter(RepoGroup.group_id.in_(allowed_ids)).count()
repo_count = count(Repository.repo_id)
OwnerUser = aliased(User)
base_q = Session.query(
RepoGroup.group_name,
RepoGroup.group_name_hash,
RepoGroup.group_description,
RepoGroup.group_id,
RepoGroup.personal,
RepoGroup.updated_on,
OwnerUser.username.label('owner_username'),
repo_count.label('repos_count')
) \
.filter(or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(RepoGroup.group_id, allowed_ids)
)) \
.outerjoin(Repository, RepoGroup.group_id == Repository.group_id) \
.join(OwnerUser, RepoGroup.user_id == OwnerUser.user_id)
base_q = (
Session.query(
RepoGroup.group_name,
RepoGroup.group_name_hash,
RepoGroup.group_description,
RepoGroup.group_id,
RepoGroup.personal,
RepoGroup.updated_on,
OwnerUser.username.label("owner_username"),
repo_count.label("repos_count"),
)
.filter(
or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(RepoGroup.group_id, allowed_ids)
)
)
.outerjoin(Repository, RepoGroup.group_id == Repository.group_id)
.join(OwnerUser, RepoGroup.user_id == OwnerUser.user_id)
)
base_q = base_q.group_by(RepoGroup, OwnerUser)
if search_q:
like_expression = f'%{safe_str(search_q)}%'
base_q = base_q.filter(or_(
RepoGroup.group_name.ilike(like_expression),
))
like_expression = f"%{safe_str(search_q)}%"
base_q = base_q.filter(
or_(
RepoGroup.group_name.ilike(like_expression),
)
)
repo_groups_data_total_filtered_count = base_q.count()
# the inactive isn't really used, but we still make it same as other data grids
@ -191,19 +188,19 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
repo_groups_data_total_filtered_inactive_count = repo_groups_data_total_filtered_count
sort_defined = False
if order_by == 'group_name':
if order_by == "group_name":
sort_col = func.lower(RepoGroup.group_name)
sort_defined = True
elif order_by == 'repos_total':
elif order_by == "repos_total":
sort_col = repo_count
sort_defined = True
elif order_by == 'user_username':
elif order_by == "user_username":
sort_col = OwnerUser.username
else:
sort_col = getattr(RepoGroup, order_by, None)
if sort_defined or sort_col:
if order_dir == 'asc':
if order_dir == "asc":
sort_col = sort_col.asc()
else:
sort_col = sort_col.desc()
@ -219,29 +216,25 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
row = {
"menu": quick_menu(repo_gr.group_name),
"name": repo_group_lnk(repo_gr.group_name),
"last_change": last_change(repo_gr.updated_on),
"last_changeset": "",
"last_changeset_raw": "",
"desc": desc(repo_gr.group_description, repo_gr.personal),
"owner": user_profile(repo_gr.owner_username),
"top_level_repos": repo_gr.repos_count,
"action": repo_group_actions(
repo_gr.group_id, repo_gr.group_name, repo_gr.repos_count),
"action": repo_group_actions(repo_gr.group_id, repo_gr.group_name, repo_gr.repos_count),
}
repo_groups_data.append(row)
data = ({
'draw': draw,
'data': repo_groups_data,
'recordsTotal': repo_groups_data_total_count,
'recordsTotalInactive': repo_groups_data_total_inactive_count,
'recordsFiltered': repo_groups_data_total_filtered_count,
'recordsFilteredInactive': repo_groups_data_total_filtered_inactive_count,
})
data = {
"draw": draw,
"data": repo_groups_data,
"recordsTotal": repo_groups_data_total_count,
"recordsTotalInactive": repo_groups_data_total_inactive_count,
"recordsFiltered": repo_groups_data_total_filtered_count,
"recordsFilteredInactive": repo_groups_data_total_filtered_inactive_count,
}
return data
@ -252,7 +245,7 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
c = self.load_default_context()
# perm check for admin, create_group perm or admin of parent_group
parent_group_id = safe_int(self.request.GET.get('parent_group'))
parent_group_id = safe_int(self.request.GET.get("parent_group"))
_gr = RepoGroup.get(parent_group_id)
if not self._can_create_repo_group(parent_group_id):
raise HTTPForbidden()
@ -261,7 +254,7 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
defaults = {} # Future proof for default of repo group
parent_group_choice = '-1'
parent_group_choice = "-1"
if not self._rhodecode_user.is_admin and self._rhodecode_user.personal_repo_group:
parent_group_choice = self._rhodecode_user.personal_repo_group
@ -269,18 +262,13 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
if parent_group_id in [x[0] for x in c.repo_groups]:
parent_group_choice = safe_str(parent_group_id)
defaults.update({'group_parent_id': parent_group_choice})
defaults.update({"group_parent_id": parent_group_choice})
data = render(
'rhodecode:templates/admin/repo_groups/repo_group_add.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=defaults,
encoding="UTF-8",
force_defaults=False
"rhodecode:templates/admin/repo_groups/repo_group_add.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(data, defaults=defaults, encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@ -291,7 +279,7 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
c = self.load_default_context()
_ = self.request.translate
parent_group_id = safe_int(self.request.POST.get('group_parent_id'))
parent_group_id = safe_int(self.request.POST.get("group_parent_id"))
can_create = self._can_create_repo_group(parent_group_id)
self._load_form_data(c)
@ -299,58 +287,54 @@ class AdminRepoGroupsView(BaseAppView, DataGridAppView):
# here in the Form
available_groups = list(map(lambda k: safe_str(k[0]), c.repo_groups))
repo_group_form = RepoGroupForm(
self.request.translate, available_groups=available_groups,
can_create_in_root=can_create)()
self.request.translate, available_groups=available_groups, can_create_in_root=can_create
)()
repo_group_name = self.request.POST.get('group_name')
repo_group_name = self.request.POST.get("group_name")
try:
owner = self._rhodecode_user
form_result = repo_group_form.to_python(dict(self.request.POST))
copy_permissions = form_result.get('group_copy_permissions')
copy_permissions = form_result.get("group_copy_permissions")
repo_group = RepoGroupModel().create(
group_name=form_result['group_name_full'],
group_description=form_result['group_description'],
group_name=form_result["group_name_full"],
group_description=form_result["group_description"],
owner=owner.user_id,
copy_permissions=form_result['group_copy_permissions']
copy_permissions=form_result["group_copy_permissions"],
)
Session().flush()
repo_group_data = repo_group.get_api_data()
audit_logger.store_web(
'repo_group.create', action_data={'data': repo_group_data},
user=self._rhodecode_user)
"repo_group.create", action_data={"data": repo_group_data}, user=self._rhodecode_user
)
Session().commit()
_new_group_name = form_result['group_name_full']
_new_group_name = form_result["group_name_full"]
repo_group_url = h.link_to(
_new_group_name,
h.route_path('repo_group_home', repo_group_name=_new_group_name))
h.flash(h.literal(_('Created repository group %s')
% repo_group_url), category='success')
_new_group_name, h.route_path("repo_group_home", repo_group_name=_new_group_name)
)
h.flash(h.literal(_("Created repository group %s") % repo_group_url), category="success")
except formencode.Invalid as errors:
data = render(
'rhodecode:templates/admin/repo_groups/repo_group_add.mako',
self._get_template_context(c), self.request)
"rhodecode:templates/admin/repo_groups/repo_group_add.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=errors.value,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
except Exception:
log.exception("Exception during creation of repository group")
h.flash(_('Error occurred during creation of repository group %s')
% repo_group_name, category='error')
raise HTTPFound(h.route_path('home'))
h.flash(_("Error occurred during creation of repository group %s") % repo_group_name, category="error")
raise HTTPFound(h.route_path("home"))
PermissionModel().trigger_permission_flush()
raise HTTPFound(
h.route_path('repo_group_home',
repo_group_name=form_result['group_name_full']))
raise HTTPFound(h.route_path("repo_group_home", repo_group_name=form_result["group_name_full"]))

163
rhodecode/apps/admin/views/repositories.py
View file

@ -30,9 +30,7 @@ from rhodecode import events
from rhodecode.apps._base import BaseAppView, DataGridAppView
from rhodecode.lib.celerylib.utils import get_task_id
from rhodecode.lib.auth import (
LoginRequired, CSRFRequired, NotAnonymous,
HasPermissionAny, HasRepoGroupPermissionAny)
from rhodecode.lib.auth import LoginRequired, CSRFRequired, NotAnonymous, HasPermissionAny, HasRepoGroupPermissionAny
from rhodecode.lib import helpers as h
from rhodecode.lib.utils import repo_name_slug
from rhodecode.lib.utils2 import safe_int, safe_str
@ -41,21 +39,18 @@ from rhodecode.model.permission import PermissionModel
from rhodecode.model.repo import RepoModel
from rhodecode.model.scm import RepoList, RepoGroupList, ScmModel
from rhodecode.model.settings import SettingsModel
from rhodecode.model.db import (
in_filter_generator, or_, func, Session, Repository, RepoGroup, User)
from rhodecode.model.db import in_filter_generator, or_, func, Session, Repository, RepoGroup, User
log = logging.getLogger(__name__)
class AdminReposView(BaseAppView, DataGridAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
return c
def _load_form_data(self, c):
acl_groups = RepoGroupList(RepoGroup.query().all(),
perm_set=['group.write', 'group.admin'])
acl_groups = RepoGroupList(RepoGroup.query().all(), perm_set=["group.write", "group.admin"])
c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
c.repo_groups_choices = list(map(lambda k: safe_str(k[0]), c.repo_groups))
c.personal_repo_group = self._rhodecode_user.personal_repo_group
@ -73,69 +68,78 @@ class AdminReposView(BaseAppView, DataGridAppView):
def repository_list_data(self):
self.load_default_context()
column_map = {
'name': 'repo_name',
'desc': 'description',
'last_change': 'updated_on',
'owner': 'user_username',
"name": "repo_name",
"desc": "description",
"last_change": "updated_on",
"owner": "user_username",
}
draw, start, limit = self._extract_chunk(self.request)
search_q, order_by, order_dir = self._extract_ordering(
self.request, column_map=column_map)
search_q, order_by, order_dir = self._extract_ordering(self.request, column_map=column_map)
_perms = ['repository.admin']
_perms = ["repository.admin"]
allowed_ids = [-1] + self._rhodecode_user.repo_acl_ids_from_stack(_perms)
repos_data_total_count = Repository.query() \
.filter(or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(Repository.repo_id, allowed_ids))
) \
repos_data_total_count = (
Repository.query()
.filter(
or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(Repository.repo_id, allowed_ids)
)
)
.count()
)
RepoFork = aliased(Repository)
OwnerUser = aliased(User)
base_q = Session.query(
Repository.repo_id,
Repository.repo_name,
Repository.description,
Repository.repo_type,
Repository.repo_state,
Repository.private,
Repository.archived,
Repository.updated_on,
Repository._changeset_cache,
RepoFork.repo_name.label('fork_repo_name'),
OwnerUser.username.label('owner_username'),
) \
.filter(or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(Repository.repo_id, allowed_ids))
) \
.outerjoin(RepoFork, Repository.fork_id == RepoFork.repo_id) \
base_q = (
Session.query(
Repository.repo_id,
Repository.repo_name,
Repository.description,
Repository.repo_type,
Repository.repo_state,
Repository.private,
Repository.archived,
Repository.updated_on,
Repository._changeset_cache,
RepoFork.repo_name.label("fork_repo_name"),
OwnerUser.username.label("owner_username"),
)
.filter(
or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(Repository.repo_id, allowed_ids)
)
)
.outerjoin(RepoFork, Repository.fork_id == RepoFork.repo_id)
.join(OwnerUser, Repository.user_id == OwnerUser.user_id)
)
if search_q:
like_expression = f'%{safe_str(search_q)}%'
base_q = base_q.filter(or_(
Repository.repo_name.ilike(like_expression),
))
like_expression = f"%{safe_str(search_q)}%"
base_q = base_q.filter(
or_(
Repository.repo_name.ilike(like_expression),
)
)
#TODO: check if we need group_by here ?
#base_q = base_q.group_by(Repository, User)
# TODO: check if we need group_by here ?
# base_q = base_q.group_by(Repository, User)
repos_data_total_filtered_count = base_q.count()
sort_defined = False
if order_by == 'repo_name':
if order_by == "repo_name":
sort_col = func.lower(Repository.repo_name)
sort_defined = True
elif order_by == 'user_username':
elif order_by == "user_username":
sort_col = OwnerUser.username
else:
sort_col = getattr(Repository, order_by, None)
if sort_defined or sort_col:
if order_dir == 'asc':
if order_dir == "asc":
sort_col = sort_col.asc()
else:
sort_col = sort_col.desc()
@ -145,15 +149,14 @@ class AdminReposView(BaseAppView, DataGridAppView):
repos_list = base_q.all()
repos_data = RepoModel().get_repos_as_dict(
repo_list=repos_list, admin=True, super_user_actions=True)
repos_data = RepoModel().get_repos_as_dict(repo_list=repos_list, admin=True, super_user_actions=True)
data = ({
'draw': draw,
'data': repos_data,
'recordsTotal': repos_data_total_count,
'recordsFiltered': repos_data_total_filtered_count,
})
data = {
"draw": draw,
"data": repos_data,
"recordsTotal": repos_data_total_count,
"recordsFiltered": repos_data_total_filtered_count,
}
return data
@LoginRequired()
@ -162,19 +165,19 @@ class AdminReposView(BaseAppView, DataGridAppView):
def repository_new(self):
c = self.load_default_context()
new_repo = self.request.GET.get('repo', '')
parent_group_id = safe_int(self.request.GET.get('parent_group'))
new_repo = self.request.GET.get("repo", "")
parent_group_id = safe_int(self.request.GET.get("parent_group"))
_gr = RepoGroup.get(parent_group_id)
if not HasPermissionAny('hg.admin', 'hg.create.repository')():
if not HasPermissionAny("hg.admin", "hg.create.repository")():
# you're not super admin nor have global create permissions,
# but maybe you have at least write permission to a parent group ?
gr_name = _gr.group_name if _gr else None
# create repositories with write permission on group is set to true
create_on_write = HasPermissionAny('hg.create.write_on_repogroup.true')()
group_admin = HasRepoGroupPermissionAny('group.admin')(group_name=gr_name)
group_write = HasRepoGroupPermissionAny('group.write')(group_name=gr_name)
create_on_write = HasPermissionAny("hg.create.write_on_repogroup.true")()
group_admin = HasRepoGroupPermissionAny("group.admin")(group_name=gr_name)
group_write = HasRepoGroupPermissionAny("group.write")(group_name=gr_name)
if not (group_admin or (group_write and create_on_write)):
raise HTTPForbidden()
@ -184,9 +187,9 @@ class AdminReposView(BaseAppView, DataGridAppView):
# apply the defaults from defaults page
defaults = SettingsModel().get_default_repo_settings(strip_prefix=True)
# set checkbox to autochecked
defaults['repo_copy_permissions'] = True
defaults["repo_copy_permissions"] = True
parent_group_choice = '-1'
parent_group_choice = "-1"
if not self._rhodecode_user.is_admin and self._rhodecode_user.personal_repo_group:
parent_group_choice = self._rhodecode_user.personal_repo_group
@ -194,16 +197,10 @@ class AdminReposView(BaseAppView, DataGridAppView):
if parent_group_id in [x[0] for x in c.repo_groups]:
parent_group_choice = safe_str(parent_group_id)
defaults.update({'repo_group': parent_group_choice})
defaults.update({"repo_group": parent_group_choice})
data = render('rhodecode:templates/admin/repos/repo_add.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=defaults,
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/repos/repo_add.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=defaults, encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@ -218,36 +215,32 @@ class AdminReposView(BaseAppView, DataGridAppView):
try:
# CanWriteToGroup validators checks permissions of this POST
form = RepoForm(
self.request.translate, repo_groups=c.repo_groups_choices)()
form = RepoForm(self.request.translate, repo_groups=c.repo_groups_choices)()
form_result = form.to_python(dict(self.request.POST))
copy_permissions = form_result.get('repo_copy_permissions')
copy_permissions = form_result.get("repo_copy_permissions")
# create is done sometimes async on celery, db transaction
# management is handled there.
task = RepoModel().create(form_result, self._rhodecode_user.user_id)
task_id = get_task_id(task)
except formencode.Invalid as errors:
data = render('rhodecode:templates/admin/repos/repo_add.mako',
self._get_template_context(c), self.request)
data = render("rhodecode:templates/admin/repos/repo_add.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=errors.value,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
except Exception as e:
msg = self._log_creation_exception(e, form_result.get('repo_name'))
h.flash(msg, category='error')
raise HTTPFound(h.route_path('home'))
msg = self._log_creation_exception(e, form_result.get("repo_name"))
h.flash(msg, category="error")
raise HTTPFound(h.route_path("home"))
repo_name = form_result.get('repo_name_full')
repo_name = form_result.get("repo_name_full")
PermissionModel().trigger_permission_flush()
raise HTTPFound(
h.route_path('repo_creating', repo_name=repo_name,
_query=dict(task_id=task_id)))
raise HTTPFound(h.route_path("repo_creating", repo_name=repo_name, _query=dict(task_id=task_id)))

5
rhodecode/apps/admin/views/scheduler.py
View file

@ -25,14 +25,13 @@ log = logging.getLogger(__name__)
class AdminSchedulerView(BaseAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
return c
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def scheduler(self):
c = self.load_default_context()
c.active = 'scheduler'
c.active = "scheduler"
return self._get_template_context(c)

10
rhodecode/apps/admin/views/security.py
View file

@ -25,22 +25,20 @@ log = logging.getLogger(__name__)
class AdminSecurityView(BaseAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
return c
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def security(self):
c = self.load_default_context()
c.active = 'security'
c.active = "security"
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def admin_security_modify_allowed_vcs_client_versions(self):
c = self.load_default_context()
c.active = 'security'
c.active = "security"
return self._get_template_context(c)

39
rhodecode/apps/admin/views/sessions.py
View file

@ -23,8 +23,7 @@ from pyramid.httpexceptions import HTTPFound
from rhodecode.apps._base import BaseAppView
from rhodecode.apps._base.navigation import navigation_list
from rhodecode.lib.auth import (
LoginRequired, HasPermissionAllDecorator, CSRFRequired)
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, CSRFRequired
from rhodecode.lib.utils2 import safe_int
from rhodecode.lib import system_info
from rhodecode.lib import user_sessions
@ -35,59 +34,53 @@ log = logging.getLogger(__name__)
class AdminSessionSettingsView(BaseAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
return c
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_sessions(self):
c = self.load_default_context()
c.active = 'sessions'
c.active = "sessions"
c.navlist = navigation_list(self.request)
c.cleanup_older_days = 60
older_than_seconds = 60 * 60 * 24 * c.cleanup_older_days
config = system_info.rhodecode_config().get_value()['value']['config']
c.session_model = user_sessions.get_session_handler(
config.get('beaker.session.type', 'memory'))(config)
config = system_info.rhodecode_config().get_value()["value"]["config"]
c.session_model = user_sessions.get_session_handler(config.get("beaker.session.type", "memory"))(config)
c.session_conf = c.session_model.config
c.session_count = c.session_model.get_count()
c.session_expired_count = c.session_model.get_expired_count(
older_than_seconds)
c.session_expired_count = c.session_model.get_expired_count(older_than_seconds)
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_sessions_cleanup(self):
_ = self.request.translate
expire_days = safe_int(self.request.params.get('expire_days'))
expire_days = safe_int(self.request.params.get("expire_days"))
if expire_days is None:
expire_days = 60
older_than_seconds = 60 * 60 * 24 * expire_days
config = system_info.rhodecode_config().get_value()['value']['config']
session_model = user_sessions.get_session_handler(
config.get('beaker.session.type', 'memory'))(config)
config = system_info.rhodecode_config().get_value()["value"]["config"]
session_model = user_sessions.get_session_handler(config.get("beaker.session.type", "memory"))(config)
try:
session_model.clean_sessions(
older_than_seconds=older_than_seconds)
h.flash(_('Cleaned up old sessions'), category='success')
session_model.clean_sessions(older_than_seconds=older_than_seconds)
h.flash(_("Cleaned up old sessions"), category="success")
except user_sessions.CleanupCommand as msg:
h.flash(str(msg), category='warning')
h.flash(str(msg), category="warning")
except Exception as e:
log.exception('Failed session cleanup')
h.flash(_('Failed to cleanup up old sessions'), category='error')
log.exception("Failed session cleanup")
h.flash(_("Failed to cleanup up old sessions"), category="error")
redirect_to = self.request.resource_path(
self.context, route_name='admin_settings_sessions')
redirect_to = self.request.resource_path(self.context, route_name="admin_settings_sessions")
return HTTPFound(redirect_to)

494
rhodecode/apps/admin/views/settings.py
View file

@ -34,8 +34,7 @@ from rhodecode.apps._base import BaseAppView
from rhodecode.apps._base.navigation import navigation_list
from rhodecode.apps.svn_support import config_keys
from rhodecode.lib import helpers as h
from rhodecode.lib.auth import (
LoginRequired, HasPermissionAllDecorator, CSRFRequired)
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, CSRFRequired
from rhodecode.lib.celerylib import tasks, run_task
from rhodecode.lib.str_utils import safe_str
from rhodecode.lib.utils import repo2db_mapper, get_rhodecode_repo_store_path, repo2db_cleanup
@ -43,29 +42,29 @@ from rhodecode.lib.utils2 import str2bool, AttributeDict
from rhodecode.lib.index import searcher_from_config
from rhodecode.model.db import RhodeCodeUi, Repository
from rhodecode.model.forms import (ApplicationSettingsForm,
ApplicationUiSettingsForm, ApplicationVisualisationForm,
LabsSettingsForm, IssueTrackerPatternsForm)
from rhodecode.model.forms import (
ApplicationSettingsForm,
ApplicationUiSettingsForm,
ApplicationVisualisationForm,
LabsSettingsForm,
IssueTrackerPatternsForm,
)
from rhodecode.model.permission import PermissionModel
from rhodecode.model.repo_group import RepoGroupModel
from rhodecode.model.scm import ScmModel
from rhodecode.model.notification import EmailNotificationModel
from rhodecode.model.meta import Session
from rhodecode.model.settings import (
IssueTrackerSettingsModel, VcsSettingsModel, SettingNotFound,
SettingsModel)
from rhodecode.model.settings import IssueTrackerSettingsModel, VcsSettingsModel, SettingNotFound, SettingsModel
log = logging.getLogger(__name__)
class AdminSettingsView(BaseAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
c.labs_active = str2bool(
rhodecode.CONFIG.get('labs_settings_active', 'true'))
c.labs_active = str2bool(rhodecode.CONFIG.get("labs_settings_active", "true"))
c.navlist = navigation_list(self.request)
return c
@ -74,11 +73,11 @@ class AdminSettingsView(BaseAppView):
ret = RhodeCodeUi.query().all()
if not ret:
raise Exception('Could not get application ui settings !')
raise Exception("Could not get application ui settings !")
settings = {
# legacy param that needs to be kept
'web_push_ssl': False,
'extensions_hgsubversion': False
"web_push_ssl": False,
"extensions_hgsubversion": False,
}
for each in ret:
k = each.ui_key
@ -86,22 +85,22 @@ class AdminSettingsView(BaseAppView):
section = each.ui_section
# skip some options if they are defined
if f"{section}_{k}" in ['web_push_ssl', 'extensions_hgsubversion']:
if f"{section}_{k}" in ["web_push_ssl", "extensions_hgsubversion"]:
continue
if k == '/':
k = 'root_path'
if k == "/":
k = "root_path"
if k in ['publish', 'enabled']:
if k in ["publish", "enabled"]:
v = str2bool(v)
if k.find('.') != -1:
k = k.replace('.', '_')
if k.find(".") != -1:
k = k.replace(".", "_")
if each.ui_section in ['hooks', 'extensions']:
if each.ui_section in ["hooks", "extensions"]:
v = each.ui_active
settings[section + '_' + k] = v
settings[section + "_" + k] = v
return settings
@ -110,17 +109,19 @@ class AdminSettingsView(BaseAppView):
defaults = SettingsModel().get_all_settings()
defaults.update(cls._get_ui_settings())
defaults.update({
'new_svn_branch': '',
'new_svn_tag': '',
})
defaults.update(
{
"new_svn_branch": "",
"new_svn_tag": "",
}
)
return defaults
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_vcs(self):
c = self.load_default_context()
c.active = 'vcs'
c.active = "vcs"
model = VcsSettingsModel()
c.svn_branch_patterns = model.get_global_svn_branch_patterns()
c.svn_tag_patterns = model.get_global_svn_tag_patterns()
@ -128,23 +129,17 @@ class AdminSettingsView(BaseAppView):
c.svn_config_path = rhodecode.ConfigGet().get_str(config_keys.config_file_path)
defaults = self._form_defaults()
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=defaults,
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=defaults, encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_vcs_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'vcs'
c.active = "vcs"
model = VcsSettingsModel()
c.svn_branch_patterns = model.get_global_svn_branch_patterns()
@ -157,18 +152,17 @@ class AdminSettingsView(BaseAppView):
try:
form_result = application_form.to_python(dict(self.request.POST))
except formencode.Invalid as errors:
h.flash(
_("Some form inputs contain invalid data."),
category='error')
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
h.flash(_("Some form inputs contain invalid data."), category="error")
data = render(
"rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=errors.value,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
@ -181,67 +175,53 @@ class AdminSettingsView(BaseAppView):
model.create_or_update_global_pr_settings(form_result)
except Exception:
log.exception("Exception while updating settings")
h.flash(_('Error occurred during updating '
'application settings'), category='error')
h.flash(_("Error occurred during updating application settings"), category="error")
else:
Session().commit()
h.flash(_('Updated VCS settings'), category='success')
raise HTTPFound(h.route_path('admin_settings_vcs'))
h.flash(_("Updated VCS settings"), category="success")
raise HTTPFound(h.route_path("admin_settings_vcs"))
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=self._form_defaults(),
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=self._form_defaults(), encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_vcs_delete_svn_pattern(self):
delete_pattern_id = self.request.POST.get('delete_svn_pattern')
delete_pattern_id = self.request.POST.get("delete_svn_pattern")
model = VcsSettingsModel()
try:
model.delete_global_svn_pattern(delete_pattern_id)
except SettingNotFound:
log.exception(
'Failed to delete svn_pattern with id %s', delete_pattern_id)
log.exception("Failed to delete svn_pattern with id %s", delete_pattern_id)
raise HTTPNotFound()
Session().commit()
return True
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_mapping(self):
c = self.load_default_context()
c.active = 'mapping'
c.active = "mapping"
c.storage_path = get_rhodecode_repo_store_path()
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=self._form_defaults(),
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=self._form_defaults(), encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_mapping_create(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'mapping'
invalidate_cache = self.request.POST.get('invalidate', False)
log.debug('rescanning repo location')
c.active = "mapping"
invalidate_cache = self.request.POST.get("invalidate", False)
log.debug("rescanning repo location")
if invalidate_cache:
log.debug('invalidating all repositories cache')
log.debug("invalidating all repositories cache")
for repo in Repository.get_all():
ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
@ -250,227 +230,216 @@ class AdminSettingsView(BaseAppView):
PermissionModel().trigger_permission_flush()
def _repr(rm_repo):
return ', '.join(map(safe_str, rm_repo)) or '-'
return ", ".join(map(safe_str, rm_repo)) or "-"
if errors:
h.flash(_('Errors during scan: {}').format(_repr(errors), ), category='error')
h.flash(
_("Errors during scan: {}").format(
_repr(errors),
),
category="error",
)
h.flash(_('Repositories successfully scanned: Added: {}').format(_repr(added)), category='success')
raise HTTPFound(h.route_path('admin_settings_mapping'))
h.flash(_("Repositories successfully scanned: Added: {}").format(_repr(added)), category="success")
raise HTTPFound(h.route_path("admin_settings_mapping"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_mapping_cleanup(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'mapping'
log.debug('rescanning repo location')
c.active = "mapping"
log.debug("rescanning repo location")
removed, errors = repo2db_cleanup()
PermissionModel().trigger_permission_flush()
def _repr(rm_repo):
return ', '.join(map(safe_str, rm_repo)) or '-'
return ", ".join(map(safe_str, rm_repo)) or "-"
h.flash(_('Repositories successfully scanned: Errors: {}, Added: {}').format(errors, _repr(removed)), category='success')
raise HTTPFound(h.route_path('admin_settings_mapping'))
h.flash(
_("Repositories successfully scanned: Errors: {}, Added: {}").format(errors, _repr(removed)),
category="success",
)
raise HTTPFound(h.route_path("admin_settings_mapping"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_global(self):
c = self.load_default_context()
c.active = 'global'
c.personal_repo_group_default_pattern = RepoGroupModel()\
.get_personal_group_name_pattern()
c.active = "global"
c.personal_repo_group_default_pattern = RepoGroupModel().get_personal_group_name_pattern()
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=self._form_defaults(),
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=self._form_defaults(), encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_global_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'global'
c.personal_repo_group_default_pattern = RepoGroupModel()\
.get_personal_group_name_pattern()
c.active = "global"
c.personal_repo_group_default_pattern = RepoGroupModel().get_personal_group_name_pattern()
application_form = ApplicationSettingsForm(self.request.translate)()
try:
form_result = application_form.to_python(dict(self.request.POST))
except formencode.Invalid as errors:
h.flash(
_("Some form inputs contain invalid data."),
category='error')
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
h.flash(_("Some form inputs contain invalid data."), category="error")
data = render(
"rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=errors.value,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
settings = [
('title', 'rhodecode_title', 'unicode'),
('realm', 'rhodecode_realm', 'unicode'),
('pre_code', 'rhodecode_pre_code', 'unicode'),
('post_code', 'rhodecode_post_code', 'unicode'),
('captcha_public_key', 'rhodecode_captcha_public_key', 'unicode'),
('captcha_private_key', 'rhodecode_captcha_private_key', 'unicode'),
('create_personal_repo_group', 'rhodecode_create_personal_repo_group', 'bool'),
('personal_repo_group_pattern', 'rhodecode_personal_repo_group_pattern', 'unicode'),
("title", "rhodecode_title", "unicode"),
("realm", "rhodecode_realm", "unicode"),
("pre_code", "rhodecode_pre_code", "unicode"),
("post_code", "rhodecode_post_code", "unicode"),
("captcha_public_key", "rhodecode_captcha_public_key", "unicode"),
("captcha_private_key", "rhodecode_captcha_private_key", "unicode"),
("create_personal_repo_group", "rhodecode_create_personal_repo_group", "bool"),
("personal_repo_group_pattern", "rhodecode_personal_repo_group_pattern", "unicode"),
]
try:
for setting, form_key, type_ in settings:
sett = SettingsModel().create_or_update_setting(
setting, form_result[form_key], type_)
sett = SettingsModel().create_or_update_setting(setting, form_result[form_key], type_)
Session().add(sett)
Session().commit()
SettingsModel().invalidate_settings_cache()
h.flash(_('Updated application settings'), category='success')
h.flash(_("Updated application settings"), category="success")
except Exception:
log.exception("Exception while updating application settings")
h.flash(
_('Error occurred during updating application settings'),
category='error')
h.flash(_("Error occurred during updating application settings"), category="error")
raise HTTPFound(h.route_path('admin_settings_global'))
raise HTTPFound(h.route_path("admin_settings_global"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_visual(self):
c = self.load_default_context()
c.active = 'visual'
c.active = "visual"
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=self._form_defaults(),
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=self._form_defaults(), encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_visual_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'visual'
c.active = "visual"
application_form = ApplicationVisualisationForm(self.request.translate)()
try:
form_result = application_form.to_python(dict(self.request.POST))
except formencode.Invalid as errors:
h.flash(
_("Some form inputs contain invalid data."),
category='error')
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
h.flash(_("Some form inputs contain invalid data."), category="error")
data = render(
"rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=errors.value,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
try:
settings = [
('show_public_icon', 'rhodecode_show_public_icon', 'bool'),
('show_private_icon', 'rhodecode_show_private_icon', 'bool'),
('stylify_metatags', 'rhodecode_stylify_metatags', 'bool'),
('repository_fields', 'rhodecode_repository_fields', 'bool'),
('dashboard_items', 'rhodecode_dashboard_items', 'int'),
('admin_grid_items', 'rhodecode_admin_grid_items', 'int'),
('show_version', 'rhodecode_show_version', 'bool'),
('use_gravatar', 'rhodecode_use_gravatar', 'bool'),
('markup_renderer', 'rhodecode_markup_renderer', 'unicode'),
('gravatar_url', 'rhodecode_gravatar_url', 'unicode'),
('clone_uri_tmpl', 'rhodecode_clone_uri_tmpl', 'unicode'),
('clone_uri_id_tmpl', 'rhodecode_clone_uri_id_tmpl', 'unicode'),
('clone_uri_ssh_tmpl', 'rhodecode_clone_uri_ssh_tmpl', 'unicode'),
('support_url', 'rhodecode_support_url', 'unicode'),
('show_revision_number', 'rhodecode_show_revision_number', 'bool'),
('show_sha_length', 'rhodecode_show_sha_length', 'int'),
("show_public_icon", "rhodecode_show_public_icon", "bool"),
("show_private_icon", "rhodecode_show_private_icon", "bool"),
("stylify_metatags", "rhodecode_stylify_metatags", "bool"),
("repository_fields", "rhodecode_repository_fields", "bool"),
("dashboard_items", "rhodecode_dashboard_items", "int"),
("admin_grid_items", "rhodecode_admin_grid_items", "int"),
("show_version", "rhodecode_show_version", "bool"),
("use_gravatar", "rhodecode_use_gravatar", "bool"),
("markup_renderer", "rhodecode_markup_renderer", "unicode"),
("gravatar_url", "rhodecode_gravatar_url", "unicode"),
("clone_uri_tmpl", "rhodecode_clone_uri_tmpl", "unicode"),
("clone_uri_id_tmpl", "rhodecode_clone_uri_id_tmpl", "unicode"),
("clone_uri_ssh_tmpl", "rhodecode_clone_uri_ssh_tmpl", "unicode"),
("support_url", "rhodecode_support_url", "unicode"),
("show_revision_number", "rhodecode_show_revision_number", "bool"),
("show_sha_length", "rhodecode_show_sha_length", "int"),
]
for setting, form_key, type_ in settings:
sett = SettingsModel().create_or_update_setting(
setting, form_result[form_key], type_)
sett = SettingsModel().create_or_update_setting(setting, form_result[form_key], type_)
Session().add(sett)
Session().commit()
SettingsModel().invalidate_settings_cache()
h.flash(_('Updated visualisation settings'), category='success')
h.flash(_("Updated visualisation settings"), category="success")
except Exception:
log.exception("Exception updating visualization settings")
h.flash(_('Error occurred during updating '
'visualisation settings'),
category='error')
h.flash(_("Error occurred during updating visualisation settings"), category="error")
raise HTTPFound(h.route_path('admin_settings_visual'))
raise HTTPFound(h.route_path("admin_settings_visual"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_issuetracker(self):
c = self.load_default_context()
c.active = 'issuetracker'
c.active = "issuetracker"
defaults = c.rc_config
entry_key = 'rhodecode_issuetracker_pat_'
entry_key = "rhodecode_issuetracker_pat_"
c.issuetracker_entries = {}
for k, v in defaults.items():
if k.startswith(entry_key):
uid = k[len(entry_key):]
uid = k[len(entry_key) :]
c.issuetracker_entries[uid] = None
for uid in c.issuetracker_entries:
c.issuetracker_entries[uid] = AttributeDict({
'pat': defaults.get('rhodecode_issuetracker_pat_' + uid),
'url': defaults.get('rhodecode_issuetracker_url_' + uid),
'pref': defaults.get('rhodecode_issuetracker_pref_' + uid),
'desc': defaults.get('rhodecode_issuetracker_desc_' + uid),
})
c.issuetracker_entries[uid] = AttributeDict(
{
"pat": defaults.get("rhodecode_issuetracker_pat_" + uid),
"url": defaults.get("rhodecode_issuetracker_url_" + uid),
"pref": defaults.get("rhodecode_issuetracker_pref_" + uid),
"desc": defaults.get("rhodecode_issuetracker_desc_" + uid),
}
)
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_issuetracker_test(self):
error_container = []
urlified_commit = h.urlify_commit_message(
self.request.POST.get('test_text', ''),
'repo_group/test_repo1', error_container=error_container)
self.request.POST.get("test_text", ""), "repo_group/test_repo1", error_container=error_container
)
if error_container:
def converter(inp):
return h.html_escape(inp)
return 'ERRORS: ' + '\n'.join(map(converter, error_container))
return "ERRORS: " + "\n".join(map(converter, error_container))
return urlified_commit
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_issuetracker_update(self):
_ = self.request.translate
@ -481,132 +450,115 @@ class AdminSettingsView(BaseAppView):
form = IssueTrackerPatternsForm(self.request.translate)()
data = form.to_python(self.request.POST)
except formencode.Invalid as errors:
log.exception('Failed to add new pattern')
log.exception("Failed to add new pattern")
error = errors
h.flash(_(f'Invalid issue tracker pattern: {error}'),
category='error')
raise HTTPFound(h.route_path('admin_settings_issuetracker'))
h.flash(_(f"Invalid issue tracker pattern: {error}"), category="error")
raise HTTPFound(h.route_path("admin_settings_issuetracker"))
if data:
for uid in data.get('delete_patterns', []):
for uid in data.get("delete_patterns", []):
settings_model.delete_entries(uid)
for pattern in data.get('patterns', []):
for pattern in data.get("patterns", []):
for setting, value, type_ in pattern:
sett = settings_model.create_or_update_setting(
setting, value, type_)
sett = settings_model.create_or_update_setting(setting, value, type_)
Session().add(sett)
Session().commit()
SettingsModel().invalidate_settings_cache()
h.flash(_('Updated issue tracker entries'), category='success')
raise HTTPFound(h.route_path('admin_settings_issuetracker'))
h.flash(_("Updated issue tracker entries"), category="success")
raise HTTPFound(h.route_path("admin_settings_issuetracker"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_issuetracker_delete(self):
_ = self.request.translate
self.load_default_context()
uid = self.request.POST.get('uid')
uid = self.request.POST.get("uid")
try:
IssueTrackerSettingsModel().delete_entries(uid)
except Exception:
log.exception('Failed to delete issue tracker setting %s', uid)
log.exception("Failed to delete issue tracker setting %s", uid)
raise HTTPNotFound()
SettingsModel().invalidate_settings_cache()
h.flash(_('Removed issue tracker entry.'), category='success')
h.flash(_("Removed issue tracker entry."), category="success")
return {'deleted': uid}
return {"deleted": uid}
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_email(self):
c = self.load_default_context()
c.active = 'email'
c.active = "email"
c.rhodecode_ini = rhodecode.CONFIG
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=self._form_defaults(),
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=self._form_defaults(), encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_email_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'email'
c.active = "email"
test_email = self.request.POST.get('test_email')
test_email = self.request.POST.get("test_email")
if not test_email:
h.flash(_('Please enter email address'), category='error')
raise HTTPFound(h.route_path('admin_settings_email'))
h.flash(_("Please enter email address"), category="error")
raise HTTPFound(h.route_path("admin_settings_email"))
email_kwargs = {
'date': datetime.datetime.now(),
'user': self._rhodecode_db_user
}
email_kwargs = {"date": datetime.datetime.now(), "user": self._rhodecode_db_user}
(subject, email_body, email_body_plaintext) = EmailNotificationModel().render_email(
EmailNotificationModel.TYPE_EMAIL_TEST, **email_kwargs)
EmailNotificationModel.TYPE_EMAIL_TEST, **email_kwargs
)
recipients = [test_email] if test_email else None
run_task(tasks.send_email, recipients, subject,
email_body_plaintext, email_body)
run_task(tasks.send_email, recipients, subject, email_body_plaintext, email_body)
h.flash(_('Send email task created'), category='success')
raise HTTPFound(h.route_path('admin_settings_email'))
h.flash(_("Send email task created"), category="success")
raise HTTPFound(h.route_path("admin_settings_email"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_hooks(self):
c = self.load_default_context()
c.active = 'hooks'
c.active = "hooks"
model = SettingsModel()
c.hooks = model.get_builtin_hooks()
c.custom_hooks = model.get_custom_hooks()
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=self._form_defaults(),
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=self._form_defaults(), encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_hooks_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'hooks'
c.active = "hooks"
if c.visual.allow_custom_hooks_settings:
ui_key = self.request.POST.get('new_hook_ui_key')
ui_value = self.request.POST.get('new_hook_ui_value')
ui_key = self.request.POST.get("new_hook_ui_key")
ui_value = self.request.POST.get("new_hook_ui_value")
hook_id = self.request.POST.get('hook_id')
hook_id = self.request.POST.get("hook_id")
new_hook = False
model = SettingsModel()
try:
if ui_value and ui_key:
model.create_or_update_hook(ui_key, ui_value)
h.flash(_('Added new hook'), category='success')
h.flash(_("Added new hook"), category="success")
new_hook = True
elif hook_id:
RhodeCodeUi.delete(hook_id)
@ -615,26 +567,24 @@ class AdminSettingsView(BaseAppView):
# check for edits
update = False
_d = self.request.POST.dict_of_lists()
for k, v in zip(_d.get('hook_ui_key', []),
_d.get('hook_ui_value_new', [])):
for k, v in zip(_d.get("hook_ui_key", []), _d.get("hook_ui_value_new", [])):
model.create_or_update_hook(k, v)
update = True
if update and not new_hook:
h.flash(_('Updated hooks'), category='success')
h.flash(_("Updated hooks"), category="success")
Session().commit()
except Exception:
log.exception("Exception during hook creation")
h.flash(_('Error occurred during hook creation'),
category='error')
h.flash(_("Error occurred during hook creation"), category="error")
raise HTTPFound(h.route_path('admin_settings_hooks'))
raise HTTPFound(h.route_path("admin_settings_hooks"))
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_search(self):
c = self.load_default_context()
c.active = 'search'
c.active = "search"
c.searcher = searcher_from_config(self.request.registry.settings)
c.statistics = c.searcher.statistics(self.request.translate)
@ -642,78 +592,63 @@ class AdminSettingsView(BaseAppView):
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_labs(self):
c = self.load_default_context()
if not c.labs_active:
raise HTTPFound(h.route_path('admin_settings'))
raise HTTPFound(h.route_path("admin_settings"))
c.active = 'labs'
c.active = "labs"
c.lab_settings = _LAB_SETTINGS
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=self._form_defaults(),
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=self._form_defaults(), encoding="UTF-8", force_defaults=False)
return Response(html)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def settings_labs_update(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'labs'
c.active = "labs"
application_form = LabsSettingsForm(self.request.translate)()
try:
form_result = application_form.to_python(dict(self.request.POST))
except formencode.Invalid as errors:
h.flash(
_("Some form inputs contain invalid data."),
category='error')
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
h.flash(_("Some form inputs contain invalid data."), category="error")
data = render(
"rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=errors.value,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
try:
session = Session()
for setting in _LAB_SETTINGS:
setting_name = setting.key[len('rhodecode_'):]
sett = SettingsModel().create_or_update_setting(
setting_name, form_result[setting.key], setting.type)
setting_name = setting.key[len("rhodecode_") :]
sett = SettingsModel().create_or_update_setting(setting_name, form_result[setting.key], setting.type)
session.add(sett)
except Exception:
log.exception('Exception while updating lab settings')
h.flash(_('Error occurred during updating labs settings'),
category='error')
log.exception("Exception while updating lab settings")
h.flash(_("Error occurred during updating labs settings"), category="error")
else:
Session().commit()
SettingsModel().invalidate_settings_cache()
h.flash(_('Updated Labs settings'), category='success')
raise HTTPFound(h.route_path('admin_settings_labs'))
h.flash(_("Updated Labs settings"), category="success")
raise HTTPFound(h.route_path("admin_settings_labs"))
data = render('rhodecode:templates/admin/settings/settings.mako',
self._get_template_context(c), self.request)
html = formencode.htmlfill.render(
data,
defaults=self._form_defaults(),
encoding="UTF-8",
force_defaults=False
)
data = render("rhodecode:templates/admin/settings/settings.mako", self._get_template_context(c), self.request)
html = formencode.htmlfill.render(data, defaults=self._form_defaults(), encoding="UTF-8", force_defaults=False)
return Response(html)
@ -722,12 +657,9 @@ class AdminSettingsView(BaseAppView):
# :param group: the i18ned group in which we should dispaly this setting
# :param label: the i18ned label we should display for this setting
# :param help: the i18ned help we should dispaly for this setting
LabSetting = collections.namedtuple(
'LabSetting', ('key', 'type', 'group', 'label', 'help'))
LabSetting = collections.namedtuple("LabSetting", ("key", "type", "group", "label", "help"))
# This list has to be kept in sync with the form
# rhodecode.model.forms.LabsSettingsForm.
_LAB_SETTINGS = [
]
_LAB_SETTINGS = []

21
rhodecode/apps/admin/views/svn_config.py
View file

@ -19,36 +19,31 @@
import logging
from rhodecode.apps._base import BaseAppView
from rhodecode.apps.svn_support.utils import generate_mod_dav_svn_config
from rhodecode.lib.auth import (
LoginRequired, HasPermissionAllDecorator, CSRFRequired)
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, CSRFRequired
log = logging.getLogger(__name__)
class AdminSvnConfigView(BaseAppView):
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
@CSRFRequired()
def vcs_svn_generate_config(self):
_ = self.request.translate
try:
file_path = generate_mod_dav_svn_config(self.request.registry)
msg = {
'message': _('Apache configuration for Subversion generated at `{}`.').format(file_path),
'level': 'success',
"message": _("Apache configuration for Subversion generated at `{}`.").format(file_path),
"level": "success",
}
except Exception:
log.exception(
'Exception while generating the Apache '
'configuration for Subversion.')
log.exception("Exception while generating the Apache configuration for Subversion.")
msg = {
'message': _('Failed to generate the Apache configuration for Subversion.'),
'level': 'error',
"message": _("Failed to generate the Apache configuration for Subversion."),
"level": "error",
}
data = {'message': msg}
data = {"message": msg}
return data

245
rhodecode/apps/admin/views/system_info.py
View file

@ -26,7 +26,7 @@ import rhodecode
from rhodecode.apps._base import BaseAppView
from rhodecode.apps._base.navigation import navigation_list
from rhodecode.lib import helpers as h
from rhodecode.lib.auth import (LoginRequired, HasPermissionAllDecorator)
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
from rhodecode.lib.utils2 import str2bool
from rhodecode.lib import system_info
from rhodecode.model.update import UpdateModel
@ -41,51 +41,49 @@ class AdminSystemInfoSettingsView(BaseAppView):
def get_env_data(self):
black_list = [
'NIX_LDFLAGS',
'NIX_CFLAGS_COMPILE',
'propagatedBuildInputs',
'propagatedNativeBuildInputs',
'postInstall',
'buildInputs',
'buildPhase',
'preShellHook',
'preShellHook',
'preCheck',
'preBuild',
'postShellHook',
'postFixup',
'postCheck',
'nativeBuildInputs',
'installPhase',
'installCheckPhase',
'checkPhase',
'configurePhase',
'shellHook'
]
secret_list = [
'RHODECODE_USER_PASS'
"NIX_LDFLAGS",
"NIX_CFLAGS_COMPILE",
"propagatedBuildInputs",
"propagatedNativeBuildInputs",
"postInstall",
"buildInputs",
"buildPhase",
"preShellHook",
"preShellHook",
"preCheck",
"preBuild",
"postShellHook",
"postFixup",
"postCheck",
"nativeBuildInputs",
"installPhase",
"installCheckPhase",
"checkPhase",
"configurePhase",
"shellHook",
]
secret_list = ["RHODECODE_USER_PASS"]
for k, v in sorted(os.environ.items()):
if k in black_list:
continue
if k in secret_list:
v = '*****'
v = "*****"
yield k, v
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_system_info(self):
_ = self.request.translate
c = self.load_default_context()
c.active = 'system'
c.active = "system"
c.navlist = navigation_list(self.request)
# TODO(marcink), figure out how to allow only selected users to do this
c.allowed_to_snapshot = self._rhodecode_user.admin
snapshot = str2bool(self.request.params.get('snapshot'))
snapshot = str2bool(self.request.params.get("snapshot"))
c.rhodecode_update_url = UpdateModel().get_update_url()
c.env_data = self.get_env_data()
@ -94,127 +92,122 @@ class AdminSystemInfoSettingsView(BaseAppView):
for key, val in server_info.items():
setattr(c, key, val)
def val(name, subkey='human_value'):
def val(name, subkey="human_value"):
return server_info[name][subkey]
def state(name):
return server_info[name]['state']
return server_info[name]["state"]
def val2(name):
val = server_info[name]['human_value']
state = server_info[name]['state']
val = server_info[name]["human_value"]
state = server_info[name]["state"]
return val, state
update_info_msg = _('Note: please make sure this server can '
'access `${url}` for the update link to work',
mapping=dict(url=c.rhodecode_update_url))
update_info_msg = _(
"Note: please make sure this server can access `${url}` for the update link to work",
mapping=dict(url=c.rhodecode_update_url),
)
version = UpdateModel().get_stored_version()
is_outdated = UpdateModel().is_outdated(
rhodecode.__version__, version)
update_state = {
'type': 'warning',
'message': 'New version available: {}'.format(version)
} \
if is_outdated else {}
is_outdated = UpdateModel().is_outdated(rhodecode.__version__, version)
update_state = (
{"type": "warning", "message": "New version available: {}".format(version)} if is_outdated else {}
)
c.data_items = [
# update info
(_('Update info'), h.literal(
'<span class="link" id="check_for_update" >%s.</span>' % (
_('Check for updates')) +
'<br/> <span >%s.</span>' % (update_info_msg)
), ''),
(
_("Update info"),
h.literal(
'<span class="link" id="check_for_update" >%s.</span>' % (_("Check for updates"))
+ "<br/> <span >%s.</span>" % (update_info_msg)
),
"",
),
# RhodeCode specific
(_('RhodeCode Version'), val('rhodecode_app')['text'], state('rhodecode_app')),
(_('Latest version'), version, update_state),
(_('RhodeCode Base URL'), val('rhodecode_config')['config'].get('app.base_url'), state('rhodecode_config')),
(_('RhodeCode Server IP'), val('server')['server_ip'], state('server')),
(_('RhodeCode Server ID'), val('server')['server_id'], state('server')),
(_('RhodeCode Configuration'), val('rhodecode_config')['path'], state('rhodecode_config')),
(_('RhodeCode Certificate'), val('rhodecode_config')['cert_path'], state('rhodecode_config')),
(_('Workers'), val('rhodecode_config')['config']['server:main'].get('workers', '?'), state('rhodecode_config')),
(_('Worker Type'), val('rhodecode_config')['config']['server:main'].get('worker_class', 'sync'), state('rhodecode_config')),
('', '', ''), # spacer
(_("RhodeCode Version"), val("rhodecode_app")["text"], state("rhodecode_app")),
(_("Latest version"), version, update_state),
(_("RhodeCode Base URL"), val("rhodecode_config")["config"].get("app.base_url"), state("rhodecode_config")),
(_("RhodeCode Server IP"), val("server")["server_ip"], state("server")),
(_("RhodeCode Server ID"), val("server")["server_id"], state("server")),
(_("RhodeCode Configuration"), val("rhodecode_config")["path"], state("rhodecode_config")),
(_("RhodeCode Certificate"), val("rhodecode_config")["cert_path"], state("rhodecode_config")),
(
_("Workers"),
val("rhodecode_config")["config"]["server:main"].get("workers", "?"),
state("rhodecode_config"),
),
(
_("Worker Type"),
val("rhodecode_config")["config"]["server:main"].get("worker_class", "sync"),
state("rhodecode_config"),
),
("", "", ""), # spacer
# Database
(_('Database'), val('database')['url'], state('database')),
(_('Database version'), val('database')['version'], state('database')),
('', '', ''), # spacer
(_("Database"), val("database")["url"], state("database")),
(_("Database version"), val("database")["version"], state("database")),
("", "", ""), # spacer
# Platform/Python
(_('Platform'), val('platform')['name'], state('platform')),
(_('Platform UUID'), val('platform')['uuid'], state('platform')),
(_('Lang'), val('locale'), state('locale')),
(_('Python version'), val('python')['version'], state('python')),
(_('Python path'), val('python')['executable'], state('python')),
('', '', ''), # spacer
(_("Platform"), val("platform")["name"], state("platform")),
(_("Platform UUID"), val("platform")["uuid"], state("platform")),
(_("Lang"), val("locale"), state("locale")),
(_("Python version"), val("python")["version"], state("python")),
(_("Python path"), val("python")["executable"], state("python")),
("", "", ""), # spacer
# Systems stats
(_('CPU'), val('cpu')['text'], state('cpu')),
(_('Load'), val('load')['text'], state('load')),
(_('Memory'), val('memory')['text'], state('memory')),
(_('Uptime'), val('uptime')['text'], state('uptime')),
('', '', ''), # spacer
(_("CPU"), val("cpu")["text"], state("cpu")),
(_("Load"), val("load")["text"], state("load")),
(_("Memory"), val("memory")["text"], state("memory")),
(_("Uptime"), val("uptime")["text"], state("uptime")),
("", "", ""), # spacer
# ulimit
(_('Ulimit'), val('ulimit')['text'], state('ulimit')),
(_("Ulimit"), val("ulimit")["text"], state("ulimit")),
# Repo storage
(_('Storage location'), val('storage')['path'], state('storage')),
(_('Storage info'), val('storage')['text'], state('storage')),
(_('Storage inodes'), val('storage_inodes')['text'], state('storage_inodes')),
('', '', ''), # spacer
(_('Gist storage location'), val('storage_gist')['path'], state('storage_gist')),
(_('Gist storage info'), val('storage_gist')['text'], state('storage_gist')),
('', '', ''), # spacer
(_('Artifacts storage backend'), val('storage_artifacts')['type'], state('storage_artifacts')),
(_('Artifacts storage location'), val('storage_artifacts')['path'], state('storage_artifacts')),
(_('Artifacts info'), val('storage_artifacts')['text'], state('storage_artifacts')),
('', '', ''), # spacer
(_('Archive cache storage backend'), val('storage_archive')['type'], state('storage_archive')),
(_('Archive cache storage location'), val('storage_archive')['path'], state('storage_archive')),
(_('Archive cache info'), val('storage_archive')['text'], state('storage_archive')),
('', '', ''), # spacer
(_('Temp storage location'), val('storage_temp')['path'], state('storage_temp')),
(_('Temp storage info'), val('storage_temp')['text'], state('storage_temp')),
('', '', ''), # spacer
(_('Search info'), val('search')['text'], state('search')),
(_('Search location'), val('search')['location'], state('search')),
('', '', ''), # spacer
(_("Storage location"), val("storage")["path"], state("storage")),
(_("Storage info"), val("storage")["text"], state("storage")),
(_("Storage inodes"), val("storage_inodes")["text"], state("storage_inodes")),
("", "", ""), # spacer
(_("Gist storage location"), val("storage_gist")["path"], state("storage_gist")),
(_("Gist storage info"), val("storage_gist")["text"], state("storage_gist")),
("", "", ""), # spacer
(_("Artifacts storage backend"), val("storage_artifacts")["type"], state("storage_artifacts")),
(_("Artifacts storage location"), val("storage_artifacts")["path"], state("storage_artifacts")),
(_("Artifacts info"), val("storage_artifacts")["text"], state("storage_artifacts")),
("", "", ""), # spacer
(_("Archive cache storage backend"), val("storage_archive")["type"], state("storage_archive")),
(_("Archive cache storage location"), val("storage_archive")["path"], state("storage_archive")),
(_("Archive cache info"), val("storage_archive")["text"], state("storage_archive")),
("", "", ""), # spacer
(_("Temp storage location"), val("storage_temp")["path"], state("storage_temp")),
(_("Temp storage info"), val("storage_temp")["text"], state("storage_temp")),
("", "", ""), # spacer
(_("Search info"), val("search")["text"], state("search")),
(_("Search location"), val("search")["location"], state("search")),
("", "", ""), # spacer
# VCS specific
(_('VCS Backends'), val('vcs_backends'), state('vcs_backends')),
(_('VCS Server'), val('vcs_server')['text'], state('vcs_server')),
(_('GIT'), val('git'), state('git')),
(_('HG'), val('hg'), state('hg')),
(_('SVN'), val('svn'), state('svn')),
(_("VCS Backends"), val("vcs_backends"), state("vcs_backends")),
(_("VCS Server"), val("vcs_server")["text"], state("vcs_server")),
(_("GIT"), val("git"), state("git")),
(_("HG"), val("hg"), state("hg")),
(_("SVN"), val("svn"), state("svn")),
]
c.rhodecode_data_items = [
(k, v) for k, v in sorted((val('rhodecode_server_config') or {}).items(), key=lambda x: x[0].lower())
(k, v) for k, v in sorted((val("rhodecode_server_config") or {}).items(), key=lambda x: x[0].lower())
]
c.vcsserver_data_items = [
(k, v) for k, v in sorted((val('vcs_server_config') or {}).items(), key=lambda x: x[0].lower())
(k, v) for k, v in sorted((val("vcs_server_config") or {}).items(), key=lambda x: x[0].lower())
]
if snapshot:
if c.allowed_to_snapshot:
c.data_items.pop(0) # remove server info
self.request.override_renderer = 'admin/settings/settings_system_snapshot.mako'
self.request.override_renderer = "admin/settings/settings_system_snapshot.mako"
else:
h.flash('You are not allowed to do this', category='warning')
h.flash("You are not allowed to do this", category="warning")
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAllDecorator('hg.admin')
@HasPermissionAllDecorator("hg.admin")
def settings_system_info_check_update(self):
_ = self.request.translate
c = self.load_default_context()
@ -228,24 +221,24 @@ class AdminSystemInfoSettingsView(BaseAppView):
data = UpdateModel().get_update_data(update_url)
except urllib.error.URLError as e:
log.exception("Exception contacting upgrade server")
self.request.override_renderer = 'string'
return _err('Failed to contact upgrade server: %r' % e)
self.request.override_renderer = "string"
return _err("Failed to contact upgrade server: %r" % e)
except ValueError as e:
log.exception("Bad data sent from update server")
self.request.override_renderer = 'string'
return _err('Bad data sent from update server')
self.request.override_renderer = "string"
return _err("Bad data sent from update server")
latest = data['versions'][0]
latest = data["versions"][0]
c.update_url = update_url
c.latest_data = latest
c.latest_ver = (latest['version'] or '').strip()
c.cur_ver = self.request.GET.get('ver') or rhodecode.__version__
c.latest_ver = (latest["version"] or "").strip()
c.cur_ver = self.request.GET.get("ver") or rhodecode.__version__
c.should_upgrade = False
is_outdated = UpdateModel().is_outdated(c.cur_ver, c.latest_ver)
if is_outdated:
c.should_upgrade = True
c.important_notices = latest['general']
UpdateModel().store_version(latest['version'])
c.important_notices = latest["general"]
UpdateModel().store_version(latest["version"])
return self._get_template_context(c)

179
rhodecode/apps/admin/views/user_groups.py
View file

@ -28,15 +28,13 @@ from pyramid.renderers import render
from rhodecode import events
from rhodecode.apps._base import BaseAppView, DataGridAppView
from rhodecode.lib.auth import (
LoginRequired, NotAnonymous, CSRFRequired, HasPermissionAnyDecorator)
from rhodecode.lib.auth import LoginRequired, NotAnonymous, CSRFRequired, HasPermissionAnyDecorator
from rhodecode.lib import helpers as h, audit_logger
from rhodecode.lib.str_utils import safe_str
from rhodecode.model.forms import UserGroupForm
from rhodecode.model.permission import PermissionModel
from rhodecode.model.db import (
or_, count, User, UserGroup, UserGroupMember, in_filter_generator)
from rhodecode.model.db import or_, count, User, UserGroup, UserGroupMember, in_filter_generator
from rhodecode.model.meta import Session
from rhodecode.model.user_group import UserGroupModel
from rhodecode.model.db import true
@ -45,11 +43,9 @@ log = logging.getLogger(__name__)
class AdminUserGroupsView(BaseAppView, DataGridAppView):
def load_default_context(self):
c = self._get_local_tmpl_context()
PermissionModel().set_global_permission_choices(
c, gettext_translator=self.request.translate)
PermissionModel().set_global_permission_choices(c, gettext_translator=self.request.translate)
return c
# permission check in data loading of
@ -66,18 +62,16 @@ class AdminUserGroupsView(BaseAppView, DataGridAppView):
def user_groups_list_data(self):
self.load_default_context()
column_map = {
'active': 'users_group_active',
'description': 'user_group_description',
'members': 'members_total',
'owner': 'user_username',
'sync': 'group_data'
"active": "users_group_active",
"description": "user_group_description",
"members": "members_total",
"owner": "user_username",
"sync": "group_data",
}
draw, start, limit = self._extract_chunk(self.request)
search_q, order_by, order_dir = self._extract_ordering(
self.request, column_map=column_map)
search_q, order_by, order_dir = self._extract_ordering(self.request, column_map=column_map)
_render = self.request.get_partial_renderer(
'rhodecode:templates/data_table/_dt_elements.mako')
_render = self.request.get_partial_renderer("rhodecode:templates/data_table/_dt_elements.mako")
def user_group_name(user_group_name):
return _render("user_group_name", user_group_name)
@ -86,66 +80,81 @@ class AdminUserGroupsView(BaseAppView, DataGridAppView):
return _render("user_group_actions", user_group_id, user_group_name)
def user_profile(username):
return _render('user_profile', username)
return _render("user_profile", username)
_perms = ['usergroup.admin']
_perms = ["usergroup.admin"]
allowed_ids = [-1] + self._rhodecode_user.user_group_acl_ids_from_stack(_perms)
user_groups_data_total_count = UserGroup.query()\
.filter(or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(UserGroup.users_group_id, allowed_ids)
))\
user_groups_data_total_count = (
UserGroup.query()
.filter(
or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(UserGroup.users_group_id, allowed_ids)
)
)
.count()
)
user_groups_data_total_inactive_count = UserGroup.query()\
.filter(or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(UserGroup.users_group_id, allowed_ids)
))\
.filter(UserGroup.users_group_active != true()).count()
user_groups_data_total_inactive_count = (
UserGroup.query()
.filter(
or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(UserGroup.users_group_id, allowed_ids)
)
)
.filter(UserGroup.users_group_active != true())
.count()
)
member_count = count(UserGroupMember.user_id)
base_q = Session.query(
UserGroup.users_group_name,
UserGroup.user_group_description,
UserGroup.users_group_active,
UserGroup.users_group_id,
UserGroup.group_data,
User,
member_count.label('member_count')
) \
.filter(or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(UserGroup.users_group_id, allowed_ids)
)) \
.outerjoin(UserGroupMember, UserGroupMember.users_group_id == UserGroup.users_group_id) \
.join(User, User.user_id == UserGroup.user_id) \
base_q = (
Session.query(
UserGroup.users_group_name,
UserGroup.user_group_description,
UserGroup.users_group_active,
UserGroup.users_group_id,
UserGroup.group_data,
User,
member_count.label("member_count"),
)
.filter(
or_(
# generate multiple IN to fix limitation problems
*in_filter_generator(UserGroup.users_group_id, allowed_ids)
)
)
.outerjoin(UserGroupMember, UserGroupMember.users_group_id == UserGroup.users_group_id)
.join(User, User.user_id == UserGroup.user_id)
.group_by(UserGroup, User)
)
base_q_inactive = base_q.filter(UserGroup.users_group_active != true())
if search_q:
like_expression = u'%{}%'.format(safe_str(search_q))
base_q = base_q.filter(or_(
UserGroup.users_group_name.ilike(like_expression),
))
like_expression = "%{}%".format(safe_str(search_q))
base_q = base_q.filter(
or_(
UserGroup.users_group_name.ilike(like_expression),
)
)
base_q_inactive = base_q.filter(UserGroup.users_group_active != true())
user_groups_data_total_filtered_count = base_q.count()
user_groups_data_total_filtered_inactive_count = base_q_inactive.count()
sort_defined = False
if order_by == 'members_total':
if order_by == "members_total":
sort_col = member_count
sort_defined = True
elif order_by == 'user_username':
elif order_by == "user_username":
sort_col = User.username
else:
sort_col = getattr(UserGroup, order_by, None)
if sort_defined or sort_col:
if order_dir == 'asc':
if order_dir == "asc":
sort_col = sort_col.asc()
else:
sort_col = sort_col.desc()
@ -164,87 +173,81 @@ class AdminUserGroupsView(BaseAppView, DataGridAppView):
"members": user_gr.member_count,
# NOTE(marcink): because of advanced query we
# need to load it like that
"sync": UserGroup._load_sync(
UserGroup._load_group_data(user_gr.group_data)),
"sync": UserGroup._load_sync(UserGroup._load_group_data(user_gr.group_data)),
"active": h.bool2icon(user_gr.users_group_active),
"owner": user_profile(user_gr.User.username),
"action": user_group_actions(
user_gr.users_group_id, user_gr.users_group_name)
"action": user_group_actions(user_gr.users_group_id, user_gr.users_group_name),
}
user_groups_data.append(row)
data = ({
'draw': draw,
'data': user_groups_data,
'recordsTotal': user_groups_data_total_count,
'recordsTotalInactive': user_groups_data_total_inactive_count,
'recordsFiltered': user_groups_data_total_filtered_count,
'recordsFilteredInactive': user_groups_data_total_filtered_inactive_count,
})
data = {
"draw": draw,
"data": user_groups_data,
"recordsTotal": user_groups_data_total_count,
"recordsTotalInactive": user_groups_data_total_inactive_count,
"recordsFiltered": user_groups_data_total_filtered_count,
"recordsFilteredInactive": user_groups_data_total_filtered_inactive_count,
}
return data
@LoginRequired()
@HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')
@HasPermissionAnyDecorator("hg.admin", "hg.usergroup.create.true")
def user_groups_new(self):
c = self.load_default_context()
return self._get_template_context(c)
@LoginRequired()
@HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')
@HasPermissionAnyDecorator("hg.admin", "hg.usergroup.create.true")
@CSRFRequired()
def user_groups_create(self):
_ = self.request.translate
c = self.load_default_context()
users_group_form = UserGroupForm(self.request.translate)()
user_group_name = self.request.POST.get('users_group_name')
user_group_name = self.request.POST.get("users_group_name")
try:
form_result = users_group_form.to_python(dict(self.request.POST))
user_group = UserGroupModel().create(
name=form_result['users_group_name'],
description=form_result['user_group_description'],
name=form_result["users_group_name"],
description=form_result["user_group_description"],
owner=self._rhodecode_user.user_id,
active=form_result['users_group_active'])
active=form_result["users_group_active"],
)
Session().flush()
creation_data = user_group.get_api_data()
user_group_name = form_result['users_group_name']
user_group_name = form_result["users_group_name"]
audit_logger.store_web(
'user_group.create', action_data={'data': creation_data},
user=self._rhodecode_user)
audit_logger.store_web("user_group.create", action_data={"data": creation_data}, user=self._rhodecode_user)
user_group_link = h.link_to(
h.escape(user_group_name),
h.route_path(
'edit_user_group', user_group_id=user_group.users_group_id))
h.flash(h.literal(_('Created user group %(user_group_link)s')
% {'user_group_link': user_group_link}),
category='success')
h.escape(user_group_name), h.route_path("edit_user_group", user_group_id=user_group.users_group_id)
)
h.flash(
h.literal(_("Created user group %(user_group_link)s") % {"user_group_link": user_group_link}),
category="success",
)
Session().commit()
user_group_id = user_group.users_group_id
except formencode.Invalid as errors:
data = render(
'rhodecode:templates/admin/user_groups/user_group_add.mako',
self._get_template_context(c), self.request)
"rhodecode:templates/admin/user_groups/user_group_add.mako", self._get_template_context(c), self.request
)
html = formencode.htmlfill.render(
data,
defaults=errors.value,
errors=errors.unpack_errors() or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False
force_defaults=False,
)
return Response(html)
except Exception:
log.exception("Exception creating user group")
h.flash(_('Error occurred during creation of user group %s') \
% user_group_name, category='error')
raise HTTPFound(h.route_path('user_groups_new'))
h.flash(_("Error occurred during creation of user group %s") % user_group_name, category="error")
raise HTTPFound(h.route_path("user_groups_new"))
PermissionModel().trigger_permission_flush()
raise HTTPFound(
h.route_path('edit_user_group', user_group_id=user_group_id))
raise HTTPFound(h.route_path("edit_user_group", user_group_id=user_group_id))

875
rhodecode/apps/admin/views/users.py
View file

File diff suppressed because it is too large Load diff