nocturne/backend/api_server/src/blog/cron/check_update/index.rs

use std::error::Error;
use std::path::Path;

use crate::blog::cron::check_update::utils::get_md_file_basename;
use crate::blog::cron::check_update::{error::PostIdxError, utils::parse_date};
use markdown::MdFile;

use sqlx::{query, PgPool, Pool, Postgres, Row};
use tokio::runtime::Runtime;
use tracing::{info, warn};

async fn base(db_connection: &PgPool, post: &MdFile) -> Result<(), PostIdxError> {
    let post_id = post.file_id;
    let title = match post.meta.get("title") {
        None => {
            return Err(PostIdxError::MissingField {
                field: "title".to_string(),
                filename: post.filename.clone(),
            })
        }
        Some(title) => title.as_str().unwrap_or_else(|| {
            warn!("invalid title for `{}`", &post.filename);
            "invalid title"
        }),
    };
    let sub_title = post
        .meta
        .get("sub_title")
        .and_then(|v| v.as_str())
        .unwrap_or("");
    let summary = post
        .meta
        .get("summary")
        .and_then(|v| v.as_str())
        .unwrap_or("");
    let content = post.content.as_str();
    let category = match post.meta.get("category") {
        None => {
            return Err(PostIdxError::MissingField {
                field: "category".to_string(),
                filename: post.filename.clone(),
            })
        }
        Some(title) => title.as_str().unwrap_or_else(|| {
            warn!("invalid category for `{}`", &post.filename);
            "invalid category"
        }),
    };
    let last_update = {
        if let Some(last_update) = post.meta.get("last_update") {
            match parse_date(last_update.as_str().unwrap()) {
                Ok(date) => Some(date),
                Err(e) => {
                    return Err(PostIdxError::InvalidField {
                        field_name: "last_update".to_string(),
                        err_field: last_update.to_string(),
                        filename: post.filename.clone(),
                        msg: e.to_string(),
                    })
                }
            }
        } else {
            None
        }
    };
    let first_update = match post.meta.get("date") {
        None => {
            return Err(PostIdxError::MissingField {
                field: "date".to_string(),
                filename: post.filename.clone(),
            })
        }
        Some(first_update) => match parse_date(first_update.as_str().unwrap()) {
            Ok(date) => date,
            Err(e) => {
                return Err(PostIdxError::InvalidField {
                    field_name: "date".to_string(),
                    err_field: first_update.to_string(),
                    filename: post.filename.clone(),
                    msg: e.to_string(),
                })
            }
        },
    };
    let filename = get_md_file_basename(&post.filename);

    if let Err(e) = query(
        r##"
INSERT INTO Post (post_id, title, summary, content, last_update, first_update, sub_title, category, filename)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
ON CONFLICT (post_id) DO
UPDATE SET
    title = EXCLUDED.title,
    summary = EXCLUDED.summary,
    content = EXCLUDED.content,
    last_update = EXCLUDED.last_update,
    first_update = EXCLUDED.first_update,
    sub_title = EXCLUDED.sub_title,
    category = EXCLUDED.category,
    filename = EXCLUDED.filename;
        "##,
    )
        .bind(post_id)
        .bind(title)
        .bind(summary)
        .bind(content)
        .bind(last_update)
        .bind(first_update)
        .bind(sub_title)
        .bind(category)
        .bind(filename)
        .execute(db_connection)
        .await
    {
        return Err(
            PostIdxError::DBWriteFailure {
                data_desc: "post base information".to_string(),
                db_table: "Post".to_string(),
                id: post_id.to_string(),
                msg: e.to_string(),
            }
        );
    }
    Ok(())
}

async fn tag(db_connection: &PgPool, post: &MdFile) -> Result<(), PostIdxError> {
    if let Some(tags_string) = post.meta.get("tags").to_owned() {
        let tags = match tags_string.as_array().map(|vec| {
            vec.iter()
                .map(|val| val.as_str().unwrap())
                .collect::<Vec<_>>()
        }) {
            None => {
                return Err(PostIdxError::MissingField {
                    field: "tags".to_string(),
                    filename: post.filename.clone(),
                })
            }
            Some(val) => val,
        };

        let post_id = post.file_id;

        // remove old record
        if let Err(e) = query("DELETE FROM Tag WHERE post_id = $1")
            .bind(post_id)
            .execute(db_connection)
            .await
        {
            return Err(PostIdxError::DBWriteFailure {
                data_desc: "post tag information".to_string(),
                db_table: "Tag".to_string(),
                id: post_id.to_string(),
                msg: e.to_string(),
            });
        }

        // add new record
        for tag in tags {
            match query("INSERT INTO Tag VALUES ($1, $2);")
                .bind(post_id)
                .bind(tag)
                .execute(db_connection)
                .await
            {
                Ok(_) => {}
                Err(e) => {
                    return Err(PostIdxError::DBWriteFailure {
                        data_desc: "post tag information".to_string(),
                        db_table: "Tag".to_string(),
                        id: post_id.to_string(),
                        msg: e.to_string(),
                    })
                }
            }
        }
    }

    Ok(())
}

