openlark-auth 0.17.0

//! Authen相关数据模型
//!
//! 本模块包含用户认证相关的数据结构定义。

use chrono::{DateTime, Utc};
use openlark_core::api::responses::ApiResponseTrait;
use serde::{Deserialize, Serialize};

/// 用户信息响应
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct UserInfoResponse {
    /// 用户信息
    pub data: UserInfo,
}

/// 用户信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserInfo {
    /// 用户Open ID
    pub open_id: String,
    /// 用户Union ID
    pub union_id: Option<String>,
    /// 用户ID
    pub user_id: Option<String>,
    /// 用户名
    pub name: Option<String>,
    /// 用户英文名/昵称
    pub en_name: Option<String>,
    /// 用户个人邮箱地址
    pub email: Option<String>,
    /// 用户企业邮箱地址
    pub enterprise_email: Option<String>,
    /// 用户手机号码
    pub mobile: Option<String>,
    /// 用户头像URL
    pub avatar_url: Option<String>,
    /// 用户头像
    pub avatar: Option<UserAvatar>,
    /// 用户状态
    pub status: Option<UserStatus>,
    /// 所属部门信息
    pub department_ids: Option<Vec<String>>,
    /// 群组信息
    pub group_ids: Option<Vec<String>>,
    /// 职位信息
    pub positions: Option<Vec<String>>,
    /// 工号
    pub employee_no: Option<String>,
    /// 钉钉UserId
    pub dingtalk_user_id: Option<String>,
    /// 企业扩展属性
    pub enterprise_extension: Option<UserEnterpriseExtension>,
    /// 自定义属性
    pub custom_attrs: Option<Vec<UserCustomAttr>>,
    /// 租户key
    pub tenant_key: Option<String>,
}

/// 用户头像
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserAvatar {
    /// 头像72x72
    pub avatar_72: Option<String>,
    /// 头像240x240
    pub avatar_240: Option<String>,
    /// 头像640x640
    pub avatar_640: Option<String>,
    /// 头像原图
    pub avatar_origin: Option<String>,
}

/// 用户状态
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserStatus {
    /// 是否激活
    pub is_activated: Option<bool>,
    /// 是否加入
    pub is_joined: Option<bool>,
    /// 是否预留
    pub is_reserved: Option<bool>,
    /// 是否离职
    pub is_exited: Option<bool>,
}

/// 企业扩展属性
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserEnterpriseExtension {
    /// 入职时间
    pub hire_date: Option<DateTime<Utc>>,
    /// 所属国家
    pub location: Option<String>,
    /// 工作地点
    pub work_station: Option<String>,
    /// 工作地点ID
    pub work_station_id: Option<String>,
    /// 通讯地址
    pub address: Option<String>,
    /// 邮政编码
    pub postcode: Option<String>,
    /// 订购电话
    pub mobile_phone: Option<String>,
    /// 分机号
    pub extension_number: Option<String>,
    /// 联系电话
    pub contact_phone: Option<String>,
    /// 主要电话
    pub primary_phone: Option<String>,
    /// 紧急联系人
    pub emergency_contact: Option<String>,
    /// 紧急联系电话
    pub emergency_phone: Option<String>,
    /// 家庭电话
    pub home_phone: Option<String>,
}

/// 用户自定义属性
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserCustomAttr {
    /// 属性Key
    pub key: Option<String>,
    /// 属性值
    pub value: Option<serde_json::Value>,
}

/// 用户访问令牌响应
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct UserAccessTokenResponse {
    /// 用户访问令牌
    pub user_access_token: String,
    /// 刷新令牌
    pub refresh_token: Option<String>,
    /// 令牌有效期（秒）
    pub expires_in: u64,
    /// 令牌类型
    pub token_type: Option<String>,
    /// 授权范围
    pub scope: Option<String>,
}

/// 用户访问令牌请求（v1版本）
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserAccessTokenV1Request {
    /// 授权码
    pub grant_code: String,
    /// 应用ID
    pub app_id: String,
    /// 应用密钥
    pub app_secret: String,
}

/// 用户访问令牌刷新请求（v1版本）
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RefreshUserAccessTokenV1Request {
    /// 刷新令牌
    pub refresh_token: String,
    /// 应用ID
    pub app_id: String,
    /// 应用密钥
    pub app_secret: String,
}

