# MikrotikLite
 
 A Rust library for interacting with Mikrotik routers.
 
 ## Features
 
 * **Simple and easy-to-use:** The library provides a simple and straightforward interface for interacting with Mikrotik routers.
 * **Asynchronous:** The library is asynchronous, making it efficient for long-running operations.
 * **Does not support event listening:** The library does not support event listening. This is because it would make the library more complex and difficult to use. It would also create problems when working with concurrency. In the future, event listening may be added, but it is not currently planned.
 ## Example: Retrieving Data in JSON Format
 
 ```no_run
 use mikrotik_lite::MikrotikLite;
 
 let mut api = MikrotikLite::new(
     "api_login".to_string(),
     "api_pass".to_string(),
     "10.80.80.1:8728".to_string(),
 ).unwrap();
 
 // Get the current user identity.
 let identity_json = api.send_command_json("/system/identity/print".to_string(), None).unwrap();
 
 // Print the JSON string.
 println!("{}", identity_json);
 ```
 
 You can predefine a structure and parse the response into that structure:
 
 ```no_run
 use serde::Deserialize;
 use mikrotik_lite::MikrotikLite;
 
 // `Identity` struct
 #[derive(Debug, Deserialize)]
 struct Identity {
     pub name: String
 }
 
 let mut api = MikrotikLite::new(
     "api_login".to_string(),
     "api_pass".to_string(),
     "10.80.80.1:8728".to_string(),
 ).unwrap();
 
 let identity = api.send_command::<Identity>(
     "/system/identity/print".to_string(),
     None
 ).unwrap();
 
 println!("{:#?}", identity);
 ```
 
 This library does not provide predefined structures, but you can easily create your own structures by sending requests through `send_command_json` and creating structures based on the fields you need. Serialization and deserialization are handled using the `serde` library. There are some considerations for handling specific field types, as MikroTik does not provide type markers in their responses. You should use `deserialize_bool_from_anything` for Boolean values and `deserialize_string_from_number` for numeric values.
 
 
 Handling Boolean values
 #[serde(deserialize_with = "deserialize_bool_from_anything")]
 
  Handling numeric values
 #[serde(deserialize_with = "deserialize_string_from_number")]
 
 
 Additionally, some field names do not follow Rust naming conventions and should be renamed using the `serde(rename = "dst-address")` attribute.
 
 In the `examples` directory, you can find usage examples for the library.
 
 All methods have asynchronous counterparts with `_async` suffixes, allowing you to use Tokio for concurrent requests. Here's an example:
 
 ```no_run
 use mikrotik_lite::MikrotikLite;
 
 let mut api1 = MikrotikLite::new(
     "api_login".to_string(),
     "api_pass".to_string(),
     "10.80.80.1:8728".to_string(),
 ).unwrap();
 
 let mut api2 = MikrotikLite::new(
     "api_login".to_string(),
     "api_pass".to_string(),
     "10.80.80.1:8728".to_string(),
 ).unwrap();
 
 let route_future = api1.send_command_json_async(
     "/ip/route/print".to_string(),
     None
 );
 
 let identity_future = api2.send_command_json_async(
     "/system/identity/print".to_string(),
     None
 );
 async {
     let (route, identity) = tokio::join!(route_future, identity_future);
 
     println!("{}", route.unwrap());
     println!("{}", identity.unwrap());
 };
 ```
 
 You can pass parameters with your commands like this:
 
 ```no_run
 use std::collections::HashMap;
 use mikrotik_lite::MikrotikLite;
 
 let mut api = MikrotikLite::new(
     "api_login".to_string(),
     "api_pass".to_string(),
     "10.80.80.1:8728".to_string(),
 ).unwrap();
 
 let mut attr = HashMap::new();
 attr.insert("address".to_string(), "8.8.8.8".to_string());
 attr.insert("count".to_string(), "5".to_string());
 
 let ping = api.send_command_json(
     "/ping".to_string(),
     Some(attr.clone())
 ).unwrap();
 
 println!("{}", ping);
 ```