meta/
lib.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
#[macro_use]
extern crate diesel;

use std::fmt;
use uuid::Uuid;
use std::io::Write;

use diesel::{deserialize, not_none, serialize};
use diesel::backend::Backend;
use diesel::deserialize::FromSql;
use diesel::pg::Pg;
use diesel::serialize::{IsNull, Output, ToSql};
use diesel::sql_types::Varchar;
use serde::Deserialize;
use serde::Serialize;


pub trait MetaFields {
    fn update_fields(&mut self, user_id: Uuid);
    fn init_fields(&mut self, user_id: Uuid);
}

#[derive(Debug, PartialEq, FromSqlRow, AsExpression, Clone, Serialize, Deserialize)]
#[sql_type = "Varchar"]
pub enum Roles {
    Accountant,
    Admin,
    Approver,
    BookingUser,
    ContentManager,
    DepAdmManager,
    DistrictClerk,
    DistrictManager,
    Facilitator,
    FederalClerk,
    FederalMinister,
    Guest,
    HeadTeacher,
    LabAssistant,
    Librarian,
    Parent,
    Psychologist,
    Pupil,
    PupilsParent,
    RegionalClerk,
    RegionalMinister,
    Minister,
    Registered,
    Student,
    SuperAdmin,
    RoboTeacher,
    SchoolCam,
    undefined,
}

impl ToSql<Varchar, Pg> for Roles {
    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
        match *self {
            Roles::Accountant => out.write_all(b"Accountant")?,
            Roles::Admin => out.write_all(b"Admin")?,
            Roles::Approver => out.write_all(b"Approver")?,
            Roles::BookingUser => out.write_all(b"BookingUser")?,
            Roles::ContentManager => out.write_all(b"ContentManager")?,
            Roles::DepAdmManager => out.write_all(b"DepAdmManager")?,
            Roles::DistrictClerk => out.write_all(b"DistrictClerk")?,
            Roles::DistrictManager => out.write_all(b"DistrictManager")?,
            Roles::Facilitator => out.write_all(b"Facilitator")?,
            Roles::FederalClerk => out.write_all(b"FederalClerk")?,
            Roles::FederalMinister => out.write_all(b"FederalMinister")?,
            Roles::Guest => out.write_all(b"Guest")?,
            Roles::HeadTeacher => out.write_all(b"HeadTeacher")?,
            Roles::LabAssistant => out.write_all(b"LabAssistant")?,
            Roles::Librarian => out.write_all(b"Librarian")?,
            Roles::Parent => out.write_all(b"Parent")?,
            Roles::Psychologist => out.write_all(b"Psychologist")?,
            Roles::Pupil => out.write_all(b"Pupil")?,
            Roles::PupilsParent => out.write_all(b"PupilsParent")?,
            Roles::RegionalClerk => out.write_all(b"RegionalClerk")?,
            Roles::RegionalMinister => out.write_all(b"RegionalMinister")?,
            Roles::Minister => out.write_all(b"Minister")?,
            Roles::Registered => out.write_all(b"Registered")?,
            Roles::Student => out.write_all(b"Student")?,
            Roles::SuperAdmin => out.write_all(b"SuperAdmin")?,
            Roles::SchoolCam => out.write_all(b"SchoolCam")?,
            Roles::RoboTeacher => out.write_all(b"RoboTeacher")?,
            Roles::undefined => out.write_all(b"undefined")?,
        }
        Ok(IsNull::No)
    }
}


impl FromSql<Varchar, Pg> for Roles {
    fn from_sql(bytes: Option<&<Pg as Backend>::RawValue>) -> deserialize::Result<Self> {
        match not_none!(bytes) {
            b"Accountant" => Ok(Roles::Accountant),
            b"Admin" => Ok(Roles::Admin),
            b"Approver" => Ok(Roles::Approver),
            b"BookingUser" => Ok(Roles::BookingUser),
            b"ContentManager" => Ok(Roles::ContentManager),
            b"DepAdmManager" => Ok(Roles::DepAdmManager),
            b"DistrictClerk" => Ok(Roles::DistrictClerk),
            b"DistrictManager" => Ok(Roles::DistrictManager),
            b"Facilitator" => Ok(Roles::Facilitator),
            b"FederalClerk" => Ok(Roles::FederalClerk),
            b"FederalMinister" => Ok(Roles::FederalMinister),
            b"Guest" => Ok(Roles::Guest),
            b"HeadTeacher" => Ok(Roles::HeadTeacher),
            b"LabAssistant" => Ok(Roles::LabAssistant),
            b"Librarian" => Ok(Roles::Librarian),
            b"Parent" => Ok(Roles::Parent),
            b"Psychologist" => Ok(Roles::Psychologist),
            b"Pupil" => Ok(Roles::Pupil),
            b"PupilsParent" => Ok(Roles::PupilsParent),
            b"RegionalClerk" => Ok(Roles::RegionalClerk),
            b"RegionalMinister" => Ok(Roles::RegionalMinister),
            b"Minister" => Ok(Roles::Minister),
            b"Registered" => Ok(Roles::Registered),
            b"Student" => Ok(Roles::Student),
            b"SuperAdmin" => Ok(Roles::SuperAdmin),
            b"RoboTeacher" => Ok(Roles::RoboTeacher),
            b"SchoolCam" => Ok(Roles::SchoolCam),
            b"undefined" => Ok(Roles::undefined),
            _ => Err("Unrecognized enum variant".into()),
        }
    }
}

impl fmt::Display for Roles {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}