Mud Tools

接口名称

职务管理API（租户令牌）- IFeishuTenantV3JobTitle

功能描述

职务是用户属性之一，通过职务API仅支持查询职务信息。当前接口使用租户令牌访问，适用于租户应用场景。职务API主要用于获取企业中定义的各种职务信息，包括职务ID、名称、多语言名称以及启用状态等，为用户管理和组织架构管理提供基础数据支持。

参考文档

https://open.feishu.cn/document/contact-v3/job_title/job-title-resources-introduction

函数列表

函数名称	功能描述	认证方式	HTTP 方法
GetJobTitlesListAsync	获取职务列表	租户令牌	GET
GetJobTitleByIdAsync	获取指定职务信息	租户令牌	GET

函数详细内容

函数名称：获取职务列表

函数签名：

csharp

Task<FeishuApiPageListResult<JobTitle>?> GetJobTitlesListAsync(
    [Query("page_size")] int? page_size = 10,
    [Query("page_token")] string? page_token = null,
    CancellationToken cancellationToken = default);

认证：租户令牌

参数：

参数名	类型	必填	说明
page_size	int?	⚪ 可选	分页大小，默认10，最大50
page_token	string	⚪ 可选	分页标记，首次请求不填

响应：

json

{
  "code": 0,
  "msg": "success",
  "data": {
    "items": [
      {
        "job_title_id": "jt_1234567890",
        "name": "软件工程师",
        "status": true,
        "i18n_name": [
          {
            "locale": "zh_cn",
            "text": "软件工程师"
          },
          {
            "locale": "en_us",
            "text": "Software Engineer"
          }
        ]
      },
      {
        "job_title_id": "jt_1234567891",
        "name": "产品经理",
        "status": true,
        "i18n_name": [
          {
            "locale": "zh_cn",
            "text": "产品经理"
          },
          {
            "locale": "en_us",
            "text": "Product Manager"
          }
        ]
      }
    ],
    "page_token": "next_page_token",
    "has_more": true
  }
}

说明：

获取当前租户下的所有职务信息
支持分页查询，适合处理大量职务数据
返回职务的基本信息，包括ID、名称、多语言名称和启用状态
使用租户令牌可以获取所有职务的完整信息

代码示例：

javascript

// 获取所有职务信息
async function getAllJobTitles() {
  let hasMore = true;
  let pageToken = null;
  const allJobTitles = [];
  let pageCount = 0;

  while (hasMore) {
    pageCount++;
    console.log(`正在获取第 ${pageCount} 页职务数据...`);
    
    const result = await feishuTenantV3JobTitle.getJobTitlesListAsync(
      50, // 每页获取更多数据
      pageToken
    );

    if (result.code === 0) {
      const jobTitles = result.data.items;
      allJobTitles.push(...jobTitles);
      hasMore = result.data.has_more;
      pageToken = result.data.page_token;
      
      console.log(`第 ${pageCount} 页获取到 ${jobTitles.length} 个职务`);
    } else {
      console.error(`第 ${pageCount} 页获取失败:`, result.msg);
      break;
    }
  }

  return allJobTitles;
}

