rakor
/
wms
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

新增巡检任务工单、pdi检测任务批量删除

This commit is contained in:
funny 2026-05-11 11:46:27 +08:00
parent b4c3aa60e7
commit 682fba28b7
17 changed files with 1048 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
nflg-qms-admin/src/main/java/com/nflg/qms/admin/controller/QmsIssueTicketController.java
View File

@ -50,6 +50,26 @@ public class QmsIssueTicketController extends BaseController {
return ApiResult.success();
}
/**
* 巡检工单分派（支持多人）
* 为每个处理人创建处理记录，并推送待办消息
*/
@PostMapping("dispatchMultiple")
public ApiResult<Void> dispatchMultiple(@Valid @RequestBody QmsIssueTicketDispatchMultipleQO request) {
issueTicketControllerService.dispatchMultiple(request);
return ApiResult.success();
}
/**
* 新增巡检工单并发布
* 一步完成：创建工单 + 设置负责人 + 状态改为处理中
*/
@PostMapping("addAndDispatch")
public ApiResult<Void> addAndDispatch(@Valid @RequestBody QmsIssueTicketAddAndDispatchQO request) {
issueTicketControllerService.addAndDispatch(request);
return ApiResult.success();
}
/**
* 新增PDI检测工单(平板使用)
* 同步创建工单，异步创建工单处理记录
@ -123,4 +143,22 @@ public class QmsIssueTicketController extends BaseController {
public ApiResult<PageData<QmsIssueTicketVO>> search(@Valid @RequestBody QmsIssueTicketSearchQO request) {
return ApiResult.success(issueTicketService.search(request));
}
/**
* 查询巡检任务列表（平板使用）
* 仅查询当前登录人创建的巡检工单
*/
@PostMapping("searchTablet")
public ApiResult<PageData<QmsIssueTicketVO>> searchTablet(@Valid @RequestBody QmsIssueTicketTabletSearchQO request) {
return ApiResult.success(issueTicketControllerService.searchTabletInspectionTickets(request));
}
/**
* 查询巡检工单详情
* 返回工单基本信息、图片列表、处理人信息、纠正措施等
*/
@GetMapping("detail/inspection-ticket")
public ApiResult<QmsInspectionTicketDetailVO> detailInspectionTicket(@NotNull(message = "ID不能为空") Long id) {
return ApiResult.success(issueTicketControllerService.getInspectionTicketDetail(id));
}
}

25
nflg-qms-admin/src/main/java/com/nflg/qms/admin/controller/QmsIssueTicketProcessController.java
View File

@ -5,7 +5,6 @@ import com.nflg.qms.admin.service.QmsIssueTicketProcessMeasureControllerService;
import com.nflg.wms.common.pojo.ApiResult;
import com.nflg.wms.common.pojo.qo.QmsIssueTicketProcessAddQO;
import com.nflg.wms.common.pojo.qo.QmsIssueTicketProcessDraftQO;
import com.nflg.wms.common.pojo.qo.QmsIssueTicketProcessLeaderDraftQO;
import com.nflg.wms.starter.BaseController;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
@ -38,37 +37,21 @@ public class QmsIssueTicketProcessController extends BaseController {
/**
* 暂存工单处理
* 支持PDI检测任务和巡检任务的处理人/领导暂存
*/
@PostMapping("draft")
public ApiResult<Void> draft(@Valid @RequestBody QmsIssueTicketProcessDraftQO request) {
issueTicketProcessMeasureControllerService.draft(request);
issueTicketProcessMeasureControllerService.draftUnified(request);
return ApiResult.success();
}
/**
* 提交工单处理
* 支持PDI检测任务和巡检任务的处理人/领导提交
*/
@PostMapping("submit")
public ApiResult<Void> submit(@Valid @RequestBody QmsIssueTicketProcessDraftQO request) {
issueTicketProcessControllerService.submit(request);
return ApiResult.success();
}
/**
* 领导暂存工单处理
*/
@PostMapping("leaderDraft")
public ApiResult<Void> leaderDraft(@Valid @RequestBody QmsIssueTicketProcessLeaderDraftQO request) {
issueTicketProcessMeasureControllerService.leaderDraft(request);
return ApiResult.success();
}
/**
* 领导提交工单处理
*/
@PostMapping("leaderSubmit")
public ApiResult<Void> leaderSubmit(@Valid @RequestBody QmsIssueTicketProcessLeaderDraftQO request) {
issueTicketProcessControllerService.leaderSubmit(request);
issueTicketProcessControllerService.submitUnified(request);
return ApiResult.success();
}
}

6
nflg-qms-admin/src/main/java/com/nflg/qms/admin/controller/QmsPdiDeliveryItemController.java
View File

