feat: show content and wip editing

src/bin/server.rs

@@ -29,6 +29,7 @@ use zettle_db::{
             html::{
                 account::{delete_account, set_api_key, show_account_page, update_timezone},
                 admin_panel::{show_admin_panel, toggle_registration_status},
+                content::{patch_text_content, show_content_page, show_text_content_edit_form},
                 documentation::{
                     show_documentation_index, show_get_started, show_mobile_friendly,
                     show_privacy_policy,
@@ -38,7 +39,8 @@ use zettle_db::{
                 ingress_form::{hide_ingress_form, process_ingress_form, show_ingress_form},
                 knowledge::{
                     delete_knowledge_entity, delete_knowledge_relationship, patch_knowledge_entity,
-                    show_edit_knowledge_entity_form, show_knowledge_page,
+                    save_knowledge_relationship, show_edit_knowledge_entity_form,
+                    show_knowledge_page,
                 },
                 search_result::search_result_handler,
                 signin::{authenticate_user, show_signin_form},
@@ -177,6 +179,11 @@ fn html_routes(
         .route("/text-content/:id", delete(delete_text_content))
         .route("/jobs/:job_id", delete(delete_job))
         .route("/active-jobs", get(show_active_jobs))
+        .route("/content", get(show_content_page))
+        .route(
+            "/content/:id",
+            get(show_text_content_edit_form).patch(patch_text_content),
+        )
         .route("/knowledge", get(show_knowledge_page))
         .route(
             "/knowledge-entity/:id",
@@ -184,6 +191,7 @@ fn html_routes(
                 .delete(delete_knowledge_entity)
                 .patch(patch_knowledge_entity),
         )
+        .route("/knowledge-relationship", post(save_knowledge_relationship))
         .route(
             "/knowledge-relationship/:id",
             delete(delete_knowledge_relationship),

src/server/routes/html/content/mod.rs

@@ -0,0 +1,108 @@
+use axum::{
+    extract::{Path, State},
+    response::{IntoResponse, Redirect},
+};
+use axum_session_auth::AuthSession;
+use axum_session_surreal::SessionSurrealPool;
+use surrealdb::{engine::any::Any, Surreal};
+
+use crate::{
+    error::HtmlError,
+    page_data,
+    server::AppState,
+    storage::types::{text_content::TextContent, user::User},
+};
+
+use super::render_template;
+
+page_data!(ContentPageData, "content/base.html", {
+    user: User,
+    text_contents: Vec<TextContent>
+});
+
+pub async fn show_content_page(
+    State(state): State<AppState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    let text_contents = User::get_text_contents(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        ContentPageData::template_name(),
+        ContentPageData {
+            user,
+            text_contents,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}
+
+#[derive(Serialize)]
+pub struct TextContentEditModal {
+    pub user: User,
+    pub text_content: TextContent,
+}
+
+pub async fn show_text_content_edit_form(
+    State(state): State<AppState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    let text_content = User::get_and_validate_text_content(&id, &user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        "content/edit_text_content_modal.html",
+        TextContentEditModal { user, text_content },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}
+
+pub async fn patch_text_content(
+    State(state): State<AppState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    let text_content = User::get_and_validate_text_content(&id, &user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let text_contents = User::get_text_contents(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let output = render_template(
+        "content/content_list.html",
+        ContentPageData {
+            user,
+            text_contents,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}

src/server/routes/html/knowledge/mod.rs

@@ -281,6 +281,8 @@ pub async fn delete_knowledge_relationship(
         None => return Ok(Redirect::to("/signin").into_response()),
     };
 
+    // GOTTA ADD AUTH VALIDATION
+
     KnowledgeRelationship::delete_relationship_by_id(&id, &state.surreal_db_client)
         .await
         .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
@@ -305,3 +307,56 @@ pub async fn delete_knowledge_relationship(
 
     Ok(output.into_response())
 }
+
+#[derive(Deserialize)]
+pub struct SaveKnowledgeRelationshipInput {
+    pub in_: String,
+    pub out: String,
+    pub relationship_type: String,
+}
+
+pub async fn save_knowledge_relationship(
+    State(state): State<AppState>,
+    auth: AuthSession<User, String, SessionSurrealPool<Any>, Surreal<Any>>,
+    Form(form): Form<SaveKnowledgeRelationshipInput>,
+) -> Result<impl IntoResponse, HtmlError> {
+    // Early return if the user is not authenticated
+    let user = match auth.current_user {
+        Some(user) => user,
+        None => return Ok(Redirect::to("/signin").into_response()),
+    };
+
+    // Construct relationship
+    let relationship = KnowledgeRelationship::new(
+        form.in_,
+        form.out,
+        user.id.clone(),
+        "manual".into(),
+        form.relationship_type,
+    );
+
+    relationship
+        .store_relationship(&state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let entities = User::get_knowledge_entities(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    let relationships = User::get_knowledge_relationships(&user.id, &state.surreal_db_client)
+        .await
+        .map_err(|e| HtmlError::new(e, state.templates.clone()))?;
+
+    // Render updated list
+    let output = render_template(
+        "knowledge/relationship_table.html",
+        RelationshipTableData {
+            entities,
+            relationships,
+        },
+        state.templates,
+    )?;
+
+    Ok(output.into_response())
+}

src/server/routes/html/mod.rs

@@ -7,6 +7,7 @@ use crate::error::{HtmlError, IntoHtmlError};
 
 pub mod account;
 pub mod admin_panel;
+pub mod content;
 pub mod documentation;
 pub mod gdpr;
 pub mod index;

src/storage/types/knowledge_relationship.rs

@@ -1,7 +1,6 @@
 use crate::storage::types::file_info::deserialize_flexible_id;
 use crate::{error::AppError, storage::db::SurrealDbClient};
 use serde::{Deserialize, Serialize};
-use surrealdb::{engine::any::Any, Surreal};
 use uuid::Uuid;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -40,7 +39,7 @@ impl KnowledgeRelationship {
             },
         }
     }
-    pub async fn store_relationship(&self, db_client: &Surreal<Any>) -> Result<(), AppError> {
+    pub async fn store_relationship(&self, db_client: &SurrealDbClient) -> Result<(), AppError> {
         let query = format!(
             r#"RELATE knowledge_entity:`{}`->relates_to:`{}`->knowledge_entity:`{}`
             SET

src/storage/types/user.rs

@@ -239,6 +239,21 @@ impl User {
         Ok(items)
     }
 
+    pub async fn get_text_contents(
+        user_id: &str,
+        db: &SurrealDbClient,
+    ) -> Result<Vec<TextContent>, AppError> {
+        let items: Vec<TextContent> = db
+            .client
+            .query("SELECT * FROM type::table($table_name) WHERE user_id = $user_id ORDER BY created_at DESC")
+            .bind(("user_id", user_id.to_owned()))
+            .bind(("table_name", TextContent::table_name()))
+            .await?
+            .take(0)?;
+
+        Ok(items)
+    }
+
     pub async fn get_latest_knowledge_entities(
         user_id: &str,
         db: &SurrealDbClient,
@@ -286,6 +301,7 @@ impl User {
 
         Ok(categories)
     }
+
     pub async fn get_and_validate_knowledge_entity(
         id: &str,
         user_id: &str,
@@ -301,4 +317,20 @@ impl User {
 
         Ok(entity)
     }
+
+    pub async fn get_and_validate_text_content(
+        id: &str,
+        user_id: &str,
+        db: &SurrealDbClient,
+    ) -> Result<TextContent, AppError> {
+        let text_content: TextContent = get_item(db, &id)
+            .await?
+            .ok_or_else(|| AppError::NotFound("Content not found".into()))?;
+
+        if text_content.user_id != user_id {
+            return Err(AppError::Auth("Access denied".into()));
+        }
+
+        Ok(text_content)
+    }
 }