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 test_optional(self):
     self.assertEqual(optional()(self.form, DummyField("foobar", raw_data=["foobar"])), None)
     self.assertRaises(StopValidation, optional(), self.form, DummyField("", raw_data=[""]))
     self.assertRaises(StopValidation, optional(), self.form, DummyField(" ", raw_data=[" "]))
     self.assertEqual(optional().field_flags, ("optional",))
     f = DummyField("", ["Invalid Integer Value"], raw_data=[""])
     self.assertEqual(len(f.errors), 1)
     self.assertRaises(StopValidation, optional(), self.form, f)
     self.assertEqual(len(f.errors), 0)

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

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 load_filters(cls, filters):
        '''Load Filter Fields
            Init a filter form using filter settings

        arguments:
            filters: a dict list with information to form a filter
            with format for each item:
                0. id: unique english name for field
                1. name: always same as the colums name to be filtered
                2. type: using following types
                            - str:  this type will only be used for search
                            - float:  this type will only be filtered
                                      with a min and max val
                            - date:  this type will only be filtered with
                                     an earliest date and a latest date

        throw a INVALID_FILTER_FORMAT error when filters not obey this rule
        '''
        must_keys = ('id', 'name', 'type')

        # check if filters' format is correct
        for item in filters:
            for mk in must_keys:
                if mk not in item.keys():
                    raise AppError('INVALID_FILTER_FORMAT')

        # init the filter
        for item in filters:
            if item['type'] == 'str':
                setattr(cls, item['id'], TextField(item['name']))
            if item['type'] == 'float':
                setattr(cls,
                        '{}_min'.format(item['id']),
                        DecimalField('min value of {}'.format(item['name']),
                                     [validators.optional()]))
                setattr(cls,
                        '{}_max'.format(item['id']),
                        DecimalField('max value of {}'.format(item['name']),
                                     [validators.optional()]))
            if item['type'] == 'date':
                setattr(cls,
                        '{}_earlier'.format(item['id']),
                        DateField('earlier {}'.format(item['name']),
                                  [validators.optional()]))
                setattr(cls,
                        '{}_later'.format(item['id']),
                        DateField('later {}'.format(item['name']),
                                  [validators.optional()]))

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 scaffold_form(self):
        class NewForm(Form):
            pass

        if self.create_form_class is None:
            return NewForm

        for field in self.create_form_class.DESCRIPTOR.fields:

            if self.form_excluded_columns and field.name in self.form_excluded_columns:
                continue

            field_type = field.type

            if field_type == 11:  # Todo: handle "message" type, which is a nested object
                continue

            FormClass = wtforms_type_map[field_type]
            description = self.swagger['definitions'][
                'lnrpc' + self.create_form_class.__name__]['properties'][
                field.name]
            description = description.get('title') or description.get(
                'description')
            if description:
                description = description.replace('/ ', '')
            form_field = FormClass(field.name,
                                   default=field.default_value or None,
                                   description=description,
                                   validators=[validators.optional()]
                                   )
            setattr(NewForm, field.name, form_field)
        return NewForm

    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 __init__(self, **kwargs):
     defaults = dict(
         icon='calendar',
         validators=[optional()],
         widget_classes="form-control"
     )
     defaults.update(kwargs)
     super(Date, self).__init__(**defaults)

 def __init__(self, **kwargs):
     warnings.warn("Field has been deprecated", PendingDeprecationWarning)
     defaults = dict(icon='flag',
                     export_key='language',
                     validators=[optional()],
                     widget_classes="form-control")
     defaults.update(kwargs)
     super(LanguageField, self).__init__(**defaults)

