kalgan 0.9.1

A web framework for Rust programing language.
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

//! Module for the asset handler which receives the request object returns the static file content.

use crate::{
    http::{request::Request, response::Response},
    settings,
};
use log::{info, warn};
use std::fs;

/// Checks whether a static file is being requested.
pub fn is_static_file(request: &Request) -> bool {
    match settings::get_string("static.folders") {
        Ok(static_folders) => {
            for static_folder in static_folders.trim().split(",") {
                let clean_static_folder = kalgan_string::strip(&static_folder.trim(), '/');
                if request.get_uri().contains(&clean_static_folder)
                    && request
                        .get_uri()
                        .find(format!("/{}/", &clean_static_folder).as_str())
                        == Some(0)
                {
                    return true;
                }
            }
            false
        }
        Err(_e) => false,
    }
}
/// Returns the content of the static file.
pub fn serve_static(request: &Request) -> Vec<u8> {
    info!("Processing static file...");
    let uri = get_clean_static_file(&request.get_uri());
    match fs::read(&uri) {
        Ok(mut contents) => {
            let result = Response::new()
                .set_status(200)
                .set_content_type(get_content_type(&uri))
                .create();
            let mut bytes = result;
            bytes.append(&mut contents);
            bytes
        }
        Err(e) => {
            warn!("Error processing static file \"{}\".", &uri);
            warn!("{}", e);
            Vec::new()
        }
    }
}
/// Returns the content type of the static file.
fn get_content_type(uri: &str) -> &str {
    let chunks: Vec<&str> = uri.split(".").collect();
    match chunks[chunks.len() - 1] {
        "aac" => "audio/aac",
        "avi" => "video/x-msvideo",
        "bmp" => "image/bmp",
        "css" => "text/css",
        "csv" => "text/csv",
        "gif" => "image/gif",
        "html" => "text/html",
        "ico" => "image/x-icon",
        "jpg" => "image/jpg",
        "jpeg" => "image/jpeg",
        "js" => "text/javascript",
        "json" => "application/json",
        "mp3" => "audio/mpeg",
        "mp4" => "video/mp4",
        "mpeg" => "video/mpeg",
        "otf" => "font/otf",
        "pdf" => "application/pdf",
        "png" => "image/png",
        "svg" => "image/svg+xml",
        "ttf" => "font/ttf",
        "txt" => "text/plain",
        "wav" => "audio/wav",
        "weba" => "audio/webm",
        "webm" => "video/webm",
        "webp" => "image/webp",
        "woff" => "font/woff",
        "woff2" => "font/woff2",
        "xhtml" => "application/xhtml+xml",
        "xls" => "application/vnd.ms-excel",
        "xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        "xml" => "application/xml",
        _ => "application/octet-stream",
    }
}
/// Returns the path of the static file.
fn get_clean_static_file(uri: &str) -> &str {
    match uri.find("?") {
        Some(pos) => kalgan_string::strip_left(&uri[..pos], '/'),
        None => kalgan_string::strip_left(&uri, '/'),
    }
}