Implement post deletion

src/fs.rs

 use async_std::fs::read_to_string;
 use std::env;
 use std::ffi::OsStr;
-use std::fs::read_dir;
-use std::io::{Error, ErrorKind};
+use std::fs::{read_dir, File};
+use std::io::{Error, ErrorKind, Write};
 use std::path::PathBuf;
 
 use crate::post::Post;
 
-pub async fn get_posts_directory_path() -> Result<PathBuf, Error> {
-    match env::var("POSTS_DIR") {
-        Ok(dir) => Ok(dir.into()),
-        Err(_) => Err(Error::new(
-            ErrorKind::Other,
-            "Posts directory environment variable not set",
-        )),
-    }
-}
-
 pub async fn get_all_posts() -> Result<Vec<Post>, Error> {
     let mut posts: Vec<Post> = vec![];
 
-    for file in post_directory_contents().await? {
+    for file in post_directory_contents()? {
         let file = file?;
         if let Some("json") = file.path().extension().and_then(OsStr::to_str) {
             let contents = read_post_from_disk(&file.path()).await?;
 }
 
 pub async fn get_one_post(post_id: String) -> Result<Post, Error> {
-    let posts_dir = get_posts_directory_path().await?;
+    let posts_dir = get_posts_directory_path()?;
     let path = posts_dir.join(format!("{}.json", post_id));
     let contents = read_post_from_disk(&path).await?;
     let post = Post::from_str(&contents)?;
     Ok(post)
 }
 
+pub fn delete_post(post_id: String) -> Result<(), Error> {
+    let posts_dir = get_posts_directory_path()?;
+    let path = posts_dir.join(format!("{}.json", post_id));
+    std::fs::remove_file(path)?;
+    Ok(())
+}
+
 async fn read_post_from_disk(path: &PathBuf) -> Result<String, Error> {
     match read_to_string(&path).await {
         Ok(c) => Ok(c),
     }
 }
 
-async fn post_directory_contents() -> Result<std::fs::ReadDir, Error> {
-    let path = get_posts_directory_path().await?;
+pub fn write_post_to_disk(post: &Post) -> Result<(), Error> {
+    let mut path: PathBuf = get_posts_directory_path()?;
+    let filename = format!("{}.json", post.id);
+    path = path.join(&filename);
+    let mut file = File::create(&path)?;
+    file.write_all(serde_json::to_string(&post)?.as_bytes())?;
+    Ok(())
+}
+
+fn post_directory_contents() -> Result<std::fs::ReadDir, Error> {
+    let path = get_posts_directory_path()?;
 
     match read_dir(path) {
         Ok(f) => Ok(f),
         )),
     }
 }
+
+fn get_posts_directory_path() -> Result<PathBuf, Error> {
+    match env::var("POSTS_DIR") {
+        Ok(dir) => Ok(dir.into()),
+        Err(_) => Err(Error::new(
+            ErrorKind::Other,
+            "Posts directory environment variable not set",
+        )),
+    }
+}

src/main.rs

         .post(routes::create_post);
     app.at("/posts/:id")
         .get(routes::single_post)
-        .post(routes::update_post);
+        .post(routes::update_post)
+        .delete(routes::delete_post);
     app.at("/posts/:id/edit")
         .with(middleware::require_auth)
         .get(routes::edit_post);

src/post.rs

 use serde::{Deserialize, Serialize};
 use serde_json;
-use std::fs::File;
-use std::io::prelude::*;
 use std::io::{Error, ErrorKind};
-use std::path::PathBuf;
 
 use crate::fs;
 
 }
 
 impl Post {
-    pub async fn save(&mut self) -> std::io::Result<()> {
-        let mut path: PathBuf = fs::get_posts_directory_path().await?;
-        let filename = format!("{}.json", self.id);
-        path = path.join(&filename);
-        let mut file = File::create(&path)?;
-        file.write_all(serde_json::to_string(&self)?.as_bytes())?;
-        Ok(())
+    pub async fn save(&mut self) -> Result<(), Error> {
+        fs::write_post_to_disk(self)
     }
 
     pub fn from_str(blob: &str) -> Result<Post, Error> {

src/routes.rs

     Ok(Redirect::new(format!("/posts/{}", post.id)).into())
 }
 
+pub async fn delete_post(req: Request<()>) -> Result {
+    let id: String = req.param("id")?;
+    fs::delete_post(id)?;
+    let mut res = Response::new(tide::StatusCode::Ok);
+    res.set_body("{\"success\": \"true\"}");
+    res.set_content_type(mime::JSON);
+    Ok(res)
+}
+
 pub async fn login_page(mut req: Request<()>) -> Result {
     let mut context = Context::new();
     let logged_in: bool = req.session().get("logged_in").unwrap_or(false);

templates/components.html

       <a class="post__link" href="/posts/{{ post.id }}">view</a>
       {% endif %} {% if logged_in %}
       <a class="post__link" href="/posts/{{ post.id }}/edit">edit</a>
+      <span class="post__link danger" data-delete="{{ post.id }}">delete</span>
       {% endif %}
     </div>
     <span class="post__title">

templates/layout.html

         padding: 0.15em 0.3em;
       }
 
+      .danger {
+        color: #942626;
+      }
+
       .container {
         margin: auto;
         max-width: 800px;
       }
 
       .post__link {
+        cursor: pointer;
         font-style: normal;
         font-weight: normal;
+        text-decoration: underline;
+      }
+
+      .post__link:hover {
+        text-decoration: none;
       }
 
       .post__body {
       </header>
       {% block content %} {% endblock %}
     </div>
+    <script>
+      document.querySelectorAll('[data-delete]').forEach((el) => {
+        el.addEventListener('click', (e) => {
+          if (confirm('Are you sure? This cannot be undone.')) {
+            let postId = e.target.dataset.delete;
+            fetch(`/posts/${postId}`, {
+              method: 'DELETE',
+            }).then((r) => {
+              r.json().then((data) => {
+                if (data.success) {
+                  window.location = '/';
+                }
+              });
+            });
+          }
+        });
+      });
+    </script>
   </body>
 </html>