wakflo_form/formschema/

common_type.rs

use serde::{Deserialize, Serialize};

/// # FumeFieldTypes
///
/// Enum for current schema status. Defaults to idle
#[derive(
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Clone,
    Debug,
    Default,
    strum_macros::AsRefStr,
    strum_macros::IntoStaticStr,
    strum_macros::Display,
    strum_macros::EnumString,
)]
pub enum FumeFieldTypes {
    #[default]
    #[serde(rename = "string")]
    #[strum(serialize = "string")]
    String,

    #[serde(rename = "number")]
    #[strum(serialize = "number")]
    Number,

    #[serde(rename = "select")]
    #[strum(serialize = "select")]
    Select,

    #[serde(rename = "dropdown")]
    #[strum(serialize = "dropdown")]
    Dropdown,

    #[serde(rename = "object")]
    #[strum(serialize = "object")]
    Object,

    #[serde(rename = "array")]
    #[strum(serialize = "array")]
    Array,

    #[serde(rename = "checkbox")]
    #[strum(serialize = "checkbox")]
    Checkbox,

    #[serde(rename = "radio")]
    #[strum(serialize = "radio")]
    Radio,

    #[serde(rename = "date")]
    #[strum(serialize = "date")]
    Date,

    #[serde(rename = "datetime")]
    #[strum(serialize = "datetime")]
    Datetime,

    #[serde(rename = "color")]
    #[strum(serialize = "color")]
    Color,
}

/// # FumeFieldStringFormat
///
/// Enum for current schema status. Defaults to idle
#[derive(
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Clone,
    Debug,
    Default,
    strum_macros::AsRefStr,
    strum_macros::IntoStaticStr,
    strum_macros::Display,
    strum_macros::EnumString,
)]
pub enum FumeFieldStringFormat {
    #[default]
    #[serde(rename = "ip")]
    #[strum(serialize = "ip")]
    Ip,

    #[serde(rename = "uuid")]
    #[strum(serialize = "uuid")]
    Uuid,

    #[serde(rename = "guid")]
    #[strum(serialize = "guid")]
    Guid,

    #[serde(rename = "email")]
    #[strum(serialize = "email")]
    Email,
}

/// # FumeFieldNumberFormat
///
/// Enum for current schema status. Defaults to idle
#[derive(
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Clone,
    Debug,
    Default,
    strum_macros::AsRefStr,
    strum_macros::IntoStaticStr,
    strum_macros::Display,
    strum_macros::EnumString,
)]
pub enum FumeFieldNumberFormat {
    #[default]
    #[serde(rename = "decimal")]
    #[strum(serialize = "decimal")]
    Decimal,

    #[serde(rename = "float")]
    #[strum(serialize = "float")]
    Float,

    #[serde(rename = "uint")]
    #[strum(serialize = "uint")]
    Uint,

    #[serde(rename = "int")]
    #[strum(serialize = "int")]
    Int,

    #[serde(rename = "currency")]
    #[strum(serialize = "currency")]
    Currency,
}

/// # FumeFieldDateTimeFormat
///
/// Enum for current schema status. Defaults to idle
#[derive(
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Clone,
    Debug,
    Default,
    strum_macros::AsRefStr,
    strum_macros::IntoStaticStr,
    strum_macros::Display,
    strum_macros::EnumString,
)]
pub enum FumeFieldDateTimeFormat {
    #[default]
    #[serde(rename = "short")]
    #[strum(serialize = "short")]
    Short,

    #[serde(rename = "long")]
    #[strum(serialize = "long")]
    Long,

    #[serde(rename = "duration")]
    #[strum(serialize = "duration")]
    Duration,

    #[serde(rename = "month")]
    #[strum(serialize = "month")]
    Month,

    #[serde(rename = "year")]
    #[strum(serialize = "year")]
    Year,

    #[serde(rename = "day")]
    #[strum(serialize = "day")]
    Day,

    #[serde(rename = "week")]
    #[strum(serialize = "week")]
    Week,
}

