107 lines
3.8 KiB
Rust
107 lines
3.8 KiB
Rust
use actix_files::NamedFile;
|
|
use actix_web::{
|
|
error,
|
|
http::header::{Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue},
|
|
web, Error, HttpRequest, HttpResponse,
|
|
};
|
|
use async_std::{fs, path::Path};
|
|
use futures::TryStreamExt;
|
|
use mime::Mime;
|
|
use sqlx::{
|
|
postgres::{PgPool, PgRow},
|
|
Row,
|
|
};
|
|
|
|
use crate::deleter;
|
|
use crate::{config::Config, file_kind::FileKind};
|
|
|
|
const VIEW_HTML: &str = include_str!("../template/view.html");
|
|
|
|
pub async fn download(
|
|
req: HttpRequest,
|
|
db: web::Data<PgPool>,
|
|
config: web::Data<Config>,
|
|
) -> Result<HttpResponse, Error> {
|
|
let id = req.match_info().query("id");
|
|
let mut rows = sqlx::query(
|
|
"SELECT file_id, file_name, kind, delete_on_download from files WHERE file_id = $1",
|
|
)
|
|
.bind(id)
|
|
.fetch(db.as_ref());
|
|
let row: PgRow = rows
|
|
.try_next()
|
|
.await
|
|
.map_err(|db_err| {
|
|
log::error!("could not run select statement {:?}", db_err);
|
|
error::ErrorInternalServerError("could not run select statement")
|
|
})?
|
|
.ok_or_else(|| error::ErrorNotFound("file does not exist or has expired"))?;
|
|
|
|
let file_id: String = row.get("file_id");
|
|
let file_name: String = row.get("file_name");
|
|
let file_kind: String = row.get("kind");
|
|
let delete_on_download: bool = row.get("delete_on_download");
|
|
let mut path = config.files_dir.clone();
|
|
path.push(&file_id);
|
|
|
|
let download = delete_on_download || req.query_string().contains("dl");
|
|
let content_type = get_content_type(&path);
|
|
let is_text = file_kind == FileKind::Text.to_string() || content_type.type_() == mime::TEXT;
|
|
let response = if is_text && !download {
|
|
let content = fs::read_to_string(path).await.map_err(|file_err| {
|
|
log::error!("file could not be read {:?}", file_err);
|
|
error::ErrorInternalServerError("this file should be here but could not be found")
|
|
})?;
|
|
let encoded = htmlescape::encode_minimal(&content);
|
|
let view_html = VIEW_HTML.replace("{text}", &encoded);
|
|
let response = HttpResponse::Ok().content_type("text/html").body(view_html);
|
|
Ok(response)
|
|
} else {
|
|
let content_disposition = ContentDisposition {
|
|
disposition: if download {
|
|
DispositionType::Attachment
|
|
} else {
|
|
DispositionType::Inline
|
|
},
|
|
parameters: get_disposition_params(&file_name),
|
|
};
|
|
let file = NamedFile::open(path)
|
|
.map_err(|file_err| {
|
|
log::error!("file could not be read {:?}", file_err);
|
|
error::ErrorInternalServerError("this file should be here but could not be found")
|
|
})?
|
|
.set_content_type(content_type)
|
|
.set_content_disposition(content_disposition);
|
|
file.into_response(&req)
|
|
};
|
|
if delete_on_download {
|
|
deleter::delete_by_id(&db, &file_id, &config.files_dir)
|
|
.await
|
|
.map_err(|db_err| {
|
|
log::error!("could not delete file {:?}", db_err);
|
|
error::ErrorInternalServerError("could not delete file")
|
|
})?;
|
|
}
|
|
response
|
|
}
|
|
|
|
fn get_content_type(path: &Path) -> Mime {
|
|
let std_path = std::path::Path::new(path.as_os_str());
|
|
tree_magic_mini::from_filepath(std_path)
|
|
.unwrap_or("application/octet-stream")
|
|
.parse::<Mime>()
|
|
.expect("tree_magic_mini should not produce invalid mime")
|
|
}
|
|
|
|
fn get_disposition_params(filename: &str) -> Vec<DispositionParam> {
|
|
let mut parameters = vec![DispositionParam::Filename(filename.to_owned())];
|
|
if !filename.is_ascii() {
|
|
parameters.push(DispositionParam::FilenameExt(ExtendedValue {
|
|
charset: Charset::Ext(String::from("UTF-8")),
|
|
language_tag: None,
|
|
value: filename.to_owned().into_bytes(),
|
|
}))
|
|
}
|
|
parameters
|
|
}
|