testlib/enums/
status.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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
use std::str;

use serde::Deserialize;
use serde::Serialize;
use strum_macros::EnumString;

#[cfg(feature = "diesel")]
use {
    diesel::{deserialize, not_none, serialize},
    diesel::{AsExpression, FromSqlRow},
    diesel::backend::Backend,
    diesel::deserialize::FromSql,
    diesel::pg::Pg,
    diesel::serialize::{IsNull, Output, ToSql},
    diesel::types::Varchar,
    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 Status {
    Draft,
    Submitted,
    Sent,
    PreApproved,
    Accepted,
    Rejected,
    Confirmed,
    Invalid,
    Substituted,
    Redirected,
    Deleted,
    Blocked,
    Returned,
    Cancelled,
    Succeded,
    Failed,
    Read,
    Unread,
    Paid,
    Completed,
    Approved,
    Unconfirmed,
    ApprovedByApprover,
    ApprovedByPsychologist,
    BlockedByApprover,
    BlockedByPsychologist,
    Recommended,
    Published,
    Registered,
    Public,
    Private,
    Incomplete,
    Checked,
    Complete,
    Error,
    ManualWaiting,
    ManualComplete,
    Skipped,
    Undefined,
}

#[cfg(feature = "diesel")]
impl ToSql<Varchar, Pg> for Status {
    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
        match *self {
            Status::Draft => out.write_all(b"Draft")?,
            Status::Submitted => out.write_all(b"Submitted")?,
            Status::Sent => out.write_all(b"Sent")?,
            Status::Undefined => out.write_all(b"undefined")?,
            Status::PreApproved => out.write_all(b"PreApproved")?,
            Status::Accepted => out.write_all(b"Accepted")?,
            Status::Rejected => out.write_all(b"Rejected")?,
            Status::Confirmed => out.write_all(b"Confirmed")?,
            Status::Invalid => out.write_all(b"Invalid")?,
            Status::Substituted => out.write_all(b"Substituted")?,
            Status::Redirected => out.write_all(b"Redirected")?,
            Status::Deleted => out.write_all(b"Deleted")?,
            Status::Blocked => out.write_all(b"Blocked")?,
            Status::Returned => out.write_all(b"Returned")?,
            Status::Cancelled => out.write_all(b"Cancelled")?,
            Status::Succeded => out.write_all(b"Succeded")?,
            Status::Failed => out.write_all(b"Failed")?,
            Status::Read => out.write_all(b"Read")?,
            Status::Unread => out.write_all(b"Unread")?,
            Status::Paid => out.write_all(b"Paid")?,
            Status::Completed => out.write_all(b"Completed")?,
            Status::Approved => out.write_all(b"Approved")?,
            Status::Unconfirmed => out.write_all(b"Unconfirmed")?,
            Status::ApprovedByApprover => out.write_all(b"ApprovedByApprover")?,
            Status::ApprovedByPsychologist => out.write_all(b"ApprovedByPsychologist")?,
            Status::BlockedByApprover => out.write_all(b"BlockedByApprover")?,
            Status::BlockedByPsychologist => out.write_all(b"BlockedByPsychologist")?,
            Status::Recommended => out.write_all(b"Recommended")?,
            Status::Published => out.write_all(b"Published")?,
            Status::Registered => out.write_all(b"Registered")?,
            Status::Public => out.write_all(b"Public")?,
            Status::Private => out.write_all(b"Private")?,
            Status::Complete => out.write_all(b"Complete")?,
            Status::Incomplete => out.write_all(b"Incomplete")?,
            Status::Error => out.write_all(b"Error")?,
            Status::ManualWaiting => out.write_all(b"ManualWaiting")?,
            Status::Checked => out.write_all(b"Checked")?,
            Status::Skipped => out.write_all(b"Skipped")?,
            Status::ManualComplete => out.write_all(b"ManualComplete")?,
        }
        Ok(IsNull::No)
    }
}

#[cfg(feature = "diesel")]
impl FromSql<Varchar, Pg> for Status {
    fn from_sql(bytes: Option<&<Pg as Backend>::RawValue>) -> deserialize::Result<Self> {
        match not_none!(bytes) {
            b"Draft" => Ok(Status::Draft),
            b"Submitted" => Ok(Status::Submitted),
            b"Sent" => Ok(Status::Sent),
            b"undefined" => Ok(Status::Undefined),
            b"PreApproved" => Ok(Status::PreApproved),
            b"Accepted" => Ok(Status::Accepted),
            b"Rejected" => Ok(Status::Rejected),
            b"Confirmed" => Ok(Status::Confirmed),
            b"Invalid" => Ok(Status::Invalid),
            b"Substituted" => Ok(Status::Substituted),
            b"Redirected" => Ok(Status::Redirected),
            b"Deleted" => Ok(Status::Deleted),
            b"Blocked" => Ok(Status::Blocked),
            b"Returned" => Ok(Status::Returned),
            b"Cancelled" => Ok(Status::Cancelled),
            b"Succeded" => Ok(Status::Succeded),
            b"Failed" => Ok(Status::Failed),
            b"Read" => Ok(Status::Read),
            b"Unread" => Ok(Status::Unread),
            b"Paid" => Ok(Status::Paid),
            b"Completed" => Ok(Status::Completed),
            b"Approved" => Ok(Status::Approved),
            b"Unconfirmed" => Ok(Status::Unconfirmed),
            b"ApprovedByApprover" => Ok(Status::ApprovedByApprover),
            b"ApprovedByPsychologist" => Ok(Status::ApprovedByPsychologist),
            b"BlockedByApprover" => Ok(Status::BlockedByApprover),
            b"BlockedByPsychologist" => Ok(Status::BlockedByPsychologist),
            b"Recommended" => Ok(Status::Recommended),
            b"Published" => Ok(Status::Published),
            b"Registered" => Ok(Status::Registered),
            b"Public" => Ok(Status::Public),
            b"Private" => Ok(Status::Private),
            b"Complete" => Ok(Status::Complete),
            b"Incomplete" => Ok(Status::Incomplete),
            b"Error" => Ok(Status::Error),
            b"ManualWaiting" => Ok(Status::ManualWaiting),
            b"Checked" => Ok(Status::Checked),
            b"Skipped" => Ok(Status::Skipped),
            b"ManualComplete" => Ok(Status::ManualComplete),
            _ => Err("Unrecognized enum variant".into()),
        }
    }
}