feat(web-antdv-next): migrate MES module

pull/355/head
XuZhiqiang 2026-06-04 16:08:03 +08:00
parent 82b22173c0
commit 6315055c08
550 changed files with 80294 additions and 0 deletions

View File

@ -54,12 +54,14 @@
"camunda-bpmn-moddle": "catalog:",
"cropperjs": "catalog:",
"dayjs": "catalog:",
"dhtmlx-gantt": "catalog:",
"diagram-js": "catalog:",
"fast-xml-parser": "catalog:",
"highlight.js": "catalog:",
"pinia": "catalog:",
"steady-xml": "catalog:",
"tinymce": "catalog:",
"tyme4ts": "catalog:",
"video.js": "catalog:",
"vue": "catalog:",
"vue-dompurify-html": "catalog:",

View File

@ -0,0 +1,27 @@
import { requestClient } from '#/api/request';
export namespace MesCalCalendarApi {
/** 排班日历班组排班项 */
export interface CalendarTeamShiftItem {
teamId?: number; // 班组编号
teamName?: string; // 班组名称
shiftId?: number; // 班次编号
shiftName?: string; // 班次名称
sort?: number; // 排序
}
/** 排班日历天 */
export interface CalendarDay {
day?: string; // 日期
shiftType?: number; // 轮班方式
teamShifts?: CalendarTeamShiftItem[]; // 班组班次
}
}
/** 查询排班日历列表 */
export function getCalendarList(params: any) {
return requestClient.get<MesCalCalendarApi.CalendarDay[]>(
'/mes/cal/calendar/list',
{ params },
);
}

View File

@ -0,0 +1,39 @@
import { requestClient } from '#/api/request';
export namespace MesCalHolidayApi {
/** MES 假期设置 */
export interface Holiday {
id?: number; // 编号
day?: number | string; // 日期
type?: number; // 日期类型
remark?: string; // 备注
createTime?: Date; // 创建时间
}
/** 假期查询参数 */
export interface HolidayQuery {
startDay?: string;
endDay?: string;
}
}
/** 查询假期设置列表 */
export function getHolidayList(params?: MesCalHolidayApi.HolidayQuery) {
return requestClient.get<MesCalHolidayApi.Holiday[]>(
'/mes/cal/holiday/list',
{ params },
);
}
/** 根据日期查询假期设置 */
export function getHolidayByDay(day: string) {
return requestClient.get<MesCalHolidayApi.Holiday>(
'/mes/cal/holiday/get-by-day',
{ params: { day } },
);
}
/** 保存假期设置 */
export function saveHoliday(data: MesCalHolidayApi.Holiday) {
return requestClient.post('/mes/cal/holiday/save', data);
}

View File

