rust_wechat_work/message/

robot.rs

use crate::error::WorkError;
use reqwest::{multipart, Client};
use rust_wechat_codegen::ServerResponse;
use rust_wechat_core::client::ClientTrait;
use rust_wechat_core::utils::{base64, md5};
use rust_wechat_core::WechatError;
use serde::ser::{SerializeSeq, SerializeStruct};
use serde::{Deserialize, Serialize, Serializer};
use serde_repr::{Deserialize_repr, Serialize_repr};

const SEND_MESSAGE_URL: &str = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send";
const UPLOAD_MEDIA_URL: &str = "https://qyapi.weixin.qq.com/cgi-bin/webhook/upload_media";

/// 表示机器人消息的通用响应
#[derive(Debug, Serialize, Deserialize, ServerResponse)]
#[sr(flatten)]
pub struct SendRobotMessage {
    #[serde(rename = "type")]
    pub media_type: Option<String>, // For media upload
    pub media_id: Option<String>,   // For media upload
    pub created_at: Option<String>, // For media upload
}

#[derive(Debug)]
pub enum MentionTarget {
    All,
    List(Vec<String>),
}

impl Serialize for MentionTarget {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match self {
            MentionTarget::All => {
                let mut seq = serializer.serialize_seq(Some(1))?;
                seq.serialize_element(vec!["@all".to_string()].as_slice())?;
                seq.end()
            }
            MentionTarget::List(v) => {
                let mut seq = serializer.serialize_seq(Some(v.len()))?;
                seq.serialize_element(v)?;
                seq.end()
            }
        }
    }
}

/// 文本消息
#[derive(Debug, Serialize)]
pub struct TextMessage {
    pub content: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mentioned_list: Option<MentionTarget>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mentioned_mobile_list: Option<MentionTarget>,
}

/// Markdown消息
#[derive(Debug, Serialize)]
pub struct MarkdownMessage {
    pub content: String,
}

/// 图片消息
#[derive(Debug, Serialize)]
pub struct ImageMessage {
    base64: String,
    md5: String,
}

impl ImageMessage {
    pub fn new(path: &str) -> rust_wechat_core::Result<Self> {
        let base64 = base64(path)?;
        let md5 = md5(&base64)?;
        Ok(ImageMessage { base64, md5 })
    }
}

/// 图文消息文章
#[derive(Debug, Serialize)]
pub struct NewsArticle {
    pub title: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub url: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub picurl: Option<String>,
}

/// 图文消息
#[derive(Debug, Serialize)]
pub struct NewsMessage {
    pub articles: Vec<NewsArticle>,
}

/// 文件消息
#[derive(Debug, Serialize)]
pub struct FileMessage {
    pub media_id: String,
}

/// 语音消息
#[derive(Debug, Serialize)]
pub struct VoiceMessage {
    pub media_id: String,
}

// --- Start of TemplateCard additions ---
#[derive(Debug, Serialize_repr, Deserialize_repr, Clone)]
#[repr(u8)]
pub enum DescColor {
    Gray = 0,
    Blue = 1,
    Red = 2,
    Green = 3,
}

/// 卡片来源，可为空
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct CardSource {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub icon_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub desc: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub desc_color: Option<DescColor>,
}

/// 主要内容，如何展示主要内容由 `emphasis_content` 和 `main_title` 控制
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct MainTitle {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub desc: Option<String>,
}

/// 关键数据样式
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct EmphasisContent {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub desc: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub enum QuotaTarget {
    None,
    Url(String),
    Weapp { appid: String, pagepath: String },
}

/// 引用文献样式，建议不与 `main_title` 同时设置
#[derive(Debug, Clone)]
pub struct QuoteArea {
    pub target: QuotaTarget,
    pub title: Option<String>,
    pub quote_text: Option<String>,
}

impl Serialize for QuoteArea {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = serializer.serialize_struct("QuoteArea", 4)?;
        s.serialize_field("title", &self.title)?;
        s.serialize_field("quote_text", &self.quote_text)?;
        match &self.target {
            QuotaTarget::None => {
                s.serialize_field("type", &0)?;
            }
            QuotaTarget::Url(url) => {
                s.serialize_field("type", &1)?;
                s.serialize_field("url", url)?;
            }
            QuotaTarget::Weapp { appid, pagepath } => {
                s.serialize_field("type", &2)?;
                s.serialize_field("appid", appid)?;
                s.serialize_field("pagepath", pagepath)?;
            }
        }
        s.end()
    }
}

