@hecom/codearts 0.1.0

package/dist/services/api.service.d.ts

@@ -0,0 +1,98 @@
+import { AddIssueNotesRequest, AddIssueNotesResponse, ApiResponse, CachedToken, HuaweiCloudConfig, ListIssuesV4Request, ListIssuesV4Response, ListProjectIterationsV4Request, ListProjectIterationsV4Response, ProjectListResponse, ProjectMemberListResponse, ProjectMemberQueryParams, ProjectQueryParams, ShowProjectWorkHoursRequest, ShowProjectWorkHoursResponse } from '../types';
+/**
+ * 华为云CodeArts API服务类
+ * 支持IAM Token认证和CodeArts API调用
+ */
+export declare class ApiService {
+    private client;
+    private iamClient;
+    private config;
+    private cachedToken;
+    private enableLogging;
+    constructor(config: HuaweiCloudConfig);
+    /**
+     * 打印curl风格的请求日志
+     */
+    private logCurlRequest;
+    /**
+     * 设置请求和响应拦截器
+     */
+    private setupInterceptors;
+    /**
+     * 获取IAM Token
+     */
+    private getIamToken;
+    /**
+     * 检查Token是否有效（距离过期时间超过5分钟）
+     */
+    private isTokenValid;
+    /**
+     * 获取有效的Token（自动处理缓存和刷新）
+     */
+    private getValidToken;
+    /**
+     * 通用请求方法
+     */
+    private request;
+    /**
+     * 设置CodeArts API的基础URL
+     */
+    setCodeArtsBaseUrl(baseUrl: string): void;
+    /**
+     * 获取项目列表
+     */
+    getProjects(params?: ProjectQueryParams): Promise<ApiResponse<ProjectListResponse>>;
+    /**
+     * 获取指定项目的详细信息
+     */
+    getProjectById(projectId: string): Promise<ApiResponse<unknown>>;
+    /**
+     * 高级查询工作项 (ListIssuesV4)
+     * 根据筛选条件查询工作项
+     */
+    getIssues(projectId: string, params?: ListIssuesV4Request): Promise<ApiResponse<ListIssuesV4Response>>;
+    /**
+     * 获取指定工作项的详细信息
+     */
+    getIssueById(projectId: string, issueId: string): Promise<ApiResponse<unknown>>;
+    /**
+     * 创建工作项
+     */
+    createIssue(projectId: string, issueData: unknown): Promise<ApiResponse<unknown>>;
+    /**
+     * 更新工作项
+     */
+    updateIssue(projectId: string, issueId: string, issueData: unknown): Promise<ApiResponse<unknown>>;
+    /**
+     * 删除工作项
+     */
+    deleteIssue(projectId: string, issueId: string): Promise<ApiResponse<unknown>>;
+    /**
+     * 获取项目的迭代列表
+     */
+    getIterations(projectId: string, params?: ListProjectIterationsV4Request): Promise<ApiResponse<ListProjectIterationsV4Response>>;
+    /**
+     * 获取指定迭代的详细信息
+     */
+    getIterationById(projectId: string, iterationId: string): Promise<ApiResponse<unknown>>;
+    /**
+     * 获取项目成员列表
+     */
+    getMembers(projectId: string, params?: ProjectMemberQueryParams): Promise<ApiResponse<ProjectMemberListResponse>>;
+    /**
+     * 按用户查询工时（单项目）
+     */
+    showProjectWorkHours(projectId: string, params?: ShowProjectWorkHoursRequest): Promise<ApiResponse<ShowProjectWorkHoursResponse>>;
+    /**
+     * 工作项添加评论
+     */
+    addIssueNotes(params: AddIssueNotesRequest): Promise<ApiResponse<AddIssueNotesResponse>>;
+    /**
+     * 获取当前Token信息（用于调试）
+     */
+    getTokenInfo(): CachedToken | null;
+    /**
+     * 手动刷新Token
+     */
+    refreshToken(): Promise<string>;
+}

package/dist/services/api.service.js