async fn hash(db_connection: &PgPool, post: &MdFile) -> Result<bool, PostIdxError> {
    let base64_form = post.hash.clone();
    match query("SELECT hash FROM Hash WHERE post_id = $1")
        .bind(post.file_id)
        .fetch_optional(db_connection)
        .await
    {
        Ok(row) => {
            let db_record: String = match row {
                None => "".to_string(),
                Some(row) => row.try_get("hash").unwrap_or("".to_string()),
            };
            if base64_form == db_record {
                Ok(false)
            } else {
                if let Err(e) = query(
                    r#"
INSERT INTO Hash (post_id, hash) VALUES ($1, $2)
    ON CONFLICT (post_id) DO UPDATE SET hash = EXCLUDED.hash"#,
                )
                .bind(post.file_id)
                .bind(&base64_form)
                .execute(db_connection)
                .await
                {
                    return Err(PostIdxError::DBWriteFailure {
                        data_desc: "post hash".to_string(),
                        db_table: "Hash".to_string(),
                        id: post.file_id.to_string(),
                        msg: e.to_string(),
                    });
                }
                Ok(true)
            }
        }
        Err(e) => Err(PostIdxError::DBReadFailure {
            data_desc: "post hash".to_string(),
            db_table: "Hash".to_string(),
            id: post.file_id.to_string(),
            msg: e.to_string(),
        }),
    }
}

async fn meta(db_connection: &PgPool, post: &MdFile) -> Result<(), PostIdxError> {
    if let Err(e) = query(
        // todo: sanitization
        format!(
            r#"
DO
$$
    DECLARE
        _post_id        UUID  := '{}';
        _meta_cols      JSONB := '{}';
        _exists         BOOLEAN;
        _col_name       TEXT;
        _col_value      TEXT;
        _sql            TEXT;
        _insert_columns TEXT  := 'post_id';
        _insert_values  TEXT  := quote_literal(_post_id);
        _update_set     TEXT  := '';
        _blacklist      TEXT[] := ARRAY['tags'];
    BEGIN
        SELECT EXISTS(SELECT 1 FROM meta WHERE post_id = _post_id) INTO _exists;

        FOR _col_name, _col_value IN SELECT key, value FROM jsonb_each_text(_meta_cols)
            LOOP
                IF _col_name = ANY(_blacklist) THEN
                    CONTINUE;
                END IF;

                IF NOT EXISTS (SELECT 1
                               FROM information_schema.columns
                               WHERE table_name = 'meta'
                                 AND column_name = _col_name
                                 -- may change in the future
                                 AND table_schema = 'public') THEN
                    _sql := 'ALTER TABLE meta ADD COLUMN ' || quote_ident(_col_name) || ' TEXT';
                    EXECUTE _sql;
                END IF;
                _insert_columns := _insert_columns || ', ' || quote_ident(_col_name);
                _insert_values := _insert_values || ', ' || quote_literal(_col_value);
                _update_set := _update_set || ', ' || quote_ident(_col_name) || ' = ' || quote_literal(_col_value);
            END LOOP;

        _update_set := substring(_update_set FROM 3);

        IF _exists THEN
            _sql := 'UPDATE meta SET ' || _update_set || ' WHERE post_id = ' || quote_literal(_post_id);
            EXECUTE _sql;
        ELSE
            _sql := 'INSERT INTO meta (' || _insert_columns || ') VALUES (' || _insert_values || ')';
            EXECUTE _sql;
        END IF;
    END;
$$ LANGUAGE plpgsql;
        "#, post.file_id.to_string().as_str(), post.meta
        ).as_str()
    )
        .execute(db_connection)
        .await {
        Err(PostIdxError::DBWriteFailure {
            data_desc: "post meta data".to_string(),
            db_table: "Meta".to_string(),
            id: post.file_id.to_string(),
            msg: e.to_string(),
        })
    } else {
        Ok(())
    }
}

pub async fn index_file(path: &Path, db_conn: &Pool<Postgres>) -> Result<(), Box<dyn Error>> {
    let md_file = MdFile::from_file(path)?;

    base(db_conn, &md_file).await?;
    tag(db_conn, &md_file).await?;
    meta(db_conn, &md_file).await?;
    hash(db_conn, &md_file).await?;

    info!("indexed markdown file: {}", path.display());
    Ok(())
}

pub fn drop_index(file_basename: &str, db_conn: &Pool<Postgres>) -> Result<(), Box<dyn Error>> {
    let rt = Runtime::new().unwrap();
    rt.block_on(async {
        if let Err(e) = query(
            r#"
WITH deleted_post AS (
    DELETE FROM post
    WHERE id = (SELECT id FROM post WHERE filename = $1)
    RETURNING id
)
DELETE FROM tag WHERE post_id IN (SELECT id FROM deleted_post);
DELETE FROM meta WHERE post_id IN (SELECT id FROM deleted_post);
DELETE FROM hash WHERE post_id IN (SELECT id FROM deleted_post);
    "#,
        )
        .bind(file_basename)
        .execute(db_conn)
        .await
        {
            Err(Box::from(
                format!("failed to drop index: {}", e).to_string(),
            ))
        } else {
            Ok(())
        }
    })
}