def test_fieldset_extract_preparer(self):
def lower(val):
return val.lower()
field = self._makeOne('test', preparer=lower)
fieldset = form.Fieldset(field).bind(params={'test': 'FORM'})
data, errors = fieldset.extract()
self.assertEqual(data['test'], 'form')
def test_fieldset_validate(self):
def validator(fs, data):
raise form.Invalid(fs, 'msg')
fieldset = form.Fieldset(field, validator=validator)
self.assertRaises(form.Invalid, fieldset.validate, {})
fieldset.bind()
self.assertRaises(form.Invalid, fieldset.validate, {})
def form_view(context, request):
myform = form.Form(context, request)
# define fields for form
myform.fields = form.Fieldset(
form.TextField('title', title=u'Title'), # field title
form.TextAreaField(
'description', title=u'Description',
missing=u''), # field use this value is request doesnt contain
# field value, effectively field is required
# if `missing` is not specified
form.TextField(
'email',
title=u'E-Mail',
description=u'Please provide email address.',
validator=form.Email(), # email validator
),
)
# form actions
def cancelAction(form):
raise HTTPFound(location='.')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
pprint(data)
form.context.title = data['title']
form.context.description = data['description']
form.message('Content has been updated.', 'info')
raise HTTPFound(location='.')
myform.buttons.add_action('Update', action=updateAction)
myform.buttons.add_action('Cancel', action=cancelAction)
# form default values
myform.content = {
'title': context.title,
'description': context.description
}
# prepare form
myform.update()
# render form
res = myform.render()
# optional, render form in layout
layout = view.LayoutRenderer('')
return layout(context, request, res)
def test_fieldset_append_simple(self):
fieldset = form.Fieldset(field, name='test')
self.assertIn('test', fieldset)
self.assertEqual(fieldset.prefix, 'test.')
self.assertIs(fieldset['test'], field)
self.assertRaises(ValueError, fieldset.append, field)
self.assertRaises(TypeError, fieldset.append, object())
def test_fieldset_extract_validate(self):
def validator(fs, data):
raise form.Invalid(fs, 'msg')
field = self._makeOne('test')
fieldset = form.Fieldset(field, validator=validator)
fieldset = fieldset.bind(params={'test': 'FORM'})
data, errors = fieldset.extract()
self.assertEqual(len(errors), 1)
def __init__(self, *args, **kwargs):
super(Group, self).__init__()
fields = form.Fieldset(*args, **kwargs)
self.__uri__ = 'settings:{0}'.format(fields.name)
self.__name__ = fields.name
self.__title__ = fields.title
self.__description__ = fields.description
self.__fields__ = fields
self.__ttw__ = kwargs.get('ttw', False)
self.__ttw_skip_fields__ = kwargs.get('ttw_skip_fields', ())
def contact_us(context, request):
contactform = form.Form(context, request)
contactform.label = 'Contact us'
contactform.fields = form.Fieldset(
form.TextField('fullname', title=u'First & Last Name'),
form.TextField('phone',
title=u'Telephone number',
description=u'Please provide telephone number',
validator=Telephone()),
form.TextField('email',
title=u'Your email',
description=u'Please provide email address.',
validator=form.Email()),
form.TextAreaField(
'subject', title=u'How can we help?',
missing=u''), # field use this value is request doesnt contain
# field value, effectively field is required
# if `missing` is not specified
)
# form actions
def cancelAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
# form.context is ...
form.context.fullname = data['fullname']
form.context.phone = data['phone']
form.context.email = data['email']
form.context.subject = data['subject']
# You would add any logic/database updates/insert here.
# You would probably also redirect.
log.info('The form was updated successfully')
form.message('The form was updated successfully')
contactform.buttons.add_action('Contact us',
action=updateAction,
actype=form.AC_PRIMARY)
contactform.buttons.add_action('Cancel', action=cancelAction)
# form default values
contactform.content = {}
return contactform()
def form_view(context, request):
myform = form.Form(context, request)
# define fields for form
myform.fields = form.Fieldset(
form.TextField(
'title',
title = u'Title'), # field title
form.TextAreaField(
'description',
title = u'Description',
missing = u''), # field use this value is request doesnt contain
# field value, effectively field is required
# if `missing` is not specified
form.TextField(
'email',
title = u'E-Mail',
description = u'Please provide email address.',
validator = form.Email(), # email validator
),
)
# form actions
def cancel_action(form):
form.message('Cancel button', 'info')
def update_action(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
pprint(data)
form.message('Content has been updated.', 'info')
return HTTPFound(location='.')
myform.buttons.add_action('Update', action=update_action,
actype=ptah.form.AC_PRIMARY)
myform.buttons.add_action('Cancel', action=cancel_action)
# form default values
myform.content = {'title': 'Test title',
'description': 'Context description'}
# render form
myform.update()
return {'view': myform}
def test_tinfo_fieldset(self):
import ptah, ptah.cms
MySchema = ptah.cms.ContentSchema + \
form.Fieldset(form.TextField('test'))
class MyContent(ptah.cms.Content):
__type__ = ptah.cms.Type('mycontent2',
'MyContent',
fieldset=MySchema)
tinfo = MyContent.__type__
self.assertIs(tinfo.fieldset, MySchema)
def build_sqla_fieldset(columns, skipPrimaryKey=False):
"""
Given a list of SQLAlchemy columns generate a ptah.form.Fieldset.
:param columns: sequence of sqlachemy.schema.Column instances
:param skipPrimaryKey: **default: False** boolean whether to include PK
Columns in Fieldset generation.
:returns: a instance of :py:class:`ptah.form.Fieldset`
"""
fields = []
for name, cl in columns:
if cl.info.get('skip', False):
continue
if 'field' in cl.info:
field = cl.info['field']
fields.append(field)
continue
if cl.primary_key and skipPrimaryKey:
continue
typ = cl.info.get('factory')
if typ is None:
typ = cl.info.get('field_type')
if typ is None:
for cls, field_type in mapping.items():
if isinstance(cl.type, cls):
typ = field_type
break
if typ is None:
continue
kwargs = {}
for attr in ('missing', 'title', 'description', 'vocabulary',
'validator'):
if attr in cl.info:
kwargs[attr] = cl.info[attr]
if cl.primary_key and (typ == 'int'):
kwargs['readonly'] = True
if callable(typ):
field = typ(name, **kwargs)
else:
field = form.FieldFactory(typ, name, **kwargs)
fields.append(field)
return form.Fieldset(*fields)
def login_form(request):
login_form = form.Form(None, request)
login_form.title = 'Login'
login_form.fields = form.Fieldset(
form.TextField(
'login',
title = u'Login Name',
description = 'Login names are case sensitive, '\
'make sure the caps lock key is not enabled.',
default = u''),
form.PasswordField(
'password',
title = u'Password',
description = 'Case sensitive, make sure caps '\
'lock is not enabled.',
default = u''),
)
def loginAction(form):
request = form.request
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
info = ptah.auth_service.authenticate(data)
if info.status:
headers = security.remember(request, info.principal.uri)
return HTTPFound(headers = headers,
location = request.application_url)
if info.message:
form.message(info.message, 'warning')
return
form.message('You enter wrong login or password.', 'error')
login_form.buttons.add_action('Log in', action=loginAction)
res = login_form.update()
if isinstance(res, HTTPFound):
return res
return {'rendered_login_form': login_form.render(),
'user': ptah.resolve(authenticated_userid(request))}
class MyForm(form.Form):
view.pview('test-form.html', context=cms.Content)
# define fields for form
fields = form.Fieldset(
form.TextField('title', title=u'Title'), # field title
form.TextAreaField(
'description', title=u'Description',
missing=u''), # field use this value is request doesnt contain
# field value, effectively field is required
# if `missing` is not specified
form.TextField(
'email',
title=u'E-Mail',
description=u'Please provide email address.',
validator=form.Email(), # email validator
),
)
# form default values
def form_content(self):
return {
'title': self.context.title,
'description': self.context.description
}
@form.button('Update')
def update_handler(self):
data, errors = self.extract()
if errors:
self.message(errors, 'form-error')
return
pprint(data)
self.context.title = data['title']
self.context.description = data['description']
self.message('Content has been updated.', 'info')
raise HTTPFound(location='.')
@form.button('Cancel')
def cancel_handler(self):
raise HTTPFound(location='.')
def test_fieldset_bind(self):
fieldset = form.Fieldset(field)
params = object()
data = {'test': 'CONTENT'}
fs = fieldset.bind(data, params)
self.assertIsNot(fieldset, fs)
self.assertEqual(len(fieldset), len(fs))
self.assertIs(fs.params, params)
self.assertIs(fs.data, data)
self.assertIs(fs['test'].params, params)
self.assertEqual(fs['test'].value, 'CONTENT')
fs = fieldset.bind()
self.assertIsNot(fieldset, fs)
self.assertEqual(len(fieldset), len(fs))
self.assertEqual(fs.params, {})
self.assertEqual(fs.data, {})
self.assertEqual(fs['test'].params, {})
self.assertIs(fs['test'].value, form.null)
""" add blob return uri """
def query(uri):
""" return blob object """
def replace(uri, data, mimetype=None, filename=None):
""" replace existing blob """
def remove(uri):
""" remove blob """
ContentSchema = form.Fieldset(
form.FieldFactory('text', 'title', title='Title'),
form.FieldFactory('textarea',
'description',
title='Description',
missing=''),
)
def specialSymbols(field, appstruct):
if '/' in appstruct:
raise form.Invalid(field, "Names cannot contain '/'")
if appstruct.startswith(' '):
raise form.Invalid(field, "Names cannot starts with ' '")
ContentNameSchema = form.Fieldset(
form.FieldFactory(
equality of password and confirm_password"""
if appstruct['password'] and appstruct['confirm_password']:
if appstruct['password'] != appstruct['confirm_password']:
raise form.Invalid(
field, _("Password and Confirm Password should be the same."))
passwordValidator(field, appstruct['password'])
PasswordSchema = form.Fieldset(
form.FieldFactory(
'password',
'password',
title = _('Password'),
description = _('Enter password. '\
'No spaces or special characters, should contain '\
'digits and letters in mixed case.'),
default = ''),
form.FieldFactory(
'password',
'confirm_password',
title = _('Confirm password'),
description = _('Re-enter the password. '
'Make sure the passwords are identical.'),
default = ''),
validator = passwordSchemaValidator
)
def test_fieldset_add_err(self):
fieldset = form.Fieldset(field)
self.assertRaises(ValueError, fieldset.__add__, object())
def test_fieldset_omit(self):
fieldset = form.Fieldset(field, field1)
newfs = fieldset.omit('test')
self.assertNotIn('test', newfs)
self.assertEqual(list(newfs.keys()), ['test1'])
class UriResolver(form.Form):
""" Uri resolver form """
fields = form.Fieldset(
form.LinesField('uri',
title='Uri',
description="List of uri's",
klass='xxlarge'))
uri = None
rst_to_html = staticmethod(ptah.rst_to_html)
def form_content(self):
return {'uri': [self.request.GET.get('uri', '')]}
@form.button('Show', actype=form.AC_PRIMARY)
def show_handler(self):
data, errors = self.extract()
if errors:
self.message(errors, 'form-error')
else:
self.uri = data['uri']
def update(self):
res = super(UriResolver, self).update()
uri = self.uri
if uri is None:
uri = [self.request.GET.get('uri', '')]
resolvers = config.get_cfg_storage(ID_RESOLVER)
self.data = data = []
for u in uri:
if u:
schema = ptah.extract_uri_schema(u)
resolver = resolvers.get(schema)
info = {
'uri': u,
'resolver': None,
'module': None,
'line': None,
'obj': None,
'cls': None,
'clsdoc': None
}
if resolver is not None:
info['resolver'] = resolver.__name__
info['r_doc'] = ptah.rst_to_html(resolver.__doc__ or '')
info['module'] = resolver.__module__
info['name'] = '%s.%s' % (resolver.__module__,
resolver.__name__)
info['line'] = inspect.getsourcelines(resolver)[-1]
obj = ptah.resolve(u)
info['obj'] = obj
if obj is not None:
cls = getattr(obj, '__class__', None)
info['cls'] = cls
info['clsdoc'] = ptah.rst_to_html(
getattr(cls, '__doc__', '') or '')
if cls is not None:
info['clsmod'] = cls.__module__
info['clsline'] = inspect.getsourcelines(cls)[-1]
data.append(info)
return res
def contact_us(context, request):
contactform = form.Form(context, request)
contactform.fields = form.Fieldset(
form.TextField(
'fullname',
title = u'First & Last Name'),
form.TextField(
'phone',
title = u'Telephone number',
description=u'Please provide telephone number',
validator = Telephone()),
form.TextField(
'email',
title = u'Your email',
description = u'Please provide email address.',
validator = form.Email()),
form.TextAreaField(
'subject',
title = u'How can we help?',
missing = u''), # field use this value is request doesnt contain
# field value, effectively field is required
# if `missing` is not specified
)
# form actions
def cancelAction(form):
return HTTPFound(location='/')
def updateAction(form):
data, errors = form.extract()
if errors:
form.message(errors, 'form-error')
return
# form.context is ...
form.context.fullname = data['fullname']
form.context.phone = data['phone']
form.context.email = data['email']
form.context.subject = data['subject']
# You would add any logic/database updates/insert here.
# You would probably also redirect.
log.info('The form was updated successfully')
form.message('The form was updated successfully')
contactform.label = u'Contact us'
contactform.buttons.add_action('Update', action=updateAction)
contactform.buttons.add_action('Cancel', action=cancelAction)
# form default values
contactform.content = {}
# prepare form
result = contactform.update()
if isinstance(result, HTTPFound):
return result
# render form into HTML
rendered_form = contactform.render()
# query for links to populate links box
links = ptah.get_session().query(models.Link)
#include library dependencies
ptah.include(request, 'bootstrap')
# render all the included libraries into html
rendered_includes = ptah.render_includes(request)
# render messages
rendered_messages = ptah.render_messages(request)
return {'links': links,
'rendered_form': rendered_form,
'rendered_messages': rendered_messages,
'rendered_includes': rendered_includes}
def test_fieldset_extract_display(self):
field = self._makeOne('test', mode=form.FORM_DISPLAY)
fieldset = form.Fieldset(field).bind(None, {'test': 'VALUE'})
data, errors = fieldset.extract()
self.assertEqual(data, {})
self.assertEqual(errors, [])
def test_fieldset_nested(self):
fieldset = form.Fieldset(field, form.Fieldset(name='fs', *(field, )))
self.assertEqual(fieldset['fs'].name, 'fs')
self.assertEqual(fieldset['fs'].prefix, 'fs.')
def test_fieldset_fields(self):
fieldset = form.Fieldset(field, field1)
self.assertEqual(list(fieldset.fields()), [field, field1])
import permissions
from themefile import ThemeFile, ThemeFileSchema
class Email(form.Email):
def __call__(self, field, value):
if value != '':
super(Email, self).__call__(field, value)
ThemeSchema = form.Fieldset(
ptah.cms.ContentSchema,
form.TextField('author', title='Author name'),
form.TextField('email',
missing='',
title='Author email',
validator=Email()),
form.TextField('url', missing='', title='Web site'),
form.FileField('preview', title='Preview image', missing=''),
)
class Theme(ptah.cms.Container):
__tablename__ = 'ploud_themes'
__type__ = ptah.cms.Type(
'diazo-theme',
'Theme',
add='newtheme.html',
fieldset=ThemeSchema,
class SharingForm(form.Form):
""" Sharing form """
csrf = True
fields = form.Fieldset(
form.FieldFactory('text',
'term',
title='Search term',
description='Searches users by login and email',
missing='',
default=''))
users = None
bsize = 15
def form_content(self):
return {'term': self.request.session.get('apps-sharing-term', '')}
def get_principal(self, id):
return ptah.resolve(id)
def update(self):
res = super(SharingForm, self).update()
request = self.request
context = self.context
self.roles = [r for r in ptah.get_roles().values() if not r.system]
self.local_roles = local_roles = context.__local_roles__
term = request.session.get('apps-sharing-term', '')
if term:
self.users = list(ptah.search_principals(term))
if 'form.buttons.save' in request.POST:
users = []
userdata = {}
for attr, val in request.POST.items():
if attr.startswith('user-'):
userId, roleId = attr[5:].rsplit('-', 1)
data = userdata.setdefault(str(userId), [])
data.append(str(roleId))
if attr.startswith('userid-'):
users.append(str(attr.split('userid-')[-1]))
for uid in users:
if userdata.get(uid):
local_roles[str(uid)] = userdata[uid]
elif uid in local_roles:
del local_roles[uid]
context.__local_roles__ = local_roles
return res
@form.button('Search', actype=form.AC_PRIMARY)
def search(self):
data, error = self.extract()
if not data['term']:
self.message('Please specify search term', 'warning')
return
self.request.session['apps-sharing-term'] = data['term']
return HTTPFound(location=self.request.url)
