ref(backend) start of refactor

backend/legacy/src/api/post/utils/post.rs

@@ -0,0 +1,120 @@
+use std::{env, fs};
+use std::error::Error;
+use std::process::Command;
+use std::str;
+use std::str::FromStr;
+
+use chrono::{DateTime, Utc};
+use serde_json::{Map, Value};
+use tracing::{error, warn};
+use uuid::Uuid;
+
+use crate::constants::GLOBAL_TIME_FORMAT;
+use crate::markdown::meta::parse_meta;
+
+pub fn from_path(path: &str) -> Result<Map<String, Value>, Box<dyn Error>> {
+    let mut res = Map::new();
+
+    // field `content`
+    let md_content = fs::read_to_string(path)?;
+    res.insert("content".to_string(), Value::from(md_content.to_owned()));
+
+    // field `meta`
+    let meta = parse_meta(&md_content);
+    let meta_map: Map<String, Value> = meta
+        .clone()
+        .into_iter()
+        .map(|(k, v)| (k, Value::from(v)))
+        .collect();
+    res.insert("meta".to_string(), Value::from(meta_map));
+
+    // field `post_id`
+    let post_id = match meta.get("id") {
+        None => Uuid::new_v4(),
+        Some(id) => match Uuid::from_str(id.as_str()) {
+            Ok(id) => id,
+            Err(e) => {
+                error!("Failed to parse UUID <{}>: {}", id.as_str(), e.to_string());
+                return Err(Box::new(e));
+            }
+        },
+    };
+    res.insert("post_id".to_string(), Value::from(post_id.to_string()));
+
+    // field `title`
+    let title = match meta.get("title") {
+        None => "Title Not Found".to_string(),
+        Some(title) => title.to_owned(),
+    };
+    res.insert("title".to_string(), Value::from(title));
+
+    // field `summary`
+    let summary = match meta.get("summary") {
+        None => "".to_string(),
+        Some(summary) => summary.to_owned(),
+    };
+    res.insert("summary".to_string(), Value::from(summary));
+
+    // field `last_update`
+    let git_output = match Command::new("git")
+        .arg("--no-pager")
+        .arg("log")
+        .arg("-1")
+        .arg("--format=%cI")
+        .arg("--")
+        .current_dir(env::var("GIT_WORK_DIR")?)
+        .arg(path)
+        .output()
+    {
+        Ok(res) => res,
+        Err(e) => {
+            error!("Failed to execute `git` command: {}", e.to_string());
+            return Err(Box::new(e));
+        }
+    };
+    let last_update: DateTime<Utc> = if git_output.status.success() {
+        chrono::DateTime::parse_from_str(
+            str::from_utf8(&git_output.stdout).unwrap().trim_end(),
+            GLOBAL_TIME_FORMAT,
+        )
+        .unwrap_or_else(|_| DateTime::from(Utc::now()))
+        .to_utc()
+    } else {
+        Utc::now().to_utc()
+    };
+    res.insert(
+        "last_update".to_string(),
+        Value::from(last_update.format(GLOBAL_TIME_FORMAT).to_string()),
+    );
+
+    // field `first_update`
+    let first_update: DateTime<Utc> = match meta.get("date") {
+        None => {
+            warn!(
+                "Failed to parse first update time for post {}, using current time instead",
+                post_id.to_string()
+            );
+            Utc::now().to_utc()
+        }
+        Some(date) => DateTime::from(
+            match DateTime::parse_from_str(format!("{}T000000", date).as_str(), "%Y-%m-%d%zT%H%M%S")
+            {
+                Ok(time) => time,
+                Err(e) => {
+                    warn!(
+                        "Failed to parse first update time for post {}, using current time instead: {}",
+                        post_id.to_string(),
+                        e.to_string()
+                    );
+                    DateTime::from(Utc::now())
+                }
+            },
+        ),
+    };
+    res.insert(
+        "first_update".to_string(),
+        Value::from(first_update.format(GLOBAL_TIME_FORMAT).to_string()),
+    );
+
+    Ok(res)
+}