mikrotik 0.0.15

REST API Wrapper for Mikrotik API
Documentation 
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

pub use crate::ip::types::{AddAddressInput, AddAddressOutput, Address};
use crate::{Client, ClientError};
use serde::{Deserialize, Serialize};

/// list all configurd ipv4 addresses
pub async fn list(client: &mut Client) -> Result<Vec<Address>, ClientError> {
    let url = format!("{}/address", super::BASE);

    client.execute_get::<Vec<Address>>(&url).await
}

/// get details of a specific ipv4 address
pub async fn get(client: &mut Client, aid: &str) -> Result<Address, ClientError> {
    let url = format!("{}/address/{}", super::BASE, aid);

    client.execute_get::<Address>(&url).await
}

pub async fn add(
    client: &mut Client,
    input: AddAddressInput,
) -> Result<AddAddressOutput, ClientError> {
    let url = format!("{}/address/add", super::BASE);

    client
        .execute_post::<AddAddressInput, AddAddressOutput>(&url, input)
        .await
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
struct RemoveAddressInput {
    pub numbers: String,
}

pub async fn remove(client: &mut Client, id: &str) -> Result<(), ClientError> {
    let url = format!("{}/address/remove", super::BASE);

    client
        .execute_post_with_no_response::<RemoveAddressInput>(
            &url,
            RemoveAddressInput {
                numbers: id.to_string(),
            },
        )
        .await
}

#[cfg(test)]
mod test {
    use super::*;
    use reqwest::Url;

    #[tokio::test]
    async fn remove_address() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "pia".to_string(), "qwertyuiop".to_string(), true)
            .expect("error in creating client");

        let response = crate::ip::address::add(
            &mut client,
            AddAddressInput {
                address: "10.20.0.1/24".to_string(),
                disabled: false,
                interface: "pia".to_string(),
                ..Default::default()
            },
        )
        .await?;

        crate::ip::address::remove(&mut client, &response.ret).await?;

        Ok(())
    }

    #[tokio::test]
    async fn add_address() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "pia".to_string(), "qwertyuiop".to_string(), true)
            .expect("error in creating client");

        let response = crate::ip::address::add(
            &mut client,
            AddAddressInput {
                address: "10.20.0.1/24".to_string(),
                disabled: false,
                interface: "pia".to_string(),
                ..Default::default()
            },
        )
        .await?;

        println!("{:?}", response);

        Ok(())
    }

    #[tokio::test]
    async fn list_address() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true)
            .expect("error in creating client");

        let response = crate::ip::address::list(&mut client).await?;

        println!("{:?}", response);

        Ok(())
    }

    #[tokio::test]
    async fn get_address() -> Result<(), ClientError> {
        let base = Url::parse("https://10.0.10.1")?;
        let mut client = Client::new(base, "admin".to_string(), "ifd783far".to_string(), true)
            .expect("error in creating client");

        let response = crate::ip::address::list(&mut client).await?;

        let response = crate::ip::address::get(&mut client, &response[0].id).await?;

        println!("{:?}", response);

        Ok(())
    }
}