def __call__(self): params = self.get_base_params() form, request = None, self.request is_a_post = request.method == 'POST' deleting = request.params.get('user_action', '') == 'delete' if is_a_post and deleting: items = [a[1] for a in request.POST.items() if a[0] == 'delete'] todelete = session.query( apexmodels.AuthUser).filter( apexmodels.AuthUser.id.in_(items) ).all() noecho = [apexmodels.delete_user(i) for i in todelete] session.commit() request.session.flash(_('Items have been deleted'), 'info') action = request.params.get('user_action', '') users = session.query(apexmodels.AuthUser).order_by(apexmodels.AuthUser.login, apexmodels.AuthUser.username, apexmodels.AuthUser.email).all() rdata = [] for u in users: item = { 'id': u.id, 'username': u.username, 'login': u.login, 'email': u.email, 'deletable': True, } rdata.append(item) params['users'] = rdata return render_to_response(self.template, params, request)
def __call__(self): global_auth_settings = [u'auth.allow_anonymous', u'auth.self_registration', u'auth.use_captcha'] global_auth_text_settings = [u'auth.recaptcha_public_key', u'auth.recaptcha_private_key'] request = self.request controls = self.request.POST.items() keys = session.query(r.Registry).filter(r.Registry.name.in_( global_auth_settings) ).all() tkeys = session.query(r.Registry).filter(r.Registry.name.in_( global_auth_text_settings) ).all() items = OrderedDict() authbackend_schema = colander.SchemaNode(colander.Mapping()) struct = {} for i in keys: authbackend_schema.add( colander.SchemaNode(colander.Boolean(), name=i.name.replace('auth.', ''), default=bool_values.get(i.value.lower(), False), missing=None )) for i in tkeys: authbackend_schema.add( colander.SchemaNode(colander.String(), name=i.name.replace('auth.', ''), default=i.value and i.value or '', missing=None )) form = w.Form(request, authbackend_schema, buttons=(_('Send'),), use_ajax=True) if request.method == 'POST': try: struct = form.validate(controls) restart = True for obj in keys + tkeys: ki = obj.name.replace('auth.', '') # store settings in database value = struct.get(ki, False) if obj.value != value: obj.value = value session.commit() restart = True if restart: self.request.registry.notify(RegenerateVelruseConfigEvent( self.request) ) except ValidationFailure, e: pass
def register_default_permissions(session): # authentication settings for k in default_permissions: try: session.query(Permission).filter(Permission.name == k).one() except NoResultFound, e: try: session.add( Permission(name=k, description=default_permissions[k]) ) session.commit() except IntegrityError: session.rollback()
def by_participation(cls, usr): # fiest get user projects res = [] def uniq_append(items): for p in items: if not p.resource in res: res.append(p.resource) uniq_append(session.query(ProjectUserRole).filter_by(user=usr).all()) for g in usr.groups: uniq_append(session.query(ProjectGroupRole).filter_by(group=g).all()) return res
def __call__(self): params = self.get_base_params() form, request = None, self.request is_a_post = request.method == 'POST' adding = request.params.get('__formid__', '') == 'add_group' default_groups = [a[0] for a in apexmodels.get_default_groups( request.registry.settings)] deleting = request.params.get('group_action', '') == 'delete' class GroupSH(colander.MappingSchema): name = colander.SchemaNode( colander.String(), title = _('Group name'), validator = colander.All( v.not_empty_string, v.existing_group, ) ) description = colander.SchemaNode(colander.String(), title=_('Group description'),) add_form = deform.Form( GroupSH(), buttons=(_('Send'),), formid = 'add_group') if is_a_post and deleting: items = [a[1] for a in request.POST.items() if a[0] == 'delete' and not a[1] in default_groups] todelete = session.query( user.Group).filter( se.and_( user.Group.id.in_(items), se.not_(user.Group.name.in_(default_groups)) ) ).all() noecho = [session.delete(i) for i in todelete] session.commit() request.session.flash(_('Items have been deleted'), 'info') if is_a_post and adding: controls = request.POST.items() try: data = add_form.validate(controls) group = session.query( user.Group).filter( user.Group.name == data['name'] ).first() if not group: rl = user.Group(name=data['name'], description=data['description']) session.add(rl) session.commit() request.session.flash(_('Group added: %s' % rl.name, 'info')) params['add_form'] = add_form.render() except Exception, e: params['add_form'] = e.render()
def __call__(self): form, request = None, self.request gurl = "%s@@ajax_groups_list" % ( self.request.resource_url(self.request.context) ) is_a_get = request.method == 'GET' is_a_post = request.method == 'POST' params = self.get_base_params() r_types = {'users':_('Users'), 'groups': _('Groups',)} rid = -666 try: rid = int(request.params.get('userid', '-666')) except: pass usr = None try: usr = session.query( user.User).filter( user.User.id==int(rid)).first() except: pass def existing_user_validator(node, value, column): item, value = None, value.strip() try: item = session.query(apexmodels.AuthUser).filter( getattr(apexmodels.AuthUser, column) == value).first() except Exception, e: raise colander.Invalid(node, _('Unknown Error: %s' % e)) if item is not None: if usr.id != item.id: raise colander.Invalid(node, _('Already exists'))
def existing_user_validator(node, value, column): item, value = None, value.strip() try: item = session.query(apexmodels.AuthUser).filter( getattr(apexmodels.AuthUser, column) == value).first() except Exception, e: raise colander.Invalid(node, _('Unknown Error: %s' % e))
def insert_update_service(name,stype,description,package,classification): """Insert a service in the database as belonging to the local - and only - server of the public project.""" try: svc = session.query(Service).filter_by(name=name, server=public_project.servers[0], project=public_project).first() if not svc: logging.info("service %s new, adding to the server" % name) svc = Service() svc.name = name svc.server = public_project.servers[0] svc.project = public_project session.add(svc) else: logging.info("service %s already here, updating" % name) svc.description = description svc.package = package svc.classification = classification svc.type = stype session.commit() return svc except: session.rollback() raise
def __call__(self): params = self.get_base_params() form, request = None, self.request is_a_post = request.method == 'POST' adding = request.params.get('__formid__', '') == 'add_permission' deleting = request.params.get('permission_action', '') == 'delete' class PermissionSH(colander.MappingSchema): name = colander.SchemaNode( colander.String(), title=_('Permission name'), validator = colander.All( v.not_empty_string, v.existing_group, ) ) description = colander.SchemaNode(colander.String(), title=_('Permission description'),) add_form = deform.Form( PermissionSH(), buttons=(_('Send'),), formid = 'add_permission') if is_a_post and deleting: items = [a[1] for a in request.POST.items() if a[0] == 'delete'] todelete = session.query( auth.Permission).filter( se.and_( auth.Permission.id.in_(items), se.not_(auth.Permission.name.in_(auth.default_permissions.keys())) ) ).all() noecho = [session.delete(i) for i in todelete] session.commit() request.session.flash(_('Items have been deleted'), 'info') if is_a_post and adding: controls = request.POST.items() try: data = add_form.validate(controls) permission = session.query( auth.Permission).filter( auth.Permission.name == data['name'] ).first() if not permission: rl = auth.Permission(name=data['name'], description=data['description']) session.add(rl) session.commit() request.session.flash(_('Permission added: %s' % rl.name, 'info')) params['add_form'] = add_form.render() except Exception, e: params['add_form'] = e.render()
def register_default_roles(session, force=False): # authentication settings if not force: force = not get_registry_key('mobyle2.configured_roles', False) if not force: return for k in default_roles: try: session.query(Role).filter(Role.name == k).one() except NoResultFound, e: try: session.add( Role(name=k, description=default_roles[k]) ) session.commit() except IntegrityError: session.rollback()
def user_created(event): request = event.request user = event.user if not session.query(User).filter_by(id=user.id).all(): newuser = User(base_user=user, status='a') session.add(newuser) session.commit() else: message = _(u'a user with this id %d already exists' % user.id) request.session.flash(message, 'error')
def set_registry_key(key, value): session = DBSession() res = None try: try: res = session.query(Registry).filter(Registry.name == key).one() res.value = value except exc.NoResultFound, e: res = Registry(key, value) session.add(res) session.commit()
def get_registry_key(key, default=notset, as_bool=True): session = DBSession() res = None try: res = session.query(Registry).filter(Registry.name == key).one().value if as_bool: res = asbool(res) except exc.NoResultFound, e: if isinstance(default, NotSet): raise else: res = default
def __call__(self, form, field): session = DBSession() if field.data and isinstance(field.data, basestring): data = field.data.strip().lower() users = session.query( AuthUser).filter( func.lower(AuthUser.email) == data).all() if len(users): self.message = field.gettext( _(u'This email already exists, ' 'please choose another one or ' 'retrieve your identity.')) field.errors[:] = [] raise validators.StopValidation(self.message)
def __call__(self): term = '%(%)s%(s)s%(%)s' % { 's': self.request.params.get('term', '').lower(), '%': '%', } table = userm.Group rows = session.query(table).filter( table.name.ilike(term) ).order_by(table.name) data = [] for row in rows: label = row.name item = ("%s"%row.id, label) if not item in data: data.append(item) return data
def not_existing_validator(node, values, table, label='item'): if isinstance(values, basestring): values = [values] errors = [] for value in values: v = value if isinstance(v, tuple) or isinstance(v, tuple): v = v[0] item, v = None, (isinstance(v, int)) and v or v.strip() if not v: continue try: item = session.query( table).filter(table.id==int(v)).one() except Exception, e: pass if item is not None: continue errors.append(v)
def velruse_config(config): settings = config.registry.settings settings['velruse.openid.store'] = 'mobyle2.core.velruse.get_sqlstore' #settings['velruse.openid.realm'] = settings.get('velruse.openid.realm', 'realm') key = 'velruse.store.' if not key+'url' in settings: key = 'sqlalchemy.' engine = engine_from_config(settings, key) providers = settings.get('velruse.providers', '') initialize_sql(engine) for ab in session.query(AuthenticationBackend).filter( AuthenticationBackend.enabled == True ): t = ab.backend_type if ab.backend_type in ['ldap']: providers += '\n%s' % 'velruse.providers.ldapprovider' url = 'ldap' if ab.use_ssl: url += 's' url += '://%s' % ab.hostname if ab.port: url +=':%s' % ab.port lk = 'velruse.providers.ldapprovider.urls' settings[lk] = settings.get(lk, '')+'\n%s' % url settings['velruse.providers.ldapprovider.basedn'] = ab.ldap_dn if ab.backend_type in ['openid',]: providers += '\n%s' % 'velruse.providers.openidconsumer' if ab.realm: settings['velruse.openid.realm'] = ab.realm if ab.backend_type in ['twitter', 'github', 'google', 'facebook']: providers += '\n%s' % 'velruse.providers.%s' % (t) settings['velruse.%s.consumer_key' % (t)] = ab.username settings['velruse.%s.consumer_secret' % (t)] = ab.password if ab.authorize: if ab.backend_type in ['twitter', 'github', 'google', 'facebook']: settings['velruse.%s.authorize' %(t)] = ab.authorize if ab.backend_type in ['github']: settings['velruse.%s.scope' %(t)] = ab.authorize if ab.backend_type=='facebook': settings['velruse.%s.app_id' %(t)] = ab.username settings['velruse.%s.app_secret' %(t)] = ab.password settings['velruse.providers'] = providers
def __call__(self): term = '%(%)s%(s)s%(%)s' % { 's': self.request.params.get('term', '').lower(), '%': '%', } table = userm.User bu = apexmodels.AuthUser rows = session.query(table).join(bu).filter( se.and_( table.status == 'a', se.or_(bu.username.ilike(term), bu.email.ilike(term), bu.login.ilike(term), ) ) ).order_by(bu.email, bu.username, bu.login).all() data = [] for row in rows: u = row.base_user label = format_user_for_form(u) item = ("%s"%row.id, label) if not item in data: data.append(item) return data
def __call__(self): request = self.request params = self.get_base_params() roles = OrderedDict([(str(ro.id), ro) for ro in session.query(auth.Role ).order_by(auth.Role.name).all()]) permissions = OrderedDict([(str(p.id), p) for p in session.query( auth.Permission ).order_by(auth.Permission.name).all()]) data = OrderedDict() params['data'] = data data['permissions'] = permissions data['roles'] = roles form = construct_schema_acls(request, permissions=permissions, roles=roles) if request.method == 'POST': try: controls = request.POST.items() data = form.validate(controls) perms = [permissions.get(pid, None) for pid in data['roles'] if permissions.get(pid, None)] modified, error = False, False try: for permission in perms: mapping = data['roles'][str(permission.id)] rles = [roles.get(rid, None) for rid in mapping if rid in roles] for role in rles: # maybe unactivate role if not mapping[str(role.id)]: if permission in role.global_permissions: modified = True role.global_permissions.pop( role.global_permissions.index( permission ) ) session.add(role) session.commit() # maybe activate role else: if not permission in role.global_permissions: modified = True role.global_permissions.append(permission) session.add(role) session.commit() except Exception, e: request.session.flash(_('Something goes wrong while saving access parameters: %s')%e, 'error') error = True # sql failure ! try: session.rollback() except: pass if modified: if not error: request.session.flash(_('Access parameters have been saved'), 'info') form = construct_schema_acls(request, permissions=permissions, roles=roles) except ValidationFailure, e: params['form'] = e.render()
def __call__(self): form, request = None, self.request url = "%s@@ajax_users_list" % ( self.request.resource_url(self.request.context) ) gurl = "%s@@ajax_groups_list" % ( self.request.resource_url(self.request.context) ) is_a_get = request.method == 'GET' is_a_post = request.method == 'POST' params = self.get_base_params() r_types = {'users':_('Users'), 'groups': _('Groups',)} rid = -666 try: rid = int(request.params.get('roleid', '-666')) except: pass role = None try: role = session.query( auth.Role).filter(auth.Role.id==int(rid)).first() except: pass params['role'] = role if role is not None: role_users = [] role_groups = [] def reset_default_users_groups(role, users, groups,): for l in users, groups: while len(l) > 0: l.pop() for u in role.global_users: users.append( (u.id, format_user_for_form(u.base_user)) ) for group in role.global_groups: groups.append( (group.id, group.name) ) reset_default_users_groups(role, role_users, role_groups) class UserS(colander.TupleSchema): id = colander.SchemaNode(colander.Int(), missing = '',) label = colander.SchemaNode(colander.String(), missing = '',) class GroupS(colander.TupleSchema): id = colander.SchemaNode(colander.Int(), missing = '',) label = colander.SchemaNode(colander.String(), missing = '',) class GroupSc(colander.SequenceSchema): group = GroupS(name="group", missing=tuple()) class UserSc(colander.SequenceSchema): user = UserS(name="user", missing=tuple()) class Members(colander.MappingSchema): users = UserSc(name="users", title=_('Users'),widget = widget.ChosenSelectWidget(url), default=role_users, validator = v.not_existing_user, missing=tuple(),) groups = GroupSc(name="groups", title=_('Groups'), widget = widget.ChosenSelectWidget(gurl), default=role_groups, validator = v.not_existing_group, missing=tuple(),) class Schema(colander.Schema): roleid = colander.SchemaNode( colander.String(), widget = deform.widget.HiddenWidget(), validator = v.not_existing_role, default = rid, name = 'roleid', title = _('Role'), ) #name = colander.SchemaNode( # colander.String(), # widget = deform.widget.TextInputWidget(size=len('%s'%role.name)), # default = role.name, # name = 'role', # title = _('Role'), #) description = colander.SchemaNode( colander.String(), widget = deform.widget.TextAreaWidget(), default = role.description, missing = '', name = 'desc', title = _('Description'), ) members = Members(name="members") form = widget.Form(request, Schema(title=_('Edit role %s' % role.name), validator=v.role_edit_form_global_validator), buttons=(_('Send'),), formid = 'add_permission') if is_a_get: params['form'] = form.render() if is_a_post: try: modified = False controls = request.POST.items() data = form.validate(controls) role = auth.Role.by_id(data['roleid']) #if not role.name == data['name']: # role.name = data['name'] # form.schema['name'].default = role.name # modified = True if not role.description == data['description']: role.description = data['description'] form.schema['description'].default = role.description modified = True users = [] for uid, label in data['members']['users']: u = user.User.by_id(uid) users.append(u) groups = [] for uid, label in data['members']['groups']: u = user.Group.by_id(uid) groups.append(u) for ilist, olist in ((users, role.global_users), (groups, role.global_groups)): if not ilist: modified = True for item in olist[:]: del olist[olist.index(item)] else: for item in ilist: if not item in olist: modified = True olist.append(item) for item in olist[:]: if not item in ilist: del olist[olist.index(item)] modified = True if modified: session.add(role) try: session.commit() reset_default_users_groups(role, role_users, role_groups) request.session.flash(_('Role modified', 'info')) except Exception, e: try: session.rollback() except: pass request.session.flash( _('Something went wrong' 'while modifying role: %s') % e) params['form'] = form.render() except deform.exception.ValidationFailure, e: params['form'] = e.render()
a.Role).filter( a.Role.name == data['name'] ).first() if not role: rl = a.Role(name=data['name'], description=data['description']) session.add(rl) session.commit() request.session.flash(_('Role added: %s' % rl.name, 'info')) params['add_form'] = add_form.render() except Exception, e: params['add_form'] = e.render() else: params['add_form'] = add_form.render() action = request.params.get('role_action', '') roles = session.query( a.Role).order_by(a.Role.name).all() rdata = [] for role in roles: item = { 'id': role.id, 'name': role.name, 'deletable': not role.name in a.default_roles, 'description':role.description, } rdata.append(item) params['roles'] = rdata return render_to_response(self.template, params, request) class ServersHome(ProjectView): template = '../templates/project/servers_home.pt' def __call__(self):
def existing_validator(node, value, cls, label='item'): item, value = None, value.strip() try: item = session.query(cls).filter(cls.name == value).first() except Exception, e: raise Invalid(node, _('Unknown Error: %s' % e))
group = session.query( user.Group).filter( user.Group.name == data['name'] ).first() if not group: rl = user.Group(name=data['name'], description=data['description']) session.add(rl) session.commit() request.session.flash(_('Group added: %s' % rl.name, 'info')) params['add_form'] = add_form.render() except Exception, e: params['add_form'] = e.render() else: params['add_form'] = add_form.render() action = request.params.get('group_action', '') groups = session.query( user.Group).order_by(user.Group.name).all() rdata = [] for group in groups: item = { 'id': group.id, 'name': group.name, 'deletable': not group.name in default_groups, 'description':group.description, } rdata.append(item) params['groups'] = rdata return render_to_response(self.template, params, request) class ManageRole(Base): template ='../templates/user/user_role.pt'
def by_owner(cls, owner): res = [] prs = session.query(cls).filter_by(owner=owner).all() noecho = [res.append(p) for p in prs if not p in res] return res
def __init__(self, request): Base.__init__(self, request) at = auth.AUTH_BACKENDS.copy() existing_types = [a[0] for a in session.query( auth.AuthenticationBackend.backend_type ).filter( auth.AuthenticationBackend.enabled == True ).group_by( auth.AuthenticationBackend.backend_type).all() ] for item in copy.deepcopy(at): if (item in existing_types) and (item in auth.ONLY_ONE_OF): del at[item] atv = [('', '')] + at.items() class AuthentSchema(colander.MappingSchema): name = colander.SchemaNode(colander.String(), title=_('Name'), validator=v.not_empty_string) description = colander.SchemaNode(colander.String(), title=_('Backend description'),) enabled = colander.SchemaNode(colander.Boolean(), default=True, title=_('Enabled'), description=_('Is this backend enabled ?')) auth_backend = colander.SchemaNode(colander.String(), widget=deform.widget.SelectWidget( **{'values': atv} ), validator=colander.OneOf(at.keys()), title=_('Authentication backend') ) class DBSchema(colander.MappingSchema): host = colander.SchemaNode(colander.String(), description=_('Host')) port = colander.SchemaNode(colander.String(), description=_('Port')) password = colander.SchemaNode(colander.String(), description=_('Password')) user = colander.SchemaNode(colander.String(), description=_('User')) db = colander.SchemaNode(colander.String(), description=_('Database')) class LDAPSchema(colander.MappingSchema): host = colander.SchemaNode(colander.String(), description=_('Host')) port = colander.SchemaNode(colander.String(), description=_('Port')) use_ssl = colander.SchemaNode(colander.Boolean(), description=_('Use SSL?')) #password = colander.SchemaNode(colander.String(), description=_('Password')) dn = colander.SchemaNode(colander.String(), description=_('Base dn mask to connect as in the ' 'form "cn=USERID,ou=people", ' 'ex: "cn=USERID,o=paster,dc=paris,dc=net. ' 'USERID is the placeholder for the login ' 'string the user will input.')) # users = colander.SchemaNode(colander.String(), description=_('LDAP filter to grab users')) # groups = colander.SchemaNode(colander.String(), description=_('LDAP filter to grab groups')) class SimpleOpenidSchema(colander.MappingSchema): key = colander.SchemaNode(colander.String(), description=_('API consumer')) secret = colander.SchemaNode(colander.String(), description=_('API consumer secret')) class OpenidSchema(colander.MappingSchema): realm = colander.SchemaNode(colander.String(), description=_('Openid Realm'), missing=None) class SimpleOauthSchema(SimpleOpenidSchema): authorize = colander.SchemaNode(colander.String(), description=_('API Scope'), missing=None) class FullOauthSchema(SimpleOauthSchema): realm = colander.SchemaNode(colander.String(), description=_('Service Realm'), validator=v.not_empty_string, missing=None) class FileSchema(colander.MappingSchema): passwd_file = colander.SchemaNode(colander.String(), description=_('Full path to the file')) self.sh_map = { 'base': AuthentSchema, 'db': DBSchema, 'facebook': SimpleOauthSchema, 'file': FileSchema, 'github': SimpleOauthSchema, 'google': SimpleOauthSchema, 'ldap': LDAPSchema, 'live': SimpleOauthSchema, 'openid': OpenidSchema, 'twitter': SimpleOauthSchema, 'yahoo': SimpleOpenidSchema, } self.fmap = { 'auth_backend': 'backend_type', 'enabled': 'enabled', 'name': 'name', 'description': 'description', 'authorize': 'authorize', 'key': 'username', 'secret': 'password', 'url': 'realm', 'realm': 'realm', 'db': 'database', 'host': 'hostname', 'port': 'port', 'user': '******', 'dn': 'ldap_dn', 'file': 'file', 'use_ssl': 'use_ssl', 'users': 'ldap_users_filter', 'groups': 'ldap_groups_filter', } request = self.request def global_auth_backend_validator(form, value): pass #if not value['title'].startswith(value['name']): # exc = colander.Invalid(form, 'Title must start with name') # exc['title'] = 'Must start with name %s' % value['name'] # raise exc def auth_schema_afterbind(node, kw): if kw.get('remove_ab'): del node['auth_backend'] self.sh = self.sh_map['base']( validator=global_auth_backend_validator, after_bind=auth_schema_afterbind) ctx = self.request.context # if we are in the context of an auth backend, we cant change the type if isinstance(ctx, auth.AuthenticationBackendResource): self.sh = self.sh.bind(remove_ab=True) self.for_ajax_form = False # maybe we are in an ajax request to solve remaining fields for a particular authtype. at = '' details_added = False if request.method == 'POST': at = request.POST.get('load_auth_backend_details') if at in auth.AUTH_BACKENDS: self.sh['auth_backend'].default = at self.for_ajax_form = True if not at: at = request.POST.get('auth_backend') if at in auth.AUTH_BACKENDS: details_added = True ash = self.sh_map[at](name="auth_backend_infos", title=_('Authentication backend details')) self.sh.add(ash) # if we are in the context of an auth backend, filling edit properties if isinstance(ctx, auth.AuthenticationBackendResource): ab = ctx.ab if not details_added: ash = self.sh_map[ab.backend_type](name="auth_backend_infos", title=_('Authentication backend details')) self.sh.add(ash) keys = {'name': 'name', 'description': 'description', 'backend_type': 'auth_backend', 'enabled': 'enabled'} dkeys = {} if (ab.backend_type == at and at != '') or (at == ''): if ab.backend_type in ['facebook', 'live', 'yahoo', 'twitter', 'openid', 'google', 'github']: dkeys.update({'username': '******', 'password': '******', 'authorize': 'authorize'}) if ab.backend_type in ['file']: dkeys.update({'file': 'file'}) if ab.backend_type in ['openid']: dkeys.update({'realm': 'realm'}) if ab.backend_type in ['ldap']: dkeys.update({'ldap_groups_filter': 'groups', 'ldap_users_filter': 'users', 'ldap_dn': 'dn', 'hostname': 'host', 'port': 'port', #,'password':'******' 'use_ssl': 'use_ssl'}) if ab.backend_type in ['db']: dkeys.update({'hostname': 'host', 'database': 'db', 'password': '******', 'port': 'port', 'username': '******', 'password': '******'}) for k in keys: if k in self.sh: self.sh[keys[k]].default = getattr(ab, k) for k in dkeys: value = getattr(ab, k) if value: self.sh['auth_backend_infos'][dkeys[k]].default = value self.form = w.Form(request, self.sh, buttons=(_('Send'),), formid = 'add_auth_backend')