class Member(schemaish.Structure):
name = schemaish.String()
title = schemaish.String()
moderator = schemaish.Boolean()
member = schemaish.String()
resend = schemaish.Boolean()
remove = schemaish.Boolean()
class StaticListStructure(BaseStructure):
body = schemaish.String()
hidden = schemaish.Boolean()
reparent = schemaish.Boolean()
list_items = schemaish.String()
custom_view = schemaish.String()
_widgets = copy.copy(BaseStructure._widgets)
_widgets.update({
'body': {
'widget': formish.TextArea,
'args': [],
'kwargs': {
'cols': 80,
'rows': 25,
'empty': ''
},
},
'hidden': {
'widget': formish.Checkbox
},
'reparent': {
'widget': formish.Checkbox
},
'list_items': {
'widget': formish.TextArea,
'args': [],
'kwargs': {
'cols': 80,
'rows': 10,
'empty': ''
},
},
})
def form_fields(self):
min_pw_length = int(get_setting(self.context, 'min_pw_length', 6))
pwlen = validator.Length(min_pw_length)
username = karlvalidators.RegularExpression(
r'^[\w-]+$',
'Username must contain only letters, numbers, and dashes')
fields = [
('username',
schemaish.String(
validator=validator.All(validator.Required(), username))),
('password',
schemaish.String(
validator=validator.All(validator.Required(), pwlen))),
('password_confirm',
schemaish.String(
validator=validator.All(validator.Required(), pwlen))),
('firstname', schemaish.String(validator=validator.Required())),
('lastname', schemaish.String(validator=validator.Required()))
]
member_fields = get_setting(self.context, 'member_fields')
for field_name in member_fields:
if field_name in self.fields:
fields.append((field_name, self.fields[field_name]))
r = queryMultiAdapter((self.context, self.request),
IInvitationBoilerplate)
if r is None:
r = DefaultInvitationBoilerplate(self.context)
if r.terms_and_conditions:
fields.append(('terms_and_conditions',
schemaish.Boolean(validator=validator.Equal(True))))
if r.privacy_statement:
fields.append(('accept_privacy_policy',
schemaish.Boolean(validator=validator.Equal(True))))
return fields
class FolderStructure(BaseStructure):
hidden = schemaish.Boolean()
default_content = schemaish.String()
heading_tab = schemaish.Boolean()
custom_view = schemaish.String()
_widgets = copy.copy(BaseStructure._widgets)
_widgets.update({
'default_content': {
'widget': formish.SelectChoice,
'kwargs': {
'options': list_contents
},
},
'hidden': {
'widget': formish.Checkbox
},
'heading_tab': {
'widget': formish.Checkbox
},
'custom_view': {
'widget': formish.Input,
'kwargs': {
'empty': ''
},
},
})
def form_fields(self):
required = validator.Required()
min_pw_length = int(get_setting(self.context, 'min_pw_length', 6))
pwlen = validator.Length(min_pw_length)
username = karlvalidators.RegularExpression(
r'^[\w-]+$',
'Username must contain only letters, numbers, and dashes')
fields = [
('username',
schemaish.String(validator=validator.All(required, username))),
('password',
schemaish.String(validator=validator.All(required, pwlen))),
('password_confirm',
schemaish.String(validator=validator.All(required, pwlen))),
('firstname', schemaish.String(validator=required)),
('lastname', schemaish.String(validator=required)),
('phone', schemaish.String()),
('extension', schemaish.String()),
('organization', schemaish.String()),
(
'country',
schemaish.String(validator=validator.All(
validator.OneOf(countries.as_dict.keys()),
validator.Required()), ),
),
('location', schemaish.String()),
('department', schemaish.String()),
('position', schemaish.String()),
('websites',
schemaish.Sequence(schemaish.String(validator=validator.URL()))),
('languages', schemaish.String()),
('biography', schemaish.String()),
('photo', schemaish.File()),
('date_format',
schemaish.String(
validator=validator.OneOf(cultures.as_dict.keys()))),
]
r = queryMultiAdapter((self.context, self.request),
IInvitationBoilerplate)
if r is None:
r = DefaultInvitationBoilerplate(self.context)
if r.terms_and_conditions:
fields.append(('terms_and_conditions',
schemaish.Boolean(validator=validator.Equal(True))))
if r.privacy_statement:
fields.append(('accept_privacy_policy',
schemaish.Boolean(validator=validator.Equal(True))))
return fields
def test_sequenceboolean_string_conversion(self):
type = schemaish.Sequence(schemaish.Boolean())
value = [True, False, True, True]
expected = 'True,False,True,True'
actual = string_converter(type).from_type(value)
self.assertEquals(actual, expected)
value, expected = expected, value
actual = string_converter(type).to_type(value)
self.assertEquals(actual, expected)
class SignupSchema(schemaish.Structure):
login = schemaish.String(validator=validator.All(
validator.Required(), validator.Length(min=5, max=32),
validator.PlainText(), form.AvailableLogin()))
password = schemaish.String(validator=validator.All(
validator.Required(), validator.Length(min=5, max=255)))
email = schemaish.String(
validator=validator.All(validator.Required(), validator.Length(
max=255), validator.Email()))
firstname = schemaish.String(validator=validator.Length(max=255))
surname = schemaish.String(validator=validator.Length(max=255))
terms = schemaish.Boolean(validator=form.MustAgree())
def test_boolean_string_conversion(self):
type = schemaish.Boolean()
value = True
expected = 'True'
actual = string_converter(type).from_type(value)
self.assertEquals(actual, expected)
value, expected = expected, value
actual = string_converter(type).to_type(value)
self.assertEquals(actual, expected)
value = False
expected = 'False'
actual = string_converter(type).from_type(value)
self.assertEquals(actual, expected)
value, expected = expected, value
actual = string_converter(type).to_type(value)
self.assertEquals(actual, expected)
class PageStructure(BaseStructure):
body = schemaish.String()
hidden = schemaish.Boolean()
_widgets = copy.copy(BaseStructure._widgets)
_widgets.update({
'body': {
'widget': formish.TextArea,
'args': [],
'kwargs': {
'cols': 80,
'rows': 25,
'empty': ''
},
},
'hidden': {
'widget': formish.Checkbox
},
})
def sample_form(request):
import logging
log = logging.getLogger(__name__)
schema = schemaish.Structure()
schema.add('email', schemaish.String())
# schema.add('birthday', schemaish.Date())
schema.add('textarea', schemaish.String())
schema.add('country', schemaish.String())
schema.add('accept', schemaish.Boolean())
form = formish.Form(schema, name="uni-form", renderer=pyramid_formish.get_default_renderer())
form['email'].description = u'Your e-mail address.'
# form['birthday'].widget = formish.DateParts()
form['textarea'].widget = formish.TextArea()
form['country'].widget = formish.SelectChoice(options=['UK', 'US'])
form['accept'].description = u'Do you accept?'
form['accept'].widget = formish.Checkbox()
try:
form.validate(request)
except formish.FormError, e:
log.debug(e)
from karl.content.models.wiki import WikiPage
from karl.content.views.utils import extract_description
from karl.security.workflow import get_security_states
_wiki_text_help = """You can create a new page by naming it and surrounding
the name with ((double parentheses)). When you save the page, the contents
of the parentheses will have a small + link next to it, which you can click
to create a new page with that name."""
tags_field = schemaish.Sequence(schemaish.String())
text_field = schemaish.String(
title='Body text',
description=_wiki_text_help,
)
sendalert_field = schemaish.Boolean(
title='Send email alert to community members?')
security_field = schemaish.String(
description=('Items marked as private can only be seen by '
'members of this community.'))
def redirect_to_front_page(context, request):
front_page = context['front_page']
location = resource_url(front_page, request)
return HTTPFound(location=location)
def redirect_to_add_form(context, request):
return HTTPFound(
location=resource_url(context, request, 'add_wikipage.html'))
keywords_widget = widgets.SequenceTextAreaWidget(cols=20)
weight_options = [
(-1, 'Less important'), # I bet no one ever uses this one.
(0, 'Normal'),
(1, 'More important'),
(2, 'Much more important'),
]
weight_widget = formish.SelectChoice(
options=weight_options,
none_option=None,
)
unlock_field = schemaish.Boolean(
title='Force unlock',
description='This wiki page is currently locked. Force unlock it.',
)
class UnlockWidget(widgets.Checkbox):
checkbox_label = 'Unlock'
unlock_widget = UnlockWidget()
class AdvancedFormController(object):
def __init__(self, context, request):
self.context = context
self.request = request
text_field = schemaish.String(
description=('This text will appear on the Overview page for this '
'community. You can use this to describe the '
'community or to make a special announcement.'))
tools_field = schemaish.Sequence(
attr=schemaish.String(),
description = 'Select which tools to enable on this community.')
default_tool_field = schemaish.String(
description=(
'This is the first page people see when they view this '
'community.'))
sendalert_default_field = schemaish.Boolean(
description=('Send alerts by default on content creation?'))
def shared_fields():
return [
('tags', tags_field),
('description', description_field),
('text', text_field),
('tools', tools_field)
]
def shared_widgets(context):
return {
'title':formish.Input(empty=''),
'description': formish.TextArea(cols=60, rows=10, empty=''),
'text':karlwidgets.RichTextWidget(empty=''),
'tools':formish.CheckboxMultiChoice(options=context.tools)
return render_to_response(
'templates/show_comment.pt',
dict(api=api,
actions=actions,
byline_info=byline_info,
attachments=attachments,
backto=backto,
old_layout=layout),
request=request,
)
add_comment_field = schemaish.String(
title='Add Comment',
description='Enter your comments below.')
sendalert_field = schemaish.Boolean(
title='Email alert')
attachments_field = schemaish.Sequence(schemaish.File(),
title='Attachments',
)
class AddCommentFormController(object):
def __init__(self, context, request):
self.context = context
self.request = request
self.filestore = get_filestore(context, request, 'comment')
self.show_sendalert = get_show_sendalert(context, request)
def form_defaults(self):
if self.show_sendalert:
return {'sendalert': True}
return {}
return widgets
class EditReportFilterFormController(EditBase):
page_title = 'Edit Report Filter'
schema = report_filter_schema
def form_widgets(self, schema):
widgets = {
'values':
formish.TextArea(rows=5, converter_options={'delimiter': '\n'}),
}
return widgets
is_staff_schema = [('include_staff', schemaish.Boolean())]
class AddIsStaffReportFilterFormController(AddBase):
page_title = 'Add IsStaff Report Filter'
schema = is_staff_schema
factory = PeopleReportIsStaffFilter
def form_widgets(self, schema):
widgets = {'include_staff': formish.Checkbox()}
return widgets
class EditIsStaffReportFilterFormController(EditBase):
page_title = 'Edit Report Filter'
schema = is_staff_schema
class QueryViewStructure(BaseStructure):
find_kind = schemaish.String(validator=validatish.Required())
body = schemaish.String()
hidden = schemaish.Boolean()
reparent = schemaish.Boolean()
filters = schemaish.String()
order_by = schemaish.String()
group_by = schemaish.String()
custom_view = schemaish.String()
_widgets = copy.copy(BaseStructure._widgets)
_widgets.update({
'body': {
'widget': formish.TextArea,
'args': [],
'kwargs': {
'cols': 80,
'rows': 25,
'empty': ''
},
},
'hidden': {
'widget': formish.Checkbox
},
'reparent': {
'widget': formish.Checkbox
},
'filters': {
'widget': formish.TextArea,
'args': [],
'kwargs': {
'cols': 80,
'rows': 5,
'empty': ''
},
},
'order_by': {
'widget': formish.TextArea,
'args': [],
'kwargs': {
'cols': 80,
'rows': 5,
'empty': ''
},
},
'group_by': {
'widget': formish.TextArea,
'args': [],
'kwargs': {
'cols': 80,
'rows': 5,
'empty': ''
},
},
'find_kind': {
'widget': formish.SelectChoice,
'kwargs': {
'options': list_query_types,
},
}
})
