File size: 3,642 Bytes
b772fd3 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 |
use std::collections::HashMap;
use actix_multipart::Multipart;
use actix_web::{get, HttpResponse, post, web};
use actix_web::http::Error;
use chrono::Local;
use futures_util::{AsyncWriteExt, StreamExt};
use serde::Deserialize;
use std::io::Write;
use crate::api::JsonResponse;
use crate::AppState;
use crate::entity::doc_info::Model;
use crate::service::doc_info::{Mutation, Query};
#[derive(Debug, Deserialize)]
pub struct Params {
pub uid: i64,
pub filter: FilterParams,
pub sortby: String,
pub page: u64,
pub per_page: u64,
}
#[derive(Debug, Deserialize)]
pub struct FilterParams {
pub keywords: Option<String>,
pub folder_id: Option<i64>,
pub tag_id: Option<i64>,
pub kb_id: Option<i64>,
}
#[derive(Debug, Deserialize)]
pub struct MvParams {
pub dids: Vec<i64>,
pub dest_did: i64,
}
#[get("/v1.0/docs")]
async fn list(params: web::Json<Params>, data: web::Data<AppState>) -> Result<HttpResponse, Error> {
let docs = Query::find_doc_infos_by_params(&data.conn, params.into_inner())
.await
.unwrap();
let mut result = HashMap::new();
result.insert("docs", docs);
let json_response = JsonResponse {
code: 200,
err: "".to_owned(),
data: result,
};
Ok(HttpResponse::Ok()
.content_type("application/json")
.body(serde_json::to_string(&json_response).unwrap()))
}
#[post("/v1.0/upload")]
async fn upload(mut payload: Multipart, filename: web::Data<String>, did: web::Data<i64>, uid: web::Data<i64>, data: web::Data<AppState>) -> Result<HttpResponse, Error> {
let mut size = 0;
while let Some(item) = payload.next().await {
let mut field = item.unwrap();
let filepath = format!("./uploads/{}", filename.as_str());
let mut file = web::block(|| std::fs::File::create(filepath))
.await
.unwrap()
.unwrap();
while let Some(chunk) = field.next().await {
let data = chunk.unwrap();
size += data.len() as u64;
file = web::block(move || file.write_all(&data).map(|_| file))
.await
.unwrap()
.unwrap();
}
}
let _ = Mutation::create_doc_info(&data.conn, Model {
did: *did.into_inner(),
uid: *uid.into_inner(),
doc_name: filename.to_string(),
size,
kb_infos: Vec::new(),
kb_progress: 0.0,
location: "".to_string(),
r#type: "".to_string(),
created_at: Local::now().date_naive(),
updated_at: Local::now().date_naive(),
}).await.unwrap();
Ok(HttpResponse::Ok().body("File uploaded successfully"))
}
#[post("/v1.0/delete_docs")]
async fn delete(doc_ids: web::Json<Vec<i64>>, data: web::Data<AppState>) -> Result<HttpResponse, Error> {
for doc_id in doc_ids.iter() {
let _ = Mutation::delete_doc_info(&data.conn, *doc_id).await.unwrap();
}
let json_response = JsonResponse {
code: 200,
err: "".to_owned(),
data: (),
};
Ok(HttpResponse::Ok()
.content_type("application/json")
.body(serde_json::to_string(&json_response).unwrap()))
}
#[post("/v1.0/mv_docs")]
async fn mv(params: web::Json<MvParams>, data: web::Data<AppState>) -> Result<HttpResponse, Error> {
Mutation::mv_doc_info(&data.conn, params.dest_did, ¶ms.dids).await.unwrap();
let json_response = JsonResponse {
code: 200,
err: "".to_owned(),
data: (),
};
Ok(HttpResponse::Ok()
.content_type("application/json")
.body(serde_json::to_string(&json_response).unwrap()))
} |