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
class FileStructure(BaseStructure):
file = schemaish.File()
_widgets = copy.copy(BaseStructure._widgets)
_widgets.update({
'file': {
'widget': formish.FileUpload,
'args': [
MemcacheFileStore,
],
'kwargs': {
'show_download_link': False,
'url_base': ''
}
}
})
def test_file_string_converstion(self):
# Just for my sanity.
FileType = schemaish.type.File
# Reference type.
type = schemaish.File()
# Check that it can't be converted without a file-like.
self.assertRaises(ValueError,
string_converter(type).from_type,
FileType(None, None, None))
# Check that the file-likes content are returned.
self.assertTrue(
string_converter(type).from_type(
FileType(StringIO('foo'), None, None)) == 'foo')
# Check that a string is converted to a file.
file = string_converter(type).to_type('foo')
self.assertTrue(file.mimetype == 'text/plain')
self.assertTrue(file.filename == 'content.txt')
self.assertTrue(file.file.read() == 'foo')
def test_thumbnail_sizing(self):
schema = schemaish.Structure()
schema.add('foo', schemaish.File())
basic_form = formish.Form(schema)
basic_form['foo'].widget = formish.FileUpload(
image_thumbnail_default='/images/blank.png',
show_image_thumbnail=True)
advanced_form = formish.Form(schema)
advanced_form['foo'].widget = formish.FileUpload(
thumbnail_size="40x40",
image_thumbnail_default='/images/blank.png',
show_image_thumbnail=True)
html = basic_form()
assert 'foo' in html
assert '/images/blank.png?size=20x20' in html
html = advanced_form()
assert 'foo' in html
assert '/images/blank.png?size=40x40' in html
class CompanySchema(schemaish.Structure):
name = schemaish.String(validator=validator.Required())
address1 = schemaish.String(validator=validator.Required())
address2 = schemaish.String()
address3 = schemaish.String()
postal_code = schemaish.String(validator=validator.Required())
city = schemaish.String(validator=validator.Required())
# Todo: provide a vocabulary with countries including country codes: used in combination with
# postal code: CH-6004 Luzern
country = schemaish.String()
e_mail = schemaish.String(validator=validator.Required())
phone = schemaish.String(validator=validator.Required())
logo = schemaish.File(validator=FileMimetypeValidator(['image/jpeg']),
description=".jpg / 70mm x 11mm / 300dpi")
hourly_rate = schemaish.Float(validator=validator.Required())
daily_rate = schemaish.Float(validator=validator.Required())
tax = schemaish.Float(validator=validator.Required())
vat_number = schemaish.String()
iban = schemaish.String()
swift = schemaish.String()
bank_address = schemaish.String()
invoice_start_number = schemaish.Integer()
invoice_template = schemaish.String(validator=validator.Required())
post_url=post_url,
byline_info=byline_info,
backto=backto,
security_states=security_states,
)
tags_field = schemaish.Sequence(schemaish.String())
text_field = schemaish.String()
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.'))
attachments_field = schemaish.Sequence(
schemaish.File(),
title='Attachments',
)
class AddBlogEntryFormController(object):
def __init__(self, context, request):
self.context = context
self.request = request
self.workflow = get_workflow(IBlogEntry, 'security', context)
self.filestore = get_filestore(context, request, 'add-blogentry')
def _get_security_states(self):
return get_security_states(self.workflow, None, self.request)
def form_defaults(self):
dict(api = api,
actions = actions,
title = context.title,
topics = topics,
batch_info = topic_batch,
backto=backto,
old_layout=layout),
request=request,
)
tags_field = schemaish.Sequence(schemaish.String())
text_field = schemaish.String()
security_field = schemaish.String(
description=('Items marked as private can only be seen by '
'members of this community.'))
attachments_field = schemaish.Sequence(schemaish.File(),
title='Attachments',
)
title_field = schemaish.String(
validator=validator.All(
validator.Length(max=100),
validator.Required(),
)
)
description_field = schemaish.String(
validator=validator.Length(max=500),
description=("This description will appear in search "
"results and on the community listing page. Please "
"limit your description to 100 words or less.")
)
firstname_field = schemaish.String(validator=validator.Required(),
title='First Name')
lastname_field = schemaish.String(validator=validator.Required(),
title='Last Name')
phone_field = schemaish.String(title='Phone Number')
extension_field = schemaish.String()
fax_field = schemaish.String(title='Fax Number')
department_field = schemaish.String()
position_field = schemaish.String()
organization_field = schemaish.String()
location_field = schemaish.String()
country_field = schemaish.String(validator=validator.Required())
websites_field = schemaish.Sequence(
schemaish.String(validator=karlvalidators.WebURL()))
languages_field = schemaish.String()
photo_field = schemaish.File()
biography_field = schemaish.String()
date_format_field = schemaish.String(title='Preferred Date Format')
class EditProfileFormController(object):
"""
Formish controller for the profile edit form. Also the base class
for the controllers for the admin profile edit and add user forms.
"""
simple_field_names = [
"firstname",
"lastname",
"email",
"phone",
"extension",
class BaseInvitationFormController(object):
fields = {
'firstname':
schemaish.String(validator=validator.Required()),
'lastname':
schemaish.String(validator=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()))
}
def __init__(self, context, request):
self.context = context
self.request = request
self.profiles = find_profiles(context)
self.api = TemplateAPI(context, request)
self.filestore = get_filestore(context, request, 'accept-invitation')
@property
def description(self):
system_name = get_setting(self.context, 'title', 'KARL')
return ('You have been invited to join the "%s". Please begin '
'by creating a login with profile information.' % system_name)
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
def form_widgets(self, fields):
default_icon = self.api.static_url + '/images/defaultUser.gif'
system_name = get_setting(self.context, 'title', 'KARL')
widgets = {
'biography':
karlwidgets.RichTextWidget(),
'password':
formish.Password(),
'password_confirm':
formish.Password(),
'country':
formish.SelectChoice(countries),
'photo':
karlwidgets.PhotoImageWidget(filestore=self.filestore,
url_base=resource_url(
self.context, self.request,
'photo'),
image_thumbnail_default=default_icon),
'date_format':
formish.SelectChoice(cultures),
'websites':
formish.TextArea(rows=3, converter_options={'delimiter': '\n'}),
}
r = queryMultiAdapter((self.context, self.request),
IInvitationBoilerplate)
if r is None:
r = DefaultInvitationBoilerplate(self.context)
terms_text = r.terms_and_conditions
if terms_text:
widgets['terms_and_conditions'] = (karlwidgets.AcceptFieldWidget(
terms_text, 'the %s Terms and Conditions' % system_name))
privacy_text = r.privacy_statement
if privacy_text:
widgets['accept_privacy_policy'] = (karlwidgets.AcceptFieldWidget(
privacy_text, 'the %s Privacy Policy' % system_name))
return widgets
def handle_cancel(self):
return HTTPFound(location=resource_url(self.context, self.request))
def get_groups(self):
return []
def handle_submit(self, converted):
context = self.context
request = self.request
users = find_users(context)
profiles = self.profiles
password = converted['password']
password_confirm = converted['password_confirm']
if password != password_confirm:
msg = 'Mismatched password and confirm'
raise ValidationError(password_confirm=msg, password=msg)
username = converted['username']
if username in profiles:
raise ValidationError(username='******')
groups = self.get_groups()
users.add(username, username, password, groups)
remember_headers = remember(request, username)
data = dict(firstname=converted['firstname'],
lastname=converted['lastname'],
email=context.email)
for field_name in get_setting(self.context, 'member_fields'):
if field_name in self.fields:
data[field_name] = converted[field_name]
profile = create_content(IProfile, **data)
profiles[username] = profile
workflow = get_workflow(IProfile, 'security')
if workflow is not None:
workflow.initialize(profile)
try:
handle_photo_upload(profile, converted)
except Invalid, e:
raise ValidationError(**e.error_dict)
self.send_mail(username, profile)
url = self.get_redirect_url()
# delete it
del context.__parent__[context.__name__]
self.filestore.clear()
return HTTPFound(headers=remember_headers, location=url)
_NOW = None
def _now():
if _NOW is not None:
return _NOW
return datetime.datetime.now()
PHOTO_DISPLAY_SIZE = (400, 400
) # XXX Wild guess. Any idea what this should be?
tags_field = schemaish.Sequence(schemaish.String())
text_field = schemaish.String()
attachments_field = schemaish.Sequence(schemaish.File(), title='Attachments')
photo_field = schemaish.File()
caption_field = schemaish.String()
publication_date_field = karlattr.KarlDateTime(
validator=validator.All(validator.Required(), karlvalidator.DateTime()))
class AddNewsItemFormController(object):
def __init__(self, context, request):
self.context = context
self.request = request
self.filestore = get_filestore(context, request, 'newsitem')
page_title = getattr(self, 'page_title', 'Add News Item')
self.api = TemplateAPI(context, request, page_title)
# calculate locale for this user
locale = get_user_date_format(context, request)
