Merge branch 'test-merge' of http://219.151.181.73:3000/zhuwei/bladex into test-merge

# Conflicts:
#	blade-service/blade-business/src/main/java/org/springblade/business/controller/TaskController.java
#	blade-service/blade-manager/src/main/java/org/springblade/manager/service/impl/TextdictInfoServiceImpl.java

blade-service-api/blade-business-api/src/main/java/org/springblade/business/dto/StandardInfoJoinDTO.java

@@ -0,0 +1,26 @@
+package org.springblade.business.dto;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+/**
+ * 条件设置
+ * @author LHB
+ */
+@Data
+public class StandardInfoJoinDTO {
+    /**
+     * 主关联id
+     */
+    @NotNull(message = "主关联id不能为空")
+    private Long leftId;
+
+    /**
+     * 副连接id
+     */
+    @NotEmpty(message = "副连接id不能为空")
+    private List<Long> rightIds;
+}

blade-service-api/blade-business-api/src/main/java/org/springblade/business/dto/StandardInfoPrivateJoinDTO.java

@@ -0,0 +1,26 @@
+package org.springblade.business.dto;
+
+import lombok.Data;
+import org.springblade.business.entity.UStandardInfoPrivateJoin;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+/**
+ * 与表单的关联对象
+ * @author LHB
+ */
+@Data
+public class StandardInfoPrivateJoinDTO {
+    /**
+     * 主关联id
+     */
+    @NotNull(message = "主关联id不能为空")
+    private Long leftId;
+    /**
+     * 副连接id
+     */
+    @NotEmpty(message = "副连接信息不能为空")
+    private List<UStandardInfoPrivateJoin> rightIds;
+}

blade-service-api/blade-business-api/src/main/java/org/springblade/business/dto/UStandardInfoDTO.java

@@ -0,0 +1,20 @@
+package org.springblade.business.dto;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springblade.business.entity.UStandardInfo;
+
+import java.util.List;
+
+/**
+ * 试验规范信息DTO
+ * @author LHB
+ */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class UStandardInfoDTO extends UStandardInfo {
+    /**
+     * 基础信息
+     */
+    private List<UStandardInfo> info;
+}

blade-service-api/blade-business-api/src/main/java/org/springblade/business/entity/PrivateStandard.java

@@ -0,0 +1,107 @@
+package org.springblade.business.entity;
+
+import cn.hutool.core.date.DateTime;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+
+import java.time.LocalDateTime;
+import java.util.Date;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+
+/**
+ * 规范文件夹及规范文件表
+ *
+ * @author LHB
+ * @TableName u_wbs_private_standard
+ */
+@TableName(value = "u_wbs_private_standard")
+@Data
+public class PrivateStandard {
+    /**
+     *
+     */
+    @TableId
+    private Long id;
+
+    /**
+     * 名称（规范文件夹名称及规范名称）
+     */
+    @NotBlank(message = "名称不能为空")
+    private String name;
+
+    /**
+     * 父级节点id
+     * type = 2 必传
+     */
+    private Long parentId;
+
+    /**
+     * 项目试验节点id
+     * type = 1 必传
+     */
+    private Long privateId;
+
+    /**
+     * 类型（1-规范文件夹，2-规范文件）
+     */
+    @NotNull(message = "类型不能为空")
+    private Integer type;
+
+    /**
+     * 下达日期（年月日）
+     */
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    private Date issueDate;
+
+    /**
+     * 实施日期（年月日）
+     */
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    private Date actualizeDate;
+
+    /**
+     * 规范文件路径
+     */
+    private String standardFileUrl;
+
+    /**
+     * 是否删除（0-正常，1-已删除）
+     */
+    private Integer isDeleted = 0;
+    /**
+     * 状态（1-正常，2-过期）
+     */
+    private Integer status = 1;
+
+    /**
+     * 创建时间
+     */
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+
+    /**
+     * 创建人
+     */
+    private Long createUser;
+
+    /**
+     * 修改时间
+     */
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime updateTime;
+
+    /**
+     * 修改人
+     */
+    private Long updateUser;
+}

blade-service-api/blade-business-api/src/main/java/org/springblade/business/entity/UStandardInfo.java

@@ -0,0 +1,73 @@
+package org.springblade.business.entity;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import java.util.Date;
+import lombok.Data;
+import org.hibernate.validator.constraints.Range;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+
+/**
+ * 规范参数管理-基础信息
+ * @author LHB
+ * @TableName u_standard_info
+ */
+@TableName(value ="u_standard_info")
+@Data
+public class UStandardInfo {
+    /**
+     * 
+     */
+    @TableId
+    private Long id;
+
+    /**
+     * 名称（样品信息名称）
+     */
+    @NotBlank(message = "名称不能为空")
+    private String name;
+
+    /**
+     * 父级节点id
+     */
+    private Long parentId;
+
+    /**
+     * 规范文件id
+     */
+    private Long standardId;
+
+    /**
+     *  类型（1-样品信息，2-技术指标）
+     */
+    @NotNull(message = "类型不能为空")
+    @Range(min = 1, max = 2, message = "类型只能为1或2")
+    private Integer type;
+
+    /**
+     *  是否删除（0-正常，1-已删除）
+     */
+    private Integer isDeleted;
+
+    /**
+     *  创建时间
+     */
+    private Date createTime;
+
+    /**
+     *  创建人
+     */
+    private Long createUser;
+
+    /**
+     *  修改时间
+     */
+    private Date updateTime;
+
+    /**
+     *  修改人
+     */
+    private Long updateUser;
+}

blade-service-api/blade-business-api/src/main/java/org/springblade/business/entity/UStandardInfoJoin.java

@@ -0,0 +1,58 @@
+package org.springblade.business.entity;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import java.util.Date;
+import lombok.Data;
+
+/**
+ * 样品信息关联表
+ * @author LHB
+ * @TableName u_standard_info_join
+ */
+@TableName(value ="u_standard_info_join")
+@Data
+public class UStandardInfoJoin {
+    /**
+     * 
+     */
+    @TableId
+    private Long id;
+
+    /**
+     * 规范基础信息关联主id
+     */
+    private Long standardInfoLeftId;
+
+    /**
+     * 规范基础信息关联副id
+     */
+    private Long standardInfoRightId;
+
+    /**
+     *  是否删除（0-正常，1-已删除）
+     */
+    private Integer isDeleted;
+
+    /**
+     *  创建时间
+     */
+    private Date createTime;
+
+    /**
+     *  创建人
+     */
+    private Long createUser;
+
+    /**
+     *  修改时间
+     */
+    private Date updateTime;
+
+    /**
+     *  修改人
+     */
+    private Long updateUser;
+
+
+}

blade-service-api/blade-business-api/src/main/java/org/springblade/business/entity/UStandardInfoPrivateJoin.java

@@ -0,0 +1,82 @@
+package org.springblade.business.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import java.util.Date;
+import lombok.Data;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+
+/**
+ * 样品信息与试验表 关联表
+ * @author LHB
+ * @TableName u_standard_info_private_join
+ */
+@TableName(value ="u_standard_info_private_join")
+@Data
+public class UStandardInfoPrivateJoin {
+    /**
+     * 
+     */
+    @TableId
+    private Long id;
+
+    /**
+     * 规范基础信息关联主id
+     */
+    @NotNull(message = "规范基础信息关联主id不能为空")
+    private Long standardInfoId;
+
+    /**
+     * 试验wbs表单id
+     */
+    @NotNull(message = "试验wbs表单id不能为空")
+    private Long privateId;
+
+    /**
+     * 元素key
+     */
+    @NotBlank(message = "元素key不能为空")
+    private String colKey;
+
+    /**
+     * 元素名称
+     */
+    @NotBlank(message = "元素名称不能为空")
+    private String colName;
+
+    /**
+     *  是否删除（0-正常，1-已删除）
+     */
+    private Integer isDeleted;
+
+    /**
+     *  创建时间
+     */
+    private Date createTime;
+
+    /**
+     *  创建人
+     */
+    private Long createUser;
+
+    /**
+     *  修改时间
+     */
+    private Date updateTime;
+
+    /**
+     *  修改人
+     */
+    private Long updateUser;
+
+
+    /**
+     * 表单名称（展示用）
+     */
+    @TableField(exist = false)
+    private String privateName;
+
+}

