kryptori / src / main.rs

use axum::{routing::get, response::Html, Form, response::Redirect, Router, extract::{Query, State}, http::StatusCode};
use sqlx::sqlite::SqlitePoolOptions;
use sqlx::SqlitePool;
use std::sync::Arc;
use std::fs;
use uuid::Uuid;
use std::env;
use lettre::{Message, SmtpTransport, Transport, transport::smtp::authentication::Credentials};
use serde::Deserialize;
use askama::Template;

#[derive(Clone)]
struct AppState {
    db: SqlitePool,
}

pub async fn create_tables_if_not_exist(pool: &SqlitePool) -> Result<(), sqlx::Error> {
    let create_advertisement_table_sql = r#"
        CREATE TABLE IF NOT EXISTS Advertisement (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
            updated_at TEXT,
            title TEXT NOT NULL,
            description TEXT NOT NULL,
            owner_email TEXT NOT NULL,
            active INT NOT NULL DEFAULT 0,
            owner_token TEXT NOT NULL UNIQUE
        );
    "#;

    sqlx::query(create_advertisement_table_sql)
        .execute(pool)
        .await?;

    Ok(())
}

#[derive(Deserialize)]
struct CreateAdForm {
    title: String,
    description: String,
    owner_email: String,
}

async fn create_ad(
    State(state): State<Arc<AppState>>,
    Form(input): Form<CreateAdForm>,
) -> Result<Redirect, (axum::http::StatusCode, String)> {
    let title = input.title.trim().chars().take(1000).collect::<String>();
    let description = input.description.trim().chars().take(1000).collect::<String>();
    let owner_email = input.owner_email.trim().chars().take(1000).collect::<String>();

    if title.is_empty() || description.is_empty() || owner_email.is_empty() {
        return Err((axum::http::StatusCode::BAD_REQUEST, "Play nice!".into()));
    }

    let token = Uuid::new_v4().to_string();

    let insert_result = sqlx::query!(
        r#"
        INSERT INTO Advertisement (title, description, owner_email, owner_token)
        VALUES (?, ?, ?, ?)
        "#,
        title,
        description,
        owner_email,
        token,
    )
    .execute(&state.db)
    .await;

    if let Err(e) = insert_result {
        eprintln!("DB insert error: {e}");
        return Err((axum::http::StatusCode::INTERNAL_SERVER_ERROR, "Could not insert ad.".into()));
    }

    if let Err(e) = send_email(&owner_email, &title, &description, &token).await {
        eprintln!("Email error: {e}");
    }

    Ok(Redirect::to("/"))
}

#[derive(Deserialize)]
struct SendMessageForm {
    ad_id: i64,
    user_email: String,
    message: String,
}

#[derive(sqlx::FromRow)]
struct Advertisement {
    title: String,
    description: String,
    owner_email: String,
}

async fn send_message(
    State(state): State<Arc<AppState>>,
    Form(form): Form<SendMessageForm>,
) -> Result<Redirect, StatusCode> {
    let ad = sqlx::query_as!(
        Advertisement,
        r#"
        SELECT title, description, owner_email
        FROM Advertisement
        WHERE id = ?
        "#,
        form.ad_id
    )
    .fetch_optional(&state.db)
    .await
    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    let Some(ad) = ad else {
        return Err(StatusCode::NOT_FOUND);
    };

    if let Err(e) = send_interested_email(
        &ad.owner_email,
        &ad.title,
        &ad.description,
        &form.message,
        &form.user_email
    ).await {
        eprintln!("Email error: {e}");
    }

    Ok(Redirect::to("/?message-sent=true"))
}

async fn send_email(
    to: &str,
    title: &str,
    description: &str,
    token: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let email = env::var("EMAIL")?;
    let password = env::var("PASSWORD")?;

    let body = format!(
        "Thanks for making a new ad!\n\
         Title: {title}\n\
         Description: {description}\n\
         Before it goes live, you must go activate the ad by loading the webpage:\n\
         kryptori.lu1.sh/manage-ad?token={token}\n\n\
         The token for this ad is: {token}\n\
         and that's what you can use to update and delete the ad.",
    );

    let msg = Message::builder()
        .from(email.parse()?)
        .to(to.parse()?)
        .subject(format!("New ad created: {title}"))
        .body(body)?;

    let creds = Credentials::new(email.clone(), password);

    let mailer = SmtpTransport::starttls_relay("smtp.gmail.com")?
        .credentials(creds)
        .build();

    mailer.send(&msg)?;
    Ok(())
}

