CheezeNotes/src/page.rs

use actix_web::body::BoxBody;
use actix_web::http::header::ContentType;
use actix_web::web::Query;
use actix_web::{get, put, Responder, HttpRequest};
use actix_web::{web, HttpResponse};
use serde::{Deserialize, Serialize};

use askama_actix::Template;
use askama_actix::TemplateToResponse;

use crate::commons::AppData;
use crate::db;

#[derive(Template)]
#[template(path = "page.html")]
pub struct PageTemplate {
    pub app_name: String,
    pub base_url: String,
    pub md: String,
    pub init: String,
}

#[derive(Debug, Deserialize)]
#[allow(non_snake_case)]
struct QueryParams {
    pub data: Option<String>,
    pub fromDomain: Option<String>,
    pub fromPage: Option<String>,
}

#[derive(Serialize, Deserialize)]
pub struct Page {
    pub domain: String,
    pub page: String,
    pub page_text: String,
    pub parent_domain: String,
    pub parent_page: String,
}
impl Responder for Page {
    type Body = BoxBody;

    fn respond_to(self, _req: &HttpRequest) -> HttpResponse<Self::Body> {
        let res_body = serde_json::to_string(&self).unwrap();

        // Create HttpResponse and set Content Type
        HttpResponse::Ok()
           .content_type(ContentType::json())
           .body(res_body)
    }
}

fn new_page_text(
    page_name: String,
    domain_from: &Option<String>,
    page_from: &Option<String>,
) -> String {
    let mut retour = String::from("");
    if let (Some(domain_f), Some(page_f)) = (domain_from, page_from) {
        retour = format!("[retour](/{}/{})\n", domain_f, page_f);
    }
    retour + "# " + page_name.replace("_", " ").as_str()
}

async fn get_data(
    data: &web::Data<AppData>,
    domain: String,
    page_name: String,
    params: &Query<QueryParams>,
) -> String {
    let fut_page_datas =
        db::get_page_by_name(&data.db_pool, domain.to_owned(), page_name.to_owned());
    let page_datas = fut_page_datas.await.unwrap();
    match page_datas.first() {
        None => new_page_text(page_name, &params.fromDomain, &params.fromPage),
        Some(dat) => (*dat.page_text).to_string(),
    }
}

#[get("/{domain}/{page}")]
async fn page(
    path: web::Path<(String, String)>,
    data: web::Data<AppData>,
    params: web::Query<QueryParams>,
) -> impl Responder {
    let domain = &path.0;
    let page_name = &path.1;

    let md = get_data(&data, domain.to_owned(), page_name.to_owned(), &params).await;

    match &params.data {
        Some(_) => {
            return HttpResponse::Ok()
                .content_type(ContentType::plaintext())
                .body(md)
        }
        None => {}
    }

    let app_name = data.app_name.to_owned() + " - " + page_name.as_str();
    let base_url = data.base_url.to_owned();
    //let init = String::from("init();");
    let init = format!("init({:?}, {:?});", domain, page_name);
    PageTemplate {
        app_name,
        base_url,
        md,
        init,
    }
    .to_response()
}

#[put("/{domain}/{page}")]
async fn save_page(
    body: String,
    path: web::Path<(String, String)>,
    data: web::Data<AppData>,
) -> impl Responder {
    let domain = &path.0;
    let pagename = &path.1;
    /*if pagename == "index" {
        return HttpResponse::Ok();
    }*/
    db::update_page(&data.db_pool, domain.to_owned(), pagename.to_owned(), body.to_owned(), None, None)
        .await
        .unwrap();
    HttpResponse::Ok()
}