def test_select_with_options_obj(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name": "ValueFred"})
renderer = FormRenderer(form)
options = Options(
[
OptGroup("OptGroup", [Option(value="ValueOG", label="LabelOG")]),
Option(value="ValueFred", label="LabelFred"),
Option(value="ValueBarney", label="LabelBarney"),
Option(value="ValueWilma", label="LabelWilma"),
Option(value="ValueBetty", label="LabelBetty"),
]
)
self.assertTrue(
renderer.select("name", options)
== """<select id="name" name="name">
<optgroup label="OptGroup">
<option value="ValueOG">LabelOG</option>
</optgroup>
<option selected="selected" value="ValueFred">LabelFred</option>
<option value="ValueBarney">LabelBarney</option>
<option value="ValueWilma">LabelWilma</option>
<option value="ValueBetty">LabelBetty</option>
</select>"""
)
def test_textarea(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name": "Fred"})
renderer = FormRenderer(form)
self.assert_(renderer.textarea("name") == '<textarea id="name" name="name">Fred</textarea>')
def test_hidden(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name": "Fred"})
renderer = FormRenderer(form)
self.assert_(renderer.hidden("name") == '<input id="name" name="name" type="hidden" value="Fred" />')
def test_end_form(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assertEqual(renderer.end(), "</form>")
def test_end_form(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assertEqual(renderer.end(), "</form>")
def test_begin_form(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.begin(url="/"), '<form action="/" method="post">')
def reg(self):
title = 'Registration'
usertypes = userTypes()
states = get_states()
msg = ''
form = Form(self.request, schema=Registration)
if 'form_submitted' in self.request.POST and form.validate():
try:
resp = self.request.POST['g-recaptcha-response']
except:
self.request.session.flash(
'danger; Failed captcha due to slow network')
return HTTPFound(location=self.request.route_url('reg'))
recaptcha_r = requests.post(
recaptcha_endpoint,
dict(secret=buddy_settings('recaptcha_secret'), response=resp))
rdata = recaptcha_r.json()
if rdata:
if not rdata['success']:
msg = 'Failed recaptcha, please solve again'
return dict(form=FormRenderer(form),
msg=msg,
title=title,
usertypes=usertypes,
states=states)
user = form.bind(Users())
if 'ref_email' in self.request.session:
referrer = Users.get_by_email(
self.request.session['ref_email'])
if referrer:
user.parent_id = referrer.id
with transaction.manager:
DBSession.add(user)
user.prefix = create_path(user.user_fullname, is_unique)
DBSession.flush()
timestamp = time.time() + 3600
hmac_key = hmac.new(
'%s:%s:%d' %
(str(user.id), 'r5$55g35%4#$:l3#24&', timestamp),
user.email).hexdigest()[0:10]
time_key = base64.urlsafe_b64encode('%d' % timestamp)
email_hash = '%s%s' % (hmac_key, time_key)
user_regmail(self.request, user.id, user.email, email_hash)
headers = buddy_remember(self.request, user, event='R')
self.session.flash(
"success;You should be receiving an email with a link to activate your "
"account within 10 minutes. Doing so will let you post properties/blog on this website."
)
return HTTPFound(location=self.request.route_url('account'),
headers=headers)
return dict(form=FormRenderer(form),
title=title,
usertypes=usertypes,
msg=msg,
states=states)
def login_view(request):
"""
Perform a 'login' by getting the service document from a sword repository.
"""
templatePath = 'templates/login.pt'
config = load_config(request)
form = Form(request, schema=LoginSchema)
field_list = [
('username', ),
('password', ),
]
session = request.session
# validate the form in order to compute all errors
valid_form = form.validate()
request['errors'] = form.all_errors()
# Check for successful form completion
if 'form.submitted' in request.POST and valid_form:
if form.data['anonymous']:
login = AnonymousSession()
else:
login = auth(form.data['service_document_url'],
form.data['username'], form.data['password'])
if login is None:
request['errors'] = [
"Invalid username or password. Please try again.",
]
response = {
'form': FormRenderer(form),
'field_list': field_list,
'config': config,
}
return render_to_response(templatePath, response, request=request)
# The login details are persisted on the session.
if TESTING:
session['login'] = TestingSession()
else:
session['login'] = login
return HTTPFound(location=request.route_url('choose'))
elif 'login' in session:
return HTTPFound(location=request.route_url('choose'))
# If not signed in, go to login page
response = {
'form': FormRenderer(form),
'field_list': field_list,
'config': config,
}
return render_to_response(templatePath, response, request=request)
def return_slideshare_upload_form(request):
check_login(request)
session = request.session
redirect_to_google_oauth = False
form = Form(request, schema=ImporterChoiceSchema)
response = {'form':FormRenderer(form)}
username = session['login'].username
if form.validate():
original_filename = session['original_filename']
slideshow_id = None
if form.data['importer'] == 'slideshare':
slideshow_id = upload_to_slideshare("saketkc", original_filename)
session['slideshare_id'] = slideshow_id
if form.data['importer'] == 'google':
if session.has_key('slideshare_oauth'):
# RETURNING USER
redirect_to_google_oauth = False
oauth_token = session['slideshare_oauth']["oauth_token"]
oauth_secret = session['slideshare_oauth']["oauth_secret"]
guploader = GooglePresentationUploader()
guploader.authentincate_client_with_oauth2(oauth_token,oauth_secret)
guploader.upload(original_filename)
guploader.get_first_revision_feed()
guploader.publish_presentation_on_web()
resource_id = guploader.get_resource_id().split(':')[1]
session['google-resource-id'] = resource_id
print "UPLOADING TO GOOGLE"
else:
print "NEW USER"
redirect_to_google_oauth = True
session['original-file-path'] = original_filename
uploaded_filename = session['uploaded_filename']
if slideshow_id is not None:
slideshare_details = get_details(slideshow_id)
cnxml = """\
<featured-links>
<!-- WARNING! The 'featured-links' section is read only. Do not edit below.
Changes to the links section in the source will not be saved. -->
<link-group type="supplemental">
<link url="""+ "\"" + uploaded_filename + "\""+""" strength="3">Download the original slides in PPT format</link>"""
if slideshow_id is not None:
cnxml += """<link url="""+ "\"" + get_slideshow_download_url(slideshare_details) + "\"" +""" strength="2">SlideShare PPT Download Link</link>"""
cnxml += """\
</link-group>
<!-- WARNING! The 'featured-links' section is read only. Do not edit above.
Changes to the links section in the source will not be saved. -->
</featured-links>"""
session['cnxml'] += cnxml
if redirect_to_google_oauth:
raise HTTPFound(location=request.route_url('google_oauth'))
raise HTTPFound(location=request.route_url('enhance'))
return {'form' : FormRenderer(form),'conversion_flag': False, 'oembed': False}
def test_label(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assertTrue(renderer.label("name") == '<label for="name">Name</label>')
def test_hidden(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name": "Fred"})
renderer = FormRenderer(form)
self.assert_(renderer.hidden("name") == \
'<input id="name" name="name" type="hidden" value="Fred" />')
def test_begin_form(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.begin(url="/"),
'<form action="/" method="post">')
def test_label_using_field_name(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.label("name", "Your name") == '<label for="name">Your name</label>')
def test_textarea(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name": "Fred"})
renderer = FormRenderer(form)
self.assert_(renderer.textarea("name") == \
'<textarea id="name" name="name">Fred</textarea>')
def test_password(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.password("password") == '<input id="password" name="password" type="password" />')
def test_file(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.file("file") == '<input id="file" name="file" type="file" />')
def test_csrf(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleSchema)
renderer = FormRenderer(form)
self.assert_(renderer.csrf() == \
'<input id="_csrf" name="_csrf" type="hidden" value="csrft" />')
def test_csrf(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assertEqual(renderer.csrf(),
'<input id="_csrf" name="_csrf" type="hidden" value="0123456789012345678901234567890123456789" />')
def test_checkbox(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name" : True})
renderer = FormRenderer(form)
self.assert_(renderer.checkbox("name") == \
'<input checked="checked" id="name" name="name" type="checkbox" '
'value="1" />')
def test_submit(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.submit("submit", "Submit") == \
'<input id="submit" name="submit" type="submit" value="Submit" />')
def test_label_using_field_name(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.label("name", "Your name") == \
'<label for="name">Your name</label>')
def test_submit(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.submit("submit", "Submit") == \
'<input id="submit" name="submit" type="submit" value="Submit" />')
def test_checkbox(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name": True})
renderer = FormRenderer(form)
self.assert_(renderer.checkbox("name") == \
'<input checked="checked" id="name" name="name" type="checkbox" '
'value="1" />')
def test_password(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.password('password') == \
'<input id="password" name="password" type="password" />')
def test_csrf_token(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.csrf_token() == \
'<div style="display:none;"><input id="_csrf" name="_csrf" '
'type="hidden" value="0123456789012345678901234567890123456789" /></div>')
def test_file(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.file('file') == \
'<input id="file" name="file" type="file" />')
def test_csrf_token(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assert_(renderer.csrf_token() == \
'<div style="display:none;"><input id="_csrf" name="_csrf" '
'type="hidden" value="0123456789012345678901234567890123456789" /></div>')
def test_date(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
import datetime
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={
"when" : datetime.date(2014, 02, 01) })
renderer = FormRenderer(form)
self.assert_(renderer.date("when", date_format="%d/%m/%Y") == \
'<input id="when" name="when" type="text" value="01/02/2014" />')
def test_csrf(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assertEqual(
renderer.csrf(),
'<input id="_csrf" name="_csrf" type="hidden" value="0123456789012345678901234567890123456789" />'
)
def test_hidden_tag_with_just_csrf(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleSchema)
renderer = FormRenderer(form)
self.assert_(renderer.hidden_tag() == \
'<div style="display:none;"><input id="_csrf" name="_csrf" '
'type="hidden" value="csrft" /></div>')
def test_is_error(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
request.method = "POST"
form = Form(request, SimpleFESchema)
self.assert_(not(form.validate()))
renderer = FormRenderer(form)
self.assert_(renderer.is_error('name'))
def test_hidden_tag_with_csrf_and_other_names(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={'name': 'foo'})
renderer = FormRenderer(form)
self.assert_(renderer.hidden_tag('name') == \
'<div style="display:none;"><input id="name" name="name" '
'type="hidden" value="foo" /><input id="_csrf" name="_csrf" '
'type="hidden" value="0123456789012345678901234567890123456789" /></div>')
def test_is_error(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
request.method = "POST"
form = Form(request, SimpleFESchema)
self.assert_(not (form.validate()))
renderer = FormRenderer(form)
self.assert_(renderer.is_error('name'))
def test_hidden_tag_with_csrf_and_other_names(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={'name':'foo'})
renderer = FormRenderer(form)
self.assert_(renderer.hidden_tag('name') == \
'<div style="display:none;"><input id="name" name="name" '
'type="hidden" value="foo" /><input id="_csrf" name="_csrf" '
'type="hidden" value="0123456789012345678901234567890123456789" /></div>')
def test_errors_for(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
request.method = "POST"
form = Form(request, SimpleFESchema)
self.assert_(not (form.validate()))
renderer = FormRenderer(form)
self.assert_(renderer.errors_for("name") == ["Missing value"])
def test_errorlist_with_field(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
request.method = "POST"
form = Form(request, SimpleFESchema)
form.validate()
renderer = FormRenderer(form)
self.assertEqual(renderer.errorlist("name"), '<ul class="error"><li>Missing value</li></ul>')
def test_checkbox_checked(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema)
renderer = FormRenderer(form)
self.assertTrue(renderer.checkbox("name") == '<input id="name" name="name" type="checkbox" ' 'value="1" />')
self.assertTrue(
renderer.checkbox("name", checked=True) == '<input checked="checked" id="name" name="name" type="checkbox" '
'value="1" />'
)
def test_errorlist_with_no_errors(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
request.method = "POST"
request.POST['name'] = 'test'
form = Form(request, SimpleFESchema)
form.validate()
renderer = FormRenderer(form)
self.assert_(renderer.errorlist() == '')
def test_errorlist_with_field(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
request.method = "POST"
form = Form(request, SimpleFESchema)
form.validate()
renderer = FormRenderer(form)
self.assertEqual(renderer.errorlist('name'),
'<ul class="error"><li>Missing value</li></ul>')
def test_errorlist_with_no_errors(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
request.method = "POST"
request.POST['name'] = 'test'
form = Form(request, SimpleFESchema)
form.validate()
renderer = FormRenderer(form)
self.assert_(renderer.errorlist() == '')
def settings_view(request):
"""docstring for settings_view"""
master = get_renderer('templates/master.pt').implementation()
tracs = None
users = None
formdata = Formdata()
if request.params:
tracs = request.params.getall("tracs")[0]
users = request.params.getall("users")[0]
formdata.tracs = formdata.form_parser(tracs)
formdata.users = formdata.form_parser(users)
with open("sql/tracs", "w") as file:
pickle.dump(formdata.tracs, file)
with open("sql/users", "w") as file:
pickle.dump(formdata.users, file)
with open("sql/tracs") as file:
tracs = pickle.load(file)
with open("sql/users") as file:
users = pickle.load(file)
tracs = formdata.create_text(tracs)
users = formdata.create_text(users)
formdata.tracs = tracs or None
formdata.users = users or None
form = Form(request)
return dict(master=master, renderer=FormRenderer(form), formdata=formdata)
def edit(request):
settings = load_settings()
my = MySetting()
for setting in settings:
if setting.valuex:
my.__dict__[setting.name] = setting.valuex
else:
my.__dict__[setting.name] = setting.value
form = Form(request, schema=SettingSchema, obj=my)
if form.validate():
form.bind(my)
# persist model somewhere...
for setting in settings:
if setting.name == "motion_id_prefix":
update_setting(setting.name, my.motion_id_prefix)
if setting.name == "admin_password":
update_setting(setting.name, my.admin_password)
if setting.name == "user_password":
update_setting(setting.name, my.user_password)
if setting.name == "mail_sender":
update_setting(setting.name, my.mail_sender)
if setting.name == "mail_smtppassword":
update_setting(setting.name, my.mail_smtppassword)
if setting.name == "mail_template":
update_setting(setting.name, "", my.mail_template)
return HTTPFound(location=route_path("setting_edit", request))
return dict(renderer=FormRenderer(form))
def text(self, name, value=None, id=None, **attrs):
kw = {"maxlength": 200, "size": const.TEXT_SIZE}
kw.update(attrs)
if kw["size"] is not None:
kw["size"] = min((kw["maxlength"] + 1, kw["size"]))
return FormRenderer.text(self, name, value, self._fix_id(id or name),
**kw)
def index(self):
form = Form(self.request)
params = self.request.params
protype = params.get('type','')
location = params.get('cities_auto','')
name = params.get('name','')
users = DBSession.query(Users)
if protype:
users = users.join(User_types).filter(User_types.id==protype)
if location and name:
st = State.get_by_name(location)
name="%"+name+"%"
filters = or_(Users.fullname.like(name),Users.company_name.like(name))
users = users.filter(Users.state_id==st.id).filter(filters)
if location and not name:
st = State.get_by_name(location)
users = users.filter(Users.state==st)
if name and not location:
namelike="%"+name+"%"
filters = or_(Users.fullname.like(namelike),Users.company_name.like(namelike))
users = users.filter(filters)
users = users.filter(and_(Users.email!=u'*****@*****.**',Users.email!=u'*****@*****.**')).order_by((Users.photo!=None).desc()).all()
page_url = PageURL_WebOb(self.request)
paginator = Page(users,
page=int(self.request.params.get("page", 1)),
items_per_page=12,
url=page_url)
return dict(title="Nairabricks Real Estate Professionals",
name = name,
location = location,
protype= protype,
form = FormRenderer(form),paginator=paginator)
def view_signup(self):
""" Register view for new users that aren't signed up yet """
username = get_param(self.request, 'username')
email = get_param(self.request, 'email')
password = u''
# Create form by using schemas with validations
form = Form(self.request, schema=SignUpSchema,
state=State(request=self.request))
if form.validate():
username = self.request.params['username']
password = self.request.params['password']
email = self.request.params['email']
get_resource('users', self.request).add(username,
password, email)
get_resource('groups', self.request).add(username,
group_names['member'])
get_resource('groups', self.request).add(username,
u'u:%s' % username)
self.message = msg['succeed_add_user'] + " " + username
_dict = {
'url': self.request.application_url + '/signup',
'username': username,
'email': email,
'password': password,
'form': FormRenderer(form),
'params': self.request.params,
'message': self.message
}
return dict(self.base_dict.items() + _dict.items())
def view_blog_edit(self):
form = Form(self.request, schema=BlogCreateSchema,
state=State(request=self.request))
blogname = get_param(self.request, 'blogname', self.context.name)
text = get_param(self.request, 'text', self.context.description)
image_url = get_param(self.request, 'image_url',
self.context.image_url)
if form.validate():
self.context.name = blogname
self.context.description = text
self.context.image_url = image_url
self.message = msg['saved']
cbs = [p for p in self.request.params.keys()
if u'checkbox' in p]
# check all the checkbox-parameters and
# parse them
for cb in cbs:
item = self.request.params[cb]
self.context.remove(item)
self.message = msg['items_removed']
_dict = {
'form': FormRenderer(form),
'message': self.message,
'blogname': blogname,
'text': text,
'image_url': image_url
}
return dict(self.base_dict.items() + _dict.items())
def view_user_edit(self):
""" View for editing a single user """
form = Form(self.request, schema=UserEditSchema,
state=State(request=self.request))
self.error_message = None
if form.validate():
password = self.request.params['password']
if self.context.validate_password(password):
if self.request.params['new_password']:
password = self.request.params['new_password']
self.message = 'Successfully saved'
email = self.request.params['email']
self.context.edit(password, email)
else:
self.error_message = msg['password_invalid']
_dict = {
'username': self.context.username,
'form': FormRenderer(form),
'email': self.context.email,
'message': self.message,
'error_message': self.error_message
}
return dict(self.base_dict.items() + _dict.items())
def login_view(request):
""" Render the login form.
Display an empty login form or check the submited credentials with the ones
from the database. Add a success flash message, an userid in the cookies
and redirect to the home page if the credentials are goods. Add an error
flash message and display again the login form if the credentials are
wrong.
:param request: a ``pyramid.request`` object
"""
_ = request.translate
form = Form(request, schema=LoginForm)
if 'form_submitted' in request.params and form.validate():
username = request.params['username']
password = request.params['password']
if AuthUser.check_password(username, password):
auth_user = AuthUser.get_by_username(username)
headers = remember(request, auth_user.user_id)
request.session.flash(_(u"Successful login."), 'success')
return HTTPFound(location=request.route_path('home'),
headers=headers)
else:
request.session.flash(_(u"Check your login credentials!"), 'error')
return dict(renderer=FormRenderer(form))
def user_add(request):
form = Form(request, schema=RegistrationSchema)
if 'form.submitted' in request.POST and form.validate():
session = DBSession()
username = form.data['username']
user = User(username=username,
password=form.data['password'],
name=form.data['name'],
email=form.data['email'])
session.add(user)
headers = remember(request, username)
redirect_url = route_url('main', request)
return HTTPFound(location=redirect_url, headers=headers)
login_form = login_form_view(request)
return {
'form': FormRenderer(form),
'toolbar': toolbar_view(request),
'cloud': cloud_view(request),
'latest': latest_view(request),
'login_form': login_form,
}
def view_files(self):
self.require_verification()
form = Form(self.request, schema=forms.UploadFileSchema)
with utils.db_session(self.dbmaker) as session:
user = session.query(User).filter(User.username==self.username).first()
current_upload_size = sum([f.size for f in user.files])
username = user.username
owned_files = dict()
shared_files = dict()
for f in user.files:
shared_with = [k.user.username for k in f.keys]
owned_file = dict(shared=shared_with, uploaded_at=f.uploaded_at, size=f.size)
owned_files[f.name] = owned_file
shared_files[f.name] = dict(size=f.size, owner=f.owner.username)
sharable_users = session.query(User).filter(User.sharable==True)
sharable_users = sharable_users.filter(User.username!=self.username).all()
sharable_users = [u.username for u in sharable_users]
return dict(
current_upload_size=current_upload_size,
form=FormRenderer(form),
username=username,
uploaded_files=owned_files,
sharable_users=sharable_users,
shared_files=shared_files
)
def test_radio(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name": 'Fred'})
renderer = FormRenderer(form)
self.assert_(renderer.radio("name", value="Fred") == \
'<input checked="checked" id="name_fred" name="name" '
'type="radio" value="Fred" />')
self.assert_(renderer.radio("name", value="Barney") == \
'<input id="name_barney" name="name" '
'type="radio" value="Barney" />')
def test_radio(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name" : 'Fred'})
renderer = FormRenderer(form)
self.assert_(renderer.radio("name", value="Fred") == \
'<input checked="checked" id="name_fred" name="name" '
'type="radio" value="Fred" />')
self.assert_(renderer.radio("name", value="Barney") == \
'<input id="name_barney" name="name" '
'type="radio" value="Barney" />')
def password_edit_view(request):
""" Render the change password form page.
Seek the database for the user datas based on user_id used in the route. If
the user did not exist then add an error flash message and redirect to the
user list.
If the user exist then render an empty password form. If the form is
validated then change the user password in the database and add
success flash message. If the form is not valid, then display again the
form with validation errors.
:param request: a ``pyramid.request`` object
"""
_ = request.translate
user_id = request.matchdict['user_id']
user = AuthUser.get_by_id(user_id)
if not user:
request.session.flash(_(u"This user did not exist!"), 'error')
return HTTPFound(location=request.route_path('tools.user_list'))
form = Form(request, schema=UserPasswordForm, obj=user)
if 'form_submitted' in request.params and form.validate():
form.bind(user)
DBSession.add(user)
request.session.flash(_(u"Password updated."), 'success')
return HTTPFound(location=request.route_path('tools.user_list'))
return dict(renderer=FormRenderer(form))
def test_errorlist_with_custom_localizer(self):
from pyramid_simpleform import Form
from pyramid_simpleform import State
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
request.method = "POST"
state = State(_=lambda s: s.upper())
form = Form(request, SimpleFESchema, state=state)
form.validate()
renderer = FormRenderer(form)
self.assertEqual(renderer.errorlist("name"), '<ul class="error"><li>MISSING VALUE</li></ul>')
def textarea(self, name, value=None, id=None, **attrs):
value = self.value(name, value) or ''
if value:
rows = len(value) // (const.TEXTAREA_COLS - 20) + const.TEXTAREA_ROWS_LONG
else:
rows = const.TEXTAREA_ROWS_LONG
kw = {'cols': const.TEXTAREA_COLS, 'rows': rows}
kw.update(attrs)
return FormRenderer.textarea(self, name, value, id, **kw)
def test_select(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name": "Fred"})
renderer = FormRenderer(form)
options = [("Fred", "Fred"), ("Barney", "Barney"), ("Wilma", "Wilma"), ("Betty", "Betty")]
self.assert_(
renderer.select("name", options)
== """<select id="name" name="name">
<option selected="selected" value="Fred">Fred</option>
<option value="Barney">Barney</option>
<option value="Wilma">Wilma</option>
<option value="Betty">Betty</option>
</select>"""
)
def textarea(self, name, value=None, id=None, **attrs):
default_rows = attrs.pop('default_rows', const.TEXTAREA_ROWS_SHORT)
max_rows = attrs.pop('max_rows', None)
value = self.value(name, value) or ''
if value:
rows = len(value) // (const.TEXTAREA_COLS - 20) + default_rows
if max_rows:
rows = min([rows, max_rows])
else:
rows = default_rows
kw = {'cols': const.TEXTAREA_COLS, 'rows': rows}
kw.update(attrs)
return FormRenderer.textarea(self, name, value, self._fix_id(id or name), **kw)
def test_select_webhelpers1_compatible(self):
from pyramid_simpleform import Form
from pyramid_simpleform.renderers import FormRenderer
request = testing.DummyRequest()
form = Form(request, SimpleFESchema, defaults={"name": "Fred"})
renderer = FormRenderer(form)
self.assertTrue(
renderer.select("currency", [["$", "Dollar"], ["DKK", "Kroner"]], "$")
== """<select id="currency" name="currency">
<option selected="selected" value="$">Dollar</option>
<option value="DKK">Kroner</option>
</select>"""
)
self.assertTrue(
renderer.select("cc", ["VISA", "MasterCard"], "MasterCard", id="cc", class_="blue")
== """<select class="blue" id="cc" name="cc">
<option value="VISA">VISA</option>
<option selected="selected" value="MasterCard">MasterCard</option>
</select>"""
)
self.assertTrue(
renderer.select("cc", ["VISA", "MasterCard", "Discover"], ["VISA", "Discover"])
== """<select id="cc" name="cc">
<option selected="selected" value="VISA">VISA</option>
<option value="MasterCard">MasterCard</option>
<option selected="selected" value="Discover">Discover</option>
</select>"""
)
self.assertTrue(
renderer.select("currency", [["$", "Dollar"], ["DKK", "Kroner"]], None, prompt="Please choose ...")
== """<select id="currency" name="currency">
<option selected="selected" value="">Please choose ...</option>
<option value="$">Dollar</option>
<option value="DKK">Kroner</option>
</select>"""
)
try:
if isinstance(long, type):
self.assertTrue(
renderer.select("privacy", [(1, "Private"), (2, "Semi-public"), (3, "Public")], long(3))
== """<select id="privacy" name="privacy">
<option value="1">Private</option>
<option value="2">Semi-public</option>
<option selected="selected" value="3">Public</option>
</select>"""
)
except NameError:
self.assertTrue(
renderer.select("privacy", [(1, "Private"), (2, "Semi-public"), (3, "Public")], 3)
== """<select id="privacy" name="privacy">
<option value="1">Private</option>
<option value="2">Semi-public</option>
<option selected="selected" value="3">Public</option>
</select>"""
)
self.assertTrue(
renderer.select(
"recipients",
[([("u1", "User1"), ("u2", "User2")], "Users"), ([("g1", "Group1"), ("g2", "Group2")], "Groups")],
None,
)
== """<select id="recipients" name="recipients">
<optgroup label="Users">
<option value="u1">User1</option>
<option value="u2">User2</option>
</optgroup>
<optgroup label="Groups">
<option value="g1">Group1</option>
<option value="g2">Group2</option>
</optgroup>
</select>"""
)
def text(self, name, value=None, id=None, **attrs):
kw = {'maxlength': 200, 'class_': 'text'}
kw.update(attrs)
return FormRenderer.text(self, name, value, id, **kw)
def text(self, name, value=None, id=None, **attrs):
kw = {'maxlength': 200, 'size': const.TEXT_SIZE}
kw.update(attrs)
kw['size'] = min((kw['maxlength']+1, kw['size']))
return FormRenderer.text(self, name, value, self._fix_id(id or name), **kw)