async fn send_interested_email(
    to: &str,
    title: &str,
    description: &str,
    user_message: &str,
    user_email: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let email = env::var("EMAIL")?;
    let password = env::var("PASSWORD")?;

    let body = format!(
        "Someone is interested in this ad!\n\
         Title: {title}\n\
         Description: {description}\n\n\
         The user says:\n\n\
         {user_message}\n\n\
         The user's email is: {user_email}\n\
         and now it's up to you to respond to them using their email address.\n\
         Good luck!",
    );

    let msg = Message::builder()
        .from(email.parse()?)
        .to(to.parse()?)
        .subject(format!("Someone interested: {title}"))
        .body(body)?;

    let creds = Credentials::new(email.clone(), password);

    let mailer = SmtpTransport::starttls_relay("smtp.gmail.com")?
        .credentials(creds)
        .build();

    mailer.send(&msg)?;
    Ok(())
}

async fn index(State(state): State<Arc<AppState>>) -> Html<String> {
    let template = fs::read_to_string("pages/index.html").expect("Failed to read template");

    let ads_html = fetch_advertisements_html(&state.db).await.unwrap_or_else(|e| {
        eprintln!("DB error: {e}");
        "<p>Could not load ads.</p>".to_string()
    });

    let rendered = template.replace("{{ ads }}", &ads_html);

    Html(rendered)
}

async fn fetch_advertisements_html(pool: &SqlitePool) -> Result<String, sqlx::Error> {
    let ads = sqlx::query!(
        r#"
        SELECT id, title, description, created_at, updated_at
        FROM Advertisement
        WHERE active = 1
        ORDER BY created_at DESC
        "#
    )
    .fetch_all(pool)
    .await?;

    let mut html = String::from("<div>");

    for ad in ads {
        let created = &ad.created_at;
        let updated_str = match &ad.updated_at {
            Some(updated) => format!(", updated on {}", updated),
            None => "-".to_string(),
        };

        html.push_str(&format!(
            r#"<div class="ad-container">
            <details>
            <summary>{title}</summary>
            <i>Created on {created}{updated}</i>
            <p style="margin-left: 50px;">{desc}</p>
            <form action="/send-message" method="post">
                <span>Get in touch with the poster!</span>
                <input type="hidden" id="ad_id" name="ad_id" value="{id}" required>
                <div style="margin-top: 4px;">
                    <label for="user_email">
                        <b>Your email</b><br />
                        This won't be stored at all...<br />
                        Check the <a target="_blank" href="https://tangled.sh/@lewis.moe/kryptori">source code</a>...
                    </label><br />
                    <input type="email" id="user_email" name="user_email" placeholder="[e-mail]" required>
                </div>
                <div class="input-container">
                    <label for="message"><b>Message</b></label><br />
                    <textarea id="message" name="message" style="width: 100%; height: 6rem;" required></textarea>
                </div>
                <p>Remember, this will just send an email to the poster... etc</p>
                <div class="input-container">
                    <button type="submit">Send Message</button>
                </div>
            </form>
            </details>
            </div>"#,
            title = ad.title,
            created = created,
            updated = updated_str,
            desc = ad.description,
            id = ad.id,
        ));
    }

    html.push_str("</div>");
    Ok(html)
}

async fn fetch_advertisement_by_token(
    pool: &SqlitePool, 
    token: &str
) -> Result<Option<(String, String, String, Option<String>, String)>, sqlx::Error> {
    let row = sqlx::query!(
        r#"
        SELECT title, description, created_at, updated_at, owner_email 
        FROM Advertisement 
        WHERE owner_token = ? 
        LIMIT 1
        "#,
        token
    )
    .fetch_optional(pool)
    .await?;

    if let Some(ad) = row {
        sqlx::query!(
            r#"
            UPDATE Advertisement 
            SET active = 1 
            WHERE owner_token = ?
            "#,
            token
        )
        .execute(pool)
        .await?;

        Ok(Some((
            ad.title,
            ad.description,
            ad.created_at,
            ad.updated_at,
            ad.owner_email,
        )))
    } else {
        Ok(None)
    }
}