#[derive(Debug, Clone)]
pub enum ContentType {
    Url {
        value: Option<String>,
        url: String,
    },
    Media {
        media_id: String,
        media_type: String,
    },
    Member {
        value: Option<String>,
        user_id: String,
    },
}

#[derive(Debug, Clone)]
pub struct HorizontalContent {
    pub title: Option<String>,
    pub content: ContentType,
}

impl Serialize for HorizontalContent {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("HorizontalContent", 2)?;
        state.serialize_field("keyname", &self.title)?;
        match &self.content {
            ContentType::Url { value, url } => {
                state.serialize_field("type", &1)?;
                state.serialize_field("url", url)?;
                state.serialize_field("value", value)?;
            }
            ContentType::Media {
                media_id,
                media_type,
            } => {
                state.serialize_field("type", &2)?;
                state.serialize_field("media_id", media_id)?;
                state.serialize_field("value", media_type)?;
            }
            ContentType::Member { value, user_id } => {
                state.serialize_field("type", &3)?;
                state.serialize_field("value", value)?;
                state.serialize_field("userid", user_id)?;
            }
        }
        state.end()
    }
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub enum JumpTarget {
    None,
    Url(String),
    Weapp { appid: String, pagepath: String },
}

/// 跳转指引样式的列表，该字段可为空数组，但有数据的话需确认对应字段是否必填，列表长度不超过3
#[derive(Debug, Clone)]
pub struct Jump {
    pub title: String,
    pub r#type: JumpTarget,
}
impl Serialize for Jump {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("Jump", 2)?;
        state.serialize_field("title", &self.title)?;
        match &self.r#type {
            JumpTarget::None => state.serialize_field("type", &0)?,
            JumpTarget::Url(url) => {
                state.serialize_field("type", &1)?;
                state.serialize_field("url", url)?;
            }
            JumpTarget::Weapp { appid, pagepath } => {
                state.serialize_field("type", &2)?;
                state.serialize_field("appid", appid)?;
                state.serialize_field("pagepath", pagepath)?;
            }
        }
        state.end()
    }
}

#[derive(Debug, Clone)]
pub enum CardAction {
    Url(String),
    Weapp { appid: String, pagepath: String },
}

impl Serialize for CardAction {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("CardAction", 2)?;
        match &self {
            CardAction::Url(url) => {
                state.serialize_field("type", &1)?;
                state.serialize_field("url", url)?;
            }
            CardAction::Weapp { appid, pagepath } => {
                state.serialize_field("type", &2)?;
                state.serialize_field("appid", appid)?;
                state.serialize_field("pagepath", pagepath)?;
            }
        }
        state.end()
    }
}

/// 图片样式
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct CardImage {
    pub url: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspect_ratio: Option<f64>,
}

/// 垂直内容，卡片二级垂直内容，该字段可为空数组，但有数据的话需确认对应字段是否必填，列表长度不超过4
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct VerticalContent {
    pub title: String, // 最多4个字
    #[serde(skip_serializing_if = "Option::is_none")]
    pub desc: Option<String>, // Desc内容，2行，最多26个字
}

/// 图文展示，图片在左，文字在右
#[derive(Debug, Clone)]
pub struct ImageTextArea {
    pub r#type: JumpTarget, // 0-普通文本, 1-url
    pub title: Option<String>,
    pub desc: Option<String>,
    pub image_url: String,
}

impl Serialize for ImageTextArea {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("ImageTextArea", 3)?;
        state.serialize_field("title", &self.title)?;
        state.serialize_field("desc", &self.desc)?;
        state.serialize_field("image_url", &self.image_url)?;
        match &self.r#type {
            JumpTarget::None => state.serialize_field("type", &0)?,
            JumpTarget::Url(url) => {
                state.serialize_field("type", &1)?;
                state.serialize_field("url", url)?;
            }
            JumpTarget::Weapp { appid, pagepath } => {
                state.serialize_field("type", &2)?;
                state.serialize_field("appid", appid)?;
                state.serialize_field("pagepath", pagepath)?;
            }
        }
        state.end()
    }
}

#[derive(Debug, Serialize, Clone)]
#[serde(untagged, rename_all = "snake_case")]
pub enum NoticeCard {
    TextNotice {
        #[serde(skip_serializing_if = "Option::is_none")]
        emphasis_content: Option<EmphasisContent>,
        #[serde(skip_serializing_if = "Option::is_none")]
        sub_title_text: Option<String>,
    },
    NewsNotice {
        #[serde(skip_serializing_if = "Option::is_none")]
        card_image: Option<CardImage>,
        #[serde(skip_serializing_if = "Option::is_none")]
        image_text_area: Option<ImageTextArea>,
        #[serde(skip_serializing_if = "Option::is_none")]
        vertical_content_list: Option<Vec<VerticalContent>>,
    },
}

