initiativelib/enums/
form_field_type.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
use serde::Deserialize;
use serde::Serialize;
use std::str;
use strum_macros::EnumString;
#[cfg(feature = "diesel")]
use {
    diesel::backend::Backend,
    diesel::deserialize::FromSql,
    diesel::pg::Pg,
    diesel::serialize::{IsNull, Output, ToSql},
    diesel::types::Varchar,
    diesel::{deserialize, not_none, serialize},
    diesel::{AsExpression, FromSqlRow},
    std::io::Write,
};

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, EnumString)]
#[cfg_attr(feature = "diesel", derive(AsExpression, FromSqlRow))]
#[cfg_attr(feature = "diesel", sql_type = "Varchar")]
pub enum FormFieldType {
    Text,
    Checkbox,
    Dropdown,
    Numerical,
    Float,
    Date,
    Email,
    LongText,
    WebsiteURL,
    Phone,
    Picture,
    File,
    ConsentStatement,
    Video,
    Time,
    DateTime,
}

#[cfg(feature = "diesel")]
impl ToSql<Varchar, Pg> for FormFieldType {
    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
        match *self {
            FormFieldType::Text => out.write_all(b"Text")?,
            FormFieldType::Checkbox => out.write_all(b"Checkbox")?,
            FormFieldType::Dropdown => out.write_all(b"Dropdown")?,
            FormFieldType::Numerical => out.write_all(b"Numerical")?,
            FormFieldType::Float => out.write_all(b"Float")?,
            FormFieldType::Date => out.write_all(b"Date")?,
            FormFieldType::Email => out.write_all(b"Email")?,
            FormFieldType::LongText => out.write_all(b"LongText")?,
            FormFieldType::WebsiteURL => out.write_all(b"WebsiteURL")?,
            FormFieldType::Phone => out.write_all(b"Phone")?,
            FormFieldType::Picture => out.write_all(b"Picture")?,
            FormFieldType::File => out.write_all(b"File")?,
            FormFieldType::ConsentStatement => out.write_all(b"ConsentStatement")?,
            FormFieldType::Video => out.write_all(b"Video")?,
            FormFieldType::Time => out.write_all(b"Time")?,
            FormFieldType::DateTime => out.write_all(b"DateTime")?,
        }
        Ok(IsNull::No)
    }
}

impl Default for FormFieldType {
    fn default() -> Self {
        FormFieldType::Text
    }
}

#[cfg(feature = "diesel")]
impl FromSql<Varchar, Pg> for FormFieldType {
    fn from_sql(bytes: Option<&<Pg as Backend>::RawValue>) -> deserialize::Result<Self> {
        match not_none!(bytes) {
            b"Text" => Ok(FormFieldType::Text),
            b"Checkbox" => Ok(FormFieldType::Checkbox),
            b"Dropdown" => Ok(FormFieldType::Dropdown),
            b"Numerical" => Ok(FormFieldType::Numerical),
            b"Float" => Ok(FormFieldType::Float),
            b"Date" => Ok(FormFieldType::Date),
            b"Email" => Ok(FormFieldType::Email),
            b"LongText" => Ok(FormFieldType::LongText),
            b"WebsiteURL" => Ok(FormFieldType::WebsiteURL),
            b"Phone" => Ok(FormFieldType::Phone),
            b"Picture" => Ok(FormFieldType::Picture),
            b"File" => Ok(FormFieldType::File),
            b"ConsentStatement" => Ok(FormFieldType::ConsentStatement),
            b"Video" => Ok(FormFieldType::Video),
            b"Time" => Ok(FormFieldType::Time),
            b"DateTime" => Ok(FormFieldType::DateTime),
            _ => Err("Unrecognized enum variant".into()),
        }
    }
}