-----------

Creates new user or updates current one if such user exists. This command can 

be executed only using api_key belonging to user with admin rights.

INPUT::

    api_key : "<api_key>"

    method :  "create_user"

    args :    {

                "username" :  "<username>",

                "password" :  "<password>",

                "active" :    "<bool> = True",

                "admin" :     "<bool> = False",

                "ldap_dn" :   "<ldap_dn> = None"

              }

OUTPUT::

    result: {

              "id" : "<new_user_id>",

              "msg" : "created new user <username>"

            }

    error:  null

- #239 option to manually mark repository as fork

- #320 mapping of commit authors to RhodeCode users

- #304 hashes are displayed using monospace font    

- diff configuration, toggle white lines and context lines

- #307 configurable diffs, whitespace toggle, increasing context lines

- sorting on branches, tags and bookmarks using YUI datatable

- improved file filter on files page

- implements #330 api method for listing nodes ar particular revision

- #73 added linking issues in commit messages to chosen issue tracker url

  based on user defined regular expression

- added linking of changesets in commit messages  

- new compact changelog with expandable commit messages

fixes

-----

- rewrote dbsession management for atomic operations, and better error handling

- fixed sorting of repo tables

- #326 escape of special html entities in diffs

- normalized user_name => username in api attributes

- fixes #298 ldap created users with mixed case emails created conflicts 

  on saving a form

- fixes issue when owner of a repo couldn't revoke permissions for users 

  and groups

                    username=user.username,

                    firstname=user.name,

                    lastname=user.lastname,

                    email=user.email,

                    active=user.active,

                    admin=user.admin,

                    ldap=user.ldap_dn

                )

            )

        return result

    @HasPermissionAllDecorator('hg.admin')

        """

        Create new user or updates current one

        :param apiuser:

        :param username:

        :param password:

        :param name:

        :param lastname:

        :param active:

        :param admin:

        :param ldap_dn:

        """

        if User.get_by_username(username):

            raise JSONRPCError("user %s already exist" % username)

        try:

            usr = UserModel().create_or_update(

                username, password, email, firstname,

                lastname, active, admin, ldap_dn

        else:

            raise Exception('Unknown or unsupported platform %s' \

                            % __platform__)

def get_crypt_password(password):

    return RhodeCodeCrypto.hash_string(password)

def check_password(password, hashed):

    return RhodeCodeCrypto.hash_check(password, hashed)

def generate_api_key(str_, salt=None):

    """

    Generates API KEY from given string

    :param str_:

    :param salt:

    """

    if salt is None:

        salt = _RandomNameSequence().next()

    return hashlib.sha1(str_ + salt).hexdigest()

                                          user_attrs):

                    log.info('created new ldap user %s', username)

                Session.commit()

                return True

            except (LdapUsernameError, LdapPasswordError,):

                pass

            except (Exception,):

                log.error(traceback.format_exc())

                pass

    return False

def login_container_auth(username):

    user = User.get_by_username(username)

    if user is None:

        user_attrs = {

            'name': username,

            'lastname': None,

            'email': None,

        }

        user = UserModel().create_for_container_auth(username, user_attrs)

        if not user:

            return None

        log.info('User %s was created by container authentication', username)

    if not user.active:

        return None

    user.update_lastlogin()

    Session.commit()

    log.debug('User %s is now logged in by container authentication',

              user.username)

    return user

def get_container_username(environ, config):

    username = None

    if str2bool(config.get('container_auth_enabled', False)):

        from paste.httpheaders import REMOTE_USER

        username = REMOTE_USER(environ)

    if not username and str2bool(config.get('proxypass_auth_enabled', False)):

        username = environ.get('HTTP_X_FORWARDED_USER')

    if username:

        # Removing realm and domain from username

        username = username.partition('@')[0]

        username = username.rpartition('\\')[2]

        log.debug('Received username %s from container', username)

    return username