blade-service-api/blade-business-api/src/main/java/org/springblade/business/vo/UStandardInfoPrivateJoinVO.java

@@ -0,0 +1,17 @@
+package org.springblade.business.vo;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springblade.business.entity.UStandardInfo;
+import org.springblade.business.entity.UStandardInfoPrivateJoin;
+
+import java.util.List;
+
+/**
+ * @author LHB
+ */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class UStandardInfoPrivateJoinVO extends UStandardInfo {
+    private List<UStandardInfoPrivateJoin> privateJoins;
+}

blade-service-api/blade-business-api/src/main/java/org/springblade/business/vo/UStandardInfoVO.java

@@ -0,0 +1,19 @@
+package org.springblade.business.vo;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springblade.business.entity.UStandardInfo;
+
+import java.util.List;
+
+/**
+ * @author LHB
+ */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class UStandardInfoVO extends UStandardInfo {
+    /**
+     * 副连接对象
+     */
+    private List<UStandardInfo> standardInfos;
+}

blade-service/blade-business/src/main/java/org/springblade/business/controller/PrivateStandardController.java

@@ -0,0 +1,124 @@
+package org.springblade.business.controller;
+
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import org.springblade.business.entity.PrivateStandard;
+import org.springblade.business.service.PrivateStandardService;
+import org.springblade.common.utils.SnowFlakeUtil;
+import org.springblade.core.mp.support.Query;
+import org.springblade.core.secure.BladeUser;
+import org.springblade.core.secure.utils.SecureUtil;
+import org.springblade.core.tool.api.R;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+
+/**
+ * 规范文件夹及规范文件表(UWbsPrivateStandard)表控制层
+ *
+ * @author makejava
+ * @since 2025-06-10 11:09:22
+ */
+@RestController
+@RequestMapping("PrivateStandard")
+public class PrivateStandardController {
+    /**
+     * 服务对象
+     */
+    @Resource
+    private PrivateStandardService privateStandardService;
+
+    /**
+     * 分页查询所有数据
+     *
+     * @param query               分页对象
+     * @param uWbsPrivateStandard 查询实体
+     * @return 所有数据
+     */
+    @GetMapping("page")
+    public R<IPage<PrivateStandard>> selectAll(Query query, PrivateStandard uWbsPrivateStandard) {
+        try {
+            Page page = new Page(query.getCurrent(), query.getSize());
+            IPage<PrivateStandard> resultPage = this.privateStandardService.page(page, new QueryWrapper<>(uWbsPrivateStandard));
+            return R.data(resultPage);
+        } catch (Exception e) {
+            // 可根据实际需求记录日志或返回特定错误信息
+            return R.fail("查询失败");
+        }
+    }
+
+
+    /**
+     * 通过主键查询单条数据
+     *
+     * @param id 主键
+     * @return 单条数据
+     */
+    @GetMapping("/getById")
+    public R<PrivateStandard> selectOne(Long id) {
+        PrivateStandard byId = this.privateStandardService.getById(id);
+        return R.data(byId);
+    }
+
+    /**
+     * 新增数据
+     *
+     * @param uWbsPrivateStandard 实体对象
+     * @return 新增结果
+     */
+    @PostMapping("add")
+    public R<Boolean> insert(@RequestBody @Validated PrivateStandard uWbsPrivateStandard) {
+        uWbsPrivateStandard.setId(SnowFlakeUtil.getId());
+        if (uWbsPrivateStandard.getType() != 1 && uWbsPrivateStandard.getType() != 2) {
+            return R.fail("类型错误");
+        }
+        if (uWbsPrivateStandard.getType() == 1) {
+            uWbsPrivateStandard.setParentId(0L);
+            if (uWbsPrivateStandard.getPrivateId() == null) {
+                return R.fail("节点不能为空");
+            }
+        } else {
+            if (uWbsPrivateStandard.getParentId() == null) {
+                return R.fail("父级节点不能为空");
+            }
+            if (uWbsPrivateStandard.getIssueDate() == null) {
+                return R.fail("下达日期不能为空");
+            }
+            if (uWbsPrivateStandard.getActualizeDate() == null) {
+                return R.fail("实施日期不能为空");
+            }
+        }
+        boolean save = this.privateStandardService.insert(uWbsPrivateStandard);
+        return R.data(save);
+    }
+
+    /**
+     * 修改数据
+     *
+     * @param uWbsPrivateStandard 实体对象
+     * @return 修改结果
+     */
+    @PostMapping("edit")
+    public R<Boolean> update(@RequestBody @Validated PrivateStandard uWbsPrivateStandard) {
+        BladeUser user = SecureUtil.getUser();
+        uWbsPrivateStandard.setUpdateUser(user.getUserId());
+        boolean b = this.privateStandardService.updateById(uWbsPrivateStandard);
+        return R.data(b);
+    }
+
+    /**
+     * 删除数据
+     *
+     * @param id 主键
+     * @return 删除结果
+     */
+    @GetMapping("/delete")
+    public R<Boolean> delete(Long id) {
+        boolean b = this.privateStandardService.delete(id);
+        return R.data(b);
+    }
+}
+

blade-service/blade-business/src/main/java/org/springblade/business/controller/UStandardInfoController.java

@@ -0,0 +1,165 @@
+package org.springblade.business.controller;
+
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.springblade.business.dto.StandardInfoJoinDTO;
+import org.springblade.business.dto.StandardInfoPrivateJoinDTO;
+import org.springblade.business.dto.UStandardInfoDTO;
+import org.springblade.business.entity.UStandardInfo;
+import org.springblade.business.service.StandardInfoService;
+import org.springblade.business.vo.UStandardInfoPrivateJoinVO;
+import org.springblade.business.vo.UStandardInfoVO;
+import org.springblade.core.mp.support.Query;
+import org.springblade.core.tool.api.R;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * 规范参数管理-基础信息(UStandardInfo)表控制层
+ *
+ * @author makejava
+ * @since 2025-06-11 10:03:01
+ */
+@RestController
+@RequestMapping("uStandardInfo")
+public class UStandardInfoController {
+    /**
+     * 服务对象
+     */
+    @Resource
+    private StandardInfoService uStandardInfoService;
+
+    /**
+     * 分页查询所有数据
+     *
+     * @param query         分页对象
+     * @param uStandardInfo 查询实体
+     * @return 所有数据
+     */
+    @GetMapping("page")
+    public R<IPage<UStandardInfoDTO>> selectAll(Query query, UStandardInfo uStandardInfo) {
+        IPage<UStandardInfoDTO> page = this.uStandardInfoService.selectMyPage(query, uStandardInfo);
+        return R.data(page);
+    }
+
+    /**
+     * 通过主键查询单条数据
+     *
+     * @param id 主键
+     * @return 单条数据
+     */
+    @GetMapping("/getById")
+    public R<UStandardInfoDTO> selectOne(Long id) {
+        UStandardInfoDTO dto = this.uStandardInfoService.selectOne(id);
+        return R.data(dto);
+    }
+
+    /**
+     * 新增数据
+     *
+     * @param uStandardInfo 实体对象
+     * @return 新增结果
+     */
+    @PostMapping("add")
+    public R<Boolean> insert(@RequestBody @Validated UStandardInfoDTO uStandardInfo) {
+        Boolean b = this.uStandardInfoService.insert(uStandardInfo);
+        return R.data(b);
+    }
+
+    /**
+     * 修改数据
+     *
+     * @param uStandardInfo 实体对象
+     * @return 修改结果
+     */
+    @PostMapping("edit")
+    public R<Boolean> update(@RequestBody @Validated UStandardInfoDTO uStandardInfo) {
+        Boolean b = this.uStandardInfoService.edit(uStandardInfo);
+        return R.data(b);
+    }
+
+    /**
+     * 删除数据
+     *
+     * @param id 主键
+     * @return 删除结果
+     */
+    @GetMapping("/delete")
+    public R<Boolean> delete(Long id) {
+        Boolean b = this.uStandardInfoService.delete(id);
+        return R.data(b);
+    }
+
+
+    /**
+     * 条件设置
+     *
+     * @param standardInfoJoins 条件设置对象
+     * @return 结果
+     */
+    @PostMapping("saveConditionSet")
+    public R<Boolean> setCondition(@RequestBody @Validated List<StandardInfoJoinDTO> standardInfoJoins) {
+        Boolean b = this.uStandardInfoService.setCondition(standardInfoJoins);
+        return R.data(b);
+    }
+
+    /**
+     * 关联元素
+     *
+     * @param standardInfoPrivateJoins 关联元素对象
+     * @return 结果
+     */
+    @PostMapping("saveElementJoin")
+    public R<Boolean> setElementJoin(@RequestBody @Validated List<StandardInfoPrivateJoinDTO> standardInfoPrivateJoins) {
+        Boolean b = this.uStandardInfoService.setElementJoin(standardInfoPrivateJoins);
+        return R.data(b);
+    }
+
+    /**
+     * 删除条件设置
+     * @param leftId 主关联id
+     * @return 删除结果
+     */
+    @GetMapping("deleteConditionSet")
+    public R<Boolean> deleteConditionSet(Long leftId) {
+        Boolean b = this.uStandardInfoService.deleteConditionSet(leftId);
+        return R.data(b);
+    }
+
+    /**
+     * 删除关联元素
+     * @param leftId 主关联id
+     * @return 删除结果
+     */
+    @GetMapping("deleteElementJoin")
+    public R<Boolean> deleteElementJoin(Long leftId) {
+        Boolean b = this.uStandardInfoService.deleteElementJoin(leftId);
+        return R.data(b);
+    }
+
+    /**
+     * 查询条件设置
+     * @param id 规范文件id
+     */
+    @GetMapping("getConditionSet")
+    public R<List<UStandardInfoVO>> getConditionSet(Long id) {
+        List<UStandardInfoVO> list = this.uStandardInfoService.getConditionSet(id);
+        return R.data(list);
+    }
+
+    /**
+     * 查询关联元素
+     * @param id 规范文件id
+     */
+    @GetMapping("getElementJoin")
+    public R<List<UStandardInfoPrivateJoinVO>> getElementJoin(Long id) {
+        List<UStandardInfoPrivateJoinVO> list = this.uStandardInfoService.getElementJoin(id);
+        return R.data(list);
+    }
+
+
+}
+

