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
128
129
130
131
132
133
134
135
136
137
138
use serde::de::DeserializeOwned;
use serde::Serialize;

use crate::client::jsonrpc::ZabbixApiResponse;
use crate::error::ZabbixApiError;
use crate::host::{ZabbixHost, ZabbixHostGroup};
use crate::host::create::{CreateHostGroupRequest, CreateHostRequest};
use crate::item::create::CreateItemRequest;
use crate::item::ZabbixItem;
use crate::trigger::create::CreateTriggerRequest;
use crate::trigger::ZabbixTrigger;
use crate::webscenario::create::CreateWebScenarioRequest;
use crate::webscenario::ZabbixWebScenario;

pub mod jsonrpc;
pub mod v6;
pub mod post;

pub trait ZabbixApiClient {
    /// API: https://www.zabbix.com/documentation/6.0/en/manual/api/reference/apiinfo/version
    fn get_api_info(&self) -> Result<String, ZabbixApiError>;

    fn get_auth_session(&self, login: &str, token: &str) -> Result<String, ZabbixApiError>;

    fn raw_api_call<P: Serialize, R: DeserializeOwned>(&self, session: &str, method: &str, params: &P) -> Result<ZabbixApiResponse<R>, ZabbixApiError>;

    fn get_host_groups<P: Serialize>(&self, session: &str, params: &P) -> Result<Vec<ZabbixHostGroup>, ZabbixApiError>;

    /// # get_hosts
    ///
    /// Find zabbix hosts.
    ///
    /// API: https://www.zabbix.com/documentation/6.0/en/manual/api/reference/host/get
    ///
    /// **Example:**
    ///
    /// ```rust
    /// use reqwest::blocking::Client;
    /// use zabbix_api::host::get::GetHostsRequest;
    /// use serde::Serialize;
    /// use zabbix_api::client::v6::ZabbixApiV6Client;
    /// use zabbix_api::client::ZabbixApiClient;
    ///
    /// #[derive(Serialize)]
    /// struct Filter {
    ///   pub host: Vec<String>
    /// }
    ///
    /// let request = GetHostsRequest {
    ///     filter: Filter {
    ///     host: vec!["srv-1203".to_string()],
    ///   },
    /// };
    ///
    /// let http_client = Client::new();
    ///
    /// let zabbix_server = env!("ZABBIX_API_URL");
    ///
    /// let client = ZabbixApiV6Client::new(http_client, &zabbix_server);
    ///
    /// let session = client.get_auth_session("Admin", "zabbix").unwrap();
    /// let hosts = client.get_hosts(&session, &request).unwrap();
    /// ```
    fn get_hosts<P: Serialize>(&self, session: &str, params: &P) -> Result<Vec<ZabbixHost>, ZabbixApiError>;


    /// # get_items
    ///
    /// Find zabbix items.
    ///
    /// API: https://www.zabbix.com/documentation/6.0/en/manual/api/reference/item/get
    fn get_items<P: Serialize>(&self, session: &str, params: &P) -> Result<Vec<ZabbixItem>, ZabbixApiError>;

    fn get_triggers<P: Serialize>(&self, session: &str, params: &P) -> Result<Vec<ZabbixTrigger>, ZabbixApiError>;

    fn get_webscenarios<P: Serialize>(&self, session: &str, params: &P) -> Result<Vec<ZabbixWebScenario>, ZabbixApiError>;

    fn create_host_group(&self, session: &str, request: &CreateHostGroupRequest) -> Result<u32, ZabbixApiError>;

    /// # create_host
    ///
    /// Create zabbix host.
    ///
    /// API: https://www.zabbix.com/documentation/6.0/en/manual/api/reference/host/create
    ///
    /// **Example:**
    ///
    /// ```rust
    /// use std::collections::HashMap;
    /// use fake::{Fake, Faker};
    /// use reqwest::blocking::Client;
    /// use zabbix_api::host::get::{GetHostGroupsRequest, GetHostsRequest};
    /// use serde::Serialize;
    /// use zabbix_api::client::v6::ZabbixApiV6Client;
    /// use zabbix_api::client::ZabbixApiClient;
    /// use zabbix_api::host::create::{CreateHostGroupRequest, CreateHostRequest};
    /// use zabbix_api::ZABBIX_EXTEND_PROPERTY_VALUE;
    ///
    /// let http_client = Client::new();
    ///
    /// let zabbix_server = env!("ZABBIX_API_URL");
    ///
    /// let client = ZabbixApiV6Client::new(http_client, &zabbix_server);
    ///
    /// let session = client.get_auth_session("Admin", "zabbix").unwrap();
    ///
    /// let filter: HashMap<String,String> = HashMap::new();
    ///
    /// let request = GetHostGroupsRequest {
    ///     output: ZABBIX_EXTEND_PROPERTY_VALUE.to_string(),
    ///     filter
    /// };
    ///
    /// let host_groups = client.get_host_groups(&session, &request).unwrap();
    /// let host_group = host_groups.first().unwrap().clone();
    /// let host_name = Faker.fake::<String>();
    ///
    /// let request = CreateHostRequest {
    ///     host: host_name,
    ///     groups: vec![host_group],
    ///     interfaces: vec![],
    ///     tags: vec![],
    ///     templates: vec![],
    ///     macros: vec![],
    ///     inventory_mode: 0,
    ///     inventory: Default::default(),
    /// };
    ///
    /// client.create_host(&session, &request).unwrap();
    /// ```
    fn create_host(&self, session: &str, request: &CreateHostRequest) -> Result<u32, ZabbixApiError>;

    fn create_item(&self, session: &str, request: &CreateItemRequest) -> Result<u32, ZabbixApiError>;

    fn create_trigger(&self, session: &str, request: &CreateTriggerRequest) -> Result<u32, ZabbixApiError>;

    fn create_webscenario(&self, session: &str, request: &CreateWebScenarioRequest) -> Result<u32, ZabbixApiError>;
}