added private endpoints working

Author: Bircoder432

examples/private_endpoints.rs

@@ -0,0 +1,64 @@
+use osars::{
+    CallRequest, Client, CreateParserRequest, LessonRequest, UpdateCallsRequest,
+    UpdateGroupsRequest, UpdateLessonsRequest,
+};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = Client::new("https://api.thisishyum.ru/schedule_api/tyumen");
+
+    // Authenticated client with token
+    let auth_client = client.authenticated().with_token("your_token_here");
+
+    // Work with admin Endpoints
+    let admin_api = auth_client.admin();
+
+    // Create parser
+    let create_request = CreateParserRequest {
+        college_name: "TKPST".to_string(),
+        campus_names: vec!["Lunacharskogo".to_string(), "Samartseva".to_string()],
+    };
+
+    let response = admin_api.create_parser(create_request).await?;
+    println!("Created parser with token: {}", response.token);
+
+    // Remove parser
+    admin_api.delete_parser(123).await?;
+    println!("Parser deleted");
+
+    // Work with parser
+    let parser_api = auth_client.parser();
+
+    // Update groups
+    let groups_request = UpdateGroupsRequest {
+        campus_id: 1,
+        student_group_names: vec!["Group A".to_string(), "Group B".to_string()],
+    };
+    parser_api.update_groups(groups_request).await?;
+
+    // Update call schedule
+    let calls_request = UpdateCallsRequest {
+        calls: vec![CallRequest {
+            weekday: 1,
+            begins: "09:00:00".to_string(),
+            ends: "10:30:00".to_string(),
+            order: 1,
+        }],
+    };
+    parser_api.update_calls(calls_request).await?;
+
+    // Add lessons
+    let lessons_request = UpdateLessonsRequest {
+        lessons: vec![LessonRequest {
+            group_id: 1,
+            order: 1,
+            title: "Mathematics".to_string(),
+            teacher: "Dr. Smith".to_string(),
+            cabinet: "Room 101".to_string(),
+            date: "2023-10-01".to_string(),
+        }],
+    };
+    parser_api.add_lessons(lessons_request).await?;
+
+    Ok(())
+}

src/api/admin.rs

@@ -0,0 +1,32 @@
+use crate::{AuthenticatedClient, CreateParserRequest, CreateParserResponse, error::Result};
+
+pub struct AdminApi {
+    client: AuthenticatedClient,
+}
+
+impl AdminApi {
+    pub fn new(client: AuthenticatedClient) -> Self {
+        Self { client }
+    }
+
+    /// Create a new parser
+    pub async fn create_parser(
+        &self,
+        request: CreateParserRequest,
+    ) -> Result<CreateParserResponse> {
+        let path = "/admin/parser";
+        self.client
+            .client
+            .post_json(path, Some(&request), Some(&self.client.auth))
+            .await
+    }
+
+    /// Delete a parser
+    pub async fn delete_parser(&self, parser_id: u32) -> Result<()> {
+        let path = format!("/admin/parser/{}", parser_id);
+        self.client
+            .client
+            .delete_json(&path, Some(&self.client.auth))
+            .await
+    }
+}

src/api/mod.rs

@@ -1,10 +1,14 @@
+pub mod admin;
 pub mod colleges;
 pub mod groups;
+pub mod parser;
 pub mod schedules;
 
+pub use admin::AdminApi;
 pub use colleges::CampusQuery;
 pub use colleges::CampusesQuery;
 pub use colleges::CollegeQuery;
 pub use colleges::CollegesQuery;
 pub use groups::GroupsQuery;
+pub use parser::ParserApi;
 pub use schedules::ScheduleQuery;

src/api/parser.rs

@@ -0,0 +1,41 @@
+use crate::{
+    AuthenticatedClient, UpdateCallsRequest, UpdateGroupsRequest, UpdateLessonsRequest,
+    error::Result,
+};
+
+pub struct ParserApi {
+    client: AuthenticatedClient,
+}
+
+impl ParserApi {
+    pub fn new(client: AuthenticatedClient) -> Self {
+        Self { client }
+    }
+
+    /// Update groups for a campus
+    pub async fn update_groups(&self, request: UpdateGroupsRequest) -> Result<()> {
+        let path = "/parser/groups";
+        self.client
+            .client
+            .post_json(path, Some(&request), Some(&self.client.auth))
+            .await
+    }
+
+    /// Update call schedule
+    pub async fn update_calls(&self, request: UpdateCallsRequest) -> Result<()> {
+        let path = "/parser/calls";
+        self.client
+            .client
+            .post_json(path, Some(&request), Some(&self.client.auth))
+            .await
+    }
+
+    /// Add lessons
+    pub async fn add_lessons(&self, request: UpdateLessonsRequest) -> Result<()> {
+        let path = "/parser/lessons";
+        self.client
+            .client
+            .post_json(path, Some(&request), Some(&self.client.auth))
+            .await
+    }
+}

src/auth.rs