/// 模板卡片消息定义
#[derive(Debug, Serialize, Clone)]
pub struct TemplateCardMessage {
    #[serde(flatten)]
    pub card: NoticeCard,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<CardSource>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub main_title: Option<MainTitle>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quote_area: Option<QuoteArea>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub horizontal_content_list: Option<Vec<HorizontalContent>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jump_list: Option<Vec<Jump>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub card_action: Option<CardAction>,
}
// --- End of TemplateCard additions ---

/// 机器人消息体
#[derive(Debug, Serialize)]
#[serde(tag = "msgtype")]
pub enum RobotMessage {
    #[serde(rename = "text")]
    Text(TextMessage),
    #[serde(rename = "markdown")]
    Markdown(MarkdownMessage),
    #[serde(rename = "image")]
    Image(ImageMessage),
    #[serde(rename = "news")]
    News(NewsMessage),
    #[serde(rename = "file")]
    File(FileMessage),
    #[serde(rename = "voice")]
    Voice(VoiceMessage),
    #[serde(rename = "template_card")]
    TemplateCard(TemplateCardMessage),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum FileType {
    Voice,
    File,
}

/// 企业微信群机器人客户端
#[derive(Clone)]
pub struct RobotClient {
    pub key: String,
    pub client: Client,
}

impl ClientTrait for RobotClient {
    async fn access_token(&self) -> rust_wechat_core::Result<String> {
        Err(WechatError::UnsupportedCommand("access_token".to_string()))
    }

    async fn refresh_access_token(&mut self) -> rust_wechat_core::Result<()> {
        Err(WechatError::UnsupportedCommand(
            "refresh_access_token".to_string(),
        ))
    }

    fn http_client(&self) -> &Client {
        &self.client
    }
}
impl RobotClient {
    /// 创建一个新的机器人客户端实例
    ///
    /// # Arguments
    ///
    /// * `webhook_key` - 机器人的 Webhook Key (从 webhook_url 中提取，例如: 693a91f6-7xxx-4bc4-97a0-0ec2sifa5aaa)
    pub fn new(key: &str) -> Self {
        RobotClient {
            key: key.to_string(),
            client: reqwest::Client::new(),
        }
    }

    /// 发送消息到群机器人
    pub async fn send_message(&self, message: &RobotMessage) -> crate::Result<()> {
        let url = self.url_with_query(SEND_MESSAGE_URL, &[("key", &self.key)])?;
        let response: SendRobotMessageResponse = self.json(url, message).await?;
        Ok(response.ignore()?)
    }

    /// 上传文件到企业微信，用于发送文件或语音消息 <mcreference link="https://developer.work.weixin.qq.com/document/path/99110#%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E6%8E%A5%E5%8F%A3" index="0">0</mcreference>
    ///
    /// # Arguments
    ///
    /// * `file_path` - 本地文件的路径
    /// * `file_type` - 文件类型，根据企业微信文档，此处应为 "file" (文件), "voice" (语音), "image" (图片) <mcreference link="https://developer.work.weixin.qq.com/document/path/99110#%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E6%8E%A5%E5%8F%A3" index="0">0</mcreference>
    pub async fn upload_media(
        &self,
        file_path: &str,
        file_type: FileType,
    ) -> crate::Result<SendRobotMessage> {
        let url = self.url_with_query(UPLOAD_MEDIA_URL, &[("key", &self.key)])?;

        let file_bytes = tokio::fs::read(file_path).await?;
        let file_name = std::path::Path::new(file_path)
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("unknown_file")
            .to_string();

        let part = multipart::Part::bytes(file_bytes)
            .file_name(file_name)
            .mime_str("application/octet-stream")?;

        let form = multipart::Form::new().part("media", part);

        let response: SendRobotMessageResponse =
            self.upload_with(url, &[("type", file_type)], form).await?;

        Ok(response.data()?)
    }

    /// 发送文件消息 (通过先上传文件获取media_id)
    pub async fn send_file_message(&self, file_path: &str) -> crate::Result<()> {
        let upload_response = self.upload_media(file_path, FileType::File).await?;
        if let Some(media_id) = upload_response.media_id {
            let file_message = FileMessage { media_id };
            self.send_message(&RobotMessage::File(file_message)).await
        } else {
            Err(WorkError::CommonError(
                "Failed to get media_id from upload response".to_string(),
            ))
        }
    }
}