Source code for flask_mongoengine.wtf.orm

"""
Tools for generating forms based on mongoengine Document schemas.
"""
import decimal
from collections import OrderedDict
from typing import List, Optional, Type

from bson import ObjectId
from mongoengine import ReferenceField
from mongoengine.base import BaseDocument, DocumentMetaclass
from wtforms import fields as f
from wtforms import validators

from flask_mongoengine.decorators import orm_deprecated
from flask_mongoengine.wtf.fields import (
    BinaryField,
    DictField,
    ModelSelectField,
    ModelSelectMultipleField,
    NoneStringField,
)
from flask_mongoengine.wtf.models import ModelForm

__all__ = (
    "model_fields",
    "model_form",
)


@orm_deprecated
def converts(*args):
    def _inner(func):
        func._converter_for = frozenset(args)
        return func

    return _inner


class ModelConverter(object):
    @orm_deprecated
    def __init__(self, converters=None):
        if not converters:
            converters = {}

        for name in dir(self):
            obj = getattr(self, name)
            if hasattr(obj, "_converter_for"):
                for classname in obj._converter_for:
                    converters[classname] = obj

        self.converters = converters

    @orm_deprecated
    def _generate_convert_base_kwargs(self, field, field_args) -> dict:
        kwargs: dict = {
            "label": getattr(field, "verbose_name", field.name),
            "description": getattr(field, "help_text", None) or "",
            "validators": getattr(field, "wtf_validators", None)
            or getattr(field, "validators", None)
            or [],
            "filters": getattr(field, "wtf_filters", None)
            or getattr(field, "filters", None)
            or [],
            "default": field.default,
        }
        if field_args:
            kwargs.update(field_args)

        # Create a copy of the lists since we will be modifying it, and if
        # validators set as shared list between fields - duplicates/conflicts may
        # be created.
        kwargs["validators"] = list(kwargs["validators"])
        kwargs["filters"] = list(kwargs["filters"])
        if field.required:
            kwargs["validators"].append(validators.InputRequired())
        else:
            kwargs["validators"].append(validators.Optional())

        return kwargs

    @orm_deprecated
    def _process_convert_for_choice_fields(self, field, field_class, kwargs):
        kwargs["choices"] = field.choices
        kwargs["coerce"] = self.coerce(field_class)
        if kwargs.pop("multiple", False):
            return f.SelectMultipleField(**kwargs)
        if kwargs.pop("radio", False):
            return f.RadioField(**kwargs)
        return f.SelectField(**kwargs)

    @orm_deprecated
    def convert(self, model, field, field_args):
        field_class = type(field).__name__

        if field_class not in self.converters:
            return None

        kwargs = self._generate_convert_base_kwargs(field, field_args)

        if field.choices:
            return self._process_convert_for_choice_fields(field, field_class, kwargs)

        if hasattr(field, "field") and isinstance(field.field, ReferenceField):
            kwargs["label_modifier"] = getattr(
                model, f"{field.name}_label_modifier", None
            )

        return self.converters[field_class](model, field, kwargs)

    @classmethod
    def _string_common(cls, model, field, kwargs):
        if field.max_length or field.min_length:
            kwargs["validators"].append(
                validators.Length(
                    max=field.max_length or -1, min=field.min_length or -1
                )
            )

    @classmethod
    def _number_common(cls, model, field, kwargs):
        if field.max_value or field.min_value:
            kwargs["validators"].append(
                validators.NumberRange(max=field.max_value, min=field.min_value)
            )

    @converts("StringField")
    def conv_String(self, model, field, kwargs):
        if field.regex:
            kwargs["validators"].append(validators.Regexp(regex=field.regex))
        self._string_common(model, field, kwargs)
        password_field = kwargs.pop("password", False)
        textarea_field = kwargs.pop("textarea", False) or not field.max_length
        if password_field:
            return f.PasswordField(**kwargs)
        if textarea_field:
            return f.TextAreaField(**kwargs)
        return f.StringField(**kwargs)

    @converts("URLField")
    def conv_URL(self, model, field, kwargs):
        kwargs["validators"].append(validators.URL())
        self._string_common(model, field, kwargs)
        return NoneStringField(**kwargs)

    @converts("EmailField")
    def conv_Email(self, model, field, kwargs):
        kwargs["validators"].append(validators.Email())
        self._string_common(model, field, kwargs)
        return NoneStringField(**kwargs)

    @converts("IntField")
    def conv_Int(self, model, field, kwargs):
        self._number_common(model, field, kwargs)
        return f.IntegerField(**kwargs)

    @converts("FloatField")
    def conv_Float(self, model, field, kwargs):
        self._number_common(model, field, kwargs)
        return f.FloatField(**kwargs)

    @converts("DecimalField")
    def conv_Decimal(self, model, field, kwargs):
        self._number_common(model, field, kwargs)
        kwargs["places"] = getattr(field, "precision", None)
        return f.DecimalField(**kwargs)

    @converts("BooleanField")
    def conv_Boolean(self, model, field, kwargs):
        return f.BooleanField(**kwargs)

    @converts("DateTimeField")
    def conv_DateTime(self, model, field, kwargs):
        return f.DateTimeField(**kwargs)

    @converts("DateField")
    def conv_Date(self, model, field, kwargs):
        return f.DateField(**kwargs)

    @converts("BinaryField")
    def conv_Binary(self, model, field, kwargs):
        # TODO: may be set file field that will save file`s data to MongoDB
        if field.max_bytes:
            kwargs["validators"].append(validators.Length(max=field.max_bytes))
        return BinaryField(**kwargs)

    @converts("DictField")
    def conv_Dict(self, model, field, kwargs):
        return DictField(**kwargs)

    @converts("ListField")
    def conv_List(self, model, field, kwargs):
        if isinstance(field.field, ReferenceField):
            return ModelSelectMultipleField(model=field.field.document_type, **kwargs)
        if field.field.choices:
            kwargs["multiple"] = True
            return self.convert(model, field.field, kwargs)
        field_args = kwargs.pop("field_args", {})
        unbound_field = self.convert(model, field.field, field_args)
        unacceptable = {
            "validators": [],
            "filters": [],
            "min_entries": kwargs.get("min_entries", 0),
        }
        kwargs.update(unacceptable)
        return f.FieldList(unbound_field, **kwargs)

    @converts("SortedListField")
    def conv_SortedList(self, model, field, kwargs):
        # TODO: sort functionality, may be need sortable widget
        return self.conv_List(model, field, kwargs)

    @converts("GeoLocationField")
    def conv_GeoLocation(self, model, field, kwargs):
        # TODO: create geo field and widget (also GoogleMaps)
        return

    @converts("ObjectIdField")
    def conv_ObjectId(self, model, field, kwargs):
        return

    @converts("EmbeddedDocumentField")
    def conv_EmbeddedDocument(self, model, field, kwargs):
        kwargs = {
            "validators": [],
            "filters": [],
            "default": field.default or field.document_type_obj,
        }
        form_class = model_form(field.document_type_obj, field_args={})
        return f.FormField(form_class, **kwargs)

    @converts("ReferenceField")
    def conv_Reference(self, model, field, kwargs):
        return ModelSelectField(model=field.document_type, **kwargs)

    @converts("GenericReferenceField")
    def conv_GenericReference(self, model, field, kwargs):
        return

    @converts("FileField")
    def conv_File(self, model, field, kwargs):
        return f.FileField(**kwargs)

    @orm_deprecated
    def coerce(self, field_type):
        coercions = {
            "IntField": int,
            "BooleanField": bool,
            "FloatField": float,
            "DecimalField": decimal.Decimal,
            "ObjectIdField": ObjectId,
        }
        return coercions.get(field_type, str)


