5.26 整理接口时添加注释与优化

PAS/src/main/java/cn/cslg/pas/common/model/params/PatentInstructionTextParams.java

@@ -4,7 +4,16 @@ import lombok.Data;
 
 @Data
 public class PatentInstructionTextParams {
+    /**
+     * 说明书
+     */
     private String manual;
+    /**
+     * 说明书（译文）
+     */
     private String manualOut;
+    /**
+     * 专利id
+     */
     private Integer patentId;
 }

PAS/src/main/java/cn/cslg/pas/common/model/params/PatentInventorParams.java

@@ -6,9 +6,24 @@ import java.util.List;
 
 @Data
 public class PatentInventorParams {
+    /**
+     * 专利id
+     */
     private Integer patentId;
+    /**
+     * 发明人地址
+     */
     private List<String> addressList;
+    /**
+     * 合并前发明人名称
+     */
     private List<String> nameList;
+    /**
+     * 第一发明人名称
+     */
     private String firstName;
+    /**
+     * 第一发明人地址
+     */
     private String firstAddress;
 }

PAS/src/main/java/cn/cslg/pas/common/model/params/PatentLicensorParams.java

@@ -6,8 +6,20 @@ import java.util.List;
 
 @Data
 public class PatentLicensorParams {
+    /**
+     * 专利id
+     */
     private Integer patentId;
+    /**
+     * 许可人
+     */
     private List<String> licensor;
+    /**
+     * 被许可人
+     */
     private List<String> licensee;
+    /**
+     * 许可类型
+     */
     private List<String> type;
 }

PAS/src/main/java/cn/cslg/pas/common/model/params/PatentPledgeParams.java

@@ -6,7 +6,16 @@ import java.util.List;
 
 @Data
 public class PatentPledgeParams {
+    /**
+     * 专利id
+     */
     private Integer patentId;
+    /**
+     * 质押人
+     */
     private List<String> pledgor;
+    /**
+     * 质权人
+     */
     private List<String> pledgee;
 }

PAS/src/main/java/cn/cslg/pas/common/model/params/PatentRightParams.java