def client_global_edit(client_id, dev_id):
    with app.db.session_scope():
        dev = app.db.get_device(dev_id)
        known_items = {}
        class F(Form):
            pass
        for item in dev["parameters"]:
            item = dev["parameters"][item]
            default = item["value"]
            arguments = [Required()]
            # keep track of the known fields
            known_items[item["key"]] = {u"id": item["id"], u"type": item["type"]}
            # build the field
            if item["type"] == "boolean":
                if default == 'y' or default == 1 or default == True: # in db value stored in lowcase
                    default = True
                else:
                    default = False
                field = BooleanField(item["key"], [validators.optional()], default=default) # set to optional field due to WTForm BooleanField return no data for false value (HTML checkbox)
            elif item["type"] == "integer":
                field = IntegerField(item["key"], arguments, default=default)
            elif item["type"] == "float":
                field = DateTimeField(item["key"], arguments, default=default)
            else:
                # time, email, ipv4, ipv6, url
                field = TextField(item["key"], arguments, default=default)
            # add the field
            setattr(F, "{0}-{1}".format(item["id"], item["key"]), field)
        form = F()
        if request.method == 'POST' and form.validate():
            for key, item in known_items.iteritems():
                val = getattr(form, "{0}-{1}".format(item["id"], key)).data
                if item["type"] == "boolean":
                    if val == False:
                        val = 'n' # in db value stored in lowcase
                    else:
                        val = 'y' # in db value stored in lowcase
                app.db.udpate_device_param(item["id"], value=val)
            return redirect("/client/{0}/dmg_devices/known".format(client_id))
            pass
        else:
                return render_template('client_global.html',
                form = form,
                clientid = client_id,
                client_detail = get_client_detail(client_id),
                mactive="clients",
                active = 'devices',
                device = dev)

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

        # Test for whitespace behavior.
        whitespace_field = DummyField(' ', raw_data=[' '])
        self.assertRaises(StopValidation, optional(), self.form, whitespace_field)
        self.assertEqual(optional(strip_whitespace=False)(self.form, whitespace_field), None)

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

        # Test for whitespace behavior.
        whitespace_field = DummyField(" ", raw_data=[" "])
        self.assertRaises(StopValidation, optional(), self.form, whitespace_field)
        self.assertEqual(optional(strip_whitespace=False)(self.form, whitespace_field), None)

    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)

