flyer 2.1.1

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

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 query(&self, key: &str) -> String {
        return self.query.get(key).get_or_insert(&"".to_string()).to_string()
    }

    pub fn value(&self, key: &str) -> String {
        return self.form.values.get(key).get_or_insert(&"".to_owned()).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;
    }
}