@ -48,11 +48,11 @@ public class QmsPdiDeliveryItemController extends BaseController {
}
/**
* 删除检查项
* 批量删除检查项
*/
@PostMapping("/delete")
public ApiResult<Void> delete(@NotNull(message = "ID不能为空") @RequestParam Long id) {
deliveryItemControllerService.delete(id);
public ApiResult<Void> delete(@NotNull(message = "ID列表不能为空") @RequestBody List<Long> ids) {
deliveryItemControllerService.batchDelete(ids);
return ApiResult.success();
}

8
nflg-qms-admin/src/main/java/com/nflg/qms/admin/controller/QmsPdiDetectionRulesController.java
View File

@ -68,15 +68,15 @@ public class QmsPdiDetectionRulesController extends BaseController {
}
/**
* 删除PDI检测规则
* 批量删除PDI检测规则
* 已发布不可删除；未发布且已启用也不可删除
*
* @param id 规则ID
* @param ids 规则ID列表
*/
@Transactional
@PostMapping("delete")
public ApiResult<Void> delete(@NotNull(message = "ID不能为空") Long id) {
pdiDetectionRulesControllerService.delete(id);
public ApiResult<Void> delete(@NotNull(message = "ID列表不能为空") @RequestBody List<Long> ids) {
pdiDetectionRulesControllerService.batchDelete(ids);
return ApiResult.success();
}

34
nflg-qms-admin/src/main/java/com/nflg/qms/admin/controller/QmsPdiStatusItemController.java
View File

@ -51,11 +51,11 @@ public class QmsPdiStatusItemController extends BaseController {
}
/**
* 删除检测项
* 批量删除检测项
*/
@PostMapping("/delete")
public ApiResult<?> delete(@NotNull(message = "ID不能为空") @RequestParam Long id) {
statusItemControllerService.delete(id);
public ApiResult<?> delete(@NotNull(message = "ID列表不能为空") @RequestBody List<Long> ids) {
statusItemControllerService.batchDelete(ids);
return ApiResult.success();
}
@ -72,14 +72,32 @@ public class QmsPdiStatusItemController extends BaseController {
/**
* 下载导入模板
* 状态：0=静态，1=动态，2=特殊
* 状态：0=动态，1=静态，2=特殊（整件）
* 注意：静态/动态检测项的部件描述必填，特殊检测项的部件描述可为空
*/
@GetMapping("/importTemplate")
public void importTemplate(HttpServletResponse response) throws IOException {
EecExcelUtil.export("PDI检测项导入模板",
Arrays.asList("部件描述", "*检查核实内容", "检测示例图", "排序"),
List.of(), response);
public void importTemplate(HttpServletResponse response,
@NotNull(message = "状态不能为空") @RequestParam Integer status) throws IOException {
String templateName;
List<String> headers;
if (status == 0) {
// 动态检测
templateName = "动态监测标准模版";
headers = Arrays.asList("部件描述", "*检查核实内容", "检测示例图", "排序");
} else if (status == 1) {
// 静态检测
templateName = "静态检测标准模版";
headers = Arrays.asList("部件描述", "*检查核实内容", "检测示例图", "排序");
} else if (status == 2) {
// 特殊检测（整件）- 不需要部件描述字段
templateName = "整件检测标准模版";
headers = Arrays.asList("*检查核实内容", "检测示例图", "排序");
} else {
throw new IllegalArgumentException("状态参数错误，只能为0、1或2");
}
EecExcelUtil.export(templateName, headers, List.of(), response);
}
/**

365
nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmsIssueTicketControllerService.java
View File

@ -3,8 +3,11 @@ package com.nflg.qms.admin.service;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nflg.wms.common.constant.STATE;
import com.nflg.wms.common.exception.NflgException;
import com.nflg.wms.common.pojo.PageData;
import com.nflg.wms.common.pojo.qo.*;
import com.nflg.wms.common.pojo.vo.*;
import com.nflg.wms.common.util.UserUtil;
@ -106,6 +109,91 @@ public class QmsIssueTicketControllerService {
.update();
}
/**
* 巡检工单分派（支持多人）
* 1. 校验工单存在且来源类型为巡检（sourceType=2）
* 2. 校验所有处理人存在
* 3. 为每个处理人创建一条处理记录（qms_issue_ticket_process）
* 4. 推送待办消息给每个处理人
*/
@Transactional(rollbackFor = Exception.class)
public void dispatchMultiple(@Valid QmsIssueTicketDispatchMultipleQO request) {
Long currentUserId = UserUtil.getUserId();
String currentUserName = UserUtil.getUserName();
LocalDateTime now = LocalDateTime.now();
// 1. 校验工单存在
QmsIssueTicket ticket = issueTicketService.getById(request.getId());
VUtil.trueThrowBusinessError(Objects.isNull(ticket)).throwMessage("工单不存在");
// 2. 校验工单来源类型为巡检
if (!Objects.equals(ticket.getSourceType(), (short) 2)) {
throw new NflgException(STATE.BusinessError, "只能分派巡检工单");
}
// 3. 查询消息类型ID
Long sourceTypeId = dictionaryItemService.getIdByCode("MessageType", "InspectionTaskWorkOrder");
VUtil.trueThrowBusinessError(Objects.isNull(sourceTypeId)).throwMessage("消息类型配置不存在");
// 4. 批量查询并校验所有处理人
List<User> handlerUsers = userService.listByIds(request.getHandlerUserIds());
if (handlerUsers.size() != request.getHandlerUserIds().size()) {
throw new NflgException(STATE.BusinessError, "部分处理人不存在");
}
// 构建处理人ID到用户的映射
Map<Long, User> handlerUserMap = handlerUsers.stream()
.collect(Collectors.toMap(User::getId, user -> user));
// 5. 为每个处理人创建处理记录并推送待办
List<QmsIssueTicketProcess> processes = new ArrayList<>();
List<QmsTodoItem> todoItems = new ArrayList<>();
for (Long handlerUserId : request.getHandlerUserIds()) {
User handlerUser = handlerUserMap.get(handlerUserId);
// 创建处理记录
QmsIssueTicketProcess process = new QmsIssueTicketProcess()
.setIssueTicketId(ticket.getId())
.setHandlerUserId(handlerUserId)
.setHandlerUserName(handlerUser.getUserName());
processes.add(process);
// 创建待办消息
QmsTodoItem todoItem = new QmsTodoItem()
.setCode(ticket.getTicketNo())
.setIsRead(false)
.setSourceTypeId(sourceTypeId)
.setSourceId(process.getId()) // 使用处理记录的ID
.setCreateUserId(handlerUserId)
.setCreateUserName(handlerUser.getUserName())
.setCreateTime(now);
todoItems.add(todoItem);
}
// 6. 批量保存处理记录
issueTicketProcessService.saveBatch(processes);
// 7. 更新处理记录中的sourceId（因为saveBatch后才有ID）
for (int i = 0; i < processes.size(); i++) {
todoItems.get(i).setSourceId(processes.get(i).getId());
}
// 8. 批量推送待办消息
todoItemService.saveBatch(todoItems);
// 9. 如果工单状态是待流转(0)，更新为处理中(1)
if (ticket.getStatus() != null && ticket.getStatus() == 0) {
issueTicketService.lambdaUpdate()
.eq(QmsIssueTicket::getId, ticket.getId())
.set(QmsIssueTicket::getStatus, (short) 1)
.set(QmsIssueTicket::getUpdateUserId, currentUserId)
.set(QmsIssueTicket::getUpdateUserName, currentUserName)
.set(QmsIssueTicket::getUpdateTime, now)
.update();
}
}
@Resource
private IQmsIssueTicketProcessService issueTicketProcessService;
@ -459,6 +547,124 @@ public class QmsIssueTicketControllerService {
issueTicketService.save(entity);
}
/**
* 新增巡检工单并发布
* 1. 创建工单（来源类型固定为2-巡检）
* 2. 直接设置为处理中状态（status=1）
* 3. 设置负责人为审批人
*/
@Transactional(rollbackFor = Exception.class)
public void addAndDispatch(@Valid QmsIssueTicketAddAndDispatchQO request) {
Long userId = UserUtil.getUserId();
String userName = UserUtil.getUserName();
LocalDateTime now = LocalDateTime.now();
// 1. 校验负责人存在
User handlerUser = userService.getById(request.getHandlerUserId());
VUtil.trueThrowBusinessError(Objects.isNull(handlerUser)).throwMessage("负责人不存在");
// 2. 自动生成工单编号
String ticketNo = basdeSerialNumberControllerService.generateSerialNumber(37);
// 3. 创建工单实体（直接设置为处理中状态）
QmsIssueTicket entity = new QmsIssueTicket()
.setSourceType((short) 2)
.setTicketNo(ticketNo)
.setTicketTitle(request.getTicketTitle())
.setProjectNo(request.getProjectNo())
.setIncidentType(request.getIncidentType())
.setExceptionCode(request.getExceptionCode())
.setUnqualifiedQty(request.getUnqualifiedQty())
.setImpactQuantity(request.getImpactQuantity())
.setIncidentLocation(request.getIncidentLocation())
.setIncidentDescription(request.getIncidentDescription())
.setIncidentReason(request.getIncidentReason())
.setIncidentConsequence(request.getIncidentConsequence())
.setImageIds(request.getImages() == null
? ""
: StrUtil.join(",", request.getImages().stream().map(FileUploadVO::getId).toList())
)
.setRemark(request.getRemark())
.setStatus((short) 1) // 直接设置为处理中
.setApprovalUserId(request.getHandlerUserId())
.setApprovalUserName(handlerUser.getUserName())
.setApprovalTime(now)
.setCreateUserId(userId)
.setCreateUserName(userName)
.setCreateTime(now)
.setUpdateUserId(userId)
.setUpdateUserName(userName)
.setUpdateTime(now);
issueTicketService.save(entity);
}
/**
* 平板端查询巡检工单列表
* 仅查询当前登录人创建的巡检工单（sourceType=2）
*/
public PageData<QmsIssueTicketVO> searchTabletInspectionTickets(@Valid QmsIssueTicketTabletSearchQO request) {
Long currentUserId = UserUtil.getUserId();
// 构建查询条件
LambdaQueryWrapper<QmsIssueTicket> wrapper = new LambdaQueryWrapper<>();
// 固定条件：仅查询巡检工单（sourceType=2）
wrapper.eq(QmsIssueTicket::getSourceType, (short) 2);
// 固定条件：仅查询当前登录人创建的工单
wrapper.eq(QmsIssueTicket::getCreateUserId, currentUserId);
// 可选条件：工单状态
wrapper.eq(request.getStatus() != null, QmsIssueTicket::getStatus, request.getStatus());
// 可选条件：工单标题（模糊匹配）
wrapper.like(StrUtil.isNotBlank(request.getTicketTitle()),
QmsIssueTicket::getTicketTitle, request.getTicketTitle());
// 可选条件：工单编号（模糊匹配）
wrapper.like(StrUtil.isNotBlank(request.getTicketNo()),
QmsIssueTicket::getTicketNo, request.getTicketNo());
// 可选条件：提交人（模糊匹配）
wrapper.like(StrUtil.isNotBlank(request.getCreateUserName()),
QmsIssueTicket::getCreateUserName, request.getCreateUserName());
// 排序：按创建时间倒序
wrapper.orderByDesc(QmsIssueTicket::getCreateTime);
// 分页查询
Page<QmsIssueTicket> page = new Page<>(request.getPage(), request.getPageSize());
Page<QmsIssueTicket> resultPage = issueTicketService.page(page, wrapper);
// 转换为VO
List<QmsIssueTicketVO> voList = resultPage.getRecords().stream()
.map(ticket -> {
QmsIssueTicketVO vo = new QmsIssueTicketVO();
vo.setId(ticket.getId());
vo.setTicketNo(ticket.getTicketNo());
vo.setTicketTitle(ticket.getTicketTitle());
vo.setProjectNo(ticket.getProjectNo());
vo.setIncidentType(ticket.getIncidentType());
vo.setExceptionCode(ticket.getExceptionCode());
vo.setSourceType(ticket.getSourceType());
vo.setCreateUserName(ticket.getCreateUserName());
vo.setCreateTime(ticket.getCreateTime());
vo.setStatus(ticket.getStatus());
return vo;
})
.collect(Collectors.toList());
// 构建分页结果
PageData<QmsIssueTicketVO> pageData = new PageData<>();
pageData.setItems(voList);
pageData.setTotal((int) resultPage.getTotal());
pageData.setPage((int) resultPage.getCurrent());
pageData.setPageSize((int) resultPage.getSize());
return pageData;
}
/**
* 新增PDI检测工单
* 工单编号自动生成（序号38），来源类型固定为1（PDI检测任务），状态默认为0（待流转）
@ -1209,6 +1415,165 @@ public class QmsIssueTicketControllerService {
return vo;
}
/**
* 查询巡检工单详情
* 返回工单基本信息、图片列表、处理人信息、纠正措施等
*/
public QmsInspectionTicketDetailVO getInspectionTicketDetail(Long id) {
// 查询工单基本信息
QmsIssueTicket ticket = issueTicketService.getById(id);
if (Objects.isNull(ticket)) {
throw new NflgException(STATE.BusinessError, "巡检工单不存在");
}
// 校验工单来源类型为巡检
if (!Objects.equals(ticket.getSourceType(), (short) 2)) {
throw new NflgException(STATE.BusinessError, "该工单不是巡检工单");
}
QmsInspectionTicketDetailVO vo = new QmsInspectionTicketDetailVO();
// 填充工单基本信息
vo.setTicketTitle(ticket.getTicketTitle());
vo.setProjectNo(ticket.getProjectNo());
vo.setIncidentType(ticket.getIncidentType());
vo.setExceptionCode(ticket.getExceptionCode());
vo.setCreateUserName(ticket.getCreateUserName());
vo.setCreateTime(ticket.getCreateTime());
vo.setUnqualifiedQty(ticket.getUnqualifiedQty());
vo.setTicketType("巡检");
vo.setIncidentLocation(ticket.getIncidentLocation());
vo.setIncidentDescription(ticket.getIncidentDescription());
vo.setIncidentReason(ticket.getIncidentReason());
vo.setIncidentConsequence(ticket.getIncidentConsequence());
// 解析图片列表
if (StrUtil.isNotBlank(ticket.getImageIds())) {
List<Long> imageIds = Arrays.stream(ticket.getImageIds().split(","))
.filter(StrUtil::isNotBlank)
.map(String::trim)
.map(Long::valueOf)
.collect(Collectors.toList());
if (CollectionUtil.isNotEmpty(imageIds)) {
List<FileUploadRecord> records = fileUploadRecordService.lambdaQuery()
.in(FileUploadRecord::getId, imageIds)
.list();
Map<Long, FileUploadRecord> imageMap = records.stream()
.collect(Collectors.toMap(FileUploadRecord::getId, r -> r, (a, b) -> a));
List<QmsInspectionTicketDetailVO.FileDetailVO> imageList = imageIds.stream()
.map(imageMap::get)
.filter(Objects::nonNull)
.map(record -> {
QmsInspectionTicketDetailVO.FileDetailVO fileVO = new QmsInspectionTicketDetailVO.FileDetailVO();
fileVO.setId(record.getId());
fileVO.setFileName(record.getFileName());
fileVO.setFileType(record.getFileType());
fileVO.setUrl(record.getUrl());
return fileVO;
})
.collect(Collectors.toList());
vo.setImages(imageList);
} else {
vo.setImages(List.of());
}
} else {
vo.setImages(List.of());
}
// 查询处理记录（取第一条）
List<QmsIssueTicketProcess> processes = issueTicketProcessService.lambdaQuery()
.eq(QmsIssueTicketProcess::getIssueTicketId, id)
.list();
if (CollectionUtil.isNotEmpty(processes)) {
QmsIssueTicketProcess process = processes.get(0);
// 填充处理人信息
vo.setHandlerUserName(process.getHandlerUserName());
// 查询处理人部门
if (process.getHandlerUserId() != null) {
UserInterior userInterior = userInteriorService.lambdaQuery()
.eq(UserInterior::getUserId, process.getHandlerUserId())
.one();
if (userInterior != null && userInterior.getDeptId() != null) {
Department department = departmentService.getById(userInterior.getDeptId());
if (department != null) {
vo.setHandlerDeptName(department.getName());
}
}
}
// 填充根本原因
if (StrUtil.isNotBlank(process.getRootCause())) {
vo.setRootCause(process.getRootCause());
}
// 填充上级领导信息
if (StrUtil.isNotBlank(process.getLeaderUserName())) {
vo.setLeaderUserName(process.getLeaderUserName());
// 查询领导部门
if (process.getLeaderUserId() != null) {
UserInterior leaderInterior = userInteriorService.lambdaQuery()
.eq(UserInterior::getUserId, process.getLeaderUserId())
.one();
if (leaderInterior != null && leaderInterior.getDeptId() != null) {
Department leaderDepartment = departmentService.getById(leaderInterior.getDeptId());
if (leaderDepartment != null) {
vo.setLeaderDeptName(leaderDepartment.getName());
}
}
}
}
// 查询纠正措施
Long temporaryTypeId = dictionaryItemService.getIdByCode("MeasureType", "TemporaryCorrectiveMeasures");
Long permanentTypeId = dictionaryItemService.getIdByCode("MeasureType", "PermanentCorrectiveMeasures");
List<QmsInspectionTicketDetailVO.MeasureVO> temporaryMeasures = new ArrayList<>();
List<QmsInspectionTicketDetailVO.MeasureVO> permanentMeasures = new ArrayList<>();
for (QmsIssueTicketProcess p : processes) {
List<QmsIssueTicketProcessMeasure> measures = issueTicketProcessMeasureService.lambdaQuery()
.eq(QmsIssueTicketProcessMeasure::getIssueTicketProcessId, p.getId())
.list();
for (QmsIssueTicketProcessMeasure measure : measures) {
QmsInspectionTicketDetailVO.MeasureVO measureVO = new QmsInspectionTicketDetailVO.MeasureVO();
measureVO.setMeasureTypeId(measure.getMeasureTypeId());
measureVO.setMeasureContent(measure.getMeasureContent());
measureVO.setChargeUser(measure.getChargeUser());
measureVO.setPlanDate(measure.getPlanDate());
measureVO.setConfirmDate(measure.getConfirmDate());
measureVO.setRemark(measure.getRemark());
// 根据measureTypeId区分临时措施和永久措施
if (measure.getMeasureTypeId() != null) {
if (measure.getMeasureTypeId().equals(temporaryTypeId)) {
temporaryMeasures.add(measureVO);
} else if (measure.getMeasureTypeId().equals(permanentTypeId)) {
permanentMeasures.add(measureVO);
}
}
}
}
vo.setTemporaryMeasures(temporaryMeasures);
vo.setPermanentMeasures(permanentMeasures);
} else {
// 如果没有处理记录，设置空列表
vo.setTemporaryMeasures(List.of());
vo.setPermanentMeasures(List.of());
}
return vo;
}
/**
* 将逗号分隔的图片ID字符串转换为 FileDetailVO 列表
*/

229
nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmsIssueTicketProcessControllerService.java
View File

@ -4,7 +4,6 @@ import com.nflg.wms.common.constant.STATE;
import com.nflg.wms.common.exception.NflgException;
import com.nflg.wms.common.pojo.qo.QmsIssueTicketProcessAddQO;
import com.nflg.wms.common.pojo.qo.QmsIssueTicketProcessDraftQO;
import com.nflg.wms.common.pojo.qo.QmsIssueTicketProcessLeaderDraftQO;
import com.nflg.wms.common.util.UserUtil;
import com.nflg.wms.common.util.VUtil;
import com.nflg.wms.repository.entity.Department;
@ -130,14 +129,151 @@ public class QmsIssueTicketProcessControllerService {
}
/**
* 提交工单处理：
* 1. 校验 approvalStatus 必传
* 2. 执行保存逻辑（复用 draft）
* 3. approvalStatus=1（驳回）：推送待办给工单创建人
* 4. approvalStatus=0（通过）：推送给当前用户所在部门负责人（TODO: 部门负责人字段暂无，后续补充）
* 统一提交接口：根据source_type和提交人身份自动判断处理逻辑
*/
@Transactional(rollbackFor = Exception.class)
public void submit(@Valid QmsIssueTicketProcessDraftQO request) {
public void submitUnified(@Valid QmsIssueTicketProcessDraftQO request) {
Long currentUserId = UserUtil.getUserId();
String currentUserName = UserUtil.getUserName();
LocalDateTime now = LocalDateTime.now();
// 1. 查询处理记录
QmsIssueTicketProcess process = issueTicketProcessService.getById(request.getId());
VUtil.trueThrowBusinessError(Objects.isNull(process)).throwMessage("工单处理记录不存在");
// 2. 查询工单获取source_type
QmsIssueTicket ticket = issueTicketService.getById(process.getIssueTicketId());
VUtil.trueThrowBusinessError(Objects.isNull(ticket)).throwMessage("工单不存在");
Short sourceType = ticket.getSourceType();
Long handlerUserId = process.getHandlerUserId();
// 3. 判断是否为处理人本人提交
boolean isHandler = currentUserId.equals(handlerUserId);
if (sourceType == 1) {
// PDI检测任务
if (isHandler) {
// 处理人审批
submitUnifiedForPDIHandler(request, ticket, process, now);
} else {
// 领导审批
leaderSubmitUnified(request, ticket, process, now, currentUserId, currentUserName);
}
} else if (sourceType == 2) {
// 巡检任务
if (isHandler) {
// 处理人处理：保存根本原因和措施，写入审批时间
issueTicketProcessMeasureControllerService.draftUnified(request);
// 写入审批时间
issueTicketProcessService.lambdaUpdate()
.eq(QmsIssueTicketProcess::getId, request.getId())
.set(QmsIssueTicketProcess::getApprovalTime, now)
.update();
// 推送给领导（处理人所在部门负责人）
UserInterior userInterior = userInteriorService.lambdaQuery()
.eq(UserInterior::getUserId, currentUserId)
.one();
if (userInterior != null && userInterior.getDeptId() != null) {
Department department = departmentService.getById(userInterior.getDeptId());
if (department != null && department.getHeadUserId() != null) {
Long sourceTypeId = dictionaryItemService.getIdByCode("MessageType", "InspectionTaskWorkOrder");
QmsTodoItem todoItem = new QmsTodoItem()
.setCode(ticket.getTicketNo())
.setIsRead(false)
.setSourceTypeId(sourceTypeId)
.setSourceId(process.getId())
.setCreateUserId(department.getHeadUserId())
.setCreateUserName(department.getHeadUserName())
.setCreateTime(now);
todoItemService.save(todoItem);
}
}
} else {
// 领导审批
leaderSubmitUnified(request, ticket, process, now, currentUserId, currentUserName);
}
} else {
throw new NflgException(STATE.BusinessError, "不支持的工单类型");
}
}
/**
* 领导审批统一处理（PDI和巡检共用）
*/
private void leaderSubmitUnified(QmsIssueTicketProcessDraftQO request, QmsIssueTicket ticket,
QmsIssueTicketProcess process, LocalDateTime now,
Long currentUserId, String currentUserName) {
// 1. 校验审批状态必传
VUtil.trueThrowBusinessError(Objects.isNull(request.getApprovalStatus()))
.throwMessage("提交时审批状态不能为空");
// 2. 保存数据：前端传入approvalStatus/approvalOpinion，数据库填入leaderApprovalResult/leaderApprovalOpinion
issueTicketProcessService.lambdaUpdate()
.eq(QmsIssueTicketProcess::getId, request.getId())
.set(request.getApprovalOpinion() != null,
QmsIssueTicketProcess::getLeaderApprovalOpinion, request.getApprovalOpinion())
.set(request.getApprovalStatus() != null,
QmsIssueTicketProcess::getLeaderApprovalResult, request.getApprovalStatus())
.set(QmsIssueTicketProcess::getLeaderUserId, currentUserId)
.set(QmsIssueTicketProcess::getLeaderUserName, UserUtil.getUserName())
.set(QmsIssueTicketProcess::getLeaderApprovalTime, now)
.update();
Short leaderApprovalResult = request.getApprovalStatus();
if (leaderApprovalResult == 0) {
// 驳回：推送待办给处理人
Long sourceTypeId = dictionaryItemService.getIdByCode("MessageType", "InspectionTaskWorkOrder");
User handler = userService.getById(process.getHandlerUserId());
QmsTodoItem todoItem = new QmsTodoItem()
.setCode(ticket.getTicketNo())
.setIsRead(false)
.setSourceTypeId(sourceTypeId)
.setSourceId(process.getId())
.setCreateUserId(process.getHandlerUserId())
.setCreateUserName(handler != null ? handler.getUserName() : null)
.setCreateTime(now);
todoItemService.save(todoItem);
} else if (leaderApprovalResult == 1) {
// 同意：检查同一工单下所有处理记录是否都已完成
Long issueTicketId = process.getIssueTicketId();
// 查询同一工单下是否存在未完成的记录
long notCompleted = issueTicketProcessService.lambdaQuery()
.eq(QmsIssueTicketProcess::getIssueTicketId, issueTicketId)
.and(w -> w
.ne(true, QmsIssueTicketProcess::getLeaderApprovalResult, (short) 1)
.or()
.isNull(QmsIssueTicketProcess::getLeaderApprovalResult))
.and(w -> w
.ne(true, QmsIssueTicketProcess::getApprovalStatus, (short) 1)
.or()
.isNull(QmsIssueTicketProcess::getApprovalStatus))
.count();
// 如果所有记录都已完成，更新工单状态为已完成
if (notCompleted == 0) {
issueTicketService.lambdaUpdate()
.eq(QmsIssueTicket::getId, issueTicketId)
.set(QmsIssueTicket::getStatus, (short) 2)
.set(QmsIssueTicket::getCompleteTime, now)
.set(QmsIssueTicket::getUpdateUserId, currentUserId)
.set(QmsIssueTicket::getUpdateUserName, currentUserName)
.set(QmsIssueTicket::getUpdateTime, now)
.update();
}
}
}
/**
* PDI处理人提交（sourceType=1且isHandler=true）
*/
private void submitUnifiedForPDIHandler(QmsIssueTicketProcessDraftQO request, QmsIssueTicket ticket,
QmsIssueTicketProcess process, LocalDateTime now) {
// 1. 校验审批状态必传
VUtil.trueThrowBusinessError(Objects.isNull(request.getApprovalStatus()))
.throwMessage("提交时审批状态不能为空");
@ -148,19 +284,14 @@ public class QmsIssueTicketProcessControllerService {
// 3. 写入审批时间
issueTicketProcessService.lambdaUpdate()
.eq(QmsIssueTicketProcess::getId, request.getId())
.set(QmsIssueTicketProcess::getApprovalTime, LocalDateTime.now())
.set(QmsIssueTicketProcess::getApprovalTime, now)
.update();
// 4. 查询工单处理记录，获取关联的工单
QmsIssueTicketProcess process = issueTicketProcessService.getById(request.getId());
QmsIssueTicket ticket = issueTicketService.getById(process.getIssueTicketId());
VUtil.trueThrowBusinessError(Objects.isNull(ticket)).throwMessage("关联的质量问题工单不存在");
// 4. 根据审批状态推送待办
Long sourceTypeId = dictionaryItemService.getIdByCode("MessageType", "RejectedPDIDefectiveProductHandling");
LocalDateTime now = LocalDateTime.now();
if (request.getApprovalStatus() == 1) {
// 驳回：推送待办给工单创建人（分配任务的user）
// 驳回：推送待办给工单创建人
User creator = userService.getById(ticket.getCreateUserId());
QmsTodoItem todoItem = new QmsTodoItem()
.setCode(ticket.getTicketNo())
@ -193,72 +324,4 @@ public class QmsIssueTicketProcessControllerService {
}
}
}
/**
* 领导提交工单处理：
* 1. 校验 leaderApprovalResult 必传
* 2. 执行保存逻辑（复用 leaderDraft）+ 写入审批时间
* 3. leaderApprovalResult=0（驳回）：推送待办给处理人
* 4. leaderApprovalResult=1（同意）：结束流程
*/
@Transactional(rollbackFor = Exception.class)
public void leaderSubmit(@Valid QmsIssueTicketProcessLeaderDraftQO request) {
// 1. 校验领导审批结果必传
VUtil.trueThrowBusinessError(Objects.isNull(request.getLeaderApprovalResult()))
.throwMessage("提交时领导审批结果不能为空");
// 2. 保存数据（leaderDraft 已写入领导信息 + 审批时间）
issueTicketProcessMeasureControllerService.leaderDraft(request);
LocalDateTime now = LocalDateTime.now();
if (request.getLeaderApprovalResult() == 0) {
// 驳回：推送待办给处理人
QmsIssueTicketProcess process = issueTicketProcessService.getById(request.getId());
QmsIssueTicket ticket = issueTicketService.getById(process.getIssueTicketId());
VUtil.trueThrowBusinessError(Objects.isNull(ticket)).throwMessage("关联的质量问题工单不存在");
Long sourceTypeId = dictionaryItemService.getIdByCode("MessageType", "RejectedPDIDefectiveProductHandling");
User handler = userService.getById(process.getHandlerUserId());
QmsTodoItem todoItem = new QmsTodoItem()
.setCode(ticket.getTicketNo())
.setIsRead(false)
.setSourceTypeId(sourceTypeId)
.setSourceId(process.getId())
.setCreateUserId(process.getHandlerUserId())
.setCreateUserName(handler != null ? handler.getUserName() : null)
.setCreateTime(now);
todoItemService.save(todoItem);
} else if (request.getLeaderApprovalResult() == 1) {
// 同意：检查同一工单下所有处理记录是否都已完成
QmsIssueTicketProcess current = issueTicketProcessService.getById(request.getId());
Long issueTicketId = current.getIssueTicketId();
// 查询同一工单下是否存在未完成的记录
// 完成条件：leaderApprovalResult=1 或（leaderApprovalResult为空 且 approvalStatus=1）
// 未完成：不满足以上任一条件的记录
long notCompleted = issueTicketProcessService.lambdaQuery()
.eq(QmsIssueTicketProcess::getIssueTicketId, issueTicketId)
.and(w -> w
// 排除 leaderApprovalResult=1 的（已完成）
.ne(true, QmsIssueTicketProcess::getLeaderApprovalResult, (short) 1)
.or()
.isNull(QmsIssueTicketProcess::getLeaderApprovalResult))
// 在 leaderApprovalResult 不为1的记录中，排除 approvalStatus=1 的（处理人驳回，也算完成）
.and(w -> w
.ne(true, QmsIssueTicketProcess::getApprovalStatus, (short) 1)
.or()
.isNull(QmsIssueTicketProcess::getApprovalStatus))
.count();
if (notCompleted == 0) {
// 所有处理记录都已完成，更新工单状态为已完成(2)
issueTicketService.lambdaUpdate()
.eq(QmsIssueTicket::getId, issueTicketId)
.set(QmsIssueTicket::getStatus, (short) 2)
.set(QmsIssueTicket::getCompleteTime, now) // 设置完成时间
.update();
}
}
}
}

88
nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmsIssueTicketProcessMeasureControllerService.java
View File

@ -4,13 +4,14 @@ import cn.hutool.core.util.StrUtil;
import com.nflg.wms.common.constant.STATE;
import com.nflg.wms.common.exception.NflgException;
import com.nflg.wms.common.pojo.qo.QmsIssueTicketProcessDraftQO;
import com.nflg.wms.common.pojo.qo.QmsIssueTicketProcessLeaderDraftQO;
import com.nflg.wms.common.util.UserUtil;
import com.nflg.wms.common.util.VUtil;
import com.nflg.wms.repository.entity.QmsIssueTicket;
import com.nflg.wms.repository.entity.QmsIssueTicketProcess;
import com.nflg.wms.repository.entity.QmsIssueTicketProcessMeasure;
import com.nflg.wms.repository.service.IQmsIssueTicketProcessMeasureService;
import com.nflg.wms.repository.service.IQmsIssueTicketProcessService;
import com.nflg.wms.repository.service.IQmsIssueTicketService;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import org.springframework.stereotype.Service;
@ -31,6 +32,9 @@ public class QmsIssueTicketProcessMeasureControllerService {
@Resource
private IQmsIssueTicketProcessService issueTicketProcessService;
@Resource
private IQmsIssueTicketService issueTicketService;
/**
* 暂存工单处理：更新工单处理记录，有措施内容则新增一条措施记录
*/
@ -73,19 +77,91 @@ public class QmsIssueTicketProcessMeasureControllerService {
* 领导暂存：更新领导审批意见、审批结果，写入领导信息
*/
@Transactional(rollbackFor = Exception.class)
public void leaderDraft(@Valid QmsIssueTicketProcessLeaderDraftQO request) {
public void leaderDraft(@Valid QmsIssueTicketProcessDraftQO request) {
QmsIssueTicketProcess process = issueTicketProcessService.getById(request.getId());
VUtil.trueThrowBusinessError(Objects.isNull(process)).throwMessage("工单处理记录不存在");
// 前端传入approvalOpinion/approvalStatus，数据库填入leaderApprovalOpinion/leaderApprovalResult
issueTicketProcessService.lambdaUpdate()
.eq(QmsIssueTicketProcess::getId, request.getId())
.set(request.getLeaderApprovalOpinion() != null,
QmsIssueTicketProcess::getLeaderApprovalOpinion, request.getLeaderApprovalOpinion())
.set(request.getLeaderApprovalResult() != null,
QmsIssueTicketProcess::getLeaderApprovalResult, request.getLeaderApprovalResult())
.set(request.getApprovalOpinion() != null,
QmsIssueTicketProcess::getLeaderApprovalOpinion, request.getApprovalOpinion())
.set(request.getApprovalStatus() != null,
QmsIssueTicketProcess::getLeaderApprovalResult, request.getApprovalStatus())
.set(QmsIssueTicketProcess::getLeaderUserId, UserUtil.getUserId())
.set(QmsIssueTicketProcess::getLeaderUserName, UserUtil.getUserName())
.set(QmsIssueTicketProcess::getLeaderApprovalTime, LocalDateTime.now())
.update();
}
/**
* 统一暂存接口：根据source_type和提交人身份自动判断处理逻辑
*/
@Transactional(rollbackFor = Exception.class)
public void draftUnified(@Valid QmsIssueTicketProcessDraftQO request) {
Long currentUserId = UserUtil.getUserId();
// 1. 查询处理记录
QmsIssueTicketProcess process = issueTicketProcessService.getById(request.getId());
VUtil.trueThrowBusinessError(Objects.isNull(process)).throwMessage("工单处理记录不存在");
// 2. 查询工单获取source_type
QmsIssueTicket ticket = issueTicketService.getById(process.getIssueTicketId());
VUtil.trueThrowBusinessError(Objects.isNull(ticket)).throwMessage("工单不存在");
Short sourceType = ticket.getSourceType();
Long handlerUserId = process.getHandlerUserId();
// 3. 判断是否为处理人本人提交
boolean isHandler = currentUserId.equals(handlerUserId);
if (sourceType == 1) {
// PDI检测任务
if (isHandler) {
// 处理人审批
draft(request);
} else {
// 领导审批
leaderDraft(request);
}
} else if (sourceType == 2) {
// 巡检任务
if (isHandler) {
// 处理人处理：只填根本原因和措施，不填审批状态
issueTicketProcessService.lambdaUpdate()
.eq(QmsIssueTicketProcess::getId, request.getId())
.set(request.getRootCause() != null, QmsIssueTicketProcess::getRootCause, request.getRootCause())
.set(QmsIssueTicketProcess::getApprovalUserId, currentUserId)
.set(QmsIssueTicketProcess::getApprovalUserName, UserUtil.getUserName())
.update();
// 有措施内容则新增
if (StrUtil.isNotBlank(request.getMeasureContent())) {
QmsIssueTicketProcessMeasure measure = new QmsIssueTicketProcessMeasure()
.setIssueTicketProcessId(request.getId())
.setMeasureContent(request.getMeasureContent())
.setMeasureTypeId(request.getMeasureTypeId())
.setChargeUser(UserUtil.getUserName())
.setPlanDate(request.getPlanDate())
.setConfirmDate(request.getConfirmDate())
.setRemark(request.getRemark());
issueTicketProcessMeasureService.save(measure);
}
} else {
// 领导审批：前端传入approvalStatus/approvalOpinion，数据库填入leaderApprovalResult/leaderApprovalOpinion
issueTicketProcessService.lambdaUpdate()
.eq(QmsIssueTicketProcess::getId, request.getId())
.set(request.getApprovalOpinion() != null,
QmsIssueTicketProcess::getLeaderApprovalOpinion, request.getApprovalOpinion())
.set(request.getApprovalStatus() != null,
QmsIssueTicketProcess::getLeaderApprovalResult, request.getApprovalStatus())
.set(QmsIssueTicketProcess::getLeaderUserId, currentUserId)
.set(QmsIssueTicketProcess::getLeaderUserName, UserUtil.getUserName())
.set(QmsIssueTicketProcess::getLeaderApprovalTime, LocalDateTime.now())
.update();
}
} else {
throw new NflgException(STATE.BusinessError, "不支持的工单类型");
}
}
}

11
nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmsPdiDeliveryItemControllerService.java
View File

@ -99,15 +99,14 @@ public class QmsPdiDeliveryItemControllerService {
// ========================= 删除 =========================
/**
* 删除PDI发货前检查项
* 批量删除PDI发货前检查项
*/
@Transactional
public void delete(Long id) {
QmsPdiDetectionRulesDeliveryItem existing = deliveryItemService.getById(id);
if (Objects.isNull(existing)) {
throw new NflgException(STATE.BusinessError, "检查项不存在");
public void batchDelete(List<Long> ids) {
if (CollectionUtil.isEmpty(ids)) {
throw new NflgException(STATE.BusinessError, "ID列表不能为空");
}
deliveryItemService.removeById(id);
deliveryItemService.removeByIds(ids);
}
// ========================= 导出 =========================

50
nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmsPdiDetectionRulesControllerService.java
View File

@ -270,31 +270,43 @@ public class QmsPdiDetectionRulesControllerService {
// ========================= 删除 =========================
/**
* 删除PDI检测规则
* 批量删除PDI检测规则
* 已发布不可删除，未发布且已启用不可删除
*/
@Transactional
public void delete(Long id) {
QmsPdiDetectionRules existing = pdiDetectionRulesService.getById(id);
if (Objects.isNull(existing)) {
throw new NflgException(STATE.BusinessError, "PDI检测规则不存在");
public void batchDelete(List<Long> ids) {
if (CollectionUtil.isEmpty(ids)) {
throw new NflgException(STATE.BusinessError, "ID列表不能为空");
}
if (Boolean.TRUE.equals(existing.getPublishEnable())) {
throw new NflgException(STATE.BusinessError, "已发布的规则不允许删除");
// 逐条校验
for (Long id : ids) {
QmsPdiDetectionRules existing = pdiDetectionRulesService.getById(id);
if (Objects.isNull(existing)) {
throw new NflgException(STATE.BusinessError, "PDI检测规则【" + id + "】不存在");
}
if (Boolean.TRUE.equals(existing.getPublishEnable())) {
throw new NflgException(STATE.BusinessError, "规则【" + existing.getRuleNo() + "】已发布，不允许删除");
}
if (Boolean.TRUE.equals(existing.getEnable())) {
throw new NflgException(STATE.BusinessError, "规则【" + existing.getRuleNo() + "】已启用，不允许删除，请先禁用后再删除");
}
}
if (Boolean.TRUE.equals(existing.getEnable())) {
throw new NflgException(STATE.BusinessError, "未发布且已启用的规则不允许删除，请先禁用后再删除");
// 批量级联删除子表数据
for (Long id : ids) {
// 级联删除动静态检测项
statusItemService.lambdaUpdate()
.eq(QmsPdiDetectionRulesStatusItem::getDetectionRulesId, id)
.remove();
// 级联删除发货前检查项
deliveryItemService.lambdaUpdate()
.eq(QmsPdiDetectionRulesDeliveryItem::getDetectionRulesId, id)
.remove();
}
// 级联删除动静态检测项
statusItemService.lambdaUpdate()
.eq(QmsPdiDetectionRulesStatusItem::getDetectionRulesId, id)
.remove();
// 级联删除发货前检查项
deliveryItemService.lambdaUpdate()
.eq(QmsPdiDetectionRulesDeliveryItem::getDetectionRulesId, id)
.remove();
// 删除主表
pdiDetectionRulesService.removeById(id);
// 批量删除主表
pdiDetectionRulesService.removeByIds(ids);
}
// ========================= 启用/禁用 =========================

31
nflg-qms-admin/src/main/java/com/nflg/qms/admin/service/QmsPdiStatusItemControllerService.java
View File

@ -137,15 +137,14 @@ public class QmsPdiStatusItemControllerService {
// ========================= 删除 =========================
/**
* 删除PDI检测项
* 批量删除PDI检测项
*/
@Transactional
public void delete(Long id) {
QmsPdiDetectionRulesStatusItem existing = statusItemService.getById(id);
if (Objects.isNull(existing)) {
throw new NflgException(STATE.BusinessError, "检测项不存在");
public void batchDelete(List<Long> ids) {
if (CollectionUtil.isEmpty(ids)) {
throw new NflgException(STATE.BusinessError, "ID列表不能为空");
}
statusItemService.removeById(id);
statusItemService.removeByIds(ids);
}
// ========================= 导出 =========================
@ -298,7 +297,25 @@ public class QmsPdiStatusItemControllerService {
vo.setDetectionRulesId(item.getDetectionRulesId());
vo.setComponentsDes(item.getComponentsDes());
vo.setInspectionContent(item.getInspectionContent());
vo.setInspectionImage(item.getInspectionImage());
// 将inspectionImage从文件ID转换为URL
if (StrUtil.isNotBlank(item.getInspectionImage())) {
try {
Long fileId = Long.valueOf(item.getInspectionImage().trim());
FileUploadRecord fileRecord = fileUploadRecordService.getById(fileId);
if (fileRecord != null && StrUtil.isNotBlank(fileRecord.getUrl())) {
vo.setInspectionImage(fileRecord.getUrl());
} else {
vo.setInspectionImage("");
}
} catch (NumberFormatException e) {
// 如果不是有效的数字ID，返回空字符串
vo.setInspectionImage("");
}
} else {
vo.setInspectionImage("");
}
vo.setStatus(item.getStatus());
vo.setSort(item.getSort());
vo.setCreateBy(item.getCreateBy());

83
nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/qo/QmsIssueTicketAddAndDispatchQO.java Normal file
View File

@ -0,0 +1,83 @@
package com.nflg.wms.common.pojo.qo;
import com.nflg.wms.common.pojo.vo.FileUploadVO;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.util.List;
/**
* 新增巡检工单并发布请求参数
*/
@Data
public class QmsIssueTicketAddAndDispatchQO {
/**
* 工单标题
*/
@NotBlank(message = "工单标题不能为空")
private String ticketTitle;
/**
* 工程编号
*/
private String projectNo;
/**
* 事故类型：0=一般，1=较严重，2=严重
*/
@NotNull(message = "事故类型不能为空")
private Short incidentType;
/**
* 异常代码
*/
private String exceptionCode;
/**
* 不合格数量
*/
private Integer unqualifiedQty;
/**
* 影响数量
*/
private String impactQuantity;
/**
* 事件地点
*/
private String incidentLocation;
/**
* 事件描述
*/
private String incidentDescription;
/**
* 事件原因
*/
private String incidentReason;
/**
* 事件后果
*/
private String incidentConsequence;
/**
* 图片列表
*/
private List<FileUploadVO> images;
/**
* 备注
*/
private String remark;
/**
* 负责人ID（user表里的id）
*/
@NotNull(message = "负责人ID不能为空")
private Long handlerUserId;
}

26
nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/qo/QmsIssueTicketDispatchMultipleQO.java Normal file
View File

@ -0,0 +1,26 @@
package com.nflg.wms.common.pojo.qo;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.util.List;
/**
* 巡检工单分派请求参数
*/
@Data
public class QmsIssueTicketDispatchMultipleQO {
/**
* 工单ID（qms_issue_ticket.id）
*/
@NotNull(message = "工单ID不能为空")
private Long id;
/**
* 处理人ID列表
*/
@NotEmpty(message = "处理人列表不能为空")
private List<Long> handlerUserIds;
}

32
nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/qo/QmsIssueTicketTabletSearchQO.java Normal file
View File

@ -0,0 +1,32 @@
package com.nflg.wms.common.pojo.qo;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 平板端巡检工单列表查询参数
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class QmsIssueTicketTabletSearchQO extends PageQO {
/**
* 工单状态：0=待流转，1=处理中，2=已完成（可选）
*/
private Short status;
/**
* 工单标题（模糊匹配，可选）
*/
private String ticketTitle;
/**
* 工单编号（模糊匹配，可选）
*/
private String ticketNo;
/**
* 提交人姓名（模糊匹配，可选）
*/
private String createUserName;
}

3
nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/qo/QmsPdiStatusItemAddQO.java
View File

@ -28,9 +28,8 @@ public class QmsPdiStatusItemAddQO {
private String inspectionContent;
/**
* 检测示例图（文件记录ID，必传）
* 检测示例图（文件记录ID，可选）
*/
@NotNull(message = "检测示例图不能为空")
private String inspectionImage;
/**

178
nflg-wms-common/src/main/java/com/nflg/wms/common/pojo/vo/QmsInspectionTicketDetailVO.java Normal file
View File

@ -0,0 +1,178 @@
package com.nflg.wms.common.pojo.vo;
import lombok.Data;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
/**
* 巡检工单详情
*/
@Data
public class QmsInspectionTicketDetailVO {
/**
* 工单标题
*/
private String ticketTitle;
/**
* 工程编号
*/
private String projectNo;
/**
* 事故类型：0=一般，1=较严重，2=严重
*/
private Short incidentType;
/**
* 异常代码
*/
private String exceptionCode;
/**
* 提交人（创建人）
*/
private String createUserName;
/**
* 反馈时间（创建时间）
*/
private LocalDateTime createTime;
/**
* 数量（不合格数量）
*/
private Integer unqualifiedQty;
/**
* 工单类型（巡检）
*/
private String ticketType;
/**
* 事件地点
*/
private String incidentLocation;
/**
* 事件描述
*/
private String incidentDescription;
/**
* 事件原因
*/
private String incidentReason;
/**
* 事件后果
*/
private String incidentConsequence;
/**
* 图片列表
*/
private List<FileDetailVO> images;
/**
* 处理人姓名
*/
private String handlerUserName;
/**
* 处理人部门
*/
private String handlerDeptName;
/**
* 临时纠正措施列表
*/
private List<MeasureVO> temporaryMeasures;
/**
* 永久纠正措施列表
*/
private List<MeasureVO> permanentMeasures;
/**
* 根本原因
*/
private String rootCause;
/**
* 上级领导姓名
*/
private String leaderUserName;
/**
* 领导部门
*/
private String leaderDeptName;
/**
* 文件详情
*/
@Data
public static class FileDetailVO {
/**
* 文件记录ID
*/
private Long id;
/**
* 文件名称
*/
private String fileName;
/**
* 文件类型
*/
private String fileType;
/**
* 访问地址
*/
private String url;
}
/**
* 纠正措施
*/
@Data
public static class MeasureVO {
/**
* 措施类型ID，关联字典项表
*/
private Long measureTypeId;
/**
* 措施内容
*/
private String measureContent;
/**
* 负责人
*/
private String chargeUser;
/**
* 计划日期
*/
private LocalDate planDate;
/**
* 确认日期
*/
private LocalDate confirmDate;
/**
* 备注
*/
private String remark;
}
}

5
nflg-wms-repository/src/main/java/com/nflg/wms/repository/entity/QmsIssueTicket.java
View File

@ -179,9 +179,4 @@ public class QmsIssueTicket implements Serializable {
* 关联检测任务单号
*/
private String associationTaskNo;
/**
* 完成时间
*/
private LocalDateTime completeTime;
}