@ -0,0 +1,59 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesCalPlanApi {
/** MES 排班计划 */
export interface Plan {
id?: number; // 计划编号
code?: string; // 计划编码
name?: string; // 计划名称
calendarType?: number; // 班组类型
startDate?: number; // 开始日期
endDate?: number; // 结束日期
shiftType?: number; // 轮班方式
shiftMethod?: number; // 倒班方式
shiftCount?: number; // 倒班天数
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询排班计划分页 */
export function getPlanPage(params: PageParam) {
return requestClient.get<PageResult<MesCalPlanApi.Plan>>(
'/mes/cal/plan/page',
{ params },
);
}
/** 查询排班计划详情 */
export function getPlan(id: number) {
return requestClient.get<MesCalPlanApi.Plan>(`/mes/cal/plan/get?id=${id}`);
}
/** 新增排班计划 */
export function createPlan(data: MesCalPlanApi.Plan) {
return requestClient.post<number>('/mes/cal/plan/create', data);
}
/** 修改排班计划 */
export function updatePlan(data: MesCalPlanApi.Plan) {
return requestClient.put('/mes/cal/plan/update', data);
}
/** 确认排班计划 */
export function confirmPlan(id: number) {
return requestClient.put(`/mes/cal/plan/confirm?id=${id}`);
}
/** 删除排班计划 */
export function deletePlan(id: number) {
return requestClient.delete(`/mes/cal/plan/delete?id=${id}`);
}
/** 导出排班计划 */
export function exportPlan(params: any) {
return requestClient.download('/mes/cal/plan/export-excel', { params });
}

View File

@ -0,0 +1,36 @@
import { requestClient } from '#/api/request';
export namespace MesCalPlanShiftApi {
/** MES 计划班次 */
export interface PlanShift {
id?: number; // 班次编号
planId?: number; // 排班计划编号
sort?: number; // 显示顺序
name?: string; // 班次名称
startTime?: string; // 开始时间
endTime?: string; // 结束时间
remark?: string; // 备注
}
}
/** 查询指定排班计划的班次列表 */
export function getPlanShiftListByPlan(planId: number) {
return requestClient.get<MesCalPlanShiftApi.PlanShift[]>(
`/mes/cal/plan-shift/list-by-plan?planId=${planId}`,
);
}
/** 新增计划班次 */
export function createPlanShift(data: MesCalPlanShiftApi.PlanShift) {
return requestClient.post('/mes/cal/plan-shift/create', data);
}
/** 修改计划班次 */
export function updatePlanShift(data: MesCalPlanShiftApi.PlanShift) {
return requestClient.put('/mes/cal/plan-shift/update', data);
}
/** 删除计划班次 */
export function deletePlanShift(id: number) {
return requestClient.delete(`/mes/cal/plan-shift/delete?id=${id}`);
}

View File

@ -0,0 +1,30 @@
import { requestClient } from '#/api/request';
export namespace MesCalPlanTeamApi {
/** MES 计划班组关联 */
export interface PlanTeam {
id?: number; // 关联编号
planId?: number; // 排班计划编号
teamId?: number; // 班组编号
teamCode?: string; // 班组编码
teamName?: string; // 班组名称
remark?: string; // 备注
}
}
/** 查询指定排班计划的班组列表 */
export function getPlanTeamListByPlan(planId: number) {
return requestClient.get<MesCalPlanTeamApi.PlanTeam[]>(
`/mes/cal/plan-team/list-by-plan?planId=${planId}`,
);
}
/** 新增计划班组关联 */
export function createPlanTeam(data: MesCalPlanTeamApi.PlanTeam) {
return requestClient.post('/mes/cal/plan-team/create', data);
}
/** 删除计划班组关联 */
export function deletePlanTeam(id: number) {
return requestClient.delete(`/mes/cal/plan-team/delete?id=${id}`);
}

View File

@ -0,0 +1,53 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesCalTeamApi {
/** MES 班组 */
export interface Team {
id?: number; // 班组编号
code?: string; // 班组编码
name?: string; // 班组名称
calendarType?: number; // 班组类型
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询班组分页 */
export function getTeamPage(params: PageParam) {
return requestClient.get<PageResult<MesCalTeamApi.Team>>(
'/mes/cal/team/page',
{ params },
);
}
/** 查询班组列表 */
export function getTeamList() {
return requestClient.get<MesCalTeamApi.Team[]>('/mes/cal/team/list');
}
/** 查询班组详情 */
export function getTeam(id: number) {
return requestClient.get<MesCalTeamApi.Team>(`/mes/cal/team/get?id=${id}`);
}
/** 新增班组 */
export function createTeam(data: MesCalTeamApi.Team) {
return requestClient.post('/mes/cal/team/create', data);
}
/** 修改班组 */
export function updateTeam(data: MesCalTeamApi.Team) {
return requestClient.put('/mes/cal/team/update', data);
}
/** 删除班组 */
export function deleteTeam(id: number) {
return requestClient.delete(`/mes/cal/team/delete?id=${id}`);
}
/** 导出班组 */
export function exportTeam(params: any) {
return requestClient.download('/mes/cal/team/export-excel', { params });
}

View File

@ -0,0 +1,51 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesCalTeamMemberApi {
/** MES 班组成员 */
export interface TeamMember {
id?: number; // 成员编号
teamId?: number; // 班组编号
userId?: number; // 用户编号
nickname?: string; // 用户昵称
telephone?: string; // 用户手机号
remark?: string; // 备注
}
}
/** 创建班组成员 */
export function createTeamMember(data: MesCalTeamMemberApi.TeamMember) {
return requestClient.post('/mes/cal/team-member/create', data);
}
/** 删除班组成员 */
export function deleteTeamMember(id: number) {
return requestClient.delete(`/mes/cal/team-member/delete?id=${id}`);
}
/** 查询班组成员分页 */
export function getTeamMemberPage(params: PageParam) {
return requestClient.get<PageResult<MesCalTeamMemberApi.TeamMember>>(
'/mes/cal/team-member/page',
{ params },
);
}
/** 查询指定班组的成员列表 */
export function getTeamMemberListByTeam(teamId: number) {
return requestClient.get<MesCalTeamMemberApi.TeamMember[]>(
'/mes/cal/team-member/list-by-team',
{ params: { teamId } },
);
}
/** 查询多个班组的成员列表 */
export function getTeamMemberListByTeamIds(teamIds: number[]) {
return requestClient.get<MesCalTeamMemberApi.TeamMember[]>(
'/mes/cal/team-member/list-by-team',
{
params: { teamIds: teamIds.join(',') },
},
);
}

View File

@ -0,0 +1,65 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesDvCheckPlanApi {
/** MES 点检保养方案 */
export interface CheckPlan {
id?: number; // 方案编号
code?: string; // 方案编码
name?: string; // 方案名称
type?: number; // 方案类型
startDate?: Date | number; // 开始日期
endDate?: Date | number; // 结束日期
cycleType?: number; // 周期类型
cycleCount?: number; // 周期数量
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询点检保养方案分页 */
export function getCheckPlanPage(params: PageParam) {
return requestClient.get<PageResult<MesDvCheckPlanApi.CheckPlan>>(
'/mes/dv/check-plan/page',
{ params },
);
}
/** 查询点检保养方案详情 */
export function getCheckPlan(id: number) {
return requestClient.get<MesDvCheckPlanApi.CheckPlan>(
`/mes/dv/check-plan/get?id=${id}`,
);
}
/** 新增点检保养方案 */
export function createCheckPlan(data: MesDvCheckPlanApi.CheckPlan) {
return requestClient.post<number>('/mes/dv/check-plan/create', data);
}
/** 修改点检保养方案 */
export function updateCheckPlan(data: MesDvCheckPlanApi.CheckPlan) {
return requestClient.put('/mes/dv/check-plan/update', data);
}
/** 启用点检保养方案 */
export function enableCheckPlan(id: number) {
return requestClient.put(`/mes/dv/check-plan/enable?id=${id}`);
}
/** 停用点检保养方案 */
export function disableCheckPlan(id: number) {
return requestClient.put(`/mes/dv/check-plan/disable?id=${id}`);
}
/** 删除点检保养方案 */
export function deleteCheckPlan(id: number) {
return requestClient.delete(`/mes/dv/check-plan/delete?id=${id}`);
}
/** 导出点检保养方案 */
export function exportCheckPlan(params: any) {
return requestClient.download('/mes/dv/check-plan/export-excel', { params });
}

View File

@ -0,0 +1,34 @@
import { requestClient } from '#/api/request';
export namespace MesDvCheckPlanMachineryApi {
/** MES 点检保养方案设备 */
export interface CheckPlanMachinery {
id?: number; // 关联编号
planId?: number; // 方案编号
machineryId?: number; // 设备编号
machineryCode?: string; // 设备编码
machineryName?: string; // 设备名称
machineryBrand?: string; // 品牌
machinerySpecification?: string; // 规格型号
remark?: string; // 备注
}
}
/** 查询指定方案的设备列表 */
export function getCheckPlanMachineryListByPlan(planId: number) {
return requestClient.get<MesDvCheckPlanMachineryApi.CheckPlanMachinery[]>(
`/mes/dv/check-plan-machinery/list-by-plan?planId=${planId}`,
);
}
/** 新增方案设备关联 */
export function createCheckPlanMachinery(
data: MesDvCheckPlanMachineryApi.CheckPlanMachinery,
) {
return requestClient.post('/mes/dv/check-plan-machinery/create', data);
}
/** 删除方案设备关联 */
export function deleteCheckPlanMachinery(id: number) {
return requestClient.delete(`/mes/dv/check-plan-machinery/delete?id=${id}`);
}

View File

@ -0,0 +1,35 @@
import { requestClient } from '#/api/request';
export namespace MesDvCheckPlanSubjectApi {
/** MES 点检保养方案项目 */
export interface CheckPlanSubject {
id?: number; // 关联编号
planId?: number; // 方案编号
subjectId?: number; // 项目编号
subjectCode?: string; // 项目编码
subjectName?: string; // 项目名称
subjectType?: number; // 项目类型
subjectContent?: string; // 项目内容
subjectStandard?: string; // 标准
remark?: string; // 备注
}
}
/** 查询指定方案的项目列表 */
export function getCheckPlanSubjectListByPlan(planId: number) {
return requestClient.get<MesDvCheckPlanSubjectApi.CheckPlanSubject[]>(
`/mes/dv/check-plan-subject/list-by-plan?planId=${planId}`,
);
}
/** 新增方案项目关联 */
export function createCheckPlanSubject(
data: MesDvCheckPlanSubjectApi.CheckPlanSubject,
) {
return requestClient.post('/mes/dv/check-plan-subject/create', data);
}
/** 删除方案项目关联 */
export function deleteCheckPlanSubject(id: number) {
return requestClient.delete(`/mes/dv/check-plan-subject/delete?id=${id}`);
}

View File

@ -0,0 +1,65 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesDvCheckRecordApi {
/** MES 设备点检记录 */
export interface CheckRecord {
id?: number; // 记录编号
planId?: number; // 点检计划编号
planName?: string; // 计划名称
machineryId?: number; // 设备编号
machineryCode?: string; // 设备编码
machineryName?: string; // 设备名称
machineryBrand?: string; // 品牌
machinerySpecification?: string; // 规格型号
checkTime?: Date | number; // 点检时间
userId?: number; // 点检人编号
nickname?: string; // 点检人名称
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询设备点检记录分页 */
export function getCheckRecordPage(params: PageParam) {
return requestClient.get<PageResult<MesDvCheckRecordApi.CheckRecord>>(
'/mes/dv/check-record/page',
{ params },
);
}
/** 查询设备点检记录详情 */
export function getCheckRecord(id: number) {
return requestClient.get<MesDvCheckRecordApi.CheckRecord>(
`/mes/dv/check-record/get?id=${id}`,
);
}
/** 新增设备点检记录 */
export function createCheckRecord(data: MesDvCheckRecordApi.CheckRecord) {
return requestClient.post<number>('/mes/dv/check-record/create', data);
}
/** 修改设备点检记录 */
export function updateCheckRecord(data: MesDvCheckRecordApi.CheckRecord) {
return requestClient.put('/mes/dv/check-record/update', data);
}
/** 提交设备点检记录 */
export function submitCheckRecord(id: number) {
return requestClient.put(`/mes/dv/check-record/submit?id=${id}`);
}
/** 删除设备点检记录 */
export function deleteCheckRecord(id: number) {
return requestClient.delete(`/mes/dv/check-record/delete?id=${id}`);
}
/** 导出设备点检记录 */
export function exportCheckRecord(params: any) {
return requestClient.download('/mes/dv/check-record/export-excel', {
params,
});
}

View File

@ -0,0 +1,53 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesDvCheckRecordLineApi {
/** MES 设备点检记录明细 */
export interface CheckRecordLine {
id?: number; // 明细编号
recordId?: number; // 点检记录编号
subjectId?: number; // 点检项目编号
subjectCode?: string; // 项目编码
subjectName?: string; // 项目名称
subjectContent?: string; // 检查内容
subjectStandard?: string; // 检查标准
checkStatus?: number; // 点检结果
checkResult?: string; // 异常描述
remark?: string; // 备注
}
}
/** 查询设备点检记录明细分页 */
export function getCheckRecordLinePage(params: PageParam) {
return requestClient.get<PageResult<MesDvCheckRecordLineApi.CheckRecordLine>>(
'/mes/dv/check-record-line/page',
{ params },
);
}
/** 查询设备点检记录明细详情 */
export function getCheckRecordLine(id: number) {
return requestClient.get<MesDvCheckRecordLineApi.CheckRecordLine>(
`/mes/dv/check-record-line/get?id=${id}`,
);
}
/** 新增设备点检记录明细 */
export function createCheckRecordLine(
data: MesDvCheckRecordLineApi.CheckRecordLine,
) {
return requestClient.post('/mes/dv/check-record-line/create', data);
}
/** 修改设备点检记录明细 */
export function updateCheckRecordLine(
data: MesDvCheckRecordLineApi.CheckRecordLine,
) {
return requestClient.put('/mes/dv/check-record-line/update', data);
}
/** 删除设备点检记录明细 */
export function deleteCheckRecordLine(id: number) {
return requestClient.delete(`/mes/dv/check-record-line/delete?id=${id}`);
}

View File

@ -0,0 +1,85 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesDvMachineryApi {
/** MES 设备台账 */
export interface Machinery {
id?: number; // 设备编号
code?: string; // 设备编码
name?: string; // 设备名称
brand?: string; // 品牌
specification?: string; // 规格型号
machineryTypeId?: number; // 设备类型编号
machineryTypeName?: string; // 设备类型名称
workshopId?: number; // 所属车间编号
workshopName?: string; // 所属车间名称
status?: number; // 设备状态
lastMaintenTime?: Date; // 最近保养时间
lastCheckTime?: Date; // 最近点检时间
remark?: string; // 备注
createTime?: Date; // 创建时间
}
/** 设备导入结果 */
export interface MachineryImportRespVO {
createCodes?: string[]; // 新增成功的设备编码
updateCodes?: string[]; // 更新成功的设备编码
failureCodes?: Record<string, string>; // 导入失败的设备编码及原因
}
}
/** 查询设备分页 */
export function getMachineryPage(params: PageParam) {
return requestClient.get<PageResult<MesDvMachineryApi.Machinery>>(
'/mes/dv/machinery/page',
{ params },
);
}
/** 查询设备精简列表 */
export function getMachinerySimpleList() {
return requestClient.get<MesDvMachineryApi.Machinery[]>(
'/mes/dv/machinery/simple-list',
);
}
/** 查询设备详情 */
export function getMachinery(id: number) {
return requestClient.get<MesDvMachineryApi.Machinery>(
`/mes/dv/machinery/get?id=${id}`,
);
}
/** 新增设备 */
export function createMachinery(data: MesDvMachineryApi.Machinery) {
return requestClient.post('/mes/dv/machinery/create', data);
}
/** 修改设备 */
export function updateMachinery(data: MesDvMachineryApi.Machinery) {
return requestClient.put('/mes/dv/machinery/update', data);
}
/** 删除设备 */
export function deleteMachinery(id: number) {
return requestClient.delete(`/mes/dv/machinery/delete?id=${id}`);
}
/** 导出设备 */
export function exportMachinery(params: any) {
return requestClient.download('/mes/dv/machinery/export-excel', { params });
}
/** 下载设备导入模板 */
export function importMachineryTemplate() {
return requestClient.download('/mes/dv/machinery/get-import-template');
}
/** 导入设备 */
export function importMachinery(file: File, updateSupport: boolean) {
return requestClient.upload<MesDvMachineryApi.MachineryImportRespVO>(
`/mes/dv/machinery/import?updateSupport=${updateSupport}`,
{ file },
);
}

View File

@ -0,0 +1,53 @@
import { requestClient } from '#/api/request';
export namespace MesDvMachineryTypeApi {
/** MES 设备类型 */
export interface MachineryType {
id?: number; // 设备类型编号
parentId?: number; // 父类型编号
code?: string; // 类型编码
name?: string; // 类型名称
sort?: number; // 显示排序
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
children?: MachineryType[]; // 子类型
}
}
/** 查询设备类型列表 */
export function getMachineryTypeList(params?: any) {
return requestClient.get<MesDvMachineryTypeApi.MachineryType[]>(
'/mes/dv/machinery-type/list',
{ params },
);
}
/** 查询设备类型精简列表 */
export function getMachineryTypeSimpleList() {
return requestClient.get<MesDvMachineryTypeApi.MachineryType[]>(
'/mes/dv/machinery-type/simple-list',
);
}
/** 查询设备类型详情 */
export function getMachineryType(id: number) {
return requestClient.get<MesDvMachineryTypeApi.MachineryType>(
`/mes/dv/machinery-type/get?id=${id}`,
);
}
/** 新增设备类型 */
export function createMachineryType(data: MesDvMachineryTypeApi.MachineryType) {
return requestClient.post('/mes/dv/machinery-type/create', data);
}
/** 修改设备类型 */
export function updateMachineryType(data: MesDvMachineryTypeApi.MachineryType) {
return requestClient.put('/mes/dv/machinery-type/update', data);
}
/** 删除设备类型 */
export function deleteMachineryType(id: number) {
return requestClient.delete(`/mes/dv/machinery-type/delete?id=${id}`);
}

View File

@ -0,0 +1,65 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesDvMaintenRecordApi {
/** MES 设备保养记录 */
export interface MaintenRecord {
id?: number; // 记录编号
planId?: number; // 计划编号
planName?: string; // 计划名称
machineryId?: number; // 设备编号
machineryCode?: string; // 设备编码
machineryName?: string; // 设备名称
machineryBrand?: string; // 品牌
machinerySpecification?: string; // 规格型号
maintenTime?: Date | number; // 保养时间
userId?: number; // 用户编号
nickname?: string; // 保养人名称
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询设备保养记录分页 */
export function getMaintenRecordPage(params: PageParam) {
return requestClient.get<PageResult<MesDvMaintenRecordApi.MaintenRecord>>(
'/mes/dv/mainten-record/page',
{ params },
);
}
/** 查询设备保养记录详情 */
export function getMaintenRecord(id: number) {
return requestClient.get<MesDvMaintenRecordApi.MaintenRecord>(
`/mes/dv/mainten-record/get?id=${id}`,
);
}
/** 新增设备保养记录 */
export function createMaintenRecord(data: MesDvMaintenRecordApi.MaintenRecord) {
return requestClient.post<number>('/mes/dv/mainten-record/create', data);
}
/** 修改设备保养记录 */
export function updateMaintenRecord(data: MesDvMaintenRecordApi.MaintenRecord) {
return requestClient.put('/mes/dv/mainten-record/update', data);
}
/** 提交设备保养记录 */
export function submitMaintenRecord(id: number) {
return requestClient.put(`/mes/dv/mainten-record/submit?id=${id}`);
}
/** 删除设备保养记录 */
export function deleteMaintenRecord(id: number) {
return requestClient.delete(`/mes/dv/mainten-record/delete?id=${id}`);
}
/** 导出设备保养记录 */
export function exportMaintenRecord(params: any) {
return requestClient.download('/mes/dv/mainten-record/export-excel', {
params,
});
}

View File

@ -0,0 +1,51 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesDvMaintenRecordLineApi {
/** MES 设备保养记录明细 */
export interface MaintenRecordLine {
id?: number; // 明细编号
recordId?: number; // 保养记录编号
subjectId?: number; // 项目编号
subjectName?: string; // 项目名称
subjectContent?: string; // 项目内容
subjectStandard?: string; // 项目标准
status?: number; // 保养结果
result?: string; // 异常描述
remark?: string; // 备注
}
}
/** 查询设备保养记录明细分页 */
export function getMaintenRecordLinePage(params: PageParam) {
return requestClient.get<
PageResult<MesDvMaintenRecordLineApi.MaintenRecordLine>
>('/mes/dv/mainten-record-line/page', { params });
}
/** 查询设备保养记录明细详情 */
export function getMaintenRecordLine(id: number) {
return requestClient.get<MesDvMaintenRecordLineApi.MaintenRecordLine>(
`/mes/dv/mainten-record-line/get?id=${id}`,
);
}
/** 新增设备保养记录明细 */
export function createMaintenRecordLine(
data: MesDvMaintenRecordLineApi.MaintenRecordLine,
) {
return requestClient.post('/mes/dv/mainten-record-line/create', data);
}
/** 修改设备保养记录明细 */
export function updateMaintenRecordLine(
data: MesDvMaintenRecordLineApi.MaintenRecordLine,
) {
return requestClient.put('/mes/dv/mainten-record-line/update', data);
}
/** 删除设备保养记录明细 */
export function deleteMaintenRecordLine(id: number) {
return requestClient.delete(`/mes/dv/mainten-record-line/delete?id=${id}`);
}

View File

@ -0,0 +1,81 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesDvRepairApi {
/** MES 维修工单 */
export interface Repair {
id?: number; // 工单编号
code?: string; // 维修工单编码
name?: string; // 维修工单名称
machineryId?: number; // 设备编号
machineryCode?: string; // 设备编码
machineryName?: string; // 设备名称
machineryBrand?: string; // 品牌
machinerySpecification?: string; // 规格型号
requireDate?: Date | number; // 报修日期
finishDate?: Date | number; // 维修完成日期
confirmDate?: Date | number; // 验收日期
result?: number; // 维修结果
acceptedUserId?: number; // 维修人编号
acceptedUserNickname?: string; // 维修人名称
confirmUserId?: number; // 验收人编号
confirmUserNickname?: string; // 验收人名称
sourceDocType?: number; // 来源单据类型
sourceDocId?: number; // 来源单据编号
sourceDocCode?: string; // 来源单据编码
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询维修工单分页 */
export function getRepairPage(params: PageParam) {
return requestClient.get<PageResult<MesDvRepairApi.Repair>>(
'/mes/dv/repair/page',
{ params },
);
}
/** 查询维修工单详情 */
export function getRepair(id: number) {
return requestClient.get<MesDvRepairApi.Repair>(
`/mes/dv/repair/get?id=${id}`,
);
}
/** 新增维修工单 */
export function createRepair(data: MesDvRepairApi.Repair) {
return requestClient.post<number>('/mes/dv/repair/create', data);
}
/** 修改维修工单 */
export function updateRepair(data: MesDvRepairApi.Repair) {
return requestClient.put('/mes/dv/repair/update', data);
}
/** 删除维修工单 */
export function deleteRepair(id: number) {
return requestClient.delete(`/mes/dv/repair/delete?id=${id}`);
}
/** 导出维修工单 */
export function exportRepair(params: any) {
return requestClient.download('/mes/dv/repair/export-excel', { params });
}
/** 提交维修工单 */
export function submitRepair(id: number) {
return requestClient.put(`/mes/dv/repair/submit?id=${id}`);
}
/** 确认维修完成 */
export function confirmRepair(data: MesDvRepairApi.Repair) {
return requestClient.put('/mes/dv/repair/confirm', data);
}
/** 完成验收 */
export function finishRepair(id: number, result: number) {
return requestClient.put(`/mes/dv/repair/finish?id=${id}&result=${result}`);
}

View File

@ -0,0 +1,49 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesDvRepairLineApi {
/** MES 维修工单行 */
export interface RepairLine {
id?: number; // 明细编号
repairId?: number; // 维修工单编号
subjectId?: number; // 项目编号
subjectName?: string; // 项目名称
subjectContent?: string; // 项目内容
subjectStandard?: string; // 项目标准
malfunction?: string; // 故障描述
malfunctionUrl?: string; // 故障图片 URL
description?: string; // 维修描述
remark?: string; // 备注
}
}
/** 查询维修工单行分页 */
export function getRepairLinePage(params: PageParam) {
return requestClient.get<PageResult<MesDvRepairLineApi.RepairLine>>(
'/mes/dv/repair-line/page',
{ params },
);
}
/** 查询维修工单行详情 */
export function getRepairLine(id: number) {
return requestClient.get<MesDvRepairLineApi.RepairLine>(
`/mes/dv/repair-line/get?id=${id}`,
);
}
/** 新增维修工单行 */
export function createRepairLine(data: MesDvRepairLineApi.RepairLine) {
return requestClient.post('/mes/dv/repair-line/create', data);
}
/** 修改维修工单行 */
export function updateRepairLine(data: MesDvRepairLineApi.RepairLine) {
return requestClient.put('/mes/dv/repair-line/update', data);
}
/** 删除维修工单行 */
export function deleteRepairLine(id: number) {
return requestClient.delete(`/mes/dv/repair-line/delete?id=${id}`);
}

View File

@ -0,0 +1,60 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesDvSubjectApi {
/** MES 点检保养项目 */
export interface Subject {
id?: number; // 项目编号
code?: string; // 项目编码
name?: string; // 项目名称
type?: number; // 项目类型
content?: string; // 项目内容
standard?: string; // 标准
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询点检保养项目分页 */
export function getSubjectPage(params: PageParam) {
return requestClient.get<PageResult<MesDvSubjectApi.Subject>>(
'/mes/dv/subject/page',
{ params },
);
}
/** 查询点检保养项目精简列表 */
export function getSubjectSimpleList() {
return requestClient.get<MesDvSubjectApi.Subject[]>(
'/mes/dv/subject/simple-list',
);
}
/** 查询点检保养项目详情 */
export function getSubject(id: number) {
return requestClient.get<MesDvSubjectApi.Subject>(
`/mes/dv/subject/get?id=${id}`,
);
}
/** 新增点检保养项目 */
export function createSubject(data: MesDvSubjectApi.Subject) {
return requestClient.post('/mes/dv/subject/create', data);
}
/** 修改点检保养项目 */
export function updateSubject(data: MesDvSubjectApi.Subject) {
return requestClient.put('/mes/dv/subject/update', data);
}
/** 删除点检保养项目 */
export function deleteSubject(id: number) {
return requestClient.delete(`/mes/dv/subject/delete?id=${id}`);
}
/** 导出点检保养项目 */
export function exportSubject(params: any) {
return requestClient.download('/mes/dv/subject/export-excel', { params });
}

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,49 @@
import { requestClient } from '#/api/request';
export namespace MesMdAutoCodePartApi {
/** MES 编码规则分段 */
export interface AutoCodePart {
id?: number; // 分段编号
ruleId?: number; // 规则编号
sort?: number; // 排序
type?: number; // 分段类型
length?: number; // 长度
dateFormat?: string; // 日期格式
fixCharacter?: string; // 固定字符
serialStartNo?: number; // 流水号起始值
serialStep?: number; // 流水号步长
cycleFlag?: boolean; // 是否循环
cycleMethod?: number; // 循环方式
remark?: string; // 备注
}
}
/** 查询编码规则分段详情 */
export function getAutoCodePart(id: number) {
return requestClient.get<MesMdAutoCodePartApi.AutoCodePart>(
`/mes/md/auto-code-part/get?id=${id}`,
);
}
/** 查询编码规则分段列表 */
export function getAutoCodePartListByRuleId(ruleId: number) {
return requestClient.get<MesMdAutoCodePartApi.AutoCodePart[]>(
'/mes/md/auto-code-part/list-by-rule-id',
{ params: { ruleId } },
);
}
/** 新增编码规则分段 */
export function createAutoCodePart(data: MesMdAutoCodePartApi.AutoCodePart) {
return requestClient.post('/mes/md/auto-code-part/create', data);
}
/** 修改编码规则分段 */
export function updateAutoCodePart(data: MesMdAutoCodePartApi.AutoCodePart) {
return requestClient.put('/mes/md/auto-code-part/update', data);
}
/** 删除编码规则分段 */
export function deleteAutoCodePart(id: number) {
return requestClient.delete(`/mes/md/auto-code-part/delete?id=${id}`);
}

View File

@ -0,0 +1,9 @@
import { requestClient } from '#/api/request';
/** 生成 MES 编码 */
export function generateAutoCode(ruleCode: string, inputChar?: string) {
return requestClient.post<string>('/mes/md/auto-code-record/generate', {
inputChar,
ruleCode,
});
}

View File

@ -0,0 +1,55 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdAutoCodeRuleApi {
/** MES 编码规则 */
export interface AutoCodeRule {
id?: number; // 规则编号
code?: string; // 规则编码
name?: string; // 规则名称
description?: string; // 规则描述
maxLength?: number; // 最大长度
padded?: boolean; // 是否补齐
paddedChar?: string; // 补齐字符
paddedMethod?: number; // 补齐方式
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询编码规则分页 */
export function getAutoCodeRulePage(params: PageParam) {
return requestClient.get<PageResult<MesMdAutoCodeRuleApi.AutoCodeRule>>(
'/mes/md/auto-code-rule/page',
{ params },
);
}
/** 查询编码规则详情 */
export function getAutoCodeRule(id: number) {
return requestClient.get<MesMdAutoCodeRuleApi.AutoCodeRule>(
`/mes/md/auto-code-rule/get?id=${id}`,
);
}
/** 新增编码规则 */
export function createAutoCodeRule(data: MesMdAutoCodeRuleApi.AutoCodeRule) {
return requestClient.post('/mes/md/auto-code-rule/create', data);
}
/** 修改编码规则 */
export function updateAutoCodeRule(data: MesMdAutoCodeRuleApi.AutoCodeRule) {
return requestClient.put('/mes/md/auto-code-rule/update', data);
}
/** 删除编码规则 */
export function deleteAutoCodeRule(id: number) {
return requestClient.delete(`/mes/md/auto-code-rule/delete?id=${id}`);
}
/** 导出编码规则 */
export function exportAutoCodeRule(params: PageParam) {
return requestClient.download('/mes/md/auto-code-rule/export-excel', { params });
}

View File

@ -0,0 +1,86 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdClientApi {
/** MES 客户 */
export interface Client {
id?: number; // 客户编号
code?: string; // 客户编码
name?: string; // 客户名称
nickname?: string; // 客户简称
englishName?: string; // 客户英文名称
description?: string; // 客户简介
logo?: string; // 客户 LOGO 地址
type?: number; // 客户类型
address?: string; // 客户地址
website?: string; // 客户官网地址
email?: string; // 客户邮箱地址
telephone?: string; // 客户电话
contact1Name?: string; // 联系人1
contact1Telephone?: string; // 联系人1电话
contact1Email?: string; // 联系人1邮箱
contact2Name?: string; // 联系人2
contact2Telephone?: string; // 联系人2电话
contact2Email?: string; // 联系人2邮箱
creditCode?: string; // 统一社会信用代码
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
/** 客户导入结果 */
export interface ClientImportRespVO {
createCodes?: string[]; // 新增成功的客户编码
updateCodes?: string[]; // 更新成功的客户编码
failureCodes?: Record<string, string>; // 导入失败的客户编码及原因
}
}
/** 查询客户分页 */
export function getClientPage(params: PageParam) {
return requestClient.get<PageResult<MesMdClientApi.Client>>(
'/mes/md-client/page',
{ params },
);
}
/** 查询客户详情 */
export function getClient(id: number) {
return requestClient.get<MesMdClientApi.Client>(
`/mes/md-client/get?id=${id}`,
);
}
/** 新增客户 */
export function createClient(data: MesMdClientApi.Client) {
return requestClient.post('/mes/md-client/create', data);
}
/** 修改客户 */
export function updateClient(data: MesMdClientApi.Client) {
return requestClient.put('/mes/md-client/update', data);
}
/** 删除客户 */
export function deleteClient(id: number) {
return requestClient.delete(`/mes/md-client/delete?id=${id}`);
}
/** 导出客户 */
export function exportClient(params: any) {
return requestClient.download('/mes/md-client/export-excel', { params });
}
/** 下载客户导入模板 */
export function importClientTemplate() {
return requestClient.download('/mes/md-client/get-import-template');
}
/** 导入客户 */
export function importClient(file: File, updateSupport: boolean) {
return requestClient.upload<MesMdClientApi.ClientImportRespVO>(
`/mes/md-client/import?updateSupport=${updateSupport}`,
{ file },
);
}

View File

@ -0,0 +1,35 @@
import { requestClient } from '#/api/request';
export namespace MesMdItemBatchConfigApi {
/** MES 物料批次属性配置 */
export interface BatchConfig {
id?: number; // 编号
itemId?: number; // 物料编号
produceDateFlag?: boolean; // 批次属性-生产日期
expireDateFlag?: boolean; // 批次属性-有效期
receiptDateFlag?: boolean; // 批次属性-入库日期
vendorFlag?: boolean; // 批次属性-供应商
clientFlag?: boolean; // 批次属性-客户
salesOrderCodeFlag?: boolean; // 批次属性-销售订单编号
purchaseOrderCodeFlag?: boolean; // 批次属性-采购订单编号
workorderFlag?: boolean; // 批次属性-生产工单
taskFlag?: boolean; // 批次属性-生产任务
workstationFlag?: boolean; // 批次属性-工作站
toolFlag?: boolean; // 批次属性-工具
moldFlag?: boolean; // 批次属性-模具
lotNumberFlag?: boolean; // 批次属性-生产批号
qualityStatusFlag?: boolean; // 批次属性-质量状态
}
}
/** 根据物料编号获取批次属性配置 */
export function getBatchConfigByItemId(itemId: number) {
return requestClient.get<MesMdItemBatchConfigApi.BatchConfig>(
`/mes/md/item-batch-config/get-by-item-id?itemId=${itemId}`,
);
}
/** 保存批次属性配置 */
export function saveBatchConfig(data: MesMdItemBatchConfigApi.BatchConfig) {
return requestClient.post('/mes/md/item-batch-config/save', data);
}

View File

@ -0,0 +1,83 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdItemApi {
/** MES 物料产品 */
export interface Item {
id?: number; // 物料编号
code?: string; // 物料编码
name?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureId?: number; // 计量单位编号
unitMeasureName?: string; // 计量单位名称
itemTypeId?: number; // 物料分类编号
itemTypeName?: string; // 物料分类名称
itemOrProduct?: string; // 物料/产品标识
status?: number; // 状态
safeStockFlag?: boolean; // 是否启用安全库存
minStock?: number; // 最低库存量
maxStock?: number; // 最高库存量
highValue?: boolean; // 是否高值物料
batchFlag?: boolean; // 是否启用批次管理
remark?: string; // 备注
createTime?: Date; // 创建时间
}
/** 物料导入结果 */
export interface ItemImportRespVO {
createCodes?: string[]; // 新增成功的物料编码
updateCodes?: string[]; // 更新成功的物料编码
failureCodes?: Record<string, string>; // 导入失败的物料编码及原因
}
}
/** 查询物料产品分页 */
export function getItemPage(params: PageParam) {
return requestClient.get<PageResult<MesMdItemApi.Item>>('/mes/md/item/page', { params });
}
/** 查询物料产品详情 */
export function getItem(id: number) {
return requestClient.get<MesMdItemApi.Item>(`/mes/md/item/get?id=${id}`);
}
/** 新增物料产品 */
export function createItem(data: MesMdItemApi.Item) {
return requestClient.post<number>('/mes/md/item/create', data);
}
/** 修改物料产品 */
export function updateItem(data: MesMdItemApi.Item) {
return requestClient.put('/mes/md/item/update', data);
}
/** 修改物料产品状态 */
export function updateItemStatus(id: number, status: number) {
return requestClient.put('/mes/md/item/update-status', undefined, {
params: { id, status },
});
}
/** 删除物料产品 */
export function deleteItem(id: number) {
return requestClient.delete(`/mes/md/item/delete?id=${id}`);
}
/** 导出物料产品 */
export function exportItem(params: any) {
return requestClient.download('/mes/md/item/export-excel', { params });
}
/** 下载物料导入模板 */
export function importItemTemplate() {
return requestClient.download('/mes/md/item/get-import-template');
}
/** 导入物料产品 */
export function importItem(file: File, updateSupport: boolean) {
return requestClient.upload<MesMdItemApi.ItemImportRespVO>(
`/mes/md/item/import?updateSupport=${updateSupport}`,
{ file },
);
}

View File

@ -0,0 +1,58 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdProductBomApi {
/** MES 产品 BOM */
export interface ProductBom {
id?: number; // BOM 编号
itemId?: number; // 物料产品编号
bomItemId?: number; // BOM 物料编号
quantity?: number; // 物料使用比例
status?: number; // 是否启用
remark?: string; // 备注
createTime?: Date; // 创建时间
bomItemCode?: string; // BOM 物料编码
bomItemName?: string; // BOM 物料名称
bomItemSpecification?: string; // BOM 物料规格
unitMeasureName?: string; // 计量单位名称
itemOrProduct?: string; // 物料/产品标识
}
}
/** 新增产品 BOM */
export function createProductBom(data: MesMdProductBomApi.ProductBom) {
return requestClient.post('/mes/md/product-bom/create', data);
}
/** 修改产品 BOM */
export function updateProductBom(data: MesMdProductBomApi.ProductBom) {
return requestClient.put('/mes/md/product-bom/update', data);
}
/** 删除产品 BOM */
export function deleteProductBom(id: number) {
return requestClient.delete(`/mes/md/product-bom/delete?id=${id}`);
}
/** 查询产品 BOM 详情 */
export function getProductBom(id: number) {
return requestClient.get<MesMdProductBomApi.ProductBom>(
`/mes/md/product-bom/get?id=${id}`,
);
}
/** 查询产品 BOM 分页 */
export function getProductBomPage(params: PageParam) {
return requestClient.get<PageResult<MesMdProductBomApi.ProductBom>>(
'/mes/md/product-bom/page',
{ params },
);
}
/** 根据物料产品编号查询产品 BOM 列表 */
export function getProductBomListByItemId(itemId: number) {
return requestClient.get<MesMdProductBomApi.ProductBom[]>(
`/mes/md/product-bom/list-by-item-id?itemId=${itemId}`,
);
}

View File

@ -0,0 +1,57 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdProductSipApi {
/** MES 产品 SIP */
export interface ProductSip {
id?: number; // SIP 编号
itemId?: number; // 物料产品编号
sort?: number; // 排列顺序
processId?: number; // 工序编号
title?: string; // 标题
description?: string; // 详细描述
url?: string; // 图片地址
remark?: string; // 备注
createTime?: Date; // 创建时间
processCode?: string; // 工序编码
processName?: string; // 工序名称
}
}
/** 新增产品 SIP */
export function createProductSip(data: MesMdProductSipApi.ProductSip) {
return requestClient.post('/mes/md/product-sip/create', data);
}
/** 修改产品 SIP */
export function updateProductSip(data: MesMdProductSipApi.ProductSip) {
return requestClient.put('/mes/md/product-sip/update', data);
}
/** 删除产品 SIP */
export function deleteProductSip(id: number) {
return requestClient.delete(`/mes/md/product-sip/delete?id=${id}`);
}
/** 查询产品 SIP 详情 */
export function getProductSip(id: number) {
return requestClient.get<MesMdProductSipApi.ProductSip>(
`/mes/md/product-sip/get?id=${id}`,
);
}
/** 查询产品 SIP 分页 */
export function getProductSipPage(params: PageParam) {
return requestClient.get<PageResult<MesMdProductSipApi.ProductSip>>(
'/mes/md/product-sip/page',
{ params },
);
}
/** 根据物料产品编号查询产品 SIP 列表 */
export function getProductSipListByItemId(itemId: number) {
return requestClient.get<MesMdProductSipApi.ProductSip[]>(
`/mes/md/product-sip/list-by-item-id?itemId=${itemId}`,
);
}

View File

@ -0,0 +1,57 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdProductSopApi {
/** MES 产品 SOP */
export interface ProductSop {
id?: number; // SOP 编号
itemId?: number; // 物料产品编号
sort?: number; // 排列顺序
processId?: number; // 工序编号
title?: string; // 标题
description?: string; // 详细描述
url?: string; // 图片地址
remark?: string; // 备注
createTime?: Date; // 创建时间
processCode?: string; // 工序编码
processName?: string; // 工序名称
}
}
/** 新增产品 SOP */
export function createProductSop(data: MesMdProductSopApi.ProductSop) {
return requestClient.post('/mes/md/product-sop/create', data);
}
/** 修改产品 SOP */
export function updateProductSop(data: MesMdProductSopApi.ProductSop) {
return requestClient.put('/mes/md/product-sop/update', data);
}
/** 删除产品 SOP */
export function deleteProductSop(id: number) {
return requestClient.delete(`/mes/md/product-sop/delete?id=${id}`);
}
/** 查询产品 SOP 详情 */
export function getProductSop(id: number) {
return requestClient.get<MesMdProductSopApi.ProductSop>(
`/mes/md/product-sop/get?id=${id}`,
);
}
/** 查询产品 SOP 分页 */
export function getProductSopPage(params: PageParam) {
return requestClient.get<PageResult<MesMdProductSopApi.ProductSop>>(
'/mes/md/product-sop/page',
{ params },
);
}
/** 根据物料产品编号查询产品 SOP 列表 */
export function getProductSopListByItemId(itemId: number) {
return requestClient.get<MesMdProductSopApi.ProductSop[]>(
`/mes/md/product-sop/list-by-item-id?itemId=${itemId}`,
);
}

View File

@ -0,0 +1,54 @@
import { requestClient } from '#/api/request';
export namespace MesMdItemTypeApi {
/** MES 物料产品分类 */
export interface ItemType {
id?: number; // 分类编号
parentId?: number; // 父分类编号
code?: string; // 分类编码
name?: string; // 分类名称
itemOrProduct?: string; // 物料/产品标识
sort?: number; // 显示排序
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
children?: ItemType[]; // 子分类
}
}
/** 查询物料产品分类列表 */
export function getItemTypeList(params?: any) {
return requestClient.get<MesMdItemTypeApi.ItemType[]>(
'/mes/md/item-type/list',
{ params },
);
}
/** 查询物料产品分类精简列表 */
export function getItemTypeSimpleList() {
return requestClient.get<MesMdItemTypeApi.ItemType[]>(
'/mes/md/item-type/simple-list',
);
}
/** 查询物料产品分类详情 */
export function getItemType(id: number) {
return requestClient.get<MesMdItemTypeApi.ItemType>(
`/mes/md/item-type/get?id=${id}`,
);
}
/** 新增物料产品分类 */
export function createItemType(data: MesMdItemTypeApi.ItemType) {
return requestClient.post('/mes/md/item-type/create', data);
}
/** 修改物料产品分类 */
export function updateItemType(data: MesMdItemTypeApi.ItemType) {
return requestClient.put('/mes/md/item-type/update', data);
}
/** 删除物料产品分类 */
export function deleteItemType(id: number) {
return requestClient.delete(`/mes/md/item-type/delete?id=${id}`);
}

View File

@ -0,0 +1,62 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdUnitMeasureApi {
/** MES 计量单位 */
export interface UnitMeasure {
id?: number; // 单位编号
code?: string; // 单位编码
name?: string; // 单位名称
primaryFlag?: boolean; // 是否主单位
primaryId?: number; // 主单位编号
changeRate?: number; // 与主单位换算比例
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询计量单位分页 */
export function getUnitMeasurePage(params: PageParam) {
return requestClient.get<PageResult<MesMdUnitMeasureApi.UnitMeasure>>(
'/mes/md/unit-measure/page',
{ params },
);
}
/** 查询计量单位精简列表 */
export function getUnitMeasureSimpleList() {
return requestClient.get<MesMdUnitMeasureApi.UnitMeasure[]>(
'/mes/md/unit-measure/simple-list',
);
}
/** 查询计量单位详情 */
export function getUnitMeasure(id: number) {
return requestClient.get<MesMdUnitMeasureApi.UnitMeasure>(
`/mes/md/unit-measure/get?id=${id}`,
);
}
/** 新增计量单位 */
export function createUnitMeasure(data: MesMdUnitMeasureApi.UnitMeasure) {
return requestClient.post('/mes/md/unit-measure/create', data);
}
/** 修改计量单位 */
export function updateUnitMeasure(data: MesMdUnitMeasureApi.UnitMeasure) {
return requestClient.put('/mes/md/unit-measure/update', data);
}
/** 删除计量单位 */
export function deleteUnitMeasure(id: number) {
return requestClient.delete(`/mes/md/unit-measure/delete?id=${id}`);
}
/** 导出计量单位 */
export function exportUnitMeasure(params: PageParam) {
return requestClient.download('/mes/md/unit-measure/export-excel', {
params,
});
}

View File

@ -0,0 +1,87 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdVendorApi {
/** MES 供应商 */
export interface Vendor {
id?: number; // 供应商编号
code?: string; // 供应商编码
name?: string; // 供应商名称
nickname?: string; // 供应商简称
englishName?: string; // 供应商英文名称
description?: string; // 供应商简介
logo?: string; // 供应商 LOGO 地址
level?: string; // 供应商等级
score?: number; // 供应商评分
address?: string; // 供应商地址
website?: string; // 供应商官网地址
email?: string; // 供应商邮箱地址
telephone?: string; // 供应商电话
contact1Name?: string; // 联系人1
contact1Telephone?: string; // 联系人1电话
contact1Email?: string; // 联系人1邮箱
contact2Name?: string; // 联系人2
contact2Telephone?: string; // 联系人2电话
contact2Email?: string; // 联系人2邮箱
creditCode?: string; // 统一社会信用代码
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
/** 供应商导入结果 */
export interface VendorImportRespVO {
createCodes?: string[]; // 新增成功的供应商编码
updateCodes?: string[]; // 更新成功的供应商编码
failureCodes?: Record<string, string>; // 导入失败的供应商编码及原因
}
}
/** 查询供应商分页 */
export function getVendorPage(params: PageParam) {
return requestClient.get<PageResult<MesMdVendorApi.Vendor>>(
'/mes/md-vendor/page',
{ params },
);
}
/** 查询供应商详情 */
export function getVendor(id: number) {
return requestClient.get<MesMdVendorApi.Vendor>(
`/mes/md-vendor/get?id=${id}`,
);
}
/** 新增供应商 */
export function createVendor(data: MesMdVendorApi.Vendor) {
return requestClient.post('/mes/md-vendor/create', data);
}
/** 修改供应商 */
export function updateVendor(data: MesMdVendorApi.Vendor) {
return requestClient.put('/mes/md-vendor/update', data);
}
/** 删除供应商 */
export function deleteVendor(id: number) {
return requestClient.delete(`/mes/md-vendor/delete?id=${id}`);
}
/** 导出供应商 */
export function exportVendor(params: any) {
return requestClient.download('/mes/md-vendor/export-excel', { params });
}
/** 下载供应商导入模板 */
export function importVendorTemplate() {
return requestClient.download('/mes/md-vendor/get-import-template');
}
/** 导入供应商 */
export function importVendor(file: File, updateSupport: boolean) {
return requestClient.upload<MesMdVendorApi.VendorImportRespVO>(
`/mes/md-vendor/import?updateSupport=${updateSupport}`,
{ file },
);
}

View File

@ -0,0 +1,58 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdWorkstationApi {
/** MES 工作站 */
export interface Workstation {
id?: number; // 工作站编号
code?: string; // 工作站编码
name?: string; // 工作站名称
address?: string; // 工作站地点
workshopId?: number; // 所在车间编号
workshopName?: string; // 所在车间名称
processId?: number; // 工序编号
processName?: string; // 工序名称
warehouseId?: number; // 线边库编号
locationId?: number; // 库区编号
areaId?: number; // 库位编号
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询工作站分页 */
export function getWorkstationPage(params: PageParam) {
return requestClient.get<PageResult<MesMdWorkstationApi.Workstation>>(
'/mes/md-workstation/page',
{ params },
);
}
/** 查询工作站详情 */
export function getWorkstation(id: number) {
return requestClient.get<MesMdWorkstationApi.Workstation>(
`/mes/md-workstation/get?id=${id}`,
);
}
/** 新增工作站 */
export function createWorkstation(data: MesMdWorkstationApi.Workstation) {
return requestClient.post<number>('/mes/md-workstation/create', data);
}
/** 修改工作站 */
export function updateWorkstation(data: MesMdWorkstationApi.Workstation) {
return requestClient.put('/mes/md-workstation/update', data);
}
/** 删除工作站 */
export function deleteWorkstation(id: number) {
return requestClient.delete(`/mes/md-workstation/delete?id=${id}`);
}
/** 导出工作站 */
export function exportWorkstation(params: any) {
return requestClient.download('/mes/md-workstation/export-excel', { params });
}

View File

@ -0,0 +1,35 @@
import { requestClient } from '#/api/request';
export namespace MesMdWorkstationMachineApi {
/** MES 工作站设备资源 */
export interface WorkstationMachine {
id?: number; // 资源编号
workstationId?: number; // 工作站编号
machineryId?: number; // 设备编号
machineryCode?: string; // 设备编码
machineryName?: string; // 设备名称
quantity?: number; // 数量
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询工作站设备资源列表 */
export function getWorkstationMachineList(workstationId: number) {
return requestClient.get<MesMdWorkstationMachineApi.WorkstationMachine[]>(
'/mes/md-workstation-machine/list-by-workstation',
{ params: { workstationId } },
);
}
/** 新增工作站设备资源 */
export function createWorkstationMachine(
data: MesMdWorkstationMachineApi.WorkstationMachine,
) {
return requestClient.post('/mes/md-workstation-machine/create', data);
}
/** 删除工作站设备资源 */
export function deleteWorkstationMachine(id: number) {
return requestClient.delete(`/mes/md-workstation-machine/delete?id=${id}`);
}

View File

@ -0,0 +1,41 @@
import { requestClient } from '#/api/request';
export namespace MesMdWorkstationToolApi {
/** MES 工作站工装夹具资源 */
export interface WorkstationTool {
id?: number; // 资源编号
workstationId?: number; // 工作站编号
toolTypeId?: number; // 工具类型编号
toolTypeName?: string; // 工具类型名称
quantity?: number; // 数量
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询工作站工装夹具资源列表 */
export function getWorkstationToolList(workstationId: number) {
return requestClient.get<MesMdWorkstationToolApi.WorkstationTool[]>(
'/mes/md-workstation-tool/list-by-workstation',
{ params: { workstationId } },
);
}
/** 新增工作站工装夹具资源 */
export function createWorkstationTool(
data: MesMdWorkstationToolApi.WorkstationTool,
) {
return requestClient.post('/mes/md-workstation-tool/create', data);
}
/** 修改工作站工装夹具资源 */
export function updateWorkstationTool(
data: MesMdWorkstationToolApi.WorkstationTool,
) {
return requestClient.put('/mes/md-workstation-tool/update', data);
}
/** 删除工作站工装夹具资源 */
export function deleteWorkstationTool(id: number) {
return requestClient.delete(`/mes/md-workstation-tool/delete?id=${id}`);
}

View File

@ -0,0 +1,41 @@
import { requestClient } from '#/api/request';
export namespace MesMdWorkstationWorkerApi {
/** MES 工作站人力资源 */
export interface WorkstationWorker {
id?: number; // 资源编号
workstationId?: number; // 工作站编号
postId?: number; // 岗位编号
postName?: string; // 岗位名称
quantity?: number; // 数量
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询工作站人力资源列表 */
export function getWorkstationWorkerList(workstationId: number) {
return requestClient.get<MesMdWorkstationWorkerApi.WorkstationWorker[]>(
'/mes/md-workstation-worker/list-by-workstation',
{ params: { workstationId } },
);
}
/** 新增工作站人力资源 */
export function createWorkstationWorker(
data: MesMdWorkstationWorkerApi.WorkstationWorker,
) {
return requestClient.post('/mes/md-workstation-worker/create', data);
}
/** 修改工作站人力资源 */
export function updateWorkstationWorker(
data: MesMdWorkstationWorkerApi.WorkstationWorker,
) {
return requestClient.put('/mes/md-workstation-worker/update', data);
}
/** 删除工作站人力资源 */
export function deleteWorkstationWorker(id: number) {
return requestClient.delete(`/mes/md-workstation-worker/delete?id=${id}`);
}

View File

@ -0,0 +1,60 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesMdWorkshopApi {
/** MES 车间 */
export interface Workshop {
id?: number; // 车间编号
code?: string; // 车间编码
name?: string; // 车间名称
area?: number; // 面积
chargeUserId?: number; // 负责人用户编号
chargeUserName?: string; // 负责人名称
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询车间分页 */
export function getWorkshopPage(params: PageParam) {
return requestClient.get<PageResult<MesMdWorkshopApi.Workshop>>(
'/mes/md-workshop/page',
{ params },
);
}
/** 查询车间精简列表 */
export function getWorkshopSimpleList() {
return requestClient.get<MesMdWorkshopApi.Workshop[]>(
'/mes/md-workshop/simple-list',
);
}
/** 查询车间详情 */
export function getWorkshop(id: number) {
return requestClient.get<MesMdWorkshopApi.Workshop>(
`/mes/md-workshop/get?id=${id}`,
);
}
/** 新增车间 */
export function createWorkshop(data: MesMdWorkshopApi.Workshop) {
return requestClient.post('/mes/md-workshop/create', data);
}
/** 修改车间 */
export function updateWorkshop(data: MesMdWorkshopApi.Workshop) {
return requestClient.put('/mes/md-workshop/update', data);
}
/** 删除车间 */
export function deleteWorkshop(id: number) {
return requestClient.delete(`/mes/md-workshop/delete?id=${id}`);
}
/** 导出车间 */
export function exportWorkshop(params: any) {
return requestClient.download('/mes/md-workshop/export-excel', { params });
}

View File

@ -0,0 +1,54 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProAndonConfigApi {
/** MES 安灯配置 */
export interface AndonConfig {
id?: number; // 编号
reason?: string; // 呼叫原因
level?: number; // 级别
handlerRoleId?: number; // 处置角色编号
handlerRoleName?: string; // 处置角色名称
handlerUserId?: number; // 处置人编号
handlerUserNickname?: string; // 处置人昵称
remark?: string; // 备注
}
}
/** 查询安灯配置分页 */
export function getAndonConfigPage(params: PageParam) {
return requestClient.get<PageResult<MesProAndonConfigApi.AndonConfig>>(
'/mes/pro/andon-config/page',
{ params },
);
}
/** 查询安灯配置列表 */
export function getAndonConfigList() {
return requestClient.get<MesProAndonConfigApi.AndonConfig[]>(
'/mes/pro/andon-config/list',
);
}
/** 查询安灯配置详情 */
export function getAndonConfig(id: number) {
return requestClient.get<MesProAndonConfigApi.AndonConfig>(
`/mes/pro/andon-config/get?id=${id}`,
);
}
/** 新增安灯配置 */
export function createAndonConfig(data: MesProAndonConfigApi.AndonConfig) {
return requestClient.post('/mes/pro/andon-config/create', data);
}
/** 修改安灯配置 */
export function updateAndonConfig(data: MesProAndonConfigApi.AndonConfig) {
return requestClient.put('/mes/pro/andon-config/update', data);
}
/** 删除安灯配置 */
export function deleteAndonConfig(id: number) {
return requestClient.delete(`/mes/pro/andon-config/delete?id=${id}`);
}

View File

@ -0,0 +1,76 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProAndonRecordApi {
/** MES 安灯记录 */
export interface AndonRecord {
id?: number;
configId?: number; // 安灯配置编号
workstationId?: number; // 工作站编号
workstationCode?: string; // 工作站编码
workstationName?: string; // 工作站名称
workOrderId?: number; // 生产工单编号
workOrderCode?: string; // 工单编码
processId?: number; // 工序编号
processName?: string; // 工序名称
userId?: number; // 发起用户编号
userNickname?: string; // 发起人昵称
reason?: string; // 呼叫原因
level?: number; // 级别
status?: number; // 处置状态
handleTime?: number; // 处置时间(毫秒时间戳)
handlerUserId?: number; // 处置人编号
handlerUserNickname?: string; // 处置人昵称
remark?: string; // 备注
createTime?: number; // 发起时间
}
/** MES 安灯记录分页查询参数 */
export interface PageParams extends PageParam {
workstationId?: number; // 工作站编号
userId?: number; // 发起用户编号
handlerUserId?: number; // 处置人编号
status?: number; // 处置状态
createTime?: string[]; // 发起时间区间
}
}
/** 查询安灯记录分页 */
export function getAndonRecordPage(params: MesProAndonRecordApi.PageParams) {
return requestClient.get<PageResult<MesProAndonRecordApi.AndonRecord>>(
'/mes/pro/andon-record/page',
{ params },
);
}
/** 查询安灯记录详情 */
export function getAndonRecord(id: number) {
return requestClient.get<MesProAndonRecordApi.AndonRecord>(
`/mes/pro/andon-record/get?id=${id}`,
);
}
/** 新增安灯记录 */
export function createAndonRecord(data: MesProAndonRecordApi.AndonRecord) {
return requestClient.post('/mes/pro/andon-record/create', data);
}
/** 删除安灯记录 */
export function deleteAndonRecord(id: number) {
return requestClient.delete(`/mes/pro/andon-record/delete?id=${id}`);
}
/** 更新安灯记录(保存/已处置) */
export function updateAndonRecord(data: MesProAndonRecordApi.AndonRecord) {
return requestClient.put('/mes/pro/andon-record/update', data);
}
/** 导出安灯记录 Excel */
export function exportAndonRecord(
params: Partial<MesProAndonRecordApi.PageParams>,
) {
return requestClient.download('/mes/pro/andon-record/export-excel', {
params,
});
}

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

@ -0,0 +1,113 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProFeedbackApi {
/** MES 生产报工 */
export interface Feedback {
id?: number;
code?: string; // 报工单编号
type?: number; // 报工类型
channel?: string; // 报工途径
feedbackTime?: number; // 报工时间
workstationId?: number; // 工作站编号
workstationCode?: string; // 工作站编码
workstationName?: string; // 工作站名称
routeId?: number; // 工艺路线编号
routeCode?: string; // 工艺路线编码
processId?: number; // 工序编号
processCode?: string; // 工序编码
processName?: string; // 工序名称
checkFlag?: boolean; // 是否需要检验
workOrderId?: number; // 生产工单编号
workOrderCode?: string; // 工单编码
workOrderName?: string; // 工单名称
taskId?: number; // 生产任务编号
taskCode?: string; // 任务编码
itemId?: number; // 产品物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
itemSpecification?: string; // 规格型号
unitMeasureId?: number; // 单位编号
unitMeasureName?: string; // 单位名称
expireDate?: number; // 过期日期
scheduledQuantity?: number; // 排产数量
feedbackQuantity?: number; // 本次报工数量
qualifiedQuantity?: number; // 合格品数量
unqualifiedQuantity?: number; // 不良品数量
uncheckQuantity?: number; // 待检测数量
laborScrapQuantity?: number; // 工废数量
materialScrapQuantity?: number; // 料废数量
otherScrapQuantity?: number; // 其他废品数量
feedbackUserId?: number; // 报工用户编号
feedbackUserNickname?: string; // 报工人昵称
approveUserId?: number; // 审核用户编号
approveUserNickname?: string; // 审核人昵称
status?: number; // 状态
remark?: string; // 备注
creator?: string; // 创建人
createTime?: number; // 创建时间
}
/** MES 生产报工分页查询参数 */
export interface PageParams extends PageParam {
code?: string;
type?: number;
workOrderId?: number;
itemId?: number;
feedbackUserId?: number;
creator?: string;
status?: number;
feedbackTime?: string[];
}
}
/** 查询生产报工分页 */
export function getFeedbackPage(params: MesProFeedbackApi.PageParams) {
return requestClient.get<PageResult<MesProFeedbackApi.Feedback>>(
'/mes/pro/feedback/page',
{ params },
);
}
/** 查询生产报工详情 */
export function getFeedback(id: number) {
return requestClient.get<MesProFeedbackApi.Feedback>(
`/mes/pro/feedback/get?id=${id}`,
);
}
/** 新增生产报工 */
export function createFeedback(data: MesProFeedbackApi.Feedback) {
return requestClient.post<number>('/mes/pro/feedback/create', data);
}
/** 修改生产报工 */
export function updateFeedback(data: MesProFeedbackApi.Feedback) {
return requestClient.put('/mes/pro/feedback/update', data);
}
/** 删除生产报工 */
export function deleteFeedback(id: number) {
return requestClient.delete(`/mes/pro/feedback/delete?id=${id}`);
}
/** 导出生产报工 Excel */
export function exportFeedback(params: Partial<MesProFeedbackApi.PageParams>) {
return requestClient.download('/mes/pro/feedback/export-excel', { params });
}
/** 提交生产报工 */
export function submitFeedback(id: number) {
return requestClient.put(`/mes/pro/feedback/submit?id=${id}`);
}
/** 驳回生产报工 */
export function rejectFeedback(id: number) {
return requestClient.put(`/mes/pro/feedback/reject?id=${id}`);
}
/** 审批生产报工(返回是否已审批完成) */
export function approveFeedback(id: number) {
return requestClient.put<boolean>(`/mes/pro/feedback/approve?id=${id}`);
}

View File

@ -0,0 +1,49 @@
import { requestClient } from '#/api/request';
export namespace MesProProcessContentApi {
/** MES 生产工序内容(操作步骤) */
export interface ProcessContent {
id?: number;
processId?: number;
sort?: number;
content?: string;
device?: string;
material?: string;
docUrl?: string;
remark?: string;
createTime?: Date;
}
}
/** 按工序编号查询工序内容列表 */
export function getProcessContentListByProcessId(processId: number) {
return requestClient.get<MesProProcessContentApi.ProcessContent[]>(
`/mes/pro/process-content/list-by-process?processId=${processId}`,
);
}
/** 查询工序内容详情 */
export function getProcessContent(id: number) {
return requestClient.get<MesProProcessContentApi.ProcessContent>(
`/mes/pro/process-content/get?id=${id}`,
);
}
/** 新增工序内容 */
export function createProcessContent(
data: MesProProcessContentApi.ProcessContent,
) {
return requestClient.post('/mes/pro/process-content/create', data);
}
/** 修改工序内容 */
export function updateProcessContent(
data: MesProProcessContentApi.ProcessContent,
) {
return requestClient.put('/mes/pro/process-content/update', data);
}
/** 删除工序内容 */
export function deleteProcessContent(id: number) {
return requestClient.delete(`/mes/pro/process-content/delete?id=${id}`);
}

View File

@ -0,0 +1,58 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProProcessApi {
/** MES 生产工序 */
export interface Process {
id?: number;
code?: string;
name?: string;
attention?: string;
status?: number;
remark?: string;
createTime?: Date;
}
}
/** 查询生产工序分页 */
export function getProcessPage(params: PageParam) {
return requestClient.get<PageResult<MesProProcessApi.Process>>(
'/mes/pro/process/page',
{ params },
);
}
/** 查询生产工序精简列表 */
export function getProcessSimpleList() {
return requestClient.get<MesProProcessApi.Process[]>(
'/mes/pro/process/simple-list',
);
}
/** 查询生产工序详情 */
export function getProcess(id: number) {
return requestClient.get<MesProProcessApi.Process>(
`/mes/pro/process/get?id=${id}`,
);
}
/** 新增生产工序 */
export function createProcess(data: MesProProcessApi.Process) {
return requestClient.post('/mes/pro/process/create', data);
}
/** 修改生产工序 */
export function updateProcess(data: MesProProcessApi.Process) {
return requestClient.put('/mes/pro/process/update', data);
}
/** 删除生产工序 */
export function deleteProcess(id: number) {
return requestClient.delete(`/mes/pro/process/delete?id=${id}`);
}
/** 导出生产工序 Excel */
export function exportProcess(params: any) {
return requestClient.download('/mes/pro/process/export-excel', { params });
}

View File

@ -0,0 +1,65 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProRouteApi {
/** MES 工艺路线 */
export interface Route {
id?: number;
code?: string;
name?: string;
description?: string;
status?: number;
remark?: string;
createTime?: Date;
}
}
/** 查询工艺路线分页 */
export function getRoutePage(params: PageParam) {
return requestClient.get<PageResult<MesProRouteApi.Route>>(
'/mes/pro/route/page',
{ params },
);
}
/** 查询工艺路线精简列表 */
export function getRouteSimpleList() {
return requestClient.get<MesProRouteApi.Route[]>(
'/mes/pro/route/simple-list',
);
}
/** 查询工艺路线详情 */
export function getRoute(id: number) {
return requestClient.get<MesProRouteApi.Route>(
`/mes/pro/route/get?id=${id}`,
);
}
/** 新增工艺路线 */
export function createRoute(data: MesProRouteApi.Route) {
return requestClient.post<number>('/mes/pro/route/create', data);
}
/** 修改工艺路线 */
export function updateRoute(data: MesProRouteApi.Route) {
return requestClient.put('/mes/pro/route/update', data);
}
/** 修改工艺路线状态 */
export function updateRouteStatus(id: number, status: number) {
return requestClient.put(
`/mes/pro/route/update-status?id=${id}&status=${status}`,
);
}
/** 删除工艺路线 */
export function deleteRoute(id: number) {
return requestClient.delete(`/mes/pro/route/delete?id=${id}`);
}
/** 导出工艺路线 Excel */
export function exportRoute(params: any) {
return requestClient.download('/mes/pro/route/export-excel', { params });
}

View File

@ -0,0 +1,70 @@
import { requestClient } from '#/api/request';
export namespace MesProRouteProcessApi {
/** MES 工艺路线工序 */
export interface RouteProcess {
id?: number;
routeId?: number;
processId?: number;
processCode?: string;
processName?: string;
sort?: number;
nextProcessId?: number;
nextProcessName?: string;
linkType?: number;
prepareTime?: number;
waitTime?: number;
colorCode?: string;
keyFlag?: boolean;
checkFlag?: boolean;
remark?: string;
createTime?: Date;
}
}
/** 按工艺路线查询工序列表 */
export function getRouteProcessListByRoute(routeId: number) {
return requestClient.get<MesProRouteProcessApi.RouteProcess[]>(
`/mes/pro/route-process/list-by-route?routeId=${routeId}`,
);
}
/** 按产品查询工序列表(自动查找关联的工艺路线) */
export function getRouteProcessListByProduct(productId: number) {
return requestClient.get<MesProRouteProcessApi.RouteProcess[]>(
`/mes/pro/route-process/list-by-product?productId=${productId}`,
);
}
/** 查询工艺路线工序详情 */
export function getRouteProcess(id: number) {
return requestClient.get<MesProRouteProcessApi.RouteProcess>(
`/mes/pro/route-process/get?id=${id}`,
);
}
/** 按工艺路线 + 工序精确查询工序配置 */
export function getRouteProcessByRouteAndProcess(
routeId: number,
processId: number,
) {
return requestClient.get<MesProRouteProcessApi.RouteProcess>(
'/mes/pro/route-process/get-by-route-and-process',
{ params: { processId, routeId } },
);
}
/** 新增工艺路线工序 */
export function createRouteProcess(data: MesProRouteProcessApi.RouteProcess) {
return requestClient.post('/mes/pro/route-process/create', data);
}
/** 修改工艺路线工序 */
export function updateRouteProcess(data: MesProRouteProcessApi.RouteProcess) {
return requestClient.put('/mes/pro/route-process/update', data);
}
/** 删除工艺路线工序 */
export function deleteRouteProcess(id: number) {
return requestClient.delete(`/mes/pro/route-process/delete?id=${id}`);
}

View File

@ -0,0 +1,48 @@
import { requestClient } from '#/api/request';
export namespace MesProRouteProductApi {
/** MES 工艺路线产品 */
export interface RouteProduct {
id?: number;
routeId?: number;
itemId?: number;
itemCode?: string;
itemName?: string;
specification?: string;
unitName?: string;
quantity?: number;
productionTime?: number;
timeUnitType?: string;
remark?: string;
createTime?: Date;
}
}
/** 按工艺路线查询产品列表 */
export function getRouteProductListByRoute(routeId: number) {
return requestClient.get<MesProRouteProductApi.RouteProduct[]>(
`/mes/pro/route-product/list-by-route?routeId=${routeId}`,
);
}
/** 查询工艺路线产品详情 */
export function getRouteProduct(id: number) {
return requestClient.get<MesProRouteProductApi.RouteProduct>(
`/mes/pro/route-product/get?id=${id}`,
);
}
/** 新增工艺路线产品 */
export function createRouteProduct(data: MesProRouteProductApi.RouteProduct) {
return requestClient.post<number>('/mes/pro/route-product/create', data);
}
/** 修改工艺路线产品 */
export function updateRouteProduct(data: MesProRouteProductApi.RouteProduct) {
return requestClient.put('/mes/pro/route-product/update', data);
}
/** 删除工艺路线产品 */
export function deleteRouteProduct(id: number) {
return requestClient.delete(`/mes/pro/route-product/delete?id=${id}`);
}

View File

@ -0,0 +1,57 @@
import { requestClient } from '#/api/request';
export namespace MesProRouteProductBomApi {
/** MES 工艺路线产品 BOM */
export interface RouteProductBom {
id?: number;
routeId?: number;
processId?: number;
productId?: number;
itemId?: number;
itemCode?: string;
itemName?: string;
specification?: string;
unitName?: string;
quantity?: number;
remark?: string;
createTime?: Date;
}
}
/** 查询工艺路线产品 BOM 列表 */
export function getRouteProductBomList(params: {
processId?: number;
productId?: number;
routeId: number;
}) {
return requestClient.get<MesProRouteProductBomApi.RouteProductBom[]>(
'/mes/pro/route-product-bom/list',
{ params },
);
}
/** 查询工艺路线产品 BOM 详情 */
export function getRouteProductBom(id: number) {
return requestClient.get<MesProRouteProductBomApi.RouteProductBom>(
`/mes/pro/route-product-bom/get?id=${id}`,
);
}
/** 新增工艺路线产品 BOM */
export function createRouteProductBom(
data: MesProRouteProductBomApi.RouteProductBom,
) {
return requestClient.post('/mes/pro/route-product-bom/create', data);
}
/** 修改工艺路线产品 BOM */
export function updateRouteProductBom(
data: MesProRouteProductBomApi.RouteProductBom,
) {
return requestClient.put('/mes/pro/route-product-bom/update', data);
}
/** 删除工艺路线产品 BOM */
export function deleteRouteProductBom(id: number) {
return requestClient.delete(`/mes/pro/route-product-bom/delete?id=${id}`);
}

View File

@ -0,0 +1,95 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProTaskApi {
/** MES 生产任务 */
export interface Task {
id?: number;
code?: string; // 任务编码
name?: string; // 任务名称
workOrderId?: number; // 生产工单编号
workOrderCode?: string; // 工单编码
workOrderName?: string; // 工单名称
workstationId?: number; // 工作站编号
workstationCode?: string; // 工作站编码
workstationName?: string; // 工作站名称
routeId?: number; // 工艺路线编号
processId?: number; // 工序编号
processName?: string; // 工序名称
itemId?: number; // 产品物料编号
itemCode?: string; // 产品编码
itemName?: string; // 产品名称
itemSpecification?: string; // 规格型号
unitMeasureId?: number; // 单位编号
unitMeasureName?: string; // 单位名称
quantity?: number; // 排产数量
producedQuantity?: number; // 已生产数量
qualifyQuantity?: number; // 合格品数量
unqualifyQuantity?: number; // 不良品数量
changedQuantity?: number; // 调整数量
clientId?: number; // 客户编号
clientName?: string; // 客户名称
startTime?: number; // 开始生产时间
endTime?: number; // 结束生产时间
duration?: number; // 生产时长工作日1=8小时
requestDate?: number; // 需求日期(从工单查)
finishDate?: number; // 完成日期
cancelDate?: number; // 取消日期
colorCode?: string; // 甘特图显示颜色
status?: number; // 任务状态
checkFlag?: boolean; // 是否质检(派生自工艺路线工序)
remark?: string; // 备注
}
/** MES 生产任务分页查询参数 */
export interface PageParams extends PageParam {
code?: string;
name?: string;
workOrderId?: number;
workstationId?: number;
routeId?: number;
processId?: number;
itemId?: number;
statuses?: number[];
status?: number;
}
}
/** 查询生产任务分页 */
export function getTaskPage(params: MesProTaskApi.PageParams) {
return requestClient.get<PageResult<MesProTaskApi.Task>>(
'/mes/pro/task/page',
{ params },
);
}
/** 查询生产任务详情 */
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,73 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProTaskIssueApi {
/** MES 生产任务投料 */
export interface TaskIssue {
id?: number; // 编号
taskId?: number; // 生产任务编号
workOrderId?: number; // 生产工单编号
workstationId?: number; // 工作站编号
sourceDocType?: string; // 来源单据类型
sourceDocId?: number; // 来源单据编号
sourceLineId?: number; // 来源单据行编号
sourceDocCode?: string; // 来源单据编码
batchCode?: string; // 投料批次
itemId?: number; // 产品物料编号
itemName?: string; // 产品名称
itemCode?: string; // 产品编码
itemSpecification?: string; // 规格型号
unitMeasureId?: number; // 单位编号
unitMeasureName?: string; // 单位名称
issuedQuantity?: number; // 总投料数量
availableQuantity?: number; // 当前可用数量
usedQuantity?: number; // 当前使用数量
remark?: string; // 备注
}
/** MES 生产任务投料分页查询参数 */
export interface PageParams extends PageParam {
taskId?: number; // 生产任务编号
workOrderId?: number; // 生产工单编号
workstationId?: number; // 工作站编号
itemId?: number; // 产品物料编号
}
}
/** 查询生产任务投料分页 */
export function getTaskIssuePage(params: MesProTaskIssueApi.PageParams) {
return requestClient.get<PageResult<MesProTaskIssueApi.TaskIssue>>(
'/mes/pro/task-issue/page',
{ params },
);
}
/** 查询生产任务投料详情 */
export function getTaskIssue(id: number) {
return requestClient.get<MesProTaskIssueApi.TaskIssue>(
`/mes/pro/task-issue/get?id=${id}`,
);
}
/** 新增生产任务投料 */
export function createTaskIssue(data: MesProTaskIssueApi.TaskIssue) {
return requestClient.post('/mes/pro/task-issue/create', data);
}
/** 修改生产任务投料 */
export function updateTaskIssue(data: MesProTaskIssueApi.TaskIssue) {
return requestClient.put('/mes/pro/task-issue/update', data);
}
/** 删除生产任务投料 */
export function deleteTaskIssue(id: number) {
return requestClient.delete(`/mes/pro/task-issue/delete?id=${id}`);
}
/** 按生产任务查询投料列表 */
export function getTaskIssueListByTask(taskId: number) {
return requestClient.get<MesProTaskIssueApi.TaskIssue[]>(
`/mes/pro/task-issue/list-by-task?taskId=${taskId}`,
);
}

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

@ -0,0 +1,101 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProWorkOrderApi {
/** MES 生产工单 */
export interface WorkOrder {
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; // 工单状态
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[];
}
}
/** 查询生产工单分页 */
export function getWorkOrderPage(params: MesProWorkOrderApi.PageParams) {
return requestClient.get<PageResult<MesProWorkOrderApi.WorkOrder>>(
'/mes/pro/work-order/page',
{ params },
);
}
/** 查询生产工单详情 */
export function getWorkOrder(id: number) {
return requestClient.get<MesProWorkOrderApi.WorkOrder>(
`/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,71 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesProWorkRecordApi {
/** MES 工作记录流水 */
export interface WorkRecordLog {
id?: number; // 编号
userId?: number; // 用户编号
userNickname?: string; // 用户昵称
workstationId?: number; // 工作站编号
workstationCode?: string; // 工作站编码
workstationName?: string; // 工作站名称
type?: number; // 1=上工 2=下工
remark?: string; // 备注
createTime?: Date; // 创建时间
}
/** MES 当前用户工作站绑定状态 */
export interface MyWorkRecord {
userId?: number; // 用户编号
userNickname?: string; // 用户昵称
workstationId?: number; // 工作站编号
workstationCode?: string; // 工作站编码
workstationName?: string; // 工作站名称
type?: number; // 1=上工 2=下工
clockInTime?: Date; // 上工时间
clockOutTime?: Date; // 下工时间
}
}
/** 查询工作记录分页 */
export function getWorkRecordLogPage(params: PageParam) {
return requestClient.get<PageResult<MesProWorkRecordApi.WorkRecordLog>>(
'/mes/pro/workrecord/log/page',
{ params },
);
}
/** 查询工作记录详情 */
export function getWorkRecordLog(id: number) {
return requestClient.get<MesProWorkRecordApi.WorkRecordLog>(
`/mes/pro/workrecord/log/get?id=${id}`,
);
}
/** 导出工作记录 */
export function exportWorkRecordLog(params: any) {
return requestClient.download('/mes/pro/workrecord/log/export-excel', {
params,
});
}
/** 上工(绑定工作站) */
export function clockInWorkRecord(workstationId: number) {
return requestClient.put('/mes/pro/workrecord/clock-in', null, {
params: { workstationId },
});
}
/** 下工(解绑工作站) */
export function clockOutWorkRecord() {
return requestClient.put('/mes/pro/workrecord/clock-out');
}
/** 查询当前用户绑定的工作站 */
export function getMyWorkRecord() {
return requestClient.get<MesProWorkRecordApi.MyWorkRecord>(
'/mes/pro/workrecord/get-my',
);
}

View File

@ -0,0 +1,54 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcDefectApi {
/** MES 缺陷类型 */
export interface Defect {
id?: number; // 编号
code?: string; // 缺陷编码
name?: string; // 缺陷描述
type?: number; // 检测项类型
level?: number; // 缺陷等级
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询缺陷类型分页 */
export function getDefectPage(params: PageParam) {
return requestClient.get<PageResult<MesQcDefectApi.Defect>>(
'/mes/qc/defect/page',
{ params },
);
}
/** 查询缺陷类型精简列表 */
export function getDefectSimpleList() {
return requestClient.get<MesQcDefectApi.Defect[]>('/mes/qc/defect/simple-list');
}
/** 查询缺陷类型详情 */
export function getDefect(id: number) {
return requestClient.get<MesQcDefectApi.Defect>(`/mes/qc/defect/get?id=${id}`);
}
/** 新增缺陷类型 */
export function createDefect(data: MesQcDefectApi.Defect) {
return requestClient.post('/mes/qc/defect/create', data);
}
/** 修改缺陷类型 */
export function updateDefect(data: MesQcDefectApi.Defect) {
return requestClient.put('/mes/qc/defect/update', data);
}
/** 删除缺陷类型 */
export function deleteDefect(id: number) {
return requestClient.delete(`/mes/qc/defect/delete?id=${id}`);
}
/** 导出缺陷类型 */
export function exportDefect(params: any) {
return requestClient.download('/mes/qc/defect/export-excel', { params });
}

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,53 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcIndicatorApi {
/** MES 质检指标 */
export interface Indicator {
id?: number; // 编号
code?: string; // 检测项编码
name?: string; // 检测项名称
type?: number; // 检测项类型
tool?: string; // 检测工具
resultType?: number; // 结果值类型
resultSpecification?: string; // 结果值属性
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询质检指标分页 */
export function getIndicatorPage(params: PageParam) {
return requestClient.get<PageResult<MesQcIndicatorApi.Indicator>>(
'/mes/qc/indicator/page',
{ params },
);
}
/** 查询质检指标详情 */
export function getIndicator(id: number) {
return requestClient.get<MesQcIndicatorApi.Indicator>(
`/mes/qc/indicator/get?id=${id}`,
);
}
/** 新增质检指标 */
export function createIndicator(data: MesQcIndicatorApi.Indicator) {
return requestClient.post('/mes/qc/indicator/create', data);
}
/** 修改质检指标 */
export function updateIndicator(data: MesQcIndicatorApi.Indicator) {
return requestClient.put('/mes/qc/indicator/update', data);
}
/** 删除质检指标 */
export function deleteIndicator(id: number) {
return requestClient.delete(`/mes/qc/indicator/delete?id=${id}`);
}
/** 导出质检指标 */
export function exportIndicator(params: any) {
return requestClient.download('/mes/qc/indicator/export-excel', { params });
}

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,51 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcTemplateApi {
/** MES 质检方案 */
export interface Template {
id?: number; // 编号
code?: string; // 方案编号
name?: string; // 方案名称
types?: number[]; // 检测种类
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询质检方案分页 */
export function getTemplatePage(params: PageParam) {
return requestClient.get<PageResult<MesQcTemplateApi.Template>>(
'/mes/qc/template/page',
{ params },
);
}
/** 查询质检方案详情 */
export function getTemplate(id: number) {
return requestClient.get<MesQcTemplateApi.Template>(
`/mes/qc/template/get?id=${id}`,
);
}
/** 新增质检方案 */
export function createTemplate(data: MesQcTemplateApi.Template) {
return requestClient.post('/mes/qc/template/create', data);
}
/** 修改质检方案 */
export function updateTemplate(data: MesQcTemplateApi.Template) {
return requestClient.put('/mes/qc/template/update', data);
}
/** 删除质检方案 */
export function deleteTemplate(id: number) {
return requestClient.delete(`/mes/qc/template/delete?id=${id}`);
}
/** 导出质检方案 */
export function exportTemplate(params: any) {
return requestClient.download('/mes/qc/template/export-excel', { params });
}

View File

@ -0,0 +1,57 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcTemplateIndicatorApi {
/** MES 质检方案-检测指标项 */
export interface TemplateIndicator {
id?: number; // 编号
templateId?: number; // 质检方案ID
indicatorId?: number; // 质检指标ID
checkMethod?: string; // 检测方法
standardValue?: number; // 标准值
unitMeasureId?: number; // 计量单位ID
thresholdMax?: number; // 误差上限
thresholdMin?: number; // 误差下限
docUrl?: string; // 说明图URL
remark?: string; // 备注
indicatorCode?: string; // 检测项编码JOIN
indicatorName?: string; // 检测项名称JOIN
indicatorType?: number; // 检测项类型JOIN
indicatorTool?: string; // 检测工具JOIN
unitMeasureName?: string; // 计量单位名称JOIN
}
}
/** 查询检测指标项分页 */
export function getTemplateIndicatorPage(params: PageParam & { templateId?: number }) {
return requestClient.get<
PageResult<MesQcTemplateIndicatorApi.TemplateIndicator>
>('/mes/qc/template/indicator/page', { params });
}
/** 查询检测指标项详情 */
export function getTemplateIndicator(id: number) {
return requestClient.get<MesQcTemplateIndicatorApi.TemplateIndicator>(
`/mes/qc/template/indicator/get?id=${id}`,
);
}
/** 新增检测指标项 */
export function createTemplateIndicator(
data: MesQcTemplateIndicatorApi.TemplateIndicator,
) {
return requestClient.post('/mes/qc/template/indicator/create', data);
}
/** 修改检测指标项 */
export function updateTemplateIndicator(
data: MesQcTemplateIndicatorApi.TemplateIndicator,
) {
return requestClient.put('/mes/qc/template/indicator/update', data);
}
/** 删除检测指标项 */
export function deleteTemplateIndicator(id: number) {
return requestClient.delete(`/mes/qc/template/indicator/delete?id=${id}`);
}

View File

@ -0,0 +1,52 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesQcTemplateItemApi {
/** MES 质检方案-产品关联 */
export interface TemplateItem {
id?: number; // 编号
templateId?: number; // 质检方案ID
itemId?: number; // 产品物料ID
quantityCheck?: number; // 最低检测数
quantityUnqualified?: number; // 最大不合格数
criticalRate?: number; // 最大致命缺陷率(%
majorRate?: number; // 最大严重缺陷率(%
minorRate?: number; // 最大轻微缺陷率(%
remark?: string; // 备注
itemCode?: string; // 物料编码JOIN
itemName?: string; // 物料名称JOIN
specification?: string; // 规格型号JOIN
unitMeasureName?: string; // 计量单位名称JOIN
}
}
/** 查询产品关联分页 */
export function getTemplateItemPage(params: PageParam & { templateId?: number }) {
return requestClient.get<PageResult<MesQcTemplateItemApi.TemplateItem>>(
'/mes/qc/template/item/page',
{ params },
);
}
/** 查询产品关联详情 */
export function getTemplateItem(id: number) {
return requestClient.get<MesQcTemplateItemApi.TemplateItem>(
`/mes/qc/template/item/get?id=${id}`,
);
}
/** 新增产品关联 */
export function createTemplateItem(data: MesQcTemplateItemApi.TemplateItem) {
return requestClient.post('/mes/qc/template/item/create', data);
}
/** 修改产品关联 */
export function updateTemplateItem(data: MesQcTemplateItemApi.TemplateItem) {
return requestClient.put('/mes/qc/template/item/update', data);
}
/** 删除产品关联 */
export function deleteTemplateItem(id: number) {
return requestClient.delete(`/mes/qc/template/item/delete?id=${id}`);
}

View File

@ -0,0 +1,61 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesTmToolApi {
/** MES 工具台账 */
export interface Tool {
id?: number; // 工具编号
code?: string; // 工具编码
name?: string; // 工具名称
brand?: string; // 品牌
specification?: string; // 型号规格
toolTypeId?: number; // 工具类型编号
toolTypeName?: string; // 工具类型名称
quantity?: number; // 数量
availableQuantity?: number; // 可用数量
maintenType?: number; // 保养维护类型
nextMaintenPeriod?: number; // 下次保养周期
nextMaintenDate?: Date | number; // 下次保养日期
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询工具台账分页 */
export function getToolPage(params: PageParam) {
return requestClient.get<PageResult<MesTmToolApi.Tool>>('/mes/tm/tool/page', {
params,
});
}
/** 查询工具精简列表 */
export function getToolSimpleList() {
return requestClient.get<MesTmToolApi.Tool[]>('/mes/tm/tool/simple-list');
}
/** 查询工具台账详情 */
export function getTool(id: number) {
return requestClient.get<MesTmToolApi.Tool>(`/mes/tm/tool/get?id=${id}`);
}
/** 新增工具台账 */
export function createTool(data: MesTmToolApi.Tool) {
return requestClient.post('/mes/tm/tool/create', data);
}
/** 修改工具台账 */
export function updateTool(data: MesTmToolApi.Tool) {
return requestClient.put('/mes/tm/tool/update', data);
}
/** 删除工具台账 */
export function deleteTool(id: number) {
return requestClient.delete(`/mes/tm/tool/delete?id=${id}`);
}
/** 导出工具台账 */
export function exportTool(params: any) {
return requestClient.download('/mes/tm/tool/export-excel', { params });
}

View File

@ -0,0 +1,59 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesTmToolTypeApi {
/** MES 工具类型 */
export interface ToolType {
id?: number; // 工具类型编号
code?: string; // 类型编码
name?: string; // 类型名称
codeFlag?: boolean; // 是否编码管理
maintenType?: number; // 保养维护类型
maintenPeriod?: number; // 保养周期
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询工具类型分页 */
export function getToolTypePage(params: PageParam) {
return requestClient.get<PageResult<MesTmToolTypeApi.ToolType>>(
'/mes/tm/tool-type/page',
{ params },
);
}
/** 查询工具类型精简列表 */
export function getToolTypeSimpleList() {
return requestClient.get<MesTmToolTypeApi.ToolType[]>(
'/mes/tm/tool-type/simple-list',
);
}
/** 查询工具类型详情 */
export function getToolType(id: number) {
return requestClient.get<MesTmToolTypeApi.ToolType>(
`/mes/tm/tool-type/get?id=${id}`,
);
}
/** 新增工具类型 */
export function createToolType(data: MesTmToolTypeApi.ToolType) {
return requestClient.post('/mes/tm/tool-type/create', data);
}
/** 修改工具类型 */
export function updateToolType(data: MesTmToolTypeApi.ToolType) {
return requestClient.put('/mes/tm/tool-type/update', data);
}
/** 删除工具类型 */
export function deleteToolType(id: number) {
return requestClient.delete(`/mes/tm/tool-type/delete?id=${id}`);
}
/** 导出工具类型 */
export function exportToolType(params: any) {
return requestClient.download('/mes/tm/tool-type/export-excel', { params });
}

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,49 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmBarcodeConfigApi {
/** MES 条码配置 */
export interface BarcodeConfig {
id?: number; // 编号
format?: number; // 条码格式
bizType?: number; // 业务类型
contentFormat?: string; // 内容格式模板
contentExample?: string; // 内容样例
autoGenerateFlag?: boolean; // 是否自动生成
defaultTemplate?: string; // 默认打印模板
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询条码配置分页 */
export function getBarcodeConfigPage(params: PageParam) {
return requestClient.get<PageResult<MesWmBarcodeConfigApi.BarcodeConfig>>(
'/mes/wm/barcode-config/page',
{ params },
);
}
/** 查询条码配置详情 */
export function getBarcodeConfig(id: number) {
return requestClient.get<MesWmBarcodeConfigApi.BarcodeConfig>(
`/mes/wm/barcode-config/get?id=${id}`,
);
}
/** 新增条码配置 */
export function createBarcodeConfig(data: MesWmBarcodeConfigApi.BarcodeConfig) {
return requestClient.post('/mes/wm/barcode-config/create', data);
}
/** 修改条码配置 */
export function updateBarcodeConfig(data: MesWmBarcodeConfigApi.BarcodeConfig) {
return requestClient.put('/mes/wm/barcode-config/update', data);
}
/** 删除条码配置 */
export function deleteBarcodeConfig(id: number) {
return requestClient.delete(`/mes/wm/barcode-config/delete?id=${id}`);
}

View File

@ -0,0 +1,70 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmBarcodeApi {
/** MES 条码清单 */
export interface Barcode {
id?: number; // 条码编号
configId?: number; // 条码配置编号
format?: number; // 条码格式
bizType?: number; // 业务类型
content?: string; // 条码内容
bizId?: number; // 业务对象编号
bizCode?: string; // 业务对象编码
bizName?: string; // 业务对象名称
status?: number; // 状态
remark?: string; // 备注
createTime?: Date; // 创建时间
}
}
/** 查询条码分页 */
export function getBarcodePage(params: PageParam) {
return requestClient.get<PageResult<MesWmBarcodeApi.Barcode>>(
'/mes/wm/barcode/page',
{ params },
);
}
/** 查询条码详情 */
export function getBarcode(id: number) {
return requestClient.get<MesWmBarcodeApi.Barcode>(
`/mes/wm/barcode/get?id=${id}`,
);
}
/** 根据业务对象获取条码 */
export function getBarcodeByBusiness(bizType: number, bizId: number) {
return requestClient.get<MesWmBarcodeApi.Barcode>(
'/mes/wm/barcode/get-by-business',
{ params: { bizId, bizType } },
);
}
/** 新增条码 */
export function createBarcode(data: MesWmBarcodeApi.Barcode) {
return requestClient.post('/mes/wm/barcode/create', data);
}
/** 修改条码 */
export function updateBarcode(data: MesWmBarcodeApi.Barcode) {
return requestClient.put('/mes/wm/barcode/update', data);
}
/** 删除条码 */
export function deleteBarcode(id: number) {
return requestClient.delete(`/mes/wm/barcode/delete?id=${id}`);
}
/** 导出条码 */
export function exportBarcode(params: any) {
return requestClient.download('/mes/wm/barcode/export-excel', { params });
}
/** 生成条码内容 */
export function generateBarcodeContent(bizType: number, bizCode: string) {
return requestClient.get<string>('/mes/wm/barcode/generate-content', {
params: { bizCode, bizType },
});
}

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,37 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmItemConsumeLineApi {
/** MES 物料消耗行 */
export interface ItemConsumeLine {
id?: number;
feedbackId?: number; // 报工编号
itemId?: number; // 物料编号
itemCode?: string; // 物资编码
itemName?: string; // 物资名称
specification?: string; // 规格型号
unitId?: number; // 单位编号
unitName?: string; // 单位
quantity?: number; // 消耗数量
batchCode?: string; // 批次号
locationId?: number; // 库位编号
locationName?: string; // 库位名称
remark?: string; // 备注
}
/** MES 物料消耗行分页查询参数 */
export interface PageParams extends PageParam {
feedbackId?: number;
}
}
/** 查询物料消耗行分页 */
export function getItemConsumeLinePage(
params: MesWmItemConsumeLineApi.PageParams,
) {
return requestClient.get<PageResult<MesWmItemConsumeLineApi.ItemConsumeLine>>(
'/mes/wm/item-consume-line/page',
{ params },
);
}

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

@ -0,0 +1,86 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmItemReceiptApi {
/** MES 采购入库单 */
export interface ItemReceipt {
id?: number; // 入库单编号
code?: string; // 入库单编码
name?: string; // 入库单名称
iqcId?: number; // 来料检验单编号
iqcCode?: string; // 来料检验单编码
noticeId?: number; // 到货通知单编号
noticeCode?: string; // 到货通知单编码
purchaseOrderCode?: string; // 采购订单号
vendorId?: number; // 供应商编号
vendorName?: string; // 供应商名称
warehouseId?: number; // 仓库编号
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: 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

@ -0,0 +1,63 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmItemReceiptLineApi {
/** MES 采购入库单行 */
export interface ItemReceiptLine {
id?: number; // 行编号
receiptId?: number; // 入库单编号
receiptCode?: string; // 入库单编码
arrivalNoticeLineId?: number; // 到货通知单行编号
purchaseOrderCode?: string; // 采购订单号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
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,61 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmMaterialStockApi {
/** MES 库存台账 */
export interface MaterialStock {
id?: number; // 编号
itemTypeId?: number; // 物料分类编号
itemId?: number; // 物料编号
itemCode?: string; // 物料编码
itemName?: string; // 物料名称
specification?: string; // 规格型号
unitMeasureName?: string; // 计量单位名称
batchId?: number; // 批次编号
batchCode?: string; // 批次号
warehouseId?: number; // 仓库编号
warehouseCode?: string; // 仓库编码
warehouseName?: string; // 仓库名称
locationId?: number; // 库区编号
locationName?: string; // 库区名称
areaId?: number; // 库位编号
areaName?: string; // 库位名称
vendorId?: number; // 供应商编号
vendorName?: string; // 供应商名称
quantity?: number; // 在库数量
receiptTime?: string; // 入库日期
frozen?: boolean; // 是否冻结
createTime?: Date; // 创建时间
}
}
/** 查询库存台账分页 */
export function getMaterialStockPage(params: PageParam) {
return requestClient.get<PageResult<MesWmMaterialStockApi.MaterialStock>>(
'/mes/wm/material-stock/page',
{ params },
);
}
/** 查询库存台账详情 */
export function getMaterialStock(id: number) {
return requestClient.get<MesWmMaterialStockApi.MaterialStock>(
`/mes/wm/material-stock/get?id=${id}`,
);
}
/** 更新库存冻结状态 */
export function updateMaterialStockFrozen(data: {
frozen: boolean;
id: number;
}) {
return requestClient.put('/mes/wm/material-stock/update-frozen', data);
}
/** 导出库存台账 */
export function exportMaterialStock(params: any) {
return requestClient.download('/mes/wm/material-stock/export-excel', {
params,
});
}

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,37 @@
import type { PageParam, PageResult } from '@vben/request';
import { requestClient } from '#/api/request';
export namespace MesWmProductProduceLineApi {
/** MES 产品产出行 */
export interface ProductProduceLine {
id?: number;
feedbackId?: number; // 报工编号
itemId?: number; // 物料编号
itemCode?: string; // 物资编码
itemName?: string; // 物资名称
specification?: string; // 规格型号
unitMeasureId?: number; // 单位编号
unitMeasureName?: string; // 单位
quantity?: number; // 产出数量
batchCode?: string; // 批次号
qualityStatus?: number; // 质量状态
locationId?: number; // 库位编号
locationName?: string; // 库位名称
remark?: string; // 备注
}
/** MES 产品产出行分页查询参数 */
export interface PageParams extends PageParam {
feedbackId?: number;
}
}
/** 查询产品产出行分页 */
export function getProductProduceLinePage(
params: MesWmProductProduceLineApi.PageParams,
) {
return requestClient.get<
PageResult<MesWmProductProduceLineApi.ProductProduceLine>
>('/mes/wm/product-produce-line/page', { params });
}

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,
});
}

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