mincat 0.1.0

Web framework
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

use mincat_core::{
    error::Error,
    request::{FromRequestParts, Parts},
};
use serde::{de::DeserializeOwned, Serialize};

use crate::middleware::session::SessionStore;

pub struct Session {
    pub(crate) store: Box<dyn SessionStore>,
    pub(crate) session_id: String,
}

impl Clone for Session {
    fn clone(&self) -> Self {
        Self {
            store: self.store.clone_box(),
            session_id: self.session_id.clone(),
        }
    }
}

impl Session {
    pub async fn set<T: Serialize>(&self, key: &str, value: T) -> Result<(), Error> {
        let value = serde_json::to_string(&value).map_err(Error::new)?;
        self.store.set(&self.session_id, key, &value).await?;
        Ok(())
    }

    pub async fn get<T: DeserializeOwned>(&self, key: &str) -> Result<Option<T>, Error> {
        let value = self.store.get(&self.session_id, key).await?;
        match value {
            Some(value) => Ok(Some(
                serde_json::from_str::<T>(value.as_str()).map_err(Error::new)?,
            )),
            None => Ok(None),
        }
    }
}

#[async_trait::async_trait]
impl FromRequestParts for Session {
    type Error = Error;

    async fn from_request_parts(parts: &mut Parts) -> Result<Self, Self::Error> {
        parts
            .extensions
            .get::<Session>()
            .cloned()
            .ok_or(Error::new("get session failed"))
    }
}