// 分析职务信息
async function analyzeJobTitles() {
  console.log("正在分析职务信息...");
  
  const jobTitles = await getAllJobTitles();
  
  if (jobTitles.length === 0) {
    console.log("未找到任何职务信息");
    return;
  }

  console.log(`\n=== 职务概览 ===`);
  console.log(`总职务数: ${jobTitles.length}`);
  
  // 按状态分类统计
  const activeJobTitles = jobTitles.filter(jt => jt.status);
  const inactiveJobTitles = jobTitles.filter(jt => !jt.status);
  
  console.log(`启用职务: ${activeJobTitles.length}`);
  console.log(`禁用职务: ${inactiveJobTitles.length}`);
  
  // 统计多语言配置情况
  const withI18n = jobTitles.filter(jt => jt.i18n_name && jt.i18n_name.length > 0);
  const withoutI18n = jobTitles.filter(jt => !jt.i18n_name || jt.i18n_name.length === 0);
  
  console.log(`配置多语言: ${withI18n.length}`);
  console.log(`未配置多语言: ${withoutI18n.length}`);
  
  // 按职务类型分类（基于名称分析）
  const techTitles = jobTitles.filter(jt => 
    ['工程师', '开发', '技术', '架构', '算法', '测试'].some(keyword => 
      jt.name.includes(keyword)
    )
  );
  
  const productTitles = jobTitles.filter(jt => 
    ['产品', '设计', '运营', '市场'].some(keyword => 
      jt.name.includes(keyword)
    )
  );
  
  const managementTitles = jobTitles.filter(jt => 
    ['总监', '经理', '主管', '负责人', '董事长', 'CEO', 'CTO'].some(keyword => 
      jt.name.includes(keyword)
    )
  );
  
  console.log(`\n=== 职务分类统计 ===`);
  console.log(`技术类职务: ${techTitles.length}`);
  console.log(`产品类职务: ${productTitles.length}`);
  console.log(`管理类职务: ${managementTitles.length}`);
  
  // 显示所有职务
  console.log(`\n=== 职务详细列表 ===`);
  jobTitles.forEach((jobTitle, index) => {
    const status = jobTitle.status ? '✓ 启用' : '✗ 禁用';
    const i18nCount = jobTitle.i18n_name ? jobTitle.i18n_name.length : 0;
    
    console.log(`${index + 1}. ${jobTitle.name} (${jobTitle.job_title_id}) [${status}]`);
    console.log(`   多语言: ${i18nCount} 种语言`);
    
    // 显示多语言配置
    if (jobTitle.i18n_name && jobTitle.i18n_name.length > 0) {
      const languages = jobTitle.i18n_name.map(item => item.locale).join(', ');
      console.log(`   语言: ${languages}`);
    }
  });
  
  return jobTitles;
}

// 搜索特定职务
async function searchJobTitles(keyword) {
  console.log(`正在搜索包含 "${keyword}" 的职务...`);
  
  const allJobTitles = await getAllJobTitles();
  const matchedTitles = allJobTitles.filter(jt => 
    jt.name.toLowerCase().includes(keyword.toLowerCase())
  );
  
  if (matchedTitles.length === 0) {
    console.log(`未找到包含 "${keyword}" 的职务`);
    return [];
  }
  
  console.log(`\n找到 ${matchedTitles.length} 个匹配的职务:`);
  matchedTitles.forEach((jobTitle, index) => {
    const status = jobTitle.status ? '启用' : '禁用';
    console.log(`${index + 1}. ${jobTitle.name} (${jobTitle.job_title_id}) [${status}]`);
    
    if (jobTitle.i18n_name && jobTitle.i18n_name.length > 0) {
      console.log(`   多语言名称:`);
      jobTitle.i18n_name.forEach(item => {
        console.log(`     ${item.locale}: ${item.text}`);
      });
    }
  });
  
  return matchedTitles;
}

// 导出职务数据
async function exportJobTitles() {
  console.log("正在导出职务数据...");
  
  const jobTitles = await getAllJobTitles();
  
  if (jobTitles.length === 0) {
    console.log("没有职务数据可导出");
    return;
  }
  
  // 创建导出数据
  const exportData = jobTitles.map(jt => {
    const languages = {};
    if (jt.i18n_name) {
      jt.i18n_name.forEach(item => {
        languages[item.locale] = item.text;
      });
    }
    
    return {
      id: jt.job_title_id,
      name: jt.name,
      status: jt.status ? '启用' : '禁用',
      languages: languages,
      language_count: jt.i18n_name ? jt.i18n_name.length : 0
    };
  });
  
  console.log(`\n=== 导出数据概览 ===`);
  console.log(`总职务数: ${exportData.length}`);
  console.log(`启用职务: ${exportData.filter(d => d.status === '启用').length}`);
  console.log(`禁用职务: ${exportData.filter(d => d.status === '禁用').length}`);
  
  console.log('\n=== 职务数据 ===');
  exportData.forEach((data, index) => {
    console.log(`${index + 1}. ${data.name}`);
    console.log(`   ID: ${data.id}`);
    console.log(`   状态: ${data.status}`);
    console.log(`   语言数: ${data.language_count}`);
    if (Object.keys(data.languages).length > 0) {
      console.log(`   多语言: ${JSON.stringify(data.languages, null, 2)}`);
    }
  });
  
  return exportData;
}

// 使用示例
analyzeJobTitles();
searchJobTitles("工程师");
exportJobTitles();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

函数名称：获取指定职务信息

函数签名：

csharp

Task<FeishuApiResult<JobTitleResult>?> GetJobTitleByIdAsync(
    [Path] string job_title_id,
    CancellationToken cancellationToken = default);

认证：租户令牌

参数：

