shrupl/src/sharry/client.rs

use std::fmt;

use log::{debug, trace};
use thiserror::Error;

use super::api::{NewShareRequest, NewShareResponse, NotifyShareResponse};

pub type Result<T> = std::result::Result<T, ClientError>;

pub trait Client {
    fn share_create(&self, endpoint: &str, alias_id: &str, data: NewShareRequest)
    -> Result<String>;

    fn share_notify(&self, endpoint: &str, alias_id: &str) -> Result<()>;

    fn file_create(
        &self,
        endpoint: &str,
        alias_id: &str,
        file_name: &str,
        file_size: u64,
    ) -> Result<String>;

    fn file_patch(&self, patch_uri: &str, alias_id: &str, offset: u64, chunk: &[u8])
    -> Result<u64>;
}

#[derive(Debug, Error)]
pub enum ClientError {
    #[error("network request failed: {0}")]
    Request(String),

    #[error("response parsing failed: {0}")]
    ResponseParsing(String),

    #[error("unexpected response status: {actual} (expected {expected})")]
    ResponseStatus { actual: u16, expected: u16 },

    #[error("unexpected response content: {0}")]
    ResponseContent(String),
}

impl ClientError {
    fn req_err(msg: impl fmt::Display) -> Self {
        Self::Request(msg.to_string())
    }

    fn res_parse_err(msg: impl fmt::Display) -> Self {
        Self::ResponseParsing(msg.to_string())
    }

    fn res_check_status<T>(actual: T, expected: T) -> Result<()>
    where
        T: Into<u16> + Eq,
    {
        if actual == expected {
            Ok(())
        } else {
            Err(Self::ResponseStatus {
                actual: actual.into(),
                expected: expected.into(),
            })
        }
    }
}

impl Client for ureq::Agent {
    fn share_create(
        &self,
        endpoint: &str,
        alias_id: &str,
        data: NewShareRequest,
    ) -> Result<String> {
        // let endpoint = uri.get_endpoint("alias/upload/new");

        let mut res = self
            .post(endpoint)
            .header("Sharry-Alias", alias_id)
            .send_json(data)
            .map_err(ClientError::req_err)?;

        trace!("{endpoint:?} response: {res:?}");
        ClientError::res_check_status(res.status(), ureq::http::StatusCode::OK)?;

        let res = res
            .body_mut()
            .read_json::<NewShareResponse>()
            .map_err(ClientError::res_parse_err)?;

        debug!("{res:?}");

        if res.success && (res.message == "Share created.") {
            Ok(res.id)
        } else {
            Err(ClientError::ResponseContent(format!("{res:?}")))
        }
    }

    fn share_notify(&self, endpoint: &str, alias_id: &str) -> Result<()> {
        // let endpoint = uri.get_endpoint(format!("alias/mail/notify/{}", share_id));

        let mut res = self
            .post(endpoint)
            .header("Sharry-Alias", alias_id)
            .send_empty()
            .map_err(|e| ClientError::req_err(e))?;

        trace!("{endpoint:?} response: {res:?}");
        ClientError::res_check_status(res.status(), ureq::http::StatusCode::OK)?;

        let res = res
            .body_mut()
            .read_json::<NotifyShareResponse>()
            .map_err(|e| ClientError::res_parse_err(e))?;

        debug!("{res:?}");

        Ok(())
    }

    fn file_create(
        &self,
        endpoint: &str,
        alias_id: &str,
        file_name: &str,
        file_size: u64,
    ) -> Result<String> {
        // let endpoint = uri.get_endpoint(format!("alias/upload/{}/files/tus", share_id));

        let res = self
            .post(endpoint)
            .header("Sharry-Alias", alias_id)
            .header("Sharry-File-Name", file_name)
            .header("Upload-Length", file_size)
            .send_empty()
            .map_err(ClientError::req_err)?;

        trace!("{endpoint:?} response: {res:?}");
        ClientError::res_check_status(res.status(), ureq::http::StatusCode::CREATED)?;

        let location = (res.headers().get("Location"))
            .ok_or_else(|| ClientError::res_parse_err("Location header not found"))?
            .to_str()
            .map_err(ClientError::res_parse_err)?
            .to_string();

        debug!("{location:?}");

        Ok(location)
    }

    fn file_patch(
        &self,
        patch_uri: &str,
        alias_id: &str,
        offset: u64,
        chunk: &[u8],
    ) -> Result<u64> {
        let res = self
            .patch(patch_uri)
            .header("Sharry-Alias", alias_id)
            .header("Upload-Offset", offset)
            .send(chunk)
            .map_err(ClientError::req_err)?;

        trace!("{patch_uri:?} response: {res:?}");
        ClientError::res_check_status(res.status(), ureq::http::StatusCode::NO_CONTENT)?;

        let res_offset = (res.headers().get("Upload-Offset"))
            .ok_or_else(|| ClientError::res_parse_err("Upload-Offset header not found"))?
            .to_str()
            .map_err(ClientError::res_parse_err)?
            .parse::<u64>()
            .map_err(ClientError::res_parse_err)?;

        // get chunk length as `u64` (we have checked while reading the chunk!)
        let chunk_len = u64::try_from(chunk.len()).expect("something's VERY wrong");

        if offset + chunk_len == res_offset {
            Ok(res_offset)
        } else {
            Err(ClientError::ResponseContent(format!(
                "Unexpected Upload-Offset: {} (expected {})",
                res_offset,
                offset + chunk_len
            )))
        }
    }
}