handlers.rs

use crate::content::{ Permission };
use crate::errors::{ Error, Result };
use crate::state::{ ServerState };
use axum::extract::{ Form, Path, State };
use axum::response::{ Html, IntoResponse, Redirect, Response };
use axum_messages::{ Messages };
use serde::{ Deserialize };
use tower_sessions::{ Session };
use std::sync::{ Arc };

#[derive(Debug, Deserialize)]
pub struct AuthenticateForm {
  username: String,
  password: String,
}

#[derive(Debug, Deserialize)]
pub struct PageForm {
  slug: String,
  title: String,
  content: String,
  tags: String,

  #[serde(default, rename = "old-slug")]
  old_slug: String,
}

const PERMISSIONS_KEY: &str = "permissions";

#[tracing::instrument]
pub async fn authenticate_api(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
  Form(form): Form<AuthenticateForm>,
) -> Result<Redirect> {
  if session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?.is_some() {
    messages.warning("You are already authenticated.");
    return Ok(Redirect::to("/"));
  };

  // Need to keep database() usage in between awaits because RwLockReadGuard is not Send
  let result = {
    let database = server_state.database();
    database.authenticate(&form.username, &form.password)
  };

  match result {
    Ok(permissions) => {
      session.insert(PERMISSIONS_KEY, permissions).await?;
      Ok(Redirect::to("/"))
    },
    Err(Error::AuthenticationFailed) => {
      messages.error("Authentication failed (check your credentials).");
      Ok(Redirect::to("/authenticate"))
    },
    Err(e) => Err(e),
  }
}

#[tracing::instrument]
pub async fn new_page_api(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
  Form(form): Form<PageForm>,
) -> Result<Redirect> {
  let session_permissions = session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?;
  server_state.check_access(&[Permission::Write], session_permissions)?;

  let tags = form.tags.trim();

  let tags = if !tags.is_empty() {
    tags
      .trim()
      .split(",")
      .map(|tag| tag.trim())
      .map(|tag| tag.to_string())
      .collect::<Vec<_>>()
  } else {
    Vec::new()
  };

  server_state.database_mut()
    .save_page_content(&form.slug, &form.content)?
    .create_page_metadata(&form.slug, &form.title, &tags)?;

  let destination = format!("/page/view/{}", form.slug);
  let response = Redirect::to(&destination);
  Ok(response)
}

#[tracing::instrument]
pub async fn edit_page_api(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
  Path(slug): Path<String>,
  Form(form): Form<PageForm>,
) -> Result<Redirect> {
  let session_permissions = session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?;
  server_state.check_access(&[Permission::Write], session_permissions)?;

  let tags = form.tags.trim();

  let tags = if !tags.is_empty() {
    tags
      .split(",")
      .map(|tag| tag.trim())
      .map(|tag| tag.to_string())
      .collect::<Vec<_>>()
  } else {
    Vec::new()
  };

  server_state.database_mut()
    .save_page_content(&form.slug, &form.content)?
    .update_page_metadata(&form.old_slug, &form.slug, &form.title, &tags)?;

  let destination = format!("/page/view/{}", form.slug);
  let response = Redirect::to(&destination);
  Ok(response)
}

#[tracing::instrument]
pub async fn index(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
) -> Result<Html<String>> {
  let session_permissions = session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?;
  server_state.check_access(&[Permission::Read], session_permissions)?;

  let database = server_state.database();
  let response = server_state
    .renderer()
    .render_view_page(&database, messages, "_index")?;

  Ok(Html(response))
}

#[tracing::instrument]
pub async fn authenticate(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
) -> Result<Response> {
  if session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?.is_some() {
    messages.warning("You are already authenticated.");
    return Ok(Redirect::to("/").into_response());
  };

  let response = server_state
    .renderer()
    .render_authenticate(messages)?;

  Ok(Html(response).into_response())
}

#[tracing::instrument]
pub async fn new_page(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
) -> Result<Html<String>> {
  let session_permissions = session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?;
  server_state.check_access(&[Permission::Write], session_permissions)?;

  let response = server_state
    .renderer()
    .render_new_page(messages)?;

  Ok(Html(response))
}

#[tracing::instrument]
pub async fn edit_page(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
  Path(slug): Path<String>,
) -> Result<Html<String>> {
  let session_permissions = session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?;
  server_state.check_access(&[Permission::Read, Permission::Write], session_permissions)?;

  let database = server_state.database();
  let response = server_state
    .renderer()
    .render_edit_page(&database, messages, &slug)?;

  Ok(Html(response))
}

#[tracing::instrument]
pub async fn view_page(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
  Path(slug): Path<String>,
) -> Result<Html<String>> {
  let session_permissions = session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?;
  server_state.check_access(&[Permission::Read], session_permissions)?;

  let database = server_state.database();
  let response = server_state
    .renderer()
    .render_view_page(&database, messages, &slug)?;

  Ok(Html(response))
}

#[tracing::instrument]
pub async fn all_tags(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
) -> Result<Html<String>> {
  let session_permissions = session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?;
  server_state.check_access(&[Permission::Read], session_permissions)?;

  let database = server_state.database();
  let response = server_state
    .renderer()
    .render_all_tags(&database, messages)?;

  Ok(Html(response))
}

#[tracing::instrument]
pub async fn in_tags(
  messages: Messages,
  session: Session,
  State(server_state): State<Arc<ServerState>>,
  Path(tag): Path<String>,
) -> Result<Html<String>> {
  let session_permissions = session.get::<Vec<Permission>>(PERMISSIONS_KEY).await?;
  server_state.check_access(&[Permission::Read], session_permissions)?;

  let database = server_state.database();
  let response = server_state
    .renderer()
    .render_in_tags(&database, messages, &[tag])?;

  Ok(Html(response))
}