package org.jeecg.modules.eam.service.impl; import cn.hutool.core.collection.CollectionUtil; import cn.hutool.core.util.StrUtil; import com.alibaba.fastjson.JSON; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import org.apache.commons.lang3.StringUtils; import org.apache.shiro.SecurityUtils; import org.flowable.engine.TaskService; import org.flowable.task.api.Task; import org.jeecg.common.api.vo.Result; import org.jeecg.common.constant.CommonConstant; import org.jeecg.common.constant.DataBaseConstant; import org.jeecg.common.exception.JeecgBootException; import org.jeecg.common.system.vo.LoginUser; import org.jeecg.common.util.oConvertUtils; import org.jeecg.modules.eam.aspect.annotation.EquipmentHistoryLog; import org.jeecg.modules.eam.constant.*; import org.jeecg.modules.eam.entity.EamEquipment; import org.jeecg.modules.eam.entity.EamEquipmentLeanOut; import org.jeecg.modules.eam.mapper.EamEquipmentLeanOutMapper; import org.jeecg.modules.eam.request.EamEquipmentLeanOutQuery; import org.jeecg.modules.eam.request.EamEquipmentLeanOutRequest; import org.jeecg.modules.eam.service.IEamEquipmentLeanOutService; import org.jeecg.modules.eam.service.IEamEquipmentService; import org.jeecg.modules.flowable.apithird.business.entity.FlowMyBusiness; import org.jeecg.modules.flowable.apithird.business.service.IFlowMyBusinessService; import org.jeecg.modules.flowable.apithird.service.FlowCallBackServiceI; import org.jeecg.modules.flowable.apithird.service.FlowCommonService; import org.jeecg.modules.flowable.service.IFlowDefinitionService; import org.jeecg.modules.flowable.service.IFlowTaskService; import org.jeecg.modules.system.service.ISysUserService; import org.jeecg.modules.system.vo.UserSelector; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import javax.annotation.Resource; import java.util.*; import java.util.stream.Collectors; /** * @Description: 设备借出归还 * @Author: jeecg-boot * @Date: 2025-05-13 * @Version: V1.0 */ @Service("IEamEquipmentLeanOutService") public class EamEquipmentLeanOutServiceImpl extends ServiceImpl implements IEamEquipmentLeanOutService, FlowCallBackServiceI { @Resource private EamEquipmentLeanOutMapper equipmentLeanOutMapper; @Autowired private IEamEquipmentService eamEquipmentService; @Autowired private FlowCommonService flowCommonService; @Autowired private IFlowDefinitionService flowDefinitionService; @Autowired private IFlowMyBusinessService flowMyBusinessService; @Autowired private TaskService taskService; @Autowired private IFlowTaskService flowTaskService; @Autowired private ISysUserService sysUserService; @Override public IPage queryPageList(Page page, EamEquipmentLeanOutQuery query) { QueryWrapper queryWrapper = new QueryWrapper<>(); queryWrapper.eq("wmo.del_flag", CommonConstant.DEL_FLAG_0); //用户数据权限 LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); if (sysUser == null) { return page; } if (StringUtils.isNotBlank(sysUser.getEquipmentIds())) { //选择了设备，根据设备id过滤设备 List equipArr = Arrays.asList(sysUser.getEquipmentIds().split(",")); queryWrapper.in("e.equipment_code", equipArr); } else { //没有选择设备，根据车间过滤设备 queryWrapper.exists("select 1 from mdc_user_production t where t.user_id={0} and t.pro_id=e.org_id ", sysUser.getId()); } //查询条件过滤 if (query != null) { if (StringUtils.isNotBlank(query.getEquipmentId())) { queryWrapper.eq("wmo.equipment_id", query.getEquipmentId()); } if (StringUtils.isNotBlank(query.getCode())) { queryWrapper.like("wmo.code", query.getCode()); } if (StringUtils.isNotBlank(query.getLeanStatus())) { queryWrapper.eq("wmo.lean_status", query.getLeanStatus()); } if (query.getLeanDateBegin() != null && query.getLeanDateEnd() != null) { queryWrapper.between("wmo.lean_start_time", query.getLeanDateBegin(), query.getLeanDateEnd()); } //排序 if (StringUtils.isNotBlank(query.getColumn()) && StringUtils.isNotBlank(query.getOrder())) { String column = query.getColumn(); if (column.endsWith(CommonConstant.DICT_TEXT_SUFFIX)) { column = column.substring(0, column.lastIndexOf(CommonConstant.DICT_TEXT_SUFFIX)); } if (DataBaseConstant.SQL_ASC.equalsIgnoreCase(query.getOrder())) { queryWrapper.orderByAsc("wmo." + oConvertUtils.camelToUnderline(column)); } else { queryWrapper.orderByDesc("wmo." + oConvertUtils.camelToUnderline(column)); } } else { queryWrapper.orderByDesc("wmo.create_time"); } } else { queryWrapper.orderByDesc("wmo.create_time"); } return equipmentLeanOutMapper.queryPageList(page, queryWrapper); } @Override @Transactional(rollbackFor = Exception.class) public boolean addLeanOut(EamEquipmentLeanOut request) { //检查设备 EamEquipment equipment = eamEquipmentService.getById(request.getEquipmentId()); if (equipment == null) { throw new JeecgBootException("设备不存在！"); } if (!AssetStatusEnum.NORMAL.name().equals(equipment.getAssetStatus())) { throw new JeecgBootException("此设备当前资产状态不允许借出！"); } if (StringUtils.isBlank(request.getLeanDepartId())) { throw new JeecgBootException("借入车间不允许为空！"); } if (request.getLeanDepartId().equals(equipment.getOrgId())) { throw new JeecgBootException("当前设备属于此车间，不需要借用！"); } LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); if (sysUser == null) { throw new JeecgBootException("当前用户无法添加借用记录！"); } request.setLeanPerson(sysUser.getUsername()); return equipmentLeanOutMapper.insert(request) > 0; } @Override @Transactional(rollbackFor = Exception.class) public boolean editLeanOut(EamEquipmentLeanOut request) { EamEquipmentLeanOut entity = equipmentLeanOutMapper.selectById(request.getId()); if (entity == null) { throw new JeecgBootException("要编辑的数据不存在，请刷新重试！"); } if (!EquipmentLeanOutStatusEnum.WAIT_SUBMIT.name().equals(entity.getLeanStatus())) { throw new JeecgBootException("当前数据状态不允许编辑！"); } //检查设备 EamEquipment equipment = eamEquipmentService.getById(request.getEquipmentId()); if (equipment == null) { throw new JeecgBootException("设备不存在！"); } if (!AssetStatusEnum.NORMAL.name().equals(equipment.getAssetStatus())) { throw new JeecgBootException("此设备当前资产状态不允许借出！"); } if (StringUtils.isBlank(request.getLeanDepartId())) { throw new JeecgBootException("借入车间不允许为空！"); } if (request.getLeanDepartId().equals(equipment.getOrgId())) { throw new JeecgBootException("当前设备属于此车间，不需要借用！"); } LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); if (sysUser == null) { throw new JeecgBootException("当前用户无法编辑借用记录！"); } UpdateWrapper updateWrapper = new UpdateWrapper<>(); updateWrapper.set("equipment_id", request.getEquipmentId()); updateWrapper.set("lean_depart_id", request.getLeanDepartId()); updateWrapper.set("remark", request.getRemark()); updateWrapper.set("lean_reason", request.getLeanReason()); updateWrapper.eq("id", request.getId()); updateWrapper.eq("lean_person", sysUser.getUsername()); return super.update(updateWrapper); } @Override @Transactional(rollbackFor = Exception.class) public boolean submit(String id) { EamEquipmentLeanOut entity = equipmentLeanOutMapper.selectById(id); if (entity == null) { throw new JeecgBootException("要提交的数据不存在，请刷新重试！"); } if (!EquipmentLeanOutStatusEnum.WAIT_SUBMIT.name().equals(entity.getLeanStatus())) { throw new JeecgBootException("该工单已进行过提交！"); } //检查设备 EamEquipment equipment = eamEquipmentService.getById(entity.getEquipmentId()); if (equipment == null) { throw new JeecgBootException("设备不存在！"); } if (!AssetStatusEnum.NORMAL.name().equals(equipment.getAssetStatus())) { throw new JeecgBootException("此设备当前资产状态不允许借出！"); } // 分配给使用单位领导 List userSelectors = sysUserService.selectOperatorList(equipment.getEquipmentCode(), equipment.getOrgId(), BusinessCodeConst.PCR0008); if (CollectionUtil.isEmpty(userSelectors)) { throw new JeecgBootException("设备未分配给单位领导，无法进入下级审批！"); } List usernames = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList()); LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); if (sysUser == null || !BusinessCodeConst.PCR0004.equals(sysUser.getPost())) { throw new JeecgBootException("不是设备管理员，无法提交此工单！"); } UpdateWrapper updateWrapper = new UpdateWrapper<>(); updateWrapper.set("lean_status", EquipmentLeanOutStatusEnum.WAIT_APPROVAL_OUT.name()); updateWrapper.eq("id", id); updateWrapper.eq("lean_person", sysUser.getUsername()); boolean success = super.update(updateWrapper); if (success) { equipment.setAssetStatus(AssetStatusEnum.LEAN_OUT.name()); eamEquipmentService.updateById(equipment); } //启动审批流程 flowCommonService.initActBusiness("工单号:" + entity.getCode() + ";设备编号: " + equipment.getEquipmentCode() + ";进行设备借用", entity.getId(), "IEamEquipmentLeanOutService", "equipment_lean_out", null); Map variables = new HashMap<>(); variables.put("dataId", entity.getId()); if (StrUtil.isEmpty(entity.getLeanReason())) { variables.put("organization", "新增借用工单默认启动流程"); variables.put("comment", "新增借用工单默认启动流程"); } else { variables.put("organization", entity.getLeanReason()); variables.put("comment", entity.getLeanReason()); } variables.put("proofreading", true); variables.put("NextAssignee", usernames); Result result = flowDefinitionService.startProcessInstanceByKey("equipment_lean_out", variables); if (result != null) { entity.setLeanStartTime(new Date()); entity.setLeanStatus(EquipmentLeanOutStatusEnum.WAIT_APPROVAL_OUT.name()); //保存工单 equipmentLeanOutMapper.updateById(entity); return result.isSuccess(); } return true; } @Override @Transactional(rollbackFor = Exception.class) public boolean equipmentReturn(String id) { EamEquipmentLeanOut entity = equipmentLeanOutMapper.selectById(id); if (entity == null) { throw new JeecgBootException("要提交的数据不存在，请刷新重试！"); } if (!EquipmentLeanOutStatusEnum.WAIT_RETURN.name().equals(entity.getLeanStatus())) { throw new JeecgBootException("当前数据状态不允许编辑！"); } //检查设备 EamEquipment equipment = eamEquipmentService.getById(entity.getEquipmentId()); if (equipment == null) { throw new JeecgBootException("设备不存在！"); } // 分配给借用单位领导 List userSelectors = sysUserService.selectOperatorList(entity.getLeanDepartId(), BusinessCodeConst.PCR0008); if (CollectionUtil.isEmpty(userSelectors)) { throw new JeecgBootException("设备未分配给单位领导，无法进入下级审批！"); } LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); if (sysUser == null || !BusinessCodeConst.PCR0004.equals(sysUser.getPost())) { throw new JeecgBootException("不是设备管理员，无法提交此工单！"); } //启动审批流程 flowCommonService.initActBusiness("工单号:" + entity.getCode() + ";设备编号: " + equipment.getEquipmentCode() + ";进行设备归还", entity.getId(), "IEamEquipmentLeanOutService", "equipment_return", null); Map variables = new HashMap<>(); variables.put("dataId", entity.getId()); variables.put("organization", "新增归还默认归还流程"); variables.put("comment", "新增归还默认归还流程"); variables.put("proofreading", true); List usernames = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList()); variables.put("NextAssignee", usernames); Result result = flowDefinitionService.startProcessInstanceByKey("equipment_return", variables); if (result != null) { entity.setLeanEndTime(new Date()); entity.setLeanStatus(EquipmentLeanOutStatusEnum.WAIT_CONFIRM_RETURN.name()); //保存工单 equipmentLeanOutMapper.updateById(entity); return result.isSuccess(); } return true; } @Override @Transactional(rollbackFor = Exception.class) @EquipmentHistoryLog(operationTag = EquipmentOperationTagEnum.LEAN_OUT, businessTable = "eam_equipment_lean_out") public EamEquipmentLeanOut approval(EamEquipmentLeanOutRequest request) { EamEquipmentLeanOut entity = equipmentLeanOutMapper.selectById(request.getId()); if (entity == null) { throw new JeecgBootException("审批的数据已删除，请刷新重试！"); } // 获取当前登录用户 LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal(); if (user == null || StrUtil.isBlank(user.getId())) { throw new JeecgBootException("未获取到登录用户，请重新登录后再试！"); } // request.setApprovalUser(user.getUsername()); // 获取流程业务记录 FlowMyBusiness flowMyBusiness = flowMyBusinessService.getFlowMyBusiness(request.getInstanceId()); if (flowMyBusiness == null) { throw new JeecgBootException("流程实例不存在，请刷新后重试！"); } boolean userAuthorized = isUserAuthorized(flowMyBusiness, user); if (!userAuthorized) { throw new JeecgBootException("用户无权操作此任务，请刷新后重试！"); } // 认领任务 if (!claimTask(flowMyBusiness.getTaskId(), user)) { throw new JeecgBootException("任务不存在、已完成或已被他人认领！"); } EamEquipment equipment = eamEquipmentService.getById(entity.getEquipmentId()); if (equipment == null) { throw new JeecgBootException("设备不存在，请检查！"); } //设置流程变量 setupProcessVariables(request, entity, user, equipment); // 完成流程任务 Result result = flowTaskService.complete(request); if (!result.isSuccess()) { throw new JeecgBootException("审批失败，请刷新查看！"); } // 根据任务完成结果更新工单状态 updateOrderStatus(result, request, entity, user, equipment); //保存工单 equipmentLeanOutMapper.updateById(entity); return entity; } /** * 更新工单状态 * @param result * @param request * @param entity * @param user * @param equipment */ private void updateOrderStatus(Result result, EamEquipmentLeanOutRequest request, EamEquipmentLeanOut entity, LoginUser user, EamEquipment equipment) { if (result.isSuccess()) { EquipmentLeanOutStatusEnum status = EquipmentLeanOutStatusEnum.getInstance(entity.getLeanStatus()); switch (status) { case WAIT_APPROVAL_OUT: entity.setUseApprovalUser(user.getUsername()); entity.setUseApprovalComment(request.getUseApprovalComment()); entity.setUseApprovalTime(new Date()); entity.setUseApprovalDealType(request.getUseApprovalDealType()); if (CommonConstant.APPROVED.equals(request.getUseApprovalDealType())) { entity.setLeanStatus(EquipmentLeanOutStatusEnum.WAIT_APPROVAL_IN.name()); } else { entity.setLeanStatus(EquipmentLeanOutStatusEnum.REJECT.name()); equipment.setAssetStatus(AssetStatusEnum.NORMAL.name()); eamEquipmentService.updateById(equipment); } break; case WAIT_APPROVAL_IN: entity.setLeanOutApprovalUser(user.getUsername()); entity.setLeanOutApprovalComment(request.getLeanOutApprovalComment()); entity.setLeanOutApprovalTime(new Date()); entity.setLeanOutApprovalDealType(request.getLeanOutApprovalDealType()); if (CommonConstant.APPROVED.equals(request.getLeanOutApprovalDealType())) { entity.setLeanStatus(EquipmentLeanOutStatusEnum.WAIT_RETURN.name()); } else { entity.setLeanStatus(EquipmentLeanOutStatusEnum.REJECT.name()); equipment.setAssetStatus(AssetStatusEnum.NORMAL.name()); eamEquipmentService.updateById(equipment); } break; case WAIT_CONFIRM_RETURN: entity.setLeanOutConfirmUser(user.getUsername()); entity.setLeanOutConfirmComment(request.getLeanOutConfirmComment()); entity.setLeanOutConfirmTime(new Date()); entity.setLeanOutConfirmDealType(request.getLeanOutConfirmDealType()); if (CommonConstant.APPROVED.equals(request.getLeanOutConfirmDealType())) { entity.setLeanStatus(EquipmentLeanOutStatusEnum.WAIT_CONFIRM_BORROW.name()); } else { entity.setLeanStatus(EquipmentLeanOutStatusEnum.WAIT_RETURN.name()); } break; case WAIT_CONFIRM_BORROW: entity.setUseConfirmUser(user.getUsername()); entity.setUseConfirmComment(request.getUseConfirmComment()); entity.setUseConfirmTime(new Date()); entity.setUseConfirmDealType(request.getUseConfirmDealType()); if (CommonConstant.APPROVED.equals(request.getUseConfirmDealType())) { entity.setLeanStatus(EquipmentLeanOutStatusEnum.COMPLETE.name()); equipment.setAssetStatus(AssetStatusEnum.NORMAL.name()); eamEquipmentService.updateById(equipment); } else { entity.setLeanStatus(EquipmentLeanOutStatusEnum.WAIT_RETURN.name()); } break; } } } /** * 更新流程状态 * * @param request * @param entity * @param user * @param equipment */ private void setupProcessVariables(EamEquipmentLeanOutRequest request, EamEquipmentLeanOut entity, LoginUser user, EamEquipment equipment) { Map values = new HashMap<>(); List userSelectors; List userApprovalList; EquipmentLeanOutStatusEnum status = EquipmentLeanOutStatusEnum.getInstance(entity.getLeanStatus()); switch (status) { case WAIT_APPROVAL_OUT: // 使用单位出厂审批完成 values.put("dataId", entity.getId()); values.put("organization", request.getUseApprovalComment()); values.put("comment", request.getUseApprovalComment()); if (CommonConstant.APPROVED.equals(request.getUseApprovalDealType())) { // 通过 values.put("approvalDealType", request.getUseApprovalDealType()); // 获取下一步审批人 userSelectors = sysUserService.selectOperatorList(entity.getLeanDepartId(), BusinessCodeConst.PCR0008); if (CollectionUtil.isEmpty(userSelectors)) { throw new JeecgBootException("未分配借用车间单位领导，无法进入下级审批！"); } userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList()); values.put("NextAssignee", userApprovalList); } else { // 驳回 values.put("approvalDealType", request.getUseApprovalDealType()); } request.setComment("使用单位出厂审批完成"); break; case WAIT_APPROVAL_IN: // 借用单位入厂审批完成 values.put("dataId", entity.getId()); values.put("organization", request.getLeanOutApprovalComment()); values.put("comment", request.getLeanOutApprovalComment()); request.setComment("借用单位入厂审批完成"); break; case WAIT_CONFIRM_RETURN: // 归还单位确认完成 values.put("dataId", entity.getId()); values.put("organization", request.getLeanOutConfirmComment()); values.put("comment", request.getLeanOutConfirmComment()); if (CommonConstant.APPROVED.equals(request.getLeanOutConfirmDealType())) { // 通过 values.put("approvalDealType", request.getLeanOutConfirmDealType()); // 获取下一步审批人 userSelectors = sysUserService.selectOperatorList(equipment.getOrgId(), BusinessCodeConst.PCR0008); if (CollectionUtil.isEmpty(userSelectors)) { throw new JeecgBootException("未分配使用车间单位领导，无法进入下级审批！"); } userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList()); values.put("NextAssignee", userApprovalList); } else { // 驳回 values.put("approvalDealType", request.getLeanOutConfirmDealType()); } request.setComment("借用单位领导确认完成"); break; case WAIT_CONFIRM_BORROW: // 借出方确认完成 values.put("dataId", entity.getId()); values.put("organization", request.getUseConfirmComment()); values.put("comment", request.getUseConfirmComment()); request.setComment("使用单位领导确认完成"); break; } request.setValues(values); } @Override public void afterFlowHandle(FlowMyBusiness business) { business.getTaskNameId();//接下来审批的节点 business.getValues();//前端传进来的参数 business.getActStatus(); } private boolean claimTask(String taskId, LoginUser user) { Task task = taskService.createTaskQuery().taskId(taskId).singleResult(); if (task == null) { return false; } if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) { return false; } taskService.claim(taskId, user.getUsername()); return true; } /** * 判断用户是否拥有此权限 * * @param flowMyBusiness * @param user * @return */ private boolean isUserAuthorized(FlowMyBusiness flowMyBusiness, LoginUser user) { List todoUsers = JSON.parseArray(flowMyBusiness.getTodoUsers(), String.class); return todoUsers != null && todoUsers.contains(user.getUsername()); } @Override public Object getBusinessDataById(String dataId) { return this.getById(dataId); } @Override public Map flowValuesOfTask(String taskNameId, Map values) { return null; } @Override public List flowCandidateUsernamesOfTask(String taskNameId, Map values) { //业务是否干预流程，业务干预，流程干预，指定人员进行处理 //获取下一步处理人 Object object = values.get("NextAssignee"); return (List) object; } }