Open Lark

https://docs.rs/open-lark/0.14.0/
Admin
Open Lark is an enterprise-grade Rust SDK for the Lark/Feishu Open API with comprehensive...
Tokens:5,924
Snippets:94
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Quick Start - Organizational Structure Management

Source: https://docs.rs/crate/open-lark

Provides examples for managing organizational structure within Lark, including creating departments, adding employees, and searching for employees. This requires appropriate permissions for directory management.

```rust
use open_lark::prelude::*;
use open_lark::service::directory::v1::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = LarkClient::builder("your_app_id", "your_app_secret")
        .with_app_type(AppType::SelfBuild)
        .build();

    // 创建部门
    let dept_request = CreateDepartmentRequest::builder()
        .name("技术部")
        .en_name("Technology Department")
        .user_id_type(UserIdType::UserId)
        .department_id_type(DepartmentIdType::DepartmentId)
        .build();
    let dept = client.directory.v1.department.create(dept_request, None).await?;
    println!("创建部门: {:?}", dept.data);

    // 创建员工
    let emp_request = CreateEmployeeRequest::builder()
        .name("张三")
        .email("zhangsan@example.com")
        .job_title("软件工程师")
        .user_id_type(UserIdType::UserId)
        .build();
    let emp = client.directory.v1.employee.create(emp_request, None).await?;
    println!("创建员工: {:?}", emp.data);

    // 搜索员工
    let search_request = SearchEmployeeRequest::builder("张")
        .page_size(10)
        .user_id_type(UserIdType::UserId)
        .build();
    let employees = client.directory.v1.employee.search(search_request, None).await?;
    println!("搜索结果: {:?}", employees.data);

    Ok(())
}

```

--------------------------------

### Attendance Module Quick Start

Source: https://docs.rs/crate/open-lark

Demonstrates initializing the Lark client and performing basic attendance operations like listing shifts and querying user tasks.

```rust
use open_lark::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建客户端
    let client = LarkClient::builder("your_app_id", "your_app_secret").build();

    // 查询所有班次
    let shifts_req = ListShiftsRequest {
        employee_type: "employee_id".to_string(),
        page_size: Some(20),
        ..Default::default()
    };
    
    let shifts_resp = client.attendance.v1.shift.list(shifts_req, None).await?;
    println!("班次列表: {:?}", shifts_resp.data);

    // 查询打卡记录
    let user_task_req = QueryUserTaskRequest {
        employee_type: "employee_id".to_string(),
        user_ids: vec!["employee_123".to_string()],
        check_date_from: "2024-06-01".to_string(),
        check_date_to: "2024-06-30".to_string(),
        ..Default::default()
    };
    
    let user_task_resp = client.attendance.v1.user_task.query(user_task_req, None).await?;
    println!("打卡记录: {:?}", user_task_resp.data);

    Ok(())
}
```

--------------------------------

### Quick Start - Recruitment Management

Source: https://docs.rs/crate/open-lark

Demonstrates how to use the Lark SDK to manage recruitment processes, including fetching job lists, talent pools, creating talents, and managing referrals. Ensure your Lark application has the necessary permissions for these services.