参数名	类型	必填	说明
job_title_id	string	✅ 必填	职务ID

响应：

json

{
  "code": 0,
  "msg": "success",
  "data": {
    "job_title": {
      "job_title_id": "jt_1234567890",
      "name": "软件工程师",
      "status": true,
      "i18n_name": [
        {
          "locale": "zh_cn",
          "text": "软件工程师"
        },
        {
          "locale": "en_us",
          "text": "Software Engineer"
        },
        {
          "locale": "ja_jp",
          "text": "ソフトウェアエンジニア"
        }
      ]
    }
  }
}

说明：

获取指定职务的详细信息
返回职务的完整属性信息
包含多语言配置和状态信息
使用租户令牌可以获取所有职务的完整信息

代码示例：

javascript

// 获取并分析职务详细信息
async function analyzeJobTitle(jobTitleId) {
  console.log(`正在获取职务 ${jobTitleId} 的详细信息...`);
  
  const result = await feishuTenantV3JobTitle.getJobTitleByIdAsync(jobTitleId);
  
  if (result.code === 0) {
    const jobTitle = result.data.job_title;
    
    console.log("\n=== 职务详细信息 ===");
    console.log(`职务ID: ${jobTitle.job_title_id}`);
    console.log(`职务名称: ${jobTitle.name}`);
    console.log(`启用状态: ${jobTitle.status ? '启用' : '禁用'}`);
    
    // 显示多语言配置
    if (jobTitle.i18n_name && jobTitle.i18n_name.length > 0) {
      console.log(`\n=== 多语言配置 ===`);
      console.log(`支持语言数: ${jobTitle.i18n_name.length}`);
      
      jobTitle.i18n_name.forEach(item => {
        console.log(`  ${item.locale}: ${item.text}`);
      });
      
      // 分析语言覆盖情况
      const languages = jobTitle.i18n_name.map(item => item.locale);
      const hasChinese = languages.includes('zh_cn');
      const hasEnglish = languages.includes('en_us');
      const hasJapanese = languages.includes('ja_jp');
      
      console.log(`\n=== 语言覆盖分析 ===`);
      console.log(`中文支持: ${hasChinese ? '✓' : '✗'}`);
      console.log(`英文支持: ${hasEnglish ? '✓' : '✗'}`);
      console.log(`日文支持: ${hasJapanese ? '✓' : '✗'}`);
    } else {
      console.log("该职务未配置多语言信息");
    }
    
    // 分析职务层级
    console.log(`\n=== 职务层级分析 ===`);
    const title = jobTitle.name;
    
    if (['助理', '专员', '实习', '初级'].some(keyword => title.includes(keyword))) {
      console.log("职务层级: 初级职务");
    } else if (['工程师', '主管', '经理'].some(keyword => title.includes(keyword))) {
      console.log("职务层级: 中级职务");
    } else if (['总监', '副总裁', 'VP', 'CTO', 'CEO'].some(keyword => title.includes(keyword))) {
      console.log("职务层级: 高级管理职务");
    } else {
      console.log("职务层级: 其他职务");
    }
    
    // 分析职务类型
    console.log(`\n=== 职务类型分析 ===`);
    if (['工程师', '开发', '技术', '架构', '算法', '测试', 'DevOps'].some(keyword => title.includes(keyword))) {
      console.log("职务类型: 技术类职务");
    } else if (['产品', '设计', '运营', '市场', '品牌'].some(keyword => title.includes(keyword))) {
      console.log("职务类型: 产品运营类职务");
    } else if (['经理', '总监', '主管', '负责人', '董事长', 'CEO', 'CTO', 'CFO'].some(keyword => title.includes(keyword))) {
      console.log("职务类型: 管理类职务");
    } else if (['销售', '商务', '客户', 'BD'].some(keyword => title.includes(keyword))) {
      console.log("职务类型: 销售商务类职务");
    } else if (['人事', '财务', '行政', '法务', 'HR', 'Finance'].some(keyword => title.includes(keyword))) {
      console.log("职务类型: 职能支持类职务");
    } else {
      console.log("职务类型: 其他职务");
    }
    
    return jobTitle;
  } else {
    console.error("获取职务信息失败:", result.msg);
    
    // 错误处理
    switch (result.code) {
      case 404:
        console.log("职务不存在或已被删除");
        break;
      case 403:
        console.log("权限不足，无法查看该职务信息");
        break;
      default:
        console.log("获取失败，请稍后重试");
    }
    
    return null;
  }
}

