renderer.rs

use crate::content::{ ContentDatabase, Permission };
use crate::errors::{ Error, Result };
use axum_messages::{ Level, Messages };
use std::path::{ Path };

#[derive(Debug)]
pub struct Renderer {
  environment: minijinja::Environment<'static>,
  site_context: minijinja::Value,
}

impl Renderer {
  pub fn new(site_title: &str, theme_path: &Path) -> Result<Renderer> {
    let site_context = minijinja::context! {
      title => site_title.to_string(),
      version => env!("CARGO_PKG_VERSION").to_string(),
    };

    let mut environment = minijinja::Environment::new();
    let templates_path = theme_path.join("templates");
    environment.set_loader(minijinja::path_loader(&templates_path));

    let renderer = Renderer {
      environment,
      site_context,
    };

    Ok(renderer)
  }

  pub fn render_administration(&self, database: &ContentDatabase, messages: Messages) -> Result<String> {
    let context = self.administration_context(database, messages)?;
    let template = self.environment.get_template("administration.html")?;
    let rendered = template.render(context)?;
    Ok(rendered)
  }

  pub fn render_authentication(&self, messages: Messages) -> Result<String> {
    let context = self.default_context(messages);
    let template = self.environment.get_template("authentication.html")?;
    let rendered = template.render(context)?;
    Ok(rendered)
  }

  pub fn render_new_page(&self, messages: Messages) -> Result<String> {
    let context = self.default_context(messages);
    let template = self.environment.get_template("new_page.html")?;
    let rendered = template.render(context)?;
    Ok(rendered)
  }

  pub fn render_view_page(&self, database: &ContentDatabase, messages: Messages, permissions: &Option<Vec<Permission>>, slug: &str) -> Result<String> {
    let context = self.view_page_context(database, messages, permissions, slug)?;
    let template = self.environment.get_template("view_page.html")?;
    let rendered = template.render(context)?;
    Ok(rendered)
  }

  pub fn render_edit_page(&self, database: &ContentDatabase, messages: Messages, permissions: &Option<Vec<Permission>>, slug: &str) -> Result<String> {
    let context = self.edit_page_context(database, messages, permissions, slug)?;
    let template = self.environment.get_template("edit_page.html")?;
    let rendered = template.render(context)?;
    Ok(rendered)
  }

  pub fn render_all_tags(&self, database: &ContentDatabase, messages: Messages) -> Result<String> {
    let tags = database
      .find_all_tags()
      .into_iter()
      .collect::<Vec<_>>();

    let context = self.tags_context(database, messages, &tags)?;
    let template = self.environment.get_template("tags.html")?;
    let rendered = template.render(context)?;
    Ok(rendered)
  }

  pub fn render_in_tags(&self, database: &ContentDatabase, messages: Messages, tags: &[String]) -> Result<String> {
    let context = self.tags_context(database, messages, tags)?;
    let template = self.environment.get_template("tags.html")?;
    let rendered = template.render(context)?;
    Ok(rendered)
  }

  pub fn render_new_user(&self, messages: Messages) -> Result<String> {
    let context = self.default_context(messages);
    let template = self.environment.get_template("new_user.html")?;
    let rendered = template.render(context)?;
    Ok(rendered)
  }

  fn default_context(&self, messages: Messages) -> minijinja::Value {
    minijinja::context! {
      site => self.site_context,
      messages => self.messages_context(messages),
    }
  }

  fn administration_context(&self, database: &ContentDatabase, messages: Messages) -> Result<minijinja::Value> {
    let users: Vec<_> = database.iter_users()
      .map(|u| minijinja::context! {
        name => u.username(),
        permissions => u.permissions(),
      })
      .collect();

    let administration_context = minijinja::context! {
      users,
    };

    let context = minijinja::context! {
      site => self.site_context,
      messages => self.messages_context(messages),
      administration => administration_context,
    };

    Ok(context)
  }

  fn view_page_context(&self, database: &ContentDatabase, messages: Messages, permissions: &Option<Vec<Permission>>, slug: &str) -> Result<minijinja::Value> {
    let Some(page) = database.find_page(slug) else {
      return Err(Error::PageNotFound(slug.to_string()));
    };

    let (is_administrator, is_authenticated) = if let Some(permissions) = permissions {
      let is_administrator = permissions
        .iter()
        .any(|x| *x == Permission::Configure);

      (is_administrator, true)
    } else {
      (false, false)
    };

    let page_context = minijinja::context! {
      is_administrator,
      is_authenticated,
      slug => slug.to_string(),
      title => page.title().to_string(),
      content => database.load_page_content_html(slug)?,
      tags => page.tags().to_vec(),
    };

    let context = minijinja::context! {
      site => self.site_context,
      messages => self.messages_context(messages),
      page => page_context,
    };

    Ok(context)
  }

  fn edit_page_context(&self, database: &ContentDatabase, messages: Messages, permissions: &Option<Vec<Permission>>, slug: &str) -> Result<minijinja::Value> {
    let Some(page) = database.find_page(slug) else {
      return Err(Error::PageNotFound(slug.to_string()));
    };

    let (is_administrator, is_authenticated) = if let Some(permissions) = permissions {
      let is_administrator = permissions
        .iter()
        .any(|x| *x == Permission::Configure);

      (is_administrator, true)
    } else {
      (false, false)
    };

    let page_context = minijinja::context! {
      is_administrator,
      is_authenticated,
      slug => slug.to_string(),
      title => page.title().to_string(),
      content => database.load_page_content_markdown(slug)?,
      tags => page.tags().to_vec(),
    };

    let context = minijinja::context! {
      site => self.site_context,
      messages => self.messages_context(messages),
      page => page_context,
    };

    Ok(context)
  }

  fn tags_context(&self, database: &ContentDatabase, messages: Messages, tags: &[String]) -> Result<minijinja::Value> {
    let links: Vec<_> = database
      .iter_pages_tagged(tags)
      .map(|page| minijinja::context! {
        slug => page.slug().to_string(),
        title => page.title().to_string(),
      })
      .collect();

    let tags_context = minijinja::context! {
      tags => tags.to_vec(),
      links,
    };

    let context = minijinja::context! {
      site => self.site_context,
      messages => self.messages_context(messages),
      tags => tags_context,
    };

    Ok(context)
  }

  fn messages_context(&self, messages: Messages) -> Vec<minijinja::Value> {
    messages
      .into_iter()
      .map(|m| minijinja::context! {
        level => match m.level {
          Level::Error => String::from("error"),
          Level::Warning => String::from("warning"),
          _ => String::from("message"),
        },
        content => m.message.clone(),
      })
      .collect()
  }
}