Edouard Vanbelle
789 lines
27 KiB
Rust
789 lines
27 KiB
Rust
use std::sync::Arc;
|
|
use uuid::Uuid;
|
|
|
|
use axum::{
|
|
Json,
|
|
body::Body,
|
|
extract::{Path, Query, State},
|
|
http::{HeaderMap, StatusCode, header},
|
|
response::{IntoResponse, Response},
|
|
};
|
|
use http_range_header::parse_range_header;
|
|
use serde::Deserialize;
|
|
use serde_json::json;
|
|
use utoipa::ToSchema;
|
|
|
|
use crate::application::services::share_browse_service::ZipTarget;
|
|
use crate::application::services::share_service::ShareService;
|
|
use crate::infrastructure::services::share_unlock_cookie;
|
|
use crate::interfaces::api::handlers::file_handler::build_content_disposition;
|
|
use crate::{
|
|
application::{
|
|
dtos::share_dto::{CreateShareDto, UpdateShareDto},
|
|
ports::{
|
|
file_ports::{FileRetrievalUseCase, OptimizedFileContent},
|
|
share_ports::ShareUseCase,
|
|
},
|
|
},
|
|
common::{di::AppState, errors::ErrorKind},
|
|
domain::entities::share::ShareItemType,
|
|
interfaces::errors::AppError,
|
|
interfaces::middleware::auth::AuthUser,
|
|
};
|
|
use tokio_util::io::ReaderStream;
|
|
|
|
fn unlock_jwt_from_headers(headers: &HeaderMap, share_token: &str) -> Option<String> {
|
|
headers
|
|
.get(header::COOKIE)
|
|
.and_then(|h| h.to_str().ok())
|
|
.and_then(|cookie_header| {
|
|
share_unlock_cookie::extract_from_cookie_header(cookie_header, share_token)
|
|
})
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct GetSharesQuery {
|
|
pub page: Option<usize>,
|
|
pub per_page: Option<usize>,
|
|
pub item_id: Option<String>,
|
|
pub item_type: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, ToSchema)]
|
|
pub struct VerifyPasswordRequest {
|
|
pub password: String,
|
|
}
|
|
|
|
/// Create a new shared link
|
|
#[utoipa::path(
|
|
post,
|
|
path = "/api/shares",
|
|
request_body = CreateShareDto,
|
|
responses(
|
|
(status = 201, description = "Share created", body = crate::application::dtos::share_dto::ShareDto),
|
|
(status = 400, description = "Bad request")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn create_shared_link(
|
|
State(share_use_case): State<Arc<ShareService>>,
|
|
auth_user: AuthUser,
|
|
Json(dto): Json<CreateShareDto>,
|
|
) -> impl IntoResponse {
|
|
match share_use_case.create_shared_link(auth_user.id, dto).await {
|
|
Ok(share) => (StatusCode::CREATED, Json(share)).into_response(),
|
|
Err(err) => AppError::from(err).into_response(),
|
|
}
|
|
}
|
|
|
|
/// Get information about a specific shared link by ID
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/shares/{id}",
|
|
params(("id" = String, Path, description = "Share ID")),
|
|
responses(
|
|
(status = 200, description = "Share details", body = crate::application::dtos::share_dto::ShareDto),
|
|
(status = 404, description = "Share not found")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn get_shared_link(
|
|
State(share_use_case): State<Arc<ShareService>>,
|
|
auth_user: AuthUser,
|
|
Path(id): Path<String>,
|
|
) -> impl IntoResponse {
|
|
let id = match Uuid::parse_str(&id) {
|
|
Ok(id) => id,
|
|
Err(_) => return AppError::bad_request("Invalid UUID").into_response(),
|
|
};
|
|
match share_use_case.get_shared_link(id, auth_user.id).await {
|
|
Ok(share) => (StatusCode::OK, Json(share)).into_response(),
|
|
Err(err) => AppError::from(err).into_response(),
|
|
}
|
|
}
|
|
|
|
/// Get all shared links created by the current user.
|
|
/// Supports optional filtering by item_id + item_type query params.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/shares",
|
|
responses(
|
|
(status = 200, description = "List of shares", body = Vec<crate::application::dtos::share_dto::ShareDto>)
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn get_user_shares(
|
|
State(share_use_case): State<Arc<ShareService>>,
|
|
auth_user: AuthUser,
|
|
Query(query): Query<GetSharesQuery>,
|
|
) -> impl IntoResponse {
|
|
let user_id = auth_user.id;
|
|
|
|
// If both item_id and item_type are provided, return shares for that specific item
|
|
if let (Some(item_id), Some(item_type_str)) = (&query.item_id, &query.item_type) {
|
|
let item_type = match ShareItemType::try_from(item_type_str.as_str()) {
|
|
Ok(t) => t,
|
|
Err(_) => {
|
|
return (
|
|
StatusCode::BAD_REQUEST,
|
|
Json(json!({ "error": format!("Invalid item_type: {}", item_type_str) })),
|
|
)
|
|
.into_response();
|
|
}
|
|
};
|
|
return match share_use_case
|
|
.get_shared_links_for_item(item_id, &item_type, user_id)
|
|
.await
|
|
{
|
|
Ok(shares) => (StatusCode::OK, Json(shares)).into_response(),
|
|
Err(err) => AppError::from(err).into_response(),
|
|
};
|
|
}
|
|
|
|
// Default: paginated list of all user shares
|
|
let page = query.page.unwrap_or(1);
|
|
let per_page = query.per_page.unwrap_or(20);
|
|
|
|
match share_use_case
|
|
.get_user_shared_links(user_id, page, per_page)
|
|
.await
|
|
{
|
|
Ok(shares) => (StatusCode::OK, Json(shares)).into_response(),
|
|
Err(err) => AppError::from(err).into_response(),
|
|
}
|
|
}
|
|
|
|
/// Update a shared link's properties
|
|
#[utoipa::path(
|
|
put,
|
|
path = "/api/shares/{id}",
|
|
params(("id" = String, Path, description = "Share ID")),
|
|
request_body = UpdateShareDto,
|
|
responses(
|
|
(status = 200, description = "Share updated", body = crate::application::dtos::share_dto::ShareDto),
|
|
(status = 404, description = "Share not found")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn update_shared_link(
|
|
State(share_use_case): State<Arc<ShareService>>,
|
|
auth_user: AuthUser,
|
|
Path(id): Path<String>,
|
|
Json(dto): Json<UpdateShareDto>,
|
|
) -> impl IntoResponse {
|
|
let id = match Uuid::parse_str(&id) {
|
|
Ok(id) => id,
|
|
Err(_) => return AppError::bad_request("Invalid UUID").into_response(),
|
|
};
|
|
match share_use_case
|
|
.update_shared_link(id, auth_user.id, dto)
|
|
.await
|
|
{
|
|
Ok(share) => (StatusCode::OK, Json(share)).into_response(),
|
|
Err(err) => AppError::from(err).into_response(),
|
|
}
|
|
}
|
|
|
|
/// Delete a shared link
|
|
#[utoipa::path(
|
|
delete,
|
|
path = "/api/shares/{id}",
|
|
params(("id" = String, Path, description = "Share ID")),
|
|
responses(
|
|
(status = 204, description = "Share deleted"),
|
|
(status = 404, description = "Share not found")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn delete_shared_link(
|
|
State(share_use_case): State<Arc<ShareService>>,
|
|
auth_user: AuthUser,
|
|
Path(id): Path<String>,
|
|
) -> impl IntoResponse {
|
|
let id = match Uuid::parse_str(&id) {
|
|
Ok(id) => id,
|
|
Err(_) => return AppError::bad_request("Invalid UUID").into_response(),
|
|
};
|
|
match share_use_case.delete_shared_link(id, auth_user.id).await {
|
|
Ok(_) => StatusCode::NO_CONTENT.into_response(),
|
|
Err(err) => AppError::from(err).into_response(),
|
|
}
|
|
}
|
|
|
|
/// Access a shared item via its token
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/s/{token}",
|
|
params(("token" = String, Path, description = "Share token")),
|
|
responses(
|
|
(status = 200, description = "Shared item details"),
|
|
(status = 401, description = "Password required"),
|
|
(status = 410, description = "Share expired")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn access_shared_item(
|
|
State(share_use_case): State<Arc<ShareService>>,
|
|
Path(token): Path<String>,
|
|
headers: HeaderMap,
|
|
) -> impl IntoResponse {
|
|
// Register the access
|
|
let _ = share_use_case.register_shared_link_access(&token).await;
|
|
|
|
// Honour an unlock cookie if one was issued by a prior `/verify` call.
|
|
let unlock_jwt = unlock_jwt_from_headers(&headers, &token);
|
|
|
|
// Get the shared link
|
|
match share_use_case
|
|
.get_shared_link_with_unlock(&token, unlock_jwt.as_deref())
|
|
.await
|
|
{
|
|
Ok(item) => (StatusCode::OK, Json(item)).into_response(),
|
|
Err(err) => {
|
|
// Special handling for share access errors
|
|
if err.kind == ErrorKind::AccessDenied {
|
|
if err.message.contains("password") {
|
|
return (
|
|
StatusCode::UNAUTHORIZED,
|
|
Json(json!({
|
|
"error": "Password required",
|
|
"requiresPassword": true
|
|
})),
|
|
)
|
|
.into_response();
|
|
}
|
|
if err.message.contains("expired") {
|
|
return AppError::new(StatusCode::GONE, err.message, "Expired").into_response();
|
|
}
|
|
}
|
|
AppError::from(err).into_response()
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Verify password for a password-protected shared item
|
|
#[utoipa::path(
|
|
post,
|
|
path = "/api/s/{token}/verify",
|
|
params(("token" = String, Path, description = "Share token")),
|
|
responses(
|
|
(status = 200, description = "Password verified, item details returned"),
|
|
(status = 401, description = "Invalid password"),
|
|
(status = 410, description = "Share expired")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn verify_shared_item_password(
|
|
State(share_use_case): State<Arc<ShareService>>,
|
|
Path(token): Path<String>,
|
|
Json(req): Json<VerifyPasswordRequest>,
|
|
) -> impl IntoResponse {
|
|
match share_use_case
|
|
.verify_shared_link_password(&token, &req.password)
|
|
.await
|
|
{
|
|
Ok(item) => match share_use_case.issue_unlock_jwt(&token) {
|
|
Ok(jwt) => {
|
|
let cookie = share_unlock_cookie::build_set_cookie(
|
|
&token,
|
|
&jwt,
|
|
share_unlock_cookie::DEFAULT_TTL_SECS,
|
|
);
|
|
(StatusCode::OK, [(header::SET_COOKIE, cookie)], Json(item)).into_response()
|
|
}
|
|
Err(_) => (StatusCode::OK, Json(item)).into_response(),
|
|
},
|
|
Err(err) => {
|
|
if err.kind == ErrorKind::AccessDenied {
|
|
if err.message.contains("expired") {
|
|
return AppError::new(StatusCode::GONE, err.message, "Expired").into_response();
|
|
}
|
|
if err.message.contains("password") {
|
|
return AppError::unauthorized("Invalid password").into_response();
|
|
}
|
|
}
|
|
AppError::from(err).into_response()
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Download the actual file content for a shared file via its token.
|
|
///
|
|
/// Validates the share token, checks it refers to a file (not folder),
|
|
/// then streams the file content to the caller.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/s/{token}/download",
|
|
params(("token" = String, Path, description = "Share token")),
|
|
responses(
|
|
(status = 200, description = "File content stream"),
|
|
(status = 401, description = "Password required"),
|
|
(status = 404, description = "Share not found"),
|
|
(status = 410, description = "Share expired"),
|
|
(status = 503, description = "Sharing disabled")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn download_shared_file(
|
|
State(state): State<Arc<AppState>>,
|
|
Path(token): Path<String>,
|
|
headers: HeaderMap,
|
|
) -> impl IntoResponse {
|
|
// 1. Resolve share service
|
|
let share_service = match &state.share_service {
|
|
Some(s) => s.clone(),
|
|
None => {
|
|
return AppError::new(
|
|
StatusCode::SERVICE_UNAVAILABLE,
|
|
"Sharing is disabled",
|
|
"Disabled",
|
|
)
|
|
.into_response();
|
|
}
|
|
};
|
|
|
|
// 2. Validate the share token (handles expiry + password checks)
|
|
let unlock_jwt = unlock_jwt_from_headers(&headers, &token);
|
|
let share_dto = match share_service
|
|
.get_shared_link_with_unlock(&token, unlock_jwt.as_deref())
|
|
.await
|
|
{
|
|
Ok(dto) => dto,
|
|
Err(err) => {
|
|
if err.kind == ErrorKind::AccessDenied {
|
|
if err.message.contains("password") {
|
|
return (
|
|
StatusCode::UNAUTHORIZED,
|
|
Json(json!({
|
|
"error": "Password required",
|
|
"requiresPassword": true
|
|
})),
|
|
)
|
|
.into_response();
|
|
}
|
|
if err.message.contains("expired") {
|
|
return AppError::new(StatusCode::GONE, err.message, "Expired").into_response();
|
|
}
|
|
}
|
|
return AppError::from(err).into_response();
|
|
}
|
|
};
|
|
|
|
// 3. Only file shares support direct download
|
|
if share_dto.item_type != "file" {
|
|
return AppError::bad_request("Download is only supported for file shares").into_response();
|
|
}
|
|
|
|
// 4. Stream the file with full Range / 304 / 416 / 206 support.
|
|
serve_share_file(
|
|
&state,
|
|
&share_dto.item_id,
|
|
share_dto.item_name.as_deref(),
|
|
&headers,
|
|
)
|
|
.await
|
|
}
|
|
|
|
/// Stream a file for a public share. Honours `If-None-Match` (304),
|
|
/// `Range` (206 / 416), and falls back to a 200 via `get_file_optimized`.
|
|
async fn serve_share_file(
|
|
state: &Arc<AppState>,
|
|
file_id: &str,
|
|
name_override: Option<&str>,
|
|
request_headers: &HeaderMap,
|
|
) -> Response {
|
|
let retrieval = &state.applications.file_retrieval_service;
|
|
|
|
let file_dto = match retrieval.get_file(file_id).await {
|
|
Ok(d) => d,
|
|
Err(err) => return AppError::from(err).into_response(),
|
|
};
|
|
|
|
let display_name = name_override.unwrap_or(&file_dto.name);
|
|
let etag = format!("\"{}-{}\"", file_dto.id, file_dto.modified_at);
|
|
let mime = file_dto.mime_type.clone();
|
|
let disposition = build_content_disposition(display_name, &mime, false);
|
|
|
|
if let Some(inm) = request_headers.get(header::IF_NONE_MATCH)
|
|
&& let Ok(client_etag) = inm.to_str()
|
|
&& (client_etag == etag || client_etag == "*")
|
|
{
|
|
return Response::builder()
|
|
.status(StatusCode::NOT_MODIFIED)
|
|
.header(header::ETAG, &etag)
|
|
.header(
|
|
header::CACHE_CONTROL,
|
|
"private, max-age=3600, must-revalidate",
|
|
)
|
|
.header(header::VARY, "Cookie, Range")
|
|
.body(Body::empty())
|
|
.unwrap()
|
|
.into_response();
|
|
}
|
|
|
|
if let Some(range_hdr) = request_headers.get(header::RANGE)
|
|
&& let Ok(range_str) = range_hdr.to_str()
|
|
&& let Ok(ranges) = parse_range_header(range_str)
|
|
{
|
|
match ranges.validate(file_dto.size) {
|
|
Ok(valid_ranges) => {
|
|
if let Some(range) = valid_ranges.first() {
|
|
let start = *range.start();
|
|
let end = *range.end();
|
|
let length = end - start + 1;
|
|
|
|
match retrieval
|
|
.get_file_range_stream(file_id, start, Some(end + 1))
|
|
.await
|
|
{
|
|
Ok(stream) => {
|
|
return Response::builder()
|
|
.status(StatusCode::PARTIAL_CONTENT)
|
|
.header(header::CONTENT_TYPE, &*mime)
|
|
.header(header::CONTENT_DISPOSITION, &disposition)
|
|
.header(header::CONTENT_LENGTH, length)
|
|
.header(
|
|
header::CONTENT_RANGE,
|
|
format!("bytes {}-{}/{}", start, end, file_dto.size),
|
|
)
|
|
.header(header::ACCEPT_RANGES, "bytes")
|
|
.header(header::ETAG, &etag)
|
|
.header(
|
|
header::CACHE_CONTROL,
|
|
"private, max-age=3600, must-revalidate",
|
|
)
|
|
.header(header::VARY, "Cookie, Range")
|
|
.body(Body::from_stream(Box::into_pin(stream)))
|
|
.unwrap()
|
|
.into_response();
|
|
}
|
|
Err(err) => {
|
|
tracing::error!("share range stream error: {}", err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Err(_) => {
|
|
return Response::builder()
|
|
.status(StatusCode::RANGE_NOT_SATISFIABLE)
|
|
.header(header::CONTENT_RANGE, format!("bytes */{}", file_dto.size))
|
|
.header(
|
|
header::CACHE_CONTROL,
|
|
"private, max-age=3600, must-revalidate",
|
|
)
|
|
.header(header::VARY, "Cookie, Range")
|
|
.body(Body::empty())
|
|
.unwrap()
|
|
.into_response();
|
|
}
|
|
}
|
|
}
|
|
|
|
match retrieval.get_file_optimized(file_id, false, true).await {
|
|
Ok((_, content)) => match content {
|
|
OptimizedFileContent::Bytes { data, .. } => Response::builder()
|
|
.status(StatusCode::OK)
|
|
.header(header::CONTENT_TYPE, &*mime)
|
|
.header(header::CONTENT_DISPOSITION, &disposition)
|
|
.header(header::CONTENT_LENGTH, data.len())
|
|
.header(header::ACCEPT_RANGES, "bytes")
|
|
.header(header::ETAG, &etag)
|
|
.header(
|
|
header::CACHE_CONTROL,
|
|
"private, max-age=3600, must-revalidate",
|
|
)
|
|
.header(header::VARY, "Cookie, Range")
|
|
.body(Body::from(data))
|
|
.unwrap()
|
|
.into_response(),
|
|
OptimizedFileContent::Mmap(mmap_data) => Response::builder()
|
|
.status(StatusCode::OK)
|
|
.header(header::CONTENT_TYPE, &*mime)
|
|
.header(header::CONTENT_DISPOSITION, &disposition)
|
|
.header(header::CONTENT_LENGTH, mmap_data.len())
|
|
.header(header::ACCEPT_RANGES, "bytes")
|
|
.header(header::ETAG, &etag)
|
|
.header(
|
|
header::CACHE_CONTROL,
|
|
"private, max-age=3600, must-revalidate",
|
|
)
|
|
.header(header::VARY, "Cookie, Range")
|
|
.body(Body::from(mmap_data))
|
|
.unwrap()
|
|
.into_response(),
|
|
OptimizedFileContent::Stream(stream) => Response::builder()
|
|
.status(StatusCode::OK)
|
|
.header(header::CONTENT_TYPE, &*mime)
|
|
.header(header::CONTENT_DISPOSITION, &disposition)
|
|
.header(header::CONTENT_LENGTH, file_dto.size)
|
|
.header(header::ACCEPT_RANGES, "bytes")
|
|
.header(header::ETAG, &etag)
|
|
.header(
|
|
header::CACHE_CONTROL,
|
|
"private, max-age=3600, must-revalidate",
|
|
)
|
|
.header(header::VARY, "Cookie, Range")
|
|
.body(Body::from_stream(stream))
|
|
.unwrap()
|
|
.into_response(),
|
|
},
|
|
Err(err) => AppError::from(err).into_response(),
|
|
}
|
|
}
|
|
|
|
// ── Public folder browsing endpoints ──────────────────────────────────────
|
|
|
|
fn sharing_disabled_response() -> Response {
|
|
AppError::new(
|
|
StatusCode::SERVICE_UNAVAILABLE,
|
|
"Sharing is disabled",
|
|
"Disabled",
|
|
)
|
|
.into_response()
|
|
}
|
|
|
|
fn share_browse_error_response(err: crate::common::errors::DomainError) -> Response {
|
|
if err.kind == ErrorKind::AccessDenied {
|
|
if err.message.contains("password") {
|
|
return (
|
|
StatusCode::UNAUTHORIZED,
|
|
Json(json!({
|
|
"error": "Password required",
|
|
"requiresPassword": true
|
|
})),
|
|
)
|
|
.into_response();
|
|
}
|
|
if err.message.contains("expired") {
|
|
return AppError::new(StatusCode::GONE, err.message, "Expired").into_response();
|
|
}
|
|
}
|
|
AppError::from(err).into_response()
|
|
}
|
|
|
|
// TODO: remove this and use the classic /api/files & /api/folders get, but with the token as session ?
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/s/{token}/contents",
|
|
params(("token" = String, Path, description = "Share token")),
|
|
responses(
|
|
(status = 200, description = "Folder contents (sub-folders + files)"),
|
|
(status = 400, description = "Share is not a folder share"),
|
|
(status = 401, description = "Password required"),
|
|
(status = 410, description = "Share expired"),
|
|
(status = 503, description = "Sharing disabled")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn list_share_contents_root(
|
|
State(state): State<Arc<AppState>>,
|
|
Path(token): Path<String>,
|
|
headers: HeaderMap,
|
|
) -> impl IntoResponse {
|
|
let Some(browse) = state.share_browse_service.clone() else {
|
|
return sharing_disabled_response();
|
|
};
|
|
let unlock_jwt = unlock_jwt_from_headers(&headers, &token);
|
|
|
|
match browse.list_root(&token, unlock_jwt.as_deref()).await {
|
|
Ok(listing) => (StatusCode::OK, Json(listing)).into_response(),
|
|
Err(err) => share_browse_error_response(err),
|
|
}
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/s/{token}/contents/{folder_id}",
|
|
params(
|
|
("token" = String, Path, description = "Share token"),
|
|
("folder_id" = String, Path, description = "Subfolder ID (must be inside the share)")
|
|
),
|
|
responses(
|
|
(status = 200, description = "Subfolder contents"),
|
|
(status = 400, description = "Share is not a folder share"),
|
|
(status = 401, description = "Password required"),
|
|
(status = 404, description = "Subfolder not found or not in share scope"),
|
|
(status = 410, description = "Share expired"),
|
|
(status = 503, description = "Sharing disabled")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn list_share_contents_subfolder(
|
|
State(state): State<Arc<AppState>>,
|
|
Path((token, folder_id)): Path<(String, String)>,
|
|
headers: HeaderMap,
|
|
) -> impl IntoResponse {
|
|
let Some(browse) = state.share_browse_service.clone() else {
|
|
return sharing_disabled_response();
|
|
};
|
|
let unlock_jwt = unlock_jwt_from_headers(&headers, &token);
|
|
|
|
match browse
|
|
.list_subfolder(&token, &folder_id, unlock_jwt.as_deref())
|
|
.await
|
|
{
|
|
Ok(listing) => (StatusCode::OK, Json(listing)).into_response(),
|
|
Err(err) => share_browse_error_response(err),
|
|
}
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/s/{token}/file/{file_id}",
|
|
params(
|
|
("token" = String, Path, description = "Share token"),
|
|
("file_id" = String, Path, description = "File ID (must be inside the share)")
|
|
),
|
|
responses(
|
|
(status = 200, description = "File content (or 206 for Range request)"),
|
|
(status = 206, description = "Partial Content"),
|
|
(status = 304, description = "Not Modified"),
|
|
(status = 401, description = "Password required"),
|
|
(status = 404, description = "File not found or not in share scope"),
|
|
(status = 410, description = "Share expired"),
|
|
(status = 416, description = "Range not satisfiable")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn download_share_file_in_folder(
|
|
State(state): State<Arc<AppState>>,
|
|
Path((token, file_id)): Path<(String, String)>,
|
|
headers: HeaderMap,
|
|
) -> impl IntoResponse {
|
|
let Some(browse) = state.share_browse_service.clone() else {
|
|
return sharing_disabled_response();
|
|
};
|
|
let unlock_jwt = unlock_jwt_from_headers(&headers, &token);
|
|
|
|
if let Err(err) = browse
|
|
.assert_file_in_share(&token, &file_id, unlock_jwt.as_deref())
|
|
.await
|
|
{
|
|
return share_browse_error_response(err);
|
|
}
|
|
|
|
serve_share_file(&state, &file_id, None, &headers).await
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/s/{token}/zip",
|
|
params(("token" = String, Path, description = "Share token")),
|
|
responses(
|
|
(status = 200, description = "ZIP archive of the shared folder"),
|
|
(status = 400, description = "Share is not a folder share"),
|
|
(status = 401, description = "Password required"),
|
|
(status = 410, description = "Share expired"),
|
|
(status = 503, description = "Sharing or ZIP service disabled")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn download_share_zip_root(
|
|
State(state): State<Arc<AppState>>,
|
|
Path(token): Path<String>,
|
|
headers: HeaderMap,
|
|
) -> impl IntoResponse {
|
|
serve_share_zip(state, token, None, headers).await
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/api/s/{token}/zip/{folder_id}",
|
|
params(
|
|
("token" = String, Path, description = "Share token"),
|
|
("folder_id" = String, Path, description = "Subfolder ID (must be inside the share)")
|
|
),
|
|
responses(
|
|
(status = 200, description = "ZIP archive of the subfolder"),
|
|
(status = 401, description = "Password required"),
|
|
(status = 404, description = "Subfolder not found or not in share scope"),
|
|
(status = 410, description = "Share expired"),
|
|
(status = 503, description = "Sharing or ZIP service disabled")
|
|
),
|
|
tag = "shares"
|
|
)]
|
|
pub async fn download_share_zip_subfolder(
|
|
State(state): State<Arc<AppState>>,
|
|
Path((token, folder_id)): Path<(String, String)>,
|
|
headers: HeaderMap,
|
|
) -> impl IntoResponse {
|
|
serve_share_zip(state, token, Some(folder_id), headers).await
|
|
}
|
|
|
|
async fn serve_share_zip(
|
|
state: Arc<AppState>,
|
|
token: String,
|
|
folder_id: Option<String>,
|
|
headers: HeaderMap,
|
|
) -> Response {
|
|
let Some(browse) = state.share_browse_service.clone() else {
|
|
return sharing_disabled_response();
|
|
};
|
|
let zip_service = match &state.core.zip_service {
|
|
Some(svc) => svc,
|
|
None => {
|
|
return AppError::new(
|
|
StatusCode::SERVICE_UNAVAILABLE,
|
|
"ZIP service not initialized",
|
|
"Disabled",
|
|
)
|
|
.into_response();
|
|
}
|
|
};
|
|
let unlock_jwt = unlock_jwt_from_headers(&headers, &token);
|
|
|
|
let target: ZipTarget = match browse
|
|
.resolve_zip_target(&token, folder_id.as_deref(), unlock_jwt.as_deref())
|
|
.await
|
|
{
|
|
Ok(t) => t,
|
|
Err(err) => return share_browse_error_response(err),
|
|
};
|
|
|
|
let temp_file = match zip_service
|
|
.create_folder_zip(&target.folder_id, &target.display_name)
|
|
.await
|
|
{
|
|
Ok(f) => f,
|
|
Err(err) => {
|
|
tracing::error!("share zip: create_folder_zip failed: {}", err);
|
|
return AppError::internal_error(format!("ZIP creation failed: {}", err))
|
|
.into_response();
|
|
}
|
|
};
|
|
|
|
let file_size = match temp_file.as_file().metadata() {
|
|
Ok(m) => m.len(),
|
|
Err(e) => {
|
|
tracing::error!("share zip: temp metadata failed: {}", e);
|
|
return AppError::internal_error("ZIP creation failed").into_response();
|
|
}
|
|
};
|
|
|
|
// Reuse the existing fd: split off the std::File and the TempPath.
|
|
let (std_file, temp_path) = temp_file.into_parts();
|
|
let tokio_file = tokio::fs::File::from_std(std_file);
|
|
let stream = ReaderStream::new(tokio_file);
|
|
let body = Body::from_stream(stream);
|
|
|
|
let disposition = build_content_disposition(
|
|
&format!("{}.zip", target.display_name),
|
|
"application/zip",
|
|
false,
|
|
);
|
|
|
|
let mut response = Response::builder()
|
|
.status(StatusCode::OK)
|
|
.header(header::CONTENT_TYPE, "application/zip")
|
|
.header(header::CONTENT_DISPOSITION, disposition)
|
|
.header(header::CONTENT_LENGTH, file_size)
|
|
.header(header::CACHE_CONTROL, "private, no-store")
|
|
.header(header::VARY, "Cookie")
|
|
.body(body)
|
|
.unwrap();
|
|
|
|
// Keep TempPath alive until the body finishes streaming.
|
|
response.extensions_mut().insert(Arc::new(temp_path));
|
|
response
|
|
}
|