def test_invalid_email_addresses():
invalid_usernames = [
# (email, message_name),
('foo\tbar', 'formencode.org', 'badUsername'),
('foo\nbar', 'formencode.org', 'badUsername'),
('test', '', 'noAt'),
('test', 'foobar', 'badDomain'),
('test', 'foobar.5', 'badDomain'),
('test', 'foo..bar.com', 'badDomain'),
('test', '.foo.bar.com', 'badDomain'),
('foo,bar', 'formencode.org', 'badUsername'),
]
def expected_message(validator, message_name, username, domain):
email = '@'.join((username, domain))
return validator.message(message_name,
email,
username=username,
domain=domain)
validator = Email()
for username, domain, message_name in invalid_usernames:
email = '@'.join(el for el in (username, domain) if el)
error = _validate(validator, email)
expected = expected_message(validator, message_name, username, domain)
yield assert_equal, error, expected
class UsuarioEditFormValidator(UsuarioAddFormValidator):
nombre_usuario = None
password = None
repita_password = None
nuevo_password = PasswordChanged()
repita_nuevo_password = PasswordChanged()
email = All(
UniqueEditEmail(),
Email(not_empty=True,
messages={
'empty': 'Ingrese una direccion de email',
'noAt': 'Un email debe contener un @',
'badUsername': '******',
'badDomain': 'Ingrese un dominio de email correcto',
}))
chained_validators = (FieldsMatch(
'nuevo_password',
'repita_nuevo_password',
messages={'invalidNoMatch': 'Passwords no coinciden'}), )
nro_documento = All(
UniqueEditNroDocumento(),
String(
min=5,
max=50,
messages={
'tooShort':
"Nro de Documendo invalido, debe tener 5 digitos como minimo",
'tooLong': "Nro de Documendo invalido",
}), NotEmpty(messages={'empty': 'Ingrese numero de documento'}),
isInt(messages={'integer': 'Ingrese un numero'}))
class UserResetPasswordForm(Schema):
"""Schema for User password reset form."""
chained_validators = [FieldsMatch('password', 'confirm')]
email = Email(not_empty=True)
password = UnicodeString(min=6)
confirm = UnicodeString(not_empty=True)
token = UnicodeString(not_empty=True)
class UserCreateSchema(Schema):
"""Schema for User create (fields may not be missing)."""
email = Email(max=255, not_empty=True)
password = UnicodeString(min=6)
role = OneOf(('user', 'superuser', 'admin'), if_missing='user',
hideList=True)
class profile(Schema):
first_name = UnicodeString(max=100, not_empty=True)
last_name = UnicodeString(max=100, not_empty=True)
class UserUpdateSchema(Schema):
"""Schema for User update (fields may be missing)."""
ignore_key_missing = True
email = Email(max=255, not_empty=True)
password = UnicodeString(min=6)
role = OneOf(('user', 'superuser', 'admin'), hideList=True, not_empty=True)
class profile(Schema):
first_name = UnicodeString(max=100, not_empty=True)
last_name = UnicodeString(max=100, not_empty=True)
class UserSchema(Schema):
username = Regex(r'^[a-zA-Z0-9_@+\.-]+$', max=150)
password = UnicodeString()
first_name = UnicodeString(max=30)
last_name = UnicodeString(max=150)
email = Email()
groups = ForEach(ResourceURI(model_cls=Group))
user_permissions = ForEach(ResourceURI(model_cls=Permission))
is_staff = Bool()
is_active = Bool()
is_superuser = Bool()
class UserRegisterForm(Schema):
"""Schema for User register form."""
pre_validators = [NestedVariables]
chained_validators = [FieldsMatch('password', 'confirm')]
email = Email(max=255, not_empty=True)
password = UnicodeString(min=6)
confirm = UnicodeString(not_empty=True)
class profile(Schema):
first_name = UnicodeString(max=100, not_empty=True)
last_name = UnicodeString(max=100, not_empty=True)
def _find_user(login):
principals = get_principals()
principal = principals.get(login)
if principal is not None:
return principal
else:
try:
Email().to_python(login)
except Exception:
pass
else:
for p in principals.search(email=login):
return p
class _RegisterForm(formencode.Schema):
allow_extra_fields = True
filter_extra_fields = True
username = All(ValidUsername(edit, old_data),
UnicodeString(strip=True, min=1, not_empty=True))
password = All(UnicodeString(strip=False, min=6, not_empty=True))
password_confirmation = All(UnicodeString(strip=False, min=6, not_empty=True))
active = StringBoolean(if_missing=False)
name = UnicodeString(strip=True, min=1, not_empty=False)
lastname = UnicodeString(strip=True, min=1, not_empty=False)
email = All(Email(not_empty=True), UniqSystemEmail(old_data))
chained_validators = [ValidPasswordsMatch, ValidPassword]
class NewResearcherForm(Schema):
"""NewResearcherForm is a Schema for validating the
data entered at the Add Researcher page.
"""
allow_extra_fields = True
filter_extra_fields = True
username = formencode.All(UniqueUsername(), PlainText(not_empty=True))
password = PlainText(not_empty=True)
firstName = UnicodeString(not_empty=True)
lastName = UnicodeString(not_empty=True)
email = Email(not_empty=True)
affiliation = UnicodeString()
role = OneOf(app_globals.roles)
personalPageContent = UnicodeString()
class UserForm(Schema):
""" Form validation schema for users."""
filter_extra_fields = True
allow_extra_fields = True
username = UsernamePlainText(min=5, max=16, strip=True)
first_name = FirstNameString(not_empty=True, strip=True)
last_name = LastNameString(not_empty=True, strip=True)
email = Email()
password = SecurePassword(min=6, max=80, strip=True)
password_confirm = String(strip=True)
group_id = Int(not_empty=True)
chained_validators = [
FieldsMatch('password', 'password_confirm'),
UniqueAuthUsername(),
UniqueAuthEmail(),
]
class ApplnValidator(Schema):
name = ByteString(not_empty=True)
email = Email()
dob = DateConverter(month_style='iso')
gender = OneOf(['M', 'F'])
applntype = OneOf(['new', 'renewal'])
race1_name = ByteString(not_empty=True)
race1_location = ByteString(not_empty=True)
race1_date = DateConverter(month_style='iso')
race1_distance = Number(min=0, max=200)
race1_units = OneOf(['miles', 'km'])
race1_time = TimeOptHoursConverter()
race1_resultslink = URL()
race2_name = ByteString(not_empty=True)
race2_location = ByteString(not_empty=True)
race2_date = DateConverter(month_style='iso')
race2_distance = Number(min=0, max=200)
race2_units = OneOf(['miles', 'km'])
race2_time = TimeOptHoursConverter()
race2_resultslink = URL()
def upgrade_request(self, **kwargs):
if not request.POST:
return
schema = DynamicSchema()
schema.chained_validators = []
schema.fields['name'] = UnicodeString(not_empty=True)
schema.fields['phone'] = UnicodeString(not_empty=True)
schema.fields['email'] = Email(not_empty=True)
if not c.logged_in_user:
schema.fields['recaptcha_challenge_field'] = UnicodeString(
not_empty=True)
schema.fields['recaptcha_response_field'] = UnicodeString(
not_empty=True)
schema.chained_validators.append(
ReCaptchaValidator(request.environ['REMOTE_ADDR']))
data = {'upgrade_request': kwargs}
data = validate_dict(data,
schema,
dict_to_validate_key='upgrade_request')
from civicboom.lib.communication.email_lib import send_email
form_string = ''
for key, value in kwargs.iteritems():
form_string += '\n%s: %s' % (key, value)
if c.logged_in_user:
form_string += '\nlogged_in_user: %s' % (c.logged_in_user.username)
form_string += '\nlogged_in_persona: %s' % (
c.logged_in_persona.username)
else:
form_string += '\nUser not logged in!'
send_email(config['email.contact'],
subject='Civicboom',
content_text='upgrade account request: %s' % form_string)
return action_ok(_('upgrade request sent'))
def test_valid_email_addresses():
valid_email_addresses = [
# (email address, expected email address),
(' [email protected] ', '*****@*****.**'),
('*****@*****.**', '*****@*****.**'),
('*****@*****.**', '*****@*****.**'),
('o*[email protected]', 'o*[email protected]'),
('*****@*****.**', '*****@*****.**'),
('*****@*****.**', '*****@*****.**'),
('[email protected]', '[email protected]'),
('foo{bar}@example.com', 'foo{bar}@example.com'),
# examples from RFC 3696
# punting on the difficult and extremely uncommon ones
#('"Abc\@def"@example.com', '"Abc\@def"@example.com'),
#('"Fred Bloggs"@example.com', '"Fred Bloggs"@example.com'),
#('"Joe\\Blow"@example.com', '"Joe\\Blow"@example.com'),
#('"Abc@def"@example.com', '"Abc@def"@example.com'),
('customer/[email protected]',
'customer/[email protected]'),
('[email protected]', '[email protected]'),
('!def!xyz%[email protected]', '!def!xyz%[email protected]'),
('*****@*****.**', '*****@*****.**'),
]
def expected_message(validator, message_name, username, domain):
email = '@'.join((username, domain))
return validator.message(message_name,
email,
username=username,
domain=domain)
validator = Email()
for email, expected in valid_email_addresses:
yield assert_equal, _validate(validator, email), expected
class UsuarioAddFormValidator(Schema):
nombre_usuario = All(
String(min=4,
max=32,
messages={
'tooShort':
'Nombre de usuario incorrecto, minimo 4 caracteres',
'tooLong':
'Nombre de usuario incorrecto, maximo 32 caracteres'
}), UniqueUsername(),
NotEmpty(messages={'empty': 'Ingrese un nombre de usuario'}))
nombre = All(
String(min=2,
max=50,
messages={
'tooShort': 'Nombre incorrecto, minimo 2 caracteres',
'tooLong': 'Nombre incorrecto, maximo 50 caracteres'
}), NotEmpty(messages={'empty': 'Ingrese un nombre'}))
apellido = All(
String(min=2,
max=50,
messages={
'tooShort': 'Apellido incorrecto, minimo 2 caracteres',
'tooLong': 'Apellido incorrecto, maximo 50 caracteres'
}), NotEmpty(messages={'empty': 'Ingrese un apellido'}))
password = All(
String(
min=6,
messages={'tooShort': 'Password incorrecto, minimo 6 caracteres'}),
NotEmpty(messages={'empty': 'Ingrese password'}))
repita_password = All(
String(
min=6,
messages={'tooShort': 'Password incorrecto, minimo 6 caracteres'}),
NotEmpty(messages={'empty': 'Ingrese password'}))
email = All(
UniqueNewEmail(),
Email(not_empty=True,
messages={
'empty': 'Ingrese una direccion de email',
'noAt': 'Un email debe contener un @',
'badUsername': '******',
'badDomain': 'Ingrese un dominio de email correcto',
}))
chained_validators = (FieldsMatch(
'password',
'repita_password',
messages={'invalidNoMatch': 'Passwords no coinciden'}), )
nro_documento = All(
UniqueNewNroDocumento(),
String(
min=5,
max=50,
messages={
'tooLong':
"Nro de Documendo invalido, debe tener 5 digitos como minimo",
'tooShort': "Nro de Documendo invalido",
}), NotEmpty(messages={'empty': 'Ingrese numero de documento'}),
isInt(messages={'integer': 'Ingrese un numero'}))
telefono = All(
String(
min=6,
max=15,
messages={
'tooShort':
"Nro de Telefono invalido, debe tener 6 digitos como minimo",
'tooLong': "Nro de Telefono invalido",
}), NotEmpty(messages={'empty': 'Ingrese numero de telefono'}),
isInt(messages={'integer': 'Ingrese un numero'}))
def setUp(self):
self.validator = Email()
def setUp(self):
self.validator = Email(resolve_domain=False)
class AddUserSchema(Schema):
username = UniqueUsername(not_empty=True)
first_name = UnicodeString(not_empty=True)
last_name = UnicodeString(not_empty=True)
email = Email(not_empty=True)
class UserLoginForm(Schema):
"""Schema for User login form."""
email = Email(not_empty=True)
password = UnicodeString(not_empty=True)
next = UnicodeString(if_missing=None)
class _PasswordResetForm(formencode.Schema):
allow_extra_fields = True
filter_extra_fields = True
email = All(ValidSystemEmail(), Email(not_empty=True))
class MyForm(Schema):
allow_extra_fields = True
name = String(not_empty=True)
email = Email(not_empty=True)