@@ -0,0 +1,405 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiService = void 0;
+const axios_1 = __importDefault(require("axios"));
+/**
+ * 华为云CodeArts API服务类
+ * 支持IAM Token认证和CodeArts API调用
+ */
+class ApiService {
+    constructor(config) {
+        this.cachedToken = null;
+        this.config = {
+            ...config,
+        };
+        this.enableLogging = config.enableLogging ?? false;
+        // 初始化IAM客户端（用于获取Token）
+        this.iamClient = axios_1.default.create({
+            baseURL: this.config.iamEndpoint,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        // 初始化主客户端（用于调用CodeArts API）
+        this.client = axios_1.default.create({
+            baseURL: this.config.endpoint,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        this.setupInterceptors();
+    }
+    /**
+     * 打印curl风格的请求日志
+     */
+    logCurlRequest(config, clientType = 'CodeArts') {
+        if (!this.enableLogging) {
+            return;
+        }
+        const baseUrl = config.baseURL || '';
+        const url = config.url?.startsWith('http') ? config.url : `${baseUrl}${config.url}`;
+        const method = (config.method || 'GET').toUpperCase();
+        let curlCmd = `curl -X ${method}`;
+        // 添加请求头
+        if (config.headers && typeof config.headers === 'object') {
+            Object.entries(config.headers).forEach(([key, value]) => {
+                if (value && typeof value === 'string') {
+                    // 对敏感信息进行脱敏处理
+                    let headerValue = value;
+                    if (key.toLowerCase().includes('token') || key.toLowerCase().includes('auth')) {
+                        headerValue = value.length > 8 ? `${value.substring(0, 8)}...` : '***';
+                    }
+                    curlCmd += ` \\\n  -H "${key}: ${headerValue}"`;
+                }
+            });
+        }
+        // 添加查询参数
+        let finalUrl = url;
+        if (config.params && Object.keys(config.params).length > 0) {
+            const searchParams = new URLSearchParams();
+            Object.entries(config.params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    searchParams.append(key, String(value));
+                }
+            });
+            const queryString = searchParams.toString();
+            if (queryString) {
+                const separator = url.includes('?') ? '&' : '?';
+                finalUrl = `${url}${separator}${queryString}`;
+            }
+        }
+        curlCmd += ` \\\n  "${finalUrl}"`;
+        // 添加请求体
+        if (config.data) {
+            let dataStr = '';
+            if (typeof config.data === 'string') {
+                dataStr = config.data;
+            }
+            else if (typeof config.data === 'object') {
+                dataStr = JSON.stringify(config.data, null, 2);
+            }
+            // 如果数据太长，进行截断显示
+            if (dataStr.length > 500) {
+                const truncated = dataStr.substring(0, 500);
+                curlCmd += ` \\\n  -d '${truncated}...'`;
+            }
+            else {
+                curlCmd += ` \\\n  -d '${dataStr}'`;
+            }
+        }
+        const emoji = clientType === 'IAM' ? '🔐' : '🔄';
+        console.log(`\n${emoji} ${clientType}请求 [${method}]:`);
+        console.log(curlCmd);
+        console.log('');
+    }
+    /**
+     * 设置请求和响应拦截器
+     */
+    setupInterceptors() {
+        // IAM客户端拦截器
+        this.iamClient.interceptors.request.use((config) => {
+            // 打印curl风格的IAM请求日志
+            this.logCurlRequest(config, 'IAM');
+            return config;
+        }, (error) => {
+            console.error('IAM请求错误:', error);
+            return Promise.reject(error);
+        });
+        this.iamClient.interceptors.response.use((response) => {
+            return response;
+        }, (error) => {
+            if (this.enableLogging) {
+                console.error('IAM响应错误:', error.response?.data || error.message);
+            }
+            return Promise.reject(error);
+        });
+        // 主客户端拦截器
+        this.client.interceptors.request.use(async (config) => {
+            // 自动添加Token到请求头
+            const token = await this.getValidToken();
+            if (token) {
+                config.headers['X-Auth-Token'] = token;
+            }
+            // 添加项目ID到请求头（如果有）
+            if (this.cachedToken?.projectId) {
+                config.headers['X-Project-Id'] = this.cachedToken.projectId;
+            }
+            // 打印curl风格的请求日志
+            this.logCurlRequest(config);
+            return config;
+        }, (error) => {
+            console.error('CodeArts请求错误:', error);
+            return Promise.reject(error);
+        });
+        this.client.interceptors.response.use((response) => {
+            return response;
+        }, async (error) => {
+            const originalRequest = error.config;
+            // 如果是401错误且没有重试过，尝试刷新Token
+            if (error.response?.status === 401 && !originalRequest._retry) {
+                originalRequest._retry = true;
+                try {
+                    this.cachedToken = null; // 清除缓存的Token
+                    const newToken = await this.getValidToken();
+                    if (newToken) {
+                        originalRequest.headers['X-Auth-Token'] = newToken;
+                        return this.client(originalRequest);
+                    }
+                }
+                catch (refreshError) {
+                    console.error('刷新Token失败:', refreshError);
+                }
+            }
+            console.error('CodeArts响应错误:', error.response?.data || error.message);
+            return Promise.reject(error);
+        });
+    }
+    /**
+     * 获取IAM Token
+     */
+    async getIamToken() {
+        const requestBody = {
+            auth: {
+                identity: {
+                    methods: ['password'],
+                    password: {
+                        user: {
+                            name: this.config.username,
+                            password: this.config.password,
+                            domain: {
+                                name: this.config.domainName,
+                            },
+                        },
+                    },
+                },
+                scope: {
+                    project: {
+                        name: this.config.region,
+                    },
+                },
+            },
+        };
+        try {
+            const response = await this.iamClient.post('/v3/auth/tokens', requestBody);
+            const token = response.headers['x-subject-token'];
+            if (!token) {
+                throw new Error('未能从响应头获取到Token');
+            }
+            const tokenData = response.data.token;
+            const expiresAt = new Date(tokenData.expires_at);
+            const issuedAt = new Date(tokenData.issued_at);
+            return {
+                token,
+                expiresAt,
+                issuedAt,
+                projectId: tokenData.project?.id,
+                projectName: tokenData.project?.name,
+            };
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                const errorMsg = error.response?.data?.error?.message || error.message;
+                throw new Error(`获取IAM Token失败: ${errorMsg}`);
+            }
+            throw new Error(`获取IAM Token失败: ${String(error)}`);
+        }
+    }
+    /**
+     * 检查Token是否有效（距离过期时间超过5分钟）
+     */
+    isTokenValid(token) {
+        const now = new Date();
+        const timeToExpire = token.expiresAt.getTime() - now.getTime();
+        const fiveMinutes = 5 * 60 * 1000; // 5分钟的毫秒数
+        return timeToExpire > fiveMinutes;
+    }
+    /**
+     * 获取有效的Token（自动处理缓存和刷新）
+     */
+    async getValidToken() {
+        if (this.cachedToken && this.isTokenValid(this.cachedToken)) {
+            return this.cachedToken.token;
+        }
+        this.cachedToken = await this.getIamToken();
+        return this.cachedToken.token;
+    }
+    /**
+     * 通用请求方法
+     */
+    async request(url, options = {}) {
+        try {
+            const config = {
+                url,
+                method: options.method || 'GET',
+                headers: options.headers,
+                params: options.params,
+                data: options.data,
+            };
+            const response = await this.client.request(config);
+            return {
+                success: true,
+                data: response.data,
+                message: 'Request successful',
+            };
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                return {
+                    success: false,
+                    data: null,
+                    error: error.response?.data?.error_msg || error.response?.data?.message || error.message,
+                };
+            }
+            return {
+                success: false,
+                data: null,
+                error: String(error),
+            };
+        }
+    }
+    /**
+     * 设置CodeArts API的基础URL
+     */
+    setCodeArtsBaseUrl(baseUrl) {
+        this.client.defaults.baseURL = baseUrl;
+    }
+    /**
+     * 获取项目列表
+     */
+    async getProjects(params) {
+        return this.request('/v4/projects', {
+            method: 'GET',
+            params: {
+                offset: 0,
+                limit: 10,
+                ...params,
+            },
+        });
+    }
+    /**
+     * 获取指定项目的详细信息
+     */
+    async getProjectById(projectId) {
+        return this.request(`/v4/projects/${projectId}`, {
+            method: 'GET',
+        });
+    }
+    /**
+     * 高级查询工作项 (ListIssuesV4)
+     * 根据筛选条件查询工作项
+     */
+    async getIssues(projectId, params) {
+        return this.request(`/v4/projects/${projectId}/issues`, {
+            method: 'POST',
+            data: {
+                offset: 0,
+                limit: 100,
+                query_type: 'backlog',
+                ...params,
+            },
+        });
+    }
+    /**
+     * 获取指定工作项的详细信息
+     */
+    async getIssueById(projectId, issueId) {
+        return this.request(`/v4/projects/${projectId}/issues/${issueId}`, {
+            method: 'GET',
+        });
+    }
+    /**
+     * 创建工作项
+     */
+    async createIssue(projectId, issueData) {
+        return this.request(`/v4/projects/${projectId}/issues`, {
+            method: 'POST',
+            data: issueData,
+        });
+    }
+    /**
+     * 更新工作项
+     */
+    async updateIssue(projectId, issueId, issueData) {
+        return this.request(`/v4/projects/${projectId}/issues/${issueId}`, {
+            method: 'PUT',
+            data: issueData,
+        });
+    }
+    /**
+     * 删除工作项
+     */
+    async deleteIssue(projectId, issueId) {
+        return this.request(`/v4/projects/${projectId}/issues/${issueId}`, {
+            method: 'DELETE',
+        });
+    }
+    /**
+     * 获取项目的迭代列表
+     */
+    async getIterations(projectId, params) {
+        return this.request(`/v4/projects/${projectId}/iterations`, {
+            method: 'GET',
+            params: params,
+        });
+    }
+    /**
+     * 获取指定迭代的详细信息
+     */
+    async getIterationById(projectId, iterationId) {
+        return this.request(`/v4/projects/${projectId}/iterations/${iterationId}`, {
+            method: 'GET',
+        });
+    }
+    /**
+     * 获取项目成员列表
+     */
+    async getMembers(projectId, params) {
+        return this.request(`/v4/projects/${projectId}/members`, {
+            method: 'GET',
+            params: {
+                offset: 0,
+                limit: 100,
+                ...params,
+            },
+        });
+    }
+    /**
+     * 按用户查询工时（单项目）
+     */
+    async showProjectWorkHours(projectId, params) {
+        return this.request(`/v4/projects/${projectId}/work-hours`, {
+            method: 'POST',
+            data: {
+                offset: 0,
+                limit: 10,
+                ...params,
+            },
+        });
+    }
+    /**
+     * 工作项添加评论
+     */
+    async addIssueNotes(params) {
+        return this.request('/v2/issues/update-issue-notes', {
+            method: 'POST',
+            data: params,
+        });
+    }
+    /**
+     * 获取当前Token信息（用于调试）
+     */
+    getTokenInfo() {
+        return this.cachedToken;
+    }
+    /**
+     * 手动刷新Token
+     */
+    async refreshToken() {
+        this.cachedToken = null;
+        return this.getValidToken();
+    }
+}
+exports.ApiService = ApiService;