/// # FumeFieldDateTimeFormat
///
/// Enum for current schema status. Defaults to idle
#[derive(
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Clone,
    Debug,
    Default,
    strum_macros::AsRefStr,
    strum_macros::IntoStaticStr,
    strum_macros::Display,
    strum_macros::EnumString,
)]
pub enum ValidationTypes {
    #[default]
    #[serde(rename = "required")]
    #[strum(serialize = "required")]
    Required,

    #[serde(rename = "min")]
    #[strum(serialize = "min")]
    Min,

    #[serde(rename = "max")]
    #[strum(serialize = "max")]
    Max,

    #[serde(rename = "maxLength")]
    #[strum(serialize = "maxLength")]
    MaxLength,

    #[serde(rename = "minLength")]
    #[strum(serialize = "minLength")]
    MinLength,

    #[serde(rename = "pattern")]
    #[strum(serialize = "pattern")]
    Pattern,
}

/// # FumeSchemaSelectionMode
///
/// Enum for current schema status. Defaults to idle
#[derive(
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Clone,
    Debug,
    Default,
    strum_macros::AsRefStr,
    strum_macros::IntoStaticStr,
    strum_macros::Display,
    strum_macros::EnumString,
)]
pub enum FumeSchemaSelectionMode {
    #[default]
    #[serde(rename = "single")]
    #[strum(serialize = "single")]
    Single,

    #[serde(rename = "multiple")]
    #[strum(serialize = "multiple")]
    Multiple,
}

#[derive(PartialEq, Eq, Serialize, Deserialize, Clone, Debug, Default)]
pub struct FumeFieldBaseValidation<V> {
    /// default input value
    pub message: Option<String>,
    /// type of validation
    pub field_type: Option<ValidationTypes>,
    pub value: Option<V>,
}

#[derive(PartialEq, Eq, Serialize, Deserialize, Clone, Debug)]
#[serde(untagged)]
pub enum FumeFieldValidation {
    Required(FumeFieldBaseValidation<bool>),
    Min(FumeFieldBaseValidation<i32>),
    Max(FumeFieldBaseValidation<i32>),
    MaxLength(FumeFieldBaseValidation<i32>),
    MinLength(FumeFieldBaseValidation<i32>),
    Pattern(FumeFieldBaseValidation<String>),
}

impl Default for FumeFieldValidation {
    fn default() -> Self {
        Self::Pattern(FumeFieldBaseValidation {
            message: None,
            field_type: None,
            value: None,
        })
    }
}

#[derive(PartialEq, Eq, Serialize, Deserialize, Clone, Debug, Default)]
pub struct FumeBaseSchema<T> {
    /// key to access data
    pub id: Option<String>,
    /// key to access data
    pub field: String,
    /// form field label
    pub label: String,
    /// form field placeholder
    pub placeholder: Option<String>,
    /// form field placeholder
    pub description: String,
    /// form field hint
    pub hint: Option<String>,
    /// defaultValue input value
    pub default_value: Option<T>,
    /// mark field as required
    pub required: Option<bool>,
    /// mark field as required
    pub disabled: Option<bool>,
    /// mark field as nullable
    pub nullable: Option<bool>,
    /// mark field as hidden
    pub hidden: Option<bool>,
    /// field validations, can control validation
    pub validations: Option<Vec<FumeFieldValidation>>,
    /// field condition, can control visibility and not validation
    pub conditions: Option<serde_json::Value>,
    /// custom component for rendering
    pub component: Option<String>,
    #[serde(rename = "deprecated")]
    pub deprecated: Option<bool>,
    #[serde(rename = "readonly")]
    pub readonly: Option<bool>,
}

#[derive(PartialEq, Eq, Serialize, Deserialize, Clone, Debug, Default)]
pub struct FumeSchemaEnum<T> {
    pub value: T,
    pub label: String,
}

#[derive(PartialEq, Eq, Serialize, Deserialize, Clone, Debug)]
#[serde(untagged)]
pub enum FumeSchemaEnumType {
    Object(FumeSchemaEnum<String>),
    String(String),
}

impl Default for FumeSchemaEnumType {
    fn default() -> Self {
        FumeSchemaEnumType::String("".to_string())
    }
}