class AddUser(grok.AddForm):
grok.context(LDAPApp)
grok.name('adduser')
grok.require(u'gum.Add')
template = grok.PageTemplateFile('gum_edit_form.pt')
form_fields = core_user_fields()
form_fields = form_fields.select(
'cn',
'sn',
'givenName',
'__name__',
'email',
'telephoneNumber',
'description',
'o',
)
label = "Add User"
@grok.action('Add User entry')
def add(self, **data):
users = self.context['users']
__name__ = data['__name__']
del data['__name__']
user = User(__name__, container=users, **data)
user.principal_id = self.request.principal.id # XXX oh the hackery!!!
notify(ObjectCreatedEvent(user))
user.save()
self.redirect(self.url(users[__name__]))
class GroupEdit(grok.EditForm):
grok.context(Group)
grok.name('editgroup')
grok.require(u'gum.EditGroup')
template = grok.PageTemplateFile('gum_edit_form.pt')
label = 'Edit Group'
form_fields = grok.AutoFields(Group).omit('dn',)
form_fields['uids'].custom_widget = AjaxUserChooserWidget
@grok.action('Save Changes')
def edit(self, **data):
# XXX validation hack
# need to improve the validation and the UI experience
app = grok.getApplication()
unique_uids = {}
for uid in data['uids']:
unique_uids[uid] = None
try:
for uid in unique_uids.keys():
app['users'][uid]
except KeyError:
pass
# return "Uid %s does not exist.\nYou supplied the User Ids %s." % (uid, data['uids'])
self.context.principal_id = self.request.principal.id # XXX oh the hackery!!!
self.applyData(self.context, **data) # sends grok.ObjectModifedEvent
self.context.save()
self.redirect(self.url(self.context))
class AddGroup(grok.AddForm):
grok.context(LDAPApp)
grok.name('addgroup')
grok.require(u'gum.Add')
template = grok.PageTemplateFile('gum_edit_form.pt')
form_fields = grok.AutoFields(Group).omit('dn', 'title')
label = "Add Group"
@grok.action(
'Add Group entry',
validator=check_for_whitespace,
)
def add(self, **data):
gid = data['cn']
groups = self.context['groups']
group = Group(
gid,
groups,
description=data['description'],
uids=data['uids'],
exists_in_ldap=False,
)
group.principal_id = self.request.principal.id # XXX oh the hackery!!!
notify(ObjectCreatedEvent(group))
group.save()
self.redirect(self.url(group))
class Join(grok.AddForm, Master):
"""
User registration form
"""
form_fields = grok.AutoFields(IMember)
label = _(u'Member registration')
template = grok.PageTemplateFile('form.pt')
@grok.action('Save')
def save(self, **data):
"""
Create a Member and grant it the ViewMemberListing permission.
"""
login = data['login']
members = self.context['members']
member = Member(**data)
try:
# if we can already fetch a member object based on the requested
# login id, then we create a validation exception and assign it
# to the login field
members[login]
msg = _(u'Login name taken. Please choose a different one.')
self.widgets['login']._error = ValidationError(msg)
self.form_reset = False
except KeyError:
# login id is not taken so we save the member object
# and grant the ViewMemberListing permission to the login id
members[login] = member
permission_mngr = IPrincipalPermissionManager(grok.getSite())
permission_mngr.grantPermissionToPrincipal(
'babylogindemo.ViewMemberListing', 'babylogindemo' + login)
self.redirect(
self.url('login') + '?' + urlencode({'login':login})
)
class EditarUsuario(grok.Form):
grok.context(Usuarios)
grok.require('ct.admin')
form_fields = grok.Fields(IEditarUsuario)
template = grok.PageTemplateFile('app_templates/usuarioform.cpt')
label = "Editar usuario"
def setUpWidgets(self, ignore_request=False):
plugin = component.getUtility(IAuthenticatorPlugin, 'autenticacion')
usuario = plugin.obtenerCuenta(self.request.get('usuario'))
super(EditarUsuario, self).setUpWidgets(ignore_request)
if usuario:
self.widgets['usuario'].extra = "readonly='true'"
self.widgets['usuario'].setRenderedValue(usuario.usuario)
self.widgets['nombre_real'].setRenderedValue(usuario.nombre_real)
self.widgets['rol'].setRenderedValue(usuario.rol)
self.widgets['seccion'].setRenderedValue(usuario.seccion)
@grok.action('Guardar cambios')
def handle_edit(self, **data):
plugin = component.getUtility(IAuthenticatorPlugin, 'autenticacion')
usuario = plugin.obtenerCuenta(self.request.form.get('form.usuario'))
password = self.request.form.get('form.password')
if password:
usuario.asignarPassword(password)
usuario.nombre_real = self.request.form.get('form.nombre_real')
usuario.seccion = self.request.form.get('form.seccion')
usuario.rol = self.request.form.get('form.rol')
self.flash(u'Cambios guardados.', type=u'message')
self.redirect(self.url(self.context))
@grok.action('Cancelar - no funca')
def handle_cancel(self, ignore_request=True):
self.redirect(self.url(self.context))
class EditUser(grok.EditForm):
grok.context(User)
grok.name('edituser')
grok.require(u'gum.Edit')
template = grok.PageTemplateFile('gum_edit_form.pt')
@property
def form_fields(self):
# this is a property because class attributes are computed
# before components which provide schema extensions are registered
form_fields = core_user_fields()
# munge roomNumber and street into officeLocation
form_fields = form_fields.omit('roomNumber', 'street', 'dn')
form_fields += FormFields(IUser['officeLocation'])
# __name__ should not be edited after an account has been created!
# (although sometimes a typo is made in account creation, so perhaps
# a special form or UI to handle this use-case maybe? say if the
# account is less than 5 minutes old ...)
form_fields['__name__'].for_display = True
extra_fields = FormFields(*additional_user_fields())
# XXX we lie about IUserSchemaExtensions being IUser objects to
# get around FormFields behaviour of adapter = interface(context)
# a better fix might be refacter the IUser interfaces in some
# manner ...
for f in extra_fields:
f.interface = IUser
form_fields += extra_fields
# limit fields which users without the Admin role can edit
# erm, this mess could be pushed into a custom IPrincipalRoleMap implementation
is_admin = False
uname = self.request.principal.id.split('.')[-1]
app = grok.getApplication()
if uname in app['groups'][app.ldap_admin_group].uids:
is_admin = True
for f in form_fields:
admin_only = getattr(f.field, 'ldap_admin_only', False)
if not is_admin and admin_only:
f.for_display = True
return form_fields
label = "Edit User"
@grok.action('Save Changes')
def edit(self, **data):
# handle password changes seperately
if data['userPassword']:
self.context.changePassword(data['userPassword'],
data['userPassword'])
# TO-DO oh the hackery!!!
self.context.principal_id = self.request.principal.id
self.applyData(self.context, **data)
self.context.save()
self.redirect(self.url(self.context))
class TabMenu(menu.Tab, grok.ViewletManager):
grok.baseclass()
template = grok.PageTemplateFile('templates/tab.pt')
def render(self):
"""Return the template with the option 'menus'"""
if not self.viewlets:
return u''
return self.template.render(self)
def render(self):
if self.help_rst:
try:
print self.help_rst
template = grok.PageTemplateFile(self.help_rst)
renderer = ReStructuredTextToHTMLRenderer(
template.render(self), None)
return renderer.render()
except ValueError, e:
pass
class OfficeLocationEdit(grok.EditForm):
"Form to edit an Organization"
grok.context(OfficeLocation)
grok.name('editofficelocation')
grok.require(u'gum.Edit')
template = grok.PageTemplateFile('gum_edit_form.pt')
label = 'Edit Office Location'
form_fields = grok.AutoFields(OfficeLocation)
@grok.action('Save changes')
def edit(self, **data):
self.applyData(self.context, **data)
self.redirect(self.url(self.context.__parent__))
class OfficeLocationAdd(grok.AddForm):
grok.context(Organization)
grok.name('addofficelocation')
grok.require(u'gum.Add')
template = grok.PageTemplateFile('gum_edit_form.pt')
form_fields = grok.AutoFields(OfficeLocation)
label = "Add Office Location"
@grok.action('Add Office Location')
def add(self, **data):
officelocation = OfficeLocation(**data)
name = INameChooser(self.context).chooseName(u'', officelocation)
self.context[name] = officelocation
self.redirect(self.url(self.context))
class EditSmartSearch(grok.EditForm):
grok.context(SmartSearch)
grok.name('editsmart')
grok.require(u'gum.Edit')
template = grok.PageTemplateFile('gum_edit_form.pt')
form_fields = grok.AutoFields(SmartSearch)
label = "Edit Smart Search"
@grok.action('Save Changes')
def edit(self, **data):
# TO-DO oh the hackery!!!
self.context.principal_id = self.request.principal.id
self.applyData(self.context, **data) # sends grok.ObjectModifiedEvent
self.redirect(self.url(self.context))
class OrganizationEdit(grok.EditForm):
"Form to edit an Organization"
grok.context(Organization)
grok.name('editorg')
grok.require(u'gum.Edit')
template = grok.PageTemplateFile('gum_edit_form.pt')
label = 'Edit Organization'
form_fields = grok.AutoFields(Organization)
form_fields = form_fields.select('title', 'description', 'orgunitTypes',
'employeeTypes')
@grok.action('Save changes')
def edit(self, **data):
self.applyData(self.context, **data)
self.redirect(self.url(self.context))
class AddSmartSearch(grok.AddForm):
grok.context(SmartSearches)
grok.name('addsmart')
grok.require(u'gum.Add')
template = grok.PageTemplateFile('gum_edit_form.pt')
form_fields = grok.Fields(id=schema.TextLine(title=u"id"))
form_fields += grok.AutoFields(SmartSearch)
label = "Add Smart Search"
@grok.action('Add Smart Search')
def add(self, id, **data):
smrt = SmartSearch(id, **data)
smrt.principal_id = self.request.principal.id # XXX oh the hackery!!!
self.context[id] = smrt
event.notify(ObjectCreatedEvent(smrt))
self.redirect(self.url(self.context[id]))
class CMSForm(object):
grok.require('asm.cms.EditContent')
grok.layer(asm.cmsui.interfaces.ICMSSkin)
template = grok.PageTemplateFile(os.path.join("templates", "form.pt"))
def __init__(self, context, request):
super(CMSForm, self).__init__(context, request)
self.group_info = {}
def setUpWidgets(self, ignore_request=False):
super(CMSForm, self).setUpWidgets(ignore_request)
self.grouped_widgets = {}
self.main_widgets = []
for widget in self.widgets:
group = getattr(self.form_fields[widget.context.__name__],
'location', None)
if group is None:
self.main_widgets.append(widget)
else:
group = self.grouped_widgets.setdefault(group, [])
group.append(widget)
class Join(grok.AddForm, Master):
"""
User registration form.
"""
form_fields = grok.AutoFields(IInternalPrincipal)
# use our customized widgets
form_fields['title'].custom_widget = FullNameWidget
form_fields['passwordManagerName'].custom_widget = PasswordManagerChoices
label = _(u'User registration')
template = grok.PageTemplateFile('form.pt')
@grok.action('Save')
def save(self, **data):
'''
Create an InternalPrincipal with the user data.
This method also grants the ViewMemberListing permission to the user.
'''
login = data['login']
pau = getUtility(IAuthentication)
principals = pau['principals']
# create an instance of InternalPrincipal
principal = InternalPrincipal(**data)
try:
principals[login] = principal
except DuplicateIDError:
# create a validation exception and assign it to the login field
msg = _(u'Login name taken. Please choose a different one.')
self.widgets['login']._error = ValidationError(msg)
self.form_reset = False # preserve the values in the fields
else:
# grant the user permission to view the member listing
permission_mngr = IPrincipalPermissionManager(grok.getSite())
permission_mngr.grantPermissionToPrincipal(
'plainlogindemo.ViewMemberListing', principals.prefix + login)
self.redirect(
self.url('login') + '?' + urlencode({'login': login}))
class Join(grok.AddForm, Master):
"""
User registration form.
"""
form_fields = grok.AutoFields(IInternalPrincipal)
form_fields['passwordManagerName'].custom_widget = MySelectWidget
form_fields['title'].custom_widget = NameTextWidget
form_fields['description'].field = EmailField(__name__='description',
title=u'E-Mail address')
label = _(u'User registration')
template = grok.PageTemplateFile('form.pt')
@grok.action('Save')
def save(self, **data):
'''
Create an InternalPrincipal with the user data.
This method also grants the ViewMemberListing permission to the user.
'''
login = data['login']
pau = getUtility(IAuthentication)
principals = pau['principals']
# XXX: the login name must be unique; need better handling of this
if login in principals:
msg = _(u'Login name taken. Please choose a different one.')
self.widgets['login']._error = ValidationError(msg)
self.form_reset = False
else:
# create an instance of InternalPrincipal
principal = InternalPrincipal(passwordManagerName='SHA1', **data)
principals[login] = principal
# grant the user permission to view the member listing
permission_mngr = IPrincipalPermissionManager(grok.getSite())
permission_mngr.grantPermissionToPrincipal(
'plainlogindemo.ViewMemberListing', principals.prefix + login)
self.redirect(
self.url('login') + '?' + urlencode({'login': login}))
class AgregarUsuario(grok.Form):
grok.context(Usuarios)
grok.require('ct.admin')
label = "Agregar usuario"
form_fields = grok.Fields(IAgregarUsuario)
template = grok.PageTemplateFile('app_templates/usuarioform.cpt')
error_color = "red"
@grok.action('Registrar')
def handle_add(self, **data):
plugin_auth = component.getUtility(IAuthenticatorPlugin,
'autenticacion')
error = plugin_auth.agregarUsuario(data['usuario'], data['password'],
data['confirmar_password'],
data['nombre_real'], data['rol'],
data['seccion'])
if error:
self.status = u'Imposible registrar'
self.errors += (Invalid(error),)
self.form_reset = False
return
self.flash(u'Usuario agregado.', type=u'message')
self.redirect(self.url(self.context))
class AddOrganization(grok.AddForm):
grok.context(Organizations)
grok.name('addorg')
grok.require(u'gum.Add')
template = grok.PageTemplateFile('gum_edit_form.pt')
form_fields = grok.AutoFields(Organization)
form_fields = form_fields.select(
'title',
'id',
'description',
'employeeTypes',
'orgunitTypes',
)
label = "Add Organization"
@grok.action('Add Organization')
def add(self, **data):
orgid = data['id']
org = Organization(**data)
self.context[orgid] = org
self.redirect(self.url(self.context[orgid]))
def findFilesystem(self, module_info):
template_dir_name = module_info.getAnnotation(
'grok.templatedir', module_info.name + '_templates')
template_dir = module_info.getResourcePath(template_dir_name)
if not os.path.isdir(template_dir):
return
for template_file in os.listdir(template_dir):
if template_file.startswith('.') or template_file.endswith('~'):
continue
if not template_file.endswith('.pt'):
# Warning when importing files. This should be
# allowed because people may be using editors that generate
# '.bak' files and such.
warnings.warn(
"File '%s' has an unrecognized extension in "
"directory '%s'" % (template_file, template_dir),
UserWarning, 2)
continue
template_name = template_file[:-3] # cut off .pt
template = grok.PageTemplateFile(template_file, template_dir)
template_path = os.path.join(template_dir, template_file)
template._annotateGrokInfo(template_name, template_path)
inline_template = self.get(template_name)
if inline_template:
raise GrokError(
"Conflicting templates found for name '%s' "
"in module %r, both inline and in template "
"directory '%s'." %
(template_name, module_info.getModule(), template_dir),
inline_template)
self.register(template_name, template)
def edit_form_template():
"""Return a Page Template suitable for usage in GUM Form Views"""
return grok.PageTemplateFile('gum_edit_form.pt')
View with an associated PageTemplate that is referred to using
``grok.template``:
>>> manfred = Mammoth()
>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest()
>>> from zope import component
>>> view = component.getMultiAdapter((manfred, request), name='food')
>>> print view()
<html>
<body>
ME GROK EAT MAMMOTH!
</body>
</html>
"""
import grok
import os.path
class Mammoth(grok.Model):
pass
class Food(grok.View):
pass
food = grok.PageTemplateFile(os.path.join('templatedirectoryname', 'food.pt'))
class Feedback(asm.cmsui.form.Form):
grok.require('zope.Public')
grok.layer(ISkin)
grok.context(asm.cms.homepage.Homepage)
title = u"Feedback"
form_fields = grok.AutoFields(IFeedbackForm)
form_fields['page'].custom_widget = get_specific_width_text_widget(70)
form_fields['name'].custom_widget = get_specific_width_text_widget(40)
form_fields['email'].custom_widget = get_specific_width_text_widget(40)
# This field is not visible for normal browser users.
form_fields += grok.Fields(honeypot=zope.schema.TextLine(
title=u'Honeypot',
description=u"You should not see this field. Do not fill it.",
required=False))
form_fields['honeypot'].custom_widget = HoneyPotWidget
template = grok.PageTemplateFile(os.path.join("templates", "form.pt"))
prefix = ''
mail_template = u'''Assembly Archive feedback.
From: %(name)s <%(email)s>
Page: %(page)s <%(root)s/%(page)s>
---- feedback starts ----
%(message)s
---- feedback ends ----
'''
smtp_host = "mail.assembly.org"
target_address = "web-dev<>assembly.org".replace("<>", "@")
@grok.action(u'Send feedback')
def send(self, message, page=None, name=None, email=None, honeypot=None):
# Detect if a spambot has just filled all form fields.
if honeypot is not None:
self.redirect(self.url('feedback-accepted-honeypot'))
return
page = page or u""
name = name or u"UNKNOWN"
email = email or u"EMPTY-EMAIL"
message_body = self.mail_template % dict(
message=message,
page=page,
name=name,
email=email,
root=self.application_url(),
)
message = email_message.Message()
message.set_payload(message_body.encode('utf-8'))
subject_header = email_header.Header(
(u'Assembly Archive feedback about "%s"' % page).encode('utf-8'),
'utf-8')
message['Subject'] = subject_header
message['To'] = self.target_address
from_header = email_header.Header(
(u'%s <%s>' % (name, email)).encode('utf-8'), 'utf-8')
message['From'] = from_header
email_encoders.encode_quopri(message)
message.set_charset('utf-8')
message_str = message.as_string()
smtp = smtplib.SMTP(self.smtp_host)
smtp.sendmail(self.target_address, [self.target_address], message_str)
self.flash(u'Your feedback was accepted.')
self.redirect(self.url('feedback-accepted'))
class Edit(grok.EditForm):
"Form to edit GUM global configuration"
grok.context(LDAPApp)
grok.name('edit')
grok.require('zope.Manager')
template = grok.PageTemplateFile('gum_edit_form.pt')
@grok.action('Save changes')
def edit(self, **data):
gumldapda = zope.component.queryUtility(IManageableLDAPAdapter,
'gumldapda')
auth = zope.component.queryUtility(IAuthenticatorPlugin,
'ldap-authenticator')
# update the LDAP Adapter
gumldapda.host = data['ldap_host']
gumldapda.port = data['ldap_port']
gumldapda.useSSL = False
gumldapda.bindDN = data['ldap_login']
gumldapda.bindPassword = data['ldap_password']
# update the LDAP Authentication plugin
auth.adapterName = 'gumldapda'
auth.searchBase = data['ldap_user_search_base']
auth.searchScope = 'one'
auth.groupsSearchBase = data['ldap_group_search_base']
auth.groupsSearchScope = 'one'
auth.loginAttribute = 'uid'
auth.principalIdPrefix = u'ldap.'
auth.idAttribute = 'uid'
auth.titleAttribute = 'sn'
auth.groupsAttribute = 'ou'
auth.groupIdAttribute = 'cn'
# register the creds and auth plug-ins with the PAU
pau = zope.component.queryUtility(IAuthentication)
pau.authenticatorPlugins = ('ldap-authenticator', )
pau.prefix = u'gum.'
# update the app
self.context.ldap_admin_group = data['ldap_admin_group']
self.context.ldap_sysadmin_group = data['ldap_sysadmin_group']
self.context.ldap_view_group = data['ldap_view_group']
# update the session settings
self.context.login_url = data['login_url']
self.context.shared_secret = data['shared_secret']
self.context.cookie_name = data['cookie_name']
self.context.enable_mod_auth_tkt = data['enable_mod_auth_tkt']
cookie_manager = zope.component.getUtility(
zope.session.interfaces.IClientIdManager)
if data['enable_mod_auth_tkt']:
cookie_manager.thirdparty = True
cookie_manager.secret = data['shared_secret']
cookie_credentials = zope.component.getUtility(
ICredentialsPlugin,
'mod_auth_tkt',
)
cookie_credentials.cookie_name = data['cookie_name']
pau.credentialsPlugins = (
'mod_auth_tkt',
'gum-creds',
)
pau.authenticatorPlugins = (
'tkt-auth',
'ldap-authenticator',
)
else:
cookie_manager.thirdparty = False
cookie_credentials = zope.component.getUtility(
ICredentialsPlugin,
'gum-creds',
)
cookie_credentials.cookie_name = data['cookie_name']
pau.credentialsPlugins = ('gum-creds', )
pau.authenticatorPlugins = ('ldap-authenticator', )
self.redirect(self.url(self.context))