@@ -18,11 +18,11 @@ public class PatentRightParams {
      */
     private String patentNo;
     /**
-     * 原文
+     * 权要原文
      */
     private String content;
     /**
-     * 译文
+     * 权要译文
      */
     private String contentOut;
     /**

PAS/src/main/java/cn/cslg/pas/common/model/params/PatentSimpleFamilyParams.java

@@ -6,8 +6,17 @@ import java.util.List;
 
 @Data
 public class PatentSimpleFamilyParams {
+    /**
+     * 专利id
+     */
     private Integer patentId;
+    /**
+     * 专利号
+     */
     private String patentNo;
+    /**
+     * 简单同族
+     */
     private List<String> simpleFamily;
     private List<String> inpadocFamily;
     private List<String> patSnapFamily;

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

@@ -34,8 +34,7 @@ public class TaskParams implements Serializable {
     private Integer projectId;
     private String selected;
     /**
-     * Excel中的全部专利的数据（每一个元素即一个专利的数据）
-     * key：表头  value：表头对应的专利内容
+     * Excel中的全部专利的数据（每一个元素的key：表头(如"公开号")  value：表头对应的专利内容(如"CN204445352U")）
      */
     private List<Map<Object, Object>> rowList;
     /**
@@ -48,6 +47,7 @@ public class TaskParams implements Serializable {
     private Integer total;
     private Integer index;
     private Integer productId;
+
     public TaskParams() {
 
     }

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

@@ -26,9 +26,10 @@ public class UploadParamsVO {
      * 权利要求
      */
     private PatentRight patentRight;
+    /**
+     * 独立权要
+     */
     private String selfContent;
-
-
     /**
      * 说明书（文本）
      */

PAS/src/main/java/cn/cslg/pas/common/utils/ExcelUtils.java

@@ -113,6 +113,11 @@ public class ExcelUtils {
         return map;
     }
 
+    /**
+     * @param pictureData 图片
+     * @return 返回图片的文件路径和文件名称
+     * @throws IOException 抛出IO异常
+     */
     public static Map<String, String> savePicture(PictureData pictureData) throws IOException {
         FileUtils fileUtils = SpringUtils.getBean(FileUtils.class);
         Map<String, String> result = new HashMap<>();

PAS/src/main/java/cn/cslg/pas/domain/Authority.java

@@ -11,7 +11,6 @@ import java.util.List;
 @Data
 @TableName("Authority")
 public class Authority extends BaseEntity<AdminUser> {
-
     /**
      * 内容
      */
@@ -23,7 +22,7 @@ public class Authority extends BaseEntity<AdminUser> {
     @TableField("contentOut")
     private String contentOut;
     /**
-     * 0代表主权要1代表次权要
+     * 0代表主权要 1代表次权要
      */
     @TableField("contentOut")
     private Integer type;
@@ -43,14 +42,12 @@ public class Authority extends BaseEntity<AdminUser> {
     @TableField("SID")
     private String SID;
     /**
-     *父id
+     * 父id
      */
     private List<Integer> fatherID;
     /**
-     *子id
+     * 子id
      */
     private List<Integer> sonID;
 
-
-
 }

PAS/src/main/java/cn/cslg/pas/domain/Patent.java

@@ -274,7 +274,7 @@ public class Patent extends BaseEntity<Patent> {
     private String notPatentQuote;
 
     /**
-     * 摘要附图
+     * 摘要附图路径
      */
     private String abstractPath;
 

PAS/src/main/java/cn/cslg/pas/domain/PatentImage.java

@@ -16,9 +16,8 @@ import lombok.Data;
 @Data
 @TableName("os_patent_img")
 public class PatentImage extends BaseEntity<PatentImage> {
-
     /**
-     * 摘要附图 
+     * 摘要附图
      */
     private Integer status;
 
@@ -27,9 +26,8 @@ public class PatentImage extends BaseEntity<PatentImage> {
      */
     @TableField("address")
     private String url;
-
     /**
-     * 专利信息ID
+     * 专利ID
      */
     @TableField("pid")
     private Integer patentId;

PAS/src/main/java/cn/cslg/pas/domain/PatentInstructionText.java

@@ -15,7 +15,6 @@ import lombok.Data;
 @Data
 @TableName(value ="os_patent_instruction_text")
 public class PatentInstructionText extends BaseEntity<PatentInstructionText> {
-
     /**
      * 专利ID
      */

PAS/src/main/java/cn/cslg/pas/domain/PatentLicensor.java

@@ -15,22 +15,21 @@ import lombok.Data;
 @Data
 @TableName("os_patent_licensor")
 public class PatentLicensor extends BaseEntity<PatentLicensor> {
-
     /**
      * 被许可人
      */
     private String licensee;
-
     /**
      * 许可人
      */
     private String licensor;
-
     /**
      * 许可类型
      */
     private String type;
-
+    /**
+     * 专利id
+     */
     private Integer patentId;
 
 }

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

@@ -18,7 +18,8 @@ import java.util.List;
 public interface PatentSimpleFamilyLinkMapper extends BaseMapper<PatentSimpleFamilyLink> {
 
 
- List<PatentSimpleFamilyLink> getPatentFamilyLinkByPatentNo(@Param("patentNos") List<String> patentNos,@Param("type")Integer type);
-   List<PatentSimpleFamily> getDirtyData(Integer type);
+    List<PatentSimpleFamilyLink> getPatentFamilyLinkByPatentNo(@Param("patentNos") List<String> patentNos, @Param("type") Integer type);
+
+    List<PatentSimpleFamily> getDirtyData(Integer type);
 
 }

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

@@ -37,15 +37,24 @@ public class PatentAgencyService extends ServiceImpl<PatentAgencyMapper, PatentA
     }
 
     public String getAgencyStringIdByName(String name) {
+        //根据代理机构名称查询os_patent_agency表
         LambdaQueryWrapper<PatentAgency> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(PatentAgency::getName, name);
         PatentAgency temp = this.getOne(queryWrapper);
+        //若没有，则将该代理机构新增入库
         if (temp == null) {
             temp = this.add(name);
         }
+        //若有，则直接拿到代理机构id，并将id转成String类型返回
         return String.valueOf(temp.getId());
     }
 
+    /**
+     * 新增代理机构入表"os_patent_agency"
+     *
+     * @param name 代理机构名称
+     * @return 返回代理机构数据
+     */
     public PatentAgency add(String name) {
         PatentAgency agency = new PatentAgency();
         agency.setName(name);

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

@@ -38,18 +38,35 @@ public class PatentAgentLinkService extends ServiceImpl<PatentAgentLinkMapper, P
         return this.list(queryWrapper);
     }
 
+    /**
+     * 更新代理人关联专利表“os_patent_agent_link”数据
+     *
+     * @param patentId 专利id
+     * @param ids      代理人ids
+     */
     public void updatePatentAgentLink(Integer patentId, List<Integer> ids) {
+        //根据专利id删除表中原数据
         this.deleteByPatentId(patentId);
+
+        //代理人关联专利表实体类集合装载数据
         List<PatentAgentLink> dataList = ids.stream().map(item -> {
             PatentAgentLink link = new PatentAgentLink();
             link.setAgentId(item);
             link.setPatentId(patentId);
             return link;
         }).collect(Collectors.toList());
+
+        //数据批量插入代理人关联专利表“os_patent_agent_link”
         this.saveOrUpdateBatch(dataList);
     }
 
+    /**
+     * 根据专利id删除代理人关联专利表“os_patent_agent_link”数据
+     *
+     * @param patentId 专利id
+     */
     public void deleteByPatentId(Integer patentId) {
         this.remove(Wrappers.<PatentAgentLink>lambdaQuery().eq(PatentAgentLink::getPatentId, patentId));
     }
+
 }

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

@@ -102,24 +102,43 @@ public class PatentAgentService extends ServiceImpl<PatentAgentMapper, PatentAge
         }
     }
 
+    /**
+     * 代理人数据入专利信息代理人表“os_patent_agent”，新增代理人ids和专利id入代理人关联专利表“os_patent_agent_link”
+     *
+     * @param patentAgentParams 代理人相关参数
+     */
     public void updatePatentAgent(PatentAgentParams patentAgentParams) {
         if (patentAgentParams.getAgent() == null || patentAgentParams.getAgent().size() == 0) {
             return;
         }
+
+        //创建ids集合，用于存放代理人ids
         List<Integer> ids = new ArrayList<>();
+        //根据代理人名称集合查询代理人表“os_patent_agent”数据
         LambdaQueryWrapper<PatentAgent> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.in(PatentAgent::getName, patentAgentParams.getAgent());
         List<PatentAgent> tempList = this.list(queryWrapper);
+        //遍历代理人名称集合
         patentAgentParams.getAgent().forEach(name -> {
+            //将从表中查询出来的代理人集合进行过滤，过滤出与当前遍历的代理人相同的数据
             PatentAgent agent = tempList.stream().filter(item -> item.getName().equals(name)).findFirst().orElse(null);
+            //判断若数据为null，则表示表中没有当前遍历的代理人，则新增该代理人入表“os_patent_agent”
             if (agent == null) {
                 agent = this.add(name);
             }
             ids.add(agent.getId());
         });
+
+        //更新代理人关联专利表“os_patent_agent_link”数据
         patentAgentLinkService.updatePatentAgentLink(patentAgentParams.getPatentId(), ids);
     }
 
+    /**
+     * 新增代理人入专利信息代理人表“os_patent_agent”
+     *
+     * @param name 代理人名称
+     * @return 返回代理人数据
+     */
     public PatentAgent add(String name) {
         PatentAgent agent = new PatentAgent();
         agent.setName(name);

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

@@ -48,7 +48,9 @@ public class PatentApplicantLinkService extends ServiceImpl<PatentApplicantLinkM
         }
         List<Integer> applicableIds = patentApplicantService.updatePatentApplicant(name, shortName, patentApplicantList);
         if (applicableIds.size() != 0) {
+            //先根据专利id删除申请人属性表”os_applicant_attr“原数据
             this.remove(Wrappers.<PatentApplicantLink>lambdaQuery().eq(PatentApplicantLink::getPatentId, patentId).eq(PatentApplicantLink::getType, type));
+            //遍历新增数据入申请人属性表”os_applicant_attr“原数据
             for (int i = 0; i < applicableIds.size(); i++) {
                 PatentApplicantLink patentApplicantLink = new PatentApplicantLink();
                 patentApplicantLink.setApplicantId(applicableIds.get(i));

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

@@ -61,18 +61,26 @@ public class PatentImageService extends ServiceImpl<PatentImageMapper, PatentIma
         return this.getOne(queryWrapper);
     }
 
+    /**
+     * 新增专利摘要附图方法
+     *
+     * @param patentId    专利id
+     * @param pictureData 摘要附图
+     * @return 返回摘要附图路径
+     * @throws IOException 抛出IO异常
+     */
     public String updatePatentImage(Integer patentId, PictureData pictureData) throws IOException {
-        //先删除该专利号下的对应摘要图片 以免上传重复
+        //专利附图表"os_patent_img"根据专利id删除该专利的摘要图片数据，以免上传重复
         this.deleteByPatentIdAndStatus(patentId, 1);
-        //将文件生成到文件夹下 并将 文件名 和 文件路径 返回出来
+        //调用方法将图片上传至本地图片文件夹下，并返回图片的文件名称和文件路径
         Map<String, String> result = ExcelUtils.savePicture(pictureData);
-        //装配数据
+        //专利附图表实体类装载数据
         PatentImage patentImage = new PatentImage();
         patentImage.setStatus(1);
         patentImage.setPatentId(patentId);
         patentImage.setUrl(result.get("path"));
         patentImage.setFileName(result.get("name"));
-        //插入对应数据
+        //数据入库
         patentImage.insert();
         return patentImage.getUrl();
     }

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

@@ -14,16 +14,22 @@ import java.util.ArrayList;
 import java.util.List;
 
 /**
-* @author Administrator
-* @description 针对表【os_patent_instruction_text(专利说明书（文本）)】的数据库操作Service
-* @createDate 2022-04-16 08:38:10
-*/
+ * @author Administrator
+ * @description 针对表【os_patent_instruction_text(专利说明书（文本）)】的数据库操作Service
+ * @createDate 2022-04-16 08:38:10
+ */
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class PatentInstructionTextService extends ServiceImpl<PatentInstructionTextMapper, PatentInstructionText> {
 
     private final PatentService patentService;
 
+    /**
+     * 根据专利id查询说明书表“os_patent_instruction_text”数据
+     *
+     * @param patentId 专利id
+     * @return 返回说明书数据
+     */
     public PatentInstructionText getPatentInstructionTextByPatentId(Integer patentId) {
         LambdaQueryWrapper<PatentInstructionText> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(PatentInstructionText::getPatentId, patentId);
@@ -54,13 +60,19 @@ public class PatentInstructionTextService extends ServiceImpl<PatentInstructionT
     }
 
     public void updatePatentInstructionText(PatentInstructionTextParams params) {
+        //根据专利id查询说明书表“os_patent_instruction_text”数据
         PatentInstructionText patentInstructionText = this.getPatentInstructionTextByPatentId(params.getPatentId());
+        //若不存在则new说明书表实体类
         if (patentInstructionText == null) {
             patentInstructionText = new PatentInstructionText();
         }
+        //装载专利id
         patentInstructionText.setPatentId(params.getPatentId());
+        //装载说明书
         patentInstructionText.setManual(params.getManual());
+        //装载说明书（译）
         patentInstructionText.setManualOut(params.getManualOut());
+        //数据入表“os_patent_instruction_text”
         patentInstructionText.insertOrUpdate();
     }
 }

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

@@ -41,7 +41,9 @@ public class PatentInventorLinkService extends ServiceImpl<PatentInventorLinkMap
     }
 
     public void updatePatentInventLink(List<Integer> inventorIds, Integer patentId, Integer firstId) {
+        //先根据专利id删除专利与发明人关联表"os_patent_inventor_relation"原数据
         this.deleteByPatentId(patentId);
+        //创建专利与发明人关联表"os_patent_inventor_relation"实体类对象集合，准备批量插入数据
         List<PatentInventorLink> dataList = inventorIds.stream().map(id -> {
             PatentInventorLink patentInventorLink = new PatentInventorLink();
             patentInventorLink.setPatentId(patentId);
@@ -50,6 +52,7 @@ public class PatentInventorLinkService extends ServiceImpl<PatentInventorLinkMap
             return patentInventorLink;
         }).collect(Collectors.toList());
         if (dataList.size() != 0) {
+            //专利与发明人关联数据插入专利与发明人关联表"os_patent_inventor_relation"
             this.saveOrUpdateBatch(dataList);
         }
     }

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

@@ -191,9 +191,13 @@ public class PatentInventorService extends ServiceImpl<PatentInventorMapper, Pat
 
     public void updatePatentInventor(PatentInventorParams params) {
         if (params.getNameList() != null && params.getNameList().size() != 0) {
+            //创建发明人表"os_patent_inventor"实体类集合，准备批量插入数据
             List<PatentInventor> dataList = new ArrayList<>();
+            //遍历发明人名称
             for (int i = 0; i < params.getNameList().size(); i++) {
+                //根据名称查询发明人表"os_patent_inventor"数据
                 PatentInventor patentInventor = this.getPatentInventorByName(params.getNameList().get(i));
+                //判断若没有该发明人，则发明人实体类装载数据新增发明人（若已有，则更新已有数据）
                 if (patentInventor == null) {
                     patentInventor = new PatentInventor();
                 }
@@ -212,8 +216,10 @@ public class PatentInventorService extends ServiceImpl<PatentInventorMapper, Pat
                 }
                 dataList.add(patentInventor);
             }
+            //批量插入或更新专利发明人表"os_patent_inventor"数据
             this.saveOrUpdateBatch(dataList);
             PatentInventor first = dataList.stream().filter(item -> item.getName().equals(params.getFirstName())).findFirst().orElse(null);
+            //准备将专利与发明人关联数据插入专利与发明人关联表"os_patent_inventor_relation"
             patentInventorLinkService.updatePatentInventLink(dataList.stream().map(PatentInventor::getId).collect(Collectors.toList()), params.getPatentId(), first == null ? 0 : first.getId());
         }
     }

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

@@ -45,13 +45,23 @@ public class PatentLicensorService extends ServiceImpl<PatentLicensorMapper, Pat
         this.saveOrUpdateBatch(patentLicensorList);
     }
 
+    /**
+     * 插入或更新专利信息许可人表“os_patent_licensor”数据
+     *
+     * @param patentLicensorParams 许可人相关信息
+     */
     public void updatePatentLicensor(PatentLicensorParams patentLicensorParams) {
         if (patentLicensorParams.getLicensor() == null || patentLicensorParams.getLicensee() == null || patentLicensorParams.getType() == null) {
             return;
         }
+
+        //判断若许可人、被许可人、许可类型三者数量相同则开始进行保存操作
         if (patentLicensorParams.getLicensor().size() == patentLicensorParams.getLicensee().size() && patentLicensorParams.getLicensee().size() == patentLicensorParams.getType().size() && patentLicensorParams.getType().size() != 0) {
+            //根据专利id删除专利信息许可人表“os_patent_licensor”原数据
             this.deletePatentLicensorByPatentId(patentLicensorParams.getPatentId());
+            //创建专利信息许可人表实体类集合，准备批量插入数据
             List<PatentLicensor> patentLicensorList = new ArrayList<>();
+            //遍历集合，创建实体类装载数据
             for (int i = 0; i < patentLicensorParams.getLicensor().size(); i++) {
                 PatentLicensor patentLicensor = new PatentLicensor();
                 patentLicensor.setType(patentLicensorParams.getType().get(i));
@@ -60,10 +70,16 @@ public class PatentLicensorService extends ServiceImpl<PatentLicensorMapper, Pat
                 patentLicensor.setPatentId(patentLicensorParams.getPatentId());
                 patentLicensorList.add(patentLicensor);
             }
+            //批量插入或更新数据
             this.saveOrUpdateBatch(patentLicensorList);
         }
     }
 
+    /**
+     * 根据专利id删除专利信息许可人表“os_patent_licensor”数据
+     *
+     * @param patentId 专利id
+     */
     public void deletePatentLicensorByPatentId(Integer patentId) {
         this.remove(Wrappers.<PatentLicensor>lambdaQuery().eq(PatentLicensor::getPatentId, patentId));
     }

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

@@ -45,13 +45,23 @@ public class PatentPledgeService extends ServiceImpl<PatentPledgeMapper, PatentP
         this.saveOrUpdateBatch(patentPledgeList);
     }
 
+    /**
+     * 新增或更新专利信息质押质权人表“os_patent_pledge”数据
+     *
+     * @param patentPledgeParams 质押质权人相关信息
+     */
     public void updatePatentPledge(PatentPledgeParams patentPledgeParams) {
         if (patentPledgeParams.getPledgee() == null || patentPledgeParams.getPledgor() == null) {
             return;
         }
+
+        //判断若有质押人与质权人并且两方数量相同
         if (patentPledgeParams.getPledgee().size() == patentPledgeParams.getPledgor().size() && patentPledgeParams.getPledgor().size() != 0) {
+            //先根据专利id删除专利信息质押质权人表“os_patent_pledge”原数据
             this.deletePatentPledgeByPatentId(patentPledgeParams.getPatentId());
+            //创建专利信息质押质权人表实体类集合，准备批量插入数据
             List<PatentPledge> patentPledgeList = new ArrayList<>();
+            //遍历实体类集合装载数据
             for (int i = 0; i < patentPledgeParams.getPledgor().size(); i++) {
                 PatentPledge patentPledge = new PatentPledge();
                 patentPledge.setPledgee(patentPledgeParams.getPledgee().get(i));
@@ -59,10 +69,16 @@ public class PatentPledgeService extends ServiceImpl<PatentPledgeMapper, PatentP
                 patentPledge.setPatentId(patentPledgeParams.getPatentId());
                 patentPledgeList.add(patentPledge);
             }
+            //新增或更新专利信息质押质权人表“os_patent_pledge”数据
             this.saveOrUpdateBatch(patentPledgeList);
         }
     }
 
+    /**
+     * 根据专利id删除专利信息质押质权人表“os_patent_pledge”数据
+     *
+     * @param patentId 专利id
+     */
     public void deletePatentPledgeByPatentId(Integer patentId) {
         this.remove(Wrappers.<PatentPledge>lambdaQuery().eq(PatentPledge::getPatentId, patentId));
     }

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

@@ -431,16 +431,18 @@ public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRig
     }
 
     /**
-     * 格式化权要、拆分并理清父子级，insert/update DB
+     * 1.格式化权要 2.理出主次权要父子关系 3.权要表"os_patent_right"更新或新增权要
      *
-     * @param params 权利要求
+     * @param params 权利要求相关数据
      */
     public void updatePatentRight(PatentRightParams params) {
-        //调用拆分权要工具类格式化并拆分权要理清父子级
+        //调用拆分权要工具类
         List<PatentRight> patentRights = PatentRightUtils.formatPatentRight(params);
-        //删除库表中原有该权要
+
         if (patentRights.size() > 0) {
+            //删除库表中原有该权要
             this.deleteByPatentId(params.getPatentId());
+            //权要数据入表"os_patent_right"
             this.saveOrUpdateBatch(patentRights);
         }
 

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

@@ -73,6 +73,9 @@ public class PatentSimpleFamilyService extends ServiceImpl<PatentSimpleFamilyMap
         this.updatePatentSimpleFamily(patentSimpleFamilyParams);
     }
 
+    /**
+     * @param params 简单同族相关信息
+     */
     public void updatePatentSimpleFamily(PatentSimpleFamilyParams params) {
         if (params.getSimpleFamily() != null && params.getSimpleFamily().size() != 0) {
             this.updateData(params.getSimpleFamily(), params.getPatentNo(), params.getPatentId(), 1);
@@ -85,6 +88,13 @@ public class PatentSimpleFamilyService extends ServiceImpl<PatentSimpleFamilyMap
         }
     }
 
+    /**
+     * 专利信息简单同族关联表"os_patent_simplefamily"新增数据
+     *
+     * @param type     1是简单同族 2.INPADOC同族
+     * @param patentNO 公开号
+     * @return 返回新增后的数据
+     */
     public PatentSimpleFamily add(Integer type, String patentNO) {
         PatentSimpleFamily patentSimpleFamily = new PatentSimpleFamily();
         patentSimpleFamily.setType(type);
@@ -101,7 +111,7 @@ public class PatentSimpleFamilyService extends ServiceImpl<PatentSimpleFamilyMap
         //1.根据专利号（faimlyNo + patentNo）从专利基础信息表中获取专利数据，以受理国家、申请日由小到大排序
         List<Patent> patent1s = patentService.getPublicDateAndPatentNoByPatentNo(familyNo);
 
-        //2.从1步取得的专利清单获取第一个CN专利号，为插入Family表中的专利号，如果没有CN专利，取第一个专利号
+        //2.从1步取得的专利清单获取第一个CN专利号，作为插入Family表中的专利号，如果没有CN专利，则取第一个专利号
         String temPatentNo = "";
         if (patent1s != null) {
             Patent patentTem = patent1s.stream().filter(item -> PatentUtils.getPatentCountry(item.getPatentNo()) == "CN").findFirst().orElse(null);
@@ -184,10 +194,5 @@ public class PatentSimpleFamilyService extends ServiceImpl<PatentSimpleFamilyMap
         }
     }
 
-    public static void main(String[] args) {
-
-    }
-
-
 
 }

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

