messengerlib/async_remote/
chat_remote.rs

use common::model::status_message::StatusMessage;
use common::remote::async_remote::{get, post};
use common::remote::services;
use hyper::header::{HeaderName, HeaderValue};
use hyper::HeaderMap;
use serde::{Deserialize, Serialize};
use uuid::Uuid;

use crate::dto::chat_request::ChatRequest;
use crate::dto::chat_response::ChatResponse;
use crate::dto::conference_ping_request::ConferencePingRequest;
use crate::dto::videocall_record_request::VideoCallRecordRequest;

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateChatModel {
    pub name: String,
    pub id: Uuid,
}

pub async fn transcript<T>(
    data: T,
    chat_id: Uuid,
    headers: HeaderMap,
) -> Result<StatusMessage, String>
where
    T: Serialize,
{
    let mut headers_json = headers.clone();
    headers_json.insert(
        HeaderName::from_static("content-type"),
        HeaderValue::from_str("application/json").expect("can't parse token"),
    );
    post(
        services::MESSENGER_API,
        format!("/chatController/transcript/{}", chat_id),
        headers_json,
        data,
    )
    .await
}

pub async fn conference_ping(req: ConferencePingRequest) -> Result<StatusMessage, String> {
    let mut headers = HeaderMap::new();
    headers.insert(
        HeaderName::from_static("content-type"),
        HeaderValue::from_str("application/json").unwrap(),
    );
    post(
        services::MESSENGER_API,
        String::from("/chatController/conferencePing"),
        headers,
        req,
    )
    .await
}

pub async fn conference_user_connect(
    domain: String,
    room_id: Uuid,
    user_id: Uuid,
) -> Result<StatusMessage, String> {
    get(
        services::MESSENGER_API,
        format!(
            "/chatController/conferenceUserConnect/{}/{}/{}",
            domain, room_id, user_id
        ),
        HeaderMap::new(),
    )
    .await
}

pub async fn conference_user_disconnect(
    domain: String,
    room_id: Uuid,
    user_id: Uuid,
) -> Result<StatusMessage, String> {
    get(
        services::MESSENGER_API,
        format!(
            "/chatController/conferenceUserDisconnect/{}/{}/{}",
            domain, room_id, user_id
        ),
        HeaderMap::new(),
    )
    .await
}

pub async fn conference_room_created(
    domain: String,
    room_id: Uuid,
    room_type: String,
) -> Result<StatusMessage, String> {
    get(
        services::MESSENGER_API,
        format!(
            "/chatController/conferenceRoomCreated/{}/{}/{}",
            domain, room_id, room_type
        ),
        HeaderMap::new(),
    )
    .await
}

pub async fn conference_room_removed(
    domain: String,
    room_id: Uuid,
) -> Result<StatusMessage, String> {
    get(
        services::MESSENGER_API,
        format!(
            "/chatController/conferenceRoomRemoved/{}/{}",
            domain, room_id
        ),
        HeaderMap::new(),
    )
    .await
}

pub async fn get_chat_ids_for_user(headers: HeaderMap) -> Result<Vec<Uuid>, String> {
    get(
        services::MESSENGER_API,
        String::from("/chatController/chatIdsForUser"),
        headers,
    )
    .await
}

pub async fn find_chat(chat_id: Uuid, headers: Option<HeaderMap>) -> Result<ChatResponse, String> {
    get(
        services::MESSENGER_API,
        format!("/chatController/{}", chat_id),
        if headers.is_some() {
            headers.unwrap()
        } else {
            HeaderMap::new()
        },
    )
    .await
}

pub async fn videocall_record(record: VideoCallRecordRequest) -> Result<StatusMessage, String> {
    let mut headers = HeaderMap::new();
    headers.insert(
        HeaderName::from_static("content-type"),
        HeaderValue::from_str("application/json").expect("can't parse token"),
    );
    post(
        services::MESSENGER_API,
        format!("/chatController/videoCallRecord"),
        headers,
        record,
    )
    .await
}

pub async fn create_chat_with_id(
    chat: ChatRequest,
    headers: HeaderMap,
) -> Result<ChatResponse, String> {
    post(
        services::MESSENGER_API,
        String::from("/chatController/createChat"),
        headers,
        chat,
    )
    .await
}

pub async fn create_chat_list(
    chat: Vec<ChatRequest>,
    headers: HeaderMap,
) -> Result<Vec<ChatResponse>, String> {
    post(
        services::MESSENGER_API,
        String::from("/chatController/createChatList"),
        headers,
        chat,
    )
    .await
}
messengerlib/async_remote/chat_remote.rs

messengerlib/async_remote/
chat_remote.rs