blade-service/blade-business/src/main/java/org/springblade/business/mapper/PrivateStandardMapper.java

@@ -0,0 +1,20 @@
+package org.springblade.business.mapper;
+
+import org.apache.ibatis.annotations.Param;
+import org.springblade.business.entity.PrivateStandard;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+* @author LHB
+* @description 针对表【u_wbs_private_standard(规范文件夹及规范文件表)】的数据库操作Mapper
+* @createDate 2025-06-10 10:48:37
+* @Entity generator.domain.UWbsPrivateStandard
+*/
+public interface PrivateStandardMapper extends BaseMapper<PrivateStandard> {
+
+    void updateStatus(@Param("parentId") Long parentId);
+}
+
+
+
+

blade-service/blade-business/src/main/java/org/springblade/business/mapper/PrivateStandardMapper.xml

@@ -0,0 +1,36 @@
+<?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="org.springblade.business.mapper.PrivateStandardMapper">
+
+    <resultMap id="BaseResultMap" type="org.springblade.business.entity.PrivateStandard">
+            <id property="id" column="id" />
+            <result property="name" column="name" />
+            <result property="parentId" column="parent_id" />
+            <result property="privateId" column="private_id" />
+            <result property="type" column="type" />
+            <result property="issueDate" column="issue_date" />
+            <result property="actualizeDate" column="actualize_date" />
+            <result property="standardFileUrl" column="standard_file_url" />
+            <result property="isDeleted" column="is_deleted" />
+            <result property="createTime" column="create_time" />
+            <result property="createUser" column="create_user" />
+            <result property="updateTime" column="update_time" />
+            <result property="updateUser" column="update_user" />
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,name,parent_id,private_id,type,issue_date,
+        actualize_date,standard_file_url,is_deleted,create_time,create_user,
+        update_time,update_user
+    </sql>
+    <update id="updateStatus">
+        UPDATE u_wbs_private_standard
+        SET `status` = 2,
+            `name` = concat( NAME, '-已过期' )
+        WHERE
+            parent_id = #{parentId}
+          AND STATUS = 1
+    </update>
+</mapper>

blade-service/blade-business/src/main/java/org/springblade/business/mapper/StandardInfoJoinMapper.java

@@ -0,0 +1,28 @@
+package org.springblade.business.mapper;
+
+import org.apache.ibatis.annotations.Param;
+import org.springblade.business.entity.UStandardInfoJoin;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+* @author LHB
+* @description 针对表【u_standard_info_join(样品信息关联表)】的数据库操作Mapper
+* @createDate 2025-06-11 09:57:39
+* @Entity org.springblade.business.entity.UStandardInfoJoin
+*/
+public interface StandardInfoJoinMapper extends BaseMapper<UStandardInfoJoin> {
+
+    /**
+     * 软删除
+     * @param userId 用户 id
+     * @param isDeleted 删除状态
+     * @param standardId 规范文件id
+     */
+    void updateJoin(@Param("userId") Long userId,
+                    @Param("isDeleted") int isDeleted,
+                    @Param("standardId") Long standardId);
+}
+
+
+
+

blade-service/blade-business/src/main/java/org/springblade/business/mapper/StandardInfoJoinMapper.xml

@@ -0,0 +1,31 @@
+<?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="org.springblade.business.mapper.StandardInfoJoinMapper">
+
+    <resultMap id="BaseResultMap" type="org.springblade.business.entity.UStandardInfoJoin">
+            <id property="id" column="id" />
+            <result property="standardInfoLeftId" column="standard_info_left_id" />
+            <result property="standardInfoRightId" column="standard_info_right_id" />
+            <result property="isDeleted" column="is_deleted" />
+            <result property="createTime" column="create_time" />
+            <result property="createUser" column="create_user" />
+            <result property="updateTime" column="update_time" />
+            <result property="updateUser" column="update_user" />
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,standard_info_left_id,standard_info_right_id,is_deleted,create_time,create_user,
+        update_time,update_user
+    </sql>
+    <update id="updateJoin">
+        UPDATE u_standard_info_join a
+            INNER JOIN u_standard_info b ON a.standard_info_left_id = b.id
+        SET a.is_deleted = #{isDeleted},
+            a.update_user = #{userId}
+        WHERE
+            b.is_deleted = 0
+          AND b.standard_id = #{standardId}
+    </update>
+</mapper>

blade-service/blade-business/src/main/java/org/springblade/business/mapper/StandardInfoMapper.java

@@ -0,0 +1,33 @@
+package org.springblade.business.mapper;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import org.apache.ibatis.annotations.Param;
+import org.springblade.business.dto.UStandardInfoDTO;
+import org.springblade.business.entity.UStandardInfo;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.springblade.business.vo.UStandardInfoPrivateJoinVO;
+import org.springblade.business.vo.UStandardInfoVO;
+
+import java.util.List;
+
+/**
+* @author LHB
+* @description 针对表【u_standard_info(规范参数管理-基础信息)】的数据库操作Mapper
+* @createDate 2025-06-11 09:57:39
+* @Entity org.springblade.business.entity.UStandardInfo
+*/
+public interface StandardInfoMapper extends BaseMapper<UStandardInfo> {
+
+    IPage<UStandardInfoDTO> selectMyPage(Page<UStandardInfoDTO> page, @Param("query") UStandardInfo uStandardInfo);
+
+    UStandardInfoDTO selectMyOne(@Param("id") Long id);
+
+    List<UStandardInfoVO> getConditionSet(@Param("id") Long id);
+
+    List<UStandardInfoPrivateJoinVO> getElementJoin(@Param("id") Long id);
+}
+
+
+
+

