import { API_BASE_URL, request, type ApiResponse } from "./request";
|
import type { PageResult } from "./basic-data";
|
import type { UserSimple } from "./purchase";
|
|
/* ==================== 基础参数（工艺参数） ==================== */
|
|
export interface PdParameter {
|
id?: number;
|
paramCode?: string;
|
paramName?: string;
|
paramType?: number;
|
unitMeasureId?: number;
|
unitMeasureName?: string;
|
required?: boolean;
|
remark?: string;
|
createTime?: string;
|
}
|
|
/* ==================== 参数模板（工艺参数模板） ==================== */
|
|
export interface PdTemplateDetail {
|
id?: number;
|
templateId?: number;
|
processParamId?: number;
|
paramCode?: string;
|
paramName?: string;
|
paramType?: number;
|
unitMeasureName?: string;
|
required?: boolean;
|
remark?: string;
|
}
|
|
export interface PdTemplate {
|
id?: number;
|
templateCode?: string;
|
templateName?: string;
|
templateType?: number;
|
remark?: string;
|
details?: PdTemplateDetail[];
|
createTime?: string;
|
}
|
|
/* ==================== 工序设置（生产工序） ==================== */
|
|
export interface ProProcess {
|
id?: number;
|
code?: string;
|
name?: string;
|
attention?: string;
|
status?: number;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface ProProcessContent {
|
id?: number;
|
processId?: number;
|
sort?: number;
|
content?: string;
|
device?: string;
|
material?: string;
|
docUrl?: string;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface ProProcessParam {
|
id?: number;
|
processId?: number;
|
processParamId?: number;
|
paramCode?: string;
|
paramName?: string;
|
paramType?: number;
|
unitMeasureId?: number;
|
unitMeasureName?: string;
|
required?: boolean;
|
sort?: number;
|
remark?: string;
|
}
|
|
export interface ProProcessParamSaveItem {
|
processParamId: number;
|
required?: boolean;
|
sort?: number;
|
remark?: string;
|
}
|
|
/* ==================== 工艺路线 ==================== */
|
|
export interface ProRoute {
|
id?: number;
|
code?: string;
|
name?: string;
|
description?: string;
|
status?: number;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface RouteProcessBomItem {
|
itemId?: number;
|
itemCode?: string;
|
itemName?: string;
|
quantity?: number;
|
remark?: string;
|
}
|
|
export interface ProRouteProcess {
|
id?: number;
|
routeId?: number;
|
processId?: number;
|
paramTemplateId?: number;
|
processCode?: string;
|
processName?: string;
|
sort?: number;
|
nextProcessId?: number;
|
nextProcessName?: string;
|
linkType?: number;
|
prepareTime?: number;
|
waitTime?: number;
|
colorCode?: string;
|
keyFlag?: boolean;
|
checkFlag?: boolean;
|
backflushFlag?: boolean;
|
outputItemId?: number;
|
outputItemCode?: string;
|
outputItemName?: string;
|
outputItemIds?: number[];
|
outputItemNames?: string;
|
remark?: string;
|
bomItems?: RouteProcessBomItem[];
|
createTime?: string;
|
}
|
|
export interface RouteProduct {
|
id?: number;
|
routeId?: number;
|
itemId?: number;
|
itemCode?: string;
|
itemName?: string;
|
specification?: string;
|
unitName?: string;
|
quantity?: number;
|
productionTime?: number;
|
timeUnitType?: string;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface RouteProductBom {
|
id?: number;
|
routeId?: number;
|
processId?: number;
|
productId?: number;
|
itemId?: number;
|
itemCode?: string;
|
itemName?: string;
|
specification?: string;
|
unitName?: string;
|
quantity?: number;
|
remark?: string;
|
createTime?: string;
|
}
|
|
/* ==================== 物料 / 产品 BOM ==================== */
|
|
export interface MdProductBom {
|
id?: number;
|
itemId?: number;
|
bomItemId?: number;
|
bomItemCode?: string;
|
bomItemName?: string;
|
bomItemSpecification?: string;
|
unitMeasureName?: string;
|
quantity?: number;
|
status?: number;
|
remark?: string;
|
itemOrProduct?: string;
|
}
|
|
type QueryValue = string | number | boolean | string[] | undefined;
|
const header = (accessToken: string) => ({ Authorization: `Bearer ${accessToken}` });
|
function query(params: Record<string, QueryValue>) {
|
const content = Object.entries(params)
|
.filter(([, value]) => value !== undefined && value !== "")
|
.flatMap(([key, value]) =>
|
Array.isArray(value)
|
? value.map(item => `${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`)
|
: [`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`],
|
)
|
.join("&");
|
return content ? `?${content}` : "";
|
}
|
|
/** 生成 MES 编码 */
|
export function generateAutoCode(accessToken: string, ruleCode: string) {
|
return request<string>("/mes/md/auto-code-record/generate", {
|
method: "POST",
|
data: { ruleCode },
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------------- 基础参数 ---------------- */
|
|
export function getParameterPage(
|
accessToken: string,
|
params: { pageNo: number; pageSize: number; paramCode?: string; paramName?: string; paramType?: number },
|
) {
|
return request<PageResult<PdParameter>>(`/mes/pd/process-param/page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
export function getParameterSimpleList(accessToken: string) {
|
return request<PdParameter[]>("/mes/pd/process-param/simple-list", { header: header(accessToken) });
|
}
|
export function getParameter(accessToken: string, id: number) {
|
return request<PdParameter>(`/mes/pd/process-param/get${query({ id })}`, { header: header(accessToken) });
|
}
|
export function createParameter(accessToken: string, data: PdParameter) {
|
return request<number>("/mes/pd/process-param/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateParameter(accessToken: string, data: PdParameter) {
|
return request<boolean>("/mes/pd/process-param/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteParameter(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/process-param/delete${query({ id })}`, {
|
method: "DELETE",
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------------- 参数模板 ---------------- */
|
|
export function getTemplatePage(
|
accessToken: string,
|
params: { pageNo: number; pageSize: number; templateCode?: string; templateName?: string; templateType?: number },
|
) {
|
return request<PageResult<PdTemplate>>(`/mes/pd/process-param-template/page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
export function getTemplate(accessToken: string, id: number) {
|
return request<PdTemplate>(`/mes/pd/process-param-template/get${query({ id })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function createTemplate(accessToken: string, data: PdTemplate) {
|
return request<number>("/mes/pd/process-param-template/create", {
|
method: "POST",
|
data,
|
header: header(accessToken),
|
});
|
}
|
export function updateTemplate(accessToken: string, data: PdTemplate) {
|
return request<boolean>("/mes/pd/process-param-template/update", {
|
method: "PUT",
|
data,
|
header: header(accessToken),
|
});
|
}
|
export function deleteTemplate(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pd/process-param-template/delete${query({ id })}`, {
|
method: "DELETE",
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------------- 工序设置 ---------------- */
|
|
export function getProcessPage(
|
accessToken: string,
|
params: { pageNo: number; pageSize: number; code?: string; name?: string; status?: number },
|
) {
|
return request<PageResult<ProProcess>>(`/mes/pro/process/page${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
export function getProcessSimpleList(accessToken: string) {
|
return request<ProProcess[]>("/mes/pro/process/simple-list", { header: header(accessToken) });
|
}
|
export function getProcess(accessToken: string, id: number) {
|
return request<ProProcess>(`/mes/pro/process/get${query({ id })}`, { header: header(accessToken) });
|
}
|
export function createProcess(accessToken: string, data: ProProcess) {
|
return request<number>("/mes/pro/process/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateProcess(accessToken: string, data: ProProcess) {
|
return request<boolean>("/mes/pro/process/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteProcess(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pro/process/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
/* ---------------- 工序操作步骤 ---------------- */
|
|
export function getProcessContentList(accessToken: string, processId: number) {
|
return request<ProProcessContent[]>(`/mes/pro/process-content/list-by-process${query({ processId })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function getProcessContent(accessToken: string, id: number) {
|
return request<ProProcessContent>(`/mes/pro/process-content/get${query({ id })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function createProcessContent(accessToken: string, data: ProProcessContent) {
|
return request<number>("/mes/pro/process-content/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateProcessContent(accessToken: string, data: ProProcessContent) {
|
return request<boolean>("/mes/pro/process-content/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteProcessContent(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pro/process-content/delete${query({ id })}`, {
|
method: "DELETE",
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------------- 工序-工艺参数绑定 ---------------- */
|
|
export function getProcessParamListByProcess(accessToken: string, processId: number) {
|
return request<ProProcessParam[]>(`/mes/pro/process-param/list-by-process${query({ processId })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function updateProcessParams(accessToken: string, processId: number, items: ProProcessParamSaveItem[]) {
|
return request<boolean>("/mes/pro/process-param/update-bindings", {
|
method: "POST",
|
data: { processId, items },
|
header: header(accessToken),
|
});
|
}
|
export function getProcessListByParam(accessToken: string, paramId: number) {
|
return request<ProProcess[]>(`/mes/pro/process-param/list-by-param${query({ paramId })}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------------- 工艺路线 ---------------- */
|
|
export function getRoutePage(
|
accessToken: string,
|
params: { pageNo: number; pageSize: number; code?: string; name?: string; status?: number },
|
) {
|
return request<PageResult<ProRoute>>(`/mes/pro/route/page${query(params)}`, { header: header(accessToken) });
|
}
|
export function getRouteSimpleList(accessToken: string) {
|
return request<ProRoute[]>("/mes/pro/route/simple-list", { header: header(accessToken) });
|
}
|
export function getRoute(accessToken: string, id: number) {
|
return request<ProRoute>(`/mes/pro/route/get${query({ id })}`, { header: header(accessToken) });
|
}
|
export function createRoute(accessToken: string, data: ProRoute) {
|
return request<number>("/mes/pro/route/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateRoute(accessToken: string, data: ProRoute) {
|
return request<boolean>("/mes/pro/route/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function updateRouteStatus(accessToken: string, id: number, status: number) {
|
return request<boolean>(`/mes/pro/route/update-status${query({ id, status })}`, {
|
method: "PUT",
|
header: header(accessToken),
|
});
|
}
|
export function deleteRoute(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pro/route/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
/* ---------------- 工艺路线工序 ---------------- */
|
|
export function getRouteProcessListByRoute(accessToken: string, routeId: number) {
|
return request<ProRouteProcess[]>(`/mes/pro/route-process/list-by-route${query({ routeId })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function getRouteProcessListByProduct(accessToken: string, productId: number) {
|
return request<ProRouteProcess[]>(`/mes/pro/route-process/list-by-product${query({ productId })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function getRouteProcess(accessToken: string, id: number) {
|
return request<ProRouteProcess>(`/mes/pro/route-process/get${query({ id })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function getRouteProcessByRouteAndProcess(accessToken: string, routeId: number, processId: number) {
|
return request<ProRouteProcess>(`/mes/pro/route-process/get-by-route-and-process${query({ routeId, processId })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function createRouteProcess(accessToken: string, data: ProRouteProcess) {
|
return request<number>("/mes/pro/route-process/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateRouteProcess(accessToken: string, data: ProRouteProcess) {
|
return request<boolean>("/mes/pro/route-process/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteRouteProcess(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pro/route-process/delete${query({ id })}`, {
|
method: "DELETE",
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------------- 工艺路线产品 ---------------- */
|
|
export function getRouteProductListByRoute(accessToken: string, routeId: number) {
|
return request<RouteProduct[]>(`/mes/pro/route-product/list-by-route${query({ routeId })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function getRouteProduct(accessToken: string, id: number) {
|
return request<RouteProduct>(`/mes/pro/route-product/get${query({ id })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function createRouteProduct(accessToken: string, data: RouteProduct) {
|
return request<number>("/mes/pro/route-product/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateRouteProduct(accessToken: string, data: RouteProduct) {
|
return request<boolean>("/mes/pro/route-product/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteRouteProduct(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pro/route-product/delete${query({ id })}`, {
|
method: "DELETE",
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------------- 工艺路线产品 BOM（投入物料） ---------------- */
|
|
export function getRouteProductBomList(
|
accessToken: string,
|
params: { routeId: number; processId?: number; productId?: number },
|
) {
|
return request<RouteProductBom[]>(`/mes/pro/route-product-bom/list${query(params)}`, {
|
header: header(accessToken),
|
});
|
}
|
export function getRouteProductBom(accessToken: string, id: number) {
|
return request<RouteProductBom>(`/mes/pro/route-product-bom/get${query({ id })}`, {
|
header: header(accessToken),
|
});
|
}
|
export function createRouteProductBom(accessToken: string, data: RouteProductBom) {
|
return request<number>("/mes/pro/route-product-bom/create", {
|
method: "POST",
|
data,
|
header: header(accessToken),
|
});
|
}
|
export function updateRouteProductBom(accessToken: string, data: RouteProductBom) {
|
return request<boolean>("/mes/pro/route-product-bom/update", {
|
method: "PUT",
|
data,
|
header: header(accessToken),
|
});
|
}
|
export function deleteRouteProductBom(accessToken: string, id: number) {
|
return request<boolean>(`/mes/pro/route-product-bom/delete${query({ id })}`, {
|
method: "DELETE",
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------------- 产品 BOM（BOM 物料数据源） ---------------- */
|
|
export function getProductBomListByItemId(accessToken: string, itemId: number) {
|
return request<MesProductBom[]>(`/mes/md/product-bom/list-by-item-id${query({ itemId })}`, {
|
header: header(accessToken),
|
});
|
}
|
|
/* ---------------- MES 物料产品（物料选择器数据源，与 web 端 MdItemSelect 一致） ---------------- */
|
|
export interface MesMdItem {
|
id?: number;
|
code?: string;
|
name?: string;
|
specification?: string;
|
unitMeasureId?: number;
|
unitMeasureName?: string;
|
itemTypeId?: number;
|
itemTypeName?: string;
|
itemOrProduct?: string;
|
status?: number;
|
safeStockFlag?: boolean;
|
minStock?: number;
|
maxStock?: number;
|
highValue?: boolean;
|
batchFlag?: boolean;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface MesWorkshop {
|
id?: number;
|
code?: string;
|
name?: string;
|
area?: number;
|
chargeUserId?: number;
|
chargeUserName?: string;
|
status?: number;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface MesWorkstation {
|
id?: number;
|
code?: string;
|
name?: string;
|
address?: string;
|
workshopId?: number;
|
workshopName?: string;
|
processId?: number;
|
processName?: string;
|
warehouseId?: number;
|
warehouseName?: string;
|
locationId?: number;
|
locationName?: string;
|
areaId?: number;
|
areaName?: string;
|
status?: number;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface MesProductBom {
|
id?: number;
|
itemId?: number;
|
bomItemId?: number;
|
quantity?: number;
|
status?: number;
|
remark?: string;
|
createTime?: string;
|
bomItemCode?: string;
|
bomItemName?: string;
|
bomItemSpecification?: string;
|
unitMeasureName?: string;
|
itemOrProduct?: string;
|
}
|
|
export interface MesBatchConfig {
|
id?: number;
|
itemId?: number;
|
produceDateFlag?: boolean;
|
expireDateFlag?: boolean;
|
receiptDateFlag?: boolean;
|
vendorFlag?: boolean;
|
clientFlag?: boolean;
|
salesOrderCodeFlag?: boolean;
|
purchaseOrderCodeFlag?: boolean;
|
workorderFlag?: boolean;
|
taskFlag?: boolean;
|
workstationFlag?: boolean;
|
toolFlag?: boolean;
|
moldFlag?: boolean;
|
lotNumberFlag?: boolean;
|
qualityStatusFlag?: boolean;
|
}
|
|
export interface ProductMedia {
|
id?: number;
|
itemId?: number;
|
sort?: number;
|
processId?: number;
|
processCode?: string;
|
processName?: string;
|
title?: string;
|
description?: string;
|
url?: string;
|
remark?: string;
|
createTime?: string;
|
}
|
export interface StorageFile {
|
id: number;
|
name?: string;
|
url?: string;
|
previewURL?: string;
|
downloadURL?: string;
|
}
|
|
export interface WorkstationMachine {
|
id?: number;
|
workstationId?: number;
|
machineryId?: number;
|
machineryCode?: string;
|
machineryName?: string;
|
quantity?: number;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface WorkstationTool {
|
id?: number;
|
workstationId?: number;
|
toolTypeId?: number;
|
toolTypeName?: string;
|
quantity?: number;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface WorkstationWorker {
|
id?: number;
|
workstationId?: number;
|
postId?: number;
|
postName?: string;
|
quantity?: number;
|
remark?: string;
|
createTime?: string;
|
}
|
|
export interface ToolTypeSimple {
|
id?: number;
|
code?: string;
|
name?: string;
|
}
|
|
export interface PostSimple {
|
id?: number;
|
code?: string;
|
name?: string;
|
}
|
|
export function getMesItemPage(
|
accessToken: string,
|
params: { pageNo: number; pageSize: number; code?: string; name?: string; status?: number; ids?: string; itemTypeId?: number },
|
) {
|
return request<PageResult<MesMdItem>>(`/mes/md/item/page${query(params)}`, { header: header(accessToken) });
|
}
|
export function getMesItem(accessToken: string, id: number) {
|
return request<MesMdItem>(`/mes/md/item/get${query({ id })}`, { header: header(accessToken) });
|
}
|
export function createMesItem(accessToken: string, data: MesMdItem) {
|
return request<number>("/mes/md/item/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateMesItem(accessToken: string, data: MesMdItem) {
|
return request<boolean>("/mes/md/item/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteMesItem(accessToken: string, id: number) {
|
return request<boolean>(`/mes/md/item/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export function getWorkshopPage(
|
accessToken: string,
|
params: { pageNo: number; pageSize: number; code?: string; name?: string; status?: number },
|
) {
|
return request<PageResult<MesWorkshop>>(`/mes/md-workshop/page${query(params)}`, { header: header(accessToken) });
|
}
|
export function getWorkshopSimpleList(accessToken: string) {
|
return request<MesWorkshop[]>("/mes/md-workshop/simple-list", { header: header(accessToken) });
|
}
|
export function getWorkshop(accessToken: string, id: number) {
|
return request<MesWorkshop>(`/mes/md-workshop/get${query({ id })}`, { header: header(accessToken) });
|
}
|
export function createWorkshop(accessToken: string, data: MesWorkshop) {
|
return request<number>("/mes/md-workshop/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateWorkshop(accessToken: string, data: MesWorkshop) {
|
return request<boolean>("/mes/md-workshop/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteWorkshop(accessToken: string, id: number) {
|
return request<boolean>(`/mes/md-workshop/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export function getWorkstationPage(
|
accessToken: string,
|
params: { pageNo: number; pageSize: number; code?: string; name?: string; workshopId?: number; processId?: number; status?: number },
|
) {
|
return request<PageResult<MesWorkstation>>(`/mes/md-workstation/page${query(params)}`, { header: header(accessToken) });
|
}
|
export function getWorkstation(accessToken: string, id: number) {
|
return request<MesWorkstation>(`/mes/md-workstation/get${query({ id })}`, { header: header(accessToken) });
|
}
|
export function createWorkstation(accessToken: string, data: MesWorkstation) {
|
return request<number>("/mes/md-workstation/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateWorkstation(accessToken: string, data: MesWorkstation) {
|
return request<boolean>("/mes/md-workstation/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteWorkstation(accessToken: string, id: number) {
|
return request<boolean>(`/mes/md-workstation/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export function createProductBom(accessToken: string, data: MesProductBom) {
|
return request<number>("/mes/md/product-bom/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateProductBom(accessToken: string, data: MesProductBom) {
|
return request<boolean>("/mes/md/product-bom/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteProductBom(accessToken: string, id: number) {
|
return request<boolean>(`/mes/md/product-bom/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
export function getBatchConfigByItemId(accessToken: string, itemId: number) {
|
return request<MesBatchConfig>(`/mes/md/item-batch-config/get-by-item-id${query({ itemId })}`, { header: header(accessToken) });
|
}
|
export function saveBatchConfig(accessToken: string, data: MesBatchConfig) {
|
return request<number>("/mes/md/item-batch-config/save", { method: "POST", data, header: header(accessToken) });
|
}
|
export function uploadMesFile(accessToken: string, filePath: string) {
|
return new Promise<StorageFile>((resolve, reject) =>
|
uni.uploadFile({
|
url: `${API_BASE_URL}/system/storage-blob/upload`,
|
filePath,
|
name: "files",
|
header: header(accessToken),
|
success: response => {
|
try {
|
const data = JSON.parse(response.data) as ApiResponse<StorageFile[]>;
|
if ((data.code === 0 || data.code === 200) && data.data?.[0]) resolve(data.data[0]);
|
else reject(new Error(data.msg || "文件上传失败"));
|
} catch {
|
reject(new Error("文件上传响应解析失败"));
|
}
|
},
|
fail: () => reject(new Error("文件上传失败，请检查网络后重试")),
|
}),
|
);
|
}
|
export function getProductSipListByItemId(accessToken: string, itemId: number) {
|
return request<ProductMedia[]>(`/mes/md/product-sip/list-by-item-id${query({ itemId })}`, { header: header(accessToken) });
|
}
|
export function createProductSip(accessToken: string, data: ProductMedia) {
|
return request<number>("/mes/md/product-sip/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateProductSip(accessToken: string, data: ProductMedia) {
|
return request<boolean>("/mes/md/product-sip/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteProductSip(accessToken: string, id: number) {
|
return request<boolean>(`/mes/md/product-sip/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
export function getProductSopListByItemId(accessToken: string, itemId: number) {
|
return request<ProductMedia[]>(`/mes/md/product-sop/list-by-item-id${query({ itemId })}`, { header: header(accessToken) });
|
}
|
export function createProductSop(accessToken: string, data: ProductMedia) {
|
return request<number>("/mes/md/product-sop/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateProductSop(accessToken: string, data: ProductMedia) {
|
return request<boolean>("/mes/md/product-sop/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteProductSop(accessToken: string, id: number) {
|
return request<boolean>(`/mes/md/product-sop/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
|
export function getWorkstationMachineList(accessToken: string, workstationId: number) {
|
return request<WorkstationMachine[]>(`/mes/md-workstation-machine/list-by-workstation${query({ workstationId })}`, { header: header(accessToken) });
|
}
|
export function createWorkstationMachine(accessToken: string, data: WorkstationMachine) {
|
return request<number>("/mes/md-workstation-machine/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function deleteWorkstationMachine(accessToken: string, id: number) {
|
return request<boolean>(`/mes/md-workstation-machine/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
export function getToolTypeSimpleList(accessToken: string) {
|
return request<ToolTypeSimple[]>("/mes/tm/tool-type/simple-list", { header: header(accessToken) });
|
}
|
export function getWorkstationToolList(accessToken: string, workstationId: number) {
|
return request<WorkstationTool[]>(`/mes/md-workstation-tool/list-by-workstation${query({ workstationId })}`, { header: header(accessToken) });
|
}
|
export function createWorkstationTool(accessToken: string, data: WorkstationTool) {
|
return request<number>("/mes/md-workstation-tool/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateWorkstationTool(accessToken: string, data: WorkstationTool) {
|
return request<boolean>("/mes/md-workstation-tool/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteWorkstationTool(accessToken: string, id: number) {
|
return request<boolean>(`/mes/md-workstation-tool/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
export function getSimplePostList(accessToken: string) {
|
return request<PostSimple[]>("/system/post/simple-list", { header: header(accessToken) });
|
}
|
export function getWorkstationWorkerList(accessToken: string, workstationId: number) {
|
return request<WorkstationWorker[]>(`/mes/md-workstation-worker/list-by-workstation${query({ workstationId })}`, { header: header(accessToken) });
|
}
|
export function getUserListByWorkstationId(accessToken: string, workstationId?: number) {
|
if (!workstationId) return Promise.resolve([] as UserSimple[]);
|
return request<UserSimple[]>(`/mes/md-workstation-worker/list-user-by-workstation${query({ workstationId })}`, { header: header(accessToken) });
|
}
|
export function createWorkstationWorker(accessToken: string, data: WorkstationWorker) {
|
return request<number>("/mes/md-workstation-worker/create", { method: "POST", data, header: header(accessToken) });
|
}
|
export function updateWorkstationWorker(accessToken: string, data: WorkstationWorker) {
|
return request<boolean>("/mes/md-workstation-worker/update", { method: "PUT", data, header: header(accessToken) });
|
}
|
export function deleteWorkstationWorker(accessToken: string, id: number) {
|
return request<boolean>(`/mes/md-workstation-worker/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
|
}
|
