废弃策略暂停、均值表v3、17个账号score排除、导出增加aigc字段

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

@@ -101,7 +101,7 @@ public class FilterService {
                 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/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;
@@ -195,7 +196,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 +211,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 +254,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 +270,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/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/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/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)));