工单优化

linwei

2026-02-05 08d4bb2bf4bfadc9ab5fcf6b0a2bfb543d22b2a0

 drone-service/drone-gd/src/main/java/org/sxkj/gd/orderdata/service/impl/GdSupplyDemandServiceImpl.java

@@ -16,17 +16,33 @@
 */
package org.sxkj.gd.orderdata.service.impl;

import org.sxkj.gd.orderdata.entity.GdSupplyDemandEntity;
import org.sxkj.gd.orderdata.param.GdSupplyDemandPageParam;
import org.sxkj.gd.orderdata.vo.GdSupplyDemandVO;
import org.sxkj.gd.orderdata.excel.GdSupplyDemandExcel;
import org.sxkj.gd.orderdata.mapper.GdSupplyDemandMapper;
import org.sxkj.gd.orderdata.service.IGdSupplyDemandService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import lombok.AllArgsConstructor;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.core.tool.utils.StringUtil;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.sxkj.gd.orderdata.dto.GdSupplyDemandDTO;
import org.sxkj.gd.orderdata.entity.GdSupplyDemandAuditAttachmentEntity;
import org.sxkj.gd.orderdata.entity.GdSupplyDemandAuditEntity;
import org.sxkj.gd.orderdata.entity.GdSupplyDemandEntity;
import org.sxkj.gd.orderdata.excel.GdSupplyDemandExcel;
import org.sxkj.gd.orderdata.mapper.GdSupplyDemandMapper;
import org.sxkj.gd.orderdata.param.GdSupplyDemandPageParam;
import org.sxkj.gd.orderdata.service.IGdSupplyDemandAuditAttachmentService;
import org.sxkj.gd.orderdata.service.IGdSupplyDemandAuditService;
import org.sxkj.gd.orderdata.service.IGdSupplyDemandService;
import org.sxkj.gd.orderdata.vo.GdSupplyDemandVO;
import org.sxkj.system.cache.SysCache;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * 供需需求信息表 服务实现类
@@ -35,13 +51,195 @@
 * @since 2026-01-16
 */
@Service
@AllArgsConstructor
public class GdSupplyDemandServiceImpl extends BaseServiceImpl<GdSupplyDemandMapper, GdSupplyDemandEntity> implements IGdSupplyDemandService {

   /**
    * 需求状态常量：0-草稿、1-申请中、2-审核通过、3-拒绝申请
    */
   private static final String STATUS_DRAFT = "0";
   private static final String STATUS_APPLY = "1";
   private static final String STATUS_APPROVED = "2";
   private static final String STATUS_REJECTED = "3";

   /**
    * 审核状态常量：0-待审核、1-审核通过、2-审核拒绝
    */
   private static final String AUDIT_PENDING = "0";
   private static final String AUDIT_PASS = "1";
   private static final String AUDIT_REJECT = "2";

   private final IGdSupplyDemandAuditService gdSupplyDemandAuditService;
   private final IGdSupplyDemandAuditAttachmentService gdSupplyDemandAuditAttachmentService;

   @Override
   public IPage<GdSupplyDemandVO> selectGdSupplyDemandPage(IPage<GdSupplyDemandVO> page, GdSupplyDemandPageParam gdSupplyDemand) {
      List<Long> deptList = new ArrayList<>();
      if (!AuthUtil.isAdministrator()) {
         deptList = SysCache.getDeptChildIds(Long.valueOf(AuthUtil.getDeptId()));
      }
      gdSupplyDemand.setDeptList(deptList);
      return page.setRecords(baseMapper.selectGdSupplyDemandPage(page, gdSupplyDemand));
   }

   @Override
   public IPage<GdSupplyDemandEntity> selectGdSupplyDemandList(IPage<GdSupplyDemandEntity> page, GdSupplyDemandDTO gdSupplyDemand) {
      return page.setRecords(baseMapper.selectGdSupplyDemandList(page, gdSupplyDemand));
   }

   @Override
   public GdSupplyDemandEntity detailSupplyDemand(GdSupplyDemandDTO gdSupplyDemand) {
      if (Func.isEmpty(gdSupplyDemand)) {
         throw new ServiceException("需求参数不能为空");
      }
      List<Long> deptList = new ArrayList<>();
      if (!AuthUtil.isAdministrator()) {
         deptList = SysCache.getDeptChildIds(Long.valueOf(AuthUtil.getDeptId()));
      }
      GdSupplyDemandEntity detail = baseMapper.selectGdSupplyDemandDetail(gdSupplyDemand, deptList);
      if (detail == null) {
         throw new ServiceException("未查询到数据");
      }
      return detail;
   }

