Merge branch 'feature/REQ-1465' of axzsource.com:universal/infrastructure/backend/msg-center-plat into dev

inside-notices/src/main/java/cn/axzo/msg/center/message/controller/MessageTemplateController.java

@@ -1,7 +1,11 @@
 package cn.axzo.msg.center.message.controller;
 
+import cn.axzo.core.utils.converter.BeanConverter;
 import cn.axzo.msg.center.message.domain.param.MessageTemplateSaveOrUpdateParam;
+import cn.axzo.msg.center.message.domain.param.RelationTemplateMapInitParam;
+import cn.axzo.msg.center.message.domain.vo.RelationTemplateMapInitRequest;
 import cn.axzo.msg.center.message.service.MessageTemplateNewService;
+import cn.axzo.msg.center.message.service.RelationTemplateMapService;
 import cn.axzo.msg.center.service.template.client.MessageTemplateClient;
 import cn.axzo.msg.center.service.template.request.MessageTemplateCreateRequest;
 import cn.axzo.msg.center.service.template.request.MessageTemplatePageRequest;
@@ -12,8 +16,12 @@ import cn.axzo.msg.center.service.template.response.MessageTemplatePageResponse;
 import cn.azxo.framework.common.model.CommonResponse;
 import cn.azxo.framework.common.model.Page;
 import lombok.RequiredArgsConstructor;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RestController;
 
+import javax.validation.Valid;
 import java.util.Collection;
 import java.util.List;
 
