class AddEntryForm(grokstar.form.GrokstarAddForm):
grok.context(Blog)
form_fields = grok.Fields(id=schema.TextLine(title=u"id"))
form_fields += grok.AutoFields(RestructuredTextEntry).omit(
'published', 'updated')
renderedPreview = ''
@grok.action('Preview')
def preview(self, content='', **data):
self.renderedPreview = '<h2>Preview</h2><div class="comment">' + renderRest(
content) + '</div>'
self.form_reset = False
@grok.action('Add draft entry')
def add(self, id, **data):
new_entry = RestructuredTextEntry(**data)
self.context['entries'][id] = new_entry
IWorkflowInfo(new_entry).fireTransition('create')
self.redirect(self.url(self.context))
@grok.action('Add published entry')
def add_published(self, id, **data):
new_entry = RestructuredTextEntry(**data)
self.context['entries'][id] = new_entry
IWorkflowInfo(new_entry).fireTransition('create')
IWorkflowInfo(new_entry).fireTransitionToward(interfaces.PUBLISHED)
self.redirect(self.url(self.context))
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 LoginForm(grok.Form):
grok.context(Interface)
grok.name("login-form")
label = "Login"
prefix = ''
form_fields = grok.Fields(ILoginFormulario)
def setUpWidgets(self, ignore_request=False):
super(LoginForm, self).setUpWidgets(ignore_request)
self.widgets['camefrom'].type = 'hidden'
@grok.action('login')
def handle_login(self, **data):
authenticated = not IUnauthenticatedPrincipal.providedBy(
self.request.principal, )
if authenticated:
camefrom = self.request.form.get('camefrom')
if camefrom:
self.redirect(camefrom, self.url(grok.getSite()))
else:
self.redirect(self.url(grok.getSite()))
self.flash(u'Logueado!', type=u'message')
else:
self.status = u'Autenticación fallida'
self.errors += (Invalid(u'Usuario y/o contraseña invalidos'), )
self.form_reset = False
class Meet(grok.Form):
form_fields = grok.Fields(other=schema.TextLine(
title=u'Mammoth to meet with'))
@grok.action('Meet')
def meet(self, other):
return self.context.name + ' meets ' + other
class Index(grok.EditForm):
grok.context(App)
form_fields = grok.Fields(IForm)
@grok.action("Submit")
def submit(self, engine_name):
self.context.engine_name = engine_name
class Edit(grok.EditForm):
form_fields = grok.Fields(
#XXX why repeat this?
title=schema.TextLine(title=u'Title'))
@grok.action('Save')
def save(self, title):
self.applyChanges(self.context, title=title)
self.redirect(self.url(self.context))
class AddTodoItem(grok.AddForm):
form_fields = grok.Fields(
title = schema.TextLine(title=u'Title')
)
@grok.action('Add')
def add(self,title):
name = title.lower().replace(' ','-')
item = TodoItem(title)
self.context[name] = item
self.redirect(self.url(item))
class ApiKey(grok.EditForm):
grok.context(UserProfile)
form_fields = grok.Fields(IUser).select('gw2_apikey')
grok.require('builder.Authenticated')
def setUpWidgets(self, ignore_request=False):
super(ApiKey, self).setUpWidgets(ignore_request)
self.widgets['gw2_apikey'].displayWidth=68
@grok.action(u'Apply')
def apply(self, **data):
self.applyData(self.context, **data)
self.redirect(self.request.URL)
def POST(self):
validate_proper_contenttype(self.request)
order_data = parse_json(self.body)
order_data = self.coerce_order_data(order_data)
item_list = []
for item_data in order_data['item_list']:
item_data = self.coerce_item_data(item_data)
item = Item()
applyData(item, grok.Fields(IItem), item_data)
item_list.append(item)
order_data['item_list'] = item_list
order = Order()
applyData(order, grok.Fields(IOrder), order_data)
self.context.add(order)
self.response.setHeader('Location', self.url(order))
self.response.setStatus('201')
return ''
class Login(grok.Form):
"""View for the login form
"""
grok.context(Interface)
form_fields = grok.Fields(ILoginForm)
def update(self):
super(Login, self).update()
@grok.action('login')
def handle_login(self, **data):
"""login button and login action
"""
self.redirect(self.request.form.get('camefrom', 'index'))
class UploadSchedule(grok.Form):
grok.context(Schedule)
form_fields = grok.Fields(data=zope.schema.Text(title=u'Data'))
def flash(self, message, level=''):
self.messages.append(message)
@grok.action(u'Upload')
def upload(self, data=None):
if data is None:
return "Give data"
self.messages = []
update_schedule(self, data.encode("utf-8"))
if len(self.messages):
return "\n".join(self.messages)
return "OK"
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 Reload(grok.Form):
"""Reload view.
"""
grok.context(Interface)
grok.implements(IReload)
message = None
form_fields = grok.Fields(IReload)
form_fields['applications'].custom_widget = MultiCheckBoxVocabularyWidget
@grok.action(u'Reload Code', validator=null_validator)
def handle_relaod(self, **kw):
self.code_reload()
@grok.action(u'Reload Code and ZCML')
def handle_relaod(self, **kw):
self.zcml_reload(kw.get('applications', []))
def status(self):
return self.message
def code_reload(self):
reloaded = reload_code()
result = ''
if reloaded:
result += 'Code reloaded:\n\n'
result += '\n'.join(reloaded)
else:
result = 'No code reloaded!'
return result
def zcml_reload(self, applications):
reloaded = reload_code()
for application in applications:
grok_module(
application.split('.')[0]) ### BBB: THIS IS VERY BUGGY...
result = ''
if reloaded:
result += 'Code reloaded:\n\n'
result += '\n'.join(reloaded)
else:
result = 'No code reloaded!'
result += '\n\nGlobal ZCML reloaded.'
return result
class LoginView(grok.Form):
''' A password based login vies '''
grok.context(component.Interface)
grok.name('login')
form_fields = grok.Fields(ILoginFields)
@grok.action(u"OK")
def do_login(self, **data):
login = Login()
self.applyData(login, **data)
principals = IOAuthPrincipalSource(grok.getApplication())
account = principals.find(login=login.login, domain=principals.domain)
if account: # check password, and authenticate if match
from zope.password.password import SSHAPasswordManager
mgr = SSHAPasswordManager()
if mgr.checkPassword(account.secret, login.secret):
session = ISession(self.request)['OAuth2']
session['principal'] = account # Found the principal
@grok.action(u"Cancel", validator=lambda *a, **k: {})
def cancel(self, **data):
pass
class OAuth2AppDelete(grok.EditForm):
''' A form to display confirming deletion '''
grok.context(OAuth2App)
grok.require('OAuth2.editing')
form_fields = grok.Fields(IOAuth2App,
for_display=True).select('service', 'client_id')
def finish(self):
sn = ISession(self.request)['OAuth2']
sn['form'] = None
self.redirect(self.request.URL)
@grok.action("Delete this app")
def delete(self, **data):
ct = self.context.__parent__
app_id = self.context.app_id
del ct[app_id]
self.finish()
@grok.action("Cancel", validator=lambda *a, **k: {})
def cancel(self, **data):
self.finish()
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 AddSeccion(grok.AddForm):
grok.context(ContenedorSecciones)
grok.require('ct.admin')
form_fields = grok.Fields(ISeccion)
label = "Seccion"
@grok.action(u"Agregar") # Boton agregar
def handle_save(self, **data):
# Si no se ingresan los datos pedidos, no agrega seccion
if data['nombre'] is None or data['descripcion'] is None\
or data['codigo'] is None:
return
if not data['codigo'].isalnum():
return
# No agrega la seccion si se repite el nombre de la seccion
# o el codigo
if self.context.contiene_seccion(data['nombre']) == True\
or self.context.contiene_codigo(data['codigo']) == True:
pass
else:
self.context.agregar_seccion(
Seccion(data['nombre'], data['descripcion'], data['codigo']))
self.redirect(self.url('index'))
class Add(GrokstarAddForm):
grok.context(Blog)
title = u'Add Entry'
# add the url that the user wants
form_fields = grok.Fields(
id=schema.TextLine(title=u"Post slug"))
# don't show them these timestamps
form_fields += grok.AutoFields(RestructuredTextEntry).omit(
'published', 'updated')
@grok.action('Add entry')
def add(self, id, **data):
new_entry = RestructuredTextEntry(**data)
self.context['entries'][id] = new_entry
IWorkflowInfo(new_entry).fireTransition('create')
self.redirect(self.url(self.context))
@grok.action('Add published entry')
def add_published(self, id, **data):
new_entry = RestructuredTextEntry(**data)
self.context['entries'][id] = new_entry
IWorkflowInfo(new_entry).fireTransition('create')
IWorkflowInfo(new_entry).fireTransitionToward(interfaces.PUBLISHED)
self.redirect(self.url(self.context))
class Edit(grok.EditForm):
form_fields = grok.Fields(text=TextLine(title=u'The text to store:'))
class Edit(grok.EditForm):
grok.context(Mammoth)
form_fields = grok.Fields(IMammoth).omit('size')
class Edit(grok.EditForm):
form_fields = grok.Fields(a=schema.TextLine(title=u"Alpha"),
b=schema.TextLine(title=u"Beta"),
g=schema.TextLine(title=u"Gamma"),
d=schema.TextLine(title=u"Delta"))
def core_user_fields():
"List of built-in User schema fields"
return grok.Fields(IINetOrgPerson)
class Edit(grok.EditForm):
form_fields = grok.Fields(name=schema.TextLine(title=u"Name"),
size=schema.TextLine(title=u"Size"))
class SignIn(grok.Form):
"""View for the sign-in form
"""
grok.context(Interface)
form_fields = grok.Fields(IPeople).omit('password')
def update(self):
super(SignIn, self).update()
self.peoplelist = queryUtility(IPeopleContainer,
context=grok.getSite())
if self.peoplelist is None:
# there is no people container at the toplevel
SessionMessageSource().send(_(u'Please choose the meeting first'))
self.redirect('index')
@grok.action('sign in')
def handle_signin(self, **data):
"""signin button and signin action
"""
# create the people
people = People()
self.applyData(people, **data)
# check the login is not taken
if people.login in self.peoplelist:
msg = _(u'This username already exists: %s')
SessionMessageSource().send(
translate(msg, context=self.request) % people.login)
return self.redirect('signin')
# generate a weak but nice password
password = u''.join([
choice([
'z', 'r', 't', 'p', 'q', 's', 'd', 'f', 'g', 'h', 'j', 'k',
'l', 'm', 'w', 'x', 'c', 'v', 'b', 'n'
]) + choice(['a', 'e', 'i', 'o', 'u', 'y']) for i in range(4)
])
people.password = password
# send an email with the password
site = grok.getSite()
email = _(u'''Content-Type: text/plain; charset=UTF-8
Subject: your account for %s
Dear %s %s,
Thanks for your account!
You can connect to %s with the following informations:
%s
login : %s
password : %s''')
url = absoluteURL(site, self.request)
if ('HTTP_X_FORWARDED_SCHEME' in self.request
and 'HTTP_X_FORWARDED_SERVER' in self.request):
url = (self.request['HTTP_X_FORWARDED_SCHEME'] + '://' +
self.request['HTTP_X_FORWARDED_SERVER'])
email = translate(email, context=self.request) % (
site.name, people.firstname, people.lastname, site.name, url,
people.login, password)
mailer = getUtility(IMailDelivery, 'afpy.barcamp')
if 'nomail' not in self.request:
mailer.send('*****@*****.**', people.email.encode('utf-8'),
email.encode('utf-8'))
# add the user
self.peoplelist[people.login] = people
# grant him the Member role
prm = IPrincipalRoleManager(grok.getSite())
prm.assignRoleToPrincipal('afpy.barcamp.Member', people.login)
self.redirect('confirmation')
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'))