/// OIDC用户访问令牌请求
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OidcUserAccessTokenRequest {
    /// 授权码
    pub code: String,
    /// 授权验证码
    pub code_verifier: Option<String>,
    /// 授权流程
    pub redirect_uri: Option<String>,
    /// 客户端ID
    pub client_id: Option<String>,
    /// 客户端密钥
    pub client_secret: Option<String>,
    /// 授权类型
    pub grant_type: Option<String>,
}

/// OIDC用户访问令牌刷新请求
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OidcRefreshUserAccessTokenRequest {
    /// 刷新令牌
    pub refresh_token: String,
    /// 客户端ID
    pub client_id: Option<String>,
    /// 客户端密钥
    pub client_secret: Option<String>,
    /// 授权类型
    pub grant_type: Option<String>,
}

/// 用户信息获取请求
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserInfoRequest {
    /// 用户访问令牌
    pub user_access_token: String,
    /// 用户ID类型
    pub user_id_type: Option<String>,
}

impl PartialEq for UserInfo {
    fn eq(&self, other: &Self) -> bool {
        self.open_id == other.open_id
            && self.union_id == other.union_id
            && self.user_id == other.user_id
            && self.name == other.name
            && self.en_name == other.en_name
            && self.email == other.email
            && self.enterprise_email == other.enterprise_email
            && self.mobile == other.mobile
            && self.avatar_url == other.avatar_url
            && self.avatar == other.avatar
            && self.status == other.status
            && self.department_ids == other.department_ids
            && self.group_ids == other.group_ids
            && self.positions == other.positions
            && self.employee_no == other.employee_no
            && self.dingtalk_user_id == other.dingtalk_user_id
            && self.enterprise_extension == other.enterprise_extension
            && self.custom_attrs == other.custom_attrs
            && self.tenant_key == other.tenant_key
    }
}

impl PartialEq for UserAvatar {
    fn eq(&self, other: &Self) -> bool {
        self.avatar_72 == other.avatar_72
            && self.avatar_240 == other.avatar_240
            && self.avatar_640 == other.avatar_640
            && self.avatar_origin == other.avatar_origin
    }
}

impl PartialEq for UserStatus {
    fn eq(&self, other: &Self) -> bool {
        self.is_activated == other.is_activated
            && self.is_joined == other.is_joined
            && self.is_reserved == other.is_reserved
            && self.is_exited == other.is_exited
    }
}

impl PartialEq for UserEnterpriseExtension {
    fn eq(&self, other: &Self) -> bool {
        self.hire_date == other.hire_date
            && self.location == other.location
            && self.work_station == other.work_station
            && self.work_station_id == other.work_station_id
            && self.address == other.address
            && self.postcode == other.postcode
            && self.mobile_phone == other.mobile_phone
            && self.extension_number == other.extension_number
            && self.contact_phone == other.contact_phone
            && self.primary_phone == other.primary_phone
            && self.emergency_contact == other.emergency_contact
            && self.emergency_phone == other.emergency_phone
            && self.home_phone == other.home_phone
    }
}

impl PartialEq for UserCustomAttr {
    fn eq(&self, other: &Self) -> bool {
        self.key == other.key && self.value == other.value
    }
}

// 为所有响应类型实现ApiResponseTrait
impl ApiResponseTrait for UserInfoResponse {}
impl ApiResponseTrait for UserAccessTokenResponse {}

/// 用户令牌信息
#[derive(Debug, Clone)]
pub struct UserTokenInfo {
    /// 用户访问令牌
    pub user_access_token: String,
    /// 刷新令牌
    pub refresh_token: Option<String>,
    /// 过期时间
    pub expires_at: DateTime<Utc>,
    /// 令牌类型
    pub token_type: String,
    /// 授权范围
    pub scope: Option<String>,
    /// 获取时间
    pub created_at: DateTime<Utc>,
}

impl UserTokenInfo {
    /// 创建新的用户令牌信息
    pub fn new(
        user_access_token: String,
        expires_in: u64,
        token_type: String,
        refresh_token: Option<String>,
        scope: Option<String>,
    ) -> Self {
        let now = Utc::now();
        let expires_at = now + chrono::Duration::seconds(expires_in as i64);

        Self {
            user_access_token,
            refresh_token,
            expires_at,
            token_type,
            scope,
            created_at: now,
        }
    }

    /// 检查令牌是否已过期
    pub fn is_expired(&self) -> bool {
        Utc::now() >= self.expires_at
    }

