Rework flash system

src/routes.rs

     let posts: Vec<Post> = fs::get_all_posts().await?;
     let mut context = Context::new();
     context.insert("posts", &posts);
-    render_response("index.html", &context, &req)
+    render_response("index.html", &context, req)
 }
 
 pub async fn single_post(req: Request<State>) -> Result {
     let post_id = req.param("id")?;
     let post = fs::get_one_post(post_id).await?;
     context.insert("post", &post);
-    render_response("single.html", &context, &req)
+    render_response("single.html", &context, req)
 }
 
 pub async fn edit_post(req: Request<State>) -> Result {
     let mut post = fs::get_one_post(post_id).await?;
     post.body = post.body.replace("<br>", "\n");
     context.insert("post", &post);
-    render_response("edit.html", &context, &req)
+    render_response("edit.html", &context, req)
 }
 
 pub async fn create_post(mut req: Request<State>) -> Result {
 pub async fn update_post(mut req: Request<State>) -> Result {
     let mut post: Post = req.body_form().await?;
     post.save().await?;
-    Ok(Redirect::new(format!("/posts/{}", post.id)).into())
+    req.session_mut().insert("flash_success", String::from("Post updated successfully"))?;
+    redirect(&format!("/posts/{}", post.id))
 }
 
-pub async fn delete_post(req: Request<State>) -> Result {
+pub async fn delete_post(mut req: Request<State>) -> Result {
     let id: String = req.param("id")?;
     fs::delete_post(id)?;
+    req.session_mut().insert("flash_success", String::from("Post deleted successfully"))?;
     let mut res = Response::new(StatusCode::Ok);
     res.set_body("{\"success\": \"true\"}");
     res.set_content_type(mime::JSON);
     Ok(res)
 }
 
-pub async fn login_page(mut req: Request<State>) -> Result {
-    let mut context = Context::new();
-    match req.session_mut().get::<String>("flash_error") {
-        Some(error) => {
-            req.session_mut().remove("flash_error");
-            &context.insert("error", &error);
-        }
-        None => {}
-    }
-    render_response("login.html", &context, &req)
+pub async fn login_page(req: Request<State>) -> Result {
+    render_response("login.html", &Context::new(), req)
 }
 
 pub async fn login(mut req: Request<State>) -> Result {
     if user.username == username && user.password == password {
         req.session_mut().remove("logged_in");
         req.session_mut().insert("logged_in", true)?;
-        Ok(Redirect::new("/").into())
+        redirect("/")
     } else {
         req.session_mut().remove("logged_in");
         req.session_mut()
             .insert("flash_error", "Invalid credentials")?;
-        Ok(Redirect::new(&req.state().login_path).into())
+        let login_path = req.state().login_path.clone();
+        redirect(&login_path)
     }
 }
 
 pub fn render_response(
     template: &str,
     context: &Context,
-    req: &Request<State>,
+    req: Request<State>,
 ) -> Result<Response> {
     let mut context = context.clone();
     let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
-    context.insert("logged_in", &logged_in);
     let login_path = &req.state().login_path;
+    context.insert("logged_in", &logged_in);
     context.insert("login_path", login_path);
+    context.extend(prepare_flash_messages(req));
+
     let html = render_template(template, &context)?;
+
     let mut res = Response::new(StatusCode::Ok);
     res.set_body(html);
     res.set_content_type(mime::HTML);
+
     Ok(res)
 }
 
     let html = tera.render(template, &context)?;
     Ok(html)
 }
+
+fn redirect(path: &str) -> Result<Response> {
+    Ok(Redirect::new(path).into())
+}
+
+fn prepare_flash_messages(mut req: Request<State>) -> Context {
+    let mut context = Context::new();
+    context.insert("flash_error", &false);
+    context.insert("flash_success", &false);
+
+    for key in vec!["flash_error", "flash_success"] {
+        match req.session_mut().get::<String>(key) {
+            Some(value) => {
+                req.session_mut().remove(key);
+                &context.insert(key, &value);
+            }
+            None => {}
+        }
+    }
+
+    context
+}

templates/layout.html

         padding: 0.5em;
       }
 
-      .error {
-        color: #942626;
+      .message {
+        border: 1px solid #383e37;
+        color: #fff;
+        margin: .5em 0;
+        padding: .25em 1.5em;
         text-align: center;
+        width: 100%;
+      }
+
+      .message--error {
+        background-color: #942626;
+      }
+
+      .message--success {
+        background-color: #289426;
       }
 
       .error__heading {
         </form>
         {% endif %}
       </header>
+      <div class="messages">
+        {% if flash_error %}
+          <p class="message message--error">{{ flash_error }}</p>
+        {% endif %}
+
+        {% if flash_success %}
+          <p class="message message--success">{{ flash_success }}</p>
+        {% endif %}
+      </div>
       {% block content %} {% endblock %}
     </div>
     <script>

templates/login.html

     <label for="password" class="form__label">Password</label>
     <input class="form__text-field" type="password" name="password" required />
   </div>
-  {% if error %}
-  <div class="error">
-    <p class="error__message">{{ error }}</p>
-  </div>
-  {% endif %}
   <div class="form__field">
-    <input class="form__button" type="submit" value="Login" />
+    <input class="btn" type="submit" value="Login" />
   </div>
 </form>
 {% endblock %}