Updated server to include notes api.

.github/workflows/deploy.yml

@@ -85,4 +85,4 @@ jobs:
           username: ${{ secrets.REMOTE_USER }}
           key: ${{ secrets.SSH_PRIVATE_KEY }}
           port: 22
-          script: "sudo systemctl daemon-reload && sudo systemctl restart personal_portfolio_client.service"
+          script: "sudo systemctl daemon-reload && sudo systemctl restart personal_portfolio_server.service"

server/src/api/health.rs

@@ -1,22 +1,24 @@
 use crate::utils::{ markdown_util, local_image_util };
 use rocket::{http::Status};
+use std::io::Error;
 use std::env;
+
+
 use std::collections::HashMap;
 
 #[get("/health")]
 pub fn check_health() -> &'static str {
     "Hello, world!"
 }
 
-
 #[get("/check_env_variable")]
 pub fn check_env_variable() -> Result<String, Status> {
     let mut result = String::new();
-
-    let mut checks: HashMap<&str, fn() -> Result<String, std::io::Error>> = HashMap::new();
+    let mut checks: HashMap<&str, fn() -> Result<String, Error>> = HashMap::new();
 
     checks.insert("markdown", markdown_util::markdown_store_location);
     checks.insert("image", local_image_util::image_store_location);
+    checks.insert("note", markdown_util::notes_store_location);
 
     for (check_name, check_method) in &checks {
         match check_method() {

server/src/api/mod.rs

@@ -1,7 +1,7 @@
-pub mod blogs;
 pub mod health;
 pub mod posts;
 pub mod user;
 pub mod local_image;
+pub mod note;
 pub mod message;
 pub mod proxy;

server/src/api/note.rs

@@ -0,0 +1,48 @@
+use rocket::{http::Status, State, serde::json::Json};
+use crate::{models::note_model::Note, repository::note_repo::NoteRepo, utils::markdown_util};
+use mongodb::{results::{ UpdateResult, InsertOneResult, DeleteResult }, bson::{doc, to_bson, oid::ObjectId }};
+use std::str::FromStr;
+
+#[post("/note", data = "<new_note>")]
+pub async fn index_note(repo: &State<NoteRepo>, new_note: Json<Note>) -> Result<Json<InsertOneResult>, Status> {
+    let mut data = new_note.into_inner();
+    data.date_created = Some(chrono::offset::Utc::now());
+    repo.0.create(data).map(Json).map_err(|_| Status::BadRequest)
+}
+
+
+#[get("/note/<id>")]
+pub async fn get_note(repo: &State<NoteRepo>, id: String, redis: &State<redis::Client>) -> Result<Json<Note>, Status> {
+    ObjectId::from_str(&id)
+        .map_err(|_| Status::BadRequest)
+        .and_then(|object_id| repo.0.get(object_id).map_err(|_| Status::InternalServerError))
+        .and_then(|blog_post| match blog_post.active {
+            Some(false) => Err(Status::NotFound),
+            _ => Ok(blog_post),
+        })
+        .and_then(|note| {
+            markdown_util::get_content(note)
+                .map_err(|_| Status::NotFound)
+                .and_then(|blog_post_content| {
+                    Ok(blog_post_content)
+                })
+        })
+        .map(Json)
+}
+
+#[get("/note")]
+pub fn get_all_note(repo: &State<NoteRepo>) -> Result<Json<Vec<Note>>, Status> {
+    let notes = match repo.0.get_all() {
+        Ok(posts) => posts.into_iter().filter(|post| {
+            match post.active {
+                Some(false) => false,
+                _ => true
+            }
+        }).collect(),
+        Err(_) => {
+            return Err(Status::InternalServerError);
+        },
+    };
+
+    Ok(Json(notes))
+}

server/src/controller/post_controller.rs

@@ -34,7 +34,6 @@ impl PostController  {
 
 pub fn get(&self, id: String, redis_con: &mut redis::Connection) -> Result<Json<Post>, Status> {
 
-        // check if cached file exists
         let value: Option<String> = redis_con.get(&id).unwrap_or(None);
         if let Some(res) = value {
             let post: Post = serde_json::from_str(&res).unwrap();
@@ -49,7 +48,7 @@ pub fn get(&self, id: String, redis_con: &mut redis::Connection) -> Result<Json<
                 _ => Ok(blog_post),
             })
             .and_then(|blog_post| {
-                markdown_util::get_post_content_for_post(blog_post)
+                markdown_util::get_content(blog_post)
                     .map_err(|_| Status::NotFound)
                     .and_then(|blog_post_content| {
                         let _: () = Self::cache_data(redis_con, &id, blog_post_content.clone())?;

server/src/main.rs

@@ -11,12 +11,12 @@ mod errors;
 mod repository;
 mod database;
 
-use repository::blog_repo::BlogRepo;
 use repository::post_repo::PostRepo;
 use repository::user_repo::UserRepo;
 use repository::mongo_repo::MongoRepo;
 use repository::local_image_repo::LocalImageRepo;
 use repository::message_repo::MessageRepo;
+use repository::note_repo::NoteRepo;
 use config::cors::CORS;
 
 use controller::{ post_controller::PostController, local_image_controller::LocalImageController };
@@ -27,6 +27,7 @@ use models::post_model::Post;
 use models::user_model::User;
 use models::local_image_model::LocalImage;
 use models::message_model::Message;
+use models::note_model::Note;
 
 #[get("/")]
 fn index() -> &'static str {
@@ -41,11 +42,11 @@ async fn rocket() -> _ {
     let redis = redis::Client::open("redis://127.0.0.1/").unwrap();
 
     // Initialize database repositories.
-    let blog_repo = BlogRepo::init();
     let post_repo = PostRepo(MongoRepo::<Post>::init("Post", &*DB).await);
     let user_repo = UserRepo(MongoRepo::<User>::init("User", &*DB).await);
     let local_image_repo = LocalImageRepo(MongoRepo::<LocalImage>::init("LocalImage", &*DB).await);
     let message_repo = MessageRepo(MongoRepo::<Message>::init("Message", &*DB).await);
+    let note_repo = NoteRepo(MongoRepo::<Note>::init("Note", &*DB).await);
 
     let post_controller = PostController::new(post_repo);
     let local_image_controller = LocalImageController::new(local_image_repo);
@@ -54,16 +55,13 @@ async fn rocket() -> _ {
     rocket::build()
         .manage(redis)
 
-        .manage(blog_repo)
         .manage(user_repo)
         .manage(message_repo)
         .manage(post_controller)
         .manage(local_image_controller)
+        .manage(note_repo)
 
         .mount("/api/", routes![index])
-        .mount("/api/", routes![api::blogs::get_all_blog_post])
-        .mount("/api/", routes![api::blogs::create_blog])
-        .mount("/api/", routes![api::blogs::get_blog])
 
         .mount("/api/", routes![api::proxy::proxy])
         .mount("/api/", routes![api::proxy::proxy_post])
@@ -91,5 +89,9 @@ async fn rocket() -> _ {
 
         .mount("/api/", routes![api::message::insert_message])
 
+        .mount("/api/", routes![api::note::index_note])
+        .mount("/api/", routes![api::note::get_note])
+        .mount("/api/", routes![api::note::get_all_note])
+
         .attach(CORS)
 }

server/src/models/mod.rs

@@ -1,8 +1,8 @@
 pub mod mongo_model;
-pub mod blog_model;
 pub mod post_model;
 pub mod user_model;
 pub mod user_session_token_model;
 pub mod local_image_model;
+pub mod note_model;
 pub mod utils;
 pub mod message_model;

server/src/models/note_model.rs

@@ -0,0 +1,24 @@
+use mongodb::bson::oid::ObjectId;
+use rocket::serde::{Serialize, Deserialize};
+use chrono::{Utc, DateTime};
+use crate::models::utils::date_format::date_format;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Note {
+    #[serde(rename = "_id", skip_serializing_if = "Option::is_none")]
+    pub id: Option<ObjectId>,
+    pub heading: String,
+    pub author: String,
+    pub description: Option<String>,
+    #[serde(with = "date_format", default)]
+    pub date_created: Option<DateTime<Utc>>,
+    #[serde(with = "date_format", default)]
+    pub date_last_modified: Option<DateTime<Utc>>,
+    pub file_path: String,
+    pub tags: Option<Vec<String>>,
+    pub reading_time_minutes: Option<i32>,
+    pub active: Option<bool>,
+    pub image: Option<ObjectId>,
+    pub checksum: Option<String>,
+    pub body: String,
+}