blade-service/blade-business/src/main/java/org/springblade/business/mapper/StandardInfoMapper.xml

@@ -0,0 +1,173 @@
+<?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="org.springblade.business.mapper.StandardInfoMapper">
+
+    <resultMap id="BaseResultMap" type="org.springblade.business.entity.UStandardInfo">
+        <id property="id" column="id"/>
+        <result property="name" column="name"/>
+        <result property="parentId" column="parent_id"/>
+        <result property="type" column="type"/>
+        <result property="isDeleted" column="is_deleted"/>
+        <result property="createTime" column="create_time"/>
+        <result property="createUser" column="create_user"/>
+        <result property="updateTime" column="update_time"/>
+        <result property="updateUser" column="update_user"/>
+    </resultMap>
+    <resultMap id="BaseResultPageMap" type="org.springblade.business.dto.UStandardInfoDTO">
+        <id property="id" column="id"/>
+        <result property="name" column="name"/>
+        <result property="parentId" column="parent_id"/>
+        <result property="standardId" column="standard_id"/>
+        <result property="type" column="type"/>
+        <result property="isDeleted" column="is_deleted"/>
+        <result property="createTime" column="create_time"/>
+        <result property="createUser" column="create_user"/>
+        <result property="updateTime" column="update_time"/>
+        <result property="updateUser" column="update_user"/>
+        <collection property="info" ofType="org.springblade.business.entity.UStandardInfo" select="findByParentId" column="{parentId=id}">
+        </collection>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id
+        ,name,parent_id,standard_id,type,is_deleted,create_time,
+        create_user,update_time,update_user
+    </sql>
+    <select id="selectMyPage" resultMap="BaseResultPageMap">
+        SELECT
+            <include refid="Base_Column_List"/>
+        FROM
+            u_standard_info
+        <where>
+            is_deleted = 0
+            <if test="query.type != null">
+                AND type = #{query.type}
+            </if>
+            <choose>
+                <when test="query.parentId != null">
+                    AND parent_id = #{query.parentId}
+                </when>
+                <otherwise>
+                    AND parent_id = 0
+                </otherwise>
+            </choose>
+            <if test="query.standardId != null">
+                AND standard_id =  #{query.standardId}
+            </if>
+        </where>
+    </select>
+    <select id="selectMyOne" resultMap="BaseResultPageMap">
+        SELECT
+            <include refid="Base_Column_List"/>
+        FROM
+            u_standard_info
+        WHERE
+            is_deleted = 0 AND
+            id = #{id}
+    </select>
+    <select id="findByParentId" resultType="org.springblade.business.entity.UStandardInfo">
+        select
+            <include refid="Base_Column_List"/>
+        FROM
+            u_standard_info
+        WHERE
+            is_deleted = 0
+            AND parent_id = #{parentId}
+    </select>
+
+
+
+
+    <!-- ``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````` -->
+
+    <resultMap id="BaseResultConditionSet" type="org.springblade.business.vo.UStandardInfoVO">
+        <id property="id" column="id"/>
+        <result property="name" column="name"/>
+        <result property="parentId" column="parent_id"/>
+        <result property="type" column="type"/>
+        <collection property="standardInfos" ofType="org.springblade.business.entity.UStandardInfo" select="findByJoinLeftId" column="{leftId=id}">
+        </collection>
+    </resultMap>
+    <sql id="Base_Column_Join_List">
+        a.id,
+        a.`name`,
+        a.parent_id,
+        a.standard_id,
+        a.`type`,
+        a.is_deleted,
+        a.create_time,
+        a.create_user,
+        a.update_time,
+        a.update_user
+    </sql>
+
+    <select id="getConditionSet" resultMap="BaseResultConditionSet">
+        select
+            <include refid="Base_Column_Join_List"/>
+        from
+            u_standard_info a
+            INNER JOIN u_standard_info_join b on a.id = b.standard_info_left_id and a.is_deleted = b.is_deleted
+        where
+            a.standard_id = #{id} and a.is_deleted = 0
+        GROUP BY
+            b.standard_info_left_id
+    </select>
+    <select id="findByJoinLeftId" resultType="org.springblade.business.entity.UStandardInfo">
+        SELECT
+            <include refid="Base_Column_Join_List"/>
+        FROM
+            u_standard_info a
+            INNER JOIN u_standard_info_join b ON a.id = b.standard_info_right_id AND a.is_deleted = b.is_deleted
+        WHERE
+            b.standard_info_left_id = #{leftId} and a.is_deleted = 0
+    </select>
+
+    <!-- ``````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````` -->
+
+    <resultMap id="BaseResultElementJoin" type="org.springblade.business.vo.UStandardInfoPrivateJoinVO">
+        <id property="id" column="id"/>
+        <result property="name" column="name"/>
+        <result property="parentId" column="parent_id"/>
+        <result property="type" column="type"/>
+        <collection property="privateJoins" ofType="org.springblade.business.entity.UStandardInfoPrivateJoin" select="findByPrivateJoinLeftId" column="{leftId=id}">
+        </collection>
+    </resultMap>
+
+    <sql id="Base_Private_Column_List">
+        a.id,
+        a.standard_info_id,
+        a.private_id,
+        a.col_key,
+        a.col_name,
+        a.is_deleted,
+        a.create_time,
+        a.create_user,
+        a.update_time,
+        a.update_user
+    </sql>
+    <select id="getElementJoin" resultMap="BaseResultElementJoin">
+        select
+            <include refid="Base_Column_Join_List"/>
+        from
+            u_standard_info a
+            INNER JOIN u_standard_info_private_join b on a.id = b.standard_info_id and a.is_deleted = b.is_deleted
+        where
+            a.standard_id = #{id} and a.is_deleted = 0
+        GROUP BY
+            b.standard_info_id
+    </select>
+
+    <select id="findByPrivateJoinLeftId" resultType="org.springblade.business.entity.UStandardInfoPrivateJoin">
+        SELECT
+            <include refid="Base_Private_Column_List"/>,
+            b.node_name
+        FROM
+            u_standard_info_private_join a
+            INNER JOIN m_wbs_tree_private b ON a.private_id = b.p_key_id AND a.is_deleted = b.is_deleted
+        WHERE
+            a.standard_info_id = #{leftId}
+          AND a.is_deleted = 0
+    </select>
+</mapper>

blade-service/blade-business/src/main/java/org/springblade/business/mapper/StandardInfoPrivateJoinMapper.java

@@ -0,0 +1,28 @@
+package org.springblade.business.mapper;
+
+import org.apache.ibatis.annotations.Param;
+import org.springblade.business.entity.UStandardInfoPrivateJoin;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+* @author LHB
+* @description 针对表【u_standard_info_private_join(样品信息与试验表 关联表)】的数据库操作Mapper
+* @createDate 2025-06-11 09:57:39
+* @Entity org.springblade.business.entity.UStandardInfoPrivateJoin
+*/
+public interface StandardInfoPrivateJoinMapper extends BaseMapper<UStandardInfoPrivateJoin> {
+
+    /**
+     * 软删除
+     * @param userId 用户 id
+     * @param isDeleted 删除状态
+     * @param standardId 规范文件id
+     */
+    void updateJoin(@Param("userId") Long userId,
+                    @Param("isDeleted") int isDeleted,
+                    @Param("standardId") Long standardId);
+}
+
+
+
+

blade-service/blade-business/src/main/java/org/springblade/business/mapper/StandardInfoPrivateJoinMapper.xml

@@ -0,0 +1,33 @@
+<?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="org.springblade.business.mapper.StandardInfoPrivateJoinMapper">
+
+    <resultMap id="BaseResultMap" type="org.springblade.business.entity.UStandardInfoPrivateJoin">
+            <id property="id" column="id" />
+            <result property="standardInfoId" column="standard_info_id" />
+            <result property="privateId" column="private_id" />
+            <result property="colKey" column="col_key" />
+            <result property="colName" column="col_name" />
+            <result property="isDeleted" column="is_deleted" />
+            <result property="createTime" column="create_time" />
+            <result property="createUser" column="create_user" />
+            <result property="updateTime" column="update_time" />
+            <result property="updateUser" column="update_user" />
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,standard_info_id,private_id,col_key,col_name,is_deleted,
+        create_time,create_user,update_time,update_user
+    </sql>
+    <update id="updateJoin">
+        UPDATE u_standard_info_private_join a
+            INNER JOIN u_standard_info b ON a.standard_info_id = b.id
+        SET a.is_deleted = #{isDeleted},
+            a.update_user = #{userId}
+        WHERE
+            b.is_deleted = 0
+          AND b.standard_id = #{standardId}
+    </update>
+</mapper>

