Merge branch 'pro' of http://git.mokasz.com/liuwei/launch-webFlux-platform into pro

launch-admin/pom.xml

@@ -33,11 +33,11 @@
 
     <dependencies>
 
-<!--        <dependency>-->
-<!--            <groupId>redis.clients</groupId>-->
-<!--            <artifactId>jedis</artifactId>-->
-<!--            <version>2.9.0</version>-->
-<!--        </dependency>-->
+        <!--        <dependency>-->
+        <!--            <groupId>redis.clients</groupId>-->
+        <!--            <artifactId>jedis</artifactId>-->
+        <!--            <version>2.9.0</version>-->
+        <!--        </dependency>-->
 
         <!-- db -->
         <dependency>
@@ -56,12 +56,24 @@
             <artifactId>hutool-all</artifactId>
             <version>5.3.7</version>
         </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>1.2.83</version>
+        </dependency>
+        <dependency>
+            <groupId>com.plumelog</groupId>
+            <artifactId>plumelog-logback</artifactId>
+            <version>3.4.2</version>
+        </dependency>
+
         <!--单点登录 -->
-<!--        <dependency>-->
-<!--            <groupId>com.xuxueli</groupId>-->
-<!--            <artifactId>xxl-sso-core</artifactId>-->
-<!--            <version>1.1.1-SNAPSHOT</version>-->
-<!--        </dependency>-->
+        <!--        <dependency>-->
+        <!--            <groupId>com.xuxueli</groupId>-->
+        <!--            <artifactId>xxl-sso-core</artifactId>-->
+        <!--            <version>1.1.1-SNAPSHOT</version>-->
+        <!--        </dependency>-->
         <!--  r2dbc 连接池 -->
         <dependency>
             <groupId>io.r2dbc</groupId>
@@ -130,6 +142,40 @@
     <build>
         <plugins>
             <plugin>
+                <groupId>com.github.shalousun</groupId>
+                <artifactId>smart-doc-maven-plugin</artifactId>
+                <version>2.3.1</version>
+                <!--建议用最新版本-->
+                <configuration>
+                    <!--指定生成文档的使用的配置文件,配置文件放在自己的项目中-->
+                    <configFile>./src/main/resources/smart-doc.json</configFile>
+                    <!--指定项目名称-->
+                    <projectName>SmartDoc-Demo</projectName>
+                    <!--smart-doc实现自动分析依赖树加载第三方依赖的源码，如果一些框架依赖库加载不到导致报错，这时请使用excludes排除掉-->
+                    <excludes>
+                        <!--格式为：groupId:artifactId;参考如下-->
+                        <!--1.0.7版本开始你还可以用正则匹配排除,如：poi.* -->
+                        <exclude>com.alibaba:fastjson</exclude>
+                    </excludes>
+                    <!--自1.0.8版本开始，插件提供includes支持-->
+                    <!--smart-doc能自动分析依赖树加载所有依赖源码，原则上会影响文档构建效率，因此你可以使用includes来让插件加载你配置的组件-->
+                    <includes>
+                        <!--格式为：groupId:artifactId;参考如下-->
+                        <include>com.launch.system.controller.tool.product</include>
+                    </includes>
+                </configuration>
+                <executions>
+                    <execution>
+                        <!--如果不需要在执行编译时启动smart-doc，则将phase注释掉-->
+                        <!--<phase>compile</phase>-->
+                        <goals>
+                            <!--smart-doc提供了html、openapi、markdown等goal，可按需配置-->
+                            <!--<goal>html</goal>-->
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.5.1</version>

launch-admin/src/main/java/com/webflux/launchadmin/config/PlumeLogilterConfig.java

