def convert_StringProperty(model, prop, kwargs):
    """Returns a form field for a ``db.StringProperty``."""
    if prop.multiline:
        kwargs['validators'].append(validators.length(max=500))
        return f.TextAreaField(**kwargs)
    else:
        return get_TextField(kwargs)

    def convert(self, column):
        kwargs = {
            'label': column.info.get('label', column.name),
            'description': column.description,
            'validators': [],
            'default': column.default and column.default.arg
        }
        
        if column.info.get('optional', False):
            kwargs['validators'].append(validators.optional())
        elif not column.nullable:
            kwargs['validators'].append(validators.required())
        
        if hasattr(column.type, 'length') and column.type.length is not None:
            kwargs['validators'].append(validators.length(max=column.type.length))
        
        fname = type(column.type).__name__

        if len(column.foreign_keys) > 0:
            return self.conv_ForeignKey(kwargs, column)

        if fname in self.SIMPLE_CONVERSIONS:
            return self.SIMPLE_CONVERSIONS[fname](**kwargs)
        else:
            mod = getattr(self, 'conv_%s' % fname, None)
            if mod is not None:
                return mod(kwargs, column)

def convert_StringProperty(model, prop, kwargs):
    """Returns a form field for a ``db.StringProperty``."""
    if prop._repeated:
        return StringListPropertyField(**kwargs)
    else:
        kwargs['validators'].append(validators.length(max=500))
        return get_TextField(kwargs)

def get_TextField(kwargs):
    """
    Returns a ``TextField``, applying the ``db.StringProperty`` length limit
    of 500 bytes.
    """
    kwargs['validators'].append(validators.length(max=500))
    return f.TextField(**kwargs)

    def create_form(self, relations=True):
        model = self.model
        class_name = '%sForm' % mixedcase(model._name)
        attrs = {}
        fields = model.fields_get(self.fields)
        defaults = model.default_get(fields.keys())
        for k, v in fields.items():
            type_field = MAPPING_TYPES.get(v.get('type', 'float'))
            if not type_field:
                continue
            override = self._get_form_overrides(k)
            if override:
                type_field = override
            kwargs = {}
            validators = []
            if 'required' in v and v['required']:
                validators.append(wtf_validators.required())
            if 'size' in v:
                validators.append(wtf_validators.length(max=v['size']))
            if k in defaults and defaults[k] is not False:
                kwargs['default'] = defaults[k]
            if v.get('help'):
                kwargs['description'] = v['help']
            if v['type'] == 'selection':
                if v['selection'] and isinstance(v['selection'][0][0], int):
                    kwargs['coerce'] = int
                kwargs['choices'] = v['selection']
            elif v['type'] == 'char' and 'invisible' in v and v['invisible']:
                type_field = PasswordField
            elif v['type'] == 'date':
                kwargs['widget'] = widgets.DatePickerWidget()
            elif v['type'] == 'datetime':
                kwargs['widget'] = widgets.DateTimePickerWidget()
            elif v['type'] in ('many2one', 'one2many'):
                kwargs['coerce'] = coerce_relation
                if v['type'] == 'many2one':
                    kwargs['widget'] = widgets.Select2Widget()
                elif v['type'] == 'one2many':
                    kwargs['widget'] = ListWidget()
                elif v['type'] == 'many2many':
                    kwargs['widget'] = widgets.Select2Widget(multiple=True)

            attrs[k] = type_field(label=v['string'], **kwargs)
        return type(class_name, (BaseForm, ), attrs)

    def test_lazy_proxy(self):
        """Tests that the validators support lazy translation strings for messages."""

        class ReallyLazyProxy(object):
            def __unicode__(self):
                raise Exception('Translator function called during form declaration: it should be called at response time.')
            __str__ = __unicode__

        message = ReallyLazyProxy()
        self.assertRaises(Exception, str, message)
        self.assertRaises(Exception, text_type, message)
        self.assertTrue(equal_to('fieldname', message=message))
        self.assertTrue(length(min=1, message=message))
        self.assertTrue(NumberRange(1, 5, message=message))
        self.assertTrue(required(message=message))
        self.assertTrue(regexp('.+', message=message))
        self.assertTrue(email(message=message))
        self.assertTrue(ip_address(message=message))
        self.assertTrue(url(message=message))

    def test_length(self):
        field = DummyField("foobar")
        self.assertEqual(length(min=2, max=6)(self.form, field), None)
        self.assertRaises(ValidationError, length(min=7), self.form, field)
        self.assertEqual(length(min=6)(self.form, field), None)
        self.assertRaises(ValidationError, length(max=5), self.form, field)
        self.assertEqual(length(max=6)(self.form, field), None)

        self.assertRaises(AssertionError, length)
        self.assertRaises(AssertionError, length, min=5, max=2)

        # Test new formatting features
        grab = lambda **k: grab_error_message(length(**k), self.form, field)
        self.assertEqual(grab(min=2, max=5, message="%(min)d and %(max)d"), "2 and 5")
        self.assert_("at least 8" in grab(min=8))
        self.assert_("longer than 5" in grab(max=5))
        self.assert_("between 2 and 5" in grab(min=2, max=5))

    def test_length(self):
        field = DummyField('foobar')
        self.assertEqual(length(min=2, max=6)(self.form, field), None)
        self.assertRaises(ValidationError, length(min=7), self.form, field)
        self.assertEqual(length(min=6)(self.form, field), None)
        self.assertRaises(ValidationError, length(max=5), self.form, field)
        self.assertEqual(length(max=6)(self.form, field), None)

        self.assertRaises(AssertionError, length)
        self.assertRaises(AssertionError, length, min=5, max=2)

        # Test new formatting features
        grab = lambda **k: grab_error_message(length(**k), self.form, field)
        self.assertEqual(grab(min=2, max=5, message='%(min)d and %(max)d'), '2 and 5')
        self.assertTrue('at least 8' in grab(min=8))
        self.assertTrue('longer than 5' in grab(max=5))
        self.assertTrue('between 2 and 5' in grab(min=2, max=5))

    def convert(self, field):
        kwargs = {
            'label': field.verbose_name,
            'description': field.help_text,
            'validators': [],
            'default': field.default,
        }
        if field.blank:
            kwargs['validators'].append(validators.optional())
        if field.max_length is not None and field.max_length > 0:
            kwargs['validators'].append(validators.length(max=field.max_length))

        fname = type(field).__name__

        if field.choices:
            kwargs['choices'] = field.choices
            return f.SelectField(**kwargs)
        elif fname in self.SIMPLE_CONVERSIONS:
            return self.SIMPLE_CONVERSIONS[fname](**kwargs)
        else:
            m = getattr(self, 'conv_%s' % fname, None)
            if m is not None:
                return m(kwargs, field)

    def scaffold_form(self):
        """改写form"""
        form_class = super(PubView, self).scaffold_form()
        delete_attrs(form_class, ('access_token_time', 'access_token', 'address', 'tel', 'base_path', 'rel_path',
                                  'pic_name', 'logo', 'create_time'))
        form_class.user = TextField(label=u'酒吧管理员', validators=[validators.required(), validators.length(max=16)])
        form_class.password = TextField(label=u'管理员密码', validators=[validators.required()])

        return form_class

