def create(self, form_data, cur_user=None):
if not cur_user:
cur_user = getattr(get_current_authuser(), 'username', None)
from kallithea.lib.hooks import log_create_user, \
check_allowed_create_user
_fd = form_data
user_data = {
'username': _fd['username'],
'password': _fd['password'],
'email': _fd['email'],
'firstname': _fd['firstname'],
'lastname': _fd['lastname'],
'active': _fd['active'],
'admin': False
}
# raises UserCreationError if it's not allowed
check_allowed_create_user(user_data, cur_user)
from kallithea.lib.auth import get_crypt_password
new_user = User()
for k, v in form_data.items():
if k == 'password':
v = get_crypt_password(v)
if k == 'firstname':
k = 'name'
setattr(new_user, k, v)
new_user.api_key = generate_api_key()
Session().add(new_user)
Session().flush() # make database assign new_user.user_id
log_create_user(new_user.get_dict(), cur_user)
return new_user
def create(self, form_data, cur_user=None):
if not cur_user:
cur_user = getattr(get_current_authuser(), 'username', None)
from kallithea.lib.hooks import log_create_user, check_allowed_create_user
_fd = form_data
user_data = {
'username': _fd['username'], 'password': _fd['password'],
'email': _fd['email'], 'firstname': _fd['firstname'], 'lastname': _fd['lastname'],
'active': _fd['active'], 'admin': False
}
# raises UserCreationError if it's not allowed
check_allowed_create_user(user_data, cur_user)
from kallithea.lib.auth import get_crypt_password
new_user = User()
for k, v in form_data.items():
if k == 'password':
v = get_crypt_password(v)
if k == 'firstname':
k = 'name'
setattr(new_user, k, v)
new_user.api_key = generate_api_key(form_data['username'])
self.sa.add(new_user)
log_create_user(new_user.get_dict(), cur_user)
return new_user
def create_test_user(force=True):
print('creating test user')
sa = get_session()
user = sa.query(User).filter(User.username == USER).scalar()
if force and user is not None:
print('removing current user')
for repo in sa.query(Repository).filter(Repository.user == user).all():
sa.delete(repo)
sa.delete(user)
sa.commit()
if user is None or force:
print('creating new one')
new_usr = User()
new_usr.username = USER
new_usr.password = get_crypt_password(PASS)
new_usr.email = '*****@*****.**'
new_usr.name = 'test'
new_usr.lastname = 'lasttestname'
new_usr.active = True
new_usr.admin = True
sa.add(new_usr)
sa.commit()
print('done')
def create_test_user(force=True):
print 'creating test user'
sa = get_session()
user = sa.query(User).filter(User.username == USER).scalar()
if force and user is not None:
print 'removing current user'
for repo in sa.query(Repository).filter(Repository.user == user).all():
sa.delete(repo)
sa.delete(user)
sa.commit()
if user is None or force:
print 'creating new one'
new_usr = User()
new_usr.username = USER
new_usr.password = get_crypt_password(PASS)
new_usr.email = '*****@*****.**'
new_usr.name = 'test'
new_usr.lastname = 'lasttestname'
new_usr.active = True
new_usr.admin = True
sa.add(new_usr)
sa.commit()
print 'done'
def update_user(self, user, **kwargs):
from kallithea.lib.auth import get_crypt_password
user = User.guess_instance(user)
if user.is_default_user:
raise DefaultUserException(
_("You can't edit this user since it's"
" crucial for entire application")
)
for k, v in kwargs.items():
if k == 'password' and v:
v = get_crypt_password(v)
setattr(user, k, v)
return user
def update_user(self, user, **kwargs):
from kallithea.lib.auth import get_crypt_password
user = User.guess_instance(user)
if user.is_default_user:
raise DefaultUserException(
_("You can't edit this user since it's"
" crucial for entire application")
)
for k, v in kwargs.items():
if k == 'password' and v:
v = get_crypt_password(v)
setattr(user, k, v)
return user
def update_user(self, user, **kwargs):
from kallithea.lib.auth import get_crypt_password
user = self._get_user(user)
if user.username == User.DEFAULT_USER:
raise DefaultUserException(
_("You can't Edit this user since it's"
" crucial for entire application")
)
for k, v in kwargs.items():
if k == 'password' and v:
v = get_crypt_password(v)
setattr(user, k, v)
self.sa.add(user)
return user
def create(cls, form_data):
from kallithea.lib.auth import get_crypt_password
try:
new_user = cls()
for k, v in form_data.items():
if k == 'password':
v = get_crypt_password(v)
setattr(new_user, k, v)
new_user.api_key = generate_api_key(form_data['username'])
Session.add(new_user)
Session.commit()
return new_user
except:
log.error(traceback.format_exc())
Session.rollback()
raise
def reset_password(self, user_email, new_passwd):
from kallithea.lib.celerylib import tasks
from kallithea.lib import auth
user = User.get_by_email(user_email)
if user is not None:
if not self.can_change_password(user):
raise Exception('trying to change password for external user')
user.password = auth.get_crypt_password(new_passwd)
Session().commit()
log.info('change password for %s', user_email)
if new_passwd is None:
raise Exception('unable to set new password')
tasks.send_email([user_email],
_('Password reset notification'),
_('The password to your account %s has been changed using password reset form.') % (user.username,))
log.info('send password reset mail to %s', user_email)
return True
def reset_password(self, user_email, new_passwd):
from kallithea.lib.celerylib import tasks
from kallithea.lib import auth
user = User.get_by_email(user_email)
if user is not None:
if not self.can_change_password(user):
raise Exception('trying to change password for external user')
user.password = auth.get_crypt_password(new_passwd)
Session().commit()
log.info('change password for %s', user_email)
if new_passwd is None:
raise Exception('unable to set new password')
tasks.send_email([user_email],
_('Password reset notification'),
_('The password to your account %s has been changed using password reset form.') % (user.username,))
log.info('send password reset mail to %s', user_email)
return True
def update(self, user_id, form_data, skip_attrs=None):
from kallithea.lib.auth import get_crypt_password
skip_attrs = skip_attrs or []
user = self.get(user_id)
if user.is_default_user:
raise DefaultUserException(
_("You can't edit this user since it's "
"crucial for entire application"))
for k, v in form_data.items():
if k in skip_attrs:
continue
if k == 'new_password' and v:
user.password = get_crypt_password(v)
else:
# old legacy thing orm models store firstname as name,
# need proper refactor to username
if k == 'firstname':
k = 'name'
setattr(user, k, v)
def update(self, user_id, form_data, skip_attrs=None):
from kallithea.lib.auth import get_crypt_password
skip_attrs = skip_attrs or []
user = self.get(user_id, cache=False)
if user.is_default_user:
raise DefaultUserException(
_("You can't edit this user since it's "
"crucial for entire application"))
for k, v in form_data.items():
if k in skip_attrs:
continue
if k == 'new_password' and v:
user.password = get_crypt_password(v)
else:
# old legacy thing orm models store firstname as name,
# need proper refactor to username
if k == 'firstname':
k = 'name'
setattr(user, k, v)
def reset_password(self, data):
from kallithea.lib.celerylib import tasks, run_task
from kallithea.lib import auth
user_email = data['email']
user = User.get_by_email(user_email)
new_passwd = auth.PasswordGenerator().gen_password(8,
auth.PasswordGenerator.ALPHABETS_BIG_SMALL)
if user:
user.password = auth.get_crypt_password(new_passwd)
Session().add(user)
Session().commit()
log.info('change password for %s' % user_email)
if new_passwd is None:
raise Exception('unable to generate new password')
run_task(tasks.send_email, [user_email],
_('Your new password'),
_('Your new Kallithea password:%s') % (new_passwd,))
log.info('send new password mail to %s' % user_email)
return True
def create_or_update(self, username, password, email, firstname='',
lastname='', active=True, admin=False,
extern_type=None, extern_name=None, cur_user=None):
"""
Creates a new instance if not found, or updates current one
:param username:
:param password:
:param email:
:param active:
:param firstname:
:param lastname:
:param active:
:param admin:
:param extern_name:
:param extern_type:
:param cur_user:
"""
if not cur_user:
cur_user = getattr(get_current_authuser(), 'username', None)
from kallithea.lib.auth import get_crypt_password, check_password
from kallithea.lib.hooks import log_create_user, \
check_allowed_create_user
user_data = {
'username': username, 'password': password,
'email': email, 'firstname': firstname, 'lastname': lastname,
'active': active, 'admin': admin
}
# raises UserCreationError if it's not allowed
check_allowed_create_user(user_data, cur_user)
log.debug('Checking for %s account in Kallithea database', username)
user = User.get_by_username(username, case_insensitive=True)
if user is None:
log.debug('creating new user %s', username)
new_user = User()
edit = False
else:
log.debug('updating user %s', username)
new_user = user
edit = True
try:
new_user.username = username
new_user.admin = admin
new_user.email = email
new_user.active = active
new_user.extern_name = extern_name
new_user.extern_type = extern_type
new_user.name = firstname
new_user.lastname = lastname
if not edit:
new_user.api_key = generate_api_key()
# set password only if creating an user or password is changed
password_change = new_user.password and \
not check_password(password, new_user.password)
if not edit or password_change:
reason = 'new password' if edit else 'new user'
log.debug('Updating password reason=>%s', reason)
new_user.password = get_crypt_password(password) \
if password else ''
if user is None:
Session().add(new_user)
Session().flush() # make database assign new_user.user_id
if not edit:
log_create_user(new_user.get_dict(), cur_user)
return new_user
except (DatabaseError,):
log.error(traceback.format_exc())
raise
def create_or_update(self, username, password, email, firstname='',
lastname='', active=True, admin=False,
extern_type=None, extern_name=None, cur_user=None):
"""
Creates a new instance if not found, or updates current one
:param username:
:param password:
:param email:
:param active:
:param firstname:
:param lastname:
:param active:
:param admin:
:param extern_name:
:param extern_type:
:param cur_user:
"""
if not cur_user:
cur_user = getattr(get_current_authuser(), 'username', None)
from kallithea.lib.auth import get_crypt_password, check_password
from kallithea.lib.hooks import log_create_user, check_allowed_create_user
user_data = {
'username': username, 'password': password,
'email': email, 'firstname': firstname, 'lastname': lastname,
'active': active, 'admin': admin
}
# raises UserCreationError if it's not allowed
check_allowed_create_user(user_data, cur_user)
log.debug('Checking for %s account in Kallithea database' % username)
user = User.get_by_username(username, case_insensitive=True)
if user is None:
log.debug('creating new user %s' % username)
new_user = User()
edit = False
else:
log.debug('updating user %s' % username)
new_user = user
edit = True
try:
new_user.username = username
new_user.admin = admin
new_user.email = email
new_user.active = active
new_user.extern_name = safe_unicode(extern_name) if extern_name else None
new_user.extern_type = safe_unicode(extern_type) if extern_type else None
new_user.name = firstname
new_user.lastname = lastname
if not edit:
new_user.api_key = generate_api_key(username)
# set password only if creating an user or password is changed
password_change = new_user.password and not check_password(password,
new_user.password)
if not edit or password_change:
reason = 'new password' if edit else 'new user'
log.debug('Updating password reason=>%s' % (reason,))
new_user.password = get_crypt_password(password) if password else None
self.sa.add(new_user)
if not edit:
log_create_user(new_user.get_dict(), cur_user)
return new_user
except (DatabaseError,):
log.error(traceback.format_exc())
raise
