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 child(twf.TableLayout):
inline_engine_name = 'kajiki'
template = '''
<div style="padding-top:20px">
<py:for each="c in w.children_hidden">
${c.display()}
</py:for>
<div class="col-md-12 ks-section-name">
Recover password
<hr/>
</div>
<div class="row">
<div class="form-group col-md-4">
${w.children.password.display()}
<span class="help-block" py:content="w.children.password.error_msg"/>
</div>
</div>
<div class="row">
<div class="form-group col-md-4">
${w.children.password_confirm.display()}
<span class="help-block" py:content="w.children.password_confirm.error_msg"/>
</div>
</div>
</div>
'''
data = HiddenField()
password = PasswordField(label=l_('New password'), validator=Validator(required=True), css_class='form-control', placeholder=l_('New password'))
password_confirm = PasswordField(label=l_('Confirm new password'), validator=Validator(required=True), css_class='form-control', placeholder=l_('Confirm password'))
validator = FieldsMatch('password', 'password_confirm')
class NewPasswordForm(TableForm):
data = HiddenField()
password = PasswordField(label=l_('New password'),
validator=Validator(required=True))
password_confirm = PasswordField(label=l_('Confirm new password'),
validator=Validator(required=True))
validator = FieldsMatch('password', 'password_confirm')
submit = SubmitButton(value=l_('Save new password'))
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 UserPasswordForm(UserForm):
""" Form validation schema for user password change."""
user_id = Int() # used in forms hidden field
username = None
first_name = None
last_name = None
email = None
group_id = None
chained_validators = [
FieldsMatch('password', 'password_confirm'),
]
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)
class ProyectoRegistrationForm(AddRecordForm):
form_validator = Schema(chained_validators=(FieldsMatch('cod_proyecto',
'verify_password',
messages={'invalidNoMatch':
'cod_proyecto do not match'}),))
__model__ = Proyecto
__require_fields__ = ['cod_proyecto', 'nombre', 'cant_fases','user_id']
__omit_fields__ = ['id_proyecto', 'estado', 'fecha_creacion', 'fecha_inicio', 'fecha_finalizacion_anulacion']
__field_order__ = ['cod_proyecto', 'nombre', 'cant_fases','user_id']
__base_validator__ = form_validator
cod_proyecto = TextField
nombre = TextField
cant_fases = TextField
class UserRegistrationForm(AddRecordForm):
form_validator = Schema(chained_validators=(FieldsMatch('password',
'verify_password',
messages={'invalidNoMatch':
'Passwords do not match'}),))
__model__ = User
__require_fields__ = ['password', 'user_name', 'email_address']
__omit_fields__ = ['_password', 'groups', 'created', 'user_id', 'town_id']
__field_order__ = ['user_name', 'email_address', 'display_name', 'password', 'verify_password']
__base_validator__ = form_validator
email_address = TextField
display_name = TextField
verify_password = PasswordField('verify_password')
def test_form_with_base_validator(self):
if hasattr(TextField, 'req'):
form_validator = FieldsMatch(
'password',
'verify_password',
messages={'invalidNoMatch': 'Passwords do not match'})
else:
form_validator = Schema(chained_validators=(FieldsMatch(
'password',
'verify_password',
messages={'invalidNoMatch': 'Passwords do not match'}), ))
class RegistrationForm(AddRecordForm):
__model__ = User
__require_fields__ = ['password', 'user_name', 'email_address']
__omit_fields__ = [
'_password', 'groups', 'created', 'user_id', 'town'
]
__field_order__ = [
'password', 'verify_password', 'user_name', 'email_address',
'display_name'
]
__base_validator__ = form_validator
email_address = TextField
display_name = TextField
verify_password = PasswordField('verify_password')
registration_form = RegistrationForm()
try:
registration_form.validate(params={
'password': '******',
'verify_password': '******'
})
except Invalid as e:
msg = form_error_message(e)
assert 'Passwords do not match' in msg, msg
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(),
]
def build_schema(*args, **kwargs):
"""
Given a list of strings will attach best match validator to them
Given a set of kargs win the form of string:validator will create a new dynamic validator
"""
schema = DynamicSchema()
schema.chained_validators = []
if kwargs:
for key in kwargs:
if isinstance(kwargs[key], Validator):
schema.fields[key] = kwargs[key]
elif args:
for field in args:
if field == 'username':
schema.fields[field] = UniqueUsernameValidator(not_empty=True)
if field == 'email':
schema.fields[field] = UniqueEmailValidator(not_empty=True)
if field == 'dob':
schema.fields[field] = MinimumAgeValidator(not_empty=True)
if field == 'password':
schema.fields[field] = PasswordValidator()
schema.fields['password_confirm'] = PasswordValidator()
from pylons import request
schema.chained_validators.append(
FieldsMatch('password', 'password_confirm'))
if config['test_mode'] or not config[
'online']: # If in test mode we should bypass captcha validation
pass
else:
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']))
#setattr(schema, 'chained_validators', [FieldsMatch('password', 'password_confirm'),
#ReCaptchaValidator(request.environ['REMOTE_ADDR']),
# ])
return schema
class ProfileForm(twbf.HorizontalForm):
user_name = MediumLabelField()
display_name = MediumTextField()
# last_name = twbf.TextField()
# first_name = twbf.TextField()
email_address = MediumTextField(validator=twc.EmailValidator)
password_l = twbf.Label(text='Only if you want to change your password:'******'New password')
password_2 = MediumPasswordField(label='Repeat password')
validator = FieldsMatch('password_1', 'password_2')
def prepare(self):
if getattr(self.value, 'disable_submit', False):
self.safe_modify('submit')
self.submit.type = 'button'
self.submit.value = 'Saving not possible'
self.submit.css_class = 'btn btn-primary disabled'
super(ProfileForm, self).prepare()
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'}))
from tw.forms import *
from sprox.tablebase import TableBase
from sprox.fillerbase import TableFiller
from sprox.fillerbase import EditFormFiller
from proyectosaptg.model import *
from tg import expose, flash, require, url, request, redirect
from tg.decorators import without_trailing_slash, with_trailing_slash
from tg.decorators import paginate
from tgext.crud.decorators import registered_validate, register_validators, catch_errors
from tg import tmpl_context
from tgext.crud.controller import CrudRestController
from sprox.widgets import PropertyMultipleSelectField
"""configuraciones del modelo User"""
user_form_validator = Schema(chained_validators=(
FieldsMatch('password',
'verify_password',
messages={'invalidNoMatch': 'Passwords do not match'}), ))
class UserRegistrationForm(AddRecordForm):
__model__ = User
__require_fields__ = ['password', 'user_name', 'email_address']
__omit_fields__ = [
'_password', 'created', 'user_id', 'town_id', 'proyectos',
'display_name'
]
__field_order__ = [
'user_name', 'email_address', 'display_name', 'password',
'verify_password'
]
__base_validator__ = user_form_validator
from tgext.admin.config import AdminConfig, CrudRestControllerConfig
from tg.decorators import without_trailing_slash, with_trailing_slash, paginate
from sprox.formbase import AddRecordForm
from formencode import Schema
from formencode.validators import FieldsMatch
from tw.forms import PasswordField, TextField
from sap.model.auth import *
from sprox.tablebase import TableBase
from sprox.fillerbase import TableFiller
form_validator = Schema(chained_validators=(FieldsMatch('password',
'verify_password',
messages={'invalidNoMatch':
'Passwords do not match'}),))
class UserTableFormType(TableBase):
__model__= User
class UserTableFillerType(TableFiller):
__model__ = User
class UserCrudConfig(CrudRestControllerConfig):
table_type = UserTableFormType
table_filler_type = UserTableFillerType
class MyUserConfig(AdminConfig):
user = UserCrudConfig
def _do_init_with_translations(self, translations):
user_id_field = translations.get('user_id', 'user_id')
user_name_field = translations.get('user_name', 'user_name')
email_field = translations.get('email_address', 'email_address')
password_field = translations.get('password', 'password')
display_name_field = translations.get('display_name', 'display_name')
if not getattr(self, 'table_type', None):
class Table(self.layout.TableBase):
__entity__ = self.model
__omit_fields__ = [
user_id_field, '_groups', '_password', password_field
]
__url__ = '../users.json'
self.table_type = Table
if not getattr(self, 'table_filler_type', None):
class MyTableFiller(self.layout.TableFiller):
__entity__ = self.model
__omit_fields__ = ['_password', password_field, '_groups']
self.table_filler_type = MyTableFiller
if hasattr(TextField, 'req'):
edit_form_validator = FieldsMatch(
'password',
'verify_password',
messages={'invalidNoMatch': 'Passwords do not match'})
else:
edit_form_validator = FilteringSchema(chained_validators=[
FieldsMatch(
'password',
'verify_password',
messages={'invalidNoMatch': 'Passwords do not match'})
])
if not getattr(self, 'edit_form_type', None):
class EditForm(self.layout.EditableForm):
__entity__ = self.model
__require_fields__ = [user_name_field, email_field]
__omit_fields__ = ['created', '_password', '_groups']
__hidden_fields__ = [user_id_field]
__field_order__ = [
user_id_field, user_name_field, email_field,
display_name_field, 'password', 'verify_password', 'groups'
]
password = PasswordField(
'password',
value='',
**self.layout.EditableForm.FIELD_OPTIONS)
verify_password = PasswordField(
'verify_password',
**self.layout.EditableForm.FIELD_OPTIONS)
__base_validator__ = edit_form_validator
if email_field is not None:
setattr(EditForm, email_field, TextField)
if display_name_field is not None:
setattr(EditForm, display_name_field, TextField)
self.edit_form_type = EditForm
if not getattr(self, 'edit_filler_type', None):
class UserEditFormFiller(EditFormFiller):
__entity__ = self.model
def get_value(self, *args, **kw):
v = super(UserEditFormFiller, self).get_value(*args, **kw)
del v['password']
return v
self.edit_filler_type = UserEditFormFiller
if not getattr(self, 'new_form_type', None):
class NewForm(self.layout.AddRecordForm):
__entity__ = self.model
__require_fields__ = [user_name_field, email_field]
__omit_fields__ = [
password_field, 'created', '_password', '_groups'
]
__hidden_fields__ = [user_id_field]
__field_order__ = [
user_name_field, email_field, display_name_field, 'groups'
]
if email_field is not None:
setattr(NewForm, email_field, TextField)
if display_name_field is not None:
setattr(NewForm, display_name_field, TextField)
self.new_form_type = NewForm
def _do_init_with_translations(self, translations):
global TableBase, TableFiller, EditableForm, AddRecordForm
if self.default_to_dojo and dojo_loaded:
TableBase = DojoTableBase
TableFiller = DojoTableFiller
EditableForm = DojoEditableForm
AddRecordForm = DojoAddRecordForm
user_id_field = translations.get('user_id', 'user_id')
user_name_field = translations.get('user_name', 'user_name')
email_field = translations.get('email_address', 'email_address')
password_field = translations.get('password', 'password')
display_name_field = translations.get('display_name', 'display_name')
if not getattr(self, 'table_type', None):
class Table(TableBase):
__entity__ = self.model
__omit_fields__ = [user_id_field, '_password', password_field]
__url__ = '../users.json'
self.table_type = Table
if not getattr(self, 'table_filler_type', None):
class MyTableFiller(TableFiller):
__entity__ = self.model
__omit_fields__ = ['_password', password_field]
self.table_filler_type = MyTableFiller
edit_form_validator = FilteringSchema(chained_validators=(FieldsMatch(
'password',
'verify_password',
messages={'invalidNoMatch': 'Passwords do not match'}), ))
if not getattr(self, 'edit_form_type', None):
class EditForm(EditableForm):
__entity__ = self.model
__require_fields__ = [user_name_field, email_field]
__omit_fields__ = ['created', '_password']
__hidden_fields__ = [user_id_field]
__field_order__ = [
user_id_field, user_name_field, email_field,
display_name_field, 'password', 'verify_password', 'groups'
]
password = PasswordField('password', value='')
verify_password = PasswordField('verify_password')
__base_validator__ = edit_form_validator
if email_field is not None:
setattr(EditForm, email_field, TextField)
if display_name_field is not None:
setattr(EditForm, display_name_field, TextField)
self.edit_form_type = EditForm
if not getattr(self, 'edit_filler_type', None):
class UserEditFormFiller(EditFormFiller):
__entity__ = self.model
def get_value(self, *args, **kw):
v = super(UserEditFormFiller, self).get_value(*args, **kw)
del v['password']
return v
self.edit_filler_type = UserEditFormFiller
if not getattr(self, 'new_form_type', None):
class NewForm(AddRecordForm):
__entity__ = self.model
__require_fields__ = [user_name_field, email_field]
__omit_fields__ = [password_field, 'created', '_password']
__hidden_fields__ = [user_id_field]
__field_order__ = [
user_name_field, email_field, display_name_field, 'groups'
]
if email_field is not None:
setattr(NewForm, email_field, TextField)
if display_name_field is not None:
setattr(NewForm, display_name_field, TextField)
self.new_form_type = NewForm
