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

//! Module for the controller which receives the request object and returns a response object.

use crate::{
    handler::{error, middleware, middleware::Outcome},
    http::{request::Request, response::Response},
    settings,
};
use log::info;
use std::str::FromStr;

/// Passes the `Request` to the middleware/controller linked to the route and returns the `Response` of the middleware/controller.
pub fn resolver(
    request: &mut Request,
    controller_factory: &fn(&Request, &str) -> Result<Response, String>,
    middleware_factory: Option<&fn(&mut Request, &str) -> Result<Outcome, String>>,
) -> Response {
    let routes = crate::ROUTES.lock().unwrap();
    match routes.get_route(&request.get_uri(), &request.get_method()) {
        Ok(route) => {
            info!("Route matched:");
            info!("{:#?}", &route);
            request.route = Some(route.clone());
            if request.route.as_ref().unwrap().language.is_empty()
                && settings::exists("i18n.language.default")
            {
                request.route.as_mut().unwrap().language =
                    settings::get_string("i18n.language.default").unwrap();
            }
            let controller = String::from_str(&route.get_controller()).unwrap();
            let middleware = String::from_str(&route.get_middleware()).unwrap();
            std::mem::drop(routes);
            if middleware.is_empty() {
                info!("No middleware has been defined for this route.");
                info!("Calling controller {}...", &controller);
                match controller_factory(&request, &controller) {
                    Ok(response) => response,
                    Err(e) => error::render(request, 500, &e, controller_factory),
                }
            } else {
                middleware::resolver(
                    request,
                    controller_factory,
                    middleware_factory,
                    &controller,
                    &middleware,
                )
            }
        }
        Err(e) => {
            std::mem::drop(routes);
            error::render(request, 404, &e, controller_factory)
        }
    }
}