```rust
use open_lark::prelude::*;
use open_lark::service::hire::models::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = LarkClient::builder("your_app_id", "your_app_secret")
        .with_app_type(AppType::SelfBuild)
        .build();

    // 获取职位列表
    let job_request = JobListRequest {
        page_size: Some(50),
        page_token: None,
        status: Some("active".to_string()),
        ..Default::default()
    };
    let jobs = client.hire.recruitment_config.job.list_jobs(job_request, None).await?;
    println!("职位列表: {:?}", jobs.data);

    // 获取人才库列表
    let pool_request = TalentPoolListRequest {
        page_size: Some(20),
        ..Default::default()
    };
    let pools = client.hire.candidate_management.talent_pool.list_pools(pool_request, None).await?;
    println!("人才库列表: {:?}", pools.data);

    // 创建人才
    let talent_request = TalentCreateRequest {
        name: "张三".to_string(),
        email: Some("zhangsan@example.com".to_string()),
        phone: Some("13800138000".to_string()),
        ..Default::default()
    };
    let talent = client.hire.candidate_management.talent.create_talent(talent_request, None).await?;
    println!("创建人才: {:?}", talent.data);

    // 获取内推列表
    let referral_request = ReferralListRequest {
        page_size: Some(30),
        ..Default::default()
    };
    let referrals = client.hire.get_candidates.referral.list_referrals(referral_request, None).await?;
    println!("内推列表: {:?}", referrals.data);

    // 查询内推账户余额
    let user_id = "user_123456";
    let balance = client.hire.referral_account.get_balance(user_id, None).await?;
    println!("账户余额: {:?}", balance.data);

    Ok(())
}

```

--------------------------------

### Quick Start - Enterprise Error Handling

Source: https://docs.rs/crate/open-lark

Illustrates how to implement robust error handling for API calls using the Lark SDK. This includes setting up error monitoring, logging, and an intelligent retry mechanism with configurable retry strategies.

```rust
use open_lark::prelude::*;
use open_lark::core::{
    error_helper::ErrorHelper,
    error_metrics::ErrorMonitor,
    retry_middleware::{RetryMiddleware, RetryConfig},
    error_logger::{ErrorLogger, LoggerBuilder, LogLevel},
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 设置监控和日志
    let monitor = ErrorMonitor::default();
    let logger = LoggerBuilder::new()
        .min_level(LogLevel::Info)
        .json_format()
        .build();

    // 设置智能重试策略
    let retry_middleware = RetryMiddleware::new(
        RetryConfig::new()
            .enabled(true)
            .server_errors_only()
    );

    let client = LarkClient::builder("your_app_id", "your_app_secret").build();

    // 执行API调用（带自动重试）
    let result = retry_middleware.execute(|| async {
        client.im.v1.message.create(&request).await
    }).await;

    // 智能错误处理
    match result {
        Ok(response) => println!("✅ 成功: {:?}", response),
        Err(error) => {
            // 记录错误
            monitor.record_error(error.clone());
            logger.log_api_error(&error);
            
            // 智能错误分析
            println!("❌ {}", error.user_friendly_message());
            let advice = ErrorHelper::handle_error(&error);
            for action in &advice.actions {
                println!("  💡 {}", action);
            }
        }
    }

    // 查看错误统计
    let stats = monitor.get_statistics();
    stats.print_detailed();

    Ok(())
}

```

--------------------------------

### AI Capability Usage

Source: https://docs.rs/crate/open-lark

Examples for using AI services including resume parsing, OCR, language detection, and text translation.

```rust
use open_lark::prelude::*;
use open_lark::service::ai::models::{
    FileRecognizeRequest, LanguageDetectRequest, TranslateRequest,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = LarkClient::builder("your_app_id", "your_app_secret").build();

    // 智能文档处理 - 简历解析
    let resume_request = FileRecognizeRequest {
        file: "resume_file_token_or_base64".to_string(),
    };
    let resume_result = client.ai.document_ai.parse_resume(resume_request, None).await?;
    println!("简历解析结果: {:?}", resume_result.data);

    // OCR文字识别
    let ocr_request = FileRecognizeRequest {
        file: "image_file_token_or_base64".to_string(),
    };
    let ocr_result = client.ai.optical_char_recognition.basic_recognize(ocr_request, None).await?;
    println!("OCR识别结果: {:?}", ocr_result.data);

    // 语种检测
    let detect_request = LanguageDetectRequest {
        text: "Hello, how are you?".to_string(),
    };
    let detect_result = client.ai.translation.detect(detect_request, None).await?;
    println!("语种检测结果: {:?}", detect_result.data);

    // 文本翻译
    let translate_request = TranslateRequest {
        source_language: Some("en".to_string()),
        target_language: "zh".to_string(),
        text: "Hello, how are you?".to_string(),
    };
    let translate_result = client.ai.translation.translate(translate_request, None).await?;
    println!("翻译结果: {:?}", translate_result.data);

    Ok(())
}
```