@orm_deprecated
def _get_fields_names(
    model,
    only: Optional[List[str]],
    exclude: Optional[List[str]],
) -> List[str]:
    """
    Filter fields names for further form generation.

    :param model: Source model class for fields list retrieval
    :param only: If provided, only these field names will have fields definition.
    :param exclude: If provided, field names will be excluded from fields definition.
      All other field names will have fields.
    """
    field_names = model._fields_ordered

    if only:
        field_names = [field for field in only if field in field_names]
    elif exclude:
        field_names = [field for field in field_names if field not in set(exclude)]

    return field_names


@orm_deprecated
def model_fields(
    model: Type[BaseDocument],
    only: Optional[List[str]] = None,
    exclude: Optional[List[str]] = None,
    field_args=None,
    converter=None,
) -> OrderedDict:
    """
    Generate a dictionary of fields for a given database model.

    See :func:`model_form` docstring for description of parameters.
    """
    if not issubclass(model, (BaseDocument, DocumentMetaclass)):
        raise TypeError("model must be a mongoengine Document schema")

    converter = converter or ModelConverter()
    field_args = field_args or {}
    form_fields_dict = OrderedDict()
    # noinspection PyTypeChecker
    fields_names = _get_fields_names(model, only, exclude)

    for field_name in fields_names:
        # noinspection PyUnresolvedReferences
        model_field = model._fields[field_name]
        form_field = converter.convert(model, model_field, field_args.get(field_name))
        if form_field is not None:
            form_fields_dict[field_name] = form_field

    return form_fields_dict


@orm_deprecated
def model_form(
    model: Type[BaseDocument],
    base_class: Type[ModelForm] = ModelForm,
    only: Optional[List[str]] = None,
    exclude: Optional[List[str]] = None,
    field_args=None,
    converter=None,
) -> Type[ModelForm]:
    """
    Create a wtforms Form for a given mongoengine Document schema::

        from flask_mongoengine.wtf import model_form
        from myproject.myapp.schemas import Article
        ArticleForm = model_form(Article)

    :param model:
        A mongoengine Document schema class
    :param base_class:
        Base form class to extend from. Must be a :class:`.ModelForm` subclass.
    :param only:
        An optional iterable with the property names that should be included in
        the form. Only these properties will have fields.
        Fields are always appear in provided order, this allows user to change form
        fields ordering, without changing database model.
    :param exclude:
        An optional iterable with the property names that should be excluded
        from the form. All other properties will have fields.
        Fields are appears in order, defined in model, excluding provided fields
        names. For adjusting fields ordering, use :attr:`only`.
    :param field_args:
        An optional dictionary of field names mapping to keyword arguments used
        to construct each field object.
    :param converter:
        A converter to generate the fields based on the model properties. If
        not set, :class:`.ModelConverter` is used.
    """
    field_dict = model_fields(model, only, exclude, field_args, converter)
    field_dict["model_class"] = model
    # noinspection PyTypeChecker
    return type(f"{model.__name__}Form", (base_class,), field_dict)