flyer 3.0.7

HTTP framework for rust
Documentation 
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

use serde::{Deserialize, Serialize};

use crate::utils::Values;

pub mod cookie;
pub mod local;

#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct Session {
    pub(crate) session: Values,
    pub(crate) flash: Values,
    pub(crate) errors: Values,
    pub(crate) old: Values,
}

impl Session {
    pub fn new() -> Self {
        return Self {
            session: Values::new(),
            flash: Values::new(),
            errors: Values::new(),
            old: Values::new(),
        };
    }
}

impl Session {
    pub fn session(&self) -> Values {
        return self
            .session
            .clone();
    }

    pub fn set(&mut self, k: impl Into<String>, v: impl Into<String>) {
        self
            .session
            .insert(k.into(), v.into());
    }

    pub fn set_values(&mut self, values: Values) {
        for (k, v) in values {
            self.set(k, v);
        }
    }

    pub fn get(&self, k: impl Into<String>) -> String {
        return self
            .session
            .get(&k.into())
            .unwrap_or(&String::new())
            .into();
    }

    pub fn remove(&mut self, k: impl Into<String>) {
        self
            .session
            .remove(&k.into());
    }

    pub fn errors(&self) -> Values {
        return self.errors.clone();
    }

    pub fn set_error(&mut self, k: impl Into<String>, v: impl Into<String>) {
        self.errors.insert(k.into(), v.into());
    }

    pub fn set_errors(&mut self, errors: Values) {
        for (k, v) in errors {
            self.set_error(k, v);
        }
    }

    pub fn error(&self, k: impl Into<String>) -> String {
        return self
            .errors
            .get(&k.into())
            .unwrap_or(&String::new())
            .into();
    }

    pub fn remove_error(&mut self, k: impl Into<String>) {
        self
            .errors
            .remove(&k.into());
    }

    pub fn set_old(&mut self, k: impl Into<String>, v: impl Into<String>) {
        self.old.insert(k.into(), v.into());
    }

    pub fn set_olds(&mut self, values: Values) {
        for (k, v) in values {
            self.set_old(k, v);
        }
    }

    pub fn old(&self, k: impl Into<String>) -> String {
        return self
            .old
            .get(&k.into())
            .unwrap_or(&String::new())
            .into()
    }

    pub fn olds(&self) -> Values {
        return self
            .old
            .clone();
    }

    pub fn set_flash(&mut self, k: impl Into<String>, v: impl Into<String>) {
        self
            .flash
            .insert(k.into(), v.into());
    }

    pub fn set_flashes(&mut self, values: Values) {
        for (k, v) in values {
            self.set_flash(k, v);
        }
    }

    pub fn flash(&self, k: impl Into<String>) -> String {
        return self
            .flash
            .get(&k.into())
            .unwrap_or(&String::new())
            .into();
    }

    pub fn flashes(&self) -> Values {
        return self
            .flash
            .clone();
    }
}