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

                except Exception, e:

                    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

def ValidForkType(old_data):

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

    messages = {'perm_new_member_name':_('This username or users group name'

                                         ' 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:]

                t = {'u':'user',

                     'g':'users_group'}[k[0]]

                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)

                raise formencode.Invalid(msg, value, state,

                                         error_dict={'perm_new_member_name':msg})

        return value

class ValidSettings(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        # settings  form can't edit user

        if value.has_key('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,

                                     error_dict={'paths_root_path':msg})

        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(

                                    _("This e-mail address is already taken"),

                                    value, state)

            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:

            raise formencode.Invalid(_("This e-mail address doesn't exist.") ,

                                     value, state)

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

            raise formencode.Invalid(_("The LDAP Login attribute of the CN "

                                       "must be specified - this is the name "

                                       "of the attribute that is equivalent "

                                       "to 'username'"),

                                     value, state)

        return value

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

# FORMS

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

class LoginForm(formencode.Schema):

    allow_extra_fields = True

    filter_extra_fields = True

    username = UnicodeString(

                             strip=True,

                             min=1,

                             not_empty=True,

                             messages={

                                'empty':_('Please enter a login'),

                                'tooShort':_('Enter a value %(min)i characters long or more')}

                            )

    password = UnicodeString(

                            strip=True,

                            min=3,

                            not_empty=True,

                            messages={

                                'empty':_('Please enter a password'),

                                'tooShort':_('Enter %(min)i characters or more')}

                                )

    chained_validators = [ValidAuth]

def UserForm(edit=False, old_data={}):

    class _UserForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        username = All(UnicodeString(strip=True, min=1, not_empty=True),

                       ValidUsername(edit, old_data))

        if edit:

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

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

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

        active = StringBoolean(if_missing=False)

        name = UnicodeString(strip=True, min=1, not_empty=True)

        lastname = UnicodeString(strip=True, min=1, not_empty=True)

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

        chained_validators = [ValidPasswordsMatch, ValidPassword]

    return _UserForm

def UsersGroupForm(edit=False, old_data={}, available_members=[]):

    class _UsersGroupForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True