@@ -651,12 +651,12 @@ public class ProjectService extends ServiceImpl<ProjectMapper, Project> {
         //获得文件路径
         String path = fileUtils.getPath(fileDTO.getPath());
 
-        //集合rowList，准备装载Excel中的全部专利的数据（Excel文件总行数即为集合长度，集合每个元素就是每一行数据，集合第一个元素是表头行数据，其余是每行专利的数据）
+        //集合rowList，准备装载Excel中所有行数据(元素个数即行数，第一个元素即为表头行数据，第二个元素开始即为每个专利内容)
         List<List<Object>> rowList = new ArrayList<>();
-        //Excel中的全部专利的数据（key：表头即专利的栏位名称如著录、权利要求等  value：表头即专利的栏位名称对应的数据）
+        //集合mapList，准备装载Excel中的全部专利的数据（每一个元素的key：表头(如"公开号")  value：表头对应的专利内容(如"CN204445352U")）
         List<Map<Object, Object>> mapList = new ArrayList<>();
 
-        //使用框架（excel工具类）解析读取excel文件，装载数据到rowList
+        //使用excel工具类解析读取excel文件，装载数据到rowList
         ExcelUtil.readBySax(path, -1, (sheetIndex, rowIndex, row) -> rowList.add(row));
 
         //集合mapList装载数据（）

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

@@ -91,8 +91,10 @@ public class UploadPatentBatchService {
                     }
 
                 }
