!350 MES 迁移收尾 99%

Merge pull request !350 from 芋道源码/migration
pull/347/MERGE
芋道源码 2026-05-30 10:01:19 +00:00 committed by Gitee
commit 70ca594a4c
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
1053 changed files with 100330 additions and 3355 deletions

3
.gitignore vendored
View File

@ -60,3 +60,6 @@ vite.config.ts.*
skills-lock.json
.atomcode
datalog
# Playwright CLI 录制产物(本地调试,不入库)
.playwright-cli

View File

@ -54,6 +54,7 @@
"camunda-bpmn-moddle": "catalog:",
"cropperjs": "catalog:",
"dayjs": "catalog:",
"dhtmlx-gantt": "catalog:",
"diagram-js": "catalog:",
"fast-xml-parser": "catalog:",
"highlight.js": "catalog:",

View File

@ -0,0 +1,55 @@
import { requestClient } from '#/api/request';
export namespace MesHomeApi {
/** MES 首页汇总统计 */
export interface Summary {
workOrderActiveCount: number; // 进行中工单数
workOrderPrepareCount: number; // 待排产工单数
workOrderFinishedCount: number; // 已完成工单数
todayOutput: number; // 今日产量
yesterdayOutput: number; // 昨日产量
todayQualifiedQuantity: number; // 今日合格品数
todayUnqualifiedQuantity: number; // 今日不良品数
machineryTotal: number; // 设备总数
machineryProducing: number; // 生产中设备数
machineryStop: number; // 停机设备数
machineryMaintenance: number; // 维护中设备数
andonActiveCount: number; // 未处置安灯呼叫数
repairActiveCount: number; // 待处理维修工单数
}
/** MES 工单状态分布 */
export interface WorkOrderStatus {
status: number; // 工单状态
statusName: string; // 工单状态名称
count: number; // 数量
}
/** MES 生产趋势 */
export interface ProductionTrend {
date: string; // 日期
quantity: number; // 产量
qualifiedQuantity: number; // 合格品数
unqualifiedQuantity: number; // 不良品数
}
}
/** 获得首页汇总统计 */
export function getHomeSummary() {
return requestClient.get<MesHomeApi.Summary>('/mes/home-statistics/summary');
}
/** 获得工单状态分布 */
export function getWorkOrderStatusDistribution() {
return requestClient.get<MesHomeApi.WorkOrderStatus[]>(
'/mes/home-statistics/work-order-status',
);
}
/** 获得生产趋势 */
export function getProductionTrend(days?: number) {
return requestClient.get<MesHomeApi.ProductionTrend[]>(
'/mes/home-statistics/production-trend',
{ params: { days } },
);
}

View File

@ -0,0 +1,79 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProCardApi {
/** MES 生产流转卡 */
export interface Card {
id?: number; // 编号
code?: string; // 流转卡编码
workOrderId?: number; // 生产工单编号
workOrderCode?: string; // 工单编码
workOrderName?: string; // 工单名称
batchCode?: string; // 批次号
itemId?: number; // 产品物料编号
itemCode?: string; // 产品编码
itemName?: string; // 产品名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位名称
transferedQuantity?: number; // 流转数量
status?: number; // 状态
remark?: string; // 备注
}
/** MES 生产流转卡分页查询参数 */
export interface PageParams extends PageParam {
code?: string;
workOrderId?: number;
itemId?: number;
batchCode?: string;
}
}
/** 查询生产流转卡分页 */
export function getCardPage(params: MesProCardApi.PageParams) {
return requestClient.get<PageResult<MesProCardApi.Card>>(
'/mes/pro/card/page',
{ params },
);
}
/** 查询生产流转卡详情 */
export function getCard(id: number) {
return requestClient.get<MesProCardApi.Card>(`/mes/pro/card/get?id=${id}`);
}
/** 新增生产流转卡 */
export function createCard(data: MesProCardApi.Card) {
return requestClient.post<number>('/mes/pro/card/create', data);
}
/** 修改生产流转卡 */
export function updateCard(data: MesProCardApi.Card) {
return requestClient.put('/mes/pro/card/update', data);
}
/** 删除生产流转卡 */
export function deleteCard(id: number) {
return requestClient.delete(`/mes/pro/card/delete?id=${id}`);
}
/** 导出生产流转卡 */
export function exportCard(params: any) {
return requestClient.download('/mes/pro/card/export-excel', { params });
}
/** 提交生产流转卡 */
export function submitCard(id: number) {
return requestClient.put(`/mes/pro/card/submit?id=${id}`);
}
/** 完成生产流转卡 */
export function finishCard(id: number) {
return requestClient.put(`/mes/pro/card/finish?id=${id}`);
}
/** 取消生产流转卡 */
export function cancelCard(id: number) {
return requestClient.put(`/mes/pro/card/cancel?id=${id}`);
}

View File

@ -0,0 +1,62 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProCardProcessApi {
/** MES 流转卡工序记录 */
export interface CardProcess {
id?: number; // 编号
cardId?: number; // 流转卡编号
sort?: number; // 序号
processId?: number; // 工序编号
processCode?: string; // 工序编码
processName?: string; // 工序名称
inputTime?: number; // 进入工序时间
outputTime?: number; // 出工序时间
inputQuantity?: number; // 投入数量
outputQuantity?: number; // 产出数量
unqualifiedQuantity?: number; // 不合格品数量
workstationId?: number; // 工位编号
workstationCode?: string; // 工位编码
workstationName?: string; // 工位名称
userId?: number; // 操作人编号
nickname?: string; // 操作人名称
ipqcId?: number; // 过程检验单编号
remark?: string; // 备注
}
/** MES 流转卡工序记录分页查询参数 */
export interface PageParams extends PageParam {
cardId?: number;
}
}
/** 查询流转卡工序记录分页 */
export function getCardProcessPage(params: MesProCardProcessApi.PageParams) {
return requestClient.get<PageResult<MesProCardProcessApi.CardProcess>>(
'/mes/pro/card-process/page',
{ params },
);
}
/** 查询流转卡工序记录详情 */
export function getCardProcess(id: number) {
return requestClient.get<MesProCardProcessApi.CardProcess>(
`/mes/pro/card-process/get?id=${id}`,
);
}
/** 新增流转卡工序记录 */
export function createCardProcess(data: MesProCardProcessApi.CardProcess) {
return requestClient.post('/mes/pro/card-process/create', data);
}
/** 修改流转卡工序记录 */
export function updateCardProcess(data: MesProCardProcessApi.CardProcess) {
return requestClient.put('/mes/pro/card-process/update', data);
}
/** 删除流转卡工序记录 */
export function deleteCardProcess(id: number) {
return requestClient.delete(`/mes/pro/card-process/delete?id=${id}`);
}

View File

