use std::{cell::RefCell, convert::Infallible, rc::Rc};
use ntex::http::{Payload, RequestHead};
use ntex::util::{Extensions, HashMap};
use ntex::web::{FromRequest, HttpRequest, WebRequest, WebResponse};
use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::error::Error as JsonError;
#[cfg(feature = "cookie-session")]
mod cookie;
#[cfg(feature = "cookie-session")]
pub use crate::cookie::{CookieSession, CookieSessionError, CookieSessionMiddleware};
pub struct Session(Rc<RefCell<SessionInner>>);
pub trait UserSession {
fn get_session(&self) -> Session;
}
impl UserSession for HttpRequest {
fn get_session(&self) -> Session {
Session::get_session(&mut self.extensions_mut())
}
}
impl<St> UserSession for WebRequest<St> {
fn get_session(&self) -> Session {
Session::get_session(&mut self.extensions_mut())
}
}
impl UserSession for RequestHead {
fn get_session(&self) -> Session {
Session::get_session(&mut self.extensions_mut())
}
}
#[derive(PartialEq, Clone, Debug, Default)]
pub enum SessionStatus {
Changed,
Purged,
Renewed,
#[default]
Unchanged,
}
#[derive(Default)]
struct SessionInner {
state: HashMap<String, String>,
pub status: SessionStatus,
}
impl Session {
pub fn get<T: DeserializeOwned>(&self, key: &str) -> Result<Option<T>, JsonError> {
if let Some(s) = self.0.borrow().state.get(key) {
Ok(Some(serde_json::from_str(s)?))
} else {
Ok(None)
}
}
pub fn set<T: Serialize>(&self, key: &str, value: T) -> Result<(), JsonError> {
let mut inner = self.0.borrow_mut();
if inner.status != SessionStatus::Purged {
inner.status = SessionStatus::Changed;
inner
.state
.insert(key.to_owned(), serde_json::to_string(&value)?);
}
Ok(())
}
pub fn remove(&self, key: &str) {
let mut inner = self.0.borrow_mut();
if inner.status != SessionStatus::Purged {
inner.status = SessionStatus::Changed;
inner.state.remove(key);
}
}
pub fn clear(&self) {
let mut inner = self.0.borrow_mut();
if inner.status != SessionStatus::Purged {
inner.status = SessionStatus::Changed;
inner.state.clear()
}
}
pub fn purge(&self) {
let mut inner = self.0.borrow_mut();
inner.status = SessionStatus::Purged;
inner.state.clear();
}
pub fn renew(&self) {
let mut inner = self.0.borrow_mut();
if inner.status != SessionStatus::Purged {
inner.status = SessionStatus::Renewed;
}
}
pub fn set_session<St>(data: impl Iterator<Item = (String, String)>, req: &WebRequest<St>) {
let session = Session::get_session(&mut req.extensions_mut());
let mut inner = session.0.borrow_mut();
inner.state.extend(data);
}
pub fn get_changes(
res: &mut WebResponse,
) -> (
SessionStatus,
Option<impl Iterator<Item = (String, String)> + use<>>,
) {
if let Some(s_impl) = res
.request()
.extensions()
.get::<Rc<RefCell<SessionInner>>>()
{
let state = std::mem::take(&mut s_impl.borrow_mut().state);
(s_impl.borrow().status.clone(), Some(state.into_iter()))
} else {
(SessionStatus::Unchanged, None)
}
}
fn get_session(extensions: &mut Extensions) -> Session {
if let Some(s_impl) = extensions.get::<Rc<RefCell<SessionInner>>>() {
return Session(Rc::clone(s_impl));
}
let inner = Rc::new(RefCell::new(SessionInner::default()));
extensions.insert(inner.clone());
Session(inner)
}
}
impl<St> FromRequest<St> for Session {
type Error = Infallible;
#[inline]
async fn from_request(
_: &St,
req: &HttpRequest,
_: &mut Payload,
) -> Result<Session, Infallible> {
Ok(Session::get_session(&mut req.extensions_mut()))
}
}
#[cfg(test)]
mod tests {
use ntex::web::{HttpResponse, test};
use super::*;
#[test]
fn session() {
let req = test::TestRequest::default().to_srv_request();
Session::set_session(
vec![("key".to_string(), "\"value\"".to_string())].into_iter(),
&req,
);
let session = Session::get_session(&mut req.extensions_mut());
let res = session.get::<String>("key").unwrap();
assert_eq!(res, Some("value".to_string()));
session.set("key2", "value2".to_string()).unwrap();
session.remove("key");
let mut res = req.into_response(HttpResponse::Ok().build());
let (_status, state) = Session::get_changes(&mut res);
let changes: Vec<_> = state.unwrap().collect();
assert_eq!(changes, [("key2".to_string(), "\"value2\"".to_string())]);
}
#[test]
fn get_session() {
let req = test::TestRequest::default().to_srv_request();
Session::set_session(
vec![("key".to_string(), "\"value\"".to_string())].into_iter(),
&req,
);
let session = req.get_session();
let res = session.get::<String>("key").unwrap();
assert_eq!(res, Some("value".to_string()));
}
#[test]
fn get_session_from_request_head() {
let mut req = test::TestRequest::default().to_srv_request();
Session::set_session(
vec![("key".to_string(), "\"value\"".to_string())].into_iter(),
&req,
);
let session = req.head_mut().get_session();
let res = session.get::<String>("key").unwrap();
assert_eq!(res, Some("value".to_string()));
}
#[test]
fn purge_session() {
let req = test::TestRequest::default().to_srv_request();
let session = req.get_session();
session.set("key", "value").unwrap();
session.purge();
session.set("key", "replacement").unwrap();
session.remove("key");
session.clear();
session.renew();
assert_eq!(session.get::<String>("key").unwrap(), None);
let mut res = req.into_response(HttpResponse::Ok().build());
let (status, state) = Session::get_changes(&mut res);
assert_eq!(status, SessionStatus::Purged);
assert_eq!(state.unwrap().count(), 0);
}
#[test]
fn renew_session() {
let req = test::TestRequest::default().to_srv_request();
Session::set_session([("key".to_owned(), "42".to_owned())].into_iter(), &req);
req.get_session().renew();
let mut res = req.into_response(HttpResponse::Ok().build());
let (status, state) = Session::get_changes(&mut res);
assert_eq!(status, SessionStatus::Renewed);
assert_eq!(
state.unwrap().collect::<Vec<_>>(),
[("key".to_owned(), "42".to_owned())]
);
}
#[test]
fn shared_session_handles_clear_and_drain_state() {
let mut untouched =
test::TestRequest::default().to_srv_response(HttpResponse::Ok().build());
let (status, state) = Session::get_changes(&mut untouched);
assert_eq!(status, SessionStatus::Unchanged);
assert!(state.is_none());
let req = test::TestRequest::default().to_http_request();
let first = req.get_session();
let second = req.clone().get_session();
first.set("first", 1).unwrap();
second.set("second", 2).unwrap();
assert_eq!(second.get::<u32>("first").unwrap(), Some(1));
assert_eq!(first.get::<u32>("second").unwrap(), Some(2));
second.clear();
assert_eq!(first.get::<u32>("first").unwrap(), None);
assert_eq!(first.get::<u32>("second").unwrap(), None);
first.set("replacement", 3).unwrap();
let mut res = WebRequest::from_request(req).into_response(HttpResponse::Ok().build());
let (status, state) = Session::get_changes(&mut res);
assert_eq!(status, SessionStatus::Changed);
assert_eq!(
state.unwrap().collect::<Vec<_>>(),
[("replacement".to_owned(), "3".to_owned())]
);
assert_eq!(second.get::<u32>("replacement").unwrap(), None);
}
#[test]
fn session_json_errors_preserve_existing_values() {
struct Unserializable;
impl Serialize for Unserializable {
fn serialize<S: serde::Serializer>(&self, _: S) -> Result<S::Ok, S::Error> {
Err(serde::ser::Error::custom("cannot serialize session value"))
}
}
let req = test::TestRequest::default().to_srv_request();
Session::set_session(
[
("bad".to_owned(), "not-json".to_owned()),
("good".to_owned(), "42".to_owned()),
]
.into_iter(),
&req,
);
let session = req.get_session();
assert!(session.get::<u32>("bad").is_err());
assert!(session.get::<String>("good").is_err());
assert!(
session
.set("good", Unserializable)
.unwrap_err()
.to_string()
.contains("cannot serialize")
);
assert_eq!(session.get::<u32>("good").unwrap(), Some(42));
let mut res = req.into_response(HttpResponse::Ok().build());
let (_, state) = Session::get_changes(&mut res);
let state: HashMap<_, _> = state.unwrap().collect();
assert_eq!(state.get("good").map(String::as_str), Some("42"));
}
}