   @Override
   @Transactional(rollbackFor = Exception.class)
   public boolean submitSupplyDemand(GdSupplyDemandDTO gdSupplyDemand) {
      if (Func.isEmpty(gdSupplyDemand)) {
         throw new ServiceException("需求参数不能为空");
      }
      GdSupplyDemandEntity supplyDemand = Objects.requireNonNull(BeanUtil.copy(gdSupplyDemand, GdSupplyDemandEntity.class));

      // 获取前端传入的需求状态
      String demandStatus = supplyDemand.getDemandStatus();
      if (StringUtil.isBlank(demandStatus)) {
         throw new ServiceException("需求状态不能为空");
      }

      // 校验状态值有效性
      if (!STATUS_DRAFT.equals(demandStatus) && !STATUS_APPLY.equals(demandStatus)) {
         throw new ServiceException("需求状态值无效，仅支持 0(草稿) 或 1(申请中)");
      }

      boolean isInsert = Func.isEmpty(supplyDemand.getId());
      Long userId = AuthUtil.getUserId();
      Long deptId = Long.valueOf(AuthUtil.getDeptId());
      supplyDemand.setUpdateUser(userId);

      boolean saved;
      if (isInsert) {
         supplyDemand.setCreateUser(userId);
         supplyDemand.setCreateDept(deptId);
         saved = baseMapper.insertGdSupplyDemand(supplyDemand) > 0;
      } else {
         saved = baseMapper.updateGdSupplyDemand(supplyDemand) > 0;
      }

      if (!saved) {
         return false;
      }

      // 仅当状态为"申请中"(1)时才创建审核记录
      if (STATUS_APPLY.equals(demandStatus)) {
         GdSupplyDemandEntity auditDemand = loadSupplyDemandForAudit(supplyDemand.getId());
         GdSupplyDemandAuditEntity auditEntity = buildAuditEntity(auditDemand, AUDIT_PENDING, null);
         return gdSupplyDemandAuditService.saveSupplyDemandAudit(auditEntity);
      }

      // 状态为"草稿"(0)时直接返回成功
      return true;
   }

   @Override
   @Transactional(rollbackFor = Exception.class)
   public boolean approveSupplyDemand(Long demandId, String auditOpinion, List<Long> attachIds) {
      GdSupplyDemandEntity supplyDemand = loadSupplyDemandForAudit(demandId);
      Long userId = AuthUtil.getUserId();
      GdSupplyDemandEntity update = new GdSupplyDemandEntity();
      update.setId(demandId);
      update.setDemandStatus(STATUS_APPROVED);
      update.setUpdateUser(userId);
      boolean updated = baseMapper.updateGdSupplyDemand(update) > 0;
      if (!updated) {
         return false;
      }
      GdSupplyDemandAuditEntity auditEntity = buildAuditEntity(supplyDemand, AUDIT_PASS, auditOpinion);
      boolean auditSaved = gdSupplyDemandAuditService.saveSupplyDemandAudit(auditEntity);
      if (!auditSaved) {
         return false;
      }
      if (Func.isEmpty(attachIds)) {
         return true;
      }
      List<GdSupplyDemandAuditAttachmentEntity> attachments = new ArrayList<>();
      Long deptId = Long.valueOf(AuthUtil.getDeptId());
      attachIds.forEach(attachId -> {
         if (attachId == null) {
            return;
         }
         GdSupplyDemandAuditAttachmentEntity attachment = new GdSupplyDemandAuditAttachmentEntity();
         attachment.setDemandId(demandId);
         attachment.setAttachId(attachId);
         attachment.setAreaCode(supplyDemand.getAreaCode());
         attachment.setCreateUser(userId);
         attachment.setCreateDept(deptId);
         attachments.add(attachment);
      });
      if (attachments.isEmpty()) {
         return true;
      }
      return gdSupplyDemandAuditAttachmentService.saveSupplyDemandAuditAttachments(attachments);
   }

   @Override
   @Transactional(rollbackFor = Exception.class)
   public boolean rejectSupplyDemand(Long demandId, String auditOpinion) {
      if (StringUtil.isBlank(auditOpinion)) {
         throw new ServiceException("拒绝原因不能为空");
      }
      GdSupplyDemandEntity supplyDemand = loadSupplyDemandForAudit(demandId);
      Long userId = AuthUtil.getUserId();
      GdSupplyDemandEntity update = new GdSupplyDemandEntity();
      update.setId(demandId);
      update.setDemandStatus(STATUS_REJECTED);
      update.setUpdateUser(userId);
      boolean updated = baseMapper.updateGdSupplyDemand(update) > 0;
      if (!updated) {
         return false;
      }
      GdSupplyDemandAuditEntity auditEntity = buildAuditEntity(supplyDemand, AUDIT_REJECT, auditOpinion);
      return gdSupplyDemandAuditService.saveSupplyDemandAudit(auditEntity);
   }

   private GdSupplyDemandAuditEntity buildAuditEntity(GdSupplyDemandEntity supplyDemand, String auditStatus, String auditOpinion) {
      if (Func.isEmpty(supplyDemand) || supplyDemand.getId() == null) {
         throw new ServiceException("需求数据不存在");
      }
      Long userId = AuthUtil.getUserId();
      Long deptId = Long.valueOf(AuthUtil.getDeptId());
      GdSupplyDemandAuditEntity auditEntity = new GdSupplyDemandAuditEntity();
      auditEntity.setDemandId(supplyDemand.getId());
      auditEntity.setAuditStatus(auditStatus);
      auditEntity.setAuditOpinion(StringUtil.isBlank(auditOpinion) ? null : auditOpinion);
      auditEntity.setAreaCode(supplyDemand.getAreaCode());
      auditEntity.setCreateUser(userId);
      auditEntity.setCreateDept(deptId);
      return auditEntity;
   }

   private GdSupplyDemandEntity loadSupplyDemandForAudit(Long demandId) {
      if (demandId == null) {
         throw new ServiceException("需求编号不能为空");
      }
      GdSupplyDemandDTO query = new GdSupplyDemandDTO();
      query.setId(demandId);
      GdSupplyDemandEntity detail = baseMapper.selectGdSupplyDemandDetail(query, SysCache.getDeptChildIds(Long.valueOf(AuthUtil.getDeptId())));
      if (detail == null) {
         throw new ServiceException("需求数据不存在");
      }
      return detail;
   }

   @Override
   public List<GdSupplyDemandExcel> exportGdSupplyDemand(Wrapper<GdSupplyDemandEntity> queryWrapper) {