def __call__(self, value):
emails = value.strip().replace('\n', '').replace('\t', '').split(self.sep)
for email in emails:
email = email.strip()
if IS_EMAIL()(email)[1] != None:
return (email, self.error_message % email)
return (emails, None)
def set_properties(self):
"""
"""
self.fields = [
Field('first_name',
'string',
requires=IS_NOT_EMPTY('Please enter a first name')),
Field('last_name',
'string',
requires=IS_NOT_EMPTY('Please enter a last name')),
Field('email',
'string',
requires=IS_EMAIL(error_message='Enter a valid email'))
]
def login(self, log=DEFAULT, **kwargs):
"""
Login a user
Keyword Args:
username/email/name_of_your_username_field (string) - username
password/name_of_your_passfield (string) - user's password
remember_me (boolean) - extend the duration of the login to settings.long_expiration
"""
settings = self.settings
session = current.session
table_user = self.table_user()
if 'username' in table_user.fields or \
not settings.login_email_validate:
userfield_validator = IS_NOT_EMPTY(
error_message=self.messages.is_empty)
if not settings.username_case_sensitive:
userfield_validator = [IS_LOWER(), userfield_validator]
else:
userfield_validator = IS_EMAIL(
error_message=self.messages.invalid_email)
if not settings.email_case_sensitive:
userfield_validator = [IS_LOWER(), userfield_validator]
passfield = settings.password_field
if log is DEFAULT:
log = self.messages['login_log']
user = None
# Setup the default field used for the userfield
if self.settings.login_userfield:
userfield = self.settings.login_userfield
else:
if 'username' in table_user.fields:
userfield = 'username'
else:
userfield = 'email'
# Get the userfield from kwargs and validate it
userfield_value = kwargs.get(userfield)
if userfield_value is None:
raise KeyError('%s not found in kwargs' % userfield)
validated, error = self.__validate(userfield_value,
userfield_validator)
if error:
return {
'errors': {
userfield: error
},
'message': self.messages.invalid_login,
'user': None
}
# Get the user for this userfield and check it
user = table_user(**{userfield: validated})
if user is None:
return {
'errors': {
userfield: self.messages.invalid_user
},
'message': self.messages.invalid_login,
'user': None
}
if (user.registration_key or '').startswith('pending'):
return {
'errors': None,
'message': self.messages.registration_pending,
'user': None
}
elif user.registration_key in ('disabled', 'blocked'):
return {
'errors': None,
'message': self.messages.login_disabled,
'user': None
}
elif (user.registration_key is not None
and user.registration_key.strip()):
return {
'errors': None,
'message': self.messages.registration_verifying,
'user': None
}
# Finally verify the password
passfield = settings.password_field
password = table_user[passfield].validate(kwargs.get(passfield, ''))[0]
if password == user[passfield]:
self.login_user(user)
session.auth.expiration = \
kwargs.get('remember_me', False) and \
settings.long_expiration or \
settings.expiration
session.auth.remember_me = kwargs.get('remember_me', False)
self.log_event(log, user)
return {
'errors': None,
'message': self.messages.logged_in,
'user': {
k: user[k]
for k in table_user.fields if table_user[k].readable
}
}
else:
self.log_event(self.messages['login_failed_log'], kwargs)
return {
'errors': {
passfield: self.messages.invalid_password
},
'message': self.messages.invalid_login,
'user': None
}
def define_tables(self,
username=None,
signature=None,
migrate=None,
fake_migrate=None):
"""
To be called unless tables are defined manually
Examples:
Use as::
# defines all needed tables and table files
# 'myprefix_auth_user.table', ...
auth.define_tables(migrate='myprefix_')
# defines all needed tables without migration/table files
auth.define_tables(migrate=False)
"""
db = self.db
if migrate is None:
migrate = db._migrate
if fake_migrate is None:
fake_migrate = db._fake_migrate
settings = self.settings
if username is None:
username = settings.use_username
else:
settings.use_username = username
if not self.signature:
self.define_signature()
if signature is True:
signature_list = [self.signature]
elif not signature:
signature_list = []
elif isinstance(signature, Table):
signature_list = [signature]
else:
signature_list = signature
self._table_signature_list = signature_list # Should it defined in __init__ first??
is_not_empty = IS_NOT_EMPTY(error_message=self.messages.is_empty)
is_crypted = CRYPT(key=settings.hmac_key,
min_length=settings.password_min_length)
is_unique_email = [
IS_EMAIL(error_message=self.messages.invalid_email),
IS_NOT_IN_DB(db,
'%s.email' % settings.table_user_name,
error_message=self.messages.email_taken)
]
if not settings.email_case_sensitive:
is_unique_email.insert(1, IS_LOWER())
if settings.table_user_name not in db.tables:
passfield = settings.password_field
extra_fields = settings.extra_fields.get(settings.table_user_name,
[]) + signature_list
# cas_provider Will always be None here but we compare it anyway so subclasses can use our define_tables
if username or settings.cas_provider:
is_unique_username = \
[IS_MATCH('[\w\.\-]+', strict=True,
error_message=self.messages.invalid_username),
IS_NOT_IN_DB(db, '%s.username' % settings.table_user_name,
error_message=self.messages.username_taken)]
if not settings.username_case_sensitive:
is_unique_username.insert(1, IS_LOWER())
db.define_table(
settings.table_user_name,
Field('first_name',
length=128,
default='',
label=self.messages.label_first_name,
requires=is_not_empty),
Field('last_name',
length=128,
default='',
label=self.messages.label_last_name,
requires=is_not_empty),
Field('email',
length=512,
default='',
label=self.messages.label_email,
requires=is_unique_email),
Field('username',
length=128,
default='',
label=self.messages.label_username,
requires=is_unique_username),
Field(passfield,
'password',
length=512,
readable=False,
label=self.messages.label_password,
requires=[is_crypted]),
Field('registration_key',
length=512,
writable=False,
readable=False,
default='',
label=self.messages.label_registration_key),
Field('reset_password_key',
length=512,
writable=False,
readable=False,
default='',
label=self.messages.label_reset_password_key),
Field('registration_id',
length=512,
writable=False,
readable=False,
default='',
label=self.messages.label_registration_id),
*extra_fields,
**dict(migrate=self._get_migrate(settings.table_user_name,
migrate),
fake_migrate=fake_migrate,
format='%(username)s'))
else:
db.define_table(
settings.table_user_name,
Field('first_name',
length=128,
default='',
label=self.messages.label_first_name,
requires=is_not_empty),
Field('last_name',
length=128,
default='',
label=self.messages.label_last_name,
requires=is_not_empty),
Field('email',
length=512,
default='',
label=self.messages.label_email,
requires=is_unique_email),
Field(passfield,
'password',
length=512,
readable=False,
label=self.messages.label_password,
requires=[is_crypted]),
Field('registration_key',
length=512,
writable=False,
readable=False,
default='',
label=self.messages.label_registration_key),
Field('reset_password_key',
length=512,
writable=False,
readable=False,
default='',
label=self.messages.label_reset_password_key),
Field('registration_id',
length=512,
writable=False,
readable=False,
default='',
label=self.messages.label_registration_id),
*extra_fields,
**dict(migrate=self._get_migrate(settings.table_user_name,
migrate),
fake_migrate=fake_migrate,
format='%(first_name)s %(last_name)s (%(id)s)'))
reference_table_user = '******' % settings.table_user_name
if settings.table_group_name not in db.tables:
extra_fields = settings.extra_fields.get(settings.table_group_name,
[]) + signature_list
db.define_table(
settings.table_group_name,
Field('role',
length=512,
default='',
label=self.messages.label_role,
requires=IS_NOT_IN_DB(
db, '%s.role' % settings.table_group_name)),
Field('description',
'text',
label=self.messages.label_description), *extra_fields,
**dict(migrate=self._get_migrate(settings.table_group_name,
migrate),
fake_migrate=fake_migrate,
format='%(role)s (%(id)s)'))
reference_table_group = 'reference %s' % settings.table_group_name
if settings.table_membership_name not in db.tables:
extra_fields = settings.extra_fields.get(
settings.table_membership_name, []) + signature_list
db.define_table(
settings.table_membership_name,
Field('user_id',
reference_table_user,
label=self.messages.label_user_id),
Field('group_id',
reference_table_group,
label=self.messages.label_group_id), *extra_fields,
**dict(migrate=self._get_migrate(
settings.table_membership_name, migrate),
fake_migrate=fake_migrate))
if settings.table_permission_name not in db.tables:
extra_fields = settings.extra_fields.get(
settings.table_permission_name, []) + signature_list
db.define_table(
settings.table_permission_name,
Field('group_id',
reference_table_group,
label=self.messages.label_group_id),
Field('name',
default='default',
length=512,
label=self.messages.label_name,
requires=is_not_empty),
Field('table_name',
length=512,
label=self.messages.label_table_name),
Field('record_id',
'integer',
default=0,
label=self.messages.label_record_id,
requires=IS_INT_IN_RANGE(0, 10**9)), *extra_fields,
**dict(migrate=self._get_migrate(
settings.table_permission_name, migrate),
fake_migrate=fake_migrate))
if settings.table_event_name not in db.tables:
db.define_table(
settings.table_event_name,
Field('time_stamp',
'datetime',
default=current.request.now,
label=self.messages.label_time_stamp),
Field('client_ip',
default=current.request.client,
label=self.messages.label_client_ip),
Field('user_id',
reference_table_user,
default=None,
label=self.messages.label_user_id),
Field('origin',
default='auth',
length=512,
label=self.messages.label_origin,
requires=is_not_empty),
Field('description',
'text',
default='',
label=self.messages.label_description,
requires=is_not_empty),
*settings.extra_fields.get(settings.table_event_name, []),
**dict(migrate=self._get_migrate(settings.table_event_name,
migrate),
fake_migrate=fake_migrate))
return self
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sys
sys.path.append(
'/Users/xcbfreedom/projects/web2py/web2py.app/Contents/Resources/')
from gluon.dal import DAL, Field
from gluon.sqlhtml import SQLFORM
from gluon.validators import IS_NOT_EMPTY, IS_EMAIL, IS_LENGTH
db = DAL("sqlite://data/mydb.sqlite")
db.define_table('t_contact', Field("name"), Field("email"), Field("phone"))
db.t_contact.name.requires = IS_NOT_EMPTY()
db.t_contact.email.requires = IS_EMAIL()
db.t_contact.phone.requires = IS_LENGTH(14)
#====insert
print db.t_contact.insert(**dict(name="fx", email="x.comll", phone='123'))
print db.t_contact.insert(**dict(name="axbc", email="x.comll", phone='123'))
db.commit()
print 'insert ok'
#====select
print "select "
print db(db.t_contact.phone == '123').select()
print "select one"
print db.t_contact(**dict(phone='123'))
def __new__(cls, **kwargs):
instance = super(PERSON_FORM, cls).__new__(cls)
instance.person = kwargs.get('person') # PERSON type
instance.readonly = kwargs.get('readonly') or False
instance.readonly_fields = kwargs.get('readonly_fields') or []
my_logger.debug(message='instance.person:%s' % instance.person)
my_logger.debug(message='instance.person.creator:%s' %
instance.person.creator)
if instance.person is not None:
current.db.person.first_name.default = instance.person.first_name
if 'first_name' in instance.readonly_fields:
current.db.person.first_name.writable = False
current.db.person.last_name.default = instance.person.last_name
if 'last_name' in instance.readonly_fields:
current.db.person.last_name.writable = False
current.db.person.email.default = instance.person.email
if 'email' in instance.readonly_fields:
current.db.person.email.writable = False
current.db.person.contact.default = instance.person.contact
if 'contact' in instance.readonly_fields:
current.db.person.contact.writable = False
current.db.person.email.requires = [
IS_NOT_EMPTY(),
IS_EMAIL(),
IS_NOT_IN_DB(
current.db(current.db.person.id != instance.person.id),
current.db.person.email)
]
# creator is a computed field and then not shown by web2py
# we need to add it manually
instance.form = SQLFORM.factory(Field('creator',
'string',
writable=not 'creator' in instance.readonly_fields,
label=cc.get_string("PERSON_CREATOR_LABEL"),
default=instance.person.creator.email \
if instance.person.creator is not None \
else ''), # creator should exists - backward compatibility
current.db.person,
Field('is_all_entity',
'boolean',
label=cc.get_string("PERSON_IS_ALL_ENTITY_LABEL"),
comment=cc.get_string("PERSON_IS_ALL_ENTITY_COMMENT"),
represent=lambda r: current.T(str(instance.person.is_all_entity())),
# disabled if the user is not admin
readable=current.auth.has_membership('all_entity') or \
current.auth.has_membership('admin_entity') or \
current.auth.has_permission('admin'), # admin_ENTITY: backward compatibility
writable=(current.auth.has_membership('all_entity') or \
current.auth.has_membership('admin_entity') or \
current.auth.has_permission('admin')) and \
not 'custom_entity' in instance.readonly_fields,
# for an update request, pre populating the widget if the user is in all entities
default=instance.person.is_all_entity(),
),
Field('custom_entity',
'list:reference entity',
comment=cc.get_string("PERSON_ENTITY_COMMENT"),
label=cc.get_string("PERSON_ENTITY_LABEL"),
required=True,
notnull=True,
writable=not 'custom_entity' in instance.readonly_fields,
# for an update request, pre populating the widget given the user entities
default=[_entity.id for _entity in instance.person.entities] \
if instance.person.entities is not None \
else [],
requires=[IS_IN_DB_AND_USER_ENTITY(current.db(current.db.entity.id > 0),
current.db.entity.id,
current.db.entity._format, multiple=True),
IS_ONE_SELECTED(db=current.db, table=current.db.entity, table_set=~current.db.entity.role.like('user_%'))],
represent=lambda r: XML(' <br/>'.join(['%s' % (e.name) \
for e in instance.person.entities])) \
if (not instance.person.is_all_entity() and instance.person.entities is not None) else 'X',
widget=lambda field, value: SQLFORM.widgets.multiple.widget(field, value, _class='required')),
Field('is_admin',
'boolean',
label=cc.get_string("PERSON_IS_ADMIN_LABEL"),
comment=cc.get_string("PERSON_IS_ADMIN_COMMENT"),
represent=lambda r: current.T(str(instance.person.is_admin())),
# disabled if the user is not admin
readable=current.auth.has_permission('admin'),
writable=current.auth.has_permission('admin') and not 'is_admin' in instance.readonly_fields,
# for an update request, pre populating the widget if the user is admin
default=instance.person.is_admin(),
),
Field('custom_permission',
'string', # this does not matter given that we define our own permission widget
label=cc.get_string("PERSON_ENTITY_PERMISSION_LABEL"),
required=True,
notnull=True,
writable=not 'custom_permission' in instance.readonly_fields,
# for an update request, pre populating the widget given the user permissions
default=[_permission.name for _permission in instance.person.permissions],
comment=cc.get_string("PERSON_ENTITY_PERMISSION_COMMENT"),
requires=IS_CHIMITHEQUE_PERMISSION(),
represent=lambda r: PermissionWidget.represent(r),
widget=lambda field, value: PermissionWidget.widget(field,
value,
_class='required',
auth_user_permissions=[_permission.name for _permission in PERSON_MAPPER().find_permissions(current.auth.user.id)] \
if not current.auth.has_permission('admin') \
else None)),
readonly=instance.readonly,
comments=not instance.readonly,
next=URL(current.request.application, 'user', 'list'),
submit_button=cc.get_string("SUBMIT")
)
else:
instance.form = SQLFORM.factory(
Field('None', 'string', writable=False, readable=False))
return instance