blade-service/blade-business/src/main/java/org/springblade/business/service/PrivateStandardService.java

@@ -0,0 +1,16 @@
+package org.springblade.business.service;
+
+import org.springblade.business.entity.PrivateStandard;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+* @author LHB
+* @description 针对表【u_wbs_private_standard(规范文件夹及规范文件表)】的数据库操作Service
+* @createDate 2025-06-10 10:48:37
+*/
+public interface PrivateStandardService extends IService<PrivateStandard> {
+
+    boolean delete(Long id);
+
+    boolean insert(PrivateStandard uWbsPrivateStandard);
+}

blade-service/blade-business/src/main/java/org/springblade/business/service/StandardInfoJoinService.java

@@ -0,0 +1,10 @@
+package org.springblade.business.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.springblade.business.entity.UStandardInfoJoin;
+
+/**
+ * @author LHB
+ */
+public interface StandardInfoJoinService extends IService<UStandardInfoJoin> {
+}

blade-service/blade-business/src/main/java/org/springblade/business/service/StandardInfoPrivateJoinService.java

@@ -0,0 +1,10 @@
+package org.springblade.business.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.springblade.business.entity.UStandardInfoPrivateJoin;
+
+/**
+ * @author LHB
+ */
+public interface StandardInfoPrivateJoinService extends IService<UStandardInfoPrivateJoin> {
+}

blade-service/blade-business/src/main/java/org/springblade/business/service/StandardInfoService.java

@@ -0,0 +1,43 @@
+package org.springblade.business.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.springblade.business.dto.StandardInfoJoinDTO;
+import org.springblade.business.dto.StandardInfoPrivateJoinDTO;
+import org.springblade.business.dto.UStandardInfoDTO;
+import org.springblade.business.entity.UStandardInfo;
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.springblade.business.vo.UStandardInfoPrivateJoinVO;
+import org.springblade.business.vo.UStandardInfoVO;
+import org.springblade.core.mp.support.Query;
+
+import java.util.List;
+
+/**
+* @author LHB
+* @description 针对表【u_standard_info(规范参数管理-基础信息)】的数据库操作Service
+* @createDate 2025-06-11 09:57:39
+*/
+public interface StandardInfoService extends IService<UStandardInfo> {
+
+    IPage<UStandardInfoDTO> selectMyPage(Query query, UStandardInfo uStandardInfo);
+
+    UStandardInfoDTO selectOne(Long id);
+
+    Boolean insert(UStandardInfoDTO uStandardInfo);
+
+    Boolean edit(UStandardInfoDTO uStandardInfo);
+
+    Boolean delete(Long id);
+
+    Boolean setCondition(List<StandardInfoJoinDTO> standardInfoJoins);
+
+    Boolean setElementJoin(List<StandardInfoPrivateJoinDTO> standardInfoPrivateJoins);
+
+    Boolean deleteConditionSet(Long leftId);
+
+    Boolean deleteElementJoin(Long leftId);
+
+    List<UStandardInfoVO> getConditionSet(Long id);
+
+    List<UStandardInfoPrivateJoinVO> getElementJoin(Long id);
+}

blade-service/blade-business/src/main/java/org/springblade/business/service/impl/PrivateStandardServiceImpl.java