@@ -0,0 +1,30 @@
+package com.webflux.launchadmin.config;
+
+import com.webflux.launchadmin.filter.TraceIdFilter;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.annotation.Order;
+import org.springframework.web.server.WebFilter;
+
+/**
+ * @author wangcheng
+ * @date 2024年07月16日 14:41
+ */
+@Order(Integer.MIN_VALUE)
+@Configuration
+public class PlumeLogilterConfig {
+
+    // @Bean
+    // public FilterRegistrationBean<WebFilter> filterRegistrationBean1() {
+    //     FilterRegistrationBean<WebFilter> filterRegistrationBean = new FilterRegistrationBean<>();
+    //     filterRegistrationBean.setFilter(initCustomFilter());
+    //     filterRegistrationBean.setUrlPatterns(Collections.singletonList("/*") );
+    //     filterRegistrationBean.setOrder(Integer.MIN_VALUE);
+    //     return filterRegistrationBean;
+    // }
+
+    @Bean
+    public WebFilter initCustomFilter() {
+        return new TraceIdFilter();
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/filter/TraceIdFilter.java

@@ -0,0 +1,33 @@
+package com.webflux.launchadmin.filter;
+
+import com.plumelog.core.TraceId;
+import lombok.SneakyThrows;
+import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.stereotype.Component;
+import org.springframework.web.server.ServerWebExchange;
+import org.springframework.web.server.WebFilter;
+import org.springframework.web.server.WebFilterChain;
+import reactor.core.publisher.Mono;
+
+/**
+ * @author wangcheng
+ * @date 2024年07月16日 14:48
+ */
+@Component
+public class TraceIdFilter implements WebFilter {
+    @SneakyThrows
+    @Override
+    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
+        try {
+            ServerHttpRequest request = exchange.getRequest();
+            String traceId = request.getQueryParams().getFirst("traceId");
+            if (traceId == null || traceId.isEmpty()) {
+                TraceId.set();
+            } else {
+                TraceId.logTraceID.set(traceId);
+            }
+        } finally {
+            return chain.filter(exchange);
+        }
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/TempAllController/TempAll0Controller.java

@@ -0,0 +1,101 @@
+package com.webflux.launchadmin.mysql.controller.TempAllController;
+
+
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+import com.webflux.launchadmin.mysql.entity.takeaway.Takeaway;
+import com.webflux.launchadmin.mysql.entity.tempAll.TempAll;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoInfo;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoNext;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.DeleteRes;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.TempAllRsNext;
+import com.webflux.launchadmin.mysql.service.tempAll.TempAllServicesInterface;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import jakarta.validation.constraints.NotNull;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+
+/**
+ * @author lw12420
+ * @date 2024/07/17
+ */
+@RestController
+@RequestMapping("in/temp1")
+public class TempAll0Controller {
+    //Todo 直接复制 这是模版禁止修改
+    @Resource
+    private TempAllServicesInterface tempAllServicesInterface;
+
+
+    private static final Integer type=0;
+    /**
+     * 下拉
+     *
+     * @param name 默认值 ""
+     * @return {@link Mono}<{@link RStatus}<{@link Takeaway}>>
+     */
+    @GetMapping("getSltList")
+    public  Mono<RStatus<List<TempAllRsNext>>> getSelectList(@RequestParam("name") String name){
+        //Todo 不需要调整可以通用
+        return   tempAllServicesInterface.getSelectList(name,type);
+
+    }
+    /**
+     * 列表查询
+     * @param name 名称 默认空字符串
+     * @param page
+     * @param size
+     * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link GroupUsers}>>>
+     */
+    @GetMapping("page")
+    public Mono<RStatus<Paged<TempAllRsNext>>> page(@RequestParam("name") String name,
+                                                  @RequestParam("page")int page,
+                                                  @RequestParam("size")int size){
+        //FixMe 可能需要调整 jsonContent 内容
+        //  TempAllRsNext 替换
+        return tempAllServicesInterface.pageCommon(name, page, size,type);
+    }
+
+
+    /**
+     * 通过id删除 支持批量 案例：././deleteById/1,2,3
+     * @param id
+     * @return {@link Mono}<{@link RStatus}<{@link Long}>>
+     */
+    @DeleteMapping("deleteById/{id}")
+    public Mono<RStatus<DeleteRes<Long>>> deleteById(@PathVariable("id") @NotNull Long[]  id) {
+        // Todo 不需要调整
+        return  tempAllServicesInterface.deleteById(id);
+
+    }
+
+    /**
+     * 新增或修改 （groupUsersId校验是否有值）
+     * @param request
+     * @return {@link Mono}<{@link RStatus}<{@link GroupUsers}>>
+     */
+    @PostMapping("saveOrUpdate")
+    public Mono<RStatus<TempAll>> saveOrUpdate(@RequestBody TempAllDtoNext request) {
+        //FixMe 可能需要调整 jsonContent 内容
+        // TempAllDtoNext 替换
+        return  tempAllServicesInterface.saveOrUpdate(request,type);
+    }
+
+    /**
+     * 回显通过id查询
+     * @param id
+     * @return {@link Mono}<{@link RStatus}<{@link GroupUsers}>>
+     */
+    @GetMapping("getById/{id}")
+    public Mono<RStatus<TempAllDtoInfo>> getById(@PathVariable("id") @NotNull Long  id) {
+        //FixMe 可能需要调整 jsonContent 内容
+        // TempAllDtoInfo 替换
+        return  tempAllServicesInterface.getById(id);
+    }
+
+
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/TempAllController/TempAll1Controller.java

@@ -0,0 +1,101 @@
+package com.webflux.launchadmin.mysql.controller.TempAllController;
+
+
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+import com.webflux.launchadmin.mysql.entity.takeaway.Takeaway;
+import com.webflux.launchadmin.mysql.entity.tempAll.TempAll;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoInfo;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoNext;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.type1.TempAllDtoInfo1;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.type1.TempAllDtoNext1;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.DeleteRes;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.TempAllRsNext;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.Type1.TempAllRsNext1;
+import com.webflux.launchadmin.mysql.service.tempAll.TempAllServicesInterface;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import jakarta.validation.constraints.NotNull;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+
+/**
+ * @author lw12420
+ * @date 2024/07/17
+ */
+@RestController
+@RequestMapping("in/temp")
+public class TempAll1Controller {
+    //Todo 直接复制 这是模版禁止修改
+    @Resource
+    private TempAllServicesInterface tempAllServicesInterface;
+
+
+    private static final Integer type=1; //Todo
+    /**
+     * 下拉
+     *
+     * @param name 默认值 ""
+     * @return {@link Mono}<{@link RStatus}<{@link Takeaway}>>
+     */
+    @GetMapping("getSltList")
+    public  Mono<RStatus<List<TempAllRsNext>>> getSelectList(@RequestParam("name") String name){
+        //Todo 不需要调整可以通用
+        return   tempAllServicesInterface.getSelectList(name,type);
+    }
+    /**
+     * 列表查询
+     * @param name 名称 默认空字符串
+     * @param page
+     * @param size
+     * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link GroupUsers}>>>
+     */
+    @GetMapping("page")
+    public Mono<RStatus<Paged<TempAllRsNext1>>> page(@RequestParam("name") String name,
+                                                     @RequestParam("page")int page,
+                                                     @RequestParam("size")int size){
+        //FixMe 可能需要调整 jsonContent 内容
+        //  TempAllRsNext 替换
+        return tempAllServicesInterface.pageCommon1(name, page, size,type);
+    }
+
+
+    /**
+     * 通过id删除 支持批量 案例：././deleteById/1,2,3
+     * @param id
+     * @return {@link Mono}<{@link RStatus}<{@link Long}>>
+     */
+    @DeleteMapping("deleteById/{id}")
+    public Mono<RStatus<DeleteRes<Long>>> deleteById(@PathVariable("id") @NotNull Long[]  id) {
+        // Todo 不需要调整
+        return  tempAllServicesInterface.deleteById(id);
+
+    }
+
+    /**
+     * 新增或修改 （groupUsersId校验是否有值）
+     * @param request
+     * @return {@link Mono}<{@link RStatus}<{@link GroupUsers}>>
+     */
+    @PostMapping("saveOrUpdate")
+    public Mono<RStatus<TempAll>> saveOrUpdate(@RequestBody TempAllDtoNext1 request) {
+        //FixMe 可能需要调整 jsonContent 内容
+        // TempAllDtoNext 替换
+        return  tempAllServicesInterface.saveOrUpdate1(request,type);
+    }
+
+    /**
+     * 回显通过id查询
+     * @param id
+     * @return {@link Mono}<{@link RStatus}<{@link GroupUsers}>>
+     */
+    @GetMapping("getById/{id}")
+    public Mono<RStatus<TempAllDtoInfo1>> getById(@PathVariable("id") @NotNull Long  id) {
+        //FixMe 可能需要调整 jsonContent 内容
+        // TempAllDtoInfo 替换
+        return  tempAllServicesInterface.getById1(id);
+    }
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/TempAllController/request/PageRequset.java

@@ -0,0 +1,12 @@
+package com.webflux.launchadmin.mysql.controller.TempAllController.request;
+
+import lombok.Data;
+@Data
+public class PageRequset {
+    /**
+     * 名称 默认空字符串
+     */
+    private String name;
+    private int page;
+    private int size;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/groupUsers/GroupUsersController.java

@@ -0,0 +1,75 @@
+package com.webflux.launchadmin.mysql.controller.groupUsers;
+
+import com.webflux.launchadmin.mysql.controller.groupUsers.res.DeleteRes;
+import com.webflux.launchadmin.mysql.controller.groupUsers.res.GroupUsersRes;
+import com.webflux.launchadmin.mysql.entity.groupUsers.Dto.GroupUsersDto;
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+import com.webflux.launchadmin.mysql.service.groupUsers.GroupUsersServiceInterface;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import jakarta.validation.constraints.NotNull;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+
+/**
+ * 群用户
+ * @author lw12420
+ * @date 2024/07/10
+ */
+@RestController
+@RequestMapping("in/groupUsers")
+public class GroupUsersController {
+
+    @Resource
+    private GroupUsersServiceInterface groupUsersServiceInterfave;
+
+    /**
+     * 列表查询
+     * @param type
+     * @param page
+     * @param size
+     * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link GroupUsers}>>>
+     */
+    @GetMapping("page")
+    public Mono<RStatus<Paged<GroupUsersRes>>> page(@RequestParam("type") Integer type,
+                                                 @RequestParam("page")int page,
+                                                 @RequestParam("size")int size){
+       return groupUsersServiceInterfave.page(type, page, size);
+    }
+
+
+    /**
+     * 通过id删除 支持批量 案例：././deleteById/1,2,3
+     * @param groupUsersId
+     * @return {@link Mono}<{@link RStatus}<{@link Long}>>
+     */
+    @DeleteMapping("deleteById/{groupUsersId}")
+    public Mono<RStatus<DeleteRes>> deletePosterById(@PathVariable("groupUsersId") @NotNull Long[]  groupUsersId) {
+        return  groupUsersServiceInterfave.deletePosterById(groupUsersId);
+
+    }
+
+    /**
+     * 新增或修改 （groupUsersId校验是否有值）
+     * @param groupUsersDto
+     * @return {@link Mono}<{@link RStatus}<{@link GroupUsers}>>
+     */
+    @PostMapping("saveOrUpdate")
+    public Mono<RStatus<GroupUsers>> saveOrUpdate(@RequestBody GroupUsersDto groupUsersDto) {
+        return  groupUsersServiceInterfave.saveOrUpdate(groupUsersDto);
+    }
+
+    /**
+     * 回显通过id查询
+     * @param groupUsersId
+     * @return {@link Mono}<{@link RStatus}<{@link GroupUsers}>>
+     */
+    @GetMapping("getById/{groupUsersId}")
+    public Mono<RStatus<GroupUsers>> getById(@PathVariable("groupUsersId") @NotNull Long  groupUsersId) {
+        return  groupUsersServiceInterfave.getById(groupUsersId);
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/groupUsers/res/DeleteRes.java

@@ -0,0 +1,12 @@
+package com.webflux.launchadmin.mysql.controller.groupUsers.res;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+public class DeleteRes<T> {
+    private List<T> Ids;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/groupUsers/res/GroupUsersRes.java

@@ -0,0 +1,40 @@
+package com.webflux.launchadmin.mysql.controller.groupUsers.res;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.ZonedDateTime;
+
+@Data
+public class GroupUsersRes {
+    /**
+     * id 修改必填
+     */
+    private Long groupUsersId;//id
+    /**
+     * 头像
+     */
+    private  String groupUsersHead;
+    /**
+     * 昵称
+     */
+    private String groupUsersNickname;
+
+    /**
+     * 分類
+     */
+    private Integer groupUsersType;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime createdAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime updatedAt;
+
+
+    private String groupUsersName;
+
+    private  String createUser;
+
+    private   String createId;
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/otherServices/OtherServicesController.java

@@ -0,0 +1,29 @@
+package com.webflux.launchadmin.mysql.controller.otherServices;
+
+import com.webflux.launchadmin.mysql.controller.otherServices.res.ByCodeGetImportDomainRes;
+import com.webflux.launchadmin.mysql.controller.planNew.res.PlanNewAllRs;
+import com.webflux.launchadmin.mysql.service.otherServices.OtherServicesInterface;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import jakarta.validation.constraints.NotNull;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Mono;
+
+@RestController
+@RequestMapping("out/otherServices")
+public class OtherServicesController {
+
+    @Resource
+    private OtherServicesInterface otherServicesInterface;
+
+    /**
+     * 【ID1015681】
+     * 入口链接对外接口
+     * @param code
+     * @return {@link Mono}<{@link RStatus}<{@link PlanNewAllRs}>>
+     */
+    @GetMapping("byCodeGetImportDomain")
+    public Mono<RStatus<ByCodeGetImportDomainRes>> byCodeGetImportDomain(@RequestParam("code")  @NotNull String code){
+        return otherServicesInterface.byCodeGetImportDomain(code);
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/otherServices/res/ByCodeGetImportDomainRes.java

@@ -0,0 +1,8 @@
+package com.webflux.launchadmin.mysql.controller.otherServices.res;
+
+import lombok.Data;
+
+@Data
+public class ByCodeGetImportDomainRes {
+    String domain;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/PlanNewCommonController.java

@@ -0,0 +1,331 @@
+package com.webflux.launchadmin.mysql.controller.planNew;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.webflux.launchadmin.config.BaseContextHandler;
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.controller.planNew.req.PlanReq;
+import com.webflux.launchadmin.mysql.controller.planNew.req.ServiceGroupSettingItemRequest;
+import com.webflux.launchadmin.mysql.controller.planNew.res.PlanNewAllRs;
+import com.webflux.launchadmin.mysql.entity.planNew.PlanNew;
+import com.webflux.launchadmin.mysql.entity.planNew.PlanNewBackgroupPoster;
+import com.webflux.launchadmin.mysql.entity.planNew.PlanNewCommon;
+import com.webflux.launchadmin.mysql.entity.planNew.Poster;
+import com.webflux.launchadmin.mysql.service.planNew.goGenerate.GoGenerateService;
+import com.webflux.launchadmin.mysql.service.planNew.structure.GoRequest;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import jakarta.validation.constraints.NotNull;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+
+/**
+ * 裂变计划通用配置列表
+ * @date 2024/07/10
+ */
+@RestController
+@RequestMapping("in/planNewCommon")
+public class PlanNewCommonController {
+    @Resource
+    private R2dbcEntityTemplate template;
+
+    @Resource
+    private GoGenerateService goGenerateService;
+
+
+    /**
+     * 保存计划
+     * @param saveRequest
+     * @return {@link Mono}<{@link RStatus}<{@link String}>>
+     */
+    @PostMapping("savePlan")
+    public Mono<RStatus<String>> savePlan(@RequestBody PlanReq saveRequest) {
+
+            if (StrUtil.isBlank(saveRequest.getPlanNewId())) {
+                // 新增
+                return this.savePlanCommon(saveRequest);
+            } else {
+                // 编辑
+                return this.updatePlanCommon(saveRequest);
+            }
+    }
+
+    /**
+     * 新增计划
+     *
+     * @param saveRequest
+     * @return {@link Mono}<{@link RStatus}<{@link String}>>
+     */
+    private Mono<RStatus<String>> savePlanCommon(PlanReq saveRequest) {
+        String userName = BaseContextHandler.getUserName();
+        String userId = BaseContextHandler.getUserId();
+        saveRequest.setCode(IdUtil.fastSimpleUUID());
+        Mono<String> previewUrl = this.getPreviewUrl(saveRequest);
+        Mono<PlanNewCommon> insert = previewUrl.flatMap(f -> {
+            PlanNewCommon plan = new PlanNewCommon(
+                    IdUtil.fastSimpleUUID(),
+                    saveRequest.getName(),
+                    saveRequest.getCode(),
+                    saveRequest.getType(),
+                    saveRequest.getGroupId(),
+                    saveRequest.getPosterTemplateId(),
+                    saveRequest.getImportDomain(),
+                    f,
+                    saveRequest.getConfigJson(),
+                    userName,
+                    userId,
+                    userName,
+                    userId,
+                    ZonedDateTime.now(),
+                    ZonedDateTime.now()
+            );
+            return template.insert(plan);
+        });
+        Mono<String> map = insert.flatMap(f -> {
+            Flux<PlanNewBackgroupPoster> just = this.getPlanNewBackGroupPosterFlux(saveRequest, f);
+            return Mono.zip(this.batchInsert(just), Mono.just(f)).flatMap(ff -> {
+                PlanNewCommon t2 = ff.getT2();
+                return Mono.just(t2.id());
+            });
+        });
+        return RStatus.success(map);
+    }
+
+    /**
+     * 编辑计划
+     */
+    private Mono<RStatus<String>> updatePlanCommon(PlanReq updateRequest) {
+        String userName = BaseContextHandler.getUserName();
+        String userId = BaseContextHandler.getUserId();
+        Mono<PlanNewCommon> planNewCommonMono = template.selectOne(Query.query(Criteria.where("id").is(updateRequest.getPlanNewId())), PlanNewCommon.class);
+        Mono<String> previewUrl = this.getPreviewUrl(updateRequest);
+        Mono<PlanNewCommon> updateMono = Mono.zip(previewUrl, planNewCommonMono).flatMap(f -> {
+            PlanNewCommon old = f.getT2();
+            PlanNewCommon plan = new PlanNewCommon(
+                    old.id(),
+                    updateRequest.getName(),
+                    old.code(),
+                    updateRequest.getType(),
+                    updateRequest.getGroupId(),
+                    updateRequest.getPosterTemplateId(),
+                    updateRequest.getImportDomain(),
+                    f.getT1(),
+                    updateRequest.getConfigJson(),
+                    old.createUser(),
+                    old.createId(),
+                    userName,
+                    userId,
+                    old.createdAt(),
+                    ZonedDateTime.now()
+            );
+            return Mono.just(plan);
+        }).flatMap(template::update);
+        Mono<String> map = updateMono.flatMap(f1 -> {
+            Mono<Long> ml = template.delete(Query.query(Criteria.where("plan_new_id").is(f1.id())), PlanNewBackgroupPoster.class);
+            return Mono.zip(Mono.just(f1), ml).flatMap(ff -> Mono.just(f1));
+        }).flatMap(f -> {
+            Flux<PlanNewBackgroupPoster> just = this.getPlanNewBackGroupPosterFlux(updateRequest, f);
+            return Mono.zip(this.batchInsert(just), Mono.just(f)).flatMap(ff -> {
+                PlanNewCommon t2 = ff.getT2();
+                return Mono.just(t2.id());
+            });
+        });
+        return RStatus.success(map);
+    }
+
+    /**
+     * 生成预览url
+     */
+    private Mono<String> getPreviewUrl(PlanReq planReq) {
+        return template
+                .select(Query.query(Criteria.where("poster_template_id").is(planReq.getPosterTemplateId()))
+                        .sort(Sort.by(Sort.Order.asc("created_at"))), Poster.class)
+                .switchIfEmpty(Mono.error(new BaseException("未查询到海报模版")))
+                .onErrorResume(throwable -> Mono.error(new Exception("未查询到海报模版")))
+                .collectList().flatMap(f -> {
+                    Poster poster = f.getFirst();
+                    String posterTemplate = poster.posterTemplate();
+                    JSONObject jsonObject = JSONUtil.parseObj(posterTemplate);
+                    GoRequest goRequest = new GoRequest();
+                    BeanUtil.copyProperties(jsonObject, goRequest);
+                    ServiceGroupSettingItemRequest serviceGroupSettingItemRequest = planReq.getBackgroupFxSetting().getFirst();
+                    return goGenerateService.saveAndUpdatePlanGenerateImage0(goRequest,
+                            goGenerateService.setCusqrcodeSetV(goRequest),// getStringBuilderMono(goRequest),
+                            serviceGroupSettingItemRequest,
+                            planReq);
+                });
+    }
+
+    private Flux<PlanNewBackgroupPoster> getPlanNewBackGroupPosterFlux(PlanReq saveRequest, PlanNewCommon f) {
+        ArrayList<PlanNewBackgroupPoster> listeningPlanNewBackGroupPosters = new ArrayList<>();
+        List<ServiceGroupSettingItemRequest> backGroupFxSetting = saveRequest.getBackgroupFxSetting();
+        backGroupFxSetting.forEach(fx -> {
+            PlanNewBackgroupPoster listeningPlanNewBackgroupPoster = fxBackGroupSettingsSave(fx, f.id(), 1);
+            listeningPlanNewBackGroupPosters.add(listeningPlanNewBackgroupPoster);
+        });
+        if (CollUtil.isNotEmpty(saveRequest.getBackgroupQsSetting())) {
+            List<ServiceGroupSettingItemRequest> backGroupQsSetting = saveRequest.getBackgroupQsSetting();
+            backGroupQsSetting.forEach(fx -> {
+                PlanNewBackgroupPoster listeningPlanNewBackGroupPoster = fxBackGroupSettingsSave(fx, f.id(), 2);
+                listeningPlanNewBackGroupPosters.add(listeningPlanNewBackGroupPoster);
+            });
+        }
+        return Flux.fromIterable(listeningPlanNewBackGroupPosters);
+    }
+
+    private PlanNewBackgroupPoster fxBackGroupSettingsSave(ServiceGroupSettingItemRequest request, String planNewId, Integer qsOrFx) {
+        return new PlanNewBackgroupPoster(null,
+                request.getAudioId(),
+                request.getGroupId(),
+                request.getImage(),
+                request.getKefu(),
+                request.getLimitTime(),
+                request.getLimitTimeRemark(),
+                request.getStatus(),
+                request.getIndex(),
+                request.getServiceGroupId(),
+                request.getServiceGroupType(),
+                qsOrFx,
+                ZonedDateTime.now(),
+                null,
+                null,
+                planNewId, null, null);
+
+    }
+
+    private Mono<List<PlanNewBackgroupPoster>> batchInsert(Flux<PlanNewBackgroupPoster> entities) {
+        return entities.flatMap(entity -> template
+                .insert(PlanNewBackgroupPoster.class).using(entity)).collectList();
+    }
+
+
+    /**
+     * 获取计划详情
+     * @param type
+     * @param planId
+     * @return {@link Mono}<{@link RStatus}<{@link PlanNewCommon}>>
+     */
+    @GetMapping("getPlanInfo/{type}/{planId}")
+    public Mono<RStatus<PlanNewCommon>> planNewInfo(@PathVariable("type") @NotNull Integer type, @PathVariable("planId") @NotNull String planId) {
+
+            // 交友计划
+            Mono<PlanNewCommon> planNewCommonMono = template.selectOne(Query.query(Criteria.where("id").is(planId)), PlanNewCommon.class)
+                    .switchIfEmpty(Mono.error(new BaseException("计划id异常")))
+                    .onErrorResume(throwable -> Mono.error(new Exception("计划id异常")));
+            return RStatus.success(planNewCommonMono);
+
+    }
+
+
+    /**
+     * 复制计划
+     * @param type
+     * @param planId
+     * @return {@link Mono}<{@link RStatus}<{@link String}>>
+     */
+    @GetMapping("copyById/{type}/{planId}")
+    public Mono<RStatus<String>> copyById(@PathVariable("type") @NotNull Integer type, @PathVariable("planId") @NotNull String planId) {
+
+            // 交友计划
+            String userName = BaseContextHandler.getUserName();
+            String userId = BaseContextHandler.getUserId();
+            Mono<PlanNewCommon> planNewCommonMono = template.selectOne(Query.query(Criteria.where("id").is(planId)), PlanNewCommon.class)
+                    .flatMap(f -> {
+                        PlanNewCommon planNewCommon = new PlanNewCommon(
+                                IdUtil.fastSimpleUUID(),
+                                f.name(),
+                                IdUtil.fastSimpleUUID(),
+                                f.type(),
+                                f.groupId(),
+                                f.posterTemplateId(),
+                                f.importDomain(),
+                                f.previewUrl(),
+                                f.configJson(),
+                                userName,
+                                userId,
+                                userName,
+                                userId,
+                                ZonedDateTime.now(),
+                                ZonedDateTime.now()
+                        );
+                        return template.insert(planNewCommon);
+                    });
+            Mono<List<PlanNewBackgroupPoster>> poster = template.select(Query.query(Criteria.where("plan_new_id")
+                            .is(planId)), PlanNewBackgroupPoster.class)
+                    .collectList();
+            Mono<String> stringMono = Mono.zip(planNewCommonMono, poster).flatMap(f -> {
+                PlanNewCommon t1 = f.getT1();
+                List<PlanNewBackgroupPoster> t2 = f.getT2();
+                if (!t2.isEmpty()) {
+                    List<PlanNewBackgroupPoster> collect = t2.stream().map(request -> new PlanNewBackgroupPoster(null,
+                            request.audioId(),
+                            request.groupId(),
+                            request.image(),
+                            request.kefu(),
+                            request.limitTime(),
+                            request.limitTimeRemark(),
+                            request.status(),
+                            request.index(),
+                            request.serviceGroupId(),
+                            request.serviceGroupType(),
+                            request.qsOrFx(),
+                            ZonedDateTime.now(),
+                            null,
+                            null,
+                            t1.id(),
+                            request.generateImagesJson(),
+                            request.generateImagesUrl())).collect(Collectors.toList());
+                    Mono<List<PlanNewBackgroupPoster>> listMono =
+                            Flux.fromIterable(collect).flatMap(entity -> template.insert(entity)).collectList();
+                    return Mono.zip(Mono.just(t1), listMono).flatMap(ff -> {
+                        PlanNewCommon t11 = ff.getT1();
+                        return Mono.just(t11.id());
+                    });
+                } else {
+                    return Mono.just(t1.id());
+                }
+            });
+            return RStatus.success(stringMono);
+
+    }
+
+
+    /**
+     * 删除计划
+     * @param type
+     * @param planId
+     * @return {@link Mono}<{@link RStatus}<{@link Long}>>
+     */
+    @DeleteMapping("deleteById/{type}/{planId}")
+    public Mono<RStatus<Long>> deleteById(@PathVariable("type") @NotNull Integer type, @PathVariable("planId") @NotNull String planId) {
+       
+            // 交友计划
+            Query plan = Query.query(Criteria.where("id").is(planId));
+            Mono<Long> planNewCommon = template.delete(plan, PlanNewCommon.class)
+                    .switchIfEmpty(Mono.error(new BaseException("计划id异常")))
+                    .onErrorResume(throwable -> Mono.error(new Exception("删除计划 " + planId + "---" + type + "error:" + throwable.getMessage())));
+            Query planNewId = Query.query(Criteria.where("plan_new_id").is(planId));
+            Mono<Long> poster = template.count(planNewId, PlanNewBackgroupPoster.class).filter(f -> f > 0)
+                    .flatMap(f -> template.delete(planNewId, PlanNewBackgroupPoster.class))
+                    .switchIfEmpty(Mono.just(0L));
+            Mono<Long> longMono = Mono.zip(poster, planNewCommon).flatMap(f -> Mono.just(f.getT1()));
+            return RStatus.success(longMono);
+
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/PlanNewCommonOutController.java

@@ -0,0 +1,796 @@
+package com.webflux.launchadmin.mysql.controller.planNew;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.RandomUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.alibaba.fastjson.JSON;
+import com.plumelog.core.util.LogExceptionStackTrace;
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.controller.planNew.req.*;
+import com.webflux.launchadmin.mysql.controller.planNew.res.*;
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayH5Data;
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+import com.webflux.launchadmin.mysql.entity.listening.ListeningPlanNew;
+import com.webflux.launchadmin.mysql.entity.planNew.*;
+import com.webflux.launchadmin.mysql.entity.redis.RedisKey;
+import com.webflux.launchadmin.mysql.service.planNew.goGenerate.GoGenerateService;
+import com.webflux.launchadmin.mysql.service.planNew.ipAnalyze.IpAnalyzeServiceInterface;
+import com.webflux.launchadmin.mysql.service.planNew.structure.GoRequest;
+import com.webflux.launchadmin.mysql.service.planNew.structure.Item;
+import com.webflux.launchadmin.mysql.service.takeaway.TakeawayServicesInterface;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import jakarta.json.Json;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Mono;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.zip.GZIPOutputStream;
+
+/**
+ * 通用计划-H5
+ *
+ * @author: wangcheng
+ * @date: 2024/7/10 14:13
+ */
+@Slf4j
+@RestController
+@RequestMapping("out/planNewCommon")
+public class PlanNewCommonOutController {
+    @Resource
+    private R2dbcEntityTemplate template;
+    @Resource
+    private GoGenerateService goGenerateService;
+    @Resource
+    private ReactiveRedisTemplate<String, String> reactiveRedisTemplate;
+    @Resource
+    private RedisTemplate<String, String> redisTemplate;
+    @Resource
+    private TakeawayServicesInterface takeawayServicesInterface;
+    @Resource
+    private IpAnalyzeServiceInterface ipAnalyzeServiceInterface;
+    private static final ConcurrentHashMap<String, Integer> MAP = new ConcurrentHashMap<>();
+
+    @Scheduled(cron = "1 1 4 * * ?")
+    public void clearUserContextHashMap() {
+        log.info("清空计划-H5用户Map数据》》》》》》》》》》》》》》》》》》》》》》开始");
+        MAP.clear();
+        log.info("清空计划-H5用户Map数据》》》》》》》》》》》》》》》》》》》》》》 结束");
+    }
+
+    /**
+     * 通过 code 获取计划配置H5信息
+     *
+     * @param code
+     * @return {@link Mono}<{@link RStatus}<{@link PlanNewCommon}>>
+     */
+    @GetMapping("getPlanNewCommonH5")
+    public Mono<RStatus<byte[]>> getPlanNewCommonH5(@RequestParam("code") String code) {
+        Mono<PlanNewCommon> planNewCommonMono = template.selectOne(Query.query(Criteria.where("code").is(code)), PlanNewCommon.class)
+                .switchIfEmpty(Mono.error(new BaseException("计划code异常：" + ExceptionUtils.getStackTrace(new Exception()))))
+                .onErrorResume(throwable -> Mono.error(new Exception(LogExceptionStackTrace.erroStackTrace(throwable).toString())));
+        Mono<PlanNewCommonRes> resMono = planNewCommonMono.flatMap(f -> {
+            // 群成员
+            Mono<List<GroupUserRes>> groupUserResMono = Mono.just(new ArrayList<>());
+            // 群封面
+            Mono<List<Image>> imageMono = template.select(Query.query(Criteria.where("type").is(1)
+                            .and("group_type_id").is(f.groupId())
+                            .and("deleted_at").isNull()), Image.class)
+                    .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage() + "2"))).collectList();
+            // 群名称
+            Mono<List<Material>> textMono = template.select(Query.query(Criteria.where("type").is(4)
+                            .and("deleted_at").isNull()
+                            .and("group_type_id").is(f.groupId())), Material.class)
+                    .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage() + "3"))).collectList();
+            if (3 == f.type()) {
+                // 交友裂变, 需要群成员
+                Mono<List<GroupUsers>> groupUsersMono = template.select(Query.query(Criteria.where("group_users_type").is(f.groupId())).limit(14), GroupUsers.class)
+                        .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage() + "4"))).collectList();
+                groupUserResMono = groupUsersMono.flatMap(groupUsers -> {
+                    List<GroupUserRes> groupUserResList = groupUsers.stream().map(groupUsers1 -> {
+                        GroupUserRes groupUserRes = new GroupUserRes();
+                        groupUserRes.setUserHead(groupUsers1.groupUsersHead());
+                        groupUserRes.setUserNickname(groupUsers1.groupUsersNickname());
+                        return groupUserRes;
+                    }).collect(Collectors.toList());
+                    return Mono.just(groupUserResList);
+                });
+            }
+            return Mono.zip(Mono.just(f), groupUserResMono, imageMono, textMono).flatMap(tuple -> {
+                PlanNewCommon plan = tuple.getT1();
+                PlanNewCommonRes res = new PlanNewCommonRes();
+                res.setCode(plan.code());
+                res.setType(plan.type());
+                res.setName(plan.name());
+                res.setGroupId(plan.groupId());
+                res.setPosterTemplateId(plan.posterTemplateId());
+                res.setImportDomain(plan.importDomain());
+                res.setConfigJson(plan.configJson());
+                res.setGroupUserList(tuple.getT2());
+                List<H5ImageAndText> h5ImageAndTextList = new ArrayList<>();
+                H5ImageAndText h5ImageAndText = new H5ImageAndText();
+                List<Image> imageList = tuple.getT3();
+                if (!imageList.isEmpty()) {
+                    Image image = imageList.get(RandomUtil.randomInt(0, imageList.size()));
+                    h5ImageAndText.setImage(image.image());
+                }
+
+                List<Material> materialList = tuple.getT4();
+                if (!materialList.isEmpty()) {
+                    Material material = materialList.get(RandomUtil.randomInt(0, materialList.size()));
+                    h5ImageAndText.setName(material.content());
+                    h5ImageAndText.setRemark(material.remark());
+                }
+                h5ImageAndTextList.add(h5ImageAndText);
+                res.setGroupImageAndTextList(h5ImageAndTextList);
+                return Mono.just(res);
+            });
+        });
+        // GZIP压缩
+        Mono<byte[]> res = resMono.flatMap(f -> Mono.just(Objects.requireNonNull(this.compressData(JSONUtil.toJsonStr(f)))));
+        return RStatus.success(res);
+    }
+
+    /**
+     * GZIP 压缩数据
+     */
+    private byte[] compressData(String data) {
+        try {
+            ByteArrayOutputStream stream = new ByteArrayOutputStream();
+            GZIPOutputStream gzipOS = new GZIPOutputStream(stream);
+            gzipOS.write(data.getBytes());
+            gzipOS.close();
+            return stream.toByteArray();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * 客服列表
+     *
+     * @param request
+     * @return {@link Mono}<{@link RStatus}<{@link DataListsKefu}>>
+     */
+    @PostMapping("kefuList")
+    public Mono<RStatus<byte[]>> kefuList(@RequestBody KefuRequest request) {
+        Mono<PlanNewCommon> code = template.selectOne(Query.query(Criteria.where("code").is(request.getCode())), PlanNewCommon.class)
+                .switchIfEmpty(Mono.error(new BaseException("code查询返回结构为空")))
+                .onErrorResume(throwable -> Mono.error(new Exception("通过code查询计划异常：：" + throwable.getMessage())));
+        Mono<DataListsKefu> dataListsKefuMono = code.flatMap(planNew -> {
+            Mono<List<Image>> image = template.select(Query.query(Criteria.where("type").is(5)
+                            .and("deleted_at").isNull()
+                            .and("group_type_id").is(planNew.groupId())), Image.class)
+                    .collectList()
+                    .switchIfEmpty(Mono.error(new BaseException(StrUtil.format("通过计划groupId:{}查询Image返回结构为空", planNew.groupId()))))
+                    .onErrorResume(throwable ->
+                            Mono.error(new Exception(StrUtil.format("通过计划groupId:{}查询Image返回结果error:{}", planNew.groupId(), throwable.getMessage()))));
+            Mono<List<Material>> text = template.select(Query.query(Criteria.where("type").is(11)
+                            .and("group_type_id").is(planNew.groupId())
+                            .and("deleted_at").isNull()), Material.class)
+                    .switchIfEmpty(Mono.error(new BaseException(StrUtil.format("通过计划groupId:{}查询Material返回结构为空", planNew.groupId()))))
+                    .onErrorResume(throwable ->
+                            Mono.error(new Exception(StrUtil.format("通过计划groupId:{}查询Material返回结果error:{}", planNew.groupId(), throwable.getMessage()))))
+                    .collectList();
+            Mono<List<H5ImageAndText>> arrayListMono = Mono.zip(Mono.just(planNew), image, text).flatMap(f -> {
+                // H5ImageAndText
+                // 群数量, 默认6
+                int integer = request.getPageShow() == null || request.getPageShow() <= 0 ? 6 : request.getPageShow();
+                List<Image> t3 = f.getT2();
+                List<Material> t4 = f.getT3();
+                if (t3.size() < integer || t4.size() < integer) {
+                    throw new BaseException("图片或文字素材小于计划设置数");
+                }
+                ArrayList<Long> listImg = new ArrayList<>();
+                ArrayList<Long> listTxt = new ArrayList<>();
+                List<H5ImageAndText> h5ImageAndTexts = new ArrayList<>();
+                IntStream.range(0, integer).forEach(i -> {
+                    H5ImageAndText h5ImageAndText = new H5ImageAndText();
+                    List<Image> collect = t3.stream().filter(fff -> !listImg.contains(fff.id())).toList();
+                    if (!collect.isEmpty()) {
+                        Image image1 = collect.get(RandomUtil.randomInt(0, collect.size()));
+                        listImg.add(image1.id());
+                        h5ImageAndText.setImage(image1.image());
+                    }
+                    List<Material> collect1 = t4.stream().filter(fff -> !listTxt.contains(fff.id())).toList();
+                    if (!collect1.isEmpty()) {
+                        Material material = collect1.get(RandomUtil.randomInt(0, collect1.size()));
+                        listTxt.add(material.id());
+                        h5ImageAndText.setName(material.content());
+                        h5ImageAndText.setRemark(material.remark());
+                    }
+                    h5ImageAndTexts.add(h5ImageAndText);
+                });
+                return Mono.just(h5ImageAndTexts);
+            });
+            Mono<List<BackgroupImageItem>> backgroupImageItem = Mono.just(List.of());
+            if (Objects.nonNull(request.getBackgroundGroupId()) && request.getBackgroundGroupId() > 0) {
+                backgroupImageItem = Mono.just(planNew)
+                        .filter(ft -> Objects.nonNull(request.getBackgroundGroupId()))
+                        .flatMap(plan -> template.select(Query.query(Criteria.where("group_id")
+                                .is(request.getBackgroundGroupId())), BackgroupImageItem.class).collectList())
+                        .switchIfEmpty(Mono.just(List.of()));
+            }
+
+            Mono<Audio> retAudioId = this.getAudio(request.getRetAudioId());
+            Mono<DataListsKefu> dataListsMono = Mono.zip(Mono.just(planNew), backgroupImageItem, retAudioId, arrayListMono).flatMap(f -> {
+                DataListsKefu dataLists = new DataListsKefu();
+                dataLists.setPlanNewCommon(f.getT1());
+                dataLists.setBaiduDot(request.getBaiduDot());
+                List<BackgroupImageItem> t2 = f.getT2();
+                if (!t2.isEmpty()) {
+                    List<String> collect = t2.stream().map(BackgroupImageItem::image).collect(Collectors.toList());
+                    dataLists.setShareQrurl(collect);
+                }
+                if (Objects.nonNull(f.getT3().id())) {
+                    dataLists.setRetAudio(f.getT3());
+                }
+                dataLists.setImages(f.getT4());
+                return Mono.just(dataLists);
+            });
+            return dataListsMono;
+        });
+        // GZIP压缩
+        Mono<byte[]> res = dataListsKefuMono.flatMap(f -> Mono.just(Objects.requireNonNull(this.compressData(JSONUtil.toJsonStr(f)))));
+        return RStatus.successList(res);
+    }
+
+    /**
+     * 查询domain
+     *
+     * @param request
+     * @return {@link Mono}<{@link RStatus}<{@link DomainSelectRes}>>
+     */
+    @PostMapping("domainSelect")
+    public Mono<RStatus<DomainSelectRes>> domainSelect(@RequestBody OutDomainRequest request) {
+        if (1 == request.getTypePlan()) {
+            // 加群裂变
+            return this.getPlanNew(request);
+        } else if (2 == request.getTypePlan()) {
+            // 听书裂变
+            return this.getListeningPlan(request);
+        } else {
+            // 交友裂变
+            return this.getFriendPlan(request);
+        }
+       // throw new BaseException("typePlan 类型错误");
+    }
+
+    /**
+     * 加群裂变
+     */
+    private Mono<RStatus<DomainSelectRes>> getPlanNew(OutDomainRequest request) {
+        Mono<PlanNew> code1 = template
+                .selectOne(Query.query(Criteria.where("code").is(request.getCode())), PlanNew.class)
+                .switchIfEmpty(Mono.error(new BaseException("计划code异常 返回结果为空")))
+                .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage())));
+        Mono<DomainSelectRes> domainSelectResMono1 = code1.flatMap(f -> {
+            Mono<String> stringMono;
+            if (f.transferPageBl() == 1 && Objects.nonNull(f.transferPageDomain())) {
+                stringMono = template.select(Query.query(Criteria
+                                .where("group_type_id").is(f.transferPageDomain())
+                                .and("status").is(1)
+                                .and("type").is(5)
+                                .and("deleted_at").isNull()), DomainSelect.class)
+                        .switchIfEmpty(Mono.error(new BaseException("transferPageDomain 域名查詢為空 group_type_id:::" + f.transferPageDomain())))
+                        .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage()))).collectList().flatMap(fff -> {
+                            if (!fff.isEmpty()) {
+                                DomainSelect domainSelect = fff.get(RandomUtil.randomInt(0, fff.size()));
+                                String string = RandomUtil.randomString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 6);
+                                String domain1 = domainSelect.domain();
+                                return Mono.just(string + "." + domain1);
+
+                            } else {
+                                throw new BaseException("transferPageDomain 中轉域名查詢為空 group_type_id:::" + f.transferPageDomain());
+                            }
+                        });
+            } else {
+                stringMono = Mono.just(" ");
+            }
+            Mono<String> stringMono1;
+            if (Objects.nonNull(f.backgroupDomain()) && !f.backgroupDomain().trim().isEmpty()) {
+                stringMono1 = template.select(Query.query(Criteria
+                                .where("group_type_id").is(f.backgroupDomain())
+                                .and("status").is(1)
+                                .and("type").is(4)
+                                .and("deleted_at").isNull()), DomainSelect.class)
+                        .switchIfEmpty(Mono.error(new BaseException("backgroupDomain 域名查询为空 group_type_id" + f.backgroupDomain())))
+                        .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage()))).collectList().flatMap(fff -> {
+                            if (!fff.isEmpty()) {
+                                DomainSelect domainSelect = fff.get(RandomUtil.randomInt(0, fff.size()));
+                                String string = RandomUtil.randomString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 6);
+                                String domain1 = domainSelect.domain();
+                                return Mono.just(string + "." + domain1);
+                            } else {
+                                throw new BaseException("backgroupDomain 背景域名查詢為空 group_type_id" + f.backgroupDomain());
+                            }
+                        });
+            } else {
+                stringMono1 = Mono.just(" ");
+            }
+            Mono<String> stringMono2 = template.select(Query.query(Criteria
+                            .where("group_type_id").is(f.landingPageDomain())
+                            .and("status").is(1)
+                            .and("type").is(request.getType())
+                            .and("deleted_at").isNull()), DomainSelect.class)
+                    .switchIfEmpty(Mono.error(new BaseException("查询domain 返回结果为空")))
+                    .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage()))).collectList().flatMap(fm -> {
+                        //  DomainSelectRes domainSelectRes = new DomainSelectRes();
+                        int i = RandomUtil.randomInt(0, fm.size());
+                        String domain = fm.get(i).domain();
+                        String string = RandomUtil.randomString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 6);
+                        return Mono.just(string + "." + domain);
+                    });
+            return Mono.zip(stringMono2, stringMono1, stringMono).flatMap(fff -> {
+                DomainSelectRes domainSelectRes = new DomainSelectRes();
+                domainSelectRes.setDomain(fff.getT1());
+                domainSelectRes.setPath("");
+                domainSelectRes.setTransferPageBl(f.transferPageBl());
+                domainSelectRes.setBackgroupDomain(fff.getT2());
+                domainSelectRes.setTransferPageDomain(fff.getT3());
+                domainSelectRes.setUnique(IdUtil.fastSimpleUUID());
+                return Mono.just(domainSelectRes);
+            });
+        });
+        return RStatus.success(domainSelectResMono1);
+    }
+
+    /**
+     * 听书裂变
+     */
+    private Mono<RStatus<DomainSelectRes>> getListeningPlan(OutDomainRequest request) {
+        Mono<ListeningPlanNew> code1 = template.selectOne(Query.query(Criteria.where("code").is(request.getCode())), ListeningPlanNew.class)
+                .switchIfEmpty(Mono.error(new BaseException("计划code异常 返回结果为空")))
+                .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage())));
+        Mono<DomainSelectRes> domainSelectResMono1 = code1.flatMap(f -> template.select(Query.query(Criteria
+                        .where("group_type_id").is(f.groupId())
+                        .and("status").is(1)
+                        .and("type").is(request.getType())
+                        .and("deleted_at").isNull()), DomainSelect.class)
+                .switchIfEmpty(Mono.error(new BaseException("查询domain 返回结果为空")))
+                .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage()))).collectList()
+                .flatMap(fm -> {
+                    DomainSelectRes domainSelectRes = new DomainSelectRes();
+                    int i = RandomUtil.randomInt(0, fm.size());
+                    String domain = fm.get(i).domain();
+                    String string = RandomUtil.randomString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 6);
+                    domainSelectRes.setDomain(string + "." + domain);
+                    domainSelectRes.setPath("");
+                    domainSelectRes.setUnique(IdUtil.fastSimpleUUID());
+                    return Mono.just(domainSelectRes);
+                }));
+        return RStatus.success(domainSelectResMono1);
+    }
+
+    /**
+     * 交友裂变
+     */
+    private Mono<RStatus<DomainSelectRes>> getFriendPlan(OutDomainRequest request) {
+        Mono<String> stringMono;
+        if (StrUtil.isBlank(request.getLandingPageDomain()) || request.getLandingPageDomain().trim().isEmpty()) {
+            stringMono = Mono.just(" ");
+        } else {
+            stringMono = template.select(Query.query(Criteria
+                            .where("group_type_id").is(request.getLandingPageDomain())
+                            .and("status").is(1)
+                            .and("deleted_at").isNull()
+                            .and("type").is(request.getType())), DomainSelect.class)
+                    .switchIfEmpty(Mono.error(new BaseException("查询domain 返回结果为空")))
+                    .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage())))
+                    .collectList().flatMap(fm -> {
+                        int i = RandomUtil.randomInt(0, fm.size());
+                        String domain = fm.get(i).domain();
+                        String string = RandomUtil.randomString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 6);
+                        return Mono.just(string + "." + domain);
+                    });
+        }
+        Mono<DomainSelectRes> res = stringMono.flatMap(fff -> {
+            DomainSelectRes domainSelectRes = new DomainSelectRes();
+            domainSelectRes.setDomain(fff);
+            domainSelectRes.setPath("");
+            domainSelectRes.setUnique(IdUtil.fastSimpleUUID());
+            return Mono.just(domainSelectRes);
+        });
+        return RStatus.success(res);
+    }
+
+    /**
+     * 查询落地页素材
+     *
+     * @param request
+     * @return {@link Mono}<{@link RStatus}<{@link PlanNewCommonMaterialRes}>>
+     */
+    @PostMapping("getCommonMaterial")
+    public Mono<RStatus<PlanNewCommonMaterialRes>> getCommonMaterial(@RequestBody PlanNewCommonMaterialReq request) {
+        Mono<PlanNewCommon> planNewCommonMono = template.selectOne(Query.query(Criteria.where("code").is(request.getCode())), PlanNewCommon.class)
+                .switchIfEmpty(Mono.error(new BaseException("计划code异常 返回结果为空")))
+                .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage())));
+        Mono<PlanNewCommonMaterialRes> materialResMono = planNewCommonMono.flatMap(plan -> {
+            // 群音频
+            Mono<Audio> groupAudio = this.getAudio(request.getAudioId());
+            // 返回音频
+            Mono<Audio> retAudio = this.getAudio(request.getRetAudioId());
+            // 返回广告
+            Mono<ReturnLoop> returnLoop;
+            if (Objects.isNull(request.getReturnLoopId()) || request.getReturnLoopId() <= 0) {
+                returnLoop = Mono.just(getReturnLoop());
+            } else {
+                returnLoop = template.selectOne(Query.query(Criteria.where("id").is(request.getReturnLoopId())
+                                .and("deleted_at").isNull()), ReturnLoop.class)
+                        .switchIfEmpty(Mono.just(getReturnLoop()))
+                        .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage() + "3")));
+            }
+            // 分享背景组
+            Mono<List<BackgroupImageItem>> backgroupImageItemMono;
+            if (Objects.isNull(request.getBackgroundGroupId()) || request.getBackgroundGroupId() <= 0) {
+                backgroupImageItemMono = Mono.just(List.of());
+            } else {
+                backgroupImageItemMono = template.select(Query.query(Criteria
+                                .where("group_id").is(request.getBackgroundGroupId())), BackgroupImageItem.class).collectList()
+                        .switchIfEmpty(Mono.just(List.of()))
+                        .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage() + "4")));
+            }
+            Mono<TakeawayH5Data> takeaway ;
+            if (Objects.nonNull(request.getTakeawayId()) && request.getTakeawayId() > 0) {
+                takeaway = takeawayServicesInterface.getTakeaway(request.getTakeawayId())
+                        .switchIfEmpty(Mono.error(new BaseException("查询外卖模版数据异常 查询结果为空")))
+                        .onErrorResume(e->Mono.error(new BaseException("查询外卖模版数据异常:::"+e.getMessage())));
+            }else {
+                takeaway=Mono.just(new TakeawayH5Data());
+            }
+            return Mono.zip(groupAudio, retAudio, returnLoop, backgroupImageItemMono,takeaway).flatMap(f -> {
+                PlanNewCommonMaterialRes materialRes = new PlanNewCommonMaterialRes();
+                materialRes.setGroupAudio(f.getT1());
+                materialRes.setRetAudio(f.getT2());
+                materialRes.setReturnLoop(f.getT3());
+                materialRes.setTakeawayH5Data(f.getT5());
+                if (!f.getT4().isEmpty()) {
+                    materialRes.setShareUrls(f.getT4().stream().map(BackgroupImageItem::image).collect(Collectors.toList()));
+                }
+                return Mono.just(materialRes);
+            });
+        });
+        // GZIP压缩
+        // Mono<byte[]> res = materialResMono.flatMap(f -> Mono.just(Objects.requireNonNull(this.compressData(JSONUtil.toJsonStr(f)))));
+        return RStatus.success(materialResMono);
+    }
+
+    /**
+     * 获取音频
+     */
+    private Mono<Audio> getAudio(Long id) {
+        if (Objects.isNull(id) || id <= 0) {
+            return Mono.just(getAudio());
+        }
+        return template.selectOne(Query.query(Criteria.where("id").is(id)), Audio.class)
+                .switchIfEmpty(Mono.error(new BaseException(StrUtil.format("通过计划retAudioId：{}查询音频为空", id))))
+                .onErrorResume(throwable -> Mono.error(new BaseException(StrUtil.format("通过计划retAudioId：{}查询音频Error::", id, throwable.getMessage()))));
+        // String value = redisTemplate.opsForValue().get(RedisKey.FISSION_AUDIO + id);
+        // 优先读缓存
+        // Mono<String> obj = reactiveRedisTemplate.opsForValue().get(RedisKey.FISSION_AUDIO + id)
+        //         .switchIfEmpty(Mono.just(" "))
+        //         .onErrorResume(throwable -> Mono.error(new BaseException(StrUtil.format("通过计划retAudioId：{}查询音频Error::", id, throwable.getMessage()))));
+        // return obj.flatMap(val -> {
+        //     if (val != null && StrUtil.isNotBlank(val.toString())) {
+        //         Audio audio = JSON.parseObject(val.toString(), Audio.class);
+        //         return Mono.just(audio);
+        //     } else {
+        //         return template.selectOne(Query.query(Criteria.where("id").is(id)), Audio.class)
+        //                 .switchIfEmpty(Mono.error(new BaseException(StrUtil.format("通过计划retAudioId：{}查询音频为空", id))))
+        //                 .onErrorResume(throwable -> Mono.error(new BaseException(StrUtil.format("通过计划retAudioId：{}查询音频Error::", id, throwable.getMessage()))));
+        //     }
+        // });
+    }
+
+    private Audio getAudio() {
+        return new Audio(null, null, null, null, null, null, null, null);
+    }
+
+    private ReturnLoop getReturnLoop() {
+        return new ReturnLoop(-1L, null, null, null, null, null, null, null, null, null, null, null, null, null);
+    }
+
+    /**
+     * H5分享
+     *
+     * @param request
+     * @return {@link Mono}<{@link RStatus}<{@link PlanNewCommonShareRes}>>
+     */
+    @PostMapping("planCommonShare")
+    public Mono<RStatus<PlanNewCommonShareRes>> planCommonShare(@RequestBody PlanNewCommonShareReq request) {
+        if (MAP.containsKey(request.getUnique())) {
+            Integer integer = MAP.get(request.getUnique());
+            MAP.put(request.getUnique(), integer + 1);
+            request.setUserVisits(integer + 1);
+        } else {
+            MAP.put(request.getUnique(), 0);
+            request.setUserVisits(0);
+        }
+        Mono<PlanNewCommon> planNewCommonMono = template.selectOne(Query.query(Criteria.where("code").is(request.getCode())), PlanNewCommon.class)
+                .switchIfEmpty(Mono.error(new BaseException(" code错误")))
+                .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage())));
+        Mono<PlanNewCommonShareRes> resMono = planNewCommonMono.flatMap(plan -> {
+            Mono<StringBuilder> stringBuilderMono;
+            boolean isQs = Objects.nonNull(request.getWx_user_id()) && !request.getWx_user_id().isEmpty();
+            if (3 == plan.type()) {
+                // 交友裂变无清水分类
+                isQs = false;
+            }
+            if (Objects.nonNull(request.getRedirectType()) && request.getRedirectType() == 2) {
+                stringBuilderMono = goGenerateService.byPlanNewIdGetUrlCommon(request.getRedirectPlanId(), isQs, request.getGroupIdQs());
+            } else {
+                stringBuilderMono = Mono.just(new StringBuilder(request.getLink()));
+            }
+            Mono<PlanNewCommon> code = Mono.just(plan);
+            return Mono.zip(code, getPosterTemplate(code), getPoster(code), getPlanNewBackgroupPoster(code), getEwm(code), stringBuilderMono).flatMap(f -> {
+                PlanNewCommonShareRes res = new PlanNewCommonShareRes();
+                res.setPlanNew(f.getT1());
+                res.setPosterTemplate(f.getT2());
+                res.setSpare(f.getT5().toString());
+                res.setRedirectType(request.getRedirectType());
+                List<Poster> t3 = f.getT3();
+                if (!t3.isEmpty()) {
+                    if (t3.size() <= request.getUserVisits()) {
+                        res.setPoster(t3.getLast());
+                    } else {
+                        res.setPoster(t3.get(request.getUserVisits()));
+                    }
+                }
+                Map<Integer, List<PlanNewBackgroupPoster>> backgroupPoster = f.getT4().stream().collect(Collectors.groupingBy(PlanNewBackgroupPoster::qsOrFx));
+                // 营销-清水, 交友裂变无清水背景
+                if (Objects.nonNull(request.getWx_user_id()) && !request.getWx_user_id().isEmpty() && 3 != plan.type()) {
+                    List<PlanNewBackgroupPoster> qs = backgroupPoster.get(2).stream()
+                            .sorted(Comparator.comparing(PlanNewBackgroupPoster::index))
+                            .toList();
+                    if (!qs.isEmpty()) {
+                        if (qs.size() <= request.getUserVisits()) {
+                            Integer userVisits = request.getUserVisits();
+                            int v = userVisits % qs.size();
+                            res.setQsSetting(qs.get(v));
+                            if (f.getT6().toString().isEmpty()) {
+                                throw new BaseException("计划链接 查询匹配域名为空");
+                            }
+                            res.setLink(f.getT6().toString());
+                        } else {
+                            res.setQsSetting(qs.get(request.getUserVisits()));
+                            res.setLink(null);
+                        }
+                    }
+                    PlanNewBackgroupPoster qsSetting = res.getQsSetting();
+                    if (Objects.nonNull(qsSetting)) {
+                        res.setLimitTime(qsSetting.limitTime());
+                        res.setLimitTimeRemark(qsSetting.limitTimeRemark());
+                    }
+                } else {
+                    List<PlanNewBackgroupPoster> fx = backgroupPoster.get(1).stream()
+                            .sorted(Comparator.comparing(PlanNewBackgroupPoster::index)).toList();
+                    if (!fx.isEmpty()) {
+                        if (fx.size() <= request.getUserVisits()) {
+                            Integer userVisits = request.getUserVisits();
+                            int v = userVisits % fx.size();
+                            res.setFxSetting(fx.get(v));
+                            if (f.getT6().toString().isEmpty()) {
+                                throw new BaseException("计划链接 查询匹配域名为空");
+                            }
+                            res.setLink(f.getT6().toString());
+                        } else {
+                            res.setLink(null);
+                            res.setFxSetting(fx.get(request.getUserVisits()));
+                        }
+                    }
+                    PlanNewBackgroupPoster fxSetting = res.getFxSetting();
+                    if (Objects.nonNull(fxSetting)) {
+                        res.setLimitTime(fxSetting.limitTime());
+                        res.setLimitTimeRemark(fxSetting.limitTimeRemark());
+                    }
+                }
+                return Mono.just(res);
+            });
+        });
+        Mono<PlanNewCommonShareRes> resMono1 = this.setEndData(request, setFmV(setAudioV(request, resMono)));
+        // GZIP压缩
+        // Mono<byte[]> res = resMono1.flatMap(f -> Mono.just(Objects.requireNonNull(this.compressData(JSONUtil.toJsonStr(f)))));
+        return RStatus.successList(resMono1);
+    }
+
+    /**
+     * 设置二维码 生成图片
+     */
+    private Mono<PlanNewCommonShareRes> setEndData(PlanNewCommonShareReq request, Mono<PlanNewCommonShareRes> resMono) {
+        Mono<PlanNewCommonShareRes> resMono1 = resMono.flatMap(fm -> {
+            Poster poster = fm.getPoster();
+            if (Objects.isNull(poster)) {
+                return Mono.just(fm);
+            }
+            String posterTemplate = poster.posterTemplate();
+            GoRequest goRequest;
+            // 交友裂变无清水分类
+            if (Objects.nonNull(request.getWx_user_id()) && !request.getWx_user_id().isEmpty() && 3 != fm.getPlanNew().type()) {
+                PlanNewBackgroupPoster qsSetting = fm.getQsSetting();
+                goRequest = setNameVal(posterTemplate, qsSetting, fm.getSpare());
+            } else {
+                PlanNewBackgroupPoster fxSetting = fm.getFxSetting();
+                goRequest = setNameVal(posterTemplate, fxSetting, fm.getSpare());
+            }
+            String ret;
+            if (Objects.nonNull(goRequest)) {
+                ret = goGenerateService.goGenerate(JSONUtil.toJsonStr(goRequest));
+            } else {
+
+                ret = goGenerateService.goGenerate(posterTemplate);
+            }
+            if (Objects.nonNull(ret)) {
+                JSONObject jsonObject1;
+                try {
+                    jsonObject1 = JSONUtil.parseObj(ret);
+                } catch (Exception e) {
+                    throw new BaseException(e.getMessage() + "---" + JSONUtil.parseObj(goRequest));
+                }
+                if (jsonObject1.containsKey("code") && jsonObject1.get("code", Integer.class) == 0 && jsonObject1.containsKey("data")) {
+                    JSONObject data = jsonObject1.get("data", JSONObject.class);
+                    if (data.containsKey("Url")) {
+                        String url = data.get("Url", String.class);
+                        if (Objects.nonNull(request.getWx_user_id()) && !request.getWx_user_id().isEmpty() && 3 != fm.getPlanNew().type()) {
+                            fm.setQsGenerateImagesUrl(url);
+                        } else {
+                            fm.setFxGenerateImagesUrl(url);
+                        }
+
+                    }
+                }
+            }
+            return Mono.just(fm);
+        });
+        return resMono1;
+    }
+
+    /**
+     * qrcode 二维码设置
+     */
+    private GoRequest setNameVal(String posterTemplate, PlanNewBackgroupPoster qsSetting, String spare) {
+        JSONObject jsonObject;
+        try {
+            jsonObject = JSONUtil.parseObj(posterTemplate);
+        } catch (Exception e) {
+            throw new BaseException(e.getMessage() + "---" + posterTemplate);
+        }
+        // JSONObject jsonObject = JSONUtil.parseObj(posterTemplate);
+        GoRequest goRequest = new GoRequest();
+        BeanUtil.copyProperties(jsonObject, goRequest);
+        if (Objects.nonNull(qsSetting)) {
+            Optional<Item> first = goRequest.getItem().stream().filter(f -> "qrcode".equals(f.getT())).findFirst();
+            if (first.isPresent()) {
+                Item item = first.get();
+                Boolean isRandom = item.getIsRandom();
+                if (isRandom && Objects.nonNull(qsSetting.status()) && qsSetting.status() == 1
+                        && Objects.nonNull(qsSetting.serviceGroupType()) && qsSetting.serviceGroupType() == 2) {
+                    String kefu = qsSetting.kefu();
+                    if (Objects.nonNull(kefu) && kefu.contains("[") && kefu.contains("]")) {
+                        JSONArray jsonArray = JSONUtil.parseArray(kefu);
+                        if (!jsonArray.isEmpty()) {
+                            String s = jsonArray.get(0, String.class);
+                            item.setV(s);
+                            item.setName("客服二维码");
+                            return goRequest;
+                        }
+                    }
+                } else if (Objects.nonNull(qsSetting.status()) && qsSetting.status() == 0) {
+                    item.setV(spare);
+                    item.setName("H5二维码");
+                    return goRequest;
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 设置封面等
+     */
+    private Mono<PlanNewCommonShareRes> setFmV(Mono<PlanNewCommonShareRes> zip) {
+        Mono<PlanNewCommonShareRes> resMono = zip.flatMap(fm -> {
+            Poster poster = fm.getPoster();
+            if (Objects.isNull(poster)) {
+                return Mono.just(fm);
+            }
+            String posterTemplate = poster.posterTemplate();
+            JSONObject jsonObject;
+            try {
+                jsonObject = JSONUtil.parseObj(posterTemplate);
+            } catch (Exception e) {
+                throw new BaseException(e.getMessage() + "---" + posterTemplate);
+            }
+            GoRequest goRequest = new GoRequest();
+            BeanUtil.copyProperties(jsonObject, goRequest);
+            Mono<String> outTemPoster;
+
+            Long aLong = fm.getPlanNew().groupId();
+            outTemPoster = goGenerateService.getOutTemPosterYx(goRequest,
+                    goGenerateService.setCusqrcodeSetV(goRequest),
+                    aLong);
+
+            return Mono.zip(Mono.just(fm), outTemPoster, (a, b) -> {
+                Poster poster1 = new Poster(poster.posterId(),
+                        poster.posterTemplateId(),
+                        b,
+                        poster.createUser(),
+                        poster.createId(),
+                        poster.createdAt(),
+                        poster.updatedAt(),
+                        poster.generateImagesJson(),
+                        poster.generateImagesUrl());
+                a.setPoster(poster1);
+                return a;
+            });
+        });
+        return resMono;
+    }
+
+    /**
+     * 音频
+     */
+    private Mono<PlanNewCommonShareRes> setAudioV(PlanNewCommonShareReq request, Mono<PlanNewCommonShareRes> resMono) {
+        Mono<PlanNewCommonShareRes> zip = resMono.flatMap(f -> {
+            Mono<Audio> id = null;
+            if (Objects.nonNull(request.getWx_user_id()) && !request.getWx_user_id().isEmpty() && 3 != f.getPlanNew().type()) {
+                PlanNewBackgroupPoster qsSetting = f.getQsSetting();
+                if (Objects.nonNull(qsSetting) && Objects.nonNull(qsSetting.audioId()) && 0 != qsSetting.audioId()) {
+                    id = template.selectOne(Query.query(Criteria.where("id").is(qsSetting.audioId()).and("deleted_at").isNull()), Audio.class);
+                }
+            } else {
+                PlanNewBackgroupPoster fxSetting = f.getFxSetting();
+                if (Objects.nonNull(fxSetting) && Objects.nonNull(fxSetting.audioId()) && 0 != fxSetting.audioId()) {
+                    id = template.selectOne(Query.query(Criteria.where("id").is(fxSetting.audioId()).and("deleted_at").isNull()), Audio.class);
+                }
+            }
+            if (Objects.isNull(id)) {
+                return Mono.just(f);
+            }
+            return Mono.zip(Mono.just(f), id, (a, b) -> {
+                a.setAudio(b);
+                return a;
+            });
+        });
+        return zip;
+    }
+
+    private Mono<List<PlanNewBackgroupPoster>> getPlanNewBackgroupPoster(Mono<PlanNewCommon> code) {
+        return code.flatMap(plan -> template.select(Query.query(Criteria.where("plan_new_id")
+                        .is(plan.id())).sort(Sort.by(Sort.Order.asc("idx"))), PlanNewBackgroupPoster.class)
+                .collectList());
+    }
+
+    private Mono<List<Poster>> getPoster(Mono<PlanNewCommon> code) {
+        return code.flatMap(plan -> template.select(Query.query(Criteria.where("poster_template_id")
+                .is(plan.posterTemplateId())).sort(Sort.by(Sort.Order.asc("created_at"))), Poster.class).collectList());
+    }
+
+    private Mono<PosterTemplate> getPosterTemplate(Mono<PlanNewCommon> code) {
+        return code.flatMap(plan -> template.selectOne(Query.query(Criteria.where("poster_template_id")
+                .is(plan.posterTemplateId())), PosterTemplate.class));
+    }
+
+    private Mono<StringBuilder> getEwm(Mono<PlanNewCommon> code) {
+        return goGenerateService.getOutImportDomainCommon(code);
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/PlanNewController.java

@@ -33,6 +33,7 @@ import org.springframework.data.relational.core.query.Update;
 import org.springframework.web.bind.annotation.*;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
+
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -43,13 +44,14 @@ import java.util.stream.Collectors;
 
 /**
  * 计划
+ *
  * @author lw12420
  * @date 2024/05/21
  */
 @RestController
 @RequestMapping("in/planNew")
 public class PlanNewController {
-    //一天时间
+    // 一天时间
     @Resource
     private R2dbcEntityTemplate template;
 
@@ -61,27 +63,26 @@ public class PlanNewController {
     private PlanServiceInterface planServiceInterface;
 
     @GetMapping("tt")
-    public String tt(){
-        String str="{\"item\": [{\"a\": \"left\", \"c\": \"rgba(0, 0, 0, 1)\", \"h\": 20, \"s\": 14, \"t\": \"title\", \"v\": \"群聊，本地视频推荐\", \"w\": 140, \"x\": 100, \"y\": 100, \"fn\": \"ali-Regular\", \"rm\": \"备注\", \"bgc\": \"\", \"name\": \"海报标题\", \"uuid\": \"b3a10a5e-8c17-4a37-9a99-13600328868c\", \"warp\": false, \"weight\": 500}, {\"c\": \"rgba(0, 0, 0, 1)\", \"h\": 300, \"t\": \"qrcode\", \"v\": \"\", \"w\": 300, \"x\": 87, \"y\": 172, \"fn\": \"\", \"rm\": \"备注\", \"bgc\": \"#ffffff\", \"name\": \"二维码\", \"uuid\": \"2862c036-ad07-48d4-ab34-94fbb2c46c30\"}], \"width\": 458, \"height\": 709, \"bg_img_src\": \"\"}";
+    public String tt() {
+        String str = "{\"item\": [{\"a\": \"left\", \"c\": \"rgba(0, 0, 0, 1)\", \"h\": 20, \"s\": 14, \"t\": \"title\", \"v\": \"群聊，本地视频推荐\", \"w\": 140, \"x\": 100, \"y\": 100, \"fn\": \"ali-Regular\", \"rm\": \"备注\", \"bgc\": \"\", \"name\": \"海报标题\", \"uuid\": \"b3a10a5e-8c17-4a37-9a99-13600328868c\", \"warp\": false, \"weight\": 500}, {\"c\": \"rgba(0, 0, 0, 1)\", \"h\": 300, \"t\": \"qrcode\", \"v\": \"\", \"w\": 300, \"x\": 87, \"y\": 172, \"fn\": \"\", \"rm\": \"备注\", \"bgc\": \"#ffffff\", \"name\": \"二维码\", \"uuid\": \"2862c036-ad07-48d4-ab34-94fbb2c46c30\"}], \"width\": 458, \"height\": 709, \"bg_img_src\": \"\"}";
 
         return goGenerateService.goGenerate(str);
     }
 
 
-
     /**
-     *
      * 分享、清水背景组-回显
+     *
      * @param planNewId 计划id
-     * @param qsOrFx 1：营销 2：清水
+     * @param qsOrFx    1：营销 2：清水
      * @return {@link Mono}<{@link RStatus}<{@link BackgroupImageRes}>>
      */
     @GetMapping("backgroupSelectOne/{type}/{planNewId}/{qsOrFx}")
-    public Mono<RStatus<List<PlanNewBackgroupPosterAllRes>>> backgroupSelectOne(@PathVariable("type")  @NotNull Integer type,
-                                                                                @PathVariable("planNewId") String planNewId,@PathVariable("qsOrFx") Integer qsOrFx ){
+    public Mono<RStatus<List<PlanNewBackgroupPosterAllRes>>> backgroupSelectOne(@PathVariable("type") @NotNull Integer type,
+                                                                                @PathVariable("planNewId") String planNewId, @PathVariable("qsOrFx") Integer qsOrFx) {
         if (1 == type) {
             Mono<List<PlanNewBackgroupPosterAllRes>> listMono = template.select(Query.query(Criteria.where("plan_new_id").is(planNewId)
-                    .and("qs_or_fx").is(qsOrFx)).sort(Sort.by(Sort.Order.asc("idx"))), PlanNewBackgroupPoster.class).flatMap(request->{
+                    .and("qs_or_fx").is(qsOrFx)).sort(Sort.by(Sort.Order.asc("idx"))), PlanNewBackgroupPoster.class).flatMap(request -> {
                 PlanNewBackgroupPosterAllRes planNewBackgroupPosterAllRes =
                         new PlanNewBackgroupPosterAllRes(request.id(),
                                 request.audioId(),
@@ -104,8 +105,8 @@ public class PlanNewController {
             return RStatus.successList(listMono);
         } else if (2 == type) {
             Mono<List<PlanNewBackgroupPosterAllRes>> listMono = template.select(Query.query(Criteria.where("listening_plan_new_id").is(planNewId)
-                    .and("qs_or_fx").is(qsOrFx))
-                    .sort(Sort.by(Sort.Order.asc("idx"))), ListeningPlanNewBackgroupPoster.class).flatMap(request->{
+                            .and("qs_or_fx").is(qsOrFx))
+                    .sort(Sort.by(Sort.Order.asc("idx"))), ListeningPlanNewBackgroupPoster.class).flatMap(request -> {
                 PlanNewBackgroupPosterAllRes planNewBackgroupPosterAllRes =
                         new PlanNewBackgroupPosterAllRes(request.id(),
                                 request.audioId(),
@@ -127,18 +128,19 @@ public class PlanNewController {
             }).collectList();
             return RStatus.successList(listMono);
         }
-            throw new BaseException("type异常");
+        throw new BaseException("type异常");
     }
 
     /**
      * 背景组详情接口
+     *
      * @param id 背景组id
      * @return {@link Mono}<{@link RStatus}<{@link DataLists}>>
      */
     @GetMapping("backgroupImageRes/{id}")
-    public Mono<RStatus<BackgroupImageRes>> backgroupImageRes(@PathVariable("id") Long id){
+    public Mono<RStatus<BackgroupImageRes>> backgroupImageRes(@PathVariable("id") Long id) {
         Mono<BackgroupImage> id1 = template.selectOne(Query.query(Criteria.where("id")
-                .is(id)), BackgroupImage.class) .switchIfEmpty(Mono.error(new BaseException(" 通过code查询结果为空")))
+                        .is(id)), BackgroupImage.class).switchIfEmpty(Mono.error(new BaseException(" 通过code查询结果为空")))
                 .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage())));
         Mono<List<BackgroupImageItem>> group_id = template.select(Query.query(Criteria.where("group_id")
                 .is(id)).sort(Sort.by(Sort.Order.asc("index"))), BackgroupImageItem.class).collectList();
@@ -154,11 +156,12 @@ public class PlanNewController {
 
     /**
      * 客服组-下拉 （ By status）
+     *
      * @param status
      * @return {@link Mono}<{@link RStatus}<{@link List}<{@link ReturnLoop}>>>
      */
     @GetMapping("serviceGroupSlt")
-    public Mono<RStatus<List<ServiceGroup>>> serviceGroupSlt (@RequestParam("status") Integer status){
+    public Mono<RStatus<List<ServiceGroup>>> serviceGroupSlt(@RequestParam("status") Integer status) {
         Mono<List<ServiceGroup>> status1 = template.select(Query.query(Criteria.where("status")
                 .is(2)), ServiceGroup.class).collectList();
         return RStatus.successList(status1);
@@ -167,56 +170,63 @@ public class PlanNewController {
 
     /**
      * 素材、清水--分类下拉（groupType）名称模糊查询
+     *
      * @param name
      * @return {@link Mono}<{@link RStatus}<{@link Long}>>
      */
     @GetMapping("groupTypeSlt")
-    public Mono<RStatus<List<GroupType>>> groupTypeSlt (@RequestParam("name") String name,@RequestParam("groupType")String groupType){
-        Criteria criteria= Criteria.where("group_type").is(groupType);
+    public Mono<RStatus<List<GroupType>>> groupTypeSlt(@RequestParam("name") String name, @RequestParam("groupType") String groupType) {
+        Criteria criteria = Criteria.where("group_type").is(groupType);
         if (Objects.nonNull(name) && "" != name) {
-            criteria = criteria.and("name").like("%"+name+"%");
+            criteria = criteria.and("name").like("%" + name + "%");
         }
         Mono<List<GroupType>> listMono = template.select(Query.query(criteria), GroupType.class).collectList();
         return RStatus.success(listMono);
     }
+
     /**
      * 返回广告下拉名称模糊查询
+     *
      * @param name
      * @return {@link Mono}<{@link RStatus}<{@link Long}>>
      */
     @GetMapping("retrunloopSlt")
-    public Mono<RStatus<List<ReturnLoop>>> retrunloopSlt (@RequestParam("name") String name){
-        Criteria criteria= Criteria.empty() ; //poster_template_id
+    public Mono<RStatus<List<ReturnLoop>>> retrunloopSlt(@RequestParam("name") String name) {
+        Criteria criteria = Criteria.empty(); // poster_template_id
         if (Objects.nonNull(name) && "" != name) {
-            criteria = criteria.and("name").like("%"+name+"%");
+            criteria = criteria.and("name").like("%" + name + "%");
         }
         Mono<List<ReturnLoop>> listMono = template.select(Query.query(criteria), ReturnLoop.class).collectList();
         return RStatus.success(listMono);
     }
+
     /**
      * （分享/清水）背景组设置下拉名称模糊查询
+     *
      * @param name groupType
      * @return {@link Mono}<{@link RStatus}<{@link Long}>>
      */
     @GetMapping("backgroupSlt")
-    public Mono<RStatus<List<BackgroupImage>>> backgroupSlt ( @RequestParam("name") String name,@RequestParam("groupType") String groupType){
-        Criteria criteria= Criteria.where("group_type").is(groupType) ; //poster_template_id
+    public Mono<RStatus<List<BackgroupImage>>> backgroupSlt(@RequestParam("name") String name, @RequestParam("groupType") String groupType) {
+        Criteria criteria = Criteria.where("group_type").is(groupType); // poster_template_id
         if (Objects.nonNull(name) && "" != name) {
-            criteria = criteria.and("name").like("%"+name+"%");
+            criteria = criteria.and("name").like("%" + name + "%");
         }
         Mono<List<BackgroupImage>> listMono = template.select(Query.query(criteria), BackgroupImage.class).collectList();
         return RStatus.success(listMono);
     }
+
     /**
      * 音频下拉名称模糊查询
+     *
      * @param name
      * @return {@link Mono}<{@link RStatus}<{@link Long}>>
      */
     @GetMapping("audioSlt")
-    public Mono<RStatus<List<Audio>>> audio (@RequestParam("name") String name){
-        Criteria criteria= Criteria.empty() ; //poster_template_id
+    public Mono<RStatus<List<Audio>>> audio(@RequestParam("name") String name) {
+        Criteria criteria = Criteria.empty(); // poster_template_id
         if (Objects.nonNull(name) && "" != name) {
-            criteria = criteria.and("name").like("%"+name+"%");
+            criteria = criteria.and("name").like("%" + name + "%");
         }
         Mono<List<Audio>> listMono = template.select(Query.query(criteria), Audio.class).collectList();
         return RStatus.success(listMono);
@@ -224,128 +234,142 @@ public class PlanNewController {
 
     /**
      * 海报保存
+     *
      * @param posterRequset
      * @return {@link Mono}<{@link RStatus}<{@link PlanNew}>>
      */
     @PostMapping("savePoster")
-    public Mono<RStatus<Poster>> savePoster(@RequestBody PosterRequest posterRequset){
+    public Mono<RStatus<Poster>> savePoster(@RequestBody PosterRequest posterRequset) {
         return goGenerateService.savePoster(posterRequset);
     }
+
     @PostMapping("test11")
-    public Mono<String> test11(){
+    public Mono<String> test11() {
         return goGenerateService.updatePoster1();
     }
+
     @PostMapping("test12")
-    public Mono<String> test112(){
+    public Mono<String> test112() {
         String string = RandomUtil.randomString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 6);
-        return Mono.just(string);//goGenerateService.updatePoster12();
+        return Mono.just(string);// goGenerateService.updatePoster12();
     }
+
     /**
      * 海报修改
+     *
      * @param posterRequset
      * @return {@link Mono}<{@link RStatus}<{@link PlanNew}>>
      */
     @PostMapping("updatePoster")
-    public Mono<RStatus<Poster>> updatePoster(@RequestBody PosterRequest posterRequset){
+    public Mono<RStatus<Poster>> updatePoster(@RequestBody PosterRequest posterRequset) {
         return goGenerateService.updatePoster(posterRequset);
     }
 
     /**
      * 海报删除
+     *
      * @param posterId
      * @return {@link Mono}<{@link RStatus}<{@link Long}>>
      */
     @DeleteMapping("deletePosterById/{posterId}")
-    public Mono<RStatus<Long>> deletePosterById (@PathVariable("posterId")  @NotNull Long posterId){
+    public Mono<RStatus<Long>> deletePosterById(@PathVariable("posterId") @NotNull Long posterId) {
         Mono<Long> plan_new_id = template.delete(Query.query(Criteria.where("poster_id").is(posterId)), Poster.class);
         return RStatus.success(plan_new_id);
     }
 
     /**
      * 海报列表
+     *
      * @param request
      * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link PosterTemplate}>>>
      */
     @PostMapping("posterList")
-    public Mono<RStatus<Paged<Poster>>> posterList(@RequestBody PosterPage request)   {
-        Criteria criteria= Criteria.empty() ; //poster_template_id
+    public Mono<RStatus<Paged<Poster>>> posterList(@RequestBody PosterPage request) {
+        Criteria criteria = Criteria.empty(); // poster_template_id
         criteria = criteria.and("poster_template_id").is(request.getPosterTemplateId());
         Query query = Query.query(criteria);
         Criteria finalCriteria = criteria;
-        int skip  = (request.getPage() - 1) * request.getSize();
-        int limit =  request.getSize();
+        int skip = (request.getPage() - 1) * request.getSize();
+        int limit = request.getSize();
         Mono<Paged<Poster>> pagedMono = template.count(query, Poster.class).flatMap(fm ->
                 template.select(Query.query(finalCriteria)
-                        .offset(skip)
-                        .limit(limit)
-                        .sort(Sort.by(Sort.Order.asc("created_at"))),Poster.class)
+                                .offset(skip)
+                                .limit(limit)
+                                .sort(Sort.by(Sort.Order.asc("created_at"))), Poster.class)
                         .collectList()
-                        .map(list -> new Paged<>(fm, list,request.getPage(),request.getSize()))
+                        .map(list -> new Paged<>(fm, list, request.getPage(), request.getSize()))
         );
         return RStatus.successList(pagedMono);
     }
 
     /**
      * 海报模版保存
+     *
      * @param posterTemplateRequset
      * @return {@link Mono}<{@link RStatus}<{@link PlanNew}>>
      */
     @PostMapping("savePosterTem")
-    public Mono<RStatus<PosterTemplate>> savePosterTem(@RequestBody PosterTemplateRequset posterTemplateRequset){
+    public Mono<RStatus<PosterTemplate>> savePosterTem(@RequestBody PosterTemplateRequset posterTemplateRequset) {
         PosterTemplate posterTemplate = new PosterTemplate(null, posterTemplateRequset.getPosterTemplateName(), BaseContextHandler.getUserName(),
                 BaseContextHandler.getUserId(), ZonedDateTime.now(),
                 ZonedDateTime.now());
         Mono<PosterTemplate> insert = template.insert(posterTemplate);
         return RStatus.success(insert);
     }
+
     /**
      * 海报模版修改
+     *
      * @param posterTemplateRequset
      * @return {@link Mono}<{@link RStatus}<{@link PlanNew}>>
      */
     @PostMapping("updatePosterTem")
-    public Mono<RStatus<Long>> updatePosterTem(@RequestBody PosterTemplateRequset posterTemplateRequset){
+    public Mono<RStatus<Long>> updatePosterTem(@RequestBody PosterTemplateRequset posterTemplateRequset) {
 
         Criteria empty = Criteria.where("poster_template_id").is(posterTemplateRequset.getPosterTemplateId());
         Update update = Update.update("updated_at", ZonedDateTime.now());
-        if(Objects.nonNull(posterTemplateRequset.getPosterTemplateName()) && !"".equals(posterTemplateRequset.getPosterTemplateName())){
-            update=  update.set("poster_template_name",posterTemplateRequset.getPosterTemplateName());
+        if (Objects.nonNull(posterTemplateRequset.getPosterTemplateName()) && !"".equals(posterTemplateRequset.getPosterTemplateName())) {
+            update = update.set("poster_template_name", posterTemplateRequset.getPosterTemplateName());
         }
         Mono<Long> update1 = template.update(Query.query(empty), update, PosterTemplate.class);
-        return  RStatus.success(update1);
+        return RStatus.success(update1);
     }
+
     /**
      * 海报模版删除
+     *
      * @param posterTemplateId
      * @return {@link Mono}<{@link RStatus}<{@link Long}>>
      */
     @DeleteMapping("deletePosterTemById/{posterTemplateId}")
-    public Mono<RStatus<Long>> deletePosterTemById (@PathVariable("posterTemplateId")  @NotNull Long posterTemplateId){
+    public Mono<RStatus<Long>> deletePosterTemById(@PathVariable("posterTemplateId") @NotNull Long posterTemplateId) {
         Mono<Long> plan_new_id = template.delete(Query.query(Criteria.where("poster_template_id").is(posterTemplateId)), PosterTemplate.class);
         return RStatus.success(plan_new_id);
     }
 
     /**
      * 海报模版-编辑回显详情
+     *
      * @param posterTemplateId
      * @return
      */
     @GetMapping("posterTem/{planNewId}")
-    public Mono<RStatus<PosterTemplate>> posterTem(@PathVariable("posterTemplateId")  @NotNull Long posterTemplateId){
+    public Mono<RStatus<PosterTemplate>> posterTem(@PathVariable("posterTemplateId") @NotNull Long posterTemplateId) {
         Mono<PosterTemplate> planNewMono = template
                 .selectOne(Query.query(Criteria.where("poster_template_id")
-                .is(posterTemplateId)), PosterTemplate.class);
+                        .is(posterTemplateId)), PosterTemplate.class);
         return RStatus.success(planNewMono);
     }
 
     /**
      * 海报模版下拉
+     *
      * @param request
      * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link PosterTemplate}>>>
      */
     @PostMapping("posterTemSelect")
-    public Mono<RStatus<List<PosterTemplate>>> posterTemSelect(@RequestBody PosterTemSelect request)   {
-        Criteria criteria= Criteria.empty() ; //poster_template_id
+    public Mono<RStatus<List<PosterTemplate>>> posterTemSelect(@RequestBody PosterTemSelect request) {
+        Criteria criteria = Criteria.empty(); // poster_template_id
         if (Objects.nonNull(request.getName()) && "" != request.getName()) {
             criteria = criteria.and("name").like(request.getName());
         }
@@ -355,19 +379,20 @@ public class PlanNewController {
 
     /**
      * 海报模版-列表
+     *
      * @param request
      * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link PosterTemplate}>>>
      */
     @PostMapping("posterTemList")
-    public Mono<RStatus<Paged<PosterTemplateRes>>> posterTemList(@RequestBody PosterTemPage request)   {
-        Criteria criteria= Criteria.empty() ; //poster_template_id
+    public Mono<RStatus<Paged<PosterTemplateRes>>> posterTemList(@RequestBody PosterTemPage request) {
+        Criteria criteria = Criteria.empty(); // poster_template_id
         if (Objects.nonNull(request.getName()) && "" != request.getName()) {
             criteria = criteria.and("name").is(request.getName());
         }
         Query query = Query.query(criteria);
         Criteria finalCriteria = criteria;
-        int skip  = (request.getPage() - 1) * request.getSize();
-        int limit =  request.getSize();
+        int skip = (request.getPage() - 1) * request.getSize();
+        int limit = request.getSize();
         Mono<Long> count = template.count(query, PosterTemplate.class);
         Flux<PosterTemplateRes> created_at = template.select(Query.query(finalCriteria)
                 .offset(skip)
@@ -394,21 +419,22 @@ public class PlanNewController {
 
     /**
      * 计划保存
+     *
      * @param saveRequest
      * @return {@link Mono}<{@link RStatus}<{@link PlanNew}>>
      */
     @PostMapping("savePlan")
-    public Mono<RStatus<String>> savePlan(@RequestBody PlanReq saveRequest){
-        if(2==saveRequest.getType()){
-            return   listeningPlanService.savePlan(saveRequest);
-        }else if(1==saveRequest.getType()){
+    public Mono<RStatus<String>> savePlan(@RequestBody PlanReq saveRequest) {
+        if (2 == saveRequest.getType()) {
+            return listeningPlanService.savePlan(saveRequest);
+        } else if (1 == saveRequest.getType()) {
             String userName = BaseContextHandler.getUserName();
             String userId = BaseContextHandler.getUserId();
             saveRequest.setCode(IdUtil.fastSimpleUUID());
             Long posterTemplateId = saveRequest.getPosterTemplateId();
             Mono<String> stringMono1 = template
                     .select(Query.query(Criteria.where("poster_template_id")
-                            .is(posterTemplateId))
+                                    .is(posterTemplateId))
                             .sort(Sort.by(Sort.Order.asc("created_at"))), Poster.class)
                     .collectList().flatMap(f -> {
                         Poster poster = f.get(0);
@@ -418,21 +444,21 @@ public class PlanNewController {
                         BeanUtil.copyProperties(jsonObject, goRequest);
                         ServiceGroupSettingItemRequest serviceGroupSettingItemRequest = saveRequest.getBackgroupFxSetting().get(0);
                         Mono<String> stringMono = goGenerateService.saveAndUpdatePlanGenerateImage0(goRequest,
-                                goGenerateService.setCusqrcodeSetV(goRequest),//getStringBuilderMono(goRequest),
+                                goGenerateService.setCusqrcodeSetV(goRequest),// getStringBuilderMono(goRequest),
                                 serviceGroupSettingItemRequest,
                                 saveRequest);
                         return stringMono;
                     });
-            Mono<StringBuilder> stringBuilderMono ;
-            if(saveRequest.getRedirectType()==2){
-                stringBuilderMono =Mono.just(new StringBuilder()); //goGenerateService.byPlanNewIdGetUrl(saveRequest.getRedirectPlanId());
-            }else {
-                stringBuilderMono=Mono.just(new StringBuilder(saveRequest.getLink()));
+            Mono<StringBuilder> stringBuilderMono;
+            if (saveRequest.getRedirectType() == 2) {
+                stringBuilderMono = Mono.just(new StringBuilder()); // goGenerateService.byPlanNewIdGetUrl(saveRequest.getRedirectPlanId());
+            } else {
+                stringBuilderMono = Mono.just(new StringBuilder(saveRequest.getLink()));
             }
-            Mono<PlanNew> insert = Mono.zip(stringMono1, stringBuilderMono).flatMap(f->{
-                String listButton="立即入群";
-                if(Objects.nonNull(saveRequest.getListButton()) && !"".equals(saveRequest.getListButton().trim())){
-                    listButton=saveRequest.getListButton();
+            Mono<PlanNew> insert = Mono.zip(stringMono1, stringBuilderMono).flatMap(f -> {
+                String listButton = "立即入群";
+                if (Objects.nonNull(saveRequest.getListButton()) && !"".equals(saveRequest.getListButton().trim())) {
+                    listButton = saveRequest.getListButton();
                 }
                 PlanNew plan = new PlanNew(IdUtil.fastSimpleUUID(),
                         saveRequest.getName(),
@@ -472,20 +498,21 @@ public class PlanNewController {
                         saveRequest.getTransferPageDomain(),
                         saveRequest.getTransferPageBl(),
                         saveRequest.getBackgroupDomain(),
-                        listButton
+                        listButton,
+                        saveRequest.getGroupListDisplay()
                 );
                 return template.insert(plan);
             });
             Mono<String> map = insert.flatMap(f -> {
                 Flux<PlanNewBackgroupPoster> just = getPlanNewBackgroupPosterFlux(saveRequest, f);
-                return  Mono.zip(batchInsert(just), Mono.just(f)).flatMap(ff -> {
+                return Mono.zip(batchInsert(just), Mono.just(f)).flatMap(ff -> {
                     PlanNew t2 = ff.getT2();
                     return Mono.just(t2.planNewId());
                 });
             });
-            return  RStatus.success(map);
+            return RStatus.success(map);
         }
-      throw new BaseException("type类型错误");
+        throw new BaseException("type类型错误");
     }
 
     private Flux<PlanNewBackgroupPoster> getPlanNewBackgroupPosterFlux(PlanReq saveRequest, PlanNew f) {
@@ -509,8 +536,9 @@ public class PlanNewController {
                 .insert(PlanNewBackgroupPoster.class).using(entity)).collectList();
         return listMono;
     }
-    public PlanNewBackgroupPoster fxBackgroupSettingsSave( ServiceGroupSettingItemRequest request,String planNewId,Integer qsOrFx){
-         return new PlanNewBackgroupPoster(null,
+
+    public PlanNewBackgroupPoster fxBackgroupSettingsSave(ServiceGroupSettingItemRequest request, String planNewId, Integer qsOrFx) {
+        return new PlanNewBackgroupPoster(null,
                 request.getAudioId(),
                 request.getGroupId(),
                 request.getImage(),
@@ -525,7 +553,7 @@ public class PlanNewController {
                 ZonedDateTime.now(),
                 null,
                 null,
-                planNewId,null,null);
+                planNewId, null, null);
 //         template.insert(planNewBackgroupPoster).subscribe(f->{
 //             JSONObject jsonObject = JSONUtil.parseObj(f);
 //             System.out.println(jsonObject);
@@ -534,12 +562,11 @@ public class PlanNewController {
     }
 
 
-
     @PostMapping("updatePlan")
-    public Mono<RStatus<String>> updatePlan(@RequestBody PlanReq saveRequest){
-        if(2==saveRequest.getType()){
-            return   listeningPlanService.savePlan(saveRequest);
-        }else if(1==saveRequest.getType()){
+    public Mono<RStatus<String>> updatePlan(@RequestBody PlanReq saveRequest) {
+        if (2 == saveRequest.getType()) {
+            return listeningPlanService.savePlan(saveRequest);
+        } else if (1 == saveRequest.getType()) {
             Long posterTemplateId = saveRequest.getPosterTemplateId();
             Mono<String> stringMono1 = template
                     .select(Query.query(Criteria.where("poster_template_id").is(posterTemplateId)).sort(Sort.by(Sort.Order.asc("created_at"))), Poster.class)
@@ -551,26 +578,26 @@ public class PlanNewController {
                         BeanUtil.copyProperties(jsonObject, goRequest);
                         ServiceGroupSettingItemRequest serviceGroupSettingItemRequest = saveRequest.getBackgroupFxSetting().get(0);
                         Mono<String> stringMono = goGenerateService.saveAndUpdatePlanGenerateImage0(goRequest,
-                              //  goGenerateService.getStringBuilderMono(goRequest),
+                                //  goGenerateService.getStringBuilderMono(goRequest),
                                 goGenerateService.setCusqrcodeSetV(goRequest),
                                 serviceGroupSettingItemRequest, saveRequest);
                         return stringMono;
                     });
             Mono<PlanNew> plan_new_id1 = template.selectOne(Query.query(Criteria.where("plan_new_id").is(saveRequest.getPlanNewId())), PlanNew.class);
-            Mono<StringBuilder> stringBuilderMono ;
-            if(saveRequest.getRedirectType()==2){
-                stringBuilderMono = Mono.just(new StringBuilder(""));//goGenerateService.byPlanNewIdGetUrl(saveRequest.getRedirectPlanId());
-            }else {
-                stringBuilderMono=Mono.just(new StringBuilder(saveRequest.getLink()));
+            Mono<StringBuilder> stringBuilderMono;
+            if (saveRequest.getRedirectType() == 2) {
+                stringBuilderMono = Mono.just(new StringBuilder(""));// goGenerateService.byPlanNewIdGetUrl(saveRequest.getRedirectPlanId());
+            } else {
+                stringBuilderMono = Mono.just(new StringBuilder(saveRequest.getLink()));
             }
             Mono<PlanNew> planNewMono = Mono.zip(stringMono1, plan_new_id1, stringBuilderMono).flatMap(f -> {
                 PlanNew map = f.getT2();
-                String listButton="立即入群";
-                if(Objects.nonNull(saveRequest.getListButton()) && !"".equals(saveRequest.getListButton().trim())){
-                    listButton=saveRequest.getListButton();
+                String listButton = "立即入群";
+                if (Objects.nonNull(saveRequest.getListButton()) && !"".equals(saveRequest.getListButton().trim())) {
+                    listButton = saveRequest.getListButton();
                 }
                 PlanNew planNew = new PlanNew(
-                       saveRequest.getPlanNewId(),
+                        saveRequest.getPlanNewId(),
                         saveRequest.getName(),
                         map.createUser(),
                         map.createId(),
@@ -608,17 +635,18 @@ public class PlanNewController {
                         saveRequest.getTransferPageDomain(),
                         saveRequest.getTransferPageBl(),
                         saveRequest.getBackgroupDomain(),
-                        listButton
+                        listButton,
+                        saveRequest.getGroupListDisplay()
                 );
                 return Mono.just(planNew);
             }).flatMap(template::update);
-            Mono<String> map = planNewMono.flatMap(f1->{
-                Mono<Long>  ml= template.delete(Query.query(Criteria.where("plan_new_id").is(f1.planNewId())),PlanNewBackgroupPoster.class);
-                return Mono.zip(Mono.just(f1),ml).flatMap(ff->Mono.just(f1));
+            Mono<String> map = planNewMono.flatMap(f1 -> {
+                Mono<Long> ml = template.delete(Query.query(Criteria.where("plan_new_id").is(f1.planNewId())), PlanNewBackgroupPoster.class);
+                return Mono.zip(Mono.just(f1), ml).flatMap(ff -> Mono.just(f1));
             }).flatMap(f -> {
                 Flux<PlanNewBackgroupPoster> just = getPlanNewBackgroupPosterFlux(saveRequest, f);
 
-                return  Mono.zip(batchInsert(just), Mono.just(f)).flatMap(ff -> {
+                return Mono.zip(batchInsert(just), Mono.just(f)).flatMap(ff -> {
                     PlanNew t2 = ff.getT2();
                     return Mono.just(t2.planNewId());
                 });
@@ -628,7 +656,8 @@ public class PlanNewController {
 
         throw new BaseException("type类型错误");
     }
-    public PlanNewBackgroupPoster fxBackgroupSettingsUpdate( ServiceGroupSettingItemRequest request,String planNewId,Integer qsOrFx){
+
+    public PlanNewBackgroupPoster fxBackgroupSettingsUpdate(ServiceGroupSettingItemRequest request, String planNewId, Integer qsOrFx) {
         PlanNewBackgroupPoster planNewBackgroupPoster = new PlanNewBackgroupPoster(request.getId(),
 
                 request.getAudioId(),
@@ -645,20 +674,22 @@ public class PlanNewController {
                 ZonedDateTime.now(),
                 ZonedDateTime.now(),
                 null,
-                planNewId,null,null);
-       // template.insert(planNewBackgroupPoster).subscribe();
+                planNewId, null, null);
+        // template.insert(planNewBackgroupPoster).subscribe();
         return planNewBackgroupPoster;
     }
+
     /**
      * 复制计划
+     *
      * @param planNewId
      * @return {@link Mono}<{@link RStatus}<{@link PlanNew}>>
      */
     @GetMapping("copyById/{type}/{planNewId}")
-    public Mono<RStatus<String>> copyById (@PathVariable("type")  @NotNull Integer type,@PathVariable("planNewId")  @NotNull String planNewId){
+    public Mono<RStatus<String>> copyById(@PathVariable("type") @NotNull Integer type, @PathVariable("planNewId") @NotNull String planNewId) {
         if (2 == type) {
-             return listeningPlanService.copyById(planNewId);
-        }else if (1==type){
+            return listeningPlanService.copyById(planNewId);
+        } else if (1 == type) {
             String userName = BaseContextHandler.getUserName();
             String userId = BaseContextHandler.getUserId();
             Mono<PlanNew> plan_new_id = template.selectOne(Query.query(Criteria.where("plan_new_id").is(planNewId)), PlanNew.class)
@@ -700,11 +731,12 @@ public class PlanNewController {
                             saveRequest.transferPageDomain(),
                             saveRequest.transferPageBl(),
                             saveRequest.backgroupDomain(),
-                            saveRequest.listButton()
+                            saveRequest.listButton(),
+                            saveRequest.groupListDisplay()
                     )).flatMap(map -> template.insert(map));
             Mono<List<PlanNewBackgroupPoster>> listening_plan_new_id1 =
                     template.select(Query.query(Criteria.where("plan_new_id")
-                            .is(planNewId)), PlanNewBackgroupPoster.class)
+                                    .is(planNewId)), PlanNewBackgroupPoster.class)
                             .collectList();
             Mono<String> stringMono = Mono.zip(plan_new_id, listening_plan_new_id1).flatMap(f -> {
                 PlanNew t1 = f.getT1();
@@ -746,27 +778,28 @@ public class PlanNewController {
 
     /**
      * 删除计划
+     *
      * @param planNewId
      * @return {@link Mono}<{@link RStatus}<{@link Long}>>
      */
     @DeleteMapping("deleteById/{type}/{planNewId}")
-    public Mono<RStatus<Long>> deleteById (@PathVariable("type")  @NotNull Integer type,@PathVariable("planNewId")  @NotNull String planNewId ){
-        if(1==type){
+    public Mono<RStatus<Long>> deleteById(@PathVariable("type") @NotNull Integer type, @PathVariable("planNewId") @NotNull String planNewId) {
+        if (1 == type) {
             Query plan_new_id2 = Query.query(Criteria.where("plan_new_id").is(planNewId));
             Mono<Long> plan_new_id = template.delete(plan_new_id2, PlanNew.class)
-                    .switchIfEmpty(Mono.error(new BaseException("计划id异常"))) //Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
-                    .onErrorResume(throwable -> Mono.error(new Exception("删除计划 " +planNewId+"---"+ type+"error:" + throwable.getMessage())));
+                    .switchIfEmpty(Mono.error(new BaseException("计划id异常"))) // Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
+                    .onErrorResume(throwable -> Mono.error(new Exception("删除计划 " + planNewId + "---" + type + "error:" + throwable.getMessage())));
             Mono<Long> plan_new_id1 = template.count(plan_new_id2, PlanNewBackgroupPoster.class).filter(f -> f > 0)
                     .flatMap(f -> template.delete(plan_new_id2, PlanNewBackgroupPoster.class))
                     .switchIfEmpty(Mono.just(0L));
             Mono<Long> longMono = Mono.zip(plan_new_id1, plan_new_id).flatMap(f -> Mono.just(f.getT1()));
             return RStatus.success(longMono);
-        }else if(2==type) {
+        } else if (2 == type) {
             Query listening_plan_new_id1 = Query.query(Criteria.where("listening_plan_new_id")
                     .is(planNewId));
             Mono<Long> listening_plan_new_id = template.delete(listening_plan_new_id1, ListeningPlanNew.class)
-                    .switchIfEmpty(Mono.error(new BaseException("计划id异常"))) //Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
-                    .onErrorResume(throwable -> Mono.error(new Exception("删除计划 " +planNewId+"---"+ type+"error:" + throwable.getMessage())));
+                    .switchIfEmpty(Mono.error(new BaseException("计划id异常"))) // Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
+                    .onErrorResume(throwable -> Mono.error(new Exception("删除计划 " + planNewId + "---" + type + "error:" + throwable.getMessage())));
             Mono<Long> plan_new_id1 = template.count(listening_plan_new_id1, ListeningPlanNewBackgroupPoster.class).filter(f -> f > 0)
                     .flatMap(f -> template.delete(listening_plan_new_id1, ListeningPlanNewBackgroupPoster.class))
                     .switchIfEmpty(Mono.just(0L));
@@ -778,11 +811,12 @@ public class PlanNewController {
 
     /**
      * 计划-编辑回显详情
+     *
      * @param planNewId
      * @return
      */
     @GetMapping("planNewInfo/{type}/{planNewId}")
-    public Mono<RStatus<PlanNewAllRs>> planNewInfo(@PathVariable("type")  @NotNull Integer type,@PathVariable("planNewId")  @NotNull String planNewId){
+    public Mono<RStatus<PlanNewAllRs>> planNewInfo(@PathVariable("type") @NotNull Integer type, @PathVariable("planNewId") @NotNull String planNewId) {
         if (1 == type) {
             Mono<PlanNewAllRs> planNewAllRsMono = template.selectOne(Query.query(Criteria.where("plan_new_id").is(planNewId)), PlanNew.class)
                     .flatMap(saveRequest -> {
@@ -822,24 +856,25 @@ public class PlanNewController {
                                         saveRequest.listButton(),
                                         Objects.nonNull(saveRequest.importDomain()) && !"".equals(saveRequest.importDomain().trim()) ? Integer.valueOf(saveRequest.importDomain()) : null,
                                         Objects.nonNull(saveRequest.landingPageDomain()) && !"".equals(saveRequest.landingPageDomain().trim()) ? Integer.valueOf(saveRequest.landingPageDomain()) : null,
-                                       // saveRequest.landingPageDomain(),
-                                        Objects.nonNull(saveRequest.transferPageDomain()) && !"".equals(saveRequest.transferPageDomain().trim()) ?Integer.valueOf(saveRequest.transferPageDomain()):null,
+                                        // saveRequest.landingPageDomain(),
+                                        Objects.nonNull(saveRequest.transferPageDomain()) && !"".equals(saveRequest.transferPageDomain().trim()) ? Integer.valueOf(saveRequest.transferPageDomain()) : null,
 
-                                        //saveRequest.transferPageDomain(),
+                                        // saveRequest.transferPageDomain(),
                                         saveRequest.transferPageBl(),
-                                        Objects.nonNull(saveRequest.backgroupDomain()) && !"".equals(saveRequest.backgroupDomain().trim()) ?Integer.valueOf(saveRequest.backgroupDomain()):null
+                                        Objects.nonNull(saveRequest.backgroupDomain()) && !"".equals(saveRequest.backgroupDomain().trim()) ? Integer.valueOf(saveRequest.backgroupDomain()) : null,
+                                        saveRequest.groupListDisplay()
 
-                                       // saveRequest.backgroupDomain()
+                                        // saveRequest.backgroupDomain()
                                 );
                                 return Mono.just(planNewAllRs);
                             }
-                    ).switchIfEmpty(Mono.error(new BaseException("计划id异常"))) //Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
+                    ).switchIfEmpty(Mono.error(new BaseException("计划id异常"))) // Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
                     .onErrorResume(throwable -> Mono.error(new Exception("计划id异常")));
             return RStatus.success(planNewAllRsMono);
-        }else if (2 == type) {
+        } else if (2 == type) {
             Mono<PlanNewAllRs> planNewAllRsMono = template
                     .selectOne(Query.query(Criteria.where("listening_plan_new_id").is(planNewId)),
-                    ListeningPlanNew.class)
+                            ListeningPlanNew.class)
                     .flatMap(saveRequest -> {
                                 PlanNewAllRs planNewAllRs = new PlanNewAllRs(saveRequest.listeningPlanNewId(),
                                         saveRequest.name(),
@@ -879,12 +914,13 @@ public class PlanNewController {
                                         null,
                                         null,
                                         null,
+                                        null,
                                         null
 
                                 );
                                 return Mono.just(planNewAllRs);
                             }
-                    ).switchIfEmpty(Mono.error(new BaseException("计划id异常"))) //Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
+                    ).switchIfEmpty(Mono.error(new BaseException("计划id异常"))) // Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
                     .onErrorResume(throwable -> Mono.error(new Exception("计划id异常")));
             return RStatus.success(planNewAllRsMono);
         }
@@ -894,35 +930,40 @@ public class PlanNewController {
 
     /**
      * 计划列表-下拉(查看自己创建的)(V2.0)
+     *
      * @param request
      * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link PlanNew}>>>
      */
     @PostMapping("planSelectSelf")
-    public Mono<RStatus<List<PlanNew>>> planSelectSelf(@RequestBody PosterTemSelectSelf request)   {
+    public Mono<RStatus<List<SelectPlanRes1>>> planSelectSelf(@RequestBody PosterTemSelectSelf request) {
 
         if (Objects.isNull(request.getUserId())) {
-            request.setUserId( BaseContextHandler.getUserId());
+            request.setUserId(BaseContextHandler.getUserId());
         }
-        Criteria criteria= Criteria.where("create_id").is(request.getUserId()) ; //poster_template_id
-        if (Objects.nonNull(request.getName()) && "" != request.getName()) {
-            criteria = criteria.and("name").like("%"+request.getName()+"%");
+        Criteria criteria = Criteria.where("create_id").is(request.getUserId()); // poster_template_id
+        if (Objects.nonNull(request.getName()) && !request.getName().isEmpty()) {
+            criteria = criteria.and("name").like("%" + request.getName() + "%");
         }
-        Mono<List<PlanNew>> listMono = template.select(Query.query(criteria), PlanNew.class).collectList();
-        return RStatus.successList(listMono);
+        return getPlanSelect(criteria);
     }
 
 
     /**
      * 计划列表-下拉
+     *
      * @param request
      * @return {@link Mono}<{@link RStatus}<{@link List}<{@link SelectPlanRes1}>>>
      */
     @PostMapping("planSelect")
-    public Mono<RStatus<List<SelectPlanRes1>>> planSelect(@RequestBody PosterTemSelect request)   {
-        Criteria criteria= Criteria.empty() ; //poster_template_id
+    public Mono<RStatus<List<SelectPlanRes1>>> planSelect(@RequestBody PosterTemSelect request) {
+        Criteria criteria = Criteria.empty(); // poster_template_id
         if (Objects.nonNull(request.getName()) && "" != request.getName()) {
             criteria = criteria.and("name").is(request.getName());
         }
+        return getPlanSelect(criteria);
+    }
+
+    private Mono<RStatus<List<SelectPlanRes1>>> getPlanSelect( Criteria criteria) {
         Mono<List<SelectPlanRes1>> listMono = template.select(Query.query(criteria), PlanNew.class).flatMap(fm -> {
             SelectPlanRes1 selectPlanRes1 = new SelectPlanRes1();
             selectPlanRes1.setName(fm.name());
@@ -937,12 +978,21 @@ public class PlanNewController {
             selectPlanRes1.setPlanNewId(fm.listeningPlanNewId());
             return Mono.just(selectPlanRes1);
         }).collectList();
-        Mono<List<SelectPlanRes1>> arrayListMono = Mono.zip(listMono, listMono1).flatMap(f -> {
+        Mono<List<SelectPlanRes1>> listMono2 = template.select(Query.query(criteria), PlanNewCommon.class).flatMap(fm -> {
+            SelectPlanRes1 selectPlanRes1 = new SelectPlanRes1();
+            selectPlanRes1.setName(fm.name());
+            selectPlanRes1.setType(3);
+            selectPlanRes1.setPlanNewId(fm.id());
+            return Mono.just(selectPlanRes1);
+        }).collectList();
+        Mono<List<SelectPlanRes1>> arrayListMono = Mono.zip(listMono, listMono1, listMono2).flatMap(f -> {
             List<SelectPlanRes1> t1 = f.getT1();
             List<SelectPlanRes1> t2 = f.getT2();
+            List<SelectPlanRes1> t3 = f.getT3();
             ArrayList<SelectPlanRes1> objects = new ArrayList<>();
             objects.addAll(t1);
             objects.addAll(t2);
+            objects.addAll(t3);
             return Mono.just(objects);
         });
         return RStatus.successList(arrayListMono);
@@ -951,51 +1001,57 @@ public class PlanNewController {
 
     /**
      * 计划列表
-     * @param request
+     *
+     * @param request request
      * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link ListeningPlanNewRes2}>>>
      */
     @PostMapping("planList")
-    public Mono<RStatus<Paged<ListeningPlanNewRes2>>> page(@RequestBody PlanReqPage request)   {
-        if (2 == request.getType()) {
-          return   listeningPlanService.page(request);
-        }else {
-          return getType1(request);
-        }
-    }
-    private Mono<RStatus<Paged<ListeningPlanNewRes2>>> getType1(PlanReqPage request) {
-        Criteria criteria= Criteria.empty() ; //poster_template_id
-        if (Objects.nonNull(request.getCode()) && "" != request.getCode().trim()) {
-            criteria = criteria.and("code").like("%"+request.getCode()+"%");
+    public Mono<RStatus<Paged<ListeningPlanNewRes2>>> page(@RequestBody PlanReqPage request) {
+        Criteria criteria = Criteria.empty(); // poster_template_id
+        if (Objects.nonNull(request.getCode()) && !request.getCode().trim().isEmpty()) {
+            criteria = criteria.and("code").like("%" + request.getCode() + "%");
         }
-        if (Objects.nonNull(request.getName()) && "" != request.getName().trim()) {
-            criteria = criteria.and("name").like("%"+request.getName()+"%");
+        if (Objects.nonNull(request.getName()) && !request.getName().trim().isEmpty()) {
+            criteria = criteria.and("name").like("%" + request.getName() + "%");
         }
-        if (Objects.nonNull(request.getCreateUser()) && "" != request.getCreateUser().trim()) {
-            criteria = criteria.and("create_user").like("%"+request.getCreateUser()+"%");
+        if (Objects.nonNull(request.getCreateUser()) && !request.getCreateUser().trim().isEmpty()) {
+            criteria = criteria.and("create_user").like("%" + request.getCreateUser() + "%");
         }
         if (Objects.nonNull(request.getPosterTemplateId()) && 0L != request.getPosterTemplateId()) {
             criteria = criteria.and("poster_template_id").is(request.getPosterTemplateId());
         }
-//        if (Objects.nonNull(request.getType()) && 0L != request.getType()) {
-//            criteria = criteria.and("type").is(request.getType());
-//        }
+        if (Objects.nonNull(request.getType()) && 0 != request.getType()) {
+            criteria = criteria.and("type").is(request.getType());
+        }
+        if (Objects.nonNull(request.getGroupId()) && 0L != request.getGroupId()) {
+            criteria = criteria.and("group_id").is(request.getType());
+        }
+        if (2 == request.getType()) {
+            return listeningPlanService.page(request, criteria);
+        } else if (1 == request.getType()) {
+            return getType1(request, criteria);
+        } else {
+            return planServiceInterface.page(request, criteria);
+        }
+    }
+
+    private Mono<RStatus<Paged<ListeningPlanNewRes2>>> getType1(PlanReqPage request, Criteria criteria) {
         Query query = Query.query(criteria);
-        Criteria finalCriteria = criteria;
-        int skip  = (request.getPage() - 1) * request.getSize();
-        int limit =  request.getSize();
+        int skip = (request.getPage() - 1) * request.getSize();
+        int limit = request.getSize();
         Mono<Long> count = template.count(query, PlanNew.class);
-        Flux<PlanNew> created_at = template.select(Query.query(finalCriteria)
+        Flux<PlanNew> created_at = template.select(Query.query(criteria)
                 .offset(skip)
                 .limit(limit)
                 .sort(Sort.by(Sort.Order.desc("created_at"))), PlanNew.class);
         Mono<List<ListeningPlanNewRes2>> listMono = created_at.flatMap(f -> {
             Mono<String> poster_template_id = template.selectOne(Query.query(Criteria.where("poster_template_id")
-                    .is(f.posterTemplateId())), PosterTemplate.class).flatMap(f0 -> Mono.just(f0.posterTemplateName()))
-                    .switchIfEmpty(Mono.just("")) //Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
+                            .is(f.posterTemplateId())), PosterTemplate.class).flatMap(f0 -> Mono.just(f0.posterTemplateName()))
+                    .switchIfEmpty(Mono.just("")) // Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
                     .onErrorResume(throwable -> Mono.error(new Exception("查询海报模版 id:" + f.posterTemplateId() + "error:" + throwable.getMessage())));
             Mono<String> id = template.selectOne(Query.query(Criteria.where("id").is(f.groupId())), GroupType.class)
                     .flatMap(f1 -> Mono.just(f1.name()))
-                    .switchIfEmpty(Mono.just(""))//Mono.error(new BaseException("查询GroupType id:"+f.groupId()+"=>空"))
+                    .switchIfEmpty(Mono.just(""))// Mono.error(new BaseException("查询GroupType id:"+f.groupId()+"=>空"))
                     .onErrorResume(throwable -> Mono.error(new Exception("查询GroupType id:" + f.groupId() + "error:" + throwable.getMessage())));
             return Mono.zip(Mono.just(f), poster_template_id, id).flatMap(ff -> {
                 PlanNew t1 = ff.getT1();

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/PlanNewOutController.java

@@ -31,7 +31,9 @@ import org.springframework.web.server.ServerWebExchange;
 import reactor.core.publisher.Mono;
 
 import java.net.InetSocketAddress;
+import java.net.URLEncoder;
 import java.net.http.HttpRequest;
+import java.nio.charset.StandardCharsets;
 import java.time.ZonedDateTime;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
@@ -69,6 +71,19 @@ public class PlanNewOutController {
         map.clear();
         log.info("清空计划-H5用户Map数据》》》》》》》》》》》》》》》》》》》》》》 结束");
     }
+
+    /**
+     * 获取二维码缓存信息
+     * @param id
+     * @return {@link Mono}<{@link RStatus}<{@link QrcodeInfo}>>
+     */
+    @GetMapping("getQrcode/{id}")
+    public Mono<RStatus<QrcodeInfo>> getQrcode(@PathVariable("id") Long id){
+        Mono<QrcodeInfo> qrcodeInfoMono = template.selectOne(Query.query(Criteria.where("id").is(id)), QrcodeInfo.class)
+                .switchIfEmpty(Mono.error(new BaseException("id异常 查询结果为空")))
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询异常：：：：" + throwable.getMessage())));
+        return RStatus.success(qrcodeInfoMono);
+    }
     /**
      *通过 code and type 查询 domain
      * @param code
@@ -128,7 +143,7 @@ public class PlanNewOutController {
                     stringMono1 =  Mono.just(" ");
                 }
                 Mono<String> stringMono2 = template.select(Query.query(Criteria.where("group_type_id").is(f.landingPageDomain())
-                        .and("status").is(1).and("type").is(type)), DomainSelect.class)
+                        .and("status").is(1).and("type").is(type).and("deleted_at").isNull()), DomainSelect.class)
                         .switchIfEmpty(Mono.error(new BaseException("查询domain 返回结果为空")))
                         .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage()))).collectList().flatMap(fm -> {
                           //  DomainSelectRes domainSelectRes = new DomainSelectRes();
@@ -160,7 +175,7 @@ public class PlanNewOutController {
                     .switchIfEmpty(Mono.error(new BaseException("计划code异常 返回结果为空"))) //Mono.error(new BaseException("查询海报模版 id:"+f.posterTemplateId()+"=>空"))
                     .onErrorResume(throwable -> Mono.error(new Exception(  throwable.getMessage())));
             Mono<DomainSelectRes> domainSelectResMono1 = code1.flatMap(f -> template.select(Query.query(Criteria.where("group_type_id").is(f.groupId())
-                    .and("status").is(1).and("type").is(type)), DomainSelect.class)
+                    .and("status").is(1).and("type").is(type).and("deleted_at").isNull()), DomainSelect.class)
                     .switchIfEmpty(Mono.error(new BaseException("查询domain 返回结果为空")))
                     .onErrorResume(throwable -> Mono.error(new Exception(throwable.getMessage()))).collectList().flatMap(fm -> {
                         DomainSelectRes domainSelectRes = new DomainSelectRes();
@@ -541,6 +556,7 @@ public class PlanNewOutController {
                 dataLists0.setSpare(f.getT5().toString());
                 dataLists0.setRedirectType(f.getT1().redirectType());
                 dataLists0.setPlanNew(f.getT1());
+                dataLists0.setGroupListDisplay(f.getT1().groupListDisplay());
                 dataLists0.setPosterTemplate(f.getT2());
                 List<Poster> t3 = f.getT3();
                 if(t3.size()!=0){
@@ -621,38 +637,75 @@ public class PlanNewOutController {
                 PlanNewBackgroupPoster fxSetting = fm.getFxSetting();
                 goRequest = setNameVal(posterTemplate, fxSetting,fm.getSpare());
             }
-            String ret;
-            if (Objects.nonNull(goRequest)) {
-                ret = goGenerateService.goGenerate(JSONUtil.toJsonStr(goRequest));
-            } else {
-
-                ret = goGenerateService.goGenerate(posterTemplate);
+            if (Objects.nonNull(goRequest) && Objects.nonNull(goRequest.getItem())) {
+                Optional<Item> first = goRequest.getItem().stream()
+                        .filter(ff -> "title".equals(ff.getT()) && ff.getIsRandom())
+                        .findFirst();
+                first.ifPresent(item -> fm.setGroupTitle(item.getV()));
+                Optional<Item> first1 = goRequest.getItem().stream().filter(ff -> "cover".equals(ff.getT()) && ff.getIsRandom()).findFirst();
+                first1.ifPresent(item -> fm.setGroupHeadUrl(item.getV()));
             }
-            if (Objects.nonNull(ret)) {
-                JSONObject jsonObject1;
-                try {
-                     jsonObject1 =  JSONUtil.parseObj(ret);
-                }catch (Exception e){
-                    throw new BaseException(e.getMessage() +"---"+JSONUtil.parseObj(goRequest));
+            if (Objects.isNull(goRequest)) {
+                throw  new BaseException("isNull(goRequest) setEndData()");
+            }
+            QrcodeInfo stringBuilder = getQrcodeInfo(goRequest);
+            Mono<QrcodeInfo> qrcodeInfoMono = template.insert(stringBuilder)
+                    .onErrorResume(throwable -> Mono.error(new BaseException("插入QrcodeInfo异常：：：：" + throwable.getMessage())));;
+//            if(Objects.nonNull(fm.getPlanNew().groupListDisplay()) && fm.getPlanNew().groupListDisplay()==1){
+//                qrcodeInfoMono = template.insert(stringBuilder)
+//                                .onErrorResume(throwable -> Mono.error(new BaseException("插入QrcodeInfo异常：：：：" + throwable.getMessage())));
+//            }else {
+//                qrcodeInfoMono = Mono.just(stringBuilder);
+//            }
+           return Mono.zip(qrcodeInfoMono,Mono.just(goRequest),Mono.just(fm)).flatMap(f9->{
+                GoRequest goRequest2 = f9.getT2();
+                if (Objects.nonNull(f9.getT1().id())) {
+                    goRequest2.getItem().stream().filter(f1 -> "qrcode".equals(f1.getT())).forEach(fe->{
+                        if (Objects.nonNull(fe.getV())) {
+                            if (fe.getV().contains("?")){
+                                String qrcode = fe.getV() + "&id=" + f9.getT1().id();
+                                fe.setV(qrcode);
+                            }else{
+                                String qrcode = fe.getV() + "?id=" + f9.getT1().id();
+                                fe.setV(qrcode);
+                            }
+                        }
+                    });
                 }
-                if (jsonObject1.containsKey("code") && jsonObject1.get("code", Integer.class) == 0 && jsonObject1.containsKey("data")) {
-                    JSONObject data = jsonObject1.get("data", JSONObject.class);
-                    if (data.containsKey("Url")) {
-                        String url = data.get("Url", String.class);
-                        if (Objects.nonNull(request.getWx_user_id()) && !"".equals(request.getWx_user_id())) {
-                            fm.setQsGenerateImagesUrl(url);
-                        } else {
-                            fm.setFxGenerateImagesUrl(url);
+                DataLists0 fm3 = f9.getT3();
+                String ret = goGenerateService.goGenerate(JSONUtil.toJsonStr(goRequest2));
+                if (Objects.nonNull(ret)) {
+                    JSONObject jsonObject1;
+                    try {
+                        jsonObject1 =  JSONUtil.parseObj(ret);
+                    }catch (Exception e){
+                        throw new BaseException(e.getMessage() +"---"+JSONUtil.parseObj(goRequest2));
+                    }
+                    if (jsonObject1.containsKey("code")
+                            && jsonObject1.get("code", Integer.class) == 0
+                            && jsonObject1.containsKey("data")) {
+                        JSONObject data = jsonObject1.get("data", JSONObject.class);
+                        if (data.containsKey("Url")) {
+                            String url = data.get("Url", String.class);
+                            if (Objects.nonNull(request.getWx_user_id()) && !"".equals(request.getWx_user_id())) {
+                                fm3.setQsGenerateImagesUrl(url);
+                            } else {
+                                fm3.setFxGenerateImagesUrl(url);
+                            }
                         }
-
                     }
                 }
-            }
-            return Mono.just(fm);
+                return Mono.just(fm3);
+            });
         });
         return dataLists0Mono1;
     }
-
+    private QrcodeInfo getQrcodeInfo(GoRequest goRequest)  {
+        Optional<Item> first = goRequest.getItem().stream().filter(ff -> "cover".equals(ff.getT()) ).findFirst();
+        Optional<Item> first3 = goRequest.getItem().stream().filter(ff -> "title".equals(ff.getT())).findFirst();
+        QrcodeInfo qrcodeInfo = new QrcodeInfo(null,first.isPresent()?first.get().getV():"",first3.isPresent()?first3.get().getV():"");
+        return qrcodeInfo;
+    }
     // 设置封面等
     private Mono<DataLists0> setFmV(HftRequest request, Mono<DataLists0> zip) {
         Mono<DataLists0> dataLists0Mono2 = zip.flatMap(fm -> {
@@ -670,6 +723,7 @@ public class PlanNewOutController {
             //JSONObject jsonObject = JSONUtil.parseObj(posterTemplate);
             GoRequest goRequest = new GoRequest();
             BeanUtil.copyProperties(jsonObject, goRequest);
+
             Mono<String> outTemPoster;
             if (Objects.nonNull(request.getWx_user_id()) && !"".equals(request.getWx_user_id())) {
                 Long aLong = fm.getPlanNew().groupIdQs();
@@ -754,6 +808,23 @@ public class PlanNewOutController {
         return code.flatMap(plan -> template.selectOne(Query.query(Criteria.where("poster_template_id")
                 .is(plan.posterTemplateId())), PosterTemplate.class));
     }
+    private StringBuilder getStringBuilder(GoRequest goRequest) {
+        Optional<Item> first = goRequest.getItem().stream().filter(ff -> "cover".equals(ff.getT()) ).findFirst();
+        Optional<Item> first3 = goRequest.getItem().stream().filter(ff -> "title".equals(ff.getT())).findFirst();
+        StringBuilder stringBuilder = new StringBuilder("&groupHeadUrl=");
+        stringBuilder.append(first.isPresent()?first.get().getV():"");
+        stringBuilder.append("&groupTitle=");
+        String encodedParam ="";
+        if(first3.isPresent() &&Objects.nonNull(first3.get().getV())){
+            try {
+                encodedParam = URLEncoder.encode(first3.get().getV(), StandardCharsets.UTF_8.toString());
+            }catch (Exception e){
+                throw new BaseException("URLEncoder Error"+e.getMessage());
+            }
+        }
+        stringBuilder.append(first3.isPresent()?encodedParam:"");
+        return stringBuilder;
+    }
 //qrcode 二维码设置
     private GoRequest setNameVal(String posterTemplate, PlanNewBackgroupPoster qsSetting,String spare) {
         JSONObject jsonObject ;
@@ -765,6 +836,7 @@ public class PlanNewOutController {
         //JSONObject jsonObject = JSONUtil.parseObj(posterTemplate);
         GoRequest goRequest = new GoRequest();
         BeanUtil.copyProperties(jsonObject,goRequest);
+       // StringBuilder stringBuilder = getStringBuilder(goRequest);
         if(Objects.nonNull(qsSetting)){
             Optional<Item> first = goRequest.getItem().stream().filter(f -> "qrcode".equals(f.getT())).findFirst();
             if (first.isPresent()) {

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/req/KefuRequest.java

@@ -8,4 +8,12 @@ public class KefuRequest {
     private String unique;
    // private String wxUserId;
     private String wx_user_id;
+    /** 群数量 */
+    private Integer pageShow;
+    /** 分享背景组id */
+    private Long backgroundGroupId;
+    /** 返回音频id */
+    private Long retAudioId;
+    /** 百度统计code */
+    private String baiduDot;
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/req/OutDomainRequest.java

@@ -0,0 +1,20 @@
+package com.webflux.launchadmin.mysql.controller.planNew.req;
+
+import lombok.Data;
+
+/**
+ * H5域名查询请求体
+ *
+ * @author: wangcheng
+ * @date: 2024/7/10 15:13
+ */
+@Data
+public class OutDomainRequest {
+    private String code;
+    /** 计划类型 1.加群计划 2.听书计划 3.交友计划  */
+    private Integer typePlan;
+    /** 域名类型 1是入口域名，2是落地页域名，4是分享背景组域名，5是中转页域名 */
+    private Integer type;
+    /** 落地页域名 */
+    private String landingPageDomain;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/req/PlanNewCommonMaterialReq.java

@@ -0,0 +1,26 @@
+package com.webflux.launchadmin.mysql.controller.planNew.req;
+
+import lombok.Data;
+
+/**
+ * H5通用计划素材请求体
+ *
+ * @author: wangcheng
+ * @date: 2024/7/10 17:59
+ */
+@Data
+public class PlanNewCommonMaterialReq {
+    private String code;
+    /** 群音频id */
+    private Long audioId;
+    /** 返回音频id */
+    private Long retAudioId;
+    /** 返回广告 */
+    private Long returnLoopId;
+    /** 分享背景组id */
+    private Long backgroundGroupId;
+    /**
+     * 外卖模版id
+     */
+    private Long takeawayId;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/req/PlanNewCommonShareReq.java

@@ -0,0 +1,25 @@
+package com.webflux.launchadmin.mysql.controller.planNew.req;
+
+import lombok.Data;
+
+/**
+ * H5通用计划分享请求体
+ *
+ * @author: wangcheng
+ * @date: 2024/7/11 09:46
+ */
+@Data
+public class PlanNewCommonShareReq {
+    private String code;
+    private String unique;
+    private String wx_user_id;
+    private Integer userVisits;
+    /** 1三方链接 2计划链接 */
+    private Integer redirectType;
+    /** 计划链接id */
+    private String redirectPlanId;
+    /** 入群链接 */
+    private String link;
+    /** 清水分类id */
+    private Long groupIdQs;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/req/PlanReq.java

@@ -16,7 +16,7 @@ public class PlanReq {
 //    private String createUser;
 //    private String createId;
     /**
-     * // 1.加群计划 2.听书计划
+     * // 1.加群计划 2.听书计划 3.交友计划
      */
     private  Integer type;
     /**
@@ -109,7 +109,7 @@ public class PlanReq {
     /**
      * 选择计划
      */
-    private  Long redirectPlanId;
+    private  String redirectPlanId;
 
 
     /**
@@ -152,4 +152,12 @@ public class PlanReq {
      * 背景组域名
      */
     private String backgroupDomain;//背景组域名
+
+    /** 配置json */
+    private String configJson;
+
+    /**
+     * 群列表展示
+     */
+    private Integer groupListDisplay;
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/req/PlanReqPage.java

@@ -1,6 +1,10 @@
 package com.webflux.launchadmin.mysql.controller.planNew.req;
+
 import lombok.Data;
 
+/**
+ * @author moka
+ */
 @Data
 public class PlanReqPage {
 
@@ -8,11 +12,21 @@ public class PlanReqPage {
     private Integer page;
     private Integer size;
 
-
-    private String name; //计划名
+    /**
+     * 计划名
+     */
+    private String name;
     private String createUser;
-    private  Integer type;// 1加群裂变2听书计划
-    private  String code;
-    private  Long posterTemplateId;//海报id
+    /**
+     * 1加群裂变2听书计划
+     */
+    private Integer type;
+    private String code;
+    /**
+     * 海报id
+     */
+    private Long posterTemplateId;
+    /** 分类 */
+    private Long groupId;
 
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/res/DataLists0.java

@@ -55,6 +55,16 @@ public class DataLists0 {
     private String limitTimeRemark;
 
     private String spare;
+    /**
+     * 群头像
+     */
+    private String groupHeadUrl;
+    /**
+     * 群名称
+     */
+    private String groupTitle;
+
+    private Integer groupListDisplay;
 
 //
 //    /**

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/res/DataListsKefu.java

@@ -1,9 +1,6 @@
 package com.webflux.launchadmin.mysql.controller.planNew.res;
 
-import com.webflux.launchadmin.mysql.entity.planNew.Ad;
-import com.webflux.launchadmin.mysql.entity.planNew.Audio;
-import com.webflux.launchadmin.mysql.entity.planNew.PlanNew;
-import com.webflux.launchadmin.mysql.entity.planNew.ReturnLoop;
+import com.webflux.launchadmin.mysql.entity.planNew.*;
 import lombok.Data;
 
 import java.util.List;
@@ -14,6 +11,8 @@ public class DataListsKefu {
      * 计划
      */
     private PlanNew planNew;
+
+    private PlanNewCommon planNewCommon;
 //    /**
 //     * 列表音频
 //     */

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/res/DomainSelectRes.java

@@ -2,21 +2,24 @@ package com.webflux.launchadmin.mysql.controller.planNew.res;
 
 import lombok.Data;
 
+/**
+ * @author moka
+ */
 @Data
 public class DomainSelectRes {
-   private String domain ;
-    private String path ;
-    private String unique ;
+    private String domain;
+    private String path;
+    private String unique;
     /**
      * 中转页域名
      */
-    private String transferPageDomain;//中转页域名
+    private String transferPageDomain;
     /**
      * 中转页开关 1:true 0:F
      */
-    private Integer transferPageBl; //中转页开关 1:true 0:F
+    private Integer transferPageBl;
     /**
      * 背景组域名
      */
-    private String backgroupDomain;//背景组域名
+    private String backgroupDomain;
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/res/GroupUserRes.java

@@ -0,0 +1,17 @@
+package com.webflux.launchadmin.mysql.controller.planNew.res;
+
+import lombok.Data;
+
+/**
+ * 群成员返回体
+ *
+ * @author: wangcheng
+ * @date: 2024/7/10 15:55
+ */
+@Data
+public class GroupUserRes {
+    /** 头像 */
+    String userHead;
+    /** 昵称 */
+    String userNickname;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/res/PlanNewAllRs.java

@@ -44,7 +44,7 @@ public class PlanNewAllRs {
     private  Long backgroundGroupIdNewAdd; //background_groupId_new_add
     private  String previewUrl;
     private  Integer redirectType; // 1三方链接 2计划链接
-    private  Long redirectPlanId;
+    private  String redirectPlanId;
     private  String listButton;
 
     /**
@@ -69,4 +69,5 @@ public class PlanNewAllRs {
     private Integer backgroupDomain;//背景组域名
 
 
+    private Integer groupListDisplay;
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/res/PlanNewCommonMaterialRes.java

@@ -0,0 +1,41 @@
+package com.webflux.launchadmin.mysql.controller.planNew.res;
+
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayH5Data;
+import com.webflux.launchadmin.mysql.entity.planNew.Audio;
+import com.webflux.launchadmin.mysql.entity.planNew.ReturnLoop;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * H5通用计划素材返回体
+ *
+ * @author: wangcheng
+ * @date: 2024/7/10 18:07
+ */
+@Data
+public class PlanNewCommonMaterialRes {
+    /**
+     * 群音频
+     */
+    private Audio groupAudio;
+
+    /**
+     * 返回音频
+     */
+    private Audio retAudio;
+
+    /**
+     * 返回广告
+     */
+    private ReturnLoop returnLoop;
+
+    /**
+     * 分享背景组
+     */
+    private List<String> shareUrls;
+    /**
+     *
+     */
+    private TakeawayH5Data takeawayH5Data;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/res/PlanNewCommonRes.java

@@ -0,0 +1,31 @@
+package com.webflux.launchadmin.mysql.controller.planNew.res;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 通用计划配置返回体
+ *
+ * @author: wangcheng
+ * @date: 2024/7/10 15:50
+ */
+@Data
+public class PlanNewCommonRes {
+    private String id;
+    private String name;
+    private String code;
+    /** 计划类型（1加群裂变 2听书裂变 3交友裂变） */
+    private Integer type;
+    /** 分类id  */
+    private Long groupId;
+    /** 海报id */
+    private Long posterTemplateId;
+    /** 入口域名 */
+    private String importDomain;
+    private String configJson;
+    /** 群成员列表 */
+    private List<GroupUserRes> groupUserList;
+    /** 群信息 */
+    private List<H5ImageAndText> groupImageAndTextList;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/planNew/res/PlanNewCommonShareRes.java

@@ -0,0 +1,62 @@
+package com.webflux.launchadmin.mysql.controller.planNew.res;
+
+import com.webflux.launchadmin.mysql.entity.planNew.*;
+import lombok.Data;
+
+/**
+ * H5通用计划分享海报返回体
+ *
+ * @author: wangcheng
+ * @date: 2024/7/11 09:35
+ */
+@Data
+public class PlanNewCommonShareRes {
+    /**
+     * 计划
+     */
+    private PlanNewCommon planNew;
+
+
+    /**
+     * 海报模版
+     */
+    private PosterTemplate posterTemplate;
+
+    /**
+     * 海报组
+     */
+    private Poster poster;
+
+    /**
+     * 分享-配置
+     */
+    private PlanNewBackgroupPoster fxSetting;
+    /**
+     * 清水-配置
+     */
+    private PlanNewBackgroupPoster qsSetting;
+    /**
+     * 分享-生成图片
+     */
+    private String fxGenerateImagesUrl;
+    /**
+     * 清水-生成图片
+     */
+    private String qsGenerateImagesUrl;
+
+    /**
+     * 音频
+     */
+    private Audio audio;
+
+    private String link;
+    private Integer redirectType;
+
+    private String limitTime;
+
+    private String limitTimeRemark;
+
+    private String spare;
+
+    private Integer type;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/takeawayController/TakeawayController.java

@@ -0,0 +1,88 @@
+package com.webflux.launchadmin.mysql.controller.takeawayController;
+
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayDeleteRes;
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayOneRes;
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayRes;
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+import com.webflux.launchadmin.mysql.entity.takeaway.Takeaway;
+import com.webflux.launchadmin.mysql.entity.takeaway.dto.TakeawayDto;
+import com.webflux.launchadmin.mysql.service.takeaway.TakeawayServicesInterface;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import jakarta.validation.constraints.NotNull;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Mono;
+import java.util.List;
+
+/**
+ * 外卖
+ * @author lw12420
+ * @date 2024/07/15
+ */
+@RestController
+@RequestMapping("in/takeaway")
+public class TakeawayController {
+
+    @Resource
+    private TakeawayServicesInterface takeawayServicesInterface;
+
+
+    /**
+     * 外卖模版下拉
+     *
+     * @param takeawayName 默认值 ""
+     * @return {@link Mono}<{@link RStatus}<{@link Takeaway}>>
+     */
+    @GetMapping("getSltList")
+    public  Mono<RStatus<List<Takeaway>>> getSelectList(@RequestParam("takeawayName") String takeawayName){
+      return   takeawayServicesInterface.getSelectList(takeawayName);
+
+    }
+    /**
+     * 列表查询
+     * @param takeawayName 名称 默认空字符串
+     * @param page
+     * @param size
+     * @return {@link Mono}<{@link RStatus}<{@link Paged}<{@link GroupUsers}>>>
+     */
+    @GetMapping("page")
+    public Mono<RStatus<Paged<TakeawayRes>>> page(@RequestParam("takeawayName") String takeawayName,
+                                                  @RequestParam("page")int page,
+                                                  @RequestParam("size")int size){
+        return takeawayServicesInterface.page(takeawayName, page, size);
+    }
+
+
+    /**
+     * 通过id删除 支持批量 案例：././deleteById/1,2,3
+     * @param takeawayId
+     * @return {@link Mono}<{@link RStatus}<{@link Long}>>
+     */
+    @DeleteMapping("deleteById/{takeawayId}")
+    public Mono<RStatus<TakeawayDeleteRes<Long>>> deleteById(@PathVariable("takeawayId") @NotNull Long[]  takeawayId) {
+        return  takeawayServicesInterface.deleteById(takeawayId);
+
+    }
+
+    /**
+     * 新增或修改 （groupUsersId校验是否有值）
+     * @param takeawayDto
+     * @return {@link Mono}<{@link RStatus}<{@link GroupUsers}>>
+     */
+    @PostMapping("saveOrUpdate")
+    public Mono<RStatus<Takeaway>> saveOrUpdate(@RequestBody TakeawayDto takeawayDto) {
+        return  takeawayServicesInterface.saveOrUpdate(takeawayDto);
+    }
+
+    /**
+     * 回显通过id查询
+     * @param takeawayId
+     * @return {@link Mono}<{@link RStatus}<{@link GroupUsers}>>
+     */
+    @GetMapping("getById/{takeawayId}")
+    public Mono<RStatus<TakeawayOneRes>> getById(@PathVariable("takeawayId") @NotNull Long  takeawayId) {
+        return  takeawayServicesInterface.getById(takeawayId);
+    }
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/takeawayController/res/ColItemRs.java

@@ -0,0 +1,16 @@
+package com.webflux.launchadmin.mysql.controller.takeawayController.res;
+
+import lombok.Data;
+
+@Data
+public class ColItemRs {
+
+    /**
+     * 选择类型名称
+     */
+    private String imageUrl;
+    /**
+     * 顺序
+     */
+    private Integer index;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/takeawayController/res/TakeawayDeleteRes.java

@@ -0,0 +1,12 @@
+package com.webflux.launchadmin.mysql.controller.takeawayController.res;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+public class TakeawayDeleteRes<T> {
+    private List<T> Ids;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/takeawayController/res/TakeawayH5Data.java

@@ -0,0 +1,18 @@
+package com.webflux.launchadmin.mysql.controller.takeawayController.res;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class TakeawayH5Data {
+    /**
+     * 主图
+     */
+    private String mainImageUrl;
+    /**
+     * 其他栏
+     */
+    private List<ColItemRs> items;
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/takeawayController/res/TakeawayOneRes.java

@@ -0,0 +1,22 @@
+package com.webflux.launchadmin.mysql.controller.takeawayController.res;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.webflux.launchadmin.mysql.entity.takeaway.dto.ColItem;
+import lombok.Data;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+
+@Data
+public class TakeawayOneRes {
+   private Long takeawayId;
+    private String takeawayName;
+    private String createUser;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime createdAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime updatedAt;
+    private String createId;
+    private Integer colNum;
+    private List<ColItem> colJson;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/controller/takeawayController/res/TakeawayRes.java

@@ -0,0 +1,20 @@
+package com.webflux.launchadmin.mysql.controller.takeawayController.res;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.ZonedDateTime;
+
+@Data
+public class TakeawayRes {
+   private Long takeawayId;
+    private String takeawayName;
+    private String createUser;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime createdAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime updatedAt;
+    private String createId;
+    private Integer colNum;
+    private String colJson;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/groupUsers/Dto/GroupUsersDto.java

@@ -0,0 +1,25 @@
+package com.webflux.launchadmin.mysql.entity.groupUsers.Dto;
+
+import lombok.Data;
+
+@Data
+public class GroupUsersDto {
+    /**
+     * id 修改必填
+     */
+    private Long groupUsersId;//id
+    /**
+     * 头像
+     */
+    private  String groupUsersHead;
+    /**
+     * 昵称
+     */
+    private String groupUsersNickname;
+
+    /**
+     * 分類
+     */
+    private Integer groupUsersType;
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/groupUsers/GroupUsers.java

@@ -0,0 +1,22 @@
+package com.webflux.launchadmin.mysql.entity.groupUsers;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.ZonedDateTime;
+
+@Table("group_users")
+public record GroupUsers(
+        @Id Long groupUsersId,//id
+        String groupUsersHead,//头像
+        String groupUsersNickname,//昵称
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime createdAt,
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime updatedAt,
+        Integer groupUsersType,
+        String createUser,
+        String createId
+
+) {
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/planNew/PlanNew.java

@@ -42,13 +42,14 @@ public record PlanNew(
         Long backgroundGroupIdNewAdd, //background_groupId_new_add
         String previewUrl,
         Integer redirectType, // 1三方链接 2计划链接
-        Long redirectPlanId,
+        String redirectPlanId,
         String importDomain, //入口域名
         String landingPageDomain,//落地页域名
         String transferPageDomain,//中转页域名
         Integer transferPageBl, //中转页开关 1:true 0:F
         String backgroupDomain,//背景组域名
-        String listButton
+        String listButton,
+        Integer groupListDisplay
 
 ) {
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/planNew/PlanNewBackgroupPoster.java

@@ -21,7 +21,7 @@ public record PlanNewBackgroupPoster(@Id Long id,//
                                      Integer index,//	背景图序号
                                      String serviceGroupId,//客服组 ，分割
                                      Integer serviceGroupType ,//1：客服组 2：上传图片
-                                     Integer qsOrFx,//1：分享背景组 2：清水背景组
+                                     Integer qsOrFx,//1：分享背景组 2：清水背景组 3客服列表背景组
                                      @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime createdAt,
                                      @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime updatedAt,
                                      @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime deletedAt,

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/planNew/PlanNewCommon.java

@@ -0,0 +1,39 @@
+package com.webflux.launchadmin.mysql.entity.planNew;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.ZonedDateTime;
+
+/**
+ * 裂变通用计划配置列表
+ *
+ * @author: wangcheng
+ * @date: 2024/7/9 15:52
+ */
+@Table("plan_new_common")
+public record PlanNewCommon(
+        @Id
+        String id,
+        String name,
+        String code,
+        /* 计划类型（1加群裂变 2听书裂变 3交友裂变） */
+        Integer type,
+        /* 分类id  */
+        Long groupId,
+        /* 海报id */
+        Long posterTemplateId,
+        /* 入口域名 */
+        String importDomain,
+        String previewUrl,
+        String configJson,
+        String createUser,
+        String createId,
+        String updateUser,
+        String updateId,
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+        ZonedDateTime createdAt,
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+        ZonedDateTime updateAt) {
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/planNew/QrcodeInfo.java

@@ -0,0 +1,8 @@
+package com.webflux.launchadmin.mysql.entity.planNew;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Table;
+
+@Table("qrcode_info")
+public record QrcodeInfo(@Id Long  id,String url,String title) {
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/redis/RedisKey.java

@@ -0,0 +1,17 @@
+package com.webflux.launchadmin.mysql.entity.redis;
+
+/**
+ * redis-key
+ *
+ * @author: wangcheng
+ * @date: 2024/7/12 10:06
+ */
+public class RedisKey {
+    private RedisKey() {
+    }
+
+    /**
+     * 音频缓冲
+     */
+    public static final String FISSION_AUDIO = "fission_audio:";
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/takeaway/Takeaway.java

@@ -0,0 +1,26 @@
+package com.webflux.launchadmin.mysql.entity.takeaway;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.ZonedDateTime;
+
+@Table("takeaway")
+public record Takeaway(
+        @Id Long takeawayId,
+        String takeawayName,
+        String createUser,
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime createdAt,
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime updatedAt,
+        String createId,
+        Integer colNum,
+        String colJson
+
+) {
+    public static Takeaway getNull(){
+        return new Takeaway(null,null,null,null,null,null,null,null);
+    }
+
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/takeaway/dto/ColItem.java

@@ -0,0 +1,23 @@
+package com.webflux.launchadmin.mysql.entity.takeaway.dto;
+
+import lombok.Data;
+
+@Data
+public class ColItem {
+    /**
+     * 选择类型
+     */
+    private Long type;
+    /**
+     * 选择类型名称
+     */
+    private String typeName;
+    /**
+     * 行名称（选填）
+     */
+    private String ColName;
+    /**
+     * 顺序
+     */
+    private Integer index;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/takeaway/dto/TakeawayDto.java

@@ -0,0 +1,24 @@
+package com.webflux.launchadmin.mysql.entity.takeaway.dto;
+import lombok.Data;
+import java.util.List;
+
+@Data
+public class TakeawayDto {
+    /**
+     * id(修改必填) 保存值为null
+     */
+     private Long takeawayId;
+    /**
+     * 名称
+     */
+    private String takeawayName;
+    /**
+     * 栏位数量
+     */
+    private Integer colNum;
+    /**
+     * 栏位内容
+     */
+    private List<ColItem> colJson;
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/TempAll.java

@@ -0,0 +1,23 @@
+package com.webflux.launchadmin.mysql.entity.tempAll;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.ZonedDateTime;
+
+@Table("temp_all")
+public record TempAll(@Id Long id,
+                      String jsonContent,
+                      String name,
+                      String createUser,
+                      @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime createdAt,
+                      @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime updatedAt,
+                      String createId,
+                      Integer type
+                      ) {
+
+    public static TempAll getNull(){
+        return new TempAll(null,null,null,null,null,null,null,null);
+    }
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/dto/TempAllDto.java

@@ -0,0 +1,20 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.ZonedDateTime;
+
+@Data
+public class TempAllDto {
+    /**
+     * id 修改必填
+     */
+    private Long id;
+    /**
+     * 名称
+     */
+    private  String name;
+
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/dto/TempAllDtoContentA.java

@@ -0,0 +1,8 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.dto;
+
+import lombok.Data;
+
+@Data
+public class TempAllDtoContentA extends TempAllDto{
+    private String jsonContent;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/dto/TempAllDtoInfo.java

@@ -0,0 +1,17 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.ZonedDateTime;
+
+@Data
+public class TempAllDtoInfo extends TempAllDtoContentA {
+    private String createUser;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime createdAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime updatedAt;
+    private  String createId;
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/dto/TempAllDtoNext.java

@@ -0,0 +1,8 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.dto;
+
+import lombok.Data;
+
+@Data
+public class TempAllDtoNext extends TempAllDtoContentA {
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/dto/type1/TempAllDtoContentA1.java

@@ -0,0 +1,9 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.dto.type1;
+
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDto;
+import lombok.Data;
+
+@Data
+public class TempAllDtoContentA1 extends TempAllDto {
+    private String jsonContent;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/dto/type1/TempAllDtoInfo1.java

@@ -0,0 +1,18 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.dto.type1;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoContentA;
+import lombok.Data;
+
+import java.time.ZonedDateTime;
+
+@Data
+public class TempAllDtoInfo1 extends TempAllDtoContentA1 {
+    private String createUser;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime createdAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private ZonedDateTime updatedAt;
+    private  String createId;
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/dto/type1/TempAllDtoNext1.java

@@ -0,0 +1,9 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.dto.type1;
+
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoContentA;
+import lombok.Data;
+
+@Data
+public class TempAllDtoNext1 extends TempAllDtoContentA1 {
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/res/DeleteRes.java

@@ -0,0 +1,12 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.res;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+public class DeleteRes<T> {
+    private List<T> Ids;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/res/SaveOrUpdateRes.java

@@ -0,0 +1,12 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.res;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+public class SaveOrUpdateRes {
+    private Long id;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/res/TempAllRes.java

@@ -0,0 +1,18 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.res;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.ZonedDateTime;
+
+@Data
+public class TempAllRes {
+    private Long id;
+    private  String name;
+    private  String createUser;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private  ZonedDateTime createdAt;
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") ZonedDateTime updatedAt;
+    private  String createId;
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/res/TempAllRsNext.java

@@ -0,0 +1,10 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.res;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class TempAllRsNext extends TempAllRes {
+    private List lists;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/entity/tempAll/res/Type1/TempAllRsNext1.java

@@ -0,0 +1,11 @@
+package com.webflux.launchadmin.mysql.entity.tempAll.res.Type1;
+
+import com.webflux.launchadmin.mysql.entity.tempAll.res.TempAllRes;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class TempAllRsNext1 extends TempAllRes {
+    private List lists;
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/repository/groupUsers/GroupUsersRepository.java

@@ -0,0 +1,17 @@
+package com.webflux.launchadmin.mysql.repository.groupUsers;
+
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+
+import org.springframework.data.domain.Example;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+
+@Repository
+public interface GroupUsersRepository extends ReactiveCrudRepository<GroupUsers,Long> {
+    Flux<GroupUsers> findByGroupUsersType(String groupUsersType, Pageable pageable);
+    Flux<GroupUsers> findByGroupUsersType(String groupUsersType);
+
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/repository/takeaway/TakeawayRepository.java

@@ -0,0 +1,7 @@
+package com.webflux.launchadmin.mysql.repository.takeaway;
+
+import com.webflux.launchadmin.mysql.entity.takeaway.Takeaway;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+
+public interface TakeawayRepository extends ReactiveCrudRepository<Takeaway,Long> {
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/repository/tempAll/TempAllRepository.java

@@ -0,0 +1,7 @@
+package com.webflux.launchadmin.mysql.repository.tempAll;
+
+import com.webflux.launchadmin.mysql.entity.tempAll.TempAll;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+
+public interface TempAllRepository extends ReactiveCrudRepository<TempAll,Long> {
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/groupUsers/GroupUsersServiceImpl.java

@@ -0,0 +1,155 @@
+package com.webflux.launchadmin.mysql.service.groupUsers;
+
+import com.webflux.launchadmin.config.BaseContextHandler;
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.controller.groupUsers.res.DeleteRes;
+import com.webflux.launchadmin.mysql.controller.groupUsers.res.GroupUsersRes;
+import com.webflux.launchadmin.mysql.entity.groupUsers.Dto.GroupUsersDto;
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
+import com.webflux.launchadmin.mysql.entity.planNew.PlanNew;
+import com.webflux.launchadmin.mysql.repository.groupUsers.GroupUsersRepository;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import org.springframework.data.domain.*;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Service
+public class GroupUsersServiceImpl implements GroupUsersServiceInterface {
+    @Resource
+    private GroupUsersRepository groupUsersRepository;
+    @Resource
+    private R2dbcEntityTemplate template;
+
+    @Override
+    public Mono<RStatus<Paged<GroupUsersRes>>> page(Integer type, int page, int size) {
+        Criteria criteria = Criteria.empty();
+        if (Objects.nonNull(type) &&type>0) {
+            criteria = criteria.and("group_users_type").is(type);
+        }
+        Query query = Query.query(criteria);
+        int skip = (page - 1) *size;
+        int limit = size;
+        Mono<Long> count = template.count(query, GroupUsers.class);
+        Mono<List<GroupUsers>> created_at = template.select(Query.query(criteria)
+                .offset(skip)
+                .limit(limit)
+                .sort(Sort.by(Sort.Order.desc("created_at"))), GroupUsers.class)
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询失败::error::" + throwable.getMessage())))
+                .collectList();
+        Mono<Paged<GroupUsersRes>> id1 = Mono.zip(count, created_at).flatMap(f -> {
+            List<GroupUsers> t2 = f.getT2();
+            List<Integer> collect = t2.stream()
+                    .filter(f3->Objects.nonNull(f3.groupUsersType()))
+                    .map(GroupUsers::groupUsersType)
+                    .collect(Collectors.toList());
+            if (collect.isEmpty()) {
+                collect.add(0);
+            }
+            Mono<List<GroupType>> id = template.select(Query.query(Criteria.where("id").in(collect)), GroupType.class)
+                    .collectList()
+                    .onErrorResume(throwable -> Mono.error(new BaseException("查询groupType异常" + throwable.getMessage())));
+            return Mono.zip(id, Mono.just(f.getT1()), Mono.just(f.getT2())).flatMap(fff -> {
+                List<GroupUsers> t3 = fff.getT3();
+                Long t21 = fff.getT2();
+                List<GroupType> t1 = fff.getT1();
+                List<GroupUsersRes> collect1 = t3.stream().map(fm -> {
+                    GroupUsersRes groupUsersRes = new GroupUsersRes();
+                    groupUsersRes.setGroupUsersId(fm.groupUsersId());
+                    groupUsersRes.setGroupUsersHead(fm.groupUsersHead());
+                    groupUsersRes.setGroupUsersType(fm.groupUsersType());
+                    groupUsersRes.setGroupUsersNickname(fm.groupUsersNickname());
+                    groupUsersRes.setCreatedAt(fm.createdAt());
+                    groupUsersRes.setCreateUser(fm.createUser());
+                    return groupUsersRes;
+                }).collect(Collectors.toList());
+                collect1.stream().filter(f1 -> Objects.nonNull(f1.getGroupUsersType())).forEach(fe1 -> {
+                    Optional<String> first = t1.stream()
+                            .filter(f11 -> f11.id() == Long.valueOf(fe1.getGroupUsersType()))
+                            .map(GroupType::name).findFirst();
+                    first.ifPresent(fe1::setGroupUsersName);
+                });
+                Paged<GroupUsersRes> groupUsersPaged = new Paged<>(t21, collect1, page, size);
+                return Mono.just(groupUsersPaged);
+            });
+
+        });
+        return RStatus.successList(id1);
+    }
+
+    @Override
+    public Mono<RStatus<DeleteRes>> deletePosterById(Long[] groupUsersId) {
+        Mono<DeleteRes> deleteResMono = groupUsersRepository
+                .deleteAllById(List.of(groupUsersId))
+                .then(Mono.just(new DeleteRes(List.of(groupUsersId))))
+                .onErrorResume(throwable -> Mono.error(new BaseException("删除：：error：：" + throwable.getMessage())));
+        return RStatus.success(deleteResMono);
+    }
+
+    @Override
+    public Mono<RStatus<GroupUsers>> saveOrUpdate(GroupUsersDto groupUsersDto) {
+        ZonedDateTime now = ZonedDateTime.now();
+        if(Objects.isNull(groupUsersDto.getGroupUsersId())){
+            Mono<GroupUsers> insert = insertGroupUsersMono(groupUsersDto, BaseContextHandler.getUserName(), BaseContextHandler.getUserId(), now);
+            return RStatus.success(insert);
+        }else {
+            Mono<GroupUsers> groupUsersMono = updateGroupUsersMono(groupUsersDto, now);
+            return RStatus.success(groupUsersMono);
+        }
+    }
+
+    @Override
+    public Mono<RStatus<GroupUsers>> getById(Long groupUsersId) {
+        Mono<GroupUsers> groupUsersMono = groupUsersRepository
+                .findById(groupUsersId)
+                .switchIfEmpty( Mono.error(new BaseException("id异常 查询结果为空")))
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询失败：：" + throwable.getMessage())));
+        return RStatus.success(groupUsersMono);
+    }
+
+    private Mono<GroupUsers> updateGroupUsersMono(GroupUsersDto groupUsersDto, ZonedDateTime now) {
+        return groupUsersRepository.findById(groupUsersDto.getGroupUsersId())
+                .onErrorResume(throwable -> Mono.error(new BaseException("修改失败：：" + throwable.getMessage())))
+                .flatMap(f -> {
+                    GroupUsers groupUsers = new GroupUsers(groupUsersDto.getGroupUsersId(),
+                            groupUsersDto.getGroupUsersHead(),
+                            groupUsersDto.getGroupUsersNickname(),
+                            f.createdAt(),
+                            now,
+                            groupUsersDto.getGroupUsersType(),
+                            f.createUser(),
+                            f.createId()
+                    );
+                 return groupUsersRepository.save(groupUsers)
+                         .onErrorResume(throwable -> Mono.error(new BaseException("修改失败：：" + throwable.getMessage())));
+                });
+    }
+
+    private Mono<GroupUsers> insertGroupUsersMono(GroupUsersDto groupUsersDto, String userName, String userId, ZonedDateTime now) {
+        GroupUsers groupUsers = new GroupUsers(groupUsersDto.getGroupUsersId(),
+                groupUsersDto.getGroupUsersHead(),
+                groupUsersDto.getGroupUsersNickname(),
+                now,
+               null,
+                groupUsersDto.getGroupUsersType(),
+                userName,
+                userId
+        );
+        return template.insert(groupUsers)
+                .onErrorResume(throwable -> Mono.error(new BaseException("插入失败：："+ throwable.getMessage())));
+    }
+}
+

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/groupUsers/GroupUsersServiceInterface.java

@@ -0,0 +1,21 @@
+package com.webflux.launchadmin.mysql.service.groupUsers;
+
+import com.webflux.launchadmin.mysql.controller.groupUsers.res.DeleteRes;
+import com.webflux.launchadmin.mysql.controller.groupUsers.res.GroupUsersRes;
+import com.webflux.launchadmin.mysql.entity.groupUsers.Dto.GroupUsersDto;
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+
+public interface GroupUsersServiceInterface {
+    Mono<RStatus<Paged<GroupUsersRes>>> page(Integer type, int page, int size);
+
+    Mono<RStatus<DeleteRes>> deletePosterById(Long[] groupUsersId);
+
+    Mono<RStatus<GroupUsers>> saveOrUpdate(GroupUsersDto groupUsersDto);
+
+    Mono<RStatus<GroupUsers>> getById(Long groupUsersId);
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/listening/ListeningPlanServiceImpl.java

@@ -52,28 +52,11 @@ public class ListeningPlanServiceImpl implements ListeningPlanServiceInterface{
     @Resource
     private R2dbcEntityTemplate template;
     @Override
-    public Mono<RStatus<Paged<ListeningPlanNewRes2>>> page(PlanReqPage request) {
-        Criteria criteria= Criteria.empty() ; //poster_template_id
-        if (Objects.nonNull(request.getCode()) && "" != request.getCode().trim()) {
-            criteria = criteria.and("code").like("%"+request.getCode()+"%");
-        }
-        if (Objects.nonNull(request.getName()) && "" != request.getName().trim()) {
-            criteria = criteria.and("name").like("%"+request.getName()+"%");
-        }
-        if (Objects.nonNull(request.getCreateUser()) && "" != request.getCreateUser().trim()) {
-            criteria = criteria.and("create_user").like("%"+request.getCreateUser()+"%");
-        }
-        if (Objects.nonNull(request.getPosterTemplateId()) && 0L != request.getPosterTemplateId()) {
-            criteria = criteria.and("poster_template_id").is(request.getPosterTemplateId());
-        }
-//        if (Objects.nonNull(request.getType()) && 0 != request.getType()) {
-//            criteria = criteria.and("type").is(request.getType());
-//        }
+    public Mono<RStatus<Paged<ListeningPlanNewRes2>>> page(PlanReqPage request, Criteria criteria) {
         Query query = Query.query(criteria);
-        Criteria finalCriteria = criteria;
         int skip  = (request.getPage() - 1) * request.getSize();
         int limit = request.getPage() * request.getSize();
-        return RStatus.successList(Mono.zip(template.count(query, ListeningPlanNew.class), template.select(Query.query(finalCriteria)
+        return RStatus.successList(Mono.zip(template.count(query, ListeningPlanNew.class), template.select(Query.query(criteria)
                 .offset(skip)
                 .limit(limit)
                 .sort(Sort.by(Sort.Order.desc("created_at"))), ListeningPlanNew.class).flatMap(f -> {

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/listening/ListeningPlanServiceInterface.java

@@ -14,6 +14,7 @@ import com.webflux.launchadmin.mysql.entity.planNew.PlanNew;
 import com.webflux.launchadmin.mysql.service.planNew.structure.GoRequest;
 import com.webflux.launchcommon.returnObj.Paged;
 import com.webflux.launchcommon.returnObj.RStatus;
+import org.springframework.data.relational.core.query.Criteria;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestParam;
 import reactor.core.publisher.Mono;
@@ -22,7 +23,7 @@ import java.util.List;
 
 public interface ListeningPlanServiceInterface {
      Mono<RStatus<List<GroupType>>> groupTypeSlt ( String name);
-    Mono<RStatus<Paged<ListeningPlanNewRes2>>> page(PlanReqPage request);
+    Mono<RStatus<Paged<ListeningPlanNewRes2>>> page(PlanReqPage request, Criteria criteria);
     Mono<RStatus<String>> savePlan(PlanReq saveRequest);
     Mono<List<StringBuilder>> setCusqrcodeRtUrl(GoRequest goRequest);
     Mono<RStatus<ListeningAudio>> saveOrUpdateAudio(ListeningAudioReq saveRequest);

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/otherServices/OtherServicesImpl.java

@@ -0,0 +1,152 @@
+package com.webflux.launchadmin.mysql.service.otherServices;
+
+import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.RandomUtil;
+import cn.hutool.core.util.StrUtil;
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.controller.otherServices.res.ByCodeGetImportDomainRes;
+import com.webflux.launchadmin.mysql.controller.planNew.res.PlanNewAllRs;
+import com.webflux.launchadmin.mysql.entity.listening.ListeningPlanNew;
+import com.webflux.launchadmin.mysql.entity.planNew.DomainSelect;
+import com.webflux.launchadmin.mysql.entity.planNew.PlanNew;
+import com.webflux.launchadmin.mysql.service.planNew.structure.Item;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.time.ZonedDateTime;
+import java.util.Objects;
+
+@Service
+public class OtherServicesImpl implements   OtherServicesInterface {
+
+    @Resource
+    private R2dbcEntityTemplate template;
+    @Override
+    public Mono<RStatus<ByCodeGetImportDomainRes>> byCodeGetImportDomain(String code) {
+        Query query = Query.query(Criteria.where("code").is(code));
+        Mono<Long> planNew = template.count(query, PlanNew.class)
+                .onErrorResume(throwable ->
+                        Mono.error(new Exception(StrUtil
+                                .format("通过code：{}查询是否裂变计划异常：：：{}",
+                                        code,
+                                        throwable.getMessage()))));
+        Mono<Long> listeningPlan = template
+                .count(query, ListeningPlanNew.class)
+                .onErrorResume(throwable ->
+                        Mono.error(new Exception(StrUtil
+                                .format("通过code：{}查询是否听书计划异常：：：{}",
+                                        code,
+                                        throwable.getMessage()))));
+        Mono<ByCodeGetImportDomainRes> stringBuilderMono1 = Mono
+                .zip(planNew, listeningPlan)
+                .flatMap(f -> {
+            Long t1 = f.getT1();
+            Long t2 = f.getT2();
+            Mono<ByCodeGetImportDomainRes> stringBuilderMono;
+            if (t1 > 0) {
+                stringBuilderMono = getNewPlan(code, query);
+            } else if (t2 > 0) {
+                stringBuilderMono = getNewListeningNewPlan(code, query);
+            } else {
+                throw new BaseException("code不存在");
+            }
+            return stringBuilderMono;
+        });
+        return RStatus.success(stringBuilderMono1);
+    }
+
+    private Mono<ByCodeGetImportDomainRes> getNewListeningNewPlan(String code, Query query) {
+        return template.selectOne(query, ListeningPlanNew.class)
+                .switchIfEmpty(Mono
+                        .error(new BaseException(StrUtil
+                                .format("通过code：{}查询裂变计划异常：：：{}",
+                                        code,
+                                        "返回结构为空"))))
+                .onErrorResume(throwable ->
+                        Mono.error(new BaseException(StrUtil
+                                .format("通过code：{}查询裂变计划异常：：：{}",
+                                        code,
+                                        throwable.getMessage()))))
+                .flatMap(ff -> {
+                    Long groupId = ff.groupId();
+                    if (Objects.isNull(groupId)) {
+                        return Mono.error(new BaseException("查询裂变计划 groupId 值为 null"));
+                    }
+                    return getDomainSetV(groupId, code);
+                });
+    }
+
+    private Mono<ByCodeGetImportDomainRes> getNewPlan(String code, Query query) {
+        return template.selectOne(query, PlanNew.class)
+                .switchIfEmpty(Mono
+                        .error(new BaseException(StrUtil
+                                .format("通过code：{}查询裂变计划异常：：：{}",
+                                        code,
+                                        "返回结构为空"))))
+                .onErrorResume(throwable ->
+                        Mono.error(new BaseException(StrUtil
+                                .format("通过code：{}查询裂变计划异常：：：{}",
+                                        code,
+                                        throwable.getMessage()))))
+                .flatMap(ff -> {
+                    String groupIdStr = ff.importDomain();
+                    if (Objects.isNull(groupIdStr)) {
+                        return Mono.error(new BaseException("查询听书计划入口域名类型值为 null"));
+                    }
+                    long groupId;
+                    try {
+                         groupId = Long.parseLong(groupIdStr);
+                    }catch (Exception e){
+                        return Mono.error(new BaseException("查询听书计划入口域名类型值解析错误"+e.getMessage()));
+                    }
+                    return getDomainSetV(groupId, code);
+                });
+    }
+
+    private Mono<ByCodeGetImportDomainRes> getDomainSetV( Long  groupId, String code) {
+        return template.select(Query.query(Criteria.where("group_type_id").is(groupId)
+                .and("status").is(1)
+                .and("type").is(1)
+                .and("deleted_at").isNull()),
+                DomainSelect.class)
+                .collectList()
+                .switchIfEmpty(Mono.error(new BaseException(StrUtil
+                        .format("通过code:{},groupId:{}；查询域名为空",
+                                code,
+                                groupId))))
+                .onErrorResume(throwable ->
+                        Mono.error(new Exception(StrUtil
+                                .format("通过code:{},groupId:{}；查询域名Error::{}",
+                                        code,
+                                        groupId,
+                                        throwable.getMessage()))))
+                .flatMap(f2 -> {
+                    StringBuilder stringBuilder = new StringBuilder();
+                    if(!f2.isEmpty()){
+                        DomainSelect domainSelect = f2.get(RandomUtil.randomInt(0, f2.size()));
+                        stringBuilder.append("http://");
+                        stringBuilder.append(get6Str());
+                        stringBuilder.append(".");
+                        stringBuilder.append(domainSelect.domain());
+                        stringBuilder.append("/index.html?code=");
+                        stringBuilder.append(code);
+                        stringBuilder.append("&sk=");
+                        stringBuilder.append(IdUtil.fastSimpleUUID());
+                    }else {
+                        return Mono.error(new BaseException(StrUtil.format("通过code:{},groupId:{}；查询域名Error::{}",code,groupId,"错误")));
+                    }
+                    ByCodeGetImportDomainRes domain = new ByCodeGetImportDomainRes();
+                    domain.setDomain(stringBuilder.toString());
+                    return Mono.just(domain);
+                });
+    }
+    private String get6Str() {
+        return RandomUtil.randomString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 6);
+    }
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/otherServices/OtherServicesInterface.java

@@ -0,0 +1,10 @@
+package com.webflux.launchadmin.mysql.service.otherServices;
+
+import com.webflux.launchadmin.mysql.controller.otherServices.res.ByCodeGetImportDomainRes;
+import com.webflux.launchadmin.mysql.controller.planNew.res.PlanNewAllRs;
+import com.webflux.launchcommon.returnObj.RStatus;
+import reactor.core.publisher.Mono;
+
+public interface OtherServicesInterface {
+    Mono<RStatus<ByCodeGetImportDomainRes>> byCodeGetImportDomain(String code);
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/planNew/PlanServiceImpl.java

@@ -1,25 +1,12 @@
 package com.webflux.launchadmin.mysql.service.planNew;
 
-import cn.hutool.core.bean.BeanUtil;
-import cn.hutool.core.util.IdUtil;
-import cn.hutool.core.util.RandomUtil;
-import cn.hutool.http.HttpUtil;
-import cn.hutool.json.JSONArray;
-import cn.hutool.json.JSONObject;
-import cn.hutool.json.JSONUtil;
-import com.webflux.launchadmin.config.BaseContextHandler;
-import com.webflux.launchadmin.global.BaseException;
-import com.webflux.launchadmin.mysql.controller.listening.req.*;
-import com.webflux.launchadmin.mysql.controller.listening.res.DataListsShare;
 import com.webflux.launchadmin.mysql.controller.listening.res.ListeningPlanNewRes;
+import com.webflux.launchadmin.mysql.controller.listening.res.ListeningPlanNewRes2;
 import com.webflux.launchadmin.mysql.controller.planNew.req.PlanReqPage;
-import com.webflux.launchadmin.mysql.entity.listening.ListeningAudio;
-import com.webflux.launchadmin.mysql.entity.listening.ListeningPlanNew;
-import com.webflux.launchadmin.mysql.entity.listening.ListeningPlanNewBackgroupPoster;
-import com.webflux.launchadmin.mysql.entity.planNew.*;
-import com.webflux.launchadmin.mysql.service.listening.ListeningPlanServiceInterface;
-import com.webflux.launchadmin.mysql.service.planNew.structure.GoRequest;
-import com.webflux.launchadmin.mysql.service.planNew.structure.Item;
+import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
+import com.webflux.launchadmin.mysql.entity.planNew.PlanNew;
+import com.webflux.launchadmin.mysql.entity.planNew.PlanNewCommon;
+import com.webflux.launchadmin.mysql.entity.planNew.PosterTemplate;
 import com.webflux.launchcommon.returnObj.Paged;
 import com.webflux.launchcommon.returnObj.RStatus;
 import jakarta.annotation.Resource;
@@ -29,19 +16,17 @@ import org.springframework.data.domain.Sort;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.data.relational.core.query.Criteria;
 import org.springframework.data.relational.core.query.Query;
-import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
-import java.time.ZonedDateTime;
 import java.util.Comparator;
 import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 
+/**
+ * @author moka
+ */
 @Slf4j
 @Service
 public class PlanServiceImpl implements PlanServiceInterface {
@@ -51,6 +36,47 @@ public class PlanServiceImpl implements PlanServiceInterface {
     @Resource
     private R2dbcEntityTemplate template;
 
-
+    @Override
+    public Mono<RStatus<Paged<ListeningPlanNewRes2>>> page(PlanReqPage request, Criteria criteria) {
+        Query query = Query.query(criteria);
+        int skip  = (request.getPage() - 1) * request.getSize();
+        int limit =  request.getSize();
+        Mono<Long> count = template.count(query, PlanNewCommon.class);
+        Flux<PlanNewCommon> createdAt = template.select(Query.query(criteria)
+                .offset(skip)
+                .limit(limit)
+                .sort(Sort.by(Sort.Order.desc("created_at"))), PlanNewCommon.class);
+        Mono<List<ListeningPlanNewRes2>> listMono = createdAt.flatMap(f -> {
+            Mono<String> posterTemplateId = template.selectOne(Query.query(Criteria.where("poster_template_id")
+                            .is(f.posterTemplateId())), PosterTemplate.class).flatMap(f0 -> Mono.just(f0.posterTemplateName()))
+                    .switchIfEmpty(Mono.just(""))
+                    .onErrorResume(throwable -> Mono.error(new Exception("查询海报模版 id:" + f.posterTemplateId() + "error:" + throwable.getMessage())));
+            Mono<String> id = template.selectOne(Query.query(Criteria.where("id").is(f.groupId())), GroupType.class)
+                    .flatMap(f1 -> Mono.just(f1.name()))
+                    .switchIfEmpty(Mono.just(""))
+                    .onErrorResume(throwable -> Mono.error(new Exception("查询GroupType id:" + f.groupId() + "error:" + throwable.getMessage())));
+            return Mono.zip(Mono.just(f), posterTemplateId, id).flatMap(ff -> {
+                PlanNewCommon t1 = ff.getT1();
+                ListeningPlanNewRes2 listeningPlanNewRes = new ListeningPlanNewRes2();
+                listeningPlanNewRes.setPlanNewId(t1.id());
+                listeningPlanNewRes.setCode(t1.code());
+                listeningPlanNewRes.setName(t1.name());
+                listeningPlanNewRes.setCreatedAt(t1.createdAt());
+                listeningPlanNewRes.setCreateUser(t1.createUser());
+                listeningPlanNewRes.setType(t1.type());
+                listeningPlanNewRes.setGroupName(ff.getT3());
+                listeningPlanNewRes.setPreviewUrl(t1.previewUrl());
+                listeningPlanNewRes.setPosterTemplateName(ff.getT2());
+                return Mono.just(listeningPlanNewRes);
+            });
+        }).collectList();
+        Mono<Paged<ListeningPlanNewRes2>> pagedMono = Mono.zip(count, listMono).flatMap(ff -> {
+            Long t1 = ff.getT1();
+            List<ListeningPlanNewRes2> t2 = ff.getT2().stream().sorted(Comparator.comparing(ListeningPlanNewRes::getCreatedAt).reversed()).collect(Collectors.toList());
+            Paged<ListeningPlanNewRes2> planNewResPaged = new Paged<>(t1, t2, request.getPage(), request.getSize());
+            return Mono.just(planNewResPaged);
+        });
+        return RStatus.successList(pagedMono);
+    }
 
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/planNew/PlanServiceInterface.java

@@ -1,19 +1,16 @@
 package com.webflux.launchadmin.mysql.service.planNew;
 
-import com.webflux.launchadmin.mysql.controller.listening.req.*;
-import com.webflux.launchadmin.mysql.controller.listening.res.DataListsShare;
-import com.webflux.launchadmin.mysql.controller.listening.res.ListeningPlanNewRes;
+import com.webflux.launchadmin.mysql.controller.listening.res.ListeningPlanNewRes2;
 import com.webflux.launchadmin.mysql.controller.planNew.req.PlanReqPage;
-import com.webflux.launchadmin.mysql.entity.listening.ListeningAudio;
-import com.webflux.launchadmin.mysql.entity.listening.ListeningPlanNew;
-import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
-import com.webflux.launchadmin.mysql.service.planNew.structure.GoRequest;
 import com.webflux.launchcommon.returnObj.Paged;
 import com.webflux.launchcommon.returnObj.RStatus;
+import org.springframework.data.relational.core.query.Criteria;
 import reactor.core.publisher.Mono;
 
-import java.util.List;
-
+/**
+ * @author moka
+ */
 public interface PlanServiceInterface {
+    Mono<RStatus<Paged<ListeningPlanNewRes2>>> page(PlanReqPage request, Criteria criteria);
 
 }

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/takeaway/TakeawayServicesImpl.java

@@ -0,0 +1,253 @@
+package com.webflux.launchadmin.mysql.service.takeaway;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.util.RandomUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.webflux.launchadmin.config.BaseContextHandler;
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.controller.groupUsers.res.DeleteRes;
+import com.webflux.launchadmin.mysql.controller.groupUsers.res.GroupUsersRes;
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.*;
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+import com.webflux.launchadmin.mysql.entity.planNew.GroupType;
+import com.webflux.launchadmin.mysql.entity.planNew.Image;
+import com.webflux.launchadmin.mysql.entity.takeaway.Takeaway;
+import com.webflux.launchadmin.mysql.entity.takeaway.dto.ColItem;
+import com.webflux.launchadmin.mysql.entity.takeaway.dto.TakeawayDto;
+import com.webflux.launchadmin.mysql.repository.takeaway.TakeawayRepository;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import jakarta.annotation.Resource;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.ZonedDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Service
+public class TakeawayServicesImpl implements TakeawayServicesInterface{
+
+    @Resource
+    private TakeawayRepository takeawayRepository;
+    @Resource
+    private R2dbcEntityTemplate template;
+    @Override
+    public Mono<RStatus<Paged<TakeawayRes>>> page(String takeawayName, int page, int size) {
+        Criteria criteria = Criteria.empty();
+        if (Objects.nonNull(takeawayName) && !"".equals(takeawayName.trim())) {
+            criteria = criteria.and("takeaway_name").is(takeawayName);
+        }
+        Query query = Query.query(criteria);
+        int skip = (page - 1) *size;
+        int limit = size;
+        Mono<Long> count = template.count(query, Takeaway.class);
+        Mono<List<Takeaway>> all = template.select(Query.query(criteria)
+                .offset(skip)
+                .limit(limit)
+                .sort(Sort.by(Sort.Order.desc("created_at"))), Takeaway.class)
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询失败::error::" + throwable.getMessage())))
+                .collectList();
+        Mono<Paged<TakeawayRes>> id1 = Mono.zip(count, all).flatMap(f -> {
+            List<Takeaway> t2 = f.getT2();
+            List<TakeawayRes> collect = t2.stream().map(map -> {
+                TakeawayRes takeawayRes = new TakeawayRes();
+                takeawayRes.setTakeawayId(map.takeawayId());
+                takeawayRes.setTakeawayName(map.takeawayName());
+                takeawayRes.setColNum(map.colNum());
+                takeawayRes.setCreatedAt(map.createdAt());
+                takeawayRes.setCreateUser(map.createUser());
+                return takeawayRes;
+            }).collect(Collectors.toList());
+            Paged<TakeawayRes> groupUsersPaged = new Paged<>(f.getT1(), collect, page, size);
+                return Mono.just(groupUsersPaged);
+            });
+        return RStatus.successList(id1);
+    }
+
+    @Override
+    public Mono<RStatus<Takeaway>> saveOrUpdate(TakeawayDto takeawayDto) {
+        List<ColItem> colJson = takeawayDto.getColJson();
+        String s;
+        try {
+             s = JSONUtil.toJsonStr(colJson);
+        }catch (Exception e){
+            return Mono.error(new BaseException("解析ColJson错误Errrr::"+e.getMessage()));
+        }
+        //保存
+        boolean b = Objects.isNull(takeawayDto.getTakeawayId());
+        String userName = BaseContextHandler.getUserName();
+        String userId = BaseContextHandler.getUserId();
+        Mono<Takeaway> just;
+        if (b) {
+             just = Mono.just(Takeaway.getNull());
+        }else {
+            just = takeawayRepository.findById(takeawayDto.getTakeawayId())
+                    .switchIfEmpty(Mono.error(new BaseException("takeawayId错误 查询结果为空")))
+                    .onErrorResume(throwable -> Mono.error(new BaseException("findById errrrr::" + throwable.getMessage())));
+        }
+        Mono<Takeaway> mono = just.flatMap(fm -> {
+            Takeaway takeaway = new Takeaway(fm.takeawayId(),
+                    takeawayDto.getTakeawayName(),
+                    b ? userName : fm.createUser(),
+                    b ? ZonedDateTime.now() : fm.createdAt(),
+                    b ? null : ZonedDateTime.now(),
+                    b ? userId : fm.createId(),
+                    takeawayDto.getColNum(),
+                    s);
+            return b ? template.insert(takeaway) : takeawayRepository.save(takeaway);
+        });
+        return RStatus.success(mono);
+    }
+
+    @Override
+    public Mono<RStatus<TakeawayOneRes>> getById(Long takeawayId) {
+        Mono<Takeaway> mono = takeawayRepository.findById(takeawayId)
+                .switchIfEmpty(Mono.error(new BaseException("id查询结果为空")))
+                .onErrorResume(error ->
+                        Mono.error(new BaseException(StrUtil.format("查询异常{} id:{}", error.getMessage(), takeawayId))));
+        return  mono.flatMap(fm->{
+            String s = fm.colJson();
+            JSONArray jsonArray = JSONUtil.parseArray(s);
+            if (jsonArray.isEmpty()) {
+                Mono<TakeawayOneRes> takeawayOneResMono =Mono.just(getTakeawayOneRes(fm, List.of()));
+                return RStatus.success(takeawayOneResMono);
+            }
+            List<ColItem> collect = jsonArray.stream().map(map -> {
+                ColItem colItem = new ColItem();
+                JSONObject jsonObject = JSONUtil.parseObj(map);
+                BeanUtil.copyProperties(colItem, jsonObject);
+                return colItem;
+            }).collect(Collectors.toList());
+            List<Long>  collectType =collect.stream().map(ColItem::getType).filter(Objects::nonNull).distinct().collect(Collectors.toList());
+            if(collectType.isEmpty()){
+                Mono<TakeawayOneRes> takeawayOneResMono =Mono.just(getTakeawayOneRes(fm, collect));
+                return RStatus.success(takeawayOneResMono);
+            }
+            Mono<List<GroupType>> id = template.select(Query
+                    .query(Criteria.where("id").in(collectType)), GroupType.class)
+                    .collectList()
+                    .onErrorResume(throwable -> Mono.error(new BaseException("查询groupType异常" + throwable.getMessage())));
+            Mono<TakeawayOneRes>  takeawayOneResMono = getTakeawayOneResMono(fm, collect, id);
+            return RStatus.success(takeawayOneResMono);
+        });
+    }
+
+    @Override
+    public Mono<RStatus<TakeawayDeleteRes<Long>>> deleteById(Long[] takeawayId) {
+        Mono<TakeawayDeleteRes<Long>> deleteResMono = takeawayRepository
+                .deleteAllById(List.of(takeawayId))
+                .then(Mono.just(new TakeawayDeleteRes<Long>(List.of(takeawayId))))
+                .onErrorResume(throwable -> Mono.error(new BaseException("删除：：error：：" + throwable.getMessage())));
+        return RStatus.success(deleteResMono);
+    }
+
+    @Override
+    public Mono<TakeawayH5Data> getTakeaway(Long takeawayId) {
+        Mono<Takeaway> mono = takeawayRepository
+                .findById(takeawayId)
+                .switchIfEmpty(Mono.error(new BaseException("id不存在查询结果为空")))
+                .onErrorResume(error ->
+                        Mono.error(new BaseException(StrUtil.format("查询异常{} id:{}", error.getMessage(), takeawayId))));
+    return  mono.flatMap(fm -> {
+            TakeawayH5Data takeawayH5Data = new TakeawayH5Data();
+            String s = fm.colJson();
+            JSONArray jsonArray = JSONUtil.parseArray(s);
+            if (jsonArray.isEmpty()) {
+                return Mono.just(takeawayH5Data);
+            }
+            List<ColItem> collect = jsonArray.stream().map(map -> {
+                ColItem colItem = new ColItem();
+                JSONObject jsonObject = JSONUtil.parseObj(map);
+                BeanUtil.copyProperties(jsonObject, colItem);
+                return colItem;
+            }).sorted(Comparator.comparing(ColItem::getIndex))
+                    .collect(Collectors.toList());
+            List<Long> collectType = collect.stream()
+                    .map(ColItem::getType)
+                    .filter(Objects::nonNull)
+                    .distinct()
+                    .collect(Collectors.toList());
+            if (collectType.isEmpty()) {
+                return Mono.just(takeawayH5Data);
+            }
+            Mono<List<Image>> image = template.select(Query.query(Criteria.where("type").is(11)
+                    .and("deleted_at").isNull()
+                    .and("group_type_id").in(collectType)), Image.class)
+                    .collectList()
+                    .switchIfEmpty(Mono.error(new BaseException(StrUtil.format("通过计划groupId:{}查询Image返回结果为空", collectType))))
+                    .onErrorResume(throwable ->
+                            Mono.error(new Exception(StrUtil.format("通过计划groupId:{}查询Image返回结果error:{}", collectType, throwable.getMessage()))));
+            return Mono.zip(image, Mono.just(collect)).flatMap(ff -> {
+                ArrayList<ColItemRs> colItemRs = new ArrayList<>();
+                ArrayList<String> strings = new ArrayList<>();
+                ff.getT2().forEach(fe -> {
+                    Integer index = fe.getIndex();
+                    Long type = fe.getType();
+                    List<Image> collect1 = ff.getT1()
+                            .stream()
+                            .filter(fr1 -> !strings.contains(fr1.image()))
+                            .filter(fr1 -> type.equals(Long.valueOf(fr1.groupTypeId())))
+                            .collect(Collectors.toList());
+                    if (collect1.isEmpty()) {
+                        throw new BaseException(StrUtil.format("去重后随机获取图片groupTypeId:{}，数量不满足模版栏匹配类型数量要求",type));
+                    }
+                    Image image1 = collect1.get(RandomUtil.randomInt(0, collect1.size()));
+                    strings.add(image1.image());
+                    if (index == 1) {
+                        takeawayH5Data.setMainImageUrl(image1.image());
+                    } else {
+                        ColItemRs colItemRs1 = new ColItemRs();
+                        colItemRs1.setIndex(index);
+                        colItemRs1.setImageUrl(image1.image());
+                        colItemRs.add(colItemRs1);
+                    }
+                });
+                takeawayH5Data.setItems(colItemRs);
+                return Mono.just(takeawayH5Data);
+            });
+        });
+    }
+
+    @Override
+    public Mono<RStatus<List<Takeaway>>> getSelectList(String takeawayName) {
+        Criteria empty = Criteria.empty();
+        if (Objects.nonNull(takeawayName) && !"".equals(takeawayName)) {
+            empty = empty.and("takeaway_name").like("%"+takeawayName+"%");
+        }
+        Query query = Query.query(empty);
+        query.columns("takeaway_name","takeaway_id");
+        Mono<List<Takeaway>> listMono = template.select(query, Takeaway.class)
+                .onErrorResume(throwable -> Mono.error(new BaseException("查异常：：：" + throwable.getMessage())))
+                .collectList();
+        return RStatus.successList(listMono);
+    }
+
+    private Mono<TakeawayOneRes> getTakeawayOneResMono(Takeaway fm, List<ColItem> collect, Mono<List<GroupType>> id) {
+        return Mono.zip(Mono.just(fm), id, Mono.just(collect)).flatMap(f1 -> {
+            List<ColItem> t3 = f1.getT3();
+            t3.forEach(fe -> f1.getT2().stream().filter(ft -> ft.id().equals(fe.getType())).map(GroupType::name).findFirst().ifPresent(fe::setTypeName));
+            TakeawayOneRes takeawayOneRes = getTakeawayOneRes(f1.getT1(), t3);
+            return Mono.just(takeawayOneRes);
+        });
+    }
+
+    private TakeawayOneRes getTakeawayOneRes(Takeaway t1, List<ColItem> t3) {
+        TakeawayOneRes takeawayOneRes = new TakeawayOneRes();
+        takeawayOneRes.setTakeawayId(t1.takeawayId());
+        takeawayOneRes.setTakeawayName(t1.takeawayName());
+        takeawayOneRes.setColNum(t1.colNum());
+        takeawayOneRes.setColJson(t3);
+        return takeawayOneRes;
+    }
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/takeaway/TakeawayServicesInterface.java

@@ -0,0 +1,29 @@
+package com.webflux.launchadmin.mysql.service.takeaway;
+
+import com.webflux.launchadmin.mysql.controller.groupUsers.res.DeleteRes;
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayDeleteRes;
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayH5Data;
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayOneRes;
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayRes;
+import com.webflux.launchadmin.mysql.entity.groupUsers.GroupUsers;
+import com.webflux.launchadmin.mysql.entity.takeaway.Takeaway;
+import com.webflux.launchadmin.mysql.entity.takeaway.dto.TakeawayDto;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+
+public interface TakeawayServicesInterface {
+    Mono<RStatus<Paged<TakeawayRes>>> page(String takeawayName, int page, int size);
+
+    Mono<RStatus<Takeaway>> saveOrUpdate(TakeawayDto takeawayDto);
+
+    Mono<RStatus<TakeawayOneRes>> getById(Long takeawayId);
+
+    Mono<RStatus<TakeawayDeleteRes<Long>>> deleteById(Long[] takeawayId);
+
+    Mono<TakeawayH5Data> getTakeaway(Long takeawayId);
+
+    Mono<RStatus<List<Takeaway>>> getSelectList(String takeawayName);
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/tempAll/TempAllServicesImpl.java

@@ -0,0 +1,317 @@
+package com.webflux.launchadmin.mysql.service.tempAll;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.webflux.launchadmin.config.BaseContextHandler;
+import com.webflux.launchadmin.global.BaseException;
+import com.webflux.launchadmin.mysql.controller.TempAllController.request.PageRequset;
+import com.webflux.launchadmin.mysql.controller.takeawayController.res.TakeawayRes;
+import com.webflux.launchadmin.mysql.entity.takeaway.Takeaway;
+import com.webflux.launchadmin.mysql.entity.takeaway.dto.ColItem;
+import com.webflux.launchadmin.mysql.entity.tempAll.TempAll;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoInfo;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoNext;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.type1.TempAllDtoInfo1;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.type1.TempAllDtoNext1;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.DeleteRes;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.SaveOrUpdateRes;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.TempAllRsNext;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.Type1.TempAllRsNext1;
+import com.webflux.launchadmin.mysql.repository.takeaway.TakeawayRepository;
+import com.webflux.launchadmin.mysql.repository.tempAll.TempAllRepository;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import io.r2dbc.spi.Parameter;
+import jakarta.annotation.Resource;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Service
+public class TempAllServicesImpl implements TempAllServicesInterface{
+    @Resource
+    private TempAllRepository tempAllRepository;
+    @Resource
+    private R2dbcEntityTemplate template;
+
+
+
+    @Override
+    public Mono<RStatus<List<TempAllRsNext>>> getSelectList(String name,Integer type) {
+        Criteria empty = Criteria.where("type").is(type);
+        if (Objects.nonNull(name) && !"".equals(name)) {
+            empty = empty.and("takeaway_name").like("%"+name+"%");
+        }
+        Query query = Query.query(empty);
+        query.columns("id","name");
+        Mono<List<TempAllRsNext>> listMono = template.select(query, TempAll.class)
+                .onErrorResume(throwable -> Mono.error(new BaseException("查异常：：：" + throwable.getMessage())))
+                .map(f -> {
+                    TempAllRsNext next = new TempAllRsNext();
+                    next.setId(f.id());
+                    next.setName(f.name());
+                    return next;
+                }).collectList();
+        return RStatus.successList(listMono);
+    }
+    @Override
+    public Mono<RStatus<Paged<TempAllRsNext>>> pageCommon(String name, int page, int size,Integer type) {
+        Criteria criteria = Criteria.where("type").is(type);
+        if (Objects.nonNull(name) && !"".equals(name.trim())) {
+            criteria = criteria.and("name").is(name);
+        }
+        Query query = Query.query(criteria);
+        int skip = (page - 1) *size;
+        Mono<Long> count = template.count(query, TempAll.class);
+        Mono<List<TempAll>> all = template.select(query
+                .offset(skip)
+                .limit(size)
+                .sort(Sort.by(Sort.Order.desc("created_at"))), TempAll.class)
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询失败::error::" + throwable.getMessage())))
+                .collectList();
+        Mono<Paged<TempAllRsNext>> id1 = Mono.zip(count, all).flatMap(f -> {
+            List<TempAll> t2 = f.getT2();
+            List<TempAllRsNext> collect = t2.stream().map(map -> {
+                TempAllRsNext res = new TempAllRsNext();
+                res.setId(map.id());
+                res.setName(map.name());
+                // Todo 如果需要进行转译
+                // Todo String s = map.jsonContent();
+                // FixMe 如果需要进行转译
+
+                res.setCreateUser(map.createUser());
+                res.setCreatedAt(map.createdAt());
+                res.setUpdatedAt(map.updatedAt());
+                return res;
+            }).collect(Collectors.toList());
+            Paged<TempAllRsNext> groupUsersPaged = new Paged<>(f.getT1(), collect, page, size);
+            return Mono.just(groupUsersPaged);
+        });
+        return RStatus.successList(id1);
+    }
+
+    @Override
+    public Mono<RStatus<Paged<TempAllRsNext>>> page(PageRequset requset, Integer type) {
+        String name = requset.getName();
+        int size = requset.getSize();
+        int page = requset.getPage();
+        Criteria criteria = Criteria.where("type").is(type);
+        if (Objects.nonNull(name) && !"".equals(name.trim())) {
+            criteria = criteria.and("name").is(name);
+        }
+        int skip = (page - 1) *size;
+        Mono<List<TempAll>> all = template.select(Query.query(criteria)
+                .sort(Sort.by(Sort.Order.desc("created_at"))), TempAll.class)
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询失败::error::" + throwable.getMessage())))
+                .collectList();
+        Mono<Paged<TempAllRsNext>> pagedMono = all.flatMap(t2 -> {
+            List<TempAll> collect1 = t2.stream().filter(ft -> {
+                String s = ft.jsonContent();
+
+                //对象
+                // FixMe JSONObject jsonObject = JSONUtil.parseObj(s);
+                // Todo 过滤符合条件的
+                // FixMe  过滤符合条件的
+
+                return true;
+            }).collect(Collectors.toList());
+
+            List<TempAll> paginatedList = collect1.stream()
+                    .skip(skip) // 跳过前 skip 个元素
+                    .limit(size) // 限制返回的元素数量
+                    .collect(Collectors.toList());
+
+            List<TempAllRsNext> collect = paginatedList.stream().map(map -> {
+                TempAllRsNext res = new TempAllRsNext();
+                res.setId(map.id());
+                res.setName(map.name());
+                // Todo 如果需要进行转译
+                // FixMe 如果需要进行转译
+                //String s = map.jsonContent();
+                res.setCreateUser(map.createUser());
+                res.setCreatedAt(map.createdAt());
+                res.setUpdatedAt(map.updatedAt());
+                return res;
+            }).collect(Collectors.toList());
+            Paged<TempAllRsNext> groupUsersPaged = new Paged<>(collect1.size(), collect, page, size);
+            return Mono.just(groupUsersPaged);
+        });
+        return RStatus.successList(pagedMono);
+    }
+
+    @Override
+    public Mono<RStatus<DeleteRes<Long>>> deleteById(Long[] id) {
+        Mono<DeleteRes<Long>> deleteResMono = tempAllRepository.deleteAllById(List.of(id))
+                .then(Mono.just(new DeleteRes<>(List.of(id))))
+                .onErrorResume(throwable -> Mono.error(new BaseException("删除异常:::" + throwable.getMessage())));
+        return RStatus.success(deleteResMono);
+    }
+
+    @Override
+    public Mono<RStatus<TempAll>> saveOrUpdate(TempAllDtoNext request,Integer type) {
+        // FixMe 根据前段传值修改
+        String jsonContent = request.getJsonContent();
+        String s;
+        try {
+            s = JSONUtil.toJsonStr(jsonContent);
+        }catch (Exception e){
+            return Mono.error(new BaseException("解析错误Errrr::"+e.getMessage()));
+        }
+        // ToDo 保存
+        boolean b = Objects.isNull(request.getId());
+        String userName = BaseContextHandler.getUserName();
+        String userId = BaseContextHandler.getUserId();
+        Mono<TempAll> just;
+        if (b) {
+            just = Mono.just(TempAll.getNull());
+        }else {
+            just = tempAllRepository.findById(request.getId())
+                    .switchIfEmpty(Mono.error(new BaseException("Id错误 查询结果为空")))
+                    .onErrorResume(throwable -> Mono.error(new BaseException("findById errrrr::" + throwable.getMessage())));
+        }
+        Mono<TempAll> mono = just.flatMap(fm -> {
+            TempAll tempAll = new TempAll(fm.id(),
+                    s,
+                    request.getName(),
+                    b ? userName : fm.createUser(),
+                    b ? ZonedDateTime.now() : fm.createdAt(),
+                    b ? null : ZonedDateTime.now(),
+                    b ? userId : fm.createId(),
+                    type);
+            return b ? template.insert(tempAll) : tempAllRepository.save(tempAll);
+        });
+        return RStatus.success(mono);
+    }
+
+    @Override
+    public Mono<RStatus<TempAllDtoInfo>> getById(Long id) {
+        Mono<TempAll> mono = tempAllRepository.findById(id)
+                .switchIfEmpty(Mono.error(new BaseException("id查询结果为空")))
+                .onErrorResume(error ->
+                        Mono.error(new BaseException(StrUtil.format("查询异常{} id:{}", error.getMessage(), id))));
+        return  mono.flatMap(fm->{
+            //  FixMe 需要根据实际情况解析
+            String s = fm.jsonContent();
+            TempAllDtoInfo next = new TempAllDtoInfo();
+            next.setId(fm.id());
+            //FixMe 这个可能会根据需求解析
+            next.setJsonContent(s);
+            next.setName(fm.name());
+            next.setUpdatedAt(fm.updatedAt());
+            next.setCreatedAt(fm.createdAt());
+            next.setCreateUser(fm.createUser());
+            next.setCreateId(fm.createId());
+            Mono<TempAllDtoInfo> takeawayOneResMono =Mono.just(next);
+            return RStatus.success(takeawayOneResMono);
+
+        });
+    }
+
+    @Override
+    public Mono<RStatus<Paged<TempAllRsNext1>>> pageCommon1(String name, int page, int size, Integer type) {
+        Criteria criteria = Criteria.where("type").is(type);
+        if (Objects.nonNull(name) && !"".equals(name.trim())) {
+            criteria = criteria.and("name").is(name);
+        }
+        Query query = Query.query(criteria);
+        int skip = (page - 1) *size;
+        Mono<Long> count = template.count(query, TempAll.class);
+        Mono<List<TempAll>> all = template.select(query
+                .offset(skip)
+                .limit(size)
+                .sort(Sort.by(Sort.Order.desc("created_at"))), TempAll.class)
+                .onErrorResume(throwable -> Mono.error(new BaseException("查询失败::error::" + throwable.getMessage())))
+                .collectList();
+        Mono<Paged<TempAllRsNext1>> id1 = Mono.zip(count, all).flatMap(f -> {
+            List<TempAll> t2 = f.getT2();
+            List<TempAllRsNext1> collect = t2.stream().map(map -> {
+                TempAllRsNext1 res = new TempAllRsNext1();
+                res.setId(map.id());
+                res.setName(map.name());
+                // Todo 如果需要进行转译
+                // Todo String s = map.jsonContent();
+                // FixMe 如果需要进行转译
+
+                res.setCreateUser(map.createUser());
+                res.setCreatedAt(map.createdAt());
+                res.setUpdatedAt(map.updatedAt());
+                return res;
+            }).collect(Collectors.toList());
+            Paged<TempAllRsNext1> groupUsersPaged = new Paged<>(f.getT1(), collect, page, size);
+            return Mono.just(groupUsersPaged);
+        });
+        return RStatus.successList(id1);
+    }
+    @Override
+    public Mono<RStatus<TempAll>> saveOrUpdate1(TempAllDtoNext1 request, Integer type) {
+        // FixMe 根据前段传值修改
+        String jsonContent = request.getJsonContent();
+        String s;
+        try {
+            s = JSONUtil.toJsonStr(jsonContent);
+        }catch (Exception e){
+            return Mono.error(new BaseException("解析错误Errrr::"+e.getMessage()));
+        }
+        // ToDo 保存
+        boolean b = Objects.isNull(request.getId());
+        String userName = BaseContextHandler.getUserName();
+        String userId = BaseContextHandler.getUserId();
+        Mono<TempAll> just;
+        if (b) {
+            just = Mono.just(TempAll.getNull());
+        }else {
+            just = tempAllRepository.findById(request.getId())
+                    .switchIfEmpty(Mono.error(new BaseException("Id错误 查询结果为空")))
+                    .onErrorResume(throwable -> Mono.error(new BaseException("findById errrrr::" + throwable.getMessage())));
+        }
+        Mono<TempAll> mono = just.flatMap(fm -> {
+            TempAll tempAll = new TempAll(fm.id(),
+                    s,
+                    request.getName(),
+                    b ? userName : fm.createUser(),
+                    b ? ZonedDateTime.now() : fm.createdAt(),
+                    b ? null : ZonedDateTime.now(),
+                    b ? userId : fm.createId(),
+                    type);
+            return b ? template.insert(tempAll) : tempAllRepository.save(tempAll);
+        });
+        return RStatus.success(mono);
+    }
+    @Override
+    public Mono<RStatus<TempAllDtoInfo1>> getById1(Long id) {
+        Mono<TempAll> mono = tempAllRepository.findById(id)
+                .switchIfEmpty(Mono.error(new BaseException("id查询结果为空")))
+                .onErrorResume(error ->
+                        Mono.error(new BaseException(StrUtil.format("查询异常{} id:{}", error.getMessage(), id))));
+        return  mono.flatMap(fm->{
+            //  FixMe 需要根据实际情况解析
+            String s = fm.jsonContent();
+            TempAllDtoInfo1 next = new TempAllDtoInfo1();
+            next.setId(fm.id());
+            //FixMe 这个可能会根据需求解析
+            next.setJsonContent(s);
+            next.setName(fm.name());
+            next.setUpdatedAt(fm.updatedAt());
+            next.setCreatedAt(fm.createdAt());
+            next.setCreateUser(fm.createUser());
+            next.setCreateId(fm.createId());
+            Mono<TempAllDtoInfo1> takeawayOneResMono =Mono.just(next);
+            return RStatus.success(takeawayOneResMono);
+
+        });
+    }
+
+}

launch-admin/src/main/java/com/webflux/launchadmin/mysql/service/tempAll/TempAllServicesInterface.java

@@ -0,0 +1,44 @@
+package com.webflux.launchadmin.mysql.service.tempAll;
+
+import com.webflux.launchadmin.mysql.controller.TempAllController.request.PageRequset;
+import com.webflux.launchadmin.mysql.entity.tempAll.TempAll;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoInfo;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.TempAllDtoNext;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.type1.TempAllDtoInfo1;
+import com.webflux.launchadmin.mysql.entity.tempAll.dto.type1.TempAllDtoNext1;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.DeleteRes;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.SaveOrUpdateRes;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.TempAllRsNext;
+import com.webflux.launchadmin.mysql.entity.tempAll.res.Type1.TempAllRsNext1;
+import com.webflux.launchcommon.returnObj.Paged;
+import com.webflux.launchcommon.returnObj.RStatus;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+
+
+public interface TempAllServicesInterface {
+
+    // Todo 通用接口 <<<<<
+    Mono<RStatus<List<TempAllRsNext>>> getSelectList(String name,Integer type);
+    //通用 name
+    Mono<RStatus<Paged<TempAllRsNext>>> pageCommon(String name, int page, int size,Integer type);
+    // name + other
+    Mono<RStatus<Paged<TempAllRsNext>>> page(PageRequset requset, Integer type);
+
+    Mono<RStatus<DeleteRes<Long>>> deleteById(Long[] id);
+
+    Mono<RStatus<TempAll>> saveOrUpdate(TempAllDtoNext request, Integer type);
+
+    Mono<RStatus<TempAllDtoInfo>> getById(Long id);
+    // Todo 通用接口 >>>>>
+
+    // Todo 接口 1 <<<<<
+    Mono<RStatus<Paged<TempAllRsNext1>>> pageCommon1(String name, int page, int size, Integer type);
+
+    Mono<RStatus<TempAll>> saveOrUpdate1(TempAllDtoNext1 request, Integer type);
+
+    Mono<RStatus<TempAllDtoInfo1>> getById1(Long id);
+    // Todo 接口 1 >>>>>
+
+}

launch-admin/src/main/resources/application-dev.yml

@@ -7,7 +7,7 @@ spring:
       database: 0
       timeout: 10000
   r2dbc:
-    url: r2dbcs:mysql://rm-uf6xylut5n33hb3o5.mysql.rds.aliyuncs.com:3306/wx_share_8?serverZoneId=GMT%2b8&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&ssl=false&sslMode=DISABLED
+    url: r2dbcs:mysql://rm-uf6xylut5n33hb3o5ro.mysql.rds.aliyuncs.com:3306/wx_share_test?serverZoneId=GMT%2b8&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&ssl=false&sslMode=DISABLED
     username: wx_share_liuwei
     password: Wx_ShARe56578AwCH
 

launch-admin/src/main/resources/application.yml

@@ -6,7 +6,7 @@ spring:
     name: launch-webflux
   profiles:
     # 环境配置
-    active: prod
+    active: dev
 
 
 xxl:

launch-admin/src/main/resources/logback-spring.xml

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration debug="false">
+    <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
+    <property name="LOG_HOME" value="/log"/>
+    <!-- 控制台输出 -->
+    <!-- 彩色日志 -->
+    <!-- 彩色日志依赖的渲染类 -->
+    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
+    <conversionRule conversionWord="wex"
+                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
+    <conversionRule conversionWord="wEx"
+                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
+    <!-- 彩色日志格式 -->
+    <property name="CONSOLE_LOG_PATTERN"
+              value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
+
+    <!--输出到控制台-->
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
+            <!-- 设置字符集 -->
+            <charset>UTF-8</charset>
+        </encoder>
+    </appender>
+
+    <springProfile name="prod">
+        <appender name="plumelog" class="com.plumelog.logback.appender.RedisAppender">
+            <appName>launch-webflux-prod</appName>
+            <redisHost>r-uf6odtyjx4otfkczwh.redis.rds.aliyuncs.com:6379</redisHost>
+            <redisAuth>NTZY_LOg666%$_redis</redisAuth>
+        </appender>
+        <root level="INFO">
+            <appender-ref ref="plumelog"/>
+            <appender-ref ref="CONSOLE"/>
+        </root>
+    </springProfile>
+
+    <springProfile name="test">
+        <appender name="plumelog" class="com.plumelog.logback.appender.RedisAppender">
+            <appName>launch-webflux-test</appName>
+            <redisHost>139.224.53.91:6381</redisHost>
+            <redisAuth>NTZY_LOg666%$_redis</redisAuth>
+        </appender>
+        <root level="INFO">
+            <appender-ref ref="plumelog"/>
+            <appender-ref ref="CONSOLE"/>
+        </root>
+    </springProfile>
+    <springProfile name="dev">
+        <root level="INFO">
+            <appender-ref ref="CONSOLE"/>
+        </root>
+    </springProfile>
+
+</configuration>

launch-admin/src/test/java/com/webflux/launchadmin/LaunchAdminApplicationTests.java

@@ -1,7 +1,9 @@
 package com.webflux.launchadmin;
 
+import com.plumelog.core.util.LogExceptionStackTrace;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
+import reactor.core.publisher.Mono;
 
 import java.net.URI;
 import java.net.http.HttpClient;
@@ -35,4 +37,11 @@ class LaunchAdminApplicationTests {
         }
     }
 
+    @Test
+    public void testLog() {
+        String val = "123abc";
+        Mono.just(val).flatMap(f -> Mono.just(Integer.parseInt(f)))
+                .onErrorResume(e -> Mono.error(new Exception(LogExceptionStackTrace.erroStackTrace(e).toString())))
+                .subscribe(System.out::println);
+    }
 }