132 lines
4.3 KiB
Rust
132 lines
4.3 KiB
Rust
use crate::errors::to_internal_error;
|
|
use crate::extractor_helper::WithProblemDetails;
|
|
use crate::files::build_system_path;
|
|
use crate::{errors, AppState};
|
|
use axum::extract::{Query, State};
|
|
use axum::http::StatusCode;
|
|
use axum::{debug_handler, Json};
|
|
use problem_details::ProblemDetails;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::io::Error;
|
|
use std::path::PathBuf;
|
|
use tokio::fs::{read_dir, DirEntry};
|
|
use tracing::{debug, error};
|
|
|
|
/// Handler to query a file tree. The query parameters can be used to control what is is queried.
|
|
#[debug_handler]
|
|
pub async fn query_file_tree(
|
|
State(state): State<AppState>,
|
|
axum::extract::Path(user_id): axum::extract::Path<String>,
|
|
WithProblemDetails(Query(query)): WithProblemDetails<Query<FileQuery>>,
|
|
) -> Result<Json<PathElements>, ProblemDetails> {
|
|
let path = build_system_path(&state.config.files.directory, &user_id, &query.path)?;
|
|
debug!("Loading path: {:?}", path);
|
|
PathElements::load(path, query.nesting)
|
|
.await
|
|
.map(Json::from)
|
|
}
|
|
|
|
/// Query to control how a file tree is queried.
|
|
#[derive(Deserialize)]
|
|
pub struct FileQuery {
|
|
/// Path which is used as base path to query the tree.
|
|
path: PathBuf,
|
|
#[serde(default = "u32::min_value")]
|
|
/// The amount of layers the tree should be loaded for. Can be used to cache a certain amount
|
|
/// of levels for a better UX when browsing the data.
|
|
nesting: u32,
|
|
}
|
|
|
|
/// Represents the root of a file tree.
|
|
#[derive(Serialize)]
|
|
pub struct PathElements {
|
|
files: Vec<PathElement>,
|
|
}
|
|
|
|
/// Represents a node in the file tree.
|
|
#[derive(Serialize)]
|
|
pub struct PathElement {
|
|
/// The name of the directory or file.
|
|
name: String,
|
|
is_dir: bool,
|
|
/// Empty children means that the node is either a file or an empty directory.
|
|
/// None means that the children have not been loaded.
|
|
children: Option<Vec<PathElement>>,
|
|
}
|
|
|
|
impl PathElements {
|
|
pub fn new(files: Vec<PathElement>) -> Self {
|
|
Self { files }
|
|
}
|
|
|
|
/// Loads a path recursively nested for up to the provided nesting parameter.
|
|
pub async fn load(path: PathBuf, nesting: u32) -> Result<Self, ProblemDetails> {
|
|
Self::load_directory(path, nesting).await.map(Self::new)
|
|
}
|
|
|
|
async fn load_directory(
|
|
path: PathBuf,
|
|
nesting: u32,
|
|
) -> Result<Vec<PathElement>, ProblemDetails> {
|
|
match read_dir(path).await {
|
|
Err(error) => Err(Self::map_io_error(error)),
|
|
Ok(mut value) => {
|
|
let mut result = vec![];
|
|
while let Some(next) = value.next_entry().await.map_err(Self::map_io_error)? {
|
|
result.push(Self::load_path_element(next, nesting).await?);
|
|
}
|
|
Ok(result)
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn load_children(
|
|
path: PathBuf,
|
|
nesting: u32,
|
|
is_dir: bool,
|
|
) -> Result<Option<Vec<PathElement>>, ProblemDetails> {
|
|
if nesting == 0 {
|
|
Ok(None)
|
|
} else if !is_dir {
|
|
Ok(Some(vec![]))
|
|
} else {
|
|
Ok(Some(
|
|
// needs to call pin to support recursion in async contexts.
|
|
Box::pin(Self::load_directory(path, nesting - 1)).await?,
|
|
))
|
|
}
|
|
}
|
|
|
|
async fn load_path_element(
|
|
value: DirEntry,
|
|
nesting: u32,
|
|
) -> Result<PathElement, ProblemDetails> {
|
|
let metadata = value.metadata().await.unwrap();
|
|
debug!("File type: {:?}", value.file_type().await.unwrap());
|
|
let is_dir = metadata.is_dir();
|
|
if is_dir || metadata.is_file() {
|
|
Ok(PathElement {
|
|
name: value.file_name().into_string().unwrap(),
|
|
is_dir,
|
|
children: Self::load_children(value.path(), nesting, is_dir).await?,
|
|
})
|
|
} else {
|
|
error!(
|
|
"File <{:?}> is neither a directory nor a file.",
|
|
value.file_name()
|
|
);
|
|
Err(
|
|
ProblemDetails::from_status_code(StatusCode::INTERNAL_SERVER_ERROR)
|
|
.with_detail(errors::ERROR_DETAILS_INTERNAL_ERROR),
|
|
)
|
|
}
|
|
}
|
|
|
|
fn map_io_error(error: Error) -> ProblemDetails {
|
|
match error.kind() {
|
|
std::io::ErrorKind::NotFound => ProblemDetails::from_status_code(StatusCode::NOT_FOUND),
|
|
_ => to_internal_error(error),
|
|
}
|
|
}
|
|
}
|