def my_account_password(self):
c.active = 'password'
self.__load_data()
managed_fields = auth_modules.get_managed_fields(c.user)
c.can_change_password = '******' not in managed_fields
if request.POST and c.can_change_password:
_form = PasswordChangeForm(request.authuser.username)()
try:
form_result = _form.to_python(request.POST)
UserModel().update(request.authuser.user_id, form_result)
Session().commit()
h.flash(_("Successfully updated password"), category='success')
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/my_account/my_account.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during update of user password'),
category='error')
return render('admin/my_account/my_account.html')
def index(self):
# Return a rendered template
p = safe_int(request.GET.get('page'), 1)
c.user = User.get(request.authuser.user_id)
c.following = UserFollowing.query() \
.filter(UserFollowing.user_id == request.authuser.user_id) \
.options(joinedload(UserFollowing.follows_repository)) \
.all()
journal = self._get_journal_data(c.following)
def url_generator(**kw):
return url.current(filter=c.search_term, **kw)
c.journal_pager = Page(journal, page=p, items_per_page=20, url=url_generator)
c.journal_day_aggregate = self._get_daily_aggregate(c.journal_pager)
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return render('journal/journal_data.html')
repos_list = Repository.query(sorted=True) \
.filter_by(owner_id=request.authuser.user_id).all()
repos_data = RepoModel().get_repos_as_dict(repos_list=repos_list,
admin=True)
#data used to render the grid
c.data = repos_data
return render('journal/journal.html')
def my_account_password(self):
c.active = 'password'
self.__load_data()
managed_fields = auth_modules.get_managed_fields(c.user)
c.can_change_password = '******' not in managed_fields
if request.POST and c.can_change_password:
_form = PasswordChangeForm(self.authuser.username)()
try:
form_result = _form.to_python(request.POST)
UserModel().update(self.authuser.user_id, form_result)
Session().commit()
h.flash(_("Successfully updated password"), category='success')
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/my_account/my_account.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during update of user password'),
category='error')
return render('admin/my_account/my_account.html')
def index(self):
users_log = UserLog.query() \
.options(joinedload(UserLog.user)) \
.options(joinedload(UserLog.repository))
#FILTERING
c.search_term = request.GET.get('filter')
users_log = _journal_filter(users_log, c.search_term)
users_log = users_log.order_by(UserLog.action_date.desc())
p = safe_int(request.GET.get('page'), 1)
def url_generator(**kw):
return url.current(filter=c.search_term, **kw)
c.users_log = Page(users_log,
page=p,
items_per_page=10,
url=url_generator)
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return render('admin/admin_log.html')
return render('admin/admin.html')
def my_account(self):
"""
GET /_admin/my_account Displays info about my account
"""
# url('my_account')
c.active = 'profile'
self.__load_data()
c.perm_user = AuthUser(user_id=self.authuser.user_id)
c.ip_addr = self.ip_addr
managed_fields = auth_modules.get_managed_fields(c.user)
def_user_perms = User.get_default_user().AuthUser.permissions['global']
if 'hg.register.none' in def_user_perms:
managed_fields.extend(['username', 'firstname', 'lastname', 'email'])
c.readonly = lambda n: 'readonly' if n in managed_fields else None
defaults = c.user.get_dict()
update = False
if request.POST:
_form = UserForm(edit=True,
old_data={'user_id': self.authuser.user_id,
'email': self.authuser.email})()
form_result = {}
try:
post_data = dict(request.POST)
post_data['new_password'] = ''
post_data['password_confirmation'] = ''
form_result = _form.to_python(post_data)
# skip updating those attrs for my account
skip_attrs = ['admin', 'active', 'extern_type', 'extern_name',
'new_password', 'password_confirmation',
] + managed_fields
UserModel().update(self.authuser.user_id, form_result,
skip_attrs=skip_attrs)
h.flash(_('Your account was updated successfully'),
category='success')
Session().commit()
update = True
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/my_account/my_account.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during update of user %s') \
% form_result.get('username'), category='error')
if update:
raise HTTPFound(location='my_account')
return htmlfill.render(
render('admin/my_account/my_account.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def settings_global(self):
"""GET /admin/settings/global: All items in the collection"""
# url('admin_settings_global')
c.active = 'global'
if request.POST:
application_form = ApplicationSettingsForm()()
try:
form_result = application_form.to_python(dict(request.POST))
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/settings/settings.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
try:
sett1 = Setting.create_or_update('title',
form_result['title'])
Session().add(sett1)
sett2 = Setting.create_or_update('realm',
form_result['realm'])
Session().add(sett2)
sett3 = Setting.create_or_update('ga_code',
form_result['ga_code'])
Session().add(sett3)
sett4 = Setting.create_or_update('captcha_public_key',
form_result['captcha_public_key'])
Session().add(sett4)
sett5 = Setting.create_or_update('captcha_private_key',
form_result['captcha_private_key'])
Session().add(sett5)
Session().commit()
set_app_settings(config)
h.flash(_('Updated application settings'), category='success')
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred while updating '
'application settings'),
category='error')
raise HTTPFound(location=url('admin_settings_global'))
defaults = Setting.get_app_settings()
defaults.update(self._get_hg_ui_settings())
return htmlfill.render(
render('admin/settings/settings.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def settings_visual(self):
"""GET /admin/settings/visual: All items in the collection"""
# url('admin_settings_visual')
c.active = 'visual'
if request.POST:
application_form = ApplicationVisualisationForm()()
try:
form_result = application_form.to_python(dict(request.POST))
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/settings/settings.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
try:
settings = [
('show_public_icon', 'show_public_icon', 'bool'),
('show_private_icon', 'show_private_icon', 'bool'),
('stylify_metatags', 'stylify_metatags', 'bool'),
('repository_fields', 'repository_fields', 'bool'),
('dashboard_items', 'dashboard_items', 'int'),
('admin_grid_items', 'admin_grid_items', 'int'),
('show_version', 'show_version', 'bool'),
('use_gravatar', 'use_gravatar', 'bool'),
('gravatar_url', 'gravatar_url', 'unicode'),
('clone_uri_tmpl', 'clone_uri_tmpl', 'unicode'),
]
for setting, form_key, type_ in settings:
sett = Setting.create_or_update(setting,
form_result[form_key], type_)
Session().add(sett)
Session().commit()
set_app_settings(config)
h.flash(_('Updated visualisation settings'),
category='success')
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during updating '
'visualisation settings'),
category='error')
raise HTTPFound(location=url('admin_settings_visual'))
defaults = Setting.get_app_settings()
defaults.update(self._get_hg_ui_settings())
return htmlfill.render(
render('admin/settings/settings.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def followers(self, repo_name):
p = safe_int(request.GET.get('page', 1), 1)
repo_id = c.db_repo.repo_id
d = UserFollowing.get_repo_followers(repo_id)\
.order_by(UserFollowing.follows_from)
c.followers_pager = Page(d, page=p, items_per_page=20)
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return render('/followers/followers_data.html')
return render('/followers/followers.html')
def my_account(self):
c.active = 'profile'
self.__load_data()
c.perm_user = AuthUser(user_id=request.authuser.user_id)
managed_fields = auth_modules.get_managed_fields(c.user)
def_user_perms = User.get_default_user().AuthUser.permissions['global']
if 'hg.register.none' in def_user_perms:
managed_fields.extend(['username', 'firstname', 'lastname', 'email'])
c.readonly = lambda n: 'readonly' if n in managed_fields else None
defaults = c.user.get_dict()
update = False
if request.POST:
_form = UserForm(edit=True,
old_data={'user_id': request.authuser.user_id,
'email': request.authuser.email})()
form_result = {}
try:
post_data = dict(request.POST)
post_data['new_password'] = ''
post_data['password_confirmation'] = ''
form_result = _form.to_python(post_data)
# skip updating those attrs for my account
skip_attrs = ['admin', 'active', 'extern_type', 'extern_name',
'new_password', 'password_confirmation',
] + managed_fields
UserModel().update(request.authuser.user_id, form_result,
skip_attrs=skip_attrs)
h.flash(_('Your account was updated successfully'),
category='success')
Session().commit()
update = True
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/my_account/my_account.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during update of user %s') \
% form_result.get('username'), category='error')
if update:
raise HTTPFound(location='my_account')
return htmlfill.render(
render('admin/my_account/my_account.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def followers(self, repo_name):
p = safe_int(request.GET.get('page', 1), 1)
repo_id = c.db_repo.repo_id
d = UserFollowing.get_repo_followers(repo_id)\
.order_by(UserFollowing.follows_from)
c.followers_pager = Page(d, page=p, items_per_page=20)
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return render('/followers/followers_data.html')
return render('/followers/followers.html')
def settings_visual(self):
c.active = 'visual'
if request.POST:
application_form = ApplicationVisualisationForm()()
try:
form_result = application_form.to_python(dict(request.POST))
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/settings/settings.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
try:
settings = [
('show_public_icon', 'show_public_icon', 'bool'),
('show_private_icon', 'show_private_icon', 'bool'),
('stylify_metalabels', 'stylify_metalabels', 'bool'),
('repository_fields', 'repository_fields', 'bool'),
('dashboard_items', 'dashboard_items', 'int'),
('admin_grid_items', 'admin_grid_items', 'int'),
('show_version', 'show_version', 'bool'),
('use_gravatar', 'use_gravatar', 'bool'),
('gravatar_url', 'gravatar_url', 'unicode'),
('clone_uri_tmpl', 'clone_uri_tmpl', 'unicode'),
('clone_ssh_tmpl', 'clone_ssh_tmpl', 'unicode'),
]
for setting, form_key, type_ in settings:
Setting.create_or_update(setting, form_result[form_key], type_)
Session().commit()
set_app_settings(config)
h.flash(_('Updated visualisation settings'),
category='success')
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during updating '
'visualisation settings'),
category='error')
raise HTTPFound(location=url('admin_settings_visual'))
defaults = Setting.get_app_settings()
defaults.update(self._get_hg_ui_settings())
return htmlfill.render(
render('admin/settings/settings.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def register(self):
def_user_perms = AuthUser(
dbuser=User.get_default_user()).permissions['global']
c.auto_active = 'hg.register.auto_activate' in def_user_perms
settings = Setting.get_app_settings()
captcha_private_key = settings.get('captcha_private_key')
c.captcha_active = bool(captcha_private_key)
c.captcha_public_key = settings.get('captcha_public_key')
if request.POST:
register_form = RegisterForm()()
try:
form_result = register_form.to_python(dict(request.POST))
form_result['active'] = c.auto_active
if c.captcha_active:
from kallithea.lib.recaptcha import submit
response = submit(request.POST.get('g-recaptcha-response'),
private_key=captcha_private_key,
remoteip=request.ip_addr)
if not response.is_valid:
_value = form_result
_msg = _('Bad captcha')
error_dict = {'recaptcha_field': _msg}
raise formencode.Invalid(_msg,
_value,
None,
error_dict=error_dict)
UserModel().create_registration(form_result)
h.flash(_('You have successfully registered with %s') %
(c.site_name or 'Kallithea'),
category='success')
Session().commit()
raise HTTPFound(location=url('login_home'))
except formencode.Invalid as errors:
return htmlfill.render(render('/register.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except UserCreationError as e:
# container auth or other auth functions that create users on
# the fly can throw this exception signaling that there's issue
# with user creation, explanation should be provided in
# Exception itself
h.flash(e, 'error')
return render('/register.html')
def show_all(self, repo_name):
c.from_ = request.GET.get('from_') or ''
c.closed = request.GET.get('closed') or ''
c.pull_requests = PullRequestModel().get_all(repo_name, from_=c.from_, closed=c.closed)
c.repo_name = repo_name
p = safe_int(request.GET.get('page', 1), 1)
c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=10)
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return render('/pullrequests/pullrequest_data.html')
return render('/pullrequests/pullrequest_show_all.html')
def index(self):
c.came_from = request.GET.get('came_from', '')
if c.came_from:
if not self._validate_came_from(c.came_from):
log.error('Invalid came_from (not server-relative): %r',
c.came_from)
raise HTTPBadRequest()
else:
c.came_from = url('home')
if request.POST:
# import Login Form validator class
login_form = LoginForm()()
try:
# login_form will check username/password using ValidAuth and report failure to the user
c.form_result = login_form.to_python(dict(request.POST))
username = c.form_result['username']
user = User.get_by_username_or_email(username)
assert user is not None # the same user get just passed in the form validation
except formencode.Invalid as errors:
defaults = errors.value
# remove password from filling in form again
defaults.pop('password', None)
return htmlfill.render(render('/login.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except UserCreationError as e:
# container auth or other auth functions that create users on
# the fly can throw this exception signaling that there's issue
# with user creation, explanation should be provided in
# Exception itself
h.flash(e, 'error')
else:
# login_form already validated the password - now set the session cookie accordingly
auth_user = log_in_user(user,
c.form_result['remember'],
is_external_auth=False,
ip_addr=request.ip_addr)
if auth_user:
raise HTTPFound(location=c.came_from)
h.flash(_('Authentication failed.'), 'error')
else:
# redirect if already logged in
if not request.authuser.is_anonymous:
raise HTTPFound(location=c.came_from)
# continue to show login to default user
return render('/login.html')
def register(self):
c.auto_active = 'hg.register.auto_activate' in User.get_default_user() \
.AuthUser.permissions['global']
settings = Setting.get_app_settings()
captcha_private_key = settings.get('captcha_private_key')
c.captcha_active = bool(captcha_private_key)
c.captcha_public_key = settings.get('captcha_public_key')
if request.POST:
register_form = RegisterForm()()
try:
form_result = register_form.to_python(dict(request.POST))
form_result['active'] = c.auto_active
if c.captcha_active:
from kallithea.lib.recaptcha import submit
response = submit(request.POST.get('recaptcha_challenge_field'),
request.POST.get('recaptcha_response_field'),
private_key=captcha_private_key,
remoteip=self.ip_addr)
if c.captcha_active and not response.is_valid:
_value = form_result
_msg = _('Bad captcha')
error_dict = {'recaptcha_field': _msg}
raise formencode.Invalid(_msg, _value, None,
error_dict=error_dict)
UserModel().create_registration(form_result)
h.flash(_('You have successfully registered into Kallithea'),
category='success')
Session().commit()
raise HTTPFound(location=url('login_home'))
except formencode.Invalid as errors:
return htmlfill.render(
render('/register.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except UserCreationError as e:
# container auth or other auth functions that create users on
# the fly can throw this exception signaling that there's issue
# with user creation, explanation should be provided in
# Exception itself
h.flash(e, 'error')
return render('/register.html')
def forks(self, repo_name):
p = safe_int(request.GET.get('page'), 1)
repo_id = c.db_repo.repo_id
d = []
for r in Repository.get_repo_forks(repo_id):
if not HasRepoPermissionLevel('read')(r.repo_name, 'get forks check'):
continue
d.append(r)
c.forks_pager = Page(d, page=p, items_per_page=20)
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return render('/forks/forks_data.html')
return render('/forks/forks.html')
def show_all(self, repo_name):
c.from_ = request.GET.get('from_') or ''
c.closed = request.GET.get('closed') or ''
c.pull_requests = PullRequestModel().get_all(repo_name,
from_=c.from_,
closed=c.closed)
c.repo_name = repo_name
p = safe_int(request.GET.get('page', 1), 1)
c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=10)
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return render('/pullrequests/pullrequest_data.html')
return render('/pullrequests/pullrequest_show_all.html')
def forks(self, repo_name):
p = safe_int(request.GET.get('page'), 1)
repo_id = c.db_repo.repo_id
d = []
for r in Repository.get_repo_forks(repo_id):
if not HasRepoPermissionLevel('read')(r.repo_name,
'get forks check'):
continue
d.append(r)
c.forks_pager = Page(d, page=p, items_per_page=20)
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return render('/forks/forks_data.html')
return render('/forks/forks.html')
def __render(self, defaults, errors):
c.defaults = {}
c.plugin_settings = {}
c.plugin_shortnames = {}
for plugin in self.enabled_plugins:
module = plugin.__class__.__module__
c.plugin_shortnames[module] = plugin.name
c.plugin_settings[module] = plugin.plugin_settings()
for v in c.plugin_settings[module]:
fullname = "auth_%s_%s" % (plugin.name, v["name"])
if "default" in v:
c.defaults[fullname] = v["default"]
# Current values will be the default on the form, if there are any
setting = Setting.get_by_name(fullname)
if setting is not None:
c.defaults[fullname] = setting.app_settings_value
# we want to show , separated list of enabled plugins
c.defaults['auth_plugins'] = ','.join(c.enabled_plugin_names)
if defaults:
c.defaults.update(defaults)
log.debug(formatted_json(defaults))
return formencode.htmlfill.render(
render('admin/auth/auth_settings.html'),
defaults=c.defaults,
errors=errors,
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
def edit_repo_group_advanced(self, group_name):
"""GET /repo_groups/group_name/edit: Form to edit an existing item"""
# url('edit_repo_group', group_name=GROUP_NAME)
c.active = 'advanced'
c.repo_group = RepoGroupModel()._get_repo_group(group_name)
return render('admin/repo_groups/repo_group_edit.html')
def permission_ips(self):
c.active = 'ips'
c.user = User.get_default_user()
c.user_ip_map = UserIpMap.query() \
.filter(UserIpMap.user == c.user).all()
return render('admin/permissions/permissions.html')
def update(self, id):
_form = DefaultsForm()()
try:
form_result = _form.to_python(dict(request.POST))
for k, v in form_result.items():
setting = Setting.create_or_update(k, v)
Session().commit()
h.flash(_('Default settings updated successfully'),
category='success')
except formencode.Invalid as errors:
defaults = errors.value
return htmlfill.render(
render('admin/defaults/defaults.html'),
defaults=defaults,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during update of defaults'),
category='error')
raise HTTPFound(location=url('defaults'))
def edit_advanced(self, repo_name):
c.repo_info = self._load_repo()
c.default_user_id = User.get_default_user().user_id
c.in_public_journal = UserFollowing.query() \
.filter(UserFollowing.user_id == c.default_user_id) \
.filter(UserFollowing.follows_repository == c.repo_info).scalar()
_repos = Repository.query(sorted=True).all()
read_access_repos = RepoList(_repos, perm_level='read')
c.repos_list = [(None, _('-- Not a fork --'))]
c.repos_list += [(x.repo_id, x.repo_name)
for x in read_access_repos
if x.repo_id != c.repo_info.repo_id]
defaults = {
'id_fork_of': c.repo_info.fork_id if c.repo_info.fork_id else ''
}
c.active = 'advanced'
if request.POST:
raise HTTPFound(location=url('repo_edit_advanced'))
return htmlfill.render(
render('admin/repos/repo_edit.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def __render(self, defaults, errors):
c.defaults = {}
c.plugin_settings = {}
c.plugin_shortnames = {}
for plugin in self.enabled_plugins:
module = plugin.__class__.__module__
c.plugin_shortnames[module] = plugin.name
c.plugin_settings[module] = plugin.plugin_settings()
for v in c.plugin_settings[module]:
fullname = "auth_%s_%s" % (plugin.name, v["name"])
if "default" in v:
c.defaults[fullname] = v["default"]
# Current values will be the default on the form, if there are any
setting = Setting.get_by_name(fullname)
if setting is not None:
c.defaults[fullname] = setting.app_settings_value
# we want to show , separated list of enabled plugins
c.defaults['auth_plugins'] = ','.join(c.enabled_plugin_names)
if defaults:
c.defaults.update(defaults)
log.debug(formatted_json(defaults))
return formencode.htmlfill.render(
render('admin/auth/auth_settings.html'),
defaults=c.defaults,
errors=errors,
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
def create(self):
self.__load_defaults()
try:
# CanWriteGroup validators checks permissions of this POST
form_result = RepoForm(repo_groups=c.repo_groups,
landing_revs=c.landing_revs_choices)() \
.to_python(dict(request.POST))
except formencode.Invalid as errors:
log.info(errors)
return htmlfill.render(render('admin/repos/repo_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
force_defaults=False,
encoding="UTF-8")
try:
# create is done sometimes async on celery, db transaction
# management is handled there.
task = RepoModel().create(form_result, request.authuser.user_id)
task_id = task.task_id
except Exception:
log.error(traceback.format_exc())
msg = (_('Error creating repository %s') %
form_result.get('repo_name'))
h.flash(msg, category='error')
raise HTTPFound(location=url('home'))
raise HTTPFound(location=h.url('repo_creating_home',
repo_name=form_result['repo_name_full'],
task_id=task_id))
def password_reset(self):
settings = Setting.get_app_settings()
captcha_private_key = settings.get('captcha_private_key')
c.captcha_active = bool(captcha_private_key)
c.captcha_public_key = settings.get('captcha_public_key')
if request.POST:
password_reset_form = PasswordResetForm()()
try:
form_result = password_reset_form.to_python(dict(request.POST))
if c.captcha_active:
from kallithea.lib.recaptcha import submit
response = submit(request.POST.get('recaptcha_challenge_field'),
request.POST.get('recaptcha_response_field'),
private_key=captcha_private_key,
remoteip=self.ip_addr)
if c.captcha_active and not response.is_valid:
_value = form_result
_msg = _('bad captcha')
error_dict = {'recaptcha_field': _msg}
raise formencode.Invalid(_msg, _value, None,
error_dict=error_dict)
UserModel().reset_password_link(form_result)
h.flash(_('Your password reset link was sent'),
category='success')
return redirect(url('login_home'))
except formencode.Invalid, errors:
return htmlfill.render(
render('/password_reset.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
def my_account_repos(self):
c.active = 'repos'
self.__load_data()
#json used to render the grid
c.data = self._load_my_repos_data()
return render('admin/my_account/my_account.html')
def edit_advanced(self, repo_name):
"""GET /repo_name/settings: Form to edit an existing item"""
# url('edit_repo', repo_name=ID)
c.repo_info = self._load_repo(repo_name)
c.default_user_id = User.get_default_user().user_id
c.in_public_journal = UserFollowing.query()\
.filter(UserFollowing.user_id == c.default_user_id)\
.filter(UserFollowing.follows_repository == c.repo_info).scalar()
_repos = Repository.query().order_by(Repository.repo_name).all()
read_access_repos = RepoList(_repos)
c.repos_list = [(None, _('-- Not a fork --'))]
c.repos_list += [(x.repo_id, x.repo_name) for x in read_access_repos
if x.repo_id != c.repo_info.repo_id]
defaults = {
'id_fork_of': c.repo_info.fork.repo_id if c.repo_info.fork else ''
}
c.active = 'advanced'
if request.POST:
return redirect(url('repo_edit_advanced'))
return htmlfill.render(render('admin/repos/repo_edit.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def create(self):
"""
POST /repos: Create a new item"""
# url('repos')
self.__load_defaults()
form_result = {}
task_id = None
try:
# CanWriteToGroup validators checks permissions of this POST
form_result = RepoForm(repo_groups=c.repo_groups_choices,
landing_revs=c.landing_revs_choices)()\
.to_python(dict(request.POST))
# create is done sometimes async on celery, db transaction
# management is handled there.
task = RepoModel().create(form_result, self.authuser.user_id)
from celery.result import BaseAsyncResult
if isinstance(task, BaseAsyncResult):
task_id = task.task_id
except formencode.Invalid, errors:
return htmlfill.render(render('admin/repos/repo_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
force_defaults=False,
encoding="UTF-8")
def create(self):
users_group_form = UserGroupForm()()
try:
form_result = users_group_form.to_python(dict(request.POST))
ug = UserGroupModel().create(
name=form_result['users_group_name'],
description=form_result['user_group_description'],
owner=request.authuser.user_id,
active=form_result['users_group_active'])
gr = form_result['users_group_name']
action_logger(request.authuser,
'admin_created_users_group:%s' % gr, None,
request.ip_addr)
h.flash(
h.HTML(_('Created user group %s')) %
h.link_to(gr, url('edit_users_group', id=ug.users_group_id)),
category='success')
Session().commit()
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/user_groups/user_group_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during creation of user group %s') %
request.POST.get('users_group_name'),
category='error')
raise HTTPFound(location=url('users_groups'))
def my_account_emails(self):
c.active = 'emails'
self.__load_data()
c.user_email_map = UserEmailMap.query()\
.filter(UserEmailMap.user == c.user).all()
return render('admin/my_account/my_account.html')
def edit_advanced(self, repo_name):
"""GET /repo_name/settings: Form to edit an existing item"""
# url('edit_repo', repo_name=ID)
c.repo_info = self._load_repo(repo_name)
c.default_user_id = User.get_default_user().user_id
c.in_public_journal = UserFollowing.query()\
.filter(UserFollowing.user_id == c.default_user_id)\
.filter(UserFollowing.follows_repository == c.repo_info).scalar()
_repos = Repository.query().order_by(Repository.repo_name).all()
read_access_repos = RepoList(_repos)
c.repos_list = [(None, _('-- Not a fork --'))]
c.repos_list += [(x.repo_id, x.repo_name)
for x in read_access_repos
if x.repo_id != c.repo_info.repo_id]
defaults = {
'id_fork_of': c.repo_info.fork.repo_id if c.repo_info.fork else ''
}
c.active = 'advanced'
if request.POST:
return redirect(url('repo_edit_advanced'))
return htmlfill.render(
render('admin/repos/repo_edit.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def index(self):
def _branchtags(localrepo):
bt_closed = {}
for bn, heads in localrepo.branchmap().iteritems():
tip = heads[-1]
if 'close' in localrepo.changelog.read(tip)[5]:
bt_closed[bn] = tip
return bt_closed
cs_g = c.db_repo_scm_instance.get_changeset
c.repo_closed_branches = {}
if c.db_repo.repo_type == 'hg':
bt_closed = _branchtags(c.db_repo_scm_instance._repo)
_closed_branches = [(safe_unicode(n), cs_g(binascii.hexlify(h)),)
for n, h in bt_closed.items()]
c.repo_closed_branches = OrderedDict(sorted(_closed_branches,
key=lambda ctx: ctx[0],
reverse=False))
_branches = [(safe_unicode(n), cs_g(h))
for n, h in c.db_repo_scm_instance.branches.items()]
c.repo_branches = OrderedDict(sorted(_branches,
key=lambda ctx: ctx[0],
reverse=False))
return render('branches/branches.html')
def permission_ips(self):
c.active = 'ips'
c.user = User.get_default_user()
c.user_ip_map = UserIpMap.query() \
.filter(UserIpMap.user == c.user).all()
return render('admin/permissions/permissions.html')
def edit_statistics(self, repo_name):
c.repo_info = self._load_repo()
repo = c.repo_info.scm_instance
if c.repo_info.stats:
# this is on what revision we ended up so we add +1 for count
last_rev = c.repo_info.stats.stat_on_revision + 1
else:
last_rev = 0
c.stats_revision = last_rev
c.repo_last_rev = repo.count() if repo.revisions else 0
if last_rev == 0 or c.repo_last_rev == 0:
c.stats_percentage = 0
else:
c.stats_percentage = '%.2f' % ((float(
(last_rev)) / c.repo_last_rev) * 100)
c.active = 'statistics'
if request.POST:
try:
RepoModel().delete_stats(repo_name)
Session().commit()
except Exception as e:
log.error(traceback.format_exc())
h.flash(
_('An error occurred during deletion of repository stats'),
category='error')
raise HTTPFound(
location=url('edit_repo_statistics', repo_name=c.repo_name))
return render('admin/repos/repo_edit.html')
def edit(self, gist_id, format='html'):
"""GET /admin/gists/gist_id/edit: Form to edit an existing item"""
# url('edit_gist', gist_id=ID)
c.gist = Gist.get_or_404(gist_id)
#check if this gist is not expired
if c.gist.gist_expires != -1:
if time.time() > c.gist.gist_expires:
log.error('Gist expired at %s',
time_to_datetime(c.gist.gist_expires))
raise HTTPNotFound()
try:
c.file_changeset, c.files = GistModel().get_gist_files(gist_id)
except VCSError:
log.error(traceback.format_exc())
raise HTTPNotFound()
self.__load_defaults(extra_values=('0', _('Unmodified')))
rendered = render('admin/gists/edit.html')
if request.POST:
rpost = request.POST
nodes = {}
for org_filename, filename, mimetype, content in zip(
rpost.getall('org_files'),
rpost.getall('files'),
rpost.getall('mimetypes'),
rpost.getall('contents')):
nodes[org_filename] = {
'org_filename': org_filename,
'filename': filename,
'content': content,
'lexer': mimetype,
}
try:
GistModel().update(
gist=c.gist,
description=rpost['description'],
owner=c.gist.owner,
gist_mapping=nodes,
gist_type=c.gist.gist_type,
lifetime=rpost['lifetime']
)
Session().commit()
h.flash(_('Successfully updated gist content'), category='success')
except NodeNotChangedError:
# raised if nothing was changed in repo itself. We anyway then
# store only DB stuff for gist
Session().commit()
h.flash(_('Successfully updated gist data'), category='success')
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during update of gist %s') % gist_id,
category='error')
raise HTTPFound(location=url('gist', gist_id=gist_id))
return rendered
def my_account_perms(self):
c.active = 'perms'
self.__load_data()
c.perm_user = AuthUser(user_id=self.authuser.user_id,
ip_addr=self.ip_addr)
return render('admin/my_account/my_account.html')
def index(self):
"""GET /admin/gists: All items in the collection"""
# url('gists')
not_default_user = not c.authuser.is_default_user
c.show_private = request.GET.get('private') and not_default_user
c.show_public = request.GET.get('public') and not_default_user
gists = Gist().query() \
.filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time())) \
.order_by(Gist.created_on.desc())
# MY private
if c.show_private and not c.show_public:
gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE) \
.filter(Gist.gist_owner == c.authuser.user_id)
# MY public
elif c.show_public and not c.show_private:
gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC) \
.filter(Gist.gist_owner == c.authuser.user_id)
# MY public+private
elif c.show_private and c.show_public:
gists = gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,
Gist.gist_type == Gist.GIST_PRIVATE)) \
.filter(Gist.gist_owner == c.authuser.user_id)
# default show ALL public gists
if not c.show_public and not c.show_private:
gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)
c.gists = gists
p = safe_int(request.GET.get('page', 1), 1)
c.gists_pager = Page(c.gists, page=p, items_per_page=10)
return render('admin/gists/index.html')
def edit_statistics(self, repo_name):
c.repo_info = self._load_repo()
repo = c.repo_info.scm_instance
if c.repo_info.stats:
# this is on what revision we ended up so we add +1 for count
last_rev = c.repo_info.stats.stat_on_revision + 1
else:
last_rev = 0
c.stats_revision = last_rev
c.repo_last_rev = repo.count() if repo.revisions else 0
if last_rev == 0 or c.repo_last_rev == 0:
c.stats_percentage = 0
else:
c.stats_percentage = '%.2f' % ((float((last_rev)) / c.repo_last_rev) * 100)
c.active = 'statistics'
if request.POST:
try:
RepoModel().delete_stats(repo_name)
Session().commit()
except Exception as e:
log.error(traceback.format_exc())
h.flash(_('An error occurred during deletion of repository stats'),
category='error')
raise HTTPFound(location=url('edit_repo_statistics', repo_name=c.repo_name))
return render('admin/repos/repo_edit.html')
def create(self):
"""POST /users: Create a new item"""
# url('users')
c.default_extern_type = auth_internal.KallitheaAuthPlugin.name
c.default_extern_name = auth_internal.KallitheaAuthPlugin.name
user_model = UserModel()
user_form = UserForm()()
try:
form_result = user_form.to_python(dict(request.POST))
user = user_model.create(form_result)
usr = form_result['username']
action_logger(self.authuser, 'admin_created_user:%s' % usr,
None, self.ip_addr, self.sa)
h.flash(h.literal(_('Created user %s') % h.link_to(h.escape(usr), url('edit_user', id=user.user_id))),
category='success')
Session().commit()
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/users/user_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except UserCreationError as e:
h.flash(e, 'error')
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during creation of user %s') \
% request.POST.get('username'), category='error')
raise HTTPFound(location=url('users'))
def index(self):
not_default_user = not request.authuser.is_default_user
c.show_private = request.GET.get('private') and not_default_user
c.show_public = request.GET.get('public') and not_default_user
gists = Gist().query() \
.filter_by(is_expired=False) \
.order_by(Gist.created_on.desc())
# MY private
if c.show_private and not c.show_public:
gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE) \
.filter(Gist.owner_id == request.authuser.user_id)
# MY public
elif c.show_public and not c.show_private:
gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC) \
.filter(Gist.owner_id == request.authuser.user_id)
# MY public+private
elif c.show_private and c.show_public:
gists = gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,
Gist.gist_type == Gist.GIST_PRIVATE)) \
.filter(Gist.owner_id == request.authuser.user_id)
# default show ALL public gists
if not c.show_public and not c.show_private:
gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)
c.gists = gists
p = safe_int(request.GET.get('page'), 1)
c.gists_pager = Page(c.gists, page=p, items_per_page=10)
return render('admin/gists/index.html')
def create(self):
self.__load_defaults()
# permissions for can create group based on parent_id are checked
# here in the Form
repo_group_form = RepoGroupForm(repo_groups=c.repo_groups)
try:
form_result = repo_group_form.to_python(dict(request.POST))
gr = RepoGroupModel().create(
group_name=form_result['group_name'],
group_description=form_result['group_description'],
parent=form_result['parent_group_id'],
owner=request.authuser.user_id, # TODO: make editable
copy_permissions=form_result['group_copy_permissions']
)
Session().commit()
#TODO: in future action_logger(, '', '', '')
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/repo_groups/repo_group_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during creation of repository group %s') \
% request.POST.get('group_name'), category='error')
parent_group_id = form_result['parent_group_id']
#TODO: maybe we should get back to the main view, not the admin one
raise HTTPFound(location=url('repos_groups', parent_group=parent_group_id))
h.flash(_('Created repository group %s') % gr.group_name,
category='success')
raise HTTPFound(location=url('repos_group_home', group_name=gr.group_name))
def edit(self, gist_id, format='html'):
"""GET /admin/gists/gist_id/edit: Form to edit an existing item"""
# url('edit_gist', gist_id=ID)
c.gist = Gist.get_or_404(gist_id)
#check if this gist is not expired
if c.gist.gist_expires != -1:
if time.time() > c.gist.gist_expires:
log.error('Gist expired at %s' %
(time_to_datetime(c.gist.gist_expires)))
raise HTTPNotFound()
try:
c.file_changeset, c.files = GistModel().get_gist_files(gist_id)
except VCSError:
log.error(traceback.format_exc())
raise HTTPNotFound()
self.__load_defaults(extra_values=('0', _('unmodified')))
rendered = render('admin/gists/edit.html')
if request.POST:
rpost = request.POST
nodes = {}
for org_filename, filename, mimetype, content in zip(
rpost.getall('org_files'),
rpost.getall('files'),
rpost.getall('mimetypes'),
rpost.getall('contents')):
nodes[org_filename] = {
'org_filename': org_filename,
'filename': filename,
'content': content,
'lexer': mimetype,
}
try:
GistModel().update(
gist=c.gist,
description=rpost['description'],
owner=c.gist.owner,
gist_mapping=nodes,
gist_type=c.gist.gist_type,
lifetime=rpost['lifetime']
)
Session().commit()
h.flash(_('Successfully updated gist content'), category='success')
except NodeNotChangedError:
# raised if nothing was changed in repo itself. We anyway then
# store only DB stuff for gist
Session().commit()
h.flash(_('Successfully updated gist data'), category='success')
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during update of gist %s') % gist_id,
category='error')
return redirect(url('gist', gist_id=gist_id))
return rendered
def show(self, group_name):
"""GET /repo_groups/group_name: Show a specific item"""
# url('repos_group', group_name=GROUP_NAME)
c.active = 'settings'
c.group = c.repo_group = RepoGroupModel()._get_repo_group(group_name)
c.group_repos = c.group.repositories.all()
#overwrite our cached list with current filter
c.repo_cnt = 0
groups = RepoGroup.query().order_by(RepoGroup.group_name)\
.filter(RepoGroup.group_parent_id == c.group.group_id).all()
c.groups = self.scm_model.get_repo_groups(groups)
c.repos_list = Repository.query()\
.filter(Repository.group_id == c.group.group_id)\
.order_by(func.lower(Repository.repo_name))\
.all()
repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,
admin=False)
#json used to render the grid
c.data = json.dumps(repos_data)
return render('admin/repo_groups/repo_group_show.html')
def edit(self, group_name):
"""GET /repo_groups/group_name/edit: Form to edit an existing item"""
# url('edit_repo_group', group_name=GROUP_NAME)
c.active = 'settings'
c.repo_group = RepoGroupModel()._get_repo_group(group_name)
#we can only allow moving empty group if it's already a top-level
#group, ie has no parents, or we're admin
if HasPermissionAll('hg.admin')('group edit'):
#we're global admin, we're ok and we can create TOP level groups
allow_empty_group = True
elif not c.repo_group.parent_group:
allow_empty_group = True
else:
allow_empty_group = False
self.__load_defaults(allow_empty_group=allow_empty_group,
exclude_group_ids=[c.repo_group.group_id])
defaults = self.__load_data(c.repo_group.group_id)
return htmlfill.render(
render('admin/repo_groups/repo_group_edit.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False
)
def edit_repo_group_advanced(self, group_name):
"""GET /repo_groups/group_name/edit: Form to edit an existing item"""
# url('edit_repo_group', group_name=GROUP_NAME)
c.active = 'advanced'
c.repo_group = RepoGroupModel()._get_repo_group(group_name)
return render('admin/repo_groups/repo_group_edit.html')
def create(self):
"""
POST /repos: Create a new item"""
# url('repos')
self.__load_defaults()
form_result = {}
task_id = None
try:
# CanWriteToGroup validators checks permissions of this POST
form_result = RepoForm(repo_groups=c.repo_groups_choices,
landing_revs=c.landing_revs_choices)()\
.to_python(dict(request.POST))
# create is done sometimes async on celery, db transaction
# management is handled there.
task = RepoModel().create(form_result, self.authuser.user_id)
from celery.result import BaseAsyncResult
if isinstance(task, BaseAsyncResult):
task_id = task.task_id
except formencode.Invalid, errors:
return htmlfill.render(
render('admin/repos/repo_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
force_defaults=False,
encoding="UTF-8")
def branch_tag_switcher(self, repo_name):
if request.is_xhr:
c.db_repo = Repository.get_by_repo_name(repo_name)
if c.db_repo:
c.db_repo_scm_instance = c.db_repo.scm_instance
return render('/switch_to_list.html')
raise HTTPBadRequest()
def create(self):
"""POST /users_groups: Create a new item"""
# url('users_groups')
users_group_form = UserGroupForm()()
try:
form_result = users_group_form.to_python(dict(request.POST))
ug = UserGroupModel().create(name=form_result['users_group_name'],
description=form_result['user_group_description'],
owner=self.authuser.user_id,
active=form_result['users_group_active'])
gr = form_result['users_group_name']
action_logger(self.authuser,
'admin_created_users_group:%s' % gr,
None, self.ip_addr, self.sa)
h.flash(h.literal(_('Created user group %s') % h.link_to(h.escape(gr), url('edit_users_group', id=ug.users_group_id))),
category='success')
Session().commit()
except formencode.Invalid, errors:
return htmlfill.render(
render('admin/user_groups/user_group_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
def index(self):
"""GET /admin/gists: All items in the collection"""
# url('gists')
not_default_user = c.authuser.username != User.DEFAULT_USER
c.show_private = request.GET.get('private') and not_default_user
c.show_public = request.GET.get('public') and not_default_user
gists = Gist().query()\
.filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time()))\
.order_by(Gist.created_on.desc())
# MY private
if c.show_private and not c.show_public:
gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE)\
.filter(Gist.gist_owner == c.authuser.user_id)
# MY public
elif c.show_public and not c.show_private:
gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)\
.filter(Gist.gist_owner == c.authuser.user_id)
# MY public+private
elif c.show_private and c.show_public:
gists = gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,
Gist.gist_type == Gist.GIST_PRIVATE))\
.filter(Gist.gist_owner == c.authuser.user_id)
# default show ALL public gists
if not c.show_public and not c.show_private:
gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)
c.gists = gists
p = safe_int(request.GET.get('page', 1), 1)
c.gists_pager = Page(c.gists, page=p, items_per_page=10)
return render('admin/gists/index.html')
def edit(self, group_name):
"""GET /repo_groups/group_name/edit: Form to edit an existing item"""
# url('edit_repo_group', group_name=GROUP_NAME)
c.active = 'settings'
c.repo_group = RepoGroupModel()._get_repo_group(group_name)
#we can only allow moving empty group if it's already a top-level
#group, ie has no parents, or we're admin
if HasPermissionAll('hg.admin')('group edit'):
#we're global admin, we're ok and we can create TOP level groups
allow_empty_group = True
elif not c.repo_group.parent_group:
allow_empty_group = True
else:
allow_empty_group = False
self.__load_defaults(allow_empty_group=allow_empty_group,
exclude_group_ids=[c.repo_group.group_id])
defaults = self.__load_data(c.repo_group.group_id)
return htmlfill.render(
render('admin/repo_groups/repo_group_edit.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def create(self):
"""POST /users_groups: Create a new item"""
# url('users_groups')
users_group_form = UserGroupForm()()
try:
form_result = users_group_form.to_python(dict(request.POST))
ug = UserGroupModel().create(
name=form_result['users_group_name'],
description=form_result['user_group_description'],
owner=self.authuser.user_id,
active=form_result['users_group_active'])
gr = form_result['users_group_name']
action_logger(self.authuser, 'admin_created_users_group:%s' % gr,
None, self.ip_addr, self.sa)
h.flash(h.literal(
_('Created user group %s') %
h.link_to(h.escape(gr),
url('edit_users_group', id=ug.users_group_id))),
category='success')
Session().commit()
except formencode.Invalid, errors:
return htmlfill.render(
render('admin/user_groups/user_group_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
def edit_advanced(self, repo_name):
c.repo_info = self._load_repo()
c.default_user_id = kallithea.DEFAULT_USER_ID
c.in_public_journal = UserFollowing.query() \
.filter(UserFollowing.user_id == c.default_user_id) \
.filter(UserFollowing.follows_repository == c.repo_info).scalar()
_repos = Repository.query(sorted=True).all()
read_access_repos = RepoList(_repos, perm_level='read')
c.repos_list = [(None, _('-- Not a fork --'))]
c.repos_list += [(x.repo_id, x.repo_name) for x in read_access_repos
if x.repo_id != c.repo_info.repo_id
and x.repo_type == c.repo_info.repo_type]
defaults = {
'id_fork_of': c.repo_info.fork_id if c.repo_info.fork_id else ''
}
c.active = 'advanced'
if request.POST:
raise HTTPFound(location=url('repo_edit_advanced'))
return htmlfill.render(render('admin/repos/repo_edit.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def edit_perms(self, id):
c.user_group = UserGroup.get_or_404(id)
c.active = 'perms'
repo_model = RepoModel()
c.users_array = repo_model.get_users_js()
c.user_groups_array = repo_model.get_user_groups_js()
defaults = {}
# fill user group users
for p in c.user_group.user_user_group_to_perm:
defaults.update(
{'u_perm_%s' % p.user.username: p.permission.permission_name})
for p in c.user_group.user_group_user_group_to_perm:
defaults.update({
'g_perm_%s' % p.user_group.users_group_name:
p.permission.permission_name
})
return htmlfill.render(
render('admin/user_groups/user_group_edit.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def create(self):
users_group_form = UserGroupForm()()
try:
form_result = users_group_form.to_python(dict(request.POST))
ug = UserGroupModel().create(name=form_result['users_group_name'],
description=form_result['user_group_description'],
owner=request.authuser.user_id,
active=form_result['users_group_active'])
gr = form_result['users_group_name']
action_logger(request.authuser,
'admin_created_users_group:%s' % gr,
None, request.ip_addr)
h.flash(h.literal(_('Created user group %s') % h.link_to(h.escape(gr), url('edit_users_group', id=ug.users_group_id))),
category='success')
Session().commit()
except formencode.Invalid as errors:
return htmlfill.render(
render('admin/user_groups/user_group_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except Exception:
log.error(traceback.format_exc())
h.flash(_('Error occurred during creation of user group %s') \
% request.POST.get('users_group_name'), category='error')
raise HTTPFound(location=url('users_groups'))
def create(self):
self.__load_defaults()
form_result = {}
try:
# CanWriteGroup validators checks permissions of this POST
form_result = RepoForm(repo_groups=c.repo_groups,
landing_revs=c.landing_revs_choices)() \
.to_python(dict(request.POST))
# create is done sometimes async on celery, db transaction
# management is handled there.
task = RepoModel().create(form_result, request.authuser.user_id)
task_id = task.task_id
except formencode.Invalid as errors:
log.info(errors)
return htmlfill.render(
render('admin/repos/repo_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
force_defaults=False,
encoding="UTF-8")
except Exception:
log.error(traceback.format_exc())
msg = (_('Error creating repository %s')
% form_result.get('repo_name'))
h.flash(msg, category='error')
raise HTTPFound(location=url('home'))
raise HTTPFound(location=h.url('repo_creating_home',
repo_name=form_result['repo_name_full'],
task_id=task_id))
def create(self):
"""POST /repo_groups: Create a new item"""
# url('repos_groups')
self.__load_defaults()
# permissions for can create group based on parent_id are checked
# here in the Form
repo_group_form = RepoGroupForm(available_groups=
map(lambda k: unicode(k[0]), c.repo_groups))()
try:
form_result = repo_group_form.to_python(dict(request.POST))
RepoGroupModel().create(
group_name=form_result['group_name'],
group_description=form_result['group_description'],
parent=form_result['group_parent_id'],
owner=self.authuser.user_id,
copy_permissions=form_result['group_copy_permissions']
)
Session().commit()
h.flash(_('Created repository group %s') \
% form_result['group_name'], category='success')
#TODO: in futureaction_logger(, '', '', '', self.sa)
except formencode.Invalid, errors:
return htmlfill.render(
render('admin/repo_groups/repo_group_add.html'),
defaults=errors.value,
errors=errors.error_dict or {},
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
def my_account_watched(self):
c.active = 'watched'
self.__load_data()
#json used to render the grid
c.data = self._load_my_repos_data(watched=True)
return render('admin/my_account/my_account.html')
