事件编辑/新增/删除时，关键词处理逻辑修改

src/main/java/com/zzsn/event/controller/EventManageController.java

@@ -150,23 +150,10 @@ public class EventManageController {
             eventParam.setCreateBy(currentUser.getUsername());
             Event event = eventService.saveMain(eventParam);
             //新增关键词
-            KeyWords keyWords = keyWordsService.saveKeyword(event, keywordsVO.getKeyword(), keywordsVO.getExclusionWord());
+            keyWordsService.saveBaseAndMap(event, keywordsVO.getKeyword(), keywordsVO.getExclusionWord());
             CompletableFuture.runAsync(() -> {
                 //插入xxlJob
                 iXxlJobInfoService.eventInsert(event);
-                /*-------------------------------------------------------------老采集逻辑---------------*/
-                //关键词入缓存
-                KeyWordsDTO redisKeywordDTO = new KeyWordsDTO();
-                BeanUtils.copyProperties(keyWords, redisKeywordDTO);
-                redisKeywordDTO.setStartTime(event.getStartTime());
-                redisKeywordDTO.setEndTime(event.getEndTime());
-                redisKeywordDTO.setSearchEngines(new ArrayList<>(Constants.DEFAULT_SEARCH_ENGINE.values()));
-                redisUtil.set(Constants.KEY_WORDS_TO_REDIS_PREFIX + keyWords.getWordsCode(), redisKeywordDTO);
-                //插入xxljob
-                iXxlJobInfoService.keyWordsInsert(redisKeywordDTO);
-                //为了立即响应，关键词新增时放入消息队列
-                kafkaTemplate.send(Constants.KEY_WORDS_COLLECT_TOPIC, JSON.toJSONString(redisKeywordDTO));
-                /*-----------------------------------------------------------------老采集逻辑---------------*/
                 //通知采集
                 configurationMessageService.bindKeyWordsEventSend(event.getId());
                 //事件分析
@@ -193,21 +180,8 @@ public class EventManageController {
             addEventParam.setUpdateTime(new Date());
             addEventParam.setUpdateBy(currentUser.getUsername());
             eventService.updateMain(addEventParam);
-            keyWordsService.update(Wrappers.<KeyWords>lambdaUpdate().eq(KeyWords::getId, keywordsVO.getId())
-                    .set(KeyWords::getKeyWord, keywordsVO.getKeyword())
-                    .set(KeyWords::getExclusionWord, keywordsVO.getExclusionWord()));
+            keyWordsService.updateBaseAndMap(addEventParam, keywordsVO.getKeyword(), keywordsVO.getExclusionWord());
             CompletableFuture.runAsync(() -> {
-                /*-----------------------------------------------------------------老采集逻辑---------------*/
-                KeyWordsDTO redisKeywordDTO = new KeyWordsDTO();
-                BeanUtils.copyProperties(keywordsVO, redisKeywordDTO);
-                redisKeywordDTO.setKeyWord(keywordsVO.getKeyword());
-                redisKeywordDTO.setStartTime(addEventParam.getStartTime());
-                redisKeywordDTO.setEndTime(addEventParam.getEndTime());
-                redisKeywordDTO.setSearchEngines(new ArrayList<>(Constants.DEFAULT_SEARCH_ENGINE.values()));
-                redisUtil.set(Constants.KEY_WORDS_TO_REDIS_PREFIX + keywordsVO.getWordsCode(), redisKeywordDTO);
-                //为了立即响应，关键词编辑时放入消息队列
-                kafkaTemplate.send(Constants.KEY_WORDS_COLLECT_TOPIC, JSON.toJSONString(redisKeywordDTO));
-                /*-----------------------------------------------------------------老采集逻辑---------------*/
                 //通知采集
                 configurationMessageService.bindKeyWordsEventSend(addEventParam.getId());
             });
@@ -257,13 +231,7 @@ public class EventManageController {
             EventVO eventVO = eventService.queryInfo(id);
             iXxlJobInfoService.deleteByInfosourceCode(eventVO.getEventCode());
             //删除关键词
-            KeywordsVO keywordsVO = eventVO.getKeywordsVO();
-            if (keywordsVO != null) {
-                String wordsCode = keywordsVO.getWordsCode();
-                keyWordsService.remove(Wrappers.<KeyWords>lambdaQuery().eq(KeyWords::getWordsCode, wordsCode));
-                redisUtil.del(Constants.KEY_WORDS_TO_REDIS_PREFIX + wordsCode);
-                iXxlJobInfoService.deleteByInfosourceCode(wordsCode);
-            }
+            keyWordsService.removeBaseAndMap(id);
         });
         return Result.OK();
     }
@@ -288,13 +256,7 @@ public class EventManageController {
                 EventVO eventVO = eventService.queryInfo(id);
                 iXxlJobInfoService.deleteByInfosourceCode(eventVO.getEventCode());
                 //删除关键词
-                KeywordsVO keywordsVO = eventVO.getKeywordsVO();
-                if (keywordsVO != null) {
-                    String wordsCode = keywordsVO.getWordsCode();
-                    keyWordsService.remove(Wrappers.<KeyWords>lambdaQuery().eq(KeyWords::getWordsCode, wordsCode));
-                    redisUtil.del(Constants.KEY_WORDS_TO_REDIS_PREFIX + wordsCode);
-                    iXxlJobInfoService.deleteByInfosourceCode(wordsCode);
-                }
+                keyWordsService.removeBaseAndMap(id);
             }
         });
         return Result.OK();