#[derive(Deserialize)]
struct ManageAdQuery {
    token: String,
}

#[derive(Template)]
#[template(path = "manage_ad.html")]
struct ManageAdTemplate {
    title: String,
    description: String,
    created_at: String,
    updated_at: String,
    owner_email: String,
    token: String,
}

fn render_updated_at(updated_at: Option<String>) -> String {
    updated_at.unwrap_or_else(|| "".to_string())
}

async fn manage_ad(
    State(state): State<Arc<AppState>>,
    Query(query): Query<ManageAdQuery>,
) -> Result<Html<String>, Redirect> {
    let token = &query.token;

    match fetch_advertisement_by_token(&state.db, token).await {
        Ok(Some((title, description, created_at, updated_at, owner_email))) => {
            let updated_at_str = render_updated_at(updated_at);
            let template = ManageAdTemplate {
                title,
                description,
                created_at,
                updated_at: updated_at_str,
                owner_email,
                token: token.to_string(),
            };

            let rendered_page = template.render().unwrap();
            
            Ok(Html(rendered_page))
        }
        Ok(None) => {
            Err(Redirect::to("/"))
        }
        Err(_) => {
            Err(Redirect::to("/"))
        }
    }
}

#[derive(Deserialize)]
struct UpdateAdForm {
    title: String,
    description: String,
    token: String,
}

#[derive(Deserialize)]
struct DeleteAdForm {
    token: String,
}

async fn update_ad(
    State(state): State<Arc<AppState>>,
    Form(form): Form<UpdateAdForm>,
) -> Result<Redirect, StatusCode> {
    let title = form.title.trim().to_string();
    let description = form.description.trim().to_string();
    let token = form.token.trim();

    if title.is_empty() || description.is_empty() {
        return Err(StatusCode::BAD_REQUEST);
    }

    let row = sqlx::query!("SELECT * FROM Advertisement WHERE owner_token = ?", token)
        .fetch_optional(&state.db)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    if row.is_none() {
        return Err(StatusCode::NOT_FOUND);
    }

    sqlx::query!(
        "UPDATE Advertisement SET title = ?, description = ?, updated_at = CURRENT_TIMESTAMP WHERE owner_token = ?",
        title, description, token
    )
    .execute(&state.db)
    .await
    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    Ok(Redirect::to(format!("/manage-ad?token={}&success=true", token).as_str()))
}

async fn delete_ad(
    State(state): State<Arc<AppState>>,
    Form(form): Form<DeleteAdForm>,
) -> Result<Redirect, StatusCode> {
    let token = form.token.trim();

    let rows_deleted = sqlx::query!("DELETE FROM Advertisement WHERE owner_token = ?", token)
        .execute(&state.db)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    if rows_deleted.rows_affected() == 0 {
        return Err(StatusCode::NOT_FOUND);
    }

    Ok(Redirect::to("/?delete-success=true"))
}

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = env::var("DATABASE_URL").unwrap_or("sqlite://kryptori.db".to_string());
    let pool = SqlitePoolOptions::new()
        .connect(&database_url)
        .await?;

    create_tables_if_not_exist(&pool).await?;

    let state = Arc::new(AppState { db: pool });

    let app = Router::new()
        .route("/", get(index))
        .route("/create-ad", axum::routing::post(create_ad))
        .route("/manage-ad", axum::routing::get(manage_ad))
        .route("/update-ad", axum::routing::post(update_ad))
        .route("/delete-ad", axum::routing::post(delete_ad))
        .route("/send-message", axum::routing::post(send_message))
        .with_state(state);

    let listener = tokio::net::TcpListener::bind("127.0.0.1:8000").await.unwrap();
    println!("Listening on {}", listener.local_addr().unwrap());
    axum::serve(listener, app).await.unwrap();

    Ok(())
}