1027 lines
27 KiB
Go
1027 lines
27 KiB
Go
package repositories
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/niangaodev/art-code/config"
|
||
"github.com/niangaodev/art-code/models"
|
||
"github.com/sergi/go-diff/diffmatchpatch"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
// TrendData 趋势数据
|
||
type TrendData struct {
|
||
Date string `json:"date"`
|
||
Count int `json:"value"`
|
||
YoY float64 `json:"yoy"`
|
||
MoM float64 `json:"mom"`
|
||
}
|
||
|
||
// GetPosts 获取所有博客文章（支持搜索、分类、标签筛选，支持分页）
|
||
func GetPosts(keyword string, categoryID uint, tagID uint, columnID uint, page int, pageSize int) ([]models.Post, int64, error) {
|
||
var posts []models.Post
|
||
var total int64
|
||
|
||
// 构建基础查询
|
||
query := config.DB.Model(&models.Post{}).
|
||
Where("is_published = ? AND deleted_at = ?", 1, 0)
|
||
|
||
if tagID > 0 {
|
||
query = query.Joins("JOIN post_tags pt ON posts.id = pt.post_id").
|
||
Where("pt.tag_id = ?", tagID)
|
||
}
|
||
|
||
if categoryID > 0 {
|
||
query = query.Where("category_id = ?", categoryID)
|
||
}
|
||
|
||
if columnID > 0 {
|
||
query = query.Where("column_id = ?", columnID)
|
||
}
|
||
|
||
if keyword != "" {
|
||
likeKeyword := "%" + keyword + "%"
|
||
query = query.Where("(MATCH(title, content) AGAINST(? IN BOOLEAN MODE) OR title LIKE ? OR content LIKE ?)",
|
||
keyword, likeKeyword, likeKeyword)
|
||
}
|
||
|
||
// 计算总数
|
||
countQuery := query
|
||
err := countQuery.Count(&total).Error
|
||
if err != nil {
|
||
log.Printf("Error counting posts: %v", err)
|
||
return nil, 0, err
|
||
}
|
||
|
||
// 应用分页
|
||
offset := (page - 1) * pageSize
|
||
err = query.
|
||
Preload("Category").
|
||
Preload("Column").
|
||
Preload("Tags").
|
||
Order("created_at DESC").
|
||
Limit(pageSize).
|
||
Offset(offset).
|
||
Find(&posts).Error
|
||
if err != nil {
|
||
log.Printf("Error querying posts: %v", err)
|
||
return nil, 0, err
|
||
}
|
||
|
||
return posts, total, nil
|
||
}
|
||
|
||
// GetPostsByUserID 获取用户已发布文章（用于公开资料页）
|
||
func GetPostsByUserID(userID uint, sort string, limit int) ([]models.Post, error) {
|
||
if limit <= 0 {
|
||
limit = 5
|
||
}
|
||
if limit > 20 {
|
||
limit = 20
|
||
}
|
||
|
||
orderClause := "created_at DESC"
|
||
if sort == "popular" {
|
||
orderClause = "read_count DESC, created_at DESC"
|
||
}
|
||
|
||
var posts []models.Post
|
||
err := config.DB.Model(&models.Post{}).
|
||
Where("user_id = ? AND is_published = ? AND deleted_at = ?", userID, 1, 0).
|
||
Preload("Category").
|
||
Preload("Column").
|
||
Preload("Tags").
|
||
Order(orderClause).
|
||
Limit(limit).
|
||
Find(&posts).Error
|
||
if err != nil {
|
||
log.Printf("Error querying posts by user ID: %v", err)
|
||
return nil, err
|
||
}
|
||
return posts, nil
|
||
}
|
||
|
||
// GetPostByID 根据ID获取博客文章
|
||
func GetPostByID(id uint) (*models.Post, error) {
|
||
var post models.Post
|
||
// 显式选择所有字段，确保 content 字段被加载
|
||
err := config.DB.Model(&models.Post{}).
|
||
Select("id", "title", "category_id", "column_id", "excerpt", "content", "read_count", "is_published", "user_id", "created_at", "updated_at", "deleted_at").
|
||
Preload("Category").
|
||
Preload("Column").
|
||
Preload("Tags").
|
||
Preload("Author", func(db *gorm.DB) *gorm.DB {
|
||
return db.Select("id", "username", "avatar", "email")
|
||
}).
|
||
Where("id = ? AND is_published = ? AND deleted_at = ?", id, 1, 0).
|
||
First(&post).Error
|
||
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return nil, nil
|
||
}
|
||
log.Printf("Error getting post by ID: %v", err)
|
||
return nil, err
|
||
}
|
||
|
||
// 不再在此处更新阅读量，由 handler 按小时去重后递增
|
||
return &post, nil
|
||
}
|
||
|
||
// IncrementReadCount 递增文章阅读量
|
||
func IncrementReadCount(id uint) error {
|
||
return config.DB.Model(&models.Post{}).
|
||
Where("id = ?", id).
|
||
UpdateColumn("read_count", gorm.Expr("read_count + ?", 1)).Error
|
||
}
|
||
|
||
// GetAllPosts 获取所有博客文章（包括未发布的，后台用，支持搜索与筛选）
|
||
type AdminPostFilter struct {
|
||
Keyword string
|
||
CategoryID uint
|
||
ColumnID uint
|
||
IsPublished int // -1 表示全部
|
||
StartDate string
|
||
EndDate string
|
||
}
|
||
|
||
func GetAllPosts(page, pageSize int, filter AdminPostFilter) ([]models.Post, int64, error) {
|
||
offset := (page - 1) * pageSize
|
||
|
||
var posts []models.Post
|
||
var total int64
|
||
|
||
query := config.DB.Model(&models.Post{}).
|
||
Where("deleted_at = ?", 0)
|
||
|
||
if filter.Keyword != "" {
|
||
likeKeyword := "%" + filter.Keyword + "%"
|
||
query = query.Where("(MATCH(title, content) AGAINST(? IN BOOLEAN MODE) OR title LIKE ? OR content LIKE ?)",
|
||
filter.Keyword, likeKeyword, likeKeyword)
|
||
}
|
||
if filter.CategoryID > 0 {
|
||
query = query.Where("category_id = ?", filter.CategoryID)
|
||
}
|
||
if filter.ColumnID > 0 {
|
||
query = query.Where("column_id = ?", filter.ColumnID)
|
||
}
|
||
if filter.IsPublished >= 0 {
|
||
query = query.Where("is_published = ?", filter.IsPublished)
|
||
}
|
||
if filter.StartDate != "" {
|
||
if ts, err := parseDateStart(filter.StartDate); err == nil {
|
||
query = query.Where("created_at >= ?", ts)
|
||
}
|
||
}
|
||
if filter.EndDate != "" {
|
||
if ts, err := parseDateEnd(filter.EndDate); err == nil {
|
||
query = query.Where("created_at <= ?", ts)
|
||
}
|
||
}
|
||
|
||
err := query.Count(&total).Error
|
||
if err != nil {
|
||
log.Printf("Error counting posts: %v", err)
|
||
return nil, 0, err
|
||
}
|
||
|
||
// Get posts
|
||
err = query.
|
||
Preload("Category").
|
||
Preload("Column").
|
||
Preload("Tags").
|
||
Order("created_at DESC").
|
||
Limit(pageSize).
|
||
Offset(offset).
|
||
Find(&posts).Error
|
||
|
||
if err != nil {
|
||
log.Printf("Error querying all posts: %v", err)
|
||
return nil, 0, err
|
||
}
|
||
|
||
return posts, total, nil
|
||
}
|
||
|
||
// CreatePost 创建博客文章
|
||
func CreatePost(post *models.Post) error {
|
||
err := config.DB.Create(post).Error
|
||
if err != nil {
|
||
log.Printf("Error creating post: %v", err)
|
||
return err
|
||
}
|
||
|
||
// Insert Tags
|
||
if len(post.Tags) > 0 {
|
||
err = config.DB.Model(post).Association("Tags").Replace(post.Tags)
|
||
if err != nil {
|
||
log.Printf("Error associating tags: %v", err)
|
||
return err
|
||
}
|
||
}
|
||
|
||
// Handle column association if ColumnID is set
|
||
if post.ColumnID != nil && *post.ColumnID > 0 {
|
||
// Add to column_posts table
|
||
err = AddPostToColumn(*post.ColumnID, post.ID, 0)
|
||
if err != nil {
|
||
log.Printf("Error adding post to column: %v", err)
|
||
// Don't fail the whole operation, just log
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// UpdatePost 更新博客文章
|
||
func UpdatePost(post *models.Post) error {
|
||
// 使用 map 更新，并明确指定要更新的字段，确保即使字段是空字符串也会被更新
|
||
updateData := map[string]interface{}{
|
||
"title": post.Title,
|
||
"category_id": post.CategoryID,
|
||
"excerpt": post.Excerpt,
|
||
"content": post.Content, // 明确包含 content，即使为空字符串也会更新
|
||
"is_published": post.IsPublished,
|
||
"updated_at": time.Now().Unix(),
|
||
}
|
||
|
||
// Update column_id if provided
|
||
if post.ColumnID != nil {
|
||
updateData["column_id"] = post.ColumnID
|
||
} else {
|
||
// Set to NULL if explicitly set to nil
|
||
updateData["column_id"] = nil
|
||
}
|
||
|
||
// 使用 Select 明确指定要更新的字段，确保所有字段都被更新
|
||
err := config.DB.Model(&models.Post{}).
|
||
Where("id = ? AND deleted_at = ?", post.ID, 0).
|
||
Select("title", "category_id", "column_id", "excerpt", "content", "is_published", "updated_at").
|
||
Updates(updateData).Error
|
||
|
||
if err != nil {
|
||
log.Printf("Error updating post: %v", err)
|
||
return err
|
||
}
|
||
|
||
// Update Tags
|
||
if len(post.Tags) > 0 {
|
||
err = config.DB.Model(&models.Post{ID: post.ID}).Association("Tags").Replace(post.Tags)
|
||
if err != nil {
|
||
log.Printf("Error updating tags: %v", err)
|
||
return err
|
||
}
|
||
} else {
|
||
// Clear all tags
|
||
err = config.DB.Model(&models.Post{ID: post.ID}).Association("Tags").Clear()
|
||
if err != nil {
|
||
log.Printf("Error clearing tags: %v", err)
|
||
return err
|
||
}
|
||
}
|
||
|
||
// Handle column association
|
||
// Always sync column_posts table with column_id
|
||
// First, remove from all columns
|
||
err = config.DB.Where("post_id = ?", post.ID).Delete(&models.ColumnPost{}).Error
|
||
if err != nil {
|
||
log.Printf("Error removing post from columns: %v", err)
|
||
// Don't fail the whole operation
|
||
}
|
||
|
||
// Then add to new column if specified
|
||
if post.ColumnID != nil && *post.ColumnID > 0 {
|
||
err = AddPostToColumn(*post.ColumnID, post.ID, 0)
|
||
if err != nil {
|
||
log.Printf("Error adding post to column: %v", err)
|
||
// Don't fail the whole operation
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// UpdatePostRelations 只更新文章的关联关系（分类、专栏、标签），不更新内容
|
||
func UpdatePostRelations(postID uint, categoryID uint, columnID *uint, tagIDs []uint) error {
|
||
// 更新分类和专栏
|
||
updateData := map[string]interface{}{
|
||
"category_id": categoryID,
|
||
"updated_at": time.Now().Unix(),
|
||
}
|
||
|
||
if columnID != nil {
|
||
updateData["column_id"] = columnID
|
||
} else {
|
||
updateData["column_id"] = nil
|
||
}
|
||
|
||
err := config.DB.Model(&models.Post{}).
|
||
Where("id = ? AND deleted_at = ?", postID, 0).
|
||
Updates(updateData).Error
|
||
|
||
if err != nil {
|
||
log.Printf("Error updating post relations: %v", err)
|
||
return err
|
||
}
|
||
|
||
// 更新标签关联
|
||
post := &models.Post{ID: postID}
|
||
if len(tagIDs) > 0 {
|
||
// 构建标签对象
|
||
tags := make([]models.Tag, 0, len(tagIDs))
|
||
for _, tagID := range tagIDs {
|
||
tags = append(tags, models.Tag{ID: tagID})
|
||
}
|
||
err = config.DB.Model(post).Association("Tags").Replace(tags)
|
||
if err != nil {
|
||
log.Printf("Error updating tags: %v", err)
|
||
return err
|
||
}
|
||
} else {
|
||
// 清除所有标签
|
||
err = config.DB.Model(post).Association("Tags").Clear()
|
||
if err != nil {
|
||
log.Printf("Error clearing tags: %v", err)
|
||
return err
|
||
}
|
||
}
|
||
|
||
// 处理专栏关联
|
||
// 先移除所有专栏关联
|
||
err = config.DB.Where("post_id = ?", postID).Delete(&models.ColumnPost{}).Error
|
||
if err != nil {
|
||
log.Printf("Error removing post from columns: %v", err)
|
||
// Don't fail the whole operation
|
||
}
|
||
|
||
// 然后添加新的专栏关联
|
||
if columnID != nil && *columnID > 0 {
|
||
err = AddPostToColumn(*columnID, postID, 0)
|
||
if err != nil {
|
||
log.Printf("Error adding post to column: %v", err)
|
||
// Don't fail the whole operation
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// UpdatePostStatus 更新文章状态
|
||
func UpdatePostStatus(id uint, status int) error {
|
||
err := config.DB.Model(&models.Post{}).
|
||
Where("id = ? AND deleted_at = ?", id, 0).
|
||
Updates(map[string]interface{}{
|
||
"is_published": status,
|
||
"updated_at": time.Now().Unix(),
|
||
}).Error
|
||
return err
|
||
}
|
||
|
||
// DeletePost 删除博客文章 (Soft Delete)
|
||
func DeletePost(id uint) error {
|
||
err := config.DB.Model(&models.Post{}).
|
||
Where("id = ?", id).
|
||
Update("deleted_at", time.Now().Unix()).Error
|
||
if err != nil {
|
||
log.Printf("Error deleting post: %v", err)
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// GetPostCount 获取文章总数
|
||
func GetPostCount() (int, error) {
|
||
var count int64
|
||
err := config.DB.Model(&models.Post{}).
|
||
Where("deleted_at = ?", 0).
|
||
Count(&count).Error
|
||
if err != nil {
|
||
log.Printf("Error getting post count: %v", err)
|
||
return 0, err
|
||
}
|
||
return int(count), nil
|
||
}
|
||
|
||
type userBrief struct {
|
||
Username string
|
||
Avatar string
|
||
Email string
|
||
}
|
||
|
||
func resolveUserBrief(post *models.Post, userMap map[uint]userBrief) (username, avatar, email string) {
|
||
if post.Author != nil && post.Author.ID > 0 {
|
||
return post.Author.Username, post.Author.Avatar, post.Author.Email
|
||
}
|
||
if userMap != nil {
|
||
if u, ok := userMap[post.UserID]; ok {
|
||
return u.Username, u.Avatar, u.Email
|
||
}
|
||
}
|
||
if post.UserID > 0 {
|
||
return lookupUserBrief(post.UserID)
|
||
}
|
||
return "", "", ""
|
||
}
|
||
|
||
func collectPostUserIDs(posts []models.Post) []uint {
|
||
ids := make([]uint, 0, len(posts))
|
||
seen := make(map[uint]struct{})
|
||
for _, post := range posts {
|
||
if post.UserID == 0 {
|
||
continue
|
||
}
|
||
if _, ok := seen[post.UserID]; ok {
|
||
continue
|
||
}
|
||
seen[post.UserID] = struct{}{}
|
||
ids = append(ids, post.UserID)
|
||
}
|
||
return ids
|
||
}
|
||
|
||
func lookupUsersBrief(ids []uint) map[uint]userBrief {
|
||
result := make(map[uint]userBrief)
|
||
if len(ids) == 0 {
|
||
return result
|
||
}
|
||
var users []models.User
|
||
err := config.DB.Model(&models.User{}).
|
||
Select("id", "username", "avatar", "email").
|
||
Where("id IN ? AND deleted_at = ?", ids, 0).
|
||
Find(&users).Error
|
||
if err != nil {
|
||
log.Printf("Error batch loading users: %v", err)
|
||
return result
|
||
}
|
||
for _, user := range users {
|
||
result[user.ID] = userBrief{
|
||
Username: user.Username,
|
||
Avatar: user.Avatar,
|
||
Email: user.Email,
|
||
}
|
||
}
|
||
return result
|
||
}
|
||
|
||
// BuildPostResponse 构建博客文章响应
|
||
func BuildPostResponse(post *models.Post, includeContent bool) *models.PostResponse {
|
||
return buildPostResponse(post, includeContent, true, nil)
|
||
}
|
||
|
||
func buildPostResponse(post *models.Post, includeContent, includeSnippets bool, userMap map[uint]userBrief) *models.PostResponse {
|
||
// Format CreatedAt to Date string
|
||
dateStr := time.Unix(post.CreatedAt, 0).Format("2006-01-02")
|
||
|
||
catName := ""
|
||
catSlug := ""
|
||
if post.Category != nil {
|
||
catName = post.Category.Name
|
||
catSlug = post.Category.Slug
|
||
} else if post.CategoryID > 0 {
|
||
catName = lookupCategoryName(post.CategoryID)
|
||
}
|
||
|
||
colName := ""
|
||
colSlug := ""
|
||
if post.Column != nil {
|
||
colName = post.Column.Name
|
||
}
|
||
|
||
userName, userAvatar, userEmail := resolveUserBrief(post, userMap)
|
||
|
||
response := &models.PostResponse{
|
||
ID: post.ID,
|
||
Title: post.Title,
|
||
CategoryID: post.CategoryID,
|
||
CategoryName: catName,
|
||
CategorySlug: catSlug,
|
||
ColumnID: post.ColumnID,
|
||
ColumnName: colName,
|
||
ColumnSlug: colSlug,
|
||
Date: dateStr,
|
||
Excerpt: post.Excerpt,
|
||
Tags: post.Tags,
|
||
IsPublished: post.IsPublished,
|
||
ReadCount: post.ReadCount,
|
||
UserID: post.UserID,
|
||
UserName: userName,
|
||
UserAvatar: userAvatar,
|
||
UserEmail: userEmail,
|
||
}
|
||
|
||
if includeContent {
|
||
// 使用指针类型，确保即使内容为空字符串也会出现在 JSON 中
|
||
content := post.Content
|
||
response.Content = &content
|
||
}
|
||
|
||
if includeSnippets {
|
||
if snippets, err := GetSnippetsByPostID(post.ID); err == nil && len(snippets) > 0 {
|
||
response.Snippets = snippets
|
||
}
|
||
}
|
||
|
||
return response
|
||
}
|
||
|
||
// BuildPostsResponse 构建博客文章列表响应（不含正文与 snippets，批量查作者）
|
||
func BuildPostsResponse(posts []models.Post) []models.PostResponse {
|
||
if len(posts) == 0 {
|
||
return []models.PostResponse{}
|
||
}
|
||
userMap := lookupUsersBrief(collectPostUserIDs(posts))
|
||
responses := make([]models.PostResponse, 0, len(posts))
|
||
for i := range posts {
|
||
responses = append(responses, *buildPostResponse(&posts[i], false, false, userMap))
|
||
}
|
||
return responses
|
||
}
|
||
|
||
// SavePostHistory 保存文章历史记录
|
||
func SavePostHistory(post *models.Post, modifiedBy uint) error {
|
||
// 获取当前最大版本号
|
||
var maxVersion int
|
||
err := config.DB.Model(&models.PostHistory{}).
|
||
Where("post_id = ?", post.ID).
|
||
Select("COALESCE(MAX(version), 0)").
|
||
Scan(&maxVersion).Error
|
||
if err != nil {
|
||
log.Printf("Error getting max version: %v", err)
|
||
return err
|
||
}
|
||
|
||
tagIDs := make([]uint, 0, len(post.Tags))
|
||
for _, tag := range post.Tags {
|
||
tagIDs = append(tagIDs, tag.ID)
|
||
}
|
||
tagJSON, _ := json.Marshal(tagIDs)
|
||
|
||
history := &models.PostHistory{
|
||
PostID: post.ID,
|
||
Version: maxVersion + 1,
|
||
Title: post.Title,
|
||
CategoryID: post.CategoryID,
|
||
ColumnID: post.ColumnID,
|
||
TagIDs: string(tagJSON),
|
||
Excerpt: post.Excerpt,
|
||
Content: post.Content,
|
||
IsPublished: post.IsPublished,
|
||
ModifiedBy: modifiedBy,
|
||
}
|
||
|
||
err = config.DB.Create(history).Error
|
||
if err != nil {
|
||
log.Printf("Error saving post history: %v", err)
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// GetTopPosts 获取热门文章 (按阅读量)
|
||
func GetTopPosts(limit int) ([]models.Post, error) {
|
||
var posts []models.Post
|
||
err := config.DB.Model(&models.Post{}).
|
||
Preload("Category").
|
||
Preload("Tags").
|
||
Where("is_published = ? AND deleted_at = ?", 1, 0).
|
||
Order("read_count DESC").
|
||
Limit(limit).
|
||
Find(&posts).Error
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return posts, nil
|
||
}
|
||
|
||
// GetNewPostsTrend 获取新增文章趋势
|
||
func GetNewPostsTrend(startDate, endDate string) ([]TrendData, error) {
|
||
// 确定日期范围
|
||
var startTime, endTime time.Time
|
||
if startDate != "" {
|
||
startUnix := parseDateToUnix(startDate, false)
|
||
startTime = time.Unix(startUnix, 0)
|
||
} else {
|
||
startTime = time.Now().AddDate(0, 0, -6)
|
||
startTime = time.Date(startTime.Year(), startTime.Month(), startTime.Day(), 0, 0, 0, 0, time.Local)
|
||
}
|
||
|
||
if endDate != "" {
|
||
endUnix := parseDateToUnix(endDate, true)
|
||
endTime = time.Unix(endUnix, 0)
|
||
} else {
|
||
endTime = time.Now()
|
||
endTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 23, 59, 59, 0, time.Local)
|
||
}
|
||
|
||
// 查询数据库
|
||
query := config.DB.Model(&models.Post{}).
|
||
Select("FROM_UNIXTIME(created_at, '%Y-%m-%d') as date, COUNT(*) as count").
|
||
Where("deleted_at = ?", 0).
|
||
Where("created_at >= ?", startTime.Unix()).
|
||
Where("created_at <= ?", endTime.Unix())
|
||
|
||
var results []TrendData
|
||
err := query.Group("date").
|
||
Order("date ASC").
|
||
Scan(&results).Error
|
||
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 创建日期到数据的映射
|
||
resultMap := make(map[string]TrendData)
|
||
for _, r := range results {
|
||
resultMap[r.Date] = r
|
||
}
|
||
|
||
// 生成完整日期列表
|
||
var fullResults []TrendData
|
||
current := time.Date(startTime.Year(), startTime.Month(), startTime.Day(), 0, 0, 0, 0, time.Local)
|
||
endDay := time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, time.Local)
|
||
|
||
for !current.After(endDay) {
|
||
dateStr := current.Format("2006-01-02")
|
||
if data, exists := resultMap[dateStr]; exists {
|
||
data.YoY = 0
|
||
data.MoM = 0
|
||
fullResults = append(fullResults, data)
|
||
} else {
|
||
// 填充0值
|
||
fullResults = append(fullResults, TrendData{
|
||
Date: dateStr,
|
||
Count: 0,
|
||
YoY: 0,
|
||
MoM: 0,
|
||
})
|
||
}
|
||
current = current.AddDate(0, 0, 1)
|
||
}
|
||
|
||
return fullResults, nil
|
||
}
|
||
|
||
// GetPostHistory 获取文章修改历史
|
||
func GetPostHistory(postID uint) ([]models.PostHistory, error) {
|
||
var history []models.PostHistory
|
||
err := config.DB.Model(&models.PostHistory{}).
|
||
Where("post_id = ?", postID).
|
||
Order("version DESC").
|
||
Find(&history).Error
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return history, nil
|
||
}
|
||
|
||
// GetPostHistoryByVersion 获取特定版本的历史记录
|
||
func GetPostHistoryByVersion(postID uint, version uint) (*models.PostHistory, error) {
|
||
var h models.PostHistory
|
||
err := config.DB.Model(&models.PostHistory{}).
|
||
Where("post_id = ? AND version = ?", postID, version).
|
||
First(&h).Error
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return nil, nil
|
||
}
|
||
return nil, err
|
||
}
|
||
return &h, nil
|
||
}
|
||
|
||
// BuildPostHistoryResponse 构建历史记录响应
|
||
func BuildPostHistoryResponse(h *models.PostHistory, includeFull bool) *models.PostHistoryResponse {
|
||
opName, opAvatar, opEmail := lookupUserBrief(h.ModifiedBy)
|
||
resp := &models.PostHistoryResponse{
|
||
ID: h.ID,
|
||
PostID: h.PostID,
|
||
Version: h.Version,
|
||
Title: h.Title,
|
||
CategoryID: h.CategoryID,
|
||
CategoryName: lookupCategoryName(h.CategoryID),
|
||
ColumnID: h.ColumnID,
|
||
ColumnName: lookupColumnName(h.ColumnID),
|
||
TagIDs: h.GetTagIDList(),
|
||
TagNames: lookupTagNames(h.GetTagIDList()),
|
||
Date: time.Unix(h.CreatedAt, 0).Format("2006-01-02"),
|
||
IsPublished: h.IsPublished,
|
||
ModifiedBy: h.ModifiedBy,
|
||
ModifiedByName: opName,
|
||
UserID: h.ModifiedBy,
|
||
UserName: opName,
|
||
UserAvatar: opAvatar,
|
||
UserEmail: opEmail,
|
||
ModifiedAt: time.Unix(h.ModifiedAt, 0).Format("2006-01-02 15:04:05"),
|
||
CreatedAt: time.Unix(h.CreatedAt, 0).Format("2006-01-02 15:04:05"),
|
||
}
|
||
|
||
if includeFull {
|
||
resp.Excerpt = h.Excerpt
|
||
resp.Content = h.Content
|
||
}
|
||
|
||
return resp
|
||
}
|
||
|
||
func lookupCategoryName(id uint) string {
|
||
if id == 0 {
|
||
return ""
|
||
}
|
||
var name string
|
||
config.DB.Model(&models.Category{}).Where("id = ?", id).Pluck("name", &name)
|
||
return name
|
||
}
|
||
|
||
func lookupColumnName(id *uint) string {
|
||
if id == nil || *id == 0 {
|
||
return ""
|
||
}
|
||
var name string
|
||
config.DB.Model(&models.Column{}).Where("id = ?", *id).Pluck("name", &name)
|
||
return name
|
||
}
|
||
|
||
func lookupTagNames(ids []uint) []string {
|
||
if len(ids) == 0 {
|
||
return nil
|
||
}
|
||
var tags []models.Tag
|
||
config.DB.Model(&models.Tag{}).Where("id IN ?", ids).Find(&tags)
|
||
names := make([]string, 0, len(tags))
|
||
for _, t := range tags {
|
||
names = append(names, t.Name)
|
||
}
|
||
return names
|
||
}
|
||
|
||
func lookupUserBrief(id uint) (username, avatar, email string) {
|
||
if id == 0 {
|
||
return "", "", ""
|
||
}
|
||
var user models.User
|
||
err := config.DB.Model(&models.User{}).
|
||
Select("username", "avatar", "email").
|
||
Where("id = ? AND deleted_at = ?", id, 0).
|
||
First(&user).Error
|
||
if err != nil {
|
||
return "", "", ""
|
||
}
|
||
return user.Username, user.Avatar, user.Email
|
||
}
|
||
|
||
func lookupUsername(id uint) string {
|
||
name, _, _ := lookupUserBrief(id)
|
||
return name
|
||
}
|
||
|
||
func formatPublishedLabel(v int) string {
|
||
if v == 1 {
|
||
return "已发布"
|
||
}
|
||
return "草稿"
|
||
}
|
||
|
||
// BuildPostHistoryResponses 构建历史记录列表响应
|
||
func BuildPostHistoryResponses(history []models.PostHistory) []models.PostHistoryResponse {
|
||
var responses []models.PostHistoryResponse
|
||
for _, h := range history {
|
||
responses = append(responses, *BuildPostHistoryResponse(&h, false))
|
||
}
|
||
return responses
|
||
}
|
||
|
||
func buildFieldDiff(from, to string, withLineDiff bool) models.PostHistoryFieldDiff {
|
||
diff := models.PostHistoryFieldDiff{
|
||
From: from,
|
||
To: to,
|
||
Changed: from != to,
|
||
}
|
||
if withLineDiff && from != to {
|
||
dmp := diffmatchpatch.New()
|
||
patches := dmp.PatchMake(from, to)
|
||
diff.Diff = dmp.PatchToText(patches)
|
||
}
|
||
return diff
|
||
}
|
||
|
||
// GetPostHistoryDiff compares two history versions.
|
||
func GetPostHistoryDiff(postID uint, fromVersion, toVersion uint) (*models.PostHistoryDiffResponse, error) {
|
||
fromHistory, err := GetPostHistoryByVersion(postID, fromVersion)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if fromHistory == nil {
|
||
return nil, fmt.Errorf("from version not found")
|
||
}
|
||
|
||
toHistory, err := GetPostHistoryByVersion(postID, toVersion)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if toHistory == nil {
|
||
return nil, fmt.Errorf("to version not found")
|
||
}
|
||
|
||
fields := map[string]models.PostHistoryFieldDiff{
|
||
"title": buildFieldDiff(fromHistory.Title, toHistory.Title, false),
|
||
"excerpt": buildFieldDiff(fromHistory.Excerpt, toHistory.Excerpt, false),
|
||
"content": buildFieldDiff(fromHistory.Content, toHistory.Content, true),
|
||
"category": buildFieldDiff(lookupCategoryName(fromHistory.CategoryID), lookupCategoryName(toHistory.CategoryID), false),
|
||
"column": buildFieldDiff(lookupColumnName(fromHistory.ColumnID), lookupColumnName(toHistory.ColumnID), false),
|
||
"tags": buildFieldDiff(strings.Join(lookupTagNames(fromHistory.GetTagIDList()), ", "), strings.Join(lookupTagNames(toHistory.GetTagIDList()), ", "), false),
|
||
"isPublished": buildFieldDiff(formatPublishedLabel(fromHistory.IsPublished), formatPublishedLabel(toHistory.IsPublished), false),
|
||
}
|
||
|
||
return &models.PostHistoryDiffResponse{
|
||
FromVersion: int(fromVersion),
|
||
ToVersion: int(toVersion),
|
||
Fields: fields,
|
||
}, nil
|
||
}
|
||
|
||
func formatOptionalUint(v *uint) string {
|
||
if v == nil {
|
||
return ""
|
||
}
|
||
return strconv.FormatUint(uint64(*v), 10)
|
||
}
|
||
|
||
// RestorePostFromHistory restores a post from a history snapshot and saves a new history entry.
|
||
func RestorePostFromHistory(postID, version, modifiedBy uint) (*models.Post, error) {
|
||
history, err := GetPostHistoryByVersion(postID, version)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if history == nil {
|
||
return nil, fmt.Errorf("history version not found")
|
||
}
|
||
|
||
var post models.Post
|
||
if err := config.DB.Preload("Tags").Where("id = ? AND deleted_at = ?", postID, 0).First(&post).Error; err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
post.Title = history.Title
|
||
post.CategoryID = history.CategoryID
|
||
post.ColumnID = history.ColumnID
|
||
post.Excerpt = history.Excerpt
|
||
post.Content = history.Content
|
||
post.IsPublished = history.IsPublished
|
||
|
||
if err := UpdatePost(&post); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
tagIDs := history.GetTagIDList()
|
||
tags := make([]models.Tag, 0, len(tagIDs))
|
||
for _, id := range tagIDs {
|
||
tags = append(tags, models.Tag{ID: id})
|
||
}
|
||
if err := config.DB.Model(&post).Association("Tags").Replace(tags); err != nil {
|
||
return nil, err
|
||
}
|
||
post.Tags = tags
|
||
|
||
if err := SavePostHistory(&post, modifiedBy); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
reloaded, err := GetPostByIDAdmin(postID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return reloaded, nil
|
||
}
|
||
|
||
// GetPostByIDAdmin loads a post for admin use without incrementing read count.
|
||
func GetPostByIDAdmin(id uint) (*models.Post, error) {
|
||
var post models.Post
|
||
err := config.DB.Model(&models.Post{}).
|
||
Preload("Category").
|
||
Preload("Column").
|
||
Preload("Tags").
|
||
Where("id = ? AND deleted_at = ?", id, 0).
|
||
First(&post).Error
|
||
if err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return nil, nil
|
||
}
|
||
return nil, err
|
||
}
|
||
return &post, nil
|
||
}
|
||
|
||
// GetRecommendedPostsByIP 基于IP的协同过滤推荐算法
|
||
// 查找相同IP访问过的其他文章，按访问频率排序返回
|
||
func GetRecommendedPostsByIP(currentPostID uint, userIP string, limit int) ([]models.Post, error) {
|
||
if userIP == "" {
|
||
// 如果IP为空，返回热门文章作为备选
|
||
return GetTopPosts(limit)
|
||
}
|
||
|
||
// 1. 查找相同IP访问过的其他文章ID及其访问次数
|
||
type PostAccessCount struct {
|
||
ArticleID uint
|
||
Count int64
|
||
}
|
||
|
||
var accessCounts []PostAccessCount
|
||
err := config.DB.Model(&models.UserAccessLog{}).
|
||
Select("article_id, COUNT(*) as count").
|
||
Where("user_ip = ? AND article_id != ? AND deleted_at = ?", userIP, currentPostID, 0).
|
||
Group("article_id").
|
||
Order("count DESC").
|
||
Limit(limit * 2). // 多查询一些，因为后面还要过滤未发布的文章
|
||
Scan(&accessCounts).Error
|
||
|
||
if err != nil {
|
||
log.Printf("Error querying recommended posts by IP: %v", err)
|
||
// 如果查询失败，返回热门文章作为备选
|
||
return GetTopPosts(limit)
|
||
}
|
||
|
||
if len(accessCounts) == 0 {
|
||
// 如果没有访问记录，返回热门文章作为备选
|
||
return GetTopPosts(limit)
|
||
}
|
||
|
||
// 2. 提取文章ID列表
|
||
articleIDs := make([]uint, 0, len(accessCounts))
|
||
for _, ac := range accessCounts {
|
||
articleIDs = append(articleIDs, ac.ArticleID)
|
||
}
|
||
|
||
// 3. 查询这些文章的详细信息（排除未发布的文章）
|
||
var posts []models.Post
|
||
err = config.DB.Model(&models.Post{}).
|
||
Preload("Category").
|
||
Preload("Tags").
|
||
Where("id IN ? AND is_published = ? AND deleted_at = ?", articleIDs, 1, 0).
|
||
Find(&posts).Error
|
||
|
||
if err != nil {
|
||
log.Printf("Error fetching recommended posts: %v", err)
|
||
return GetTopPosts(limit)
|
||
}
|
||
|
||
// 4. 按照访问次数排序（保持与 accessCounts 的顺序一致）
|
||
postMap := make(map[uint]models.Post)
|
||
for _, post := range posts {
|
||
postMap[post.ID] = post
|
||
}
|
||
|
||
var sortedPosts []models.Post
|
||
for _, ac := range accessCounts {
|
||
if post, exists := postMap[ac.ArticleID]; exists {
|
||
sortedPosts = append(sortedPosts, post)
|
||
if len(sortedPosts) >= limit {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
// 5. 如果推荐的文章数量不足，用热门文章补充
|
||
if len(sortedPosts) < limit {
|
||
topPosts, err := GetTopPosts(limit - len(sortedPosts))
|
||
if err == nil {
|
||
// 排除已经推荐的文章
|
||
existingIDs := make(map[uint]bool)
|
||
for _, p := range sortedPosts {
|
||
existingIDs[p.ID] = true
|
||
}
|
||
for _, p := range topPosts {
|
||
if !existingIDs[p.ID] && p.ID != currentPostID {
|
||
sortedPosts = append(sortedPosts, p)
|
||
if len(sortedPosts) >= limit {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return sortedPosts, nil
|
||
}
|
||
|
||
func parseDateStart(dateStr string) (int64, error) {
|
||
t, err := time.ParseInLocation("2006-01-02", dateStr, time.Local)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return t.Unix(), nil
|
||
}
|
||
|
||
func parseDateEnd(dateStr string) (int64, error) {
|
||
t, err := time.ParseInLocation("2006-01-02", dateStr, time.Local)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return t.Add(24*time.Hour - time.Second).Unix(), nil
|
||
}
|