code stringlengths 1 1.72M | language stringclasses 1 value |
|---|---|
import forms
title = 'Form Types'
description = 'Example of using different typed fields.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aInteger', forms.Integer())
form.addField('aFloat', forms.Float())
form.addField('aBoolean', forms.Boolean())
form.addField('aDate', forms.Date())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from datetime import date
import forms
title = 'Missing Values'
description = 'Providing default values when missing'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String(missing='<nothing>'))
form.addField('aDate', forms.Date(missing=date(2005, 8, 1)))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
import forms
title = 'File Upload'
description = 'Uploading a file'
def makeForm(ctx):
form = forms.Form()
form.addField('file', forms.File())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import pkg_resources
from twisted.python import reflect
from nevow import appserver, loaders, rend, static, tags as T, url
import forms
DOCTYPE = T.xml('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">')
CHARSET = T.xml('<meta http-equiv="content-type" content="text/html; charset=utf-8" />')
examples = [
'forms.examples.simple',
'forms.examples.types',
'forms.examples.required',
'forms.examples.missing',
'forms.examples.prepopulate',
'forms.examples.fileupload',
'forms.examples.smartupload',
'forms.examples.selections',
'forms.examples.dates',
'forms.examples.actionbuttons',
]
def makeSite(application):
root = RootPage()
site = appserver.NevowSite(root, logPath='web.log')
return site
class RootPage(rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title['Forms Examples'],
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
],
T.body[
T.directive('examples'),
],
],
],
)
def render_examples(self, ctx, data):
for name in examples:
module = reflect.namedAny(name)
yield T.div(class_='example')[
T.h1[T.a(href=url.here.child(name))[module.title]],
T.p[module.description],
]
def childFactory(self, ctx, name):
if name in examples:
return FormExamplePage(reflect.namedAny(name))
class FormExamplePage(forms.ResourceMixin, rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title(data=T.directive('title'), render=rend.data),
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
T.link(rel='stylesheet', type='text/css', href=url.root.child('forms.css')),
],
T.body[
T.h1(data=T.directive('title'), render=rend.data),
T.p(data=T.directive('description'), render=rend.data),
T.directive('form example'),
],
],
],
)
def data_title(self, ctx, data):
return self.original.title
def data_description(self, ctx, data):
return self.original.description
def form_example(self, ctx):
return self.original.makeForm(ctx)
# Add child_ attributes
examples_css = pkg_resources.resource_filename('forms.examples', 'examples.css')
setattr(RootPage, 'child_examples.css', static.File(examples_css))
setattr(RootPage, 'child_forms.css', forms.defaultCSS)
| Python |
import forms
title = 'Smart File Upload'
description = 'Smart uploading of files where the file is "carried across" when the validation fails'
def makeForm(ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('file', forms.File(), forms.FileUploadWidget)
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
from datetime import datetime
import forms
title = 'Prepopulate'
description = 'Example of prepopulating form fields'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
form.data = {
'aTime': datetime.utcnow().time(),
}
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from twisted.internet import defer
from datetime import date
import forms
title = 'Selection widgets'
description = 'Example of the various selection widgets'
differentNone = ('none value', '- select -')
def makeForm(ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('oneString', forms.String(), forms.widgetFactory(forms.SelectChoice, options=strings))
form.addField('anotherString', forms.String(), forms.widgetFactory(forms.SelectChoice, options=data_strings))
form.addField('oneMoreString', forms.String(required=True), forms.widgetFactory(forms.RadioChoice, options=data_strings))
form.addField('oneDate', forms.Date(), forms.widgetFactory(forms.SelectChoice, options=dates))
form.addField('multipleStrings', forms.Sequence(forms.String()), forms.widgetFactory(forms.CheckboxMultiChoice, options=strings))
form.addField('multipleDates', forms.Sequence(forms.Date()), forms.widgetFactory(forms.CheckboxMultiChoice, options=dates))
form.addField('differentNoneSelect', forms.String(), forms.widgetFactory(forms.SelectChoice, options=strings, noneOption=differentNone))
form.addField('differentNoneRadios', forms.String(), forms.widgetFactory(forms.RadioChoice, options=data_strings, noneOption=differentNone))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
# A boring list of (value, label) pairs.
strings = [
('foo', 'Foo'),
('bar', 'Bar'),
]
# A list of dates with meaningful names.
dates = [
(date(2005, 01, 01), 'New Year Day'),
(date(2005, 11, 06), 'My Birthday'),
(date(2005, 12, 25), 'Christmas Day'),
]
def data_strings(ctx, data):
# Let's defer it, just for fun.
return defer.succeed(strings)
| Python |
import forms
title = 'Required Fields'
description = 'Demonstration of required fields'
def makeForm(ctx):
form = forms.Form()
form.addField('name', forms.String(required=True))
form.addField('age', forms.Integer())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
"""A package (for Nevow) for defining the schema, validation and rendering of
HTML forms.
"""
version_info = (0, 3, 4)
version = '.'.join([str(i) for i in version_info])
from nevow import static
from forms.types import *
from forms.validation import *
from forms.widget import *
from forms.form import Form, ResourceMixin, renderForm
from forms import iforms
def widgetFactory(widgetClass, *a, **k):
def _(original):
return widgetClass(original, *a, **k)
return _
try:
import pkg_resources
except ImportError:
import os.path
defaultCSS = static.File(os.path.join(os.path.split(__file__)[0], 'forms.css'))
else:
from forms.util import LazyResource
defaultCSS = LazyResource(lambda: static.File(pkg_resources.resource_filename('forms', 'forms.css')))
del LazyResource
# Register standard adapters
from nevow.compy import registerAdapter
from forms import converters
registerAdapter(TextInput, String, iforms.IWidget)
registerAdapter(TextInput, Integer, iforms.IWidget)
registerAdapter(TextInput, Float, iforms.IWidget)
registerAdapter(Checkbox, Boolean, iforms.IWidget)
registerAdapter(DatePartsInput, Date, iforms.IWidget)
registerAdapter(TextInput, Time, iforms.IWidget)
registerAdapter(FileUploadRaw, File, iforms.IWidget)
from forms import util
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.IKey)
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.ILabel)
registerAdapter(converters.NullConverter, String, iforms.IStringConvertible)
registerAdapter(converters.DateToDateTupleConverter, Date, iforms.IDateTupleConvertible)
registerAdapter(converters.BooleanToStringConverter, Boolean, iforms.IBooleanConvertible)
registerAdapter(converters.IntegerToStringConverter, Integer, iforms.IStringConvertible)
registerAdapter(converters.FloatToStringConverter, Float, iforms.IStringConvertible)
registerAdapter(converters.DateToStringConverter, Date, iforms.IStringConvertible)
registerAdapter(converters.TimeToStringConverter, Time, iforms.IStringConvertible)
registerAdapter(converters.NullConverter, File, iforms.IFileConvertible)
registerAdapter(converters.NullConverter, Sequence, iforms.ISequenceConvertible)
del registerAdapter
| Python |
from nevow.compy import Interface
class IType(Interface):
def validate(self, value):
pass
class IStructure(Interface):
pass
class IWidget(Interface):
def render(self, ctx, key, args, errors):
pass
def renderImmutable(self, ctx, key, args, errors):
pass
def processInput(self, ctx, key, args):
pass
class IFormFactory(Interface):
def formFactory(self, ctx, name):
pass
class IFormData(Interface):
pass
class IFormErrors(Interface):
pass
class IKey(Interface):
def key(self):
pass
class ILabel(Interface):
def label(self):
pass
class IConvertible(Interface):
def fromType(self, value):
pass
def toType(self, value):
pass
class IStringConvertible(IConvertible):
pass
class IBooleanConvertible(IConvertible):
pass
class IDateTupleConvertible(IConvertible):
pass
class IFileConvertible(IConvertible):
pass
class ISequenceConvertible(IConvertible):
pass
class IForm( Interface ):
pass
class IValidator(Interface):
def validate(self, field, value):
pass
| Python |
from twisted.application import internet, service
from nevow import appserver
from forms.examples import main
application = service.Application('examples')
service = internet.TCPServer(8000, main.makeSite(application))
service.setServiceParent(application)
| Python |
from setuptools import setup, find_packages
import forms
setup(
name='forms',
version=forms.version,
description='HTML forms framework for Nevow',
author='Matt Goodall',
author_email='matt@pollenation.net',
packages=find_packages(),
package_data={
'forms': ['forms.css'],
}
)
| Python |
from datetime import date, time
from twisted.application import internet, service
from nevow import appserver, compy, loaders, rend, static, tags as T
import forms
import os
from shutil import copyfileobj
import mimetypes, datetime
from forms import iforms, htmleditor, converters
from fileresource import fileResource
class KeyToFileConverter( object ):
__implements__ = iforms.IFileConvertible,
def fromType( self, value, context=None ):
"""
Given a string generate a (mimetype, filelike, fileName) or None
"""
if not value or value == '':
return None
mimetype = mimetypes.guess_type( value )
filelike = open(os.path.join('images',value),'r')
return (mimetype, filelike, value)
def toType( self, value ):
"""
Given a (mimetype, filelike, filename) tuple return a string
"""
if not value:
return None
(mimetype, filelike,fileName) = value;
target = file(os.path.join('images',fileName),'w')
copyfileobj( filelike, target )
target.close()
filelike.close()
return fileName
dates = [
(date(2005,1,1), 'New year\'s day'),
(date(2005,11,6), 'My birthday'),
(date(2005,12,25), 'Christmas day'),
]
times = [
(time(5,0), 'Really early'),
(time(7,0), 'A bit too early'),
(time(8,0), 'Hmm, not bad'),
(time(10,0), 'Nice :)'),
]
class Person(object):
def __init__(self, id, firstName, lastName):
self.id = id
self.firstName = firstName
self.lastName = lastName
class PersonKeyLabelAdapter(object):
__implements__ = iforms.IKey, iforms.ILabel
def __init__(self, original):
self.original = original
def key(self):
return self.original.id
def label(self):
return '%s, %s' % (self.original.lastName, self.original.firstName)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.IKey)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.ILabel)
people = [
Person(1, 'Matt', 'Goodall'),
Person(2, 'Tim', 'Parkin'),
]
class Page(rend.Page, forms.ResourceMixin):
addSlash = True
docFactory = loaders.xmlfile('test.html')
def __init__(self, *a, **k):
rend.Page.__init__(self, *a, **k)
forms.ResourceMixin.__init__(self)
def child_self(self, ctx):
return self
def form_oneOfEach(self, ctx):
form = forms.Form(self._submit)
form.addField('hidden_string', forms.Integer(), forms.Hidden)
form.addField('string', forms.String(required=True))
form.addField('password', forms.String(), forms.CheckedPassword)
form.addField('integer', forms.Integer())
form.addField('float', forms.Float())
form.addField('boolean', forms.Boolean())
form.addField('date', forms.Date(), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('time', forms.Time())
form.addAction(self._submit)
form.data = {'hidden_string': 101}
return form
def form_readonlyOneOfEach(self, ctx):
form = forms.Form(self._submit)
immutable=True
form.addField('string', forms.String(immutable=immutable), forms.TextInput)
form.addField('textarea', forms.String(immutable=immutable), forms.TextArea)
form.addField('password', forms.String(immutable=immutable), forms.CheckedPassword)
form.addField('integer', forms.Integer(immutable=immutable))
form.addField('float', forms.Float(immutable=immutable))
form.addField('boolean', forms.Boolean(immutable=immutable), forms.Checkbox)
form.addField('date', forms.Date(immutable=immutable), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('date2', forms.Date(immutable=immutable), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('time', forms.Time(immutable=immutable))
form.addField('author', forms.Integer(immutable=immutable), lambda original: forms.SelectChoice(original, people))
form.addField('bar', forms.Sequence(forms.String(),immutable=immutable), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.addField('file', forms.File(immutable=immutable), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
form.data = {'string':'hello', 'textarea':'some long text', 'password': ['one','one'], 'integer':10, 'float':22.22, 'boolean':True, 'author': 2, 'file':'dm.gif', 'date': datetime.date(2005, 10, 1), 'bar': ['a'], 'time': datetime.time(12, 51, 30)}
return form
def form_test(self, ctx):
form = forms.Form(self._submit)
form.addField('lastName', forms.String(required=True), label='Surname', description='This should be used to store your surname.. no really!!')
form.addField('date', forms.Date(), forms.widgetFactory(forms.SelectChoice, dates))
form.addField('time', forms.Time(), lambda original: forms.SelectChoice(original, times))
form.addField('author', forms.Integer(), lambda original: forms.SelectChoice(original, people))
form.addField('notes', forms.String(), htmleditor.TinyMCE)
form.addField('foo', forms.Sequence(forms.Time()), forms.widgetFactory(forms.CheckboxMultiChoice, times))
form.addField('bar', forms.Sequence(forms.String(),required=True), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.data = {'foo': [time(10,0)]}
form.addAction(self._submit)
form.addAction(self._submit, 'another')
return form
def form_1(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_2(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_3(self, ctx):
''' This test needs an 'assets' folder to store files in. The widget is passed a fileResource which
is used to get a preview url and to save the upload results. commit/rollback type hooks will need
to be added to forms to allow 'clean' operation. -- tp
'''
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.String(required=True), forms.widgetFactory(forms.FileUpload,fileResource(),preview='image'))
form.addAction(self._submit)
#form.data = {
# 'file': 'product.jpg'
# }
return form
def form_4(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.File(required=True), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
# form.data = {
# 'file': 'dm.gif'
# }
return form
def _submit(self, ctx, form, data):
print form
print data
if data.get('string') == 'error':
raise forms.FieldError('Failed the field!', 'string')
if data.get('string') == 'formerror':
raise forms.FormError('Failed the form!')
setattr(Page, 'child_nevow-forms.css', forms.defaultCSS)
setattr(Page, 'child_tiny_mce', static.File('tiny_mce'))
setattr(Page, 'child_webassets', static.File('assets'))
setattr(Page, 'child_images', static.File('images'))
setattr(Page, 'child_uploads', static.File('uploads'))
root = Page()
site = appserver.NevowSite(root, logPath='/dev/null')
application = service.Application('forms2-test')
internet.TCPServer(8000, site).setServiceParent(application)
| Python |
import os
from shutil import copyfileobj
FILESTORE_DIR='assets'
FILESTORE_URL='webassets'
class fileResource:
def getUrlForFile(self, id):
if id:
return os.path.join(FILESTORE_URL, id)
else:
return None
def storeFile( self, source, name ):
id = name
target = file(os.path.join(FILESTORE_DIR,id),'w')
copyfileobj( source, target )
target.close()
return id | Python |
"""
Form types.
"""
from forms import iforms, validation
from zope.interface import implements
class Type(object):
implements( iforms.IType )
# Name of the instance
name = None
# Instance is required
required = False
# Value to use if no value entered
missing = None
# Instance cannot be changed
immutable = False
# List of validators to test the value against
validators = []
def __init__(self, name=None, required=None, missing=None, immutable=None, validators=None):
if name is not None:
self.name = name
if missing is not None:
self.missing = missing
if immutable is not None:
self.immutable = immutable
if validators is not None:
self.validators = validators[:]
else:
self.validators = self.validators[:]
if required is None:
required = self.required
if required:
self.validators.append(validation.RequiredValidator())
def validate(self, value):
for validator in self.validators:
validator.validate(self, value)
if value is None:
value = self.missing
return value
class String(Type):
# Strip the value before validation
strip = False
def __init__(self, **k):
strip = k.pop('strip', None)
if strip is not None:
self.strip = strip
super(String, self).__init__(**k)
def validate(self, value):
if value is not None and self.strip:
value = value.strip()
if not value:
value = None
return super(String, self).validate(value)
class Integer(Type):
pass
class Float(Type):
pass
class Boolean(Type):
pass
class Date(Type):
pass
class Time(Type):
pass
class Sequence(Type):
# Type of items in the sequence
type = None
def __init__(self, type=None, **k):
super(Sequence, self).__init__(**k)
if type is not None:
self.type = type
def validate(self, value):
# Map empty sequence to None
if not value:
value = None
return super(Sequence, self).validate(value)
class File(Type):
pass
__all__ = [
'Boolean', 'Date', 'File', 'Float', 'Integer', 'Sequence', 'String', 'Time',
]
| Python |
"""
Form implementation and high-level renderers.
"""
from twisted.internet import defer
from nevow import context, loaders, inevow, tags as T, url
from nevow.compy import registerAdapter, Interface
from forms import iforms, util, validation
from resourcemanager import ResourceManager
from zope.interface import implements
ACTION_SEP = '!!'
FORM_ACTION = '__nevow_form__'
WIDGET_RESOURCE = '__widget_res__'
def renderForm(name):
def _(ctx, data):
def _processForm( form, ctx, name ):
# Find the form
ctx.remember(form, iforms.IForm)
# Create a keyed tag that will render the form when flattened.
tag = T.invisible(key=name)[inevow.IRenderer(form)]
# Create a new context, referencing the above tag, so that we don't
# pollute the current context with anything the form needs during
# rendering.
ctx = context.WovenContext(parent=ctx, tag=tag)
# Find errors for *this* form and remember things on the context
errors = iforms.IFormErrors(ctx, None)
if errors is not None and errors.formName == name:
ctx.remember(errors.data, iforms.IFormData)
else:
ctx.remember(None, iforms.IFormErrors)
ctx.remember(form.data or {}, iforms.IFormData)
return ctx
d = defer.succeed( ctx )
d.addCallback( locateForm, name )
d.addCallback( _processForm, ctx, name )
return d
return _
class Action(object):
"""Tracks an action that has been added to a form.
"""
def __init__(self, callback, name, validate):
self.callback = callback
self.name = name
self.validate = validate
class Form(object):
implements( iforms.IForm )
callback = None
items = None
actions = None
widgets = None
data = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
def addField(self, name, type, widgetFactory=None, label=None, description=None, cssClass=None):
if self.items is None:
self.items = []
type.name = name
if label is None:
label = util.titleFromName(name)
self.items.append( (name,type,label,description,cssClass) )
if widgetFactory is not None:
if self.widgets is None:
self.widgets = {}
self.widgets[name] = widgetFactory
def addAction(self, callback, name="submit", validate=True):
if self.actions is None:
self.actions = []
if name in [action.name for action in self.actions]:
raise ValueError('Action with name %r already exists.' % name)
self.actions.append( Action(callback, name, validate) )
def widgetForItem(self, itemName):
for name, type, label, description, cssClass in self.items:
if name == itemName:
break
else:
raise KeyError()
if self.widgets is not None:
try:
widgetFactory = self.widgets[name]
except KeyError:
pass
else:
return widgetFactory(type)
return iforms.IWidget(type)
def process(self, ctx):
# Unflatten the request into nested dicts.
args = {}
for name, value in inevow.IRequest(ctx).args.iteritems():
name = name.split('.')
group, name = name[:-1], name[-1]
d = args
for g in group:
d = args.setdefault(g,{})
d[name] = value
# Find the callback to use, defaulting to the form default
callback, validate = self.callback, True
if self.actions is not None:
for action in self.actions:
if action.name in args:
# Remove it from the data
args.pop(action.name)
# Remember the callback and whether to validate
callback, validate = action.callback, action.validate
break
if callback is None:
raise Exception('The form has no callback and no action was found.')
# Store an errors object in the context
errors = FormErrors(self.name)
errors.data = args
ctx.remember(errors, iforms.IFormErrors)
# Iterate the items and collect the form data and/or errors.
data = {}
for name, type, label, description, cssClass in self.items:
try:
if not type.immutable:
data[name] = self.widgetForItem(name).processInput(ctx, name, args)
else:
data[name] = self.data.get(name)
errors.data[name] = self.data.get(name)
except validation.FieldError, e:
if validate:
if e.fieldName is None:
e.fieldName = name
errors.add(e)
if errors:
return errors
# toType
for name, type, label, description, cssClass in self.items:
widget = self.widgetForItem(name)
if hasattr( widget, 'convertibleFactory' ) and not type.immutable:
data[name] = widget.convertibleFactory(type).toType( data.get(name) )
def _clearUpResources( r ):
self.resourceManager.clearUpResources()
return r
d = defer.maybeDeferred(callback, ctx, self, data)
d.addCallback( _clearUpResources )
d.addErrback(self._cbFormProcessingFailed, ctx)
return d
def _cbFormProcessingFailed(self, failure, ctx):
e = failure.value
failure.trap(validation.FormError, validation.FieldError)
errors = iforms.IFormErrors(ctx)
errors.add(failure.value)
return errors
class FormErrors(object):
implements( iforms.IFormErrors )
def __init__(self, formName):
self.formName = formName
self.errors = []
def add(self, error):
self.errors.append(error)
def getFieldError(self, name):
fieldErrors = [e for e in self.errors if isinstance(e, validation.FieldError)]
for error in fieldErrors:
if error.fieldName == name:
return error
def getFormErrors(self):
return [e for e in self.errors if isinstance(e, validation.FormError)]
def __nonzero__(self):
return len(self.errors) != 0
class ResourceMixin(object):
implements( iforms.IFormFactory )
def __init__(self, *a, **k):
super(ResourceMixin, self).__init__(*a, **k)
self.remember(self, iforms.IFormFactory)
def render_form(self, name):
def _(ctx, data):
return renderForm(name)
return _
def formFactory(self, ctx, name):
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
s = super(ResourceMixin, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
def locateChild(self, ctx, segments):
# Leave now if this it not meant for me.
if not segments[0].startswith(FORM_ACTION) and not segments[0].startswith(WIDGET_RESOURCE):
return super(ResourceMixin, self).locateChild(ctx, segments)
# Find the form name, the form and remember them.
formName = segments[0].split(ACTION_SEP)[1]
d = defer.succeed( ctx )
d.addCallback( locateForm, formName )
d.addCallback( self._processForm, ctx, segments )
return d
def _processForm( self, form, ctx, segments ):
ctx.remember(form, iforms.IForm)
# Serve up file from the resource manager
if segments[0].startswith( WIDGET_RESOURCE ):
return self._fileFromWidget( ctx, form, segments[1:] )
# Process the form.
d = defer.maybeDeferred(form.process, ctx)
d.addCallback(self._formProcessed, ctx)
return d
def _fileFromWidget( self, ctx, form, segments ):
widget = form.widgetForItem( segments[0] )
return widget.getResource( ctx, segments[1:] )
def _formProcessed(self, r, ctx):
if isinstance(r, FormErrors):
if r:
return NoAddSlashHack(self), ()
else:
r = None
if r is None:
r = url.URL.fromContext(ctx)
return r, ()
class IKnownForms(Interface):
"""Marker interface used to locate a dict instance containing the named
forms we know about during this request.
"""
class KnownForms(dict):
implements( IKnownForms )
def locateForm(ctx, name):
"""Locate a form by name.
Initially, a form is located by calling on an IFormFactory that is found
on the context. Once a form has been found, it is remembered in an
KnownForms instance for the lifetime of the request.
This ensures that the form that is located during form processing will be
the same instance that is located when a form is rendered after validation
failure.
"""
# Get hold of the request
request = inevow.IRequest(ctx)
# Find or create the known forms instance
knownForms = request.getComponent(IKnownForms)
if knownForms is None:
knownForms = KnownForms()
request.setComponent(IKnownForms, knownForms)
# See if the form is already known
form = knownForms.get(name)
if form is not None:
return form
# Not known yet, ask a form factory to create the form
factory = iforms.IFormFactory(ctx)
def cacheForm( form, name ):
if form is None:
raise Exception('Form %r not found'%name)
form.name = name
# Make it a known
knownForms[name] = form
return form
d = defer.succeed( None )
d.addCallback( lambda r : factory.formFactory( ctx, name ) )
d.addCallback( cacheForm, name )
return d
def formAction(name):
return '%s%s%s' % (FORM_ACTION, ACTION_SEP, name)
def formWidgetResource(name):
return '%s%s%s' % (WIDGET_RESOURCE, ACTION_SEP, name)
class FormRenderer(object):
implements( inevow.IRenderer )
loader = loaders.stan(
T.form(id=T.slot('id'), action=T.slot('action'), class_='nevow-form', method='post', enctype='multipart/form-data', **{'accept-charset':'utf-8'})[
T.fieldset[
T.input(type='hidden', name='_charset_'),
T.slot('errors'),
T.slot('items'),
T.div(id=T.slot('fieldId'), pattern='item', _class=T.slot('class'))[
T.label(_class='label', _for=T.slot('id'))[T.slot('label')],
T.div(_class='inputs')[T.slot('inputs')],
T.slot('description'),
T.slot('message'),
],
T.div(class_='hiddenitems')[
T.slot('hiddenitems'),
T.invisible(pattern="hiddenitem")[T.slot('inputs')]
],
T.div(class_='actions')[
T.slot('actions'),
],
],
]
)
def __init__(self, original, *a, **k):
super(FormRenderer, self).__init__(*a, **k)
self.original = original
def rend(self, ctx, data):
segs = inevow.ICurrentSegments(ctx)
if segs and segs[-1].startswith(FORM_ACTION):
urlFactory = url.here.sibling
else:
urlFactory = url.here.child
tag = T.invisible[self.loader.load()]
tag.fillSlots('id', util.keytocssid(ctx.key))
tag.fillSlots('action', urlFactory(formAction(self.original.name)))
tag.fillSlots('errors', self._renderErrors)
tag.fillSlots('items', self._renderItems)
tag.fillSlots('hiddenitems', self._renderHiddenItems)
tag.fillSlots('actions', self._renderActions)
return tag
def _renderErrors(self, ctx, data):
errors = iforms.IFormErrors(ctx, None)
if errors is not None:
errors = errors.getFormErrors()
if not errors:
return ''
return T.div(class_='errors')[
T.p['Please correct the following errors:'],
T.ul[[T.li[str(error)] for error in errors]],
]
def _renderItems(self, ctx, data):
if self.original.items is None:
yield ''
return
itemPattern = inevow.IQ(ctx).patternGenerator('item')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') != 'hidden':
yield itemPattern(key=item[0], data=item, render=self._renderItem)
def _renderHiddenItems(self, ctx, data):
if self.original.items is None:
yield ''
return
hiddenItemPattern = inevow.IQ(ctx).patternGenerator('hiddenitem')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') == 'hidden':
yield hiddenItemPattern(key=item[0], data=item, render=self._renderHiddenItem)
def _renderItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
if formErrors is None:
error = None
else:
error = formErrors.getFieldError(name)
classes = [
'field',
type.__class__.__name__.lower(),
widget.__class__.__name__.lower(),
]
if cssClass:
classes.append(cssClass)
if error is None:
message = ''
else:
classes.append('error')
message = T.div(class_='message')[str(error)]
ctx.tag.fillSlots('class', ' '.join(classes))
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('label', label)
if type.immutable:
render = widget.renderImmutable
else:
render = widget.render
ctx.tag.fillSlots('inputs', render(ctx, name, formData, formErrors))
ctx.tag.fillSlots('message', message)
ctx.tag.fillSlots('description', T.div(class_='description')[description or ''])
return ctx.tag
return _
def _renderHiddenItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('inputs', widget.render(ctx, name, formData, formErrors))
return ctx.tag
return _
def _renderActions(self, ctx, data):
if self.original.actions is None:
yield ''
return
for action in self.original.actions:
yield T.invisible(data=action, render=self._renderAction)
def _renderAction(self, ctx, data):
return T.input(type='submit', id='%s-action-%s'%(util.keytocssid(ctx.key), data.name), name=data.name, value=util.titleFromName(data.name))
class NoAddSlashHack:
implements( inevow.IResource )
def __init__(self, wrapped):
self.wrapped = wrapped
def __getattr__(self, name):
return getattr(self.wrapped, name)
def renderHTTP(self, ctx):
MISSING = object()
addSlash = getattr(self.wrapped, 'addSlash', MISSING)
if addSlash:
self.wrapped.addSlash = False
try:
r = self.wrapped.renderHTTP(ctx)
finally:
if addSlash is not MISSING:
self.wrapped.addSlash = addSlash
else:
del self.wrapped.addSlash
return r
registerAdapter(FormRenderer, Form, inevow.IRenderer)
| Python |
from nevow import tags as T, util
from forms import iforms
from zope.interface import implements
tinyMCEGlue = T.xml("""
<!-- tinyMCE -->
<script language="javascript" type="text/javascript" src="/tiny_mce/tiny_mce.js"></script>
<script language="javascript" type="text/javascript">
tinyMCE.init({
mode : "specific_textareas"
theme: 'advanced',
theme_advanced_toolbar_location: 'top',
theme_advanced_toolbar_align: 'left'
});
</script>
<!-- /tinyMCE -->
""" )
class TinyMCE(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.textarea(name=key, id=key, mce_editable='true')[value or '']
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if value:
value=T.xml(value)
else:
value=''
return T.div(id=key, class_="readonly-textarea-container") [
T.div(class_='readonly-textarea readonly')[value]
]
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
| Python |
import tempfile
import mimetypes
import re
import os
from shutil import copyfileobj
from exceptions import IOError, OSError
class ResourceManagerException( Exception ):
def __init__( self, *args, **kwds ):
super( ResourceManagerException, self ).__init__( *args, **kwds )
class ResourceManager( object ):
def __init__( self ):
self.widgetToID = {}
def register( self, widgetName, resourceId ):
self.widgetToID[widgetName] = resourceId
def getResourceId( self, widgetName ):
return self.widgetToID.get( widgetName )
def getResourceForWidget( self, widgetName ):
resourceId = self.getResourceId( widgetName )
if resourceId is None:
return None
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
try:
filelike = open( path, 'r' )
return (mimetype, filelike, fileName)
except IOError:
return None
def getResourcePath( self, resourceId ):
"""
Required to create an instance of nevow.static.File
"""
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
return (mimetype, path, fileName)
def setResource( self, widgetName, filelike, fileName ):
existingResource = self.widgetToID.get( widgetName )
if existingResource is not None:
try:
(path, ignore) = self._fromResourceId( existingResource )
os.remove( path )
except OSError:
pass
# Encode the filename to avoid any unicode filesystem errors.
fileName = self._encodeFilename(fileName)
(target, path) = tempfile.mkstemp( '__' + fileName )
# target is a file handle. We want a file object.
target = os.fdopen(target, 'w')
copyfileobj( filelike, target )
target.close()
resourceId = self._toResourceId( path )
self.widgetToID[widgetName] = resourceId
return resourceId
def _fromResourceId( self, resourceId ):
match = re.match( '^.*__(.*)$', resourceId )
if match is None:
return None
fileName = match.group( 1 )
path = os.sep.join( (tempfile.gettempdir(), resourceId) )
return path, self._decodeFilename(fileName)
def _toResourceId( self, path ):
path = path[len(tempfile.gettempdir()):]
if path[0] == os.sep:
path = path[1:]
return path
def clearUpResources( self ):
for id in self.widgetToID.values():
try:
(path, fileName) = self._fromResourceId( id )
os.remove( path )
except OSError:
pass
def _encodeFilename(self, filename):
"""
Encode the filename (which may be unicode) so it's safe to use with
the filesystem.
"""
return filename.encode('utf-8').encode('base64')[:-1]
def _decodeFilename(self, filename):
"""
Undo what _encodeFilename did.
"""
filename = filename + '\n'
return filename.decode('base64').decode('utf-8')
| Python |
"""Adapters for converting to and from a type's value according to an
IConvertible protocol.
"""
from datetime import date, time
from nevow.compy import Adapter
from forms import iforms, validation
from zope.interface import implements
class NullConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value
def toType(self, value):
if value is None:
return None
return value
class NumberToStringConverter(Adapter):
implements( iforms.IStringConvertible )
cast = None
def fromType(self, value):
if value is None:
return None
return str(value)
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
try:
value = self.cast(value)
except ValueError:
raise validation.FieldValidationError("Not a valid number")
return value
class IntegerToStringConverter(NumberToStringConverter):
cast = int
class FloatToStringConverter(NumberToStringConverter):
cast = float
class BooleanToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
if value:
return 'True'
return 'False'
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
if value not in ('True', 'False'):
raise validation.FieldValidationError('%r should be either True or False')
return value == 'True'
class DateToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseDate(value)
def parseDate(self, value):
try:
y, m, d = [int(p) for p in value.split('-')]
except ValueError:
raise validation.FieldValidationError('Invalid date')
try:
value = date(y, m, d)
except ValueError, e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
class TimeToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseTime(value)
def parseTime(self, value):
if '.' in value:
value, ms = value.split('.')
else:
ms = 0
try:
parts = value.split(':')
if len(parts)<2 or len(parts)>3:
raise ValueError()
if len(parts) == 2:
h, m = parts
s = 0
else:
h, m, s = parts
h, m, s, ms = int(h), int(m), int(s), int(ms)
except:
raise validation.FieldValidationError('Invalid time')
try:
value = time(h, m, s, ms)
except ValueError, e:
raise validation.FieldValidationError('Invalid time: '+str(e))
return value
class DateToDateTupleConverter(Adapter):
implements( iforms.IDateTupleConvertible )
def fromType(self, value):
if value is None:
return None, None, None
return value.year, value.month, value.day
def toType(self, value):
if value is None:
return None
try:
value = date(*value)
except (TypeError, ValueError), e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
| Python |
from forms import iforms
from zope.interface import implements
def titleFromName(name):
def _():
it = iter(name)
last = None
while 1:
ch = it.next()
if ch == '_':
if last != '_':
yield ' '
elif last in (None,'_'):
yield ch.upper()
elif ch.isupper() and not last.isupper():
yield ' '
yield ch.upper()
else:
yield ch
last = ch
return ''.join(_())
def keytocssid(key):
return '-'.join(key.split('.'))
class SequenceKeyLabelAdapter(object):
implements( iforms.IKey, iforms.ILabel )
def __init__(self, original):
self.original = original
def key(self):
return self.original[0]
def label(self):
return self.original[1]
| Python |
"""
Widgets are small components that render form fields for inputing data in a
certain format.
"""
import itertools
from nevow import inevow, tags as T, util, url, static
from forms import converters, iforms, validation
from forms.util import keytocssid
from forms.form import formWidgetResource
from zope.interface import implements
from twisted.internet import defer
# Marker object for args that are not supplied
_UNSET = object()
class TextInput(object):
"""
A text input field.
<input type="text" ... />
"""
implements( iforms.IWidget )
inputType = 'text'
showValueOnFailure = True
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, readonly):
tag=T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if not self.showValueOnFailure:
value = None
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class Checkbox(object):
"""
A checkbox input field.
<input type="checkbox" ... />
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, disabled):
tag = T.input(type='checkbox', name=key, id=keytocssid(ctx.key), value='True')
if value == 'True':
tag(checked='checked')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [None])[0]
if not value:
value = 'False'
value = iforms.IBooleanConvertible(self.original).toType(value)
return self.original.validate(value)
class Password(TextInput):
"""
A text input field that hides the text.
<input type="password" ... />
"""
inputType = 'password'
showValueOnFailure = False
class TextArea(object):
"""
A large text entry area that accepts newline characters.
<textarea>...</textarea>
"""
implements( iforms.IWidget )
cols = 48
rows = 6
def __init__(self, original, cols=None, rows=None):
self.original = original
if cols is not None:
self.cols = cols
if rows is not None:
self.rows = rows
def _renderTag(self, ctx, key, value, readonly):
tag=T.textarea(name=key, id=keytocssid(ctx.key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class CheckedPassword(object):
"""
Two password entry fields that must contain the same value to validate.
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors and not errors.getFieldError(key):
values = args.get(key)
else:
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0]),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1]),
]
def renderImmutable(self, ctx, key, args, errors):
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0], class_='readonly', readonly='readonly'),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1], class_='readonly', readonly='readonly')
]
def processInput(self, ctx, key, args):
pwds = [pwd for pwd in args.get(key, [])]
if len(pwds) == 0:
pwd = ''
elif len(pwds) == 1:
raise validation.FieldValidationError('Please enter the password twice for confirmation.')
else:
if pwds[0] != pwds[1]:
raise validation.FieldValidationError('Passwords do not match.')
return self.original.validate(pwds[0])
class ChoiceBase(object):
"""
A base class for widgets that provide the UI to select one or more items
from a list.
options:
A sequence of objects adaptable to IKey and ILabel. IKey is used as the
<option>'s value attribute; ILabel is used as the <option>'s child.
IKey and ILabel adapters for tuple are provided.
noneOption:
An object adaptable to IKey and ILabel that is used to identify when
nothing has been selected. Defaults to ('', '')
"""
options = None
noneOption = None
def __init__(self, original, options=None, noneOption=_UNSET):
self.original = original
if options is not None:
self.options = options
if noneOption is not _UNSET:
self.noneOption = noneOption
class SelectChoice(ChoiceBase):
"""
A drop-down list of options.
<select>
<option value="...">...</option>
</select>
"""
implements( iforms.IWidget )
noneOption = ('', '')
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iforms.IKey(self.noneOption).key())[iforms.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
option = T.option(value=optValue)[optLabel]
if optValue == value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=keytocssid(ctx.key), data=self.options)[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0]
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class RadioChoice(ChoiceBase):
"""
A list of options in the form of radio buttons.
<input type="radio" ... value="..."/><label>...</label><br />
<input type="radio" ... value="..."/><label>...</label><br />
"""
implements( iforms.IWidget )
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOption(ctx, itemKey, itemLabel, num, selected):
cssid = (keytocssid(ctx.key),'-',num)
tag = T.input(name=key, type='radio', id=cssid, value=itemKey)
if selected:
tag = tag(checked='checked')
return tag, ' ', T.label(for_=cssid)[itemLabel], T.br
def renderOptions(ctx, data):
# A counter to assign unique ids to each input
idCounter = itertools.count()
if self.noneOption is not None:
itemKey = iforms.IKey(self.noneOption).key()
itemLabel = iforms.ILabel(self.noneOption).label()
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
if not data:
return
for item in data:
itemKey = iforms.IKey(item).key()
itemLabel = iforms.ILabel(item).label()
itemKey = converter.fromType(itemKey)
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
return T.invisible(data=self.options)[renderOptions]
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0]
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class DatePartsInput(object):
"""
Three text input fields for entering a date in parts.
Default format is mm/dd/yyyy
dayFirst:
Make the day the first input field. dd/mm/yyyy
"""
implements( iforms.IWidget )
dayFirst = False
def __init__(self, original, dayFirst=None):
self.original = original
if dayFirst is not None:
self.dayFirst = dayFirst
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, day, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=4)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
dayTag = T.input(type="text", name=namer('day'), value=day, size=2)
if readonly:
tags = (yearTag, monthTag, dayTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
if self.dayFirst:
return dayTag, ' / ', monthTag, ' / ', yearTag, ' (dd/mm/yyyy)'
else:
return monthTag, ' / ', dayTag, ' / ', yearTag, ' (mm/dd/yyyy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
day = args.get(namer('day'), [''])[0]
else:
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month', 'day')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 3:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
value = iforms.IDateTupleConvertible(self.original).toType(value)
return self.original.validate(value)
class MMYYDatePartsInput(object):
"""
Two input fields for entering the month and year.
"""
implements( iforms.IWidget )
cutoffYear = 70
def __init__(self, original, cutoffYear=None):
self.original = original
if cutoffYear is not None:
self.cutoffYear = cutoffYear
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=2)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
if readonly:
tags=(yearTag, monthTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
return monthTag, ' / ', yearTag, ' (mm/yy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
# return a blank for the day
day = ''
else:
year, month, day = converter.fromType(args.get(key))
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
year, month, day = converter.fromType(args.get(key))
namer = self._namer(key)
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 2:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
if value[1] < 0 or value[1] > 99:
raise validation.FieldValidationError("Invalid year. Please enter a two-digit year.")
if value[0] > self.cutoffYear:
value[0] = 1900 + value[0]
else:
value[0] = 2000 + value[0]
value.append(1)
value = iforms.IDateTupleConvertible(self.original).toType( value )
return self.original.validate(value)
class CheckboxMultiChoice(object):
"""
Multiple choice list, rendered as a list of checkbox fields.
"""
implements( iforms.IWidget )
options = None
def __init__(self, original, options=None):
self.original = original
if options is not None:
self.options = options
def _renderTag(self, ctx, key, values, converter, disabled):
# loops through checkbox options and renders
for n,item in enumerate(self.options):
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
optid = (keytocssid(ctx.key),'-',n)
checkbox = T.input(type='checkbox', name=key, value=optValue, id=optid )
if optValue in values:
checkbox = checkbox(checked='checked')
if disabled:
checkbox = checkbox(class_='disabled', disabled='disabled')
yield checkbox, T.label(for_=optid)[optLabel], T.br()
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
if errors:
values = args.get(key, [])
else:
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, True)
def processInput(self, ctx, key, args):
values = args.get(key, [])
converter = iforms.IStringConvertible(self.original.type)
values = [converter.toType(v) for v in values]
return self.original.validate(values)
class FileUploadRaw(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, disabled):
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
value = (name, fileitem.file)
value = iforms.IFileConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUpload(object):
implements( iforms.IWidget )
def __init__(self, original, fileHandler, preview=None):
self.original = original
self.fileHandler = fileHandler
self.preview = preview
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, key, value, namer, disabled):
name = self.fileHandler.getUrlForFile(value)
if name:
if self.preview == 'image':
yield T.p[value,T.img(src=self.fileHandler.getUrlForFile(value))]
else:
yield T.p[value]
else:
yield T.p[T.strong['nothing uploaded']]
yield T.input(name=namer('value'),value=value,type='hidden')
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
yield tag
def render(self, ctx, key, args, errors):
namer = self._namer(key)
if errors:
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = name
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, False)
def renderImmutable(self, ctx, key, args, errors):
namer = self._namer(key)
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = self.fileHandler.storeFile( fileitem.file, name )
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUploadWidget(object):
"""
File upload widget that carries the uploaded file around until the form
validates.
The widget uses the resource manager to save the file to temporary storage
until the form validates. This makes file uploads behave like most of the
other widgets, i.e. the value is kept when a form is redisplayed due to
validation errors.
"""
implements( iforms.IWidget )
FROM_RESOURCE_MANAGER = 'rm'
FROM_CONVERTIBLE = 'cf'
convertibleFactory = converters.NullConverter
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def __init__( self, original, convertibleFactory=None, originalKeyIsURL=False ):
self.original = original
if convertibleFactory is not None:
self.convertibleFactory = convertibleFactory
self.originalKeyIsURL = originalKeyIsURL
def _blankField( self, field ):
"""
Convert empty strings into None.
"""
if field and field == '':
return None
return field
def _getFromArgs( self, args, name ):
"""
Get the first value of 'name' from 'args', or None.
"""
rv = args.get( name )
if rv:
rv = rv[0]
return rv
def render(self, ctx, key, args, errors):
"""
Render the data.
This either renders a link to the original file, if specified, and
no new file has been uploaded. Or a link to the uploaded file.
The request to get the data should be routed to the getResouce
method.
"""
form = iforms.IForm( ctx )
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
originalIdName = namer( 'original_id' )
# get the resource id first from the resource manager
# then try the request
resourceId = form.resourceManager.getResourceId( key )
if resourceId is None:
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
# Get the original key from a hidden field in the request,
# then try the request file.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if errors:
urlFactory = url.URL.fromContext( ctx ).sibling
else:
urlFactory = url.URL.fromContext( ctx ).child
if resourceId:
# Have an uploaded file, so render a URL to the uploaded file
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child( self.FROM_RESOURCE_MANAGER ).child( resourceId )
yield T.p[T.img(src=tmpURL)]
elif originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child( self.FROM_CONVERTIBLE ).child( originalKey )
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
yield T.input(name=key, id=keytocssid(ctx.key),type='file')
# Id of uploaded file in the resource manager
yield T.input(name=resourceIdName,value=resourceId,type='hidden')
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def renderImmutable(self, ctx, key, args, errors):
form = iforms.IForm(ctx)
namer = self._namer(key)
originalIdName = namer('original_id')
# Get the original key from a hidden field in the request,
# then try the request form.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if errors:
urlFactory = url.URL.fromContext( ctx ).sibling
else:
urlFactory = url.URL.fromContext( ctx ).child
if originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child(self.FROM_CONVERTIBLE).child(originalKey)
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def processInput(self, ctx, key, args):
"""
Process the request, storing any uploaded file in the
resource manager.
"""
resourceManager = iforms.IForm( ctx ).resourceManager
# Ping the resource manager with any resource ids that I know
self._registerWithResourceManager( key, args, resourceManager )
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
# Store the uploaded file in the resource manager
resourceManager.setResource( key, fileitem.file, name )
# Validating against an uploaded file. Should the fact that there is
# original file meet a required field validation?
return self.original.validate( resourceManager.getResourceForWidget( key ) )
def _registerWithResourceManager( self, key, args, resourceManager ):
"""
If there is a resource id in the request, then let the
resource manager know about it.
"""
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
if resourceId:
resourceManager.register( key, resourceId )
def getResource( self, ctx, segments ):
"""
Return an Resource that contains the image, either a file
from the resource manager, or a data object from the convertible.
"""
if segments[0] == self.FROM_RESOURCE_MANAGER:
# Resource manager can provide a path so return a static.File
# instance that points to the file
rm = iforms.IForm( ctx ).resourceManager
(mimetype, path, fileName) = rm.getResourcePath( segments[1] )
return static.File( path, mimetype ), []
elif segments[0] == self.FROM_CONVERTIBLE:
# The convertible can provide a file like object so create a
# static.Data instance with the data from the convertible.
def _( result ):
mimetype, filelike, fileName = result
data = filelike.read()
filelike.close()
return static.Data( data, mimetype ), []
d = defer.maybeDeferred( self.convertibleFactory(self.original).fromType, segments[1], context=ctx )
d.addCallback( _ )
return d
else:
return None
class Hidden(object):
"""
A hidden form field.
"""
__implements__ = iforms.IWidget,
inputType = 'hidden'
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
def renderImmutable(self, ctx, key, args, errors):
return self.render(ctx, key, args, errors)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
__all__ = [
'Checkbox', 'CheckboxMultiChoice', 'CheckedPassword','FileUploadRaw', 'FileUpload', 'FileUploadWidget',
'Password', 'SelectChoice', 'TextArea', 'TextInput', 'DatePartsInput',
'MMYYDatePartsInput', 'Hidden', 'RadioChoice',
]
| Python |
import re
from zope.interface import implements
from forms import iforms
class FormError(Exception):
pass
class FieldError(Exception):
def __init__(self, message, fieldName=None):
Exception.__init__(self, message)
self.message = message
self.fieldName = fieldName
class FieldValidationError(FieldError):
pass
class FieldRequiredError(FieldValidationError):
pass
class RequiredValidator(object):
implements(iforms.IValidator)
def validate(self, field, value):
if value is None:
raise FieldRequiredError, 'Required'
class LengthValidator(object):
"""Validate the length of the value is within a given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be longer than %r characters'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be shorter than %r characters'%(self.max,)
return 'Must be between %r and %r characters'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
length = len(value)
if self.min is not None and length < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and length > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class RangeValidator(object):
"""Validate the size of the value is within is given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be greater than %r'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be less than %r'%(self.max,)
return 'Must be between %r and %r'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
if self.min is not None and value < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and value > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class PatternValidator(object):
"""Validate the value is a certain pattern.
The required pattern is defined as a regular expression. The regex will be
compiled automatically if necessary.
"""
implements(iforms.IValidator)
def __init__(self, regex):
self.regex = regex
def validate(self, field, value):
if value is None:
return
# If it doesn't look like a regex object then compile it now
if not hasattr(self.regex, 'match'):
self.regex = re.compile(self.regex)
if self.regex.match(value) is None:
raise FieldValidationError, 'Invalid format'
__all__ = [
'FormError', 'FieldError', 'FieldValidationError', 'FieldRequiredError',
'RequiredValidator', 'LengthValidator', 'RangeValidator', 'PatternValidator',
]
| Python |
import forms
title = 'Dates'
description = 'Date entry examples'
def makeForm(ctx):
form = forms.Form()
form.addField('isoFormat', forms.Date(), forms.TextInput)
form.addField('monthFirst', forms.Date(), forms.DatePartsInput)
form.addField('dayFirst', forms.Date(), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('monthAndYear', forms.Date(), forms.MMYYDatePartsInput)
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import forms
title = 'Simple Form'
description = 'Probably the simplest form possible.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import forms
title = 'Form Types'
description = 'Example of using different typed fields.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aInteger', forms.Integer())
form.addField('aFloat', forms.Float())
form.addField('aBoolean', forms.Boolean())
form.addField('aDate', forms.Date())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from datetime import date
import forms
title = 'Missing Values'
description = 'Providing default values when missing'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String(missing='<nothing>'))
form.addField('aDate', forms.Date(missing=date(2005, 8, 1)))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
import forms
title = 'File Upload'
description = 'Uploading a file'
def makeForm(ctx):
form = forms.Form()
form.addField('file', forms.File())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import pkg_resources
from twisted.python import reflect
from nevow import appserver, loaders, rend, static, tags as T, url
import forms
DOCTYPE = T.xml('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">')
CHARSET = T.xml('<meta http-equiv="content-type" content="text/html; charset=utf-8" />')
examples = [
'forms.examples.simple',
'forms.examples.types',
'forms.examples.required',
'forms.examples.missing',
'forms.examples.prepopulate',
'forms.examples.fileupload',
'forms.examples.smartupload',
'forms.examples.selections',
'forms.examples.dates',
'forms.examples.extrabutton',
]
def makeSite(application):
root = RootPage()
site = appserver.NevowSite(root, logPath='web.log')
return site
class RootPage(rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title['Forms Examples'],
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
],
T.body[
T.directive('examples'),
],
],
],
)
def render_examples(self, ctx, data):
for name in examples:
module = reflect.namedAny(name)
yield T.div(class_='example')[
T.h1[T.a(href=url.here.child(name))[module.title]],
T.p[module.description],
]
def childFactory(self, ctx, name):
if name in examples:
return FormPage(reflect.namedAny(name))
class FormPage(forms.ResourceMixin, rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title(data=T.directive('title'), render=rend.data),
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
T.link(rel='stylesheet', type='text/css', href=url.root.child('forms.css')),
],
T.body[
T.h1(data=T.directive('title'), render=rend.data),
T.p(data=T.directive('description'), render=rend.data),
T.directive('form example'),
],
],
],
)
def data_title(self, ctx, data):
return self.original.title
def data_description(self, ctx, data):
return self.original.description
def form_example(self, ctx):
return self.original.makeForm(ctx)
# Add child_ attributes
examples_css = pkg_resources.resource_filename('forms.examples', 'examples.css')
setattr(RootPage, 'child_examples.css', static.File(examples_css))
setattr(RootPage, 'child_forms.css', forms.defaultCSS)
| Python |
import forms
title = 'Smart File Upload'
description = 'Smart uploading of files where the file is "carried across" when the validation fails'
def makeForm(ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('file', forms.File(), forms.FileUploadWidget)
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
from datetime import datetime
import forms
title = 'Prepopulate'
description = 'Example of prepopulating form fields'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
form.data = {
'aTime': datetime.utcnow().time(),
}
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from twisted.internet import defer
from datetime import date
import forms
title = 'Selection widgets'
description = 'Example of the various selection widgets'
def makeForm(ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('oneString', forms.String(), forms.widgetFactory(forms.SelectChoice, options=strings))
form.addField('anotherString', forms.String(), forms.widgetFactory(forms.SelectChoice, options=data_strings))
form.addField('oneMoreString', forms.String(required=True), forms.widgetFactory(forms.RadioChoice, options=data_strings))
form.addField('oneDate', forms.Date(), forms.widgetFactory(forms.SelectChoice, options=dates))
form.addField('multipleStrings', forms.Sequence(forms.String()), forms.widgetFactory(forms.CheckboxMultiChoice, options=strings))
form.addField('multipleDates', forms.Sequence(forms.Date()), forms.widgetFactory(forms.CheckboxMultiChoice, options=dates))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
# A boring list of (value, label) pairs.
strings = [
('foo', 'Foo'),
('bar', 'Bar'),
]
# A list of dates with meaningful names.
dates = [
(date(2005, 01, 01), 'New Year Day'),
(date(2005, 11, 06), 'My Birthday'),
(date(2005, 12, 25), 'Christmas Day'),
]
def data_strings(ctx, data):
# Let's defer it, just for fun.
return defer.succeed(strings)
| Python |
from nevow import url
import forms
title = 'Extra Button'
description = 'Example of adding an extra, non-validating button'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String(required=True))
form.addAction(formSubmitted)
form.addAction(redirect, 'back', validate=False)
return form
def formSubmitted(ctx, form, data):
print form, data
def redirect(ctx, form, data):
return url.rootaccessor(ctx)
| Python |
import forms
title = 'Required Fields'
description = 'Demonstration of required fields'
def makeForm(ctx):
form = forms.Form()
form.addField('name', forms.String(required=True))
form.addField('age', forms.Integer())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
"""A package (for Nevow) for defining the schema, validation and rendering of
HTML forms.
"""
version_info = (0, 2, 4)
version = '.'.join([str(i) for i in version_info])
from nevow import static
from forms.types import *
from forms.validation import *
from forms.widget import *
from forms.form import Form, ResourceMixin, renderForm
from forms import iforms
def widgetFactory(widgetClass, *a, **k):
def _(original):
return widgetClass(original, *a, **k)
return _
try:
import pkg_resources
except ImportError:
import os.path
defaultCSS = static.File(os.path.join(os.path.split(__file__)[0], 'forms.css'))
else:
defaultCSS = static.File(pkg_resources.resource_filename('forms', 'forms.css'))
# Register standard adapters
from nevow.compy import registerAdapter
from forms import converters
registerAdapter(TextInput, String, iforms.IWidget)
registerAdapter(TextInput, Integer, iforms.IWidget)
registerAdapter(TextInput, Float, iforms.IWidget)
registerAdapter(Checkbox, Boolean, iforms.IWidget)
registerAdapter(DatePartsInput, Date, iforms.IWidget)
registerAdapter(TextInput, Time, iforms.IWidget)
registerAdapter(FileUploadRaw, File, iforms.IWidget)
from forms import util
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.IKey)
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.ILabel)
registerAdapter(converters.NullConverter, String, iforms.IStringConvertible)
registerAdapter(converters.DateToDateTupleConverter, Date, iforms.IDateTupleConvertible)
registerAdapter(converters.BooleanToStringConverter, Boolean, iforms.IBooleanConvertible)
registerAdapter(converters.IntegerToStringConverter, Integer, iforms.IStringConvertible)
registerAdapter(converters.FloatToStringConverter, Float, iforms.IStringConvertible)
registerAdapter(converters.DateToStringConverter, Date, iforms.IStringConvertible)
registerAdapter(converters.TimeToStringConverter, Time, iforms.IStringConvertible)
registerAdapter(converters.NullConverter, File, iforms.IFileConvertible)
registerAdapter(converters.NullConverter, Sequence, iforms.ISequenceConvertible)
del registerAdapter
| Python |
from nevow.compy import Interface
class IType(Interface):
def validate(self, value):
pass
class IStructure(Interface):
pass
class IWidget(Interface):
def render(self, ctx, key, args, errors):
pass
def renderImmutable(self, ctx, key, args, errors):
pass
def processInput(self, ctx, key, args):
pass
class IFormFactory(Interface):
def formFactory(self, ctx, name):
pass
class IFormData(Interface):
pass
class IFormErrors(Interface):
pass
class IKey(Interface):
def key(self):
pass
class ILabel(Interface):
def label(self):
pass
class IConvertible(Interface):
def fromType(self, value):
pass
def toType(self, value):
pass
class IStringConvertible(IConvertible):
pass
class IBooleanConvertible(IConvertible):
pass
class IDateTupleConvertible(IConvertible):
pass
class IFileConvertible(IConvertible):
pass
class ISequenceConvertible(IConvertible):
pass
class IForm( Interface ):
pass
class IValidator(Interface):
def validate(self, field, value):
pass
| Python |
from twisted.application import internet, service
from nevow import appserver
from forms.examples import main
application = service.Application('examples')
service = internet.TCPServer(8000, main.makeSite(application))
service.setServiceParent(application)
| Python |
from setuptools import setup, find_packages
import forms
setup(
name='forms',
version=forms.version,
description='HTML forms framework for Nevow',
author='Matt Goodall',
author_email='matt@pollenation.net',
packages=find_packages(),
package_data={
'forms': ['forms.css'],
}
)
| Python |
from datetime import date, time
from twisted.application import internet, service
from nevow import appserver, compy, loaders, rend, static, tags as T
import forms
import os
from shutil import copyfileobj
import mimetypes, datetime
from forms import iforms, htmleditor, converters
from fileresource import fileResource
class KeyToFileConverter( object ):
__implements__ = iforms.IFileConvertible,
def fromType( self, value, context=None ):
"""
Given a string generate a (mimetype, filelike, fileName) or None
"""
if not value or value == '':
return None
mimetype = mimetypes.guess_type( value )
filelike = open(os.path.join('images',value),'r')
return (mimetype, filelike, value)
def toType( self, value ):
"""
Given a (mimetype, filelike, filename) tuple return a string
"""
if not value:
return None
(mimetype, filelike,fileName) = value;
target = file(os.path.join('images',fileName),'w')
copyfileobj( filelike, target )
target.close()
filelike.close()
return fileName
dates = [
(date(2005,1,1), 'New year\'s day'),
(date(2005,11,6), 'My birthday'),
(date(2005,12,25), 'Christmas day'),
]
times = [
(time(5,0), 'Really early'),
(time(7,0), 'A bit too early'),
(time(8,0), 'Hmm, not bad'),
(time(10,0), 'Nice :)'),
]
class Person(object):
def __init__(self, id, firstName, lastName):
self.id = id
self.firstName = firstName
self.lastName = lastName
class PersonKeyLabelAdapter(object):
__implements__ = iforms.IKey, iforms.ILabel
def __init__(self, original):
self.original = original
def key(self):
return self.original.id
def label(self):
return '%s, %s' % (self.original.lastName, self.original.firstName)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.IKey)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.ILabel)
people = [
Person(1, 'Matt', 'Goodall'),
Person(2, 'Tim', 'Parkin'),
]
class Page(rend.Page, forms.ResourceMixin):
addSlash = True
docFactory = loaders.xmlfile('test.html')
def __init__(self, *a, **k):
rend.Page.__init__(self, *a, **k)
forms.ResourceMixin.__init__(self)
def child_self(self, ctx):
return self
def form_oneOfEach(self, ctx):
form = forms.Form(self._submit)
form.addField('hidden_string', forms.Integer(), forms.Hidden)
form.addField('string', forms.String(required=True))
form.addField('password', forms.String(), forms.CheckedPassword)
form.addField('integer', forms.Integer())
form.addField('float', forms.Float())
form.addField('boolean', forms.Boolean())
form.addField('date', forms.Date(), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('time', forms.Time())
form.addAction(self._submit)
form.data = {'hidden_string': 101}
return form
def form_readonlyOneOfEach(self, ctx):
form = forms.Form(self._submit)
immutable=True
form.addField('string', forms.String(immutable=immutable), forms.TextInput)
form.addField('textarea', forms.String(immutable=immutable), forms.TextArea)
form.addField('password', forms.String(immutable=immutable), forms.CheckedPassword)
form.addField('integer', forms.Integer(immutable=immutable))
form.addField('float', forms.Float(immutable=immutable))
form.addField('boolean', forms.Boolean(immutable=immutable), forms.Checkbox)
form.addField('date', forms.Date(immutable=immutable), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('date2', forms.Date(immutable=immutable), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('time', forms.Time(immutable=immutable))
form.addField('author', forms.Integer(immutable=immutable), lambda original: forms.SelectChoice(original, people))
form.addField('bar', forms.Sequence(forms.String(),immutable=immutable), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.addField('file', forms.File(immutable=immutable), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
form.data = {'string':'hello', 'textarea':'some long text', 'password': ['one','one'], 'integer':10, 'float':22.22, 'boolean':True, 'author': 2, 'file':'dm.gif', 'date': datetime.date(2005, 10, 1), 'bar': ['a'], 'time': datetime.time(12, 51, 30)}
return form
def form_test(self, ctx):
form = forms.Form(self._submit)
form.addField('lastName', forms.String(required=True), label='Surname', description='This should be used to store your surname.. no really!!')
form.addField('date', forms.Date(), forms.widgetFactory(forms.SelectChoice, dates))
form.addField('time', forms.Time(), lambda original: forms.SelectChoice(original, times))
form.addField('author', forms.Integer(), lambda original: forms.SelectChoice(original, people))
form.addField('notes', forms.String(), htmleditor.TinyMCE)
form.addField('foo', forms.Sequence(forms.Time()), forms.widgetFactory(forms.CheckboxMultiChoice, times))
form.addField('bar', forms.Sequence(forms.String(),required=True), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.data = {'foo': [time(10,0)]}
form.addAction(self._submit)
form.addAction(self._submit, 'another')
return form
def form_1(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_2(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_3(self, ctx):
''' This test needs an 'assets' folder to store files in. The widget is passed a fileResource which
is used to get a preview url and to save the upload results. commit/rollback type hooks will need
to be added to forms to allow 'clean' operation. -- tp
'''
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.String(required=True), forms.widgetFactory(forms.FileUpload,fileResource(),preview='image'))
form.addAction(self._submit)
#form.data = {
# 'file': 'product.jpg'
# }
return form
def form_4(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.File(required=True), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
# form.data = {
# 'file': 'dm.gif'
# }
return form
def _submit(self, ctx, form, data):
print form
print data
if data.get('string') == 'error':
raise forms.FieldError('Failed the field!', 'string')
if data.get('string') == 'formerror':
raise forms.FormError('Failed the form!')
setattr(Page, 'child_nevow-forms.css', forms.defaultCSS)
setattr(Page, 'child_tiny_mce', static.File('tiny_mce'))
setattr(Page, 'child_webassets', static.File('assets'))
setattr(Page, 'child_images', static.File('images'))
setattr(Page, 'child_uploads', static.File('uploads'))
root = Page()
site = appserver.NevowSite(root, logPath='/dev/null')
application = service.Application('forms2-test')
internet.TCPServer(8000, site).setServiceParent(application)
| Python |
import os
from shutil import copyfileobj
FILESTORE_DIR='assets'
FILESTORE_URL='webassets'
class fileResource:
def getUrlForFile(self, id):
if id:
return os.path.join(FILESTORE_URL, id)
else:
return None
def storeFile( self, source, name ):
id = name
target = file(os.path.join(FILESTORE_DIR,id),'w')
copyfileobj( source, target )
target.close()
return id | Python |
"""
Form types.
"""
from forms import iforms, validation
from zope.interface import implements
class Type(object):
implements( iforms.IType )
# Name of the instance
name = None
# Instance is required
required = False
# Value to use if no value entered
missing = None
# Instance cannot be changed
immutable = False
def __init__(self, name=None, required=None, missing=None, immutable=None):
if name is not None:
self.name = name
if required is not None:
self.required = required
if missing is not None:
self.missing = missing
if immutable is not None:
self.immutable = immutable
def validate(self, value):
if self.required and value is None:
raise validation.FieldRequiredError('required field')
if value is None:
value = self.missing
return value
class String(Type):
# Strip the value before validation
strip = False
def __init__(self, **k):
strip = k.pop('strip', None)
if strip is not None:
self.strip = strip
super(String, self).__init__(**k)
def validate(self, value):
if value is not None and self.strip:
value = value.strip()
if not value:
value = None
return super(String, self).validate(value)
class Integer(Type):
pass
class Float(Type):
pass
class Boolean(Type):
pass
class Date(Type):
pass
class Time(Type):
pass
class Sequence(Type):
# Type of items in the sequence
type = None
def __init__(self, type=None, **k):
super(Sequence, self).__init__(**k)
if type is not None:
self.type = type
class File(Type):
pass
__all__ = [
'Boolean', 'Date', 'File', 'Float', 'Integer', 'Sequence', 'String', 'Time',
]
| Python |
"""
Form implementation and high-level renderers.
"""
from twisted.internet import defer
from nevow import context, loaders, inevow, tags as T, url
from nevow.compy import registerAdapter, Interface
from forms import iforms, util, validation
from resourcemanager import ResourceManager
from zope.interface import implements
ACTION_SEP = '!!'
FORM_ACTION = '__nevow_form__'
WIDGET_RESOURCE = '__widget_res__'
def renderForm(name):
def _(ctx, data):
def _processForm( form, ctx, name ):
# Find the form
ctx.remember(form, iforms.IForm)
# Create a keyed tag that will render the form when flattened.
tag = T.invisible(key=name)[inevow.IRenderer(form)]
# Create a new context, referencing the above tag, so that we don't
# pollute the current context with anything the form needs during
# rendering.
ctx = context.WovenContext(parent=ctx, tag=tag)
# Find errors for *this* form and remember things on the context
errors = iforms.IFormErrors(ctx, None)
if errors is not None and errors.formName == name:
ctx.remember(errors.data, iforms.IFormData)
else:
ctx.remember(None, iforms.IFormErrors)
ctx.remember(form.data or {}, iforms.IFormData)
return ctx
d = defer.succeed( ctx )
d.addCallback( locateForm, name )
d.addCallback( _processForm, ctx, name )
return d
return _
class Action(object):
"""Tracks an action that has been added to a form.
"""
def __init__(self, callback, name, validate):
self.callback = callback
self.name = name
self.validate = validate
class Form(object):
implements( iforms.IForm )
callback = None
items = None
actions = None
widgets = None
data = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
def addField(self, name, type, widgetFactory=None, label=None, description=None, cssClass=None):
if self.items is None:
self.items = []
type.name = name
if label is None:
label = util.titleFromName(name)
self.items.append( (name,type,label,description,cssClass) )
if widgetFactory is not None:
if self.widgets is None:
self.widgets = {}
self.widgets[name] = widgetFactory
def addAction(self, callback, name="submit", validate=True):
if self.actions is None:
self.actions = []
if name in [action.name for action in self.actions]:
raise ValueError('Action with name %r already exists.' % name)
self.actions.append( Action(callback, name, validate) )
def widgetForItem(self, itemName):
for name, type, label, description, cssClass in self.items:
if name == itemName:
break
else:
raise KeyError()
if self.widgets is not None:
try:
widgetFactory = self.widgets[name]
except KeyError:
pass
else:
return widgetFactory(type)
return iforms.IWidget(type)
def process(self, ctx):
# Unflatten the request into nested dicts.
args = {}
for name, value in inevow.IRequest(ctx).args.iteritems():
name = name.split('.')
group, name = name[:-1], name[-1]
d = args
for g in group:
d = args.setdefault(g,{})
d[name] = value
# Find the callback to use, defaulting to the form default
callback, validate = self.callback, True
if self.actions is not None:
for action in self.actions:
if action.name in args:
# Remove it from the data
args.pop(action.name)
# Remember the callback and whether to validate
callback, validate = action.callback, action.validate
break
if callback is None:
raise Exception('The form has no callback and no action was found.')
# Store an errors object in the context
errors = FormErrors(self.name)
errors.data = args
ctx.remember(errors, iforms.IFormErrors)
# Iterate the items and collect the form data and/or errors.
data = {}
for name, type, label, description, cssClass in self.items:
try:
if not type.immutable:
data[name] = self.widgetForItem(name).processInput(ctx, name, args)
else:
data[name] = self.data.get(name)
errors.data[name] = self.data.get(name)
except validation.FieldError, e:
if e.fieldName is None:
e.fieldName = name
errors.add(e)
if errors:
return errors
# toType
for name, type, label, description, cssClass in self.items:
widget = self.widgetForItem(name)
if hasattr( widget, 'convertibleFactory' ) and not type.immutable:
data[name] = widget.convertibleFactory(type).toType( data.get(name) )
def _clearUpResources( r ):
self.resourceManager.clearUpResources()
return r
d = defer.maybeDeferred(callback, ctx, self, data)
d.addCallback( _clearUpResources )
d.addErrback(self._cbFormProcessingFailed, ctx)
return d
def _cbFormProcessingFailed(self, failure, ctx):
e = failure.value
failure.trap(validation.FormError, validation.FieldError)
errors = iforms.IFormErrors(ctx)
errors.add(failure.value)
return errors
class FormErrors(object):
implements( iforms.IFormErrors )
errors = None
def __init__(self, formName):
self.formName = formName
def add(self, error):
if self.errors is None:
self.errors = []
self.errors.append(error)
def getFieldError(self, name):
if self.errors is None:
return None
fieldErrors = [e for e in self.errors if isinstance(e, validation.FieldError)]
for error in fieldErrors:
if error.fieldName == name:
return error
def getFormErrors(self):
return [e for e in self.errors if isinstance(e, validation.FormError)]
def __nonzero__(self):
return self.errors is not None
class ResourceMixin(object):
implements( iforms.IFormFactory )
def __init__(self, *a, **k):
super(ResourceMixin, self).__init__(*a, **k)
self.remember(self, iforms.IFormFactory)
def render_form(self, name):
def _(ctx, data):
return renderForm(name)
return _
def formFactory(self, ctx, name):
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
s = super(ResourceMixin, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
def locateChild(self, ctx, segments):
# Leave now if this it not meant for me.
if not segments[0].startswith(FORM_ACTION) and not segments[0].startswith(WIDGET_RESOURCE):
return super(ResourceMixin, self).locateChild(ctx, segments)
# Find the form name, the form and remember them.
formName = segments[0].split(ACTION_SEP)[1]
d = defer.succeed( ctx )
d.addCallback( locateForm, formName )
d.addCallback( self._processForm, ctx, segments )
return d
def _processForm( self, form, ctx, segments ):
ctx.remember(form, iforms.IForm)
# Serve up file from the resource manager
if segments[0].startswith( WIDGET_RESOURCE ):
return self._fileFromWidget( ctx, form, segments[1:] )
# Process the form.
d = defer.maybeDeferred(form.process, ctx)
d.addCallback(self._formProcessed, ctx)
return d
def _fileFromWidget( self, ctx, form, segments ):
widget = form.widgetForItem( segments[0] )
return widget.getResource( ctx, segments[1:] )
def _formProcessed(self, r, ctx):
if isinstance(r, FormErrors):
if r:
return NoAddSlashHack(self), ()
else:
r = None
if r is None:
r = url.URL.fromContext(ctx)
return r, ()
class IKnownForms(Interface):
"""Marker interface used to locate a dict instance containing the named
forms we know about during this request.
"""
class KnownForms(dict):
implements( IKnownForms )
def locateForm(ctx, name):
"""Locate a form by name.
Initially, a form is located by calling on an IFormFactory that is found
on the context. Once a form has been found, it is remembered in an
KnownForms instance for the lifetime of the request.
This ensures that the form that is located during form processing will be
the same instance that is located when a form is rendered after validation
failure.
"""
# Get hold of the request
request = inevow.IRequest(ctx)
# Find or create the known forms instance
knownForms = request.getComponent(IKnownForms)
if knownForms is None:
knownForms = KnownForms()
request.setComponent(IKnownForms, knownForms)
# See if the form is already known
form = knownForms.get(name)
if form is not None:
return form
# Not known yet, ask a form factory to create the form
factory = iforms.IFormFactory(ctx)
def cacheForm( form, name ):
if form is None:
raise Exception('Form %r not found'%name)
form.name = name
# Make it a known
knownForms[name] = form
return form
d = defer.succeed( None )
d.addCallback( lambda r : factory.formFactory( ctx, name ) )
d.addCallback( cacheForm, name )
return d
def formAction(name):
return '%s%s%s' % (FORM_ACTION, ACTION_SEP, name)
def formWidgetResource(name):
return '%s%s%s' % (WIDGET_RESOURCE, ACTION_SEP, name)
class FormRenderer(object):
implements( inevow.IRenderer )
loader = loaders.stan(
T.form(id=T.slot('id'), action=T.slot('action'), class_='nevow-form', method='post', enctype='multipart/form-data', **{'accept-charset':'utf-8'})[
T.input(type='hidden', name='_charset_'),
T.slot('errors'),
T.slot('items'),
T.div(id=T.slot('fieldId'), pattern='item', _class=T.slot('class'))[
T.label(_for=T.slot('id'))[T.slot('label')],
T.div(_class='inputs')[T.slot('inputs')],
T.slot('description'),
T.slot('message'),
],
T.div(class_='hiddenitems')[
T.slot('hiddenitems'),
T.invisible(pattern="hiddenitem")[T.slot('inputs')]
],
T.div(class_='actions')[
T.slot('actions'),
],
]
)
def __init__(self, original, *a, **k):
super(FormRenderer, self).__init__(*a, **k)
self.original = original
def rend(self, ctx, data):
segs = inevow.ICurrentSegments(ctx)
if segs and segs[-1].startswith(FORM_ACTION):
urlFactory = url.here.sibling
else:
urlFactory = url.here.child
tag = T.invisible[self.loader.load()]
tag.fillSlots('id', util.keytocssid(ctx.key))
tag.fillSlots('action', urlFactory(formAction(self.original.name)))
tag.fillSlots('errors', self._renderErrors)
tag.fillSlots('items', self._renderItems)
tag.fillSlots('hiddenitems', self._renderHiddenItems)
tag.fillSlots('actions', self._renderActions)
return tag
def _renderErrors(self, ctx, data):
errors = iforms.IFormErrors(ctx, None)
if errors is not None:
errors = errors.getFormErrors()
if not errors:
return ''
return T.div(class_='errors')[
T.p['Please correct the following errors:'],
T.ul[[T.li[str(error)] for error in errors]],
]
def _renderItems(self, ctx, data):
if self.original.items is None:
yield ''
return
itemPattern = inevow.IQ(ctx).patternGenerator('item')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') != 'hidden':
yield itemPattern(key=item[0], data=item, render=self._renderItem)
def _renderHiddenItems(self, ctx, data):
if self.original.items is None:
yield ''
return
hiddenItemPattern = inevow.IQ(ctx).patternGenerator('hiddenitem')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') == 'hidden':
yield hiddenItemPattern(key=item[0], data=item, render=self._renderHiddenItem)
def _renderItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
if formErrors is None:
error = None
else:
error = formErrors.getFieldError(name)
classes = [
'field',
type.__class__.__name__.lower(),
widget.__class__.__name__.lower(),
]
if cssClass:
classes.append(cssClass)
if error is None:
message = ''
else:
classes.append('error')
message = T.div(class_='message')[str(error)]
ctx.tag.fillSlots('class', ' '.join(classes))
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('label', label)
if type.immutable:
render = widget.renderImmutable
else:
render = widget.render
ctx.tag.fillSlots('inputs', render(ctx, name, formData, formErrors))
ctx.tag.fillSlots('message', message)
ctx.tag.fillSlots('description', T.div(class_='description')[description or ''])
return ctx.tag
return _
def _renderHiddenItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('inputs', widget.render(ctx, name, formData, formErrors))
return ctx.tag
return _
def _renderActions(self, ctx, data):
if self.original.actions is None:
yield ''
return
for action in self.original.actions:
yield T.invisible(data=action, render=self._renderAction)
def _renderAction(self, ctx, data):
return T.input(type='submit', id='%s-action-%s'%(util.keytocssid(ctx.key), data.name), name=data.name, value=util.titleFromName(data.name))
class NoAddSlashHack:
implements( inevow.IResource )
def __init__(self, wrapped):
self.wrapped = wrapped
def __getattr__(self, name):
return getattr(self.wrapped, name)
def renderHTTP(self, ctx):
MISSING = object()
addSlash = getattr(self.wrapped, 'addSlash', MISSING)
if addSlash:
self.wrapped.addSlash = False
try:
r = self.wrapped.renderHTTP(ctx)
finally:
if addSlash is not MISSING:
self.wrapped.addSlash = addSlash
else:
del self.wrapped.addSlash
return r
registerAdapter(FormRenderer, Form, inevow.IRenderer)
| Python |
from nevow import tags as T, util
from forms import iforms
from zope.interface import implements
tinyMCEGlue = T.xml("""
<!-- tinyMCE -->
<script language="javascript" type="text/javascript" src="/tiny_mce/tiny_mce.js"></script>
<script language="javascript" type="text/javascript">
tinyMCE.init({
mode : "specific_textareas"
theme: 'advanced',
theme_advanced_toolbar_location: 'top',
theme_advanced_toolbar_align: 'left'
});
</script>
<!-- /tinyMCE -->
""" )
class TinyMCE(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.textarea(name=key, id=key, mce_editable='true')[value or '']
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if value:
value=T.xml(value)
else:
value=''
return T.div(id=key, class_="readonly-textarea-container") [
T.div(class_='readonly-textarea readonly')[value]
]
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
| Python |
import tempfile
import mimetypes
import re
import os
from shutil import copyfileobj
from exceptions import IOError, OSError
class ResourceManagerException( Exception ):
def __init__( self, *args, **kwds ):
super( ResourceManagerException, self ).__init__( *args, **kwds )
class ResourceManager( object ):
def __init__( self ):
self.widgetToID = {}
def register( self, widgetName, resourceId ):
self.widgetToID[widgetName] = resourceId
def getResourceId( self, widgetName ):
return self.widgetToID.get( widgetName )
def getResourceForWidget( self, widgetName ):
resourceId = self.getResourceId( widgetName )
if resourceId is None:
return None
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
try:
filelike = open( path, 'r' )
return (mimetype, filelike, fileName)
except IOError:
return None
def getResourcePath( self, resourceId ):
"""
Required to create an instance of nevow.static.File
"""
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
return (mimetype, path, fileName)
def setResource( self, widgetName, filelike, fileName ):
existingResource = self.widgetToID.get( widgetName )
if existingResource is not None:
try:
(path, ignore) = self._fromResourceId( existingResource )
os.remove( path )
except OSError:
pass
fileName = fileName.replace( '_', '-' )
(target, path) = tempfile.mkstemp( '__' + fileName )
os.close( target )
target = open( path, 'w' )
copyfileobj( filelike, target )
target.close()
resourceId = self._toResourceId( path )
self.widgetToID[widgetName] = resourceId
return resourceId
def _fromResourceId( self, resourceId ):
match = re.match( '^.*__(.*)$', resourceId )
if match is None:
return None
fileName = match.group( 1 )
path = os.sep.join( (tempfile.gettempdir(), resourceId) )
return path, fileName
def _toResourceId( self, path ):
path = path[len(tempfile.gettempdir()):]
if path[0] == os.sep:
path = path[1:]
return path
def clearUpResources( self ):
for id in self.widgetToID.values():
try:
(path, fileName) = self._fromResourceId( id )
os.remove( path )
except OSError:
pass
| Python |
"""Adapters for converting to and from a type's value according to an
IConvertible protocol.
"""
from datetime import date, time
from nevow.compy import Adapter
from forms import iforms, validation
from zope.interface import implements
class NullConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value
def toType(self, value):
if value is None:
return None
return value
class NumberToStringConverter(Adapter):
implements( iforms.IStringConvertible )
cast = None
def fromType(self, value):
if value is None:
return None
return str(value)
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
try:
value = self.cast(value)
except ValueError:
raise validation.FieldValidationError("Not a valid number")
return value
class IntegerToStringConverter(NumberToStringConverter):
cast = int
class FloatToStringConverter(NumberToStringConverter):
cast = float
class BooleanToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
if value:
return 'True'
return 'False'
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
if value not in ('True', 'False'):
raise validation.FieldValidationError('%r should be either True or False')
return value == 'True'
class DateToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseDate(value)
def parseDate(self, value):
try:
y, m, d = [int(p) for p in value.split('-')]
except ValueError:
raise validation.FieldValidationError('Invalid date')
try:
value = date(y, m, d)
except ValueError, e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
class TimeToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseTime(value)
def parseTime(self, value):
if '.' in value:
value, ms = value.split('.')
else:
ms = 0
try:
parts = value.split(':')
if len(parts)<2 or len(parts)>3:
raise ValueError()
if len(parts) == 2:
h, m = parts
s = 0
else:
h, m, s = parts
h, m, s, ms = int(h), int(m), int(s), int(ms)
except:
raise validation.FieldValidationError('Invalid time')
try:
value = time(h, m, s, ms)
except ValueError, e:
raise validation.FieldValidationError('Invalid time: '+str(e))
return value
class DateToDateTupleConverter(Adapter):
implements( iforms.IDateTupleConvertible )
def fromType(self, value):
if value is None:
return None, None, None
return value.year, value.month, value.day
def toType(self, value):
if value is None:
return None
try:
value = date(*value)
except (TypeError, ValueError), e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
| Python |
from forms import iforms
from zope.interface import implements
def titleFromName(name):
def _():
it = iter(name)
last = None
while 1:
ch = it.next()
if ch == '_':
if last != '_':
yield ' '
elif last in (None,'_'):
yield ch.upper()
elif ch.isupper() and not last.isupper():
yield ' '
yield ch.upper()
else:
yield ch
last = ch
return ''.join(_())
def keytocssid(key):
return '-'.join(key.split('.'))
class SequenceKeyLabelAdapter(object):
implements( iforms.IKey, iforms.ILabel )
def __init__(self, original):
self.original = original
def key(self):
return self.original[0]
def label(self):
return self.original[1]
| Python |
"""
Widgets are small components that render form fields for inputing data in a
certain format.
"""
from nevow import inevow, tags as T, util, url, static
from forms import converters, iforms, validation
from forms.util import keytocssid
from forms.form import formWidgetResource
from zope.interface import implements
from twisted.internet import defer
# Marker object for args that are not supplied
_UNSET = object()
class TextInput(object):
implements( iforms.IWidget )
inputType = 'text'
showValueOnFailure = True
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, readonly):
tag=T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if not self.showValueOnFailure:
value = None
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class Checkbox(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, disabled):
tag = T.input(type='checkbox', name=key, id=keytocssid(ctx.key), value='True')
if value == 'True':
tag(checked='checked')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [None])[0]
if not value:
value = 'False'
value = iforms.IBooleanConvertible(self.original).toType(value)
return self.original.validate(value)
class Password(TextInput):
inputType = 'password'
showValueOnFailure = False
class TextArea(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, readonly):
tag=T.textarea(name=key, id=keytocssid(ctx.key))[value or '']
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class CheckedPassword(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors and not errors.getFieldError(key):
values = args.get(key)
else:
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0]),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1]),
]
def renderImmutable(self, ctx, key, args, errors):
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0], class_='readonly', readonly='readonly'),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1], class_='readonly', readonly='readonly')
]
def processInput(self, ctx, key, args):
pwds = [pwd for pwd in args.get(key, [])]
if len(pwds) == 0:
pwd = ''
elif len(pwds) == 1:
raise validation.FieldValidationError('Please enter the password twice for confirmation.')
else:
if pwds[0] != pwds[1]:
raise validation.FieldValidationError('Passwords do not match.')
return self.original.validate(pwds[0])
class SelectChoice(object):
implements( iforms.IWidget )
options = None
noneOption = ('', '')
def __init__(self, original, options=None, noneOption=_UNSET):
self.original = original
if options is not None:
self.options = options
if noneOption is not _UNSET:
self.noneOption = noneOption
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iforms.IKey(self.noneOption).key())[iforms.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
option = T.option(value=optValue)[optLabel]
if optValue == value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=keytocssid(ctx.key), data=self.options)[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0]
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class DatePartsInput(object):
implements( iforms.IWidget )
dayFirst = False
def __init__(self, original, dayFirst=None):
self.original = original
if dayFirst is not None:
self.dayFirst = dayFirst
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, day, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=4)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
dayTag = T.input(type="text", name=namer('day'), value=day, size=2)
if readonly:
tags = (yearTag, monthTag, dayTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
if self.dayFirst:
return dayTag, ' / ', monthTag, ' / ', yearTag, ' (dd/mm/yyyy)'
else:
return monthTag, ' / ', dayTag, ' / ', yearTag, ' (mm/dd/yyyy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
day = args.get(namer('day'), [''])[0]
else:
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month', 'day')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 3:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
value = iforms.IDateTupleConvertible(self.original).toType(value)
return self.original.validate(value)
class MMYYDatePartsInput(object):
implements( iforms.IWidget )
cutoffYear = 70
def __init__(self, original, cutoffYear=None):
self.original = original
if cutoffYear is not None:
self.cutoffYear = cutoffYear
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=2)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
if readonly:
tags=(yearTag, monthTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
return monthTag, ' / ', yearTag, ' (mm/yy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
# return a blank for the day
day = ''
else:
year, month, day = converter.fromType(args.get(key))
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
year, month, day = converter.fromType(args.get(key))
namer = self._namer(key)
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 2:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
if value[1] < 0 or value[1] > 99:
raise validation.FieldValidationError("Invalid year. Please enter a two-digit year.")
if value[0] > self.cutoffYear:
value[0] = 1900 + value[0]
else:
value[0] = 2000 + value[0]
value.append(1)
value = iforms.IDateTupleConvertible(self.original).toType( value )
return self.original.validate(value)
class CheckboxMultiChoice(object):
implements( iforms.IWidget )
options = None
noneOption = ('', '')
def __init__(self, original, options=None, noneOption=_UNSET):
self.original = original
if options is not None:
self.options = options
if noneOption is not _UNSET:
self.noneOption = noneOption
def _renderTag(self, ctx, key, values, converter, disabled):
# loops through checkbox options and renders
for n,item in enumerate(self.options):
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
optid = (keytocssid(ctx.key),'-',n)
checkbox = T.input(type='checkbox', name=key, value=optValue, id=optid )
if optValue in values:
checkbox = checkbox(checked='checked')
if disabled:
checkbox = checkbox(class_='disabled', disabled='disabled')
yield checkbox, T.label(for_=optid)[optLabel], T.br()
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
if errors:
values = args.get(key, [])
else:
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, True)
def processInput(self, ctx, key, args):
values = args.get(key, [])
converter = iforms.IStringConvertible(self.original.type)
values = [converter.toType(v) for v in values]
return self.original.validate(values)
class FileUploadRaw(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, disabled):
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
value = (name, fileitem.file)
value = iforms.IFileConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUpload(object):
implements( iforms.IWidget )
def __init__(self, original, fileHandler, preview=None):
self.original = original
self.fileHandler = fileHandler
self.preview = preview
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, key, value, namer, disabled):
name = self.fileHandler.getUrlForFile(value)
if name:
if self.preview == 'image':
yield T.p[value,T.img(src=self.fileHandler.getUrlForFile(value))]
else:
yield T.p[value]
else:
yield T.p[T.strong['nothing uploaded']]
yield T.input(name=namer('value'),value=value,type='hidden')
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
yield tag
def render(self, ctx, key, args, errors):
namer = self._namer(key)
if errors:
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = name
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, False)
def renderImmutable(self, ctx, key, args, errors):
namer = self._namer(key)
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = self.fileHandler.storeFile( fileitem.file, name )
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUploadWidget(object):
implements( iforms.IWidget )
FROM_RESOURCE_MANAGER = 'rm'
FROM_CONVERTIBLE = 'cf'
convertibleFactory = converters.NullConverter
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def __init__( self, original, convertibleFactory=None, originalKeyIsURL=False ):
self.original = original
if convertibleFactory is not None:
self.convertibleFactory = convertibleFactory
self.originalKeyIsURL = originalKeyIsURL
def _blankField( self, field ):
"""
Convert empty strings into None.
"""
if field and field == '':
return None
return field
def _getFromArgs( self, args, name ):
"""
Get the first value of 'name' from 'args', or None.
"""
rv = args.get( name )
if rv:
rv = rv[0]
return rv
def render(self, ctx, key, args, errors):
"""
Render the data.
This either renders a link to the original file, if specified, and
no new file has been uploaded. Or a link to the uploaded file.
The request to get the data should be routed to the getResouce
method.
"""
form = iforms.IForm( ctx )
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
originalIdName = namer( 'original_id' )
# get the resource id first from the resource manager
# then try the request
resourceId = form.resourceManager.getResourceId( key )
if resourceId is None:
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
# Get the original key from a hidden field in the request,
# then try the request file.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if errors:
urlFactory = url.URL.fromContext( ctx ).sibling
else:
urlFactory = url.URL.fromContext( ctx ).child
if resourceId:
# Have an uploaded file, so render a URL to the uploaded file
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child( self.FROM_RESOURCE_MANAGER ).child( resourceId )
yield T.p[T.img(src=tmpURL)]
elif originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child( self.FROM_CONVERTIBLE ).child( originalKey )
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
yield T.input(name=key, id=keytocssid(ctx.key),type='file')
# Id of uploaded file in the resource manager
yield T.input(name=resourceIdName,value=resourceId,type='hidden')
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def renderImmutable(self, ctx, key, args, errors):
form = iforms.IForm(ctx)
namer = self._namer(key)
originalIdName = namer('original_id')
# Get the original key from a hidden field in the request,
# then try the request form.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if errors:
urlFactory = url.URL.fromContext( ctx ).sibling
else:
urlFactory = url.URL.fromContext( ctx ).child
if originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child(self.FROM_CONVERTIBLE).child(originalKey)
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def processInput(self, ctx, key, args):
"""
Process the request, storing any uploaded file in the
resource manager.
"""
resourceManager = iforms.IForm( ctx ).resourceManager
# Ping the resource manager with any resource ids that I know
self._registerWithResourceManager( key, args, resourceManager )
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
# Store the uploaded file in the resource manager
resourceManager.setResource( key, fileitem.file, name )
# Validating against an uploaded file. Should the fact that there is
# original file meet a required field validation?
return self.original.validate( resourceManager.getResourceForWidget( key ) )
def _registerWithResourceManager( self, key, args, resourceManager ):
"""
If there is a resource id in the request, then let the
resource manager know about it.
"""
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
if resourceId:
resourceManager.register( key, resourceId )
def getResource( self, ctx, segments ):
"""
Return an Resource that contains the image, either a file
from the resource manager, or a data object from the convertible.
"""
if segments[0] == self.FROM_RESOURCE_MANAGER:
# Resource manager can provide a path so return a static.File
# instance that points to the file
rm = iforms.IForm( ctx ).resourceManager
(mimetype, path, fileName) = rm.getResourcePath( segments[1] )
return static.File( path, mimetype ), []
elif segments[0] == self.FROM_CONVERTIBLE:
# The convertible can provide a file like object so create a
# static.Data instance with the data from the convertible.
def _( result ):
mimetype, filelike, fileName = result
data = filelike.read()
filelike.close()
return static.Data( data, mimetype ), []
d = defer.maybeDeferred( self.convertibleFactory(self.original).fromType, segments[1], context=ctx )
d.addCallback( _ )
return d
else:
return None
class Hidden(object):
__implements__ = iforms.IWidget,
inputType = 'hidden'
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
def renderImmutable(self, ctx, key, args, errors):
return self.render(ctx, key, args, errors)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
__all__ = [
'Checkbox', 'CheckboxMultiChoice', 'CheckedPassword','FileUploadRaw', 'FileUpload', 'FileUploadWidget',
'Password', 'SelectChoice', 'TextArea', 'TextInput', 'DatePartsInput',
'MMYYDatePartsInput', 'Hidden'
]
| Python |
import re
from zope.interface import implements
from forms import iforms
class FormError(Exception):
pass
class FieldError(Exception):
def __init__(self, message, fieldName=None):
Exception.__init__(self, message)
self.message = message
self.fieldName = fieldName
class FieldValidationError(FieldError):
pass
class FieldRequiredError(FieldValidationError):
pass
class RequiredValidator(object):
implements(iforms.IValidator)
def validate(self, field, value):
if value is None:
raise FieldRequiredError, 'Required'
class LengthValidator(object):
"""Validate the length of the value is within a given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be longer than %r characters'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be shorter than %r characters'%(self.max,)
return 'Must be between %r and %r characters'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
length = len(value)
if self.min is not None and length < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and length > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class RangeValidator(object):
"""Validate the size of the value is within is given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be greater than %r'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be less than %r'%(self.max,)
return 'Must be between %r and %r'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
if self.min is not None and value < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and value > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class PatternValidator(object):
"""Validate the value is a certain pattern.
The required pattern is defined as a regular expression. The regex will be
compiled automatically if necessary.
"""
implements(iforms.IValidator)
def __init__(self, regex):
self.regex = regex
def validate(self, field, value):
if value is None:
return
# If it doesn't look like a regex object then compile it now
if not hasattr(self.regex, 'match'):
self.regex = re.compile(self.regex)
if self.regex.match(value) is None:
raise FieldValidationError, 'Invalid format'
__all__ = [
'FormError', 'FieldError', 'FieldValidationError', 'FieldRequiredError',
'RequiredValidator', 'LengthValidator', 'RangeValidator', 'PatternValidator',
]
| Python |
import forms
title = 'Simple Form'
description = 'Probably the simplest form possible.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import forms
title = 'Form Types'
description = 'Example of using different typed fields.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aInteger', forms.Integer())
form.addField('aFloat', forms.Float())
form.addField('aBoolean', forms.Boolean())
form.addField('aDate', forms.Date())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from datetime import date
import forms
title = 'Missing Values'
description = 'Providing default values when missing'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String(missing='<nothing>'))
form.addField('aDate', forms.Date(missing=date(2005, 8, 1)))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
import pkg_resources
from twisted.python import reflect
from nevow import appserver, loaders, rend, static, tags as T, url
import forms
examples = [
'forms.examples.simple',
'forms.examples.types',
'forms.examples.required',
'forms.examples.missing',
'forms.examples.prepopulate',
]
def makeSite(application):
root = RootPage()
site = appserver.NevowSite(root, logPath='web.log')
return site
class RootPage(rend.Page):
docFactory = loaders.stan(
T.html[
T.head[
T.title['Forms Examples'],
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
],
T.body[
T.directive('examples'),
],
]
)
def render_examples(self, ctx, data):
for name in examples:
module = reflect.namedAny(name)
yield T.div(class_='example')[
T.h1[T.a(href=url.here.child(name))[module.title]],
T.p[module.description],
]
def childFactory(self, ctx, name):
if name in examples:
return FormPage(reflect.namedAny(name))
class FormPage(forms.ResourceMixin, rend.Page):
docFactory = loaders.stan(
T.html[
T.head[
T.title(data=T.directive('title'), render=rend.data),
T.link(rel='stylesheet', type='text/css', href=url.root.child('forms.css')),
],
T.body[
T.h1(data=T.directive('title'), render=rend.data),
T.p(data=T.directive('description'), render=rend.data),
T.directive('form example'),
],
]
)
def data_title(self, ctx, data):
return self.original.title
def data_description(self, ctx, data):
return self.original.description
def form_example(self, ctx):
return self.original.makeForm(ctx)
# Add child_ attributes
examples_css = pkg_resources.resource_filename('forms.examples', 'examples.css')
setattr(RootPage, 'child_examples.css', static.File(examples_css))
setattr(RootPage, 'child_forms.css', forms.defaultCSS)
| Python |
from datetime import datetime
import forms
title = 'Prepopulate'
description = 'Example of prepopulating form fields'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
form.data = {
'aTime': datetime.utcnow().time(),
}
return form
def formSubmitted(ctx, form, data):
print data
| Python |
import forms
title = 'Required Fields'
description = 'Demonstration of required fields'
def makeForm(ctx):
form = forms.Form()
form.addField('name', forms.String(required=True))
form.addField('age', forms.Integer())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
"""A package (for Nevow) for defining the schema, validation and rendering of
HTML forms.
"""
version_info = (0, 1, 0)
version = '.'.join([str(i) for i in version_info])
from nevow import static
from forms.types import *
from forms.validation import *
from forms.widget import *
from forms.form import Form, ResourceMixin, renderForm
from forms import iforms
def widgetFactory(widgetClass, *a, **k):
def _(original):
return widgetClass(original, *a, **k)
return _
try:
import pkg_resources
except ImportError:
import os.path
defaultCSS = static.File(os.path.join(os.path.split(__file__)[0], 'forms.css'))
else:
defaultCSS = static.File(pkg_resources.resource_filename('forms', 'forms.css'))
# Register standard adapters
from nevow.compy import registerAdapter
from forms import converters
registerAdapter(TextInput, String, iforms.IWidget)
registerAdapter(TextInput, Integer, iforms.IWidget)
registerAdapter(TextInput, Float, iforms.IWidget)
registerAdapter(Checkbox, Boolean, iforms.IWidget)
registerAdapter(DatePartsInput, Date, iforms.IWidget)
registerAdapter(TextInput, Time, iforms.IWidget)
registerAdapter(FileUploadRaw, File, iforms.IWidget)
from forms import util
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.IKey)
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.ILabel)
registerAdapter(converters.NullConverter, String, iforms.IStringConvertible)
registerAdapter(converters.DateToDateTupleConverter, Date, iforms.IDateTupleConvertible)
registerAdapter(converters.BooleanToStringConverter, Boolean, iforms.IBooleanConvertible)
registerAdapter(converters.IntegerToStringConverter, Integer, iforms.IStringConvertible)
registerAdapter(converters.FloatToStringConverter, Float, iforms.IStringConvertible)
registerAdapter(converters.DateToStringConverter, Date, iforms.IStringConvertible)
registerAdapter(converters.TimeToStringConverter, Time, iforms.IStringConvertible)
registerAdapter(converters.NullConverter, File, iforms.IFileConvertible)
registerAdapter(converters.NullConverter, Sequence, iforms.ISequenceConvertible)
del registerAdapter
| Python |
from nevow.compy import Interface
class IType(Interface):
def validate(self, value):
pass
class IStructure(Interface):
pass
class IWidget(Interface):
def render(self, ctx, key, args, errors):
pass
def processInput(self, ctx, key, args):
pass
class IFormFactory(Interface):
def formFactory(self, ctx, name):
pass
class IFormData(Interface):
pass
class IFormErrors(Interface):
pass
class IKey(Interface):
def key(self):
pass
class ILabel(Interface):
def label(self):
pass
class IConvertible(Interface):
def fromType(self, value):
pass
def toType(self, value):
pass
class IStringConvertible(IConvertible):
pass
class IBooleanConvertible(IConvertible):
pass
class IDateTupleConvertible(IConvertible):
pass
class IFileConvertible(IConvertible):
pass
class ISequenceConvertible(IConvertible):
pass
class IForm( Interface ):
pass
class IValidator(Interface):
def validate(self, field, value):
pass
| Python |
from twisted.application import internet, service
from nevow import appserver
from forms.examples import main
application = service.Application('examples')
service = internet.TCPServer(8000, main.makeSite(application))
service.setServiceParent(application)
| Python |
from setuptools import setup, find_packages
import forms
setup(
name='forms',
version=forms.version,
description='HTML forms framework for Nevow',
author='Matt Goodall',
author_email='matt@pollenation.net',
packages=find_packages(),
package_data={
'forms': ['forms.css'],
}
)
| Python |
from datetime import date, time
from twisted.application import internet, service
from nevow import appserver, compy, loaders, rend, static, tags as T
import forms
import os
from shutil import copyfileobj
import mimetypes, datetime
from forms import iforms, htmleditor, converters
from fileresource import fileResource
class KeyToFileConverter( object ):
__implements__ = iforms.IFileConvertible,
def fromType( self, value, context=None ):
"""
Given a string generate a (mimetype, filelike, fileName) or None
"""
if not value or value == '':
return None
mimetype = mimetypes.guess_type( value )
filelike = open(os.path.join('images',value),'r')
return (mimetype, filelike, value)
def toType( self, value ):
"""
Given a (mimetype, filelike, filename) tuple return a string
"""
if not value:
return None
(mimetype, filelike,fileName) = value;
target = file(os.path.join('images',fileName),'w')
copyfileobj( filelike, target )
target.close()
filelike.close()
return fileName
dates = [
(date(2005,1,1), 'New year\'s day'),
(date(2005,11,6), 'My birthday'),
(date(2005,12,25), 'Christmas day'),
]
times = [
(time(5,0), 'Really early'),
(time(7,0), 'A bit too early'),
(time(8,0), 'Hmm, not bad'),
(time(10,0), 'Nice :)'),
]
class Person(object):
def __init__(self, id, firstName, lastName):
self.id = id
self.firstName = firstName
self.lastName = lastName
class PersonKeyLabelAdapter(object):
__implements__ = iforms.IKey, iforms.ILabel
def __init__(self, original):
self.original = original
def key(self):
return self.original.id
def label(self):
return '%s, %s' % (self.original.lastName, self.original.firstName)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.IKey)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.ILabel)
people = [
Person(1, 'Matt', 'Goodall'),
Person(2, 'Tim', 'Parkin'),
]
class Page(rend.Page, forms.ResourceMixin):
addSlash = True
docFactory = loaders.xmlfile('test.html')
def __init__(self, *a, **k):
rend.Page.__init__(self, *a, **k)
forms.ResourceMixin.__init__(self)
def child_self(self, ctx):
return self
def form_oneOfEach(self, ctx):
form = forms.Form(self._submit)
form.addField('hidden_string', forms.Integer(), forms.Hidden)
form.addField('string', forms.String(required=True))
form.addField('password', forms.String(), forms.CheckedPassword)
form.addField('integer', forms.Integer())
form.addField('float', forms.Float())
form.addField('boolean', forms.Boolean())
form.addField('date', forms.Date(), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('time', forms.Time())
form.addAction(self._submit)
form.data = {'hidden_string': 101}
return form
def form_readonlyOneOfEach(self, ctx):
form = forms.Form(self._submit)
immutable=True
form.addField('string', forms.String(immutable=immutable), forms.TextInput)
form.addField('textarea', forms.String(immutable=immutable), forms.TextArea)
form.addField('password', forms.String(immutable=immutable), forms.CheckedPassword)
form.addField('integer', forms.Integer(immutable=immutable))
form.addField('float', forms.Float(immutable=immutable))
form.addField('boolean', forms.Boolean(immutable=immutable), forms.Checkbox)
form.addField('date', forms.Date(immutable=immutable), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('date2', forms.Date(immutable=immutable), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('time', forms.Time(immutable=immutable))
form.addField('author', forms.Integer(immutable=immutable), lambda original: forms.SelectChoice(original, people))
form.addField('bar', forms.Sequence(forms.String(),immutable=immutable), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.addField('file', forms.File(immutable=immutable), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
form.data = {'string':'hello', 'textarea':'some long text', 'password': ['one','one'], 'integer':10, 'float':22.22, 'boolean':True, 'author': 2, 'file':'dm.gif', 'date': datetime.date(2005, 10, 1), 'bar': ['a'], 'time': datetime.time(12, 51, 30)}
return form
def form_test(self, ctx):
form = forms.Form(self._submit)
form.addField('lastName', forms.String(required=True), label='Surname', description='This should be used to store your surname.. no really!!')
form.addField('date', forms.Date(), forms.widgetFactory(forms.SelectChoice, dates))
form.addField('time', forms.Time(), lambda original: forms.SelectChoice(original, times))
form.addField('author', forms.Integer(), lambda original: forms.SelectChoice(original, people))
form.addField('notes', forms.String(), htmleditor.TinyMCE)
form.addField('foo', forms.Sequence(forms.Time()), forms.widgetFactory(forms.CheckboxMultiChoice, times))
form.addField('bar', forms.Sequence(forms.String(),required=True), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.data = {'foo': [time(10,0)]}
form.addAction(self._submit)
form.addAction(self._submit, 'another')
return form
def form_1(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_2(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_3(self, ctx):
''' This test needs an 'assets' folder to store files in. The widget is passed a fileResource which
is used to get a preview url and to save the upload results. commit/rollback type hooks will need
to be added to forms to allow 'clean' operation. -- tp
'''
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.String(required=True), forms.widgetFactory(forms.FileUpload,fileResource(),preview='image'))
form.addAction(self._submit)
#form.data = {
# 'file': 'product.jpg'
# }
return form
def form_4(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.File(required=True), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
# form.data = {
# 'file': 'dm.gif'
# }
return form
def _submit(self, ctx, form, data):
print form
print data
if data.get('string') == 'error':
raise forms.FieldError('Failed the field!', 'string')
if data.get('string') == 'formerror':
raise forms.FormError('Failed the form!')
setattr(Page, 'child_nevow-forms.css', forms.defaultCSS)
setattr(Page, 'child_tiny_mce', static.File('tiny_mce'))
setattr(Page, 'child_webassets', static.File('assets'))
setattr(Page, 'child_images', static.File('images'))
setattr(Page, 'child_uploads', static.File('uploads'))
root = Page()
site = appserver.NevowSite(root, logPath='/dev/null')
application = service.Application('forms2-test')
internet.TCPServer(8000, site).setServiceParent(application)
| Python |
import os
from shutil import copyfileobj
FILESTORE_DIR='assets'
FILESTORE_URL='webassets'
class fileResource:
def getUrlForFile(self, id):
if id:
return os.path.join(FILESTORE_URL, id)
else:
return None
def storeFile( self, source, name ):
id = name
target = file(os.path.join(FILESTORE_DIR,id),'w')
copyfileobj( source, target )
target.close()
return id | Python |
"""
Form types.
"""
from forms import iforms, validation
from zope.interface import implements
class Type(object):
implements( iforms.IType )
# Name of the instance
name = None
# Instance is required
required = False
# Value to use if no value entered
missing = None
# Instance cannot be changed
immutable = False
# List of validators to test the value against
validators = []
def __init__(self, name=None, required=None, missing=None, immutable=None, validators=None):
if name is not None:
self.name = name
if missing is not None:
self.missing = missing
if immutable is not None:
self.immutable = immutable
if validators is not None:
self.validators = validators[:]
else:
self.validators = self.validators[:]
if required is None:
required = self.required
if required:
self.validators.append(validation.RequiredValidator())
def validate(self, value):
for validator in self.validators:
validator.validate(self, value)
if value is None:
value = self.missing
return value
class String(Type):
# Strip the value before validation
strip = False
def __init__(self, **k):
strip = k.pop('strip', None)
if strip is not None:
self.strip = strip
super(String, self).__init__(**k)
def validate(self, value):
if value is not None and self.strip:
value = value.strip()
if not value:
value = None
return super(String, self).validate(value)
class Integer(Type):
pass
class Float(Type):
pass
class Boolean(Type):
pass
class Date(Type):
pass
class Time(Type):
pass
class Sequence(Type):
# Type of items in the sequence
type = None
def __init__(self, type=None, **k):
super(Sequence, self).__init__(**k)
if type is not None:
self.type = type
def validate(self, value):
# Map empty sequence to None
if not value:
value = None
return super(Sequence, self).validate(value)
class File(Type):
pass
__all__ = [
'Boolean', 'Date', 'File', 'Float', 'Integer', 'Sequence', 'String', 'Time',
]
| Python |
"""
Form implementation and high-level renderers.
"""
from twisted.internet import defer
from nevow import context, loaders, inevow, tags as T, url
from nevow.compy import registerAdapter, Interface
from forms import iforms, util, validation
from resourcemanager import ResourceManager
from zope.interface import implements
ACTION_SEP = '!!'
FORM_ACTION = '__nevow_form__'
WIDGET_RESOURCE = '__widget_res__'
def renderForm(name):
def _(ctx, data):
def _processForm( form, ctx, name ):
# Find the form
ctx.remember(form, iforms.IForm)
# Create a keyed tag that will render the form when flattened.
tag = T.invisible(key=name)[inevow.IRenderer(form)]
# Create a new context, referencing the above tag, so that we don't
# pollute the current context with anything the form needs during
# rendering.
ctx = context.WovenContext(parent=ctx, tag=tag)
# Find errors for *this* form and remember things on the context
errors = iforms.IFormErrors(ctx, None)
if errors is not None and errors.formName == name:
ctx.remember(errors.data, iforms.IFormData)
else:
ctx.remember(None, iforms.IFormErrors)
ctx.remember(form.data or {}, iforms.IFormData)
return ctx
d = defer.succeed( ctx )
d.addCallback( locateForm, name )
d.addCallback( _processForm, ctx, name )
return d
return _
class Action(object):
"""Tracks an action that has been added to a form.
"""
def __init__(self, callback, name, validate):
self.callback = callback
self.name = name
self.validate = validate
class Form(object):
implements( iforms.IForm )
callback = None
items = None
actions = None
widgets = None
data = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
def addField(self, name, type, widgetFactory=None, label=None, description=None, cssClass=None):
if self.items is None:
self.items = []
type.name = name
if label is None:
label = util.titleFromName(name)
self.items.append( (name,type,label,description,cssClass) )
if widgetFactory is not None:
if self.widgets is None:
self.widgets = {}
self.widgets[name] = widgetFactory
def addAction(self, callback, name="submit", validate=True):
if self.actions is None:
self.actions = []
if name in [action.name for action in self.actions]:
raise ValueError('Action with name %r already exists.' % name)
self.actions.append( Action(callback, name, validate) )
def widgetForItem(self, itemName):
for name, type, label, description, cssClass in self.items:
if name == itemName:
break
else:
raise KeyError()
if self.widgets is not None:
try:
widgetFactory = self.widgets[name]
except KeyError:
pass
else:
return widgetFactory(type)
return iforms.IWidget(type)
def process(self, ctx):
# Unflatten the request into nested dicts.
args = {}
for name, value in inevow.IRequest(ctx).args.iteritems():
name = name.split('.')
group, name = name[:-1], name[-1]
d = args
for g in group:
d = args.setdefault(g,{})
d[name] = value
# Find the callback to use, defaulting to the form default
callback, validate = self.callback, True
if self.actions is not None:
for action in self.actions:
if action.name in args:
# Remove it from the data
args.pop(action.name)
# Remember the callback and whether to validate
callback, validate = action.callback, action.validate
break
if callback is None:
raise Exception('The form has no callback and no action was found.')
# Store an errors object in the context
errors = FormErrors(self.name)
errors.data = args
ctx.remember(errors, iforms.IFormErrors)
# Iterate the items and collect the form data and/or errors.
data = {}
for name, type, label, description, cssClass in self.items:
try:
if not type.immutable:
data[name] = self.widgetForItem(name).processInput(ctx, name, args)
else:
data[name] = self.data.get(name)
errors.data[name] = self.data.get(name)
except validation.FieldError, e:
if e.fieldName is None:
e.fieldName = name
errors.add(e)
if errors:
return errors
# toType
for name, type, label, description, cssClass in self.items:
widget = self.widgetForItem(name)
if hasattr( widget, 'convertibleFactory' ) and not type.immutable:
data[name] = widget.convertibleFactory(type).toType( data.get(name) )
def _clearUpResources( r ):
self.resourceManager.clearUpResources()
return r
d = defer.maybeDeferred(callback, ctx, self, data)
d.addCallback( _clearUpResources )
d.addErrback(self._cbFormProcessingFailed, ctx)
return d
def _cbFormProcessingFailed(self, failure, ctx):
e = failure.value
failure.trap(validation.FormError, validation.FieldError)
errors = iforms.IFormErrors(ctx)
errors.add(failure.value)
return errors
class FormErrors(object):
implements( iforms.IFormErrors )
def __init__(self, formName):
self.formName = formName
self.errors = []
def add(self, error):
self.errors.append(error)
def getFieldError(self, name):
fieldErrors = [e for e in self.errors if isinstance(e, validation.FieldError)]
for error in fieldErrors:
if error.fieldName == name:
return error
def getFormErrors(self):
return [e for e in self.errors if isinstance(e, validation.FormError)]
def __nonzero__(self):
return len(self.errors) != 0
class ResourceMixin(object):
implements( iforms.IFormFactory )
def __init__(self, *a, **k):
super(ResourceMixin, self).__init__(*a, **k)
self.remember(self, iforms.IFormFactory)
def render_form(self, name):
def _(ctx, data):
return renderForm(name)
return _
def formFactory(self, ctx, name):
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
s = super(ResourceMixin, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
def locateChild(self, ctx, segments):
# Leave now if this it not meant for me.
if not segments[0].startswith(FORM_ACTION) and not segments[0].startswith(WIDGET_RESOURCE):
return super(ResourceMixin, self).locateChild(ctx, segments)
# Find the form name, the form and remember them.
formName = segments[0].split(ACTION_SEP)[1]
d = defer.succeed( ctx )
d.addCallback( locateForm, formName )
d.addCallback( self._processForm, ctx, segments )
return d
def _processForm( self, form, ctx, segments ):
ctx.remember(form, iforms.IForm)
# Serve up file from the resource manager
if segments[0].startswith( WIDGET_RESOURCE ):
return self._fileFromWidget( ctx, form, segments[1:] )
# Process the form.
d = defer.maybeDeferred(form.process, ctx)
d.addCallback(self._formProcessed, ctx)
return d
def _fileFromWidget( self, ctx, form, segments ):
widget = form.widgetForItem( segments[0] )
return widget.getResource( ctx, segments[1:] )
def _formProcessed(self, r, ctx):
if isinstance(r, FormErrors):
if r:
return NoAddSlashHack(self), ()
else:
r = None
if r is None:
r = url.URL.fromContext(ctx)
return r, ()
class IKnownForms(Interface):
"""Marker interface used to locate a dict instance containing the named
forms we know about during this request.
"""
class KnownForms(dict):
implements( IKnownForms )
def locateForm(ctx, name):
"""Locate a form by name.
Initially, a form is located by calling on an IFormFactory that is found
on the context. Once a form has been found, it is remembered in an
KnownForms instance for the lifetime of the request.
This ensures that the form that is located during form processing will be
the same instance that is located when a form is rendered after validation
failure.
"""
# Get hold of the request
request = inevow.IRequest(ctx)
# Find or create the known forms instance
knownForms = request.getComponent(IKnownForms)
if knownForms is None:
knownForms = KnownForms()
request.setComponent(IKnownForms, knownForms)
# See if the form is already known
form = knownForms.get(name)
if form is not None:
return form
# Not known yet, ask a form factory to create the form
factory = iforms.IFormFactory(ctx)
def cacheForm( form, name ):
if form is None:
raise Exception('Form %r not found'%name)
form.name = name
# Make it a known
knownForms[name] = form
return form
d = defer.succeed( None )
d.addCallback( lambda r : factory.formFactory( ctx, name ) )
d.addCallback( cacheForm, name )
return d
def formAction(name):
return '%s%s%s' % (FORM_ACTION, ACTION_SEP, name)
def formWidgetResource(name):
return '%s%s%s' % (WIDGET_RESOURCE, ACTION_SEP, name)
class FormRenderer(object):
implements( inevow.IRenderer )
loader = loaders.stan(
T.form(id=T.slot('id'), action=T.slot('action'), class_='nevow-form', method='post', enctype='multipart/form-data', **{'accept-charset':'utf-8'})[
T.fieldset[
T.input(type='hidden', name='_charset_'),
T.slot('errors'),
T.slot('items'),
T.div(id=T.slot('fieldId'), pattern='item', _class=T.slot('class'))[
T.label(_for=T.slot('id'))[T.slot('label')],
T.div(_class='inputs')[T.slot('inputs')],
T.slot('description'),
T.slot('message'),
],
T.div(class_='hiddenitems')[
T.slot('hiddenitems'),
T.invisible(pattern="hiddenitem")[T.slot('inputs')]
],
T.div(class_='actions')[
T.slot('actions'),
],
],
]
)
def __init__(self, original, *a, **k):
super(FormRenderer, self).__init__(*a, **k)
self.original = original
def rend(self, ctx, data):
segs = inevow.ICurrentSegments(ctx)
if segs and segs[-1].startswith(FORM_ACTION):
urlFactory = url.here.sibling
else:
urlFactory = url.here.child
tag = T.invisible[self.loader.load()]
tag.fillSlots('id', util.keytocssid(ctx.key))
tag.fillSlots('action', urlFactory(formAction(self.original.name)))
tag.fillSlots('errors', self._renderErrors)
tag.fillSlots('items', self._renderItems)
tag.fillSlots('hiddenitems', self._renderHiddenItems)
tag.fillSlots('actions', self._renderActions)
return tag
def _renderErrors(self, ctx, data):
errors = iforms.IFormErrors(ctx, None)
if errors is not None:
errors = errors.getFormErrors()
if not errors:
return ''
return T.div(class_='errors')[
T.p['Please correct the following errors:'],
T.ul[[T.li[str(error)] for error in errors]],
]
def _renderItems(self, ctx, data):
if self.original.items is None:
yield ''
return
itemPattern = inevow.IQ(ctx).patternGenerator('item')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') != 'hidden':
yield itemPattern(key=item[0], data=item, render=self._renderItem)
def _renderHiddenItems(self, ctx, data):
if self.original.items is None:
yield ''
return
hiddenItemPattern = inevow.IQ(ctx).patternGenerator('hiddenitem')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') == 'hidden':
yield hiddenItemPattern(key=item[0], data=item, render=self._renderHiddenItem)
def _renderItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
if formErrors is None:
error = None
else:
error = formErrors.getFieldError(name)
classes = [
'field',
type.__class__.__name__.lower(),
widget.__class__.__name__.lower(),
]
if cssClass:
classes.append(cssClass)
if error is None:
message = ''
else:
classes.append('error')
message = T.div(class_='message')[str(error)]
ctx.tag.fillSlots('class', ' '.join(classes))
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('label', label)
if type.immutable:
render = widget.renderImmutable
else:
render = widget.render
ctx.tag.fillSlots('inputs', render(ctx, name, formData, formErrors))
ctx.tag.fillSlots('message', message)
ctx.tag.fillSlots('description', T.div(class_='description')[description or ''])
return ctx.tag
return _
def _renderHiddenItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('inputs', widget.render(ctx, name, formData, formErrors))
return ctx.tag
return _
def _renderActions(self, ctx, data):
if self.original.actions is None:
yield ''
return
for action in self.original.actions:
yield T.invisible(data=action, render=self._renderAction)
def _renderAction(self, ctx, data):
return T.input(type='submit', id='%s-action-%s'%(util.keytocssid(ctx.key), data.name), name=data.name, value=util.titleFromName(data.name))
class NoAddSlashHack:
implements( inevow.IResource )
def __init__(self, wrapped):
self.wrapped = wrapped
def __getattr__(self, name):
return getattr(self.wrapped, name)
def renderHTTP(self, ctx):
MISSING = object()
addSlash = getattr(self.wrapped, 'addSlash', MISSING)
if addSlash:
self.wrapped.addSlash = False
try:
r = self.wrapped.renderHTTP(ctx)
finally:
if addSlash is not MISSING:
self.wrapped.addSlash = addSlash
else:
del self.wrapped.addSlash
return r
registerAdapter(FormRenderer, Form, inevow.IRenderer)
| Python |
from nevow import tags as T, util
from forms import iforms
from zope.interface import implements
tinyMCEGlue = T.xml("""
<!-- tinyMCE -->
<script language="javascript" type="text/javascript" src="/tiny_mce/tiny_mce.js"></script>
<script language="javascript" type="text/javascript">
tinyMCE.init({
mode : "specific_textareas"
theme: 'advanced',
theme_advanced_toolbar_location: 'top',
theme_advanced_toolbar_align: 'left'
});
</script>
<!-- /tinyMCE -->
""" )
class TinyMCE(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.textarea(name=key, id=key, mce_editable='true')[value or '']
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if value:
value=T.xml(value)
else:
value=''
return T.div(id=key, class_="readonly-textarea-container") [
T.div(class_='readonly-textarea readonly')[value]
]
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
| Python |
import tempfile
import mimetypes
import re
import os
from shutil import copyfileobj
from exceptions import IOError, OSError
class ResourceManagerException( Exception ):
def __init__( self, *args, **kwds ):
super( ResourceManagerException, self ).__init__( *args, **kwds )
class ResourceManager( object ):
def __init__( self ):
self.widgetToID = {}
def register( self, widgetName, resourceId ):
self.widgetToID[widgetName] = resourceId
def getResourceId( self, widgetName ):
return self.widgetToID.get( widgetName )
def getResourceForWidget( self, widgetName ):
resourceId = self.getResourceId( widgetName )
if resourceId is None:
return None
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
try:
filelike = open( path, 'r' )
return (mimetype, filelike, fileName)
except IOError:
return None
def getResourcePath( self, resourceId ):
"""
Required to create an instance of nevow.static.File
"""
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
return (mimetype, path, fileName)
def setResource( self, widgetName, filelike, fileName ):
existingResource = self.widgetToID.get( widgetName )
if existingResource is not None:
try:
(path, ignore) = self._fromResourceId( existingResource )
os.remove( path )
except OSError:
pass
# Encode the filename to avoid any unicode filesystem errors.
fileName = self._encodeFilename(fileName)
(target, path) = tempfile.mkstemp( '__' + fileName )
# target is a file handle. We want a file object.
target = os.fdopen(target, 'w')
copyfileobj( filelike, target )
target.close()
resourceId = self._toResourceId( path )
self.widgetToID[widgetName] = resourceId
return resourceId
def _fromResourceId( self, resourceId ):
match = re.match( '^.*__(.*)$', resourceId )
if match is None:
return None
fileName = match.group( 1 )
path = os.sep.join( (tempfile.gettempdir(), resourceId) )
return path, self._decodeFilename(fileName)
def _toResourceId( self, path ):
path = path[len(tempfile.gettempdir()):]
if path[0] == os.sep:
path = path[1:]
return path
def clearUpResources( self ):
for id in self.widgetToID.values():
try:
(path, fileName) = self._fromResourceId( id )
os.remove( path )
except OSError:
pass
def _encodeFilename(self, filename):
"""
Encode the filename (which may be unicode) so it's safe to use with
the filesystem.
"""
return filename.encode('utf-8').encode('base64')[:-1]
def _decodeFilename(self, filename):
"""
Undo what _encodeFilename did.
"""
filename = filename + '\n'
return filename.decode('base64').decode('utf-8')
| Python |
"""Adapters for converting to and from a type's value according to an
IConvertible protocol.
"""
from datetime import date, time
from nevow.compy import Adapter
from forms import iforms, validation
from zope.interface import implements
class NullConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value
def toType(self, value):
if value is None:
return None
return value
class NumberToStringConverter(Adapter):
implements( iforms.IStringConvertible )
cast = None
def fromType(self, value):
if value is None:
return None
return str(value)
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
try:
value = self.cast(value)
except ValueError:
raise validation.FieldValidationError("Not a valid number")
return value
class IntegerToStringConverter(NumberToStringConverter):
cast = int
class FloatToStringConverter(NumberToStringConverter):
cast = float
class BooleanToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
if value:
return 'True'
return 'False'
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
if value not in ('True', 'False'):
raise validation.FieldValidationError('%r should be either True or False')
return value == 'True'
class DateToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseDate(value)
def parseDate(self, value):
try:
y, m, d = [int(p) for p in value.split('-')]
except ValueError:
raise validation.FieldValidationError('Invalid date')
try:
value = date(y, m, d)
except ValueError, e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
class TimeToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseTime(value)
def parseTime(self, value):
if '.' in value:
value, ms = value.split('.')
else:
ms = 0
try:
parts = value.split(':')
if len(parts)<2 or len(parts)>3:
raise ValueError()
if len(parts) == 2:
h, m = parts
s = 0
else:
h, m, s = parts
h, m, s, ms = int(h), int(m), int(s), int(ms)
except:
raise validation.FieldValidationError('Invalid time')
try:
value = time(h, m, s, ms)
except ValueError, e:
raise validation.FieldValidationError('Invalid time: '+str(e))
return value
class DateToDateTupleConverter(Adapter):
implements( iforms.IDateTupleConvertible )
def fromType(self, value):
if value is None:
return None, None, None
return value.year, value.month, value.day
def toType(self, value):
if value is None:
return None
try:
value = date(*value)
except (TypeError, ValueError), e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
| Python |
from forms import iforms
from zope.interface import implements
def titleFromName(name):
def _():
it = iter(name)
last = None
while 1:
ch = it.next()
if ch == '_':
if last != '_':
yield ' '
elif last in (None,'_'):
yield ch.upper()
elif ch.isupper() and not last.isupper():
yield ' '
yield ch.upper()
else:
yield ch
last = ch
return ''.join(_())
def keytocssid(key):
return '-'.join(key.split('.'))
class SequenceKeyLabelAdapter(object):
implements( iforms.IKey, iforms.ILabel )
def __init__(self, original):
self.original = original
def key(self):
return self.original[0]
def label(self):
return self.original[1]
| Python |
"""
Widgets are small components that render form fields for inputing data in a
certain format.
"""
import itertools
from nevow import inevow, tags as T, util, url, static
from forms import converters, iforms, validation
from forms.util import keytocssid
from forms.form import formWidgetResource
from zope.interface import implements
from twisted.internet import defer
# Marker object for args that are not supplied
_UNSET = object()
class TextInput(object):
"""
A text input field.
<input type="text" ... />
"""
implements( iforms.IWidget )
inputType = 'text'
showValueOnFailure = True
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, readonly):
tag=T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if not self.showValueOnFailure:
value = None
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class Checkbox(object):
"""
A checkbox input field.
<input type="checkbox" ... />
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, disabled):
tag = T.input(type='checkbox', name=key, id=keytocssid(ctx.key), value='True')
if value == 'True':
tag(checked='checked')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [None])[0]
if not value:
value = 'False'
value = iforms.IBooleanConvertible(self.original).toType(value)
return self.original.validate(value)
class Password(TextInput):
"""
A text input field that hides the text.
<input type="password" ... />
"""
inputType = 'password'
showValueOnFailure = False
class TextArea(object):
"""
A large text entry area that accepts newline characters.
<textarea>...</textarea>
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, readonly):
tag=T.textarea(name=key, id=keytocssid(ctx.key))[value or '']
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class CheckedPassword(object):
"""
Two password entry fields that must contain the same value to validate.
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors and not errors.getFieldError(key):
values = args.get(key)
else:
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0]),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1]),
]
def renderImmutable(self, ctx, key, args, errors):
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0], class_='readonly', readonly='readonly'),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1], class_='readonly', readonly='readonly')
]
def processInput(self, ctx, key, args):
pwds = [pwd for pwd in args.get(key, [])]
if len(pwds) == 0:
pwd = ''
elif len(pwds) == 1:
raise validation.FieldValidationError('Please enter the password twice for confirmation.')
else:
if pwds[0] != pwds[1]:
raise validation.FieldValidationError('Passwords do not match.')
return self.original.validate(pwds[0])
class ChoiceBase(object):
"""
A base class for widgets that provide the UI to select one or more items
from a list.
options:
A sequence of objects adaptable to IKey and ILabel. IKey is used as the
<option>'s value attribute; ILabel is used as the <option>'s child.
IKey and ILabel adapters for tuple are provided.
noneOption:
An object adaptable to IKey and ILabel that is used to identify when
nothing has been selected. Defaults to ('', '')
"""
options = None
noneOption = None
def __init__(self, original, options=None, noneOption=_UNSET):
self.original = original
if options is not None:
self.options = options
if noneOption is not _UNSET:
self.noneOption = noneOption
class SelectChoice(ChoiceBase):
"""
A drop-down list of options.
<select>
<option value="...">...</option>
</select>
"""
implements( iforms.IWidget )
noneOption = ('', '')
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iforms.IKey(self.noneOption).key())[iforms.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
option = T.option(value=optValue)[optLabel]
if optValue == value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=keytocssid(ctx.key), data=self.options)[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0]
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class RadioChoice(ChoiceBase):
"""
A list of options in the form of radio buttons.
<input type="radio" ... value="..."/><label>...</label><br />
<input type="radio" ... value="..."/><label>...</label><br />
"""
implements( iforms.IWidget )
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOption(ctx, itemKey, itemLabel, num, selected):
cssid = (keytocssid(ctx.key),'-',num)
tag = T.input(name=key, type='radio', id=cssid, value=itemKey)
if selected:
tag = tag(checked='checked')
return tag, ' ', T.label(for_=cssid)[itemLabel], T.br
def renderOptions(ctx, data):
# A counter to assign unique ids to each input
idCounter = itertools.count()
if self.noneOption is not None:
itemKey = iforms.IKey(self.noneOption).key()
itemLabel = iforms.ILabel(self.noneOption).label()
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
if not data:
return
for item in data:
itemKey = iforms.IKey(item).key()
itemLabel = iforms.ILabel(item).label()
itemKey = converter.fromType(itemKey)
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
return T.invisible(data=self.options)[renderOptions]
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0]
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class DatePartsInput(object):
"""
Three text input fields for entering a date in parts.
Default format is mm/dd/yyyy
dayFirst:
Make the day the first input field. dd/mm/yyyy
"""
implements( iforms.IWidget )
dayFirst = False
def __init__(self, original, dayFirst=None):
self.original = original
if dayFirst is not None:
self.dayFirst = dayFirst
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, day, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=4)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
dayTag = T.input(type="text", name=namer('day'), value=day, size=2)
if readonly:
tags = (yearTag, monthTag, dayTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
if self.dayFirst:
return dayTag, ' / ', monthTag, ' / ', yearTag, ' (dd/mm/yyyy)'
else:
return monthTag, ' / ', dayTag, ' / ', yearTag, ' (mm/dd/yyyy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
day = args.get(namer('day'), [''])[0]
else:
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month', 'day')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 3:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
value = iforms.IDateTupleConvertible(self.original).toType(value)
return self.original.validate(value)
class MMYYDatePartsInput(object):
"""
Two input fields for entering the month and year.
"""
implements( iforms.IWidget )
cutoffYear = 70
def __init__(self, original, cutoffYear=None):
self.original = original
if cutoffYear is not None:
self.cutoffYear = cutoffYear
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=2)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
if readonly:
tags=(yearTag, monthTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
return monthTag, ' / ', yearTag, ' (mm/yy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
# return a blank for the day
day = ''
else:
year, month, day = converter.fromType(args.get(key))
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
year, month, day = converter.fromType(args.get(key))
namer = self._namer(key)
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 2:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
if value[1] < 0 or value[1] > 99:
raise validation.FieldValidationError("Invalid year. Please enter a two-digit year.")
if value[0] > self.cutoffYear:
value[0] = 1900 + value[0]
else:
value[0] = 2000 + value[0]
value.append(1)
value = iforms.IDateTupleConvertible(self.original).toType( value )
return self.original.validate(value)
class CheckboxMultiChoice(object):
"""
Multiple choice list, rendered as a list of checkbox fields.
"""
implements( iforms.IWidget )
options = None
def __init__(self, original, options=None):
self.original = original
if options is not None:
self.options = options
def _renderTag(self, ctx, key, values, converter, disabled):
# loops through checkbox options and renders
for n,item in enumerate(self.options):
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
optid = (keytocssid(ctx.key),'-',n)
checkbox = T.input(type='checkbox', name=key, value=optValue, id=optid )
if optValue in values:
checkbox = checkbox(checked='checked')
if disabled:
checkbox = checkbox(class_='disabled', disabled='disabled')
yield checkbox, T.label(for_=optid)[optLabel], T.br()
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
if errors:
values = args.get(key, [])
else:
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, True)
def processInput(self, ctx, key, args):
values = args.get(key, [])
converter = iforms.IStringConvertible(self.original.type)
values = [converter.toType(v) for v in values]
return self.original.validate(values)
class FileUploadRaw(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, disabled):
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
value = (name, fileitem.file)
value = iforms.IFileConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUpload(object):
implements( iforms.IWidget )
def __init__(self, original, fileHandler, preview=None):
self.original = original
self.fileHandler = fileHandler
self.preview = preview
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, key, value, namer, disabled):
name = self.fileHandler.getUrlForFile(value)
if name:
if self.preview == 'image':
yield T.p[value,T.img(src=self.fileHandler.getUrlForFile(value))]
else:
yield T.p[value]
else:
yield T.p[T.strong['nothing uploaded']]
yield T.input(name=namer('value'),value=value,type='hidden')
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
yield tag
def render(self, ctx, key, args, errors):
namer = self._namer(key)
if errors:
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = name
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, False)
def renderImmutable(self, ctx, key, args, errors):
namer = self._namer(key)
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = self.fileHandler.storeFile( fileitem.file, name )
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUploadWidget(object):
"""
File upload widget that carries the uploaded file around until the form
validates.
The widget uses the resource manager to save the file to temporary storage
until the form validates. This makes file uploads behave like most of the
other widgets, i.e. the value is kept when a form is redisplayed due to
validation errors.
"""
implements( iforms.IWidget )
FROM_RESOURCE_MANAGER = 'rm'
FROM_CONVERTIBLE = 'cf'
convertibleFactory = converters.NullConverter
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def __init__( self, original, convertibleFactory=None, originalKeyIsURL=False ):
self.original = original
if convertibleFactory is not None:
self.convertibleFactory = convertibleFactory
self.originalKeyIsURL = originalKeyIsURL
def _blankField( self, field ):
"""
Convert empty strings into None.
"""
if field and field == '':
return None
return field
def _getFromArgs( self, args, name ):
"""
Get the first value of 'name' from 'args', or None.
"""
rv = args.get( name )
if rv:
rv = rv[0]
return rv
def render(self, ctx, key, args, errors):
"""
Render the data.
This either renders a link to the original file, if specified, and
no new file has been uploaded. Or a link to the uploaded file.
The request to get the data should be routed to the getResouce
method.
"""
form = iforms.IForm( ctx )
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
originalIdName = namer( 'original_id' )
# get the resource id first from the resource manager
# then try the request
resourceId = form.resourceManager.getResourceId( key )
if resourceId is None:
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
# Get the original key from a hidden field in the request,
# then try the request file.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if errors:
urlFactory = url.URL.fromContext( ctx ).sibling
else:
urlFactory = url.URL.fromContext( ctx ).child
if resourceId:
# Have an uploaded file, so render a URL to the uploaded file
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child( self.FROM_RESOURCE_MANAGER ).child( resourceId )
yield T.p[T.img(src=tmpURL)]
elif originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child( self.FROM_CONVERTIBLE ).child( originalKey )
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
yield T.input(name=key, id=keytocssid(ctx.key),type='file')
# Id of uploaded file in the resource manager
yield T.input(name=resourceIdName,value=resourceId,type='hidden')
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def renderImmutable(self, ctx, key, args, errors):
form = iforms.IForm(ctx)
namer = self._namer(key)
originalIdName = namer('original_id')
# Get the original key from a hidden field in the request,
# then try the request form.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if errors:
urlFactory = url.URL.fromContext( ctx ).sibling
else:
urlFactory = url.URL.fromContext( ctx ).child
if originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child(self.FROM_CONVERTIBLE).child(originalKey)
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def processInput(self, ctx, key, args):
"""
Process the request, storing any uploaded file in the
resource manager.
"""
resourceManager = iforms.IForm( ctx ).resourceManager
# Ping the resource manager with any resource ids that I know
self._registerWithResourceManager( key, args, resourceManager )
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
# Store the uploaded file in the resource manager
resourceManager.setResource( key, fileitem.file, name )
# Validating against an uploaded file. Should the fact that there is
# original file meet a required field validation?
return self.original.validate( resourceManager.getResourceForWidget( key ) )
def _registerWithResourceManager( self, key, args, resourceManager ):
"""
If there is a resource id in the request, then let the
resource manager know about it.
"""
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
if resourceId:
resourceManager.register( key, resourceId )
def getResource( self, ctx, segments ):
"""
Return an Resource that contains the image, either a file
from the resource manager, or a data object from the convertible.
"""
if segments[0] == self.FROM_RESOURCE_MANAGER:
# Resource manager can provide a path so return a static.File
# instance that points to the file
rm = iforms.IForm( ctx ).resourceManager
(mimetype, path, fileName) = rm.getResourcePath( segments[1] )
return static.File( path, mimetype ), []
elif segments[0] == self.FROM_CONVERTIBLE:
# The convertible can provide a file like object so create a
# static.Data instance with the data from the convertible.
def _( result ):
mimetype, filelike, fileName = result
data = filelike.read()
filelike.close()
return static.Data( data, mimetype ), []
d = defer.maybeDeferred( self.convertibleFactory(self.original).fromType, segments[1], context=ctx )
d.addCallback( _ )
return d
else:
return None
class Hidden(object):
"""
A hidden form field.
"""
__implements__ = iforms.IWidget,
inputType = 'hidden'
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
def renderImmutable(self, ctx, key, args, errors):
return self.render(ctx, key, args, errors)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
__all__ = [
'Checkbox', 'CheckboxMultiChoice', 'CheckedPassword','FileUploadRaw', 'FileUpload', 'FileUploadWidget',
'Password', 'SelectChoice', 'TextArea', 'TextInput', 'DatePartsInput',
'MMYYDatePartsInput', 'Hidden', 'RadioChoice',
]
| Python |
import re
from zope.interface import implements
from forms import iforms
class FormError(Exception):
pass
class FieldError(Exception):
def __init__(self, message, fieldName=None):
Exception.__init__(self, message)
self.message = message
self.fieldName = fieldName
class FieldValidationError(FieldError):
pass
class FieldRequiredError(FieldValidationError):
pass
class RequiredValidator(object):
implements(iforms.IValidator)
def validate(self, field, value):
if value is None:
raise FieldRequiredError, 'Required'
class LengthValidator(object):
"""Validate the length of the value is within a given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be longer than %r characters'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be shorter than %r characters'%(self.max,)
return 'Must be between %r and %r characters'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
length = len(value)
if self.min is not None and length < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and length > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class RangeValidator(object):
"""Validate the size of the value is within is given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be greater than %r'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be less than %r'%(self.max,)
return 'Must be between %r and %r'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
if self.min is not None and value < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and value > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class PatternValidator(object):
"""Validate the value is a certain pattern.
The required pattern is defined as a regular expression. The regex will be
compiled automatically if necessary.
"""
implements(iforms.IValidator)
def __init__(self, regex):
self.regex = regex
def validate(self, field, value):
if value is None:
return
# If it doesn't look like a regex object then compile it now
if not hasattr(self.regex, 'match'):
self.regex = re.compile(self.regex)
if self.regex.match(value) is None:
raise FieldValidationError, 'Invalid format'
__all__ = [
'FormError', 'FieldError', 'FieldValidationError', 'FieldRequiredError',
'RequiredValidator', 'LengthValidator', 'RangeValidator', 'PatternValidator',
]
| Python |
import forms
title = 'Dates'
description = 'Date entry examples'
def makeForm(ctx):
form = forms.Form()
form.addField('isoFormat', forms.Date(), forms.TextInput)
form.addField('monthFirst', forms.Date(), forms.DatePartsInput)
form.addField('dayFirst', forms.Date(), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('monthAndYear', forms.Date(), forms.MMYYDatePartsInput)
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import forms
title = 'Simple Form'
description = 'Probably the simplest form possible.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import forms
title = 'Form Types'
description = 'Example of using different typed fields.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aInteger', forms.Integer())
form.addField('aFloat', forms.Float())
form.addField('aBoolean', forms.Boolean())
form.addField('aDate', forms.Date())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from datetime import date
import forms
title = 'Missing Values'
description = 'Providing default values when missing'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String(missing='<nothing>'))
form.addField('aDate', forms.Date(missing=date(2005, 8, 1)))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
import forms
title = 'File Upload'
description = 'Uploading a file'
def makeForm(ctx):
form = forms.Form()
form.addField('file', forms.File())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import pkg_resources
from twisted.python import reflect
from nevow import appserver, loaders, rend, static, tags as T, url
import forms
DOCTYPE = T.xml('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">')
CHARSET = T.xml('<meta http-equiv="content-type" content="text/html; charset=utf-8" />')
examples = [
'forms.examples.simple',
'forms.examples.types',
'forms.examples.required',
'forms.examples.missing',
'forms.examples.prepopulate',
'forms.examples.fileupload',
'forms.examples.smartupload',
'forms.examples.selections',
'forms.examples.dates',
]
def makeSite(application):
root = RootPage()
site = appserver.NevowSite(root, logPath='web.log')
return site
class RootPage(rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title['Forms Examples'],
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
],
T.body[
T.directive('examples'),
],
],
],
)
def render_examples(self, ctx, data):
for name in examples:
module = reflect.namedAny(name)
yield T.div(class_='example')[
T.h1[T.a(href=url.here.child(name))[module.title]],
T.p[module.description],
]
def childFactory(self, ctx, name):
if name in examples:
return FormPage(reflect.namedAny(name))
class FormPage(forms.ResourceMixin, rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title(data=T.directive('title'), render=rend.data),
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
T.link(rel='stylesheet', type='text/css', href=url.root.child('forms.css')),
],
T.body[
T.h1(data=T.directive('title'), render=rend.data),
T.p(data=T.directive('description'), render=rend.data),
T.directive('form example'),
],
],
],
)
def data_title(self, ctx, data):
return self.original.title
def data_description(self, ctx, data):
return self.original.description
def form_example(self, ctx):
return self.original.makeForm(ctx)
# Add child_ attributes
examples_css = pkg_resources.resource_filename('forms.examples', 'examples.css')
setattr(RootPage, 'child_examples.css', static.File(examples_css))
setattr(RootPage, 'child_forms.css', forms.defaultCSS)
| Python |
import forms
title = 'Smart File Upload'
description = 'Smart uploading of files where the file is "carried across" when the validation fails'
def makeForm(ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('file', forms.File(), forms.FileUploadWidget)
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
from datetime import datetime
import forms
title = 'Prepopulate'
description = 'Example of prepopulating form fields'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
form.data = {
'aTime': datetime.utcnow().time(),
}
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from twisted.internet import defer
from datetime import date
import forms
title = 'Selection widgets'
description = 'Example of the various selection widgets'
def makeForm(ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('oneString', forms.String(), forms.widgetFactory(forms.SelectChoice, options=strings))
form.addField('anotherString', forms.String(), forms.widgetFactory(forms.SelectChoice, options=data_strings))
form.addField('oneMoreString', forms.String(required=True), forms.widgetFactory(forms.RadioChoice, options=data_strings))
form.addField('oneDate', forms.Date(), forms.widgetFactory(forms.SelectChoice, options=dates))
form.addField('multipleStrings', forms.Sequence(forms.String()), forms.widgetFactory(forms.CheckboxMultiChoice, options=strings))
form.addField('multipleDates', forms.Sequence(forms.Date()), forms.widgetFactory(forms.CheckboxMultiChoice, options=dates))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
# A boring list of (value, label) pairs.
strings = [
('foo', 'Foo'),
('bar', 'Bar'),
]
# A list of dates with meaningful names.
dates = [
(date(2005, 01, 01), 'New Year Day'),
(date(2005, 11, 06), 'My Birthday'),
(date(2005, 12, 25), 'Christmas Day'),
]
def data_strings(ctx, data):
# Let's defer it, just for fun.
return defer.succeed(strings)
| Python |
import forms
title = 'Required Fields'
description = 'Demonstration of required fields'
def makeForm(ctx):
form = forms.Form()
form.addField('name', forms.String(required=True))
form.addField('age', forms.Integer())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
"""A package (for Nevow) for defining the schema, validation and rendering of
HTML forms.
"""
version_info = (0, 2, 2)
version = '.'.join([str(i) for i in version_info])
from nevow import static
from forms.types import *
from forms.validation import *
from forms.widget import *
from forms.form import Form, ResourceMixin, renderForm
from forms import iforms
def widgetFactory(widgetClass, *a, **k):
def _(original):
return widgetClass(original, *a, **k)
return _
try:
import pkg_resources
except ImportError:
import os.path
defaultCSS = static.File(os.path.join(os.path.split(__file__)[0], 'forms.css'))
else:
defaultCSS = static.File(pkg_resources.resource_filename('forms', 'forms.css'))
# Register standard adapters
from nevow.compy import registerAdapter
from forms import converters
registerAdapter(TextInput, String, iforms.IWidget)
registerAdapter(TextInput, Integer, iforms.IWidget)
registerAdapter(TextInput, Float, iforms.IWidget)
registerAdapter(Checkbox, Boolean, iforms.IWidget)
registerAdapter(DatePartsInput, Date, iforms.IWidget)
registerAdapter(TextInput, Time, iforms.IWidget)
registerAdapter(FileUploadRaw, File, iforms.IWidget)
from forms import util
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.IKey)
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.ILabel)
registerAdapter(converters.NullConverter, String, iforms.IStringConvertible)
registerAdapter(converters.DateToDateTupleConverter, Date, iforms.IDateTupleConvertible)
registerAdapter(converters.BooleanToStringConverter, Boolean, iforms.IBooleanConvertible)
registerAdapter(converters.IntegerToStringConverter, Integer, iforms.IStringConvertible)
registerAdapter(converters.FloatToStringConverter, Float, iforms.IStringConvertible)
registerAdapter(converters.DateToStringConverter, Date, iforms.IStringConvertible)
registerAdapter(converters.TimeToStringConverter, Time, iforms.IStringConvertible)
registerAdapter(converters.NullConverter, File, iforms.IFileConvertible)
registerAdapter(converters.NullConverter, Sequence, iforms.ISequenceConvertible)
del registerAdapter
| Python |
from nevow.compy import Interface
class IType(Interface):
def validate(self, value):
pass
class IStructure(Interface):
pass
class IWidget(Interface):
def render(self, ctx, key, args, errors):
pass
def renderImmutable(self, ctx, key, args, errors):
pass
def processInput(self, ctx, key, args):
pass
class IFormFactory(Interface):
def formFactory(self, ctx, name):
pass
class IFormData(Interface):
pass
class IFormErrors(Interface):
pass
class IKey(Interface):
def key(self):
pass
class ILabel(Interface):
def label(self):
pass
class IConvertible(Interface):
def fromType(self, value):
pass
def toType(self, value):
pass
class IStringConvertible(IConvertible):
pass
class IBooleanConvertible(IConvertible):
pass
class IDateTupleConvertible(IConvertible):
pass
class IFileConvertible(IConvertible):
pass
class ISequenceConvertible(IConvertible):
pass
class IForm( Interface ):
pass
class IValidator(Interface):
def validate(self, field, value):
pass
| Python |
from twisted.application import internet, service
from nevow import appserver
from forms.examples import main
application = service.Application('examples')
service = internet.TCPServer(8000, main.makeSite(application))
service.setServiceParent(application)
| Python |
from setuptools import setup, find_packages
import forms
setup(
name='forms',
version=forms.version,
description='HTML forms framework for Nevow',
author='Matt Goodall',
author_email='matt@pollenation.net',
packages=find_packages(),
package_data={
'forms': ['forms.css'],
}
)
| Python |
from datetime import date, time
from twisted.application import internet, service
from nevow import appserver, compy, loaders, rend, static, tags as T
import forms
import os
from shutil import copyfileobj
import mimetypes, datetime
from forms import iforms, htmleditor, converters
from fileresource import fileResource
class KeyToFileConverter( object ):
__implements__ = iforms.IFileConvertible,
def fromType( self, value, context=None ):
"""
Given a string generate a (mimetype, filelike, fileName) or None
"""
if not value or value == '':
return None
mimetype = mimetypes.guess_type( value )
filelike = open(os.path.join('images',value),'r')
return (mimetype, filelike, value)
def toType( self, value ):
"""
Given a (mimetype, filelike, filename) tuple return a string
"""
if not value:
return None
(mimetype, filelike,fileName) = value;
target = file(os.path.join('images',fileName),'w')
copyfileobj( filelike, target )
target.close()
filelike.close()
return fileName
dates = [
(date(2005,1,1), 'New year\'s day'),
(date(2005,11,6), 'My birthday'),
(date(2005,12,25), 'Christmas day'),
]
times = [
(time(5,0), 'Really early'),
(time(7,0), 'A bit too early'),
(time(8,0), 'Hmm, not bad'),
(time(10,0), 'Nice :)'),
]
class Person(object):
def __init__(self, id, firstName, lastName):
self.id = id
self.firstName = firstName
self.lastName = lastName
class PersonKeyLabelAdapter(object):
__implements__ = iforms.IKey, iforms.ILabel
def __init__(self, original):
self.original = original
def key(self):
return self.original.id
def label(self):
return '%s, %s' % (self.original.lastName, self.original.firstName)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.IKey)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.ILabel)
people = [
Person(1, 'Matt', 'Goodall'),
Person(2, 'Tim', 'Parkin'),
]
class Page(rend.Page, forms.ResourceMixin):
addSlash = True
docFactory = loaders.xmlfile('test.html')
def __init__(self, *a, **k):
rend.Page.__init__(self, *a, **k)
forms.ResourceMixin.__init__(self)
def child_self(self, ctx):
return self
def form_oneOfEach(self, ctx):
form = forms.Form(self._submit)
form.addField('hidden_string', forms.Integer(), forms.Hidden)
form.addField('string', forms.String(required=True))
form.addField('password', forms.String(), forms.CheckedPassword)
form.addField('integer', forms.Integer())
form.addField('float', forms.Float())
form.addField('boolean', forms.Boolean())
form.addField('date', forms.Date(), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('time', forms.Time())
form.addAction(self._submit)
form.data = {'hidden_string': 101}
return form
def form_readonlyOneOfEach(self, ctx):
form = forms.Form(self._submit)
immutable=True
form.addField('string', forms.String(immutable=immutable), forms.TextInput)
form.addField('textarea', forms.String(immutable=immutable), forms.TextArea)
form.addField('password', forms.String(immutable=immutable), forms.CheckedPassword)
form.addField('integer', forms.Integer(immutable=immutable))
form.addField('float', forms.Float(immutable=immutable))
form.addField('boolean', forms.Boolean(immutable=immutable), forms.Checkbox)
form.addField('date', forms.Date(immutable=immutable), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('date2', forms.Date(immutable=immutable), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('time', forms.Time(immutable=immutable))
form.addField('author', forms.Integer(immutable=immutable), lambda original: forms.SelectChoice(original, people))
form.addField('bar', forms.Sequence(forms.String(),immutable=immutable), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.addField('file', forms.File(immutable=immutable), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
form.data = {'string':'hello', 'textarea':'some long text', 'password': ['one','one'], 'integer':10, 'float':22.22, 'boolean':True, 'author': 2, 'file':'dm.gif', 'date': datetime.date(2005, 10, 1), 'bar': ['a'], 'time': datetime.time(12, 51, 30)}
return form
def form_test(self, ctx):
form = forms.Form(self._submit)
form.addField('lastName', forms.String(required=True), label='Surname', description='This should be used to store your surname.. no really!!')
form.addField('date', forms.Date(), forms.widgetFactory(forms.SelectChoice, dates))
form.addField('time', forms.Time(), lambda original: forms.SelectChoice(original, times))
form.addField('author', forms.Integer(), lambda original: forms.SelectChoice(original, people))
form.addField('notes', forms.String(), htmleditor.TinyMCE)
form.addField('foo', forms.Sequence(forms.Time()), forms.widgetFactory(forms.CheckboxMultiChoice, times))
form.addField('bar', forms.Sequence(forms.String(),required=True), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.data = {'foo': [time(10,0)]}
form.addAction(self._submit)
form.addAction(self._submit, 'another')
return form
def form_1(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_2(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_3(self, ctx):
''' This test needs an 'assets' folder to store files in. The widget is passed a fileResource which
is used to get a preview url and to save the upload results. commit/rollback type hooks will need
to be added to forms to allow 'clean' operation. -- tp
'''
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.String(required=True), forms.widgetFactory(forms.FileUpload,fileResource(),preview='image'))
form.addAction(self._submit)
#form.data = {
# 'file': 'product.jpg'
# }
return form
def form_4(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.File(required=True), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
# form.data = {
# 'file': 'dm.gif'
# }
return form
def _submit(self, ctx, form, data):
print form
print data
if data.get('string') == 'error':
raise forms.FieldError('Failed the field!', 'string')
if data.get('string') == 'formerror':
raise forms.FormError('Failed the form!')
setattr(Page, 'child_nevow-forms.css', forms.defaultCSS)
setattr(Page, 'child_tiny_mce', static.File('tiny_mce'))
setattr(Page, 'child_webassets', static.File('assets'))
setattr(Page, 'child_images', static.File('images'))
setattr(Page, 'child_uploads', static.File('uploads'))
root = Page()
site = appserver.NevowSite(root, logPath='/dev/null')
application = service.Application('forms2-test')
internet.TCPServer(8000, site).setServiceParent(application)
| Python |
import os
from shutil import copyfileobj
FILESTORE_DIR='assets'
FILESTORE_URL='webassets'
class fileResource:
def getUrlForFile(self, id):
if id:
return os.path.join(FILESTORE_URL, id)
else:
return None
def storeFile( self, source, name ):
id = name
target = file(os.path.join(FILESTORE_DIR,id),'w')
copyfileobj( source, target )
target.close()
return id | Python |
"""
Form types.
"""
from forms import iforms, validation
from zope.interface import implements
class Type(object):
implements( iforms.IType )
# Name of the instance
name = None
# Value to use if no value entered
missing = None
# Instance cannot be changed
immutable = False
# List of validators to test the value against
validators = []
def __init__(self, name=None, required=None, missing=None, immutable=None, validators=None):
if name is not None:
self.name = name
if missing is not None:
self.missing = missing
if immutable is not None:
self.immutable = immutable
if validators is not None:
self.validators = validators[:]
else:
self.validators = self.validators[:]
if required is None:
required = self.required
if required:
self.validators.append(validation.RequiredValidator())
def validate(self, value):
for validator in self.validators:
validator.validate(self, value)
if value is None:
value = self.missing
return value
def hasValidator(self, validatorType):
"""
Check for the existance of a validator of a specific type.
"""
for v in self.validators:
if isinstance(v, validatorType):
return True
return False
def required():
def get(self):
return self.hasValidator(validation.RequiredValidator)
return get,
required = property(*required())
class String(Type):
# Strip the value before validation
strip = False
def __init__(self, **k):
strip = k.pop('strip', None)
if strip is not None:
self.strip = strip
super(String, self).__init__(**k)
def validate(self, value):
if value is not None and self.strip:
value = value.strip()
if not value:
value = None
return super(String, self).validate(value)
class Integer(Type):
pass
class Float(Type):
pass
class Boolean(Type):
pass
class Date(Type):
pass
class Time(Type):
pass
class Sequence(Type):
# Type of items in the sequence
type = None
def __init__(self, type=None, **k):
super(Sequence, self).__init__(**k)
if type is not None:
self.type = type
def validate(self, value):
# Map empty sequence to None
if not value:
value = None
return super(Sequence, self).validate(value)
class File(Type):
pass
__all__ = [
'Boolean', 'Date', 'File', 'Float', 'Integer', 'Sequence', 'String', 'Time',
]
| Python |
"""
Form implementation and high-level renderers.
"""
from twisted.internet import defer
from nevow import appserver, context, loaders, inevow, tags as T, url
from nevow.compy import registerAdapter, Interface
from nevow.util import getPOSTCharset
from forms import iforms, util, validation
from resourcemanager import ResourceManager
from zope.interface import implements
SEPARATOR = '!!'
FORMS_KEY = '__nevow_form__'
WIDGET_RESOURCE_KEY = 'widget_resource'
def renderForm(name):
def _(ctx, data):
def _processForm( form, ctx, name ):
# Remember the form
ctx.remember(form, iforms.IForm)
# Create a keyed tag that will render the form when flattened.
tag = T.invisible(key=name)[inevow.IRenderer(form)]
# Create a new context, referencing the above tag, so that we don't
# pollute the current context with anything the form needs during
# rendering.
ctx = context.WovenContext(parent=ctx, tag=tag)
# Find errors for *this* form and remember things on the context
errors = iforms.IFormErrors(ctx, None)
if errors is not None and errors.formName == name:
ctx.remember(errors.data, iforms.IFormData)
else:
ctx.remember(None, iforms.IFormErrors)
ctx.remember(form.data or {}, iforms.IFormData)
return ctx
d = defer.succeed( ctx )
d.addCallback( locateForm, name )
d.addCallback( _processForm, ctx, name )
return d
return _
class Action(object):
"""Tracks an action that has been added to a form.
"""
def __init__(self, callback, name, validate, label):
self.callback = callback
self.name = name
self.validate = validate
if label is None:
self.label = util.titleFromName(name)
else:
self.label = label
class Form(object):
implements( iforms.IForm )
callback = None
items = None
actions = None
widgets = None
data = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
def addField(self, name, type, widgetFactory=None, label=None, description=None, cssClass=None):
if self.items is None:
self.items = []
type.name = name
if label is None:
label = util.titleFromName(name)
self.items.append( (name,type,label,description,cssClass) )
if widgetFactory is not None:
if self.widgets is None:
self.widgets = {}
self.widgets[name] = widgetFactory
def addAction(self, callback, name="submit", validate=True, label=None):
if self.actions is None:
self.actions = []
if name in [action.name for action in self.actions]:
raise ValueError('Action with name %r already exists.' % name)
self.actions.append( Action(callback, name, validate, label) )
def widgetForItem(self, itemName):
for name, type, label, description, cssClass in self.items:
if name == itemName:
break
else:
raise KeyError()
if self.widgets is not None:
try:
widgetFactory = self.widgets[name]
except KeyError:
pass
else:
return widgetFactory(type)
return iforms.IWidget(type)
def process(self, ctx):
# Get the request args
requestArgs = inevow.IRequest(ctx).args
# Decode the request arg names
charset = getPOSTCharset(ctx)
requestArgs = dict([(k.decode(charset),v) for k,v in requestArgs.iteritems()])
# Unflatten the request into nested dicts.
args = {}
for name, value in requestArgs.iteritems():
name = name.split('.')
group, name = name[:-1], name[-1]
d = args
for g in group:
d = args.setdefault(g,{})
d[name] = value
# Find the callback to use, defaulting to the form default
callback, validate = self.callback, True
if self.actions is not None:
for action in self.actions:
if action.name in args:
# Remove it from the data
args.pop(action.name)
# Remember the callback and whether to validate
callback, validate = action.callback, action.validate
break
if callback is None:
raise Exception('The form has no callback and no action was found.')
# Store an errors object in the context
errors = FormErrors(self.name)
errors.data = args
ctx.remember(errors, iforms.IFormErrors)
# Iterate the items and collect the form data and/or errors.
data = {}
for name, type, label, description, cssClass in self.items:
try:
if not type.immutable:
data[name] = self.widgetForItem(name).processInput(ctx, name, args)
else:
data[name] = self.data.get(name)
errors.data[name] = self.data.get(name)
except validation.FieldError, e:
if validate:
if e.fieldName is None:
e.fieldName = name
errors.add(e)
if errors:
return errors
def _clearUpResources( r ):
self.resourceManager.clearUpResources()
return r
d = defer.maybeDeferred(callback, ctx, self, data)
d.addCallback( _clearUpResources )
d.addErrback(self._cbFormProcessingFailed, ctx)
return d
def _cbFormProcessingFailed(self, failure, ctx):
e = failure.value
failure.trap(validation.FormError, validation.FieldError)
errors = iforms.IFormErrors(ctx)
errors.add(failure.value)
return errors
class FormErrors(object):
implements( iforms.IFormErrors )
def __init__(self, formName):
self.formName = formName
self.errors = []
def add(self, error):
self.errors.append(error)
def getFieldError(self, name):
fieldErrors = [e for e in self.errors if isinstance(e, validation.FieldError)]
for error in fieldErrors:
if error.fieldName == name:
return error
def getFormErrors(self):
return [e for e in self.errors if isinstance(e, validation.FormError)]
def __nonzero__(self):
return len(self.errors) != 0
class FormResource(object):
implements(inevow.IResource)
def locateChild(self, ctx, segments):
# The form name is the first segment
formName = segments[0]
if segments[1] == WIDGET_RESOURCE_KEY:
# Serve up file from the resource manager
d = locateForm(ctx, formName)
d.addCallback(self._fileFromWidget, ctx, segments[2:])
return d
return appserver.NotFound
def renderHTTP(self, ctx):
raise NotImplemented()
def _fileFromWidget(self, form, ctx, segments):
ctx.remember(form, iforms.IForm)
widget = form.widgetForItem(segments[0])
return widget.getResource(ctx, segments[1:])
class FormsResourceBehaviour(object):
"""
I provide the IResource behaviour needed to process and render a page
containing a Form.
"""
def __init__(self, **k):
parent = k.pop('parent')
super(FormsResourceBehaviour, self).__init__(**k)
self.parent = parent
def locateChild(self, ctx, segments):
if segments[0] == FORMS_KEY:
self.remember(ctx)
return FormResource(), segments[1:]
return appserver.NotFound
def renderHTTP(self, ctx):
# Get hold of the request
request = inevow.IRequest(ctx)
# Intercept POST requests to see if it's for me
if request.method != 'POST':
return None
# Try to find the form name
formName = request.args.get(FORMS_KEY, [None])[0]
if formName is None:
return None
# Find the actual form and process it
self.remember(ctx)
d = defer.succeed(ctx)
d.addCallback(locateForm, formName)
d.addCallback(self._processForm, ctx)
return d
def remember(self, ctx):
ctx.remember(self.parent, iforms.IFormFactory)
def render_form(self, name):
def _(ctx, data):
self.remember(ctx)
return renderForm(name)
return _
def _processForm(self, form, ctx):
ctx.remember(form, iforms.IForm)
d = defer.maybeDeferred(form.process, ctx)
d.addCallback(self._formProcessed, ctx)
return d
def _formProcessed(self, result, ctx):
if isinstance(result, FormErrors):
return None
elif result is None:
resource = url.URL.fromContext(ctx)
else:
resource = result
return resource
class ResourceMixin(object):
implements( iforms.IFormFactory )
def __init__(self, *a, **k):
super(ResourceMixin, self).__init__(*a, **k)
self.remember(self, iforms.IFormFactory)
self.__formsBehaviour = FormsResourceBehaviour(parent=self)
def locateChild(self, ctx, segments):
def gotResult(result):
if result is not appserver.NotFound:
return result
return super(ResourceMixin, self).locateChild(ctx, segments)
d = defer.maybeDeferred(self.__formsBehaviour.locateChild, ctx, segments)
d.addCallback(gotResult)
return d
def renderHTTP(self, ctx):
def gotResult(result):
if result is not None:
return result
return super(ResourceMixin, self).renderHTTP(ctx)
d = defer.maybeDeferred(self.__formsBehaviour.renderHTTP, ctx)
d.addCallback(gotResult)
return d
def render_form(self, name):
return self.__formsBehaviour.render_form(name)
def formFactory(self, ctx, name):
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
s = super(ResourceMixin, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
class IKnownForms(Interface):
"""Marker interface used to locate a dict instance containing the named
forms we know about during this request.
"""
class KnownForms(dict):
implements( IKnownForms )
def locateForm(ctx, name):
"""Locate a form by name.
Initially, a form is located by calling on an IFormFactory that is found
on the context. Once a form has been found, it is remembered in an
KnownForms instance for the lifetime of the request.
This ensures that the form that is located during form processing will be
the same instance that is located when a form is rendered after validation
failure.
"""
# Get hold of the request
request = inevow.IRequest(ctx)
# Find or create the known forms instance
knownForms = request.getComponent(IKnownForms)
if knownForms is None:
knownForms = KnownForms()
request.setComponent(IKnownForms, knownForms)
# See if the form is already known
form = knownForms.get(name)
if form is not None:
return form
# Not known yet, ask a form factory to create the form
factory = ctx.locate(iforms.IFormFactory)
def cacheForm( form, name ):
if form is None:
raise Exception('Form %r not found'%name)
form.name = name
# Make it a known
knownForms[name] = form
return form
d = defer.succeed( None )
d.addCallback( lambda r : factory.formFactory( ctx, name ) )
d.addCallback( cacheForm, name )
return d
def widgetResourceURL(name):
return url.here.child(FORMS_KEY).child(name).child(WIDGET_RESOURCE_KEY)
class FormRenderer(object):
implements( inevow.IRenderer )
loader = loaders.stan(
T.form(id=T.slot('id'), action=T.slot('action'), class_='nevow-form', method='post', enctype='multipart/form-data', **{'accept-charset':'utf-8'})[
T.fieldset[
T.input(type='hidden', name='_charset_'),
T.input(type='hidden', name=FORMS_KEY, value=T.slot('name')),
T.slot('errors'),
T.slot('items'),
T.div(id=T.slot('fieldId'), pattern='item', _class=T.slot('class'))[
T.label(_class='label', _for=T.slot('id'))[T.slot('label')],
T.div(_class='inputs')[T.slot('inputs')],
T.slot('description'),
T.slot('message'),
],
T.div(class_='hiddenitems')[
T.slot('hiddenitems'),
T.invisible(pattern="hiddenitem")[T.slot('inputs')]
],
T.div(class_='actions')[
T.slot('actions'),
],
],
]
)
def __init__(self, original, *a, **k):
super(FormRenderer, self).__init__(*a, **k)
self.original = original
def rend(self, ctx, data):
tag = T.invisible[self.loader.load()]
tag.fillSlots('name', self.original.name)
tag.fillSlots('id', util.keytocssid(ctx.key))
tag.fillSlots('action', url.here)
tag.fillSlots('errors', self._renderErrors)
tag.fillSlots('items', self._renderItems)
tag.fillSlots('hiddenitems', self._renderHiddenItems)
tag.fillSlots('actions', self._renderActions)
return tag
def _renderErrors(self, ctx, data):
errors = iforms.IFormErrors(ctx, None)
if errors is not None:
errors = errors.getFormErrors()
if not errors:
return ''
return T.div(class_='errors')[
T.p['Please correct the following errors:'],
T.ul[[T.li[str(error)] for error in errors]],
]
def _renderItems(self, ctx, data):
if self.original.items is None:
yield ''
return
itemPattern = inevow.IQ(ctx).patternGenerator('item')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') != 'hidden':
yield itemPattern(key=item[0], data=item, render=self._renderItem)
def _renderHiddenItems(self, ctx, data):
if self.original.items is None:
yield ''
return
hiddenItemPattern = inevow.IQ(ctx).patternGenerator('hiddenitem')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') == 'hidden':
yield hiddenItemPattern(key=item[0], data=item, render=self._renderHiddenItem)
def _renderItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
if formErrors is None:
error = None
else:
error = formErrors.getFieldError(name)
# Basic classes are 'field', the type's class name and the widget's
# class name.
classes = [
'field',
type.__class__.__name__.lower(),
widget.__class__.__name__.lower(),
]
# Add a required class
if type.required:
classes.append('required')
# Add a user-specified class
if cssClass:
classes.append(cssClass)
if error is None:
message = ''
else:
classes.append('error')
message = T.div(class_='message')[str(error)]
ctx.tag.fillSlots('class', ' '.join(classes))
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('label', label)
if type.immutable:
render = widget.renderImmutable
else:
render = widget.render
ctx.tag.fillSlots('inputs', render(ctx, name, formData, formErrors))
ctx.tag.fillSlots('message', message)
ctx.tag.fillSlots('description', T.div(class_='description')[description or ''])
return ctx.tag
return _
def _renderHiddenItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('inputs', widget.render(ctx, name, formData, formErrors))
return ctx.tag
return _
def _renderActions(self, ctx, data):
if self.original.actions is None:
yield ''
return
for action in self.original.actions:
yield T.invisible(data=action, render=self._renderAction)
def _renderAction(self, ctx, data):
return T.input(type='submit', id='%s-action-%s'%(util.keytocssid(ctx.key), data.name), name=data.name, value=data.label)
registerAdapter(FormRenderer, Form, inevow.IRenderer)
| Python |
from nevow import tags as T, util
from forms import iforms
from zope.interface import implements
tinyMCEGlue = T.xml("""
<!-- tinyMCE -->
<script language="javascript" type="text/javascript" src="/tiny_mce/tiny_mce.js"></script>
<script language="javascript" type="text/javascript">
tinyMCE.init({
mode : "specific_textareas"
theme: 'advanced',
theme_advanced_toolbar_location: 'top',
theme_advanced_toolbar_align: 'left'
});
</script>
<!-- /tinyMCE -->
""" )
class TinyMCE(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.textarea(name=key, id=key, mce_editable='true')[value or '']
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if value:
value=T.xml(value)
else:
value=''
return T.div(id=key, class_="readonly-textarea-container") [
T.div(class_='readonly-textarea readonly')[value]
]
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
| Python |
from nevow import appserver, rend
from forms.form import FormsResourceBehaviour
class FormPage(rend.Page):
"""
Base class for pages that contain a Form.
XXX This really, really needs to turn into a ComponentPage that iterates
a bunch of component behaviours looking for something that succeeded.
The components probably needs to be per-interface, i.e IResource for
locateChild/renderHTTP, IRenderer for render_, etc.
"""
def __init__(self, *a, **k):
rend.Page.__init__(self, *a, **k)
self._formsComponent = FormsResourceBehaviour(parent=self)
def locateChild(self, ctx, segments):
def gotResult(result):
if result is not appserver.NotFound:
return result
return rend.Page.locateChild(self, ctx, segments)
d = defer.maybeDeferred(self._formsComponent.locateChild, ctx, segments)
d.addCallback(gotResult)
return d
def renderHTTP(self, ctx):
def gotResult(result):
if result is not None:
return result
return rend.Page.renderHTTP(self, ctx)
d = defer.maybeDeferred(self._formsComponent.renderHTTP, ctx)
d.addCallback(gotResult)
return d
def render_form(self, name):
return self._formsComponent.render_form(name)
def formFactory(self, ctx, name):
# Find the factory method
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
# Try the super class
s = super(FormPage, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
| Python |
import tempfile
import mimetypes
import re
import os
from shutil import copyfileobj
from exceptions import IOError, OSError
class ResourceManagerException( Exception ):
def __init__( self, *args, **kwds ):
super( ResourceManagerException, self ).__init__( *args, **kwds )
class ResourceManager( object ):
def __init__( self ):
self.widgetToID = {}
def register( self, widgetName, resourceId ):
self.widgetToID[widgetName] = resourceId
def getResourceId( self, widgetName ):
return self.widgetToID.get( widgetName )
def getResourceForWidget( self, widgetName ):
resourceId = self.getResourceId( widgetName )
if resourceId is None:
return None
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
try:
filelike = open( path, 'r' )
return (mimetype, filelike, fileName)
except IOError:
return None
def getResourcePath( self, resourceId ):
"""
Required to create an instance of nevow.static.File
"""
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
return (mimetype, path, fileName)
def setResource( self, widgetName, filelike, fileName ):
existingResource = self.widgetToID.get( widgetName )
if existingResource is not None:
try:
(path, ignore) = self._fromResourceId( existingResource )
os.remove( path )
except OSError:
pass
# Encode the filename to avoid any unicode filesystem errors.
fileName = self._encodeFilename(fileName)
(target, path) = tempfile.mkstemp( '__' + fileName )
# target is a file handle. We want a file object.
target = os.fdopen(target, 'w')
copyfileobj( filelike, target )
target.close()
resourceId = self._toResourceId( path )
self.widgetToID[widgetName] = resourceId
return resourceId
def _fromResourceId( self, resourceId ):
match = re.match( '^.*__(.*)$', resourceId )
if match is None:
return None
fileName = match.group( 1 )
path = os.sep.join( (tempfile.gettempdir(), resourceId) )
return path, self._decodeFilename(fileName)
def _toResourceId( self, path ):
path = path[len(tempfile.gettempdir()):]
if path[0] == os.sep:
path = path[1:]
return path
def clearUpResources( self ):
for id in self.widgetToID.values():
try:
(path, fileName) = self._fromResourceId( id )
os.remove( path )
except OSError:
pass
def _encodeFilename(self, filename):
"""
Encode the filename (which may be unicode) so it's safe to use with
the filesystem.
"""
return filename.encode('utf-8').encode('base64')[:-1]
def _decodeFilename(self, filename):
"""
Undo what _encodeFilename did.
"""
filename = filename + '\n'
return filename.decode('base64').decode('utf-8')
| Python |
"""Adapters for converting to and from a type's value according to an
IConvertible protocol.
"""
from datetime import date, time
from nevow.compy import Adapter
from forms import iforms, validation
from zope.interface import implements
class NullConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value
def toType(self, value):
if value is None:
return None
return value
class NumberToStringConverter(Adapter):
implements( iforms.IStringConvertible )
cast = None
def fromType(self, value):
if value is None:
return None
return str(value)
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
try:
value = self.cast(value)
except ValueError:
raise validation.FieldValidationError("Not a valid number")
return value
class IntegerToStringConverter(NumberToStringConverter):
cast = int
class FloatToStringConverter(NumberToStringConverter):
cast = float
class BooleanToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
if value:
return 'True'
return 'False'
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
if value not in ('True', 'False'):
raise validation.FieldValidationError('%r should be either True or False')
return value == 'True'
class DateToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseDate(value)
def parseDate(self, value):
try:
y, m, d = [int(p) for p in value.split('-')]
except ValueError:
raise validation.FieldValidationError('Invalid date')
try:
value = date(y, m, d)
except ValueError, e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
class TimeToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseTime(value)
def parseTime(self, value):
if '.' in value:
value, ms = value.split('.')
else:
ms = 0
try:
parts = value.split(':')
if len(parts)<2 or len(parts)>3:
raise ValueError()
if len(parts) == 2:
h, m = parts
s = 0
else:
h, m, s = parts
h, m, s, ms = int(h), int(m), int(s), int(ms)
except:
raise validation.FieldValidationError('Invalid time')
try:
value = time(h, m, s, ms)
except ValueError, e:
raise validation.FieldValidationError('Invalid time: '+str(e))
return value
class DateToDateTupleConverter(Adapter):
implements( iforms.IDateTupleConvertible )
def fromType(self, value):
if value is None:
return None, None, None
return value.year, value.month, value.day
def toType(self, value):
if value is None:
return None
try:
value = date(*value)
except (TypeError, ValueError), e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
| Python |
from zope.interface import implements
from nevow import inevow
from forms import iforms
def titleFromName(name):
def _():
it = iter(name)
last = None
while 1:
ch = it.next()
if ch == '_':
if last != '_':
yield ' '
elif last in (None,'_'):
yield ch.upper()
elif ch.isupper() and not last.isupper():
yield ' '
yield ch.upper()
else:
yield ch
last = ch
return ''.join(_())
def keytocssid(key):
return '-'.join(key.split('.'))
class SequenceKeyLabelAdapter(object):
implements( iforms.IKey, iforms.ILabel )
def __init__(self, original):
self.original = original
def key(self):
return self.original[0]
def label(self):
return self.original[1]
class LazyResource(object):
implements(inevow.IResource)
def __init__(self, factory):
self.factory = factory
self._resource = None
def locateChild(self, ctx, segments):
return self.resource().locateCHild(ctx, segments)
def renderHTTP(self, ctx):
return self.resource().renderHTTP(ctx)
def resource(self):
if self._resource is None:
self._resource = self.factory()
return self._resource
| Python |
"""
Widgets are small components that render form fields for inputing data in a
certain format.
"""
import itertools
from nevow import inevow, tags as T, util, url, static
from nevow.i18n import _
from forms import converters, iforms, validation
from forms.util import keytocssid
from forms.form import widgetResourceURL
from zope.interface import implements
from twisted.internet import defer
# Marker object for args that are not supplied
_UNSET = object()
class TextInput(object):
"""
A text input field.
<input type="text" ... />
"""
implements( iforms.IWidget )
inputType = 'text'
showValueOnFailure = True
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, readonly):
tag=T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if not self.showValueOnFailure:
value = None
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class Checkbox(object):
"""
A checkbox input field.
<input type="checkbox" ... />
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, disabled):
tag = T.input(type='checkbox', name=key, id=keytocssid(ctx.key), value='True')
if value == 'True':
tag(checked='checked')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [None])[0]
if not value:
value = 'False'
value = iforms.IBooleanConvertible(self.original).toType(value)
return self.original.validate(value)
class Password(TextInput):
"""
A text input field that hides the text.
<input type="password" ... />
"""
inputType = 'password'
showValueOnFailure = False
class TextArea(object):
"""
A large text entry area that accepts newline characters.
<textarea>...</textarea>
"""
implements( iforms.IWidget )
cols = 48
rows = 6
def __init__(self, original, cols=None, rows=None):
self.original = original
if cols is not None:
self.cols = cols
if rows is not None:
self.rows = rows
def _renderTag(self, ctx, key, value, readonly):
tag=T.textarea(name=key, id=keytocssid(ctx.key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class CheckedPassword(object):
"""
Two password entry fields that must contain the same value to validate.
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors and not errors.getFieldError(key):
values = args.get(key)
else:
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0]),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1]),
]
def renderImmutable(self, ctx, key, args, errors):
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0], class_='readonly', readonly='readonly'),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1], class_='readonly', readonly='readonly')
]
def processInput(self, ctx, key, args):
pwds = [pwd for pwd in args.get(key, [])]
if len(pwds) == 0:
pwd = ''
elif len(pwds) == 1:
raise validation.FieldValidationError('Please enter the password twice for confirmation.')
else:
if pwds[0] != pwds[1]:
raise validation.FieldValidationError('Passwords do not match.')
return self.original.validate(pwds[0])
class ChoiceBase(object):
"""
A base class for widgets that provide the UI to select one or more items
from a list.
options:
A sequence of objects adaptable to IKey and ILabel. IKey is used as the
<option>'s value attribute; ILabel is used as the <option>'s child.
IKey and ILabel adapters for tuple are provided.
noneOption:
An object adaptable to IKey and ILabel that is used to identify when
nothing has been selected. Defaults to ('', '')
"""
options = None
noneOption = None
def __init__(self, original, options=None, noneOption=_UNSET):
self.original = original
if options is not None:
self.options = options
if noneOption is not _UNSET:
self.noneOption = noneOption
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0]
value = iforms.IStringConvertible(self.original).toType(value)
if self.noneOption is not None and value == self.noneOption[0]:
value = None
return self.original.validate(value)
class SelectChoice(ChoiceBase):
"""
A drop-down list of options.
<select>
<option value="...">...</option>
</select>
"""
implements( iforms.IWidget )
noneOption = ('', '')
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iforms.IKey(self.noneOption).key())[iforms.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
option = T.option(value=optValue)[optLabel]
if optValue == value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=keytocssid(ctx.key), data=self.options)[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
class RadioChoice(ChoiceBase):
"""
A list of options in the form of radio buttons.
<input type="radio" ... value="..."/><label>...</label><br />
<input type="radio" ... value="..."/><label>...</label><br />
"""
implements( iforms.IWidget )
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOption(ctx, itemKey, itemLabel, num, selected):
cssid = (keytocssid(ctx.key),'-',num)
tag = T.input(name=key, type='radio', id=cssid, value=itemKey)
if selected:
tag = tag(checked='checked')
return tag, ' ', T.label(for_=cssid)[itemLabel], T.br
def renderOptions(ctx, data):
# A counter to assign unique ids to each input
idCounter = itertools.count()
if self.noneOption is not None:
itemKey = iforms.IKey(self.noneOption).key()
itemLabel = iforms.ILabel(self.noneOption).label()
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
if not data:
return
for item in data:
itemKey = iforms.IKey(item).key()
itemLabel = iforms.ILabel(item).label()
itemKey = converter.fromType(itemKey)
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
return T.invisible(data=self.options)[renderOptions]
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
class DatePartsInput(object):
"""
Three text input fields for entering a date in parts.
Default format is month/day/year
dayFirst:
Make the day the first input field. day/month/year
"""
implements( iforms.IWidget )
dayFirst = False
def __init__(self, original, dayFirst=None):
self.original = original
if dayFirst is not None:
self.dayFirst = dayFirst
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, day, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=4)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
dayTag = T.input(type="text", name=namer('day'), value=day, size=2)
if readonly:
tags = (yearTag, monthTag, dayTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
if self.dayFirst:
return dayTag, ' / ', monthTag, ' / ', yearTag, ' ', _('(day/month/year)')
else:
return monthTag, ' / ', dayTag, ' / ', yearTag, ' ', _('(month/day/year)')
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
day = args.get(namer('day'), [''])[0]
else:
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month', 'day')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 3:
raise validation.FieldValidationError("Invalid date")
if value is not None and len(value[0]) != 4:
raise validation.FieldValidationError("Please enter a 4-digit year")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
value = iforms.IDateTupleConvertible(self.original).toType(value)
return self.original.validate(value)
class MMYYDatePartsInput(object):
"""
Two input fields for entering the month and year.
"""
implements( iforms.IWidget )
cutoffYear = 70
def __init__(self, original, cutoffYear=None):
self.original = original
if cutoffYear is not None:
self.cutoffYear = cutoffYear
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=2)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
if readonly:
tags=(yearTag, monthTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
return monthTag, ' / ', yearTag, ' (mm/yy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
# return a blank for the day
day = ''
else:
year, month, day = converter.fromType(args.get(key))
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
year, month, day = converter.fromType(args.get(key))
namer = self._namer(key)
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 2:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
if value[1] < 0 or value[1] > 99:
raise validation.FieldValidationError("Invalid year. Please enter a two-digit year.")
if value[0] > self.cutoffYear:
value[0] = 1900 + value[0]
else:
value[0] = 2000 + value[0]
value.append(1)
value = iforms.IDateTupleConvertible(self.original).toType( value )
return self.original.validate(value)
class CheckboxMultiChoice(object):
"""
Multiple choice list, rendered as a list of checkbox fields.
"""
implements( iforms.IWidget )
options = None
def __init__(self, original, options=None):
self.original = original
if options is not None:
self.options = options
def _renderTag(self, ctx, key, values, converter, disabled):
# loops through checkbox options and renders
for n,item in enumerate(self.options):
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
optid = (keytocssid(ctx.key),'-',n)
checkbox = T.input(type='checkbox', name=key, value=optValue, id=optid )
if optValue in values:
checkbox = checkbox(checked='checked')
if disabled:
checkbox = checkbox(class_='disabled', disabled='disabled')
yield checkbox, T.label(for_=optid)[optLabel], T.br()
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
if errors:
values = args.get(key, [])
else:
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, True)
def processInput(self, ctx, key, args):
values = args.get(key, [])
converter = iforms.IStringConvertible(self.original.type)
values = [converter.toType(v) for v in values]
return self.original.validate(values)
class FileUploadRaw(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, disabled):
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
value = (name, fileitem.file)
value = iforms.IFileConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUpload(object):
implements( iforms.IWidget )
def __init__(self, original, fileHandler, preview=None):
self.original = original
self.fileHandler = fileHandler
self.preview = preview
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, key, value, namer, disabled):
name = self.fileHandler.getUrlForFile(value)
if name:
if self.preview == 'image':
yield T.p[value,T.img(src=self.fileHandler.getUrlForFile(value))]
else:
yield T.p[value]
else:
yield T.p[T.strong['nothing uploaded']]
yield T.input(name=namer('value'),value=value,type='hidden')
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
yield tag
def render(self, ctx, key, args, errors):
namer = self._namer(key)
if errors:
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = name
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, False)
def renderImmutable(self, ctx, key, args, errors):
namer = self._namer(key)
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = self.fileHandler.storeFile( fileitem.file, name )
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUploadWidget(object):
"""
File upload widget that carries the uploaded file around until the form
validates.
The widget uses the resource manager to save the file to temporary storage
until the form validates. This makes file uploads behave like most of the
other widgets, i.e. the value is kept when a form is redisplayed due to
validation errors.
"""
implements( iforms.IWidget )
FROM_RESOURCE_MANAGER = 'rm'
FROM_CONVERTIBLE = 'cf'
convertibleFactory = converters.NullConverter
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def __init__( self, original, convertibleFactory=None, originalKeyIsURL=False ):
self.original = original
if convertibleFactory is not None:
self.convertibleFactory = convertibleFactory
self.originalKeyIsURL = originalKeyIsURL
def _blankField( self, field ):
"""
Convert empty strings into None.
"""
if field and field == '':
return None
return field
def _getFromArgs( self, args, name ):
"""
Get the first value of 'name' from 'args', or None.
"""
rv = args.get( name )
if rv:
rv = rv[0]
return rv
def render(self, ctx, key, args, errors):
"""
Render the data.
This either renders a link to the original file, if specified, and
no new file has been uploaded. Or a link to the uploaded file.
The request to get the data should be routed to the getResouce
method.
"""
form = iforms.IForm( ctx )
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
originalIdName = namer( 'original_id' )
# get the resource id first from the resource manager
# then try the request
resourceId = form.resourceManager.getResourceId( key )
if resourceId is None:
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
# Get the original key from a hidden field in the request,
# then try the request file.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if resourceId:
# Have an uploaded file, so render a URL to the uploaded file
tmpURL = widgetResourceURL(form.name).child(key).child( self.FROM_RESOURCE_MANAGER ).child(resourceId)
yield T.p[T.img(src=tmpURL)]
elif originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = widgetResourceURL(form.name).child(key).child( self.FROM_CONVERTIBLE ).child( originalKey )
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
yield T.input(name=key, id=keytocssid(ctx.key),type='file')
# Id of uploaded file in the resource manager
yield T.input(name=resourceIdName,value=resourceId,type='hidden')
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def renderImmutable(self, ctx, key, args, errors):
form = iforms.IForm(ctx)
namer = self._namer(key)
originalIdName = namer('original_id')
# Get the original key from a hidden field in the request,
# then try the request form.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = widgetResourceURL(form.name).child(key).child(self.FROM_CONVERTIBLE).child(originalKey)
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def processInput(self, ctx, key, args):
"""
Process the request, storing any uploaded file in the
resource manager.
"""
resourceManager = iforms.IForm( ctx ).resourceManager
# Ping the resource manager with any resource ids that I know
self._registerWithResourceManager( key, args, resourceManager )
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
# Store the uploaded file in the resource manager
resourceManager.setResource( key, fileitem.file, name )
# Validating against an uploaded file. Should the fact that there is
# original file meet a required field validation?
value = resourceManager.getResourceForWidget( key )
value = self.convertibleFactory(self.original).toType( value )
return self.original.validate( value )
def _registerWithResourceManager( self, key, args, resourceManager ):
"""
If there is a resource id in the request, then let the
resource manager know about it.
"""
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
if resourceId:
resourceManager.register( key, resourceId )
def getResource( self, ctx, segments ):
"""
Return an Resource that contains the image, either a file
from the resource manager, or a data object from the convertible.
"""
if segments[0] == self.FROM_RESOURCE_MANAGER:
# Resource manager can provide a path so return a static.File
# instance that points to the file
rm = iforms.IForm( ctx ).resourceManager
(mimetype, path, fileName) = rm.getResourcePath( segments[1] )
return static.File( path, mimetype ), []
elif segments[0] == self.FROM_CONVERTIBLE:
# The convertible can provide a file like object so create a
# static.Data instance with the data from the convertible.
def _( result ):
mimetype, filelike, fileName = result
data = filelike.read()
filelike.close()
return static.Data( data, mimetype ), []
d = defer.maybeDeferred( self.convertibleFactory(self.original).fromType, segments[1], context=ctx )
d.addCallback( _ )
return d
else:
return None
class Hidden(object):
"""
A hidden form field.
"""
__implements__ = iforms.IWidget,
inputType = 'hidden'
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
def renderImmutable(self, ctx, key, args, errors):
return self.render(ctx, key, args, errors)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
__all__ = [
'Checkbox', 'CheckboxMultiChoice', 'CheckedPassword','FileUploadRaw', 'FileUpload', 'FileUploadWidget',
'Password', 'SelectChoice', 'TextArea', 'TextInput', 'DatePartsInput',
'MMYYDatePartsInput', 'Hidden', 'RadioChoice',
]
| Python |
import re
from zope.interface import implements
from forms import iforms
class FormError(Exception):
pass
class FieldError(Exception):
def __init__(self, message, fieldName=None):
Exception.__init__(self, message)
self.message = message
self.fieldName = fieldName
class FieldValidationError(FieldError):
pass
class FieldRequiredError(FieldValidationError):
pass
class RequiredValidator(object):
implements(iforms.IValidator)
def validate(self, field, value):
if value is None:
raise FieldRequiredError, 'Required'
class LengthValidator(object):
"""Validate the length of the value is within a given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be longer than %r characters'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be shorter than %r characters'%(self.max,)
return 'Must be between %r and %r characters'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
length = len(value)
if self.min is not None and length < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and length > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class RangeValidator(object):
"""Validate the size of the value is within is given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be greater than %r'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be less than %r'%(self.max,)
return 'Must be between %r and %r'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
if self.min is not None and value < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and value > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class PatternValidator(object):
"""Validate the value is a certain pattern.
The required pattern is defined as a regular expression. The regex will be
compiled automatically if necessary.
"""
implements(iforms.IValidator)
def __init__(self, regex):
self.regex = regex
def validate(self, field, value):
if value is None:
return
# If it doesn't look like a regex object then compile it now
if not hasattr(self.regex, 'match'):
self.regex = re.compile(self.regex)
if self.regex.match(value) is None:
raise FieldValidationError, 'Invalid format'
__all__ = [
'FormError', 'FieldError', 'FieldValidationError', 'FieldRequiredError',
'RequiredValidator', 'LengthValidator', 'RangeValidator', 'PatternValidator',
]
| Python |
import forms
title = 'Dates'
description = 'Date entry examples'
def makeForm(ctx):
form = forms.Form()
form.addField('isoFormat', forms.Date(), forms.TextInput)
form.addField('monthFirst', forms.Date(), forms.DatePartsInput)
form.addField('dayFirst', forms.Date(), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('monthAndYear', forms.Date(), forms.MMYYDatePartsInput)
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
from nevow import url
import forms
title = 'Action Button'
description = 'Example of non-validating button, buttons with non-default labels, etc'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String(required=True))
form.addAction(formSubmitted, label="Click, click, clickety-click!")
form.addAction(redirect, 'back', validate=False)
return form
def formSubmitted(ctx, form, data):
print form, data
def redirect(ctx, form, data):
return url.rootaccessor(ctx)
| Python |
import forms
title = 'Simple Form'
description = 'Probably the simplest form possible.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import forms
title = 'Form Types'
description = 'Example of using different typed fields.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aInteger', forms.Integer())
form.addField('aFloat', forms.Float())
form.addField('aBoolean', forms.Boolean())
form.addField('aDate', forms.Date())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from datetime import date
import forms
title = 'Missing Values'
description = 'Providing default values when missing'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String(missing='<nothing>'))
form.addField('aDate', forms.Date(missing=date(2005, 8, 1)))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
import forms
title = 'File Upload'
description = 'Uploading a file'
def makeForm(ctx):
form = forms.Form()
form.addField('file', forms.File())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import pkg_resources
from twisted.python import reflect
from nevow import appserver, loaders, rend, static, tags as T, url
import forms
DOCTYPE = T.xml('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">')
CHARSET = T.xml('<meta http-equiv="content-type" content="text/html; charset=utf-8" />')
examples = [
'forms.examples.simple',
'forms.examples.types',
'forms.examples.required',
'forms.examples.missing',
'forms.examples.prepopulate',
'forms.examples.fileupload',
'forms.examples.smartupload',
'forms.examples.selections',
'forms.examples.dates',
'forms.examples.actionbuttons',
]
def makeSite(application):
root = RootPage()
site = appserver.NevowSite(root, logPath='web.log')
return site
class RootPage(rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title['Forms Examples'],
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
],
T.body[
T.directive('examples'),
],
],
],
)
def render_examples(self, ctx, data):
for name in examples:
module = reflect.namedAny(name)
yield T.div(class_='example')[
T.h1[T.a(href=url.here.child(name))[module.title]],
T.p[module.description],
]
def childFactory(self, ctx, name):
if name in examples:
return FormExamplePage(reflect.namedAny(name))
class FormExamplePage(forms.ResourceMixin, rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title(data=T.directive('title'), render=rend.data),
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
T.link(rel='stylesheet', type='text/css', href=url.root.child('forms.css')),
],
T.body[
T.h1(data=T.directive('title'), render=rend.data),
T.p(data=T.directive('description'), render=rend.data),
T.directive('form example'),
],
],
],
)
def data_title(self, ctx, data):
return self.original.title
def data_description(self, ctx, data):
return self.original.description
def form_example(self, ctx):
return self.original.makeForm(ctx)
# Add child_ attributes
examples_css = pkg_resources.resource_filename('forms.examples', 'examples.css')
setattr(RootPage, 'child_examples.css', static.File(examples_css))
setattr(RootPage, 'child_forms.css', forms.defaultCSS)
| Python |
import forms
title = 'Smart File Upload'
description = 'Smart uploading of files where the file is "carried across" when the validation fails'
def makeForm(ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('file', forms.File(), forms.FileUploadWidget)
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.