args :    {

                "username" :  "<username>",

                "password" :  "<password>",

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

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

                "ldap_dn" :   "<ldap_dn> = None"

  based on user defined regular expression

- added linking of changesets in commit messages  

- new compact changelog with expandable commit messages

fixes

-----

        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:

def check_password(password, hashed):

    return RhodeCodeCrypto.hash_check(password, hashed)

def generate_api_key(str_, salt=None):

    """

    Generates API KEY from given string

                pass

    return False

def login_container_auth(username):

    user = User.get_by_username(username)

    if user is None:

              user.username)

    return user

def get_container_username(environ, config):

    username = None

    return username

class  AuthUser(object):

    """

    A simple object that handles all attributes of user in RhodeCode

        self.permissions = {}

        self._api_key = api_key

        self.propagate_data()

    def propagate_data(self):

        user_model = UserModel()

    def is_admin(self):

        return self.admin

    def __repr__(self):

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

                                              self.is_authenticated)

            self.is_authenticated = authenticated

    def get_cookie_store(self):

                'user_id': self.user_id,

    @classmethod

    def from_cookie_store(cls, cookie_store):

        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

    try:

        sa = meta.Session

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

        pass

    finally:

        meta.Session.remove()

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

    @property

    def full_contact(self):

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

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

    def __json__(self):

class UserLog(Base, BaseModel):

# VALIDATORS

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

class ValidAuthToken(formencode.validators.FancyValidator):

    def validate_python(self, value, state):

        if value != authentication_token():

def ValidUsername(edit, old_data):

                                               'exists') , value, state)

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

    return _ValidUsername

                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 to_python(self, value, state):

class ValidPasswordsMatch(formencode.validators.FancyValidator):

    }

    # error mapping

    def validate_python(self, value, state):

        password = value['password']

        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):

                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

                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 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)

            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)

class ValidPerms(formencode.validators.FancyValidator):

                                         ' is not valid')}

    def to_python(self, value, state):

                        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

            except Exception:

                msg = self.message('perm_new_member_name',

                                     state=State_obj)

        return value

    def to_python(self, value, state):

        # settings  form can't edit user

            del['value']['user']

        return value

        if not os.path.isdir(value):

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

            raise formencode.Invalid(msg, value, state,

        return value

    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

        value = value.lower()

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

        if  user is None:

        return value

    def to_python(self, value, state):

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

        return value

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

# FORMS

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

    allow_extra_fields = True

    filter_extra_fields = True

    username = UnicodeString(

    password = UnicodeString(

    remember = StringBoolean(if_missing=False)

                       ValidUsername(edit, old_data))

        if edit:

            new_password = All(UnicodeString(strip=True, min=6, not_empty=False))

            admin = StringBoolean(if_missing=False)

        else:

            password = All(UnicodeString(strip=True, min=6, not_empty=True))

        active = StringBoolean(if_missing=False)

        email = All(Email(not_empty=True), UniqSystemEmail(old_data))

        chained_validators = [ValidPasswordsMatch, ValidPassword]

        password = All(UnicodeString(strip=True, min=6, not_empty=True))

        password_confirmation = All(UnicodeString(strip=True, min=6, not_empty=True))

        active = StringBoolean(if_missing=False)

        email = All(Email(not_empty=True), UniqSystemEmail(old_data))

        chained_validators = [ValidPasswordsMatch, ValidPassword]

    return _RegisterForm

def PasswordResetForm():

    class _PasswordResetForm(formencode.Schema):

        allow_extra_fields = True

        email = All(ValidSystemEmail(), Email(not_empty=True))

    return _PasswordResetForm

def RepoForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),

             repo_groups=[]):

    class _RepoForm(formencode.Schema):

        chained_validators = [ValidRepoName(edit, old_data), ValidPerms]

    return _RepoForm

def RepoForkForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),

                 repo_groups=[]):

    class _RepoForkForm(formencode.Schema):

    return _RepoForkForm

def RepoSettingsForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),

                     repo_groups=[]):

    class _RepoForm(formencode.Schema):

    return _ApplicationSettingsForm

def ApplicationUiSettingsForm():

    class _ApplicationUiSettingsForm(formencode.Schema):

        allow_extra_fields = True

    return _ApplicationUiSettingsForm

def DefaultPermissionsForm(perms_choices, register_choices, create_choices):

    class _DefaultPermissionsForm(formencode.Schema):

        allow_extra_fields = True

            log.error(traceback.format_exc())

            raise

    def create_or_update(self, username, password, email, name, lastname,

                         active=True, admin=False, ldap_dn=None):

        """

            log.error(traceback.format_exc())

            raise

    def create_for_container_auth(self, username, attrs):

        """

        Creates the given user if it's not already in the database

            body = body % (new_user.username, new_user.full_name,

                           new_user.email)

            edit_url = url('edit_user', id=new_user.user_id, qualified=True)

            NotificationModel().create(created_by=new_user, subject=subject,

                                       body=body, recipients=None,

                                       type_=Notification.TYPE_REGISTRATION,

        new.permission = perm

        self.sa.add(new)

    def revoke_perm(self, user, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class '

                    <label for="active">${_('Active')}:</label>

                </div>

                <div class="checkboxes">

                </div>

             </div>

            ${h.end_form()}

        %else:

            <div class="links_left">

                <div class="email">${c.rhodecode_user.email}</div>

                <div class="big_gravatar"><img alt="gravatar" src="${h.gravatar_url(c.rhodecode_user.email,48)}" /></div>

            </div>