@ -48,6 +48,8 @@ export namespace MesProTaskApi {
name?: string;
workOrderId?: number;
workstationId?: number;
routeId?: number;
processId?: number;
itemId?: number;
statuses?: number[];
status?: number;
@ -66,3 +68,28 @@ export function getTaskPage(params: MesProTaskApi.PageParams) {
export function getTask(id: number) {
return requestClient.get<MesProTaskApi.Task>(`/mes/pro/task/get?id=${id}`);
}
/** 新增生产任务 */
export function createTask(data: MesProTaskApi.Task) {
return requestClient.post('/mes/pro/task/create', data);
}
/** 修改生产任务 */
export function updateTask(data: MesProTaskApi.Task) {
return requestClient.put('/mes/pro/task/update', data);
}
/** 删除生产任务 */
export function deleteTask(id: number) {
return requestClient.delete(`/mes/pro/task/delete?id=${id}`);
}
/** 导出生产任务 */
export function exportTask(params: any) {
return requestClient.download('/mes/pro/task/export-excel', { params });
}
/** 查询甘特图任务列表(非分页) */
export function getGanttTaskList(params: any) {
return requestClient.get<any[]>('/mes/pro/task/gantt-list', { params });
}

View File

@ -0,0 +1,62 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProWorkOrderBomApi {
/** MES 生产工单 BOM */
export interface WorkOrderBom {
id?: number; // 编号
workOrderId?: number; // 生产工单编号
itemId?: number; // BOM 物料编号
itemName?: string; // 物料名称
itemCode?: string; // 物料编码
itemSpecification?: string; // 规格型号
unitMeasureId?: number; // 单位编号
unitMeasureName?: string; // 单位名称
quantity?: number; // 预计使用量
remark?: string; // 备注
itemOrProduct?: string; // 物料产品标识
}
/** MES 生产工单 BOM 分页查询参数 */
export interface PageParams extends PageParam {
workOrderId?: number;
}
}
/** 查询工单 BOM 分页 */
export function getWorkOrderBomPage(params: MesProWorkOrderBomApi.PageParams) {
return requestClient.get<PageResult<MesProWorkOrderBomApi.WorkOrderBom>>(
'/mes/pro/work-order-bom/page',
{ params },
);
}
/** 查询工单 BOM 详情 */
export function getWorkOrderBom(id: number) {
return requestClient.get<MesProWorkOrderBomApi.WorkOrderBom>(
`/mes/pro/work-order-bom/get?id=${id}`,
);
}
/** 新增工单 BOM */
export function createWorkOrderBom(data: MesProWorkOrderBomApi.WorkOrderBom) {
return requestClient.post('/mes/pro/work-order-bom/create', data);
}
/** 修改工单 BOM */
export function updateWorkOrderBom(data: MesProWorkOrderBomApi.WorkOrderBom) {
return requestClient.put('/mes/pro/work-order-bom/update', data);
}
/** 删除工单 BOM */
export function deleteWorkOrderBom(id: number) {
return requestClient.delete(`/mes/pro/work-order-bom/delete?id=${id}`);
}
/** 查询工单物料需求列表 */
export function getWorkOrderBomItemListByWorkOrderId(workOrderId: number) {
return requestClient.get<MesProWorkOrderBomApi.WorkOrderBom[]>(
`/mes/pro/work-order-bom/item-list-by-work-order-id?workOrderId=${workOrderId}`,
);
}

View File

@ -5,35 +5,48 @@ import { requestClient } from '#/api/request';
export namespace MesProWorkOrderApi {
/** MES 生产工单 */
export interface WorkOrder {
id?: number;
id?: number; // 编号
code?: string; // 工单编码
name?: string; // 工单名称
type?: number; // 工单类型
orderSourceType?: number; // 来源类型
orderSourceCode?: string; // 来源单据编号
productId?: number; // 产品编号
productName?: string; // 产品名称
productCode?: string; // 产品编码
productSpecification?: string; // 规格型号
unitMeasureName?: string; // 单位名称
quantity?: number; // 生产数量
quantityProduced?: number; // 已生产数量
quantityChanged?: number; // 调整数量
quantityScheduled?: number; // 已排产数量
clientId?: number; // 客户编号
clientCode?: string; // 客户编码
clientName?: string; // 客户名称
vendorId?: number; // 供应商编号
vendorName?: string; // 供应商名称
vendorCode?: string; // 供应商编码
batchCode?: string; // 批次号
requestDate?: number; // 需求日期
parentId?: number; // 父工单编号
parentCode?: string; // 父工单编码
finishDate?: number; // 完成时间
cancelDate?: number; // 取消时间
status?: number; // 工单状态
sourceType?: number;
productId?: number; // 产品物料编号
productCode?: string;
productName?: string;
productSpecification?: string;
quantity?: number;
unitName?: string;
routeId?: number;
routeName?: string;
clientId?: number;
clientName?: string;
planStartTime?: number | string;
planEndTime?: number | string;
actualStartTime?: number | string;
actualEndTime?: number | string;
remark?: string;
createTime?: number | string;
remark?: string; // 备注
createTime?: number; // 创建时间
}
/** MES 生产工单分页查询参数 */
export interface PageParams extends PageParam {
code?: string;
name?: string;
orderSourceCode?: string;
productId?: number;
clientId?: number;
status?: number;
type?: number;
requestDate?: number[];
}
}
@ -51,3 +64,38 @@ export function getWorkOrder(id: number) {
`/mes/pro/work-order/get?id=${id}`,
);
}
/** 新增生产工单 */
export function createWorkOrder(data: MesProWorkOrderApi.WorkOrder) {
return requestClient.post<number>('/mes/pro/work-order/create', data);
}
/** 修改生产工单 */
export function updateWorkOrder(data: MesProWorkOrderApi.WorkOrder) {
return requestClient.put('/mes/pro/work-order/update', data);
}
/** 删除生产工单 */
export function deleteWorkOrder(id: number) {
return requestClient.delete(`/mes/pro/work-order/delete?id=${id}`);
}
/** 导出生产工单 */
export function exportWorkOrder(params: any) {
return requestClient.download('/mes/pro/work-order/export-excel', { params });
}
/** 完成工单 */
export function finishWorkOrder(id: number) {
return requestClient.put(`/mes/pro/work-order/finish?id=${id}`);
}
/** 取消工单 */
export function cancelWorkOrder(id: number) {
return requestClient.put(`/mes/pro/work-order/cancel?id=${id}`);
}
/** 确认工单 */
export function confirmWorkOrder(id: number) {
return requestClient.put(`/mes/pro/work-order/confirm?id=${id}`);
}

View File

@ -0,0 +1,49 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcDefectRecordApi {
/** MES 质检缺陷记录 */
export interface DefectRecord {
id?: number; // 编号
qcType?: number; // 检验类型
qcId?: number; // 检验单 ID
lineId?: number; // 检验行 ID
name?: string; // 缺陷描述
level?: number; // 缺陷等级
quantity?: number; // 缺陷数量
remark?: string; // 备注
}
}
/** 查询质检缺陷记录 */
export function getDefectRecord(id: number) {
return requestClient.get<MesQcDefectRecordApi.DefectRecord>(
`/mes/qc/defect-record/get?id=${id}`,
);
}
/** 查询质检缺陷记录分页 */
export function getDefectRecordPage(
params: PageParam & { lineId?: number; qcId?: number; qcType?: number; },
) {
return requestClient.get<PageResult<MesQcDefectRecordApi.DefectRecord>>(
'/mes/qc/defect-record/page',
{ params },
);
}
/** 新增质检缺陷记录 */
export function createDefectRecord(data: MesQcDefectRecordApi.DefectRecord) {
return requestClient.post('/mes/qc/defect-record/create', data);
}
/** 修改质检缺陷记录 */
export function updateDefectRecord(data: MesQcDefectRecordApi.DefectRecord) {
return requestClient.put('/mes/qc/defect-record/update', data);
}
/** 删除质检缺陷记录 */
export function deleteDefectRecord(id: number) {
return requestClient.delete(`/mes/qc/defect-record/delete?id=${id}`);
}

View File

@ -0,0 +1,73 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcIndicatorResultApi {
/** MES 检验结果明细 */
export interface IndicatorResultDetail {
id?: number; // 编号
resultId?: number; // 关联检验结果 ID
indicatorId?: number; // 检测指标 ID
value?: string; // 检测值(统一存为字符串)
valueNumber?: number; // UI 数值绑定(提交前转字符串)
remark?: string; // 备注
// 关联查询字段(来自 indicator
indicatorName?: string; // 检测指标名称
valueType?: number; // 质检值类型
valueSpecification?: string; // 值属性
}
/** MES 检验结果 */
export interface IndicatorResult {
id?: number; // 编号
code?: string; // 样品编号
qcId?: number; // 关联质检单 ID
qcType?: number; // 质检类型
itemId?: number; // 产品物料 ID
sn?: string; // 物资 SN
remark?: string; // 备注
createTime?: Date; // 创建时间
items?: IndicatorResultDetail[]; // 检验结果明细列表
}
}
/** 查询检验结果分页 */
export function getIndicatorResultPage(
params: PageParam & { qcId?: number; qcType?: number },
) {
return requestClient.get<PageResult<MesQcIndicatorResultApi.IndicatorResult>>(
'/mes/qc/indicator-result/page',
{ params },
);
}
/** 查询检验结果明细(含检测项模板):编辑传 id新增不传 */
export function getIndicatorResultDetail(
qcId: number,
qcType: number,
id?: number,
) {
return requestClient.get<MesQcIndicatorResultApi.IndicatorResult>(
'/mes/qc/indicator-result/get-detail',
{ params: { id, qcId, qcType } },
);
}
/** 新增检验结果 */
export function createIndicatorResult(
data: MesQcIndicatorResultApi.IndicatorResult,
) {
return requestClient.post('/mes/qc/indicator-result/create', data);
}
/** 修改检验结果 */
export function updateIndicatorResult(
data: MesQcIndicatorResultApi.IndicatorResult,
) {
return requestClient.put('/mes/qc/indicator-result/update', data);
}
/** 删除检验结果 */
export function deleteIndicatorResult(id: number) {
return requestClient.delete(`/mes/qc/indicator-result/delete?id=${id}`);
}

View File

@ -0,0 +1,87 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcIpqcApi {
/** MES 过程检验单 */
export interface Ipqc {
id?: number; // 编号
code?: string; // 检验单编号
name?: string; // 检验单名称
type?: number; // IPQC 检验类型
templateId?: number; // 检验模板 ID
sourceDocType?: number; // 来源单据类型
sourceDocId?: number; // 来源单据 ID
sourceLineId?: number; // 来源单据行 ID
sourceDocCode?: string; // 来源单据编号(关联查询)
workOrderId?: number; // 生产工单 ID
workOrderCode?: string; // 工单编号(关联查询)
workOrderName?: string; // 工单名称(关联查询)
taskId?: number; // 生产任务 ID
workstationId?: number; // 工位 ID
workstationName?: string; // 工位名称(关联查询)
processId?: number; // 工序 ID
processName?: string; // 工序名称(关联查询)
itemId?: number; // 产品物料 ID
itemCode?: string; // 产品物料编码(关联查询)
itemName?: string; // 产品物料名称(关联查询)
itemSpecification?: string; // 规格型号(关联查询)
unitName?: string; // 单位名称(关联查询)
checkQuantity?: number; // 检测数量
qualifiedQuantity?: number; // 合格品数量
unqualifiedQuantity?: number; // 不合格品数量
laborScrapQuantity?: number; // 工废数量
materialScrapQuantity?: number; // 料废数量
otherScrapQuantity?: number; // 其他废品数量
criticalRate?: number; // 致命缺陷率(%
majorRate?: number; // 严重缺陷率(%
minorRate?: number; // 轻微缺陷率(%
criticalQuantity?: number; // 致命缺陷数量
majorQuantity?: number; // 严重缺陷数量
minorQuantity?: number; // 轻微缺陷数量
checkResult?: number; // 检测结果
inspectDate?: number; // 检测日期
inspectorUserId?: number; // 检测人员用户 ID
inspectorNickname?: string; // 检测人员昵称(关联查询)
status?: number; // 状态
remark?: string; // 备注
}
}
/** 查询过程检验单分页 */
export function getIpqcPage(params: PageParam) {
return requestClient.get<PageResult<MesQcIpqcApi.Ipqc>>(
'/mes/qc/ipqc/page',
{ params },
);
}
/** 查询过程检验单详情 */
export function getIpqc(id: number) {
return requestClient.get<MesQcIpqcApi.Ipqc>(`/mes/qc/ipqc/get?id=${id}`);
}
/** 新增过程检验单 */
export function createIpqc(data: MesQcIpqcApi.Ipqc) {
return requestClient.post('/mes/qc/ipqc/create', data);
}
/** 修改过程检验单 */
export function updateIpqc(data: MesQcIpqcApi.Ipqc) {
return requestClient.put('/mes/qc/ipqc/update', data);
}
/** 完成过程检验单 */
export function finishIpqc(id: number) {
return requestClient.put(`/mes/qc/ipqc/finish?id=${id}`);
}
/** 删除过程检验单 */
export function deleteIpqc(id: number) {
return requestClient.delete(`/mes/qc/ipqc/delete?id=${id}`);
}
/** 导出过程检验单 */
export function exportIpqc(params: any) {
return requestClient.download('/mes/qc/ipqc/export-excel', { params });
}

View File

@ -0,0 +1,42 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcIpqcLineApi {
/** MES 过程检验单行 */
export interface IpqcLine {
id?: number; // 编号
ipqcId?: number; // 过程检验单 ID
indicatorId?: number; // 检测指标 ID
indicatorCode?: string; // 检测指标编码(关联查询)
indicatorName?: string; // 检测指标名称(关联查询)
indicatorType?: number; // 检测指标类型(关联查询)
toolId?: number; // 检测工具 ID
toolName?: string; // 检测工具名称(关联查询)
checkMethod?: string; // 检测方法
standardValue?: number; // 标准值
unitMeasureId?: number; // 计量单位 ID
unitMeasureName?: string; // 计量单位名称(关联查询)
maxThreshold?: number; // 误差上限
minThreshold?: number; // 误差下限
criticalQuantity?: number; // 致命缺陷数量
majorQuantity?: number; // 严重缺陷数量
minorQuantity?: number; // 轻微缺陷数量
remark?: string; // 备注
}
}
/** 查询过程检验单行分页 */
export function getIpqcLinePage(params: PageParam & { ipqcId?: number }) {
return requestClient.get<PageResult<MesQcIpqcLineApi.IpqcLine>>(
'/mes/qc/ipqc/line/page',
{ params },
);
}
/** 查询过程检验单行详情 */
export function getIpqcLine(id: number) {
return requestClient.get<MesQcIpqcLineApi.IpqcLine>(
`/mes/qc/ipqc/line/get?id=${id}`,
);
}

View File

@ -0,0 +1,80 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcIqcApi {
/** MES 来料检验单 */
export interface Iqc {
id?: number; // 编号
code?: string; // 检验单编号
name?: string; // 检验单名称
templateId?: number; // 检验模板 ID
sourceDocType?: number; // 来源单据类型
sourceDocId?: number; // 来源单据 ID
sourceLineId?: number; // 来源单据行 ID
sourceDocCode?: string; // 来源单据编号(关联查询)
vendorId?: number; // 供应商 ID
vendorNickname?: string; // 供应商简称(关联查询)
vendorBatch?: string; // 供应商批次号
itemId?: number; // 产品物料 ID
itemCode?: string; // 产品物料编码(关联查询)
itemName?: string; // 产品物料名称(关联查询)
itemSpecification?: string; // 规格型号(关联查询)
unitName?: string; // 单位名称(关联查询)
receivedQuantity?: number; // 本次接收数量
checkQuantity?: number; // 本次检测数量
qualifiedQuantity?: number; // 合格品数量
unqualifiedQuantity?: number; // 不合格品数量
criticalRate?: number; // 致命缺陷率(%
majorRate?: number; // 严重缺陷率(%
minorRate?: number; // 轻微缺陷率(%
criticalQuantity?: number; // 致命缺陷数量
majorQuantity?: number; // 严重缺陷数量
minorQuantity?: number; // 轻微缺陷数量
checkResult?: number; // 检测结果
receiveDate?: number; // 来料日期
inspectDate?: number; // 检测日期
inspector?: string; // 检测人员(昵称)
inspectorUserId?: number; // 检测人员 ID
inspectorNickname?: string; // 检测人员昵称(关联查询)
status?: number; // 状态
remark?: string; // 备注
}
}
/** 查询来料检验单分页 */
export function getIqcPage(params: PageParam) {
return requestClient.get<PageResult<MesQcIqcApi.Iqc>>('/mes/qc/iqc/page', {
params,
});
}
/** 查询来料检验单详情 */
export function getIqc(id: number) {
return requestClient.get<MesQcIqcApi.Iqc>(`/mes/qc/iqc/get?id=${id}`);
}
/** 新增来料检验单 */
export function createIqc(data: MesQcIqcApi.Iqc) {
return requestClient.post('/mes/qc/iqc/create', data);
}
/** 修改来料检验单 */
export function updateIqc(data: MesQcIqcApi.Iqc) {
return requestClient.put('/mes/qc/iqc/update', data);
}
/** 完成来料检验单 */
export function finishIqc(id: number) {
return requestClient.put(`/mes/qc/iqc/finish?id=${id}`);
}
/** 删除来料检验单 */
export function deleteIqc(id: number) {
return requestClient.delete(`/mes/qc/iqc/delete?id=${id}`);
}
/** 导出来料检验单 */
export function exportIqc(params: any) {
return requestClient.download('/mes/qc/iqc/export-excel', { params });
}

View File

@ -0,0 +1,41 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcIqcLineApi {
/** MES 来料检验单行 */
export interface IqcLine {
id?: number; // 编号
iqcId?: number; // 来料检验单 ID
indicatorId?: number; // 检测指标 ID
indicatorCode?: string; // 检测指标编码(关联查询)
indicatorName?: string; // 检测指标名称(关联查询)
indicatorType?: number; // 检测指标类型(关联查询)
tool?: string; // 检测工具
checkMethod?: string; // 检测方法
standardValue?: number; // 标准值
unitMeasureId?: number; // 计量单位 ID
unitMeasureName?: string; // 计量单位名称(关联查询)
maxThreshold?: number; // 误差上限
minThreshold?: number; // 误差下限
criticalQuantity?: number; // 致命缺陷数量
majorQuantity?: number; // 严重缺陷数量
minorQuantity?: number; // 轻微缺陷数量
remark?: string; // 备注
}
}
/** 查询来料检验单行分页 */
export function getIqcLinePage(params: PageParam & { iqcId?: number }) {
return requestClient.get<PageResult<MesQcIqcLineApi.IqcLine>>(
'/mes/qc/iqc/line/page',
{ params },
);
}
/** 查询来料检验单行详情 */
export function getIqcLine(id: number) {
return requestClient.get<MesQcIqcLineApi.IqcLine>(
`/mes/qc/iqc/line/get?id=${id}`,
);
}

View File

@ -0,0 +1,81 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcOqcApi {
/** MES 出货检验单 */
export interface Oqc {
id?: number; // 编号
code?: string; // 检验单编号
name?: string; // 检验单名称
templateId?: number; // 检验模板 ID
sourceDocType?: number; // 来源单据类型
sourceDocId?: number; // 来源单据 ID
sourceLineId?: number; // 来源单据行 ID
sourceDocCode?: string; // 来源单据编号(关联查询)
clientId?: number; // 客户 ID
clientNickname?: string; // 客户简称(关联查询)
batchCode?: string; // 批次号
itemId?: number; // 产品物料 ID
itemCode?: string; // 产品物料编码(关联查询)
itemName?: string; // 产品物料名称(关联查询)
itemSpecification?: string; // 规格型号(关联查询)
unitName?: string; // 单位名称(关联查询)
minCheckQuantity?: number; // 最低检测数
maxUnqualifiedQuantity?: number; // 最大不合格数
outQuantity?: number; // 本次出货数量
checkQuantity?: number; // 本次检测数量
qualifiedQuantity?: number; // 合格品数量
unqualifiedQuantity?: number; // 不合格品数量
criticalRate?: number; // 致命缺陷率(%
majorRate?: number; // 严重缺陷率(%
minorRate?: number; // 轻微缺陷率(%
criticalQuantity?: number; // 致命缺陷数量
majorQuantity?: number; // 严重缺陷数量
minorQuantity?: number; // 轻微缺陷数量
checkResult?: number; // 检测结果
outDate?: number; // 出货日期
inspectDate?: number; // 检测日期
inspectorUserId?: number; // 检测人员用户 ID
inspectorNickname?: string; // 检测人员昵称(关联查询)
status?: number; // 状态
remark?: string; // 备注
}
}
/** 查询出货检验单分页 */
export function getOqcPage(params: PageParam) {
return requestClient.get<PageResult<MesQcOqcApi.Oqc>>('/mes/qc/oqc/page', {
params,
});
}
/** 查询出货检验单详情 */
export function getOqc(id: number) {
return requestClient.get<MesQcOqcApi.Oqc>(`/mes/qc/oqc/get?id=${id}`);
}
/** 新增出货检验单 */
export function createOqc(data: MesQcOqcApi.Oqc) {
return requestClient.post('/mes/qc/oqc/create', data);
}
/** 修改出货检验单 */
export function updateOqc(data: MesQcOqcApi.Oqc) {
return requestClient.put('/mes/qc/oqc/update', data);
}
/** 完成出货检验单 */
export function finishOqc(id: number) {
return requestClient.put(`/mes/qc/oqc/finish?id=${id}`);
}
/** 删除出货检验单 */
export function deleteOqc(id: number) {
return requestClient.delete(`/mes/qc/oqc/delete?id=${id}`);
}
/** 导出出货检验单 */
export function exportOqc(params: any) {
return requestClient.download('/mes/qc/oqc/export-excel', { params });
}

View File

@ -0,0 +1,41 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcOqcLineApi {
/** MES 出货检验单行 */
export interface OqcLine {
id?: number; // 编号
oqcId?: number; // 出货检验单 ID
indicatorId?: number; // 检测指标 ID
indicatorCode?: string; // 检测指标编码(关联查询)
indicatorName?: string; // 检测指标名称(关联查询)
indicatorType?: number; // 检测指标类型(关联查询)
tool?: string; // 检测工具
checkMethod?: string; // 检测方法
standardValue?: number; // 标准值
unitMeasureId?: number; // 计量单位 ID
unitMeasureName?: string; // 计量单位名称(关联查询)
maxThreshold?: number; // 误差上限
minThreshold?: number; // 误差下限
criticalQuantity?: number; // 致命缺陷数量
majorQuantity?: number; // 严重缺陷数量
minorQuantity?: number; // 轻微缺陷数量
remark?: string; // 备注
}
}
/** 查询出货检验单行分页 */
export function getOqcLinePage(params: PageParam & { oqcId?: number }) {
return requestClient.get<PageResult<MesQcOqcLineApi.OqcLine>>(
'/mes/qc/oqc/line/page',
{ params },
);
}
/** 查询出货检验单行详情 */
export function getOqcLine(id: number) {
return requestClient.get<MesQcOqcLineApi.OqcLine>(
`/mes/qc/oqc/line/get?id=${id}`,
);
}

View File

@ -0,0 +1,41 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcPendingInspectApi {
/** MES 待检任务 */
export interface PendingInspect {
sourceDocType?: number; // 来源单据类型MesBizTypeConstants
sourceDocId?: number; // 来源单据 ID
sourceLineId?: number; // 来源单据行 ID
sourceDocCode?: string; // 来源单据编号
qcType?: number; // 检验类型MesQcTypeEnum
itemId?: number; // 物料 ID
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitName?: string; // 单位名称
quantity?: number; // 待检数量
// 供应商IQC 场景)
vendorId?: number; // 供应商 ID
vendorName?: string; // 供应商名称
// 工单/工作站/任务IPQC/RQC 场景)
workOrderId?: number; // 生产工单 ID
workstationId?: number; // 工作站 ID
workstationName?: string; // 工作站名称
taskId?: number; // 生产任务 ID
taskCode?: string; // 生产任务编码
// 客户OQC/RQC 场景)
clientId?: number; // 客户 ID
clientName?: string; // 客户名称
recordTime?: number; // 记录时间epoch ms
}
}
/** 查询待检任务分页 */
export function getPendingInspectPage(params: PageParam) {
return requestClient.get<PageResult<MesQcPendingInspectApi.PendingInspect>>(
'/mes/qc/pending-inspect/page',
{ params },
);
}

View File

@ -0,0 +1,77 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcRqcApi {
/** MES 退货检验单 */
export interface Rqc {
id?: number; // 编号
code?: string; // 检验单编号
name?: string; // 检验单名称
templateId?: number; // 检验模板 ID
sourceDocType?: number; // 来源单据类型
sourceDocId?: number; // 来源单据 ID
sourceLineId?: number; // 来源单据行 ID
sourceDocCode?: string; // 来源单据编号(关联查询)
type?: number; // 检验类型
itemId?: number; // 产品物料 ID
itemCode?: string; // 产品物料编码(关联查询)
itemName?: string; // 产品物料名称(关联查询)
itemSpecification?: string; // 规格型号(关联查询)
unitName?: string; // 单位名称(关联查询)
batchCode?: string; // 批次号
checkQuantity?: number; // 检测数量
qualifiedQuantity?: number; // 合格品数量
unqualifiedQuantity?: number; // 不合格数量
checkResult?: number; // 检测结果
inspectDate?: number; // 检测日期
inspectorUserId?: number; // 检测人员用户 ID
inspectorNickname?: string; // 检测人员昵称(关联查询)
status?: number; // 状态
remark?: string; // 备注
// 缺陷统计
criticalRate?: number; // 致命缺陷率(%
majorRate?: number; // 严重缺陷率(%
minorRate?: number; // 轻微缺陷率(%
criticalQuantity?: number; // 致命缺陷数量
majorQuantity?: number; // 严重缺陷数量
minorQuantity?: number; // 轻微缺陷数量
}
}
/** 查询退货检验单分页 */
export function getRqcPage(params: PageParam) {
return requestClient.get<PageResult<MesQcRqcApi.Rqc>>('/mes/qc/rqc/page', {
params,
});
}
/** 查询退货检验单详情 */
export function getRqc(id: number) {
return requestClient.get<MesQcRqcApi.Rqc>(`/mes/qc/rqc/get?id=${id}`);
}
/** 新增退货检验单 */
export function createRqc(data: MesQcRqcApi.Rqc) {
return requestClient.post<number>('/mes/qc/rqc/create', data);
}
/** 修改退货检验单 */
export function updateRqc(data: MesQcRqcApi.Rqc) {
return requestClient.put('/mes/qc/rqc/update', data);
}
/** 完成退货检验单 */
export function finishRqc(id: number) {
return requestClient.put(`/mes/qc/rqc/finish?id=${id}`);
}
/** 删除退货检验单 */
export function deleteRqc(id: number) {
return requestClient.delete(`/mes/qc/rqc/delete?id=${id}`);
}
/** 导出退货检验单 */
export function exportRqc(params: any) {
return requestClient.download('/mes/qc/rqc/export-excel', { params });
}

View File

@ -0,0 +1,41 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcRqcLineApi {
/** MES 退货检验单行 */
export interface RqcLine {
id?: number; // 编号
rqcId?: number; // 退货检验单 ID
indicatorId?: number; // 检测指标 ID
indicatorCode?: string; // 检测指标编码(关联查询)
indicatorName?: string; // 检测指标名称(关联查询)
indicatorType?: number; // 检测指标类型(关联查询)
tool?: string; // 检测工具
checkMethod?: string; // 检测方法
standardValue?: number; // 标准值
unitMeasureId?: number; // 计量单位 ID
unitMeasureName?: string; // 计量单位名称(关联查询)
maxThreshold?: number; // 误差上限
minThreshold?: number; // 误差下限
criticalQuantity?: number; // 致命缺陷数量
majorQuantity?: number; // 严重缺陷数量
minorQuantity?: number; // 轻微缺陷数量
remark?: string; // 备注
}
}
/** 查询退货检验单行分页 */
export function getRqcLinePage(params: PageParam & { rqcId?: number }) {
return requestClient.get<PageResult<MesQcRqcLineApi.RqcLine>>(
'/mes/qc/rqc/line/page',
{ params },
);
}
/** 查询退货检验单行详情 */
export function getRqcLine(id: number) {
return requestClient.get<MesQcRqcLineApi.RqcLine>(
`/mes/qc/rqc/line/get?id=${id}`,
);
}

View File

@ -0,0 +1,68 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmArrivalNoticeApi {
/** MES 到货通知单 */
export interface ArrivalNotice {
id?: number; // 通知单编号
code?: string; // 通知单编号
name?: string; // 通知单名称
purchaseOrderCode?: string; // 采购订单编号
vendorId?: number; // 供应商编号
vendorCode?: string; // 供应商编码
vendorName?: string; // 供应商名称
arrivalDate?: number; // 到货日期
contactName?: string; // 联系人
contactTelephone?: string; // 联系方式
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询到货通知单分页 */
export function getArrivalNoticePage(params: PageParam) {
return requestClient.get<PageResult<MesWmArrivalNoticeApi.ArrivalNotice>>(
'/mes/wm/arrival-notice/page',
{ params },
);
}
/** 查询到货通知单详情 */
export function getArrivalNotice(id: number) {
return requestClient.get<MesWmArrivalNoticeApi.ArrivalNotice>(
`/mes/wm/arrival-notice/get?id=${id}`,
);
}
/** 新增到货通知单 */
export function createArrivalNotice(
data: MesWmArrivalNoticeApi.ArrivalNotice,
) {
return requestClient.post<number>('/mes/wm/arrival-notice/create', data);
}
/** 修改到货通知单 */
export function updateArrivalNotice(
data: MesWmArrivalNoticeApi.ArrivalNotice,
) {
return requestClient.put('/mes/wm/arrival-notice/update', data);
}
/** 删除到货通知单 */
export function deleteArrivalNotice(id: number) {
return requestClient.delete(`/mes/wm/arrival-notice/delete?id=${id}`);
}
/** 提交到货通知单 */
export function submitArrivalNotice(id: number) {
return requestClient.put(`/mes/wm/arrival-notice/submit?id=${id}`);
}
/** 导出到货通知单 */
export function exportArrivalNotice(params: any) {
return requestClient.download('/mes/wm/arrival-notice/export-excel', {
params,
});
}

View File

@ -0,0 +1,58 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmArrivalNoticeLineApi {
/** MES 到货通知单行 */
export interface ArrivalNoticeLine {
id?: number; // 行编号
noticeId?: number; // 到货通知单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
arrivalQuantity?: number; // 到货数量
qualifiedQuantity?: number; // 合格数量
iqcCheckFlag?: boolean; // 是否检验
iqcId?: number; // 来料检验单编号
iqcCode?: string; // 来料检验单编码
remark?: string; // 备注
}
}
/** 查询到货通知单行分页 */
export function getArrivalNoticeLinePage(params: PageParam) {
return requestClient.get<
PageResult<MesWmArrivalNoticeLineApi.ArrivalNoticeLine>
>('/mes/wm/arrival-notice-line/page', { params });
}
/** 查询到货通知单行详情 */
export function getArrivalNoticeLine(id: number) {
return requestClient.get<MesWmArrivalNoticeLineApi.ArrivalNoticeLine>(
`/mes/wm/arrival-notice-line/get?id=${id}`,
);
}
/** 新增到货通知单行 */
export function createArrivalNoticeLine(
data: MesWmArrivalNoticeLineApi.ArrivalNoticeLine,
) {
return requestClient.post<number>(
'/mes/wm/arrival-notice-line/create',
data,
);
}
/** 修改到货通知单行 */
export function updateArrivalNoticeLine(
data: MesWmArrivalNoticeLineApi.ArrivalNoticeLine,
) {
return requestClient.put('/mes/wm/arrival-notice-line/update', data);
}
/** 删除到货通知单行 */
export function deleteArrivalNoticeLine(id: number) {
return requestClient.delete(`/mes/wm/arrival-notice-line/delete?id=${id}`);
}

View File

@ -0,0 +1,87 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmBatchApi {
/** MES 批次 */
export interface Batch {
id?: number; // 批次 ID
code?: string; // 批次编码
itemId?: number; // 物料 ID
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
itemSpecification?: string; // 规格型号
unitName?: string; // 单位名称
produceDate?: Date; // 生产日期
expireDate?: Date; // 有效期
receiptDate?: Date; // 入库日期
vendorId?: number; // 供应商 ID
vendorCode?: string; // 供应商编码
vendorName?: string; // 供应商名称
clientId?: number; // 客户 ID
clientCode?: string; // 客户编码
clientName?: string; // 客户名称
purchaseOrderCode?: string; // 采购订单编号
salesOrderCode?: string; // 销售订单编号
workOrderId?: number; // 生产工单 ID
workOrderCode?: string; // 生产工单编号
taskId?: number; // 生产任务 ID
taskCode?: string; // 生产任务编号
workstationId?: number; // 工作站 ID
workstationCode?: string; // 工作站编码
toolId?: number; // 工具 ID
toolCode?: string; // 工具编号
moldId?: number; // 模具 ID
lotNumber?: string; // 生产批号
qualityStatus?: number; // 质量状态
remark?: string; // 备注
}
/** MES 批次分页查询参数 */
export interface PageParams extends PageParam {
code?: string;
itemId?: number;
vendorId?: number;
clientId?: number;
workOrderId?: number;
taskId?: number;
workstationId?: number;
toolId?: number;
moldId?: number;
salesOrderCode?: string;
purchaseOrderCode?: string;
lotNumber?: string;
qualityStatus?: number;
produceDate?: string[];
expireDate?: string[];
receiptDate?: string[];
}
}
/** 查询批次详情 */
export function getBatch(id: number) {
return requestClient.get<MesWmBatchApi.Batch>(`/mes/wm/batch/get?id=${id}`);
}
/** 查询批次分页 */
export function getBatchPage(params: MesWmBatchApi.PageParams) {
return requestClient.get<PageResult<MesWmBatchApi.Batch>>(
'/mes/wm/batch/page',
{ params },
);
}
/** 批次向前追溯 */
export function getForwardBatchList(code: string) {
return requestClient.get<MesWmBatchApi.Batch[]>('/mes/wm/batch/forward-list', {
params: { code },
});
}
/** 批次向后追溯 */
export function getBackwardBatchList(code: string) {
return requestClient.get<MesWmBatchApi.Batch[]>(
'/mes/wm/batch/backward-list',
{ params: { code } },
);
}

View File

@ -0,0 +1,58 @@
import { requestClient } from '#/api/request';
export namespace MesWmItemReceiptDetailApi {
/** MES 采购入库明细 */
export interface ItemReceiptDetail {
id?: number; // 明细编号
lineId?: number; // 入库单行编号
receiptId?: number; // 入库单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
quantity?: number; // 数量
batchId?: number; // 批次编号
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
}
}
/** 查询采购入库明细列表(按行编号) */
export function getItemReceiptDetailListByLineId(lineId: number) {
return requestClient.get<MesWmItemReceiptDetailApi.ItemReceiptDetail[]>(
'/mes/wm/item-receipt-detail/list-by-line',
{ params: { lineId } },
);
}
/** 查询采购入库明细详情 */
export function getItemReceiptDetail(id: number) {
return requestClient.get<MesWmItemReceiptDetailApi.ItemReceiptDetail>(
`/mes/wm/item-receipt-detail/get?id=${id}`,
);
}
/** 新增采购入库明细 */
export function createItemReceiptDetail(
data: MesWmItemReceiptDetailApi.ItemReceiptDetail,
) {
return requestClient.post<number>('/mes/wm/item-receipt-detail/create', data);
}
/** 修改采购入库明细 */
export function updateItemReceiptDetail(
data: MesWmItemReceiptDetailApi.ItemReceiptDetail,
) {
return requestClient.put('/mes/wm/item-receipt-detail/update', data);
}
/** 删除采购入库明细 */
export function deleteItemReceiptDetail(id: number) {
return requestClient.delete(`/mes/wm/item-receipt-detail/delete?id=${id}`);
}

View File

@ -1,3 +1,5 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmItemReceiptApi {
@ -19,16 +21,66 @@ export namespace MesWmItemReceiptApi {
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
receiptDate?: Date | number | string; // 入库日期
receiptDate?: number; // 入库日期
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询采购入库单分页 */
export function getItemReceiptPage(params: PageParam) {
return requestClient.get<PageResult<MesWmItemReceiptApi.ItemReceipt>>(
'/mes/wm/item-receipt/page',
{ params },
);
}
/** 查询采购入库单详情 */
export function getItemReceipt(id: number) {
return requestClient.get<MesWmItemReceiptApi.ItemReceipt>(
`/mes/wm/item-receipt/get?id=${id}`,
);
}
/** 新增采购入库单 */
export function createItemReceipt(data: MesWmItemReceiptApi.ItemReceipt) {
return requestClient.post<number>('/mes/wm/item-receipt/create', data);
}
/** 修改采购入库单 */
export function updateItemReceipt(data: MesWmItemReceiptApi.ItemReceipt) {
return requestClient.put('/mes/wm/item-receipt/update', data);
}
/** 删除采购入库单 */
export function deleteItemReceipt(id: number) {
return requestClient.delete(`/mes/wm/item-receipt/delete?id=${id}`);
}
/** 提交采购入库单 */
export function submitItemReceipt(id: number) {
return requestClient.put(`/mes/wm/item-receipt/submit?id=${id}`);
}
/** 执行上架 */
export function stockItemReceipt(id: number) {
return requestClient.put(`/mes/wm/item-receipt/stock?id=${id}`);
}
/** 执行入库 */
export function finishItemReceipt(id: number) {
return requestClient.put(`/mes/wm/item-receipt/finish?id=${id}`);
}
/** 取消采购入库单 */
export function cancelItemReceipt(id: number) {
return requestClient.put(`/mes/wm/item-receipt/cancel?id=${id}`);
}
/** 导出采购入库单 */
export function exportItemReceipt(params: any) {
return requestClient.download('/mes/wm/item-receipt/export-excel', {
params,
});
}

View File

@ -3,11 +3,12 @@ import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmItemReceiptLineApi {
/** MES 物料接收单行 */
/** MES 采购入库单行 */
export interface ItemReceiptLine {
id?: number; // 行编号
receiptId?: number; // 入库单编号
receiptCode?: string; // 入库单编码
arrivalNoticeLineId?: number; // 到货通知单行编号
purchaseOrderCode?: string; // 采购订单号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
@ -15,14 +16,48 @@ export namespace MesWmItemReceiptLineApi {
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
receivedQuantity?: number; // 入库数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
productionDate?: number; // 生产日期
expireDate?: number; // 有效期
lotNumber?: string; // 生产批号
iqcCheckFlag?: boolean; // 是否检验
iqcId?: number; // 来料检验单编号
iqcCode?: string; // 来料检验单编码
remark?: string; // 备注
}
}
/** 查询物料接收单行分页 */
/** 查询采购入库单行分页 */
export function getItemReceiptLinePage(params: PageParam) {
return requestClient.get<PageResult<MesWmItemReceiptLineApi.ItemReceiptLine>>(
'/mes/wm/item-receipt-line/page',
{ params },
);
}
/** 查询采购入库单行详情 */
export function getItemReceiptLine(id: number) {
return requestClient.get<MesWmItemReceiptLineApi.ItemReceiptLine>(
`/mes/wm/item-receipt-line/get?id=${id}`,
);
}
/** 新增采购入库单行 */
export function createItemReceiptLine(
data: MesWmItemReceiptLineApi.ItemReceiptLine,
) {
return requestClient.post<number>('/mes/wm/item-receipt-line/create', data);
}
/** 修改采购入库单行 */
export function updateItemReceiptLine(
data: MesWmItemReceiptLineApi.ItemReceiptLine,
) {
return requestClient.put('/mes/wm/item-receipt-line/update', data);
}
/** 删除采购入库单行 */
export function deleteItemReceiptLine(id: number) {
return requestClient.delete(`/mes/wm/item-receipt-line/delete?id=${id}`);
}

View File

@ -0,0 +1,70 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmMiscIssueApi {
/** MES 杂项出库单 */
export interface MiscIssue {
id?: number; // 编号
code?: string; // 出库单编号
name?: string; // 出库单名称
type?: number; // 业务类型
sourceDocType?: string; // 来源单据类型
sourceDocId?: number; // 来源单据编号
sourceDocCode?: string; // 来源单据编码
issueDate?: number; // 出库日期
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询杂项出库单分页 */
export function getMiscIssuePage(params: PageParam) {
return requestClient.get<PageResult<MesWmMiscIssueApi.MiscIssue>>(
'/mes/wm/misc-issue/page',
{ params },
);
}
/** 查询杂项出库单详情 */
export function getMiscIssue(id: number) {
return requestClient.get<MesWmMiscIssueApi.MiscIssue>(
`/mes/wm/misc-issue/get?id=${id}`,
);
}
/** 新增杂项出库单 */
export function createMiscIssue(data: MesWmMiscIssueApi.MiscIssue) {
return requestClient.post<number>('/mes/wm/misc-issue/create', data);
}
/** 修改杂项出库单 */
export function updateMiscIssue(data: MesWmMiscIssueApi.MiscIssue) {
return requestClient.put('/mes/wm/misc-issue/update', data);
}
/** 删除杂项出库单 */
export function deleteMiscIssue(id: number) {
return requestClient.delete(`/mes/wm/misc-issue/delete?id=${id}`);
}
/** 提交杂项出库单 */
export function submitMiscIssue(id: number) {
return requestClient.put(`/mes/wm/misc-issue/submit?id=${id}`);
}
/** 执行出库 */
export function finishMiscIssue(id: number) {
return requestClient.put(`/mes/wm/misc-issue/finish?id=${id}`);
}
/** 取消杂项出库单 */
export function cancelMiscIssue(id: number) {
return requestClient.put(`/mes/wm/misc-issue/cancel?id=${id}`);
}
/** 导出杂项出库单 */
export function exportMiscIssue(params: any) {
return requestClient.download('/mes/wm/misc-issue/export-excel', { params });
}

View File

@ -0,0 +1,70 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmMiscIssueLineApi {
/** MES 杂项出库单行 */
export interface MiscIssueLine {
id?: number; // 编号
issueId?: number; // 出库单编号
sourceDocLineId?: number; // 来源单据行编号
materialStockId?: number; // 库存编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasure?: string; // 计量单位
unitMeasureName?: string; // 计量单位名称
quantity?: number; // 出库数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
warehouseId?: number; // 仓库编号
warehouseCode?: string; // 仓库编码
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationCode?: string; // 库区编码
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaCode?: string; // 库位编码
areaName?: string; // 库位名称
remark?: string; // 备注
quantityMax?: number; // 可出库最大数量(前端用于限制出库数量,取自库存在库数量)
}
}
/** 查询杂项出库单行分页 */
export function getMiscIssueLinePage(params: PageParam) {
return requestClient.get<PageResult<MesWmMiscIssueLineApi.MiscIssueLine>>(
'/mes/wm/misc-issue-line/page',
{ params },
);
}
/** 查询杂项出库单行列表 */
export function getMiscIssueLineListByIssueId(issueId: number) {
return requestClient.get<MesWmMiscIssueLineApi.MiscIssueLine[]>(
`/mes/wm/misc-issue-line/list-by-issue-id?issueId=${issueId}`,
);
}
/** 查询杂项出库单行详情 */
export function getMiscIssueLine(id: number) {
return requestClient.get<MesWmMiscIssueLineApi.MiscIssueLine>(
`/mes/wm/misc-issue-line/get?id=${id}`,
);
}
/** 新增杂项出库单行 */
export function createMiscIssueLine(data: MesWmMiscIssueLineApi.MiscIssueLine) {
return requestClient.post('/mes/wm/misc-issue-line/create', data);
}
/** 修改杂项出库单行 */
export function updateMiscIssueLine(data: MesWmMiscIssueLineApi.MiscIssueLine) {
return requestClient.put('/mes/wm/misc-issue-line/update', data);
}
/** 删除杂项出库单行 */
export function deleteMiscIssueLine(id: number) {
return requestClient.delete(`/mes/wm/misc-issue-line/delete?id=${id}`);
}

View File

@ -0,0 +1,70 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmMiscReceiptApi {
/** MES 杂项入库单 */
export interface MiscReceipt {
id?: number; // 编号
code?: string; // 入库单编号
name?: string; // 入库单名称
type?: number; // 杂项类型
sourceDocType?: string; // 来源单据类型
sourceDocId?: number; // 来源单据编号
sourceDocCode?: string; // 来源单据编码
receiptDate?: number; // 入库日期
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询杂项入库单分页 */
export function getMiscReceiptPage(params: PageParam) {
return requestClient.get<PageResult<MesWmMiscReceiptApi.MiscReceipt>>(
'/mes/wm/misc-receipt/page',
{ params },
);
}
/** 查询杂项入库单详情 */
export function getMiscReceipt(id: number) {
return requestClient.get<MesWmMiscReceiptApi.MiscReceipt>(
`/mes/wm/misc-receipt/get?id=${id}`,
);
}
/** 新增杂项入库单 */
export function createMiscReceipt(data: MesWmMiscReceiptApi.MiscReceipt) {
return requestClient.post<number>('/mes/wm/misc-receipt/create', data);
}
/** 修改杂项入库单 */
export function updateMiscReceipt(data: MesWmMiscReceiptApi.MiscReceipt) {
return requestClient.put('/mes/wm/misc-receipt/update', data);
}
/** 删除杂项入库单 */
export function deleteMiscReceipt(id: number) {
return requestClient.delete(`/mes/wm/misc-receipt/delete?id=${id}`);
}
/** 提交杂项入库单 */
export function submitMiscReceipt(id: number) {
return requestClient.put(`/mes/wm/misc-receipt/submit?id=${id}`);
}
/** 执行入库 */
export function finishMiscReceipt(id: number) {
return requestClient.put(`/mes/wm/misc-receipt/finish?id=${id}`);
}
/** 取消杂项入库单 */
export function cancelMiscReceipt(id: number) {
return requestClient.put(`/mes/wm/misc-receipt/cancel?id=${id}`);
}
/** 导出杂项入库单 */
export function exportMiscReceipt(params: any) {
return requestClient.download('/mes/wm/misc-receipt/export-excel', { params });
}

View File

@ -0,0 +1,57 @@
import { requestClient } from '#/api/request';
export namespace MesWmMiscReceiptLineApi {
/** MES 杂项入库单行 */
export interface MiscReceiptLine {
id?: number; // 编号
receiptId?: number; // 入库单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 计量单位名称
quantity?: number; // 入库数量
batchCode?: string; // 批次号
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询杂项入库单行列表 */
export function getMiscReceiptLineListByReceiptId(receiptId: number) {
return requestClient.get<MesWmMiscReceiptLineApi.MiscReceiptLine[]>(
`/mes/wm/misc-receipt-line/list-by-receipt-id?receiptId=${receiptId}`,
);
}
/** 查询杂项入库单行详情 */
export function getMiscReceiptLine(id: number) {
return requestClient.get<MesWmMiscReceiptLineApi.MiscReceiptLine>(
`/mes/wm/misc-receipt-line/get?id=${id}`,
);
}
/** 新增杂项入库单行 */
export function createMiscReceiptLine(
data: MesWmMiscReceiptLineApi.MiscReceiptLine,
) {
return requestClient.post('/mes/wm/misc-receipt-line/create', data);
}
/** 修改杂项入库单行 */
export function updateMiscReceiptLine(
data: MesWmMiscReceiptLineApi.MiscReceiptLine,
) {
return requestClient.put('/mes/wm/misc-receipt-line/update', data);
}
/** 删除杂项入库单行 */
export function deleteMiscReceiptLine(id: number) {
return requestClient.delete(`/mes/wm/misc-receipt-line/delete?id=${id}`);
}

View File

@ -0,0 +1,60 @@
import { requestClient } from '#/api/request';
export namespace MesWmOutsourceIssueDetailApi {
/** MES 外协发料单明细 */
export interface OutsourceIssueDetail {
id?: number; // 明细编号
lineId?: number; // 行编号
issueId?: number; // 发料单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 计量单位名称
quantity?: number; // 数量
materialStockId?: number; // 库存编号
batchId?: number; // 批次编号
batchCode?: string; // 批次编码
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询外协发料单明细列表 */
export function getOutsourceIssueDetailListByLineId(lineId: number) {
return requestClient.get<
MesWmOutsourceIssueDetailApi.OutsourceIssueDetail[]
>('/mes/wm/outsource-issue-detail/list-by-line', { params: { lineId } });
}
/** 查询外协发料单明细详情 */
export function getOutsourceIssueDetail(id: number) {
return requestClient.get<MesWmOutsourceIssueDetailApi.OutsourceIssueDetail>(
`/mes/wm/outsource-issue-detail/get?id=${id}`,
);
}
/** 新增外协发料单明细 */
export function createOutsourceIssueDetail(
data: MesWmOutsourceIssueDetailApi.OutsourceIssueDetail,
) {
return requestClient.post('/mes/wm/outsource-issue-detail/create', data);
}
/** 修改外协发料单明细 */
export function updateOutsourceIssueDetail(
data: MesWmOutsourceIssueDetailApi.OutsourceIssueDetail,
) {
return requestClient.put('/mes/wm/outsource-issue-detail/update', data);
}
/** 删除外协发料单明细 */
export function deleteOutsourceIssueDetail(id: number) {
return requestClient.delete(`/mes/wm/outsource-issue-detail/delete?id=${id}`);
}

View File

@ -0,0 +1,90 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmOutsourceIssueApi {
/** MES 外协发料单 */
export interface OutsourceIssue {
id?: number; // 发料单编号
code?: string; // 发料单编号
name?: string; // 发料单名称
vendorId?: number; // 供应商编号
vendorCode?: string; // 供应商编码
vendorName?: string; // 供应商名称
workOrderId?: number; // 生产工单编号
workOrderCode?: string; // 生产工单编码
workOrderName?: string; // 生产工单名称
issueDate?: number; // 发料日期
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询外协发料单分页 */
export function getOutsourceIssuePage(params: PageParam) {
return requestClient.get<PageResult<MesWmOutsourceIssueApi.OutsourceIssue>>(
'/mes/wm/outsource-issue/page',
{ params },
);
}
/** 查询外协发料单详情 */
export function getOutsourceIssue(id: number) {
return requestClient.get<MesWmOutsourceIssueApi.OutsourceIssue>(
`/mes/wm/outsource-issue/get?id=${id}`,
);
}
/** 新增外协发料单 */
export function createOutsourceIssue(
data: MesWmOutsourceIssueApi.OutsourceIssue,
) {
return requestClient.post<number>('/mes/wm/outsource-issue/create', data);
}
/** 修改外协发料单 */
export function updateOutsourceIssue(
data: MesWmOutsourceIssueApi.OutsourceIssue,
) {
return requestClient.put('/mes/wm/outsource-issue/update', data);
}
/** 删除外协发料单 */
export function deleteOutsourceIssue(id: number) {
return requestClient.delete(`/mes/wm/outsource-issue/delete?id=${id}`);
}
/** 提交外协发料单 */
export function submitOutsourceIssue(id: number) {
return requestClient.put(`/mes/wm/outsource-issue/submit?id=${id}`);
}
/** 执行拣货 */
export function stockOutsourceIssue(id: number) {
return requestClient.put(`/mes/wm/outsource-issue/stock?id=${id}`);
}
/** 执行领出 */
export function finishOutsourceIssue(id: number) {
return requestClient.put(`/mes/wm/outsource-issue/finish?id=${id}`);
}
/** 取消外协发料单 */
export function cancelOutsourceIssue(id: number) {
return requestClient.put(`/mes/wm/outsource-issue/cancel?id=${id}`);
}
/** 校验外协发料单拣货数量是否与发料数量一致 */
export function checkOutsourceIssueQuantity(id: number) {
return requestClient.get<boolean>(
`/mes/wm/outsource-issue/check-quantity?id=${id}`,
);
}
/** 导出外协发料单 */
export function exportOutsourceIssue(params: any) {
return requestClient.download('/mes/wm/outsource-issue/export-excel', {
params,
});
}

View File

@ -0,0 +1,55 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmOutsourceIssueLineApi {
/** MES 外协发料单行 */
export interface OutsourceIssueLine {
id?: number; // 行编号
issueId?: number; // 发料单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 计量单位名称
quantity?: number; // 发料数量
materialStockId?: number; // 库存编号
batchId?: number; // 批次编号
batchCode?: string; // 批次编码
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询外协发料单行分页 */
export function getOutsourceIssueLinePage(params: PageParam) {
return requestClient.get<
PageResult<MesWmOutsourceIssueLineApi.OutsourceIssueLine>
>('/mes/wm/outsource-issue-line/page', { params });
}
/** 查询外协发料单行详情 */
export function getOutsourceIssueLine(id: number) {
return requestClient.get<MesWmOutsourceIssueLineApi.OutsourceIssueLine>(
`/mes/wm/outsource-issue-line/get?id=${id}`,
);
}
/** 新增外协发料单行 */
export function createOutsourceIssueLine(
data: MesWmOutsourceIssueLineApi.OutsourceIssueLine,
) {
return requestClient.post('/mes/wm/outsource-issue-line/create', data);
}
/** 修改外协发料单行 */
export function updateOutsourceIssueLine(
data: MesWmOutsourceIssueLineApi.OutsourceIssueLine,
) {
return requestClient.put('/mes/wm/outsource-issue-line/update', data);
}
/** 删除外协发料单行 */
export function deleteOutsourceIssueLine(id: number) {
return requestClient.delete(`/mes/wm/outsource-issue-line/delete?id=${id}`);
}

View File

@ -0,0 +1,61 @@
import { requestClient } from '#/api/request';
export namespace MesWmOutsourceReceiptDetailApi {
/** MES 外协入库单明细 */
export interface OutsourceReceiptDetail {
id?: number; // 明细编号
lineId?: number; // 行编号
receiptId?: number; // 入库单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 计量单位名称
quantity?: number; // 上架数量
batchId?: number; // 批次编号
batchCode?: string; // 批次编码
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询外协入库单明细列表 */
export function getOutsourceReceiptDetailListByLineId(lineId: number) {
return requestClient.get<
MesWmOutsourceReceiptDetailApi.OutsourceReceiptDetail[]
>('/mes/wm/outsource-receipt-detail/list-by-line', { params: { lineId } });
}
/** 查询外协入库单明细详情 */
export function getOutsourceReceiptDetail(id: number) {
return requestClient.get<MesWmOutsourceReceiptDetailApi.OutsourceReceiptDetail>(
`/mes/wm/outsource-receipt-detail/get?id=${id}`,
);
}
/** 新增外协入库单明细 */
export function createOutsourceReceiptDetail(
data: MesWmOutsourceReceiptDetailApi.OutsourceReceiptDetail,
) {
return requestClient.post('/mes/wm/outsource-receipt-detail/create', data);
}
/** 修改外协入库单明细 */
export function updateOutsourceReceiptDetail(
data: MesWmOutsourceReceiptDetailApi.OutsourceReceiptDetail,
) {
return requestClient.put('/mes/wm/outsource-receipt-detail/update', data);
}
/** 删除外协入库单明细 */
export function deleteOutsourceReceiptDetail(id: number) {
return requestClient.delete(
`/mes/wm/outsource-receipt-detail/delete?id=${id}`,
);
}

View File

@ -0,0 +1,81 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmOutsourceReceiptApi {
/** MES 外协入库单 */
export interface OutsourceReceipt {
id?: number; // 入库单编号
code?: string; // 入库单编码
name?: string; // 入库单名称
workOrderId?: number; // 外协工单编号
workOrderCode?: string; // 外协工单编码
vendorId?: number; // 供应商编号
vendorName?: string; // 供应商名称
receiptDate?: number; // 入库日期
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询外协入库单分页 */
export function getOutsourceReceiptPage(params: PageParam) {
return requestClient.get<PageResult<MesWmOutsourceReceiptApi.OutsourceReceipt>>(
'/mes/wm/outsource-receipt/page',
{ params },
);
}
/** 查询外协入库单详情 */
export function getOutsourceReceipt(id: number) {
return requestClient.get<MesWmOutsourceReceiptApi.OutsourceReceipt>(
`/mes/wm/outsource-receipt/get?id=${id}`,
);
}
/** 新增外协入库单 */
export function createOutsourceReceipt(
data: MesWmOutsourceReceiptApi.OutsourceReceipt,
) {
return requestClient.post<number>('/mes/wm/outsource-receipt/create', data);
}
/** 修改外协入库单 */
export function updateOutsourceReceipt(
data: MesWmOutsourceReceiptApi.OutsourceReceipt,
) {
return requestClient.put('/mes/wm/outsource-receipt/update', data);
}
/** 删除外协入库单 */
export function deleteOutsourceReceipt(id: number) {
return requestClient.delete(`/mes/wm/outsource-receipt/delete?id=${id}`);
}
/** 提交外协入库单 */
export function submitOutsourceReceipt(id: number) {
return requestClient.put(`/mes/wm/outsource-receipt/submit?id=${id}`);
}
/** 执行上架 */
export function stockOutsourceReceipt(id: number) {
return requestClient.put(`/mes/wm/outsource-receipt/stock?id=${id}`);
}
/** 完成入库 */
export function finishOutsourceReceipt(id: number) {
return requestClient.put(`/mes/wm/outsource-receipt/finish?id=${id}`);
}
/** 取消外协入库单 */
export function cancelOutsourceReceipt(id: number) {
return requestClient.put(`/mes/wm/outsource-receipt/cancel?id=${id}`);
}
/** 导出外协入库单 */
export function exportOutsourceReceipt(params: any) {
return requestClient.download('/mes/wm/outsource-receipt/export-excel', {
params,
});
}

View File

@ -0,0 +1,59 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmOutsourceReceiptLineApi {
/** MES 外协入库单行 */
export interface OutsourceReceiptLine {
id?: number; // 行编号
receiptId?: number; // 入库单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 计量单位名称
quantity?: number; // 入库数量
batchId?: number; // 批次编号
batchCode?: string; // 批次编码
productionDate?: number; // 生产日期
expireDate?: number; // 有效期
lotNumber?: string; // 生产批号
iqcCheckFlag?: boolean; // 是否需要质检
qualityStatus?: number; // 质量状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询外协入库单行分页 */
export function getOutsourceReceiptLinePage(params: PageParam) {
return requestClient.get<
PageResult<MesWmOutsourceReceiptLineApi.OutsourceReceiptLine>
>('/mes/wm/outsource-receipt-line/page', { params });
}
/** 查询外协入库单行详情 */
export function getOutsourceReceiptLine(id: number) {
return requestClient.get<MesWmOutsourceReceiptLineApi.OutsourceReceiptLine>(
`/mes/wm/outsource-receipt-line/get?id=${id}`,
);
}
/** 新增外协入库单行 */
export function createOutsourceReceiptLine(
data: MesWmOutsourceReceiptLineApi.OutsourceReceiptLine,
) {
return requestClient.post('/mes/wm/outsource-receipt-line/create', data);
}
/** 修改外协入库单行 */
export function updateOutsourceReceiptLine(
data: MesWmOutsourceReceiptLineApi.OutsourceReceiptLine,
) {
return requestClient.put('/mes/wm/outsource-receipt-line/update', data);
}
/** 删除外协入库单行 */
export function deleteOutsourceReceiptLine(id: number) {
return requestClient.delete(`/mes/wm/outsource-receipt-line/delete?id=${id}`);
}

View File

@ -0,0 +1,83 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmPackageApi {
/** 装箱单 */
export interface Package {
id?: number; // 装箱单编号
code?: string; // 装箱单编码
parentId?: number; // 父箱编号
packageDate?: number; // 装箱日期
salesOrderCode?: string; // 销售订单编号
invoiceCode?: string; // 发票编号
clientId?: number; // 客户编号
clientCode?: string; // 客户编码
clientName?: string; // 客户名称
clientNickname?: string; // 客户简称
length?: number; // 箱长度
width?: number; // 箱宽度
height?: number; // 箱高度
sizeUnitId?: number; // 尺寸单位编号
sizeUnitName?: string; // 尺寸单位名称
netWeight?: number; // 净重
grossWeight?: number; // 毛重
weightUnitId?: number; // 重量单位编号
weightUnitName?: string; // 重量单位名称
inspectorUserId?: number; // 检查员用户编号
inspectorName?: string; // 检查员名称
status?: number; // 单据状态
remark?: string; // 备注
createTime?: string; // 创建时间
children?: Package[]; // 子箱列表
}
}
/** 查询装箱单分页 */
export function getPackagePage(params: PageParam) {
return requestClient.get<PageResult<MesWmPackageApi.Package>>(
'/mes/wm/package/page',
{ params },
);
}
/** 查询装箱单详情 */
export function getPackage(id: number) {
return requestClient.get<MesWmPackageApi.Package>(
`/mes/wm/package/get?id=${id}`,
);
}
/** 新增装箱单 */
export function createPackage(data: MesWmPackageApi.Package) {
return requestClient.post<number>('/mes/wm/package/create', data);
}
/** 修改装箱单 */
export function updatePackage(data: MesWmPackageApi.Package) {
return requestClient.put('/mes/wm/package/update', data);
}
/** 删除装箱单 */
export function deletePackage(id: number) {
return requestClient.delete(`/mes/wm/package/delete?id=${id}`);
}
/** 完成装箱单 */
export function finishPackage(id: number) {
return requestClient.put(`/mes/wm/package/finish?id=${id}`);
}
/** 添加子箱 */
export function addChildPackage(parentId: number, childId: number) {
return requestClient.put('/mes/wm/package/add-child-package', null, {
params: { childId, parentId },
});
}
/** 移除子箱 */
export function removeChildPackage(childId: number) {
return requestClient.put(
`/mes/wm/package/remove-child-package?childId=${childId}`,
);
}

View File

@ -0,0 +1,54 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmPackageLineApi {
/** 装箱明细 */
export interface PackageLine {
id?: number; // 装箱明细编号
packageId?: number; // 装箱单编号
materialStockId?: number; // 库存编号
itemId?: number; // 产品物料编号
itemCode?: string; // 产品物料编码
itemName?: string; // 产品物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 计量单位名称
quantity?: number; // 装箱数量
workOrderId?: number; // 生产工单编号
workOrderCode?: string; // 生产工单编号
batchCode?: string; // 批次号
expireDate?: number; // 有效期
remark?: string; // 备注
createTime?: string; // 创建时间
}
}
/** 查询装箱明细分页 */
export function getPackageLinePage(params: PageParam) {
return requestClient.get<PageResult<MesWmPackageLineApi.PackageLine>>(
'/mes/wm/package-line/page',
{ params },
);
}
/** 查询装箱明细详情 */
export function getPackageLine(id: number) {
return requestClient.get<MesWmPackageLineApi.PackageLine>(
`/mes/wm/package-line/get?id=${id}`,
);
}
/** 新增装箱明细 */
export function createPackageLine(data: MesWmPackageLineApi.PackageLine) {
return requestClient.post('/mes/wm/package-line/create', data);
}
/** 修改装箱明细 */
export function updatePackageLine(data: MesWmPackageLineApi.PackageLine) {
return requestClient.put('/mes/wm/package-line/update', data);
}
/** 删除装箱明细 */
export function deletePackageLine(id: number) {
return requestClient.delete(`/mes/wm/package-line/delete?id=${id}`);
}

View File

@ -0,0 +1,56 @@
import { requestClient } from '#/api/request';
export namespace MesWmProductIssueDetailApi {
/** MES 领料出库明细 */
export interface ProductIssueDetail {
id?: number; // 明细编号
issueId?: number; // 领料单编号
lineId?: number; // 领料单行编号
materialStockId?: number; // 库存记录编号
itemId?: number; // 物料编号
quantity?: number; // 数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
}
}
/** 查询领料出库明细列表(按行编号) */
export function getProductIssueDetailListByLineId(lineId: number) {
return requestClient.get<MesWmProductIssueDetailApi.ProductIssueDetail[]>(
'/mes/wm/product-issue-detail/list-by-line',
{ params: { lineId } },
);
}
/** 查询领料出库明细详情 */
export function getProductIssueDetail(id: number) {
return requestClient.get<MesWmProductIssueDetailApi.ProductIssueDetail>(
`/mes/wm/product-issue-detail/get?id=${id}`,
);
}
/** 新增领料出库明细 */
export function createProductIssueDetail(
data: MesWmProductIssueDetailApi.ProductIssueDetail,
) {
return requestClient.post<number>('/mes/wm/product-issue-detail/create', data);
}
/** 修改领料出库明细 */
export function updateProductIssueDetail(
data: MesWmProductIssueDetailApi.ProductIssueDetail,
) {
return requestClient.put('/mes/wm/product-issue-detail/update', data);
}
/** 删除领料出库明细 */
export function deleteProductIssueDetail(id: number) {
return requestClient.delete(`/mes/wm/product-issue-detail/delete?id=${id}`);
}

View File

@ -0,0 +1,87 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmProductIssueApi {
/** MES 领料出库单 */
export interface ProductIssue {
id?: number; // 领料单编号
code?: string; // 领料单编号
name?: string; // 领料单名称
workstationId?: number; // 工作站编号
workstationCode?: string; // 工作站编码
workstationName?: string; // 工作站名称
workOrderId?: number; // 生产工单编号
workOrderCode?: string; // 生产工单编码
clientCode?: string; // 客户编码
clientName?: string; // 客户名称
requiredTime?: number; // 需求时间
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询领料出库单分页 */
export function getProductIssuePage(params: PageParam) {
return requestClient.get<PageResult<MesWmProductIssueApi.ProductIssue>>(
'/mes/wm/product-issue/page',
{ params },
);
}
/** 查询领料出库单详情 */
export function getProductIssue(id: number) {
return requestClient.get<MesWmProductIssueApi.ProductIssue>(
`/mes/wm/product-issue/get?id=${id}`,
);
}
/** 新增领料出库单 */
export function createProductIssue(data: MesWmProductIssueApi.ProductIssue) {
return requestClient.post<number>('/mes/wm/product-issue/create', data);
}
/** 修改领料出库单 */
export function updateProductIssue(data: MesWmProductIssueApi.ProductIssue) {
return requestClient.put('/mes/wm/product-issue/update', data);
}
/** 删除领料出库单 */
export function deleteProductIssue(id: number) {
return requestClient.delete(`/mes/wm/product-issue/delete?id=${id}`);
}
/** 提交领料出库单 */
export function submitProductIssue(id: number) {
return requestClient.put(`/mes/wm/product-issue/submit?id=${id}`);
}
/** 执行拣货 */
export function stockProductIssue(id: number) {
return requestClient.put(`/mes/wm/product-issue/stock?id=${id}`);
}
/** 完成领料出库单 */
export function finishProductIssue(id: number) {
return requestClient.put(`/mes/wm/product-issue/finish?id=${id}`);
}
/** 取消领料出库单 */
export function cancelProductIssue(id: number) {
return requestClient.put(`/mes/wm/product-issue/cancel?id=${id}`);
}
/** 校验领料出库单拣货数量是否与领料数量一致 */
export function checkProductIssueQuantity(id: number) {
return requestClient.get<boolean>(
`/mes/wm/product-issue/check-quantity?id=${id}`,
);
}
/** 导出领料出库单 */
export function exportProductIssue(params: any) {
return requestClient.download('/mes/wm/product-issue/export-excel', {
params,
});
}

View File

@ -0,0 +1,53 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmProductIssueLineApi {
/** MES 领料出库单行 */
export interface ProductIssueLine {
id?: number; // 行编号
issueId?: number; // 领料单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
quantity?: number; // 领料数量
batchId?: number; // 批次编号
remark?: string; // 备注
}
}
/** 查询领料出库单行分页 */
export function getProductIssueLinePage(params: PageParam) {
return requestClient.get<PageResult<MesWmProductIssueLineApi.ProductIssueLine>>(
'/mes/wm/product-issue-line/page',
{ params },
);
}
/** 查询领料出库单行详情 */
export function getProductIssueLine(id: number) {
return requestClient.get<MesWmProductIssueLineApi.ProductIssueLine>(
`/mes/wm/product-issue-line/get?id=${id}`,
);
}
/** 新增领料出库单行 */
export function createProductIssueLine(
data: MesWmProductIssueLineApi.ProductIssueLine,
) {
return requestClient.post<number>('/mes/wm/product-issue-line/create', data);
}
/** 修改领料出库单行 */
export function updateProductIssueLine(
data: MesWmProductIssueLineApi.ProductIssueLine,
) {
return requestClient.put('/mes/wm/product-issue-line/update', data);
}
/** 删除领料出库单行 */
export function deleteProductIssueLine(id: number) {
return requestClient.delete(`/mes/wm/product-issue-line/delete?id=${id}`);
}

View File

@ -0,0 +1,58 @@
import { requestClient } from '#/api/request';
export namespace MesWmProductReceiptDetailApi {
/** MES 产品入库明细 */
export interface ProductReceiptDetail {
id?: number; // 明细编号
lineId?: number; // 入库单行编号
receiptId?: number; // 入库单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
quantity?: number; // 数量
batchId?: number; // 批次编号
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
}
}
/** 查询产品入库明细列表(按行编号) */
export function getProductReceiptDetailListByLineId(lineId: number) {
return requestClient.get<MesWmProductReceiptDetailApi.ProductReceiptDetail[]>(
'/mes/wm/product-receipt-detail/list-by-line',
{ params: { lineId } },
);
}
/** 查询产品入库明细详情 */
export function getProductReceiptDetail(id: number) {
return requestClient.get<MesWmProductReceiptDetailApi.ProductReceiptDetail>(
`/mes/wm/product-receipt-detail/get?id=${id}`,
);
}
/** 新增产品入库明细 */
export function createProductReceiptDetail(
data: MesWmProductReceiptDetailApi.ProductReceiptDetail,
) {
return requestClient.post<number>(
'/mes/wm/product-receipt-detail/create',
data,
);
}
/** 修改产品入库明细 */
export function updateProductReceiptDetail(
data: MesWmProductReceiptDetailApi.ProductReceiptDetail,
) {
return requestClient.put('/mes/wm/product-receipt-detail/update', data);
}
/** 删除产品入库明细 */
export function deleteProductReceiptDetail(id: number) {
return requestClient.delete(`/mes/wm/product-receipt-detail/delete?id=${id}`);
}

View File

@ -0,0 +1,91 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmProductReceiptApi {
/** MES 产品入库单 */
export interface ProductReceipt {
id?: number; // 入库单编号
code?: string; // 入库单编码
name?: string; // 入库单名称
workOrderId?: number; // 生产工单编号
workOrderCode?: string; // 生产工单编码
itemId?: number; // 产品物料编号
itemCode?: string; // 产品物料编码
itemName?: string; // 产品物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
receiptDate?: number; // 入库日期
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询产品入库单分页 */
export function getProductReceiptPage(params: PageParam) {
return requestClient.get<PageResult<MesWmProductReceiptApi.ProductReceipt>>(
'/mes/wm/product-receipt/page',
{ params },
);
}
/** 查询产品入库单详情 */
export function getProductReceipt(id: number) {
return requestClient.get<MesWmProductReceiptApi.ProductReceipt>(
`/mes/wm/product-receipt/get?id=${id}`,
);
}
/** 新增产品入库单 */
export function createProductReceipt(
data: MesWmProductReceiptApi.ProductReceipt,
) {
return requestClient.post<number>('/mes/wm/product-receipt/create', data);
}
/** 修改产品入库单 */
export function updateProductReceipt(
data: MesWmProductReceiptApi.ProductReceipt,
) {
return requestClient.put('/mes/wm/product-receipt/update', data);
}
/** 删除产品入库单 */
export function deleteProductReceipt(id: number) {
return requestClient.delete(`/mes/wm/product-receipt/delete?id=${id}`);
}
/** 提交产品入库单 */
export function submitProductReceipt(id: number) {
return requestClient.put(`/mes/wm/product-receipt/submit?id=${id}`);
}
/** 执行上架 */
export function stockProductReceipt(id: number) {
return requestClient.put(`/mes/wm/product-receipt/stock?id=${id}`);
}
/** 执行入库 */
export function finishProductReceipt(id: number) {
return requestClient.put(`/mes/wm/product-receipt/finish?id=${id}`);
}
/** 取消产品入库单 */
export function cancelProductReceipt(id: number) {
return requestClient.put(`/mes/wm/product-receipt/cancel?id=${id}`);
}
/** 校验产品入库单明细数量是否与行收货数量一致 */
export function checkProductReceiptQuantity(id: number) {
return requestClient.get<boolean>(
`/mes/wm/product-receipt/check-quantity?id=${id}`,
);
}
/** 导出产品入库单 */
export function exportProductReceipt(params: any) {
return requestClient.download('/mes/wm/product-receipt/export-excel', {
params,
});
}

View File

@ -0,0 +1,57 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmProductReceiptLineApi {
/** MES 产品入库单行 */
export interface ProductReceiptLine {
id?: number; // 行编号
receiptId?: number; // 入库单编号
itemId?: number; // 物料编号
materialStockId?: number; // 库存记录编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
quantity?: number; // 入库数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
remark?: string; // 备注
}
}
/** 查询产品入库单行分页 */
export function getProductReceiptLinePage(params: PageParam) {
return requestClient.get<
PageResult<MesWmProductReceiptLineApi.ProductReceiptLine>
>('/mes/wm/product-receipt-line/page', { params });
}
/** 查询产品入库单行详情 */
export function getProductReceiptLine(id: number) {
return requestClient.get<MesWmProductReceiptLineApi.ProductReceiptLine>(
`/mes/wm/product-receipt-line/get?id=${id}`,
);
}
/** 新增产品入库单行 */
export function createProductReceiptLine(
data: MesWmProductReceiptLineApi.ProductReceiptLine,
) {
return requestClient.post<number>(
'/mes/wm/product-receipt-line/create',
data,
);
}
/** 修改产品入库单行 */
export function updateProductReceiptLine(
data: MesWmProductReceiptLineApi.ProductReceiptLine,
) {
return requestClient.put('/mes/wm/product-receipt-line/update', data);
}
/** 删除产品入库单行 */
export function deleteProductReceiptLine(id: number) {
return requestClient.delete(`/mes/wm/product-receipt-line/delete?id=${id}`);
}

View File

@ -0,0 +1,58 @@
import { requestClient } from '#/api/request';
export namespace MesWmProductSalesDetailApi {
/** MES 销售出库明细 */
export interface ProductSalesDetail {
id?: number; // 明细编号
lineId?: number; // 出库单行编号
salesId?: number; // 出库单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
quantity?: number; // 数量
materialStockId?: number; // 库存记录编号
batchId?: number; // 批次编号
batchCode?: string; // 批次号
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
}
}
/** 查询销售出库明细列表(按行编号) */
export function getProductSalesDetailListByLineId(lineId: number) {
return requestClient.get<MesWmProductSalesDetailApi.ProductSalesDetail[]>(
'/mes/wm/product-sales-detail/list-by-line',
{ params: { lineId } },
);
}
/** 查询销售出库明细详情 */
export function getProductSalesDetail(id: number) {
return requestClient.get<MesWmProductSalesDetailApi.ProductSalesDetail>(
`/mes/wm/product-sales-detail/get?id=${id}`,
);
}
/** 新增销售出库明细 */
export function createProductSalesDetail(
data: MesWmProductSalesDetailApi.ProductSalesDetail,
) {
return requestClient.post<number>('/mes/wm/product-sales-detail/create', data);
}
/** 修改销售出库明细 */
export function updateProductSalesDetail(
data: MesWmProductSalesDetailApi.ProductSalesDetail,
) {
return requestClient.put('/mes/wm/product-sales-detail/update', data);
}
/** 删除销售出库明细 */
export function deleteProductSalesDetail(id: number) {
return requestClient.delete(`/mes/wm/product-sales-detail/delete?id=${id}`);
}

View File

@ -5,12 +5,24 @@ import { requestClient } from '#/api/request';
export namespace MesWmProductSalesApi {
/** MES 销售出库单 */
export interface ProductSales {
id?: number; // 销售出库单编号
id?: number; // 出库单编号
code?: string; // 出库单编号
name?: string; // 出库单名称
noticeId?: number; // 发货通知单编号
noticeCode?: string; // 发货通知单编码
clientId?: number; // 客户编号
clientCode?: string; // 客户编码
clientName?: string; // 客户名称
salesOrderCode?: string; // 销售订单编号
salesDate?: Date; // 出库日期
salesDate?: number; // 出库日期
contactName?: string; // 收货人
contactTelephone?: string; // 联系方式
contactAddress?: string; // 收货地址
carrier?: string; // 承运商
shippingNumber?: string; // 运输单号
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
@ -21,3 +33,64 @@ export function getProductSalesPage(params: PageParam) {
{ params },
);
}
/** 查询销售出库单详情 */
export function getProductSales(id: number) {
return requestClient.get<MesWmProductSalesApi.ProductSales>(
`/mes/wm/product-sales/get?id=${id}`,
);
}
/** 新增销售出库单 */
export function createProductSales(data: MesWmProductSalesApi.ProductSales) {
return requestClient.post<number>('/mes/wm/product-sales/create', data);
}
/** 修改销售出库单 */
export function updateProductSales(data: MesWmProductSalesApi.ProductSales) {
return requestClient.put('/mes/wm/product-sales/update', data);
}
/** 删除销售出库单 */
export function deleteProductSales(id: number) {
return requestClient.delete(`/mes/wm/product-sales/delete?id=${id}`);
}
/** 提交销售出库单 */
export function submitProductSales(id: number) {
return requestClient.put(`/mes/wm/product-sales/submit?id=${id}`);
}
/** 执行拣货 */
export function stockProductSales(id: number) {
return requestClient.put(`/mes/wm/product-sales/stock?id=${id}`);
}
/** 填写运单 */
export function shippingProductSales(data: MesWmProductSalesApi.ProductSales) {
return requestClient.put('/mes/wm/product-sales/shipping', data);
}
/** 执行出库 */
export function finishProductSales(id: number) {
return requestClient.put(`/mes/wm/product-sales/finish?id=${id}`);
}
/** 取消销售出库单 */
export function cancelProductSales(id: number) {
return requestClient.put(`/mes/wm/product-sales/cancel?id=${id}`);
}
/** 校验销售出库单拣货数量是否与出库数量一致 */
export function checkProductSalesQuantity(id: number) {
return requestClient.get<boolean>(
`/mes/wm/product-sales/check-quantity?id=${id}`,
);
}
/** 导出销售出库单 */
export function exportProductSales(params: any) {
return requestClient.download('/mes/wm/product-sales/export-excel', {
params,
});
}

View File

@ -6,13 +6,19 @@ export namespace MesWmProductSalesLineApi {
/** MES 销售出库单行 */
export interface ProductSalesLine {
id?: number; // 行编号
salesId?: number; // 出库单编号
noticeLineId?: number; // 发货通知单行编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
quantity?: number; // 出库数量
pickedQuantity?: number; // 已拣货数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
oqcCheckFlag?: boolean; // 是否检验
remark?: string; // 备注
}
}
@ -22,3 +28,29 @@ export function getProductSalesLinePage(params: PageParam) {
PageResult<MesWmProductSalesLineApi.ProductSalesLine>
>('/mes/wm/product-sales-line/page', { params });
}
/** 查询销售出库单行详情 */
export function getProductSalesLine(id: number) {
return requestClient.get<MesWmProductSalesLineApi.ProductSalesLine>(
`/mes/wm/product-sales-line/get?id=${id}`,
);
}
/** 新增销售出库单行 */
export function createProductSalesLine(
data: MesWmProductSalesLineApi.ProductSalesLine,
) {
return requestClient.post<number>('/mes/wm/product-sales-line/create', data);
}
/** 修改销售出库单行 */
export function updateProductSalesLine(
data: MesWmProductSalesLineApi.ProductSalesLine,
) {
return requestClient.put('/mes/wm/product-sales-line/update', data);
}
/** 删除销售出库单行 */
export function deleteProductSalesLine(id: number) {
return requestClient.delete(`/mes/wm/product-sales-line/delete?id=${id}`);
}

View File

@ -0,0 +1,56 @@
import { requestClient } from '#/api/request';
export namespace MesWmReturnIssueDetailApi {
/** MES 生产退料明细 */
export interface ReturnIssueDetail {
id?: number; // 明细编号
issueId?: number; // 退料单编号
lineId?: number; // 退料单行编号
materialStockId?: number; // 库存记录编号
itemId?: number; // 物料编号
quantity?: number; // 数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
}
}
/** 查询生产退料明细列表(按行编号) */
export function getReturnIssueDetailListByLineId(lineId: number) {
return requestClient.get<MesWmReturnIssueDetailApi.ReturnIssueDetail[]>(
'/mes/wm/return-issue-detail/list-by-line',
{ params: { lineId } },
);
}
/** 查询生产退料明细详情 */
export function getReturnIssueDetail(id: number) {
return requestClient.get<MesWmReturnIssueDetailApi.ReturnIssueDetail>(
`/mes/wm/return-issue-detail/get?id=${id}`,
);
}
/** 新增生产退料明细 */
export function createReturnIssueDetail(
data: MesWmReturnIssueDetailApi.ReturnIssueDetail,
) {
return requestClient.post<number>('/mes/wm/return-issue-detail/create', data);
}
/** 修改生产退料明细 */
export function updateReturnIssueDetail(
data: MesWmReturnIssueDetailApi.ReturnIssueDetail,
) {
return requestClient.put('/mes/wm/return-issue-detail/update', data);
}
/** 删除生产退料明细 */
export function deleteReturnIssueDetail(id: number) {
return requestClient.delete(`/mes/wm/return-issue-detail/delete?id=${id}`);
}

View File

@ -0,0 +1,78 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmReturnIssueApi {
/** MES 生产退料单 */
export interface ReturnIssue {
id?: number; // 退料单编号
code?: string; // 退料单编号
name?: string; // 退料单名称
workstationId?: number; // 工作站编号
workstationName?: string; // 工作站名称
workOrderId?: number; // 生产工单编号
workOrderCode?: string; // 生产工单编码
type?: number; // 退料类型
returnDate?: number; // 退料日期
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询生产退料单分页 */
export function getReturnIssuePage(params: PageParam) {
return requestClient.get<PageResult<MesWmReturnIssueApi.ReturnIssue>>(
'/mes/wm/return-issue/page',
{ params },
);
}
/** 查询生产退料单详情 */
export function getReturnIssue(id: number) {
return requestClient.get<MesWmReturnIssueApi.ReturnIssue>(
`/mes/wm/return-issue/get?id=${id}`,
);
}
/** 新增生产退料单 */
export function createReturnIssue(data: MesWmReturnIssueApi.ReturnIssue) {
return requestClient.post<number>('/mes/wm/return-issue/create', data);
}
/** 修改生产退料单 */
export function updateReturnIssue(data: MesWmReturnIssueApi.ReturnIssue) {
return requestClient.put('/mes/wm/return-issue/update', data);
}
/** 删除生产退料单 */
export function deleteReturnIssue(id: number) {
return requestClient.delete(`/mes/wm/return-issue/delete?id=${id}`);
}
/** 提交生产退料单 */
export function submitReturnIssue(id: number) {
return requestClient.put(`/mes/wm/return-issue/submit?id=${id}`);
}
/** 入库上架 */
export function stockReturnIssue(id: number) {
return requestClient.put(`/mes/wm/return-issue/stock?id=${id}`);
}
/** 完成生产退料单 */
export function finishReturnIssue(id: number) {
return requestClient.put(`/mes/wm/return-issue/finish?id=${id}`);
}
/** 取消生产退料单 */
export function cancelReturnIssue(id: number) {
return requestClient.put(`/mes/wm/return-issue/cancel?id=${id}`);
}
/** 导出生产退料单 */
export function exportReturnIssue(params: any) {
return requestClient.download('/mes/wm/return-issue/export-excel', {
params,
});
}

View File

@ -0,0 +1,58 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmReturnIssueLineApi {
/** MES 生产退料单行 */
export interface ReturnIssueLine {
id?: number; // 行编号
issueId?: number; // 退料单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
materialStockId?: number; // 库存记录编号
quantity?: number; // 退料数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
rqcCheckFlag?: boolean; // 是否检测
qualityStatus?: number; // 质量状态
rqcId?: number; // 退货检验单编号
remark?: string; // 备注
}
}
/** 查询生产退料单行分页 */
export function getReturnIssueLinePage(params: PageParam) {
return requestClient.get<PageResult<MesWmReturnIssueLineApi.ReturnIssueLine>>(
'/mes/wm/return-issue-line/page',
{ params },
);
}
/** 查询生产退料单行详情 */
export function getReturnIssueLine(id: number) {
return requestClient.get<MesWmReturnIssueLineApi.ReturnIssueLine>(
`/mes/wm/return-issue-line/get?id=${id}`,
);
}
/** 新增生产退料单行 */
export function createReturnIssueLine(
data: MesWmReturnIssueLineApi.ReturnIssueLine,
) {
return requestClient.post<number>('/mes/wm/return-issue-line/create', data);
}
/** 修改生产退料单行 */
export function updateReturnIssueLine(
data: MesWmReturnIssueLineApi.ReturnIssueLine,
) {
return requestClient.put('/mes/wm/return-issue-line/update', data);
}
/** 删除生产退料单行 */
export function deleteReturnIssueLine(id: number) {
return requestClient.delete(`/mes/wm/return-issue-line/delete?id=${id}`);
}

View File

@ -0,0 +1,55 @@
import { requestClient } from '#/api/request';
export namespace MesWmReturnSalesDetailApi {
/** MES 销售退货明细 */
export interface ReturnSalesDetail {
id?: number; // 明细编号
returnId?: number; // 退货单编号
lineId?: number; // 退货单行编号
itemId?: number; // 物料编号
quantity?: number; // 数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
}
}
/** 查询销售退货明细列表(按行编号) */
export function getReturnSalesDetailListByLineId(lineId: number) {
return requestClient.get<MesWmReturnSalesDetailApi.ReturnSalesDetail[]>(
'/mes/wm/return-sales-detail/list-by-line',
{ params: { lineId } },
);
}
/** 查询销售退货明细详情 */
export function getReturnSalesDetail(id: number) {
return requestClient.get<MesWmReturnSalesDetailApi.ReturnSalesDetail>(
`/mes/wm/return-sales-detail/get?id=${id}`,
);
}
/** 新增销售退货明细 */
export function createReturnSalesDetail(
data: MesWmReturnSalesDetailApi.ReturnSalesDetail,
) {
return requestClient.post<number>('/mes/wm/return-sales-detail/create', data);
}
/** 修改销售退货明细 */
export function updateReturnSalesDetail(
data: MesWmReturnSalesDetailApi.ReturnSalesDetail,
) {
return requestClient.put('/mes/wm/return-sales-detail/update', data);
}
/** 删除销售退货明细 */
export function deleteReturnSalesDetail(id: number) {
return requestClient.delete(`/mes/wm/return-sales-detail/delete?id=${id}`);
}

View File

@ -0,0 +1,78 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmReturnSalesApi {
/** MES 销售退货单 */
export interface ReturnSales {
id?: number; // 退货单编号
code?: string; // 退货单编号
name?: string; // 退货单名称
salesOrderCode?: string; // 销售订单号
clientId?: number; // 客户编号
clientCode?: string; // 客户编码
clientName?: string; // 客户名称
returnDate?: number; // 退货日期
returnReason?: string; // 退货原因
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询销售退货单分页 */
export function getReturnSalesPage(params: PageParam) {
return requestClient.get<PageResult<MesWmReturnSalesApi.ReturnSales>>(
'/mes/wm/return-sales/page',
{ params },
);
}
/** 查询销售退货单详情 */
export function getReturnSales(id: number) {
return requestClient.get<MesWmReturnSalesApi.ReturnSales>(
`/mes/wm/return-sales/get?id=${id}`,
);
}
/** 新增销售退货单 */
export function createReturnSales(data: MesWmReturnSalesApi.ReturnSales) {
return requestClient.post<number>('/mes/wm/return-sales/create', data);
}
/** 修改销售退货单 */
export function updateReturnSales(data: MesWmReturnSalesApi.ReturnSales) {
return requestClient.put('/mes/wm/return-sales/update', data);
}
/** 删除销售退货单 */
export function deleteReturnSales(id: number) {
return requestClient.delete(`/mes/wm/return-sales/delete?id=${id}`);
}
/** 提交销售退货单 */
export function submitReturnSales(id: number) {
return requestClient.put(`/mes/wm/return-sales/submit?id=${id}`);
}
/** 执行退货 */
export function finishReturnSales(id: number) {
return requestClient.put(`/mes/wm/return-sales/finish?id=${id}`);
}
/** 执行上架 */
export function stockReturnSales(id: number) {
return requestClient.put(`/mes/wm/return-sales/stock?id=${id}`);
}
/** 取消销售退货单 */
export function cancelReturnSales(id: number) {
return requestClient.put(`/mes/wm/return-sales/cancel?id=${id}`);
}
/** 导出销售退货单 */
export function exportReturnSales(params: any) {
return requestClient.download('/mes/wm/return-sales/export-excel', {
params,
});
}

View File

@ -0,0 +1,57 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmReturnSalesLineApi {
/** MES 销售退货单行 */
export interface ReturnSalesLine {
id?: number; // 行编号
returnId?: number; // 退货单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
quantity?: number; // 退货数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
rqcCheckFlag?: boolean; // 是否需要质检
rqcId?: number; // 退货检验单编号
qualityStatus?: number; // 质量状态
remark?: string; // 备注
}
}
/** 查询销售退货单行分页 */
export function getReturnSalesLinePage(params: PageParam) {
return requestClient.get<PageResult<MesWmReturnSalesLineApi.ReturnSalesLine>>(
'/mes/wm/return-sales-line/page',
{ params },
);
}
/** 查询销售退货单行详情 */
export function getReturnSalesLine(id: number) {
return requestClient.get<MesWmReturnSalesLineApi.ReturnSalesLine>(
`/mes/wm/return-sales-line/get?id=${id}`,
);
}
/** 新增销售退货单行 */
export function createReturnSalesLine(
data: MesWmReturnSalesLineApi.ReturnSalesLine,
) {
return requestClient.post<number>('/mes/wm/return-sales-line/create', data);
}
/** 修改销售退货单行 */
export function updateReturnSalesLine(
data: MesWmReturnSalesLineApi.ReturnSalesLine,
) {
return requestClient.put('/mes/wm/return-sales-line/update', data);
}
/** 删除销售退货单行 */
export function deleteReturnSalesLine(id: number) {
return requestClient.delete(`/mes/wm/return-sales-line/delete?id=${id}`);
}

View File

@ -0,0 +1,56 @@
import { requestClient } from '#/api/request';
export namespace MesWmReturnVendorDetailApi {
/** MES 供应商退货明细 */
export interface ReturnVendorDetail {
id?: number; // 明细编号
returnId?: number; // 退货单编号
lineId?: number; // 退货单行编号
materialStockId?: number; // 库存记录编号
itemId?: number; // 物料编号
quantity?: number; // 数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
remark?: string; // 备注
}
}
/** 查询供应商退货明细列表(按行编号) */
export function getReturnVendorDetailListByLineId(lineId: number) {
return requestClient.get<MesWmReturnVendorDetailApi.ReturnVendorDetail[]>(
'/mes/wm/return-vendor-detail/list-by-line',
{ params: { lineId } },
);
}
/** 查询供应商退货明细详情 */
export function getReturnVendorDetail(id: number) {
return requestClient.get<MesWmReturnVendorDetailApi.ReturnVendorDetail>(
`/mes/wm/return-vendor-detail/get?id=${id}`,
);
}
/** 新增供应商退货明细 */
export function createReturnVendorDetail(
data: MesWmReturnVendorDetailApi.ReturnVendorDetail,
) {
return requestClient.post<number>('/mes/wm/return-vendor-detail/create', data);
}
/** 修改供应商退货明细 */
export function updateReturnVendorDetail(
data: MesWmReturnVendorDetailApi.ReturnVendorDetail,
) {
return requestClient.put('/mes/wm/return-vendor-detail/update', data);
}
/** 删除供应商退货明细 */
export function deleteReturnVendorDetail(id: number) {
return requestClient.delete(`/mes/wm/return-vendor-detail/delete?id=${id}`);
}

View File

@ -0,0 +1,88 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmReturnVendorApi {
/** MES 供应商退货单 */
export interface ReturnVendor {
id?: number; // 退货单编号
code?: string; // 退货单编号
name?: string; // 退货单名称
purchaseOrderCode?: string; // 采购订单号
vendorId?: number; // 供应商编号
vendorCode?: string; // 供应商编码
vendorName?: string; // 供应商名称
vendorNickname?: string; // 供应商简称
returnDate?: number; // 退货日期
returnReason?: string; // 退货原因
transportCode?: string; // 运单号
transportTelephone?: string; // 联系电话
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询供应商退货单分页 */
export function getReturnVendorPage(params: PageParam) {
return requestClient.get<PageResult<MesWmReturnVendorApi.ReturnVendor>>(
'/mes/wm/return-vendor/page',
{ params },
);
}
/** 查询供应商退货单详情 */
export function getReturnVendor(id: number) {
return requestClient.get<MesWmReturnVendorApi.ReturnVendor>(
`/mes/wm/return-vendor/get?id=${id}`,
);
}
/** 新增供应商退货单 */
export function createReturnVendor(data: MesWmReturnVendorApi.ReturnVendor) {
return requestClient.post<number>('/mes/wm/return-vendor/create', data);
}
/** 修改供应商退货单 */
export function updateReturnVendor(data: MesWmReturnVendorApi.ReturnVendor) {
return requestClient.put('/mes/wm/return-vendor/update', data);
}
/** 删除供应商退货单 */
export function deleteReturnVendor(id: number) {
return requestClient.delete(`/mes/wm/return-vendor/delete?id=${id}`);
}
/** 提交供应商退货单 */
export function submitReturnVendor(id: number) {
return requestClient.put(`/mes/wm/return-vendor/submit?id=${id}`);
}
/** 执行拣货 */
export function stockReturnVendor(id: number) {
return requestClient.put(`/mes/wm/return-vendor/stock?id=${id}`);
}
/** 完成供应商退货单 */
export function finishReturnVendor(id: number) {
return requestClient.put(`/mes/wm/return-vendor/finish?id=${id}`);
}
/** 取消供应商退货单 */
export function cancelReturnVendor(id: number) {
return requestClient.put(`/mes/wm/return-vendor/cancel?id=${id}`);
}
/** 校验供应商退货单拣货数量是否与退货数量一致 */
export function checkReturnVendorQuantity(id: number) {
return requestClient.get<boolean>(
`/mes/wm/return-vendor/check-quantity?id=${id}`,
);
}
/** 导出供应商退货单 */
export function exportReturnVendor(params: any) {
return requestClient.download('/mes/wm/return-vendor/export-excel', {
params,
});
}

View File

@ -0,0 +1,54 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmReturnVendorLineApi {
/** MES 供应商退货单行 */
export interface ReturnVendorLine {
id?: number; // 行编号
returnId?: number; // 退货单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
quantity?: number; // 退货数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
remark?: string; // 备注
}
}
/** 查询供应商退货单行分页 */
export function getReturnVendorLinePage(params: PageParam) {
return requestClient.get<PageResult<MesWmReturnVendorLineApi.ReturnVendorLine>>(
'/mes/wm/return-vendor-line/page',
{ params },
);
}
/** 查询供应商退货单行详情 */
export function getReturnVendorLine(id: number) {
return requestClient.get<MesWmReturnVendorLineApi.ReturnVendorLine>(
`/mes/wm/return-vendor-line/get?id=${id}`,
);
}
/** 新增供应商退货单行 */
export function createReturnVendorLine(
data: MesWmReturnVendorLineApi.ReturnVendorLine,
) {
return requestClient.post<number>('/mes/wm/return-vendor-line/create', data);
}
/** 修改供应商退货单行 */
export function updateReturnVendorLine(
data: MesWmReturnVendorLineApi.ReturnVendorLine,
) {
return requestClient.put('/mes/wm/return-vendor-line/update', data);
}
/** 删除供应商退货单行 */
export function deleteReturnVendorLine(id: number) {
return requestClient.delete(`/mes/wm/return-vendor-line/delete?id=${id}`);
}

View File

@ -0,0 +1,65 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmSalesNoticeApi {
/** MES 发货通知单 */
export interface SalesNotice {
id?: number; // 通知单编号
code?: string; // 通知单编号
name?: string; // 通知单名称
salesOrderCode?: string; // 销售订单编号
clientId?: number; // 客户编号
clientCode?: string; // 客户编码
clientName?: string; // 客户名称
salesDate?: number; // 发货日期
recipientName?: string; // 收货人
recipientTelephone?: string; // 联系方式
recipientAddress?: string; // 收货地址
status?: number; // 单据状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询发货通知单分页 */
export function getSalesNoticePage(params: PageParam) {
return requestClient.get<PageResult<MesWmSalesNoticeApi.SalesNotice>>(
'/mes/wm/sales-notice/page',
{ params },
);
}
/** 查询发货通知单详情 */
export function getSalesNotice(id: number) {
return requestClient.get<MesWmSalesNoticeApi.SalesNotice>(
`/mes/wm/sales-notice/get?id=${id}`,
);
}
/** 新增发货通知单 */
export function createSalesNotice(data: MesWmSalesNoticeApi.SalesNotice) {
return requestClient.post<number>('/mes/wm/sales-notice/create', data);
}
/** 修改发货通知单 */
export function updateSalesNotice(data: MesWmSalesNoticeApi.SalesNotice) {
return requestClient.put('/mes/wm/sales-notice/update', data);
}
/** 删除发货通知单 */
export function deleteSalesNotice(id: number) {
return requestClient.delete(`/mes/wm/sales-notice/delete?id=${id}`);
}
/** 提交发货通知单 */
export function submitSalesNotice(id: number) {
return requestClient.put(`/mes/wm/sales-notice/submit?id=${id}`);
}
/** 导出发货通知单 */
export function exportSalesNotice(params: any) {
return requestClient.download('/mes/wm/sales-notice/export-excel', {
params,
});
}

View File

@ -0,0 +1,55 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmSalesNoticeLineApi {
/** MES 发货通知单行 */
export interface SalesNoticeLine {
id?: number; // 行编号
noticeId?: number; // 发货通知单编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位
batchId?: number; // 批次编号
batchCode?: string; // 批次号
quantity?: number; // 发货数量
oqcCheckFlag?: boolean; // 是否检验
remark?: string; // 备注
}
}
/** 查询发货通知单行分页 */
export function getSalesNoticeLinePage(params: PageParam) {
return requestClient.get<PageResult<MesWmSalesNoticeLineApi.SalesNoticeLine>>(
'/mes/wm/sales-notice-line/page',
{ params },
);
}
/** 查询发货通知单行详情 */
export function getSalesNoticeLine(id: number) {
return requestClient.get<MesWmSalesNoticeLineApi.SalesNoticeLine>(
`/mes/wm/sales-notice-line/get?id=${id}`,
);
}
/** 新增发货通知单行 */
export function createSalesNoticeLine(
data: MesWmSalesNoticeLineApi.SalesNoticeLine,
) {
return requestClient.post<number>('/mes/wm/sales-notice-line/create', data);
}
/** 修改发货通知单行 */
export function updateSalesNoticeLine(
data: MesWmSalesNoticeLineApi.SalesNoticeLine,
) {
return requestClient.put('/mes/wm/sales-notice-line/update', data);
}
/** 删除发货通知单行 */
export function deleteSalesNoticeLine(id: number) {
return requestClient.delete(`/mes/wm/sales-notice-line/delete?id=${id}`);
}

View File

@ -0,0 +1,68 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmSnApi {
/** MES SN 码分组 */
export interface SnGroup {
uuid?: string; // 批次 UUID
count?: number; // SN 码数量
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitName?: string; // 单位名称
batchCode?: string; // 批次号
workOrderId?: number; // 生产工单编号
createTime?: Date; // 生成时间
}
/** MES SN 码生成参数 */
export interface SnGenerate {
itemId?: number; // 物料编号
batchCode?: string; // 批次号
workOrderId?: number; // 生产工单编号
count?: number; // 生成数量
}
/** MES SN 码分组分页查询参数 */
export interface PageParams extends PageParam {
uuid?: string;
code?: string;
itemId?: number;
batchCode?: string;
createTime?: string[];
}
}
/** 生成 SN 码 */
export function generateSnCodes(data: MesWmSnApi.SnGenerate) {
return requestClient.post('/mes/wm/sn/generate', data);
}
/** 查询 SN 码分组分页 */
export function getSnGroupPage(params: MesWmSnApi.PageParams) {
return requestClient.get<PageResult<MesWmSnApi.SnGroup>>(
'/mes/wm/sn/group-page',
{ params },
);
}
/** 批量删除 SN 码(按批次 UUID */
export function deleteSnBatch(uuid: string) {
return requestClient.delete('/mes/wm/sn/delete-batch', {
params: { uuid },
});
}
/** 导出 SN 码分组 Excel */
export function exportSnGroupExcel(params: MesWmSnApi.PageParams) {
return requestClient.download('/mes/wm/sn/group-export-excel', { params });
}
/** 导出批次 SN 码明细 Excel */
export function exportSnDetailExcel(uuid: string) {
return requestClient.download('/mes/wm/sn/export-excel', {
params: { uuid },
});
}

View File

@ -0,0 +1,68 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmStockTakingPlanApi {
/** 盘点方案 */
export interface StockTakingPlan {
id?: number; // 方案编号
code?: string; // 方案编码
name?: string; // 方案名称
type?: number; // 盘点类型
startTime?: number; // 开始时间
endTime?: number; // 结束时间
blindFlag?: boolean; // 是否盲盘
frozen?: boolean; // 是否冻结库存
status?: number; // 状态
remark?: string; // 备注
createTime?: string; // 创建时间
}
}
/** 查询盘点方案分页 */
export function getStockTakingPlanPage(params: PageParam) {
return requestClient.get<PageResult<MesWmStockTakingPlanApi.StockTakingPlan>>(
'/mes/wm/stocktaking-plan/page',
{ params },
);
}
/** 查询盘点方案详情 */
export function getStockTakingPlan(id: number) {
return requestClient.get<MesWmStockTakingPlanApi.StockTakingPlan>(
`/mes/wm/stocktaking-plan/get?id=${id}`,
);
}
/** 新增盘点方案 */
export function createStockTakingPlan(
data: MesWmStockTakingPlanApi.StockTakingPlan,
) {
return requestClient.post<number>('/mes/wm/stocktaking-plan/create', data);
}
/** 修改盘点方案 */
export function updateStockTakingPlan(
data: MesWmStockTakingPlanApi.StockTakingPlan,
) {
return requestClient.put('/mes/wm/stocktaking-plan/update', data);
}
/** 修改盘点方案状态 */
export function updateStockTakingPlanStatus(id: number, status: number) {
return requestClient.put('/mes/wm/stocktaking-plan/update-status', null, {
params: { id, status },
});
}
/** 删除盘点方案 */
export function deleteStockTakingPlan(id: number) {
return requestClient.delete(`/mes/wm/stocktaking-plan/delete?id=${id}`);
}
/** 导出盘点方案 */
export function exportStockTakingPlan(params: any) {
return requestClient.download('/mes/wm/stocktaking-plan/export-excel', {
params,
});
}

View File

@ -0,0 +1,49 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmStockTakingPlanParamApi {
/** 盘点方案条件 */
export interface StockTakingPlanParam {
id?: number; // 条件编号
planId?: number; // 方案编号
type?: number; // 条件类型
valueId?: number; // 条件值编号
valueCode?: string; // 条件值编码
valueName?: string; // 条件值名称
remark?: string; // 备注
}
}
/** 查询盘点方案条件分页 */
export function getStockTakingPlanParamPage(params: PageParam) {
return requestClient.get<
PageResult<MesWmStockTakingPlanParamApi.StockTakingPlanParam>
>('/mes/wm/stocktaking-plan-param/page', { params });
}
/** 查询盘点方案条件详情 */
export function getStockTakingPlanParam(id: number) {
return requestClient.get<MesWmStockTakingPlanParamApi.StockTakingPlanParam>(
`/mes/wm/stocktaking-plan-param/get?id=${id}`,
);
}
/** 新增盘点方案条件 */
export function createStockTakingPlanParam(
data: MesWmStockTakingPlanParamApi.StockTakingPlanParam,
) {
return requestClient.post('/mes/wm/stocktaking-plan-param/create', data);
}
/** 修改盘点方案条件 */
export function updateStockTakingPlanParam(
data: MesWmStockTakingPlanParamApi.StockTakingPlanParam,
) {
return requestClient.put('/mes/wm/stocktaking-plan-param/update', data);
}
/** 删除盘点方案条件 */
export function deleteStockTakingPlanParam(id: number) {
return requestClient.delete(`/mes/wm/stocktaking-plan-param/delete?id=${id}`);
}

View File

@ -0,0 +1,86 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmStockTakingTaskApi {
/** 盘点任务 */
export interface StockTakingTask {
id?: number; // 任务编号
code?: string; // 任务编码
name?: string; // 任务名称
takingDate?: string; // 盘点日期
type?: number; // 盘点类型
userId?: number; // 盘点人用户编号
userNickname?: string; // 盘点人名称
planId?: number; // 盘点方案编号
planCode?: string; // 盘点方案编码
planName?: string; // 盘点方案名称
blindFlag?: boolean; // 是否盲盘
frozen?: boolean; // 是否冻结库存
startTime?: number; // 开始时间
endTime?: number; // 结束时间
status?: number; // 单据状态
remark?: string; // 备注
createTime?: string; // 创建时间
}
}
/** 查询盘点任务分页 */
export function getStockTakingPage(params: PageParam) {
return requestClient.get<PageResult<MesWmStockTakingTaskApi.StockTakingTask>>(
'/mes/wm/stocktaking-task/page',
{ params },
);
}
/** 查询盘点任务详情 */
export function getStockTaking(id: number) {
return requestClient.get<MesWmStockTakingTaskApi.StockTakingTask>(
`/mes/wm/stocktaking-task/get?id=${id}`,
);
}
/** 新增盘点任务 */
export function createStockTaking(
data: MesWmStockTakingTaskApi.StockTakingTask,
) {
return requestClient.post<number>('/mes/wm/stocktaking-task/create', data);
}
/** 修改盘点任务 */
export function updateStockTaking(
data: MesWmStockTakingTaskApi.StockTakingTask,
) {
return requestClient.put('/mes/wm/stocktaking-task/update', data);
}
/** 删除盘点任务 */
export function deleteStockTaking(id: number) {
return requestClient.delete(`/mes/wm/stocktaking-task/delete?id=${id}`);
}
/** 提交盘点任务 */
export function submitStockTaking(id: number) {
return requestClient.put('/mes/wm/stocktaking-task/submit', null, {
params: { id },
});
}
/** 取消盘点任务 */
export function cancelStockTaking(id: number) {
return requestClient.put('/mes/wm/stocktaking-task/cancel', null, {
params: { id },
});
}
/** 执行盘点任务 */
export function finishStockTaking(id: number) {
return requestClient.put('/mes/wm/stocktaking-task/finish', { id });
}
/** 导出盘点任务 */
export function exportStockTaking(params: any) {
return requestClient.download('/mes/wm/stocktaking-task/export-excel', {
params,
});
}

View File

@ -0,0 +1,72 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmStockTakingTaskLineApi {
/** 盘点任务行 */
export interface StockTakingTaskLine {
id?: number; // 盘点行编号
taskId?: number; // 任务编号
materialStockId?: number; // 库存编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 计量单位名称
batchId?: number; // 批次编号
batchCode?: string; // 批次号
quantity?: number; // 在库数量
takingQuantity?: number; // 盘点数量
differenceQuantity?: number; // 差异数量
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
status?: number; // 状态
remark?: string; // 备注
}
}
/** 查询盘点任务行分页 */
export function getStockTakingTaskLinePage(params: PageParam) {
return requestClient.get<
PageResult<MesWmStockTakingTaskLineApi.StockTakingTaskLine>
>('/mes/wm/stocktaking-task-line/page', { params });
}
/** 查询盘点任务行精简列表 */
export function getStockTakingTaskLineSimpleList(taskId: number) {
return requestClient.get<MesWmStockTakingTaskLineApi.StockTakingTaskLine[]>(
'/mes/wm/stocktaking-task-line/simple-list',
{ params: { taskId } },
);
}
/** 查询盘点任务行详情 */
export function getStockTakingTaskLine(id: number) {
return requestClient.get<MesWmStockTakingTaskLineApi.StockTakingTaskLine>(
'/mes/wm/stocktaking-task-line/get',
{ params: { id } },
);
}
/** 新增盘点任务行 */
export function createStockTakingTaskLine(
data: MesWmStockTakingTaskLineApi.StockTakingTaskLine,
) {
return requestClient.post('/mes/wm/stocktaking-task-line/create', data);
}
/** 修改盘点任务行 */
export function updateStockTakingTaskLine(
data: MesWmStockTakingTaskLineApi.StockTakingTaskLine,
) {
return requestClient.put('/mes/wm/stocktaking-task-line/update', data);
}
/** 删除盘点任务行 */
export function deleteStockTakingTaskLine(id: number) {
return requestClient.delete(`/mes/wm/stocktaking-task-line/delete?id=${id}`);
}

View File

@ -0,0 +1,64 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmStockTakingResultApi {
/** 盘点结果 */
export interface StockTakingResult {
id?: number; // 结果编号
taskId?: number; // 任务编号
lineId?: number; // 盘点行编号
materialStockId?: number; // 库存编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 计量单位名称
batchId?: number; // 批次编号
batchCode?: string; // 批次号
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
quantity?: number; // 在库数量
takingQuantity?: number; // 盘点数量
remark?: string; // 备注
createTime?: string; // 创建时间
}
}
/** 查询盘点结果分页 */
export function getStockTakingResultPage(params: PageParam) {
return requestClient.get<
PageResult<MesWmStockTakingResultApi.StockTakingResult>
>('/mes/wm/stocktaking-task-result/page', { params });
}
/** 查询盘点结果详情 */
export function getStockTakingResult(id: number) {
return requestClient.get<MesWmStockTakingResultApi.StockTakingResult>(
'/mes/wm/stocktaking-task-result/get',
{ params: { id } },
);
}
/** 新增盘点结果 */
export function createStockTakingResult(
data: MesWmStockTakingResultApi.StockTakingResult,
) {
return requestClient.post('/mes/wm/stocktaking-task-result/create', data);
}
/** 修改盘点结果 */
export function updateStockTakingResult(
data: MesWmStockTakingResultApi.StockTakingResult,
) {
return requestClient.put('/mes/wm/stocktaking-task-result/update', data);
}
/** 删除盘点结果 */
export function deleteStockTakingResult(id: number) {
return requestClient.delete(`/mes/wm/stocktaking-task-result/delete?id=${id}`);
}

View File

@ -0,0 +1,59 @@
import { requestClient } from '#/api/request';
export namespace MesWmTransferDetailApi {
/** MES 调拨明细 */
export interface TransferDetail {
id?: number; // 编号
lineId?: number; // 转移单行编号
transferId?: number; // 转移单编号
itemId?: number; // 物料产品编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位名称
quantity?: number; // 数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
toWarehouseId?: number; // 移入仓库编号
toWarehouseName?: string; // 移入仓库名称
toLocationId?: number; // 移入库区编号
toLocationName?: string; // 移入库区名称
toAreaId?: number; // 移入库位编号
toAreaName?: string; // 移入库位名称
remark?: string; // 备注
}
}
/** 查询调拨明细列表(按行编号) */
export function getTransferDetailListByLineId(lineId: number) {
return requestClient.get<MesWmTransferDetailApi.TransferDetail[]>(
'/mes/wm/transfer-detail/list-by-line',
{ params: { lineId } },
);
}
/** 查询调拨明细详情 */
export function getTransferDetail(id: number) {
return requestClient.get<MesWmTransferDetailApi.TransferDetail>(
`/mes/wm/transfer-detail/get?id=${id}`,
);
}
/** 新增调拨明细 */
export function createTransferDetail(
data: MesWmTransferDetailApi.TransferDetail,
) {
return requestClient.post('/mes/wm/transfer-detail/create', data);
}
/** 修改调拨明细 */
export function updateTransferDetail(
data: MesWmTransferDetailApi.TransferDetail,
) {
return requestClient.put('/mes/wm/transfer-detail/update', data);
}
/** 删除调拨明细 */
export function deleteTransferDetail(id: number) {
return requestClient.delete(`/mes/wm/transfer-detail/delete?id=${id}`);
}

View File

@ -0,0 +1,92 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmTransferApi {
/** MES 转移单 */
export interface Transfer {
id?: number; // 编号
code?: string; // 转移单编号
name?: string; // 转移单名称
type?: number; // 转移单类型
deliveryFlag?: boolean; // 是否配送
recipientName?: string; // 收货人
recipientTelephone?: string; // 联系电话
destinationAddress?: string; // 目的地
carrier?: string; // 承运商
shippingNumber?: string; // 运输单号
confirmFlag?: boolean; // 是否确认
transferDate?: string; // 转移日期
status?: number; // 单据状态
remark?: string; // 备注
createTime?: number; // 创建时间
}
/** MES 转移单分页查询参数 */
export interface PageParams extends PageParam {
code?: string;
name?: string;
type?: number;
status?: number;
}
}
/** 查询转移单分页 */
export function getTransferPage(params: MesWmTransferApi.PageParams) {
return requestClient.get<PageResult<MesWmTransferApi.Transfer>>(
'/mes/wm/transfer/page',
{ params },
);
}
/** 查询转移单详情 */
export function getTransfer(id: number) {
return requestClient.get<MesWmTransferApi.Transfer>(
`/mes/wm/transfer/get?id=${id}`,
);
}
/** 新增转移单 */
export function createTransfer(data: MesWmTransferApi.Transfer) {
return requestClient.post<number>('/mes/wm/transfer/create', data);
}
/** 修改转移单 */
export function updateTransfer(data: MesWmTransferApi.Transfer) {
return requestClient.put('/mes/wm/transfer/update', data);
}
/** 删除转移单 */
export function deleteTransfer(id: number) {
return requestClient.delete(`/mes/wm/transfer/delete?id=${id}`);
}
/** 提交转移单 */
export function submitTransfer(id: number) {
return requestClient.put(`/mes/wm/transfer/submit?id=${id}`);
}
/** 到货确认 */
export function confirmTransfer(id: number) {
return requestClient.put(`/mes/wm/transfer/confirm?id=${id}`);
}
/** 执行上架 */
export function stockTransfer(id: number) {
return requestClient.put(`/mes/wm/transfer/stock?id=${id}`);
}
/** 完成转移 */
export function finishTransfer(id: number) {
return requestClient.put(`/mes/wm/transfer/finish?id=${id}`);
}
/** 取消转移单 */
export function cancelTransfer(id: number) {
return requestClient.put(`/mes/wm/transfer/cancel?id=${id}`);
}
/** 导出转移单 */
export function exportTransfer(params: any) {
return requestClient.download('/mes/wm/transfer/export-excel', { params });
}

View File

@ -0,0 +1,55 @@
import { requestClient } from '#/api/request';
export namespace MesWmTransferLineApi {
/** MES 转移单行 */
export interface TransferLine {
id?: number; // 编号
transferId?: number; // 转移单编号
materialStockId?: number; // 库存台账编号
itemId?: number; // 物料产品编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 单位名称
quantity?: number; // 转移数量
batchId?: number; // 批次编号
batchCode?: string; // 批次号
fromWarehouseId?: number; // 移出仓库编号
fromWarehouseName?: string; // 移出仓库名称
fromLocationId?: number; // 移出库区编号
fromLocationName?: string; // 移出库区名称
fromAreaId?: number; // 移出库位编号
fromAreaName?: string; // 移出库位名称
remark?: string; // 备注
}
}
/** 查询转移单行列表 */
export function getTransferLineList(transferId: number) {
return requestClient.get<MesWmTransferLineApi.TransferLine[]>(
'/mes/wm/transfer-line/list',
{ params: { transferId } },
);
}
/** 查询转移单行详情 */
export function getTransferLine(id: number) {
return requestClient.get<MesWmTransferLineApi.TransferLine>(
`/mes/wm/transfer-line/get?id=${id}`,
);
}
/** 新增转移单行 */
export function createTransferLine(data: MesWmTransferLineApi.TransferLine) {
return requestClient.post('/mes/wm/transfer-line/create', data);
}
/** 修改转移单行 */
export function updateTransferLine(data: MesWmTransferLineApi.TransferLine) {
return requestClient.put('/mes/wm/transfer-line/update', data);
}
/** 删除转移单行 */
export function deleteTransferLine(id: number) {
return requestClient.delete(`/mes/wm/transfer-line/delete?id=${id}`);
}

View File

@ -0,0 +1,55 @@
import type { RouteRecordRaw } from 'vue-router';
const routes: RouteRecordRaw[] = [
{
path: '/mes',
name: 'MesCenter',
meta: {
title: 'MES 制造执行',
icon: 'lucide:factory',
keepAlive: true,
hideInMenu: true,
},
children: [
{
path: 'wm/warehouse/location',
name: 'MesWmLocation',
meta: {
title: '库区设置',
activePath: '/mes/wm/warehouse',
},
component: () =>
import('#/views/mes/wm/warehouse/location/index.vue'),
},
{
path: 'wm/warehouse/area',
name: 'MesWmArea',
meta: {
title: '库位设置',
activePath: '/mes/wm/warehouse',
},
component: () => import('#/views/mes/wm/warehouse/area/index.vue'),
},
{
path: 'wm/barcode/config',
name: 'MesWmBarcodeConfig',
meta: {
title: '条码配置',
activePath: '/mes/wm/barcode',
},
component: () => import('#/views/mes/wm/barcode/config/index.vue'),
},
{
path: 'pro/task/gantt-edit',
name: 'MesProTaskGanttEdit',
meta: {
title: '甘特图编辑',
activePath: '/mes/pro/task',
},
component: () => import('#/views/mes/pro/task/edit/index.vue'),
},
],
},
];
export default routes;

View File

@ -105,9 +105,7 @@ const [Grid, gridApi] = useVbenVxeGrid({
/** 解绑账号 */
function onUnbind(row: SystemSocialUserApi.SocialUser) {
confirm({
content: `确定解绑[${getDictLabel(DICT_TYPE.SYSTEM_SOCIAL_TYPE, row.type)}]平台的[${row.openid}]账号吗?`,
}).then(async () => {
confirm(`确定解绑[${getDictLabel(DICT_TYPE.SYSTEM_SOCIAL_TYPE, row.type)}]平台的[${row.openid}]账号吗?`).then(async () => {
await socialUnbind({ type: row.type, openid: row.openid });
//
message.success($t('ui.actionMessage.operationSuccess'));

View File

@ -39,9 +39,7 @@ async function handleUpdatePublicStatusChange(
): Promise<boolean | undefined> {
const text = newStatus ? '公开' : '私有';
try {
await confirm({
content: `确认要将该图片切换为【${text}】吗?`,
});
await confirm(`确认要将该图片切换为【${text}】吗?`);
} catch {
return false;
}

View File

@ -77,9 +77,7 @@ async function handleStatusChange(
row: AiKnowledgeDocumentApi.KnowledgeDocument,
): Promise<boolean | undefined> {
try {
await confirm({
content: `你要将${row.name}的状态切换为【${getDictLabel(DICT_TYPE.COMMON_STATUS, newStatus)}】吗?`,
});
await confirm(`你要将${row.name}的状态切换为【${getDictLabel(DICT_TYPE.COMMON_STATUS, newStatus)}】吗?`);
} catch {
return false;
}

View File

@ -65,9 +65,7 @@ async function handleStatusChange(
row: AiKnowledgeSegmentApi.KnowledgeSegment,
): Promise<boolean | undefined> {
try {
await confirm({
content: `你要将片段 ${row.id} 的状态切换为【${getDictLabel(DICT_TYPE.COMMON_STATUS, newStatus)}】吗?`,
});
await confirm(`你要将片段 ${row.id} 的状态切换为【${getDictLabel(DICT_TYPE.COMMON_STATUS, newStatus)}】吗?`);
} catch {
return false;
}

View File

@ -39,9 +39,7 @@ async function handleUpdatePublicStatusChange(
): Promise<boolean | undefined> {
const text = newStatus ? '公开' : '私有';
try {
await confirm({
content: `确认要将该音乐切换为【${text}】吗?`,
});
await confirm(`确认要将该音乐切换为【${text}】吗?`);
} catch {
return false;
}

View File

@ -75,9 +75,7 @@ async function handleDeleteContactBusinessList() {
return;
}
try {
await confirm({
content: `确定要将${checkedRows.value.map((item) => item.name).join(',')}解除关联吗?`,
});
await confirm(`确定要将${checkedRows.value.map((item) => item.name).join(',')}解除关联吗?`);
} catch {
return false;
}

View File

@ -84,9 +84,7 @@ function handleTransfer() {
/** 转化为客户 */
async function handleTransform(): Promise<boolean | undefined> {
try {
await confirm({
content: '确定将该线索转化为客户吗?',
});
await confirm('确定将该线索转化为客户吗?');
} catch {
return false;
}

View File

@ -72,9 +72,7 @@ async function handleDeleteContactBusinessList() {
return;
}
try {
await confirm({
content: `确定要将${checkedRows.value.map((item) => item.name).join(',')}解除关联吗?`,
});
await confirm(`确定要将${checkedRows.value.map((item) => item.name).join(',')}解除关联吗?`);
} catch {
return false;
}

View File

@ -102,9 +102,7 @@ function handleTransfer() {
/** 锁定客户 */
async function handleLock(lockStatus: boolean): Promise<boolean | undefined> {
try {
await confirm({
content: `确定锁定客户【${customer.value.name}】吗?`,
});
await confirm(`确定锁定客户【${customer.value.name}】吗?`);
} catch {
return false;
}
@ -118,9 +116,7 @@ async function handleLock(lockStatus: boolean): Promise<boolean | undefined> {
/** 领取客户 */
async function handleReceive(): Promise<boolean | undefined> {
try {
await confirm({
content: `确定领取客户【${customer.value.name}】吗?`,
});
await confirm(`确定领取客户【${customer.value.name}】吗?`);
} catch {
return false;
}
@ -139,9 +135,7 @@ function handleDistributeForm() {
/** 客户放入公海 */
async function handlePutPool(): Promise<boolean | undefined> {
try {
await confirm({
content: `确定将客户【${customer.value.name}】放入公海吗?`,
});
await confirm(`确定将客户【${customer.value.name}】放入公海吗?`);
} catch {
return false;
}
@ -156,9 +150,7 @@ async function handlePutPool(): Promise<boolean | undefined> {
async function handleUpdateDealStatus(): Promise<boolean | undefined> {
const dealStatus = !customer.value.dealStatus;
try {
await confirm({
content: `确定更新成交状态为【${dealStatus ? '已成交' : '未成交'}】吗?`,
});
await confirm(`确定更新成交状态为【${dealStatus ? '已成交' : '未成交'}】吗?`);
} catch {
return false;
}

View File

@ -100,9 +100,7 @@ async function handleDelete() {
return;
}
try {
await confirm({
content: `你要将${checkedRows.value.map((item) => item.nickname).join(',')}移出团队吗?`,
});
await confirm(`你要将${checkedRows.value.map((item) => item.nickname).join(',')}移出团队吗?`);
} catch {
return false;
}

View File

@ -100,7 +100,6 @@ const [Modal, modalApi] = useVbenModal({
},
async onOpenChange(isOpen: boolean) {
if (!isOpen) {
await formApi.resetForm();
return;
}
//

View File

@ -67,9 +67,7 @@ async function handleDefaultStatusChange(
): Promise<boolean | undefined> {
const text = newStatus ? '设置' : '取消';
try {
await confirm({
content: `确认要${text}"${row.name}"默认吗?`,
});
await confirm(`确认要${text}"${row.name}"默认吗?`);
} catch {
return false;
}

View File

@ -65,9 +65,7 @@ async function handleDefaultStatusChange(
): Promise<boolean | undefined> {
const text = newStatus ? '设置' : '取消';
try {
await confirm({
content: `确认要${text}"${row.name}"默认吗?`,
});
await confirm(`确认要${text}"${row.name}"默认吗?`);
} catch {
return false;
}

View File

@ -42,9 +42,7 @@ function handleDetail(row: InfraApiErrorLogApi.ApiErrorLog) {
/** 处理已处理 / 已忽略的操作 */
async function handleProcess(id: number, processStatus: number) {
await confirm({
content: `确认标记为${InfraApiErrorLogProcessStatusEnum.DONE ? '已处理' : '已忽略'}?`,
});
await confirm(`确认标记为${InfraApiErrorLogProcessStatusEnum.DONE ? '已处理' : '已忽略'}?`);
const hideLoading = message.loading({
content: '正在处理中...',
duration: 0,

View File

@ -285,7 +285,7 @@ function handleEditPoint(row: IotDeviceModbusPointApi.ModbusPoint) {
/** 删除点位 */
async function handleDeletePoint(row: IotDeviceModbusPointApi.ModbusPoint) {
await confirm({ content: `确定要删除点位【${row.name}】吗?` });
await confirm(`确定要删除点位【${row.name}】吗?`);
await deleteModbusPoint(row.id!);
message.success('删除成功');
await gridApi.query();

View File

@ -126,7 +126,7 @@ function handleRowCheckboxChange({
/** 解绑单个设备 */
async function handleUnbind(row: IotDeviceApi.Device) {
await confirm({ content: `确定要解绑子设备【${row.deviceName}】吗?` });
await confirm(`确定要解绑子设备【${row.deviceName}】吗?`);
const hideLoading = message.loading({
content: `正在解绑【${row.deviceName}】...`,
duration: 0,
@ -142,9 +142,7 @@ async function handleUnbind(row: IotDeviceApi.Device) {
/** 批量解绑 */
async function handleUnbindBatch() {
await confirm({
content: `确定要解绑选中的 ${checkedIds.value.length} 个子设备吗?`,
});
await confirm(`确定要解绑选中的 ${checkedIds.value.length} 个子设备吗?`);
const hideLoading = message.loading({
content: '正在批量解绑...',
duration: 0,

View File

@ -1,4 +1,4 @@
import type { VbenFormSchema } from '#/adapter/form';
import type { VbenFormApi, VbenFormSchema } from '#/adapter/form';
import type { VxeTableGridOptions } from '#/adapter/vxe-table';
import type { IotProductApi } from '#/api/iot/product/product';
@ -14,7 +14,7 @@ import { getSimpleProductCategoryList } from '#/api/iot/product/category';
/** 基础表单字段(不含图标、图片、描述) */
export function useBasicFormSchema(
formApi?: any,
formApi?: VbenFormApi,
generateProductKey?: () => string,
): VbenFormSchema[] {
return [

View File

@ -60,9 +60,6 @@ const [AdvancedForm, advancedFormApi] = useVbenForm({
showDefaultActions: false,
});
/** 基础表单需要 formApi 引用,所以通过 setState 设置 schema */
formApi.setState({ schema: useBasicFormSchema(formApi, generateProductKey) });
/** 获取高级表单的值(如果表单未挂载,则从 formData 中获取) */
async function getAdvancedFormValues() {
if (advancedFormApi.isMounted) {
@ -106,6 +103,9 @@ const [Modal, modalApi] = useVbenModal({
activeKey.value = [];
return;
}
formApi.setState({
schema: useBasicFormSchema(formApi, generateProductKey),
});
//
const data = modalApi.getData<IotProductApi.Product>();
if (!data || !data.id) {

View File

@ -69,7 +69,6 @@ const [Modal, modalApi] = useVbenModal({
async onOpenChange(isOpen: boolean) {
if (!isOpen) {
formData.value = undefined;
await formApi.resetForm();
sourceConfigRef.value?.setData([]);
return;
}

View File

@ -65,9 +65,7 @@ async function handleStatusChange(
): Promise<boolean | undefined> {
const text = newStatus ? '展示' : '隐藏';
try {
await confirm({
content: `确认要${text}该评论吗?`,
});
await confirm(`确认要${text}该评论吗?`);
} catch {
return false;
}

View File

@ -134,7 +134,6 @@ const [Modal, modalApi] = useVbenModal({
if (!isOpen) {
return;
}
await formApi.resetForm();
},
});
</script>

View File

@ -110,9 +110,7 @@ async function handleStatusChange(
//
const text = newStatus ? '上架' : '下架';
try {
await confirm({
content: `确认要${text + row.name}吗?`,
});
await confirm(`确认要${text + row.name}吗?`);
} catch {
return false;
}
@ -132,9 +130,7 @@ async function handleStatus02Change(row: MallSpuApi.Spu, newStatus: number) {
newStatus === ProductSpuStatusEnum.RECYCLE.status
? '加入到回收站'
: '恢复到仓库';
await confirm({
content: `确认要"${row.name}"${text}吗?`,
});
await confirm(`确认要"${row.name}"${text}吗?`);
const hideLoading = message.loading({
content: `正在${text}中...`,
duration: 0,

View File

@ -61,9 +61,7 @@ async function handleStatusChange(
row: MallCouponTemplateApi.CouponTemplate,
): Promise<boolean | undefined> {
try {
await confirm({
content: `你要将${row.name}的状态切换为【${newStatus === CommonStatusEnum.ENABLE ? '启用' : '停用'}】吗?`,
});
await confirm(`你要将${row.name}的状态切换为【${newStatus === CommonStatusEnum.ENABLE ? '启用' : '停用'}】吗?`);
} catch {
return false;
}

View File

@ -7,7 +7,7 @@ import type {
SpuProperty,
} from '#/views/mall/product/spu/components';
import { computed, nextTick, ref } from 'vue';
import { computed, ref } from 'vue';
import { useVbenForm, useVbenModal } from '@vben/common-ui';
import { PromotionDiscountTypeEnum } from '@vben/constants';
@ -213,13 +213,11 @@ function handleSkuDiscountPercentChange(row: SkuExtension) {
}
/** 重置表单 */
async function resetForm() {
function resetForm() {
spuList.value = [];
spuPropertyList.value = [];
spuIdList.value = [];
formData.value = {};
await nextTick();
await formApi.resetForm();
}
// ================= =================
@ -264,7 +262,7 @@ const [Modal, modalApi] = useVbenModal({
},
async onOpenChange(isOpen: boolean) {
if (!isOpen) {
await resetForm();
resetForm();
return;
}
//

View File

@ -4,6 +4,7 @@ import type { MallKefuConversationApi } from '#/api/mall/promotion/kefu/conversa
import { onBeforeUnmount, onMounted, ref, watch } from 'vue';
import { Page } from '@vben/common-ui';
import { WebSocketMessageTypeConstants } from '@vben/constants';
import { useAccessStore } from '@vben/stores';
import { useWebSocket } from '@vueuse/core';
@ -14,7 +15,6 @@ import { useMallKefuStore } from '#/store/mall/kefu';
import ConversationList from './modules/conversation-list.vue';
import MemberInfo from './modules/member/member-info.vue';
import MessageList from './modules/message-list.vue';
import { WebSocketMessageTypeConstants } from './modules/tools/constants';
const accessStore = useAccessStore();
const kefuStore = useMallKefuStore(); //

View File

@ -4,6 +4,7 @@ import type { MallKefuConversationApi } from '#/api/mall/promotion/kefu/conversa
import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue';
import { confirm } from '@vben/common-ui';
import { KeFuMessageContentTypeEnum } from '@vben/constants';
import { IconifyIcon } from '@vben/icons';
import { formatPast, jsonParse } from '@vben/utils';
@ -15,7 +16,6 @@ import {
} from '#/api/mall/promotion/kefu/conversation';
import { useMallKefuStore } from '#/store/mall/kefu';
import { KeFuMessageContentTypeEnum } from './tools/constants';
import { useEmoji } from './tools/emoji';
/** 打开右侧的消息列表 */
@ -125,9 +125,7 @@ async function updateConversationPinnedFn(pinned: boolean) {
/** 删除会话 */
async function deleteConversationFn() {
// 1.
confirm({
content: '您确定要删除该会话吗?',
}).then(async () => {
confirm('您确定要删除该会话吗?').then(async () => {
await deleteConversation(rightClickConversation.value.id);
// 2.
closeRightMenu();

View File

@ -4,7 +4,7 @@ import type { Emoji } from './tools/emoji';
import type { MallKefuConversationApi } from '#/api/mall/promotion/kefu/conversation';
import type { MallKefuMessageApi } from '#/api/mall/promotion/kefu/message';
import { computed, reactive, ref, toRefs, unref, watch } from 'vue';
import { computed, KeFuMessageContentTypeEnum, reactive, ref, toRefs, unref, watch } from 'vue';
import { UserTypeEnum } from '@vben/constants';
import { IconifyIcon } from '@vben/icons';
@ -25,7 +25,6 @@ import { useMallKefuStore } from '#/store/mall/kefu';
import MessageItem from './message/message-item.vue';
import OrderItem from './message/order-item.vue';
import ProductItem from './message/product-item.vue';
import { KeFuMessageContentTypeEnum } from './tools/constants';
import { useEmoji } from './tools/emoji';
import EmojiSelectPopover from './tools/emoji-select-popover.vue';
import PictureSelectUpload from './tools/picture-select-upload.vue';

View File

@ -1,17 +0,0 @@
/** 客服消息类型枚举类 */
export const KeFuMessageContentTypeEnum = {
TEXT: 1, // 文本消息
IMAGE: 2, // 图片消息
VOICE: 3, // 语音消息
VIDEO: 4, // 视频消息
SYSTEM: 5, // 系统消息
// ========== 商城特殊消息 ==========
PRODUCT: 10, // 商品消息
ORDER: 11, // 订单消息"
};
/** Promotion 的 WebSocket 消息类型枚举类 */
export const WebSocketMessageTypeConstants = {
KEFU_MESSAGE_TYPE: 'kefu_message_type', // 客服消息类型
KEFU_MESSAGE_ADMIN_READ: 'kefu_message_read_status_change', // 客服消息管理员已读
};

View File

@ -62,9 +62,7 @@ async function handleStatusChange(
//
const text = row.status === 0 ? '启用' : '停用';
try {
await confirm({
content: `确认要${text + row.name}吗?`,
});
await confirm(`确认要${text + row.name}吗?`);
} catch {
return false;
}

View File

@ -104,9 +104,7 @@ async function loadProductStatisticsList() {
async function handleExport() {
try {
//
await confirm({
content: '确认导出商品状况数据吗?',
});
await confirm('确认导出商品状况数据吗?');
//
exportLoading.value = true;
const data = await exportProductStatisticsExcel({

View File

@ -107,9 +107,7 @@ async function loadTradeStatisticsList() {
async function handleExport() {
try {
//
await confirm({
content: '确认导出交易状况数据吗?',
});
await confirm('确认导出交易状况数据吗?');
//
exportLoading.value = true;
const data = await exportTradeStatisticsExcel({

View File

@ -89,9 +89,7 @@ async function handleBrokerageEnabledChange(
): Promise<boolean | undefined> {
const text = newEnabled ? '开通' : '关闭';
try {
await confirm({
content: `你要将${row.nickname}的推广资格切换为【${text}】吗?`,
});
await confirm(`你要将${row.nickname}的推广资格切换为【${text}】吗?`);
} catch {
return false;
}

View File

@ -3,12 +3,12 @@ import type { MesCalCalendarApi } from '#/api/mes/cal/calendar';
import { computed } from 'vue';
import { MesCalShiftTypeEnum } from '@vben/constants';
import { Tag } from 'ant-design-vue';
import dayjs from 'dayjs';
import { SolarDay } from 'tyme4ts';
import { MesCalShiftTypeEnum } from '#/views/mes/utils/constants';
const props = defineProps<{
calendarDayMap: Map<string, MesCalCalendarApi.CalendarDay>; //
day: string; // yyyy-MM-dd

Some files were not shown because too many files have changed in this diff Show More