src/main/java/com/zzsn/event/controller/yjzx/EventDataController.java

@@ -180,7 +180,7 @@ public class EventDataController {
      * @author lkg
      * @date 2024/7/22
      */
-    @PostMapping("/simpleSaveEvent")
+    //@PostMapping("/simpleSaveEvent")
     public Result<?> addEvent(@RequestBody AddEventVO addEventVO) {
         if(StringUtils.isNotEmpty(CLB_EVENT_ADD)){
             UserVo currentUser = UserUtil.getLoginUser();
@@ -255,6 +255,32 @@ public class EventDataController {
         }
     }
 
+    @PostMapping("/simpleSaveEvent")
+    public Result<?> addEvent_new(@RequestBody AddEventVO addEventVO) {
+        KeywordsVO keywordsVO = addEventVO.getKeywordsVO();
+        if (keywordsVO != null) {
+            UserVo currentUser = UserUtil.getLoginUser();
+            AddEventParam eventParam = new AddEventParam();
+            BeanUtils.copyProperties(addEventVO, eventParam);
+            eventParam.setCreateBy(currentUser.getUsername());
+            Event event = eventService.saveMain(eventParam);
+            //新增关键词
+            keyWordsService.saveBaseAndMap(event, keywordsVO.getKeyword(), keywordsVO.getExclusionWord());
+            CompletableFuture.runAsync(() -> {
+                //插入xxlJob
+                iXxlJobInfoService.eventInsert(event);
+                //通知采集
+                configurationMessageService.bindKeyWordsEventSend(event.getId());
+                //事件分析
+                kafkaTemplate.send(EVENT_MODEL_KAFKA_CHANNEL, event.getEventCode());
+            });
+            return Result.OK();
+        } else {
+            return Result.FAIL(500, "关键词不能为空");
+        }
+    }
+
+
     /**
      * 编辑事件(页面简化版)
      *
@@ -262,7 +288,7 @@ public class EventDataController {
      * @author lkg
      * @date 2024/7/22
      */
-    @PostMapping("/simpleUpdateEvent")
+    //@PostMapping("/simpleUpdateEvent")
     public Result<?> updateEvent(@RequestBody AddEventVO addEventVO) {
         if(StringUtils.isNotEmpty(CLB_EVENT_EDIT)){
             UserVo currentUser = UserUtil.getLoginUser();
@@ -322,6 +348,28 @@ public class EventDataController {
         }
     }
 
+
+    @PostMapping("/simpleUpdateEvent")
+    public Result<?> updateEvent_new(@RequestBody AddEventVO addEventVO) {
+        KeywordsVO keywordsVO = addEventVO.getKeywordsVO();
+        AddEventParam addEventParam = new AddEventParam();
+        BeanUtils.copyProperties(addEventVO, addEventParam);
+        if (keywordsVO != null) {
+            UserVo currentUser = UserUtil.getLoginUser();
+            addEventParam.setUpdateTime(new Date());
+            addEventParam.setUpdateBy(currentUser.getUsername());
+            eventService.updateMain(addEventParam);
+            keyWordsService.updateBaseAndMap(addEventParam, keywordsVO.getKeyword(), keywordsVO.getExclusionWord());
+            CompletableFuture.runAsync(() -> {
+                //通知采集
+                configurationMessageService.bindKeyWordsEventSend(addEventParam.getId());
+            });
+            return Result.OK();
+        } else {
+            return Result.FAIL(500, "关键词不能为空");
+        }
+    }
+
     /**
      * 事件配置校验
      *
@@ -342,7 +390,7 @@ public class EventDataController {
      * @author lkg
      * @date 2025/2/6
      */
-    @GetMapping("/clearData")
+    //@GetMapping("/clearData")
     public Result<?> clearData(@RequestParam String eventId){
         if (StringUtils.isNotEmpty(CLB_CLEAR_DATA)) {
             try {
@@ -360,14 +408,19 @@ public class EventDataController {
         return Result.OK("正在清空数据");
     }
 
+    @GetMapping("/clearData")
+    public Result<?> clearData_new(@RequestParam String eventId){
+        eventService.clearSubjectData(eventId);
+        return Result.OK("正在清空数据");
+    }
+
     /**
      * 通过id删除
      *
      * @param param:id 事件id
      * @return
      */
-    @ApiOperation(value = "事件-通过id删除", notes = "事件-通过id删除")
-    @PostMapping(value = "/simpleDeleteEvent")
+    //@PostMapping(value = "/simpleDeleteEvent")
     public Result<?> delete(@RequestBody JSONObject param) {
         if(StringUtils.isNotEmpty(CLB_EVENT_DELETE)){
             try {
@@ -412,6 +465,19 @@ public class EventDataController {
         }
     }
 
+    @PostMapping(value = "/simpleDeleteEvent")
+    public Result<?> delete_new(@RequestBody JSONObject param) {
+        String id = param.getString("id");
+        eventService.deleteMain(id);
+        CompletableFuture.runAsync(() -> {
+            EventVO eventVO = eventService.queryInfo(id);
+            iXxlJobInfoService.deleteByInfosourceCode(eventVO.getEventCode());
+            //删除关键词
+            keyWordsService.removeBaseAndMap(id);
+        });
+        return Result.OK();
+    }
+
 
     /**
      * 事件资讯分页列表

src/main/java/com/zzsn/event/service/IKeyWordsService.java

@@ -91,4 +91,33 @@ public interface IKeyWordsService extends IService<KeyWords> {
     Integer countByTypeAndIdList(String userId, String customerId,List<String> finalIdList, String subjectId);
 
     List<KeyWordsPage> bindKeyWordsListByIdsAndBindType(List<String> ids, String bindingType,Integer metaSearchFlag);
+
+    /**
+     * 保存基本信息以及关系数据
+     *
+     * @param event 事件信息
+     * @param keyword 关键词
+     * @param exclusionWord 排除词
+     * @author lkg
+     * @date 2025/7/15
+     */
+    void saveBaseAndMap(Event event, String keyword, String exclusionWord);
+    /**
+     * 更新基本信息以及关系数据
+     *
+     * @param event 事件信息
+     * @param keyword 关键词
+     * @param exclusionWord 排除词
+     * @author lkg
+     * @date 2025/7/15
+     */
+    void updateBaseAndMap(Event event, String keyword, String exclusionWord);
+    /**
+     * 删除基本信息以及关系数据
+     *
+     * @param eventId 事件id
+     * @author lkg
+     * @date 2025/7/15
+     */
+    void removeBaseAndMap(String eventId);
 }

src/main/java/com/zzsn/event/service/impl/KeyWordsServiceImpl.java

 package com.zzsn.event.service.impl;
 
+import com.alibaba.fastjson2.JSON;
 import com.alibaba.fastjson2.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.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 com.zzsn.clb.common.model.task.dto.titr.KeyWordsDTO;
 import com.zzsn.event.constant.Constants;
-import com.zzsn.event.entity.Event;
-import com.zzsn.event.entity.KeyWords;
-import com.zzsn.event.entity.KeywordsType;
-import com.zzsn.event.entity.KeywordsTypeMap;
+import com.zzsn.event.entity.*;
 import com.zzsn.event.enums.CodePrefixEnum;
 import com.zzsn.event.mapper.KeyWordsMapper;
-import com.zzsn.event.service.IKeyWordsService;
-import com.zzsn.event.service.IKeywordsTypeMapService;
-import com.zzsn.event.service.IKeywordsTypeService;
-import com.zzsn.event.service.ISubjectKeywordsMapService;
+import com.zzsn.event.service.*;
 import com.zzsn.event.util.CodeGenerateUtil;
 import com.zzsn.event.util.RedisUtil;
 import com.zzsn.event.util.tree.Node;
@@ -28,17 +25,22 @@ import com.zzsn.event.vo.KeyWordsPage;
 import com.zzsn.event.vo.KeywordsVO;
 import com.zzsn.event.vo.SubjectKeywordsMap;
 import com.zzsn.event.xxljob.service.IXxlJobInfoService;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.ibatis.annotations.Param;
+import org.checkerframework.checker.units.qual.K;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.kafka.core.KafkaTemplate;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  * @Description: 关键词管理
@@ -63,6 +65,8 @@ public class KeyWordsServiceImpl extends ServiceImpl<KeyWordsMapper, KeyWords> i
     private RedisUtil redisUtil;
     @Autowired
     private ConfigurationMessageService configurationMessageService;
+    @Autowired
+    private SubjectKeywordsGroupRelationService subjectKeywordsGroupRelationService;
 
     @Resource
     private KafkaTemplate<String,String> kafkaTemplate;
@@ -318,4 +322,134 @@ public class KeyWordsServiceImpl extends ServiceImpl<KeyWordsMapper, KeyWords> i
     public List<KeyWordsPage> bindKeyWordsListByIdsAndBindType(List<String> ids, String bindingType,Integer metaSearchFlag) {
         return baseMapper.bindKeyWordsListByIdsAndBindType(ids,bindingType,metaSearchFlag);
     }
+
+    @Override
+    @Transactional
+    public void saveBaseAndMap(Event event, String keyword, String exclusionWord) {
+        if (StringUtils.isNotEmpty(keyword)) {
+            addMapMain(event, keyword,1);
+        }
+        if (StringUtils.isNotEmpty(exclusionWord)) {
+            addMapMain(event, exclusionWord,2);
+        }
+    }
+
+    @Override
+    @Transactional
+    public void updateBaseAndMap(Event event, String keyword, String exclusionWord) {
+        //采集词
+        LambdaQueryWrapper<SubjectKeywordsMap> queryWrapper = Wrappers.lambdaQuery();
+        queryWrapper.eq(SubjectKeywordsMap::getSubjectId, event.getId()).eq(SubjectKeywordsMap::getBindingType, 1);
+        SubjectKeywordsMap one = subjectKeywordsMapService.getOne(queryWrapper);
+        if (one != null) {
+            String keywordsId = one.getKeywordsId();
+            LambdaUpdateWrapper<KeyWords> update = Wrappers.lambdaUpdate();
+            update.set(KeyWords::getKeyWord, keyword).eq(KeyWords::getId, keywordsId);
+            this.update(update);
+        }
+        //排除词
+        LambdaQueryWrapper<SubjectKeywordsMap> query = Wrappers.lambdaQuery();
+        query.eq(SubjectKeywordsMap::getSubjectId, event.getId()).eq(SubjectKeywordsMap::getBindingType, 3);
+        SubjectKeywordsMap excludeOne = subjectKeywordsMapService.getOne(queryWrapper);
+        if (StringUtils.isNotEmpty(exclusionWord)) {
+            if (excludeOne == null) {
+                addMapMain(event, exclusionWord,2);
+            } else {
+                String keywordsId = excludeOne.getKeywordsId();
+                LambdaUpdateWrapper<KeyWords> update = Wrappers.lambdaUpdate();
+                update.set(KeyWords::getKeyWord, exclusionWord).eq(KeyWords::getId, keywordsId);
+                this.update(update);
+            }
+        } else {
+            if (excludeOne != null) {
+                this.removeById(excludeOne.getKeywordsId());
+                subjectKeywordsMapService.removeById(excludeOne.getId());
+                LambdaQueryWrapper<SubjectKeywordsGroupRelation> wrapper = Wrappers.lambdaQuery();
+                wrapper.eq(SubjectKeywordsGroupRelation::getRelationType, 3)
+                        .eq(SubjectKeywordsGroupRelation::getSubjectId, excludeOne.getSubjectId());
+                subjectKeywordsGroupRelationService.remove(wrapper);
+            }
+        }
+    }
+
+    @Override
+    @Transactional
+    public void removeBaseAndMap(String eventId) {
+        LambdaQueryWrapper<SubjectKeywordsMap> queryWrapper = Wrappers.lambdaQuery();
+        queryWrapper.eq(SubjectKeywordsMap::getSubjectId, eventId);
+        List<SubjectKeywordsMap> list = subjectKeywordsMapService.list(queryWrapper);
+        Set<String> ids = list.stream().map(SubjectKeywordsMap::getKeywordsId).collect(Collectors.toSet());
+        this.removeByIds(ids);
+        subjectKeywordsMapService.remove(queryWrapper);
+        LambdaQueryWrapper<SubjectKeywordsGroupRelation> query = Wrappers.lambdaQuery();
+        query.eq(SubjectKeywordsGroupRelation::getSubjectId, eventId);
+        subjectKeywordsGroupRelationService.remove(query);
+    }
+
+    private void addMapMain(Event event, String keyword, Integer type) {
+        KeyWords keyWords = new KeyWords();
+        //关键词
+        String wordsCode = codeGenerateUtil.geneCodeNo(CodePrefixEnum.KEY_WORDS_DEFAULT.getValue());
+        keyWords.setWordsCode(wordsCode);
+        String wordsName = event.getEventName() + "_" + System.currentTimeMillis();
+        keyWords.setWordsName(wordsName);
+        keyWords.setKeyWord(keyword);
+        keyWords.setStatus("1");
+        this.save(keyWords);
+        String keyWordsId = keyWords.getId();
+        //关键词和分类关系
+        KeywordsTypeMap keywordsTypeMap = new KeywordsTypeMap();
+        keywordsTypeMap.setKeywordsId(keyWordsId);
+        //分类默认 事件专题
+        keywordsTypeMap.setTypeId("1802634369064525826");
+        keywordsTypeMapService.save(keywordsTypeMap);
+        //词组间关系
+        List<SubjectKeywordsGroupRelation> relationList = new ArrayList<>();
+        //专题和关键词关系
+        List<SubjectKeywordsMap> dataList = new ArrayList<>();
+        if (type == 1) {
+            for (int i = 1; i < 3; i++) {
+                //专题和词组关系
+                SubjectKeywordsMap subjectKeywordsMap = new SubjectKeywordsMap();
+                subjectKeywordsMap.setKeywordsId(keyWordsId);
+                subjectKeywordsMap.setSubjectId(event.getId());
+                subjectKeywordsMap.setType("1");
+                subjectKeywordsMap.setBindingType(String.valueOf(i));
+                subjectKeywordsMap.setMetaSearchFlag(1);
+                dataList.add(subjectKeywordsMap);
+                //词组关系
+                SubjectKeywordsGroupRelation relation = new SubjectKeywordsGroupRelation();
+                relation.setSubjectId(event.getId());
+                relation.setKeywordsGroupIds(keyWordsId);
+                relation.setRelationType(String.valueOf(i));
+                relation.setExpressionStr(keyWordsId);
+                JSONObject jsonObject = new JSONObject();
+                jsonObject.put("title", wordsName);
+                jsonObject.put("value", keyWordsId);
+                relation.setParamsStr(JSON.toJSONString(jsonObject));
+                relationList.add(relation);
+            }
+        } else if (type == 2) {
+            //专题和词组关系
+            SubjectKeywordsMap subjectKeywordsMap = new SubjectKeywordsMap();
+            subjectKeywordsMap.setKeywordsId(keyWordsId);
+            subjectKeywordsMap.setSubjectId(event.getId());
+            subjectKeywordsMap.setType("1");
+            subjectKeywordsMap.setBindingType("3");
+            dataList.add(subjectKeywordsMap);
+            //词组关系
+            SubjectKeywordsGroupRelation relation = new SubjectKeywordsGroupRelation();
+            relation.setSubjectId(event.getId());
+            relation.setKeywordsGroupIds(keyWordsId);
+            relation.setRelationType("3");
+            relation.setExpressionStr(keyWordsId);
+            JSONObject jsonObject = new JSONObject();
+            jsonObject.put("title", wordsName);
+            jsonObject.put("value", keyWordsId);
+            relation.setParamsStr(JSON.toJSONString(jsonObject));
+            relationList.add(relation);
+        }
+        subjectKeywordsMapService.saveBatch(dataList);
+        subjectKeywordsGroupRelationService.saveBatch(relationList);
+    }
 }