package/dist/services/business.service.d.ts

@@ -0,0 +1,69 @@
+import { AllWorkHourStats, HuaweiCloudConfig, IssueDetailResponseV2, IssueItem, IterationInfo, ProjectMember, WorkHourStats, WorkProgressStats } from '../types';
+import { ApiService } from './api.service';
+/**
+ * 业务服务类
+ * 提供面向业务场景的高级操作，封装ApiService的底层调用
+ */
+export declare class BusinessService {
+    private apiService;
+    constructor(config: HuaweiCloudConfig);
+    /**
+     * 获取底层ApiService实例
+     * 用于需要直接访问API服务的场景
+     */
+    getApiService(): ApiService;
+    /**
+     * 通过角色ID获取项目成员
+     * @param projectId 项目ID
+     * @param roleId 角色ID
+     * @returns 指定角色的成员列表
+     */
+    getMembersByRoleId(projectId: string, roleId: number): Promise<ProjectMember[]>;
+    /**
+     * 获取指定日期之后的迭代列表
+     * @param projectId 项目ID
+     * @param targetDate 目标日期，格式：YYYY-MM-DD
+     * @returns 正在进行中的和未来的迭代列表
+     */
+    getActiveIterationsOnDate(projectId: string, targetDate: string): Promise<IterationInfo[]>;
+    /**
+     * 根据多个迭代ID和用户ID列表查询工作量列表（仅Task）
+     * @param projectId 项目ID
+     * @param iterationIds 迭代ID列表
+     * @param userIds 用户ID列表
+     * @returns Task类型的工作项列表
+     */
+    getWorkloadByIterationsAndUsers(projectId: string, iterationIds: number[], userIds: string[]): Promise<IssueItem[]>;
+    /**
+     * 根据迭代ID和用户ID列表查询工作量列表（仅Task和Story）
+     * @param projectId 项目ID
+     * @param iterationId 迭代ID
+     * @param userIds 用户ID列表
+     * @returns Task和Story类型的工作项列表
+     */
+    getWorkloadByIterationAndUsers(projectId: string, iterationId: number, userIds: string[]): Promise<IssueItem[]>;
+    addIssueNote(projectId: string, issueId: number, content: string): Promise<IssueDetailResponseV2>;
+    /**
+     * 统计工作项进度信息
+     * @param issues 工作项列表
+     * @returns 工作项进度统计结果，包括总体统计和按用户分组统计
+     */
+    calculateWorkProgress(issues: IssueItem[]): WorkProgressStats;
+    /**
+     * 查询指定用户在指定日期的工时统计
+     * @param projectId 项目ID
+     * @param userIds 用户ID列表
+     * @param date 查询日期，格式：YYYY-MM-DD
+     * @returns 工时统计结果，包括总工时和按用户分组的工时详情
+     */
+    getDailyWorkHourStats(projectId: string, userIds: string[], date: string): Promise<WorkHourStats>;
+    /**
+     * 查询指定用户在指定时间段内的所有工时统计（按人和领域分组）
+     * @param projectId 项目ID
+     * @param userIds 用户ID列表
+     * @param beginDate 开始日期，格式：YYYY-MM-DD
+     * @param endDate 结束日期，格式：YYYY-MM-DD
+     * @returns 工时统计结果，按用户和领域两个维度分组
+     */
+    getAllWorkHourStats(projectId: string, userIds: string[], beginDate: string, endDate: string): Promise<AllWorkHourStats>;
+}