@@ -0,0 +1,85 @@
+package org.springblade.business.service.impl;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springblade.business.entity.PrivateStandard;
+import org.springblade.business.entity.UStandardInfo;
+import org.springblade.business.mapper.StandardInfoJoinMapper;
+import org.springblade.business.mapper.StandardInfoMapper;
+import org.springblade.business.mapper.StandardInfoPrivateJoinMapper;
+import org.springblade.business.service.PrivateStandardService;
+import org.springblade.business.mapper.PrivateStandardMapper;
+import org.springblade.core.log.exception.ServiceException;
+import org.springblade.core.secure.BladeUser;
+import org.springblade.core.secure.utils.SecureUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+
+/**
+* @author LHB
+* @description 针对表【u_wbs_private_standard(规范文件夹及规范文件表)】的数据库操作Service实现
+* @createDate 2025-06-10 10:48:37
+*/
+@Service
+public class PrivateStandardServiceImpl extends ServiceImpl<PrivateStandardMapper, PrivateStandard>
+    implements PrivateStandardService {
+    @Resource
+    private StandardInfoMapper standardInfoMapper;
+    @Resource
+    private StandardInfoJoinMapper standardInfoJoinMapper;
+    @Resource
+    private StandardInfoPrivateJoinMapper standardInfoPrivateJoinMapper;
+
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean insert(PrivateStandard uWbsPrivateStandard) {
+        BladeUser user = SecureUtil.getUser();
+        uWbsPrivateStandard.setCreateUser(user.getUserId());
+        if(uWbsPrivateStandard.getType() == 2){
+            //修改之前的规则为过期
+            baseMapper.updateStatus(uWbsPrivateStandard.getParentId());
+        }
+        return baseMapper.insert(uWbsPrivateStandard) > 0;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean delete(Long id) {
+
+        try {
+            //获取当前用户
+            BladeUser user = SecureUtil.getUser();
+            int update = baseMapper.update(null, Wrappers.<PrivateStandard>lambdaUpdate()
+                    .set(PrivateStandard::getIsDeleted, 1)
+                    .set(PrivateStandard::getUpdateUser, user.getUserId())
+                    .eq(PrivateStandard::getId, id)
+                    .or()
+                    .eq(PrivateStandard::getParentId, id)
+            );
+            //TODO 后续还要删除规范详细信息
+
+
+
+            int update1 = standardInfoMapper.update(null, Wrappers.<UStandardInfo>lambdaUpdate()
+                    .set(UStandardInfo::getIsDeleted, 1)
+                    .set(UStandardInfo::getUpdateUser, user.getUserId())
+                    .eq(UStandardInfo::getStandardId, id));
+            //TODO 还要删除关联信息
+            standardInfoJoinMapper.updateJoin(user.getUserId(),1,id);
+            //TODo 还要删除与表单的关联信息
+            standardInfoPrivateJoinMapper.updateJoin(user.getUserId(),1,id);
+            return update > 0;
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new ServiceException("删除失败");
+        }
+    }
+}
+
+
+
+

blade-service/blade-business/src/main/java/org/springblade/business/service/impl/StandardInfoJoinServiceImpl.java

@@ -0,0 +1,14 @@
+package org.springblade.business.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springblade.business.entity.UStandardInfoJoin;
+import org.springblade.business.mapper.StandardInfoJoinMapper;
+import org.springblade.business.service.StandardInfoJoinService;
+import org.springframework.stereotype.Service;
+
+/**
+ * @author LHB
+ */
+@Service
+public class StandardInfoJoinServiceImpl extends ServiceImpl<StandardInfoJoinMapper,UStandardInfoJoin> implements StandardInfoJoinService {
+}

blade-service/blade-business/src/main/java/org/springblade/business/service/impl/UStandardInfoPrivateJoinServiceImpl.java

@@ -0,0 +1,14 @@
+package org.springblade.business.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springblade.business.entity.UStandardInfoPrivateJoin;
+import org.springblade.business.mapper.StandardInfoPrivateJoinMapper;
+import org.springblade.business.service.StandardInfoPrivateJoinService;
+import org.springframework.stereotype.Service;
+
+/**
+ * @author LHB
+ */
+@Service
+public class UStandardInfoPrivateJoinServiceImpl extends ServiceImpl<StandardInfoPrivateJoinMapper, UStandardInfoPrivateJoin> implements StandardInfoPrivateJoinService {
+}

blade-service/blade-business/src/main/java/org/springblade/business/service/impl/UStandardInfoServiceImpl.java

@@ -0,0 +1,255 @@
+package org.springblade.business.service.impl;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springblade.business.dto.StandardInfoJoinDTO;
+import org.springblade.business.dto.StandardInfoPrivateJoinDTO;
+import org.springblade.business.dto.UStandardInfoDTO;
+import org.springblade.business.entity.UStandardInfo;
+import org.springblade.business.entity.UStandardInfoJoin;
+import org.springblade.business.entity.UStandardInfoPrivateJoin;
+import org.springblade.business.mapper.StandardInfoMapper;
+import org.springblade.business.service.StandardInfoJoinService;
+import org.springblade.business.service.StandardInfoPrivateJoinService;
+import org.springblade.business.service.StandardInfoService;
+import org.springblade.business.vo.UStandardInfoPrivateJoinVO;
+import org.springblade.business.vo.UStandardInfoVO;
+import org.springblade.common.utils.SnowFlakeUtil;
+import org.springblade.core.log.exception.ServiceException;
+import org.springblade.core.mp.support.Query;
+import org.springblade.core.secure.BladeUser;
+import org.springblade.core.secure.utils.SecureUtil;
+import org.springblade.core.tool.utils.BeanUtil;
+import org.springframework.beans.BeansException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author LHB
+ * @description 针对表【u_standard_info(规范参数管理-基础信息)】的数据库操作Service实现
+ * @createDate 2025-06-11 09:57:39
+ */
+@Service
+public class UStandardInfoServiceImpl extends ServiceImpl<StandardInfoMapper, UStandardInfo>
+        implements StandardInfoService {
+
+    /**
+     * 关联表
+     */
+    @Resource
+    private StandardInfoJoinService standardInfoJoinService;
+
+    /**
+     * 与表单的关联关系
+     */
+    @Resource
+    private StandardInfoPrivateJoinService standardInfoPrivateJoinService;
+
+
+    @Override
+    public IPage<UStandardInfoDTO> selectMyPage(Query query, UStandardInfo uStandardInfo) {
+        return baseMapper.selectMyPage(new Page<UStandardInfoDTO>(query.getCurrent(), query.getSize()), uStandardInfo);
+    }
+
+    @Override
+    public UStandardInfoDTO selectOne(Long id) {
+        return baseMapper.selectMyOne(id);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Boolean insert(UStandardInfoDTO uStandardInfo) {
+        try {
+            //获取当前用户
+            BladeUser user = SecureUtil.getUser();
+            uStandardInfo.setId(SnowFlakeUtil.getId());
+            uStandardInfo.setCreateUser(user.getUserId());
+
+            List<UStandardInfo> info = uStandardInfo.getInfo();
+
+            //给集合设置id、父级id、创建人
+            info.forEach(item -> {
+                item.setId(SnowFlakeUtil.getId());
+                item.setParentId(uStandardInfo.getId());
+                item.setStandardId(uStandardInfo.getStandardId());
+                item.setCreateUser(user.getUserId());
+            });
+
+            //把父级对象转出来单独保存
+            UStandardInfo parent = BeanUtil.copyProperties(uStandardInfo, UStandardInfo.class);
+            baseMapper.insert(parent);
+            //通过mybatis-plus 批量新增
+            this.saveBatch(info);
+
+            return true;
+        } catch (BeansException e) {
+            e.printStackTrace();
+            throw new ServiceException("添加失败");
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Boolean edit(UStandardInfoDTO uStandardInfo) {
+        try {
+            //获取当前用户
+            BladeUser user = SecureUtil.getUser();
+            uStandardInfo.setUpdateUser(user.getUserId());
+
+            List<UStandardInfo> info = uStandardInfo.getInfo();
+            info.forEach(item -> {
+                if (item.getId() == null) {
+                    //新增的子集合设置id、父级id、创建人
+                    item.setId(SnowFlakeUtil.getId());
+                    item.setParentId(uStandardInfo.getId());
+                    item.setStandardId(uStandardInfo.getStandardId());
+                    item.setCreateUser(user.getUserId());
+                } else {
+                    //更新的子集合 添加更新人
+                    item.setUpdateUser(user.getUserId());
+                }
+            });
+            //更新父级对象
+            UStandardInfo parent = BeanUtil.copyProperties(uStandardInfo, UStandardInfo.class);
+            baseMapper.updateById(parent);
+            //批量更新
+            this.saveOrUpdateBatch(info);
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new ServiceException("更新失败");
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Boolean delete(Long id) {
+        try {
+            //查询关联表 如果有关联关系不允许删除
+            long joinCount = standardInfoJoinService.count(Wrappers.<UStandardInfoJoin>lambdaQuery()
+                    .eq(UStandardInfoJoin::getStandardInfoRightId, id)
+                    .or()
+                    .eq(UStandardInfoJoin::getStandardInfoLeftId, id));
+            if (joinCount > 0) {
+                throw new ServiceException("当前数据正在【条件设置】中使用，无法删除");
+            }
+            //查询与表单的关联表
+            long privateJoinCount = standardInfoPrivateJoinService.count(Wrappers.<UStandardInfoPrivateJoin>lambdaQuery()
+                    .eq(UStandardInfoPrivateJoin::getStandardInfoId, id));
+            if (privateJoinCount > 0) {
+                throw new ServiceException("当前数据正在【关联元素】中使用，无法删除");
+            }
+
+            int update = baseMapper.update(null, Wrappers.<UStandardInfo>lambdaUpdate()
+                    .set(UStandardInfo::getIsDeleted, 1)
+                    .eq(UStandardInfo::getId, id)
+                    .or()
+                    .eq(UStandardInfo::getParentId, id));
+            return update > 0;
+        } catch (ServiceException e) {
+            e.printStackTrace();
+            throw new ServiceException("删除失败");
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Boolean setCondition(List<StandardInfoJoinDTO> standardInfoJoins) {
+        BladeUser user = SecureUtil.getUser();
+        List<UStandardInfoJoin> saveData = new ArrayList<>();
+        try {
+            for (StandardInfoJoinDTO standardInfoJoin : standardInfoJoins) {
+                Long leftId = standardInfoJoin.getLeftId();
+                List<Long> rightIds = standardInfoJoin.getRightIds();
+                for (Long rightId : rightIds) {
+                    UStandardInfoJoin uStandardInfoJoin = new UStandardInfoJoin();
+                    uStandardInfoJoin.setId(SnowFlakeUtil.getId());
+                    uStandardInfoJoin.setStandardInfoLeftId(leftId);
+                    uStandardInfoJoin.setStandardInfoRightId(rightId);
+                    uStandardInfoJoin.setCreateUser(user.getUserId());
+                    saveData.add(uStandardInfoJoin);
+                }
+            }
+            return standardInfoJoinService.saveBatch(saveData);
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new ServiceException("条件设置失败");
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Boolean setElementJoin(List<StandardInfoPrivateJoinDTO> standardInfoPrivateJoins) {
+        BladeUser user = SecureUtil.getUser();
+        List<UStandardInfoPrivateJoin> saveData = new ArrayList<>();
+
+        try {
+            for (StandardInfoPrivateJoinDTO standardInfoPrivateJoin : standardInfoPrivateJoins) {
+                Long leftId = standardInfoPrivateJoin.getLeftId();
+                List<UStandardInfoPrivateJoin> rightIds = standardInfoPrivateJoin.getRightIds();
+                rightIds.forEach(f -> {
+                    f.setId(SnowFlakeUtil.getId());
+                    f.setStandardInfoId(leftId);
+                    f.setUpdateUser(user.getUserId());
+                });
+                saveData.addAll(rightIds);
+            }
+            return standardInfoPrivateJoinService.saveBatch(saveData);
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new ServiceException("元素关联失败");
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Boolean deleteConditionSet(Long leftId) {
+        BladeUser user = SecureUtil.getUser();
+        try {
+            return standardInfoJoinService.update(Wrappers.<UStandardInfoJoin>lambdaUpdate()
+                    .set(UStandardInfoJoin::getIsDeleted, 1)
+                    .set(UStandardInfoJoin::getUpdateUser, user.getUserId())
+                    .eq(UStandardInfoJoin::getStandardInfoLeftId, leftId));
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new ServiceException("删除失败");
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Boolean deleteElementJoin(Long leftId) {
+        BladeUser user = SecureUtil.getUser();
+        try {
+            return standardInfoPrivateJoinService.update(Wrappers.<UStandardInfoPrivateJoin>lambdaUpdate()
+                    .set(UStandardInfoPrivateJoin::getIsDeleted, 1)
+                    .set(UStandardInfoPrivateJoin::getUpdateUser, user.getUserId())
+                    .eq(UStandardInfoPrivateJoin::getStandardInfoId, leftId));
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new ServiceException("删除失败");
+        }
+    }
+
+    @Override
+    public List<UStandardInfoVO> getConditionSet(Long id) {
+        return baseMapper.getConditionSet(id);
+    }
+
+    @Override
+    public List<UStandardInfoPrivateJoinVO> getElementJoin(Long id) {
+        return baseMapper.getElementJoin(id);
+
+    }
+}
+
+
+
+

blade-service/blade-manager/src/main/java/org/springblade/manager/mapper/WbsTreeContractMapper.java

@@ -146,4 +146,7 @@ public interface WbsTreeContractMapper extends EasyBaseMapper<WbsTreeContract> {
     void updateSortNotIsUseSort(@Param("type") int type,
                                 @Param("projectId") Long projectId,
                                 @Param("pKeyId") Long pKeyId);
+
+    void updateSortByPId(@Param("pId") Long pId,
+                         @Param("sort") Integer sort);
 }

blade-service/blade-manager/src/main/java/org/springblade/manager/mapper/WbsTreeContractMapper.xml

@@ -816,6 +816,13 @@
             a.project_id = #{projectId}
           AND a.is_deleted = 0
     </update>
+    <update id="updateSortByPId">
+        update
+            m_wbs_tree_contract
+        set
+            sort = sort +1
+        where p_id = #{pId} and sort >= #{sort}
+    </update>
 
     <select id="selectQueryValueLikeNodeName" resultMap="ResultMap">
         select *

blade-service/blade-manager/src/main/java/org/springblade/manager/mapper/WbsTreePrivateMapper.java

@@ -144,4 +144,6 @@ public interface WbsTreePrivateMapper extends EasyBaseMapper<WbsTreePrivate> {
      */
     void updateBatchAncestorsByPKeyId(@Param("allNodes") List<WbsTreePrivate> allNodes);
 
+    void updateSortByPId(@Param("pId") Long pId,
+                         @Param("sort") Integer sort);
 }

blade-service/blade-manager/src/main/java/org/springblade/manager/mapper/WbsTreePrivateMapper.xml

@@ -929,6 +929,11 @@
             where p_key_id = #{item.pKeyId}
         </foreach>
     </update>
+    <update id="updateSortByPId">
+        update m_wbs_tree_private
+        set sort = sort + 1
+        where p_id = #{pId} and sort >= #{sort}
+    </update>
 
     <select id="linkNodeTreeBynodeId" resultType="java.lang.Long" >
         select p_key_id from m_wbs_tree_private where `type` = 1 and is_deleted = 0

blade-service/blade-manager/src/main/java/org/springblade/manager/service/impl/TextdictInfoServiceImpl.java

@@ -49,6 +49,7 @@ import java.io.FileNotFoundException;
 import java.io.InputStream;
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.*;
 
 /**
  * 参数信息表 服务实现类

blade-service/blade-manager/src/main/java/org/springblade/manager/service/impl/WbsSynchronousServiceImpl.java

@@ -311,8 +311,8 @@ public class WbsSynchronousServiceImpl {
                 List<WbsTreePrivate> editPrivateNodes = new ArrayList<>();
                 for (WbsTreePrivate templateNode : templateNodes) {
                     //数据修复-----------------------------------------------------------------------------------------------------------------------------------开始
-                    if (!isPublic && templateNode.getType() == 2 && collect.contains(2) ) {
-                        if(CollectionUtil.isNotEmpty(formList) && !formList.contains(templateNode.getPKeyId())){
+                    if (!isPublic && templateNode.getType() == 2 && collect.contains(2)) {
+                        if (CollectionUtil.isNotEmpty(formList) && !formList.contains(templateNode.getPKeyId())) {
                             continue;
                         }
                         boolean isUpdate = false;
@@ -402,6 +402,8 @@ public class WbsSynchronousServiceImpl {
                             if (collect.contains(2)) {
                                 //绑定清表
                                 editPrivateNode.setExcelId(templateNode.getExcelId());
+                                editPrivateNode.setNodeName(templateNode.getNodeName());
+                                editPrivateNode.setFullName(templateNode.getFullName());
                                 //绑定实体表
                                 editPrivateNode.setInitTableName(templateNode.getInitTableName());
 
@@ -510,8 +512,17 @@ public class WbsSynchronousServiceImpl {
         Integer nodeNumEnd = 0;
         for (Long pId : pIds) {
             nodeNumEnd++;
+            List<WbsTreePrivate> list = collect1.get(pId);
+            //排序调整
+            if (wbsTreeSynchronousRecord.getType().contains("7")) {
+                list.sort(Comparator.comparingInt(WbsTreePrivate::getSort));
+                for (WbsTreePrivate wbsTreePrivate : list) {
+                    wbsTreePrivateMapper.updateSortByPId(pId, wbsTreePrivate.getSort());
+                }
+            }
+
             //更新最新节点
-            wbsSynchronousEViSaService.updatePrivate(wbsTreeSynchronousRecord.getCreateUserId(), collect1.get(pId));
+            wbsSynchronousEViSaService.updatePrivate(wbsTreeSynchronousRecord.getCreateUserId(), list);
 
             synchronousRecordMapper.update(null, Wrappers.<WbsTreeSynchronousRecord>lambdaUpdate()
                     .set(WbsTreeSynchronousRecord::getNodeNumEnd, nodeNumEnd)
@@ -786,7 +797,16 @@ public class WbsSynchronousServiceImpl {
 
         for (Long pId : pIds) {
             nodeNumEnd++;
-            wbsSynchronousEViSaService.updateContract(wbsTreeSynchronousRecord.getCreateUserId(), collect1.get(pId));
+            List<WbsTreeContract> list = collect1.get(pId);
+            //排序调整
+            if (wbsTreeSynchronousRecord.getType().contains("7")) {
+                list.sort(Comparator.comparingInt(WbsTreeContract::getSort));
+                for (WbsTreeContract wbsTreeContract : list) {
+                    wbsTreePrivateMapper.updateSortByPId(pId, wbsTreeContract.getSort());
+                }
+            }
+
+            wbsSynchronousEViSaService.updateContract(wbsTreeSynchronousRecord.getCreateUserId(), list);
             synchronousRecordMapper.update(null, Wrappers.<WbsTreeSynchronousRecord>lambdaUpdate()
                     .set(WbsTreeSynchronousRecord::getNodeNumEnd, nodeNumEnd)
                     .set(WbsTreeSynchronousRecord::getUpdateTime, DateTime.now())
@@ -837,6 +857,7 @@ public class WbsSynchronousServiceImpl {
                 WbsTreePrivate parent = addPrivateParentNodes.get(0);
 
                 addPrivateNode.setPId(parent.getPKeyId());
+                addPrivateNode.setAncestorsPId(parent.getAncestorsPId() + "," + addPrivateNode.getPId());
                 addPrivateNode.setWbsId(parent.getWbsId());
                 addPrivateNode.setWbsType(parent.getWbsType());
                 addPrivateNode.setIsAddConceal(0);
@@ -887,34 +908,53 @@ public class WbsSynchronousServiceImpl {
             }
 
             //查询出当前项目所有节点---------------------------------------------------------------------------------------------------
-            List<WbsTreePrivate> addList = wbsTreePrivateMapper.selectList(Wrappers.<WbsTreePrivate>lambdaQuery()
-                    .select(WbsTreePrivate::getPKeyId, WbsTreePrivate::getPId)
-                    .eq(WbsTreePrivate::getIsDeleted, 0)
-                    .eq(WbsTreePrivate::getProjectId, addData.get(0).getProjectId()));
-
-            addList.addAll(addData);
-            //组合祖级路径 根据当前选中节点为开始
-            Map<Long, WbsTreePrivate> collect = addList.stream().collect(Collectors.toMap(WbsTreePrivate::getPKeyId, Function.identity()));
-
-            addData.forEach(node -> {
-                String correctAncestors = createAncestorsPId(node, collect);
-                node.setAncestorsPId(correctAncestors);
-            });
+//            List<WbsTreePrivate> addList = wbsTreePrivateMapper.selectList(Wrappers.<WbsTreePrivate>lambdaQuery()
+//                    .select(WbsTreePrivate::getPKeyId, WbsTreePrivate::getPId)
+//                    .eq(WbsTreePrivate::getIsDeleted, 0)
+//                    .eq(WbsTreePrivate::getProjectId, addData.get(0).getProjectId()));
+//
+//            addList.addAll(addData);
+//            //组合祖级路径 根据当前选中节点为开始
+//            Map<Long, WbsTreePrivate> collect = addList.stream().collect(Collectors.toMap(WbsTreePrivate::getPKeyId, Function.identity()));
+//
+//            addData.forEach(node -> {
+//                String correctAncestors = createAncestorsPId(node, collect);
+//                node.setAncestorsPId(correctAncestors);
+//            });
 
             //新增-----------------------------------------------------------------------------------------------------------------
-            List<List<WbsTreePrivate>> partition = Lists.partition(addData, 1000);
-            Integer count = 0;
-            for (List<WbsTreePrivate> data : partition) {
+            Map<Long, List<WbsTreePrivate>> collect = addData.stream().collect(Collectors.groupingBy(WbsTreePrivate::getPId));
+            Set<Long> longs = collect.keySet();
+
+            List<Long> pIds = new ArrayList<>(longs);
+            List<WbsTreePrivate> saveData = new ArrayList<>();
+            //按最小节点批量新增
+            List<List<Long>> partition = Lists.partition(pIds, 100);
+
+            for (List<Long> data : partition) {
+                for (Long datum : data) {
+                    List<WbsTreePrivate> list = collect.get(datum);
+                    //修改排序
+                    if (wbsTreeSynchronousRecord.getType().contains("7")) {
+                        list.sort(Comparator.comparingInt(WbsTreePrivate::getSort));
+                        for (WbsTreePrivate wbsTreePrivate : list) {
+                            Integer sort = wbsTreePrivate.getSort();
+                            if (sort != null) {
+                                wbsTreePrivateMapper.updateSortByPId(datum, wbsTreePrivate.getSort());
+                            }
+                        }
+                    }
+                    boolean b = saveData.addAll(list);
+                }
+
                 //单个批次一个事务，只会回滚当前批次数据
-                Integer i = wbsTreePrivateMapper.insertBatchSomeColumn(data);
+                Integer i = wbsTreePrivateMapper.insertBatchSomeColumn(saveData);
                 //如果失败  -- - - - - 继续执行   或者把当前节点的p_key_id 记录到某个地方 方便后续处理
                 if (i == 0) {
                     List<Long> collect1 = addData.stream().map(WbsTreePrivate::getPKeyId).collect(Collectors.toList());
                     //这里可以保存到数据库指定错误日志表
-                    throw new ServiceException("重置表单路径错误:" + StringUtil.join(collect1, ","));
+                    throw new ServiceException("添加失败:" + StringUtil.join(collect1, ","));
                 }
-
-                count += i;
             }
         }
     }
@@ -970,7 +1010,7 @@ public class WbsSynchronousServiceImpl {
                 //TODO
                 addContractNode.setPId(parent.getPKeyId());
                 //TODO
-                addContractNode.setContractId(parent.getContractId());
+                addContractNode.setAncestorsPId(parent.getAncestorsPId() + "," + addContractNode.getPId());
                 addContractNode.setContractId(String.valueOf(contractInfo.getId()));
                 //更新创建时间
                 addContractNode.setCreateTime(DateTime.now());
@@ -981,32 +1021,55 @@ public class WbsSynchronousServiceImpl {
 
 
         //查询出当前项目所有节点---------------------------------------------------------------------------------------------------
-        List<WbsTreeContract> addList = wbsTreeContractMapper.selectList(Wrappers.<WbsTreeContract>lambdaQuery()
-                .select(WbsTreeContract::getPKeyId, WbsTreeContract::getPId)
-                .eq(WbsTreeContract::getIsDeleted, 0)
-                .eq(WbsTreeContract::getContractId, contractInfo.getId()));
-
-        addList.addAll(addData);
-
-
-        //组合祖级路径 根据当前选中节点为开始
-        Map<Long, WbsTreeContract> collect = addList.stream().collect(Collectors.toMap(WbsTreeContract::getPKeyId, Function.identity()));
-
-        addData.forEach(node -> {
-            //通过转换为WbsTreePrivate的方式 去获取祖级节点
-            String correctAncestors = createAncestorsPId(node, collect);
-            node.setAncestorsPId(correctAncestors);
-        });
+//        List<WbsTreeContract> addList = wbsTreeContractMapper.selectList(Wrappers.<WbsTreeContract>lambdaQuery()
+//                .select(WbsTreeContract::getPKeyId, WbsTreeContract::getPId)
+//                .eq(WbsTreeContract::getIsDeleted, 0)
+//                .eq(WbsTreeContract::getContractId, contractInfo.getId()));
+//
+//        addList.addAll(addData);
+//
+//
+//        //组合祖级路径 根据当前选中节点为开始
+//        Map<Long, WbsTreeContract> collect = addList.stream().collect(Collectors.toMap(WbsTreeContract::getPKeyId, Function.identity()));
+//
+//        addData.forEach(node -> {
+//            //通过转换为WbsTreePrivate的方式 去获取祖级节点
+//            String correctAncestors = createAncestorsPId(node, collect);
+//            node.setAncestorsPId(correctAncestors);
+//        });
 
         //新增-----------------------------------------------------------------------------------------------------------------
-        List<List<WbsTreeContract>> partition = Lists.partition(addData, 1000);
-        for (List<WbsTreeContract> data : partition) {
+        Map<Long, List<WbsTreeContract>> collect = addData.stream().collect(Collectors.groupingBy(WbsTreeContract::getPId));
+        Set<Long> longs = collect.keySet();
+
+        List<Long> pIds = new ArrayList<>(longs);
+        List<WbsTreeContract> saveData = new ArrayList<>();
+        //按最小节点批量新增
+        List<List<Long>> partition = Lists.partition(pIds, 100);
+        for (List<Long> data : partition) {
+            for (Long datum : data) {
+                List<WbsTreeContract> list = collect.get(datum);
+                //修改排序
+                if (wbsTreeSynchronousRecord.getType().contains("7")) {
+                    list.sort(Comparator.comparingInt(WbsTreeContract::getSort));
+                    for (WbsTreeContract wbsTreeContract : list) {
+                        Integer sort = wbsTreeContract.getSort();
+                        if (sort != null) {
+                            wbsTreeContractMapper.updateSortByPId(datum, wbsTreeContract.getSort());
+                        }
+                    }
+                }
+                boolean b = saveData.addAll(list);
+            }
+
             //单个批次一个事务，只会回滚当前批次数据
-            Integer i = wbsTreeContractMapper.insertBatchSomeColumn(data);
+            Integer i = wbsTreeContractMapper.insertBatchSomeColumn(saveData);
             //如果失败  -- - - - - 继续执行   或者把当前节点的p_key_id 记录到某个地方 方便后续处理
             if (i == 0) {
                 List<Long> collect1 = addData.stream().map(WbsTreeContract::getPKeyId).collect(Collectors.toList());
                 //这里可以保存到数据库指定错误日志表
+                //这里可以保存到数据库指定错误日志表
+                throw new ServiceException("添加失败:" + StringUtil.join(collect1, ","));
             }
         }
     }