hydrus_api/wrapper/
hydrus.rs

1use crate::api_core::common::{FileIdentifier, ServiceIdentifier};
2use crate::api_core::endpoints::searching_and_fetching_files::FullMetadata;
3use crate::error::{Error, Result};
4use crate::wrapper::address::Address;
5use crate::wrapper::builders::delete_files_builder::DeleteFilesBuilder;
6use crate::wrapper::builders::import_builder::ImportBuilder;
7use crate::wrapper::builders::search_builder::SearchBuilder;
8use crate::wrapper::builders::tagging_builder::TaggingBuilder;
9use crate::wrapper::hydrus_file::HydrusFile;
10use crate::wrapper::page::HydrusPage;
11use crate::wrapper::service::Services;
12use crate::wrapper::url::Url;
13use crate::wrapper::version::Version;
14use crate::Client;
15use std::fmt::Debug;
16
17use super::builders::tag_search_builder::TagSearchBuilder;
18
19/// A high level wrapper for the hydrus API for easier management of files, tags
20/// urls etc.
21pub struct Hydrus {
22    client: Client,
23}
24
25impl Hydrus {
26    /// Creates a new high level Hydrus API client
27    pub fn new(client: Client) -> Self {
28        Self { client }
29    }
30
31    /// Returns the Hydrus and API Version
32    pub async fn version(&self) -> Result<Version> {
33        let response = self.client.api_version().await?;
34        Ok(Version {
35            api: response.version,
36            hydrus: response.hydrus_version,
37        })
38    }
39
40    /// Returns a list of available services
41    pub async fn services(&self) -> Result<Services> {
42        let response = self.client.get_services().await?;
43
44        Ok(Services::from_response(self.client.clone(), response))
45    }
46
47    /// Creates an import builder to build an import request to hydrus
48    pub fn import(&self) -> ImportBuilder {
49        ImportBuilder {
50            client: self.client.clone(),
51        }
52    }
53
54    /// Returns the address as an object that can be used to get and set cookies
55    pub fn address<S: AsRef<str> + Debug>(&self, address: S) -> Address {
56        Address::from_str(self.client.clone(), address.as_ref())
57    }
58
59    /// Returns information about a given url in an object that allows
60    /// further operations with that url
61    pub async fn url<S: AsRef<str> + Debug>(&self, url: S) -> Result<Url> {
62        let info = self.client.get_url_info(&url).await?;
63
64        Ok(Url {
65            client: self.client.clone(),
66            normalised_url: info.normalised_url,
67            url_type: info.url_type.into(),
68            match_name: info.match_name,
69            url: url.as_ref().to_string(),
70            can_parse: info.can_parse,
71        })
72    }
73
74    /// Returns a file by identifier to perform further operations on
75    pub async fn file(&self, identifier: FileIdentifier) -> Result<HydrusFile> {
76        let metadata = self
77            .client
78            .get_file_metadata_by_identifier::<FullMetadata>(identifier)
79            .await?;
80
81        Ok(HydrusFile::from_metadata(self.client.clone(), metadata))
82    }
83
84    /// Creates a builder to delete files
85    pub async fn delete(&self) -> DeleteFilesBuilder {
86        DeleteFilesBuilder::new(self.client.clone())
87    }
88
89    /// Starts a request to bulk add tags to files
90    pub fn tagging(&self) -> TaggingBuilder {
91        TaggingBuilder::new(self.client.clone())
92    }
93
94    /// Starts a request to search for files
95    pub fn search(&self) -> SearchBuilder {
96        SearchBuilder::new(self.client.clone())
97    }
98
99    /// Starts a search request for tags with additional filter options
100    pub fn search_tags<S: ToString>(&self, query: S) -> TagSearchBuilder {
101        TagSearchBuilder::new(self.client.clone(), query.to_string())
102    }
103
104    /// Returns a hydrus page by page key
105    pub async fn page<S: AsRef<str> + Debug>(&self, page_key: S) -> Result<HydrusPage> {
106        let info_response = self.client.get_page_info(page_key).await?;
107
108        Ok(HydrusPage::from_info(
109            self.client.clone(),
110            info_response.page_info,
111        ))
112    }
113
114    /// Returns the root page in the client
115    pub async fn root_page(&self) -> Result<HydrusPage> {
116        let pages_response = self.client.get_pages().await?;
117
118        Ok(HydrusPage::from_info(
119            self.client.clone(),
120            pages_response.pages,
121        ))
122    }
123
124    /// Sets the user agent hydrus uses for http requests
125    pub async fn set_user_agent<S: ToString + Debug>(&self, user_agent: S) -> Result<()> {
126        self.client.set_user_agent(user_agent).await
127    }
128
129    /// Returns the key for a given service identifier
130    pub async fn get_service_key(&self, service: ServiceIdentifier) -> Result<String> {
131        let key = match service {
132            ServiceIdentifier::Name(n) => self
133                .client
134                .get_services()
135                .await?
136                .other
137                .values()
138                .flatten()
139                .filter(|v| *v.name == n)
140                .next()
141                .ok_or_else(|| Error::Hydrus(String::from("Service not found")))?
142                .service_key
143                .clone(),
144            ServiceIdentifier::Key(k) => k,
145        };
146
147        Ok(key)
148    }
149}
hydrus_api/wrapper/hydrus.rs

hydrus_api/wrapper/
hydrus.rs
