kyanite/src/routes/mod.rs

pub(crate) mod page_resolver;
pub(crate) mod post_resolver;
pub(crate) mod posts;

use askama::Template;
use chrono::{Utc, Datelike};
use crate::{block_types::BlockTypes, AppState};

use axum::extract::State;
use log::warn;

use crate::block_types;
use crate::entities::{prelude::*, *};
use sea_orm::*;

#[derive(Template)]
#[template(path = "page.html")]
pub(crate) struct PageTemplate {
    menu: Vec<menu_entry::Model>,
    draft: bool,
    title: String,
    description: Option<String>,
    show_title: bool,
    content_blocks: Vec<BlockTypes>,
    year: String,
    settings: settings::Model
}

#[derive(Template)]
#[template(path = "post.html")]
pub(crate) struct PostTemplate {
    menu: Vec<menu_entry::Model>,
    draft: bool,
    title: String,
    summary: Option<String>,
    publish_date: String,
    last_updated: Option<String>,
    content_blocks: Vec<BlockTypes>,
    year: String,
    settings: settings::Model
}

#[derive(Template)]
#[template(path = "notfound.html")]
pub(crate) struct NotFoundTemplate {
    menu: Vec<menu_entry::Model>,
    slug: String,
    year: String,
    settings: settings::Model
}

#[derive(Template)]
#[template(path = "page.html")]
pub(crate) struct HomeSpecialTemplate {
    menu: Vec<menu_entry::Model>,
    draft: bool,
    title: String,
    description: Option<String>,
    show_title: bool,
    content_blocks: Vec<BlockTypes>,
    year: String,
    settings: settings::Model
}

// Handle the special home page
pub(crate) async fn root(
        state: State<AppState>
        ) -> HomeSpecialTemplate {

    // Grab special home slug page content
    let page_meta: page::Model = Page::find()
        .filter(page::Column::Slug.eq("home"))
        .one(&state.db_conn)
        .await
        .expect("Failed to get home page! HALTING")
        .unwrap();

    let blocks: Vec<page_block::Model> = page_meta.find_related(PageBlock)
        .order_by_asc(page_block::Column::Order)
        .all(&state.db_conn)
        .await
        .expect("Failed to get home page blocks! HALTING");

    let content_blocks: Vec<BlockTypes> = blocks.into_iter().map(|f|
        match f.r#type.as_str() {
            "HR" => BlockTypes::HR,
            "PARAGRAPH" => BlockTypes::PARAGRAPH { text: f.content },
            "MARKDOWN" => BlockTypes::MARKDOWN { content: f.content },
            "HEADER" => {
                let deserde: block_types::Header = serde_json::from_str(&f.content.as_str()).expect("Incorrect HEADER formatting");

                BlockTypes::HEADER { text: deserde.text, size: deserde.size  }
            },
            "HTML" => BlockTypes::HTML { content: f.content },
            _ => {
                warn!("Unsupported block type! ({})", f.r#type.as_str());
                BlockTypes::UNSUPPORTED
            }
        }
    ).collect();

    let menu: Vec<menu_entry::Model> = Menu::find()
        .filter(menu::Column::Name.eq("primary"))
        .one(&state.db_conn)
        .await
        .expect("Failed to get primary menu! HALTING")
        .unwrap()
        .find_related(MenuEntry)
        .order_by_asc(menu_entry::Column::Order)
        .all(&state.db_conn)
        .await
        .expect("Failed to get primary menu items!");

    let settings: settings::Model = Settings::find()
        .filter(settings::Column::Id.eq("current"))
        .one(&state.db_conn)
        .await
        .expect("Failed to get site settings!")
        .unwrap();

    HomeSpecialTemplate {
        title: page_meta.clone().title,
        description: page_meta.clone().description,
        show_title: page_meta.clone().show_title,
        content_blocks,
        year:  Utc::now().date_naive().year().to_string(),
        draft: false,
        menu,
        settings
    }
}