long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/common/enums/AccountBusinessTypeEnum.java

@@ -0,0 +1,33 @@
+package com.tzld.longarticle.recommend.server.common.enums;
+
+import lombok.Getter;
+
+import java.util.Objects;
+
+@Getter
+public enum AccountBusinessTypeEnum {
+    changwen(1, "长文"),
+    touliu(2, "投流"),
+    qiwei(3, "企微"),
+    
+    other(999, "其他"),
+
+    ;
+
+    private final Integer type;
+    private final String description;
+
+    AccountBusinessTypeEnum(Integer type, String description) {
+        this.type = type;
+        this.description = description;
+    }
+
+    public static AccountBusinessTypeEnum from(Integer type) {
+        for (AccountBusinessTypeEnum typeEnum : AccountBusinessTypeEnum.values()) {
+            if (Objects.equals(typeEnum.type, type)) {
+                return typeEnum;
+            }
+        }
+        return other;
+    }
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/model/MiniprogramTaskParam.java

@@ -0,0 +1,9 @@
+package com.tzld.longarticle.recommend.server.model;
+
+import lombok.Data;
+
+@Data
+public class MiniprogramTaskParam {
+    private String accountId;
+    private String planId;
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/model/NewSortStrategyExport.java

@@ -11,6 +11,7 @@ public class NewSortStrategyExport {
     private String accountSource;
     private String accountType;
     private String accountStatus;
+    private String businessType;
     private String accountName;
     private String strategy;
     private long fans;
@@ -37,4 +38,21 @@ public class NewSortStrategyExport {
     private Double fission0ReadAvg500Rate = 0.0;
     private Double fission0ReadAvg1000Rate = 0.0;
 
+    // 抓取计划名称
+    private String crawlerPlanName;
+    // 抓取计划策略
+    private String crawlerPlanTag;
+    // 生成计划名称
+    private String producePlanName;
+    // 生成计划策略
+    private String producePlanTag;
+    // 发布计划名称
+    private String publishPlanName;
+    // 发布匹配小程序策略
+    private String publishMiniProgramInsertStrategy;
+    // 发布匹配小程序小程序用途
+    private String publishMiniProgramInsertUseType;
+    // 发布内容小程序数量
+    private Integer publishMiniProgramNum;
+
 }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/model/ProduceAuditLayoutContentObjVO.java

@@ -0,0 +1,14 @@
+package com.tzld.longarticle.recommend.server.model;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
+@Getter
+@Setter
+@Accessors(chain = true)
+public class ProduceAuditLayoutContentObjVO {
+
+    private Integer type;
+    private String data;
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/model/PublishContentParam.java

@@ -0,0 +1,9 @@
+package com.tzld.longarticle.recommend.server.model;
+
+import lombok.Data;
+
+@Data
+public class PublishContentParam {
+    private String publishAccountId;
+    private String title;
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/aigc/ProducePlanExeRecordRepository.java

@@ -0,0 +1,13 @@
+package com.tzld.longarticle.recommend.server.repository.aigc;
+
+import com.tzld.longarticle.recommend.server.repository.entity.aigc.ProducePlanExeRecord;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ProducePlanExeRecordRepository extends JpaRepository<ProducePlanExeRecord, String> {
+
+    List<ProducePlanExeRecord> findByPlanExeIdIn(List<String> planExeIds);
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/aigc/ProducePlanInputSourceRepository.java

@@ -0,0 +1,13 @@
+package com.tzld.longarticle.recommend.server.repository.aigc;
+
+import com.tzld.longarticle.recommend.server.repository.entity.aigc.ProducePlanInputSource;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ProducePlanInputSourceRepository extends JpaRepository<ProducePlanInputSource, String> {
+
+    List<ProducePlanInputSource> findByPlanIdIn(List<String> planIds);
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/aigc/ProducePlanRepository.java

@@ -0,0 +1,13 @@
+package com.tzld.longarticle.recommend.server.repository.aigc;
+
+import com.tzld.longarticle.recommend.server.repository.entity.aigc.ProducePlan;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ProducePlanRepository extends JpaRepository<ProducePlan, String> {
+
+    List<ProducePlan> findByIdIn(List<String> planIds);
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/aigc/PublishAccountRepository.java

@@ -0,0 +1,14 @@
+package com.tzld.longarticle.recommend.server.repository.aigc;
+
+import com.tzld.longarticle.recommend.server.repository.entity.aigc.PublishAccount;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Set;
+
+@Repository
+public interface PublishAccountRepository extends JpaRepository<PublishAccount, String> {
+
+    List<PublishAccount> getAllByGhIdIn(Set<String> ghIds);
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/aigc/PublishContentLayOutRepository.java

@@ -0,0 +1,13 @@
+package com.tzld.longarticle.recommend.server.repository.aigc;
+
+import com.tzld.longarticle.recommend.server.repository.entity.aigc.PublishContentLayout;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface PublishContentLayOutRepository extends JpaRepository<PublishContentLayout, String> {
+
+    List<PublishContentLayout> findByPublishContentIdIn(List<String> publishContentIds);
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/aigc/PublishContentRepository.java

@@ -0,0 +1,10 @@
+package com.tzld.longarticle.recommend.server.repository.aigc;
+
+import com.tzld.longarticle.recommend.server.repository.entity.aigc.PublishContent;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface PublishContentRepository extends JpaRepository<PublishContent, String> {
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/aigc/PublishPlanRepository.java

@@ -0,0 +1,13 @@
+package com.tzld.longarticle.recommend.server.repository.aigc;
+
+import com.tzld.longarticle.recommend.server.repository.entity.aigc.PublishPlan;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface PublishPlanRepository extends JpaRepository<PublishPlan, String> {
+
+    List<PublishPlan> findByIdIn(List<String> planIds);
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/crawler/AccountAvgInfoRepository.java

@@ -10,9 +10,13 @@ import java.util.Set;
 @Repository
 public interface AccountAvgInfoRepository extends JpaRepository<AccountAvgInfo, AccountAvgInfo.PK> {
 
+    List<AccountAvgInfo> getAllByGhIdIn(Set<String> ghIds);
+
     List<AccountAvgInfo> getAllByGhIdInAndStatusEquals(Set<String> ghIds, Integer status);
 
     List<AccountAvgInfo> getAllByGhIdEqualsAndStatusEquals(String ghId, Integer status);
 
     List<AccountAvgInfo> getAllByStatusEquals(Integer status);
+
+    List<AccountAvgInfo> getAllByUpdateTimeGreaterThanEqual(String updateTime);
 }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/crawler/ArticleRepository.java

@@ -12,10 +12,10 @@ public interface ArticleRepository extends JpaRepository<Article, String> {
 
     List<Article> getByAccountNameAndItemIndexInAndTypeEquals(String accountName, List<Integer> indexList, String type);
 
-    List<Article> getByTitleIn(List<String> titleList);
+    List<Article> getByTitleInAndTypeEquals(List<String> titleList, String type);
 
-    List<Article> getByGhIdInAndAppMsgIdInAndItemIndex(Set<String> ghIds, Set<String> appMsgIds, Integer itemIndex);
+    List<Article> getByGhIdInAndAppMsgIdInAndItemIndexAndTypeEquals(Set<String> ghIds, Set<String> appMsgIds, Integer itemIndex, String type);
 
-    List<Article> getByGhIdInAndUpdateTimeGreaterThan(Set<String> ghIds, Long updateTime);
+    List<Article> getByGhIdInAndUpdateTimeGreaterThanAndTypeEquals(Set<String> ghIds, Long updateTime, String type);
 
 }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/CrawlerPlan.java

@@ -0,0 +1,111 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Column;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "crawler_plan")
+public class CrawlerPlan {
+
+    @Id
+    @Column(name = "id")
+    private String id;
+
+    @Column(name = "plan_type")
+    private Integer planType;
+
+    @Column(name = "frequency_type")
+    private Integer frequencyType;
+
+    @Column(name = "plan_tag")
+    private String planTag;
+
+    @Column(name = "tag_penetrate_flag")
+    private Integer tagPenetrateFlag;
+
+    @Column(name = "status")
+    private Integer status;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "channel")
+    private Integer channel;
+
+    @Column(name = "content_modal")
+    private Integer contentModal;
+
+    @Column(name = "crawler_mode")
+    private Integer crawlerMode;
+
+    @Column(name = "crawler_mode_value")
+    private String crawlerModeValue; // mediumtext 映射为 String
+
+    @Column(name = "has_created_task")
+    private boolean hasCreatedTask;
+
+    @Column(name = "crawler_status")
+    private Integer crawlerStatus;
+
+    @Column(name = "crawler_comment")
+    private Integer crawlerComment;
+
+    @Column(name = "error_msg")
+    private String errorMsg;
+
+    @Column(name = "crawler_total_num")
+    private Integer crawlerTotalNum;
+
+    @Column(name = "crawler_last_num")
+    private Integer crawlerLastNum;
+
+    @Column(name = "analyze_priority")
+    private Integer analyzePriority;
+
+    @Column(name = "analyze_status")
+    private Integer analyzeStatus;
+
+    @Column(name = "analyze_total_num")
+    private Integer analyzeTotalNum;
+
+    @Column(name = "analyze_last_num")
+    private Integer analyzeLastNum;
+
+    @Column(name = "filter_account_match_mode")
+    private Integer filterAccountMatchMode;
+
+    @Column(name = "filter_content_match_mode")
+    private Integer filterContentMatchMode;
+
+    @Column(name = "next_crawler_timestamp")
+    private Long nextCrawlerTimestamp;
+
+    @Column(name = "last_crawler_timestamp")
+    private Long lastCrawlerTimestamp;
+
+    @Column(name = "next_analyze_timestamp")
+    private Long nextAnalyzeTimestamp;
+
+    @Column(name = "last_analyze_timestamp")
+    private Long lastAnalyzeTimestamp;
+
+    @Column(name = "create_timestamp")
+    private Long createTimestamp;
+
+    @Column(name = "update_timestamp")
+    private Long updateTimestamp;
+
+    @Column(name = "create_account")
+    private String createAccount;
+
+}
+

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/CrawlerPlanResultRel.java

@@ -0,0 +1,39 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Column;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "crawler_plan_result_rel")
+public class CrawlerPlanResultRel {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "plan_id")
+    private String planId;
+
+    @Column(name = "task_id")
+    private String taskId;
+
+    @Column(name = "channel_source_id")
+    private String channelSourceId;
+
+    @Column(name = "create_timestamp")
+    private Long createTimestamp;
+
+}
+

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/ProducePlan.java

@@ -0,0 +1,92 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Column;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "produce_plan")
+public class ProducePlan {
+
+    @Id
+    @Column(name = "id")
+    private String id;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "produce_modal")
+    private Integer produceModal;
+
+    @Column(name = "plan_tag")
+    private String planTag;
+
+    @Column(name = "tag_penetrate_flag")
+    private Integer tagPenetrateFlag;
+
+    @Column(name = "input_type")
+    private Integer inputType;
+
+    @Column(name = "input_modal")
+    private Integer inputModal;
+
+    @Column(name = "input_channel")
+    private Integer inputChannel;
+
+    @Column(name = "layout_type")
+    private Integer layoutType;
+
+    @Column(name = "active_manual_review")
+    private Integer activeManualReview;
+
+    @Column(name = "active_manual_review_count")
+    private Integer activeManualReviewCount;
+
+    @Column(name = "auto_composite")
+    private Integer autoComposite;
+
+    @Column(name = "daily_produce_num")
+    private Integer dailyProduceNum;
+
+    @Column(name = "total_produce_num")
+    private Integer totalProduceNum;
+
+    @Column(name = "filter_match_mode")
+    private Integer filterMatchMode;
+
+    @Column(name = "max_concurrent_num")
+    private Integer maxConcurrentNum;
+
+    @Column(name = "plan_status")
+    private Integer planStatus;
+
+    @Column(name = "execute_status")
+    private Integer executeStatus;
+
+    @Column(name = "next_execute_timestamp")
+    private Long nextExecuteTimestamp;
+
+    @Column(name = "last_execute_timestamp")
+    private Long lastExecuteTimestamp;
+
+    @Column(name = "create_timestamp")
+    private Long createTimestamp;
+
+    @Column(name = "update_timestamp")
+    private Long updateTimestamp;
+
+    @Column(name = "create_account")
+    private String createAccount;
+
+    @Column(name = "update_account")
+    private String updateAccount;
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/ProducePlanExeRecord.java

@@ -0,0 +1,56 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Column;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "produce_plan_exe_record")
+public class ProducePlanExeRecord {
+
+    @Id
+    @Column(name = "plan_exe_id")
+    private String planExeId;
+
+    @Column(name = "plan_id")
+    private String planId;
+
+    @Column(name = "channel_content_id")
+    private String channelContentId;
+
+    @Column(name = "status")
+    private Integer status;
+
+    @Column(name = "error_msg")
+    private String errorMsg;
+
+    @Column(name = "create_timestamp")
+    private Long createTimestamp;
+
+    @Column(name = "update_timestamp")
+    private Long updateTimestamp;
+
+    @Column(name = "produce_timestamp")
+    private Long produceTimestamp;
+
+    @Column(name = "audit_status")
+    private Integer auditStatus;
+
+    @Column(name = "audit_account")
+    private String auditAccount;
+
+    @Column(name = "audit_timestamp")
+    private Long auditTimestamp;
+
+    @Column(name = "audit_count")
+    private Integer auditCount;
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/ProducePlanInputSource.java

@@ -0,0 +1,59 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Table;
+import javax.persistence.Column;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "produce_plan_input_source")
+public class ProducePlanInputSource {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "plan_id")
+    private String planId;
+
+    @Column(name = "group_id")
+    private String groupId;
+
+    @Column(name = "data_status")
+    private Integer dataStatus;
+
+    @Column(name = "input_modal")
+    private Integer inputModal;
+
+    @Column(name = "input_channel")
+    private Integer inputChannel;
+
+    @Column(name = "input_content_type")
+    private Integer inputContentType;
+
+    @Column(name = "input_source_type")
+    private Integer inputSourceType;
+
+    @Column(name = "input_source_sub_type")
+    private Integer inputSourceSubType;
+
+    @Column(name = "input_field_name")
+    private String inputFieldName;
+
+    @Column(name = "input_source_value")
+    private String inputSourceValue;
+
+    @Column(name = "input_source_label")
+    private String inputSourceLabel;
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/PublishAccount.java

@@ -0,0 +1,147 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "publish_account")
+public class PublishAccount {
+
+    @Id
+    @Column(name = "id")
+    private String id;
+
+    @Column(name = "channel")
+    private Integer channel;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "city_id")
+    private String cityId;
+
+    @Column(name = "platform_account_id")
+    private String platformAccountId;
+
+    @Column(name = "user_name_id")
+    private String userNameId;
+
+    @Column(name = "home_page")
+    private String homePage;
+
+    @Column(name = "introduction")
+    private String introduction;
+
+    @Column(name = "background_url")
+    private String backgroundUrl;
+
+    @Column(name = "avatar_url")
+    private String avatarUrl;
+
+    @Column(name = "type")
+    private String type;
+
+    @Column(name = "role_prompt")
+    private String rolePrompt;
+
+    @Column(name = "remark")
+    private String remark;
+
+    @Column(name = "authentication_value")
+    private String authenticationValue;
+
+    @Column(name = "token")
+    private String token;
+
+    @Column(name = "status")
+    private Integer status;
+
+    @Column(name = "message_status")
+    private Integer messageStatus;
+
+    @Column(name = "notify_status")
+    private Integer notifyStatus;
+
+    @Column(name = "follower_count")
+    private Integer followerCount;
+
+    @Column(name = "follower_count_homepage")
+    private Integer followerCountHomepage;
+
+    @Column(name = "follower_count_search_account")
+    private Integer followerCountSearchAccount;
+
+    @Column(name = "follower_count_search_note")
+    private Integer followerCountSearchNote;
+
+    @Column(name = "follower_count_other")
+    private Integer followerCountOther;
+
+    @Column(name = "app_id")
+    private String appId;
+
+    @Column(name = "refresh_token")
+    private String refreshToken;
+
+    @Column(name = "access_token")
+    private String accessToken;
+
+    @Column(name = "biz_id")
+    private String bizId;
+
+    @Column(name = "gh_id")
+    private String ghId;
+
+    @Column(name = "alias")
+    private String alias;
+
+    @Column(name = "signature")
+    private String signature;
+
+    @Column(name = "refresh_access_token_timestamp")
+    private Long refreshAccessTokenTimestamp;
+
+    @Column(name = "daily_max_publish_num")
+    private Integer dailyMaxPublishNum;
+
+    @Column(name = "publish_rule")
+    private Integer publishRule;
+
+    @Column(name = "pre_auth_code")
+    private String preAuthCode;
+
+    @Column(name = "device_num")
+    private String deviceNum;
+
+    @Column(name = "create_account")
+    private String createAccount;
+
+    @Column(name = "error_msg")
+    private String errorMsg;
+
+    @Column(name = "create_timestamp")
+    private Long createTimestamp;
+
+    @Column(name = "update_account")
+    private String updateAccount;
+
+    @Column(name = "update_timestamp")
+    private Long updateTimestamp;
+
+    @Column(name = "authentication_update_timestamp")
+    private Long authenticationUpdateTimestamp;
+
+    @Column(name = "authentication_invalid_decision_side")
+    private String authenticationInvalidDecisionSide;
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/PublishContent.java

@@ -0,0 +1,185 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.*;
+import java.math.BigDecimal;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "publish_content")
+public class PublishContent {
+
+    @Id
+    @Column(name = "id")
+    private String id;
+
+    @Column(name = "plan_id")
+    private String planId;
+
+    @Column(name = "channel")
+    private Integer channel;
+
+    @Column(name = "content_modal")
+    private Integer contentModal;
+
+    @Column(name = "source_type")
+    private Integer sourceType;
+
+    @Column(name = "source_id")
+    private String sourceId;
+
+    @Column(name = "source_local_id")
+    private String sourceLocalId;
+
+    @Column(name = "crawler_channel_content_id")
+    private String crawlerChannelContentId;
+
+    @Column(name = "status")
+    private Integer status;
+
+    @Column(name = "audit_status")
+    private Integer auditStatus;
+
+    @Column(name = "audit_reject_reason")
+    private String auditRejectReason;
+
+    @Column(name = "publish_account_id")
+    private String publishAccountId;
+
+    @Column(name = "publish_stage_id")
+    private String publishStageId;
+
+    @Column(name = "publish_stage_url")
+    private String publishStageUrl;
+
+    @Column(name = "view_count")
+    private Integer viewCount;
+
+    @Column(name = "like_count")
+    private Integer likeCount;
+
+    @Column(name = "comment_count")
+    private Integer commentCount;
+
+    @Column(name = "share_count")
+    private Integer shareCount;
+
+    @Column(name = "collect_count")
+    private Integer collectCount;
+
+    @Column(name = "looking_count")
+    private Integer lookingCount;
+
+    @Column(name = "fans_increase_count")
+    private Integer fansIncreaseCount;
+
+    @Column(name = "page_look_count")
+    private Integer pageLookCount;
+
+    @Column(name = "finish_rate")
+    private String finishRate;
+
+    @Column(name = "coin_count")
+    private Integer coinCount;
+
+    @Column(name = "danmaku_count")
+    private Integer danmakuCount;
+
+    @Column(name = "text_centre_adv_reqsuc_count")
+    private Integer textCentreAdvReqsucCount;
+
+    @Column(name = "text_centre_adv_expo_count")
+    private Integer textCentreAdvExpoCount;
+
+    @Column(name = "text_centre_adv_click_count")
+    private Integer textCentreAdvClickCount;
+
+    @Column(name = "text_centre_adv_ecpm")
+    private Integer textCentreAdvEcpm;
+
+    @Column(name = "text_centre_adv_income")
+    private Integer textCentreAdvIncome;
+
+    @Column(name = "text_tail_adv_reqsuc_count")
+    private Integer textTailAdvReqsucCount;
+
+    @Column(name = "text_tail_adv_expo_count")
+    private Integer textTailAdvExpoCount;
+
+    @Column(name = "text_tail_adv_click_count")
+    private Integer textTailAdvClickCount;
+
+    @Column(name = "text_tail_adv_ecpm")
+    private Integer textTailAdvEcpm;
+
+    @Column(name = "text_tail_adv_income")
+    private Integer textTailAdvIncome;
+
+    @Column(name = "xhs_location")
+    private String xhsLocation;
+
+    @Lob
+    @Column(name = "douyin_setting_data")
+    private String douyinSettingData;
+
+    @Column(name = "edit_timestamp")
+    private Long editTimestamp;
+
+    @Column(name = "edit_account")
+    private String editAccount;
+
+    @Column(name = "publish_timestamp")
+    private Long publishTimestamp;
+
+    @Column(name = "audit_timestamp")
+    private Long auditTimestamp;
+
+    @Column(name = "audit_account")
+    private String auditAccount;
+
+    @Column(name = "require_word_num")
+    private Integer requireWordNum;
+
+    @Column(name = "require_word_operator")
+    private String requireWordOperator;
+
+    @Column(name = "word_num")
+    private Integer wordNum;
+
+    @Column(name = "require_similarity_ratio")
+    private BigDecimal requireSimilarityRatio;
+
+    @Column(name = "require_similarity_operator")
+    private String requireSimilarityOperator;
+
+    @Column(name = "similarity_ratio")
+    private BigDecimal similarityRatio;
+
+    @Column(name = "algorithm_score")
+    private BigDecimal algorithmScore;
+
+    @Column(name = "algorithm_strategy")
+    private String algorithmStrategy;
+
+    @Column(name = "item_index")
+    private Integer itemIndex;
+
+    @Column(name = "publish_fail_msg")
+    private String publishFailMsg;
+
+    @Column(name = "create_timestamp")
+    private Long createTimestamp;
+
+    @Column(name = "create_account")
+    private String createAccount;
+
+    @Column(name = "update_timestamp")
+    private Long updateTimestamp;
+
+    private String title;
+}
+

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/PublishContentLayout.java

@@ -0,0 +1,32 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Column;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "publish_content_layout")
+public class PublishContentLayout {
+
+    @Id
+    @Column(name = "publish_content_id")
+    private String publishContentId;
+
+    @Column(name = "content", columnDefinition = "MEDIUMTEXT")
+    private String content;
+
+    @Column(name = "update_timestamp")
+    private Long updateTimestamp;
+
+    @Column(name = "update_account")
+    private String updateAccount;
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/PublishPlan.java

@@ -0,0 +1,74 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Column;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "publish_plan")
+public class PublishPlan {
+
+    @Id
+    @Column(name = "id")
+    private String id;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "channel")
+    private Integer channel;
+
+    @Column(name = "plan_tag")
+    private String planTag;
+
+    @Column(name = "plan_type")
+    private Integer planType;
+
+    @Column(name = "account_from")
+    private Integer accountFrom;
+
+    @Column(name = "tag_penetrate_flag")
+    private Integer tagPenetrateFlag;
+
+    @Column(name = "content_modal")
+    private Integer contentModal;
+
+    @Column(name = "active_manual_review")
+    private Integer activeManualReview;
+
+    @Column(name = "machine_review_match_mode")
+    private Integer machineReviewMatchMode;
+
+    @Column(name = "plan_status")
+    private Integer planStatus;
+
+    @Column(name = "error_msg")
+    private String errorMsg;
+
+    @Column(name = "next_execute_timestamp")
+    private Long nextExecuteTimestamp;
+
+    @Column(name = "last_execute_timestamp")
+    private Long lastExecuteTimestamp;
+
+    @Column(name = "create_timestamp")
+    private Long createTimestamp;
+
+    @Column(name = "update_timestamp")
+    private Long updateTimestamp;
+
+    @Column(name = "create_account")
+    private String createAccount;
+
+    @Column(name = "update_account")
+    private String updateAccount;
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/aigc/PublishPlanMiniprogramTask.java

@@ -0,0 +1,42 @@
+package com.tzld.longarticle.recommend.server.repository.entity.aigc;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Column;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "publish_plan_miniprogram_task")
+public class PublishPlanMiniprogramTask {
+
+    @Id
+    @Column(name = "task_id")
+    private String taskId;
+
+    @Column(name = "plan_id")
+    private String planId;
+
+    @Column(name = "task_index")
+    private Integer taskIndex;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "strategy")
+    private String strategy;
+
+    @Column(name = "account_ids")
+    private String accountIds;
+
+    @Column(name = "miniprogram_use_type")
+    private Integer miniprogramUseType;
+
+}
+

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/crawler/AccountAvgInfo.java

@@ -11,7 +11,7 @@ import java.io.Serializable;
 @AllArgsConstructor
 @NoArgsConstructor
 @Entity
-@Table(name = "account_avg_info_v2")
+@Table(name = "account_avg_info_v3")
 @IdClass(AccountAvgInfo.PK.class)
 public class AccountAvgInfo implements Serializable {
 
@@ -23,6 +23,7 @@ public class AccountAvgInfo implements Serializable {
     private String position;
     @Column(name = "account_name")
     private String accountName;
+    @Id
     @Column(name = "update_time")
     private String updateTime;
     @Column(name = "fans")
@@ -41,12 +42,18 @@ public class AccountAvgInfo implements Serializable {
     private String accountSource;
     @Column(name = "account_status")
     private String accountStatus;
+    @Column(name = "business_type")
+    private Integer businessType; // 1 表示长文，2 表示投流，3 表示企微
+    @Column(name = "read_rate_avg")
+    private Double readRateAvg;
 
     @Data
     public static class PK implements Serializable {
 
         @Column(name = "gh_id")
         private String ghId;
+        @Column(name = "update_time")
+        private String updateTime;
         @Column(name = "position")
         private String position;
 

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/entity/crawler/DatastatSortStrategy.java

@@ -78,6 +78,22 @@ public class DatastatSortStrategy  implements Serializable {
     private Double fission0ReadAvg500Rate;
     @Column(name = "fission0_read_avg_1000_rate")
     private Double fission0ReadAvg1000Rate;
+    @Column(name = "crawler_plan_name")
+    private String crawlerPlanName;
+    @Column(name = "crawler_plan_tag")
+    private String crawlerPlanTag;
+    @Column(name = "produce_plan_name")
+    private String producePlanName;
+    @Column(name = "produce_plan_tag")
+    private String producePlanTag;
+    @Column(name = "publish_plan_name")
+    private String publishPlanName;
+    @Column(name = "publish_mini_program_insert_strategy")
+    private String publishMiniProgramInsertStrategy;
+    @Column(name = "publish_mini_program_insert_use_type")
+    private String publishMiniProgramInsertUseType;
+    @Column(name = "publish_mini_program_num")
+    private Integer publishMiniProgramNum;
 
 
     @Data

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/mapper/aigc/AigcBaseMapper.java

@@ -1,8 +1,20 @@
 package com.tzld.longarticle.recommend.server.repository.mapper.aigc;
 
+import com.tzld.longarticle.recommend.server.model.MiniprogramTaskParam;
+import com.tzld.longarticle.recommend.server.model.PublishContentParam;
+import com.tzld.longarticle.recommend.server.repository.entity.aigc.*;
 import org.apache.ibatis.annotations.Mapper;
 
+import java.util.List;
+
 @Mapper
 public interface AigcBaseMapper {
 
+    List<PublishContent> getPublishContentByTitle(List<PublishContentParam> list);
+
+    List<PublishPlanMiniprogramTask> getMiniProgramTask(List<MiniprogramTaskParam> miniprogramTaskParamList);
+
+    List<CrawlerPlanResultRel> getCrawlerPlanRelByChannelContentIds(List<String> channelContentIds);
+
+    List<CrawlerPlan> getCrawlerPlanByPlanIds(List<String> planIds);
 }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/DataDashboardService.java

@@ -5,12 +5,19 @@ import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
 import com.ctrip.framework.apollo.spring.annotation.ApolloJsonValue;
 import com.google.common.collect.Lists;
+import com.tzld.longarticle.recommend.server.common.enums.AccountBusinessTypeEnum;
+import com.tzld.longarticle.recommend.server.model.MiniprogramTaskParam;
 import com.tzld.longarticle.recommend.server.model.NewSortStrategyExport;
+import com.tzld.longarticle.recommend.server.model.ProduceAuditLayoutContentObjVO;
+import com.tzld.longarticle.recommend.server.model.PublishContentParam;
+import com.tzld.longarticle.recommend.server.repository.aigc.*;
 import com.tzld.longarticle.recommend.server.repository.crawler.AccountAvgInfoRepository;
 import com.tzld.longarticle.recommend.server.repository.crawler.ArticleDetailInfoRepository;
 import com.tzld.longarticle.recommend.server.repository.crawler.ArticleRepository;
 import com.tzld.longarticle.recommend.server.repository.crawler.PublishSortLogRepository;
+import com.tzld.longarticle.recommend.server.repository.entity.aigc.*;
 import com.tzld.longarticle.recommend.server.repository.entity.crawler.*;
+import com.tzld.longarticle.recommend.server.repository.mapper.aigc.AigcBaseMapper;
 import com.tzld.longarticle.recommend.server.repository.mapper.crawler.CrawlerBaseMapper;
 import com.tzld.longarticle.recommend.server.util.DateUtils;
 import com.tzld.longarticle.recommend.server.util.MapBuilder;
@@ -46,6 +53,20 @@ public class DataDashboardService {
     private PublishSortLogRepository publishSortLogRepository;
     @Autowired
     private CrawlerBaseMapper crawlerBaseMapper;
+    @Autowired
+    private AigcBaseMapper aigcBaseMapper;
+    @Autowired
+    private PublishAccountRepository publishAccountRepository;
+    @Autowired
+    private PublishContentLayOutRepository publishContentLayOutRepository;
+    @Autowired
+    private PublishPlanRepository publishPlanRepository;
+    @Autowired
+    private ProducePlanExeRecordRepository producePlanExeRecordRepository;
+    @Autowired
+    private ProducePlanRepository producePlanRepository;
+    @Autowired
+    private ProducePlanInputSourceRepository producePlanInputSourceRepository;
 
     @ApolloJsonValue("${export.account.ghId:[]}")
     private static List<String> ghIdList;
@@ -56,7 +77,7 @@ public class DataDashboardService {
         exportFeishuNewSortStrategy(dateStrList, sheetToken, "7d4e12");
     }
 
-    @Scheduled(cron = "0 0 9 * * ?")
+    @Scheduled(cron = "0 0 4 * * ?")
     public void scheduledExport() {
         List<String> dateStrList = getBeforeThreeDays(null);
         exportFeishuNewSortStrategy(dateStrList, sheetToken, "7d4e12");
@@ -114,15 +135,15 @@ public class DataDashboardService {
 
         List<Pair<String, String>> styles = Arrays
                 .asList(
-                        Pair.of("R", "0.00%"),
                         Pair.of("S", "0.00%"),
                         Pair.of("T", "0.00%"),
                         Pair.of("U", "0.00%"),
                         Pair.of("V", "0.00%"),
                         Pair.of("W", "0.00%"),
-                        Pair.of("AC", "0.00%"),
+                        Pair.of("X", "0.00%"),
                         Pair.of("AD", "0.00%"),
-                        Pair.of("AE", "0.00%")
+                        Pair.of("AE", "0.00%"),
+                        Pair.of("AF", "0.00%")
                 );
 
         doSendFeishuSheet(dateStrList, sheetToken, sheetId, rowNum, rows, 2, styles);
@@ -130,23 +151,118 @@ public class DataDashboardService {
 
     private List<NewSortStrategyExport> newSortStrategyData(String dateStr) {
         long timestamp = DateUtils.dateStrToTimestamp(dateStr, "yyyyMMdd");
-        List<AccountAvgInfo> accountAvgInfoList = accountAvgInfoRepository.getAllByStatusEquals(1);
+        String dateStrS = DateUtils.timestampToYMDStr(timestamp, "yyyy-MM-dd");
+        List<AccountAvgInfo> accountAvgInfoList = accountAvgInfoRepository.getAllByUpdateTimeGreaterThanEqual(dateStrS);
         Set<String> ghIds = accountAvgInfoList.stream().map(AccountAvgInfo::getGhId).collect(Collectors.toSet());
-        List<Article> articleList = articleRepository.getByGhIdInAndUpdateTimeGreaterThan(ghIds, timestamp);
+
+        List<Article> articleList = articleRepository.getByGhIdInAndUpdateTimeGreaterThanAndTypeEquals(ghIds, timestamp, "9");
         Map<String, Map<String, Map<Integer, Article>>> articleMap = articleList.stream().collect(Collectors.groupingBy(Article::getGhId,
                 Collectors.groupingBy(Article::getAppMsgId, Collectors.toMap(Article::getItemIndex, o -> o))));
 
         Set<String> snList = articleList.stream().map(Article::getWxSn).collect(Collectors.toSet());
-        List<ArticleDetailInfo> articleDetailInfoList = articleDetailInfoRepository.getAllByWxSnIn(new ArrayList<>(snList));
+        List<ArticleDetailInfo> articleDetailInfoList = new ArrayList<>();
+        for (List<String> partitions : Lists.partition(new ArrayList<>(snList), 1000)) {
+            articleDetailInfoList.addAll(articleDetailInfoRepository.getAllByWxSnIn(partitions));
+        }
         Map<String, List<ArticleDetailInfo>> articleDetailInfoMap = articleDetailInfoList.stream()
                 .collect(Collectors.groupingBy(ArticleDetailInfo::getWxSn));
         List<PublishSortLog> sortLogList = publishSortLogRepository.findByGhIdInAndDateStrGreaterThanEqual(ghIds, dateStr);
         Map<String, Map<String, String>> sortStrategyMap = sortLogList.stream()
                 .collect(Collectors.groupingBy(PublishSortLog::getGhId,
                         Collectors.toMap(PublishSortLog::getDateStr, PublishSortLog::getStrategy, (existing, replacement) -> replacement)));
-
-        Map<String, Map<String, AccountAvgInfo>> accountAvgInfoIndexMap = accountAvgInfoList.stream().collect(
-                Collectors.groupingBy(AccountAvgInfo::getGhId, Collectors.toMap(AccountAvgInfo::getPosition, o -> o)));
+        Map<String, Map<String, Map<String, AccountAvgInfo>>> accountAvgInfoIndexMap = accountAvgInfoList.stream().collect(
+                Collectors.groupingBy(AccountAvgInfo::getUpdateTime, Collectors.groupingBy(AccountAvgInfo::getGhId,
+                        Collectors.toMap(AccountAvgInfo::getPosition, o -> o))));
+        // 获取发布账号
+        List<PublishAccount> publishAccountList = publishAccountRepository.getAllByGhIdIn(ghIds);
+        Map<String, PublishAccount> publishAccountMap = publishAccountList.stream().collect(Collectors.toMap(PublishAccount::getGhId, o -> o));
+        // 获取发布内容
+        List<PublishContentParam> publishContentParamList = articleList.stream().map(article -> {
+            PublishContentParam item = new PublishContentParam();
+            item.setTitle(article.getTitle());
+            PublishAccount account = publishAccountMap.get(article.getGhId());
+            if (Objects.nonNull(account)) {
+                item.setPublishAccountId(account.getId());
+                return item;
+            }
+            return null;
+        }).filter(Objects::nonNull).collect(Collectors.toList());
+        List<PublishContent> publishContents = new ArrayList<>();
+        for (List<PublishContentParam> partitions : Lists.partition(publishContentParamList, 1000)) {
+            publishContents.addAll(aigcBaseMapper.getPublishContentByTitle(partitions));
+        }
+        Map<String, Map<String, PublishContent>> publishContentMap = publishContents.stream().collect(
+                Collectors.groupingBy(PublishContent::getPublishAccountId,
+                        Collectors.toMap(PublishContent::getTitle, o -> o, (existing, replacement) -> existing)));
+        // 获取发布内容排版
+        List<String> publishContentIds = publishContents.stream().map(PublishContent::getId).collect(Collectors.toList());
+        List<PublishContentLayout> publishContentLayoutList = new ArrayList<>();
+        for (List<String> partitions : Lists.partition(publishContentIds, 1000)) {
+            publishContentLayoutList.addAll(publishContentLayOutRepository.findByPublishContentIdIn(partitions));
+        }
+        Map<String, PublishContentLayout> publishContentLayoutMap = publishContentLayoutList.stream()
+                .collect(Collectors.toMap(PublishContentLayout::getPublishContentId, o -> o,
+                        (existing, replacement) -> replacement));
+        //获取发布计划
+        List<String> publishPlanIds = publishContents.stream().map(PublishContent::getPlanId).distinct()
+                .collect(Collectors.toList());
+        List<PublishPlan> publishPlanList = publishPlanRepository.findByIdIn(publishPlanIds);
+        Map<String, PublishPlan> publishPlanMap = publishPlanList.stream()
+                .collect(Collectors.toMap(PublishPlan::getId, o -> o));
+        // 获取生成记录
+        List<String> contentSourceIds = publishContents.stream()
+                .filter(o -> Arrays.asList(1, 2).contains(o.getSourceType()))
+                .map(PublishContent::getSourceId).distinct().collect(Collectors.toList());
+        List<ProducePlanExeRecord> planExeRecordList = new ArrayList<>();
+        for (List<String> partitions : Lists.partition(contentSourceIds, 1000)) {
+            planExeRecordList.addAll(producePlanExeRecordRepository.findByPlanExeIdIn(partitions));
+        }
+        Map<String, ProducePlanExeRecord> planExeRecordMap = planExeRecordList.stream()
+                .collect(Collectors.toMap(ProducePlanExeRecord::getPlanExeId, o -> o));
+        // 获取生成计划
+        List<String> producePlanIds = planExeRecordList.stream().map(ProducePlanExeRecord::getPlanId).distinct()
+                .collect(Collectors.toList());
+        List<ProducePlan> producePlanList = producePlanRepository.findByIdIn(producePlanIds);
+        Map<String, ProducePlan> producePlanMap = producePlanList.stream()
+                .collect(Collectors.toMap(ProducePlan::getId, o -> o));
+        // 获取生成计划输入
+        List<ProducePlanInputSource> inputSourceList = producePlanInputSourceRepository.findByPlanIdIn(producePlanIds);
+        Map<String, List<ProducePlanInputSource>> inputSourceMap = inputSourceList.stream()
+                .collect(Collectors.groupingBy(ProducePlanInputSource::getPlanId));
+        // 获取抓取内容关联
+        List<String> crawlerChannelContentIds = publishContents.stream().map(PublishContent::getCrawlerChannelContentId)
+                .distinct().collect(Collectors.toList());
+        List<CrawlerPlanResultRel> resultRelList = aigcBaseMapper.getCrawlerPlanRelByChannelContentIds(crawlerChannelContentIds);
+        Map<String, List<CrawlerPlanResultRel>> resultRelMap = resultRelList.stream()
+                .collect(Collectors.groupingBy(CrawlerPlanResultRel::getChannelSourceId));
+        // 获取抓取计划
+        List<String> crawlerPlanIds = resultRelList.stream().map(CrawlerPlanResultRel::getPlanId).distinct()
+                .collect(Collectors.toList());
+        List<CrawlerPlan> crawlerPlanList = aigcBaseMapper.getCrawlerPlanByPlanIds(crawlerPlanIds);
+        Map<String, CrawlerPlan> crawlerPlanMap = crawlerPlanList.stream()
+                .collect(Collectors.toMap(CrawlerPlan::getId, o -> o));
+        // 获取小程序任务
+        List<MiniprogramTaskParam> miniprogramTaskParamList = new ArrayList<>();
+        Set<String> distinct = new HashSet<>();
+        for (PublishContent publishContent : publishContents) {
+            String key = publishContent.getPlanId() + publishContent.getPublishAccountId();
+            if (distinct.contains(key)) {
+                continue;
+            } else {
+                distinct.add(key);
+            }
+            MiniprogramTaskParam param = new MiniprogramTaskParam();
+            param.setAccountId(publishContent.getPublishAccountId());
+            param.setPlanId(publishContent.getPlanId());
+            miniprogramTaskParamList.add(param);
+        }
+        List<PublishPlanMiniprogramTask> miniprogramTaskList = new ArrayList<>();
+        for (List<MiniprogramTaskParam> partitions : Lists.partition(miniprogramTaskParamList, 1000)) {
+            miniprogramTaskList.addAll(aigcBaseMapper.getMiniProgramTask(partitions));
+        }
+        Map<String, List<PublishPlanMiniprogramTask>> miniprogramTaskMap = miniprogramTaskList.stream()
+                .collect(Collectors.groupingBy(PublishPlanMiniprogramTask::getPlanId));
+        // result
         List<NewSortStrategyExport> result = new ArrayList<>();
         for (Article article : articleList) {
             List<ArticleDetailInfo> articleDetailInfos = articleDetailInfoMap.get(article.getWxSn());
@@ -168,7 +284,11 @@ public class DataDashboardService {
                     sumFission2 += Optional.ofNullable(articleDetailInfo.getFission2()).orElse(0);
                 }
             }
-            Map<String, AccountAvgInfo> accountAvgInfoMap = accountAvgInfoIndexMap.get(article.getGhId());
+            String hisPublishDate = DateUtils.timestampToYMDStr(article.getUpdateTime(), "yyyy-MM-dd");
+            List<String> avgMapDateList = new ArrayList<>(accountAvgInfoIndexMap.keySet());
+            hisPublishDate = DateUtils.findNearestDate(avgMapDateList, hisPublishDate, "yyyy-MM-dd");
+            Map<String, Map<String, AccountAvgInfo>> dateAvgMap = accountAvgInfoIndexMap.get(hisPublishDate);
+            Map<String, AccountAvgInfo> accountAvgInfoMap = dateAvgMap.get(article.getGhId());
             AccountAvgInfo avgInfo = null;
             AccountAvgInfo firstAvgInfo = null;
             if (Objects.nonNull(accountAvgInfoMap)) {
@@ -204,6 +324,7 @@ public class DataDashboardService {
                 obj.setAccountSource(avgInfo.getAccountSource());
                 obj.setAccountType(avgInfo.getAccountType());
                 obj.setAccountStatus(avgInfo.getAccountStatus());
+                obj.setBusinessType(AccountBusinessTypeEnum.from(avgInfo.getBusinessType()).getDescription());
                 obj.setFans(avgInfo.getFans());
                 obj.setAvgViewCount(avgInfo.getReadAvg());
                 if (avgInfo.getReadAvg() > 0) {
@@ -226,6 +347,61 @@ public class DataDashboardService {
             if (sumFission0 > 0) {
                 obj.setFission1Fission0Rate((sumFission1 * 1.0) / sumFission0);
             }
+            // aigc 数据
+            PublishAccount publishAccount = publishAccountMap.get(article.getGhId());
+            Map<String, PublishContent> titleContentMap = publishContentMap.get(publishAccount.getId());
+            if (Objects.isNull(titleContentMap)) {
+                continue;
+            }
+            PublishContent publishContent = titleContentMap.get(article.getTitle());
+            if (Objects.isNull(publishContent)) {
+                continue;
+            }
+            PublishContentLayout layout = publishContentLayoutMap.get(publishContent.getId());
+            List<ProduceAuditLayoutContentObjVO> layoutList = JSON.parseArray(layout.getContent(), ProduceAuditLayoutContentObjVO.class);
+            if (CollectionUtil.isNotEmpty(layoutList)) {
+                long miniProgramNum = layoutList.stream().filter(o -> o.getType() == 4).count();
+                obj.setPublishMiniProgramNum((int) miniProgramNum);
+            }
+            PublishPlan publishPlan = publishPlanMap.get(publishContent.getPlanId());
+            obj.setPublishPlanName(publishPlan.getName());
+            // 插入小程序任务
+            List<PublishPlanMiniprogramTask> miniprogramTasks = miniprogramTaskMap.get(publishPlan.getId());
+            if (CollectionUtil.isNotEmpty(miniprogramTasks)) {
+                miniprogramTasks = miniprogramTasks.stream()
+                        .filter(o -> o.getAccountIds().contains(publishAccount.getId()))
+                        .collect(Collectors.toList());
+                if (CollectionUtil.isNotEmpty(miniprogramTasks)) {
+                    obj.setPublishMiniProgramInsertStrategy(miniprogramTasks.get(0).getStrategy());
+                    obj.setPublishMiniProgramInsertUseType(miniprogramTasks.get(0).getMiniprogramUseType() == 1 ? "自然流" : "投流");
+                }
+            }
+            List<ProducePlanInputSource> producePlanInputSourceList = new ArrayList<>();
+            if (Arrays.asList(1, 2).contains(publishContent.getSourceType())) {
+                ProducePlanExeRecord record = planExeRecordMap.get(publishContent.getSourceId());
+                if (Objects.nonNull(record)) {
+                    ProducePlan producePlan = producePlanMap.get(record.getPlanId());
+                    obj.setProducePlanName(producePlan.getName());
+                    obj.setProducePlanTag(producePlan.getPlanTag());
+                }
+                producePlanInputSourceList = inputSourceMap.get(record.getPlanId());
+            }
+            List<CrawlerPlanResultRel> crawlerPlanRelList = resultRelMap.get(publishContent.getCrawlerChannelContentId());
+            if (CollectionUtil.isNotEmpty(crawlerPlanRelList) && CollectionUtil.isNotEmpty(producePlanInputSourceList)) {
+                List<String> inputSourceValues = producePlanInputSourceList.stream()
+                        .map(ProducePlanInputSource::getInputSourceValue).collect(Collectors.toList());
+                List<CrawlerPlan> crawlerPlanItemList = new ArrayList<>();
+                for (CrawlerPlanResultRel crawlerPlanResultRel : crawlerPlanRelList) {
+                    crawlerPlanItemList.add(crawlerPlanMap.get(crawlerPlanResultRel.getPlanId()));
+                }
+                for (CrawlerPlan crawlerPlan : crawlerPlanItemList) {
+                    if (inputSourceValues.contains(crawlerPlan.getId())) {
+                        obj.setCrawlerPlanName(crawlerPlan.getName());
+                        obj.setCrawlerPlanTag(crawlerPlan.getPlanTag());
+                        break;
+                    }
+                }
+            }
             result.add(obj);
         }
         result.sort(Comparator.comparing(NewSortStrategyExport::getDateStr).reversed()
@@ -257,8 +433,8 @@ public class DataDashboardService {
         // 先删除掉已存在的dateStr数据
         HttpEntity<Object> queryEntity = new HttpEntity<>(httpHeaders);
         ResponseEntity<String> queryResponseEntity = restTemplate.exchange(
-                String.format("https://open.feishu.cn/open-apis/sheets/v2/spreadsheets/%s/values/%s!A" + startRowIndex + ":A" + (startRowIndex + (rowNum * 2)),
-                        sheetToken, sheetId),
+                String.format("https://open.feishu.cn/open-apis/sheets/v2/spreadsheets/%s/values/%s!A"
+                                + startRowIndex + ":A" + (startRowIndex + (rowNum * 2)), sheetToken, sheetId),
                 HttpMethod.GET, queryEntity, String.class);
         JSONArray values = JSON.parseObject(queryResponseEntity.getBody())
                 .getJSONObject("data")
@@ -327,6 +503,11 @@ public class DataDashboardService {
 //                    HttpMethod.POST, mergeEntity, String.class);
 //        }
         // 此处先简单处理，调整单元格为”百分比小数点“
+        try {
+            Thread.sleep(1000);
+        } catch (Exception e) {
+            log.error("export sleep error");
+        }
         if (CollectionUtil.isNotEmpty(styles)) {
             startRow = startRowIndex;
             do {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/filter/FilterService.java

@@ -94,13 +94,14 @@ public class FilterService {
         strategies.add(ServiceBeanFactory.getBean(BadStrategy.class));
         strategies.add(ServiceBeanFactory.getBean(SensitiveStrategy.class));
         strategies.add(ServiceBeanFactory.getBean(DeDuplicationStrategy.class));
+        strategies.add(ServiceBeanFactory.getBean(KeywordStrategy.class));
         switch (param.getScene()) {
             case FWH_COLD_START:
                 strategies.add(ServiceBeanFactory.getBean(HistoryTitleForFwhColdStartStrategy.class));
                 break;
             default:
                 strategies.add(ServiceBeanFactory.getBean(HistoryTitleStrategy.class));
-                strategies.add(ServiceBeanFactory.getBean(LowScoreStrategy.class));
+//                strategies.add(ServiceBeanFactory.getBean(LowScoreStrategy.class));
                 break;
         }
         return strategies;

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/filter/strategy/KeywordStrategy.java

@@ -0,0 +1,46 @@
+package com.tzld.longarticle.recommend.server.service.filter.strategy;
+
+import com.ctrip.framework.apollo.spring.annotation.ApolloJsonValue;
+import com.tzld.longarticle.recommend.server.model.Content;
+import com.tzld.longarticle.recommend.server.service.filter.FilterParam;
+import com.tzld.longarticle.recommend.server.service.filter.FilterResult;
+import com.tzld.longarticle.recommend.server.service.filter.FilterStrategy;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Component
+@Slf4j
+public class KeywordStrategy implements FilterStrategy {
+
+    @ApolloJsonValue("${keywords:[]}")
+    private static List<String> keywords;
+
+    @Override
+    public FilterResult filter(FilterParam param) {
+        long start = System.currentTimeMillis();
+        FilterResult filterResult = new FilterResult();
+        List<String> result = new ArrayList<>();
+        List<Content> contents = param.getContents();
+        List<Content> filterContents = new ArrayList<>();
+        for (Content content : contents) {
+            for (String keyword : keywords) {
+                if (content.getTitle().contains(keyword)) {
+                    content.setFilterReason("关键词过滤");
+                    filterContents.add(content);
+                }
+            }
+            if (!StringUtils.hasText(content.getFilterReason())) {
+                result.add(content.getId());
+            }
+        }
+        filterResult.setContentIds(result);
+        filterResult.setFilterContent(filterContents);
+        log.info("KeywordStrategy cost:{}", System.currentTimeMillis() - start);
+        return filterResult;
+    }
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/rank/strategy/DefaultRankStrategy.java

@@ -104,6 +104,8 @@ public class DefaultRankStrategy implements RankStrategy {
         List<Content> pool = contentMap.get(contentPools[0]);
         if (CollectionUtils.isNotEmpty(pool)) {
             result.add(pool.get(RandomUtils.nextInt(0, Math.min(pool.size(), 5))));
+        } else {
+            return new RankResult(result);
         }
 
         // 次

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/rank/strategy/RankV10Strategy.java

@@ -92,15 +92,7 @@ public class RankV10Strategy implements RankStrategy {
         if (CollectionUtils.isNotEmpty(pool1)) {
             result.add(pool1.get(0));
         } else {
-            // 替补
-            AccountIndexReplacePoolConfig replacePoolConfig = indexReplacePoolConfigMap.get(1);
-            if (Objects.nonNull(replacePoolConfig)) {
-                List<Content> pool1Replace = contentMap.get(replacePoolConfig.getContentPool());
-                if (CollectionUtils.isNotEmpty(pool1Replace)) {
-                    publishPool[0] = replacePoolConfig.getContentPool();
-                    result.add(pool1Replace.get(0));
-                }
-            }
+            return new RankResult(result);
         }
         // 次
         List<Content> pool2 = contentMap.get(contentPools[1]);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/rank/strategy/RankV3Strategy.java

@@ -8,16 +8,16 @@ import com.tzld.longarticle.recommend.server.service.rank.RankItem;
 import com.tzld.longarticle.recommend.server.service.rank.RankParam;
 import com.tzld.longarticle.recommend.server.service.rank.RankResult;
 import com.tzld.longarticle.recommend.server.service.rank.RankStrategy;
+import com.tzld.longarticle.recommend.server.service.score.AccountIndexReplacePoolConfig;
 import com.tzld.longarticle.recommend.server.service.score.ScoreParam;
 import com.tzld.longarticle.recommend.server.service.score.ScoreResult;
 import com.tzld.longarticle.recommend.server.service.score.ScoreService;
 import com.tzld.longarticle.recommend.server.service.score.strategy.*;
 import com.tzld.longarticle.recommend.server.util.CommonCollectionUtils;
-import com.tzld.longarticle.recommend.server.util.JSONUtils;
 import com.tzld.longarticle.recommend.server.util.TitleSimilarCheckUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
-import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.RandomUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -39,30 +39,30 @@ public class RankV3Strategy implements RankStrategy {
 
         //log.info("RankParam {}", JSONUtils.toJson(param));
         ScoreResult scoreResult = scoreService.score(convertToScoreParam(param));
-        //log.info("ScoreResult {}", JSONUtils.toJson(scoreResult));
 
         Map<String, Map<String, Double>> scoreMap = scoreResult.getScoreMap();
+        String[] contentPools = accountContentPoolConfigService.getContentPools(param.getAccountName());
+        Map<Integer, AccountIndexReplacePoolConfig> indexReplacePoolConfigMap = accountContentPoolConfigService.getContentReplacePools(param.getAccountName());
 
         List<RankItem> items = CommonCollectionUtils.toList(param.getContents(), c -> {
             RankItem item = new RankItem();
             item.setContent(c);
             c.setScoreMap(scoreMap.get(c.getId()));
             item.setScoreMap(scoreMap.get(c.getId()));
-            String[] contentPools = accountContentPoolConfigService.getContentPools(param.getAccountName());
             double score;
-            if (contentPools[0].equals(item.getContent().getContentPoolType())) {
+            if (contentPools[0].equals(item.getContent().getContentPoolType())
+                    || contentPools[1].equals(item.getContent().getContentPoolType())) {
                 score = item.getScore(SimilarityStrategy.class.getSimpleName())
-                        + item.getScore(CategoryStrategy.class.getSimpleName())
-                        + item.getScore(ViewCountRateStrategy.class.getSimpleName())
-                        + item.getScore(FlowCtlDecreaseStrategy.class.getSimpleName());
-            } else if (contentPools[1].equals(item.getContent().getContentPoolType())) {
-                score = item.getScore(ViewCountStrategy.class.getSimpleName())
                         + item.getScore(CategoryStrategy.class.getSimpleName())
                         + item.getScore(FlowCtlDecreaseStrategy.class.getSimpleName());
+                if (item.getScore(PublishTimesStrategy.class.getSimpleName()) >= 0) {
+                    score += item.getScore(ViewCountRateStrategy.class.getSimpleName());
+                }
             } else {
                 score = item.getScore(SimilarityStrategy.class.getSimpleName())
                         + item.getScore(CategoryStrategy.class.getSimpleName())
                         + item.getScore(AccountPreDistributeStrategy.class.getSimpleName())
+                        + item.getScore(PublishTimesStrategy.class.getSimpleName())
                         + item.getScore(FlowCtlDecreaseStrategy.class.getSimpleName());
             }
             c.setScore(score);
@@ -72,11 +72,9 @@ public class RankV3Strategy implements RankStrategy {
 
         // 1 排序
         Collections.sort(items, (o1, o2) -> -Double.compare(o1.getScore(), o2.getScore()));
-        log.info("SortResult {}", JSONUtils.toJson(items));
         // 2 相似去重
         List<Content> contents = CommonCollectionUtils.toList(items, RankItem::getContent);
 //        contents = deduplication(contents);
-        log.info("Deduplication {}", JSONUtils.toJson(contents));
 
         // 3 文章按照内容池分组
         Map<String, List<Content>> contentMap = new HashMap<>();
@@ -84,66 +82,37 @@ public class RankV3Strategy implements RankStrategy {
             List<Content> data = contentMap.computeIfAbsent(c.getContentPoolType(), k -> new ArrayList<>());
             data.add(c);
         }
-        log.info("ContentMap {}", JSONUtils.toJson(contentMap));
         // 4 选文章
         List<Content> result = new ArrayList<>();
-        String[] contentPools = accountContentPoolConfigService.getContentPools(param.getAccountName());
         String[] publishPool = Arrays.copyOf(contentPools, contentPools.length);
 
-        // 头、次
-        if (StringUtils.equals(contentPools[0], contentPools[1])) {
-            List<Content> pool = contentMap.get(contentPools[0]);
-            Integer level = accountContentPoolConfigService.getLevelByContentPool(contentPools[0]);
-            if (level == 1) {
-                if (CollectionUtils.isNotEmpty(pool)) {
-                    result.add(pool.get(0));
-                    if (pool.size() > 2) {
-                        result.add(pool.get(2));
-                    }
-                } else {
-                    // level2 兜底
-                    pool = contentMap.get(accountContentPoolConfigService.getContentPoolByLevel(2));
-                    if (CollectionUtils.isNotEmpty(pool)) {
-                        result.add(pool.get(0));
-                        if (pool.size() > 1) {
-                            result.add(pool.get(1));
-                        }
-                    }
-                }
-            } else if (level == 2) {
-                if (CollectionUtils.isNotEmpty(pool)) {
-                    result.add(pool.get(0));
-                    if (pool.size() > 1) {
-                        result.add(pool.get(1));
-                    }
-                } else {
-                    pool = contentMap.get(ContentPoolEnum.autoArticlePoolLevel1.getContentPool());
-                    if (CollectionUtils.isNotEmpty(pool)) {
-                        result.add(pool.get(0));
-                    }
-                }
-            }
+        // 头
+        List<Content> pool1 = contentMap.get(contentPools[0]);
+        if (CollectionUtils.isNotEmpty(pool1)) {
+            result.add(pool1.get(0));
         } else {
-            // 配置错误 兜底
-            List<Content> pool1 = contentMap.get(contentPools[0]);
-            List<Content> pool2 = contentMap.get(contentPools[1]);
-            if (CollectionUtils.isNotEmpty(pool1)) {
-                result.add(pool1.get(0));
-                if (CollectionUtils.isNotEmpty(pool2)) {
-                    result.add(pool2.get(0));
-                }
-            } else if (CollectionUtils.isNotEmpty(pool2)) {
-                result.add(pool2.get(0));
-                publishPool[0] = contentPools[1];
-                if (pool2.size() > 1) {
-                    result.add(pool2.get(1));
+            return new RankResult(result);
+        }
+        // 次
+        List<Content> pool2 = contentMap.get(contentPools[1]);
+        if (CollectionUtils.isNotEmpty(pool2)) {
+            int i = RandomUtils.nextInt(0, Math.min(pool2.size(), 5));
+            result.add(pool2.get(i));
+        } else {
+            // 替补 根据设置替补内容池查找内容尽心替补
+            AccountIndexReplacePoolConfig replacePoolConfig = indexReplacePoolConfigMap.get(2);
+            if (Objects.nonNull(replacePoolConfig)) {
+                List<Content> pool2Replace = contentMap.get(replacePoolConfig.getContentPool());
+                if (CollectionUtils.isNotEmpty(pool2Replace)) {
+                    publishPool[1] = replacePoolConfig.getContentPool();
+                    result.add(pool2Replace.get(0));
                 }
             }
         }
 
         // 3-8
         List<Content> pool = contentMap.get(contentPools[2]);
-        if (CollectionUtils.isNotEmpty(pool)) {
+        if (CollectionUtils.isNotEmpty(pool) && param.getSize() > result.size()) {
             result.addAll(pool.subList(0, Math.min(pool.size(), param.getSize() - result.size())));
         }
 
@@ -158,6 +127,7 @@ public class RankV3Strategy implements RankStrategy {
         scoreParam.setAccountName(param.getAccountName());
         scoreParam.setContents(param.getContents());
         scoreParam.setStrategy(param.getStrategy());
+        scoreParam.setScene(param.getScene());
         return scoreParam;
     }
 

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/rank/strategy/RankV4Strategy.java

@@ -98,14 +98,7 @@ public class RankV4Strategy implements RankStrategy {
                         result.add(pool.get(2));
                     }
                 } else {
-                    // level2 兜底
-                    pool = contentMap.get(accountContentPoolConfigService.getContentPoolByLevel(2));
-                    if (CollectionUtils.isNotEmpty(pool)) {
-                        result.add(pool.get(0));
-                        if (pool.size() > 1) {
-                            result.add(pool.get(1));
-                        }
-                    }
+                    return new RankResult(result);
                 }
             } else if (level == 2) {
                 if (CollectionUtils.isNotEmpty(pool)) {
@@ -114,10 +107,7 @@ public class RankV4Strategy implements RankStrategy {
                         result.add(pool.get(1));
                     }
                 } else {
-                    pool = contentMap.get(ContentPoolEnum.autoArticlePoolLevel1.getContentPool());
-                    if (CollectionUtils.isNotEmpty(pool)) {
-                        result.add(pool.get(0));
-                    }
+                    return new RankResult(result);
                 }
             }
         } else {
@@ -129,12 +119,8 @@ public class RankV4Strategy implements RankStrategy {
                 if (CollectionUtils.isNotEmpty(pool2)) {
                     result.add(pool2.get(0));
                 }
-            } else if (CollectionUtils.isNotEmpty(pool2)) {
-                result.add(pool2.get(0));
-                publishPool[0] = contentPools[1];
-                if (pool2.size() > 1) {
-                    result.add(pool2.get(1));
-                }
+            } else {
+                return new RankResult(result);
             }
         }
 

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/rank/strategy/RankV5Strategy.java

@@ -91,15 +91,7 @@ public class RankV5Strategy implements RankStrategy {
         if (CollectionUtils.isNotEmpty(pool1)) {
             result.add(pool1.get(0));
         } else {
-            // 替补
-            AccountIndexReplacePoolConfig replacePoolConfig = indexReplacePoolConfigMap.get(1);
-            if (Objects.nonNull(replacePoolConfig)) {
-                List<Content> pool1Replace = contentMap.get(replacePoolConfig.getContentPool());
-                if (CollectionUtils.isNotEmpty(pool1Replace)) {
-                    publishPool[0] = replacePoolConfig.getContentPool();
-                    result.add(pool1Replace.get(0));
-                }
-            }
+            return new RankResult(result);
         }
         // 次
         List<Content> pool2 = contentMap.get(contentPools[1]);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/rank/strategy/RankV7Strategy.java

@@ -92,15 +92,7 @@ public class RankV7Strategy implements RankStrategy {
         if (CollectionUtils.isNotEmpty(pool1)) {
             result.add(pool1.get(0));
         } else {
-            // 替补
-            AccountIndexReplacePoolConfig replacePoolConfig = indexReplacePoolConfigMap.get(1);
-            if (Objects.nonNull(replacePoolConfig)) {
-                List<Content> pool1Replace = contentMap.get(replacePoolConfig.getContentPool());
-                if (CollectionUtils.isNotEmpty(pool1Replace)) {
-                    publishPool[0] = replacePoolConfig.getContentPool();
-                    result.add(pool1Replace.get(0));
-                }
-            }
+            return new RankResult(result);
         }
         // 次
         List<Content> pool2 = contentMap.get(contentPools[1]);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/rank/strategy/RankV8Strategy.java

@@ -95,15 +95,7 @@ public class RankV8Strategy implements RankStrategy {
         if (CollectionUtils.isNotEmpty(pool1)) {
             result.add(pool1.get(0));
         } else {
-            // 替补
-            AccountIndexReplacePoolConfig replacePoolConfig = indexReplacePoolConfigMap.get(1);
-            if (Objects.nonNull(replacePoolConfig)) {
-                List<Content> pool1Replace = contentMap.get(replacePoolConfig.getContentPool());
-                if (CollectionUtils.isNotEmpty(pool1Replace)) {
-                    publishPool[0] = replacePoolConfig.getContentPool();
-                    result.add(pool1Replace.get(0));
-                }
-            }
+            return new RankResult(result);
         }
         // 次
         List<Content> pool2 = contentMap.get(contentPools[1]);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/rank/strategy/RankV9Strategy.java

@@ -92,15 +92,7 @@ public class RankV9Strategy implements RankStrategy {
         if (CollectionUtils.isNotEmpty(pool1)) {
             result.add(pool1.get(0));
         } else {
-            // 替补
-            AccountIndexReplacePoolConfig replacePoolConfig = indexReplacePoolConfigMap.get(1);
-            if (Objects.nonNull(replacePoolConfig)) {
-                List<Content> pool1Replace = contentMap.get(replacePoolConfig.getContentPool());
-                if (CollectionUtils.isNotEmpty(pool1Replace)) {
-                    publishPool[0] = replacePoolConfig.getContentPool();
-                    result.add(pool1Replace.get(0));
-                }
-            }
+            return new RankResult(result);
         }
         // 次
         List<Content> pool2 = contentMap.get(contentPools[1]);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recall/RecallService.java

@@ -17,6 +17,7 @@ import com.tzld.longarticle.recommend.server.repository.mapper.crawler.CrawlerBa
 import com.tzld.longarticle.recommend.server.service.AccountIndexAvgViewCountService;
 import com.tzld.longarticle.recommend.server.service.recall.strategy.DefaultRecallStrategy;
 import com.tzld.longarticle.recommend.server.util.CommonCollectionUtils;
+import com.tzld.longarticle.recommend.server.util.DateUtils;
 import com.tzld.longarticle.recommend.server.util.JSONUtils;
 import com.tzld.longarticle.recommend.server.util.Md5Util;
 import lombok.extern.slf4j.Slf4j;
@@ -124,6 +125,9 @@ public class RecallService implements ApplicationContextAware {
 
     private List<Content> getAllContent(RecallParam param) {
         List<Content> content = aigcRemoteService.getAllContent(param);
+        if (CollectionUtils.isEmpty(content)) {
+            return content;
+        }
         // 标题历史均值
         setTitleAvgViewCount(content);
         // category 查询
@@ -195,7 +199,7 @@ public class RecallService implements ApplicationContextAware {
         List<Article> hisArticleList = new ArrayList<>();
         List<List<String>> titlePartition = Lists.partition(new ArrayList<>(titleList), 1000);
         for (List<String> titles : titlePartition) {
-            hisArticleList.addAll(articleRepository.getByTitleIn(titles));
+            hisArticleList.addAll(articleRepository.getByTitleInAndTypeEquals(titles, "9"));
         }
         Map<String, Map<Integer, List<Article>>> map = hisArticleList.stream()
                 .collect(Collectors.groupingBy(Article::getTitle, Collectors.groupingBy(Article::getItemIndex)));
@@ -210,15 +214,16 @@ public class RecallService implements ApplicationContextAware {
         // 获取历史已发布文章所属头条内容
         Set<String> ghIds = hisArticleList.stream().map(Article::getGhId).collect(Collectors.toSet());
         Set<String> appMsgIds = hisArticleList.stream().map(Article::getAppMsgId).collect(Collectors.toSet());
-        List<Article> firstIndexHisArticleList = articleRepository.getByGhIdInAndAppMsgIdInAndItemIndex(ghIds, appMsgIds, 1);
+        List<Article> firstIndexHisArticleList = articleRepository.getByGhIdInAndAppMsgIdInAndItemIndexAndTypeEquals(ghIds, appMsgIds, 1, "9");
         Map<String, Map<String, Article>> firstIndexHisArticleMap = firstIndexHisArticleList.stream().collect(
                 Collectors.groupingBy(Article::getGhId, Collectors.toMap(Article::getAppMsgId, o -> o)));
         // 获取发布账号 位置历史均值
-        List<AccountAvgInfo> accountAvgInfoList = accountAvgInfoRepository.getAllByGhIdInAndStatusEquals(ghIds, 1);
-        Map<String, Map<String, AccountAvgInfo>> accountAvgInfoIndexMap = accountAvgInfoList.stream().collect(
-                Collectors.groupingBy(AccountAvgInfo::getGhId, Collectors.toMap(AccountAvgInfo::getPosition, o -> o)));
-        Map<String, AccountAvgInfo> firstIndexAvgInfoMap = accountAvgInfoList.stream().filter(o -> "1".equals(o.getPosition()))
-                .collect(Collectors.toMap(AccountAvgInfo::getGhId, o -> o));
+        List<AccountAvgInfo> accountAvgInfoList = accountAvgInfoRepository.getAllByGhIdIn(ghIds);
+        Map<String, Map<String, Map<String, AccountAvgInfo>>> accountAvgInfoIndexMap = accountAvgInfoList.stream().collect(
+                Collectors.groupingBy(AccountAvgInfo::getUpdateTime, Collectors.groupingBy(AccountAvgInfo::getGhId,
+                        Collectors.toMap(AccountAvgInfo::getPosition, o -> o))));
+        Map<String, Map<String, AccountAvgInfo>> firstIndexAvgInfoMap = accountAvgInfoList.stream().filter(o -> "1".equals(o.getPosition()))
+                .collect(Collectors.groupingBy(AccountAvgInfo::getGhId, Collectors.toMap(AccountAvgInfo::getUpdateTime, o -> o)));
         for (Content content : contentList) {
             List<Article> hisArticles = new ArrayList<>();
             Map<Integer, List<Article>> indexArticleMap = map.get(content.getTitle());
@@ -252,7 +257,11 @@ public class RecallService implements ApplicationContextAware {
                 article.setArticleDetailInfoList(articleDetailInfoMap.get(hisArticle.getWxSn()));
                 // 设置账号位置阅读均值
                 int avgViewCount = 0;
-                Map<String, AccountAvgInfo> indexMap = accountAvgInfoIndexMap.get(hisArticle.getGhId());
+                String hisPublishDate = DateUtils.timestampToYMDStr(article.getUpdateTime(), "yyyy-MM-dd");
+                List<String> avgMapDateList = new ArrayList<>(accountAvgInfoIndexMap.keySet());
+                hisPublishDate = DateUtils.findNearestDate(avgMapDateList, hisPublishDate, "yyyy-MM-dd");
+                Map<String, Map<String, AccountAvgInfo>> dateAvgMap = accountAvgInfoIndexMap.get(hisPublishDate);
+                Map<String, AccountAvgInfo> indexMap = dateAvgMap.get(hisArticle.getGhId());
                 if (Objects.nonNull(indexMap) && indexMap.containsKey(hisArticle.getItemIndex().toString())) {
                     article.setInnerAccount(true);
                     avgViewCount = Optional.ofNullable(indexMap.get(hisArticle.getItemIndex().toString()).getReadAvg())
@@ -264,9 +273,13 @@ public class RecallService implements ApplicationContextAware {
                     article.setViewCountRate((article.getViewCount() * 1.0) / article.getAvgViewCount());
                 }
                 // 设置头条阅读均值
-                AccountAvgInfo firstIndexAvgInfo = firstIndexAvgInfoMap.get(hisArticle.getGhId());
-                if (Objects.nonNull(firstIndexAvgInfo)) {
-                    article.setFans(firstIndexAvgInfo.getFans());
+                AccountAvgInfo firstIndexAvgInfo = null;
+                Map<String, AccountAvgInfo> firstIndexDateAvgInfo = firstIndexAvgInfoMap.get(hisArticle.getGhId());
+                if (Objects.nonNull(firstIndexDateAvgInfo)) {
+                    firstIndexAvgInfo = firstIndexDateAvgInfo.get(hisPublishDate);
+                    if (Objects.nonNull(firstIndexAvgInfo)) {
+                        article.setFans(firstIndexAvgInfo.getFans());
+                    }
                 }
                 Map<String, Article> firstIndexArticle = firstIndexHisArticleMap.get(hisArticle.getGhId());
                 if (Objects.nonNull(firstIndexArticle) && firstIndexArticle.containsKey(hisArticle.getAppMsgId())) {

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/score/ScoreService.java

@@ -52,9 +52,12 @@ public class ScoreService implements ApplicationContextAware {
         List<Future<List<Score>>> futures = new ArrayList<>();
         for (final ScoreStrategy strategy : strategies) {
             Future<List<Score>> future = pool.submit(() -> {
-                List<Score> result = strategy.score(param);
-                cdl.countDown();
-                return result;
+                try {
+                    List<Score> result = strategy.score(param);
+                    return result;
+                } finally {
+                    cdl.countDown();
+                }
             });
             futures.add(future);
         }
@@ -86,14 +89,8 @@ public class ScoreService implements ApplicationContextAware {
         List<ScoreStrategy> strategies = new ArrayList<>();
         strategies.add(strategyMap.get(SimilarityStrategy.class.getSimpleName()));
         strategies.add(strategyMap.get(ViewCountStrategy.class.getSimpleName()));
-        if (StringUtils.equals(param.getStrategy(), RankStrategyEnum.ArticleRankV3.getStrategy())) {
-            strategies.add(strategyMap.get(ViewMultiplierStrategy.class.getSimpleName()));
-            strategies.add(strategyMap.get(CategoryStrategy.class.getSimpleName()));
-            strategies.add(strategyMap.get(AccountPreDistributeStrategy.class.getSimpleName()));
-            strategies.add(strategyMap.get(FlowCtlDecreaseStrategy.class.getSimpleName()));
-            strategies.add(strategyMap.get(ViewCountRateStrategy.class.getSimpleName()));
-        }
-        if (StringUtils.equals(param.getStrategy(), RankStrategyEnum.ArticleRankV4.getStrategy())
+        if (StringUtils.equals(param.getStrategy(), RankStrategyEnum.ArticleRankV3.getStrategy())
+                || StringUtils.equals(param.getStrategy(), RankStrategyEnum.ArticleRankV4.getStrategy())
                 || StringUtils.equals(param.getStrategy(), RankStrategyEnum.ArticleRankV5.getStrategy())
                 || StringUtils.equals(param.getStrategy(), RankStrategyEnum.ArticleRankV7.getStrategy())
                 || StringUtils.equals(param.getStrategy(), RankStrategyEnum.ArticleRankV8.getStrategy())

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/score/strategy/FlowCtlDecreaseStrategy.java

@@ -40,6 +40,9 @@ public class FlowCtlDecreaseStrategy implements ScoreStrategy {
     @ApolloJsonValue("${totalAvgReadCountBase:{\"default\":{\"3\":100,\"1\":100,\"2\":100}}}")
     private Map<String, Map<String, Integer>> totalAvgReadCountBaseMap;
 
+    @ApolloJsonValue("${filterCalGhId:[]}")
+    private static List<String> filterCalGhId;
+
     @Override
     public List<Score> score(ScoreParam param) {
         long start = System.currentTimeMillis();
@@ -89,9 +92,12 @@ public class FlowCtlDecreaseStrategy implements ScoreStrategy {
             List<PublishSortLog> publishContents = hisPublishedContentMap.get(content.getTitle());
             double sumViewCount = 0;
             if (CollectionUtil.isNotEmpty(publishContents)) {
-                sumViewCount = publishContents.stream().mapToDouble(PublishSortLog::getIndexAvgCount).sum();
+                sumViewCount = publishContents.stream().filter(o -> !filterCalGhId.contains(o.getGhId()))
+                        .mapToDouble(PublishSortLog::getIndexAvgCount).sum();
             }
-            int hisViewCountSum = content.getHisPublishArticleList().stream().filter(ContentHisPublishArticle::isInnerAccount)
+            int hisViewCountSum = content.getHisPublishArticleList().stream()
+                    .filter(ContentHisPublishArticle::isInnerAccount)
+                    .filter(o -> !filterCalGhId.contains(o.getGhId()))
                     .mapToInt(ContentHisPublishArticle::getAvgViewCount).sum();
             if ((sumViewCount + hisViewCountSum) > indexTotalAvgReadCountBase.get(String.valueOf(index))) {
                 return indexWeight.get(String.valueOf(index));

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/score/strategy/PublishTimesStrategy.java

@@ -36,6 +36,9 @@ public class PublishTimesStrategy implements ScoreStrategy {
     @ApolloJsonValue("${accountPublishTimesConfig:{}}")
     private Map<String, AccountPublishTimesConfig[]> accountPublishTimesConfigMap;
 
+    @ApolloJsonValue("${filterCalGhId:[]}")
+    private static List<String> filterCalGhId;
+
 
     @Override
     public List<Score> score(ScoreParam param) {
@@ -52,6 +55,7 @@ public class PublishTimesStrategy implements ScoreStrategy {
         String dateStr = DateUtils.getCurrentDateStr("yyyyMMdd");
         List<PublishSortLog> hisPublishContentList = publishSortLogRepository.findByDateStr(dateStr);
         Map<String, Set<PublishSortLog>> hisPublishedContentMap = hisPublishContentList.stream()
+                .filter(o -> !filterCalGhId.contains(o.getGhId()))
                 .collect(Collectors.groupingBy(
                         PublishSortLog::getTitle,
                         Collectors.collectingAndThen(

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/score/strategy/ViewCountRateStrategy.java

@@ -82,7 +82,7 @@ public class ViewCountRateStrategy implements ScoreStrategy {
                                 if (hisItem.getFirstViewCountRate() > 1) {
                                     // 对于头条均值倍数大于1的情况，次条均值线性增加，用于debias；
                                     // TODO: 对于小于1的情况，是否要减去？
-                                    avgViewCountSumSecond += hisItem.getAvgViewCount() * hisItem.getFirstViewCountRate();
+                                    avgViewCountSumSecond += hisItem.getAvgViewCount() * (hisItem.getFirstViewCountRate() - 1);
                                 } else {
                                     avgViewCountSumSecond += hisItem.getAvgViewCount();
                                 }
@@ -94,7 +94,7 @@ public class ViewCountRateStrategy implements ScoreStrategy {
                                 if (hisItem.getFirstViewCountRate() > 1) {
                                     // 对于头条均值倍数大于1的情况，次条均值线性增加，用于debias；
                                     // TODO: 对于小于1的情况，是否要减去？
-                                    avgViewCountSum += hisItem.getAvgViewCount() * hisItem.getFirstViewCountRate();
+                                    avgViewCountSum += hisItem.getAvgViewCount() * (hisItem.getFirstViewCountRate() - 1);
                                 } else {
                                     avgViewCountSum += hisItem.getAvgViewCount();
                                 }
@@ -103,7 +103,7 @@ public class ViewCountRateStrategy implements ScoreStrategy {
                     }
                 }
                 double viewCountRate = 0D; // 设置默认值
-                double minRate = 5D;
+                double bigRateW = 1D;
                 // 如果有头条反馈数据，优先选取头条反馈数据；
                 if (showViewCountSumFirst > 0) {
                     showViewCountSum = showViewCountSumFirst;
@@ -112,9 +112,9 @@ public class ViewCountRateStrategy implements ScoreStrategy {
                     showViewCountSum = showViewCountSumSecond;
                     avgViewCountSum = avgViewCountSumSecond;
                     // 如果是大号头条，则降权
-//                    if (avgViewCountFirst >= 2000 && i == 0) {
-//                        minRate = 1.001D;
-//                    }
+                    if (avgViewCountFirst >= 3000 && i == 0) {
+                        bigRateW = 0.001D;
+                    }
                 }
                 // 均值倍数
                 if (avgViewCountSum > 0) {
@@ -126,8 +126,12 @@ public class ViewCountRateStrategy implements ScoreStrategy {
 
                 if (viewCountRate > 0) {
                     // 最终分数 = 置信度 * 均值倍数
-                    viewCountRateScore = viewCountRateW * viewCountRate;
-//                    viewCountRateScore = (Math.min(viewCountRate, minRate) - 1D) * viewCountRateW;
+                    if (viewCountRate > 1 && bigRateW < 1) {
+                        // 如果是大号头条，则降权
+                        viewCountRateScore = viewCountRateW * ((viewCountRate - 1) * bigRateW + 1);
+                    } else {
+                        viewCountRateScore = viewCountRateW * viewCountRate;
+                    }
                 }
                 Score score = new Score();
                 score.setStrategy(this);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/util/DateUtils.java

@@ -6,8 +6,10 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
 import java.util.Calendar;
 import java.util.Date;
+import java.util.List;
 
 /**
  * @author dyp
@@ -88,6 +90,30 @@ public final class DateUtils {
         return dateTime.format(formatter);
     }
 
+    public static String findNearestDate(List<String> dateList, String targetDateStr, String format) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
+        // 将目标日期字符串转换为 LocalDate
+        LocalDate targetDate = LocalDate.parse(targetDateStr, formatter);
+
+        // 初始化最近的日期和最小的天数差值
+        String nearestDateStr = null;
+        long minDiff = Long.MAX_VALUE;
+
+        // 遍历日期列表，找到最近的日期
+        for (String dateStr : dateList) {
+            LocalDate currentDate = LocalDate.parse(dateStr, formatter);
+            long diff = Math.abs(ChronoUnit.DAYS.between(currentDate, targetDate));  // 计算天数差异
+
+            // 如果找到更小的差异，更新最近的日期
+            if (diff < minDiff) {
+                minDiff = diff;
+                nearestDateStr = dateStr;
+            }
+        }
+
+        return nearestDateStr;  // 返回最近的日期字符串
+    }
+
 
     public static void main(String[] args) {
         Calendar calendar = Calendar.getInstance();

long-article-recommend-service/src/main/resources/application-dev.yml

@@ -15,13 +15,13 @@ spring:
 #        min-idle: 0
   datasource:
     crawler:
-#      jdbc-url: jdbc:mysql://rm-bp1159bu17li9hi94.mysql.rds.aliyuncs.com:3306/piaoquan-crawler?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false
-#      username: crawler
-#      password: crawler123456@
-      # 测试库
-      jdbc-url: jdbc:mysql://rm-bp1k5853td1r25g3n690.mysql.rds.aliyuncs.com:3306/piaoquan-crawler?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false
+      jdbc-url: jdbc:mysql://rm-bp1159bu17li9hi94.mysql.rds.aliyuncs.com:3306/piaoquan-crawler?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false
       username: crawler
       password: crawler123456@
+      # 测试库
+#      jdbc-url: jdbc:mysql://rm-bp1k5853td1r25g3n690.mysql.rds.aliyuncs.com:3306/piaoquan-crawler?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false
+#      username: crawler
+#      password: crawler123456@
       driver-class-name: com.mysql.jdbc.Driver
       hikari:
         connection-timeout: 30000

long-article-recommend-service/src/main/resources/mapper/aigc/AigcBaseMapper.xml

@@ -2,5 +2,67 @@
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.tzld.longarticle.recommend.server.repository.mapper.aigc.AigcBaseMapper">
 
+    <select id="getPublishAccountByGhId"
+            resultType="com.tzld.longarticle.recommend.server.repository.entity.aigc.PublishAccount">
+        select * from publish_account where gh_id = #{ghId} limit 1
+    </select>
+
+    <select id="getPublishContentByTitle"
+            resultType="com.tzld.longarticle.recommend.server.repository.entity.aigc.PublishContent">
+        select content.*, output.output as title
+        from publish_content content
+        join publish_content_output output
+          on content.id = output.publish_content_id and output.content_type = 3 AND output.select_status = 1
+        where content.status = 2
+          and (content.publish_account_id, output.output) in
+        <foreach collection="list" item="item" open="(" close=")" separator=",">
+            (#{item.publishAccountId}, #{item.title})
+        </foreach>
+    </select>
+
+    <select id="getPublishPlanById"
+            resultType="com.tzld.longarticle.recommend.server.repository.entity.aigc.PublishPlan">
+        select * from publish_plan where id = #{planId}
+    </select>
+
+    <select id="getMiniProgramTask"
+            resultType="com.tzld.longarticle.recommend.server.repository.entity.aigc.PublishPlanMiniprogramTask">
+        select * from publish_plan_miniprogram_task where
+        <foreach collection="list" item="item" open="(" close=")" separator=" or ">
+            (plan_id = #{item.planId} and account_ids like CONCAT("%", #{item.accountId}, "%"))
+        </foreach>
+    </select>
+
+    <select id="getProduceContent"
+            resultType="com.tzld.longarticle.recommend.server.repository.entity.aigc.ProducePlanExeRecord">
+        select * from produce_plan_exe_record where plan_exe_id = #{id}
+    </select>
+
+    <select id="getProducePlan"
+            resultType="com.tzld.longarticle.recommend.server.repository.entity.aigc.ProducePlan">
+        select * from produce_plan where id = #{id}
+    </select>
+
+    <select id="getProducePlanInputSources"
+            resultType="com.tzld.longarticle.recommend.server.repository.entity.aigc.ProducePlanInputSource">
+        select * from produce_plan_input_source where plan_id = #{planId} and data_status = 1
+    </select>
+
+    <select id="getCrawlerPlanRelByChannelContentIds"
+            resultType="com.tzld.longarticle.recommend.server.repository.entity.aigc.CrawlerPlanResultRel">
+        select * from crawler_plan_result_rel where channel_source_id in
+        <foreach collection="channelContentIds" item="item" open="(" close=")" separator=",">
+            #{item}
+        </foreach>
+    </select>
+
+    <select id="getCrawlerPlanByPlanIds"
+            resultType="com.tzld.longarticle.recommend.server.repository.entity.aigc.CrawlerPlan">
+        select * from crawler_plan where id in
+        <foreach collection="planIds" item="item" open="(" close=")" separator=",">
+            #{item}
+        </foreach>
+    </select>
+
 
 </mapper>

long-article-recommend-service/src/main/resources/mapper/crawler/CrawlerBaseMapper.xml

@@ -9,20 +9,26 @@
     <insert id="batchInsertDatastatSortStrategy">
         INSERT INTO datastat_sort_strategy
         (date_str, publish_time, account_mode, account_source, account_type, account_status, account_name, strategy,
-         fans, view_count, avg_view_count, first_view_count, first_avg_view_count, first_level, fission0, fission1,
-         fission2, read_rate, read_fans_rate, first_read_rate, fission0_first_rate, fission1_fission0_rate,
-         fission0_read_avg_rate, position, gh_id, title, link, wx_sn, fission0_read_avg_100_rate,
-         fission0_read_avg_500_rate, fission0_read_avg_1000_rate)
+        fans, view_count, avg_view_count, first_view_count, first_avg_view_count, first_level, fission0, fission1,
+        fission2, read_rate, read_fans_rate, first_read_rate, fission0_first_rate, fission1_fission0_rate,
+        fission0_read_avg_rate, position, gh_id, title, link, wx_sn, fission0_read_avg_100_rate,
+        fission0_read_avg_500_rate, fission0_read_avg_1000_rate, crawler_plan_name, crawler_plan_tag,
+        produce_plan_name, produce_plan_tag, publish_plan_name, publish_mini_program_insert_strategy,
+        publish_mini_program_insert_use_type, publish_mini_program_num)
         VALUES
         <foreach collection="list" item="item" separator=",">
             (#{item.dateStr}, #{item.publishTime}, #{item.accountMode}, #{item.accountSource}, #{item.accountType},
-             #{item.accountStatus}, #{item.accountName}, #{item.strategy}, #{item.fans}, #{item.viewCount},
-             #{item.avgViewCount}, #{item.firstViewCount}, #{item.firstAvgViewCount}, #{item.firstLevel},
-             #{item.fission0}, #{item.fission1}, #{item.fission2}, #{item.readRate}, #{item.readFansRate},
-             #{item.firstReadRate}, #{item.fission0FirstRate}, #{item.fission1Fission0Rate},
-             #{item.fission0ReadAvgRate}, #{item.position}, #{item.ghId}, #{item.title}, #{item.link},
-             #{item.wxSn}, #{item.fission0ReadAvg100Rate}, #{item.fission0ReadAvg500Rate},
-             #{item.fission0ReadAvg1000Rate})
+            #{item.accountStatus}, #{item.accountName}, #{item.strategy}, #{item.fans}, #{item.viewCount},
+            #{item.avgViewCount}, #{item.firstViewCount}, #{item.firstAvgViewCount}, #{item.firstLevel},
+            #{item.fission0}, #{item.fission1}, #{item.fission2}, #{item.readRate}, #{item.readFansRate},
+            #{item.firstReadRate}, #{item.fission0FirstRate}, #{item.fission1Fission0Rate},
+            #{item.fission0ReadAvgRate}, #{item.position}, #{item.ghId}, #{item.title}, #{item.link},
+            #{item.wxSn}, #{item.fission0ReadAvg100Rate}, #{item.fission0ReadAvg500Rate},
+            #{item.fission0ReadAvg1000Rate}, #{item.crawlerPlanName}, #{item.crawlerPlanTag},
+            #{item.producePlanName}, #{item.producePlanTag}, #{item.publishPlanName},
+            #{item.publishMiniProgramInsertStrategy}, #{item.publishMiniProgramInsertUseType},
+            #{item.publishMiniProgramNum})
         </foreach>
     </insert>
+
 </mapper>

long-article-recommend-service/src/test/java/com/tzld/longarticle/recommend/server/RecommendTest.java

@@ -47,7 +47,7 @@ public class RecommendTest {
 //    @Test
 //    void exportData() {
 //        Set<String> ghIds = new HashSet<>(Arrays.asList("gh_adca24a8f429", "gh_e0eb490115f5", "gh_51e4ad40466d", "gh_95ed5ecf9363"));
-//        List<Article> articleList = articleRepository.getByGhIdInAndUpdateTimeGreaterThan(ghIds, 1722441600L);
+//        List<Article> articleList = articleRepository.getByGhIdInAndUpdateTimeGreaterThanAndTypeEquals(ghIds, 1722441600L);
 //
 //        Map<String, Map<Integer, List<Article>>> map = articleList.stream()
 //                .collect(Collectors.groupingBy(Article::getTitle, Collectors.groupingBy(Article::getItemIndex)));