actix-type-util 0.1.0

Crate with some useful types for working with actix-web
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

use actix_web::cookie::{Cookie, Expiration, SameSite};
use actix_web::{HttpRequest, HttpResponse, Responder};
use std::borrow::Cow;

pub struct SetCookie<'c, T: Responder> {
    inner: T,
    cookie: Cookie<'c>,
}

impl<'c, T: Responder> SetCookie<'c, T> {
    pub fn new<N, V>(
        inner: T,
        cookie_name: N,
        cookie_value: V
    ) -> Self
    where
        N: Into<Cow<'c, str>>,
        V: Into<Cow<'c, str>>,
    {
        Self {
            inner,
            cookie: Self::create_cookie(
                cookie_name,
                cookie_value,
                "/",
                true,
                Expiration::Session,
                Some(SameSite::None),
                true,
            )
        }
    }

    pub fn new_with_opts<N, V, P>(
        inner: T,
        cookie_name: N,
        cookie_value: V,
        path: P,
        http_only: bool,
        expires: Expiration,
        same_site: Option<SameSite>,
        secure: bool,
    ) -> Self
    where
        N: Into<Cow<'c, str>>,
        V: Into<Cow<'c, str>>,
        P: Into<Cow<'c, str>>
    {
        Self {
            inner,
            cookie: Self::create_cookie(
                cookie_name,
                cookie_value,
                path,
                http_only,
                expires,
                same_site,
                secure,
            )
        }
    }

    fn create_cookie<'c1, N, V, P>(
        cookie_name: N,
        cookie_value: V,
        path: P,
        http_only: bool,
        expires: Expiration,
        same_site: Option<SameSite>,
        secure: bool,
    ) -> Cookie<'c1>
    where
        N: Into<Cow<'c1, str>>,
        V: Into<Cow<'c1, str>>,
        P: Into<Cow<'c1, str>>
    {
        let mut cookie = Cookie::new(cookie_name, cookie_value);
        cookie.set_path(path);
        cookie.set_http_only(http_only);
        cookie.set_expires(expires);
        cookie.set_same_site(same_site);
        cookie.set_secure(secure);

        cookie
    }
}

impl<'c, T: Responder> Responder for SetCookie<'c, T> {
    type Body = <T as Responder>::Body;

    fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
        let mut response = self.inner.respond_to(req);
        response.add_cookie(&self.cookie).unwrap();
        response
    }
}