class  AuthUser(object):

    """

    A simple object that handles all attributes of user in RhodeCode

    It does lookup based on API key,given user, or user present in session

    Then it fills all required information for such user. It also checks if

    anonymous access is enabled and if so, it returns default user as logged

    in

    """

    def __init__(self, user_id=None, api_key=None, username=None):

        self.user_id = user_id

        self.api_key = None

        self.username = username

        self.name = ''

        self.lastname = ''

        self.email = ''

        self.is_authenticated = False

        self.admin = False

        self.permissions = {}

        self._api_key = api_key

        self.propagate_data()

    def propagate_data(self):

        user_model = UserModel()

        self.anonymous_user = User.get_by_username('default', cache=True)

        is_user_loaded = False

        # try go get user by api key

        if self._api_key and self._api_key != self.anonymous_user.api_key:

            log.debug('Auth User lookup by API KEY %s', self._api_key)

            is_user_loaded = user_model.fill_data(self, api_key=self._api_key)

        # lookup by userid

        elif (self.user_id is not None and

                self.is_authenticated = False

        if not self.username:

            self.username = 'None'

        log.debug('Auth User is now %s', self)

        user_model.fill_perms(self)

    @property

    def is_admin(self):

        return self.admin

    def __repr__(self):

        return "<AuthUser('id:%s:%s|%s')>" % (self.user_id, self.username,

                                              self.is_authenticated)

    def set_authenticated(self, authenticated=True):

        if self.user_id != self.anonymous_user.user_id:

            self.is_authenticated = authenticated

    def get_cookie_store(self):

                'user_id': self.user_id,

    @classmethod

    def from_cookie_store(cls, cookie_store):

        user_id = cookie_store.get('user_id')

        username = cookie_store.get('username')

        api_key = cookie_store.get('api_key')

        return AuthUser(user_id, api_key, username)

def set_available_permissions(config):

    """

    This function will propagate pylons globals with all available defined

    permission given in db. We don't want to check each time from db for new

    permissions since adding a new permission also requires application restart

    ie. to decorate new views with the newly created permission

    :param config: current pylons config instance

    """

    log.info('getting information about all available permissions')

    try:

        sa = meta.Session

        all_perms = sa.query(Permission).all()

        pass

    finally:

        meta.Session.remove()

    config['available_permissions'] = [x.permission_name for x in all_perms]

#==============================================================================

# CHECK DECORATORS

#==============================================================================

class LoginRequired(object):

    """

    def email(self):

        return self._email

    @email.setter

    def email(self, val):

        self._email = val.lower() if val else None

    @property

    def full_name(self):

        return '%s %s' % (self.name, self.lastname)

    @property

    def full_contact(self):

        return '%s %s <%s>' % (self.name, self.lastname, self.email)

    @property

    def short_contact(self):

        return '%s %s' % (self.name, self.lastname)

    @property

    def is_admin(self):

        return self.admin

    def __repr__(self):

        if cache:

            q = q.options(FromCache("sql_cache_short",

                                    "get_api_key_%s" % email))

        return q.scalar()

    def update_lastlogin(self):

        """Update user lastlogin"""

        self.last_login = datetime.datetime.now()

        Session.add(self)

        log.debug('updated user %s lastlogin', self.username)

    def __json__(self):

class UserLog(Base, BaseModel):

    __tablename__ = 'user_logs'

    __table_args__ = {'extend_existing': True}

    user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)

    repository_name = Column("repository_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    user_ip = Column("user_ip", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action = Column("action", UnicodeText(length=1200000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)

log = logging.getLogger(__name__)

#this is needed to translate the messages using _() in validators

class State_obj(object):

    _ = staticmethod(_)

#==============================================================================

# VALIDATORS

#==============================================================================

class ValidAuthToken(formencode.validators.FancyValidator):

    def validate_python(self, value, state):

        if value != authentication_token():

def ValidUsername(edit, old_data):

    class _ValidUsername(formencode.validators.FancyValidator):

        def validate_python(self, value, state):

            if value in ['default', 'new_user']:

                raise formencode.Invalid(_('Invalid username'), value, state)

            #check if user is unique

            old_un = None

            if edit:

                old_un = User.get(old_data.get('user_id')).username

            if old_un != value or not edit:

                if User.get_by_username(value, case_insensitive=True):

                    raise formencode.Invalid(_('This username already '

                                               'exists') , value, state)

            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:

    return _ValidUsername

def ValidUsersGroup(edit, old_data):

    class _ValidUsersGroup(formencode.validators.FancyValidator):

        def validate_python(self, value, state):

            if value in ['default']:

                raise formencode.Invalid(_('Invalid group name'), value, state)

            #check if group is unique

            old_ugname = None

            if edit:

                old_ugname = UsersGroup.get(

                            old_data.get('users_group_id')).users_group_name

            if old_ugname != value or not edit:

                if UsersGroup.get_by_group_name(value, cache=False,

                                               case_insensitive=True):

                    raise formencode.Invalid(_('This users group '

                                             state)

            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:

    return _ValidUsersGroup

def ValidReposGroup(edit, old_data):

    class _ValidReposGroup(formencode.validators.FancyValidator):

        def validate_python(self, value, state):

            # TODO WRITE VALIDATIONS

            group_name = value.get('group_name')

            group_parent_id = value.get('group_parent_id')

                        'group_name': _('Repository with this name already exists')

                    }

                    raise formencode.Invalid('', value, state,

                                             error_dict=e_dict)

    return _ValidReposGroup

class ValidPassword(formencode.validators.FancyValidator):

    def to_python(self, value, state):

class ValidPasswordsMatch(formencode.validators.FancyValidator):

    def validate_python(self, value, state):

        pass_val = value.get('password') or value.get('new_password')

        if pass_val != value['password_confirmation']:

            e_dict = {'password_confirmation':

                   _('Passwords do not match')}

            raise formencode.Invalid('', value, state, error_dict=e_dict)

class ValidAuth(formencode.validators.FancyValidator):

    messages = {

        'invalid_password':_('invalid password'),

        'invalid_login':_('invalid user name'),

        'disabled_account':_('Your account is disabled')

    }

    # error mapping

    def validate_python(self, value, state):

        password = value['password']

        username = value['username']

        user = User.get_by_username(username)

        if authenticate(username, password):

            return value

        else:

            if user and user.active is False:

                log.warning('user %s is disabled', username)

            else:

                log.warning('user %s not authenticated', username)

class ValidRepoUser(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        try:

            User.query().filter(User.active == True)\

                .filter(User.username == value).one()

        except Exception:

            raise formencode.Invalid(_('This username is not valid'),

                                     value, state)

        return value

def ValidRepoName(edit, old_data):

    class _ValidRepoName(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            repo_name = value.get('repo_name')

            slug = repo_name_slug(repo_name)

            if slug in [ADMIN_PREFIX, '']:

                e_dict = {'repo_name': _('This repository name is disallowed')}

                raise formencode.Invalid('', value, state, error_dict=e_dict)

            if value.get('repo_group'):

                gr = RepoGroup.get(value.get('repo_group'))

                group_path = gr.full_path

                # value needs to be aware of group name in order to check

                # db key This is an actual just the name to store in the

                # database

                repo_name_full = group_path + RepoGroup.url_sep() + repo_name

            else:

                group_path = ''

                repo_name_full = repo_name

            value['repo_name_full'] = repo_name_full

            rename = old_data.get('repo_name') != repo_name_full

            create = not edit

            if  rename or create:

                if group_path != '':

                    if Repository.get_by_repo_name(repo_name_full):

                        raise formencode.Invalid('', value, state,

                                                 error_dict=e_dict)

                elif RepoGroup.get_by_group_name(repo_name_full):

                        raise formencode.Invalid('', value, state,

                                                 error_dict=e_dict)

                elif Repository.get_by_repo_name(repo_name_full):

                                                'already exists')}

                        raise formencode.Invalid('', value, state,

                                                 error_dict=e_dict)

            return value

    return _ValidRepoName

def ValidForkName(*args, **kwargs):

    return ValidRepoName(*args, **kwargs)

def ValidCloneUri():

    from mercurial.httprepo import httprepository, httpsrepository

    from rhodecode.lib.utils import make_ui

    class _ValidCloneUri(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            if not value:

                pass

            elif value.startswith('https'):

                try:

                    httpsrepository(make_ui('db'), value).capabilities

                    log.error(traceback.format_exc())

                    raise formencode.Invalid(_('invalid clone url'), value,

                                             state)

            elif value.startswith('http'):

                try:

                    httprepository(make_ui('db'), value).capabilities

                    log.error(traceback.format_exc())

                    raise formencode.Invalid(_('invalid clone url'), value,

                                             state)

            else:

                raise formencode.Invalid(_('Invalid clone url, provide a '

                                           'valid clone http\s url'), value,

                                         state)

            return value

    return _ValidCloneUri

    class _ValidForkType(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            if old_data['repo_type'] != value:

                raise formencode.Invalid(_('Fork have to be the same '

                                           'type as original'), value, state)

            return value

    return _ValidForkType

class ValidPerms(formencode.validators.FancyValidator):

                                         ' is not valid')}

    def to_python(self, value, state):

        perms_update = []

        perms_new = []

        #build a list of permission to update and new permission to create

        for k, v in value.items():

            #means new added member to permissions

            if k.startswith('perm_new_member'):

                new_perm = value.get('perm_new_member', False)

                new_member = value.get('perm_new_member_name', False)

                new_type = value.get('perm_new_member_type')

                if new_member and new_perm:

                    if (new_member, new_perm, new_type) not in perms_new:

                        perms_new.append((new_member, new_perm, new_type))

            elif k.startswith('u_perm_') or k.startswith('g_perm_'):

                member = k[7:]

                if member == 'default':

                    if value['private']:

                        #set none for default when updating to private repo

                        v = 'repository.none'

                perms_update.append((member, v, t))

        value['perms_updates'] = perms_update

        value['perms_new'] = perms_new

        #update permissions

        for k, v, t in perms_new:

            try:

                if t is 'user':

                    self.user_db = User.query()\

                        .filter(User.active == True)\

                        .filter(User.username == k).one()

                if t is 'users_group':

                    self.user_db = UsersGroup.query()\

                        .filter(UsersGroup.users_group_active == True)\

                        .filter(UsersGroup.users_group_name == k).one()

            except Exception:

                msg = self.message('perm_new_member_name',

                                     state=State_obj)

        return value

class ValidSettings(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        # settings  form can't edit user

            del['value']['user']

        return value

class ValidPath(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        if not os.path.isdir(value):

            msg = _('This is not a valid path')

            raise formencode.Invalid(msg, value, state,

        return value

def UniqSystemEmail(old_data):

    class _UniqSystemEmail(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            value = value.lower()

                user = User.get_by_email(value, case_insensitive=True)

                if user:

                    raise formencode.Invalid(

            return value

    return _UniqSystemEmail

class ValidSystemEmail(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        value = value.lower()

        user = User.get_by_email(value, case_insensitive=True)

        if  user is None:

        return value

class LdapLibValidator(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        try:

            import ldap

        except ImportError:

            raise LdapImportError

        return value

class AttrLoginValidator(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        if not value or not isinstance(value, (str, unicode)):

        return value

#==============================================================================

# FORMS

#==============================================================================

class LoginForm(formencode.Schema):

    allow_extra_fields = True

    filter_extra_fields = True

    username = UnicodeString(