Struct SessionModel 

pub struct SessionModel { /* private fields */ }

Available on native and crate feature auth only.

Session model for database storage

Represents a session stored in the database with expiration information. This model implements the ORM Model trait when the database feature is enabled.

Example

use reinhardt_auth::sessions::models::SessionModel;
use chrono::Utc;
use serde_json::json;

// Create a new session model
let session = SessionModel::new(
    "abc123".to_string(),
    json!({"user_id": 42, "authenticated": true}),
    3600,
);

assert_eq!(session.session_key(), "abc123");
assert!(session.is_valid());

Implementations

impl SessionModel

pub fn new( session_key: String, session_data: Value, ttl_seconds: i64, ) -> SessionModel

Create a new session model

Arguments

• session_key - Unique session identifier
• session_data - Session data as JSON value
• ttl_seconds - Time to live in seconds

Example

use reinhardt_auth::sessions::models::SessionModel;
use serde_json::json;

let session = SessionModel::new(
    "session_123".to_string(),
    json!({"cart_total": 99.99}),
    7200,
);

pub fn with_expire_date( session_key: String, session_data: Value, expire_date: DateTime<Utc>, ) -> SessionModel

Create a session model with a specific expiration date

Example

use reinhardt_auth::sessions::models::SessionModel;
use chrono::{Utc, Duration};
use serde_json::json;

let expire_date = Utc::now() + Duration::hours(2);
let session = SessionModel::with_expire_date(
    "session_xyz".to_string(),
    json!({"preferences": {"theme": "dark"}}),
    expire_date,
);

pub fn session_key(&self) -> &str

Get the session key

Example

use reinhardt_auth::sessions::models::SessionModel;
use serde_json::json;

let session = SessionModel::new("key_123".to_string(), json!({}), 3600);
assert_eq!(session.session_key(), "key_123");

pub fn session_data(&self) -> &Value

Get the session data

Example

use reinhardt_auth::sessions::models::SessionModel;
use serde_json::json;

let data = json!({"user": "alice"});
let session = SessionModel::new("key".to_string(), data.clone(), 3600);
assert_eq!(session.session_data(), &data);

pub fn expire_date(&self) -> &DateTime<Utc>

Get the expiration date

Example

use reinhardt_auth::sessions::models::SessionModel;
use chrono::Utc;
use serde_json::json;

let session = SessionModel::new("key".to_string(), json!({}), 3600);
assert!(session.expire_date() > &Utc::now());

pub fn set_session_data(&mut self, data: Value)

Set the session data

Example

use reinhardt_auth::sessions::models::SessionModel;
use serde_json::json;

let mut session = SessionModel::new("key".to_string(), json!({}), 3600);
session.set_session_data(json!({"updated": true}));
assert_eq!(session.session_data()["updated"], true);

pub fn set_expire_date(&mut self, expire_date: DateTime<Utc>)

Set the expiration date

Example

use reinhardt_auth::sessions::models::SessionModel;
use chrono::{Utc, Duration};
use serde_json::json;

let mut session = SessionModel::new("key".to_string(), json!({}), 3600);
let new_expire = Utc::now() + Duration::hours(24);
session.set_expire_date(new_expire);

pub fn is_valid(&self) -> bool

Check if the session is still valid (not expired)

Example

use reinhardt_auth::sessions::models::SessionModel;
use serde_json::json;

let session = SessionModel::new("key".to_string(), json!({}), 3600);
assert!(session.is_valid());

let expired = SessionModel::new("old".to_string(), json!({}), -100);
assert!(!expired.is_valid());

pub fn is_expired(&self) -> bool

Check if the session has expired

Example

use reinhardt_auth::sessions::models::SessionModel;
use serde_json::json;

let session = SessionModel::new("key".to_string(), json!({}), 3600);
assert!(!session.is_expired());

let expired = SessionModel::new("old".to_string(), json!({}), -100);
assert!(expired.is_expired());

pub fn extend(&mut self, seconds: i64)

Extend the session expiration by the given number of seconds

Example

use reinhardt_auth::sessions::models::SessionModel;
use chrono::Utc;
use serde_json::json;

let mut session = SessionModel::new("key".to_string(), json!({}), 3600);
let old_expire = *session.expire_date();

session.extend(1800);
assert!(session.expire_date() > &old_expire);

pub fn refresh(&mut self, ttl_seconds: i64)

Refresh the session with a new TTL from now

Example

use reinhardt_auth::sessions::models::SessionModel;
use chrono::Utc;
use serde_json::json;

let mut session = SessionModel::new("key".to_string(), json!({}), 3600);
session.refresh(7200);

// New expiration should be approximately 7200 seconds from now
let expected = Utc::now() + chrono::Duration::seconds(7200);
assert!(session.expire_date().signed_duration_since(expected).num_seconds().abs() < 2);

Trait Implementations

impl Clone for SessionModel

fn clone(&self) -> SessionModel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SessionModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SessionModel

fn deserialize<__D>( __deserializer: __D, ) -> Result<SessionModel, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Model for SessionModel

Available on crate feature database only.

type PrimaryKey = String

The primary key type

type Fields = SessionModelFields

Type-safe field selector

type Objects = Manager<SessionModel>

The manager type returned by objects().

fn table_name() -> &'static str

Get the table name

fn new_fields() -> <SessionModel as Model>::Fields

Create a new field selector instance

fn primary_key_field() -> &'static str

Get the primary key field name

fn primary_key(&self) -> Option<<SessionModel as Model>::PrimaryKey>

Get the primary key value

fn set_primary_key(&mut self, value: <SessionModel as Model>::PrimaryKey)

Set the primary key value

fn app_label() -> &'static str

Get the app label for this model

fn composite_primary_key() -> Option<CompositePrimaryKey>

Get composite primary key definition if this model uses composite PK

fn get_composite_pk_values(&self) -> HashMap<String, PkValue>

Get composite primary key values for this instance

fn field_metadata() -> Vec<FieldInfo>

Get field metadata for inspection

fn relationship_metadata() -> Vec<RelationInfo>

Get relationship metadata for inspection

fn index_metadata() -> Vec<IndexInfo>

Get index metadata for inspection

fn constraint_metadata() -> Vec<ConstraintInfo>

Get constraint metadata for inspection

fn objects() -> Self::Objects

where Self: Sized,

Django-style objects manager accessor

fn save(&mut self) -> impl Future<Output = Result<(), Error>> + Send

where Self: Sized,

Save the model instance to the database with event dispatching

fn delete(&self) -> impl Future<Output = Result<(), Error>> + Send

where Self: Sized,

Delete the model instance from the database with event dispatching

impl Serialize for SessionModel

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.