feat: dashboard implementation

src/handlers/http/modal/server.rs

@@ -241,7 +241,6 @@ impl Server {
             )
     }
 
-    // get the dashboards web scope
     pub fn get_dashboards_webscope() -> Scope {
         web::scope("/dashboards")
             .service(
@@ -258,21 +257,31 @@ impl Server {
                     ),
             )
             .service(
-                web::resource("/{dashboard_id}")
-                    .route(
-                        web::get()
-                            .to(dashboards::get)
-                            .authorize(Action::GetDashboard),
-                    )
-                    .route(
-                        web::delete()
-                            .to(dashboards::delete)
-                            .authorize(Action::DeleteDashboard),
+                web::scope("/{dashboard_id}")
+                    .service(
+                        web::resource("")
+                            .route(
+                                web::get()
+                                    .to(dashboards::get)
+                                    .authorize(Action::GetDashboard),
+                            )
+                            .route(
+                                web::delete()
+                                    .to(dashboards::delete)
+                                    .authorize(Action::DeleteDashboard),
+                            )
+                            .route(
+                                web::put()
+                                    .to(dashboards::update)
+                                    .authorize(Action::CreateDashboard),
+                            ),
                     )
-                    .route(
-                        web::put()
-                            .to(dashboards::update)
-                            .authorize(Action::CreateDashboard),
+                    .service(
+                        web::resource("/add_tile").route(
+                            web::put()
+                                .to(dashboards::add_tile)
+                                .authorize(Action::CreateDashboard),
+                        ),
                     ),
             )
     }

src/handlers/http/users/dashboards.rs

@@ -18,42 +18,57 @@
 
 use crate::{
     handlers::http::rbac::RBACError,
-    parseable::PARSEABLE,
-    storage::{object_storage::dashboard_path, ObjectStorageError},
-    users::dashboards::{Dashboard, CURRENT_DASHBOARD_VERSION, DASHBOARDS},
-    utils::{actix::extract_session_key_from_req, get_hash, get_user_from_request},
+    storage::ObjectStorageError,
+    users::dashboards::{validate_dashboard_id, Dashboard, Tile, DASHBOARDS},
+    utils::{get_hash, get_user_from_request},
 };
 use actix_web::{
     http::header::ContentType,
     web::{self, Json, Path},
     HttpRequest, HttpResponse, Responder,
 };
-use bytes::Bytes;
-use rand::distributions::DistString;
-
-use chrono::Utc;
 use http::StatusCode;
-use serde_json::Error as SerdeError;
-
-pub async fn list(req: HttpRequest) -> Result<impl Responder, DashboardError> {
-    let key =
-        extract_session_key_from_req(&req).map_err(|e| DashboardError::Custom(e.to_string()))?;
-    let dashboards = DASHBOARDS.list_dashboards(&key).await;
-
+use serde_json::{Error as SerdeError, Map};
+
+pub async fn list() -> Result<impl Responder, DashboardError> {
+    let dashboards = DASHBOARDS.list_dashboards().await;
+    //dashboards list should contain the title, author and modified date
+    let dashboards: Vec<Map<String, serde_json::Value>> = dashboards
+        .iter()
+        .map(|dashboard| {
+            let mut map = Map::new();
+            map.insert(
+                "title".to_string(),
+                serde_json::Value::String(dashboard.title.clone()),
+            );
+            if let Some(author) = &dashboard.author {
+                map.insert(
+                    "author".to_string(),
+                    serde_json::Value::String(author.to_string()),
+                );
+            }
+            if let Some(modified) = &dashboard.modified {
+                map.insert(
+                    "modified".to_string(),
+                    serde_json::Value::String(modified.to_string()),
+                );
+            }
+            if let Some(dashboard_id) = &dashboard.dashboard_id {
+                map.insert(
+                    "dashboard_id".to_string(),
+                    serde_json::Value::String(dashboard_id.to_string()),
+                );
+            }
+            map
+        })
+        .collect();
     Ok((web::Json(dashboards), StatusCode::OK))
 }
 
-pub async fn get(
-    req: HttpRequest,
-    dashboard_id: Path<String>,
-) -> Result<impl Responder, DashboardError> {
-    let user_id = get_user_from_request(&req)?;
-    let dashboard_id = dashboard_id.into_inner();
+pub async fn get(dashboard_id: Path<String>) -> Result<impl Responder, DashboardError> {
+    let dashboard_id = validate_dashboard_id(dashboard_id.into_inner())?;
 
-    if let Some(dashboard) = DASHBOARDS
-        .get_dashboard(&dashboard_id, &get_hash(&user_id))
-        .await
-    {
+    if let Some(dashboard) = DASHBOARDS.get_dashboard(dashboard_id).await {
         return Ok((web::Json(dashboard), StatusCode::OK));
     }
 
@@ -64,33 +79,14 @@ pub async fn post(
     req: HttpRequest,
     Json(mut dashboard): Json<Dashboard>,
 ) -> Result<impl Responder, DashboardError> {
+    if dashboard.title.is_empty() {
+        return Err(DashboardError::Metadata("Title must be provided"));
+    }
     let mut user_id = get_user_from_request(&req)?;
     user_id = get_hash(&user_id);
-    let dashboard_id = get_hash(Utc::now().timestamp_micros().to_string().as_str());
-    dashboard.dashboard_id = Some(dashboard_id.clone());
-    dashboard.version = Some(CURRENT_DASHBOARD_VERSION.to_string());
-
-    dashboard.user_id = Some(user_id.clone());
-    for tile in dashboard.tiles.iter_mut() {
-        tile.tile_id = Some(get_hash(
-            format!(
-                "{}{}",
-                rand::distributions::Alphanumeric.sample_string(&mut rand::thread_rng(), 8),
-                Utc::now().timestamp_micros()
-            )
-            .as_str(),
-        ));
-    }
-    DASHBOARDS.update(&dashboard).await;
-
-    let path = dashboard_path(&user_id, &format!("{}.json", dashboard_id));
-
-    let store = PARSEABLE.storage.get_object_store();
-    let dashboard_bytes = serde_json::to_vec(&dashboard)?;
-    store
-        .put_object(&path, Bytes::from(dashboard_bytes))
-        .await?;
+    dashboard.author = Some(user_id.clone());
 
+    DASHBOARDS.create(&user_id, &mut dashboard).await?;
     Ok((web::Json(dashboard), StatusCode::OK))
 }
 
@@ -101,33 +97,20 @@ pub async fn update(
 ) -> Result<impl Responder, DashboardError> {
     let mut user_id = get_user_from_request(&req)?;
     user_id = get_hash(&user_id);
-    let dashboard_id = dashboard_id.into_inner();
+    let dashboard_id = validate_dashboard_id(dashboard_id.into_inner())?;
 
-    if DASHBOARDS
-        .get_dashboard(&dashboard_id, &user_id)
-        .await
-        .is_none()
-    {
-        return Err(DashboardError::Metadata("Dashboard does not exist"));
-    }
-    dashboard.dashboard_id = Some(dashboard_id.to_string());
-    dashboard.user_id = Some(user_id.clone());
-    dashboard.version = Some(CURRENT_DASHBOARD_VERSION.to_string());
-    for tile in dashboard.tiles.iter_mut() {
-        if tile.tile_id.is_none() {
-            tile.tile_id = Some(get_hash(Utc::now().timestamp_micros().to_string().as_str()));
+    for tile in dashboard.tiles.as_ref().unwrap_or(&Vec::new()) {
+        if tile.tile_id.is_nil() {
+            return Err(DashboardError::Metadata(
+                "Tile ID must be provided by the client",
+            ));
         }
     }
-    DASHBOARDS.update(&dashboard).await;
+    dashboard.author = Some(user_id.clone());
 
-    let path = dashboard_path(&user_id, &format!("{}.json", dashboard_id));
-
-    let store = PARSEABLE.storage.get_object_store();
-    let dashboard_bytes = serde_json::to_vec(&dashboard)?;
-    store
-        .put_object(&path, Bytes::from(dashboard_bytes))
+    DASHBOARDS
+        .update(&user_id, dashboard_id, &mut dashboard)
         .await?;
-
     Ok((web::Json(dashboard), StatusCode::OK))
 }
 
@@ -137,21 +120,38 @@ pub async fn delete(
 ) -> Result<HttpResponse, DashboardError> {
     let mut user_id = get_user_from_request(&req)?;
     user_id = get_hash(&user_id);
-    let dashboard_id = dashboard_id.into_inner();
-    if DASHBOARDS
-        .get_dashboard(&dashboard_id, &user_id)
-        .await
-        .is_none()
-    {
-        return Err(DashboardError::Metadata("Dashboard does not exist"));
+    let dashboard_id = validate_dashboard_id(dashboard_id.into_inner())?;
+    DASHBOARDS.delete_dashboard(&user_id, dashboard_id).await?;
+
+    Ok(HttpResponse::Ok().finish())
+}
+
+pub async fn add_tile(
+    req: HttpRequest,
+    dashboard_id: Path<String>,
+    Json(tile): Json<Tile>,
+) -> Result<impl Responder, DashboardError> {
+    let mut user_id = get_user_from_request(&req)?;
+    user_id = get_hash(&user_id);
+    let dashboard_id = validate_dashboard_id(dashboard_id.into_inner())?;
+
+    if tile.tile_id.is_nil() {
+        return Err(DashboardError::Metadata(
+            "Tile ID must be provided by the client",
+        ));
     }
-    let path = dashboard_path(&user_id, &format!("{}.json", dashboard_id));
-    let store = PARSEABLE.storage.get_object_store();
-    store.delete_object(&path).await?;
 
-    DASHBOARDS.delete_dashboard(&dashboard_id).await;
+    let mut dashboard = DASHBOARDS
+        .get_dashboard_by_user(dashboard_id, &user_id)
+        .await
+        .ok_or(DashboardError::Unauthorized)?;
+    let tiles = dashboard.tiles.get_or_insert_with(Vec::new);
+    tiles.push(tile.clone());
+    DASHBOARDS
+        .update(&user_id, dashboard_id, &mut dashboard)
+        .await?;
 
-    Ok(HttpResponse::Ok().finish())
+    Ok((web::Json(dashboard), StatusCode::OK))
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -166,6 +166,8 @@ pub enum DashboardError {
     UserDoesNotExist(#[from] RBACError),
     #[error("Error: {0}")]
     Custom(String),
+    #[error("Unauthorized to access resource")]
+    Unauthorized,
 }
 
 impl actix_web::ResponseError for DashboardError {
@@ -176,6 +178,7 @@ impl actix_web::ResponseError for DashboardError {
             Self::Metadata(_) => StatusCode::BAD_REQUEST,
             Self::UserDoesNotExist(_) => StatusCode::NOT_FOUND,
             Self::Custom(_) => StatusCode::INTERNAL_SERVER_ERROR,
+            Self::Unauthorized => StatusCode::UNAUTHORIZED,
         }
     }
 

src/prism/home/mod.rs

@@ -103,7 +103,7 @@ pub async fn generate_home_response(key: &SessionKey) -> Result<HomeResponse, Pr
         get_stream_titles(key),
         get_alert_titles(key),
         get_correlation_titles(key),
-        get_dashboard_titles(key),
+        get_dashboard_titles(),
         get_filter_titles(key),
         get_alerts_info()
     );
@@ -239,19 +239,14 @@ async fn get_correlation_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, Pri
     Ok(correlation_titles)
 }
 
-async fn get_dashboard_titles(key: &SessionKey) -> Result<Vec<TitleAndId>, PrismHomeError> {
+async fn get_dashboard_titles() -> Result<Vec<TitleAndId>, PrismHomeError> {
     let dashboard_titles = DASHBOARDS
-        .list_dashboards(key)
+        .list_dashboards()
         .await
         .iter()
         .map(|dashboard| TitleAndId {
-            title: dashboard.name.clone(),
-            id: dashboard
-                .dashboard_id
-                .as_ref()
-                .ok_or_else(|| anyhow::Error::msg("Dashboard ID is null"))
-                .unwrap()
-                .clone(),
+            title: dashboard.title.clone(),
+            id: dashboard.dashboard_id.as_ref().unwrap().to_string(),
         })
         .collect_vec();