broke down modules and renamed them

1 files changed, 0 insertions, 449 deletions

diff --git a/src/client_async.rs b/src/client_async.rs
deleted file mode 100644
index c189a06..0000000
--- a/src/client_async.rs
+++ /dev/null
@@ -1,449 +0,0 @@
-use std::{collections::HashMap, path::PathBuf};
-
-use async_trait::async_trait;
-use reqwest::{Body, RequestBuilder};
-use serde::Deserialize;
-use tokio_util::codec::{BytesCodec, FramedRead};
-
-use crate::{traits_async::*, types::*};
-
-type Result<T> = std::result::Result<T, HydrusError>;
-
-/// hydrus client
-pub struct HydrusClient {
-    client: reqwest::Client,
-    apikey: Option<String>,
-    sessionkey: Option<String>,
-    url: String,
-}
-
-impl HydrusClient {
-    /// create a new hydurs client object. requires a url to hydrus API endpoint
-    pub fn new(url: &str) -> HydrusClient {
-        HydrusClient {
-            client: reqwest::Client::new(),
-            apikey: None,
-            sessionkey: None,
-            url: url.to_string(),
-        }
-    }
-    /// set an api key
-    pub fn set_api_key(&mut self, key: &str) {
-        self.apikey = Some(key.to_owned())
-    }
-    /// set a session key
-    pub fn set_session_key(&mut self, key: &str) {
-        self.sessionkey = Some(key.to_owned())
-    }
-
-    fn set_get_request_key(&self, url: &str) -> Result<RequestBuilder> {
-        let request = self.client.get(url);
-        if let Some(key) = &self.sessionkey {
-            Ok(request.header("Hydrus-Client-API-Access-Key", key))
-        } else if let Some(key) = &self.apikey {
-            Ok(request.header("Hydrus-Client-API-Access-Key", key))
-        } else {
-            Err(HydrusError::KeyNotSupplied)
-        }
-    }
-
-    fn set_post_request_key(&self, url: &str) -> Result<RequestBuilder> {
-        let request = self.client.post(url);
-        if let Some(key) = &self.sessionkey {
-            Ok(request.header("Hydrus-Client-API-Access-Key", key))
-        } else if let Some(key) = &self.apikey {
-            Ok(request.header("Hydrus-Client-API-Access-Key", key))
-        } else {
-            Err(HydrusError::KeyNotSupplied)
-        }
-    }
-}
-
-#[derive(Deserialize, Debug)]
-struct HydrusResponse<T> {
-    #[serde(
-        alias = "service",
-        alias = "services",
-        alias = "access_key",
-        alias = "session_key"
-    )]
-    body: T,
-}
-
-#[async_trait]
-impl AccessManagement for HydrusClient {
-    async fn request_new_permissions(
-        &self,
-        name: &str,
-        permissions: &[HydrusPermissions],
-    ) -> Result<String> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("request_new_permissions");
-
-        let mut request = self.client.get(req_url);
-        request = request.query(&[("name", &urlencoding::encode(name))]);
-
-        if permissions.is_empty() {
-            request = request.query(&[("permit_everything", "true")]);
-        } else {
-            let json_string = serde_json::to_string(&permissions)?;
-            request = request.query(&[("basic_permissions", &urlencoding::encode(&json_string))]);
-        };
-
-        Ok(request
-            .send()
-            .await?
-            .json::<HydrusResponse<String>>()
-            .await?
-            .body)
-    }
-
-    async fn get_session_key(&self) -> Result<String> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("session_key");
-
-        let mut request = self.client.get(req_url);
-
-        if let Some(key) = &self.apikey {
-            request = request.header("Hydrus-Client-API-Access-Key", key);
-        }
-
-        Ok(request
-            .send()
-            .await?
-            .json::<HydrusResponse<String>>()
-            .await?
-            .body)
-    }
-
-    async fn verify_access_key(&self, key: &str) -> Result<KeyInfo> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("verify_access_key");
-
-        Ok(self
-            .client
-            .get(req_url)
-            .header("Hydrus-Client-API-Access-Key", key)
-            .send()
-            .await?
-            .json::<KeyInfo>()
-            .await?)
-    }
-
-    async fn get_service_name(&self, name: &str) -> Result<Service> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("get_service");
-        let mut request = self.set_get_request_key(&req_url)?;
-        request = request.query(&[("service_name", &urlencoding::encode(name))]);
-
-        Ok(request
-            .send()
-            .await?
-            .json::<HydrusResponse<Service>>()
-            .await?
-            .body)
-    }
-
-    async fn get_service_key(&self, key: &str) -> Result<Service> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("get_service");
-        let mut request = self.set_get_request_key(&req_url)?;
-        request = request.query(&[("service_key", &urlencoding::encode(key))]);
-
-        Ok(request
-            .send()
-            .await?
-            .json::<HydrusResponse<Service>>()
-            .await?
-            .body)
-    }
-
-    async fn get_services(&self) -> Result<HashMap<String, Service>> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("get_services");
-
-        let mut services = self
-            .set_get_request_key(&req_url)?
-            .send()
-            .await?
-            .json::<HydrusResponse<HashMap<String, Service>>>()
-            .await?
-            .body;
-
-        for (key, service) in services.iter_mut() {
-            service.service_key = key.to_string();
-        }
-
-        Ok(services)
-    }
-}
-
-#[async_trait]
-impl ImportingAndDeletingFiles for HydrusClient {
-    async fn add_file_via_path(
-        &self,
-        path: PathBuf,
-        delete: Option<bool>,
-        domains: Option<FileDomain>,
-    ) -> Result<AddFileResponse> {
-        let mut form = AddFileRequest {
-            path: path.to_owned(),
-            delete_after_successful_import: delete,
-            ..Default::default()
-        };
-
-        if let Some(file_domain) = domains {
-            match file_domain {
-                FileDomain::FileServiceKey(key) => form.file_service_key = Some(key.to_string()),
-                FileDomain::FileServiceKeys(keys) => form.file_service_keys = Some(keys.to_owned()),
-                FileDomain::DeletedFileServiceKey(key) => {
-                    form.deleted_file_service_key = Some(key.to_string())
-                }
-                FileDomain::DeletedFileServiceKeys(keys) => {
-                    form.deleted_file_service_keys = Some(keys.to_owned())
-                }
-            }
-        }
-
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/add_file");
-
-        Ok(self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/json")
-            .json(&form)
-            .send()
-            .await?
-            .json::<AddFileResponse>()
-            .await?)
-    }
-
-    async fn add_file_via_file(&self, file: PathBuf) -> Result<AddFileResponse> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/add_file");
-
-        let file = tokio::fs::File::open(file).await?;
-
-        let stream = FramedRead::new(file, BytesCodec::new());
-        let body = Body::wrap_stream(stream);
-
-        Ok(self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/octet-stream")
-            .body(body)
-            .send()
-            .await?
-            .json::<AddFileResponse>()
-            .await?)
-    }
-
-    async fn delete_files(
-        &self,
-        file: HydrusFile,
-        domain: Option<FileDomain>,
-        reason: Option<String>,
-    ) -> Result<()> {
-        let mut form = FileRequest {
-            file,
-            reason,
-            ..Default::default()
-        };
-
-        if let Some(file_domain) = domain {
-            match file_domain {
-                FileDomain::FileServiceKey(key) => form.file_service_key = Some(key.to_string()),
-                FileDomain::FileServiceKeys(keys) => form.file_service_keys = Some(keys.to_owned()),
-                FileDomain::DeletedFileServiceKey(key) => {
-                    form.deleted_file_service_key = Some(key.to_string())
-                }
-                FileDomain::DeletedFileServiceKeys(keys) => {
-                    form.deleted_file_service_keys = Some(keys.to_owned())
-                }
-            }
-        }
-
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/delete_files");
-
-        let _ = self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/json")
-            .json(&form)
-            .send()
-            .await?;
-
-        Ok(())
-    }
-
-    async fn undelete_files(&self, file: HydrusFile, domain: Option<FileDomain>) -> Result<()> {
-        let mut form = FileRequest {
-            file,
-            ..Default::default()
-        };
-
-        if let Some(file_domain) = domain {
-            match file_domain {
-                FileDomain::FileServiceKey(key) => form.file_service_key = Some(key.to_string()),
-                FileDomain::FileServiceKeys(keys) => form.file_service_keys = Some(keys.to_owned()),
-                FileDomain::DeletedFileServiceKey(key) => {
-                    form.deleted_file_service_key = Some(key.to_string())
-                }
-                FileDomain::DeletedFileServiceKeys(keys) => {
-                    form.deleted_file_service_keys = Some(keys.to_owned())
-                }
-            }
-        }
-
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/undelete_files");
-
-        let _ = self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/json")
-            .json(&form)
-            .send()
-            .await?;
-
-        Ok(())
-    }
-
-    async fn clear_file_deletion_records(&self, file: HydrusFile) -> Result<()> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/clear_file_deletion_record");
-        let _ = self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/json")
-            .json(&file)
-            .send()
-            .await?;
-
-        Ok(())
-    }
-
-    async fn migrate_files(&self, file: HydrusFile, domain: FileDomain) -> Result<()> {
-        let mut form = FileRequest {
-            file,
-            ..Default::default()
-        };
-
-        match domain {
-            FileDomain::FileServiceKey(key) => form.file_service_key = Some(key.to_string()),
-            FileDomain::FileServiceKeys(keys) => form.file_service_keys = Some(keys.to_owned()),
-            FileDomain::DeletedFileServiceKey(key) => {
-                form.deleted_file_service_key = Some(key.to_string())
-            }
-            FileDomain::DeletedFileServiceKeys(keys) => {
-                form.deleted_file_service_keys = Some(keys.to_owned())
-            }
-        }
-
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/migrate_files");
-        let _ = self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/json")
-            .json(&form)
-            .send()
-            .await?;
-
-        Ok(())
-    }
-
-    async fn archive_files(&self, file: HydrusFile) -> Result<()> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/archive_files");
-
-        let form = FileRequest {
-            file,
-            ..Default::default()
-        };
-
-        let _ = self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/json")
-            .json(&form)
-            .send()
-            .await?;
-
-        Ok(())
-    }
-
-    async fn unarchive_files(&self, file: HydrusFile) -> Result<()> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/unarchive_files");
-
-        let form = FileRequest {
-            file,
-            ..Default::default()
-        };
-
-        let _ = self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/json")
-            .json(&form)
-            .send()
-            .await?;
-
-        Ok(())
-    }
-
-    async fn generate_hashes_for_path(&self, file: PathBuf) -> Result<HashResponse> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/generate_hashes");
-
-        let form = AddFileRequest {
-            path: file.to_owned(),
-            ..Default::default()
-        };
-
-        Ok(self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/json")
-            .json(&form)
-            .send()
-            .await?
-            .json::<HashResponse>()
-            .await?)
-    }
-
-    async fn generate_hashes_for_file(&self, file: PathBuf) -> Result<HashResponse> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_files/generate_hashes");
-
-        let file = tokio::fs::File::open(file).await?;
-
-        let stream = FramedRead::new(file, BytesCodec::new());
-        let body = Body::wrap_stream(stream);
-
-        Ok(self
-            .set_post_request_key(&req_url)?
-            .header("Content-Type", "application/octet-stream")
-            .body(body)
-            .send()
-            .await?
-            .json::<HashResponse>()
-            .await?)
-    }
-}
-
-#[async_trait]
-impl ImportingAndEditingUrls for HydrusClient {
-    async fn get_url_files(
-        &self,
-        url: &str,
-        doublecheck_file_system: Option<bool>,
-    ) -> Result<FilesUrlResponse> {
-        let mut req_url = self.url.to_owned();
-        req_url.push_str("add_urls/get_url_files");
-
-        let mut request = self.set_get_request_key(&req_url)?;
-
-        request = request.query(&[("url", url)]);
-
-        if let Some(doublecheck) = doublecheck_file_system {
-            request = request.query(&[("doublecheck_file_system", doublecheck)]);
-        }
-
-        Ok(request.send().await?.json::<FilesUrlResponse>().await?)
-    }
-}