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

 def test_required(self):
     self.assertEqual(required()(self.form, DummyField("foobar")), None)
     self.assertRaises(StopValidation, required(), self.form, DummyField(""))
     self.assertRaises(StopValidation, required(), self.form, DummyField(" "))
     self.assertEqual(required().field_flags, ("required",))
     f = DummyField("", ["Invalid Integer Value"])
     self.assertEqual(len(f.errors), 1)
     self.assertRaises(StopValidation, required(), self.form, f)
     self.assertEqual(len(f.errors), 0)

 def test_required(self):
     self.assertEqual(required()(self.form, DummyField('foobar')), None)
     self.assertRaises(StopValidation, required(), self.form, DummyField(''))
     self.assertRaises(StopValidation, required(), self.form, DummyField(' '))
     self.assertEqual(required().field_flags, ('required', ))
     f = DummyField('', ['Invalid Integer Value'])
     self.assertEqual(len(f.errors), 1)
     self.assertRaises(StopValidation, required(), self.form, f)
     self.assertEqual(len(f.errors), 0)

 def set_validators(column):
     vldts=[]
     for key,val in column.iteritems():
         if key == 'notnull':
             if val == 0:
                 self.vldts + validators.required()
     return vldts

def field_factory(attr):
        kwargs = defaultdict(list)
        kwargs['id'] = attr.name
        kwargs['label'] = attr.comment
        if attr.in_key: kwargs['validators'].append(required())
        if attr.nullable or attr.default is not None:
            kwargs['validators'].append(optional())
        if attr.type.startswith('int'):
            return wtf.IntegerField(**kwargs)
        elif attr.type == 'double' or attr.type == 'float':
            return wtf.FloatField(**kwargs)
        elif attr.type.startswith('varchar'):
            ml = int(attr.type.split('(')[-1][:-1])
            return wtf.StringField(**kwargs) # TODO: can I specify a max length here?
        elif attr.type == 'date':
            kwargs['validators'].append(date_validator)
            return wtf.DateField(format='%Y-%m-%d', default=datetime.date.today(), **kwargs)
        elif attr.type.startswith('enum'):
            choices = [(e[1:-1],e[1:-1]) for e in attr.type[attr.type.find('(')+1:attr.type.rfind(')')].split(',')]
            return wtf.SelectField(choices=choices, **kwargs)
        elif attr.type.startswith('char'):
            l = int(attr.type.split('(')[-1][:-1])
            kwargs['validators'].append(len_validator_factory(l))
            return wtf.StringField(**kwargs) # TODO: can I specify a max length here?
        elif attr.type == 'timestamp':
            return wtf.DateTimeField(format='%Y-%m-%d %H:%M', default=datetime.datetime.today(), **kwargs)
        else:
            raise NotImplementedError('FieldFactory does not know what to do with %s' % (attr.type))

 def setUp(self):
     F = make_form(
         a=TextField(validators=[validators.required()]),
         b=TextField(),
     )
     self.F1 = make_form('F1', a=FormField(F))
     self.F2 = make_form('F2', a=FormField(F, separator='::'))

    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

 def postprocess_form(self, form):
     form.product_id = Select2Field(_("Product"), default=0,
         choices=[(g.id, g.customer.customer_name + " " + g.product_name +
             " " + str(g.specification) + "")
             for g in Product.query.filter_by(active=True)
         .order_by("customer_id")
         .order_by('product_name')],
         coerce=int, validators=[required()])
     form.inventory_location_id = Select2Field(_("Inventory Location"),
         default=0, choices=[(g.id, g.location_full_name) for g in
         InventoryLocation.query.filter_by(active=True).
         order_by('location_name')],
         coerce=int, validators=[required()])
     form.quantity = IntegerField(_("Quantity"), validators=[required()],
         default=1)
     return form

    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(self, model, prop, field_args):
        """
        Returns a form field for a single model property.

        :param model:
            The ``db.Model`` class that contains the property.
        :param prop:
            The model property: a ``db.Property`` instance.
        :param field_args:
            Optional keyword arguments to construct the field.
        """
        prop_type_name = type(prop).__name__
        kwargs = {
            'label': prop.name.replace('_', ' ').title(),
            'default': prop.default_value(),
            'validators': [],
        }
        if field_args:
            kwargs.update(field_args)

        if prop.required and prop_type_name not in self.NO_AUTO_REQUIRED:
            kwargs['validators'].append(validators.required())

        if prop.choices:
            # Use choices in a select field if it was not provided in field_args
            if 'choices' not in kwargs:
                kwargs['choices'] = [(v, v) for v in prop.choices]
            return f.SelectField(**kwargs)
        else:
            converter = self.converters.get(prop_type_name, None)
            if converter is not None:
                return converter(model, prop, kwargs)

