Merge branch 'V0.0.2' of http://10.87.10.227:4000/jzyd_yyds/soc into V0.0.2

project_data/sql/0.0.3/soc/soc.sql

@@ -112,6 +112,15 @@ CREATE TABLE if not exists `core_safety_deduct_data` (
      KEY `idx_orgId` (`org_id`) USING BTREE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='安全指数扣分表';
 
+CREATE TABLE  if not exists `core_safecheck_plan_to_check_org_type` (
+                                                         `plan_id` bigint NOT NULL COMMENT '计划id',
+                                                         `type_id` bigint NOT NULL COMMENT '类型id',
+                                                         `create_time` datetime DEFAULT NULL COMMENT '创建时间',
+                                                         `update_time` datetime DEFAULT NULL COMMENT '修改时间',
+                                                         `create_by` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '创建人',
+                                                         `update_by` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '修改人'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='常规安全检查-受检机构类型关联表';
+
 create table if not exists core_register_book_pdf(
     id                 bigint       not null
         primary key,

soc-api/soc-api-system/src/main/java/com/xunmei/system/api/RemoteOrgService.java

@@ -10,6 +10,7 @@ import com.xunmei.system.api.Eto.OrgListByTypesConditionEto;
 import com.xunmei.system.api.domain.SysOrg;
 import com.xunmei.system.api.domain.SysOrgExtend;
 import com.xunmei.system.api.factory.RemoteOrgFallbackFactory;
+import com.xunmei.system.api.vo.FindOrgTypes;
 import com.xunmei.system.api.vo.SysOrgVO;
 import org.springframework.cloud.openfeign.FeignClient;
 import org.springframework.web.bind.annotation.*;
@@ -172,4 +173,7 @@ public interface RemoteOrgService {
 
     @GetMapping("/dept/selectOrgNameByPath")
     String selectOrgNameByPath(@RequestParam("orgId") Long orgId, @RequestHeader(SecurityConstants.FROM_SOURCE) String source);
+    @PostMapping("/dept/findByOrgTypesAndParent")
+    List<SysOrg> findByOrgTypesAndParent(@RequestBody FindOrgTypes types, @RequestHeader(SecurityConstants.FROM_SOURCE) String source);
+
 }

soc-api/soc-api-system/src/main/java/com/xunmei/system/api/domain/SysUser.java

@@ -51,7 +51,7 @@ public class SysUser extends BaseEntity {
      */
     @ApiModelProperty(value = "启用/禁用")
     private String isLock;
-    @ApiModelProperty(value = "是否管理员")
+    @ApiModelProperty(value = "安保部门从业人员")
     private String isManage;
     /**
      * 岗位

soc-api/soc-api-system/src/main/java/com/xunmei/system/api/factory/RemoteOrgFallbackFactory.java

@@ -9,6 +9,7 @@ import com.xunmei.system.api.Eto.OrgListByTypesConditionEto;
 import com.xunmei.system.api.RemoteOrgService;
 import com.xunmei.system.api.domain.SysOrg;
 import com.xunmei.system.api.domain.SysOrgExtend;
+import com.xunmei.system.api.vo.FindOrgTypes;
 import com.xunmei.system.api.vo.SysOrgVO;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -180,6 +181,11 @@ public class RemoteOrgFallbackFactory implements FallbackFactory<RemoteOrgServic
             }
 
             @Override
+            public List<SysOrg> findByOrgTypesAndParent(FindOrgTypes types, String source) {
+                return null;
+            }
+
+            @Override
 
 
             public List<SysOrg> selectOrgTreeListByCurOrgId(Long id, String source) {

soc-api/soc-api-system/src/main/java/com/xunmei/system/api/vo/FindOrgTypes.java

@@ -0,0 +1,14 @@
+package com.xunmei.system.api.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class FindOrgTypes {
+    private List<Integer> types;
+    private String path;
+}

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/question/service/impl/QuestionReformServiceImpl.java

@@ -4,6 +4,7 @@ import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.alibaba.excel.EasyExcel;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/question/service/impl/QuestionServiceImpl.java

@@ -4,6 +4,7 @@ import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.alibaba.excel.EasyExcel;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/reportForms/resumption/controller/ResumptionReportController.java

@@ -5,6 +5,7 @@ import com.xunmei.common.security.annotation.RequiresPermissions;
 import com.xunmei.core.reportForms.monitor.dto.MonitoringAccessDTO;
 import com.xunmei.core.reportForms.resumption.dto.ResumptionDTO;
 import com.xunmei.core.reportForms.resumption.service.ResumptionReportService;
+import com.xunmei.core.reportForms.resumption.vo.IntrusionTestReportVO;
 import com.xunmei.core.reportForms.resumption.vo.ResumptionDayVO;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
@@ -44,4 +45,19 @@ public class ResumptionReportController {
         ajaxResult.put("title", "日报表-营业网点每日安全保卫履职(" + resumptionDTO.getSearchTime() + ")");
         return ajaxResult;
     }
+
+    @ApiOperation(value = "报警测试报表")
+    @RequiresPermissions("core:resumptionReport:list")
+    @GetMapping("/intrusionTest")
+    public AjaxResult intrusionTest(ResumptionDTO resumptionDTO) {
+        if (null == resumptionDTO.getSearchTime()) {
+            LocalDate currentDate = LocalDate.now();
+            resumptionDTO.setSearchTime(currentDate.getYear()+"-"+currentDate.getMonthValue());
+        }
+        AjaxResult ajaxResult = AjaxResult.success();
+        List<IntrusionTestReportVO> intrusionTestReportVOList = resumptionReportService.intrusionTest(resumptionDTO);
+        ajaxResult.put(AjaxResult.DATA_TAG, intrusionTestReportVOList);
+        ajaxResult.put("title", "报警测试报表(" + resumptionDTO.getSearchTime() + ")");
+        return ajaxResult;
+    }
 }

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/reportForms/resumption/mapper/ResumptionReportMapper.java

@@ -1,6 +1,7 @@
 package com.xunmei.core.reportForms.resumption.mapper;
 
 import com.xunmei.core.reportForms.resumption.dto.ResumptionDTO;
+import com.xunmei.core.reportForms.resumption.vo.IntrusionTestReportVO;
 import com.xunmei.core.reportForms.resumption.vo.ResumptionDayVO;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
@@ -15,4 +16,13 @@ import java.util.List;
 public interface ResumptionReportMapper {
 
     ResumptionDayVO selectReport(@Param("planType") Integer planType, @Param("orgId") Long orgId, @Param("date") String date,@Param("orgPath")String orgPath);
+
+    /**
+     * 已整改数量
+     * @param taskId
+     * @return
+     */
+    Integer planRectification(@Param("taskId")Long taskId);
+
+    IntrusionTestReportVO selectIntrusionTestReport( @Param("date") String date,@Param("orgPath")String orgPath);
 }

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/reportForms/resumption/service/ResumptionReportService.java

@@ -1,6 +1,7 @@
 package com.xunmei.core.reportForms.resumption.service;
 
 import com.xunmei.core.reportForms.resumption.dto.ResumptionDTO;
+import com.xunmei.core.reportForms.resumption.vo.IntrusionTestReportVO;
 import com.xunmei.core.reportForms.resumption.vo.ResumptionDayVO;
 
 import java.util.List;
@@ -11,4 +12,6 @@ import java.util.List;
  */
 public interface ResumptionReportService {
     List<ResumptionDayVO> report(ResumptionDTO resumptionDTO);
+
+  List<IntrusionTestReportVO>  intrusionTest(ResumptionDTO resumptionDTO);
 }

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/reportForms/resumption/service/impl/ResumptionReportServiceImpl.java

@@ -1,14 +1,18 @@
 package com.xunmei.core.reportForms.resumption.service.impl;
 
+import com.xunmei.common.core.constant.ErrorMsgConstants;
 import com.xunmei.common.core.constant.SecurityConstants;
 import com.xunmei.common.security.utils.SecurityUtils;
 import com.xunmei.core.reportForms.monitor.mapper.MonitorAccessReportMapper;
 import com.xunmei.core.reportForms.resumption.dto.ResumptionDTO;
 import com.xunmei.core.reportForms.resumption.mapper.ResumptionReportMapper;
 import com.xunmei.core.reportForms.resumption.service.ResumptionReportService;
+import com.xunmei.core.reportForms.resumption.vo.IntrusionTestReportVO;
 import com.xunmei.core.reportForms.resumption.vo.ResumptionDayVO;
 import com.xunmei.system.api.RemoteOrgService;
 import com.xunmei.system.api.domain.SysOrg;
+import com.xunmei.system.api.function.RemoteCallHandlerExecutor;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -34,20 +38,26 @@ public class ResumptionReportServiceImpl implements ResumptionReportService {
         if (null == resumptionDTO.getOrgId()) {
             resumptionDTO.setOrgId(SecurityUtils.getLoginUser().getOrgId());
         }
-//判断机构类型,如果机构类型大于行社，都展示行社数据
+        //判断机构类型,如果机构类型大于行社，都展示行社数据
         SysOrg sysOrg = orgService.selectSysOrgById(resumptionDTO.getOrgId(), SecurityConstants.INNER);
-        List<SysOrg> sysOrgs = new ArrayList<>();
-        if (sysOrg.getType() > 3) {
+        List<SysOrg> sysOrgs;
+        if (sysOrg.getType() < 3 || sysOrg.getShortName().endsWith("地区行社") || sysOrg.getType() == 9) {
             sysOrgs = orgService.selectSysOrgByPathAndType(sysOrg.getPath(), 3, SecurityConstants.INNER);
         } else if (sysOrg.getType() == 3) {
             sysOrgs = orgService.selectSysOrgByPathAndType(sysOrg.getPath(), 4, SecurityConstants.INNER);
         } else {
             return null;
         }
-        orgService.selectSysOrgByParentId(resumptionDTO.getOrgId(), SecurityConstants.INNER);
         List<ResumptionDayVO> resumptionDayVOS = new ArrayList<>();
         sysOrgs.forEach(o -> {
             ResumptionDayVO resumptionDayVO = new ResumptionDayVO();
+            SysOrg sysOrg1;
+            if (sysOrg.getType() < 3 || sysOrg.getShortName().endsWith("地区行社") || sysOrg.getType() == 9) {
+                sysOrg1 = orgService.selectOrgById(o.getParentId(), SecurityConstants.INNER);
+            } else {
+                sysOrg1 = orgService.selectOrgById(orgService.selectOrgById(o.getParentId(), SecurityConstants.INNER).getParentId(), SecurityConstants.INNER);
+            }
+            resumptionDayVO.setCity(sysOrg1.getShortName().split("地区行社")[0]);
             resumptionDayVO.setOrgName(o.getShortName());
             Integer integer = monitorAccessReportMapper.selectNetworkNumberByPath(o.getPath());
             resumptionDayVO.setNetworkNumber(integer);
@@ -70,8 +80,12 @@ public class ResumptionReportServiceImpl implements ResumptionReportService {
             resumptionDayVO.setAfterPlanNumber(resumptionDayVO3.getFrontPlanNumber());
             resumptionDayVO.setAfterRealityNumber(resumptionDayVO3.getFrontRealityNumber());
             Integer totalPlan = resumptionDayVO3.getFrontPlanNumber() + resumptionDayVO2.getFrontPlanNumber() + resumptionDayVO1.getFrontPlanNumber();
+            //总计实际履职次数
             Integer totalReality = resumptionDayVO3.getFrontRealityNumber() + resumptionDayVO2.getFrontRealityNumber() + resumptionDayVO1.getFrontRealityNumber();
+            //总计隐患问题数
             Integer totalAbnormal = resumptionDayVO3.getFrontAbnormalNumber() + resumptionDayVO2.getFrontAbnormalNumber() + resumptionDayVO1.getFrontAbnormalNumber();
+            //总计已整改数量
+            Integer totalRealityRectificationNumber = resumptionDayVO3.getTotalRealityRectificationNumber() + resumptionDayVO2.getTotalRealityRectificationNumber() + resumptionDayVO1.getTotalRealityRectificationNumber();
             resumptionDayVO.setTotalPlanNumber(totalPlan);
             resumptionDayVO.setTotalRealityNumber(totalReality);
             int i = 0;
@@ -80,8 +94,49 @@ public class ResumptionReportServiceImpl implements ResumptionReportService {
             }
             resumptionDayVO.setTotalRate(i + "%");
             resumptionDayVO.setTotalAbnormalNumber(totalAbnormal);
+            int n = 0;
+            if (totalAbnormal != 0 && totalRealityRectificationNumber != 0) {
+                n = totalRealityRectificationNumber / totalAbnormal * 100;
+            }
+            resumptionDayVO.setTotalRealityRectificationRate(n + "%");
+            resumptionDayVO.setTotalRealityRectificationNumber(totalRealityRectificationNumber);
             resumptionDayVOS.add(resumptionDayVO);
         });
         return resumptionDayVOS;
     }
+
+    @Override
+    public List<IntrusionTestReportVO> intrusionTest(ResumptionDTO resumptionDTO) {
+        if (null == resumptionDTO.getOrgId()) {
+            resumptionDTO.setOrgId(SecurityUtils.getLoginUser().getOrgId());
+        }
+        //判断机构类型,如果机构类型大于行社，都展示行社数据
+        SysOrg sysOrg = orgService.selectSysOrgById(resumptionDTO.getOrgId(), SecurityConstants.INNER);
+        List<SysOrg> sysOrgs;
+        if (sysOrg.getType() < 3 || sysOrg.getShortName().endsWith("地区行社") || sysOrg.getType() == 9) {
+            sysOrgs = orgService.selectSysOrgByPathAndType(sysOrg.getPath(), 3, SecurityConstants.INNER);
+        } else if (sysOrg.getType() == 3) {
+            sysOrgs = orgService.selectSysOrgByPathAndType(sysOrg.getPath(), 4, SecurityConstants.INNER);
+        } else {
+            return null;
+        }
+        List<IntrusionTestReportVO> intrusionTestReportVOList = new ArrayList<>(16);
+        sysOrgs.forEach(o -> {
+            IntrusionTestReportVO intrusionTestReportVO = new IntrusionTestReportVO();
+            SysOrg sysOrg1;
+            if (sysOrg.getType() < 3 || sysOrg.getShortName().endsWith("地区行社") || sysOrg.getType() == 9) {
+                sysOrg1 = orgService.selectOrgById(o.getParentId(), SecurityConstants.INNER);
+            } else {
+                sysOrg1 = orgService.selectOrgById(orgService.selectOrgById(o.getParentId(), SecurityConstants.INNER).getParentId(), SecurityConstants.INNER);
+            }
+            IntrusionTestReportVO intrusionTestReportVO1 = resumptionReportMapper.selectIntrusionTestReport(resumptionDTO.getSearchTime(), o.getPath());
+            BeanUtils.copyProperties(intrusionTestReportVO1, intrusionTestReportVO);
+            intrusionTestReportVO.setCity(sysOrg1.getShortName().split("地区行社")[0]);
+            intrusionTestReportVO.setOrgName(o.getShortName());
+            Integer integer = monitorAccessReportMapper.selectNetworkNumberByPath(o.getPath());
+            intrusionTestReportVO.setNetworkNumber(integer);
+            intrusionTestReportVOList.add(intrusionTestReportVO);
+        });
+        return intrusionTestReportVOList;
+    }
 }

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/reportForms/resumption/vo/IntrusionTestReportVO.java

@@ -0,0 +1,30 @@
+package com.xunmei.core.reportForms.resumption.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * 入侵报警测试报表
+ *
+ * @author :LuoWei
+ * @date : 2023/11/13
+ */
+@Data
+public class IntrusionTestReportVO {
+    private String city;
+    private String orgName;
+    @ApiModelProperty(value = "网点数量")
+    private Integer networkNumber;
+    @ApiModelProperty(value = "应履职次数")
+    private Integer planNumber;
+    @ApiModelProperty(value = "已履职次数")
+    private Integer realityNumber;
+    @ApiModelProperty(value = "履职完成率")
+    private String realityRate;
+    @ApiModelProperty(value = "隐患数量")
+    private Integer abnormalNumber;
+    @ApiModelProperty(value = "已整改数量")
+    private Integer realityRectificationNumber;
+    @ApiModelProperty(value = "整改完成率")
+    private String realityRectificationRate;
+}

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/reportForms/resumption/vo/ResumptionDayVO.java

@@ -9,6 +9,7 @@ import lombok.Data;
  */
 @Data
 public class ResumptionDayVO {
+    private String city;
     private String orgName;
     @ApiModelProperty(value = "网点数量")
     private Integer networkNumber;
@@ -18,6 +19,12 @@ public class ResumptionDayVO {
     private Integer totalRealityNumber;
     @ApiModelProperty(value = "总计检查率")
     private String totalRate;
+    @ApiModelProperty(value = "总计已整改数量")
+    private Integer totalRealityRectificationNumber;
+    @ApiModelProperty(value = "总计整改完成率")
+    private String totalRealityRectificationRate;
+
+
     @ApiModelProperty(value = "总计隐患问题数")
     private Integer totalAbnormalNumber;
     @ApiModelProperty(value = "前应履职次数")

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/safetyCheck/domain/CoreSafecheckPlan.java

@@ -52,6 +52,8 @@ public class CoreSafecheckPlan extends BaseEntity {
 //    private Long index;
 
     private String distribute;
+    @TableField(exist = false)
+    private String typeNames;
     /**
      * 计划名称
      */
@@ -150,6 +152,11 @@ public class CoreSafecheckPlan extends BaseEntity {
     @ApiModelProperty(value = "受检机构")
     private String checkOrg;
 
+    @TableField(exist = false)
+    private List<CoreSafecheckPlanToCheckOrgType> checkOrgTypeList;
+    @TableField(exist = false)
+    private List<Integer> checkOrgTypes;
+
     /**
      * 计划状态：0：启用，1禁用
      */
@@ -243,7 +250,7 @@ public class CoreSafecheckPlan extends BaseEntity {
                 .append("execOrgType", getExecOrgType())
 
 
-                .append("checkOrgType", getCheckOrgType())
+//                .append("checkOrgType", getCheckOrgType())
 
 
                 .append("planStatus", getPlanStatus())

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/safetyCheck/domain/CoreSafecheckPlanToCheckOrgType.java

@@ -0,0 +1,73 @@
+package com.xunmei.core.safetyCheck.domain;
+
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+import org.apache.commons.lang3.builder.ToStringBuilder;
+import org.apache.commons.lang3.builder.ToStringStyle;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.annotation.IdType;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+import com.xunmei.common.core.web.domain.BaseEntity;
+
+/**
+ * 常规安全检查-受检机构类型关联对象 core_safecheck_plan_to_check_org_type
+ *
+ * @author xunmei
+ * @date 2023-11-14
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Accessors(chain = true)
+@NoArgsConstructor
+@TableName("core_safecheck_plan_to_check_org_type")
+@ApiModel(value = "CoreSafecheckPlanToCheckOrgType对象", description = "常规安全检查-受检机构类型关联")
+public class CoreSafecheckPlanToCheckOrgType extends BaseEntity {
+    private static final long serialVersionUID = 1L;
+
+    public CoreSafecheckPlanToCheckOrgType(Long planId, Integer typeId) {
+        this.planId = planId;
+        this.typeId = typeId;
+    }
+
+    /**
+     * 计划id
+     */
+    @ApiModelProperty(value = "计划id")
+    private Long planId;
+
+    /**
+     * 类型id
+     */
+    @ApiModelProperty(value = "类型id")
+    private Integer typeId;
+
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
+
+
+                .append("planId", getPlanId())
+
+
+                .append("typeId", getTypeId())
+
+
+                .append("createTime", getCreateTime())
+
+
+                .append("updateTime", getUpdateTime())
+
+
+                .append("createBy", getCreateBy())
+
+
+                .append("updateBy", getUpdateBy())
+                .toString();
+    }
+}

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/safetyCheck/job/SafetyCheckJobBusiness.java

@@ -26,6 +26,7 @@ import com.xunmei.core.safetyCheck.vo.PlanTaskBuildVo;
 import com.xunmei.system.api.RemoteOrgService;
 import com.xunmei.system.api.RemoteWorkTimeService;
 import com.xunmei.system.api.domain.SysOrg;
+import com.xunmei.system.api.vo.FindOrgTypes;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.annotation.Async;
@@ -62,6 +63,8 @@ public class SafetyCheckJobBusiness extends TaskCreatingServiceImplBase<CoreSafe
     private RemoteOrgService orgService;
     @Autowired
     RemoteWorkTimeService workTimeService;
+    @Autowired
+    private CoreSafecheckPlanToCheckOrgTypeMapper coreSafecheckPlanToCheckOrgTypeMapper;
 
     @Transactional(rollbackFor = Exception.class)
     public void createTaskForNow(Long planId, Date start, Date end, Boolean isNeedSendTodo, Integer sourceType) throws Exception {
@@ -201,8 +204,8 @@ public class SafetyCheckJobBusiness extends TaskCreatingServiceImplBase<CoreSafe
 
         List<PlanTaskBuildVo> list = new ArrayList<>();
         Integer execOrgType = Math.toIntExact(plan.getExecOrgType());
-        Integer checkOrgType = Math.toIntExact(plan.getCheckOrgType());
-
+//        Integer checkOrgType = Math.toIntExact(plan.getCheckOrgType());
+        List<Integer> checkOrgTypes = coreSafecheckPlanToCheckOrgTypeMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToCheckOrgType>().eq(CoreSafecheckPlanToCheckOrgType::getPlanId, plan.getId())).stream().map(CoreSafecheckPlanToCheckOrgType::getTypeId).collect(Collectors.toList());
         //获取具体执行检查的机构
         QueryWrapper<CoreSafecheckPlanToExecOrg> eos = new QueryWrapper<>();
         eos.lambda().eq(CoreSafecheckPlanToExecOrg::getPlanId, plan.getId());
@@ -237,11 +240,11 @@ public class SafetyCheckJobBusiness extends TaskCreatingServiceImplBase<CoreSafe
             List<SysOrg> checkOrgs = null;
             if (ObjectUtil.isEmpty(checkOrg)) {
                 //如果没有选择具体受检的机构，则根据受检机构类型查询
-                if (ObjectUtil.equal(plan.getCheckOrgType(), plan.getExecOrgType())) {
+                if (checkOrgTypes.contains(execOrgType) && checkOrgTypes.size() == 1) {
                     //如果检查机构类型与被检机构类型一致，则表示查自己
                     checkOrgs = Arrays.asList(org);
                 } else {
-                    checkOrgs = orgService.findByOrgTypeAndParent(checkOrgType, org.getPath(), SecurityConstants.INNER);
+                    checkOrgs = orgService.findByOrgTypesAndParent(new FindOrgTypes(checkOrgTypes, org.getPath()), SecurityConstants.INNER);
                 }
             } else {
                 //选择了具体的受检机构
@@ -268,7 +271,8 @@ public class SafetyCheckJobBusiness extends TaskCreatingServiceImplBase<CoreSafe
 
         List<PlanTaskBuildVo> list = new ArrayList<>();
         Integer execOrgType = Math.toIntExact(plan.getExecOrgType());
-        Integer checkOrgType = Math.toIntExact(plan.getCheckOrgType());
+//        Integer checkOrgType = Math.toIntExact(plan.getCheckOrgType());
+        List<Integer> checkOrgTypes = coreSafecheckPlanToCheckOrgTypeMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToCheckOrgType>().eq(CoreSafecheckPlanToCheckOrgType::getPlanId, plan.getId())).stream().map(CoreSafecheckPlanToCheckOrgType::getTypeId).collect(Collectors.toList());
 
         //获取具体执行检查的机构
         List<CoreSafecheckPlanToExecOrg> execOrg = null;
@@ -334,10 +338,11 @@ public class SafetyCheckJobBusiness extends TaskCreatingServiceImplBase<CoreSafe
             List<SysOrg> checkOrgs = null;
             if (ObjectUtil.isEmpty(checkOrg)) {
                 //如果没有选择具体受检的机构，则根据受检机构类型查询
-                if (ObjectUtil.equal(plan.getCheckOrgType(), plan.getExecOrgType())) {
+                if (checkOrgTypes.contains(execOrgType) && checkOrgTypes.size() == 1) {
+                    //如果检查机构类型与被检机构类型一致，则表示查自己
                     checkOrgs = Arrays.asList(org);
                 } else {
-                    checkOrgs = orgService.findByOrgTypeAndParent(checkOrgType, org.getPath(), SecurityConstants.INNER);
+                    checkOrgs = orgService.findByOrgTypesAndParent(new FindOrgTypes(checkOrgTypes, org.getPath()), SecurityConstants.INNER);
                 }
             } else {
                 //选择了具体的受检机构
@@ -525,7 +530,7 @@ public class SafetyCheckJobBusiness extends TaskCreatingServiceImplBase<CoreSafe
                 //如果存在同批次的已完成或者已逾期的任务需要同步批次id
                 checkTask.setBatchId(coreSafetyTasks.get(0).getBatchId());
             } else {
-                checkTaskService.remove(new LambdaQueryWrapper<CoreSafetyTask>().eq(CoreSafetyTask::getOrgId, checkTask.getOrgId()).eq(CoreSafetyTask::getYmdDate, checkTask.getYmdDate()).in(CoreSafetyTask::getStatus, 1, 2).eq(CoreSafetyTask::getPlanId,checkTask.getPlanId()));
+                checkTaskService.remove(new LambdaQueryWrapper<CoreSafetyTask>().eq(CoreSafetyTask::getOrgId, checkTask.getOrgId()).eq(CoreSafetyTask::getYmdDate, checkTask.getYmdDate()).in(CoreSafetyTask::getStatus, 1, 2).eq(CoreSafetyTask::getPlanId, checkTask.getPlanId()));
                 ats.add(checkTask);
             }
 
@@ -580,111 +585,111 @@ public class SafetyCheckJobBusiness extends TaskCreatingServiceImplBase<CoreSafe
         buildTask(safetyTaskBuildDto.getDate(), tasks, map.get("start"), map.get("end"), true, 0);
     }
 
-    //检查参数
-    public List<String> checkParam(SafetyTaskBuildDto safetyTaskBuildDto) {
-        List<String> list = new ArrayList<>();
-        DateHelper dateHelper = new DateHelper(safetyTaskBuildDto.getDate());
-        Map<String, Date> map = null;
-        List<CoreSafecheckPlan> plans = null;
-        if (safetyTaskBuildDto.getPlanId() != null) {
-            plans = new ArrayList<>();
-            CoreSafecheckPlan coreSafecheckPlan = planMapper.selectById(safetyTaskBuildDto.getPlanId());
-            if (coreSafecheckPlan.getPlanStatus() == 1) {
-                list.add("当前计划:" + coreSafecheckPlan.getPlanName() + "已禁用!");
-                return list;
-            }
-            plans.add(coreSafecheckPlan);
-            map = DateHelper.getStartAndEnd(safetyTaskBuildDto.getDate(), Math.toIntExact(coreSafecheckPlan.getPlanCycle()));
-        } else {
-            LambdaUpdateWrapper<CoreSafecheckPlan> qw = new LambdaUpdateWrapper<>();
-            qw.eq(CoreSafecheckPlan::getPlanCycle, safetyTaskBuildDto.getPlanCycle());
-            qw.eq(CoreSafecheckPlan::getIsDeleted, 0);
-            qw.eq(CoreSafecheckPlan::getPlanStatus, 0);
-            plans = planMapper.selectList(qw);
-            map = DateHelper.getStartAndEnd(safetyTaskBuildDto.getDate(), safetyTaskBuildDto.getPlanCycle());
-        }
-        if (CollectionUtil.isEmpty(plans)) {
-            list.add("计划不存在");
-        }
-        for (CoreSafecheckPlan plan : plans) {
-            if (ObjectUtil.notEqual(plan.getPlanCycle(), safetyTaskBuildDto.getPlanCycle())) {
-                list.add("计划周期与计划不匹配");
-                break;
-            }
-        }
-        if (map.keySet().size() == 0) {
-            list.add("计划周期不存在");
-        }
-        if (ObjectUtil.isNotEmpty(safetyTaskBuildDto.getExecOrgIdList())) {
-            List<Long> execOrgIdList = safetyTaskBuildDto.getExecOrgIdList();
-            for (CoreSafecheckPlan plan : plans) {
-                List<CoreSafecheckPlanToExecOrg> coreSafecheckPlanToExecOrgs = planToExecOrgMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToExecOrg>().eq(CoreSafecheckPlanToExecOrg::getPlanId, plan.getId()));
-                if (CollectionUtil.isEmpty(coreSafecheckPlanToExecOrgs)) {
-                    //说明计划是根据机构类型配置的，获取所有的机构类型，如果参数中执行机构的机构类型存在不属于此计划的执行机构，则返回错误
-                    List<Long> orgTypeList = orgService.selectOrgTypeByIdList(execOrgIdList, SecurityConstants.INNER);
-                    for (Long orgType : orgTypeList) {
-                        if (ObjectUtil.notEqual(orgType, plan.getExecOrgType())) {
-                            list.add("参数中," + plan.getPlanName() + "计划下存在错误执行机构数据");
-                            break;
-                        }
-                    }
-                } else {
-                    //获取当前计划的所有执行机构，如果参数中存在不属于此计划的执行机构，则返回错误
-                    List<Long> collect = coreSafecheckPlanToExecOrgs.stream().map(CoreSafecheckPlanToExecOrg::getOrgId).collect(Collectors.toList());
-                    for (Long execOrgId : execOrgIdList) {
-                        if (!collect.contains(execOrgId)) {
-                            list.add("参数中," + plan.getPlanName() + "计划下存在错误执行机构数据");
-                            break;
-                        }
-                    }
-                }
-
-
-            }
-
-        }
-        if (ObjectUtil.isNotEmpty(safetyTaskBuildDto.getCheckOrgIdList())) {
-            List<Long> checkOrgIdList = safetyTaskBuildDto.getCheckOrgIdList();
-            for (CoreSafecheckPlan plan : plans) {
-                List<CoreSafecheckPlanToCheckOrg> coreSafecheckPlanToCheckOrgs = planToCheckOrgMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToCheckOrg>().eq(CoreSafecheckPlanToCheckOrg::getPlanId, plan.getId()));
-                if (ObjectUtil.isEmpty(coreSafecheckPlanToCheckOrgs)) {
-                    //说明计划是根据机构类型配置的，获取所有的机构类型，如果参数中受检机构的机构类型存在不属于此计划的受检机构，则返回错误
-                    List<Long> orgTypeList = orgService.selectOrgTypeByIdList(checkOrgIdList, SecurityConstants.INNER);
-                    for (Long orgType : orgTypeList) {
-                        if (ObjectUtil.notEqual(orgType, plan.getCheckOrgType())) {
-                            list.add("参数中," + plan.getPlanName() + "计划下存在错误检查机构数据");
-                            break;
-                        }
-                    }
-                } else {
-                    //获取当前计划的所有受检机构，如果参数中存在不属于此计划的受检机构，则返回错误
-                    List<Long> collect = coreSafecheckPlanToCheckOrgs.stream().map(CoreSafecheckPlanToCheckOrg::getOrgId).collect(Collectors.toList());
-                    for (Long checkOrgId : checkOrgIdList) {
-                        if (!collect.contains(checkOrgId)) {
-                            list.add("参数中," + plan.getPlanName() + "计划下存在错误检查机构数据");
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        if (ObjectUtil.isNotEmpty(safetyTaskBuildDto.getRoleIdList())) {
-            List<Long> roleIdList = safetyTaskBuildDto.getRoleIdList();
-            for (CoreSafecheckPlan plan : plans) {
-                List<CoreSafecheckPlanToRole> coreSafecheckPlanToRoles = planToRoleMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToRole>().eq(CoreSafecheckPlanToRole::getPlanId, plan.getId()));
-                List<Long> collect = coreSafecheckPlanToRoles.stream().map(CoreSafecheckPlanToRole::getRoleId).collect(Collectors.toList());
-                if (!new HashSet<>(collect).containsAll(roleIdList)) {
-                    list.add("参数中," + plan.getPlanName() + "计划下存在错误角色数据");
-                    break;
-                }
-            }
-        }
-        if (DateUtil.beginOfDay(map.get("end")).isBefore(DateUtil.beginOfDay(new Date()))) {
-            list.add("计划周期已过");
-        }
-        return list;
-
-    }
+//    //检查参数
+//    public List<String> checkParam(SafetyTaskBuildDto safetyTaskBuildDto) {
+//        List<String> list = new ArrayList<>();
+//        DateHelper dateHelper = new DateHelper(safetyTaskBuildDto.getDate());
+//        Map<String, Date> map = null;
+//        List<CoreSafecheckPlan> plans = null;
+//        if (safetyTaskBuildDto.getPlanId() != null) {
+//            plans = new ArrayList<>();
+//            CoreSafecheckPlan coreSafecheckPlan = planMapper.selectById(safetyTaskBuildDto.getPlanId());
+//            if (coreSafecheckPlan.getPlanStatus() == 1) {
+//                list.add("当前计划:" + coreSafecheckPlan.getPlanName() + "已禁用!");
+//                return list;
+//            }
+//            plans.add(coreSafecheckPlan);
+//            map = DateHelper.getStartAndEnd(safetyTaskBuildDto.getDate(), Math.toIntExact(coreSafecheckPlan.getPlanCycle()));
+//        } else {
+//            LambdaUpdateWrapper<CoreSafecheckPlan> qw = new LambdaUpdateWrapper<>();
+//            qw.eq(CoreSafecheckPlan::getPlanCycle, safetyTaskBuildDto.getPlanCycle());
+//            qw.eq(CoreSafecheckPlan::getIsDeleted, 0);
+//            qw.eq(CoreSafecheckPlan::getPlanStatus, 0);
+//            plans = planMapper.selectList(qw);
+//            map = DateHelper.getStartAndEnd(safetyTaskBuildDto.getDate(), safetyTaskBuildDto.getPlanCycle());
+//        }
+//        if (CollectionUtil.isEmpty(plans)) {
+//            list.add("计划不存在");
+//        }
+//        for (CoreSafecheckPlan plan : plans) {
+//            if (ObjectUtil.notEqual(plan.getPlanCycle(), safetyTaskBuildDto.getPlanCycle())) {
+//                list.add("计划周期与计划不匹配");
+//                break;
+//            }
+//        }
+//        if (map.keySet().size() == 0) {
+//            list.add("计划周期不存在");
+//        }
+//        if (ObjectUtil.isNotEmpty(safetyTaskBuildDto.getExecOrgIdList())) {
+//            List<Long> execOrgIdList = safetyTaskBuildDto.getExecOrgIdList();
+//            for (CoreSafecheckPlan plan : plans) {
+//                List<CoreSafecheckPlanToExecOrg> coreSafecheckPlanToExecOrgs = planToExecOrgMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToExecOrg>().eq(CoreSafecheckPlanToExecOrg::getPlanId, plan.getId()));
+//                if (CollectionUtil.isEmpty(coreSafecheckPlanToExecOrgs)) {
+//                    //说明计划是根据机构类型配置的，获取所有的机构类型，如果参数中执行机构的机构类型存在不属于此计划的执行机构，则返回错误
+//                    List<Long> orgTypeList = orgService.selectOrgTypeByIdList(execOrgIdList, SecurityConstants.INNER);
+//                    for (Long orgType : orgTypeList) {
+//                        if (ObjectUtil.notEqual(orgType, plan.getExecOrgType())) {
+//                            list.add("参数中," + plan.getPlanName() + "计划下存在错误执行机构数据");
+//                            break;
+//                        }
+//                    }
+//                } else {
+//                    //获取当前计划的所有执行机构，如果参数中存在不属于此计划的执行机构，则返回错误
+//                    List<Long> collect = coreSafecheckPlanToExecOrgs.stream().map(CoreSafecheckPlanToExecOrg::getOrgId).collect(Collectors.toList());
+//                    for (Long execOrgId : execOrgIdList) {
+//                        if (!collect.contains(execOrgId)) {
+//                            list.add("参数中," + plan.getPlanName() + "计划下存在错误执行机构数据");
+//                            break;
+//                        }
+//                    }
+//                }
+//
+//
+//            }
+//
+//        }
+//        if (ObjectUtil.isNotEmpty(safetyTaskBuildDto.getCheckOrgIdList())) {
+//            List<Long> checkOrgIdList = safetyTaskBuildDto.getCheckOrgIdList();
+//            for (CoreSafecheckPlan plan : plans) {
+//                List<CoreSafecheckPlanToCheckOrg> coreSafecheckPlanToCheckOrgs = planToCheckOrgMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToCheckOrg>().eq(CoreSafecheckPlanToCheckOrg::getPlanId, plan.getId()));
+//                if (ObjectUtil.isEmpty(coreSafecheckPlanToCheckOrgs)) {
+//                    //说明计划是根据机构类型配置的，获取所有的机构类型，如果参数中受检机构的机构类型存在不属于此计划的受检机构，则返回错误
+//                    List<Long> orgTypeList = orgService.selectOrgTypeByIdList(checkOrgIdList, SecurityConstants.INNER);
+//                    for (Long orgType : orgTypeList) {
+//                        if (ObjectUtil.notEqual(orgType, plan.getCheckOrgType())) {
+//                            list.add("参数中," + plan.getPlanName() + "计划下存在错误检查机构数据");
+//                            break;
+//                        }
+//                    }
+//                } else {
+//                    //获取当前计划的所有受检机构，如果参数中存在不属于此计划的受检机构，则返回错误
+//                    List<Long> collect = coreSafecheckPlanToCheckOrgs.stream().map(CoreSafecheckPlanToCheckOrg::getOrgId).collect(Collectors.toList());
+//                    for (Long checkOrgId : checkOrgIdList) {
+//                        if (!collect.contains(checkOrgId)) {
+//                            list.add("参数中," + plan.getPlanName() + "计划下存在错误检查机构数据");
+//                            break;
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//        if (ObjectUtil.isNotEmpty(safetyTaskBuildDto.getRoleIdList())) {
+//            List<Long> roleIdList = safetyTaskBuildDto.getRoleIdList();
+//            for (CoreSafecheckPlan plan : plans) {
+//                List<CoreSafecheckPlanToRole> coreSafecheckPlanToRoles = planToRoleMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToRole>().eq(CoreSafecheckPlanToRole::getPlanId, plan.getId()));
+//                List<Long> collect = coreSafecheckPlanToRoles.stream().map(CoreSafecheckPlanToRole::getRoleId).collect(Collectors.toList());
+//                if (!new HashSet<>(collect).containsAll(roleIdList)) {
+//                    list.add("参数中," + plan.getPlanName() + "计划下存在错误角色数据");
+//                    break;
+//                }
+//            }
+//        }
+//        if (DateUtil.beginOfDay(map.get("end")).isBefore(DateUtil.beginOfDay(new Date()))) {
+//            list.add("计划周期已过");
+//        }
+//        return list;
+//
+//    }
 
     @Override
     public void rebuildDayTask(List<Long> orgIds, SysWorkTime workTime) {
@@ -742,9 +747,22 @@ public class SafetyCheckJobBusiness extends TaskCreatingServiceImplBase<CoreSafe
                     ofType = ofhs.getType();
                     //拿到当前周期所有检查计划
                     List<CoreSafecheckPlan> plans = planMapper.selectByPlanStatus(1, planCycle);
-                    Long fcheckOrgType = Long.valueOf(worg.getType());
+//                    Long fcheckOrgType = Long.valueOf(worg.getType());
                     //过滤受检机构类型为作息变更机构类型的计划
-                    plans = plans.stream().filter(p -> p.getCheckOrgType().equals(fcheckOrgType)).collect(Collectors.toList());
+
+                    Iterator<CoreSafecheckPlan> iterator = plans.iterator();
+
+                    while (iterator.hasNext()) {
+                        CoreSafecheckPlan p = iterator.next();
+                        List<Integer> checkOrgTypes = coreSafecheckPlanToCheckOrgTypeMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToCheckOrgType>().eq(CoreSafecheckPlanToCheckOrgType::getPlanId, p.getId())).stream().map(CoreSafecheckPlanToCheckOrgType::getTypeId).collect(Collectors.toList());
+                        if (!checkOrgTypes.contains(worg.getType())) {
+                            iterator.remove();
+                        }
+                    }
+
+//                    plans = plans.stream().filter(p -> {
+//                        p.getCheckOrgType().equals(fcheckOrgType)
+//                    }).collect(Collectors.toList());
                     Integer fofOrgType = ofType;
                     //过滤所属机构类型为作息变更机构所属行社的机构类型的计划
                     plans = plans.stream().filter(p -> p.getPlanOfOrgType().equals(fofOrgType)).collect(Collectors.toList());

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/safetyCheck/mapper/CoreSafecheckPlanToCheckOrgTypeMapper.java

@@ -0,0 +1,62 @@
+package com.xunmei.core.safetyCheck.mapper;
+
+import java.util.List;
+
+import com.xunmei.core.safetyCheck.domain.CoreSafecheckPlanToCheckOrgType;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * 常规安全检查-受检机构类型关联Mapper接口
+ *
+ * @author xunmei
+ * @date 2023-11-14
+ */
+public interface CoreSafecheckPlanToCheckOrgTypeMapper extends BaseMapper<CoreSafecheckPlanToCheckOrgType> {
+    /**
+     * 查询常规安全检查-受检机构类型关联
+     *
+     * @param planId 常规安全检查-受检机构类型关联主键
+     * @return 常规安全检查-受检机构类型关联
+     */
+    CoreSafecheckPlanToCheckOrgType selectCoreSafecheckPlanToCheckOrgTypeByPlanId(Long planId);
+
+    /**
+     * 查询常规安全检查-受检机构类型关联列表
+     *
+     * @param coreSafecheckPlanToCheckOrgType 常规安全检查-受检机构类型关联
+     * @return 常规安全检查-受检机构类型关联集合
+     */
+    List<CoreSafecheckPlanToCheckOrgType> selectCoreSafecheckPlanToCheckOrgTypeList(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType);
+
+    /**
+     * 新增常规安全检查-受检机构类型关联
+     *
+     * @param coreSafecheckPlanToCheckOrgType 常规安全检查-受检机构类型关联
+     * @return 结果
+     */
+    int insertCoreSafecheckPlanToCheckOrgType(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType);
+
+    /**
+     * 修改常规安全检查-受检机构类型关联
+     *
+     * @param coreSafecheckPlanToCheckOrgType 常规安全检查-受检机构类型关联
+     * @return 结果
+     */
+    int updateCoreSafecheckPlanToCheckOrgType(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType);
+
+    /**
+     * 删除常规安全检查-受检机构类型关联
+     *
+     * @param planId 常规安全检查-受检机构类型关联主键
+     * @return 结果
+     */
+    int deleteCoreSafecheckPlanToCheckOrgTypeByPlanId(Long planId);
+
+    /**
+     * 批量删除常规安全检查-受检机构类型关联
+     *
+     * @param planIds 需要删除的数据主键集合
+     * @return 结果
+     */
+    int deleteCoreSafecheckPlanToCheckOrgTypeByPlanIds(Long[] planIds);
+}

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/safetyCheck/service/ICoreSafecheckPlanToCheckOrgTypeService.java

@@ -0,0 +1,72 @@
+package com.xunmei.core.safetyCheck.service;
+
+import java.util.List;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.xunmei.common.core.web.page.TableDataInfo;
+import com.xunmei.core.safetyCheck.domain.CoreSafecheckPlanToCheckOrgType;
+
+/**
+ * 常规安全检查-受检机构类型关联Service接口
+ *
+ * @author xunmei
+ * @date 2023-11-14
+ */
+public interface ICoreSafecheckPlanToCheckOrgTypeService extends IService<CoreSafecheckPlanToCheckOrgType> {
+    /**
+     * 查询常规安全检查-受检机构类型关联
+     *
+     * @param planId 常规安全检查-受检机构类型关联主键
+     * @return 常规安全检查-受检机构类型关联
+     */
+    CoreSafecheckPlanToCheckOrgType selectCoreSafecheckPlanToCheckOrgTypeByPlanId(Long planId);
+
+    /**
+     * 查询常规安全检查-受检机构类型关联列表
+     *
+     * @param coreSafecheckPlanToCheckOrgType 常规安全检查-受检机构类型关联
+     * @return 常规安全检查-受检机构类型关联集合
+     */
+    List<CoreSafecheckPlanToCheckOrgType> selectCoreSafecheckPlanToCheckOrgTypeList(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType);
+
+    /**
+     * 新增常规安全检查-受检机构类型关联
+     *
+     * @param coreSafecheckPlanToCheckOrgType 常规安全检查-受检机构类型关联
+     * @return 结果
+     */
+    int insertCoreSafecheckPlanToCheckOrgType(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType);
+
+    /**
+     * 修改常规安全检查-受检机构类型关联
+     *
+     * @param coreSafecheckPlanToCheckOrgType 常规安全检查-受检机构类型关联
+     * @return 结果
+     */
+    int updateCoreSafecheckPlanToCheckOrgType(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType);
+
+    /**
+     * 批量删除常规安全检查-受检机构类型关联
+     *
+     * @param planIds 需要删除的常规安全检查-受检机构类型关联主键集合
+     * @return 结果
+     */
+    int deleteCoreSafecheckPlanToCheckOrgTypeByPlanIds(Long[] planIds);
+
+    /**
+     * 删除常规安全检查-受检机构类型关联信息
+     *
+     * @param planId 常规安全检查-受检机构类型关联主键
+     * @return 结果
+     */
+    int deleteCoreSafecheckPlanToCheckOrgTypeByPlanId(Long planId);
+
+    /**
+     * 查询常规安全检查-受检机构类型关联分页数据
+     *
+     * @param coreSafecheckPlanToCheckOrgType 查询条件对象
+     * @return Page
+     */
+    TableDataInfo<CoreSafecheckPlanToCheckOrgType> selectPage(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType);
+}

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/safetyCheck/service/impl/CoreSafecheckPlanServiceImpl.java

@@ -82,6 +82,8 @@ public class CoreSafecheckPlanServiceImpl extends ServiceImpl<CoreSafecheckPlanM
     private AppPlanMapper appPlanMapper;
     @Autowired
     private RemoteFileService fileService;
+    @Autowired
+    private CoreSafecheckPlanToCheckOrgTypeMapper coreSafecheckPlanToCheckOrgTypeMapper;
     @Override
     public TableDataInfo<CoreSafecheckPlan> selectPage(CoreSafecheckPlan coreSafecheckPlan) {
         //未删除
@@ -329,7 +331,6 @@ public class CoreSafecheckPlanServiceImpl extends ServiceImpl<CoreSafecheckPlanM
             throw new RuntimeException("未选择检查项!");
         }
 
-        Long pid = coreSafecheckPlan.getId();
         if (coreSafecheckPlan.getId() == null) {
             //先处理检查计划
             coreSafecheckPlan.setPlanOfOrgId(coreSafecheckPlan.getPlanCreateOrgId());
@@ -398,6 +399,15 @@ public class CoreSafecheckPlanServiceImpl extends ServiceImpl<CoreSafecheckPlanM
 
             }
         }
+        //再处理受检机构类型
+        if(coreSafecheckPlan.getCheckOrgTypes()!=null){
+            //删除当前计划的受检机构类型
+            coreSafecheckPlanToCheckOrgTypeMapper.delete(new LambdaQueryWrapper<CoreSafecheckPlanToCheckOrgType>().eq(CoreSafecheckPlanToCheckOrgType::getPlanId, coreSafecheckPlan.getId()));
+            for (Integer type :
+                    coreSafecheckPlan.getCheckOrgTypes()) {
+                coreSafecheckPlanToCheckOrgTypeMapper.insert(new CoreSafecheckPlanToCheckOrgType(coreSafecheckPlan.getId(),type));
+            }
+        }
 
 
         return returnId;
@@ -416,7 +426,7 @@ public class CoreSafecheckPlanServiceImpl extends ServiceImpl<CoreSafecheckPlanM
             p.setModifiedBy(SecurityUtils.getUserId());
             p.setPlanName(coreSafecheckPlan.getPlanName());
             p.setBuildTaskNow(coreSafecheckPlan.isBuildTaskNow());
-            p.setCheckOrgType(coreSafecheckPlan.getCheckOrgType());
+//            p.setCheckOrgType(coreSafecheckPlan.getCheckOrgType());
             p.setCheckType(coreSafecheckPlan.getCheckType());
             p.setCount(p.getCount() > coreSafecheckPlan.getCount() ? p.getCount() : coreSafecheckPlan.getCount());
             p.setDescription(coreSafecheckPlan.getDescription());
@@ -460,6 +470,16 @@ public class CoreSafecheckPlanServiceImpl extends ServiceImpl<CoreSafecheckPlanM
 
                 }
             }
+            //再处理受检机构类型
+            List<CoreSafecheckPlanToCheckOrgType> checkOrgTypes = coreSafecheckPlanToCheckOrgTypeMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToCheckOrgType>().eq(CoreSafecheckPlanToCheckOrgType::getPlanId, coreSafecheckPlan.getId()));
+            if(checkOrgTypes!=null){
+                //删除当前计划的受检机构类型
+                coreSafecheckPlanToCheckOrgTypeMapper.delete(new LambdaQueryWrapper<CoreSafecheckPlanToCheckOrgType>().eq(CoreSafecheckPlanToCheckOrgType::getPlanId, coreSafecheckPlan.getId()));
+                for (CoreSafecheckPlanToCheckOrgType type :
+                        checkOrgTypes) {
+                    coreSafecheckPlanToCheckOrgTypeMapper.insert(new CoreSafecheckPlanToCheckOrgType(p.getId(),type.getTypeId()));
+                }
+            }
             //再处理子计划检查要点关系
             //查询计划id为当前父计划的id,所属机构id为当前父计划所属机构id的数据
             List<CoreSafecheckPlanToPoint> rpList = coreSafecheckPlanToPointMapper.selectList(new LambdaQueryWrapper<CoreSafecheckPlanToPoint>().eq(CoreSafecheckPlanToPoint::getPlanId, coreSafecheckPlan.getId()).eq(CoreSafecheckPlanToPoint::getOfOrgId, coreSafecheckPlan.getPlanOfOrgId()));

soc-modules/soc-modules-core/src/main/java/com/xunmei/core/safetyCheck/service/impl/CoreSafecheckPlanToCheckOrgTypeServiceImpl.java

@@ -0,0 +1,125 @@
+package com.xunmei.core.safetyCheck.service.impl;
+
+import java.util.List;
+
+import com.xunmei.common.core.utils.DateUtils;
+import com.xunmei.core.safetyCheck.domain.CoreSafecheckPlanToCheckOrgType;
+import com.xunmei.core.safetyCheck.mapper.CoreSafecheckPlanToCheckOrgTypeMapper;
+import com.xunmei.core.safetyCheck.service.ICoreSafecheckPlanToCheckOrgTypeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.Arrays;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.xunmei.common.core.web.page.TableDataInfo;
+
+/**
+ * 常规安全检查-受检机构类型关联Service业务层处理
+ *
+ * @author xunmei
+ * @date 2023-11-14
+ */
+@Service
+public class CoreSafecheckPlanToCheckOrgTypeServiceImpl extends ServiceImpl<CoreSafecheckPlanToCheckOrgTypeMapper, CoreSafecheckPlanToCheckOrgType> implements ICoreSafecheckPlanToCheckOrgTypeService {
+    @Autowired
+    private CoreSafecheckPlanToCheckOrgTypeMapper coreSafecheckPlanToCheckOrgTypeMapper;
+
+    @Override
+    public TableDataInfo<CoreSafecheckPlanToCheckOrgType> selectPage(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType) {
+        //未删除
+        Page<CoreSafecheckPlanToCheckOrgType> page;
+        //分页
+        if (coreSafecheckPlanToCheckOrgType.getPageNum() != null && coreSafecheckPlanToCheckOrgType.getPageSize() != null) {
+            page = new Page<>(coreSafecheckPlanToCheckOrgType.getPageNum(), coreSafecheckPlanToCheckOrgType.getPageSize());
+        } else {
+            page = new Page<>();
+        }
+        //查询条件
+        QueryWrapper<CoreSafecheckPlanToCheckOrgType> query = new QueryWrapper<>(coreSafecheckPlanToCheckOrgType);
+        //下穿
+        if (coreSafecheckPlanToCheckOrgType.getCheckSub()) {
+        }
+        //时间范围查询
+        if (coreSafecheckPlanToCheckOrgType.getParams().get("beginTime") != null && coreSafecheckPlanToCheckOrgType.getParams().get("endTime") != null) {
+            query.between("create_time", coreSafecheckPlanToCheckOrgType.getParams().get("beginTime"), coreSafecheckPlanToCheckOrgType.getParams().get("endTime"));
+        }
+        //获取数据
+        page = coreSafecheckPlanToCheckOrgTypeMapper.selectPage(page, query);
+        //抓换为TableDataInfo适配前端
+        return TableDataInfo.build(page);
+
+
+    }
+
+
+    /**
+     * 查询常规安全检查-受检机构类型关联
+     *
+     * @param planId 常规安全检查-受检机构类型关联主键
+     * @return 常规安全检查-受检机构类型关联
+     */
+    @Override
+    public CoreSafecheckPlanToCheckOrgType selectCoreSafecheckPlanToCheckOrgTypeByPlanId(Long planId) {
+        return coreSafecheckPlanToCheckOrgTypeMapper.selectById(planId);
+    }
+
+    /**
+     * 查询常规安全检查-受检机构类型关联列表
+     *
+     * @param coreSafecheckPlanToCheckOrgType 常规安全检查-受检机构类型关联
+     * @return 常规安全检查-受检机构类型关联
+     */
+    @Override
+    public List<CoreSafecheckPlanToCheckOrgType> selectCoreSafecheckPlanToCheckOrgTypeList(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType) {
+        return coreSafecheckPlanToCheckOrgTypeMapper.selectList(new QueryWrapper<>(coreSafecheckPlanToCheckOrgType));
+    }
+
+    /**
+     * 新增常规安全检查-受检机构类型关联
+     *
+     * @param coreSafecheckPlanToCheckOrgType 常规安全检查-受检机构类型关联
+     * @return 结果
+     */
+    @Override
+    public int insertCoreSafecheckPlanToCheckOrgType(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType) {
+        coreSafecheckPlanToCheckOrgType.setCreateTime(DateUtils.getNowDate());
+        return coreSafecheckPlanToCheckOrgTypeMapper.insert(coreSafecheckPlanToCheckOrgType);
+    }
+
+    /**
+     * 修改常规安全检查-受检机构类型关联
+     *
+     * @param coreSafecheckPlanToCheckOrgType 常规安全检查-受检机构类型关联
+     * @return 结果
+     */
+    @Override
+    public int updateCoreSafecheckPlanToCheckOrgType(CoreSafecheckPlanToCheckOrgType coreSafecheckPlanToCheckOrgType) {
+        coreSafecheckPlanToCheckOrgType.setUpdateTime(DateUtils.getNowDate());
+        return coreSafecheckPlanToCheckOrgTypeMapper.updateById(coreSafecheckPlanToCheckOrgType);
+    }
+
+    /**
+     * 批量删除常规安全检查-受检机构类型关联
+     *
+     * @param planIds 需要删除的常规安全检查-受检机构类型关联主键
+     * @return 结果
+     */
+    @Override
+    public int deleteCoreSafecheckPlanToCheckOrgTypeByPlanIds(Long[] planIds) {
+        return coreSafecheckPlanToCheckOrgTypeMapper.deleteBatchIds(Arrays.asList((planIds)));
+    }
+
+    /**
+     * 删除常规安全检查-受检机构类型关联信息
+     *
+     * @param planId 常规安全检查-受检机构类型关联主键
+     * @return 结果
+     */
+    @Override
+    public int deleteCoreSafecheckPlanToCheckOrgTypeByPlanId(Long planId) {
+        return coreSafecheckPlanToCheckOrgTypeMapper.deleteById(planId);
+    }
+}

soc-modules/soc-modules-core/src/main/resources/mapper/reportForms/ResumptionReportMapper.xml

@@ -6,16 +6,27 @@
 
     <select id="selectReport" resultType="com.xunmei.core.reportForms.resumption.vo.ResumptionDayVO">
         SELECT
-            COUNT( a.id ) AS frontPlanNumber,
-            IFNULL( SUM( IF ( a.`status` = 3, 1, 0 )), 0 ) AS frontRealityNumber,
-        IF( SUM( IF ( a.`status` = 3, 1, 0 ))=0 OR COUNT( a.id )=0,'0%',IFNULL(
+        COUNT( d.id ) AS totalRealityRectificationNumber,
+        COUNT( a.id ) AS frontPlanNumber,
+        IFNULL( SUM( IF ( a.`status` = 3, 1, 0 )), 0 ) AS frontRealityNumber,
+        IF
+        (
+        SUM(
+        IF
+        ( a.`status` = 3, 1, 0 ))= 0
+        OR COUNT( a.id )= 0,
+        '0%',
+        IFNULL(
         CONCAT( SUM( IF ( a.`status` = 3, 1, 0 ))/ COUNT( a.id )* 100, '%' ),
         '0%'
         )) AS frontRate,
-            IFNULL( SUM( a.exception_count ), 0 ) AS frontAbnormalNumber
+        IFNULL( SUM( a.exception_count ), 0 ) AS frontAbnormalNumber,
+        IFNULL( COUNT( d.id )/ IFNULL( SUM( a.exception_count ), 0 )* 100, '0%' ) AS totalRealityRectificationRate
         FROM
-            core_resumption a
-                LEFT JOIN core_resumption_plan b ON a.plan_id = b.id
+        core_resumption a
+        LEFT JOIN core_resumption_plan b ON a.plan_id = b.id
+        LEFT JOIN core_question d ON a.id = d.src_task_id
+        AND d.reform_status = 11
         WHERE
             b.plan_type = #{planType}
           AND a.type = 2
@@ -29,4 +40,45 @@
             and a.org_path  like concat(#{orgPath},'%')
         </if>
     </select>
+    <select id="planRectification" resultType="java.lang.Integer">
+        SELECT
+            COUNT(1)
+        FROM
+            core_question
+        WHERE
+            confirm_status = 2
+          AND reform_status = 10
+          AND src_task_id = #{taskId}
+    </select>
+    <select id="selectIntrusionTestReport"
+            resultType="com.xunmei.core.reportForms.resumption.vo.IntrusionTestReportVO">
+        SELECT
+            IFNULL(a.exception_count,0) AS abnormalNumber,
+            COUNT( a.id ) AS planNumber,
+            IFNULL( SUM( IF ( a.`status` = 3, 1, 0 )), 0 ) AS realityNumber,
+            IF
+                (
+                            IFNULL( SUM( IF ( a.`status` = 3, 1, 0 )), 0 )= 0
+                        OR COUNT( a.id )= 0,
+                            '0%',
+                            CONCAT(
+                                            IFNULL( SUM( IF ( a.`status` = 3, 1, 0 )), 0 )/ COUNT( a.id )* 100,
+                                            '%'
+                                )) AS realityRate,
+            COUNT( c.id ) AS realityRectificationNumber,
+            IF(COUNT( c.id )=0 OR IFNULL(a.exception_count,0)=0,'0%',CONCAT(COUNT( c.id )/IFNULL(a.exception_count,0)*100,'%'))	 AS realityRectificationRate
+        FROM
+            core_resumption a
+                LEFT JOIN core_resumption_plan b ON a.plan_id = b.id
+                LEFT JOIN core_question c ON c.src_task_id = a.id
+                AND reform_status = 11
+        WHERE
+            b.plan_type =4
+        <if test="date !=null">
+            AND a.ymd_date like concat(#{date},'%')
+        </if>
+        <if test="orgPath !=null">
+            and a.org_path  like concat(#{orgPath},'%')
+        </if>
+    </select>
 </mapper>

soc-modules/soc-modules-core/src/main/resources/mapper/safetycheck/CoreSafecheckPlanMapper.xml

@@ -22,6 +22,7 @@
         <result property="modifiedBy" column="modified_by"/>
         <result property="sourceType" column="source_type"/>
         <result property="roleNames" column="role_names"/>
+        <result property="typeNames" column="type_names"/>
 
         <result property="distribute" column="distribute"/>
         <result property="distributeStatus" column="distribute_status"/>
@@ -55,6 +56,12 @@
             <result column="exec_org_id" property="id"/>
             <result column="exec_org_name" property="name"/>
         </collection>
+        <!-- 检查机构类型关系映射 -->
+        <collection property="checkOrgTypeList"
+                    ofType="com.xunmei.core.safetyCheck.domain.CoreSafecheckPlanToCheckOrgType">
+            <result column="type_plan_id" property="planId"/>
+            <result column="type_id" property="typeId"/>
+        </collection>
         <!-- 检查要点关系映射 -->
         <collection property="rulePointList" ofType="com.xunmei.core.safetyCheck.vo.ruleItem.SafetyCheckRulePointVo">
             <result column="rule_point_id" property="id"/>
@@ -161,7 +168,9 @@
                o3.NAME          AS exec_org_name,
                o4.id            AS check_org_id,
                o4.NAME          AS check_org_name,
-               pp.of_org_id
+               pp.of_org_id,
+               typ.type_id,
+               typ.plan_id      as type_plan_id
         FROM core_safecheck_plan c
                  LEFT JOIN sys_org o1 ON c.plan_create_org_id = o1.id
                  LEFT JOIN sys_org o2 ON c.plan_of_org_id = o2.id
@@ -175,8 +184,8 @@
                  LEFT JOIN core_safetycheck_rule_point rp ON rp.id = pp.point_id
                  LEFT JOIN core_safetycheck_rule_item ri ON ri.id = rp.item_id
                  LEFT JOIN core_safetycheck_rule cr ON cr.id = ri.rule_id
-                 LEFT JOIN sys_area are
-        ON are.id = rp.area_id
+                 LEFT JOIN sys_area are ON are.id = rp.area_id
+                 LEFT JOIN core_safecheck_plan_to_check_org_type typ ON c.id = typ.plan_id
         where c.id = #{id}
 
     </select>
@@ -185,6 +194,7 @@
         GROUP_CONCAT(DISTINCT role_name) as role_names,
         GROUP_CONCAT( tem.check_org_name) as check_org,
         GROUP_CONCAT( tem.exec_org_name) as exec_org,
+        GROUP_CONCAT( tem.dict_label) as type_names,
         tem.*
         FROM
         (
@@ -192,7 +202,6 @@
         c.plan_name,
         c.plan_cycle,
         c.exec_org_type,
-        c.check_org_type,
         c.plan_status,
         c.start_date,
         c.end_date,
@@ -221,7 +230,10 @@
         o3.id AS check_org_id,
         o3.short_name AS check_org_name,
         o4.id AS exec_org_id,
-        o4.short_name AS exec_org_name
+        o4.short_name AS exec_org_name,
+        typ.type_id,
+        typ.plan_id as type_plan_id,
+        dic.dict_label
         FROM
         core_safecheck_plan c
         LEFT JOIN sys_org o1 ON c.plan_create_org_id = o1.id
@@ -233,8 +245,11 @@
         LEFT JOIN core_safecheck_plan_to_exec_org eo ON eo.plan_id = c.id
         LEFT JOIN sys_org o4 ON o4.id = eo.org_id
         LEFT JOIN sys_user u1 ON u1.id = c.modified_by
+        LEFT JOIN core_safecheck_plan_to_check_org_type typ ON c.id=typ.plan_id
+        LEFT JOIN sys_dict_data dic ON dic.dict_value = typ.type_id
         WHERE
         1 =1
+        and dic.dict_type='sys_org_type'
         <if test="check.planName != null  and check.planName != ''">
             and c.plan_name like concat('%', #{check.planName}, '%')
         </if>
@@ -247,9 +262,9 @@
         <if test="check.execOrgType != null and check.execOrgType != ''">
             and c.exec_org_type = #{check.execOrgType}
         </if>
-        <if test="check.checkOrgType != null and check.checkOrgType != ''">
-            and c.check_org_type = #{check.checkOrgType}
-        </if>
+        <!--        <if test="check.checkOrgType != null and check.checkOrgType != ''">-->
+        <!--            and c.check_org_type = #{check.checkOrgType}-->
+        <!--        </if>-->
         <if test="check.planStatus != null ">
             and c.plan_status = #{check.planStatus}
         </if>
@@ -294,7 +309,7 @@
         1,
         2
         )
-            )
+        )
 
 
     </select>
@@ -434,11 +449,11 @@
     </delete>
     <select id="selectByRole" resultType="com.xunmei.core.safetyCheck.domain.CoreSafecheckPlan">
         select * from core_safecheck_plan p
-<!--        inner join sys_org o on p.plan_of_org_id =o.id and o.deleted=0 and o.type=3-->
-            inner join core_safecheck_plan_to_role r on p.id=r.plan_id and r.role_id in
-            <foreach collection="roleIds" item="id" separator="," open="(" close=")">
-                #{id}
-            </foreach>
+        <!--        inner join sys_org o on p.plan_of_org_id =o.id and o.deleted=0 and o.type=3-->
+        inner join core_safecheck_plan_to_role r on p.id=r.plan_id and r.role_id in
+        <foreach collection="roleIds" item="id" separator="," open="(" close=")">
+            #{id}
+        </foreach>
         where status=1 and plan_of_org_id=#{hangsheOrgId};
     </select>
     <select id="selectChildren" resultMap="CoreSafecheckPlanResult">
@@ -581,6 +596,5 @@
         </if>
 
 
-
     </select>
 </mapper>

soc-modules/soc-modules-core/src/main/resources/mapper/safetycheck/CoreSafecheckPlanToCheckOrgTypeMapper.xml

@@ -0,0 +1,110 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.xunmei.core.safetyCheck.mapper.CoreSafecheckPlanToCheckOrgTypeMapper">
+
+    <resultMap type="com.xunmei.core.safetyCheck.domain.CoreSafecheckPlanToCheckOrgType"
+               id="CoreSafecheckPlanToCheckOrgTypeResult">
+        <result property="planId" column="plan_id"/>
+        <result property="typeId" column="type_id"/>
+        <result property="createTime" column="create_time"/>
+        <result property="updateTime" column="update_time"/>
+        <result property="createBy" column="create_by"/>
+        <result property="updateBy" column="update_by"/>
+    </resultMap>
+
+    <sql id="selectCoreSafecheckPlanToCheckOrgTypeVo">
+        select plan_id, type_id, create_time, update_time, create_by, update_by
+        from core_safecheck_plan_to_check_org_type
+    </sql>
+
+    <select id="selectCoreSafecheckPlanToCheckOrgTypeList"
+            parameterType="com.xunmei.core.safetyCheck.domain.CoreSafecheckPlanToCheckOrgType"
+            resultMap="CoreSafecheckPlanToCheckOrgTypeResult">
+        <include refid="selectCoreSafecheckPlanToCheckOrgTypeVo"/>
+        <where>
+            <if test="planId != null ">
+                and plan_id = #{planId}
+            </if>
+            <if test="typeId != null ">
+                and type_id = #{typeId}
+            </if>
+        </where>
+    </select>
+
+    <select id="selectCoreSafecheckPlanToCheckOrgTypeByPlanId" parameterType="Long"
+            resultMap="CoreSafecheckPlanToCheckOrgTypeResult">
+        <include refid="selectCoreSafecheckPlanToCheckOrgTypeVo"/>
+        where plan_id = #{planId}
+    </select>
+
+    <insert id="insertCoreSafecheckPlanToCheckOrgType"
+            parameterType="com.xunmei.core.safetyCheck.domain.CoreSafecheckPlanToCheckOrgType">
+        insert into core_safecheck_plan_to_check_org_type
+        <trim prefix="(" suffix=")" suffixOverrides=",">
+            <if test="planId != null">plan_id,
+            </if>
+            <if test="typeId != null">type_id,
+            </if>
+            <if test="createTime != null">create_time,
+            </if>
+            <if test="updateTime != null">update_time,
+            </if>
+            <if test="createBy != null">create_by,
+            </if>
+            <if test="updateBy != null">update_by,
+            </if>
+        </trim>
+        <trim prefix="values (" suffix=")" suffixOverrides=",">
+            <if test="planId != null">#{planId},
+            </if>
+            <if test="typeId != null">#{typeId},
+            </if>
+            <if test="createTime != null">#{createTime},
+            </if>
+            <if test="updateTime != null">#{updateTime},
+            </if>
+            <if test="createBy != null">#{createBy},
+            </if>
+            <if test="updateBy != null">#{updateBy},
+            </if>
+        </trim>
+    </insert>
+
+    <update id="updateCoreSafecheckPlanToCheckOrgType"
+            parameterType="com.xunmei.core.safetyCheck.domain.CoreSafecheckPlanToCheckOrgType">
+        update core_safecheck_plan_to_check_org_type
+        <trim prefix="SET" suffixOverrides=",">
+            <if test="typeId != null">type_id =
+                #{typeId},
+            </if>
+            <if test="createTime != null">create_time =
+                #{createTime},
+            </if>
+            <if test="updateTime != null">update_time =
+                #{updateTime},
+            </if>
+            <if test="createBy != null">create_by =
+                #{createBy},
+            </if>
+            <if test="updateBy != null">update_by =
+                #{updateBy},
+            </if>
+        </trim>
+        where plan_id = #{planId}
+    </update>
+
+    <delete id="deleteCoreSafecheckPlanToCheckOrgTypeByPlanId" parameterType="Long">
+        delete
+        from core_safecheck_plan_to_check_org_type
+        where plan_id = #{planId}
+    </delete>
+
+    <delete id="deleteCoreSafecheckPlanToCheckOrgTypeByPlanIds" parameterType="String">
+        delete from core_safecheck_plan_to_check_org_type where plan_id in
+        <foreach item="planId" collection="array" open="(" separator="," close=")">
+            #{planId}
+        </foreach>
+    </delete>
+</mapper>

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/controller/SysDeptController.java

@@ -21,6 +21,7 @@ import com.xunmei.system.api.Eto.SysOrgTreeRequestDto;
 import com.xunmei.system.api.domain.SysDept;
 import com.xunmei.system.api.domain.SysOrg;
 import com.xunmei.system.api.domain.SysUser;
+import com.xunmei.system.api.vo.FindOrgTypes;
 import com.xunmei.system.api.vo.SysOrgVO;
 import com.xunmei.system.service.ISysDeptService;
 import com.xunmei.system.service.ISysOrgService;
@@ -346,7 +347,12 @@ public class SysDeptController extends BaseController {
         return orgService.findByOrgTypeAndParent(orgType, path);
     }
 
-
+    @ApiOperation(value = "根据受检机构类型查询")
+    @InnerAuth
+    @PostMapping("/findByOrgTypesAndParent")
+    List<SysOrg> findByOrgTypesAndParent(@RequestBody FindOrgTypes types) {
+        return orgService.findByOrgTypesAndParent(types);
+    }
     @ApiOperation(value = "获取机构查询参数")
     @PostMapping("/selectOrgTreeReq")
     R<OrgTreeResp> getOrgTreeResp(@RequestBody OrgTreeReq orgTreeReq) {

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/controller/SysUserController.java

@@ -94,24 +94,13 @@ public class SysUserController extends BaseController {
         if (null != sysUser && "Y".equals(sysUser.getIsManage())) {
             admin = true;
         }
- /*       String s = roleService.selectRoleNameByUserId(SecurityUtils.getUserId());
-        if (StringUtils.isNotEmpty(s)) {
-            int i = s.indexOf(",");
-
-            if (i >= 0) {
-                String[] split = s.split(",");
-                for (int l = 0; l < split.length; l++) {
-                    if (split[l].endsWith("管理人员") || split[l].equals("超级管理员")) {
-                        admin = true;
-                        break;
-                    }
-                }
-            } else if (s.endsWith("管理人员") || s.equals("超级管理员")) {
-                admin = true;
-            }
-        }*/
-
         ajax.put("check", admin);
+        String orgName="福建农信";
+        if (null!=user.getOrgId()){
+            SysOrg sysOrg = orgMapper.selectSysOrgById(user.getOrgId());
+            orgName=sysOrg.getShortName();
+        }
+        ajax.put("orgName",orgName);
         return ajax;
     }
 

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/mapper/SysOrgMapper.java

@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.xunmei.common.core.vo.IdNameVo;
 import com.xunmei.system.api.domain.SysOrg;
+import com.xunmei.system.api.vo.FindOrgTypes;
 import com.xunmei.system.api.vo.SysOrgVO;
 import org.apache.ibatis.annotations.Param;
 import org.springframework.stereotype.Component;
@@ -88,4 +89,6 @@ public interface SysOrgMapper extends BaseMapper<SysOrg> {
     List<IdNameVo> getParentName(@Param("ids") List<Long> ids);
 
     List<SysOrg> findByOrgTypeAndParent(@Param("orgType")Integer orgType, @Param("path")String path);
+
+    List<SysOrg> findByOrgTypesAndParent(@Param("types")List<Integer> types,@Param("path") String path);
 }

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/service/ISysOrgService.java

@@ -5,6 +5,7 @@ import com.xunmei.common.core.domain.OrgTreeReq;
 import com.xunmei.common.core.domain.OrgTreeResp;
 import com.xunmei.common.core.web.page.TableDataInfo;
 import com.xunmei.system.api.domain.SysOrg;
+import com.xunmei.system.api.vo.FindOrgTypes;
 import com.xunmei.system.api.vo.SysOrgVO;
 
 import java.util.List;
@@ -142,4 +143,6 @@ public interface ISysOrgService extends IService<SysOrg> {
     SysOrg selectByShortName(String shortName);
 
     String selectOrgNameByPath(Long orgId);
+
+    List<SysOrg> findByOrgTypesAndParent(FindOrgTypes types);
 }

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/service/impl/SysOrgServiceImpl.java

@@ -21,6 +21,7 @@ import com.xunmei.common.core.web.page.TableDataInfo;
 import com.xunmei.common.redis.utils.RedisUtils;
 import com.xunmei.common.security.utils.SecurityUtils;
 import com.xunmei.system.api.domain.SysOrg;
+import com.xunmei.system.api.vo.FindOrgTypes;
 import com.xunmei.system.api.vo.SysOrgVO;
 import com.xunmei.system.mapper.SysOrgMapper;
 import com.xunmei.system.mapper.SysUserMapper;
@@ -582,4 +583,9 @@ public class SysOrgServiceImpl extends ServiceImpl<SysOrgMapper, SysOrg> impleme
         });
         return String.join("_", list);
     }
+
+    @Override
+    public List<SysOrg> findByOrgTypesAndParent(FindOrgTypes types) {
+        return sysOrgMapper.findByOrgTypesAndParent(types.getTypes(),types.getPath());
+    }
 }

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/util/GenderConverter.java

@@ -0,0 +1,40 @@
+package com.xunmei.system.util;
+
+import com.alibaba.excel.converters.Converter;
+import com.alibaba.excel.enums.CellDataTypeEnum;
+import com.alibaba.excel.metadata.CellData;
+import com.alibaba.excel.metadata.GlobalConfiguration;
+import com.alibaba.excel.metadata.property.ExcelContentProperty;
+
+/**
+ * @author :LuoWei
+ * @date : 2023/11/14
+ */
+public class GenderConverter implements Converter<String> {
+    @Override
+    public Class supportJavaTypeKey() {
+        return null;
+    }
+
+    @Override
+    public CellDataTypeEnum supportExcelTypeKey() {
+        return null;
+    }
+
+    @Override
+    public String convertToJavaData(CellData cellData, ExcelContentProperty excelContentProperty, GlobalConfiguration globalConfiguration) throws Exception {
+        return null;
+    }
+
+    @Override
+    public CellData convertToExcelData(String s, ExcelContentProperty excelContentProperty, GlobalConfiguration globalConfiguration) throws Exception {
+        // 根据条件修改是否管理人员的值
+        if ("0".equals(s)) {
+            return new CellData("男");
+        } else if ("1".equals(s)){
+            return new CellData("女");
+        }else {
+            return new CellData("未知");
+        }
+    }
+}

soc-modules/soc-modules-system/src/main/java/com/xunmei/system/util/UserExport.java

@@ -33,10 +33,13 @@ public class UserExport {
     private String phone;
     @ExcelProperty(value = "状态", index = 6, converter = UserStatusConverter.class)
     private String isLock;
-    @ExcelProperty(value = "是否管理人员", index = 7, converter = UserManagerConverter.class)
+    @ExcelProperty(value = "安保部门从业人员", index = 7, converter = UserManagerConverter.class)
     private String isManager;
+
     @ExcelProperty(value = "登录IP", index = 8)
     private String lastIp;
     @ExcelProperty(value = "登录时间", index = 9)
     private Date lastTime;
+    @ExcelProperty(value = "性别", index = 10, converter = GenderConverter.class)
+    private String gender;
 }

soc-modules/soc-modules-system/src/main/resources/mapper/system/SysOrgMapper.xml

@@ -689,5 +689,14 @@
     <select id="selectByShortName" resultType="com.xunmei.system.api.domain.SysOrg">
             SELECT * FROM sys_org WHERE short_name=#{name}  AND deleted=0
     </select>
+    <select id="findByOrgTypesAndParent" resultType="com.xunmei.system.api.domain.SysOrg">
+        select c.* from sys_org c where c.path like concat('%',#{path}, '%')  and deleted=0
+and
+            c.type in
+
+        <foreach collection="types" item="type" separator="," open="(" close=")">
+            #{type}
+        </foreach>
+    </select>
 
 </mapper>

soc-modules/soc-modules-system/src/main/resources/mapper/system/SysUserMapper.xml

@@ -502,6 +502,9 @@
         <if test="info.onlyManager ==true">
             AND t.is_manage ='Y'
         </if>
+        <if test="info.onlyManager ==false or info.onlyManager==null">
+            AND t.is_manage is NULL
+        </if>
         ORDER BY t.org_id DESC
     </select>
     <select id="selectrolesByOrgId" resultType="com.xunmei.system.api.domain.SysRole">