use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum Platform {
#[serde(rename = "feishu")]
Feishu,
#[serde(rename = "wecom")]
Wecom,
#[serde(rename = "dingtalk")]
Dingtalk,
#[serde(rename = "slack")]
Slack,
#[serde(rename = "teams")]
Teams,
#[serde(rename = "telegram")]
Telegram,
#[serde(rename = "whatsapp")]
Whatsapp,
}
impl Platform {
pub fn as_str(self) -> &'static str {
match self {
Platform::Feishu => "feishu",
Platform::Wecom => "wecom",
Platform::Dingtalk => "dingtalk",
Platform::Slack => "slack",
Platform::Teams => "teams",
Platform::Telegram => "telegram",
Platform::Whatsapp => "whatsapp",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum Region {
#[serde(rename = "cn")]
Cn,
#[serde(rename = "intl")]
Intl,
}
impl Region {
pub fn as_str(self) -> &'static str {
match self {
Region::Cn => "cn",
Region::Intl => "intl",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum IntegrationStatus {
#[serde(rename = "pending")]
Pending,
#[serde(rename = "active")]
Active,
#[serde(rename = "suspended")]
Suspended,
#[serde(rename = "revoked")]
Revoked,
}
impl IntegrationStatus {
pub fn as_str(self) -> &'static str {
match self {
IntegrationStatus::Pending => "pending",
IntegrationStatus::Active => "active",
IntegrationStatus::Suspended => "suspended",
IntegrationStatus::Revoked => "revoked",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct CredentialRef(String);
impl CredentialRef {
pub fn as_str(&self) -> &str {
&self.0
}
}
impl std::fmt::Display for CredentialRef {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
pub fn as_credential_ref(s: impl Into<String>) -> CredentialRef {
CredentialRef(s.into())
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChannelAttachment {
pub kind: String,
pub url: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub size: Option<i64>,
#[serde(
rename = "contentType",
default,
skip_serializing_if = "Option::is_none"
)]
pub content_type: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChannelCardAction {
pub kind: String,
pub id: String,
pub label: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChannelCard {
pub kind: String,
pub title: String,
pub body: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub actions: Option<Vec<ChannelCardAction>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChannelInboundEvent {
pub platform: Platform,
#[serde(rename = "threadHash")]
pub thread_hash: String,
#[serde(
rename = "senderHash",
default,
skip_serializing_if = "Option::is_none"
)]
pub sender_hash: Option<String>,
pub content: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub attachments: Option<Vec<ChannelAttachment>>,
#[serde(rename = "messageId", default, skip_serializing_if = "Option::is_none")]
pub message_id: Option<String>,
#[serde(
rename = "receivedAt",
default,
skip_serializing_if = "Option::is_none"
)]
pub received_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<HashMap<String, String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChannelOutboundEvent {
#[serde(rename = "threadHash")]
pub thread_hash: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub content: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cards: Option<Vec<ChannelCard>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<HashMap<String, String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BridgeThreadRef {
#[serde(rename = "threadId")]
pub thread_id: String,
#[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
pub run_id: Option<String>,
#[serde(
rename = "remoteSessionId",
default,
skip_serializing_if = "Option::is_none"
)]
pub remote_session_id: Option<String>,
#[serde(rename = "tenantId")]
pub tenant_id: String,
#[serde(rename = "userId")]
pub user_id: String,
#[serde(rename = "appId")]
pub app_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatIntegration {
pub id: String,
#[serde(rename = "tenantId")]
pub tenant_id: String,
#[serde(rename = "appId")]
pub app_id: String,
pub platform: Platform,
pub region: Region,
#[serde(
rename = "workspaceIdHash",
default,
skip_serializing_if = "Option::is_none"
)]
pub workspace_id_hash: Option<String>,
#[serde(rename = "botIdHash", default, skip_serializing_if = "Option::is_none")]
pub bot_id_hash: Option<String>,
pub status: IntegrationStatus,
#[serde(
rename = "configJson",
default,
skip_serializing_if = "Option::is_none"
)]
pub config_json: Option<String>,
#[serde(
rename = "installedByUserId",
default,
skip_serializing_if = "Option::is_none"
)]
pub installed_by_user_id: Option<String>,
#[serde(
rename = "lastUsedAt",
default,
skip_serializing_if = "Option::is_none"
)]
pub last_used_at: Option<String>,
#[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "updatedAt", default, skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatCredentialPublic {
#[serde(rename = "credentialRef")]
pub credential_ref: CredentialRef,
#[serde(rename = "integrationId")]
pub integration_id: String,
pub platform: Platform,
pub region: Region,
#[serde(rename = "secretKind")]
pub secret_kind: String,
pub fingerprint: String,
#[serde(rename = "keyId")]
pub key_id: String,
pub version: i64,
pub status: String,
#[serde(
rename = "lastUsedAt",
default,
skip_serializing_if = "Option::is_none"
)]
pub last_used_at: Option<String>,
#[serde(rename = "rotatedAt", default, skip_serializing_if = "Option::is_none")]
pub rotated_at: Option<String>,
#[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "updatedAt", default, skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatThread {
pub id: String,
#[serde(rename = "tenantId")]
pub tenant_id: String,
#[serde(rename = "integrationId")]
pub integration_id: String,
#[serde(rename = "platformThreadHash")]
pub platform_thread_hash: String,
pub platform: Platform,
#[serde(rename = "userId")]
pub user_id: String,
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
pub session_id: Option<String>,
#[serde(rename = "lastRunId", default, skip_serializing_if = "Option::is_none")]
pub last_run_id: Option<String>,
#[serde(
rename = "senderHash",
default,
skip_serializing_if = "Option::is_none"
)]
pub sender_hash: Option<String>,
#[serde(
rename = "lastInboundAt",
default,
skip_serializing_if = "Option::is_none"
)]
pub last_inbound_at: Option<String>,
#[serde(
rename = "lastOutboundAt",
default,
skip_serializing_if = "Option::is_none"
)]
pub last_outbound_at: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatBridgeSession {
pub id: String,
#[serde(rename = "tenantId")]
pub tenant_id: String,
#[serde(rename = "threadId")]
pub thread_id: String,
#[serde(rename = "integrationId")]
pub integration_id: String,
#[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
pub run_id: Option<String>,
#[serde(
rename = "remoteSessionId",
default,
skip_serializing_if = "Option::is_none"
)]
pub remote_session_id: Option<String>,
pub status: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub adapter: Option<String>,
#[serde(
rename = "lastFrameAt",
default,
skip_serializing_if = "Option::is_none"
)]
pub last_frame_at: Option<String>,
#[serde(rename = "closedAt", default, skip_serializing_if = "Option::is_none")]
pub closed_at: Option<String>,
#[serde(
rename = "disconnectReason",
default,
skip_serializing_if = "Option::is_none"
)]
pub disconnect_reason: Option<String>,
#[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "updatedAt", default, skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
}
pub const ALL_PLATFORMS: &[Platform] = &[
Platform::Feishu,
Platform::Wecom,
Platform::Dingtalk,
Platform::Slack,
Platform::Teams,
Platform::Telegram,
Platform::Whatsapp,
];
pub const ALL_REGIONS: &[Region] = &[Region::Cn, Region::Intl];
pub const ALL_INTEGRATION_STATUS: &[IntegrationStatus] = &[
IntegrationStatus::Pending,
IntegrationStatus::Active,
IntegrationStatus::Suspended,
IntegrationStatus::Revoked,
];
pub fn is_platform(v: &str) -> bool {
ALL_PLATFORMS.iter().any(|p| p.as_str() == v)
}
pub fn is_region(v: &str) -> bool {
ALL_REGIONS.iter().any(|r| r.as_str() == v)
}
pub fn is_integration_status(v: &str) -> bool {
ALL_INTEGRATION_STATUS.iter().any(|s| s.as_str() == v)
}
pub fn is_channel_inbound_event(v: &serde_json::Value) -> bool {
let obj = match v.as_object() {
Some(o) => o,
None => return false,
};
let platform_ok = obj
.get("platform")
.and_then(|p| p.as_str())
.map(is_platform)
.unwrap_or(false);
let thread_hash_ok = obj
.get("threadHash")
.and_then(|t| t.as_str())
.map(|s| !s.is_empty())
.unwrap_or(false);
let content_ok = obj.get("content").map(|c| c.is_string()).unwrap_or(false);
platform_ok && thread_hash_ok && content_ok
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn credential_ref_is_transparent_newtype() {
let r = as_credential_ref("cred_abc123");
let v = serde_json::to_value(&r).unwrap();
assert_eq!(v, serde_json::Value::String("cred_abc123".into()));
let back: CredentialRef = serde_json::from_str("\"cred_xyz\"").unwrap();
assert_eq!(back.as_str(), "cred_xyz");
}
#[test]
fn chat_credential_public_response_is_camel_case() {
let c: ChatCredentialPublic = serde_json::from_str(
r#"{"credentialRef":"cred_aaa","integrationId":"int1","platform":"slack",
"region":"intl","secretKind":"bot_token","fingerprint":"fp","keyId":"k1",
"version":2,"status":"active"}"#,
)
.unwrap();
assert_eq!(c.credential_ref.as_str(), "cred_aaa");
assert_eq!(c.platform, Platform::Slack);
assert_eq!(c.region, Region::Intl);
assert_eq!(c.secret_kind, "bot_token");
assert_eq!(c.version, 2);
}
#[test]
fn integration_response_no_config_json_when_absent() {
let i: ChatIntegration = serde_json::from_str(
r#"{"id":"int1","tenantId":"t1","appId":"a1","platform":"feishu",
"region":"cn","status":"active"}"#,
)
.unwrap();
assert!(i.config_json.is_none());
assert_eq!(i.platform, Platform::Feishu);
}
#[test]
fn type_guards_validate_strings() {
assert!(is_platform("slack"));
assert!(!is_platform("discord"));
assert!(is_region("cn"));
assert!(!is_region("us"));
assert!(is_integration_status("revoked"));
assert!(!is_integration_status("deleted"));
}
#[test]
fn is_channel_inbound_event_checks_minimal_fields() {
let ok = serde_json::json!({"platform":"slack","threadHash":"h","content":"hi"});
assert!(is_channel_inbound_event(&ok));
let bad = serde_json::json!({"platform":"slack","threadHash":"h"});
assert!(!is_channel_inbound_event(&bad));
let bad2 = serde_json::json!({"platform":"x","threadHash":"h","content":"hi"});
assert!(!is_channel_inbound_event(&bad2));
let bad3 = serde_json::json!({"platform":"slack","threadHash":"","content":"hi"});
assert!(!is_channel_inbound_event(&bad3));
}
}