增加管理制度

qushaowei

2025-06-10 78ee8165199655f2fb5a73775d3101da77a0d367

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/controller/StreamController.java

@@ -1,5 +1,11 @@
package org.jeecg.modules.eam.controller;

import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.jeecg.dingtalk.api.user.vo.User;
import com.jeecg.dingtalk.api.user.vo.UserRole;
import org.jeecg.common.api.dto.message.MessageDTO;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.query.QueryGenerator;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -7,20 +13,26 @@
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.eam.entity.*;
import org.jeecg.modules.eam.service.*;
import org.jeecg.modules.eam.vo.ButtonVo;
import org.jeecg.modules.system.entity.*;
import org.jeecg.modules.system.service.*;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import java.util.Arrays;

import java.time.LocalDate;
import java.time.ZoneId;
import java.util.*;

import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.eam.entity.StreamOperation;
import org.jeecg.modules.eam.entity.ABCAssessment;
import org.jeecg.modules.eam.entity.Stream;
import org.jeecg.modules.eam.service.IStreamService;
import org.jeecg.modules.eam.service.IStreamOperationService;
import org.jeecg.modules.eam.service.IABCAssessmentService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;
@@ -34,8 +46,6 @@
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

 /**
@@ -59,6 +69,45 @@
   @Autowired
   private IABCAssessmentService aBCAssessmentService;

   @Autowired
   private ISysUserRoleService userRoleService;

   @Autowired
   private ISysRoleService roleService;

   @Autowired
   private ISysDictService sysDictService;

   @Autowired
   private ISysDictItemService sysDictItemService;

    @Autowired
    private ISysBaseAPI sysBaseAPI;

    @Autowired
    private ISysUserService userService;

    @Autowired
    private IEamEquipmentService equipmentService;

    @Autowired
    private IdentityService sysIdentityService;

    @Autowired
    private IEquipmentMaintenancePlanDetailService planDetailService;

    @Autowired
    private IEquipmentMaintenancePlanService planService;

    @Autowired
    private IMaintenanceStandardService maintenanceStandardService;
    @Autowired
    private IEquipmentUpdateInfoService updateInfoService;






   /*---------------------------------主表处理-begin-------------------------------------*/

@@ -77,9 +126,14 @@
                           @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                           @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                           HttpServletRequest req) {
      LoginUser user= (LoginUser) SecurityUtils.getSubject().getPrincipal();
      SysUser sysUser = userService.getById(user.getId());
      if(StringUtils.isNotBlank(sysUser.getAreaId())){
         stream.setAreaId(sysUser.getAreaId());
      }
      QueryWrapper<Stream> queryWrapper = QueryGenerator.initQueryWrapper(stream, req.getParameterMap());
      Page<Stream> page = new Page<Stream>(pageNo, pageSize);
      IPage<Stream> pageList = streamService.page(page, queryWrapper);
      IPage<Stream> pageList = streamService.myPage(page, stream);
      return Result.OK(pageList);
   }

@@ -101,6 +155,22 @@
      streamService.save(stream);
       List<ABCAssessment> abcAssessmentList = stream.getAssessmentList();
       for(ABCAssessment abcAssessment:abcAssessmentList){
          Equipment equipment = equipmentService.getById(abcAssessment.getEquipmentId());
          boolean isD = "D".equals(abcAssessment.getFinalStandard());
          boolean a = StringUtils.isNotBlank(equipment.getStandardA())&&StringUtils.isNotBlank(abcAssessment.getStandardA())&&equipment.getStandardA().equals(abcAssessment.getStandardA());
         boolean b = StringUtils.isNotBlank(equipment.getStandardB())&&StringUtils.isNotBlank(abcAssessment.getStandardB())&&equipment.getStandardB().equals(abcAssessment.getStandardB());
         boolean c = StringUtils.isNotBlank(equipment.getStandardC())&&StringUtils.isNotBlank(abcAssessment.getStandardC())&&equipment.getStandardC().equals(abcAssessment.getStandardC());
         boolean d = StringUtils.isNotBlank(equipment.getStandardD())&&StringUtils.isNotBlank(abcAssessment.getStandardD())&&equipment.getStandardD().equals(abcAssessment.getStandardD());
         boolean e = StringUtils.isNotBlank(equipment.getStandardE())&&StringUtils.isNotBlank(abcAssessment.getStandardE())&&equipment.getStandardE().equals(abcAssessment.getStandardE());
         boolean f = StringUtils.isNotBlank(equipment.getStandardF())&&StringUtils.isNotBlank(abcAssessment.getStandardF())&&equipment.getStandardF().equals(abcAssessment.getStandardF());
          if(isD&&a&&b&&c&&d&&e&&f){
             abcAssessment.setStandardA(null);
            abcAssessment.setStandardB(null);
            abcAssessment.setStandardC(null);
            abcAssessment.setStandardD(null);
            abcAssessment.setStandardE(null);
            abcAssessment.setStandardF(null);
         }
          abcAssessment.setStreamId(stream.getId());
      }
       aBCAssessmentService.saveBatch(abcAssessmentList);
