feature: history endpoint

src/data/enums/session_status.rs

@@ -4,9 +4,10 @@ use diesel::{
     pg::{Pg, PgValue},
     serialize::{self, IsNull, Output, ToSql},
 };
+use serde::{Deserialize, Serialize};
 use std::io::Write;
 
-#[derive(Debug, AsExpression, FromSqlRow, PartialEq, Eq, Clone, Copy)]
+#[derive(Debug, AsExpression, FromSqlRow, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
 #[diesel(sql_type = crate::data::schema::sql_types::SessionStatus)]
 pub enum SessionStatus {
     Active,

src/dto/session/internal/mod.rs

@@ -1,2 +1,5 @@
 pub mod new_session;
 pub use new_session::NewSession;
+
+pub mod session_history;
+pub use session_history::SessionHistory;

src/dto/session/internal/session_history.rs

@@ -0,0 +1,15 @@
+use chrono::NaiveDateTime;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::data::enums::Country;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct SessionHistory {
+    pub id: Uuid,
+    pub device_id: Uuid,
+    pub opened_at: NaiveDateTime,
+    pub closed_at: NaiveDateTime,
+    pub duration: i64,
+    pub country: Country,
+}

src/dto/session/request/get_history.rs

@@ -0,0 +1,12 @@
+use serde::Deserialize;
+use uuid::Uuid;
+
+use crate::data::enums::Country;
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Params {
+    pub limit: Option<i64>,
+    pub offset: Option<i64>,
+    pub countries: Option<Vec<Country>>,
+    pub devices: Option<Vec<Uuid>>,
+}

src/dto/session/request/mod.rs

@@ -1,2 +1,5 @@
 pub mod create_session;
 pub use create_session::CreateSession;
+
+pub mod get_history;
+pub use get_history::Params;

src/handlers/session/get_history.rs

@@ -0,0 +1,26 @@
+use axum::{extract::State, http::StatusCode};
+use deadpool_diesel::postgres::Pool;
+use tracing::info;
+
+use crate::{
+    dto::{
+        auth::internal::AccessToken,
+        response::success::Response,
+        session::{internal::SessionHistory, request::Params},
+    },
+    enums::errors::external::ExternalError,
+    extractors::Json,
+    services::session_service,
+};
+
+pub async fn get_history(
+    claims: AccessToken,
+    State(pool): State<Pool>,
+    Json(payload): Json<Params>,
+) -> Result<Response<Vec<SessionHistory>>, ExternalError> {
+    info!("Getting session history");
+
+    let history = session_service::get_history(&pool, &claims.user_id, &payload).await?;
+
+    Ok(Response::new(StatusCode::OK, "Successfully got session history").with_data(history))
+}

src/handlers/session/mod.rs

@@ -3,3 +3,6 @@ pub use create_session::create_session;
 
 pub mod close_session;
 pub use close_session::close_session;
+
+pub mod get_history;
+pub use get_history::get_history;

src/routers/session_router.rs

@@ -1,15 +1,16 @@
 use crate::{
-    handlers::session::{close_session, create_session},
+    handlers::session::{close_session, create_session, get_history},
     AppState,
 };
 use axum::{
-    routing::{post, put},
+    routing::{get, post, put},
     Router,
 };
 
 pub fn session_router(state: AppState) -> Router<AppState> {
     Router::new()
         .route("/", post(create_session))
         .route("/", put(close_session))
+        .route("/history", get(get_history))
         .with_state(state)
 }

src/services/session_service.rs

@@ -1,13 +1,14 @@
 use crate::{
     data::{
         enums::{ConfigStatus, Country, SessionStatus},
-        models::Session,
+        models::{Config, Server, Session},
         schema,
     },
     dto::session::{
         interface::get_session,
-        internal::NewSession,
+        internal::{NewSession, SessionHistory},
         query::{ActiveSessionAndDevice, ActiveSessionAndDeviceAndCountry},
+        request::Params,
         response,
     },
     enums::errors::internal::{InternalError, SessionError},
@@ -118,3 +119,63 @@ pub async fn close_session(
     let session_id = close_session_by_id(pool, &session.id).await?;
     Ok(session_id)
 }
+
+pub async fn get_history(
+    pool: &deadpool_diesel::postgres::Pool,
+    user_id: &Uuid,
+    params: &Params,
+) -> Result<Vec<SessionHistory>, InternalError> {
+    let conn = pool.get().await?;
+
+    let limit = params.limit.unwrap_or(10);
+    let offset = params.offset.unwrap_or(0);
+    let devices = params.devices.clone();
+    let countries = params.countries.clone();
+    let user_id = *user_id;
+
+    let data: Vec<(Session, Config, Server)> = conn
+        .interact(move |conn| {
+            schema::session::table
+                .inner_join(schema::config::table.inner_join(schema::server::table))
+                .filter(schema::session::status.eq(SessionStatus::Closed))
+                .filter(
+                    schema::server::country.eq_any(
+                        countries.unwrap_or(
+                            schema::server::table
+                                .select(schema::server::country)
+                                .load::<Country>(conn)?,
+                        ),
+                    ),
+                )
+                .filter(
+                    schema::session::device_id.eq_any(
+                        devices.unwrap_or(
+                            schema::device::table
+                                .select(schema::device::id)
+                                .filter(schema::device::user_id.eq(user_id))
+                                .load::<Uuid>(conn)?,
+                        ),
+                    ),
+                )
+                .limit(limit)
+                .offset(offset)
+                .select((
+                    Session::as_select(),
+                    Config::as_select(),
+                    Server::as_select(),
+                ))
+                .load::<(Session, Config, Server)>(conn)
+        })
+        .await??;
+
+    let history = data.iter().map(|(session, _, server)| SessionHistory {
+        id: session.id,
+        device_id: session.device_id,
+        opened_at: session.opened_at,
+        closed_at: session.closed_at.unwrap(),
+        duration: (session.closed_at.unwrap() - session.opened_at).num_seconds(),
+        country: server.country,
+    });
+
+    Ok(history.collect())
+}