def formfield_from_modelfield(field):
    field_type = field.__class__.__name__.lower()
    opts = {
        'validators': []
    }

    default = getattr(field, 'default', odis.EMPTY)

    if field_type == 'relfield':
        opts['queryset'] = field.model.obj.all()

    if is_coll_field(field):
        opts['validators'].append(validators.optional())
    elif default != odis.EMPTY or getattr(field, 'nil', False):
        opts['validators'].append(validators.optional())
    else:
        opts['validators'].append(validators.required())

    if default != odis.EMPTY:
        opts['default'] = default

    if getattr(field, 'choices', False):
        opts['choices'] = field.choices

    opts['label'] = field.verbose_name or field.name

    if 'choices' in opts:
        form_field = fields.SelectField
        #opts['coerce'] = field.to_python
    else:
        form_field = fields_table[field_type]

    return form_field(**opts)

    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 __init__(self, *args, **kwargs):
        super(AddProjectForm, self).__init__(*args, **kwargs)

        project_types = ProjectTypes.query.all()
        self.project_type_id.choices = [(u.id, u.name) for u in project_types]

        # additional validators
        self.project_type_id.validators = [validators.required()]

def build_questionnaire(form, data=None):
    fields = {'groups': []}
    fields['participant'] = StringField(
        u'Participant',
        filters=[partial(filter_participants, form)],
        validators=[validators.required()])

    for group in form.groups:
        groupspec = (group.name, [])

        for field in group.fields:
            # if the field has options, create a list of choices
            if field.options:
                choices = [(v, k) for k, v in field.options.iteritems()]

                if field.allows_multiple_values:
                    fields[field.name] = IntegerSplitterField(
                        field.name,
                        choices=choices,
                        description=field.description,
                        validators=[validators.optional()],
                    )
                else:
                    fields[field.name] = SelectField(
                        field.name,
                        choices=choices,
                        coerce=int,
                        description=field.description,
                        validators=[validators.optional()],
                        widget=widgets.TextInput()
                    )
            else:
                if form.form_type == 'CHECKLIST':
                    fields[field.name] = IntegerField(
                        field.name,
                        description=field.description,
                        validators=[
                            validators.optional(),
                            validators.NumberRange(min=field.min_value,
                                                   max=field.max_value)]
                    )
                else:
                    fields[field.name] = IntegerField(
                        field.name,
                        description=field.description,
                        validators=[validators.optional()]
                    )

        fields['groups'].append(groupspec)

    form_class = type('QuestionnaireForm', (BaseQuestionnaireForm,), fields)


    return form_class(data)

    def convert(self, model, prop, field_args):
        """
        Returns a form field for a single model property.

        :param model:
            The ``db.Model`` class that contains the property.
        :param prop:
            The model property: a ``db.Property`` instance.
        :param field_args:
            Optional keyword arguments to construct the field.
        """

        prop_type_name = type(prop).__name__

        # Check for generic property
        if(prop_type_name == "GenericProperty"):
            # Try to get type from field args
            generic_type = field_args.get("type")
            if generic_type:
                prop_type_name = field_args.get("type")

            # If no type is found, the generic property uses string set in convert_GenericProperty

        kwargs = {
            'label': prop._code_name.replace('_', ' ').title(),
            'default': prop._default,
            'validators': [],
        }
        if field_args:
            kwargs.update(field_args)

        if prop._required and prop_type_name not in self.NO_AUTO_REQUIRED:
            kwargs['validators'].append(validators.required())

        if kwargs.get('choices', None):
            # Use choices in a select field.
            kwargs['choices'] = [(v, v) for v in kwargs.get('choices')]
            return f.SelectField(**kwargs)

        if prop._choices:
            # Use choices in a select field.
            kwargs['choices'] = [(v, v) for v in prop._choices]
            return f.SelectField(**kwargs)

        else:
            converter = self.converters.get(prop_type_name, None)
            if converter is not None:
                return converter(model, prop, kwargs)
            else:
                return self.fallback_converter(model, prop, kwargs)

        def __init__(cls,**kwargs):
            super(AddEntryForm,cls).__init__(**kwargs)
            #
            columns = [c for c in kwargs['columns'] if c['pk'] == 0]
            colnames = [c['name'] for c in columns]
            #self._fields = {}
            _table = kwargs['table']
            #
            for column in columns:
                vldts = []
                if column['notnull'] == 1:
                    vldts.append(validators.required())
                setattr(cls,column['name'],None)

                if column['type'] == 'integer':

    def convert(self, model, prop, field_args):
        """
        Returns a form field for a single model property.

        :param model:
            The ``db.Model`` class that contains the property.
        :param prop:
            The model property: a ``db.Property`` instance.
        :param field_args:
            Optional keyword arguments to construct the field.
        """

        name = prop._code_name
        #if prop.verbose_name:
        #    name = prop.verbose_name
        kwargs = {
            'label': name.replace('_', ' ').title(),
            'default': prop._default,
            'validators': [],
        }
        choices = None
        #default = None
        if field_args:
            choices = field_args.get("choices", None)
            if choices:
                del field_args["choices"]
            kwargs.update(field_args)

        if prop._required:
            kwargs['validators'].append(validators.required())

        if prop._choices:
            # Use choices in a select field.
            kwargs['choices'] = [(v, v) for v in prop._choices]
            return f.SelectField(**kwargs)

        if choices:
            kwargs['choices'] = [(v, v) for v in choices]
            field = f.SelectField(**kwargs)
            #field.process_data(default)
            return field
        else:
            converter = self.converters.get(type(prop).__name__, None)
            if converter is not None:
                return converter(model, prop, kwargs)

    def convert(self, model, prop, field_args):
        """
        Returns a form field for a single model property.

        :param model:
            The ``db.Model`` class that contains the property.
        :param prop:
            The model property: a ``db.Property`` instance.
        :param field_args:
            Optional keyword arguments to construct the field or an
            UnboundField instance (i.e. Field declaration).
        """
        if isinstance(field_args, UnboundField):
            return field_args

        prop_type_name = self.get_prop_type_name(prop, field_args)

        kwargs = {
            'label': prop._code_name.replace('_', ' ').title(),
            'default': prop._default,
            'validators': [],
        }
        if field_args:
            kwargs.update(field_args)

        if prop._required and prop_type_name not in self.NO_AUTO_REQUIRED:
            kwargs['validators'].append(validators.required())

        if kwargs.get('choices', None) or prop._choices:
            # Use choices in a select field.
            if not kwargs.get('choices', None):
                kwargs['choices'] = [(v, v) for v in sorted(prop._choices)]

            if prop._repeated:
                return f.SelectMultipleField(**kwargs)
            else:
                return f.SelectField(**kwargs)

        else:
            converter = self.get_converter(
                prop_type_name,
                prop,
                field_args)

            return converter(model, prop, 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))