@@ -0,0 +1,63 @@
+use crate::AdminApi;
+use crate::ParserApi;
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct Auth {
+    pub token: Option<String>,
+}
+
+impl Auth {
+    pub fn new(token: Option<String>) -> Self {
+        Self { token }
+    }
+
+    pub fn with_token(mut self, token: &str) -> Self {
+        self.token = Some(token.to_string());
+        self
+    }
+
+    pub fn clear_token(mut self) -> Self {
+        self.token = None;
+        self
+    }
+
+    pub(crate) fn apply_to_request(
+        &self,
+        request: reqwest::RequestBuilder,
+    ) -> reqwest::RequestBuilder {
+        if let Some(token) = &self.token {
+            request.bearer_auth(token)
+        } else {
+            request
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct AuthenticatedClient {
+    pub client: crate::Client,
+    pub auth: Auth,
+}
+
+impl AuthenticatedClient {
+    pub fn new(client: crate::Client) -> Self {
+        Self {
+            client,
+            auth: Auth::new(None),
+        }
+    }
+
+    pub fn with_token(mut self, token: &str) -> Self {
+        self.auth = self.auth.with_token(token);
+        self
+    }
+
+    pub fn admin(&self) -> AdminApi {
+        AdminApi::new(self.clone())
+    }
+
+    pub fn parser(&self) -> ParserApi {
+        ParserApi::new(self.clone())
+    }
+}

src/client.rs

@@ -1,3 +1,8 @@
+use crate::Auth;
+use crate::api::{CampusQuery, CampusesQuery, CollegeQuery, CollegesQuery};
+use crate::auth::AuthenticatedClient;
+use crate::error::Result;
+use crate::{GroupsQuery, ScheduleQuery, error::Error};
 /// A client for interacting with the educational schedule API.
 ///
 /// The `Client` provides methods to query colleges, campuses, groups, and schedules.
@@ -14,10 +19,6 @@
 #[cfg(feature = "logging")]
 use tracing::{debug, error};
 
-use crate::api::{CampusQuery, CampusesQuery, CollegeQuery, CollegesQuery};
-use crate::error::Result;
-use crate::{GroupsQuery, ScheduleQuery, error::Error};
-
 #[derive(Debug, Clone)]
 pub struct Client {
     pub(crate) base_url: String,
@@ -216,6 +217,95 @@ impl Client {
             ))
         }
     }
+    pub(crate) async fn post_json<T, B>(
+        &self,
+        path: &str,
+        body: Option<&B>,
+        auth: Option<&Auth>,
+    ) -> Result<T>
+    where
+        T: serde::de::DeserializeOwned,
+        B: serde::Serialize,
+    {
+        let url = format!("{}{}", self.base_url, path);
+        #[cfg(feature = "logging")]
+        debug!("POST {}", url);
+
+        let mut request = self.http_client.post(&url);
+
+        if let Some(auth) = auth {
+            request = auth.apply_to_request(request);
+        }
+
+        if let Some(body) = body {
+            request = request.json(body);
+        }
+
+        let response = request.send().await.map_err(crate::error::Error::Reqwest)?;
+
+        self.handle_response(response).await
+    }
+
+    pub(crate) async fn delete_json<T>(&self, path: &str, auth: Option<&Auth>) -> Result<T>
+    where
+        T: serde::de::DeserializeOwned,
+    {
+        let url = format!("{}{}", self.base_url, path);
+        #[cfg(feature = "logging")]
+        debug!("DELETE {}", url);
+
+        let mut request = self.http_client.delete(&url);
+
+        if let Some(auth) = auth {
+            request = auth.apply_to_request(request);
+        }
+
+        let response = request.send().await.map_err(crate::error::Error::Reqwest)?;
+
+        self.handle_response(response).await
+    }
+
+    async fn handle_response<T>(&self, response: reqwest::Response) -> Result<T>
+    where
+        T: serde::de::DeserializeOwned,
+    {
+        let status = response.status();
+        let raw_body = response
+            .text()
+            .await
+            .map_err(crate::error::Error::Reqwest)?;
+
+        #[cfg(feature = "logging")]
+        {
+            if status.is_success() {
+                debug!("Success {}: raw response = {}", status, raw_body);
+            } else {
+                error!("API error {}: raw response = {}", status, raw_body);
+            }
+        }
+
+        if status.is_success() {
+            if raw_body.is_empty() {
+                // Handle empty response for DELETE and some POST requests
+                serde_json::from_str("null").map_err(|e| {
+                    #[cfg(feature = "logging")]
+                    error!("JSON parse error for empty response: {}", e);
+                    crate::error::Error::Serialization(e)
+                })
+            } else {
+                serde_json::from_str(&raw_body).map_err(|e| {
+                    #[cfg(feature = "logging")]
+                    error!("JSON parse error: {}\nRaw body: {}", e, raw_body);
+                    crate::error::Error::Serialization(e)
+                })
+            }
+        } else {
+            Err(crate::error::Error::from_response(
+                status.as_u16(),
+                raw_body,
+            ))
+        }
+    }
 
     /// Creates a query to list groups for a campus.
     ///
@@ -252,6 +342,10 @@ impl Client {
     pub fn tomorrow(&self, group_id: u32) -> ScheduleQuery {
         self.schedule(group_id).tomorrow()
     }
+    /// Create an authenticated client for private endpoints
+    pub fn authenticated(&self) -> AuthenticatedClient {
+        AuthenticatedClient::new(self.clone())
+    }
 }
 
 #[cfg(test)]

src/lib.rs

@@ -1,11 +1,13 @@
 pub mod api;
+pub mod auth;
 pub mod client;
 pub mod error;
 pub mod logging;
 pub mod models;
 pub mod utils;
 
 pub use api::*;
+pub use auth::*;
 pub use client::*;
 pub use error::{Error, Result};
 pub use models::*;

src/models/mod.rs

@@ -11,6 +11,7 @@ pub use campus::Campus;
 pub use college::College;
 pub use group::Group;
 pub use lesson::Lesson;
+pub use requests::*;
 pub use schedule::Schedule;
 use std::fmt;