// 批量分析多个职务
async function batchAnalyzeJobTitles(jobTitleIds) {
  console.log(`准备批量分析 ${jobTitleIds.length} 个职务...`);
  
  const analysisResults = [];
  
  for (const jobTitleId of jobTitleIds) {
    console.log(`\n正在分析职务: ${jobTitleId}`);
    const jobTitle = await analyzeJobTitle(jobTitleId);
    
    if (jobTitle) {
      analysisResults.push(jobTitle);
    }
    
    // 添加延迟避免请求过于频繁
    await new Promise(resolve => setTimeout(resolve, 100));
  }
  
  // 统计分析结果
  console.log(`\n=== 批量分析结果 ===`);
  console.log(`成功分析: ${analysisResults.length} 个职务`);
  console.log(`失败分析: ${jobTitleIds.length - analysisResults.length} 个职务`);
  
  if (analysisResults.length > 0) {
    const activeCount = analysisResults.filter(jt => jt.status).length;
    const withI18nCount = analysisResults.filter(jt => jt.i18n_name && jt.i18n_name.length > 0).length;
    
    console.log(`启用职务: ${activeCount}`);
    console.log(`配置多语言: ${withI18nCount}`);
    
    // 显示所有分析结果
    console.log(`\n=== 分析结果列表 ===`);
    analysisResults.forEach((jobTitle, index) => {
      const status = jobTitle.status ? '启用' : '禁用';
      const i18nCount = jobTitle.i18n_name ? jobTitle.i18n_name.length : 0;
      
      console.log(`${index + 1}. ${jobTitle.name} (${jobTitle.job_title_id}) [${status}] [${i18nCount}语言]`);
    });
  }
  
  return analysisResults;
}

// 验证职务信息完整性
async function validateJobTitle(jobTitleId) {
  console.log(`正在验证职务 ${jobTitleId} 的信息完整性...`);
  
  const jobTitle = await analyzeJobTitle(jobTitleId);
  
  if (!jobTitle) {
    console.log("职务信息验证失败：无法获取职务信息");
    return false;
  }
  
  let isValid = true;
  const issues = [];
  
  // 检查基本信息
  if (!jobTitle.job_title_id || jobTitle.job_title_id.trim() === '') {
    issues.push("职务ID为空");
    isValid = false;
  }
  
  if (!jobTitle.name || jobTitle.name.trim() === '') {
    issues.push("职务名称为空");
    isValid = false;
  }
  
  // 检查多语言配置
  if (!jobTitle.i18n_name || jobTitle.i18n_name.length === 0) {
    issues.push("未配置多语言名称");
  } else {
    // 检查是否包含主要语言
    const languages = jobTitle.i18n_name.map(item => item.locale);
    
    if (!languages.includes('zh_cn')) {
      issues.push("缺少中文配置");
    }
    
    if (!languages.includes('en_us')) {
      issues.push("缺少英文配置");
    }
    
    // 检查多语言内容是否完整
    jobTitle.i18n_name.forEach(item => {
      if (!item.text || item.text.trim() === '') {
        issues.push(`语言 ${item.locale} 的内容为空`);
      }
    });
  }
  
  // 检查状态
  if (typeof jobTitle.status !== 'boolean') {
    issues.push("职务状态格式不正确");
  }
  
  console.log(`\n=== 验证结果 ===`);
  console.log(`验证${isValid ? '通过' : '失败'}`);
  
  if (issues.length > 0) {
    console.log('\n发现问题:');
    issues.forEach((issue, index) => {
      console.log(`${index + 1}. ${issue}`);
    });
  } else {
    console.log('✓ 职务信息完整且格式正确');
  }
  
  return isValid;
}

// 使用示例
analyzeJobTitle("jt_1234567890");
batchAnalyzeJobTitles(["jt_1234567890", "jt_1234567891", "jt_1234567892"]);
validateJobTitle("jt_1234567890");

部门管理

员工管理

用户管理

用户组管理

职位管理

角色管理

工作城市管理

接口名称

功能描述

参考文档

函数列表

函数详细内容

函数名称：获取职务列表

函数名称：获取指定职务信息

接口名称 ​

功能描述 ​

参考文档 ​

函数列表 ​

函数详细内容 ​

函数名称：获取职务列表 ​

函数名称：获取指定职务信息 ​

接口名称

功能描述

参考文档

函数列表

函数详细内容

函数名称：获取职务列表

函数名称：获取指定职务信息