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