Merge remote-tracking branch 'origin/dev' into dev

PAS/src/main/java/cn/cslg/pas/common/config/WebSocketConfig.java

@@ -6,7 +6,7 @@ import org.springframework.web.socket.server.standard.ServerEndpointExporter;
 
 @Configuration
 public class WebSocketConfig {
-    @Bean
+    //@Bean
     public ServerEndpointExporter serverEndpointExporter() {
         return new ServerEndpointExporter();
     }

PAS/src/main/java/cn/cslg/pas/common/model/dto/StructureAddNewDTO.java

@@ -20,7 +20,7 @@ public class StructureAddNewDTO implements Serializable {
      */
     private String structureName;
     /**
-     * 路径
+     * 父级路径
      */
     private String parentPath;
     /**

PAS/src/main/java/cn/cslg/pas/common/model/dto/StructurePictureUpdateDTO.java

@@ -0,0 +1,38 @@
+package cn.cslg.pas.common.model.dto;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+/**
+ * 架构的修改图片DTO类
+ *
+ * @Author chenyu
+ * @Date 2023/3/13
+ */
+@Accessors(chain = true)
+@Data
+public class StructurePictureUpdateDTO implements Serializable {
+    /**
+     * ID
+     */
+    private Integer id;
+    /**
+     * 架构id
+     */
+    private Integer structureId;
+    /**
+     * 图片名称
+     */
+    private String name;
+    /**
+     * 后缀类型
+     */
+    private String suffix;
+    /**
+     * 路径
+     */
+    private String url;
+
+}

PAS/src/main/java/cn/cslg/pas/common/model/dto/StructureUpdateDTO.java

@@ -1,15 +1,13 @@
 package cn.cslg.pas.common.model.dto;
 
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.experimental.Accessors;
 
 import java.io.Serializable;
+import java.util.List;
 
 /**
- * 元素表实体类
+ * 架构的修改架构DTO类
  */
 @Accessors(chain = true)
 @Data
@@ -27,9 +25,9 @@ public class StructureUpdateDTO implements Serializable {
      */
     private String structureName;
     /**
-     * 路径
+     * 父级路径
      */
-    private String path;
+    private String parentPath;
     /**
      * 说明
      */
@@ -38,5 +36,9 @@ public class StructureUpdateDTO implements Serializable {
      * 产品id
      */
     private Integer productId;
+    /**
+     * 图片
+     */
+    private List<StructurePictureUpdateDTO> pictures;
 
 }

PAS/src/main/java/cn/cslg/pas/common/model/vo/PathStructureNameVO.java

@@ -0,0 +1,26 @@
+package cn.cslg.pas.common.model.vo;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+
+/**
+ * 架构路径和路径架构名称
+ *
+ * @Author chenyu
+ * @Date 2023/3/13
+ */
+@Accessors(chain = true)
+@Data
+public class PathStructureNameVO implements Serializable {
+    /**
+     * 路径
+     */
+    private String path;
+    /**
+     * 路径对应的完整架构名称
+     */
+    private String pathStructureName;
+
+}

PAS/src/main/java/cn/cslg/pas/common/model/vo/StructureVO.java

@@ -7,7 +7,7 @@ import java.io.Serializable;
 import java.util.List;
 
 /**
- * 元素表实体类
+ * 架构表标准查询VO类
  */
 @Accessors(chain = true)
 @Data

PAS/src/main/java/cn/cslg/pas/controller/StructureController.java

@@ -3,6 +3,8 @@ package cn.cslg.pas.controller;
 import cn.cslg.pas.common.core.base.Constants;
 import cn.cslg.pas.common.model.dto.StructureAddNewDTO;
 import cn.cslg.pas.common.model.dto.StructureQueryPageDTO;
+import cn.cslg.pas.common.model.dto.StructureUpdateDTO;
+import cn.cslg.pas.common.model.vo.PathStructureNameVO;
 import cn.cslg.pas.common.model.vo.StructureVO;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.exception.XiaoShiException;
@@ -12,10 +14,7 @@ import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.util.List;
@@ -50,12 +49,48 @@ public class StructureController {
         return Response.error("请求参数为null");
     }
 
-    @Operation(summary = "分页查询架构树")
+    @Operation(summary = "修改架构")
+    @PostMapping("/update")
+    public String update(String jsons, List<MultipartFile> files) {
+        if (jsons != null) {
+            StructureUpdateDTO structureUpdateDTO = JSONObject.parseObject(jsons, StructureUpdateDTO.class);
+            log.info("开始处理【修改架构】的请求，请求参数为：{}, {}", structureUpdateDTO, files);
+            try {
+                structureService.update(structureUpdateDTO, files);
+            } catch (XiaoShiException e) {
+                return Response.error(e.getMessage());
+            }
+            return Response.success("修改架构完成");
+        }
+        return Response.error("请求参数为null");
+    }
+
+    @Operation(summary = "查询架构树")
     @PostMapping("/query")
-    public String query(@RequestBody StructureQueryPageDTO structureQueryPageDTO) {
-        log.info("开始处理【分页查询架构】的请求，请求参数为：{}", structureQueryPageDTO);
+    public Response query(@RequestBody StructureQueryPageDTO structureQueryPageDTO) {
+        log.info("开始处理【查询架构树】的请求，请求参数为：{}", structureQueryPageDTO);
         StructureVO queryResult = structureService.query(structureQueryPageDTO);
-        return Response.success(queryResult);
+        return Response.success2(queryResult);
+    }
+
+    @Operation(summary = "查询拼接路径名")
+    @GetMapping("/queryPathStructureName")
+    public String queryPathStructureName(Integer productId) {
+        log.info("开始处理【查询所有架构路径和路径架构名称】的业务，参数为：{}", productId);
+        List<PathStructureNameVO> queryResults = structureService.queryPathStructureName(productId);
+        return Response.success(queryResults);
+    }
+
+    @Operation(summary = "删除架构")
+    @GetMapping("/delete")
+    public String delete(Integer id) {
+        log.info("开始处理【删除架构】的请求，请求参数为：{}", id);
+        try {
+            structureService.delete(id);
+        } catch (XiaoShiException e) {
+            return Response.error(e.getMessage());
+        }
+        return Response.success("删除架构完成");
     }
 
 }

PAS/src/main/java/cn/cslg/pas/mapper/AssoStructurePatentMapper.java

@@ -0,0 +1,23 @@
+package cn.cslg.pas.mapper;
+
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * 架构和专利关联表的Mapper层接口
+ *
+ * @Author chenyu
+ * @Date 2023/3/13
+ */
+@Repository
+public interface AssoStructurePatentMapper {
+    /**
+     * 根据架构id批量删除数据
+     *
+     * @param structureIds 架构ids
+     * @return 返回受影响的行数
+     */
+    int deleteByStructureIds(List<Integer> structureIds);
+
+}

PAS/src/main/java/cn/cslg/pas/mapper/AssoStructurePictureMapper.java

@@ -1,5 +1,6 @@
 package cn.cslg.pas.mapper;
 
+import cn.cslg.pas.common.model.vo.StructurePictureVO;
 import cn.cslg.pas.domain.asso.AssoStructurePicture;
 import org.springframework.stereotype.Repository;
 
@@ -21,4 +22,28 @@ public interface AssoStructurePictureMapper {
      */
     int insertBatch(List<AssoStructurePicture> assoStructurePictures);
 
+    /**
+     * 根据id批量删除数据
+     *
+     * @param ids ids
+     * @return 返回受影响的行数
+     */
+    int deleteByIds(List<Integer> ids);
+
+    /**
+     * 根据架构ids批量删除数据
+     *
+     * @param structures 架构ids
+     * @return 返回受影响的行数
+     */
+    int deleteByStructureIds(List<Integer> structures);
+
+    /**
+     * 根据架构id查询数据
+     *
+     * @param structureId 架构id
+     * @return 返回查询到的数据
+     */
+    List<StructurePictureVO> selectByStructureId(Integer structureId);
+
 }

PAS/src/main/java/cn/cslg/pas/mapper/StructureMapper.java

@@ -2,6 +2,7 @@ package cn.cslg.pas.mapper;
 
 import cn.cslg.pas.common.model.vo.StructureVO;
 import cn.cslg.pas.domain.Structure;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
@@ -13,7 +14,7 @@ import java.util.List;
  * @Date 2023/3/10
  */
 @Repository
-public interface StructureMapper {
+public interface StructureMapper extends BaseMapper<Structure> {
     /**
      * 插入数据
      *
@@ -31,6 +32,14 @@ public interface StructureMapper {
     int deleteById(Integer id);
 
     /**
+     * 根据id批量删除数据
+     *
+     * @param ids 架构ids
+     * @return 返回受影响的行数
+     */
+    int deleteByIds(List<Integer> ids);
+
+    /**
      * 根据id修改数据
      *
      * @param structure 数据对象
@@ -39,13 +48,14 @@ public interface StructureMapper {
     int update(Structure structure);
 
     /**
-     * 根据父级id和名称统计数量
+     * 根据父级id和名称和架构id统计数量
      *
      * @param parentId      父级id
      * @param structureName 架构名称
+     * @param structureId   架构id
      * @return 返回统计到的数量
      */
-    int countByparentIdAndStructureName(Integer parentId, String structureName);
+    int countByparentIdAndStructureName(Integer parentId, String structureName, Integer structureId);
 
     /**
      * 根据id查询数据
@@ -56,18 +66,40 @@ public interface StructureMapper {
     Structure getStandardById(Integer id);
 
     /**
-     * 根据父级id查询数据
+     * 根据父级id和产品id查询数据
+     *
+     * @param parentId  父级id
+     * @param productId 产品id
+     * @return 返回查询到的数据
+     */
+    List<StructureVO> selectByParentIdAndProductId(Integer parentId, Integer productId,List<Integer> ids);
+
+    /**
+     * 根据模糊路径查询数据
      *
-     * @param parentId 父级id
+     * @param findInSetPath 模糊路径
      * @return 返回查询到的数据
      */
-    List<StructureVO> selectByParentId(Integer parentId);
+    List<StructureVO> selectByFindInSetPath(String findInSetPath);
+
+    /**/
+    /**/
+    List<StructureVO> selectByName(String name);
 
     /**
      * 根据产品id查询数据
+     *
      * @param productId 产品id
      * @return 返回查询到的数据
      */
-    List<StructureVO> selectByProductId(Integer productId);
+    List<StructureVO> selectAllByProductId(Integer productId);
+
+    /**
+     * 根据产品名称模糊查询数据
+     *
+     * @param structureName
+     * @return 返回查询到的数据
+     */
+    //List<Structure> getStandardByStructureName(String structureName);
 
 }

PAS/src/main/java/cn/cslg/pas/service/IStructureService.java

@@ -3,6 +3,7 @@ package cn.cslg.pas.service;
 import cn.cslg.pas.common.model.dto.StructureAddNewDTO;
 import cn.cslg.pas.common.model.dto.StructureQueryPageDTO;
 import cn.cslg.pas.common.model.dto.StructureUpdateDTO;
+import cn.cslg.pas.common.model.vo.PathStructureNameVO;
 import cn.cslg.pas.common.model.vo.StructureVO;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.multipart.MultipartFile;
@@ -44,4 +45,19 @@ public interface IStructureService {
      */
     StructureVO query(StructureQueryPageDTO structureQueryPageDTO);
 
+    /**
+     * 查询所有架构的路径和路径拼接成的架构名称
+     *
+     * @return 返回查询到的数据
+     */
+    List<PathStructureNameVO> queryPathStructureName(Integer productId);
+
+    /**
+     * 删除架构
+     *
+     * @param structureId 架构id
+     */
+    @Transactional
+    void delete(Integer structureId);
+
 }

PAS/src/main/java/cn/cslg/pas/service/impl/ProductServiceImpl.java

@@ -147,7 +147,7 @@ public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product>  imp
             throw new XiaoShiException(message);
         }
 
-        //先通过产品id查询出所有原来的图片文件id
+        //先根据产品id查询出原来的产品图片文件id
         List<ProductPictureVO> productPictureVOs = assoProductPictureMapper.selectByProductId(productId);
         ArrayList<Integer> oldPictureIds = new ArrayList<>();
         for (ProductPictureVO productPictureVO : productPictureVOs) {

PAS/src/main/java/cn/cslg/pas/service/impl/StructureServiceImpl.java

@@ -1,9 +1,8 @@
 package cn.cslg.pas.service.impl;
 
-import cn.cslg.pas.common.model.dto.StructureAddNewDTO;
-import cn.cslg.pas.common.model.dto.StructureQueryPageDTO;
-import cn.cslg.pas.common.model.dto.StructureUpdateDTO;
-import cn.cslg.pas.common.model.dto.UploadFileDTO;
+import cn.cslg.pas.common.model.dto.*;
+import cn.cslg.pas.common.model.vo.PathStructureNameVO;
+import cn.cslg.pas.common.model.vo.StructurePictureVO;
 import cn.cslg.pas.common.model.vo.StructureVO;
 import cn.cslg.pas.common.utils.FileUtils;
 import cn.cslg.pas.domain.Structure;
@@ -12,6 +11,8 @@ import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.AssoStructurePictureMapper;
 import cn.cslg.pas.mapper.StructureMapper;
 import cn.cslg.pas.service.IStructureService;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
@@ -19,7 +20,10 @@ import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * 架构的Service层接口实现类
@@ -30,7 +34,7 @@ import java.util.List;
 @RequiredArgsConstructor
 @Slf4j
 @Service
-public class StructureServiceImpl implements IStructureService {
+public class StructureServiceImpl extends ServiceImpl<StructureMapper, Structure> implements IStructureService {
     private final StructureMapper structureMapper;
     private final AssoStructurePictureMapper assoStructurePictureMapper;
     private final FileUtils fileUtils;
@@ -52,11 +56,11 @@ public class StructureServiceImpl implements IStructureService {
 
         Integer parentId = structureAddNewDTO.getParentId();
         String structureName = structureAddNewDTO.getStructureName();
-        //检查名称是否被占用(检查当前父级下是否有同名架构)
+        //检查名称是否被占用(检查当前架构父级下是否有同名架构)
         log.info("检查名称是否被占用(检查当前父级下是否有同名架构)");
-        int count = structureMapper.countByparentIdAndStructureName(parentId, structureName);
+        int count = structureMapper.countByparentIdAndStructureName(parentId, structureName, null);
         if (count > 0) {
-            String message = "新增架构失败，当前父级下已存在【" + structureName + "】";
+            String message = "新增架构失败，当前父级下已存在【" + structureName + "】，请尝试更换名称";
             log.info("{}", message);
             throw new XiaoShiException(message);
         }
@@ -123,6 +127,130 @@ public class StructureServiceImpl implements IStructureService {
      */
     @Override
     public void update(StructureUpdateDTO structureUpdateDTO, List<MultipartFile> files) {
+        log.info("开始处理【修改架构】的业务，参数为：{}, {}", structureUpdateDTO, files);
+
+        //检查尝试修改的数据是否存在
+        Integer structureId = structureUpdateDTO.getId();
+        log.info("检查尝试修改的数据是否存在");
+        Structure queryResult = structureMapper.getStandardById(structureId);
+        if (queryResult == null) {
+            String message = "修改架构失败，尝试访问的数据已不存在";
+            log.info("{}", message);
+            throw new XiaoShiException(message);
+        }
+
+        Integer oldParentId = queryResult.getParentId();
+        String oldPath = queryResult.getPath();
+        Integer newParentId = structureUpdateDTO.getParentId();
+        String newStructureName = structureUpdateDTO.getStructureName();
+        //检查名称是否被占用(检查当前尝试修改的架构父级下是否有同名架构)
+        log.info("检查名称是否被占用(检查当前尝试修改的架构父级下是否有同名架构)");
+        int count = structureMapper.countByparentIdAndStructureName(newParentId, newStructureName, structureId);
+        if (count > 0) {
+            String message = "修改架构失败，当前尝试修改的架构父级下已存在【" + newStructureName + "】，请尝试更换名称";
+            log.info("{}", message);
+            throw new XiaoShiException(message);
+        }
+
+        //DTO对象赋值给实体类
+        Structure structure = new Structure();
+        BeanUtils.copyProperties(structureUpdateDTO, structure);
+        String parentPath = structureUpdateDTO.getParentPath();
+        if (parentPath == null) {
+            parentPath = "0";
+        }
+
+        //该架构新的path路径
+        String newPath = parentPath + "," + structureId;
+        //如果新路径和原路径不一样，则表示架构更换了父级
+        if (!oldParentId.equals(newParentId)) {
+            structure.setParentId(newParentId);
+            structure.setPath(newPath);
+        }
+
+        //架构表修改数据
+        log.info("架构表修改数据");
+        int rows = structureMapper.update(structure);
+        if (rows != 1) {
+            String message = "修改架构失败，服务器忙请稍后再次尝试!";
+            log.info("{}", message);
+            throw new XiaoShiException(message);
+        }
+
+        //如果当前修改的架构更换了父级，则要将当前架构下所有子级架构的路径也都更新
+        if (!oldParentId.equals(newParentId)) {
+            //根据当前架构原来的路径查询所有子级架构
+            List<StructureVO> structures = structureMapper.selectByFindInSetPath(oldPath);
+            for (StructureVO n : structures) {
+                String path = n.getPath();
+                //从当前架构(即它们的父级架构)的原来的路径的长度的位置处截取后面路径
+                String behindString = path.substring(oldPath.length());
+                path = newPath + behindString;
+                n.setPath(path);
+                Structure structure2 = new Structure();
+                BeanUtils.copyProperties(n, structure2);
+                log.info("修改当前已更换父级的架构的子级架构路径path");
+                rows = structureMapper.update(structure2);
+                if (rows != 1) {
+                    String message = "修改架构失败，修改当前已更换父级的架构的子级架构路径path失败，服务器忙请稍后再次尝试!";
+                    log.info("{}", message);
+                    throw new XiaoShiException(message);
+                }
+            }
+        }
+
+        //架构图片关联表删除数据(若有原有图片被删除)
+        //根据架构id查询出所有原有图片
+        log.info("根据架构id查询出所有原有图片");
+        List<StructurePictureVO> structurePictures = assoStructurePictureMapper.selectByStructureId(structureId);
+        ArrayList<Integer> oldPictureIds = new ArrayList<>();
+        for (StructurePictureVO structurePicture : structurePictures) {
+            Integer oldPictureId = structurePicture.getId();
+            oldPictureIds.add(oldPictureId);
+        }
+        //从DTO中获取传过来的原有图片
+        List<StructurePictureUpdateDTO> pictures = structureUpdateDTO.getPictures();
+        ArrayList<Integer> newOldPictureIds = new ArrayList<>();
+        for (StructurePictureUpdateDTO picture : pictures) {
+            Integer newOldPictureId = picture.getId();
+            newOldPictureIds.add(newOldPictureId);
+        }
+        //图片id集合去重，保留下来的即被删除的图片id
+        oldPictureIds.removeAll(newOldPictureIds);
+
+        if (oldPictureIds.size() > 0) {
+            log.info("架构图片关联表删除数据");
+            rows = assoStructurePictureMapper.deleteByIds(oldPictureIds);
+            if (rows != oldPictureIds.size()) {
+                String message = "修改架构失败，架构图片关联表删除数据失败，服务器忙请稍后再次尝试!";
+                log.info("{}", message);
+                throw new XiaoShiException(message);
+            }
+        }
+
+        //数据入架构图片关联表(若有新增新图片)
+        if (files != null && files.size() != 0) {
+            ArrayList<AssoStructurePicture> assoStructurePictures = new ArrayList<>();
+            for (MultipartFile file : files) {
+                UploadFileDTO fileDTO = fileUtils.uploadFile(file);
+                AssoStructurePicture assoStructurePicture = new AssoStructurePicture()
+                        .setStructureId(structureId)
+                        .setName(fileDTO.getName())
+                        .setSuffix(fileDTO.getExtName())
+                        .setUrl(fileDTO.getPath());
+                assoStructurePictures.add(assoStructurePicture);
+            }
+            log.info("数据入架构图片关联表");
+            rows = assoStructurePictureMapper.insertBatch(assoStructurePictures);
+            if (rows != files.size()) {
+                String message = "修改架构失败，数据入架构图片关联表失败，服务器忙请稍后再次尝试!";
+                log.info("{}", message);
+                throw new XiaoShiException(message);
+            }
+        }
+
+        log.info("修改架构完成");
+
     }
 
     /**
@@ -133,33 +261,137 @@ public class StructureServiceImpl implements IStructureService {
      */
     @Override
     public StructureVO query(StructureQueryPageDTO structureQueryPageDTO) {
-        log.info("开始处理【分页查询架构】的业务，参数为：{}", structureQueryPageDTO);
-
-        //取出DTO中structureId，若structureId为null则表示查询的是整个架构树，手动给structureId设为0
-        if (structureQueryPageDTO.getStructureId() == null) {
-            structureQueryPageDTO.setStructureId(0);
-        }
-
-        //从DTO中取出产品id、架构id、架构名称
+        log.info("开始处理【查询架构树】的业务，参数为：{}", structureQueryPageDTO);
+        StructureVO structureVO = new StructureVO();
+        //从DTO中取出产品id、架构id
         Integer productId = structureQueryPageDTO.getProductId();
         Integer structureId = structureQueryPageDTO.getStructureId();
+        if (structureId == null) {
+            structureId = 0;
+        }
         String structureName = structureQueryPageDTO.getStructureName();
-        StructureVO structureVO = new StructureVO()
-                .setProductId(productId)
-                .setId(structureId)
-                .setStructureName(structureName);
-        diGui(structureVO, structureId);
+        LambdaQueryWrapper<Structure> wrapper = new LambdaQueryWrapper<>();
+        if (structureName != null) {
+            wrapper.like(Structure::getStructureName, structureQueryPageDTO.getStructureName());
+        }
+        List<Structure> structures = this.list(wrapper);
+        List<Integer> ids = structures.stream().map(Structure::getId).collect(Collectors.toList());
+        List<String> paths = structures.stream().map(Structure::getPath).collect(Collectors.toList());
+        paths.forEach(
+                item -> {
+                    String[] pathStrs = item.split(",");
+                    List<String> pathStr = new ArrayList<>(Arrays.asList(pathStrs));
+                    pathStr.forEach(
+                            tem -> {
+                                Integer paId = Integer.parseInt(tem);
+                                if (!ids.contains(paId)) {
+                                    ids.add(paId);
+                                }
+                            }
+                    );
+                }
+        );
+        if (ids.size() != 0) {
+            diGui(structureVO, structureId, productId, ids);
+        }
         return structureVO;
     }
 
-    //递归组装架构集合树
-    private void diGui(StructureVO structureVO, Integer structureId) {
-        List<StructureVO> structureVOs = structureMapper.selectByParentId(structureId);
+    /**
+     * 查询所有架构的路径和路径拼接成的架构名称
+     *
+     * @return 返回查询到的数据
+     */
+    @Override
+    public List<PathStructureNameVO> queryPathStructureName(Integer productId) {
+        log.info("开始处理【查询所有架构路径和路径架构名称】的业务，参数为：{}", productId);
+
+        ArrayList<PathStructureNameVO> pathStructureNames = new ArrayList<>();
+
+        log.info("根据产品id查询所有架构数据");
+        List<StructureVO> structures = structureMapper.selectAllByProductId(productId);
+        //map存储所有架构id(key)和架构名称(value)
+        HashMap<String, String> map = new HashMap<>();
+        for (StructureVO structure : structures) {
+            Integer structureId = structure.getId();
+            String structureStrId = structureId + "";
+            String structureName = structure.getStructureName();
+            map.put(structureStrId, structureName);
+        }
+
+        for (StructureVO structure : structures) {
+            String path = structure.getPath();
+            //path = path.substring(path.indexOf(",") + 1);
+            String[] pathSplit = path.split(",");
+            //String pathStructureName = "";
+            StringBuilder builder = new StringBuilder();
+            for (int i = 1; i < pathSplit.length; i++) {
+                String structureName = map.get(pathSplit[i]);
+                //pathStructureName = pathStructureName + structureName + "/";
+                builder.append(structureName).append("/");
+            }
+            PathStructureNameVO pathStructureNameVO = new PathStructureNameVO()
+                    .setPath(path)
+                    .setPathStructureName(builder + "");
+            pathStructureNames.add(pathStructureNameVO);
+        }
+
+        return pathStructureNames;
+    }
+
+    /**
+     * 删除架构
+     *
+     * @param id 架构id
+     */
+    @Override
+    public void delete(Integer id) {
+        log.info("开始处理【删除架构】的业务，参数为：{}", id);
+
+        //检查尝试删除的数据是否存在
+        Structure queryResult = structureMapper.getStandardById(id);
+        if (queryResult == null) {
+            String message = "删除架构失败，尝试访问的数据已不存在";
+            log.info("{}", message);
+            throw new XiaoShiException(message);
+        }
+
+        ArrayList<Integer> structureIds = new ArrayList<>();
+        structureIds.add(id);
+        //根据架构路径查询其所有子级架构
+        String path = queryResult.getPath();
+        log.info("根据架构路径查询其所有子级架构");
+        List<StructureVO> structures = structureMapper.selectByFindInSetPath(path);
+        for (StructureVO structure : structures) {
+            Integer childStructureId = structure.getId();
+            structureIds.add(childStructureId);
+        }
+
+        //架构和专利关联表删除数据
+        log.info("架构和专利关联表删除数据");
+        assoStructurePictureMapper.deleteByIds(structureIds);
+
+        //架构和图片关联表删除数据
+        log.info("架构和图片关联表删除数据");
+        assoStructurePictureMapper.deleteByStructureIds(structureIds);
+
+        //架构表删除数据
+        log.info("架构表删除数据");
+        int rows = structureMapper.deleteByIds(structureIds);
+
+        log.info("删除架构完成");
+
+    }
+
+    //递归组装架构树集合
+    //递归组装架构树集合
+    private void diGui(StructureVO structureVO, Integer structureId, Integer productId, List<Integer> ids) {
+        List<StructureVO> structureVOs = structureMapper.selectByParentIdAndProductId(structureId, productId, ids);
         if (structureVOs != null) {
             structureVO.setChildren(structureVOs);
             for (StructureVO n : structureVOs) {
                 structureId = n.getId();
-                diGui(n, structureId);
+                diGui(n, structureId, productId, ids);
             }
         }
     }

PAS/src/main/resources/application.yml

@@ -20,7 +20,7 @@ spring:
       max-file-size: 1000MB
       max-request-size: 1000MB
   profiles:
-    active: prod2
+    active: dev
   jackson:
     default-property-inclusion: non_null
     serialization:

PAS/src/main/resources/mapper/AssoStructurePatentMapper.xml

@@ -0,0 +1,18 @@
+<?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="cn.cslg.pas.mapper.AssoStructurePatentMapper">
+    <!--根据架构id批量删除数据-->
+    <!--int deleteByStructureIds(List<Integer> structureIds);-->
+    <delete id="deleteByStructureIds">
+        delete
+        from asso_structure_patent
+        where structure_id in (
+        <foreach collection="list" item="n" separator=",">
+            #{n}
+        </foreach>
+        )
+    </delete>
+
+
+</mapper>

PAS/src/main/resources/mapper/AssoStructurePictureMapper.xml

@@ -12,4 +12,46 @@
         </foreach>
     </insert>
 
+    <!--根据id批量删除数据-->
+    <!--int deleteByIds(List<Integer> ids);-->
+    <delete id="deleteByIds">
+        delete from asso_structure_picture where id in (
+        <foreach collection="list" item="n" separator=",">
+            #{n}
+        </foreach>
+        )
+    </delete>
+
+    <!--根据架构ids批量删除数据-->
+    <!--int deleteByStructureIds(List<Integer> structures);-->
+    <delete id="deleteByStructureIds">
+        delete
+        from asso_structure_picture
+        where structure_id in (
+        <foreach collection="list" item="n" separator=",">
+            #{n}
+        </foreach>
+        )
+    </delete>
+
+    <!--根据架构id查询数据-->
+    <!--List<StructurePictureVO> selectByStructureId(Integer structureId);-->
+    <select id="selectByStructureId" resultMap="selectByStructureIdMap">
+        select id,
+               structure_id,
+               name,
+               suffix,
+               url
+        from asso_structure_picture
+        where structure_id = #{structureId}
+    </select>
+
+    <resultMap id="selectByStructureIdMap" type="cn.cslg.pas.common.model.vo.StructurePictureVO">
+        <id column="id" property="id"/>
+        <result column="structure_id" property="structureId"/>
+        <result column="name" property="name"/>
+        <result column="suffix" property="suffix"/>
+        <result column="url" property="url"/>
+    </resultMap>
+
 </mapper>

PAS/src/main/resources/mapper/StructureMapper.xml

@@ -17,6 +17,18 @@
         where id = #{id}
     </delete>
 
+    <!--根据id批量删除数据-->
+    <!--int deleteByIds(List<Integer> ids);-->
+    <delete id="deleteByIds">
+        delete
+        from structure
+        where id in (
+        <foreach collection="list" item="n" separator=",">
+            #{n}
+        </foreach>
+        )
+    </delete>
+
     <!--根据id修改数据-->
     <!--int update(Structure structure);-->
     <update id="update">
@@ -41,19 +53,27 @@
         where id = #{id}
     </update>
 
-    <!--根据父级id和名称统计数量-->
-    <!--int countByparentIdAndStructureName(Integer parentId, String structureName);-->
+    <!--根据父级id和名称和架构id统计数量-->
+    <!--int countByparentIdAndStructureName(Integer parentId, String structureName, Integer structureId);-->
     <select id="countByparentIdAndStructureName" resultType="int">
         select count(*)
         from structure
-        where structure_name = #{structureName}
-          and parent_id = #{parentId}
+        where parent_id = #{parentId}
+        and structure_name = #{structureName}
+        <if test="structureId != null">
+            and id != #{structureId}
+        </if>
     </select>
 
     <!--根据id查询数据-->
     <!--Structure selectById(Integer id);-->
     <select id="getStandardById" resultMap="getStandardByIdMap">
-        select id, parent_id, structure_name, path, remark, product_id
+        select id,
+               parent_id,
+               structure_name,
+               path,
+               remark,
+               product_id
         from structure
         where id = #{id}
     </select>
@@ -67,19 +87,26 @@
         <result column="product_id" property="productId"/>
     </resultMap>
 
-    <!--根据父级id查询数据-->
-    <!--List<StructureVO> selectByParentId(Integer parentId);-->
-    <select id="selectByParentId" resultMap="selectByParentIdMap">
+    <!--根据父级id和产品id查询数据-->
+    <!--List<StructureVO> selectByParentIdAndProductId(Integer parentId, Integer productId);-->
+    <select id="selectByParentIdAndProductId" resultMap="selectByParentIdMap">
         select id s_id,
-               parent_id,
-               structure_name,
-               path,
-               remark,
-               product_id
+        parent_id,
+        structure_name,
+        path,
+        remark,
+        product_id
         from structure
         where parent_id = #{parentId}
+        and product_id = #{productId}
+        and id in
+        <foreach collection="ids" item="item" separator="," open="(" close=")">
+            #{item}
+        </foreach>
+        order by s_id
     </select>
 
+
     <resultMap id="selectByParentIdMap" type="cn.cslg.pas.common.model.vo.StructureVO">
         <id column="s_id" property="id"/>
         <result column="parent_id" property="parentId"/>
@@ -110,17 +137,55 @@
         <result column="url" property="url"/>
     </resultMap>
 
+    <!--根据模糊路径查询数据-->
+    <!--List<StructureVO> selectByFindInSetPath(String findInSetPath);-->
+    <select id="selectByFindInSetPath" resultMap="selectByFindInSetPathMap">
+        select id,
+               parent_id,
+               structure_name,
+               path,
+               remark,
+               product_id
+        from structure
+        where find_in_set(#{findInSetPath}, path)
+        order by id
+    </select>
+
+    <!---->
+    <!---->
+    <select id="selectByName" resultMap="selectByFindInSetPathMap">
+        select id,
+               parent_id,
+               structure_name,
+               path,
+               remark,
+               product_id
+        from structure
+        where structure_name like concat('%', #{name}, '%')
+    </select>
+
+    <resultMap id="selectByFindInSetPathMap" type="cn.cslg.pas.common.model.vo.StructureVO">
+        <id column="id" property="id"/>
+        <result column="parent_id" property="parentId"/>
+        <result column="structure_name" property="structureName"/>
+        <result column="path" property="path"/>
+        <result column="remark" property="remark"/>
+        <result column="product_id" property="productId"/>
+    </resultMap>
+
+
     <!--根据产品id查询数据-->
-    <!--List<StructureVO> selectByProductId(Integer productId);-->
-    <select id="selectByProductId" resultMap="selectByParentIdMap">
-        select id s_id,
+    <!--List<StructureVO> selectAllByProductId(Integer productId);-->
+    <select id="selectAllByProductId" resultMap="selectByFindInSetPathMap">
+        select id,
                parent_id,
                structure_name,
                path,
                remark,
                product_id
         from structure
-        where product_id = #{parentproductIdId}
+        where product_id = #{productId}
+        order by id
     </select>
 
 </mapper>

PAS/src/test/java/cn/cslg/pas/mapper/AssoStructurePictureMapperTests.java

@@ -1,5 +1,6 @@
 package cn.cslg.pas.mapper;
 
+import cn.cslg.pas.common.model.vo.StructurePictureVO;
 import cn.cslg.pas.domain.asso.AssoStructurePicture;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.Test;
@@ -7,6 +8,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * 架构图片关联表的Mapper层接口测试类
@@ -41,4 +43,31 @@ public class AssoStructurePictureMapperTests {
         }
     }
 
+    @Test
+    void deleteByIds() {
+        ArrayList<Integer> ids = new ArrayList<>();
+        ids.add(7);
+        ids.add(8);
+        int rows = assoStructurePictureMapper.deleteByIds(ids);
+        log.info("根据id批量删除数据完成，受影响的行数为：{}", rows);
+    }
+
+    @Test
+    void deleteByStructureIds() {
+        ArrayList<Integer> structureIds = new ArrayList<>();
+        structureIds.add(7);
+        structureIds.add(8);
+        int rows = assoStructurePictureMapper.deleteByStructureIds(structureIds);
+        log.info("根据id批量删除数据完成，受影响的行数为：{}", rows);
+    }
+
+    @Test
+    void selectByStructureId() {
+        List<StructurePictureVO> structurePictures = assoStructurePictureMapper.selectByStructureId(16);
+        log.info("根据架构id查询数据完成，数据信息为：");
+        for (StructurePictureVO structurePicture : structurePictures) {
+            log.info("{}", structurePicture);
+        }
+    }
+
 }

PAS/src/test/java/cn/cslg/pas/mapper/StructureMapperTests.java

@@ -7,6 +7,7 @@ import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -40,6 +41,16 @@ public class StructureMapperTests {
     }
 
     @Test
+    void deleteByIds() {
+        ArrayList<Integer> ids = new ArrayList<>();
+        ids.add(55);
+        ids.add(56);
+        ids.add(57);
+        int rows = structureMapper.deleteByIds(ids);
+        log.info("根据id批量删除数据完成，受影响的行数为：{}", rows);
+    }
+
+    @Test
     void update() {
         Structure structure = new Structure()
                 .setParentId(0)
@@ -53,7 +64,7 @@ public class StructureMapperTests {
 
     @Test
     void countByparentIdAndStructureName() {
-        int count = structureMapper.countByparentIdAndStructureName(0, "手机后壳");
+        int count = structureMapper.countByparentIdAndStructureName(0, "手机后壳", null);
         log.info("根据名称统计数量完成，数量为：{}", count);
     }
 
@@ -65,7 +76,7 @@ public class StructureMapperTests {
 
     @Test
     void selectByParentId() {
-        List<StructureVO> structureVOs = structureMapper.selectByParentId(3);
+        List<StructureVO> structureVOs = structureMapper.selectByParentIdAndProductId(3, 0);
         log.info("根据父级id查询子级架构完成，数据信息为：");
         for (StructureVO structureVO : structureVOs) {
             log.info("{}", structureVO);
@@ -73,12 +84,21 @@ public class StructureMapperTests {
     }
 
     @Test
-    void selectByProductId() {
-        List<StructureVO> structureVOs = structureMapper.selectByProductId(22);
-        log.info("根据产品id查询数据完成，数据信息为：");
-        for (StructureVO structureVO : structureVOs) {
+    void selectByFindInSetPath() {
+        List<StructureVO> queryResults = structureMapper.selectByFindInSetPath("0");
+        log.info("根据模糊路径查询数据完成，数据信息为：");
+        for (StructureVO structureVO : queryResults) {
             log.info("{}", structureVO);
         }
     }
 
+    @Test
+    void selectAllByProductId() {
+        List<StructureVO> queryResults = structureMapper.selectAllByProductId(22);
+        log.info("根据产品id查询数据完成，数据信息为：");
+        for (StructureVO queryResult : queryResults) {
+            log.info("{}", queryResult);
+        }
+    }
+
 }

PAS/src/test/java/cn/cslg/pas/service/StructureServiceImplTests.java

@@ -1,12 +1,15 @@
 package cn.cslg.pas.service;
 
 import cn.cslg.pas.common.model.dto.StructureQueryPageDTO;
+import cn.cslg.pas.common.model.vo.PathStructureNameVO;
 import cn.cslg.pas.common.model.vo.StructureVO;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
+import java.util.List;
+
 /**
  * @Author 陈宇
  * @Date 2023/3/11
@@ -26,4 +29,13 @@ public class StructureServiceImplTests {
         log.info("{}", queryResult);
     }
 
+    @Test
+    void queryPathStructureName() {
+        List<PathStructureNameVO> queryResults = structureService.queryPathStructureName(22);
+        log.info("查询架构路径和路径架构名称完成，数据信息为：");
+        for (PathStructureNameVO queryResult : queryResults) {
+            log.info("{}", queryResult);
+        }
+    }
+
 }