@@ -479,5 +549,209 @@
       List<ABCAssessment> aBCAssessmentList = aBCAssessmentService.selectByMainId(id);
       return Result.OK(aBCAssessmentList);
    }
    @GetMapping("getPreInfo")
    public Result<Map<String,Object>> getPreInfo(){
       Map<String,Object> map = new HashMap<>(3);
       LoginUser user= (LoginUser) SecurityUtils.getSubject().getPrincipal();
       SysDict roleNode = sysDictService.getOne(new QueryWrapper<SysDict>().eq("dict_code","abc_stream_node_role"),false);
       SysDict nodeOperation = sysDictService.getOne(new QueryWrapper<SysDict>().eq("dict_code","stream_node_operation"),false);
       SysDict operation = sysDictService.getOne(new QueryWrapper<SysDict>().eq("dict_code","stream_operation"),false);
       if(ObjectUtils.isNotNull(roleNode)){
          List<SysDictItem> roleNodeItems = sysDictItemService.selectItemsByMainId(roleNode.getId());
          List<String> roleCodes = roleNodeItems.stream().map(SysDictItem::getItemText).collect(Collectors.toList());
          if(ObjectUtils.isNotNull(nodeOperation)){
             List<SysDictItem> nodeOperationItems = sysDictItemService.selectItemsByMainId(nodeOperation.getId());
             List<SysUserRole> userRoles = userRoleService.list(new QueryWrapper<SysUserRole>().eq("user_id",user.getId()));
             List<String> roleIds = userRoles.stream().map(SysUserRole::getRoleId).collect(Collectors.toList());
             List<SysRole> roles = roleService.list(new QueryWrapper<SysRole>().in("id",roleIds).in("role_code",roleCodes));
             if(roles.size()==1){
                for(SysDictItem roleNodeItem:roleNodeItems){
                   if(roles.get(0).getRoleCode().equals(roleNodeItem.getItemText())){
                      for(SysDictItem nodeOperationItem:nodeOperationItems){
                         if(roleNodeItem.getItemValue().equals(nodeOperationItem.getItemValue())){
                            if(ObjectUtils.isNotNull(operation)){
                               List<String> buttonValues = Arrays.asList(nodeOperationItem.getItemText().split(","));
                              List<SysDictItem> operations = sysDictItemService.selectItemsByMainId(operation.getId());
                              List<ButtonVo> buttons = new ArrayList<>();
                              for(String value:buttonValues){
                                 for(SysDictItem name:operations){

                                    if(name.getItemValue().equals(value)){
                                       ButtonVo button = new ButtonVo();
                                       button.setName(name.getItemText());
                                       button.setValue(value);
                                       buttons.add(button);
                                    }
                                 }
                              }
                              map.put("buttons",buttons);
                              map.put("nodeValue",nodeOperationItem.getItemValue());
                              map.put("nodeSort",roleNodeItem.getSortOrder());
                              map.put("msg","ok");
                              return Result.OK(map);
                           }

                        }
                     }
                  }
               }
             }
          }

       }
       map.put("msg","该用户无签审角色");
       return Result.OK(map);
    }
    @PostMapping("next")
    @Transactional(rollbackFor = {Exception.class})
    public Result<?> handleNext(@RequestBody ButtonVo buttonVo){
       LoginUser user= (LoginUser) SecurityUtils.getSubject().getPrincipal();
       List<StreamOperation> streamOperations = streamOperationService.list(new QueryWrapper<StreamOperation>().eq("stream_id",buttonVo.getStreamId()).orderByDesc("sort"));
       SysDict streamNode = sysDictService.getOne(new QueryWrapper<SysDict>().eq("dict_code","stream_node"),false);
       if(ObjectUtils.isNotNull(streamNode)){
          List<SysDictItem> nodes = sysDictItemService.selectItemsByMainId(streamNode.getId());
          if(buttonVo.getNodeSort()+1==nodes.size()){
             List<ABCAssessment> abcAssessments = aBCAssessmentService.selectByMainId(buttonVo.getStreamId());
            EquipmentMaintenancePlan plan = new EquipmentMaintenancePlan();
            UUID uuid = UUID.randomUUID();
            long mostSignificantBits = uuid.getMostSignificantBits();
            long leastSignificantBits = uuid.getLeastSignificantBits();

            // 将最高位和最低位取出，然后合并为一个long类型的值
            long combinedBits = mostSignificantBits ^ leastSignificantBits;

            // 将合并后的long值转换为16进制字符串
            String hexString = Long.toHexString(combinedBits);
            String planNum = sysIdentityService.getNumByTypeAndLength("MaintenancePlan",4);
            plan.setId(hexString);
            plan.setNum(planNum);
            plan.setType("3");
            plan.setStatus("created");
                plan.setCreateReason("因ABC标识从B或C变更为A而导致下次三保时间过期，就这些设备生成的临时保养计划");
            List<EquipmentMaintenancePlanDetail> details = new ArrayList<>();
             for(ABCAssessment abcAssessment:abcAssessments){
               Equipment equipment = equipmentService.getById(abcAssessment.getEquipmentId());
               String oldStandard = abcAssessment.getOldStandard();
               String newStandard = abcAssessment.getFinalStandard();
               LocalDate currentDate = LocalDate.now();

               // 将当前日期加一天
               LocalDate nextDay = currentDate.plusDays(1);
               LocalDate nextMonth = currentDate.plusMonths(1);

               // 将LocalDate转换为Date
               Date currentDateAsDate = Date.from(currentDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
               Date nextDayAsDate =Date.from(nextDay.atStartOfDay(ZoneId.systemDefault()).toInstant());
               Date nextMonthAsDate = Date.from(nextMonth.atStartOfDay(ZoneId.systemDefault()).toInstant());
               Date needingDate = equipment.getNextThirdMaintenanceTime();
               Boolean a = StringUtils.isNotBlank(oldStandard)&&(oldStandard.equals("B")||oldStandard.equals("C"));
               Boolean b = StringUtils.isNotBlank(newStandard)&&newStandard.equals("A");;
               Boolean c = ObjectUtils.isNotNull(needingDate)&&needingDate.compareTo(currentDateAsDate)<0;
               if(a&&b&&c){
                  EquipmentMaintenancePlanDetail equipmentMaintenancePlanDetail = new EquipmentMaintenancePlanDetail();
                  equipmentMaintenancePlanDetail.setPlanId(hexString);
                  equipmentMaintenancePlanDetail.setEquipmentId(equipment.getId());
                  equipmentMaintenancePlanDetail.setPlanStartTime(nextDayAsDate);
                  equipmentMaintenancePlanDetail.setPlanEndTime(nextMonthAsDate);
                  MaintenanceStandard maintenanceStandard = maintenanceStandardService.getOne(new QueryWrapper<MaintenanceStandard>()
                        .eq("equipment_id",equipment.getId())
                        .eq("maintenance_type","3")
                        .eq("version_status","2")
                        .eq("del_flag",0),false);
                  if(ObjectUtils.isNotNull(maintenanceStandard)){
                     equipmentMaintenancePlanDetail.setStandardId(maintenanceStandard.getId());
                     details.add(equipmentMaintenancePlanDetail);
                  }
               }
               equipment.setEquipmentImportanceId(abcAssessment.getFinalStandard());
               equipment.setStandardA(abcAssessment.getStandardA());
               equipment.setStandardB(abcAssessment.getStandardB());
               equipment.setStandardC(abcAssessment.getStandardC());
               equipment.setStandardD(abcAssessment.getStandardD());
               equipment.setStandardE(abcAssessment.getStandardE());
               equipment.setStandardF(abcAssessment.getStandardF());
               equipmentService.updateById(equipment);
               EquipmentUpdateInfo equipmentUpdateInfo = new EquipmentUpdateInfo();
               equipmentUpdateInfo.setOldAbcTag(oldStandard);
               equipmentUpdateInfo.setNewAbcTag(newStandard);
               equipmentUpdateInfo.setEquipmentId(equipment.getId());
               equipmentUpdateInfo.setUpdatePerson(user.getId());
               equipmentUpdateInfo.setUpdateType("ABC");
               equipmentUpdateInfo.setUpdateDate(currentDateAsDate);
               updateInfoService.save(equipmentUpdateInfo);

            }
             if(details.size()>0){
                planService.save(plan);
                planDetailService.saveBatch(details);
            }
         }

         SysDictItem nextStreamNodeItem = sysDictItemService.getOne(new QueryWrapper<SysDictItem>().eq("dict_id",streamNode.getId()).eq("sort_order",buttonVo.getNodeSort()+1),false);
         return getResult(buttonVo, user, streamOperations, nextStreamNodeItem);
      }
       return Result.error("签审流系统出现错误，请联系管理员");
    }

    @NotNull
    private Result<?> getResult(@RequestBody ButtonVo buttonVo, LoginUser user, List<StreamOperation> streamOperations, SysDictItem nextStreamNodeItem) {
       SysDict roleNode = sysDictService.getOne(new QueryWrapper<SysDict>().eq("dict_code","abc_stream_node_role"),false);
       SysDictItem roleNodeItem = sysDictItemService.getOne(new QueryWrapper<SysDictItem>().eq("dict_id",roleNode.getId()).eq("item_value",nextStreamNodeItem.getItemValue()));
       SysRole nextRole = roleService.getOne(new QueryWrapper<SysRole>().eq("role_code",roleNodeItem.getItemText()));
       return getResult(buttonVo, user, streamOperations, nextStreamNodeItem,nextRole);
    }

    @NotNull
    private Result<?> getResult(@RequestBody ButtonVo buttonVo, LoginUser user, List<StreamOperation> streamOperations, SysDictItem nextStreamNodeItem,SysRole role) {
       if(ObjectUtils.isNotNull(nextStreamNodeItem)){
          Stream stream = streamService.getById(buttonVo.getStreamId());
          stream.setStatus(nextStreamNodeItem.getItemValue());
          streamService.updateById(stream);
          StreamOperation streamOperation = new StreamOperation();
          streamOperation.setOperation(buttonVo.getValue());
          streamOperation.setStreamId(stream.getId());
          streamOperation.setOperationNode(buttonVo.getNode());
          streamOperation.setUserId(user.getId());
          streamOperation.setCreateTime(new Date());
          streamOperation.setRemark(buttonVo.getRemark());
          if(streamOperations.size()==0){
             streamOperation.setSort(0);
          }
          else {
             streamOperation.setSort(streamOperations.get(0).getSort()+1);
             streamOperation.setSourceId(streamOperations.get(0).getId());
          }
          streamOperationService.save(streamOperation);
          List<String> userIds = userRoleService.list(new QueryWrapper<SysUserRole>().eq("role_id",role.getId())).stream().map(SysUserRole::getUserId).collect(Collectors.toList());
          for(String uId:userIds){
             SysUser toU = userService.getById(uId);
              String msg = "单据号为"+stream.getNum()+"的ABC标识变更单需要确认";
             MessageDTO messageDTO = new MessageDTO();
             messageDTO.setTitle("ABC标识变更");
             messageDTO.setContent(msg);
             messageDTO.setCategory("ABC变更");
             messageDTO.setFromUser(user.getUsername());
             messageDTO.setToUser(toU.getUsername());
             sysBaseAPI.sendSysAnnouncement(messageDTO);
          }
          return Result.OK("操作成功");
       }else {
          return Result.error("签审流系统出现错误，请联系管理员");
       }
    }

    @PostMapping("last")
    @Transactional(rollbackFor = {Exception.class})
    public Result<?> handleLast(@RequestBody ButtonVo buttonVo){
       LoginUser user= (LoginUser) SecurityUtils.getSubject().getPrincipal();
       List<StreamOperation> streamOperations = streamOperationService.list(new QueryWrapper<StreamOperation>().eq("stream_id",buttonVo.getStreamId()).orderByDesc("sort"));
       SysDict streamNode = sysDictService.getOne(new QueryWrapper<SysDict>().eq("dict_code","stream_node"),false);
       if(ObjectUtils.isNotNull(streamNode)){
          SysDictItem nextStreamNodeItem = sysDictItemService.getOne(new QueryWrapper<SysDictItem>().eq("dict_id",streamNode.getId()).eq("sort_order",buttonVo.getNodeSort()-1),false);
          return getResult(buttonVo, user, streamOperations, nextStreamNodeItem);
       }
       return Result.error("签审流系统出现错误，请联系管理员");
    }


}