use crate::{models::FileManagerEntry, CpanelClient, CpanelError};
use serde::Serialize;
use tokio::io::AsyncRead;
use tokio::io::AsyncReadExt as _;
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateFile {
pub path: String,
pub content: Option<String>,
pub overwrite: bool,
}
#[derive(Debug, Clone, Default, serde::Serialize)]
pub struct RenameFile {
pub source: String,
pub destination: String,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateDir {
pub path: String,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CompressFiles {
pub paths: Vec<String>,
pub archive_name: String,
}
impl CpanelClient {
pub async fn list_files(
&self,
user: &str,
path: &str,
) -> Result<Vec<FileManagerEntry>, CpanelError> {
let result: Vec<FileManagerEntry> = self
.uapi("Fileman", "listdir", &[("path", path), ("user", user)])
.await?;
Ok(result)
}
pub async fn create_file(&self, user: &str, create: &CreateFile) -> Result<(), CpanelError> {
let overwrite_str = create.overwrite.to_string();
let mut params: Vec<(&str, &str)> = vec![
("path", &create.path),
("user", user),
("overwrite", &overwrite_str),
];
if let Some(content) = &create.content {
params.push(("content", content.as_str()));
}
let _: () = self.uapi("Fileman", "create_file", ¶ms).await?;
Ok(())
}
pub async fn delete_file(&self, user: &str, path: &str) -> Result<(), CpanelError> {
let _: () = self
.uapi("Fileman", "delete", &[("path", path), ("user", user)])
.await?;
Ok(())
}
pub async fn rename_file(&self, user: &str, rename: &RenameFile) -> Result<(), CpanelError> {
let _: () = self
.uapi(
"Fileman",
"rename",
&[
("path", &rename.source),
("newpath", &rename.destination),
("user", user),
],
)
.await?;
Ok(())
}
pub async fn copy_file(
&self,
user: &str,
source: &str,
destination: &str,
) -> Result<(), CpanelError> {
let _: () = self
.uapi(
"Fileman",
"copy",
&[("source", source), ("dest", destination), ("user", user)],
)
.await?;
Ok(())
}
pub async fn chmod(&self, user: &str, path: &str, mode: &str) -> Result<(), CpanelError> {
let _: () = self
.uapi(
"Fileman",
"chmod",
&[("path", path), ("mode", mode), ("user", user)],
)
.await?;
Ok(())
}
pub async fn mkdir(&self, user: &str, create: &CreateDir) -> Result<(), CpanelError> {
let _: () = self
.uapi(
"Fileman",
"mkdir",
&[("path", &create.path), ("user", user)],
)
.await?;
Ok(())
}
pub async fn download_file(&self, user: &str, path: &str) -> Result<Vec<u8>, CpanelError> {
let url = format!(
"{}/json-api/cpanel?cpanel_jsonapi_module=Fileman&cpanel_jsonapi_apiversion=2&cpanel_jsonapi_func=getfile&user={}&path={}",
self.base_url(),
urlencoding::encode(user),
urlencoding::encode(path),
);
let response = self
.http_client()
.get(&url)
.headers(self.auth_headers())
.send()
.await?;
Ok(response.bytes().await?.to_vec())
}
pub async fn upload_file_from_reader<R: AsyncRead + Unpin>(
&self,
user: &str,
path: &str,
reader: &mut R,
filename: &str,
_chunk_size: usize,
) -> Result<(), CpanelError> {
let path_owned = path.to_string();
let filename_owned = filename.to_string();
let url = format!(
"{}/json-api/cpanel?cpanel_jsonapi_module=Fileman&cpanel_jsonapi_apiversion=2&cpanel_jsonapi_func=uploadfile&user={}",
self.base_url(),
urlencoding::encode(user),
);
let mut buf = Vec::new();
reader.read_to_end(&mut buf).await?;
let form = reqwest::multipart::Form::new()
.part("path", reqwest::multipart::Part::text(path_owned))
.part(
"file",
reqwest::multipart::Part::bytes(buf).file_name(filename_owned),
);
let response = self
.http_client()
.post(&url)
.headers(self.auth_headers())
.multipart(form)
.send()
.await?;
let text: String = response.text().await?;
let api_resp: crate::types::ApiResponse<serde_json::Value> =
serde_json::from_str(&text).map_err(CpanelError::Serialization)?;
if !api_resp.is_ok() {
return Err(CpanelError::ApiError(crate::types::ApiFailure {
message: api_resp.status_msg,
call: "Fileman.uploadfile".into(),
..Default::default()
}));
}
Ok(())
}
pub async fn upload_file(
&self,
user: &str,
path: &str,
content: &[u8],
filename: &str,
) -> Result<(), CpanelError> {
let path_owned = path.to_string();
let filename_owned = filename.to_string();
let form = reqwest::multipart::Form::new()
.part("path", reqwest::multipart::Part::text(path_owned))
.part(
"file",
reqwest::multipart::Part::bytes(content.to_vec()).file_name(filename_owned),
);
let url = format!(
"{}/json-api/cpanel?cpanel_jsonapi_module=Fileman&cpanel_jsonapi_apiversion=2&cpanel_jsonapi_func=uploadfile&user={}",
self.base_url(),
urlencoding::encode(user),
);
let response = self
.http_client()
.post(&url)
.headers(self.auth_headers())
.multipart(form)
.send()
.await?;
let text: String = response.text().await?;
let api_resp: crate::types::ApiResponse<serde_json::Value> =
serde_json::from_str(&text).map_err(CpanelError::Serialization)?;
if !api_resp.is_ok() {
return Err(CpanelError::ApiError(crate::types::ApiFailure {
message: api_resp.status_msg,
call: "Fileman.uploadfile".into(),
..Default::default()
}));
}
Ok(())
}
pub async fn compress(&self, user: &str, compress: &CompressFiles) -> Result<(), CpanelError> {
let paths_json =
serde_json::to_string(&compress.paths).map_err(CpanelError::Serialization)?;
let _: () = self
.uapi(
"Fileman",
"compress",
&[
("paths", &paths_json),
("name", &compress.archive_name),
("user", user),
],
)
.await?;
Ok(())
}
pub async fn extract(
&self,
user: &str,
archive_path: &str,
dest_path: &str,
) -> Result<(), CpanelError> {
let _: () = self
.uapi(
"Fileman",
"extract",
&[
("path", archive_path),
("destpath", dest_path),
("user", user),
],
)
.await?;
Ok(())
}
}