@@ -29,6 +37,7 @@ import java.util.List;
 public class MessageTemplateController implements MessageTemplateClient {
 
     private final MessageTemplateNewService messageTemplateNewService;
+    private final RelationTemplateMapService relationTemplateMapService;
 
     @Override
     public CommonResponse<String> save(MessageTemplateCreateRequest request) {
@@ -62,4 +71,11 @@ public class MessageTemplateController implements MessageTemplateClient {
         messageTemplateNewService.updateStatus(request.getOperatorId(), request.getTemplateCode(), request.getStatus());
         return CommonResponse.success();
     }
+
+    @PostMapping(value = "/message/template/relation/init", produces = {MediaType.APPLICATION_JSON_VALUE})
+    public CommonResponse<Void> initRelationTemplateMap(@RequestBody @Valid RelationTemplateMapInitRequest request) {
+        RelationTemplateMapInitParam param = BeanConverter.convert(request, RelationTemplateMapInitParam.class);
+        relationTemplateMapService.init(param);
+        return CommonResponse.success();
+    }
 }

inside-notices/src/main/java/cn/axzo/msg/center/message/domain/param/RelationTemplateMapInitParam.java

@@ -0,0 +1,31 @@
+package cn.axzo.msg.center.message.domain.param;
+
+import com.alibaba.fastjson.JSON;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Collection;
+
+/**
+ * @author cold_blade
+ * @date 2023/10/27
+ * @version 1.0
+ */
+@Setter
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class RelationTemplateMapInitParam {
+
+    private Collection<Long> relationIds;
+    private String groupNodeCode;
+
+    @Override
+    public String toString() {
+        return JSON.toJSONString(this);
+    }
+}

inside-notices/src/main/java/cn/axzo/msg/center/message/domain/vo/RelationTemplateMapInitRequest.java

@@ -0,0 +1,33 @@
+package cn.axzo.msg.center.message.domain.vo;
+
+import com.alibaba.fastjson.JSON;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+import java.util.Collection;
+
+/**
+ * @author cold_blade
+ * @date 2023/10/27
+ * @version 1.0
+ */
+@Setter
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class RelationTemplateMapInitRequest {
+
+    private Collection<Long> relationIds;
+    @NotBlank(message = "groupNodeCode is required")
+    private String groupNodeCode;
+
+    @Override
+    public String toString() {
+        return JSON.toJSONString(this);
+    }
+}

inside-notices/src/main/java/cn/axzo/msg/center/message/service/MessageTemplateGroupService.java

@@ -29,6 +29,13 @@ public interface MessageTemplateGroupService {
      */
     void templateGroup(String templateNode, Collection<String> groupNodeCodes);
 
+    /**
+     * 模板关联分类
+     *
+     * @param templateGroupMap  模板编码与分类结点编码列表的map
+     */
+    void templateGroup(Map<String, List<String>> templateGroupMap);
+
     /**
      * 更新模板的分类关系
      *

inside-notices/src/main/java/cn/axzo/msg/center/message/service/RelationTemplateMapService.java

@@ -1,5 +1,8 @@
 package cn.axzo.msg.center.message.service;
 
+import cn.axzo.msg.center.message.domain.param.RelationTemplateMapInitParam;
+
+import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
 
@@ -15,4 +18,6 @@ public interface RelationTemplateMapService {
     Optional<String> queryByRelationId(Long relationId);
 
     void mapRelationAndTemplate(Map<Long, String> map);
+
+    void init(RelationTemplateMapInitParam param);
 }

inside-notices/src/main/java/cn/axzo/msg/center/message/service/impl/MessageTemplateGroupServiceImpl.java

@@ -1,6 +1,7 @@
 package cn.axzo.msg.center.message.service.impl;
 
 import cn.axzo.basics.common.util.AssertUtil;
+import cn.axzo.framework.core.util.MapUtil;
 import cn.axzo.msg.center.common.enums.TableIsDeleteEnum;
 import cn.axzo.msg.center.dal.MessageTemplateGroupDao;
 import cn.axzo.msg.center.domain.entity.MessageTemplateGroup;
@@ -18,6 +19,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -67,6 +69,29 @@ public class MessageTemplateGroupServiceImpl implements MessageTemplateGroupServ
         messageTemplateGroupDao.saveBatch(rows);
     }
 
+    @Override
+    public void templateGroup(Map<String, List<String>> templateGroupMap) {
+        if (MapUtil.isEmpty(templateGroupMap)) {
+            log.info("the templateGroupMap is empty.");
+            return;
+        }
+        Set<String> groupNodes = templateGroupMap.values().stream()
+                .flatMap(Collection::stream)
+                .collect(Collectors.toSet());
+        Map<String, String> pathMap = messageGroupNodeService.leafGroupNodeCodePaths(groupNodes);
+        List<MessageTemplateGroup> rows = templateGroupMap.entrySet().stream()
+                .flatMap(e -> e.getValue().stream()
+                        .filter(pathMap::containsKey)
+                        .map(nodeCode -> {
+                            MessageTemplateGroup group = new MessageTemplateGroup();
+                            group.setTemplateCode(e.getKey());
+                            group.setPath(pathMap.get(nodeCode));
+                            return group;
+                        })
+                ).collect(Collectors.toList());
+        messageTemplateGroupDao.saveBatch(rows);
+    }
+
     @Override
     public void updateTemplateGroup(String templateNode, Collection<String> groupNodeCodes) {
         // 先解除之前的关联关系

inside-notices/src/main/java/cn/axzo/msg/center/message/service/impl/RelationTemplateMapServiceImpl.java

@@ -1,11 +1,39 @@
 package cn.axzo.msg.center.message.service.impl;
 
 import cn.axzo.msg.center.common.enums.TableIsDeleteEnum;
+import cn.axzo.msg.center.dal.MessageBaseTemplateDao;
 import cn.axzo.msg.center.dal.RelationTemplateMapDao;
+import cn.axzo.msg.center.domain.entity.MessageBaseTemplate;
+import cn.axzo.msg.center.domain.entity.MessageRelation;
+import cn.axzo.msg.center.domain.entity.MessageRouter;
+import cn.axzo.msg.center.domain.entity.MessageTemplate;
 import cn.axzo.msg.center.domain.entity.RelationTemplateMap;
+import cn.axzo.msg.center.inside.notices.service.MessageRelationService;
+import cn.axzo.msg.center.inside.notices.service.MessageRouterService;
+import cn.axzo.msg.center.inside.notices.service.MessageTemplateService;
+import cn.axzo.msg.center.message.domain.dto.RawMessageRouterDTO;
+import cn.axzo.msg.center.message.domain.param.RelationTemplateMapInitParam;
+import cn.axzo.msg.center.message.service.MessageTemplateGroupService;
+import cn.axzo.msg.center.message.service.MessageTemplateRouterService;
 import cn.axzo.msg.center.message.service.RelationTemplateMapService;
+import cn.axzo.msg.center.service.dto.MessageRouterButtonDTO;
+import cn.axzo.msg.center.service.dto.MessageRouterTerminalDTO;
+import cn.axzo.msg.center.service.enums.ButtonStyleEnum;
+import cn.axzo.msg.center.service.enums.MessageCategoryEnum;
+import cn.axzo.msg.center.service.enums.PushTerminalEnum;
+import cn.axzo.msg.center.service.enums.RouterCategoryEnum;
+import cn.axzo.msg.center.service.enums.TerminalTypeEnum;
+import cn.axzo.msg.center.utils.JSONObjectUtil;
+import cn.axzo.msg.center.utils.UUIDUtil;
+import com.google.common.collect.Lists;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.RequiredArgsConstructor;
+import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -13,6 +41,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 /**
@@ -27,7 +57,13 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor
 public class RelationTemplateMapServiceImpl implements RelationTemplateMapService {
 
+    private final MessageRouterService messageRouterService;
+    private final MessageRelationService messageRelationService;
+    private final MessageTemplateService messageTemplateService;
     private final RelationTemplateMapDao relationTemplateMapDao;
+    private final MessageBaseTemplateDao messageBaseTemplateDao;
+    private final MessageTemplateGroupService messageTemplateGroupService;
+    private final MessageTemplateRouterService messageTemplateRouterService;
 
     @Override
     public Optional<String> queryByRelationId(Long relationId) {
@@ -61,4 +97,116 @@ public class RelationTemplateMapServiceImpl implements RelationTemplateMapServic
                 }).collect(Collectors.toList());
         relationTemplateMapDao.saveBatch(rows);
     }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void init(RelationTemplateMapInitParam param) {
+        List<MessageRelation> allRelations = messageRelationService.getAllRelations();
+        if (CollectionUtils.isNotEmpty(param.getRelationIds())) {
+            // 指定了需要创建并关联的relationId
+            allRelations = allRelations.stream()
+                    .filter(e -> param.getRelationIds().contains(e.getId()))
+                    .collect(Collectors.toList());
+        }
+        // relationId与templateId的map
+        Map<Long, Long> relationIdTemplateIdMap = allRelations.stream()
+                .collect(Collectors.toMap(MessageRelation::getId, MessageRelation::getTemplateId));
+        // 获取已经建立关联关系的relationId集合
+        Set<Long> mappedRelationIds = getAllOriginalRelationIds();
+        // 过滤掉已经建立关联关系的relationId
+        relationIdTemplateIdMap = relationIdTemplateIdMap.entrySet().stream()
+                .filter(e -> !mappedRelationIds.contains(e.getKey()))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        // 获取生效中的模板
+        Map<Long, MessageTemplate> messageTemplates = messageTemplateService.getAllTemplates().stream()
+                .collect(Collectors.toMap(MessageTemplate::getId, Function.identity()));
+        // 过滤掉relationId对应的消息模板已经删除的场景
+        relationIdTemplateIdMap = relationIdTemplateIdMap.entrySet().stream()
+                .filter(e -> messageTemplates.containsKey(e.getValue()))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        // 获取真实有效且待建立关联关系的relationId对应的消息模板路由
+        Map<Long, List<MessageRouter>> messageRouters = messageRouterService.getRouterMapByRelationIds(
+                        Lists.newArrayList(relationIdTemplateIdMap.keySet())).stream()
+                .collect(Collectors.groupingBy(MessageRouter::getRelationId));
+        // 转化为新模板的数据模型wrapper
+        List<CreateNewTemplateAndMapWrapper> wrappers = relationIdTemplateIdMap.entrySet().stream()
+                .map(e -> convert(e.getKey(), messageTemplates.get(e.getValue()), messageRouters.get(e.getKey())))
+                .collect(Collectors.toList());
+        // 批量插入
+        messageBaseTemplateDao.saveBatch(wrappers.stream()
+                .map(CreateNewTemplateAndMapWrapper::getBaseTemplate).collect(Collectors.toList()));
+        messageTemplateRouterService.batchInsert(wrappers.stream()
+                .filter(e -> CollectionUtils.isNotEmpty(e.getRouters()))
+                .flatMap(e -> e.getRouters().stream()).collect(Collectors.toList()));
+        List<String> groupNodes = Lists.newArrayList(param.getGroupNodeCode());
+        Map<String, List<String>> templateGroupNodeMap = wrappers.stream()
+                .map(CreateNewTemplateAndMapWrapper::getBaseTemplate)
+                .collect(Collectors.toMap(MessageBaseTemplate::getCode, e -> groupNodes));
+        messageTemplateGroupService.templateGroup(templateGroupNodeMap);
+        Map<Long, String> relationIdTemplateCodeMap = wrappers.stream()
+                .collect(Collectors
+                        .toMap(CreateNewTemplateAndMapWrapper::getRelationId, e -> e.getBaseTemplate().getCode()));
+        mapRelationAndTemplate(relationIdTemplateCodeMap);
+    }
+
+    private CreateNewTemplateAndMapWrapper convert(Long relationId, MessageTemplate template,
+                                                   List<MessageRouter> routers) {
+        MessageBaseTemplate baseTemplate = convert(template);
+        CreateNewTemplateAndMapWrapper wrapper = CreateNewTemplateAndMapWrapper.builder()
+                .baseTemplate(baseTemplate)
+                .relationId(relationId)
+                .build();
+        if (CollectionUtils.isNotEmpty(routers)) {
+            wrapper.setRouters(Lists.newArrayList(
+                    RawMessageRouterDTO.from(convert(routers), baseTemplate.getCode())));
+        }
+        return wrapper;
+    }
+
+    private MessageBaseTemplate convert(MessageTemplate srcTemplate) {
+        MessageBaseTemplate template = new MessageBaseTemplate();
+        template.setCode(UUIDUtil.uuidString());
+        template.setName("template_" + srcTemplate.getId());
+        template.setMsgCategory(MessageCategoryEnum.GENERAL_MESSAGE);
+        template.setTitle(srcTemplate.getTitle());
+        template.setContent(srcTemplate.getContent());
+        template.setCardContent(JSONObjectUtil.toJSONString(null));
+        template.setPushTerminal(JSONObjectUtil.toJSONString(PushTerminalEnum.values()));
+        template.setCreatorId(0L);
+        template.setUpdaterId(0L);
+        return template;
+    }
+
+    private MessageRouterButtonDTO convert(List<MessageRouter> routers) {
+        return MessageRouterButtonDTO.builder()
+                .style(Lists.newArrayList(ButtonStyleEnum.values()))
+                .desc("查看详情")
+                .category(RouterCategoryEnum.DETAIL)
+                .terminals(routers.stream().map(this::convert).collect(Collectors.toList()))
+                .build();
+    }
+
+    private MessageRouterTerminalDTO convert(MessageRouter router) {
+        return MessageRouterTerminalDTO.builder()
+                .url(router.getRouterUrl())
+                .terminalType(TerminalTypeEnum.codeOf(router.getRouterType().getCode()))
+                .build();
+    }
+
+    private Set<Long> getAllOriginalRelationIds() {
+        return relationTemplateMapDao.lambdaQuery()
+                .select(RelationTemplateMap::getOriginalRelationId)
+                .list().stream().map(RelationTemplateMap::getOriginalRelationId).collect(Collectors.toSet());
+    }
+
+    @Setter
+    @Getter
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    private static class CreateNewTemplateAndMapWrapper {
+        private Long relationId;
+        private MessageBaseTemplate baseTemplate;
+        private List<RawMessageRouterDTO> routers;
+    }
 }

msg-center-api/src/main/java/cn/axzo/msg/center/service/enums/TerminalTypeEnum.java

@@ -4,6 +4,8 @@ import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
+import java.util.Arrays;
+
 /**
  * @description
  *
@@ -45,4 +47,10 @@ public enum TerminalTypeEnum {
         }
         return WEB;
     }
+
+    public static TerminalTypeEnum codeOf(Integer code) {
+        return Arrays.stream(values())
+                .filter(e -> e.code.equals(code))
+                .findFirst().orElse(null);
+    }
 }

msg-center-domain/src/main/java/cn/axzo/msg/center/domain/entity/RelationTemplateMap.java

@@ -1,6 +1,6 @@
 package cn.axzo.msg.center.domain.entity;
 
-import cn.axzo.msg.center.domain.persistence.BaseEntity;
+import cn.axzo.msg.center.domain.persistence.BaseEntityExt;
 import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Getter;
@@ -16,7 +16,7 @@ import java.io.Serializable;
 @Setter
 @Getter
 @TableName("relation_template_map")
-public class RelationTemplateMap extends BaseEntity<RelationTemplateMap> implements Serializable {
+public class RelationTemplateMap extends BaseEntityExt<RelationTemplateMap> implements Serializable {
 
     private static final long serialVersionUID = 2716916154882729387L;
 

start/src/main/resources/bootstrap.yml

@@ -7,7 +7,7 @@ spring:
     nacos:
       config:
         #nacos 服务地址
-        server-addr: ${NACOS_HOST:dev-nacos.axzo.cn}:${NACOS_PORT:80}
+        server-addr: ${NACOS_HOST:https://dev-nacos.axzo.cn}:${NACOS_PORT:443}
         # 文件格式
         file-extension: yaml
         # 指定命名空间