code stringlengths 1 1.72M | language stringclasses 1 value |
|---|---|
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-rest',
version=forms.version,
description='HTML forms framework for Nevow, branch with ReST control',
author='Matt Goodall',
author_email='matt@pollenation.net',
packages=find_packages(),
package_data={
'forms': ['forms.css','forms.js'],
}
)
| 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[0], 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)
def widgetResourceURLFromContext(ctx,name):
# Could this replace widgetResourceURL?
u = url.URL.fromContext(ctx)
if u.pathList()[-1] != FORMS_KEY:
u = u.child(FORMS_KEY)
return u.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.
NOTE: the string encode('base64') can result in strings with '\n'
embedded in them. the base64.b64encode() does not appear to suffer this
problem.
"""
import base64
rv = filename.encode('utf-8')
rv = base64.b64encode(rv)
return rv
def _decodeFilename(self, filename):
"""
Undo what _encodeFilename did.
"""
import base64
rv = base64.b64decode(filename)
rv = rv.decode('utf-8')
return rv
| 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, rend, loaders
from nevow.i18n import _
from forms import converters, iforms, validation
from forms.util import keytocssid
from forms.form import widgetResourceURL, widgetResourceURLFromContext
from zope.interface import implements
from twisted.internet import defer
from cStringIO import StringIO
# 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, key, 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)
class ReSTTextArea(TextArea):
"""
A large text entry area that accepts ReST and previews it as HTML
This will accept a restWriter parameter
"""
def __init__(self, original, **kwds):
try:
self.restWriter = kwds.pop('restWriter')
except KeyError:
self.restWriter = None
TextArea.__init__(self, original, **kwds)
def _renderTag(self, ctx, key, value, readonly):
tag=T.invisible()
ta=T.textarea(name=key, id=keytocssid(ctx.key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
ta(class_='readonly', readonly='readonly')
tag[ta]
if not readonly:
try:
import docutils
form = iforms.IForm( ctx )
srcId = keytocssid(ctx.key)
previewDiv = srcId + '-preview-div'
frameId = srcId + '-preview-frame'
targetURL = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId )
tag[T.br()]
tag[T.button(onClick="return Forms.Util.previewShow('%s', '%s', '%s');"%(previewDiv, frameId, targetURL))['Preview ...']]
tag[T.div(id=previewDiv, class_="preview-hidden")[
T.iframe(class_="preview-frame", name=frameId, id=frameId),
T.br(),
T.button(onClick="return Forms.Util.previewHide('%s');"%(previewDiv))['Close']
]
]
except:
pass
return tag
def getResource(self, ctx, key, segments):
return ReSTPreview(ctx, self.restWriter, key, segments[0]), segments[1:]
class ReSTPreview(rend.Page):
def __init__(self, ctx, restWriter, key, srcId):
self.restWriter = restWriter
form = iforms.IForm( ctx )
u = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId ).child('_submit')
self.destId=srcId + '-dest'
formId=srcId + '-form'
stan = T.html()[
T.head()[
T.script(type="text/javascript")["""
function ReSTTranslate() {
dest = document.getElementById('%(destId)s');
form = document.getElementById('%(formId)s');
src = parent.document.getElementById('%(srcId)s');
dest.value = src.value;
form.submit();
}
"""%{'srcId':srcId, 'destId':self.destId, 'formId':formId}]
],
T.body()[
T.form(id=formId, method="POST", action=u)[
T.input(type="hidden", name=self.destId, id=self.destId)
],
T.script(type="text/javascript")["ReSTTranslate();"],
],
]
self.docFactory = loaders.stan(stan)
def child__submit(self, ctx):
args = inevow.IRequest(ctx).args
value = args.get(self.destId, [''])[0]
from docutils.utils import SystemMessage
try:
if self.restWriter:
restValue = self._html_fragment(value, writer=self.restWriter)
else:
restValue = self._html_fragment(value, writer_name='html')
except SystemMessage, e:
restValue = str(e)
stan = T.html()[
T.head()[
T.style(type="text/css")["""
.system-message {border: 1px solid red; background-color: #FFFFDD; margin: 5px; padding: 5px;}
.system-message-title { font-weight: bold;}
"""
]
],
T.body()[
T.div()[
T.xml(restValue)
]
],
]
self.docFactory = loaders.stan(stan)
return self
def _html_fragment(self, input_string, writer=None, writer_name=None):
from docutils.core import publish_parts
overrides = {'input_encoding': 'utf8',
'doctitle_xform': 0,
'initial_header_level': 1}
parts = publish_parts(
source=input_string,
writer_name=writer_name, writer=writer, settings_overrides=overrides)
fragment = parts['fragment']
return fragment.encode('utf8')
__all__ = [
'Checkbox', 'CheckboxMultiChoice', 'CheckedPassword','FileUploadRaw', 'FileUpload', 'FileUploadWidget',
'Password', 'SelectChoice', 'TextArea', 'TextInput', 'DatePartsInput',
'MMYYDatePartsInput', 'Hidden', 'RadioChoice', 'ReSTTextArea'
]
| 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
from docutils.writers.html4css1 import Writer, HTMLTranslator
from docutils import nodes
title = 'ReST widget'
description = 'The ReST widget captures ReST and previews as HTML.'
class CustomisedHTMLTranslator(HTMLTranslator):
def visit_newdirective_node(self, node):
self.body.append('<div>Some HTML with a %s parameter</div>\n'%(node.attributes['parameter'],))
def depart_newdirective_node(self, node):
pass
def makeForm(ctx):
w = Writer()
w.translator_class = CustomisedHTMLTranslator
form = forms.Form()
form.addField('restString', forms.String(required=True), forms.widgetFactory(forms.ReSTTextArea, restWriter=w))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
class newdirective_node(nodes.General, nodes.Inline, nodes.TextElement):
pass
def newdirective(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
return [newdirective_node('', parameter=arguments[0])]
newdirective.arguments = (1, 0, 0)
newdirective.options = None
from docutils.parsers.rst import directives
directives.register_directive('newdirective', newdirective)
| 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',
'forms.examples.restwidget',
]
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.script(type='text/javascript', src='forms.js'),
],
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)
setattr(RootPage, 'child_forms.js', forms.defaultJS)
| 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, 6)
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'))
defaultJS = static.File(os.path.join(os.path.split(__file__)[0], 'forms.js'))
else:
from forms.util import LazyResource
defaultCSS = LazyResource(lambda: static.File(pkg_resources.resource_filename('forms', 'forms.css')))
defaultJS = LazyResource(lambda: static.File(pkg_resources.resource_filename('forms', 'forms.js')))
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 |
"""
Form types.
"""
try:
import decimal
haveDecimal = True
except ImportError:
haveDecimal = False
from zope.interface import implements
from formal import iformal, validation
class Type(object):
implements( iformal.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 = list(validators)
else:
self.validators = list(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
if haveDecimal:
class Decimal(Type):
"""
Forms type for Python 2.4's decimal.Decimal type.
"""
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',
]
if haveDecimal:
__all__.append('Decimal')
| Python |
"""
Form implementation and high-level renderers.
"""
from zope.interface import Interface
from twisted.internet import defer
from twisted.python.components import registerAdapter
from nevow import appserver, context, loaders, inevow, rend, tags as T, url
from nevow.util import getPOSTCharset
from formal import iformal, util, validation
from resourcemanager import ResourceManager
from zope.interface import implements
SEPARATOR = '!!'
FORMS_KEY = '__nevow_form__'
WIDGET_RESOURCE_KEY = 'widget_resource'
# Backwards compatability/workaround until there's nothing left in Formal or
# application code that adapts the context to IFormErrors.
def formErrorsFinder(ctx):
form = iformal.IForm(ctx)
return form.errors
registerAdapter(formErrorsFinder, context.WovenContext, iformal.IFormErrors)
def renderForm(name):
def _(ctx, data):
def _processForm( form, ctx, name ):
# Remember the form
ctx.remember(form, iformal.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
if form.errors:
ctx.remember(form.errors.data, iformal.IFormData)
else:
ctx.remember(form.data or {}, iformal.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):
if not util.validIdentifier(name):
import warnings
warnings.warn('[0.9] Invalid action name %r. This will become an error in the future.' %
name, FutureWarning, stacklevel=3)
self.callback = callback
self.name = name
self.validate = validate
if label is None:
self.label = util.titleFromName(name)
else:
self.label = label
def itemKey(item):
"""
Build the form item's key from the the item's name and the name of all
ancestors.
"""
parts = [item.name]
parent = item.itemParent
while parent is not None:
parts.append(parent.name)
parent = parent.itemParent
parts.reverse()
return '.'.join(parts)
class Field(object):
itemParent = None
def __init__(self, name, type, widgetFactory=None, label=None,
description=None, cssClass=None):
if not util.validIdentifier(name):
raise ValueError('%r is an invalid field name'%name)
if label is None:
label = util.titleFromName(name)
if widgetFactory is None:
widgetFactory = iformal.IWidget
self.name = name
self.type = type
self.widgetFactory = widgetFactory
self.label = label
self.description = description
self.cssClass = cssClass
def setItemParent(self, itemParent):
self.itemParent = itemParent
key = property(lambda self: itemKey(self))
def makeWidget(self):
return self.widgetFactory(self.type)
def process(self, ctx, form, args, errors):
# If the type is immutable then copy the original value to args in case
# another validation error causes this field to be re-rendered.
if self.type.immutable:
args[self.key] = form.data.get(self.key)
return
# Process the input using the widget, storing the data back on the form.
try:
form.data[self.key] = self.makeWidget().processInput(ctx, self.key, args)
except validation.FieldError, e:
if e.fieldName is None:
e.fieldName = self.key
errors.add(e)
class FieldFragment(rend.Fragment):
implements(inevow.IRenderer)
docFactory = loaders.stan(
T.div(id=T.slot('fieldId'), _class=T.slot('class'),
render=T.directive('field'))[
T.label(_class='label', _for=T.slot('id'))[T.slot('label')],
T.div(_class='inputs')[T.slot('inputs')],
T.slot('description'),
T.slot('message'),
])
hiddenDocFactory = loaders.stan(
T.invisible(render=T.directive('field'))[T.slot('inputs')])
def __init__(self, field):
self.field = field
# Nasty hack to work out if this is a hidden field. Keep the widget
# for later anyway.
self.widget = field.makeWidget()
if getattr(self.widget, 'inputType', None) == 'hidden':
self.docFactory = self.hiddenDocFactory
def render_field(self, ctx, data):
# The field we're rendering
field = self.field
# Get stuff from the context
formData = iformal.IFormData(ctx)
formErrors = iformal.IFormErrors(ctx, None)
# Find any error
if formErrors is None:
error = None
else:
error = formErrors.getFieldError(field.key)
# Build the error message
if error is None:
message = ''
else:
message = T.div(class_='message')[error.message]
# Create the widget (it's created in __init__ as a hack)
widget = self.widget
# Build the list of CSS classes
classes = [
'field',
field.type.__class__.__name__.lower(),
widget.__class__.__name__.lower(),
]
if field.type.required:
classes.append('required')
if field.cssClass:
classes.append(field.cssClass)
if error:
classes.append('error')
# Create the widget and decide the method that should be called
if field.type.immutable:
render = widget.renderImmutable
else:
render = widget.render
# Fill the slots
tag = ctx.tag
tag.fillSlots('id', util.render_cssid(field.key))
tag.fillSlots('fieldId', [util.render_cssid(field.key), '-field'])
tag.fillSlots('class', ' '.join(classes))
tag.fillSlots('label', field.label)
tag.fillSlots('inputs', render(ctx, field.key, formData,
formErrors))
tag.fillSlots('message', message)
tag.fillSlots('description',
T.div(class_='description')[field.description or ''])
return ctx.tag
registerAdapter(FieldFragment, Field, inevow.IRenderer)
class AddHelperMixin(object):
"""
A mixin that provides methods for common uses of add(...).
"""
def addGroup(self, *a, **k):
return self.add(Group(*a, **k))
def addField(self, *a, **k):
return self.add(Field(*a, **k))
def __getitem__(self, items):
"""
Overridden to allow stan-style construction of forms.
"""
# Items may be a list or a scalar so stick a scalar into a list
# immediately to simplify the code.
try:
items = iter(items)
except TypeError:
items = [items]
# Add each item
for item in items:
self.add(item)
# Return myself
return self
class Group(AddHelperMixin, object):
itemParent = None
def __init__(self, name, label=None, description=None, cssClass=None):
if label is None:
label = util.titleFromName(name)
self.name = name
self.label = label
self.description = description
self.cssClass = cssClass
self.items = FormItems(self)
# Forward to FormItems methods
self.add = self.items.add
self.getItemByName = self.items.getItemByName
key = property(lambda self: itemKey(self))
def setItemParent(self, itemParent):
self.itemParent = itemParent
def process(self, ctx, form, args, errors):
for item in self.items:
item.process(ctx, form, args, errors)
class GroupFragment(rend.Fragment):
docFactory = loaders.stan(
T.fieldset(id=T.slot('id'), class_=T.slot('cssClass'),
render=T.directive('group'))[
T.legend[T.slot('label')],
T.div(class_='description')[T.slot('description')],
T.slot('items'),
]
)
def __init__(self, group):
super(GroupFragment, self).__init__()
self.group = group
def render_group(self, ctx, data):
# Get a reference to the group, for simpler code.
group = self.group
# Build the CSS class string
cssClass = ['group']
if group.cssClass is not None:
cssClass.append(group.cssClass)
cssClass = ' '.join(cssClass)
# Fill the slots
tag = ctx.tag
tag.fillSlots('id', util.render_cssid(group.key))
tag.fillSlots('cssClass', cssClass)
tag.fillSlots('label', group.label)
tag.fillSlots('description', group.description or '')
tag.fillSlots('items', [inevow.IRenderer(item) for item in
group.items])
return ctx.tag
registerAdapter(GroupFragment, Group, inevow.IRenderer)
class Form(AddHelperMixin, object):
implements( iformal.IForm )
callback = None
actions = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
self.data = {}
self.items = FormItems(None)
self.errors = FormErrors()
# Forward to FormItems methods
self.add = self.items.add
self.getItemByName = self.items.getItemByName
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 process(self, ctx):
request = inevow.IRequest(ctx)
charset = getPOSTCharset(ctx)
# Get the request args and decode the arg names
args = dict([(k.decode(charset),v) for k,v in request.args.items()])
# 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
# IE does not send a button name in the POST args for forms containing
# a single field when the user presses <enter> to submit the form. If
# we only have one possible action then we can safely assume that's the
# action to take.
#
# If there are 0 or 2+ actions then we can't assume anything because we
# have no idea what order the buttons are on the page (someone might
# have altered the DOM using JavaScript for instance). In that case
# throw an error and make it a problem for the developer.
if callback is None:
if self.actions is None or len(self.actions) != 1:
raise Exception('The form has no callback and no action was found.')
else:
callback, validate = self.actions[0].callback, \
self.actions[0].validate
# Remember the args in case validation fails.
self.errors.data = args
# Iterate the items and collect the form data and/or errors.
for item in self.items:
item.process(ctx, self, args, self.errors)
if self.errors and validate:
return self.errors
def _clearUpResources( r ):
if not self.errors:
self.resourceManager.clearUpResources()
return r
d = defer.maybeDeferred(callback, ctx, self, 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)
self.errors.add(failure.value)
return self.errors
class FormItems(object):
"""
A managed collection of form items.
"""
def __init__(self, itemParent):
self.items = []
self.itemParent = itemParent
def __iter__(self):
return iter(self.items)
def add(self, item):
# Check the item name is unique
if item.name in [i.name for i in self.items]:
raise ValueError('Item named %r already added to %r' %
(item.name, self))
# Add to child items and set self the parent
self.items.append(item)
item.setItemParent(self.itemParent)
return item
def getItemByName(self, name):
name = name.split('.', 1)
if len(name) == 1:
name, rest = name[0], None
else:
name, rest = name[0], name[1]
for item in self.items:
if item.name == name:
if rest is None:
return item
return item.getItemByName(rest)
raise KeyError("No item called %r" % name)
class FormErrors(object):
implements( iformal.IFormErrors )
def __init__(self):
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 self.errors
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, iformal.IForm)
widget = form.getItemByName(segments[0]).makeWidget()
return widget.getResource(ctx, segments[0], 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, iformal.IFormFactory)
def render_form(self, name):
def _(ctx, data):
self.remember(ctx)
return renderForm(name)
return _
def _processForm(self, form, ctx):
ctx.remember(form, iformal.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( iformal.IFormFactory )
__formsBehaviour = None
def __behaviour(self):
if self.__formsBehaviour is None:
self.__formsBehaviour = FormsResourceBehaviour(parent=self)
return self.__formsBehaviour
def locateChild(self, ctx, segments):
def gotResult(result):
if result is not appserver.NotFound:
return result
return super(ResourceMixin, self).locateChild(ctx, segments)
self.remember(self, iformal.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().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)
self.remember(self, iformal.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().renderHTTP, ctx)
d.addCallback(gotResult)
return d
def render_form(self, name):
return self.__behaviour().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(iformal.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)
def widgetResourceURLFromContext(ctx,name):
# Could this replace widgetResourceURL?
u = url.URL.fromContext(ctx)
if u.pathList()[-1] != FORMS_KEY:
u = u.child(FORMS_KEY)
return u.child(name).child(WIDGET_RESOURCE_KEY)
class FormRenderer(object):
implements( inevow.IRenderer )
loader = loaders.stan(
T.form(**{'id': T.slot('formName'), 'action': T.slot('formAction'),
'class': 'nevow-form', 'method': 'post', 'enctype':
'multipart/form-data', 'accept-charset': 'utf-8'})[
T.div[
T.input(type='hidden', name='_charset_'),
T.input(type='hidden', name=FORMS_KEY, value=T.slot('formName')),
T.slot('formErrors'),
T.slot('formItems'),
T.div(class_='actions')[
T.slot('formActions'),
],
],
]
)
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('formName', self.original.name)
tag.fillSlots('formAction', url.here)
tag.fillSlots('formErrors', self._renderErrors)
tag.fillSlots('formItems', self._renderItems)
tag.fillSlots('formActions', self._renderActions)
return tag
def _renderErrors(self, ctx, data):
if not self.original.errors:
return ''
errors = self.original.errors.getFormErrors()
errorList = T.ul()
for error in errors:
if isinstance(error, validation.FormError):
errorList[ T.li[ error.message ] ]
for error in errors:
if isinstance(error, validation.FieldError):
item = self.original.getItemByName(error.fieldName)
errorList[ T.li[ T.strong[ item.label, ' : ' ], error.message ] ]
return T.div(class_='errors')[ T.p['Please correct the following errors:'], errorList ]
def _renderItems(self, ctx, data):
if self.original.items is None:
yield ''
return
for item in self.original.items:
yield inevow.IRenderer(item)
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'%(self.original.name, data.name), name=data.name, value=data.label)
registerAdapter(FormRenderer, Form, inevow.IRenderer)
| Python |
import warnings
warnings.warn(
"The htmleditor module is deprecated. To use an HTML editor with " \
"formal, render your field as a formal.TextArea and use JavaScript " \
"to turn the textarea into a HTML editor.",
DeprecationWarning,
stacklevel=2)
from nevow import tags as T, util
from formal import iformal
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( iformal.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iformal.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 = iformal.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 = iformal.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
| Python |
from nevow import appserver, rend
from formal.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 base64
import tempfile
import mimetypes
import re
import os
from shutil import copyfileobj
from exceptions import IOError, OSError
# Use Python 2.4 base64 API if possible. Simulate on Python 2.3.
try:
base64.b64encode
except AttributeError:
# Python 2.3
def base64encode(s):
return base64.encodestring(s).replace('\n', '')
base64decode = base64.decodestring
else:
# Python 2.4
base64encode = base64.b64encode
base64decode = base64.b64decode
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.
NOTE: the string encode('base64') can result in strings with '\n'
embedded in them. the base64.b64encode() does not appear to suffer this
problem.
"""
rv = filename.encode('utf-8')
rv = base64encode(rv)
return rv
def _decodeFilename(self, filename):
"""
Undo what _encodeFilename did.
"""
rv = base64decode(filename)
rv = rv.decode('utf-8')
return rv
| Python |
"""
ReST text area widget.
"""
from nevow import inevow, loaders, rend, tags as T
from formal import iformal, widget
from formal.util import render_cssid
from formal.form import widgetResourceURLFromContext
class ReSTTextArea(widget.TextArea):
"""
A large text entry area that accepts ReST and previews it as HTML
This will accept a restWriter parameter
"""
restWriter = None
def __init__(self, original, **kwds):
restWriter = kwds.pop('restWriter', None)
super(ReSTTextArea, self).__init__(original, **kwds)
if restWriter is not None:
self.restWriter = restWriter
def _renderTag(self, ctx, key, value, readonly):
tag=T.invisible()
ta=T.textarea(name=key, id=render_cssid(key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
ta(class_='readonly', readonly='readonly')
tag[ta]
if not readonly:
try:
import docutils
except ImportError:
raise
else:
form = iformal.IForm( ctx )
srcId = render_cssid(key)
previewDiv = render_cssid(key, 'preview-div')
frameId = render_cssid(key, 'preview-frame')
targetURL = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId )
tag[T.br()]
onclick = ["return Forms.Util.previewShow('",previewDiv, "', '",
frameId, "', '", targetURL, "');"]
tag[T.button(onclick=onclick)['Preview ...']]
tag[T.div(id=previewDiv, class_="preview-hidden")[
T.iframe(class_="preview-frame", name=frameId, id=frameId),
T.br(),
T.button(onclick=["return Forms.Util.previewHide('", previewDiv, "');"])['Close']
]
]
return tag
def getResource(self, ctx, key, segments):
return ReSTPreview(ctx, self.restWriter, key, segments[0]), segments[1:]
class ReSTPreview(rend.Page):
def __init__(self, ctx, restWriter, key, srcId):
self.restWriter = restWriter
form = iformal.IForm( ctx )
u = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId ).child('_submit')
self.destId=srcId + '-dest'
formId=srcId + '-form'
stan = T.html()[
T.head()[
T.script(type="text/javascript")["""
function ReSTTranslate() {
dest = document.getElementById('%(destId)s');
form = document.getElementById('%(formId)s');
src = parent.document.getElementById('%(srcId)s');
dest.value = src.value;
form.submit();
}
"""%{'srcId':srcId, 'destId':self.destId, 'formId':formId}]
],
T.body()[
T.form(id=formId, method="POST", action=u)[
T.input(type="hidden", name=self.destId, id=self.destId)
],
T.script(type="text/javascript")["ReSTTranslate();"],
],
]
self.docFactory = loaders.stan(stan)
def child__submit(self, ctx):
args = inevow.IRequest(ctx).args
value = args.get(self.destId, [''])[0]
from docutils.utils import SystemMessage
try:
if self.restWriter:
restValue = self._html_fragment(value, writer=self.restWriter)
else:
restValue = self._html_fragment(value, writer_name='html')
except SystemMessage, e:
restValue = str(e)
stan = T.html()[
T.head()[
T.style(type="text/css")["""
.system-message {border: 1px solid red; background-color: #FFFFDD; margin: 5px; padding: 5px;}
.system-message-title { font-weight: bold;}
"""
]
],
T.body()[
T.div()[
T.xml(restValue)
]
],
]
self.docFactory = loaders.stan(stan)
return self
def _html_fragment(self, input_string, writer=None, writer_name=None):
from docutils.core import publish_parts
overrides = {'input_encoding': 'utf8',
'doctitle_xform': 0,
'initial_header_level': 1}
parts = publish_parts(
source=input_string,
writer_name=writer_name, writer=writer, settings_overrides=overrides)
fragment = parts['fragment']
return fragment.encode('utf8')
__all__ = ['ReSTTextArea']
| Python |
from zope.interface import implements
from nevow import tags as T
from formal import iformal
from formal.util import render_cssid
_UNSET = object()
class MultichoiceBase(object):
"""
A base class for widgets that provide the UI to select one or more items
from a list.
Based on ChoiceBase
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):
values = args.get(key, [''])
rv = []
for value in values:
value = iformal.IStringConvertible(self.original).toType(value)
if self.noneOption is not None and value == self.noneOption[0]:
value = None
rv.append(self.original.validate(value))
return rv
class MultiselectChoice(MultichoiceBase):
"""
A drop-down list of options.
<select>
<option value="...">...</option>
</select>
"""
implements( iformal.IWidget )
noneOption = ('', '')
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iformal.IKey(self.noneOption).key())[iformal.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iformal.IKey(item).key()
optLabel = iformal.ILabel(item).label()
optValue = converter.fromType(optValue)
option = T.option(value=optValue)[optLabel]
if value and optValue in value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=render_cssid(key), data=self.options, multiple="multiple")[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iformal.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iformal.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
| Python |
from zope.interface import implements
from nevow import tags as T, util
from formal import iformal
from formal.util import render_cssid
class TextAreaWithSelect(object):
"""
A large text entry area that accepts newline characters.
<textarea>...</textarea>
"""
implements( iformal.IWidget )
cols = 48
rows = 6
def __init__(self, original, cols=None, rows=None, values=None):
self.original = original
self.values = values
if cols is not None:
self.cols = cols
if rows is not None:
self.rows = rows
def _renderTag(self, ctx, key, value, readonly):
html = []
tag=T.textarea(name=key, id=render_cssid(key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
tag(class_='readonly', readonly='readonly')
html.append(tag)
if self.values is None:
return html
def renderOptions(ctx,options):
for value,label in options:
yield T.option(value=value)[label]
selecttrigger = T.select(name='%s__selecttrigger'%key, data=self.values)[ renderOptions ]
form = iformal.IForm( ctx )
js = T.xml("var x = document.getElementById('%(form)s');x.%(key)s.value += x.%(key)s__selecttrigger.options[x.%(key)s__selecttrigger.options.selectedIndex].value + "\\n";"%{'key':key,'form':form.name})
aonclick = T.a(onclick=js)[ 'add' ]
html.append(T.div(class_="add")[selecttrigger,aonclick])
return html
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iformal.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iformal.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 = iformal.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
| Python |
"""Adapters for converting to and from a type's value according to an
IConvertible protocol.
"""
from datetime import date, time
try:
import decimal
haveDecimal = True
except ImportError:
haveDecimal = False
from formal import iformal, validation
from zope.interface import implements
class _Adapter(object):
def __init__(self, original):
self.original = original
class NullConverter(_Adapter):
implements( iformal.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( iformal.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
# "Cast" the value to the correct type. For some strange reason,
# Python's decimal.Decimal type raises an ArithmeticError when it's
# given a dodgy value.
try:
value = self.cast(value)
except (ValueError, ArithmeticError):
raise validation.FieldValidationError("Not a valid number")
return value
class IntegerToStringConverter(NumberToStringConverter):
cast = int
class FloatToStringConverter(NumberToStringConverter):
cast = float
if haveDecimal:
class DecimalToStringConverter(NumberToStringConverter):
cast = decimal.Decimal
class BooleanToStringConverter(_Adapter):
implements( iformal.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'%value)
return value == 'True'
class DateToStringConverter(_Adapter):
implements( iformal.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( iformal.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( iformal.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
class SequenceToStringConverter(_Adapter):
implements( iformal.IStringConvertible)
def fromType(self, value):
if value is None:
return None
import cStringIO as StringIO
import csv
sf = StringIO.StringIO()
writer = csv.writer(sf)
writer.writerow(value)
sf.seek(0,0)
return sf.read().strip()
def toType(self, value):
if not value:
return None
import cStringIO as StringIO
import csv
sf = StringIO.StringIO()
csvReader = csv.reader(sf)
sf.write(value)
sf.seek(0,0)
return csvReader.next()
| Python |
import re
from zope.interface import implements
from nevow import inevow, tags
from formal import iformal
_IDENTIFIER_REGEX = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*$')
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 render_cssid(fieldKey, *extras):
"""
Render the CSS id for the form field's key.
"""
l = [tags.slot('formName'), '-', '-'.join(fieldKey.split('.'))]
for extra in extras:
l.append('-')
l.append(extra)
return l
def validIdentifier(name):
"""
Test that name is a valid Python identifier.
"""
return _IDENTIFIER_REGEX.match(name) is not None
class SequenceKeyLabelAdapter(object):
implements( iformal.IKey, iformal.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, loaders, tags as T, util, url, static, rend
from nevow.i18n import _
from formal import converters, iformal, validation
from formal.util import render_cssid
from formal.form import widgetResourceURL, widgetResourceURLFromContext
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( iformal.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=render_cssid(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 = iformal.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 = iformal.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 = iformal.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class Checkbox(object):
"""
A checkbox input field.
<input type="checkbox" ... />
"""
implements( iformal.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, disabled):
tag = T.input(type='checkbox', name=key, id=render_cssid(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 = iformal.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iformal.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 = iformal.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( iformal.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=render_cssid(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 = iformal.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iformal.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 = iformal.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( iformal.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=render_cssid(key), value=values[0]),
T.br,
T.label(for_=render_cssid(key, 'confirm'))[' Confirm '],
T.input(type='password', name=key, id=render_cssid(key, 'confirm'), value=values[1]),
]
def renderImmutable(self, ctx, key, args, errors):
values = ('', '')
return [
T.input(type='password', name=key, id=render_cssid(key), value=values[0], class_='readonly', readonly='readonly'),
T.br,
T.label(for_=render_cssid(key, 'confirm'))[' Confirm '],
T.input(type='password', name=key, id=render_cssid(key, 'confirm'),
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.
"""
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 = iformal.IStringConvertible(self.original).toType(value)
if self.noneOption is not None and \
value == iformal.IKey(self.noneOption).key():
value = None
return self.original.validate(value)
class SelectChoice(ChoiceBase):
"""
A drop-down list of options.
<select>
<option value="...">...</option>
</select>
"""
implements( iformal.IWidget )
noneOption = ('', '')
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iformal.IKey(self.noneOption).key())[iformal.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iformal.IKey(item).key()
optLabel = iformal.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=render_cssid(key), data=self.options)[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iformal.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 = iformal.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
class SelectOtherChoice(object):
"""
A <select> widget that includes an "Other ..." option. When the other
option is selected an <input> field is enabled to allow free text entry.
Unlike SelectChoice, the options items are not a (value,label) tuple
because that makes no sense with the free text entry facility.
TODO:
* Make the Other option configurable in the JS
* Refactor, refactor, refactor
"""
implements(iformal.IWidget)
options = None
noneOption = ('', '')
otherOption = ('...', 'Other ...')
template = None
def __init__(self, original, options=None, otherOption=None):
self.original = original
if options is not None:
self.options = options
if otherOption is not None:
self.otherOption = otherOption
if self.template is None:
self.template = loaders.xmlfile(util.resource_filename('formal',
'html/SelectOtherChoice.html'))
def _valueFromRequestArgs(self, key, args):
value = args.get(key, [''])[0]
if value == self.otherOption[0]:
value = args.get(key+'-other', [''])[0]
return value
def render(self, ctx, key, args, errors):
converter = iformal.IStringConvertible(self.original)
if errors:
value = self._valueFromRequestArgs(key, args)
else:
value = converter.fromType(args.get(key))
if value is None:
value = iformal.IKey(self.noneOption).key()
optionGen = inevow.IQ(self.template).patternGenerator('option')
selectedOptionGen = inevow.IQ(self.template).patternGenerator('selectedOption')
optionTags = []
selectOther = True
if self.noneOption is not None:
noneValue = iformal.IKey(self.noneOption).key()
if value == noneValue:
tag = selectedOptionGen()
selectOther = False
else:
tag = optionGen()
tag.fillSlots('value', noneValue)
tag.fillSlots('label', iformal.ILabel(self.noneOption).label())
optionTags.append(tag)
if self.options is not None:
for item in self.options:
if value == item:
tag = selectedOptionGen()
selectOther = False
else:
tag = optionGen()
tag.fillSlots('value', item)
tag.fillSlots('label', item)
optionTags.append(tag)
if selectOther:
tag = selectedOptionGen()
otherValue = value
else:
tag = optionGen()
otherValue = ''
tag.fillSlots('value', self.otherOption[0])
tag.fillSlots('label', self.otherOption[1])
optionTags.append(tag)
tag = T.invisible[self.template.load(ctx)]
tag.fillSlots('key', key)
tag.fillSlots('id', render_cssid(key))
tag.fillSlots('options', optionTags)
tag.fillSlots('otherValue', otherValue)
return tag
def renderImmutable(self, ctx, key, args, errors):
raise NotImplemented
def processInput(self, ctx, key, args):
value = self._valueFromRequestArgs(key, args)
value = iformal.IStringConvertible(self.original).toType(value)
if self.noneOption is not None and value == iformal.IKey(self.noneOption).key():
value = None
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( iformal.IWidget )
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOption(ctx, itemKey, itemLabel, num, selected):
cssid = render_cssid(key, num)
tag = T.input(name=key, type='radio', id=cssid, value=itemKey)
if selected:
tag = tag(checked='checked')
if disabled:
tag = tag(disabled='disabled')
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 = iformal.IKey(self.noneOption).key()
itemLabel = iformal.ILabel(self.noneOption).label()
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
if not data:
return
for item in data:
itemKey = iformal.IKey(item).key()
itemLabel = iformal.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 = iformal.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 = iformal.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
class DatePartsSelect(object):
"""
A date entry widget that uses three <input> elements for the day, month and
year parts.
The default entry format is the US (month, day, year) but can be switched to
the more common (day, month, year) by setting the dayFirst attribute to
True.
The start and end year can be passed through but default to 1970 and 2070.
The months default to non-zero prefixed numerics but can be passed as a list
of label, value pairs
"""
implements( iformal.IWidget )
dayFirst = False
days = [ (d,d) for d in xrange(1,32) ]
months = [ (m,m) for m in xrange(1,13) ]
yearFrom = 1970
yearTo = 2070
def __init__(self, original, dayFirst=None, yearFrom=None, yearTo=None, months=None):
self.original = original
if dayFirst is not None:
self.dayFirst = dayFirst
if yearFrom is not None:
self.yearFrom = yearFrom
if yearTo is not None:
self.yearTo = yearTo
if months is not None:
self.months = months
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, day, namer, readonly):
years = [(v,v) for v in xrange(self.yearFrom,self.yearTo)]
months = self.months
days = self.days
options = []
for value in years:
if value[0] == year:
options.append( T.option(value=value[0],selected='selected')[value[1]] )
else:
options.append( T.option(value=value[0])[value[1]] )
yearTag = T.select(name=namer('year'))[ options ]
options = []
for value in months:
if value[0] == month:
options.append( T.option(value=value[0],selected='selected')[value[1]] )
else:
options.append( T.option(value=value[0])[value[1]] )
monthTag = T.select(name=namer('month'))[ options ]
options = []
for value in days:
if value[0] == day:
options.append( T.option(value=value[0],selected='selected')[value[1]] )
else:
options.append( T.option(value=value[0])[value[1]] )
dayTag = T.select(name=namer('day'))[ options ]
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 = iformal.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 = iformal.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)
# Get the form field values as a (y,m,d) tuple
ymd = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month', 'day')]
# Remove parts that were not entered.
ymd = [p for p in ymd if p]
# Nothing entered means None otherwise we need all three.
if not ymd:
ymd = None
elif len(ymd) != 3:
raise validation.FieldValidationError("Invalid date")
# So, we have what looks like a good attempt to enter a date.
if ymd is not None:
# Map to integers
try:
ymd = [int(p) for p in ymd]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
ymd = iformal.IDateTupleConvertible(self.original).toType(ymd)
return self.original.validate(ymd)
class DatePartsInput(object):
"""
A date entry widget that uses three <input> elements for the day, month and
year parts.
The default entry format is the US (month, day, year) but can be switched to
the more common (day, month, year) by setting the dayFirst attribute to
True.
By default the widget is designed to only accept unambiguous years, i.e.
the user must enter 4 character dates.
Many people find it convenient or even necessary to allow a 2 character
year. This can be allowed by setting the twoCharCutoffYear attribute to an
integer value between 0 and 99. Anything greater than or equal to the cutoff
year will be considered part of the 20th century (1900 + year); anything
less the cutoff year is a 21st century (2000 + year) date.
A typical twoCharCutoffYear value is 70 (i.e. 1970). However, that value is
somewhat arbitrary. It's the year that time began according to the PC, but
it doesn't mean much to your non-techie user.
dayFirst:
Make the day the first input field, i.e. day, month, year
twoCharCutoffYear:
Allow 2 char years and set the year where the century flips between
20th and 21st century.
"""
implements( iformal.IWidget )
dayFirst = False
twoCharCutoffYear = None
def __init__(self, original, dayFirst=None, twoCharCutoffYear=None):
self.original = original
if dayFirst is not None:
self.dayFirst = dayFirst
if twoCharCutoffYear is not None:
self.twoCharCutoffYear = twoCharCutoffYear
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 = iformal.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 = iformal.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)
# Get the form field values as a (y,m,d) tuple
ymd = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month', 'day')]
# Remove parts that were not entered.
ymd = [p for p in ymd if p]
# Nothing entered means None otherwise we need all three.
if not ymd:
ymd = None
elif len(ymd) != 3:
raise validation.FieldValidationError("Invalid date")
# So, we have what looks like a good attempt to enter a date.
if ymd is not None:
# If a 2-char year is allowed then prepend the century.
if self.twoCharCutoffYear is not None and len(ymd[0]) == 2:
try:
if int(ymd[0]) >= self.twoCharCutoffYear:
century = '19'
else:
century = '20'
ymd[0] = century + ymd[0]
except ValueError:
pass
# By now, we should have a year of at least 4 characters.
if len(ymd[0]) < 4:
if self.twoCharCutoffYear is not None:
msg = "Please enter a 2 or 4 digit year"
else:
msg = "Please enter a 4 digit year"
raise validation.FieldValidationError(msg)
# Map to integers
try:
ymd = [int(p) for p in ymd]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
ymd = iformal.IDateTupleConvertible(self.original).toType(ymd)
return self.original.validate(ymd)
class MMYYDatePartsInput(object):
"""
Two input fields for entering the month and year.
"""
implements( iformal.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 = iformal.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 = iformal.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 = iformal.IDateTupleConvertible(self.original).toType( value )
return self.original.validate(value)
class CheckboxMultiChoice(object):
"""
Multiple choice list, rendered as a list of checkbox fields.
"""
implements( iformal.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):
def renderer(ctx, options):
# loops through checkbox options and renders
for n,item in enumerate(options):
optValue = iformal.IKey(item).key()
optLabel = iformal.ILabel(item).label()
optValue = converter.fromType(optValue)
optid = render_cssid(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()
# Let Nevow worry if self.options is not already a list.
return T.invisible(data=self.options)[renderer]
def render(self, ctx, key, args, errors):
converter = iformal.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 = iformal.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 = iformal.IStringConvertible(self.original.type)
values = [converter.toType(v) for v in values]
return self.original.validate(values)
class FileUploadRaw(object):
implements( iformal.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, disabled):
tag=T.input(name=key, id=render_cssid(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 = iformal.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, False)
def renderImmutable(self, ctx, key, args, errors):
value = iformal.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 = iformal.IFileConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUpload(object):
implements( iformal.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=render_cssid(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 = iformal.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 = iformal.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 = iformal.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( iformal.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, removeable=False ):
self.original = original
if convertibleFactory is not None:
self.convertibleFactory = convertibleFactory
self.originalKeyIsURL = originalKeyIsURL
self.removeable = removeable
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 = iformal.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 we have a removeable attribute, generate the html
if self.removeable is True:
checkbox = T.input(type='checkbox', name='%s_remove'%key, id=render_cssid('%s_remove'%key),class_='upload-checkbox-remove',value='remove')
if args.get('%s_remove'%key, [None])[0] is not None:
checkbox = checkbox = checkbox(checked='checked')
removeableHtml = T.p[ 'check to remove', checkbox]
else:
removeableHtml = ''
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)],removeableHtml]
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)], removeableHtml ]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
yield T.input(name=key, id=render_cssid(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 = iformal.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 = iformal.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 )
# check to see if we should remove this
if self.removeable is True:
remove = args.get('%s_remove'%key, [None])[0]
if remove is not None:
value = (None,None,None)
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, key, 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 = iformal.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__ = iformal.IWidget,
inputType = 'hidden'
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])
if isinstance(value, list):
value = value[0]
else:
value = iformal.IStringConvertible(self.original).fromType(args.get(key))
return T.input(type=self.inputType, name=key, id=render_cssid(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 = iformal.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
__all__ = [
'Checkbox', 'CheckboxMultiChoice', 'CheckedPassword', 'FileUploadRaw',
'Password', 'SelectChoice', 'TextArea', 'TextInput', 'DatePartsInput',
'DatePartsSelect', 'MMYYDatePartsInput', 'Hidden', 'RadioChoice',
'SelectOtherChoice', 'FileUpload', 'FileUploadWidget',
]
| Python |
import re
from zope.interface import implements
from formal import iformal
class FormsError(Exception):
"""
Base class for all Forms errors. A single string, message, is accepted and
stored as an attribute.
The message is not passed on to the Exception base class because it doesn't
seem to be able to handle unicode at all.
"""
def __init__(self, message):
Exception.__init__(self, message)
self.message = message
class FormError(FormsError):
"""
Form validation error. Raise this, typically from a submit callback, to
signal that the form (not an individual field) failed to validate.
"""
pass
class FieldError(FormsError):
"""
Base class for field-related exceptions. The failure message and the failing
field name are stored as attributes.
"""
def __init__(self, message, fieldName=None):
FormsError.__init__(self, message)
self.fieldName = fieldName
class FieldValidationError(FieldError):
"""
Exception that signals that a field failed to validate.
"""
pass
class FieldRequiredError(FieldValidationError):
"""
Exception that signals that a field that is marked as required was not
entered.
"""
pass
class RequiredValidator(object):
implements(iformal.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(iformal.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(iformal.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(iformal.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 |
from nevow import url
import formal
from formal.examples import main
class ActionButtonsPage(main.FormExamplePage):
title = 'Action Button'
description = 'Example of non-validating button, buttons with non-default labels, etc'
def form_example(self, ctx):
form = formal.Form()
form.addField('aString', formal.String(required=True))
form.addAction(self.submitted, label="Click, click, clickety-click!")
form.addAction(self.redirect, 'back', validate=False)
return form
def submitted(self, ctx, form, data):
print form, data
def redirect(self, ctx, form, data):
return url.rootaccessor(ctx)
| Python |
import formal
from formal.examples import main
# Let the examples run if docutils is not installed
try:
import docutils
except ImportError:
import warnings
warnings.warn("docutils is not installed")
docutilsAvailable = False
else:
docutilsAvailable = True
if docutilsAvailable:
from docutils.writers.html4css1 import Writer, HTMLTranslator
from docutils import nodes
class CustomisedHTMLTranslator(HTMLTranslator):
def visit_newdirective_node(self, node):
self.body.append('<div>Some HTML with a %s parameter</div>\n'%(node.attributes['parameter'],))
def depart_newdirective_node(self, node):
pass
class newdirective_node(nodes.General, nodes.Inline, nodes.TextElement):
pass
def newdirective(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
return [newdirective_node('', parameter=arguments[0])]
newdirective.arguments = (1, 0, 0)
newdirective.options = None
from docutils.parsers.rst import directives
directives.register_directive('newdirective', newdirective)
class ReSTWidgetFormPage(main.FormExamplePage):
title = 'ReST widget'
description = 'The ReST widget captures ReST and previews as HTML.'
def form_example(self, ctx):
form = formal.Form()
form.addField('restString', formal.String(required=True),
widgetFactory=formal.ReSTTextArea)
if docutilsAvailable:
w = Writer()
w.translator_class = CustomisedHTMLTranslator
form.addField('customRestString', formal.String(required=True),
formal.widgetFactory(formal.ReSTTextArea, restWriter=w))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
from zope.interface import implements
import formal
from formal import iformal
from formal.examples import main
# A not-too-good regex for matching an IP address.
IP_ADDRESS_PATTERN = '^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$'
class ValidatorFormPage(main.FormExamplePage):
title = 'Custom form validation'
description = 'Example of installing additional validators and writing a new one'
def form_example(self, ctx):
form = formal.Form()
# This actually installs a RequiredValidator for you.
form.addField('required', formal.String(required=True))
# Exactly the same as above, only with a "manually" installed validator.
form.addField('required2', formal.String(validators=[formal.RequiredValidator()]))
# Check for a minimum length, if anything entered.
form.addField('atLeastFiveChars', formal.String(validators=[formal.LengthValidator(min=5)]))
# Check for a minimum length, if anything entered.
form.addField('ipAddress', formal.String(strip=True, validators=[formal.PatternValidator(regex=IP_ADDRESS_PATTERN)]))
# Check for the word 'silly'
form.addField('silly', formal.String(validators=[SillyValidator()]))
# Check age is between 18 and 30
form.addField('ohToBeYoungAgain', formal.Integer(validators=[formal.RangeValidator(min=18, max=30)]))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
class SillyValidator(object):
"""
A pointless example that checks a specific word, 'silly', is entered.
"""
implements(iformal.IValidator)
word = u'silly'
def validate(self, field, value):
if value is None:
return
if value.lower() != self.word.lower():
raise formal.FieldValidationError(u'You must enter \'%s\''%self.word)
| Python |
import formal
from formal.examples import main
class SimpleFormPage(main.FormExamplePage):
title = 'Simple Form'
description = 'Probably the simplest form possible.'
def form_example(self, ctx):
form = formal.Form()
form.addField('aString', formal.String())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
try:
import decimal
haveDecimal = True
except ImportError:
haveDecimal = False
import formal
from formal.examples import main
class TypesFormPage(main.FormExamplePage):
title = 'Form Types'
description = 'Example of using different typed fields.'
def form_example(self, ctx):
form = formal.Form()
form.addField('aString', formal.String())
form.addField('aInteger', formal.Integer())
form.addField('aFloat', formal.Float())
if haveDecimal:
form.addField('aDecimal', formal.Decimal())
form.addField('aBoolean', formal.Boolean())
form.addField('aDate', formal.Date())
form.addField('aTime', formal.Time())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
from datetime import date
import formal
from formal.examples import main
class MissingFormPage(main.FormExamplePage):
title = 'Missing Values'
description = 'Providing default values when missing'
def form_example(self, ctx):
form = formal.Form()
form.addField('aString', formal.String(missing='<nothing>'))
form.addField('aDate', formal.Date(missing=date(2005, 8, 1)))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
import formal
from formal.examples import main
class FileUploadFormPage(main.FormExamplePage):
title = 'File Upload'
description = 'Uploading a file'
def form_example(self, ctx):
form = formal.Form()
form.addField('file', formal.File())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import pkg_resources
from zope.interface import implements
from twisted.python import reflect
from nevow import appserver, inevow, loaders, rend, static, tags as T, url
import formal
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 = [
'formal.examples.simple.SimpleFormPage',
'formal.examples.types.TypesFormPage',
'formal.examples.required.RequiredFormPage',
'formal.examples.missing.MissingFormPage',
'formal.examples.prepopulate.PrepopulateFormPage',
'formal.examples.group.GroupFormPage',
'formal.examples.stanstyle.StanStyleFormPage',
'formal.examples.fileupload.FileUploadFormPage',
'formal.examples.smartupload.SmartUploadFormPage',
'formal.examples.selections.SelectionFormPage',
'formal.examples.datestimes.DatesTimesFormPage',
'formal.examples.actionbuttons.ActionButtonsPage',
'formal.examples.validator.ValidatorFormPage',
'formal.examples.restwidget.ReSTWidgetFormPage',
'formal.examples.nofields.NoFieldsFormPage',
'formal.examples.hidden.HiddenFieldsFormPage',
'formal.examples.textareawithselect.TextAreaWithSelectFormPage',
]
def makeSite():
root = RootPage()
site = appserver.NevowSite(root, logPath="web.log")
return site
class RootPage(rend.Page):
"""
Main page that lists the examples and makes the example page a child
resource.
"""
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:
cls = reflect.namedAny(name)
yield T.div(class_='example')[
T.h1[T.a(href=url.here.child(name))[cls.title]],
T.p[cls.description],
]
def childFactory(self, ctx, name):
if name in examples:
cls = reflect.namedAny(name)
return cls()
class FormExamplePage(formal.ResourceMixin, rend.Page):
"""
A base page for the actual examples. The page renders something sensible,
including the title example and description. It also include the "example"
form in an appropriate place.
Each example page is expected to provide the title and description
attributes as well as a form_example method that builds and returns a
formal.Form instance.
"""
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('formal.css')),
T.script(type='text/javascript', src='js/formal.js'),
],
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.title
def data_description(self, ctx, data):
return self.description
# Add child_ attributes
examples_css = pkg_resources.resource_filename('formal.examples', 'examples.css')
setattr(RootPage, 'child_examples.css', static.File(examples_css))
setattr(RootPage, 'child_formal.css', formal.defaultCSS)
setattr(RootPage, 'child_js', formal.formsJS)
if __name__ == '__main__':
import sys
from twisted.internet import reactor
from twisted.python import log
if len(sys.argv) > 1:
port = int(sys.argv[1])
else:
port = 8000
log.startLogging(sys.stdout)
site = makeSite()
reactor.listenTCP(port, site)
reactor.run()
| Python |
import formal
from formal.examples import main
class SmartUploadFormPage(main.FormExamplePage):
title = 'Smart File Upload'
description = 'Smart uploading of files where the file is "carried across" when the validation fails'
def form_example(self, ctx):
form = formal.Form()
form.addField('required', formal.String(required=True))
form.addField('file', formal.File(), formal.FileUploadWidget)
form.addField('removeableFile', formal.File(), formal.widgetFactory(formal.FileUploadWidget, removeable=True ) )
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import formal
from formal.examples import main
class GroupFormPage(main.FormExamplePage):
title = 'Field Group Form'
description = 'Groups of fields on a form'
def form_example(self, ctx):
def makeAddressGroup(name):
address = formal.Group(name)
address.add(formal.Field('address', formal.String()))
address.add(formal.Field('city', formal.String()))
address.add(formal.Field('postalCode', formal.String()))
return address
def makePersonGroup(name):
person = formal.Group(name, cssClass=name)
person.add(formal.Field('name', formal.String(required=True)))
person.add(formal.Field('dateOfBirth', formal.Date(required=True)))
person.add(makeAddressGroup('address'))
return person
form = formal.Form()
form.add(formal.Field('before', formal.String()))
form.add(makePersonGroup('me'))
form.add(makePersonGroup('you'))
form.add(formal.Field('after', formal.String()))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import formal
from formal.examples import main
class HiddenFieldsFormPage(main.FormExamplePage):
title = 'Hidden Fields Form'
description = 'A form with a hidden field.'
def form_example(self, ctx):
form = formal.Form()
form.addField('hiddenString', formal.String(), widgetFactory=formal.Hidden)
form.addField('hiddenInt', formal.Integer(), widgetFactory=formal.Hidden)
form.addField('visibleString', formal.String())
form.addAction(self.submitted)
form.data = {
'hiddenString': 'foo',
'hiddenInt': 1,
}
return form
def submitted(self, ctx, form, data):
print data
| Python |
from datetime import datetime
import formal
from formal.examples import main
class PrepopulateFormPage(main.FormExamplePage):
title = 'Prepopulate'
description = 'Example of prepopulating form fields'
def form_example(self, ctx):
form = formal.Form()
form.addField('aString', formal.String())
form.addField('aTime', formal.Time())
form.addAction(self.submitted)
form.data = {
'aTime': datetime.utcnow().time(),
}
return form
def submitted(self, ctx, form, data):
print data
| Python |
import formal
from formal.examples import main
class DatesTimesFormPage(main.FormExamplePage):
title = 'Dates'
description = 'Date entry examples'
def form_example(self, ctx):
form = formal.Form()
form.addField('isoFormatDate', formal.Date(), formal.TextInput)
form.addField('datePartsSelect', formal.Date(), formal.widgetFactory(formal.DatePartsSelect, dayFirst=True))
form.addField('monthFirstDate', formal.Date(), formal.DatePartsInput)
form.addField('dayFirstDate', formal.Date(), formal.widgetFactory(formal.DatePartsInput, dayFirst=True))
form.addField('monthYearDate', formal.Date(), formal.MMYYDatePartsInput)
form.addField('twoCharYearDate', formal.Date(), formal.widgetFactory(formal.DatePartsInput, twoCharCutoffYear=70))
form.addField('time', formal.Time())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
from twisted.internet import defer
from datetime import date
import formal
from formal.examples import main
# 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'),
]
tuples = [
(('a',1), 'a1'),
(('b',1), 'b1'),
(('c',1), 'c1'),
]
def data_strings(ctx, data):
# Let's defer it, just for fun.
return defer.succeed(strings)
# A different "none" option tuple
differentNone = ('none value', '- select -')
class SelectionFormPage(main.FormExamplePage):
title = 'Selection widgets'
description = 'Example of the various selection widgets'
def form_example(self, ctx):
form = formal.Form()
form.addField('required', formal.String(required=True))
form.addField('oneString', formal.String(),
formal.widgetFactory(formal.SelectChoice, options=strings))
form.addField('anotherString', formal.String(),
formal.widgetFactory(formal.SelectChoice, options=data_strings))
form.addField('oneMoreString', formal.String(required=True),
formal.widgetFactory(formal.RadioChoice, options=data_strings))
form.addField('oneDate', formal.Date(),
formal.widgetFactory(formal.SelectChoice, options=dates))
form.addField('multipleStrings', formal.Sequence(formal.String()),
formal.widgetFactory(formal.CheckboxMultiChoice,
options=data_strings))
form.addField('multipleDates', formal.Sequence(formal.Date()),
formal.widgetFactory(formal.CheckboxMultiChoice, options=dates))
form.addField('multipleTuples', formal.Sequence(formal.Sequence()),
formal.widgetFactory(formal.CheckboxMultiChoice,
options=tuples))
form.addField('differentNoneSelect', formal.String(),
formal.widgetFactory(formal.SelectChoice, options=strings,
noneOption=differentNone))
form.addField('differentNoneRadios', formal.String(),
formal.widgetFactory(formal.RadioChoice, options=data_strings,
noneOption=differentNone))
form.addField('selectOther', formal.String(),
formal.widgetFactory(formal.SelectOtherChoice, options=['Mr',
'Mrs']))
form.addField('selectOtherCustomOther', formal.String(),
formal.widgetFactory(formal.SelectOtherChoice, options=['Mr',
'Mrs'], otherOption=('...','Other (Please Enter)')))
form.addField('selectOtherRequired', formal.String(required=True),
formal.widgetFactory(formal.SelectOtherChoice, options=['Mr',
'Mrs']))
form.addField('multiselect', formal.String(),
formal.widgetFactory(formal.MultiselectChoice, options=strings))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import formal
from formal.examples import main
class NoFieldsFormPage(main.FormExamplePage):
title = 'Form With no Fields'
description = 'A form with no fields, just button(s). (Just to prove ' \
'it works.)'
def form_example(self, ctx):
form = formal.Form()
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
from formal import Field, Form, Group, String
from formal.examples import main
class StanStyleFormPage(main.FormExamplePage):
title = 'Stan-Style Form'
description = 'Building a Form in a stan style'
def form_example(self, ctx):
form = Form()[
Group("me")[
Field("firstNames", String()),
Field("lastName", String()),
],
Group("you")[
Field("firstNames", String()),
Field("lastName", String()),
],
]
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
import formal
from formal.examples import main
from formal.widgets.textareawithselect import TextAreaWithSelect
class TextAreaWithSelectFormPage(main.FormExamplePage):
title = 'Text area with select'
description = 'text area with a select box to append new info'
def form_example(self, ctx):
form = formal.Form()
form.addField('myTextArea', formal.String(),
formal.widgetFactory(TextAreaWithSelect,values=(('aval','alabel'),('bval','blabel')) ))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import formal
from formal.examples import main
class RequiredFormPage(main.FormExamplePage):
title = 'Required Fields'
description = 'Demonstration of required fields'
def form_example(self, ctx):
form = formal.Form()
form.addField('name', formal.String(required=True))
form.addField('age', formal.Integer())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
from zope.interface 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 |
"""A package (for Nevow) for defining the schema, validation and rendering of
HTML forms.
"""
version_info = (0, 11, 0)
version = '.'.join([str(i) for i in version_info])
from nevow import static
from formal.types import *
from formal.validation import *
from formal.widget import *
from formal.widgets.restwidget import *
from formal.widgets.multiselect import *
from formal.form import Form, Field, Group, ResourceMixin, renderForm
from formal import iformal
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], 'formal.css'))
formsJS = static.File(os.path.join(os.path.split(__file__)[0], 'js'))
else:
from formal.util import LazyResource
defaultCSS = LazyResource(lambda: static.File(pkg_resources.resource_filename('formal', 'formal.css')))
formsJS = LazyResource(lambda: static.File(pkg_resources.resource_filename('formal', 'js')))
del LazyResource
# Register standard adapters
from twisted.python.components import registerAdapter
from formal import converters
from formal.util import SequenceKeyLabelAdapter
registerAdapter(TextInput, String, iformal.IWidget)
registerAdapter(TextInput, Integer, iformal.IWidget)
registerAdapter(TextInput, Float, iformal.IWidget)
registerAdapter(Checkbox, Boolean, iformal.IWidget)
registerAdapter(DatePartsInput, Date, iformal.IWidget)
registerAdapter(TextInput, Time, iformal.IWidget)
registerAdapter(FileUploadRaw, File, iformal.IWidget)
registerAdapter(SequenceKeyLabelAdapter, tuple, iformal.IKey)
registerAdapter(SequenceKeyLabelAdapter, tuple, iformal.ILabel)
registerAdapter(converters.NullConverter, String, iformal.IStringConvertible)
registerAdapter(converters.DateToDateTupleConverter, Date, iformal.IDateTupleConvertible)
registerAdapter(converters.BooleanToStringConverter, Boolean, iformal.IBooleanConvertible)
registerAdapter(converters.BooleanToStringConverter, Boolean, iformal.IStringConvertible)
registerAdapter(converters.IntegerToStringConverter, Integer, iformal.IStringConvertible)
registerAdapter(converters.FloatToStringConverter, Float, iformal.IStringConvertible)
registerAdapter(converters.DateToStringConverter, Date, iformal.IStringConvertible)
registerAdapter(converters.TimeToStringConverter, Time, iformal.IStringConvertible)
registerAdapter(converters.NullConverter, File, iformal.IFileConvertible)
registerAdapter(converters.NullConverter, Sequence, iformal.ISequenceConvertible)
registerAdapter(converters.SequenceToStringConverter, Sequence, iformal.IStringConvertible)
try:
Decimal
except NameError:
pass
else:
registerAdapter(TextInput, Decimal, iformal.IWidget)
registerAdapter(converters.DecimalToStringConverter, Decimal, iformal.IStringConvertible)
del SequenceKeyLabelAdapter
del registerAdapter
| Python |
from twisted.application import internet, service
from nevow import appserver
from formal.examples import main
application = service.Application('examples')
service = internet.TCPServer(8000, main.makeSite())
service.setServiceParent(application)
| Python |
from setuptools import setup, find_packages
setup(
name='formal',
version='0.11.0',
description='HTML forms framework for Nevow',
author='Matt Goodall',
author_email='matt@pollenation.net',
packages=find_packages(),
include_package_data=True,
zip_safe = True,
)
| 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', 'html/*', 'js/*'],
},
zip_safe = True,
)
| 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 = list(validators)
else:
self.validators = list(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 render(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 render
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
actions = None
widgets = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
self.data = {}
self.items = []
def addField(self, name, type, widgetFactory=None, label=None, description=None, cssClass=None):
if not util.validIdentifier(name):
raise ValueError('%r is an invalid field name'%name)
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 getField(self,fieldName):
for name, type, label, description, cssClass in self.items:
if name == fieldName:
return (name, type, label, description, cssClass)
else:
return None
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 self.errors
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[0], 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 render(ctx, data):
self.remember(ctx)
return renderForm(name)
return render
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 )
__formsBehaviour = None
def __behaviour(self):
if self.__formsBehaviour is None:
self.__formsBehaviour = FormsResourceBehaviour(parent=self)
return self.__formsBehaviour
def locateChild(self, ctx, segments):
def gotResult(result):
if result is not appserver.NotFound:
return result
return super(ResourceMixin, self).locateChild(ctx, segments)
self.remember(self, iforms.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().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)
self.remember(self, iforms.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().renderHTTP, ctx)
d.addCallback(gotResult)
return d
def render_form(self, name):
return self.__behaviour().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)
def widgetResourceURLFromContext(ctx,name):
# Could this replace widgetResourceURL?
u = url.URL.fromContext(ctx)
if u.pathList()[-1] != FORMS_KEY:
u = u.child(FORMS_KEY)
return u.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 ''
errorList = T.ul()
for error in errors:
if isinstance(error, validation.FormError):
errorList[ T.li[ error.message ] ]
for error in errors:
if isinstance(error, validation.FieldError):
name, type, label, description, cssClass = self.original.getField(error.fieldName)
errorList[ T.li[ T.strong[ label, ' : ' ], error.message ] ]
return T.div(class_='errors')[ T.p['Please correct the following errors:'], errorList ]
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 render(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')[error.message]
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 render
def _renderHiddenItem(self, ctx, data):
def render(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 render
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.
NOTE: the string encode('base64') can result in strings with '\n'
embedded in them. the base64.b64encode() does not appear to suffer this
problem.
"""
import base64
rv = filename.encode('utf-8')
rv = base64.b64encode(rv)
return rv
def _decodeFilename(self, filename):
"""
Undo what _encodeFilename did.
"""
import base64
rv = base64.b64decode(filename)
rv = rv.decode('utf-8')
return rv
| Python |
"""
ReST text area widget.
"""
from nevow import inevow, loaders, rend, tags as T
from forms import iforms, widget
from forms.util import keytocssid
from forms.form import widgetResourceURLFromContext
class ReSTTextArea(widget.TextArea):
"""
A large text entry area that accepts ReST and previews it as HTML
This will accept a restWriter parameter
"""
restWriter = None
def __init__(self, original, **kwds):
restWriter = kwds.pop('restWriter', None)
super(ReSTTextArea, self).__init__(original, **kwds)
if restWriter is not None:
self.restWriter = restWriter
def _renderTag(self, ctx, key, value, readonly):
tag=T.invisible()
ta=T.textarea(name=key, id=keytocssid(ctx.key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
ta(class_='readonly', readonly='readonly')
tag[ta]
if not readonly:
try:
import docutils
except ImportError:
raise
else:
form = iforms.IForm( ctx )
srcId = keytocssid(ctx.key)
previewDiv = srcId + '-preview-div'
frameId = srcId + '-preview-frame'
targetURL = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId )
tag[T.br()]
tag[T.button(onClick="return Forms.Util.previewShow('%s', '%s', '%s');"%(previewDiv, frameId, targetURL))['Preview ...']]
tag[T.div(id=previewDiv, class_="preview-hidden")[
T.iframe(class_="preview-frame", name=frameId, id=frameId),
T.br(),
T.button(onClick="return Forms.Util.previewHide('%s');"%(previewDiv))['Close']
]
]
return tag
def getResource(self, ctx, key, segments):
return ReSTPreview(ctx, self.restWriter, key, segments[0]), segments[1:]
class ReSTPreview(rend.Page):
def __init__(self, ctx, restWriter, key, srcId):
self.restWriter = restWriter
form = iforms.IForm( ctx )
u = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId ).child('_submit')
self.destId=srcId + '-dest'
formId=srcId + '-form'
stan = T.html()[
T.head()[
T.script(type="text/javascript")["""
function ReSTTranslate() {
dest = document.getElementById('%(destId)s');
form = document.getElementById('%(formId)s');
src = parent.document.getElementById('%(srcId)s');
dest.value = src.value;
form.submit();
}
"""%{'srcId':srcId, 'destId':self.destId, 'formId':formId}]
],
T.body()[
T.form(id=formId, method="POST", action=u)[
T.input(type="hidden", name=self.destId, id=self.destId)
],
T.script(type="text/javascript")["ReSTTranslate();"],
],
]
self.docFactory = loaders.stan(stan)
def child__submit(self, ctx):
args = inevow.IRequest(ctx).args
value = args.get(self.destId, [''])[0]
from docutils.utils import SystemMessage
try:
if self.restWriter:
restValue = self._html_fragment(value, writer=self.restWriter)
else:
restValue = self._html_fragment(value, writer_name='html')
except SystemMessage, e:
restValue = str(e)
stan = T.html()[
T.head()[
T.style(type="text/css")["""
.system-message {border: 1px solid red; background-color: #FFFFDD; margin: 5px; padding: 5px;}
.system-message-title { font-weight: bold;}
"""
]
],
T.body()[
T.div()[
T.xml(restValue)
]
],
]
self.docFactory = loaders.stan(stan)
return self
def _html_fragment(self, input_string, writer=None, writer_name=None):
from docutils.core import publish_parts
overrides = {'input_encoding': 'utf8',
'doctitle_xform': 0,
'initial_header_level': 1}
parts = publish_parts(
source=input_string,
writer_name=writer_name, writer=writer, settings_overrides=overrides)
fragment = parts['fragment']
return fragment.encode('utf8')
__all__ = ['ReSTTextArea']
| Python |
from zope.interface import implements
from nevow import tags as T
from forms import iforms
from forms.util import keytocssid
_UNSET = object()
class MultichoiceBase(object):
"""
A base class for widgets that provide the UI to select one or more items
from a list.
Based on ChoiceBase
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):
values = args.get(key, [''])
rv = []
for value in values:
value = iforms.IStringConvertible(self.original).toType(value)
if self.noneOption is not None and value == self.noneOption[0]:
value = None
rv.append(self.original.validate(value))
return rv
class MultiselectChoice(MultichoiceBase):
"""
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 value and optValue in value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=keytocssid(ctx.key), data=self.options, multiple="multiple")[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, [''])
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)
| 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 |
import re
from zope.interface import implements
from nevow import inevow
from forms import iforms
_IDENTIFIER_REGEX = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*$')
def titleFromName(name):
def gen():
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(gen())
def keytocssid(key):
return '-'.join(key.split('.'))
def validIdentifier(name):
"""
Test that name is a valid Python identifier.
"""
return _IDENTIFIER_REGEX.match(name) is not None
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, loaders, tags as T, util, url, static, rend
from nevow.i18n import _
from forms import converters, iforms, validation
from forms.util import keytocssid
from forms.form import widgetResourceURL, widgetResourceURLFromContext
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 SelectOtherChoice(object):
"""
A <select> widget that includes an "Other ..." option. When the other
option is selected an <input> field is enabled to allow free text entry.
Unlike SelectChoice, the options items are not a (value,label) tuple
because that makes no sense with the free text entry facility.
TODO:
* Make the Other option configurable in the JS
* Refactor, refactor, refactor
"""
implements(iforms.IWidget)
options = None
noneOption = ('', '')
otherOption = ('...', 'Other ...')
template = None
def __init__(self, original, options=None):
self.original = original
if options is not None:
self.options = options
if self.template is None:
self.template = loaders.xmlfile(util.resource_filename('forms',
'html/SelectOtherChoice.html'))
def _valueFromRequestArgs(self, key, args):
value = args.get(key, [''])[0]
if value == self.otherOption[0]:
value = args.get(key+'-other', [''])[0]
return value
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = self._valueFromRequestArgs(key, args)
else:
value = converter.fromType(args.get(key))
if value is None:
value = iforms.IKey(self.noneOption).key()
optionGen = inevow.IQ(self.template).patternGenerator('option')
selectedOptionGen = inevow.IQ(self.template).patternGenerator('selectedOption')
optionTags = []
selectOther = True
if self.noneOption is not None:
noneValue = iforms.IKey(self.noneOption).key()
if value == noneValue:
tag = selectedOptionGen()
selectOther = False
else:
tag = optionGen()
tag.fillSlots('value', noneValue)
tag.fillSlots('label', iforms.ILabel(self.noneOption).label())
optionTags.append(tag)
if self.options is not None:
for item in self.options:
if value == item:
tag = selectedOptionGen()
selectOther = False
else:
tag = optionGen()
tag.fillSlots('value', item)
tag.fillSlots('label', item)
optionTags.append(tag)
if selectOther:
tag = selectedOptionGen()
otherValue = value
else:
tag = optionGen()
otherValue = ''
tag.fillSlots('value', self.otherOption[0])
tag.fillSlots('label', self.otherOption[1])
optionTags.append(tag)
tag = T.invisible[self.template.load(ctx)]
tag.fillSlots('key', key)
tag.fillSlots('id', keytocssid(ctx.key))
tag.fillSlots('options', optionTags)
tag.fillSlots('otherValue', otherValue)
return tag
def renderImmutable(self, ctx, key, args, errors):
raise NotImplemented
def processInput(self, ctx, key, args):
value = self._valueFromRequestArgs(key, args)
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 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):
"""
A date entry widget that uses three <input> elements for the day, month and
year parts.
The default entry format is the US (month, day, year) but can be switched to
the more common (day, month, year) by setting the dayFirst attribute to
True.
By default the widget is designed to only accept unambiguous years, i.e.
the user must enter 4 character dates.
Many people find it convenient or even necessary to allow a 2 character
year. This can be allowed by setting the twoCharCutoffYear attribute to an
integer value between 0 and 99. Anything greater than or equal to the cutoff
year will be considered part of the 20th century (1900 + year); anything
less the cutoff year is a 21st century (2000 + year) date.
A typical twoCharCutoffYear value is 70 (i.e. 1970). However, that value is
somewhat arbitrary. It's the year that time began according to the PC, but
it doesn't mean much to your non-techie user.
dayFirst:
Make the day the first input field, i.e. day, month, year
twoCharCutoffYear:
Allow 2 char years and set the year where the century flips between
20th and 21st century.
"""
implements( iforms.IWidget )
dayFirst = False
twoCharCutoffYear = None
def __init__(self, original, dayFirst=None, twoCharCutoffYear=None):
self.original = original
if dayFirst is not None:
self.dayFirst = dayFirst
if twoCharCutoffYear is not None:
self.twoCharCutoffYear = twoCharCutoffYear
def _namer(self, prefix):
def f(part):
return '%s__%s' % (prefix,part)
return f
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)
# Get the form field values as a (y,m,d) tuple
ymd = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month', 'day')]
# Remove parts that were not entered.
ymd = [p for p in ymd if p]
# Nothing entered means None otherwise we need all three.
if not ymd:
ymd = None
elif len(ymd) != 3:
raise validation.FieldValidationError("Invalid date")
# So, we have what looks like a good attempt to enter a date.
if ymd is not None:
# If a 2-char year is allowed then prepend the century.
if self.twoCharCutoffYear is not None and len(ymd[0]) == 2:
try:
if int(ymd[0]) >= self.twoCharCutoffYear:
century = '19'
else:
century = '20'
ymd[0] = century + ymd[0]
except ValueError:
pass
# By now, we should have a year of at least 4 characters.
if len(ymd[0]) < 4:
if self.twoCharCutoffYear is not None:
msg = "Please enter a 2 or 4 digit year"
else:
msg = "Please enter a 4 digit year"
raise validation.FieldValidationError(msg)
# Map to integers
try:
ymd = [int(p) for p in ymd]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
ymd = iforms.IDateTupleConvertible(self.original).toType(ymd)
return self.original.validate(ymd)
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 f(part):
return '%s__%s' % (prefix,part)
return f
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 f(part):
return '%s__%s' % (prefix,part)
return f
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 f(part):
return '%s__%s' % (prefix,part)
return f
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, key, 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 gotResult( 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(gotResult)
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, [''])
if isinstance(value, list):
value = value[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',
'Password', 'SelectChoice', 'TextArea', 'TextInput', 'DatePartsInput',
'MMYYDatePartsInput', 'Hidden', 'RadioChoice', 'SelectOtherChoice',
'FileUpload', 'FileUploadWidget',
]
| Python |
import re
from zope.interface import implements
from forms import iforms
class FormsError(Exception):
"""
Base class for all Forms errors. A single string, message, is accepted and
stored as an attribute.
The message is not passed on to the Exception base class because it doesn't
seem to be able to handle unicode at all.
"""
def __init__(self, message):
Exception.__init__(self, message)
self.message = message
class FormError(FormsError):
"""
Form validation error. Raise this, typically from a submit callback, to
signal that the form (not an individual field) failed to validate.
"""
pass
class FieldError(FormsError):
"""
Base class for field-related exceptions. The failure message and the failing
field name are stored as attributes.
"""
def __init__(self, message, fieldName=None):
FormsError.__init__(self, message)
self.fieldName = fieldName
class FieldValidationError(FieldError):
"""
Exception that signals that a field failed to validate.
"""
pass
class FieldRequiredError(FieldValidationError):
"""
Exception that signals that a field that is marked as required was not
entered.
"""
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 |
from nevow import url
import forms
from forms.examples import main
class ActionButtonsPage(main.FormExamplePage):
title = 'Action Button'
description = 'Example of non-validating button, buttons with non-default labels, etc'
def form_example(self, ctx):
form = forms.Form()
form.addField('aString', forms.String(required=True))
form.addAction(self.submitted, label="Click, click, clickety-click!")
form.addAction(self.redirect, 'back', validate=False)
return form
def submitted(self, ctx, form, data):
print form, data
def redirect(self, ctx, form, data):
return url.rootaccessor(ctx)
| Python |
import forms
from forms.examples import main
# Let the examples run if docutils is not installed
try:
import docutils
except ImportError:
import warnings
warnings.warn("docutils is not installed")
docutilsAvailable = False
else:
docutilsAvailable = True
if docutilsAvailable:
from docutils.writers.html4css1 import Writer, HTMLTranslator
from docutils import nodes
class CustomisedHTMLTranslator(HTMLTranslator):
def visit_newdirective_node(self, node):
self.body.append('<div>Some HTML with a %s parameter</div>\n'%(node.attributes['parameter'],))
def depart_newdirective_node(self, node):
pass
class newdirective_node(nodes.General, nodes.Inline, nodes.TextElement):
pass
def newdirective(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
return [newdirective_node('', parameter=arguments[0])]
newdirective.arguments = (1, 0, 0)
newdirective.options = None
from docutils.parsers.rst import directives
directives.register_directive('newdirective', newdirective)
class ReSTWidgetFormPage(main.FormExamplePage):
title = 'ReST widget'
description = 'The ReST widget captures ReST and previews as HTML.'
def form_example(self, ctx):
form = forms.Form()
form.addField('restString', forms.String(required=True),
widgetFactory=forms.ReSTTextArea)
if docutilsAvailable:
w = Writer()
w.translator_class = CustomisedHTMLTranslator
form.addField('customRestString', forms.String(required=True),
forms.widgetFactory(forms.ReSTTextArea, restWriter=w))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
from zope.interface import implements
import forms
from forms import iforms
from forms.examples import main
# A not-too-good regex for matching an IP address.
IP_ADDRESS_PATTERN = '^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$'
class ValidatorFormPage(main.FormExamplePage):
title = 'Custom form validation'
description = 'Example of installing additional validators and writing a new one'
def form_example(self, ctx):
form = forms.Form()
# This actually installs a RequiredValidator for you.
form.addField('required', forms.String(required=True))
# Exactly the same as above, only with a "manually" installed validator.
form.addField('required2', forms.String(validators=[forms.RequiredValidator()]))
# Check for a minimum length, if anything entered.
form.addField('atLeastFiveChars', forms.String(validators=[forms.LengthValidator(min=5)]))
# Check for a minimum length, if anything entered.
form.addField('ipAddress', forms.String(strip=True, validators=[forms.PatternValidator(regex=IP_ADDRESS_PATTERN)]))
# Check for the word 'silly'
form.addField('silly', forms.String(validators=[SillyValidator()]))
# Check age is between 18 and 30
form.addField('ohToBeYoungAgain', forms.Integer(validators=[forms.RangeValidator(min=18, max=30)]))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
class SillyValidator(object):
"""
A pointless example that checks a specific word, 'silly', is entered.
"""
implements(iforms.IValidator)
word = u'silly'
def validate(self, field, value):
if value is None:
return
if value.lower() != self.word.lower():
raise forms.FieldValidationError(u'You must enter \'%s\''%self.word)
| Python |
import forms
from forms.examples import main
class SimpleFormPage(main.FormExamplePage):
title = 'Simple Form'
description = 'Probably the simplest form possible.'
def form_example(self, ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import forms
from forms.examples import main
class TypesFormPage(main.FormExamplePage):
title = 'Form Types'
description = 'Example of using different typed fields.'
def form_example(self, 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(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
from datetime import date
import forms
from forms.examples import main
class MissingFormPage(main.FormExamplePage):
title = 'Missing Values'
description = 'Providing default values when missing'
def form_example(self, ctx):
form = forms.Form()
form.addField('aString', forms.String(missing='<nothing>'))
form.addField('aDate', forms.Date(missing=date(2005, 8, 1)))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
import forms
from forms.examples import main
class FileUploadFormPage(main.FormExamplePage):
title = 'File Upload'
description = 'Uploading a file'
def form_example(self, ctx):
form = forms.Form()
form.addField('file', forms.File())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import pkg_resources
from zope.interface import implements
from twisted.python import reflect
from nevow import appserver, inevow, 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.SimpleFormPage',
'forms.examples.types.TypesFormPage',
'forms.examples.required.RequiredFormPage',
'forms.examples.missing.MissingFormPage',
'forms.examples.prepopulate.PrepopulateFormPage',
'forms.examples.fileupload.FileUploadFormPage',
'forms.examples.smartupload.SmartUploadFormPage',
'forms.examples.selections.SelectionFormPage',
'forms.examples.datestimes.DatesTimesFormPage',
'forms.examples.actionbuttons.ActionButtonsPage',
'forms.examples.validator.ValidatorFormPage',
'forms.examples.restwidget.ReSTWidgetFormPage',
'forms.examples.nofields.NoFieldsFormPage',
]
def makeSite(application):
root = RootPage()
site = appserver.NevowSite(root, logPath='web.log')
return site
class RootPage(rend.Page):
"""
Main page that lists the examples and makes the example page a child
resource.
"""
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:
cls = reflect.namedAny(name)
yield T.div(class_='example')[
T.h1[T.a(href=url.here.child(name))[cls.title]],
T.p[cls.description],
]
def childFactory(self, ctx, name):
if name in examples:
cls = reflect.namedAny(name)
return cls()
class FormExamplePage(forms.ResourceMixin, rend.Page):
"""
A base page for the actual examples. The page renders something sensible,
including the title example and description. It also include the "example"
form in an appropriate place.
Each example page is expected to provide the title and description
attributes as well as a form_example method that builds and returns a
forms.Form instance.
"""
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.script(type='text/javascript', src='js/forms.js'),
],
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.title
def data_description(self, ctx, data):
return self.description
# 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)
setattr(RootPage, 'child_js', forms.formsJS)
| Python |
import forms
from forms.examples import main
class SmartUploadFormPage(main.FormExamplePage):
title = 'Smart File Upload'
description = 'Smart uploading of files where the file is "carried across" when the validation fails'
def form_example(self, ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('file', forms.File(), forms.FileUploadWidget)
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
from datetime import datetime
import forms
from forms.examples import main
class PrepopulateFormPage(main.FormExamplePage):
title = 'Prepopulate'
description = 'Example of prepopulating form fields'
def form_example(self, ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aTime', forms.Time())
form.addAction(self.submitted)
form.data = {
'aTime': datetime.utcnow().time(),
}
return form
def submitted(self, ctx, form, data):
print data
| Python |
import forms
from forms.examples import main
class DatesTimesFormPage(main.FormExamplePage):
title = 'Dates'
description = 'Date entry examples'
def form_example(self, ctx):
form = forms.Form()
form.addField('isoFormatDate', forms.Date(), forms.TextInput)
form.addField('monthFirstDate', forms.Date(), forms.DatePartsInput)
form.addField('dayFirstDate', forms.Date(), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('monthYearDate', forms.Date(), forms.MMYYDatePartsInput)
form.addField('twoCharYearDate', forms.Date(), forms.widgetFactory(forms.DatePartsInput, twoCharCutoffYear=70))
form.addField('time', forms.Time())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
from twisted.internet import defer
from datetime import date
import forms
from forms.examples import main
# 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)
# A different "none" option tuple
differentNone = ('none value', '- select -')
class SelectionFormPage(main.FormExamplePage):
title = 'Selection widgets'
description = 'Example of the various selection widgets'
def form_example(self, 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.addField('selectOther', forms.String(), forms.widgetFactory(forms.SelectOtherChoice, options=['Mr', 'Mrs']))
form.addField('selectOtherRequired', forms.String(required=True), forms.widgetFactory(forms.SelectOtherChoice, options=['Mr', 'Mrs']))
form.addField('multiselect', forms.String(), forms.widgetFactory(forms.MultiselectChoice, options=strings))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import forms
from forms.examples import main
class NoFieldsFormPage(main.FormExamplePage):
title = 'Form With no Fields'
description = 'A form with no fields, just button(s). (Just to prove ' \
'it works.)'
def form_example(self, ctx):
form = forms.Form()
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import forms
from forms.examples import main
class RequiredFormPage(main.FormExamplePage):
title = 'Required Fields'
description = 'Demonstration of required fields'
def form_example(self, ctx):
form = forms.Form()
form.addField('name', forms.String(required=True))
form.addField('age', forms.Integer())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
"""A package (for Nevow) for defining the schema, validation and rendering of
HTML forms.
"""
version_info = (0, 7, 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.widgets.restwidget import *
from forms.widgets.multiselect import *
from forms.form import Form, ResourceMixin, renderForm
from forms import iforms
def widgetFactory(widgetClass, *a, **k):
def factory(original):
return widgetClass(original, *a, **k)
return factory
try:
import pkg_resources
except ImportError:
import os.path
defaultCSS = static.File(os.path.join(os.path.split(__file__)[0], 'forms.css'))
formsJS = static.File(os.path.join(os.path.split(__file__)[0], 'js'))
else:
from forms.util import LazyResource
defaultCSS = LazyResource(lambda: static.File(pkg_resources.resource_filename('forms', 'forms.css')))
formsJS = LazyResource(lambda: static.File(pkg_resources.resource_filename('forms', 'js')))
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 util
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 |
"""
Form types.
"""
try:
import decimal
haveDecimal = True
except ImportError:
haveDecimal = False
from zope.interface import implements
from twisted.internet import defer
from formal import iformal, validation
class Type(object):
implements( iformal.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 = list(validators)
else:
self.validators = list(self.validators)
if required is None:
required = self.required
if required:
self.validators.append(validation.RequiredValidator())
def validate(self, value):
dl = []
for validator in self.validators:
dl.append(defer.maybeDeferred(validator.validate, self, value))
def _cbValidate(_, value):
if value is None:
value = self.missing
return value
def _err(failure):
failure.trap(defer.FirstError)
return failure.value.subFailure
d = defer.DeferredList(dl, consumeErrors=True, fireOnOneErrback=True)
d.addCallbacks(_cbValidate, _err, [value])
return d
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
if haveDecimal:
class Decimal(Type):
"""
Forms type for Python 2.4's decimal.Decimal type.
"""
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
class RichText:
"""
A data structure for the RichTextType to use
"""
def __init__(self,type,value):
self.type = type
self.value = value
def __repr__(self):
shortvalue = self.value[:30]
if len(self.value) > 30:
shortvalue += '...'
return '<formal.types.RichText instance, (%s,"%s")>'%(self.type,shortvalue)
class RichTextType(Type):
"""Forms type used for rich text"""
def __init__(self, **kwds):
strip = kwds.pop('strip', None)
super(RichTextType, self).__init__(**kwds)
self.strip = strip or False
def validate(self, value):
# For the moment all the validation is against the content
if self.strip:
value.value = value.value.strip()
if not value.value:
value=None
return super(RichTextType, self).validate(value)
__all__ = [
'Boolean', 'Date', 'File', 'Float', 'Integer', 'Sequence', 'String', 'Time', 'RichTextType', 'RichText',
]
if haveDecimal:
__all__.append('Decimal')
| Python |
"""
Form implementation and high-level renderers.
"""
from zope.interface import Interface
from twisted.internet import defer
from twisted.internet import reactor
from twisted.python.components import registerAdapter
from nevow import appserver, context, loaders, inevow, rend, tags as T, url
from nevow.util import getPOSTCharset
from formal import iformal, util, validation
from resourcemanager import ResourceManager
from zope.interface import implements
SEPARATOR = '!!'
FORMS_KEY = '__nevow_form__'
WIDGET_RESOURCE_KEY = 'widget_resource'
# Backwards compatability/workaround until there's nothing left in Formal or
# application code that adapts the context to IFormErrors.
def formErrorsFinder(ctx):
form = iformal.IForm(ctx)
return form.errors
registerAdapter(formErrorsFinder, context.WovenContext, iformal.IFormErrors)
def renderForm(name):
def _(ctx, data):
def _processForm( form, ctx, name ):
# Remember the form
ctx.remember(form, iformal.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
if form.errors:
ctx.remember(form.errors.data, iformal.IFormData)
else:
ctx.remember(form.data or {}, iformal.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):
if not util.validIdentifier(name):
import warnings
warnings.warn('[0.9] Invalid action name %r. This will become an error in the future.' %
name, FutureWarning, stacklevel=3)
self.callback = callback
self.name = name
self.validate = validate
if label is None:
self.label = util.titleFromName(name)
else:
self.label = label
def itemKey(item):
"""
Build the form item's key from the the item's name and the name of all
ancestors.
"""
parts = [item.name]
parent = item.itemParent
while parent is not None:
parts.append(parent.name)
parent = parent.itemParent
parts.reverse()
return '.'.join(parts)
class Field(object):
itemParent = None
def __init__(self, name, type, widgetFactory=None, label=None,
description=None, cssClass=None):
if not util.validIdentifier(name):
raise ValueError('%r is an invalid field name'%name)
if label is None:
label = util.titleFromName(name)
if widgetFactory is None:
widgetFactory = iformal.IWidget
self.name = name
self.type = type
self.widgetFactory = widgetFactory
self.label = label
self.description = description
self.cssClass = cssClass
def setItemParent(self, itemParent):
self.itemParent = itemParent
key = property(lambda self: itemKey(self))
def makeWidget(self):
return self.widgetFactory(self.type)
def process(self, ctx, form, args, errors):
# If the type is immutable then copy the original value to args in case
# another validation error causes this field to be re-rendered.
if self.type.immutable:
args[self.key] = form.data.get(self.key)
return
# Process the input using the widget, storing the data back on the form.
widget = self.makeWidget()
def _cbProcess(data):
form.data[self.key] = data
def _errProcess(failure):
failure.trap(validation.FieldError)
e = failure.value
if e.fieldName is None:
e.fieldName = self.key
errors.add(e)
d = defer.maybeDeferred(widget.processInput, ctx, self.key, args)
d.addCallbacks(_cbProcess, _errProcess)
return d
class FieldFragment(rend.Fragment):
implements(inevow.IRenderer)
docFactory = loaders.stan(
T.div(id=T.slot('fieldId'), _class=T.slot('class'),
render=T.directive('field'))[
T.label(_class='label', _for=T.slot('id'))[T.slot('label')],
T.div(_class='inputs')[T.slot('inputs')],
T.slot('description'),
T.slot('message'),
])
hiddenDocFactory = loaders.stan(
T.invisible(render=T.directive('field'))[T.slot('inputs')])
def __init__(self, field):
self.field = field
# Nasty hack to work out if this is a hidden field. Keep the widget
# for later anyway.
self.widget = field.makeWidget()
if getattr(self.widget, 'inputType', None) == 'hidden':
self.docFactory = self.hiddenDocFactory
def render_field(self, ctx, data):
# The field we're rendering
field = self.field
# Get stuff from the context
formData = iformal.IFormData(ctx)
formErrors = iformal.IFormErrors(ctx, None)
# Find any error
if formErrors is None:
error = None
else:
error = formErrors.getFieldError(field.key)
# Build the error message
if error is None:
message = ''
else:
message = T.div(class_='message')[error.message]
# Create the widget (it's created in __init__ as a hack)
widget = self.widget
# Build the list of CSS classes
classes = [
'field',
field.type.__class__.__name__.lower(),
widget.__class__.__name__.lower(),
]
if field.type.required:
classes.append('required')
if field.cssClass:
classes.append(field.cssClass)
if error:
classes.append('error')
# Create the widget and decide the method that should be called
if field.type.immutable:
render = widget.renderImmutable
else:
render = widget.render
# Fill the slots
tag = ctx.tag
tag.fillSlots('id', util.render_cssid(field.key))
tag.fillSlots('fieldId', [util.render_cssid(field.key), '-field'])
tag.fillSlots('class', ' '.join(classes))
tag.fillSlots('label', field.label)
tag.fillSlots('inputs', render(ctx, field.key, formData,
formErrors))
tag.fillSlots('message', message)
tag.fillSlots('description',
T.div(class_='description')[field.description or ''])
return ctx.tag
registerAdapter(FieldFragment, Field, inevow.IRenderer)
class AddHelperMixin(object):
"""
A mixin that provides methods for common uses of add(...).
"""
def addGroup(self, *a, **k):
return self.add(Group(*a, **k))
def addField(self, *a, **k):
return self.add(Field(*a, **k))
def __getitem__(self, items):
"""
Overridden to allow stan-style construction of forms.
"""
# Items may be a list or a scalar so stick a scalar into a list
# immediately to simplify the code.
try:
items = iter(items)
except TypeError:
items = [items]
# Add each item
for item in items:
self.add(item)
# Return myself
return self
class Group(AddHelperMixin, object):
itemParent = None
def __init__(self, name, label=None, description=None, cssClass=None):
if label is None:
label = util.titleFromName(name)
self.name = name
self.label = label
self.description = description
self.cssClass = cssClass
self.items = FormItems(self)
# Forward to FormItems methods
self.add = self.items.add
self.getItemByName = self.items.getItemByName
key = property(lambda self: itemKey(self))
def setItemParent(self, itemParent):
self.itemParent = itemParent
def process(self, ctx, form, args, errors):
for item in self.items:
item.process(ctx, form, args, errors)
class GroupFragment(rend.Fragment):
docFactory = loaders.stan(
T.fieldset(id=T.slot('id'), class_=T.slot('cssClass'),
render=T.directive('group'))[
T.legend[T.slot('label')],
T.div(class_='description')[T.slot('description')],
T.slot('items'),
]
)
def __init__(self, group):
super(GroupFragment, self).__init__()
self.group = group
def render_group(self, ctx, data):
# Get a reference to the group, for simpler code.
group = self.group
# Build the CSS class string
cssClass = ['group']
if group.cssClass is not None:
cssClass.append(group.cssClass)
cssClass = ' '.join(cssClass)
# Fill the slots
tag = ctx.tag
tag.fillSlots('id', util.render_cssid(group.key))
tag.fillSlots('cssClass', cssClass)
tag.fillSlots('label', group.label)
tag.fillSlots('description', group.description or '')
tag.fillSlots('items', [inevow.IRenderer(item) for item in
group.items])
return ctx.tag
registerAdapter(GroupFragment, Group, inevow.IRenderer)
class Form(AddHelperMixin, object):
implements( iformal.IForm )
callback = None
actions = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
self.data = {}
self.items = FormItems(None)
self.errors = FormErrors()
# Forward to FormItems methods
self.add = self.items.add
self.getItemByName = self.items.getItemByName
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 process(self, ctx):
request = inevow.IRequest(ctx)
charset = getPOSTCharset(ctx)
# Get the request args and decode the arg names
args = dict([(k.decode(charset),v) for k,v in request.args.items()])
# 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
# IE does not send a button name in the POST args for forms containing
# a single field when the user presses <enter> to submit the form. If
# we only have one possible action then we can safely assume that's the
# action to take.
#
# If there are 0 or 2+ actions then we can't assume anything because we
# have no idea what order the buttons are on the page (someone might
# have altered the DOM using JavaScript for instance). In that case
# throw an error and make it a problem for the developer.
if callback is None:
if self.actions is None or len(self.actions) != 1:
raise Exception('The form has no callback and no action was found.')
else:
callback, validate = self.actions[0].callback, \
self.actions[0].validate
# Remember the args in case validation fails.
self.errors.data = args
def _cbProcessingDone(_):
if self.errors and validate:
return self.errors
def _clearUpResources( r ):
if not self.errors:
self.resourceManager.clearUpResources()
return r
d = defer.maybeDeferred(callback, ctx, self, self.data)
d.addCallback( _clearUpResources )
d.addErrback(self._cbFormProcessingFailed, ctx)
return d
# Iterate the items and collect the form data and/or errors.
dl = []
for item in self.items:
dl.append(defer.maybeDeferred(item.process, ctx, self, args, self.errors))
d = defer.gatherResults(dl)
d.addCallback(_cbProcessingDone)
return d
def _cbFormProcessingFailed(self, failure, ctx):
e = failure.value
failure.trap(validation.FormError, validation.FieldError)
self.errors.add(failure.value)
return self.errors
class FormItems(object):
"""
A managed collection of form items.
"""
def __init__(self, itemParent):
self.items = []
self.itemParent = itemParent
def __iter__(self):
return iter(self.items)
def add(self, item):
# Check the item name is unique
if item.name in [i.name for i in self.items]:
raise ValueError('Item named %r already added to %r' %
(item.name, self))
# Add to child items and set self the parent
self.items.append(item)
item.setItemParent(self.itemParent)
return item
def getItemByName(self, name):
name = name.split('.', 1)
if len(name) == 1:
name, rest = name[0], None
else:
name, rest = name[0], name[1]
for item in self.items:
if item.name == name:
if rest is None:
return item
return item.getItemByName(rest)
raise KeyError("No item called %r" % name)
class FormErrors(object):
implements( iformal.IFormErrors )
def __init__(self):
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 self.errors
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, iformal.IForm)
widget = form.getItemByName(segments[0]).makeWidget()
return widget.getResource(ctx, segments[0], 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, iformal.IFormFactory)
def render_form(self, name):
def _(ctx, data):
self.remember(ctx)
return renderForm(name)
return _
def _processForm(self, form, ctx):
ctx.remember(form, iformal.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( iformal.IFormFactory )
__formsBehaviour = None
def __behaviour(self):
if self.__formsBehaviour is None:
self.__formsBehaviour = FormsResourceBehaviour(parent=self)
return self.__formsBehaviour
def locateChild(self, ctx, segments):
def gotResult(result):
if result is not appserver.NotFound:
return result
return super(ResourceMixin, self).locateChild(ctx, segments)
self.remember(self, iformal.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().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)
self.remember(self, iformal.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().renderHTTP, ctx)
d.addCallback(gotResult)
return d
def render_form(self, name):
return self.__behaviour().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(iformal.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)
def widgetResourceURLFromContext(ctx,name):
# Could this replace widgetResourceURL?
u = url.URL.fromContext(ctx)
if u.pathList()[-1] != FORMS_KEY:
u = u.child(FORMS_KEY)
return u.child(name).child(WIDGET_RESOURCE_KEY)
class FormRenderer(object):
implements( inevow.IRenderer )
loader = loaders.stan(
T.form(**{'id': T.slot('formName'), 'action': T.slot('formAction'),
'class': 'nevow-form', 'method': 'post', 'enctype':
'multipart/form-data', 'accept-charset': 'utf-8'})[
T.div[
T.input(type='hidden', name='_charset_'),
T.input(type='hidden', name=FORMS_KEY, value=T.slot('formName')),
T.slot('formErrors'),
T.slot('formItems'),
T.div(class_='actions')[
T.slot('formActions'),
],
],
]
)
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('formName', self.original.name)
tag.fillSlots('formAction', url.here)
tag.fillSlots('formErrors', self._renderErrors)
tag.fillSlots('formItems', self._renderItems)
tag.fillSlots('formActions', self._renderActions)
return tag
def _renderErrors(self, ctx, data):
if not self.original.errors:
return ''
errors = self.original.errors.getFormErrors()
errorList = T.ul()
for error in errors:
if isinstance(error, validation.FormError):
errorList[ T.li[ error.message ] ]
for error in errors:
if isinstance(error, validation.FieldError):
item = self.original.getItemByName(error.fieldName)
errorList[ T.li[ T.strong[ item.label, ' : ' ], error.message ] ]
return T.div(class_='errors')[ T.p['Please correct the following errors:'], errorList ]
def _renderItems(self, ctx, data):
if self.original.items is None:
yield ''
return
for item in self.original.items:
yield inevow.IRenderer(item)
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'%(self.original.name, data.name), name=data.name, value=data.label)
registerAdapter(FormRenderer, Form, inevow.IRenderer)
| Python |
import warnings
warnings.warn(
"The htmleditor module is deprecated. To use an HTML editor with " \
"formal, render your field as a formal.TextArea and use JavaScript " \
"to turn the textarea into a HTML editor.",
DeprecationWarning,
stacklevel=2)
from nevow import tags as T, util
from formal import iformal
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( iformal.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iformal.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 = iformal.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 = iformal.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
| Python |
from nevow import appserver, rend
from formal.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 base64
import tempfile
import mimetypes
import re
import os
from shutil import copyfileobj
from exceptions import IOError, OSError
# Use Python 2.4 base64 API if possible. Simulate on Python 2.3.
try:
base64.b64encode
except AttributeError:
# Python 2.3
def base64encode(s):
return base64.encodestring(s).replace('\n', '')
base64decode = base64.decodestring
else:
# Python 2.4
base64encode = base64.b64encode
base64decode = base64.b64decode
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.
NOTE: the string encode('base64') can result in strings with '\n'
embedded in them. the base64.b64encode() does not appear to suffer this
problem.
"""
rv = filename.encode('utf-8')
rv = base64encode(rv)
return rv
def _decodeFilename(self, filename):
"""
Undo what _encodeFilename did.
"""
rv = base64decode(filename)
rv = rv.decode('utf-8')
return rv
| Python |
"""
ReST text area widget.
"""
from nevow import inevow, loaders, rend, tags as T
from formal import iformal, widget
from formal.util import render_cssid
from formal.form import widgetResourceURLFromContext
class ReSTTextArea(widget.TextArea):
"""
A large text entry area that accepts ReST and previews it as HTML
This will accept a restWriter parameter
"""
restWriter = None
def __init__(self, original, **kwds):
restWriter = kwds.pop('restWriter', None)
super(ReSTTextArea, self).__init__(original, **kwds)
if restWriter is not None:
self.restWriter = restWriter
def _renderTag(self, ctx, key, value, readonly):
tag=T.invisible()
ta=T.textarea(name=key, id=render_cssid(key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
ta(class_='readonly', readonly='readonly')
tag[ta]
if not readonly:
try:
import docutils
except ImportError:
raise
else:
form = iformal.IForm( ctx )
srcId = render_cssid(key)
previewDiv = render_cssid(key, 'preview-div')
frameId = render_cssid(key, 'preview-frame')
targetURL = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId )
tag[T.br()]
onclick = ["return Forms.Util.previewShow('",previewDiv, "', '",
frameId, "', '", targetURL, "');"]
tag[T.button(onclick=onclick)['Preview ...']]
tag[T.div(id=previewDiv, class_="preview-hidden")[
T.iframe(class_="preview-frame", name=frameId, id=frameId),
T.br(),
T.button(onclick=["return Forms.Util.previewHide('", previewDiv, "');"])['Close']
]
]
return tag
def getResource(self, ctx, key, segments):
return ReSTPreview(ctx, self.restWriter, key, segments[0]), segments[1:]
class ReSTPreview(rend.Page):
def __init__(self, ctx, restWriter, key, srcId):
self.restWriter = restWriter
form = iformal.IForm( ctx )
u = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId ).child('_submit')
self.destId=srcId + '-dest'
formId=srcId + '-form'
stan = T.html()[
T.head()[
T.script(type="text/javascript")["""
function ReSTTranslate() {
dest = document.getElementById('%(destId)s');
form = document.getElementById('%(formId)s');
src = parent.document.getElementById('%(srcId)s');
dest.value = src.value;
form.submit();
}
"""%{'srcId':srcId, 'destId':self.destId, 'formId':formId}]
],
T.body()[
T.form(id=formId, method="POST", action=u)[
T.input(type="hidden", name=self.destId, id=self.destId)
],
T.script(type="text/javascript")["ReSTTranslate();"],
],
]
self.docFactory = loaders.stan(stan)
def child__submit(self, ctx):
args = inevow.IRequest(ctx).args
value = args.get(self.destId, [''])[0]
from docutils.utils import SystemMessage
try:
if self.restWriter:
restValue = self._html_fragment(value, writer=self.restWriter)
else:
restValue = self._html_fragment(value, writer_name='html')
except SystemMessage, e:
restValue = str(e)
stan = T.html()[
T.head()[
T.style(type="text/css")["""
.system-message {border: 1px solid red; background-color: #FFFFDD; margin: 5px; padding: 5px;}
.system-message-title { font-weight: bold;}
"""
]
],
T.body()[
T.div()[
T.xml(restValue)
]
],
]
self.docFactory = loaders.stan(stan)
return self
def _html_fragment(self, input_string, writer=None, writer_name=None):
from docutils.core import publish_parts
overrides = {'input_encoding': 'utf8',
'doctitle_xform': 0,
'initial_header_level': 1}
parts = publish_parts(
source=input_string,
writer_name=writer_name, writer=writer, settings_overrides=overrides)
fragment = parts['fragment']
return fragment.encode('utf8')
__all__ = ['ReSTTextArea']
| Python |
"""
Rich text area widget.
"""
from nevow import inevow, loaders, rend, tags as T, util
from formal import iformal, widget, types
from formal.util import render_cssid
from zope.interface import Interface
class RichTextArea(widget.TextArea):
"""
A large text entry area that can be used for different formats of formatted text (rest, html, markdown, texy)
"""
def __init__(self, original, **kwds):
parsers = kwds.pop('parsers', None)
super(RichTextArea, self).__init__(original, **kwds)
self.parsers = parsers
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, tparser, tvalue, namer, readonly):
tag=T.invisible()
if len(self.parsers) > 1:
tp = T.select(name=namer('tparser'),id=render_cssid(namer('tparser')))
if readonly:
tp(class_='disabled', disabled='disabled')
for k,v in self.parsers:
if k == tparser:
tp[T.option(selected='selected',value=k)[ v ]]
else:
tp[T.option(value=k)[ v ]]
else:
tp = T.input(type='hidden',name=namer('tparser'),id=render_cssid(namer('tparser')),value=self.parsers[0][0])
ta=T.textarea(name=namer('tvalue'), id=render_cssid(namer('tvalue')), cols=self.cols, rows=self.rows)[tvalue or '']
if readonly:
ta(class_='readonly', readonly='readonly')
tag[tp,T.br,ta]
return tag
def render(self, ctx, key, args, errors):
namer = self._namer(key)
if errors:
tparser = args.get(namer('tparser'), [''])[0]
tvalue = args.get(namer('tvalue'), [''])[0]
else:
value = args.get(key)
if value is not None:
tparser = getattr(value,'type',None)
tvalue = getattr(value,'value','')
else:
tparser = None
tvalue = ''
return self._renderTag(ctx, tparser, tvalue, namer, False)
def renderImmutable(self, ctx, key, args, errors):
namer = self._namer(key)
if errors:
tparser = args.get(namer('tparser'), [''])[0]
tvalue = args.get(namer('tvalue'), [''])[0]
else:
value = args.get(key)
if value is not None:
tparser = value.type
tvalue = getattr(value,'value','')
else:
tparser = None
tvalue = ''
return self._renderTag(ctx, tparser, tvalue, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip().decode(util.getPOSTCharset(ctx)) for part in ('tparser', 'tvalue')]
return self.original.validate(types.RichText(*value))
| Python |
from zope.interface import implements
from nevow import tags as T
from formal import iformal
from formal.util import render_cssid
_UNSET = object()
class MultichoiceBase(object):
"""
A base class for widgets that provide the UI to select one or more items
from a list.
Based on ChoiceBase
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):
values = args.get(key, [''])
rv = []
for value in values:
value = iformal.IStringConvertible(self.original).toType(value)
if self.noneOption is not None and value == self.noneOption[0]:
value = None
rv.append(self.original.validate(value))
return rv
class MultiselectChoice(MultichoiceBase):
"""
A drop-down list of options.
<select>
<option value="...">...</option>
</select>
"""
implements( iformal.IWidget )
noneOption = ('', '')
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iformal.IKey(self.noneOption).key())[iformal.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iformal.IKey(item).key()
optLabel = iformal.ILabel(item).label()
optValue = converter.fromType(optValue)
option = T.option(value=optValue)[optLabel]
if value and optValue in value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=render_cssid(key), data=self.options, multiple="multiple")[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iformal.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iformal.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
| 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.