users.py
505 lines
| 19.3 KiB
| text/x-python
|
PythonLexer
r853 | # -*- coding: utf-8 -*- | |||
r1206 | # This program is free software: you can redistribute it and/or modify | |||
# it under the terms of the GNU General Public License as published by | ||||
# the Free Software Foundation, either version 3 of the License, or | ||||
# (at your option) any later version. | ||||
r1203 | # | |||
r547 | # This program is distributed in the hope that it will be useful, | |||
# but WITHOUT ANY WARRANTY; without even the implied warranty of | ||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||||
# GNU General Public License for more details. | ||||
r1203 | # | |||
r547 | # You should have received a copy of the GNU General Public License | |||
r1206 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
|
r4116 | """ | ||
rhodecode.controllers.admin.users | ||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | ||||
Users crud controller for pylons | ||||
:created_on: Apr 4, 2010 | ||||
:author: marcink | ||||
:copyright: (c) 2013 RhodeCode GmbH. | ||||
:license: GPLv3, see LICENSE for more details. | ||||
""" | ||||
r853 | ||||
import logging | ||||
import traceback | ||||
import formencode | ||||
r2658 | from pylons import response | |||
r547 | ||||
from formencode import htmlfill | ||||
r895 | from pylons import request, session, tmpl_context as c, url, config | |||
r1824 | from pylons.controllers.util import redirect | |||
r547 | from pylons.i18n.translation import _ | |||
|
r4116 | from sqlalchemy.sql.expression import func | ||
r853 | ||||
r2709 | import rhodecode | |||
r1245 | from rhodecode.lib.exceptions import DefaultUserException, \ | |||
r4074 | UserOwnsReposException, UserCreationError | |||
r547 | from rhodecode.lib import helpers as h | |||
r2658 | from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \ | |||
|
r4116 | AuthUser, generate_api_key | ||
import rhodecode.lib.auth_modules.auth_rhodecode | ||||
from rhodecode.lib import auth_modules | ||||
r547 | from rhodecode.lib.base import BaseController, render | |||
|
r4116 | from rhodecode.model.api_key import ApiKeyModel | ||
r853 | ||||
r3736 | from rhodecode.model.db import User, UserEmailMap, UserIpMap, UserToPerm | |||
from rhodecode.model.forms import UserForm, CustomDefaultPermissionsForm | ||||
r713 | from rhodecode.model.user import UserModel | |||
r1749 | from rhodecode.model.meta import Session | |||
r2375 | from rhodecode.lib.utils import action_logger | |||
r2658 | from rhodecode.lib.compat import json | |||
|
r4116 | from rhodecode.lib.utils2 import datetime_to_time, str2bool, safe_int | ||
r547 | ||||
log = logging.getLogger(__name__) | ||||
r1245 | ||||
r547 | class UsersController(BaseController): | |||
"""REST Controller styled on the Atom Publishing Protocol""" | ||||
r673 | ||||
r547 | @LoginRequired() | |||
@HasPermissionAllDecorator('hg.admin') | ||||
def __before__(self): | ||||
super(UsersController, self).__before__() | ||||
r895 | c.available_permissions = config['available_permissions'] | |||
r547 | ||||
def index(self, format='html'): | ||||
"""GET /users: All items in the collection""" | ||||
# url('users') | ||||
r673 | ||||
r3799 | c.users_list = User.query().order_by(User.username)\ | |||
.filter(User.username != User.DEFAULT_USER)\ | ||||
|
r4116 | .order_by(func.lower(User.username))\ | ||
r3799 | .all() | |||
r2658 | ||||
users_data = [] | ||||
total_records = len(c.users_list) | ||||
r2663 | _tmpl_lookup = rhodecode.CONFIG['pylons.app_globals'].mako_lookup | |||
template = _tmpl_lookup.get_template('data_table/_dt_elements.html') | ||||
grav_tmpl = lambda user_email, size: ( | ||||
template.get_def("user_gravatar") | ||||
r2674 | .render(user_email, size, _=_, h=h, c=c)) | |||
r2663 | ||||
|
r4116 | username = lambda user_id, username: ( | ||
r2663 | template.get_def("user_name") | |||
r2674 | .render(user_id, username, _=_, h=h, c=c)) | |||
r2663 | ||||
user_actions = lambda user_id, username: ( | ||||
template.get_def("user_actions") | ||||
r2674 | .render(user_id, username, _=_, h=h, c=c)) | |||
r2663 | ||||
r2658 | for user in c.users_list: | |||
r2699 | ||||
r2658 | users_data.append({ | |||
|
r4116 | "gravatar": grav_tmpl(user. email, 20), | ||
"raw_name": user.username, | ||||
"username": username(user.user_id, user.username), | ||||
r2658 | "firstname": user.name, | |||
"lastname": user.lastname, | ||||
"last_login": h.fmt_date(user.last_login), | ||||
r2699 | "last_login_raw": datetime_to_time(user.last_login), | |||
|
r3627 | "active": h.boolicon(user.active), | ||
"admin": h.boolicon(user.admin), | ||||
|
r4116 | "extern_type": user.extern_type, | ||
"extern_name": user.extern_name, | ||||
r2663 | "action": user_actions(user.user_id, user.username), | |||
r2658 | }) | |||
c.data = json.dumps({ | ||||
"totalRecords": total_records, | ||||
"startIndex": 0, | ||||
"sort": None, | ||||
"dir": "asc", | ||||
"records": users_data | ||||
}) | ||||
r547 | return render('admin/users/users.html') | |||
r673 | ||||
r547 | def create(self): | |||
"""POST /users: Create a new item""" | ||||
# url('users') | ||||
|
r4116 | c.default_extern_type = auth_modules.auth_rhodecode.RhodeCodeAuthPlugin.name | ||
r547 | user_model = UserModel() | |||
r1644 | user_form = UserForm()() | |||
r547 | try: | |||
r1644 | form_result = user_form.to_python(dict(request.POST)) | |||
r547 | user_model.create(form_result) | |||
r2375 | usr = form_result['username'] | |||
action_logger(self.rhodecode_user, 'admin_created_user:%s' % usr, | ||||
None, self.ip_addr, self.sa) | ||||
|
r3565 | h.flash(_('Created user %s') % usr, | ||
r547 | category='success') | |||
r2662 | Session().commit() | |||
r564 | except formencode.Invalid, errors: | |||
r547 | return htmlfill.render( | |||
render('admin/users/user_add.html'), | ||||
defaults=errors.value, | ||||
errors=errors.error_dict or {}, | ||||
prefix_error=False, | ||||
r673 | encoding="UTF-8") | |||
r4074 | except UserCreationError, e: | |||
h.flash(e, 'error') | ||||
r547 | except Exception: | |||
log.error(traceback.format_exc()) | ||||
|
r3565 | h.flash(_('Error occurred during creation of user %s') \ | ||
r673 | % request.POST.get('username'), category='error') | |||
r547 | return redirect(url('users')) | |||
r673 | ||||
r547 | def new(self, format='html'): | |||
"""GET /users/new: Form to create a new item""" | ||||
# url('new_user') | ||||
|
r4116 | c.default_extern_type = auth_modules.auth_rhodecode.RhodeCodeAuthPlugin.name | ||
r547 | return render('admin/users/user_add.html') | |||
def update(self, id): | ||||
"""PUT /users/id: Update an existing item""" | ||||
# Forms posted to this method should contain a hidden field: | ||||
# <input type="hidden" name="_method" value="PUT" /> | ||||
# Or using helpers: | ||||
r1266 | # h.form(url('update_user', id=ID), | |||
r547 | # method='put') | |||
# url('user', id=ID) | ||||
|
r4116 | c.active = 'profile' | ||
r547 | user_model = UserModel() | |||
r629 | c.user = user_model.get(id) | |||
|
r4116 | c.extern_type = c.user.extern_type | ||
c.extern_name = c.user.extern_name | ||||
r3125 | c.perm_user = AuthUser(user_id=id, ip_addr=self.ip_addr) | |||
r1245 | _form = UserForm(edit=True, old_data={'user_id': id, | |||
'email': c.user.email})() | ||||
r547 | form_result = {} | |||
try: | ||||
form_result = _form.to_python(dict(request.POST)) | ||||
|
r4116 | skip_attrs = ['extern_type', 'extern_name'] | ||
#TODO: plugin should define if username can be updated | ||||
if c.extern_type != "rhodecode": | ||||
# forbid updating username for external accounts | ||||
skip_attrs.append('username') | ||||
r3021 | user_model.update(id, form_result, skip_attrs=skip_attrs) | |||
r2375 | usr = form_result['username'] | |||
action_logger(self.rhodecode_user, 'admin_updated_user:%s' % usr, | ||||
None, self.ip_addr, self.sa) | ||||
r1266 | h.flash(_('User updated successfully'), category='success') | |||
r2662 | Session().commit() | |||
r564 | except formencode.Invalid, errors: | |||
r2479 | defaults = errors.value | |||
r1266 | e = errors.error_dict or {} | |||
r2709 | defaults.update({ | |||
|
r4116 | 'create_repo_perm': user_model.has_perm(id, | ||
'hg.create.repository'), | ||||
r2709 | 'fork_repo_perm': user_model.has_perm(id, 'hg.fork.repository'), | |||
'_method': 'put' | ||||
}) | ||||
r547 | return htmlfill.render( | |||
render('admin/users/user_edit.html'), | ||||
r2479 | defaults=defaults, | |||
r1266 | errors=e, | |||
r547 | prefix_error=False, | |||
r673 | encoding="UTF-8") | |||
r547 | except Exception: | |||
log.error(traceback.format_exc()) | ||||
|
r3565 | h.flash(_('Error occurred during update of user %s') \ | ||
r547 | % form_result.get('username'), category='error') | |||
r2709 | return redirect(url('edit_user', id=id)) | |||
r673 | ||||
r547 | def delete(self, id): | |||
"""DELETE /users/id: Delete an existing item""" | ||||
# Forms posted to this method should contain a hidden field: | ||||
# <input type="hidden" name="_method" value="DELETE" /> | ||||
# Or using helpers: | ||||
r1266 | # h.form(url('delete_user', id=ID), | |||
r547 | # method='delete') | |||
# url('user', id=ID) | ||||
r2709 | usr = User.get_or_404(id) | |||
r547 | try: | |||
r2709 | UserModel().delete(usr) | |||
r2662 | Session().commit() | |||
|
r3565 | h.flash(_('Successfully deleted user'), category='success') | ||
r713 | except (UserOwnsReposException, DefaultUserException), e: | |||
r2155 | h.flash(e, category='warning') | |||
r547 | except Exception: | |||
r2155 | log.error(traceback.format_exc()) | |||
r860 | h.flash(_('An error occurred during deletion of user'), | |||
r673 | category='error') | |||
r547 | return redirect(url('users')) | |||
r673 | ||||
r547 | def show(self, id, format='html'): | |||
"""GET /users/id: Show a specific item""" | ||||
# url('user', id=ID) | ||||
r3731 | User.get_or_404(-1) | |||
r673 | ||||
r547 | def edit(self, id, format='html'): | |||
"""GET /users/id/edit: Form to edit an existing item""" | ||||
# url('edit_user', id=ID) | ||||
r2496 | c.user = User.get_or_404(id) | |||
|
r4116 | if c.user.username == User.DEFAULT_USER: | ||
h.flash(_("You can't edit this user"), category='warning') | ||||
return redirect(url('users')) | ||||
r2496 | ||||
|
r4116 | c.active = 'profile' | ||
c.extern_type = c.user.extern_type | ||||
c.extern_name = c.user.extern_name | ||||
c.perm_user = AuthUser(user_id=id, ip_addr=self.ip_addr) | ||||
defaults = c.user.get_dict() | ||||
return htmlfill.render( | ||||
render('admin/users/user_edit.html'), | ||||
defaults=defaults, | ||||
encoding="UTF-8", | ||||
force_defaults=False) | ||||
def edit_advanced(self, id): | ||||
c.user = User.get_or_404(id) | ||||
if c.user.username == User.DEFAULT_USER: | ||||
r673 | h.flash(_("You can't edit this user"), category='warning') | |||
r547 | return redirect(url('users')) | |||
r2709 | ||||
|
r4116 | c.active = 'advanced' | ||
r3125 | c.perm_user = AuthUser(user_id=id, ip_addr=self.ip_addr) | |||
|
r4116 | |||
r3736 | umodel = UserModel() | |||
r832 | defaults = c.user.get_dict() | |||
r2709 | defaults.update({ | |||
|
r4116 | 'create_repo_perm': umodel.has_perm(c.user, 'hg.create.repository'), | ||
'create_user_group_perm': umodel.has_perm(c.user, | ||||
'hg.usergroup.create.true'), | ||||
'fork_repo_perm': umodel.has_perm(c.user, 'hg.fork.repository'), | ||||
r2709 | }) | |||
|
r4116 | return htmlfill.render( | ||
render('admin/users/user_edit.html'), | ||||
defaults=defaults, | ||||
encoding="UTF-8", | ||||
force_defaults=False) | ||||
r895 | ||||
|
r4116 | def edit_api_keys(self, id): | ||
c.user = User.get_or_404(id) | ||||
if c.user.username == User.DEFAULT_USER: | ||||
h.flash(_("You can't edit this user"), category='warning') | ||||
return redirect(url('users')) | ||||
c.active = 'api_keys' | ||||
show_expired = True | ||||
c.lifetime_values = [ | ||||
(str(-1), _('forever')), | ||||
(str(5), _('5 minutes')), | ||||
(str(60), _('1 hour')), | ||||
(str(60 * 24), _('1 day')), | ||||
(str(60 * 24 * 30), _('1 month')), | ||||
] | ||||
c.lifetime_options = [(c.lifetime_values, _("Lifetime"))] | ||||
c.user_api_keys = ApiKeyModel().get_api_keys(c.user.user_id, | ||||
show_expired=show_expired) | ||||
defaults = c.user.get_dict() | ||||
r547 | return htmlfill.render( | |||
render('admin/users/user_edit.html'), | ||||
defaults=defaults, | ||||
encoding="UTF-8", | ||||
|
r4116 | force_defaults=False) | ||
def add_api_key(self, id): | ||||
c.user = User.get_or_404(id) | ||||
if c.user.username == User.DEFAULT_USER: | ||||
h.flash(_("You can't edit this user"), category='warning') | ||||
return redirect(url('users')) | ||||
lifetime = safe_int(request.POST.get('lifetime'), -1) | ||||
description = request.POST.get('description') | ||||
new_api_key = ApiKeyModel().create(c.user.user_id, description, lifetime) | ||||
Session().commit() | ||||
h.flash(_("Api key successfully created"), category='success') | ||||
return redirect(url('edit_user_api_keys', id=c.user.user_id)) | ||||
def delete_api_key(self, id): | ||||
c.user = User.get_or_404(id) | ||||
if c.user.username == User.DEFAULT_USER: | ||||
h.flash(_("You can't edit this user"), category='warning') | ||||
return redirect(url('users')) | ||||
r1266 | ||||
|
r4116 | api_key = request.POST.get('del_api_key') | ||
if request.POST.get('del_api_key_builtin'): | ||||
user = User.get(c.user.user_id) | ||||
if user: | ||||
user.api_key = generate_api_key(user.username) | ||||
Session().add(user) | ||||
Session().commit() | ||||
h.flash(_("Api key successfully reset"), category='success') | ||||
elif api_key: | ||||
ApiKeyModel().delete(api_key, c.user.user_id) | ||||
Session().commit() | ||||
h.flash(_("Api key successfully deleted"), category='success') | ||||
return redirect(url('edit_user_api_keys', id=c.user.user_id)) | ||||
def update_account(self, id): | ||||
pass | ||||
def edit_perms(self, id): | ||||
c.user = User.get_or_404(id) | ||||
if c.user.username == User.DEFAULT_USER: | ||||
h.flash(_("You can't edit this user"), category='warning') | ||||
return redirect(url('users')) | ||||
c.active = 'perms' | ||||
c.perm_user = AuthUser(user_id=id, ip_addr=self.ip_addr) | ||||
umodel = UserModel() | ||||
defaults = c.user.get_dict() | ||||
defaults.update({ | ||||
'create_repo_perm': umodel.has_perm(c.user, 'hg.create.repository'), | ||||
'create_user_group_perm': umodel.has_perm(c.user, | ||||
'hg.usergroup.create.true'), | ||||
'fork_repo_perm': umodel.has_perm(c.user, 'hg.fork.repository'), | ||||
}) | ||||
return htmlfill.render( | ||||
render('admin/users/user_edit.html'), | ||||
defaults=defaults, | ||||
encoding="UTF-8", | ||||
force_defaults=False) | ||||
def update_perms(self, id): | ||||
r1266 | """PUT /users_perm/id: Update an existing item""" | |||
# url('user_perm', id=ID, method='put') | ||||
r3736 | user = User.get_or_404(id) | |||
r1818 | ||||
r2709 | try: | |||
r3736 | form = CustomDefaultPermissionsForm()() | |||
form_result = form.to_python(request.POST) | ||||
inherit_perms = form_result['inherit_default_permissions'] | ||||
user.inherit_default_permissions = inherit_perms | ||||
Session().add(user) | ||||
user_model = UserModel() | ||||
r1266 | ||||
r3736 | defs = UserToPerm.query()\ | |||
.filter(UserToPerm.user == user)\ | ||||
.all() | ||||
for ug in defs: | ||||
Session().delete(ug) | ||||
if form_result['create_repo_perm']: | ||||
user_model.grant_perm(id, 'hg.create.repository') | ||||
r2709 | else: | |||
r3736 | user_model.grant_perm(id, 'hg.create.none') | |||
if form_result['create_user_group_perm']: | ||||
user_model.grant_perm(id, 'hg.usergroup.create.true') | ||||
r2709 | else: | |||
r3736 | user_model.grant_perm(id, 'hg.usergroup.create.false') | |||
if form_result['fork_repo_perm']: | ||||
user_model.grant_perm(id, 'hg.fork.repository') | ||||
else: | ||||
user_model.grant_perm(id, 'hg.fork.none') | ||||
h.flash(_("Updated permissions"), category='success') | ||||
r2662 | Session().commit() | |||
r2709 | except Exception: | |||
log.error(traceback.format_exc()) | ||||
h.flash(_('An error occurred during permissions saving'), | ||||
category='error') | ||||
|
r4116 | return redirect(url('edit_user_perms', id=id)) | ||
def edit_emails(self, id): | ||||
c.user = User.get_or_404(id) | ||||
if c.user.username == User.DEFAULT_USER: | ||||
h.flash(_("You can't edit this user"), category='warning') | ||||
return redirect(url('users')) | ||||
c.active = 'emails' | ||||
c.user_email_map = UserEmailMap.query()\ | ||||
.filter(UserEmailMap.user == c.user).all() | ||||
defaults = c.user.get_dict() | ||||
return htmlfill.render( | ||||
render('admin/users/user_edit.html'), | ||||
defaults=defaults, | ||||
encoding="UTF-8", | ||||
force_defaults=False) | ||||
r2330 | ||||
def add_email(self, id): | ||||
r2467 | """POST /user_emails:Add an existing item""" | |||
r2330 | # url('user_emails', id=ID, method='put') | |||
email = request.POST.get('new_email') | ||||
user_model = UserModel() | ||||
try: | ||||
user_model.add_extra_email(id, email) | ||||
r2662 | Session().commit() | |||
|
r2570 | h.flash(_("Added email %s to user") % email, category='success') | ||
r2479 | except formencode.Invalid, error: | |||
msg = error.error_dict['email'] | ||||
h.flash(msg, category='error') | ||||
r2330 | except Exception: | |||
log.error(traceback.format_exc()) | ||||
h.flash(_('An error occurred during email saving'), | ||||
category='error') | ||||
|
r4116 | return redirect(url('edit_user_emails', id=id)) | ||
r2330 | ||||
def delete_email(self, id): | ||||
"""DELETE /user_emails_delete/id: Delete an existing item""" | ||||
# url('user_emails_delete', id=ID, method='delete') | ||||
|
r4116 | email_id = request.POST.get('del_email_id') | ||
r2330 | user_model = UserModel() | |||
|
r4116 | user_model.delete_extra_email(id, email_id) | ||
r2662 | Session().commit() | |||
r2330 | h.flash(_("Removed email from user"), category='success') | |||
|
r4116 | return redirect(url('edit_user_emails', id=id)) | ||
def edit_ips(self, id): | ||||
c.user = User.get_or_404(id) | ||||
if c.user.username == User.DEFAULT_USER: | ||||
h.flash(_("You can't edit this user"), category='warning') | ||||
return redirect(url('users')) | ||||
c.active = 'ips' | ||||
c.user_ip_map = UserIpMap.query()\ | ||||
.filter(UserIpMap.user == c.user).all() | ||||
c.inherit_default_ips = c.user.inherit_default_permissions | ||||
c.default_user_ip_map = UserIpMap.query()\ | ||||
.filter(UserIpMap.user == User.get_default_user()).all() | ||||
defaults = c.user.get_dict() | ||||
return htmlfill.render( | ||||
render('admin/users/user_edit.html'), | ||||
defaults=defaults, | ||||
encoding="UTF-8", | ||||
force_defaults=False) | ||||
r3125 | ||||
def add_ip(self, id): | ||||
"""POST /user_ips:Add an existing item""" | ||||
# url('user_ips', id=ID, method='put') | ||||
ip = request.POST.get('new_ip') | ||||
user_model = UserModel() | ||||
try: | ||||
user_model.add_extra_ip(id, ip) | ||||
Session().commit() | ||||
|
r4116 | h.flash(_("Added ip %s to user whitelist") % ip, category='success') | ||
r3125 | except formencode.Invalid, error: | |||
msg = error.error_dict['ip'] | ||||
h.flash(msg, category='error') | ||||
except Exception: | ||||
log.error(traceback.format_exc()) | ||||
h.flash(_('An error occurred during ip saving'), | ||||
category='error') | ||||
|
r4116 | |||
r3125 | if 'default_user' in request.POST: | |||
|
r4116 | return redirect(url('admin_permissions_ips')) | ||
return redirect(url('edit_user_ips', id=id)) | ||||
r3125 | ||||
def delete_ip(self, id): | ||||
"""DELETE /user_ips_delete/id: Delete an existing item""" | ||||
# url('user_ips_delete', id=ID, method='delete') | ||||
|
r4116 | ip_id = request.POST.get('del_ip_id') | ||
r3125 | user_model = UserModel() | |||
|
r4116 | user_model.delete_extra_ip(id, ip_id) | ||
r3125 | Session().commit() | |||
|
r4116 | h.flash(_("Removed ip address from user whitelist"), category='success') | ||
r3125 | if 'default_user' in request.POST: | |||
|
r4116 | return redirect(url('admin_permissions_ips')) | ||
return redirect(url('edit_user_ips', id=id)) | ||||