rocket_base_app/src/session.rs

extern crate redis;
use redis::Commands;
use rocket::http::CookieJar;
use serde_json::Value;
use serde_json::json;
use std::error::Error;

pub const COOKIE_NAME: &str = "app_base_uuid";
pub const EXPIRE_SESSION_SECS: i64 = 60 * 60; //365 * 24 * 60 * 60; //1 anno, 1 year
pub static REDIS_URL: &str = "redis://127.0.0.1";

pub fn get_session(
    cookies: &CookieJar<'_>,
    cookie_name: String,
    val: String,
) -> Result<String, Box<dyn Error>> {
    let res: String;
    match cookies.get(cookie_name.as_str()) {
        Some(c) => {
            let mut client_valkey = redis::Client::open(REDIS_URL)?;
            let valkey_session: String = client_valkey.get(c.value().to_string())?; //valkey_session contiene l'intero json
            let json_str = valkey_session; //json convertito in str
            let v: Value = serde_json::from_str(json_str.as_str())?;
            res = v[val.as_str()].to_string().replace("\"", "");
        }

        None => {
            res = "".to_string();
            println!("Coookie {} not found!", cookie_name);
        }
    }
    Ok(res)
}

pub fn set_session(
    cookies: &CookieJar<'_>,
    cookie_name: String,
    val: String,
    val_elem: String,
) -> Result<String, Box<dyn Error>> {
    let cv: String;
    match cookies.get(cookie_name.as_str()) {
        Some(c) => cv = c.value().to_string(),
        None => {
            eprintln!("Cookie {} not found!", cookie_name);
            return Ok(String::new());
        }
    };

    let client = redis::Client::open(REDIS_URL)?;
    let mut conn = client.get_connection()?;

    let key = cv.as_str();

    let json_blank = json!({"id":"","username":""});
    let valkey_session: String = conn.get(key).unwrap_or_else(|_e| json_blank.to_string());
    let mut v: Value = serde_json::from_str(&valkey_session).unwrap_or_else(|_e| json_blank);

    v[val.as_str()] = Value::String(val_elem);
    let new_json: String = v.to_string();
    conn.set::<&str, String, ()>(key, new_json.clone())?;

    Ok(new_json)
}

pub fn set_expire_session(session_name: &str, s: i64) -> Result<bool, Box<dyn Error>> {
    let client = redis::Client::open(REDIS_URL)?;
    let mut conn = client.get_connection()?;
    let ok: bool = conn.expire(session_name, s)?;
    Ok(ok)
}
pub fn del_session(session_name: &str) -> Result<bool, Box<dyn Error>> {
    let client = redis::Client::open(REDIS_URL)?;
    let mut conn = client.get_connection()?;
    let ok: bool = conn.del(session_name)?;
    Ok(ok)
}