    /// 检查令牌是否即将过期（提前5分钟）
    pub fn is_expiring_soon(&self) -> bool {
        let soon = Utc::now() + chrono::Duration::minutes(5);
        soon >= self.expires_at
    }

    /// 获取剩余有效时间（秒）
    pub fn remaining_seconds(&self) -> i64 {
        (self.expires_at - Utc::now()).num_seconds().max(0)
    }

    /// 检查是否有刷新令牌
    pub fn has_refresh_token(&self) -> bool {
        self.refresh_token.is_some()
    }
}

#[cfg(test)]
#[allow(unused_imports)]
mod tests {
    use super::*;

    #[test]
    fn test_user_info_serialization() {
        let user_info = UserInfo {
            open_id: "test_open_id".to_string(),
            union_id: Some("test_union_id".to_string()),
            user_id: Some("test_user_id".to_string()),
            name: Some("测试用户".to_string()),
            en_name: Some("Test User".to_string()),
            email: Some("test@example.com".to_string()),
            enterprise_email: Some("test@company.com".to_string()),
            mobile: Some("13800138000".to_string()),
            avatar_url: Some("https://example.com/avatar.jpg".to_string()),
            avatar: None,
            status: None,
            department_ids: None,
            group_ids: None,
            positions: None,
            employee_no: None,
            dingtalk_user_id: None,
            enterprise_extension: None,
            custom_attrs: None,
            tenant_key: None,
        };

        let json = serde_json::to_string(&user_info).unwrap();
        assert!(json.contains("test_open_id"));
        assert!(json.contains("测试用户"));
    }

    #[test]
    fn test_user_token_info() {
        let token = UserTokenInfo::new(
            "test_token".to_string(),
            3600,
            "Bearer".to_string(),
            Some("refresh_token".to_string()),
            Some("user_info".to_string()),
        );

        assert_eq!(token.user_access_token, "test_token");
        assert_eq!(token.token_type, "Bearer");
        assert!(token.has_refresh_token());
        assert!(!token.is_expired());
        assert!(token.remaining_seconds() > 0);
    }

    #[test]
    fn test_user_avatar() {
        let avatar = UserAvatar {
            avatar_72: Some("https://example.com/72.jpg".to_string()),
            avatar_240: Some("https://example.com/240.jpg".to_string()),
            avatar_640: Some("https://example.com/640.jpg".to_string()),
            avatar_origin: Some("https://example.com/original.jpg".to_string()),
        };

        let json = serde_json::to_string(&avatar).unwrap();
        assert!(json.contains("72.jpg"));
        assert!(json.contains("240.jpg"));
    }

    #[test]
    fn test_user_info_with_enterprise_email() {
        // 测试包含企业邮箱的用户信息
        let user_info = UserInfo {
            open_id: "test_open_id".to_string(),
            union_id: Some("test_union_id".to_string()),
            user_id: Some("test_user_id".to_string()),
            name: Some("测试用户".to_string()),
            en_name: Some("Test User".to_string()),
            email: Some("test@example.com".to_string()),
            enterprise_email: Some("test@company.com".to_string()),
            mobile: Some("13800138000".to_string()),
            avatar_url: Some("https://example.com/avatar.jpg".to_string()),
            avatar: None,
            status: None,
            department_ids: None,
            group_ids: None,
            positions: None,
            employee_no: None,
            dingtalk_user_id: None,
            enterprise_extension: None,
            custom_attrs: None,
            tenant_key: None,
        };

        // 序列化
        let json = serde_json::to_string(&user_info).unwrap();
        assert!(json.contains("enterprise_email"));
        assert!(json.contains("test@company.com"));

        // 反序列化
        let deserialized: UserInfo = serde_json::from_str(&json).expect("JSON 反序列化失败");
        assert_eq!(
            deserialized.enterprise_email,
            Some("test@company.com".to_string())
        );

        // 测试没有企业邮箱的情况
        let user_info_no_enterprise_email = UserInfo {
            enterprise_email: None,
            ..user_info
        };

        let json_no_enterprise = serde_json::to_string(&user_info_no_enterprise_email).unwrap();
        let deserialized_no_enterprise: UserInfo =
            serde_json::from_str(&json_no_enterprise).expect("JSON 反序列化失败");
        assert!(deserialized_no_enterprise.enterprise_email.is_none());
    }
}