Esempio n. 1
0
    def convert(self, model, field, field_args):
        kwargs = {
            'label': field.verbose_name,
            'description': field.help_text,
            'validators': [],
            'filters': [],
            'default': field.default,
        }
        if field_args:
            kwargs.update(field_args)

        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))

        ftype = type(field).__name__
        if field.choices:
            kwargs['choices'] = field.choices
            return f.SelectField(widget=form.ChosenSelectWidget(), **kwargs)
        elif ftype in self.converters:
            return self.converters[ftype](model, field, kwargs)
        else:
            converter = getattr(self, 'conv_%s' % ftype, None)
            if converter is not None:
                return converter(model, field, kwargs)
Esempio n. 2
0
 def conv_ForeignKey(self, model, field, kwargs):
     return ModelSelectField(widget=form.ChosenSelectWidget(),
                             model=field.rel.to,
                             **kwargs)
Esempio n. 3
0
    def convert(self, model, mapper, prop, field_args, *args):
        kwargs = {'validators': [], 'filters': []}

        if field_args:
            kwargs.update(field_args)

        if hasattr(prop, 'direction'):
            remote_model = prop.mapper.class_
            local_column = prop.local_remote_pairs[0][0]

            kwargs.update({
                'allow_blank':
                local_column.nullable,
                'label':
                self._get_label(prop.key, kwargs),
                'query_factory':
                lambda: self.view.session.query(remote_model)
            })
            if local_column.nullable:
                kwargs['validators'].append(validators.Optional())
            elif prop.direction.name not in ('MANYTOMANY', 'ONETOMANY'):
                kwargs['validators'].append(validators.Required())

            # Override field type if necessary
            override = self._get_field_override(prop.key)
            if override:
                return override(**kwargs)

            if prop.direction.name == 'MANYTOONE':
                return QuerySelectField(widget=form.ChosenSelectWidget(),
                                        **kwargs)
            elif prop.direction.name == 'ONETOMANY':
                # Skip backrefs
                if not local_column.foreign_keys and self.view.hide_backrefs:
                    return None

                return QuerySelectMultipleField(
                    widget=form.ChosenSelectWidget(multiple=True), **kwargs)
            elif prop.direction.name == 'MANYTOMANY':
                return QuerySelectMultipleField(
                    widget=form.ChosenSelectWidget(multiple=True), **kwargs)
        else:
            # Ignore pk/fk
            if hasattr(prop, 'columns'):
                column = prop.columns[0]

                # Do not display foreign keys - use relations
                if column.foreign_keys:
                    return None

                unique = False

                if column.primary_key:
                    # By default, don't show primary keys either
                    if self.view.fields is None:
                        return None

                    # If PK is not explicitly allowed, ignore it
                    if prop.key not in self.view.fields:
                        return None

                    kwargs['validators'].append(
                        Unique(self.view.session, model, column))
                    unique = True

                # If field is unique, validate it
                if column.unique and not unique:
                    kwargs['validators'].append(
                        Unique(self.view.session, model, column))

                if column.nullable:
                    kwargs['validators'].append(validators.Optional())
                else:
                    kwargs['validators'].append(validators.Required())

            # Apply label
            kwargs['label'] = self._get_label(prop.key, kwargs)

            # Override field type if necessary
            override = self._get_field_override(prop.key)
            if override:
                return override(**kwargs)

            return super(AdminModelConverter,
                         self).convert(model, mapper, prop, kwargs)