+
                 //将装配对象中的数据保存到数据库
                 dataToDB(params, uploadParamsVO, projectImportPatentVO);
+
                 //通过WebSocket 在每一次循环结束后 向前端发送完成进度
                 WebSocketServer.sendInfo(Response.websocket(new TaskWebSocketDTO()
                         .setTaskId(params.getTaskId())
@@ -203,7 +205,7 @@ public class UploadPatentBatchService {
     @Transactional(rollbackFor = Exception.class)
     public void dataToDB(TaskParams params, UploadParamsVO uploadParamsVO, ProjectImportPatentVO projectImportPatentVO) {
         try {
-            //专利信息 OS_PATENT
+            //保存法律状态
             if (uploadParamsVO.getPatent() != null) {
                 List<SystemDict> systemDictList = systemDictService.getSystemDictListByType(Collections.singletonList(Constants.PATENT_SIMPLE_STATUS));
                 Integer simpleStatus = Integer.parseInt(systemDictList.stream()
@@ -213,54 +215,62 @@ public class UploadPatentBatchService {
                 uploadParamsVO.getPatent().setSimpleStatus(simpleStatus);
                 uploadParamsVO.getPatent().updateById();
             }
-            //权利要求 OS_PATENT_RIGHT
+
+            //保存权利要求
             patentRightBusiness(uploadParamsVO);
 
-            //说明书(文本) OS_PATENT_INSTRUCTION_TEXT
+            //保存说明书
             if (uploadParamsVO.getPatentInstructionText() != null) {
                 patentInstructionTextBusiness(uploadParamsVO);
             }
-            //代理人 OS_PATENT_AGENT
+
+            //保存代理人
             if (uploadParamsVO.getPatentAgentList() != null) {
                 patentAgentBusiness(uploadParamsVO);
             }
-            //质押质权人 OS_PATENT_PLEDGE
+
+            //保存质押质权人
             if (uploadParamsVO.getPatentPledgeList() != null) {
                 patentPledgeBusiness(uploadParamsVO);
             }
-            //许可人 OS_PATENT_LICENSOR
+
+            //保存许可人
             if (uploadParamsVO.getPatentLicensorList() != null) {
                 patentLicensorBusiness(uploadParamsVO);
             }
-            //简单同族 OS_PATENT_SIMPLEFAMILY
+
+            //保存简单同族
             patentSimplyFamilyBusiness(uploadParamsVO);
-            //发明人 OS_PATENT_INVENTOR
+
+            //保存发明人
             patentInventorBusiness(uploadParamsVO);
-            //申请人(原始)/权利人(当前) OS_PATENT_APPLICATION || OS_APPLICATION_ATTR
+
+            //保存申请人(原始)/权利人(当前)
             patentApplicationBusiness(uploadParamsVO);
-            //申请人地址 OS_PATENT_APPLICATION
+
+            //保存申请人地址
             patentApplicationAddressBusiness(uploadParamsVO);
-            //专题库关联专利信息 OS_THEMATIC_PID
+            //保存专题库关联专利信息
             if (uploadParamsVO.getPatent() != null) {
                 patentThematicPidBusiness(uploadParamsVO, projectImportPatentVO);
             }
-            //标引内容关联专利信息 OS_PATENT_FIELD_PATENT_LINK
+            //保存标引内容关联专利信息
             if (uploadParamsVO.getPatent() != null) {
                 patentProjectFieldPatentLinkBusiness(uploadParamsVO, projectImportPatentVO);
             }
-            //文件夹管理 OS_PORTFOLIO_LINK
+            //保存文件夹管理
             if (uploadParamsVO.getPatent() != null) {
                 patentProjectFolderPatentLinkBusiness(uploadParamsVO, projectImportPatentVO);
             }
-            //标签 OS_PATENT_LABEL
+            //保存标签
             if (uploadParamsVO.getPatentLabelList() != null) {
                 patentLabelBusiness(uploadParamsVO, projectImportPatentVO);
             }
-            //分类号关联 OS_PATENT_TYPENO
+            //保存分类号关联
             patentTypeNoBusiness(uploadParamsVO);
-            //事务信息 OS_PATENT_AFFAIR
+            //保存事务信息
             patentAffairBusiness(uploadParamsVO);
-            //自定义字段
+            //保存自定义字段
             if (uploadParamsVO.getCustomerFieldList() != null) {
                 patentFieldBusiness(params, uploadParamsVO, projectImportPatentVO);
             }
@@ -368,106 +378,146 @@ public class UploadPatentBatchService {
         }
     }
 
+    //权利要求
     private void patentRightBusiness(UploadParamsVO uploadParamsVO) {
+        //创建PatentRightParams对象保存权要基本信息
         PatentRightParams patentRightParams = new PatentRightParams();
+        //装载专利id
         patentRightParams.setPatentId(uploadParamsVO.getPatent().getId());
+        //装载专利号
         patentRightParams.setPatentNo(uploadParamsVO.getPatent().getPatentNo());
         if (uploadParamsVO.getPatentRight() != null) {
+            //装载权利要求原文
             patentRightParams.setContent(uploadParamsVO.getPatentRight().getContent());
+            //装载权利要求译文
             patentRightParams.setContentOut(uploadParamsVO.getPatentRight().getContentOut());
         }
         if (uploadParamsVO.getSelfContent() != null) {
+            //装载独立权要
             patentRightParams.setSelfContent(uploadParamsVO.getSelfContent());
         }
+        //开始保存权要入库(1.格式化权要 2.理出主次权要父子关系 3.权要入表"os_patent_right")
         patentRightService.updatePatentRight(patentRightParams);
+        //暂未使用
         patentRightService.importAuthority(patentRightParams);
     }
 
+    //说明书文本
     private void patentInstructionTextBusiness(UploadParamsVO uploadParamsVO) {
+        //创建PatentInstructionTextParams对象装载说明书相关数据
         PatentInstructionTextParams patentInstructionTextParams = new PatentInstructionTextParams();
+        //装载专利id
         patentInstructionTextParams.setPatentId(uploadParamsVO.getPatent().getId());
+        //装载说明书
         patentInstructionTextParams.setManual(uploadParamsVO.getPatentInstructionText().getManual());
+        //装载说明书（译）
         patentInstructionTextParams.setManualOut(uploadParamsVO.getPatentInstructionText().getManualOut());
 
+        //开始保存说明书入表“os_patent_instruction_text”
         patentInstructionTextService.updatePatentInstructionText(patentInstructionTextParams);
     }
 
     //代理人
     private void patentAgentBusiness(UploadParamsVO uploadParamsVO) {
+        //创建PatentAgentParams对象装载代理人相关数据
         PatentAgentParams patentAgentParams = new PatentAgentParams();
+        //装载专利id
         patentAgentParams.setPatentId(uploadParamsVO.getPatent().getId());
         List<String> agentList = uploadParamsVO.getPatentAgentList().stream().map(PatentAgent::getName).collect(Collectors.toList());
+        //装载代理人集合
         patentAgentParams.setAgent(agentList);
+        //开始保存代理人信息入表“os_patent_agent”
         patentAgentService.updatePatentAgent(patentAgentParams);
     }
 
-    //质押质权人 OS_PATENT_PLEDGE
+    //质押质权人
     private void patentPledgeBusiness(UploadParamsVO uploadParamsVO) {
+        //创建PatentPledgeParams对象装载质押质权人相关数据
         PatentPledgeParams patentPledgeParams = new PatentPledgeParams();
+        //装载专利id
         patentPledgeParams.setPatentId(uploadParamsVO.getPatent().getId());
         List<String> pledgeeList = uploadParamsVO.getPatentPledgeList().stream().map(PatentPledge::getPledgee).collect(Collectors.toList());
         List<String> pledgorList = uploadParamsVO.getPatentPledgeList().stream().map(PatentPledge::getPledgor).collect(Collectors.toList());
+        //装载质权人集合
         patentPledgeParams.setPledgee(pledgeeList);
+        //装载质押人集合
         patentPledgeParams.setPledgor(pledgorList);
-
+        //开始保存质押质权人信息入表“os_patent_pledge”
         patentPledgeService.updatePatentPledge(patentPledgeParams);
     }
 
 
-    //许可人 OS_PATENT_LICENSOR
+    //许可人
     private void patentLicensorBusiness(UploadParamsVO uploadParamsVO) {
+        //创建PatentLicensorParams对象装载许可人相关数据
         PatentLicensorParams patentLicensorParams = new PatentLicensorParams();
+        //装载专利id
         patentLicensorParams.setPatentId(uploadParamsVO.getPatent().getId());
         List<String> licensorList = uploadParamsVO.getPatentLicensorList().stream().map(PatentLicensor::getLicensor).collect(Collectors.toList());
         List<String> licenseeList = uploadParamsVO.getPatentLicensorList().stream().map(PatentLicensor::getLicensee).collect(Collectors.toList());
         List<String> typeList = uploadParamsVO.getPatentLicensorList().stream().map(PatentLicensor::getType).collect(Collectors.toList());
+        //装载许可人
         patentLicensorParams.setLicensor(licensorList);
+        //装载被许可人
         patentLicensorParams.setLicensee(licenseeList);
+        //装载许可类型
         patentLicensorParams.setType(typeList);
-
+        //开始保存许可人相关信息入专利信息许可人表“os_patent_licensor”
         patentLicensorService.updatePatentLicensor(patentLicensorParams);
     }
 
 
     //简单同族
     private void patentSimplyFamilyBusiness(UploadParamsVO uploadParamsVO) {
+        //创建PatentSimpleFamilyParams对象装载简单同族相关数据
         PatentSimpleFamilyParams patentSimpleFamilyParams = new PatentSimpleFamilyParams();
         if (uploadParamsVO.getSimpleFamily() != null) {
+            //装载简单同族
             patentSimpleFamilyParams.setSimpleFamily(uploadParamsVO.getSimpleFamily());
         }
         if (uploadParamsVO.getPatSnapFamily() != null) {
+            //装载
             patentSimpleFamilyParams.setPatSnapFamily(uploadParamsVO.getPatSnapFamily());
         }
         if (uploadParamsVO.getInpadocFamily() != null) {
+            //装载
             patentSimpleFamilyParams.setInpadocFamily(uploadParamsVO.getInpadocFamily());
         }
+        //装载专利id
         patentSimpleFamilyParams.setPatentId(uploadParamsVO.getPatent().getId());
+        //装载专利号
         patentSimpleFamilyParams.setPatentNo(uploadParamsVO.getPatent().getPatentNo());
-
+        //开始
         patentSimpleFamilyService.updatePatentSimpleFamily(patentSimpleFamilyParams);
     }
 
-    //发明人 OS_PATENT_INVENTOR
+    //发明人
     private void patentInventorBusiness(UploadParamsVO uploadParamsVO) {
+        //创建PatentInventorParams对象装载发明人相关数据
         PatentInventorParams patentInventorParams = new PatentInventorParams();
         if (uploadParamsVO.getPatentInventorList() != null) {
             List<String> addressList = uploadParamsVO.getPatentInventorList().stream().map(PatentInventor::getAddress).filter(Objects::nonNull).collect(Collectors.toList());
+            //装载发明人地址集合
             patentInventorParams.setAddressList(addressList);
             List<String> nameList = uploadParamsVO.getPatentInventorList().stream().map(PatentInventor::getName).collect(Collectors.toList());
+            //装载发明人名称集合
             patentInventorParams.setNameList(nameList);
         }
         if (uploadParamsVO.getFirstName() != null) {
+            //装载第一发明人名称
             patentInventorParams.setFirstName(uploadParamsVO.getFirstName());
         }
         if (uploadParamsVO.getFirstAddress() != null) {
+            //装载第一发明人地址
             patentInventorParams.setFirstAddress(uploadParamsVO.getFirstAddress());
         }
+        //装载专利号
         patentInventorParams.setPatentId(uploadParamsVO.getPatent().getId());
-
+        //开始装载发明人表实体类相关信息、专利与发明人关联表实体类集合相关信息，然后各自数据分别插入这两张表
         patentInventorService.updatePatentInventor(patentInventorParams);
     }
 
-    //申请人(原始)/权利人(当前) OS_PATENT_APPLICATION || OS_APPLICATION_ATTR
+    //申请人(原始)/权利人(当前)
     private void patentApplicationBusiness(UploadParamsVO uploadParamsVO) {
         // 根据本条数据的名字查询所有的申请人信息
         List<String> name = new ArrayList<>();

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

@@ -2,11 +2,22 @@
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 
 <mapper namespace="cn.cslg.pas.mapper.PatentSimpleFamilyLinkMapper">
-    <select id="getPatentFamilyLinkByPatentNo"  resultType="cn.cslg.pas.domain.PatentSimpleFamilyLink">
-        select a.* from os_patent_simplefamily_link a left join os_patent_simplefamily b on a.family_id=b.id where b.type=#{type}
-        and a.patent_no in <foreach collection="patentNos" item="id" open="(" separator="," close=")"> #{id}</foreach>
+    <select id="getPatentFamilyLinkByPatentNo" resultType="cn.cslg.pas.domain.PatentSimpleFamilyLink">
+        select a.* from os_patent_simplefamily_link a
+        left join os_patent_simplefamily b on a.family_id=b.id
+        where
+        b.type = #{type}
+        and a.patent_no in
+        <foreach collection="patentNos" item="id" open="(" separator="," close=")">
+            #{id}
+        </foreach>
     </select>
-    <select id="getDirtyData"  resultType="cn.cslg.pas.domain.PatentSimpleFamily">
-        select *,count(*) as count from os_patent_simplefamily where type =#{type} group by patent_no having  count(*)>1 limit 10000
+    <select id="getDirtyData" resultType="cn.cslg.pas.domain.PatentSimpleFamily">
+        select *, count(*) as count
+        from os_patent_simplefamily
+        where type = #{type}
+        group by patent_no
+        having count(*) > 1
+        limit 10000
     </select>
 </mapper>