lib.itmens/common/forms.py

from django import forms
from markdownx.fields import MarkdownxFormField
import django.contrib.postgres.forms as postgres
from django.utils import formats
from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _
import json


class KeyValueInput(forms.Widget):
    """
    Input widget for Json field
    """

    template_name = "widgets/hstore.html"

    def get_context(self, name, value, attrs):
        context = super().get_context(name, value, attrs)
        data = None
        if context["widget"]["value"] is not None:
            data = json.loads(context["widget"]["value"])
        context["widget"]["value"] = (
            [{p[0]: p[1]} for p in data.items()] if data else []
        )
        return context

    class Media:
        js = ("js/key_value_input.js",)


class HstoreInput(forms.Widget):
    """
    Input widget for Hstore field
    """

    template_name = "widgets/hstore.html"

    def format_value(self, value):
        """
        Return a value as it should appear when rendered in a template.
        """
        if value == "" or value is None:
            return None
        if self.is_localized:
            return formats.localize_input(value)
        # do not return str
        return value

    class Media:
        js = ("js/key_value_input.js",)


class JSONField(forms.fields.JSONField):
    widget = KeyValueInput

    def to_python(self, value):
        if not value:
            return None
        j = {}
        if isinstance(value, dict):
            j = value
        else:
            pairs = json.loads("[" + value + "]")
            if isinstance(pairs, dict):
                j = pairs
            else:
                # list or tuple
                for pair in pairs:
                    j = {**j, **pair}
        return super().to_python(j)


class RadioBooleanField(forms.ChoiceField):
    widget = forms.RadioSelect

    def to_python(self, value):
        """Return a Python boolean object."""
        # Explicitly check for the string 'False', which is what a hidden field
        # will submit for False. Also check for '0', since this is what
        # RadioSelect will provide. Because bool("True") == bool('1') == True,
        # we don't need to handle that explicitly.
        if isinstance(value, str) and value.lower() in ("false", "0"):
            value = False
        else:
            value = bool(value)
        return value


class RatingValidator:
    """empty value is not validated"""

    def __call__(self, value):
        if not isinstance(value, int):
            raise ValidationError(
                _("%(value)s is not an integer"),
                params={"value": value},
            )
        if not str(value) in [str(i) for i in range(0, 11)]:
            raise ValidationError(
                _("%(value)s is not an integer in range 1-10"),
                params={"value": value},
            )


class PreviewImageInput(forms.FileInput):
    template_name = "widgets/image.html"

    def format_value(self, value):
        """
        Return the file object if it has a defined url attribute.
        """
        if self.is_initial(value):
            if value.url:
                return value.url
            else:
                return

    def is_initial(self, value):
        """
        Return whether value is considered to be initial value.
        """
        return bool(value and getattr(value, "url", False))


class TagInput(forms.TextInput):
    """
    Dump tag queryset into tag list
    """

    template_name = "widgets/tag.html"

    def format_value(self, value):
        if value == "" or value is None or len(value) == 0:
            return ""
        tag_list = []
        try:
            tag_list = [t["content"] for t in value]
        except TypeError:
            tag_list = [t.content for t in value]
        # return ','.join(tag_list)
        return tag_list

    class Media:
        css = {"all": ("lib/css/tag-input.css",)}
        js = ("lib/js/tag-input.js",)


class TagField(forms.CharField):
    """
    Split comma connected string into tag list
    """

    widget = TagInput

    def to_python(self, value):
        value = super().to_python(value)
        if not value:
            return
        return [t.strip() for t in value.split(",")]


class MultiSelect(forms.SelectMultiple):
    template_name = "widgets/multi_select.html"

    class Media:
        css = {
            "all": (
                "https://cdn.jsdelivr.net/npm/multiple-select@1.5.2/dist/multiple-select.min.css",
            )
        }
        js = (
            "https://cdn.jsdelivr.net/npm/multiple-select@1.5.2/dist/multiple-select.min.js",
        )


class HstoreField(forms.CharField):
    widget = HstoreInput

    def to_python(self, value):
        if not value:
            return None
        # already in python types
        if isinstance(value, list):
            return value
        pairs = json.loads("[" + value + "]")
        return pairs


class DurationInput(forms.TextInput):
    """
    HH:mm:ss input widget
    """

    input_type = "time"

    def get_context(self, name, value, attrs):
        context = super().get_context(name, value, attrs)
        # context['widget']['type'] = self.input_type
        context["widget"]["attrs"]["step"] = "1"
        return context

    def format_value(self, value):
        """
        Given `value` is an integer in ms
        """
        ms = value
        if not ms:
            return super().format_value(None)
        x = ms // 1000
        seconds = x % 60
        x //= 60
        if x == 0:
            return super().format_value(f"00:00:{seconds:0>2}")
        minutes = x % 60
        x //= 60
        if x == 0:
            return super().format_value(f"00:{minutes:0>2}:{seconds:0>2}")
        hours = x % 24
        return super().format_value(f"{hours:0>2}:{minutes:0>2}:{seconds:0>2}")


class DurationField(forms.TimeField):
    widget = DurationInput

    def to_python(self, value):

        # empty value
        if value is None or value == "":
            return

        # if value is integer in ms
        if isinstance(value, int):
            return value

        # if value is string in time format
        h, m, s = value.split(":")
        return (int(h) * 3600 + int(m) * 60 + int(s)) * 1000


#############################
# Form
#############################
VISIBILITY_CHOICES = [
    (0, _("公开")),
    (1, _("仅关注者")),
    (2, _("仅自己")),
]


class MarkForm(forms.ModelForm):
    id = forms.IntegerField(required=False, widget=forms.HiddenInput())
    share_to_mastodon = forms.BooleanField(
        label=_("分享到联邦网络"), initial=True, required=False
    )
    rating = forms.IntegerField(
        label=_("评分"),
        validators=[RatingValidator()],
        widget=forms.HiddenInput(),
        required=False,
    )
    visibility = forms.TypedChoiceField(
        label=_("可见性"),
        initial=0,
        coerce=int,
        choices=VISIBILITY_CHOICES,
        widget=forms.RadioSelect,
    )
    tags = TagField(
        required=False,
        widget=TagInput(attrs={"placeholder": _("回车增加标签")}),
        label=_("标签"),
    )
    text = forms.CharField(
        required=False,
        widget=forms.Textarea(
            attrs={"placeholder": _("最多只能写360字哦~"), "maxlength": 360}
        ),
        label=_("短评"),
    )


class ReviewForm(forms.ModelForm):
    title = forms.CharField(label=_("标题"))
    content = MarkdownxFormField(label=_("正文 (Markdown)"))
    share_to_mastodon = forms.BooleanField(
        label=_("分享到联邦网络"), initial=True, required=False
    )
    id = forms.IntegerField(required=False, widget=forms.HiddenInput())
    visibility = forms.TypedChoiceField(
        label=_("可见性"),
        initial=0,
        coerce=int,
        choices=VISIBILITY_CHOICES,
        widget=forms.RadioSelect,
    )