datatrash/src/download.rs

107 lines
3.8 KiB
Rust
Raw Normal View History

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
}