import { API_BASE_URL, request, type ApiResponse } from "./request";
|
import type { PageResult } from "./basic-data";
|
|
/* ==================================================================
|
* 产品设计（mes/pd）接口层
|
* 与 web 端 mom-pro2-before/src/api/mes/pd/** 逐字对齐
|
* ================================================================== */
|
|
const header = (accessToken: string) => ({ Authorization: `Bearer ${accessToken}` });
|
|
type QueryValue = string | number | boolean | string[] | undefined;
|
|
/** 过滤 undefined / ""，数组展开为多个同名参数，全部 encodeURIComponent */
|
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("&")}` : "";
|
}
|
|
/* ==================== 设计项目（/mes/pd/project） ==================== */
|
|
/** 产品设计项目 */
|
export interface PdProject {
|
id?: number;
|
/** 任务编码 */
|
taskCode?: string;
|
/** 任务名称 */
|
taskName?: string;
|
/** 产品ID（选择产品时使用，提交前需剥离） */
|
productId?: number;
|
/** 产品编码 */
|
productCode?: string;
|
/** 产品名称 */
|
productName?: string;
|
/** 版本号 */
|
version?: string;
|
/** 状态：0待发布 1待上传 2待审核 5审批中 3待归档 4已归档 */
|
status?: number;
|
/** 主设计师（用户ID） */
|
chiefDesigner?: number;
|
/** 主设计师名称 */
|
chiefDesignerNickname?: string;
|
/** 审核人（用户ID） */
|
reviewer?: number;
|
/** 审核人名称 */
|
reviewerNickname?: string;
|
/** 计划完成时间 */
|
planFinishTime?: number;
|
/** 备注 */
|
remark?: string;
|
/** 创建时间 */
|
createTime?: number;
|
/** BPM 流程实例编号 */
|
processInstanceId?: string;
|
/** 待审核文件数（auditStatus=0 的审核记录数） */
|
pendingAuditCount?: number;
|
}
|
|
export interface PdProjectPageParams {
|
pageNo: number;
|
pageSize: number;
|
taskCode?: string;
|
taskName?: string;
|
productCode?: string;
|
productName?: string;
|
status?: number;
|
planFinishTime?: number[];
|
}
|
|
export function getPdProjectPage(accessToken: string, params: PdProjectPageParams) {
|
return request<PageResult<PdProject>>(`/mes/pd/project/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
export function getPdProject(accessToken: string, id: number) {
|
return request<PdProject>(`/mes/pd/project/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createPdProject(accessToken: string, data: PdProject) {
|
return request<number>("/mes/pd/project/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updatePdProject(accessToken: string, data: PdProject) {
|
return request<boolean>("/mes/pd/project/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deletePdProject(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/project/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
/** 发布（待发布→待上传） */
|
export function publishPdProject(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/project/publish${query({ id })}`, { method: "PUT", header: header(accessToken) });
|
}
|
|
/** 上传资料（待上传→待审核），后端自动创建资料审核记录 */
|
export function uploadPdProject(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/project/upload${query({ id })}`, { method: "PUT", header: header(accessToken) });
|
}
|
|
/** 提交审批（待审核→审批中） */
|
export function submitPdProjectApproval(accessToken: string, id: number, processDefinitionKey: string) {
|
return request<boolean>(`/mes/pd/project/submit-approval${query({ id, processDefinitionKey })}`, {
|
method: "PUT",
|
header: header(accessToken),
|
});
|
}
|
|
/** 获得审批流程列表 */
|
export interface PdApproveProcess {
|
id: string;
|
name: string;
|
key: string;
|
}
|
|
export function getPdProjectApproveProcessList(accessToken: string) {
|
return request<PdApproveProcess[]>("/mes/pd/project/approve-process-list", { header: header(accessToken) });
|
}
|
|
/** 归档（待归档→已归档），后端自动创建归档台账记录 */
|
export function archivePdProject(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/project/archive${query({ id })}`, { method: "PUT", header: header(accessToken) });
|
}
|
|
/* ==================== 设计资料（/mes/pd/document） ==================== */
|
|
/** 设计资料 */
|
export interface PdDocument {
|
id?: number;
|
projectId?: number;
|
/** 资料类型（字典 mes_pd_document_type，字符串） */
|
documentType?: string;
|
documentName?: string;
|
documentVersion?: string;
|
fileName?: string;
|
fileUrl?: string;
|
uploadUserId?: number;
|
uploadUserNickname?: string;
|
uploadTime?: number;
|
blobIds?: number[];
|
attachmentList?: StorageAttachment[];
|
remark?: string;
|
createTime?: number;
|
}
|
|
export interface PdDocumentPageParams {
|
pageNo: number;
|
pageSize: number;
|
projectId: number;
|
documentType?: string;
|
documentName?: string;
|
documentVersion?: string;
|
}
|
|
export function getPdDocumentPage(accessToken: string, params: PdDocumentPageParams) {
|
return request<PageResult<PdDocument>>(`/mes/pd/document/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
export function getPdDocument(accessToken: string, id: number) {
|
return request<PdDocument>(`/mes/pd/document/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createPdDocument(accessToken: string, data: PdDocument) {
|
return request<number>("/mes/pd/document/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updatePdDocument(accessToken: string, data: PdDocument) {
|
return request<boolean>("/mes/pd/document/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deletePdDocument(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/document/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
/* ==================== 资料审核（/mes/pd/document-audit） ==================== */
|
|
/** 资料审核（上传资料时后端自动创建，前端无需调用 create） */
|
export interface PdDocumentAudit {
|
id?: number;
|
auditNo?: string;
|
documentId?: number;
|
documentName?: string;
|
documentVersion?: string;
|
reviewer?: number;
|
reviewerNickname?: string;
|
/** 审核状态（字典 mes_pd_document_audit_status） */
|
auditStatus?: number;
|
auditTime?: number;
|
remark?: string;
|
createTime?: number;
|
}
|
|
export interface PdDocumentAuditPageParams {
|
pageNo: number;
|
pageSize: number;
|
projectId?: number;
|
auditNo?: string;
|
documentId?: number;
|
documentName?: string;
|
auditStatus?: number;
|
}
|
|
export function getPdDocumentAuditPage(accessToken: string, params: PdDocumentAuditPageParams) {
|
return request<PageResult<PdDocumentAudit>>(`/mes/pd/document-audit/page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
export function getPdDocumentAudit(accessToken: string, id: number) {
|
return request<PdDocumentAudit>(`/mes/pd/document-audit/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function updatePdDocumentAudit(accessToken: string, data: PdDocumentAudit) {
|
return request<boolean>("/mes/pd/document-audit/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deletePdDocumentAudit(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/document-audit/delete${query({ id })}`, {
|
method: "DELETE",
|
header: header(accessToken),
|
});
|
}
|
|
/* ==================== 设计 BOM（/mes/pd/bom） ==================== */
|
|
/** 设计 BOM 行 */
|
export interface PdBomLine {
|
id?: number;
|
projectId?: number;
|
itemId?: number;
|
itemCode?: string;
|
itemName?: string;
|
specification?: string;
|
unitMeasureName?: string;
|
quantity?: number;
|
remark?: string;
|
createTime?: number;
|
}
|
|
export interface PdBomPageParams {
|
pageNo: number;
|
pageSize: number;
|
projectId: number;
|
itemCode?: string;
|
itemName?: string;
|
}
|
|
export function getPdBomPage(accessToken: string, params: PdBomPageParams) {
|
return request<PageResult<PdBomLine>>(`/mes/pd/bom/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
export function createPdBomLine(accessToken: string, data: PdBomLine) {
|
return request<number>("/mes/pd/bom/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updatePdBomLine(accessToken: string, data: PdBomLine) {
|
return request<boolean>("/mes/pd/bom/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deletePdBomLine(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/bom/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
/* ==================== 设计任务（/mes/pd/task） ==================== */
|
|
/** 产品设计任务 */
|
export interface PdTask {
|
id?: number;
|
code?: string;
|
projectId?: number;
|
projectCode?: string;
|
projectName?: string;
|
taskName?: string;
|
taskType?: number;
|
assigneeId?: number;
|
assigneeName?: string;
|
assignerId?: number;
|
assignerName?: string;
|
priority?: number;
|
status?: number;
|
planFinishDate?: number;
|
actualFinishDate?: number;
|
remark?: string;
|
createTime?: number;
|
}
|
|
export interface PdTaskPageParams {
|
pageNo: number;
|
pageSize: number;
|
code?: string;
|
projectId?: number;
|
taskName?: string;
|
assigneeId?: number;
|
status?: number;
|
}
|
|
export interface PdTaskDispatchParams {
|
id: number;
|
assigneeId: number;
|
planFinishDate?: number;
|
remark?: string;
|
}
|
|
export function getPdTaskPage(accessToken: string, params: PdTaskPageParams) {
|
return request<PageResult<PdTask>>(`/mes/pd/task/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
export function getPdTask(accessToken: string, id: number) {
|
return request<PdTask>(`/mes/pd/task/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createPdTask(accessToken: string, data: PdTask) {
|
return request<number>("/mes/pd/task/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updatePdTask(accessToken: string, data: PdTask) {
|
return request<boolean>("/mes/pd/task/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deletePdTask(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/task/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export function dispatchPdTask(accessToken: string, data: PdTaskDispatchParams) {
|
return request<boolean>("/mes/pd/task/dispatch", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function completePdTask(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/task/complete${query({ id })}`, { method: "PUT", header: header(accessToken) });
|
}
|
|
/* ==================== 版本变更（/mes/pd/version-change） ==================== */
|
|
/** 版本变更 */
|
export interface PdVersionChange {
|
id?: number;
|
code?: string;
|
projectId?: number;
|
projectCode?: string;
|
projectName?: string;
|
/** 变更类型：1主版本 2次版本 3修订 */
|
changeType?: number;
|
fromVersion?: string;
|
toVersion?: string;
|
changeReason?: string;
|
changeContent?: string;
|
applicantId?: number;
|
applicantName?: string;
|
remark?: string;
|
createTime?: number;
|
}
|
|
export interface PdVersionChangePageParams {
|
pageNo: number;
|
pageSize: number;
|
code?: string;
|
projectId?: number;
|
changeType?: number;
|
}
|
|
export function getPdVersionChangePage(accessToken: string, params: PdVersionChangePageParams) {
|
return request<PageResult<PdVersionChange>>(`/mes/pd/version-change/page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
export function getPdVersionChange(accessToken: string, id: number) {
|
return request<PdVersionChange>(`/mes/pd/version-change/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createPdVersionChange(accessToken: string, data: PdVersionChange) {
|
return request<number>("/mes/pd/version-change/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function updatePdVersionChange(accessToken: string, data: PdVersionChange) {
|
return request<boolean>("/mes/pd/version-change/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deletePdVersionChange(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/version-change/delete${query({ id })}`, {
|
method: "DELETE",
|
header: header(accessToken),
|
});
|
}
|
|
export function approvePdVersionChange(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/version-change/approve${query({ id })}`, {
|
method: "PUT",
|
header: header(accessToken),
|
});
|
}
|
|
/* ==================== 图纸审核（/mes/pd/drawing-review） ==================== */
|
|
/** 图纸审核 */
|
export interface PdDrawingReview {
|
id?: number;
|
code?: string;
|
projectId?: number;
|
projectCode?: string;
|
projectName?: string;
|
documentId?: number;
|
documentName?: string;
|
documentVersion?: string;
|
reviewerId?: number;
|
reviewerName?: string;
|
status?: number;
|
reviewComment?: string;
|
reviewTime?: number;
|
createTime?: number;
|
}
|
|
export interface PdDrawingReviewPageParams {
|
pageNo: number;
|
pageSize: number;
|
code?: string;
|
projectId?: number;
|
status?: number;
|
reviewerId?: number;
|
}
|
|
export interface PdDrawingReviewParams {
|
id: number;
|
status: number;
|
reviewComment?: string;
|
}
|
|
export function getPdDrawingReviewPage(accessToken: string, params: PdDrawingReviewPageParams) {
|
return request<PageResult<PdDrawingReview>>(`/mes/pd/drawing-review/page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
|
export function getPdDrawingReview(accessToken: string, id: number) {
|
return request<PdDrawingReview>(`/mes/pd/drawing-review/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function createPdDrawingReview(accessToken: string, data: PdDrawingReview) {
|
return request<number>("/mes/pd/drawing-review/create", { method: "POST", data, header: header(accessToken) });
|
}
|
|
export function reviewPdDrawing(accessToken: string, data: PdDrawingReviewParams) {
|
return request<boolean>("/mes/pd/drawing-review/review", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
/* ==================== 设计流程节点（/mes/pd/workflow） ==================== */
|
|
/** 设计流程节点 */
|
export interface PdWorkflowNode {
|
id?: number;
|
projectId?: number;
|
nodeName?: string;
|
nodeType?: string;
|
operatorName?: string;
|
status?: number;
|
operateTime?: number;
|
remark?: string;
|
}
|
|
export function getPdWorkflowList(accessToken: string, projectId: number) {
|
return request<PdWorkflowNode[]>(`/mes/pd/workflow/list${query({ projectId })}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/* ==================== 设计归档台账（/mes/pd/archive） ==================== */
|
|
/** 归档台账（分页聚合） */
|
export interface PdArchive {
|
id?: number;
|
/** 最新归档编号 */
|
archiveCode?: string;
|
/** 设计项目ID */
|
projectId?: number;
|
taskCode?: string;
|
taskName?: string;
|
productCode?: string;
|
productName?: string;
|
/** 该项目下归档记录总数 */
|
archiveCount?: number;
|
archiver?: number;
|
archiverNickname?: string;
|
/** 归档状态（字典 mes_pd_archive_status） */
|
archiveStatus?: number;
|
archiveTime?: number;
|
remark?: string;
|
createTime?: number;
|
updater?: string;
|
updaterNickname?: string;
|
updateTime?: number;
|
}
|
|
export interface PdArchivePageParams {
|
pageNo: number;
|
pageSize: number;
|
archiveCode?: string;
|
projectId?: number;
|
archiveStatus?: number;
|
productCode?: string;
|
productName?: string;
|
}
|
|
/** 归档详情 - 项目信息 */
|
export interface PdArchiveProjectInfo {
|
id?: number;
|
taskCode?: string;
|
taskName?: string;
|
productCode?: string;
|
productName?: string;
|
version?: string;
|
status?: number;
|
chiefDesigner?: number;
|
chiefDesignerNickname?: string;
|
reviewer?: number;
|
reviewerNickname?: string;
|
planFinishTime?: number;
|
remark?: string;
|
createTime?: number;
|
}
|
|
/** 归档详情 - 归档记录 */
|
export interface PdArchiveInfo {
|
id?: number;
|
archiveCode?: string;
|
archiver?: number;
|
archiverNickname?: string;
|
archiveStatus?: number;
|
archiveTime?: number;
|
remark?: string;
|
createTime?: number;
|
}
|
|
/** 归档详情 - 设计资料 */
|
export interface PdArchiveDocumentInfo {
|
id?: number;
|
documentType?: string;
|
documentName?: string;
|
documentVersion?: string;
|
fileName?: string;
|
fileUrl?: string;
|
uploadUserId?: number;
|
uploadUserNickname?: string;
|
uploadTime?: number;
|
remark?: string;
|
createTime?: number;
|
}
|
|
/** 归档详情（按产品聚合的多项目） */
|
export interface PdArchiveDetailItem {
|
project: PdArchiveProjectInfo;
|
archives: PdArchiveInfo[];
|
documents: PdArchiveDocumentInfo[];
|
}
|
|
export function getPdArchivePage(accessToken: string, params: PdArchivePageParams) {
|
return request<PageResult<PdArchive>>(`/mes/pd/archive/page${query(params)}`, { header: header(accessToken) });
|
}
|
|
/** 归档台账详情（按产品编码查询，返回该产品下所有项目的归档与资料） */
|
export function getPdArchiveDetailByProduct(accessToken: string, productCode: string) {
|
return request<PdArchiveDetailItem[]>(`/mes/pd/archive/detail-by-product${query({ productCode })}`, {
|
header: header(accessToken),
|
});
|
}
|
|
export function getPdArchive(accessToken: string, id: number) {
|
return request<PdArchive>(`/mes/pd/archive/get${query({ id })}`, { header: header(accessToken) });
|
}
|
|
export function updatePdArchive(accessToken: string, data: PdArchive) {
|
return request<boolean>("/mes/pd/archive/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
|
export function deletePdArchive(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/archive/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
/* ==================== 通用支撑（人员 / 编码 / 文件上传） ==================== */
|
|
/** 简单用户（审批人/设计师选择） */
|
export interface PdSimpleUser {
|
id: number;
|
nickname?: string;
|
username?: string;
|
}
|
|
export function getPdSimpleUserList(accessToken: string) {
|
return request<PdSimpleUser[]>("/system/user/simple-list", { header: header(accessToken) });
|
}
|
|
/** 自动编码生成 */
|
export function generatePdAutoCode(accessToken: string, ruleCode: string, inputChar?: string) {
|
return request<string>("/mes/md/auto-code-record/generate", {
|
method: "POST",
|
data: { ruleCode, inputChar },
|
header: header(accessToken),
|
});
|
}
|
|
/** 存储文件（上传返回体） */
|
export interface StorageAttachment {
|
id?: number;
|
name?: string;
|
url?: string;
|
path?: string;
|
size?: number;
|
type?: string;
|
createTime?: number;
|
}
|
|
/**
|
* 文件上传（设计资料 blobIds）
|
* 与 web 端 FileUpload 组件走同一后端接口 /system/storage-blob/upload
|
*/
|
export function uploadPdFile(accessToken: string, filePath: string) {
|
return new Promise<StorageAttachment>((resolve, reject) => {
|
uni.uploadFile({
|
url: `${API_BASE_URL}/system/storage-blob/upload`,
|
filePath,
|
name: "files",
|
header: { Authorization: `Bearer ${accessToken}` },
|
formData: { directory: "mes/pd" },
|
success: response => {
|
try {
|
const data = JSON.parse(response.data) as ApiResponse<StorageAttachment[]>;
|
if (data.code === 0 && data.data?.[0]) resolve(data.data[0]);
|
else reject(new Error(data.msg || "文件上传失败"));
|
} catch {
|
reject(new Error("文件上传响应解析失败"));
|
}
|
},
|
fail: () => reject(new Error("文件上传失败，请检查网络后重试")),
|
});
|
});
|
}
|
|
/** 本地选中的待上传文件 */
|
export interface PickedFile {
|
path: string;
|
name?: string;
|
}
|
|
/**
|
* 跨端文件选择（H5 / 微信小程序 / App 三端兼容）
|
*
|
* 平台差异（uni-app 官方支持矩阵）：
|
* - H5 ：uni.chooseFile 可用（浏览器是 <input type="file">）
|
* - 微信小程序：uni.chooseFile **不可用**；需用 uni.chooseMessageFile 从聊天记录选文件
|
* - App ：uni.chooseFile 可用
|
*
|
* 因此这里用条件编译分流，统一返回 { path, name }[]，调用方无需关心平台。
|
*/
|
export function choosePdFile(count = 9): Promise<PickedFile[]> {
|
return new Promise((resolve, reject) => {
|
const onSuccess = (files: PickedFile[]) => 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
|
});
|
}
|