--------------------------------

### GET /attendance/v1/shift

Source: https://docs.rs/crate/open-lark

Retrieves a list of shifts for employees.

```APIDOC
## GET /attendance/v1/shift

### Description
Queries the list of available shifts.

### Method
GET

### Parameters
#### Request Body
- **employee_type** (string) - Required - The type of employee identifier (e.g., "employee_id").
- **page_size** (integer) - Optional - Number of records per page.
```

--------------------------------

### IM File and Image Service Builder Pattern

Source: https://docs.rs/crate/open-lark

Demonstrates file and image upload/download operations using the Builder pattern.

```rust
use open_lark::core::trait_system::ExecutableBuilder;

// 文件上传
let upload_result = client
    .im
    .v1
    .file
    .upload_builder()
    .file_type("pdf")
    .file_name("document.pdf")
    .file_data(file_data)
    .execute(&client.im.v1.file)
    .await?;

println!("文件上传成功: {}", upload_result.file_key);

// 文件下载
let download_result = client
    .im
    .v1
    .file
    .download_builder()
    .file_key(&upload_result.file_key)
    .execute(&client.im.v1.file)
    .await?;

println!("文件下载成功，大小: {} 字节", download_result.data.len());
```

```rust
// 图片上传
let image_upload = client
    .im
    .v1
    .image
    .upload_builder()
    .image_type("png")
    .image_data(image_bytes)
    .execute(&client.im.v1.image)
    .await?;

// 图片下载
let image_download = client
    .im
    .v1
    .image
    .download_builder()
    .image_key(&image_upload.image_key)
    .execute(&client.im.v1.image)
    .await?;
```

--------------------------------

### Build User Creation with Conditional Parameters

Source: https://docs.rs/crate/open-lark

Demonstrates how to conditionally add parameters to a builder for creating a user. Use this when certain user attributes depend on external conditions.

```rust
let mut builder = client
    .contact
    .v3
    .user
    .create_user_builder()
    .user(user.clone());

// 条件性添加参数
if use_open_id {
    builder = builder.user_id_type("open_id");
}

if include_department {
    builder = builder.department_id_type("open_department_id");
}

let response = builder.execute(&client.contact.v3.user).await?;
```

--------------------------------

### Batch File Upload with Dynamic Data

Source: https://docs.rs/crate/open-lark

Shows how to upload multiple files in a batch, specifying type, name, and data for each. Suitable for scenarios requiring bulk file uploads.

```rust
let files = [("txt", "file1.txt", data1), ("pdf", "file2.pdf", data2)];
for (file_type, file_name, file_data) in files {
    let result = client
        .im
        .v1
        .file
        .upload_builder()
        .file_type(file_type)
        .file_name(file_name)
        .file_data(file_data)
        .execute(&client.im.v1.file)
        .await?;
    
    println!("上传成功: {} -> {}", file_name, result.file_key);
}
```

--------------------------------

### Contact Service Builder Pattern

Source: https://docs.rs/crate/open-lark

Compares the traditional request structure with the modern fluent Builder pattern for creating users.

```rust
let request = CreateUserRequest {
    user: user.clone(),
    user_id_type: Some("open_id".to_string()),
    department_id_type: Some("open_department_id".to_string()),
};

let response = client.contact.v3.user.create(&request).await?;
```

```rust
use open_lark::core::trait_system::ExecutableBuilder;

let response = client
    .contact
    .v3
    .user
    .create_user_builder()
    .user(user.clone())
    .user_id_type("open_id")
    .department_id_type("open_department_id")
    .execute(&client.contact.v3.user)
    .await?;
```