FIELD_MAXLENGTH = 50  # intended to stop maliciously long input
PHONE_MAXLENGTH = 15
TAGS = {'TAG1', 'TAG2', 'TAG3'}

NAME_FIELD_VALIDATORS = [validators.DataRequired(),
                         validators.Length(max=FIELD_MAXLENGTH,
                                           message=_("Field cannot be longer than %(max)d characters.")),
                         validators.regexp(utils.NAME_LASTNAME_REGEXP,
                                           message=_("Name invalid. Use only letters and numbers."))]
EMAIL_FIELD_VALIDATORS = [validators.Length(min=0, max=FIELD_MAXLENGTH, message=_(
                              "Field must be between %(min)d and %(max)d characters long.")),
                          validators.regexp(utils.EMAIL_REGEXP, message=_('Invalid email address.'))]
PHONE_FIELD_VALIDATORS = [validators.length(max=PHONE_MAXLENGTH,
                                            message=_('Phone invalid. Should be less than %(max)s '
                                                      'character long.'))]
WEBSITE_FIELD_VALIDATORS = [validators.Length(max=FIELD_MAXLENGTH,
                                              message=_('Field cannot be longer than %(max)d characters.'))]
NOTES_FIELD_VALIDATORS = [validators.Length(max=65536)]
PASSWORD_FIELD_VALIDATORS = [validators.DataRequired(),
                             validators.Length(max=FIELD_MAXLENGTH, message=_(
                                 "Field cannot be longer than %(max)d characters."))]
TAG_FIELD_VALIDATORS = [validators.Required()]
PRICE_FIELD_VALIDATORS = [validators.NumberRange(min=0.0)]

CARE_TYPE_CHOICES = [('Transfers', 'Transfers'),
                     ('Showering', 'Showering'),
                     ('Dressing', 'Dressing'),
                     ('Personal Care', 'Personal Care'),
                     ('Shopping', 'Shopping'),

def password_field(label="Password", required=True):
    v = [validators.length(min=6)]
    if required:
        v.append(validators.required())
    return PasswordField(label, v)

 def convert_GenericProperty(self, model, prop, kwargs):
     """Returns a form field for a ``ndb.ListProperty``."""
     kwargs['validators'].append(validators.length(max=500))
     return get_TextField(kwargs)

    def scaffold_form(self):
        """改写form"""
        form_class = super(TicketView, self).scaffold_form()
        delete_attrs(form_class, ('base_path', 'rel_path', 'pic_name', 'pub', 'create_time', 'intro'))
        form_class.intro = TextAreaField(label=u'优惠券介绍', validators=[validators.required(), validators.length(max=256)])
        form_class.picture = FileField(label=u'优惠券图片', description=u'推荐使用640*288')

        return form_class

    def scaffold_form(self):
        """改写form"""
        form_class = super(GiftView, self).scaffold_form()
        delete_attrs(form_class, ("pub", "number", "win_number", "create_time", "intro"))
        form_class.intro = TextAreaField(label=u"奖品介绍", validators=[validators.required(), validators.length(max=256)])

        return form_class

from wtforms import fields, validators
from common import form


UserNameField = lambda: fields.TextField(u"Username",
        [validators.required(), validators.regexp('[-a-zA-Z0-9]+'), validators.length(max=256)])


class RegisterForm(form.Form):
    username = UserNameField()
    password = fields.PasswordField(u"Password", [validators.required()])