flyer 2.1.15

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

pub mod form;
pub mod parser;

use std::cmp::Ordering;

use crate::{
    cookies::Cookies,
    request::form::{File, Files, Form},
    session::Session,
    utils::{Headers, Values}
};

pub struct Request {
    pub(crate) cookies: Box<Cookies>,
    pub(crate) session: Option<Box<dyn Session>>,
    pub ip: String,
    pub host: String,
    pub method: String,
    pub path: String,
    pub query: Values,
    pub parameters: Values,
    pub protocol: String,
    pub headers: Headers,
    pub body: Vec<u8>,
    pub form: Form,
}

impl Request {
    pub fn new(method: &str, path: &str, headers: Values, body: Vec<u8>) -> Self {
        return Self {
            session: None,
            ip: "".to_owned(),
            host: "".to_owned(),
            method: method.to_owned(),
            path: path.to_owned(),
            query: Values::new(),
            parameters: Values::new(),
            protocol: "HTTP/1.1".to_string(),
            headers: headers,
            body: body,
            form: Form::new(Values::new(), Files::new()),
            cookies: Box::new(Cookies::new(Values::new())),
        }
    }

    pub(crate) fn is_asset(&mut self) -> bool {
        let end = self.path.split("/").last();

        if end.is_none() {
            return false;
        }

        let file_split: Vec<&str> = end.unwrap().split(".").collect();

        return file_split.len() > 1;
    }

    pub fn ip(&self) -> String {
        return self.ip.to_owned();
    }

    pub fn header(&self, key: &str) -> String {
        return self.headers.get(key).get_or_insert(&"".to_string()).to_string()
    }
    
    pub fn parameter(&self, key: &str) -> String {
        return self.parameters.get(key).get_or_insert(&"".to_string()).to_string()
    }

    pub fn parameter_default<T>(&self, key: &str, default: T) -> T
    where
        T: std::str::FromStr
    {
        return self.parameters.get(key).and_then(|v| v.parse::<T>().ok()).unwrap_or(default);
    }

    pub fn parameter_parse<T>(&self, key: &str) -> Option<T>
    where
        T: std::str::FromStr
    {
        return self.parameters.get(key).and_then(|v| v.parse::<T>().ok());
    }

    pub fn query(&self, key: &str) -> String {
        return self.query.get(key).unwrap_or(&String::new()).to_string();
    }

    pub fn query_default<T>(&self, key: &str, default: T) -> T
    where
        T: std::str::FromStr
    {
        return self.query.get(key).and_then(|v| v.parse::<T>().ok()).unwrap_or(default);
    }

    pub fn query_parse<T>(&self, key: &str) -> Option<T>
    where
        T: std::str::FromStr
    {
        return self.query.get(key).and_then(|v| v.parse::<T>().ok());
    }

    pub fn value(&self, key: &str) -> String {
        return self.form.values.get(key).unwrap_or(&String::new()).to_string();
    }

    pub fn file(&self, key: &str) -> Option<&File> {
        return self.form.files.get(key);
    }

    pub fn content_type(&self) -> String {
        let content_type = self.header("content-type");
        let content_type_piece: Vec<&str> = content_type.split(";").collect();

        return content_type_piece.get(0).unwrap().to_string();
    }

    pub fn is_json(&self) -> bool {
        let header = self.header("content-type");
        let header_piece: Vec<&str> = header.split(";").collect();

        return  header_piece.get(0).unwrap().cmp(&"application/json") == Ordering::Equal;
    }

    pub fn session(&mut self) -> &mut Box<dyn Session + 'static> {
        return self.session.as_mut().unwrap();
    }

    pub fn cookies(&mut self) -> &mut Cookies {
        return &mut self.cookies;
    }
}