--------------------------------

### Unified Error Handling with StandardResponse

Source: https://docs.rs/crate/open-lark

Illustrates how to handle various API errors using a match statement on `LarkAPIError`. Provides specific suggestions based on common error codes.

```rust
use open_lark::core::error::LarkAPIError;

match result {
    Ok(response) => {
        println!("✅ 操作成功: {:?}", response);
    }
    Err(e) => {
        match &e {
            LarkAPIError::APIError { code, msg, .. } => {
                println!("API错误 - 代码: {}, 消息: {}", code, msg);
                
                // 根据错误码提供具体建议
                match *code {
                    429 => println!("💡 建议: 请求频率过高，建议稍后重试"),
                    403 => println!("💡 建议: 权限不足，请检查应用权限配置"),
                    413 => println!("💡 建议: 文件太大，请压缩后重试"),
                    415 => println!("💡 建议: 不支持的文件类型"),
                    _ => println!("💡 建议: 检查网络连接和API配置"),
                }
            }
            LarkAPIError::DataError(msg) => {
                println!("数据错误: {}", msg);
                println!("💡 建议: 检查输入数据格式和内容");
            }
            _ => {
                println!("其他错误: {}", e);
                println!("💡 建议: 查看详细日志获取更多信息");
            }
        }
    }
}
```

--------------------------------

### POST /contact/v3/user

Source: https://docs.rs/crate/open-lark

Creates a new user in the contact directory using the Builder pattern.

```APIDOC
## POST /contact/v3/user

### Description
Creates a user record using the fluent Builder pattern.

### Method
POST

### Parameters
#### Request Body
- **user** (object) - Required - User details object.
- **user_id_type** (string) - Optional - Type of user ID.
- **department_id_type** (string) - Optional - Type of department ID.
```

--------------------------------

### IM File and Image Operations

Source: https://docs.rs/crate/open-lark

Endpoints for uploading and downloading files and images in the IM service.

```APIDOC
## IM File/Image Operations

### Description
Handles file and image uploads/downloads using the Builder pattern.

### Methods
- **upload_builder**: Uploads files or images.
- **download_builder**: Downloads files or images using a key.
```

--------------------------------

### AI Services API

Source: https://docs.rs/crate/open-lark

Endpoints for AI-powered document parsing, OCR, language detection, and translation.

```APIDOC
## AI Services

### Description
Provides access to AI capabilities including resume parsing, OCR, language detection, and text translation.

### Methods
- **parse_resume**: Parses resume files.
- **basic_recognize**: Performs OCR on images.
- **detect**: Detects the language of the provided text.
- **translate**: Translates text between languages.
```

--------------------------------

### Attendance Event Listener

Source: https://docs.rs/crate/open-lark

Registers handlers for attendance-related events using the EventDispatcherHandler.

```rust
use open_lark::event::EventDispatcherHandler;

let handler = EventDispatcherHandler::builder()
    .register_p2_attendance_user_task_updated_v1(|event| {
        println!("收到打卡流水事件: {:?}", event);
    })
    .register_p2_attendance_user_task_status_change_v1(|event| {
        println!("收到任务状态变更事件: {:?}", event);
    })
    .build();
```

--------------------------------

### POST /attendance/v1/user_task

Source: https://docs.rs/crate/open-lark

Queries attendance task records for specific users within a date range.

```APIDOC
## POST /attendance/v1/user_task

### Description
Queries打卡记录 (attendance records) for specified users.

### Method
POST

### Parameters
#### Request Body
- **employee_type** (string) - Required - The type of employee identifier.
- **user_ids** (array) - Required - List of user IDs to query.
- **check_date_from** (string) - Required - Start date (YYYY-MM-DD).
- **check_date_to** (string) - Required - End date (YYYY-MM-DD).
```
Tokens:
Raw