#.........这里部分代码省略.........
                    ('.3%', '".3%" | 1234543.210%'),
                    ('.4r', '".4r" | 12350'),
                    ('.3f', '".3f" | 12345.432'),
                    ('+,', '"+," | +12,345.4321'),
                    ('$,.2f', '"$,.2f" | $12,345.43'),
                ],
                "description": _("D3 format syntax for numbers "
                            "https: //github.com/mbostock/\n"
                            "d3/wiki/Formatting")
            }),
            'row_limit': (FreeFormSelectField, {
                "label": _('Row limit'),
                "default": config.get("ROW_LIMIT"),
                "choices": self.choicify(
                    [10, 50, 100, 250, 500, 1000, 5000, 10000, 50000])
            }),
            'limit': (FreeFormSelectField, {
                "label": _('Series limit'),
                "choices": self.choicify(self.series_limits),
                "default": 50,
                "description": _(
                    "Limits the number of time series that get displayed")
            }),
            'rolling_type': (SelectField, {
                "label": _("Rolling"),
                "default": 'None',
                "choices": [(s, s) for s in ['None', 'mean', 'sum', 'std', 'cumsum']],
                "description": _(
                    "Defines a rolling window function to apply, works along "
                    "with the [Periods] text box")
            }),
            'rolling_periods': (IntegerField, {
                "label": _("Periods"),
                "validators": [validators.optional()],
                "description": _(
                    "Defines the size of the rolling window function, "
                    "relative to the time granularity selected")
            }),
            'series': (SelectField, {
                "label": _("Series"),
                "choices": group_by_choices,
                "default": default_groupby,
                "description": _(
                    "Defines the grouping of entities. "
                    "Each serie is shown as a specific color on the chart and "
                    "has a legend toggle")
            }),
            'entity': (SelectField, {
                "label": _("Entity"),
                "choices": group_by_choices,
                "default": default_groupby,
                "description": _("This define the element to be plotted on the chart")
            }),
            'x': (SelectField, {
                "label": _("X Axis"),
                "choices": datasource.metrics_combo,
                "default": default_metric,
                "description": _("Metric assigned to the [X] axis")
            }),
            'y': (SelectField, {
                "label": _("Y Axis"),
                "choices": datasource.metrics_combo,
                "default": default_metric,
                "description": _("Metric assigned to the [Y] axis")
            }),
            'size': (SelectField, {

 def __init__(self, viz):
     self.viz = viz
     from panoramix.viz import viz_types
     viz = self.viz
     datasource = viz.datasource
     default_metric = datasource.metrics_combo[0][0]
     default_groupby = datasource.groupby_column_names[0]
     group_by_choices = [(s, s) for s in datasource.groupby_column_names]
     # Pool of all the fields that can be used in Panoramix
     self.field_dict = {
         'viz_type': SelectField(
             'Viz',
             default='table',
             choices=[(k, v.verbose_name) for k, v in viz_types.items()],
             description="The type of visualization to display"),
         'metrics': SelectMultipleField(
             'Metrics', choices=datasource.metrics_combo,
             default=[default_metric],
             description="One or many metrics to display"),
         'metric': SelectField(
             'Metric', choices=datasource.metrics_combo,
             default=default_metric,
             description="One or many metrics to display"),
         'groupby': SelectMultipleField(
             'Group by',
             choices=self.choicify(datasource.groupby_column_names),
             description="One or many fields to group by"),
         'granularity': TextField(
             'Time Granularity', default="one day",
             description=(
                 "The time granularity for the visualization. Note that you "
                 "can type and use simple natural language as in '10 seconds', "
                 "'1 day' or '56 weeks'")),
         'since': TextField(
             'Since', default="7 days ago", description=(
                 "Timestamp from filter. This supports free form typing and "
                 "natural language as in '1 day ago', '28 days' or '3 years'")),
         'until': TextField('Until', default="now"),
         'row_limit':
             SelectField(
                 'Row limit',
                 default=config.get("ROW_LIMIT"),
                 choices=self.choicify(self.row_limits)),
         'limit':
             SelectField(
                 'Series limit',
                 choices=self.choicify(self.series_limits),
                 default=50,
                 description=(
                     "Limits the number of time series that get displayed")),
         'rolling_type': SelectField(
             'Rolling',
             default='mean',
             choices=[(s, s) for s in ['mean', 'sum', 'std']],
             description=(
                 "Defines a rolling window function to apply")),
         'rolling_periods': IntegerField(
             'Periods',
             validators=[validators.optional()],
             description=(
             "Defines the size of the rolling window function, "
             "relative to the 'granularity' field")),
         'series': SelectField(
             'Series', choices=group_by_choices,
             default=default_groupby,
             description=(
                 "Defines the grouping of entities. "
                 "Each serie is shown as a specific color on the chart and "
                 "has a legend toggle")),
         'entity': SelectField('Entity', choices=group_by_choices,
             default=default_groupby,
             description="This define the element to be plotted on the chart"),
         'x': SelectField(
             'X Axis', choices=datasource.metrics_combo,
             default=default_metric,
             description="Metric assigned to the [X] axis"),
         'y': SelectField('Y Axis', choices=datasource.metrics_combo,
             default=default_metric,
             description="Metric assigned to the [Y] axis"),
         'size': SelectField(
                 'Bubble Size',
                 default=default_metric,
                 choices=datasource.metrics_combo),
         'where': TextField('Custom WHERE clause', default=''),
         'compare_lag': TextField('Comparison Period Lag',
             description="Based on granularity, number of time periods to compare against"),
         'compare_suffix': TextField('Comparison suffix',
             description="Suffix to apply after the percentage display"),
         'markup_type': SelectField(
             "Markup Type",
             choices=self.choicify(['markdown', 'html']),
             default="markdown",
             description="Pick your favorite markup language"),
         'rotation': SelectField(
             "Rotation",
             choices=[(s, s) for s in ['random', 'flat', 'square']],
             default="random",
             description="Rotation to apply to words in the cloud"),
         'line_interpolation': SelectField(
             "Line Interpolation",
#.........这里部分代码省略.........

def vytvor_formular_pre_manazovanie_studentov(studenti_predmetu):
	class F(Form):
		pass

	count=0
	
	for student_predmetu in studenti_predmetu:

		#konecna znamka
		setattr(F, 'select0_%d'%count, SelectField(student_predmetu.student.user.priezvisko,
	                                    validators=[validators.optional()],
	                                    choices=[('A', 'A'), ('B', 'B'), ('C', 'C'),
	                                     ('D', 'D'), ('E', 'E'), ('FX', 'FX'),
	                                     ('n/a', 'n/a')],
	                                     default=student_predmetu.konecna_znamka if student_predmetu.konecna_znamka is not None else 'FX'))
		setattr(F, 'body_za_semester_%d'%count, TextField("", validators=[validators.optional()], 
								default=student_predmetu.body_za_semester if student_predmetu.body_za_semester is not None else 0))

		setattr(F, 'select1_%d'%count, SelectField(student_predmetu.student.user.priezvisko,
	                                    validators=[validators.optional()],
	                                    choices=[('A', 'A'), ('B', 'B'), ('C', 'C'),
	                                     ('D', 'D'), ('E', 'E'), ('FX', 'FX'),
	                                     ('n/a', 'n/a')],
	                                     default=student_predmetu.znamka1 if student_predmetu.znamka1 is not None else 'FX'))
		setattr(F, 'poznamka1_%d'%count, TextField("", validators=[validators.optional()],default=student_predmetu.poznamka1))
		setattr(F, 'datum1_%d'%count, TextField("", validators=[validators.optional()],
			default=student_predmetu.datum1.strftime("%x") if student_predmetu.datum1 else ""))


		setattr(F, 'select2_%d'%count, SelectField(student_predmetu.student.user.priezvisko,
	                                    validators=[validators.optional()],
	                                    choices=[('A', 'A'), ('B', 'B'), ('C', 'C'),
	                                     ('D', 'D'), ('E', 'E'), ('FX', 'FX'),
	                                     ('n/a', 'n/a')],
	                                     default=student_predmetu.znamka2 if student_predmetu.znamka2 is not None else 'FX'))
		setattr(F, 'poznamka2_%d'%count, TextField("", validators=[validators.optional()],default=student_predmetu.poznamka2))
		setattr(F, 'datum2_%d'%count, TextField("", validators=[validators.optional()],
			default=student_predmetu.datum2.strftime("%x") if student_predmetu.datum2 else ""))


		setattr(F, 'select3_%d'%count, SelectField(student_predmetu.student.user.priezvisko,
	                                    validators=[validators.optional()],
	                                    choices=[('A', 'A'), ('B', 'B'), ('C', 'C'),
	                                     ('D', 'D'), ('E', 'E'), ('FX', 'FX'),
	                                     ('n/a', 'n/a')],
	                                     default=student_predmetu.znamka3 if student_predmetu.znamka3 is not None else 'FX'))
		setattr(F, 'poznamka3_%d'%count, TextField("", validators=[validators.optional()],default=student_predmetu.poznamka3))
		setattr(F, 'datum3_%d'%count, TextField("", validators=[validators.optional()],
			default=student_predmetu.datum3.strftime("%x") if student_predmetu.datum3 else ""))

		count +=1
	return F()

def client_global_edit(client_id, dev_id):
    with app.db.session_scope():
        dev = app.db.get_device(dev_id)
        known_items = {}
        class F(Form):
            pass
        for item in dev["parameters"]:
            item = dev["parameters"][item]
            default = item["value"]
            arguments = [InputRequired()]
            # keep track of the known fields
            known_items[item["key"]] = {u"id": item["id"], u"type": item["type"]}
            # build the field
            if item["type"] == "boolean":
                if default == 'y' or default == 1 or default == True: # in db value stored in lowcase
                    #default = True
                    default = 'y'
                else:
                    #default = False
                    default = 'n'
                #field = BooleanField(item["key"], [validators.optional()], default=default) # set to optional field due to WTForm BooleanField return no data for false value (HTML checkbox)
                field = RadioField( item["key"], 
                                [validators.optional()],
                                choices=[('y', 'Yes'), ('n', 'No')], default=default
                              )
            elif item["type"] == "integer":
                field = IntegerField(item["key"], arguments, default=default)
            elif item["type"] == "datetime":
                field = DateTimeField(item["key"], arguments, default=default)
            elif item["type"] == "float":
                field = FloatField(item["key"], arguments, default=default)
            else:
                # time, email, ipv4, ipv6, url
                field = TextField(item["key"], arguments, default=default)
            # add the field
            setattr(F, "{0}-{1}".format(item["id"], item["key"]), field)
        form = F()
        if request.method == 'POST' and form.validate():
            for key, item in known_items.items():
                val = getattr(form, "{0}-{1}".format(item["id"], key)).data
                if item["type"] == "boolean":
                    if val == 'n':
                        val = 'n' # in db value stored in lowcase
                    else:
                        val = 'y' # in db value stored in lowcase
                cli = MQSyncReq(app.zmq_context)
                msg = MQMessage()
                msg.set_action('deviceparam.update')
                msg.add_data('dpid', item["id"])
                msg.add_data('value', val)
                res = cli.request('dbmgr', msg.get(), timeout=10)
                if res is not None:
                    data = res.get_data()
                    if data["status"]:
                        flash(gettext("Param update succesfully"), 'success')
                    else:
                        flash(gettext("Param update failed"), 'warning')
                        flash(data["reason"], 'danger')
                else:
                    flash(gettext("DbMgr did not respond on the deviceparam.update, check the logs"), 'danger')
            return redirect("/client/{0}/dmg_devices/known".format(client_id))
            pass
        else:
                return render_template('client_global.html',
                form = form,
                clientid = client_id,
                client_detail = get_client_detail(client_id),
                mactive="clients",
                active = 'devices',
                device = dev)

def generate_submission_edit_form_class(form):
    form_fields = {}
    STATUS_CHOICES = (
        ('', _('Unmarked')),
        ('confirmed', _('Confirmed')),
        ('rejected', _('Rejected')),
        ('citizen', _('Citizen Report')),
    )
    WITNESS_CHOICES = (
        ('', _('Unspecified')),
        ('witnessed', _('I witnessed the incident')),
        ('after', _('I arrived just after the incident')),
        ('reported', _('The incident was reported to me by someone else')),
    )

    form_fields['contributor'] = CustomModelSelectField(
        _('Participant'),
        allow_blank=True,
        blank_text=_('Participant'),
        widget=widgets.HiddenInput(),
        validators=[validators.optional()],
        model=Participant,
        queryset=participants.find()
        )

    form_fields['location'] = CustomModelSelectField(
        _('Location'),
        allow_blank=True,
        blank_text=_('Location'),
        widget=widgets.HiddenInput(),
        model=Location,
        queryset=locations.find()
        )

    for index, group in enumerate(form.groups):
        for field in group.fields:
            if field.options:
                choices = [(v, k) for k, v in field.options.iteritems()]

                if field.allows_multiple_values:
                    form_fields[field.name] = SelectMultipleField(
                        field.name,
                        choices=choices,
                        coerce=int,
                        description=field.description,
                        validators=[validators.optional()],
                        option_widget=widgets.CheckboxInput(),
                        widget=widgets.ListWidget()
                    )
                else:
                    form_fields[field.name] = IntegerField(
                        field.name,
                        description=field.description,
                        validators=[
                            validators.optional(),
                            validators.AnyOf([v for v, k in choices])],
                        widget=widgets.TextInput()
                    )
            else:
                if form.form_type == 'CHECKLIST':
                    form_fields[field.name] = IntegerField(
                        field.name,
                        description=field.description,
                        validators=[
                            validators.optional(),
                            validators.NumberRange(min=field.min_value,
                                                   max=field.max_value)]
                    )
                else:
                    form_fields[field.name] = BooleanField(
                        field.name,
                        description=field.description,
                        filters=[lambda data: 1 if data else None],
                        validators=[validators.optional()]
                    )

    if form.form_type == 'INCIDENT':
        form_fields['status'] = SelectField(
            choices=STATUS_CHOICES,
            filters=[lambda data: data if data else None],
            validators=[validators.optional()]
        )
        form_fields['witness'] = SelectField(
            choices=WITNESS_CHOICES,
            validators=[validators.optional()]
        )
        form_fields['description'] = StringField(
            widget=widgets.TextArea()
        )

    return type(
        'SubmissionEditForm',
        (WTSecureForm,),
        form_fields
    )

#.........这里部分代码省略.........
             description=(
                 "Timestamp from filter. This supports free form typing and "
                 "natural language as in '1 day ago', '28 days' or '3 years'")),
         'until': FreeFormSelectField('Until', default="now",
             choices=self.choicify([
                 'now',
                 '1 day ago',
                 '7 days ago',
                 '28 days ago',
                 '90 days ago',
                 '1 year ago'])
             ),
         'row_limit':
             SelectField(
                 'Row limit',
                 default=config.get("ROW_LIMIT"),
                 choices=self.choicify(self.row_limits)),
         'limit':
             SelectField(
                 'Series limit',
                 choices=self.choicify(self.series_limits),
                 default=50,
                 description=(
                     "Limits the number of time series that get displayed")),
         'rolling_type': SelectField(
             'Rolling',
             default='None',
             choices=[(s, s) for s in ['None', 'mean', 'sum', 'std', 'cumsum']],
             description=(
                 "Defines a rolling window function to apply, works along "
                 "with the [Periods] text box")),
         'rolling_pe