import { API_BASE_URL, request } from "./request";
|
import type { PageResult } from "./basic-data";
|
|
const header = (accessToken: string) => ({ Authorization: `Bearer ${accessToken}` });
|
|
type QueryValue = string | number | boolean | string[] | number[] | undefined;
|
|
function query(params: Record<string, QueryValue>) {
|
const parts: string[] = [];
|
Object.entries(params).forEach(([key, value]) => {
|
if (value === undefined || value === null || value === "") return;
|
const list = Array.isArray(value) ? value : [value];
|
list.forEach(item => {
|
if (item === undefined || item === null || item === "") return;
|
parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
|
});
|
});
|
return parts.length ? `?${parts.join("&")}` : "";
|
}
|
|
/* ---------- 通用结构 ---------- */
|
|
export interface BpmUser {
|
id?: number;
|
username?: string;
|
nickname?: string;
|
mobile?: string;
|
avatar?: string;
|
deptId?: number;
|
}
|
|
export interface BpmSummaryItem {
|
key?: string;
|
value?: string;
|
}
|
|
/** 流程分类（/bpm/category/simple-list） */
|
export interface BpmCategory {
|
id?: number;
|
name?: string;
|
code?: string;
|
status?: number;
|
description?: string;
|
sort?: number;
|
}
|
|
/** 表单字段权限：'1' 只读 / '2' 可写 / '3' 隐藏 */
|
export type BpmFieldPermission = Record<string, string>;
|
|
/** 流程定义（/bpm/process-definition/*） */
|
export interface BpmProcessDefinition {
|
id?: string;
|
key?: string;
|
name?: string;
|
description?: string;
|
category?: string;
|
icon?: string;
|
/** 10 BPMN / 20 SIMPLE */
|
modelType?: number;
|
/** 10 流程表单 / 20 业务表单 */
|
formType?: number;
|
formCustomCreatePath?: string;
|
formCustomViewPath?: string;
|
/** 表单全局配置（JSON 字符串） */
|
formConf?: string;
|
/** 表单字段规则（每条为 JSON 字符串） */
|
formFields?: string[];
|
suspensionState?: number;
|
version?: number;
|
}
|
|
/** 流程实例（/bpm/process-instance/*） */
|
export interface BpmProcessInstance {
|
id?: string;
|
name?: string;
|
summary?: BpmSummaryItem[];
|
category?: string;
|
categoryName?: string;
|
/** -1 未开始 / 1 审批中 / 2 通过 / 3 不通过 / 4 已取消 */
|
status?: number;
|
/** 毫秒时间戳，部分接口返回 "yyyy-MM-dd HH:mm:ss" 字符串 */
|
startTime?: number | string;
|
endTime?: number | string;
|
createTime?: number | string;
|
processDefinitionId?: string;
|
processDefinitionKey?: string;
|
processDefinition?: BpmProcessDefinition;
|
startUser?: BpmUser;
|
/** 字段名 -> 值 */
|
formVariables?: Record<string, any>;
|
businessKey?: string;
|
tasks?: BpmTask[];
|
}
|
|
/** 任务（/bpm/task/*） */
|
export interface BpmTask {
|
id?: string;
|
name?: string;
|
/** 0 待审批 / 1 审批中 / 2 通过 / 3 不通过 / 4 已取消 / 5 退回 / 7 审批通过中 */
|
status?: number;
|
/** 毫秒时间戳，部分接口返回 "yyyy-MM-dd HH:mm:ss" 字符串 */
|
createTime?: number | string;
|
endTime?: number | string;
|
startTime?: number | string;
|
durationInMillis?: number;
|
reason?: string;
|
processInstanceId?: string;
|
processInstance?: BpmProcessInstance;
|
taskDefinitionKey?: string;
|
assigneeUser?: BpmUser;
|
ownerUser?: BpmUser;
|
formId?: number;
|
signEnable?: boolean;
|
children?: BpmTask[];
|
buttonsSetting?: Record<string, { enable?: boolean; displayName?: string }>;
|
}
|
|
/** 抄送（/bpm/process-instance/copy/page） */
|
export interface BpmProcessInstanceCopy {
|
id?: number;
|
activityId?: string;
|
activityName?: string;
|
createTime?: number | string;
|
createUser?: BpmUser;
|
processInstanceId?: string;
|
processInstanceName?: string;
|
processInstanceStartTime?: number | string;
|
reason?: string;
|
startUser?: BpmUser;
|
summary?: BpmSummaryItem[];
|
taskId?: string;
|
}
|
|
/** 审批节点（时间线 / 流转记录） */
|
export interface BpmApprovalNode {
|
id?: string;
|
name?: string;
|
nodeType?: number;
|
candidateStrategy?: number;
|
candidateUsers?: BpmUser[];
|
status?: number;
|
/** 毫秒时间戳，部分接口返回 "yyyy-MM-dd HH:mm:ss" 字符串 */
|
startTime?: number | string;
|
endTime?: number | string;
|
processInstanceId?: string;
|
tasks?: BpmApprovalTaskInfo[];
|
}
|
|
export interface BpmApprovalTaskInfo {
|
id?: number;
|
assigneeUser?: BpmUser;
|
ownerUser?: BpmUser;
|
reason?: string;
|
signPicUrl?: string;
|
status?: number;
|
attachments?: string[];
|
}
|
|
/** 审批详情（/bpm/process-instance/get-approval-detail） */
|
export interface BpmApprovalDetail {
|
activityNodes?: BpmApprovalNode[];
|
formFieldsPermission?: BpmFieldPermission;
|
processDefinition?: BpmProcessDefinition;
|
processInstance?: BpmProcessInstance;
|
status?: number;
|
todoTask?: BpmTask;
|
}
|
|
/* ---------- 字典数据（复用 crm 的通用字典接口） ---------- */
|
|
export { getSimpleDictDataList, type DictData } from "./crm";
|
|
/* ---------- 用户 ---------- */
|
|
export function getBpmSimpleUserList(accessToken: string) {
|
return request<BpmUser[]>("/system/user/simple-list", { header: header(accessToken) });
|
}
|
|
export function getBpmUserPage(accessToken: string, params: { pageNo: number; pageSize: number; nickname?: string; username?: string; mobile?: string; status?: number }) {
|
return request<PageResult<BpmUser>>(`/system/user/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
export function getBpmUserListByIds(accessToken: string, ids: number[]) {
|
return request<BpmUser[]>(`/system/user/list${query({ ids: ids.join(",") })}`, { header: header(accessToken) });
|
}
|
|
/** 部门树（发起流程候选人、部门选择器用） */
|
export interface BpmDept {
|
id?: number;
|
name?: string;
|
parentId?: number;
|
children?: BpmDept[];
|
}
|
|
export function getBpmSimpleDeptList(accessToken: string) {
|
return request<BpmDept[]>("/system/dept/simple-list", { header: header(accessToken) });
|
}
|
|
/* ---------- 流程分类 ---------- */
|
|
export function getCategorySimpleList(accessToken: string) {
|
return request<BpmCategory[]>("/bpm/category/simple-list", { header: header(accessToken) });
|
}
|
|
export function getCategoryPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
|
return request<PageResult<BpmCategory>>(`/bpm/category/page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
export function getCategory(accessToken: string, id: number) {
|
return request<BpmCategory>(`/bpm/category/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createCategory(accessToken: string, data: BpmCategory) {
|
return request<number>("/bpm/category/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updateCategory(accessToken: string, data: BpmCategory) {
|
return request<boolean>("/bpm/category/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deleteCategory(accessToken: string, id: number) {
|
return request<boolean>(`/bpm/category/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export interface BpmFormConfig {
|
id?: number;
|
name: string;
|
conf?: string;
|
fields?: string[];
|
status?: number;
|
remark?: string;
|
createTime?: number | string;
|
}
|
|
export function getFormPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
|
return request<PageResult<BpmFormConfig>>(`/bpm/form/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
export function getForm(accessToken: string, id: number) {
|
return request<BpmFormConfig>(`/bpm/form/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createForm(accessToken: string, data: BpmFormConfig) {
|
return request<number>("/bpm/form/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updateForm(accessToken: string, data: BpmFormConfig) {
|
return request<boolean>("/bpm/form/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deleteForm(accessToken: string, id: number) {
|
return request<boolean>(`/bpm/form/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export function getFormSimpleList(accessToken: string) {
|
return request<BpmFormConfig[]>("/bpm/form/simple-list", { header: header(accessToken) });
|
}
|
|
export interface BpmModelProcessDefinition {
|
id?: string;
|
key?: string;
|
version?: number;
|
deploymentTime?: number | string;
|
suspensionState?: number;
|
}
|
|
export interface BpmModel {
|
id?: number;
|
key: string;
|
name: string;
|
icon?: string;
|
description?: string;
|
category?: string;
|
formName?: string;
|
formType?: number;
|
formId?: number;
|
formCustomCreatePath?: string;
|
formCustomViewPath?: string;
|
processDefinition?: BpmModelProcessDefinition;
|
status?: number;
|
remark?: string;
|
createTime?: string;
|
bpmnXml?: string;
|
startUsers?: BpmUser[];
|
}
|
|
export function getModelList(accessToken: string, name?: string) {
|
return request<BpmModel[]>(`/bpm/model/list${query({ name })}`, { header: header(accessToken) });
|
}
|
|
export function getModel(accessToken: string, id: number | string) {
|
return request<BpmModel>(`/bpm/model/get${query({ id: String(id) })}`, { header: header(accessToken) });
|
}
|
|
export function createModel(accessToken: string, data: BpmModel) {
|
return request<number>("/bpm/model/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updateModel(accessToken: string, data: BpmModel) {
|
return request<boolean>("/bpm/model/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function updateModelState(accessToken: string, id: number, state: number) {
|
return request<boolean>("/bpm/model/update-state", {
|
method: "PUT",
|
data: { id, state },
|
header: header(accessToken),
|
});
|
}
|
|
export function deployModel(accessToken: string, id: number) {
|
return request<boolean>(`/bpm/model/deploy${query({ id })}`, { method: "POST", header: header(accessToken) });
|
}
|
|
export function cleanModel(accessToken: string, id: number) {
|
return request<boolean>(`/bpm/model/clean${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export function deleteModel(accessToken: string, id: number) {
|
return request<boolean>(`/bpm/model/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export interface BpmUserGroup {
|
id?: number;
|
name: string;
|
description?: string;
|
userIds?: number[];
|
status?: number;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export function getUserGroupPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
|
return request<PageResult<BpmUserGroup>>(`/bpm/user-group/page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
export function getUserGroup(accessToken: string, id: number) {
|
return request<BpmUserGroup>(`/bpm/user-group/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createUserGroup(accessToken: string, data: BpmUserGroup) {
|
return request<number>("/bpm/user-group/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updateUserGroup(accessToken: string, data: BpmUserGroup) {
|
return request<boolean>("/bpm/user-group/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deleteUserGroup(accessToken: string, id: number) {
|
return request<boolean>(`/bpm/user-group/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export interface BpmProcessListener {
|
id?: number;
|
name: string;
|
type?: number;
|
status?: number;
|
event?: string;
|
valueType?: number;
|
value?: string;
|
createTime?: number | string;
|
}
|
|
export function getProcessListenerPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
|
return request<PageResult<BpmProcessListener>>(`/bpm/process-listener/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
export function getProcessListener(accessToken: string, id: number) {
|
return request<BpmProcessListener>(`/bpm/process-listener/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createProcessListener(accessToken: string, data: BpmProcessListener) {
|
return request<number>("/bpm/process-listener/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updateProcessListener(accessToken: string, data: BpmProcessListener) {
|
return request<boolean>("/bpm/process-listener/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deleteProcessListener(accessToken: string, id: number) {
|
return request<boolean>(`/bpm/process-listener/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export interface BpmProcessExpression {
|
id?: number;
|
name: string;
|
status?: number;
|
expression?: string;
|
createTime?: number | string;
|
}
|
|
export function getProcessExpressionPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
|
return request<PageResult<BpmProcessExpression>>(`/bpm/process-expression/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
export function getProcessExpression(accessToken: string, id: number) {
|
return request<BpmProcessExpression>(`/bpm/process-expression/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createProcessExpression(accessToken: string, data: BpmProcessExpression) {
|
return request<number>("/bpm/process-expression/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updateProcessExpression(accessToken: string, data: BpmProcessExpression) {
|
return request<boolean>("/bpm/process-expression/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deleteProcessExpression(accessToken: string, id: number) {
|
return request<boolean>(`/bpm/process-expression/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export interface BpmBusinessAttach {
|
id?: number;
|
name: string;
|
code?: string;
|
status?: number;
|
processDefinitionKey?: string;
|
taskDefinitionKey?: string;
|
fileTypes?: string;
|
maxSize?: number;
|
required?: boolean;
|
remark?: string;
|
createTime?: number | string;
|
}
|
|
export function getBusinessAttachPage(accessToken: string, params: { pageNo: number; pageSize: number; name?: string }) {
|
return request<PageResult<BpmBusinessAttach>>(`/bpm/business-attach/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
export function getBusinessAttach(accessToken: string, id: number) {
|
return request<BpmBusinessAttach>(`/bpm/business-attach/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createBusinessAttach(accessToken: string, data: BpmBusinessAttach) {
|
return request<number>("/bpm/business-attach/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updateBusinessAttach(accessToken: string, data: BpmBusinessAttach) {
|
return request<boolean>("/bpm/business-attach/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deleteBusinessAttach(accessToken: string, id: number) {
|
return request<boolean>(`/bpm/business-attach/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
/* ---------- 流程定义 ---------- */
|
|
/** 启用中的流程定义列表（发起流程页面用，suspensionState 为必填） */
|
export function getProcessDefinitionList(accessToken: string, suspensionState = 1) {
|
return request<BpmProcessDefinition[]>(
|
`/bpm/process-definition/list${query({ suspensionState })}`,
|
{ header: header(accessToken) },
|
);
|
}
|
|
/**
|
* 流程定义精简列表（筛选项下拉用）
|
* 与 web 端 getSimpleProcessDefinitionList 一致，返回 PageResult（取 .list）
|
* 注意：不能改用 /list —— 那个接口要求 suspensionState 必填
|
*/
|
export function getSimpleProcessDefinitionList(accessToken: string) {
|
return request<PageResult<BpmProcessDefinition>>("/bpm/process-definition/simple-list", {
|
header: header(accessToken),
|
});
|
}
|
|
export function getProcessDefinition(accessToken: string, params: { id?: string; key?: string }) {
|
return request<BpmProcessDefinition>(`/bpm/process-definition/get${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------- 流程实例 ---------- */
|
|
export interface ProcessInstancePageParams {
|
pageNo: number;
|
pageSize: number;
|
name?: string;
|
processDefinitionId?: string;
|
processDefinitionKey?: string;
|
category?: string;
|
status?: number;
|
createTime?: number[];
|
}
|
|
/** 我的流程分页 */
|
export function getProcessInstanceMyPage(accessToken: string, params: ProcessInstancePageParams) {
|
return request<PageResult<BpmProcessInstance>>(`/bpm/process-instance/my-page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/** 流程实例管理分页 */
|
export function getProcessInstanceManagerPage(accessToken: string, params: ProcessInstancePageParams) {
|
return request<PageResult<BpmProcessInstance>>(`/bpm/process-instance/manager-page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
export function getProcessInstance(accessToken: string, id: string) {
|
return request<BpmProcessInstance>(`/bpm/process-instance/get?id=${encodeURIComponent(id)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/** 审批详情（任务详情页核心接口） */
|
export function getApprovalDetail(
|
accessToken: string,
|
params: { processInstanceId: string; taskId?: string; activityId?: string },
|
) {
|
return request<BpmApprovalDetail>(`/bpm/process-instance/get-approval-detail${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/**
|
* 发起阶段的流程节点预测
|
*
|
* 与上面的 getApprovalDetail 形态不同：web 端发起时传的是**流程定义 id**（不是 processInstanceId）
|
* 加 processVariablesStr，后端依此预测审批节点与「发起人自选审批人」候选。
|
* 见 web 端 create/modules/form.vue 第 152、182 行。
|
*/
|
export function getStartApprovalNodes(
|
accessToken: string,
|
params: { processDefinitionId: string; activityId?: string; processVariablesStr?: string },
|
) {
|
return request<BpmApprovalDetail>(`/bpm/process-instance/get-approval-detail${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/** 发起流程 */
|
export function createProcessInstance(
|
accessToken: string,
|
data: {
|
processDefinitionId?: string;
|
variables: Record<string, any>;
|
startUserSelectAssignees?: Record<string, number[]>;
|
},
|
) {
|
return request<BpmProcessInstance>("/bpm/process-instance/create", {
|
method: "POST",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 发起人取消流程（DELETE + body） */
|
export function cancelProcessInstanceByStartUser(
|
accessToken: string,
|
data: { id: string; reason: string },
|
) {
|
return request<boolean>("/bpm/process-instance/cancel-by-start-user", {
|
method: "DELETE",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 抄送我的分页 */
|
export function getProcessInstanceCopyPage(
|
accessToken: string,
|
params: ProcessInstancePageParams,
|
) {
|
return request<PageResult<BpmProcessInstanceCopy>>(
|
`/bpm/process-instance/copy/page${query(params)}`,
|
{ header: header(accessToken) },
|
);
|
}
|
|
/** 审批时获取下一个节点的审批人（自选审批人 / 网关分支） */
|
export function getNextApprovalNodes(
|
accessToken: string,
|
params: { processInstanceId: string; taskId?: string; activityId?: string; processVariablesStr?: string },
|
) {
|
return request<BpmApprovalDetail>(`/bpm/process-instance/get-next-approval-nodes${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------- 任务 ---------- */
|
|
export interface TaskPageParams {
|
pageNo: number;
|
pageSize: number;
|
name?: string;
|
processDefinitionKey?: string;
|
category?: string;
|
status?: number;
|
createTime?: number[];
|
}
|
|
/** 待办任务分页 */
|
export function getTaskTodoPage(accessToken: string, params: TaskPageParams) {
|
return request<PageResult<BpmTask>>(`/bpm/task/todo-page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/** 已办任务分页 */
|
export function getTaskDonePage(accessToken: string, params: TaskPageParams) {
|
return request<PageResult<BpmTask>>(`/bpm/task/done-page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/** 流程任务管理分页 */
|
export function getTaskManagerPage(accessToken: string, params: TaskPageParams) {
|
return request<PageResult<BpmTask>>(`/bpm/task/manager-page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
export interface OaNotice {
|
id?: number; title: string; content: string; type: number; status: number; sendScope: number;
|
isTop?: number; publishUserId?: number; publishTime?: string; createTime?: string; userIds?: number[];
|
}
|
export function getNoticePage(accessToken: string, params: { pageNo: number; pageSize: number; title?: string; type?: number; status?: number; sendScope?: number }) {
|
return request<PageResult<OaNotice>>(`/bpm/oa/notice/page${query(params)}`, { header: header(accessToken) });
|
}
|
export function getNotice(accessToken: string, id: number) { return request<OaNotice>(`/bpm/oa/notice/get${query({ id })}`, { header: header(accessToken) }); }
|
export function createNotice(accessToken: string, data: OaNotice) { return request<number>("/bpm/oa/notice/create", { method: "POST", data, header: header(accessToken) }); }
|
export function updateNotice(accessToken: string, data: OaNotice) { return request<boolean>("/bpm/oa/notice/update", { method: "PUT", data, header: header(accessToken) }); }
|
export function deleteNotice(accessToken: string, id: number) { return request<boolean>(`/bpm/oa/notice/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
|
|
/** 审批通过 */
|
export function approveTask(
|
accessToken: string,
|
data: {
|
id: string;
|
reason?: string;
|
attachments?: string[];
|
variables?: Record<string, any>;
|
nextAssignees?: Record<string, number[]>;
|
signPicUrl?: string;
|
},
|
) {
|
return request<boolean>("/bpm/task/approve", {
|
method: "PUT",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 审批驳回（拒绝后直接结束流程） */
|
export function rejectTask(
|
accessToken: string,
|
data: { id: string; reason?: string; attachments?: string[] },
|
) {
|
return request<boolean>("/bpm/task/reject", {
|
method: "PUT",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 退回到指定节点 */
|
export function returnTask(
|
accessToken: string,
|
data: { id: string; reason?: string; targetTaskDefinitionKey: string },
|
) {
|
return request<boolean>("/bpm/task/return", {
|
method: "PUT",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 可退回的节点列表 */
|
export function getTaskListByReturn(accessToken: string, id: string) {
|
return request<Array<{ taskDefinitionKey?: string; name?: string }>>(
|
`/bpm/task/list-by-return?id=${encodeURIComponent(id)}`,
|
{ header: header(accessToken) },
|
);
|
}
|
|
/** 转办 */
|
export function transferTask(
|
accessToken: string,
|
data: { id: string; reason?: string; assigneeUserId: number },
|
) {
|
return request<boolean>("/bpm/task/transfer", {
|
method: "PUT",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 委派 */
|
export function delegateTask(
|
accessToken: string,
|
data: { id: string; reason?: string; delegateUserId: number },
|
) {
|
return request<boolean>("/bpm/task/delegate", {
|
method: "PUT",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 加签 */
|
export function signCreateTask(
|
accessToken: string,
|
data: { id: string; type: "after" | "before"; reason?: string; userIds: number[] },
|
) {
|
return request<boolean>("/bpm/task/create-sign", {
|
method: "PUT",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 减签（id 为被减签的子任务 id） */
|
export function signDeleteTask(accessToken: string, data: { id: string; reason?: string }) {
|
return request<boolean>("/bpm/task/delete-sign", {
|
method: "DELETE",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 抄送 */
|
export function copyTask(
|
accessToken: string,
|
data: { id: string; reason?: string; copyUserIds: number[] },
|
) {
|
return request<boolean>("/bpm/task/copy", {
|
method: "PUT",
|
data,
|
header: header(accessToken),
|
});
|
}
|
|
/** 撤回任务（PUT + query，body 为 null） */
|
export function withdrawTask(accessToken: string, taskId: string) {
|
return request<boolean>(`/bpm/task/withdraw?taskId=${encodeURIComponent(taskId)}`, {
|
method: "PUT",
|
header: header(accessToken),
|
});
|
}
|
|
/** 按流程实例查询全部审批任务（流转记录） */
|
export function getTaskListByProcessInstanceId(accessToken: string, processInstanceId: string) {
|
return request<BpmTask[]>(
|
`/bpm/task/list-by-process-instance-id?processInstanceId=${encodeURIComponent(processInstanceId)}`,
|
{ header: header(accessToken) },
|
);
|
}
|
|
/* ---------- 文件上传 ---------- */
|
|
export interface BpmUploadResult {
|
id?: number;
|
name?: string;
|
url?: string;
|
path?: string;
|
size?: number;
|
type?: string;
|
}
|
|
/** 上传 BPM 附件 / 签名图片（字段名 file，与 web 端 requestClient.upload 一致） */
|
export function uploadBpmFile(accessToken: string, filePath: string, directory = "bpm/task-attachment") {
|
return new Promise<BpmUploadResult>((resolve, reject) => {
|
uni.uploadFile({
|
url: `${API_BASE_URL}/infra/file/upload`,
|
filePath,
|
name: "file",
|
header: { Authorization: `Bearer ${accessToken}` },
|
formData: { directory },
|
success: response => {
|
try {
|
const data = JSON.parse(response.data) as {
|
code?: number;
|
msg?: string;
|
data?: BpmUploadResult;
|
};
|
if (data.code === 0 && data.data) resolve(data.data);
|
else reject(new Error(data.msg || "文件上传失败"));
|
} catch {
|
reject(new Error("文件上传响应解析失败"));
|
}
|
},
|
fail: () => reject(new Error("文件上传失败，请检查网络后重试")),
|
});
|
});
|
}
|
|
/** 本地选中的待上传文件 */
|
export interface BpmPickedFile {
|
path: string;
|
name?: string;
|
}
|
|
/**
|
* 跨端文件选择（H5 / 微信小程序 / App 三端兼容）
|
* - H5 / App：uni.chooseFile
|
* - 微信小程序：uni.chooseMessageFile（uni.chooseFile 在小程序不可用）
|
*/
|
export function chooseBpmFile(count = 9): Promise<BpmPickedFile[]> {
|
return new Promise((resolve, reject) => {
|
const onSuccess = (files: BpmPickedFile[]) => resolve(files);
|
const onFail = (error: unknown) => reject(error);
|
|
// #ifdef MP-WEIXIN
|
uni.chooseMessageFile({
|
count,
|
type: "file",
|
success: result => {
|
onSuccess(
|
(result.tempFiles || [])
|
.map(item => ({ path: item.path, name: item.name }))
|
.filter(item => Boolean(item.path)),
|
);
|
},
|
fail: onFail,
|
});
|
// #endif
|
|
// #ifndef MP-WEIXIN
|
uni.chooseFile({
|
count,
|
success: result => {
|
onSuccess(
|
(result.tempFiles || [])
|
.map(item => ({ path: item.path, name: item.name }))
|
.filter(item => Boolean(item.path)),
|
);
|
},
|
fail: onFail,
|
});
|
// #endif
|
});
|
}
|
|
/** 跨端选择图片（签名图片、图片类附件） */
|
export function chooseBpmImage(count = 1): Promise<BpmPickedFile[]> {
|
return new Promise((resolve, reject) => {
|
uni.chooseImage({
|
count,
|
success: result => {
|
resolve((result.tempFilePaths || []).map(path => ({ path })));
|
},
|
fail: reject,
|
});
|
});
|
}
|
