obsolute-paste/src/main.rs

use actix_files as fs;
use actix_web::{
    get,
    http::header::ContentType,
    web::{Data, Query},
    App, HttpResponse, HttpServer, Responder,
};
use base64::{engine::general_purpose, Engine};
use mime::TEXT_HTML;
use reqwest::{header::HeaderMap, Client};
use serde::{Deserialize, Serialize};
use std::env;
use tera::{Context, Tera};

struct Template {
    paste: Tera,
}

#[derive(Deserialize)]
struct Paste {
    paste_id: Option<String>,
    parse_md: Option<String>,
}

#[derive(Serialize, Deserialize)]
struct GiteaSuccessJSON {
    name: String,
    path: String,
    size: u64,
    encoding: String,
    sha: String,
    target: Option<String>,
    url: String,
    html_url: String,
    git_url: String,
    submodule_git_url: Option<String>,
    content: String,
}

#[derive(Serialize, Deserialize)]
struct GiteaFailedJSON {
    errors: Option<Vec<String>>,
    message: String,
    url: String,
}

#[get("/")]
async fn paste_render(data: Data<Template>, paste: Query<Paste>) -> impl Responder {
    let my_data = data.get_ref();
    let mut context = Context::new();
    let gitea_token = env::var("GITEA_TOKEN").unwrap_or("".to_string());
    let mut headers = HeaderMap::new();
    headers.insert("Authorization", gitea_token.parse().unwrap());
    let base_url = env::var("BASE_URL").unwrap_or("https://gitea.com".to_string());
    let client = Client::builder()
        .default_headers(headers)
        .gzip(true)
        .build()
        .unwrap();
    let paste_content: String;
    if paste.paste_id.is_some() {
        let response = client
            .get(format!(
                "{}/contents/{}?ref=master",
                base_url,
                paste.paste_id.as_ref().unwrap()
            ))
            .send()
            .await
            .unwrap();
        let response_code = response.status().as_str().to_string();
        let response_json = response.text().await.unwrap();
        if response_code != "200" {
            let resp_struct: GiteaFailedJSON = serde_json::from_str(&response_json).unwrap();
            if resp_struct.message == "The target couldn't be found." {
                context.insert("md", "true");
                paste_content = "Project ID Mismatch/Gitea Token Missing".to_string();
            } else {
                context.insert("md", "true");
                paste_content = "Paste ID is Invalid".to_string();
            }
        } else {
            let resp_struct: GiteaSuccessJSON = serde_json::from_str(&response_json).unwrap();
            paste_content = String::from_utf8(
                general_purpose::STANDARD
                    .decode(resp_struct.content)
                    .unwrap(),
            )
            .unwrap();
        }
    } else {
        context.insert("md", "true");
        paste_content = "This is a no-nonsense Pastebin Server, written in Rust. It serves the content from files on a Gitea Private Repository. Please look into the repository for hosting your own copy of this.".to_string();
    }
    context.insert("paste_content", &paste_content);
    if paste.parse_md.is_some() {
        context.insert("md", "true");
    }
    let rendered = my_data.paste.render("paste.html", &context);
    HttpResponse::Ok()
        .insert_header(ContentType(TEXT_HTML))
        .body(rendered.unwrap())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let tera = match Tera::new("templates/*.html") {
        Ok(t) => t,
        Err(e) => {
            println!("Parsing error(s): {}", e);
            ::std::process::exit(1);
        }
    };
    let data = Data::new(Template { paste: tera });
    println!("Paste Server is launched on 0.0.0.0:8080");
    HttpServer::new(move || {
        App::new()
            .app_data(Data::clone(&data))
            .service(paste_render)
            .service(fs::Files::new("/static", "static"))
    })
    .bind(env::var("BIND_ADDRESS").unwrap_or("0.0.0.0:8080".to_string()))?
    .run()
    .await
}