115 lines
3.4 KiB
Rust
115 lines
3.4 KiB
Rust
use crate::addressing::Address;
|
|
use crate::database::Entry;
|
|
use crate::filesystem::{list_directory, UPath};
|
|
use crate::hash::{decode, encode};
|
|
use actix::prelude::*;
|
|
use actix_files::NamedFile;
|
|
use actix_web::error::{ErrorBadRequest, ErrorInternalServerError, ErrorNotFound};
|
|
use actix_web::{error, get, post, web, Error, HttpResponse};
|
|
use anyhow::Result;
|
|
use log::debug;
|
|
use serde::Deserialize;
|
|
use std::collections::HashMap;
|
|
use std::path::PathBuf;
|
|
|
|
#[derive(Clone)]
|
|
pub struct State {
|
|
pub directory: PathBuf,
|
|
pub db: Addr<crate::database::DbExecutor>,
|
|
pub hasher: Addr<crate::hash::HasherWorker>,
|
|
}
|
|
|
|
#[get("/raw/{hash}")]
|
|
pub async fn get_raw(state: web::Data<State>, hash: web::Path<String>) -> Result<NamedFile, Error> {
|
|
let address = Address::decode(&decode(hash.into_inner()).map_err(ErrorInternalServerError)?)
|
|
.map_err(ErrorInternalServerError)?;
|
|
if let Address::Hash(hash) = address {
|
|
let response = state
|
|
.db
|
|
.send(crate::database::RetrieveByHash { hash })
|
|
.await?;
|
|
|
|
debug!("{:?}", response);
|
|
|
|
match response {
|
|
Ok(result) => match result {
|
|
Some(path) => Ok(NamedFile::open(path)?),
|
|
None => Err(error::ErrorNotFound("NOT FOUND")),
|
|
},
|
|
Err(e) => Err(error::ErrorInternalServerError(e)),
|
|
}
|
|
} else {
|
|
Err(ErrorBadRequest("Address does not refer to a file."))
|
|
}
|
|
}
|
|
|
|
#[get("/get/{address_str}")]
|
|
pub async fn get_object(
|
|
state: web::Data<State>,
|
|
address_str: web::Path<String>,
|
|
) -> Result<HttpResponse, Error> {
|
|
let response: Result<Vec<Entry>> = state
|
|
.db
|
|
.send(crate::database::RetrieveObject {
|
|
target: Address::decode(
|
|
&decode(address_str.into_inner()).map_err(ErrorInternalServerError)?,
|
|
)
|
|
.map_err(ErrorInternalServerError)?,
|
|
})
|
|
.await?;
|
|
|
|
debug!("{:?}", response);
|
|
|
|
let mut result: HashMap<String, serde_json::Value> = HashMap::new();
|
|
for entry in response.map_err(error::ErrorInternalServerError)? {
|
|
result.insert(encode(&entry.identity.0), entry.as_json());
|
|
}
|
|
Ok(HttpResponse::Ok().json(result))
|
|
}
|
|
|
|
#[get("/hier/{path:.*}")]
|
|
pub async fn list_hier(
|
|
state: web::Data<State>,
|
|
path: web::Path<String>,
|
|
) -> Result<HttpResponse, Error> {
|
|
let upath: UPath = path.into_inner().parse().map_err(ErrorBadRequest)?;
|
|
let entries: Vec<Entry> = list_directory(&state.db, &upath)
|
|
.await
|
|
.map_err(ErrorNotFound)?; // todo: 500 if actual error occurs
|
|
|
|
Ok(HttpResponse::Ok().json(
|
|
entries
|
|
.iter()
|
|
.map(Entry::as_json)
|
|
.collect::<serde_json::Value>(),
|
|
))
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct LookupRequest {
|
|
query: String,
|
|
}
|
|
|
|
#[get("/api/lookup")]
|
|
pub async fn get_lookup(
|
|
state: web::Data<State>,
|
|
web::Query(info): web::Query<LookupRequest>,
|
|
) -> Result<HttpResponse, Error> {
|
|
let response = state
|
|
.db
|
|
.send(crate::database::LookupByFilename { query: info.query })
|
|
.await?;
|
|
|
|
Ok(HttpResponse::Ok().json(response.map_err(error::ErrorInternalServerError)?))
|
|
}
|
|
|
|
#[post("/api/refresh")]
|
|
pub async fn api_refresh(state: web::Data<State>) -> Result<HttpResponse, Error> {
|
|
actix::spawn(crate::filesystem::reimport_directory(
|
|
state.directory.clone(),
|
|
state.db.clone(),
|
|
state.hasher.clone(),
|
|
));
|
|
Ok(HttpResponse::Ok().finish())
|
|
}
|