mirror of
https://github.com/ctwj/urldb.git
synced 2025-11-25 03:15:04 +08:00
1508 lines
44 KiB
Go
1508 lines
44 KiB
Go
package handlers
|
||
|
||
import (
|
||
"fmt"
|
||
"net/http"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
pan "github.com/ctwj/urldb/common"
|
||
panutils "github.com/ctwj/urldb/common"
|
||
commonutils "github.com/ctwj/urldb/common/utils"
|
||
"github.com/ctwj/urldb/db/converter"
|
||
"github.com/ctwj/urldb/db/dto"
|
||
"github.com/ctwj/urldb/db/entity"
|
||
"github.com/ctwj/urldb/utils"
|
||
|
||
"github.com/gin-gonic/gin"
|
||
)
|
||
|
||
// GetResources 获取资源列表
|
||
func GetResources(c *gin.Context) {
|
||
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
||
pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
|
||
|
||
utils.Info("资源列表请求 - page: %d, pageSize: %d, User-Agent: %s", page, pageSize, c.GetHeader("User-Agent"))
|
||
|
||
// 添加缓存控制头，优化 SSR 性能
|
||
c.Header("Cache-Control", "public, max-age=30") // 30秒缓存，平衡性能和实时性
|
||
c.Header("ETag", fmt.Sprintf("resources-%d-%d-%s-%s", page, pageSize, c.Query("search"), c.Query("pan_id")))
|
||
|
||
params := map[string]interface{}{
|
||
"page": page,
|
||
"page_size": pageSize,
|
||
}
|
||
|
||
if search := c.Query("search"); search != "" {
|
||
params["search"] = search
|
||
}
|
||
if panID := c.Query("pan_id"); panID != "" {
|
||
if id, err := strconv.ParseUint(panID, 10, 32); err == nil {
|
||
params["pan_id"] = uint(id)
|
||
}
|
||
}
|
||
if categoryID := c.Query("category_id"); categoryID != "" {
|
||
utils.Info("收到分类ID参数: %s", categoryID)
|
||
if id, err := strconv.ParseUint(categoryID, 10, 32); err == nil {
|
||
params["category_id"] = uint(id)
|
||
utils.Info("解析分类ID成功: %d", uint(id))
|
||
} else {
|
||
utils.Error("解析分类ID失败: %v", err)
|
||
}
|
||
}
|
||
if hasSaveURL := c.Query("has_save_url"); hasSaveURL != "" {
|
||
if hasSaveURL == "true" {
|
||
params["has_save_url"] = true
|
||
} else if hasSaveURL == "false" {
|
||
params["has_save_url"] = false
|
||
}
|
||
}
|
||
if noSaveURL := c.Query("no_save_url"); noSaveURL != "" {
|
||
if noSaveURL == "true" {
|
||
params["no_save_url"] = true
|
||
}
|
||
}
|
||
if panName := c.Query("pan_name"); panName != "" {
|
||
params["pan_name"] = panName
|
||
}
|
||
|
||
// 获取违禁词配置（只获取一次）
|
||
cleanWords, err := utils.GetForbiddenWordsFromConfig(func() (string, error) {
|
||
return repoManager.SystemConfigRepository.GetConfigValue(entity.ConfigKeyForbiddenWords)
|
||
})
|
||
if err != nil {
|
||
utils.Error("获取违禁词配置失败: %v", err)
|
||
cleanWords = []string{} // 如果获取失败，使用空列表
|
||
}
|
||
|
||
var resources []entity.Resource
|
||
var total int64
|
||
|
||
// 如果有搜索关键词且启用了Meilisearch，优先使用Meilisearch搜索
|
||
if search := c.Query("search"); search != "" && meilisearchManager != nil && meilisearchManager.IsEnabled() {
|
||
// 构建Meilisearch过滤器
|
||
filters := make(map[string]interface{})
|
||
if panID := c.Query("pan_id"); panID != "" {
|
||
if id, err := strconv.ParseUint(panID, 10, 32); err == nil {
|
||
// 直接使用pan_id进行过滤
|
||
filters["pan_id"] = id
|
||
}
|
||
}
|
||
|
||
// 使用Meilisearch搜索
|
||
service := meilisearchManager.GetService()
|
||
if service != nil {
|
||
docs, docTotal, err := service.Search(search, filters, page, pageSize)
|
||
if err == nil {
|
||
|
||
// 将Meilisearch文档转换为ResourceResponse（包含高亮信息）并处理违禁词
|
||
var resourceResponses []dto.ResourceResponse
|
||
for _, doc := range docs {
|
||
resourceResponse := converter.ToResourceResponseFromMeilisearch(doc)
|
||
|
||
// 处理违禁词（Meilisearch场景，需要处理高亮标记）
|
||
if len(cleanWords) > 0 {
|
||
forbiddenInfo := utils.CheckResourceForbiddenWords(resourceResponse.Title, resourceResponse.Description, cleanWords)
|
||
if forbiddenInfo.HasForbiddenWords {
|
||
resourceResponse.Title = forbiddenInfo.ProcessedTitle
|
||
resourceResponse.Description = forbiddenInfo.ProcessedDesc
|
||
resourceResponse.TitleHighlight = forbiddenInfo.ProcessedTitle
|
||
resourceResponse.DescriptionHighlight = forbiddenInfo.ProcessedDesc
|
||
}
|
||
resourceResponse.HasForbiddenWords = forbiddenInfo.HasForbiddenWords
|
||
resourceResponse.ForbiddenWords = forbiddenInfo.ForbiddenWords
|
||
}
|
||
|
||
resourceResponses = append(resourceResponses, resourceResponse)
|
||
}
|
||
|
||
// 返回Meilisearch搜索结果（包含高亮信息）
|
||
SuccessResponse(c, gin.H{
|
||
"data": resourceResponses,
|
||
"total": docTotal,
|
||
"page": page,
|
||
"page_size": pageSize,
|
||
"source": "meilisearch",
|
||
})
|
||
return
|
||
} else {
|
||
utils.Error("Meilisearch搜索失败，回退到数据库搜索: %v", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果Meilisearch未启用、搜索失败或没有搜索关键词，使用数据库搜索
|
||
if meilisearchManager == nil || !meilisearchManager.IsEnabled() || len(resources) == 0 {
|
||
resources, total, err = repoManager.ResourceRepository.SearchWithFilters(params)
|
||
}
|
||
|
||
if err != nil {
|
||
ErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
// 处理违禁词替换和标记
|
||
var processedResources []entity.Resource
|
||
if len(cleanWords) > 0 {
|
||
processedResources = utils.ProcessResourcesForbiddenWords(resources, cleanWords)
|
||
// 复制标签数据到处理后的资源
|
||
for i := range processedResources {
|
||
if i < len(resources) {
|
||
processedResources[i].Tags = resources[i].Tags
|
||
}
|
||
}
|
||
} else {
|
||
processedResources = resources
|
||
}
|
||
|
||
// 转换为响应格式并添加违禁词标记
|
||
var resourceResponses []gin.H
|
||
for i, processedResource := range processedResources {
|
||
// 使用原始资源进行检查违禁词（数据库搜索场景，使用普通处理）
|
||
originalResource := resources[i]
|
||
forbiddenInfo := utils.CheckResourceForbiddenWords(originalResource.Title, originalResource.Description, cleanWords)
|
||
|
||
resourceResponse := gin.H{
|
||
"id": processedResource.ID,
|
||
"key": processedResource.Key, // 添加key字段
|
||
"title": forbiddenInfo.ProcessedTitle, // 使用处理后的标题
|
||
"url": processedResource.URL,
|
||
"description": forbiddenInfo.ProcessedDesc, // 使用处理后的描述
|
||
"pan_id": processedResource.PanID,
|
||
"view_count": processedResource.ViewCount,
|
||
"created_at": processedResource.CreatedAt.Format("2006-01-02 15:04:05"),
|
||
"updated_at": processedResource.UpdatedAt.Format("2006-01-02 15:04:05"),
|
||
}
|
||
|
||
// 添加违禁词标记
|
||
resourceResponse["has_forbidden_words"] = forbiddenInfo.HasForbiddenWords
|
||
resourceResponse["forbidden_words"] = forbiddenInfo.ForbiddenWords
|
||
|
||
// 添加标签信息（需要预加载）
|
||
var tagResponses []gin.H
|
||
if len(processedResource.Tags) > 0 {
|
||
for _, tag := range processedResource.Tags {
|
||
tagResponse := gin.H{
|
||
"id": tag.ID,
|
||
"name": tag.Name,
|
||
"description": tag.Description,
|
||
}
|
||
tagResponses = append(tagResponses, tagResponse)
|
||
}
|
||
}
|
||
resourceResponse["tags"] = tagResponses
|
||
resourceResponse["cover"] = originalResource.Cover
|
||
|
||
resourceResponses = append(resourceResponses, resourceResponse)
|
||
}
|
||
|
||
// 构建响应数据
|
||
responseData := gin.H{
|
||
"data": resourceResponses,
|
||
"total": total,
|
||
"page": page,
|
||
"page_size": pageSize,
|
||
}
|
||
|
||
SuccessResponse(c, responseData)
|
||
}
|
||
|
||
// GetResourceByID 根据ID获取资源
|
||
func GetResourceByID(c *gin.Context) {
|
||
idStr := c.Param("id")
|
||
id, err := strconv.ParseUint(idStr, 10, 32)
|
||
if err != nil {
|
||
ErrorResponse(c, "无效的ID", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
resource, err := repoManager.ResourceRepository.FindByID(uint(id))
|
||
if err != nil {
|
||
ErrorResponse(c, "资源不存在", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
response := converter.ToResourceResponse(resource)
|
||
SuccessResponse(c, response)
|
||
}
|
||
|
||
// GetResourcesByKey 根据Key获取资源组
|
||
func GetResourcesByKey(c *gin.Context) {
|
||
key := c.Param("key")
|
||
if key == "" {
|
||
ErrorResponse(c, "Key参数不能为空", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
resources, err := repoManager.ResourceRepository.FindByKey(key)
|
||
if err != nil {
|
||
ErrorResponse(c, "资源不存在", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
if len(resources) == 0 {
|
||
ErrorResponse(c, "资源不存在", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
// 转换为响应格式并处理违禁词
|
||
cleanWords, err := utils.GetForbiddenWordsFromConfig(func() (string, error) {
|
||
return repoManager.SystemConfigRepository.GetConfigValue(entity.ConfigKeyForbiddenWords)
|
||
})
|
||
if err != nil {
|
||
utils.Error("获取违禁词配置失败: %v", err)
|
||
cleanWords = []string{}
|
||
}
|
||
|
||
var responses []dto.ResourceResponse
|
||
for _, resource := range resources {
|
||
response := converter.ToResourceResponse(&resource)
|
||
// 检查违禁词
|
||
forbiddenInfo := utils.CheckResourceForbiddenWords(response.Title, response.Description, cleanWords)
|
||
response.HasForbiddenWords = forbiddenInfo.HasForbiddenWords
|
||
response.ForbiddenWords = forbiddenInfo.ForbiddenWords
|
||
responses = append(responses, response)
|
||
}
|
||
|
||
SuccessResponse(c, gin.H{
|
||
"resources": responses,
|
||
"total": len(responses),
|
||
"key": key,
|
||
})
|
||
}
|
||
|
||
// CheckResourceExists 检查资源是否存在（测试FindExists函数）
|
||
func CheckResourceExists(c *gin.Context) {
|
||
url := c.Query("url")
|
||
if url == "" {
|
||
ErrorResponse(c, "URL参数不能为空", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
excludeIDStr := c.Query("exclude_id")
|
||
var excludeID uint
|
||
if excludeIDStr != "" {
|
||
if id, err := strconv.ParseUint(excludeIDStr, 10, 32); err == nil {
|
||
excludeID = uint(id)
|
||
}
|
||
}
|
||
|
||
exists, err := repoManager.ResourceRepository.FindExists(url, excludeID)
|
||
if err != nil {
|
||
ErrorResponse(c, "检查失败: "+err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
SuccessResponse(c, gin.H{
|
||
"url": url,
|
||
"exists": exists,
|
||
})
|
||
}
|
||
|
||
// CreateResource 创建资源
|
||
func CreateResource(c *gin.Context) {
|
||
var req dto.CreateResourceRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
ErrorResponse(c, err.Error(), http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
resource := &entity.Resource{
|
||
Title: req.Title,
|
||
Description: req.Description,
|
||
URL: req.URL,
|
||
PanID: req.PanID,
|
||
SaveURL: req.SaveURL,
|
||
FileSize: req.FileSize,
|
||
CategoryID: req.CategoryID,
|
||
IsValid: req.IsValid,
|
||
IsPublic: req.IsPublic,
|
||
Cover: req.Cover,
|
||
Author: req.Author,
|
||
ErrorMsg: req.ErrorMsg,
|
||
}
|
||
|
||
err := repoManager.ResourceRepository.Create(resource)
|
||
if err != nil {
|
||
ErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
// 处理标签关联
|
||
if len(req.TagIDs) > 0 {
|
||
err = repoManager.ResourceRepository.UpdateWithTags(resource, req.TagIDs)
|
||
if err != nil {
|
||
ErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
}
|
||
|
||
// 同步到Meilisearch
|
||
if meilisearchManager != nil && meilisearchManager.IsEnabled() {
|
||
go func() {
|
||
if err := meilisearchManager.SyncResourceToMeilisearch(resource); err != nil {
|
||
utils.Error("同步资源到Meilisearch失败: %v", err)
|
||
}
|
||
}()
|
||
}
|
||
|
||
SuccessResponse(c, gin.H{
|
||
"message": "资源创建成功",
|
||
"resource": converter.ToResourceResponse(resource),
|
||
})
|
||
}
|
||
|
||
// UpdateResource 更新资源
|
||
func UpdateResource(c *gin.Context) {
|
||
idStr := c.Param("id")
|
||
id, err := strconv.ParseUint(idStr, 10, 32)
|
||
if err != nil {
|
||
ErrorResponse(c, "无效的ID", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
var req dto.UpdateResourceRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
ErrorResponse(c, err.Error(), http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
resource, err := repoManager.ResourceRepository.FindByID(uint(id))
|
||
if err != nil {
|
||
ErrorResponse(c, "资源不存在", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
// 更新资源信息
|
||
if req.Title != "" {
|
||
resource.Title = req.Title
|
||
}
|
||
if req.Description != "" {
|
||
resource.Description = req.Description
|
||
}
|
||
if req.URL != "" {
|
||
resource.URL = req.URL
|
||
}
|
||
if req.PanID != nil {
|
||
resource.PanID = req.PanID
|
||
}
|
||
if req.SaveURL != "" {
|
||
resource.SaveURL = req.SaveURL
|
||
}
|
||
if req.FileSize != "" {
|
||
resource.FileSize = req.FileSize
|
||
}
|
||
if req.CategoryID != nil {
|
||
resource.CategoryID = req.CategoryID
|
||
}
|
||
resource.IsValid = req.IsValid
|
||
resource.IsPublic = req.IsPublic
|
||
if req.Cover != "" {
|
||
resource.Cover = req.Cover
|
||
}
|
||
if req.Author != "" {
|
||
resource.Author = req.Author
|
||
}
|
||
if req.ErrorMsg != "" {
|
||
resource.ErrorMsg = req.ErrorMsg
|
||
}
|
||
|
||
// 处理标签关联
|
||
if len(req.TagIDs) > 0 {
|
||
err = repoManager.ResourceRepository.UpdateWithTags(resource, req.TagIDs)
|
||
if err != nil {
|
||
ErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
} else {
|
||
err = repoManager.ResourceRepository.Update(resource)
|
||
if err != nil {
|
||
ErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
}
|
||
|
||
// 同步到Meilisearch
|
||
if meilisearchManager != nil && meilisearchManager.IsEnabled() {
|
||
go func() {
|
||
if err := meilisearchManager.SyncResourceToMeilisearch(resource); err != nil {
|
||
utils.Error("同步资源到Meilisearch失败: %v", err)
|
||
}
|
||
}()
|
||
}
|
||
|
||
SuccessResponse(c, gin.H{"message": "资源更新成功"})
|
||
}
|
||
|
||
// DeleteResource 删除资源
|
||
func DeleteResource(c *gin.Context) {
|
||
idStr := c.Param("id")
|
||
id, err := strconv.ParseUint(idStr, 10, 32)
|
||
if err != nil {
|
||
ErrorResponse(c, "无效的ID", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
// 先从数据库中删除资源
|
||
err = repoManager.ResourceRepository.Delete(uint(id))
|
||
if err != nil {
|
||
ErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
// 如果启用了Meilisearch，尝试从Meilisearch中删除对应数据
|
||
if meilisearchManager != nil && meilisearchManager.IsEnabled() {
|
||
go func() {
|
||
service := meilisearchManager.GetService()
|
||
if service != nil {
|
||
if err := service.DeleteDocument(uint(id)); err != nil {
|
||
utils.Error("从Meilisearch删除资源失败 (ID: %d): %v", uint(id), err)
|
||
} else {
|
||
utils.Info("成功从Meilisearch删除资源 (ID: %d)", uint(id))
|
||
}
|
||
} else {
|
||
utils.Error("无法获取Meilisearch服务进行资源删除 (ID: %d)", uint(id))
|
||
}
|
||
}()
|
||
}
|
||
|
||
SuccessResponse(c, gin.H{"message": "资源删除成功"})
|
||
}
|
||
|
||
// SearchResources 搜索资源
|
||
func SearchResources(c *gin.Context) {
|
||
query := c.Query("q")
|
||
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
||
pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
|
||
|
||
var resources []entity.Resource
|
||
var total int64
|
||
var err error
|
||
|
||
// 如果启用了Meilisearch，优先使用Meilisearch搜索
|
||
if meilisearchManager != nil && meilisearchManager.IsEnabled() {
|
||
// 构建过滤器
|
||
filters := make(map[string]interface{})
|
||
if categoryID := c.Query("category_id"); categoryID != "" {
|
||
if id, err := strconv.ParseUint(categoryID, 10, 32); err == nil {
|
||
filters["category"] = uint(id)
|
||
}
|
||
}
|
||
|
||
// 使用Meilisearch搜索
|
||
service := meilisearchManager.GetService()
|
||
if service != nil {
|
||
docs, docTotal, err := service.Search(query, filters, page, pageSize)
|
||
if err == nil {
|
||
// 将Meilisearch文档转换为Resource实体
|
||
for _, doc := range docs {
|
||
resource := entity.Resource{
|
||
ID: doc.ID,
|
||
Title: doc.Title,
|
||
Description: doc.Description,
|
||
URL: doc.URL,
|
||
SaveURL: doc.SaveURL,
|
||
FileSize: doc.FileSize,
|
||
Key: doc.Key,
|
||
PanID: doc.PanID,
|
||
CreatedAt: doc.CreatedAt,
|
||
UpdatedAt: doc.UpdatedAt,
|
||
}
|
||
resources = append(resources, resource)
|
||
}
|
||
total = docTotal
|
||
} else {
|
||
utils.Error("Meilisearch搜索失败，回退到数据库搜索: %v", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果Meilisearch未启用或搜索失败，使用数据库搜索
|
||
if meilisearchManager == nil || !meilisearchManager.IsEnabled() || err != nil {
|
||
if query == "" {
|
||
// 搜索关键词为空时，返回最新记录（分页）
|
||
resources, total, err = repoManager.ResourceRepository.FindWithRelationsPaginated(page, pageSize)
|
||
} else {
|
||
// 有搜索关键词时，执行搜索
|
||
resources, total, err = repoManager.ResourceRepository.Search(query, nil, page, pageSize)
|
||
}
|
||
}
|
||
|
||
if err != nil {
|
||
ErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
SuccessResponse(c, gin.H{
|
||
"resources": converter.ToResourceResponseList(resources),
|
||
"total": total,
|
||
"page": page,
|
||
"page_size": pageSize,
|
||
})
|
||
}
|
||
|
||
// 增加资源浏览次数
|
||
func IncrementResourceViewCount(c *gin.Context) {
|
||
idStr := c.Param("id")
|
||
id, err := strconv.Atoi(idStr)
|
||
if err != nil {
|
||
ErrorResponse(c, "无效的资源ID", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
// 增加资源访问量
|
||
err = repoManager.ResourceRepository.IncrementViewCount(uint(id))
|
||
if err != nil {
|
||
ErrorResponse(c, "增加浏览次数失败", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
// 记录访问记录
|
||
ipAddress := c.ClientIP()
|
||
userAgent := c.GetHeader("User-Agent")
|
||
err = repoManager.ResourceViewRepository.RecordView(uint(id), ipAddress, userAgent)
|
||
if err != nil {
|
||
// 记录访问失败不影响主要功能，只记录日志
|
||
utils.Error("记录资源访问失败: %v", err)
|
||
}
|
||
|
||
SuccessResponse(c, gin.H{"message": "浏览次数+1"})
|
||
}
|
||
|
||
// BatchDeleteResources 批量删除资源
|
||
func BatchDeleteResources(c *gin.Context) {
|
||
var req struct {
|
||
IDs []uint `json:"ids"`
|
||
}
|
||
if err := c.ShouldBindJSON(&req); err != nil || len(req.IDs) == 0 {
|
||
ErrorResponse(c, "参数错误", 400)
|
||
return
|
||
}
|
||
|
||
count := 0
|
||
var deletedIDs []uint
|
||
|
||
// 先删除数据库中的资源
|
||
for _, id := range req.IDs {
|
||
if err := repoManager.ResourceRepository.Delete(id); err == nil {
|
||
count++
|
||
deletedIDs = append(deletedIDs, id)
|
||
}
|
||
}
|
||
|
||
// 如果启用了Meilisearch，异步删除对应的搜索数据
|
||
if meilisearchManager != nil && meilisearchManager.IsEnabled() && len(deletedIDs) > 0 {
|
||
go func() {
|
||
service := meilisearchManager.GetService()
|
||
if service != nil {
|
||
deletedCount := 0
|
||
for _, id := range deletedIDs {
|
||
if err := service.DeleteDocument(id); err != nil {
|
||
utils.Error("从Meilisearch批量删除资源失败 (ID: %d): %v", id, err)
|
||
} else {
|
||
deletedCount++
|
||
utils.Info("成功从Meilisearch批量删除资源 (ID: %d)", id)
|
||
}
|
||
}
|
||
utils.Info("批量删除完成：成功删除 %d 个资源，Meilisearch删除 %d 个资源", count, deletedCount)
|
||
} else {
|
||
utils.Error("批量删除时无法获取Meilisearch服务")
|
||
}
|
||
}()
|
||
}
|
||
|
||
SuccessResponse(c, gin.H{"deleted": count, "message": "批量删除成功"})
|
||
}
|
||
|
||
// GetResourceLink 获取资源链接（智能转存）
|
||
func GetResourceLink(c *gin.Context) {
|
||
// 获取资源ID
|
||
resourceIDStr := c.Param("id")
|
||
resourceID, err := strconv.ParseUint(resourceIDStr, 10, 32)
|
||
if err != nil {
|
||
ErrorResponse(c, "无效的资源ID", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
utils.Info("获取资源链接请求 - resourceID: %d", resourceID)
|
||
|
||
// 查询资源信息
|
||
resource, err := repoManager.ResourceRepository.FindByID(uint(resourceID))
|
||
if err != nil {
|
||
utils.Error("查询资源失败: %v", err)
|
||
ErrorResponse(c, "资源不存在", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
// 查询平台信息
|
||
var panInfo entity.Pan
|
||
if resource.PanID != nil {
|
||
panPtr, err := repoManager.PanRepository.FindByID(*resource.PanID)
|
||
if err != nil {
|
||
utils.Error("查询平台信息失败: %v", err)
|
||
} else if panPtr != nil {
|
||
panInfo = *panPtr
|
||
}
|
||
}
|
||
|
||
utils.Info("资源信息 - 平台: %s, 原始链接: %s, 转存链接: %s", panInfo.Name, resource.URL, resource.SaveURL)
|
||
|
||
// 统计访问次数
|
||
err = repoManager.ResourceRepository.IncrementViewCount(uint(resourceID))
|
||
if err != nil {
|
||
utils.Error("增加资源访问量失败: %v", err)
|
||
}
|
||
|
||
// 记录访问记录
|
||
ipAddress := c.ClientIP()
|
||
userAgent := c.GetHeader("User-Agent")
|
||
err = repoManager.ResourceViewRepository.RecordView(uint(resourceID), ipAddress, userAgent)
|
||
if err != nil {
|
||
utils.Error("记录资源访问失败: %v", err)
|
||
}
|
||
|
||
// 如果不是夸克网盘，直接返回原链接
|
||
if panInfo.Name != "quark" && panInfo.Name != "xunlei" {
|
||
utils.Info("非夸克和迅雷资源，直接返回原链接")
|
||
SuccessResponse(c, gin.H{
|
||
"url": resource.URL,
|
||
"type": "original",
|
||
"platform": panInfo.Remark,
|
||
"resource_id": resource.ID,
|
||
})
|
||
return
|
||
}
|
||
|
||
// 如果已存在转存链接，直接返回
|
||
if resource.SaveURL != "" {
|
||
utils.Info("已存在转存链接，直接返回: %s", resource.SaveURL)
|
||
SuccessResponse(c, gin.H{
|
||
"url": resource.SaveURL,
|
||
"type": "transferred",
|
||
"platform": panInfo.Remark,
|
||
"resource_id": resource.ID,
|
||
})
|
||
return
|
||
}
|
||
|
||
// 检查是否开启自动转存
|
||
autoTransferEnabled, err := repoManager.SystemConfigRepository.GetConfigBool(entity.ConfigKeyAutoTransferEnabled)
|
||
if err != nil {
|
||
utils.Error("获取自动转存配置失败: %v", err)
|
||
// 配置获取失败，返回原链接
|
||
SuccessResponse(c, gin.H{
|
||
"url": resource.URL,
|
||
"type": "original",
|
||
"platform": panInfo.Remark,
|
||
"resource_id": resource.ID,
|
||
"message": "",
|
||
})
|
||
return
|
||
}
|
||
|
||
if !autoTransferEnabled {
|
||
utils.Info("自动转存功能未开启，返回原链接")
|
||
SuccessResponse(c, gin.H{
|
||
"url": resource.URL,
|
||
"type": "original",
|
||
"platform": panInfo.Remark,
|
||
"resource_id": resource.ID,
|
||
"message": "",
|
||
})
|
||
return
|
||
}
|
||
|
||
// 执行自动转存
|
||
utils.Info("开始执行自动转存")
|
||
transferResult := performAutoTransfer(resource)
|
||
|
||
if transferResult.Success {
|
||
utils.Info("自动转存成功，返回转存链接: %s", transferResult.SaveURL)
|
||
SuccessResponse(c, gin.H{
|
||
"url": transferResult.SaveURL,
|
||
"type": "transferred",
|
||
"platform": panInfo.Remark,
|
||
"resource_id": resource.ID,
|
||
"message": "资源易和谐，请及时用手机夸克扫码转存",
|
||
})
|
||
} else {
|
||
utils.Error("自动转存失败: %s", transferResult.ErrorMsg)
|
||
SuccessResponse(c, gin.H{
|
||
"url": resource.URL,
|
||
"type": "original",
|
||
"platform": panInfo.Remark,
|
||
"resource_id": resource.ID,
|
||
"message": "",
|
||
})
|
||
}
|
||
}
|
||
|
||
// TransferResult 转存结果
|
||
type TransferResult struct {
|
||
Success bool `json:"success"`
|
||
Fid string `json:"fid"`
|
||
SaveURL string `json:"save_url"`
|
||
ErrorMsg string `json:"error_msg"`
|
||
}
|
||
|
||
// performAutoTransfer 执行自动转存
|
||
func performAutoTransfer(resource *entity.Resource) TransferResult {
|
||
utils.Info("开始执行资源转存 - ID: %d, URL: %s", resource.ID, resource.URL)
|
||
|
||
// 平台ID
|
||
panID := resource.PanID
|
||
|
||
// 获取可用的夸克账号
|
||
accounts, err := repoManager.CksRepository.FindByPanID(*panID)
|
||
if err != nil {
|
||
utils.Error("获取网盘账号失败: %v", err)
|
||
return TransferResult{
|
||
Success: false,
|
||
ErrorMsg: fmt.Sprintf("获取网盘账号失败: %v", err),
|
||
}
|
||
}
|
||
|
||
// 测试阶段，移除最小限制
|
||
// 获取最小存储空间配置
|
||
autoTransferMinSpace, err := repoManager.SystemConfigRepository.GetConfigInt(entity.ConfigKeyAutoTransferMinSpace)
|
||
if err != nil {
|
||
utils.Error("获取最小存储空间配置失败: %v", err)
|
||
autoTransferMinSpace = 5 // 默认5GB
|
||
}
|
||
|
||
// 过滤：只保留已激活、夸克平台、剩余空间足够的账号
|
||
minSpaceBytes := int64(autoTransferMinSpace) * 1024 * 1024 * 1024
|
||
var validAccounts []entity.Cks
|
||
for _, acc := range accounts {
|
||
if acc.IsValid && acc.PanID == *panID && acc.LeftSpace >= minSpaceBytes {
|
||
validAccounts = append(validAccounts, acc)
|
||
}
|
||
}
|
||
|
||
if len(validAccounts) == 0 {
|
||
utils.Info("没有可用的网盘账号")
|
||
return TransferResult{
|
||
Success: false,
|
||
ErrorMsg: "没有可用的网盘账号",
|
||
}
|
||
}
|
||
|
||
utils.Info("找到 %d 个可用网盘账号，开始转存处理...", len(validAccounts))
|
||
|
||
// 使用第一个可用账号进行转存
|
||
account := validAccounts[0]
|
||
// account := accounts[0]
|
||
|
||
// 创建网盘服务工厂
|
||
factory := pan.NewPanFactory()
|
||
|
||
// 执行转存
|
||
result := transferSingleResource(resource, account, factory)
|
||
|
||
if result.Success {
|
||
// 更新资源的转存信息
|
||
resource.SaveURL = result.SaveURL
|
||
resource.Fid = result.Fid
|
||
resource.CkID = &account.ID
|
||
resource.ErrorMsg = ""
|
||
if err := repoManager.ResourceRepository.Update(resource); err != nil {
|
||
utils.Error("更新资源转存信息失败: %v", err)
|
||
}
|
||
} else {
|
||
// 更新错误信息
|
||
resource.ErrorMsg = result.ErrorMsg
|
||
if err := repoManager.ResourceRepository.Update(resource); err != nil {
|
||
utils.Error("更新资源错误信息失败: %v", err)
|
||
}
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
// transferSingleResource 转存单个资源
|
||
func transferSingleResource(resource *entity.Resource, account entity.Cks, factory *pan.PanFactory) TransferResult {
|
||
utils.Info("开始转存资源 - 资源ID: %d, 账号: %s", resource.ID, account.Username)
|
||
|
||
service, err := factory.CreatePanService(resource.URL, &pan.PanConfig{
|
||
URL: resource.URL,
|
||
ExpiredType: 0,
|
||
IsType: 0,
|
||
Cookie: account.Ck,
|
||
})
|
||
if err != nil {
|
||
utils.Error("创建网盘服务失败: %v", err)
|
||
return TransferResult{
|
||
Success: false,
|
||
ErrorMsg: fmt.Sprintf("创建网盘服务失败: %v", err),
|
||
}
|
||
}
|
||
|
||
// 设置账号信息
|
||
service.SetCKSRepository(repoManager.CksRepository, account)
|
||
|
||
// 提取分享ID
|
||
shareID, _ := commonutils.ExtractShareIdString(resource.URL)
|
||
if shareID == "" {
|
||
return TransferResult{
|
||
Success: false,
|
||
ErrorMsg: "无效的分享链接",
|
||
}
|
||
}
|
||
|
||
// 执行转存
|
||
transferResult, err := service.Transfer(shareID) // 有些链接还需要其他信息从 url 中自行解析
|
||
if err != nil {
|
||
utils.Error("转存失败: %v", err)
|
||
return TransferResult{
|
||
Success: false,
|
||
ErrorMsg: fmt.Sprintf("转存失败: %v", err),
|
||
}
|
||
}
|
||
|
||
if transferResult == nil || !transferResult.Success {
|
||
errMsg := "转存失败"
|
||
if transferResult != nil && transferResult.Message != "" {
|
||
errMsg = transferResult.Message
|
||
}
|
||
utils.Error("转存失败: %s", errMsg)
|
||
return TransferResult{
|
||
Success: false,
|
||
ErrorMsg: errMsg,
|
||
}
|
||
}
|
||
|
||
// 提取转存链接
|
||
var saveURL string
|
||
var fid string
|
||
|
||
if data, ok := transferResult.Data.(map[string]interface{}); ok {
|
||
if v, ok := data["shareUrl"]; ok {
|
||
saveURL, _ = v.(string)
|
||
}
|
||
if v, ok := data["fid"]; ok {
|
||
fid, _ = v.(string)
|
||
}
|
||
}
|
||
if saveURL == "" {
|
||
saveURL = transferResult.ShareURL
|
||
}
|
||
|
||
if saveURL == "" {
|
||
return TransferResult{
|
||
Success: false,
|
||
ErrorMsg: "转存成功但未获取到分享链接",
|
||
}
|
||
}
|
||
|
||
utils.Info("转存成功 - 资源ID: %d, 转存链接: %s", resource.ID, saveURL)
|
||
|
||
return TransferResult{
|
||
Success: true,
|
||
SaveURL: saveURL,
|
||
Fid: fid,
|
||
}
|
||
}
|
||
|
||
// GetHotResources 获取热门资源
|
||
func GetHotResources(c *gin.Context) {
|
||
limit, _ := strconv.Atoi(c.DefaultQuery("limit", "10"))
|
||
|
||
utils.Info("获取热门资源请求 - limit: %d", limit)
|
||
|
||
// 限制最大请求数量
|
||
if limit > 20 {
|
||
limit = 20
|
||
}
|
||
if limit <= 0 {
|
||
limit = 10
|
||
}
|
||
|
||
// 使用公共缓存机制
|
||
cacheKey := fmt.Sprintf("hot_resources_%d", limit)
|
||
ttl := time.Hour // 1小时缓存
|
||
cacheManager := utils.GetHotResourcesCache()
|
||
|
||
// 尝试从缓存获取
|
||
if cachedData, found := cacheManager.Get(cacheKey, ttl); found {
|
||
utils.Info("使用热门资源缓存 - key: %s", cacheKey)
|
||
c.Header("Cache-Control", "public, max-age=3600")
|
||
c.Header("ETag", fmt.Sprintf("hot-resources-%d", len(cachedData.([]gin.H))))
|
||
|
||
// 转换为正确的类型
|
||
if data, ok := cachedData.([]gin.H); ok {
|
||
SuccessResponse(c, gin.H{
|
||
"data": data,
|
||
"total": len(data),
|
||
"limit": limit,
|
||
"cached": true,
|
||
})
|
||
}
|
||
return
|
||
}
|
||
|
||
// 缓存未命中，从数据库获取
|
||
resources, err := repoManager.ResourceRepository.GetHotResources(limit)
|
||
if err != nil {
|
||
utils.Error("获取热门资源失败: %v", err)
|
||
ErrorResponse(c, "获取热门资源失败", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
// 获取违禁词配置
|
||
cleanWords, err := utils.GetForbiddenWordsFromConfig(func() (string, error) {
|
||
return repoManager.SystemConfigRepository.GetConfigValue(entity.ConfigKeyForbiddenWords)
|
||
})
|
||
if err != nil {
|
||
utils.Error("获取违禁词配置失败: %v", err)
|
||
cleanWords = []string{}
|
||
}
|
||
|
||
// 处理违禁词并转换为响应格式
|
||
var resourceResponses []gin.H
|
||
for _, resource := range resources {
|
||
// 检查违禁词
|
||
forbiddenInfo := utils.CheckResourceForbiddenWords(resource.Title, resource.Description, cleanWords)
|
||
|
||
resourceResponse := gin.H{
|
||
"id": resource.ID,
|
||
"key": resource.Key,
|
||
"title": forbiddenInfo.ProcessedTitle,
|
||
"url": resource.URL,
|
||
"description": forbiddenInfo.ProcessedDesc,
|
||
"pan_id": resource.PanID,
|
||
"view_count": resource.ViewCount,
|
||
"created_at": resource.CreatedAt.Format("2006-01-02 15:04:05"),
|
||
"updated_at": resource.UpdatedAt.Format("2006-01-02 15:04:05"),
|
||
"cover": resource.Cover,
|
||
"author": resource.Author,
|
||
"file_size": resource.FileSize,
|
||
}
|
||
|
||
// 添加违禁词标记
|
||
resourceResponse["has_forbidden_words"] = forbiddenInfo.HasForbiddenWords
|
||
resourceResponse["forbidden_words"] = forbiddenInfo.ForbiddenWords
|
||
|
||
// 添加标签信息
|
||
var tagResponses []gin.H
|
||
if len(resource.Tags) > 0 {
|
||
for _, tag := range resource.Tags {
|
||
tagResponse := gin.H{
|
||
"id": tag.ID,
|
||
"name": tag.Name,
|
||
"description": tag.Description,
|
||
}
|
||
tagResponses = append(tagResponses, tagResponse)
|
||
}
|
||
}
|
||
resourceResponse["tags"] = tagResponses
|
||
|
||
resourceResponses = append(resourceResponses, resourceResponse)
|
||
}
|
||
|
||
// 存储到缓存
|
||
cacheManager.Set(cacheKey, resourceResponses)
|
||
utils.Info("热门资源已缓存 - key: %s, count: %d", cacheKey, len(resourceResponses))
|
||
|
||
// 设置缓存头
|
||
c.Header("Cache-Control", "public, max-age=3600")
|
||
c.Header("ETag", fmt.Sprintf("hot-resources-%d", len(resourceResponses)))
|
||
|
||
SuccessResponse(c, gin.H{
|
||
"data": resourceResponses,
|
||
"total": len(resourceResponses),
|
||
"limit": limit,
|
||
"cached": false,
|
||
})
|
||
}
|
||
|
||
// GetRelatedResources 获取相关资源
|
||
func GetRelatedResources(c *gin.Context) {
|
||
// 获取查询参数
|
||
key := c.Query("key") // 当前资源的key
|
||
limit, _ := strconv.Atoi(c.DefaultQuery("limit", "8"))
|
||
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
||
|
||
utils.Info("获取相关资源请求 - key: %s, limit: %d", key, limit)
|
||
|
||
if key == "" {
|
||
ErrorResponse(c, "缺少资源key参数", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
// 首先通过key获取当前资源信息
|
||
currentResources, err := repoManager.ResourceRepository.FindByKey(key)
|
||
if err != nil {
|
||
utils.Error("获取当前资源失败: %v", err)
|
||
ErrorResponse(c, "资源不存在", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
if len(currentResources) == 0 {
|
||
ErrorResponse(c, "资源不存在", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
currentResource := ¤tResources[0] // 取第一个资源作为当前资源
|
||
|
||
var resources []entity.Resource
|
||
var total int64
|
||
|
||
// 获取当前资源的标签ID列表
|
||
var tagIDsList []string
|
||
if currentResource.Tags != nil {
|
||
for _, tag := range currentResource.Tags {
|
||
tagIDsList = append(tagIDsList, strconv.Itoa(int(tag.ID)))
|
||
}
|
||
}
|
||
|
||
utils.Info("当前资源标签: %v", tagIDsList)
|
||
|
||
// 1. 优先使用Meilisearch进行标签搜索
|
||
if meilisearchManager != nil && meilisearchManager.IsEnabled() && len(tagIDsList) > 0 {
|
||
service := meilisearchManager.GetService()
|
||
if service != nil {
|
||
// 使用标签进行搜索
|
||
filters := make(map[string]interface{})
|
||
filters["tag_ids"] = tagIDsList
|
||
|
||
// 使用当前资源的标题作为搜索关键词，提高相关性
|
||
searchQuery := currentResource.Title
|
||
if searchQuery == "" {
|
||
searchQuery = strings.Join(tagIDsList, " ") // 如果没有标题，使用标签作为搜索词
|
||
}
|
||
|
||
docs, docTotal, err := service.Search(searchQuery, filters, page, limit)
|
||
if err == nil && len(docs) > 0 {
|
||
// 转换为Resource实体
|
||
for _, doc := range docs {
|
||
// 排除当前资源
|
||
if doc.Key == key {
|
||
continue
|
||
}
|
||
resource := entity.Resource{
|
||
ID: doc.ID,
|
||
Title: doc.Title,
|
||
Description: doc.Description,
|
||
URL: doc.URL,
|
||
SaveURL: doc.SaveURL,
|
||
FileSize: doc.FileSize,
|
||
Key: doc.Key,
|
||
PanID: doc.PanID,
|
||
ViewCount: 0, // Meilisearch文档中没有ViewCount字段，设为默认值
|
||
CreatedAt: doc.CreatedAt,
|
||
UpdatedAt: doc.UpdatedAt,
|
||
Cover: doc.Cover,
|
||
Author: doc.Author,
|
||
}
|
||
resources = append(resources, resource)
|
||
}
|
||
total = docTotal
|
||
utils.Info("Meilisearch搜索到 %d 个相关资源", len(resources))
|
||
} else {
|
||
utils.Error("Meilisearch搜索失败，回退到标签搜索: %v", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 2. 如果Meilisearch未启用、搜索失败或没有结果，使用数据库标签搜索
|
||
if len(resources) == 0 {
|
||
params := map[string]interface{}{
|
||
"page": page,
|
||
"page_size": limit,
|
||
"is_public": true,
|
||
"order_by": "updated_at",
|
||
"order_dir": "desc",
|
||
}
|
||
|
||
// 使用当前资源的标签进行搜索
|
||
if len(tagIDsList) > 0 {
|
||
params["tag_ids"] = strings.Join(tagIDsList, ",")
|
||
} else {
|
||
// 如果没有标签，使用当前资源的分类作为搜索条件
|
||
if currentResource.CategoryID != nil && *currentResource.CategoryID > 0 {
|
||
params["category_id"] = *currentResource.CategoryID
|
||
}
|
||
}
|
||
|
||
var err error
|
||
resources, total, err = repoManager.ResourceRepository.SearchWithFilters(params)
|
||
if err != nil {
|
||
utils.Error("搜索相关资源失败: %v", err)
|
||
ErrorResponse(c, "搜索相关资源失败", http.StatusInternalServerError)
|
||
return
|
||
}
|
||
|
||
// 排除当前资源
|
||
var filteredResources []entity.Resource
|
||
for _, resource := range resources {
|
||
if resource.Key != key {
|
||
filteredResources = append(filteredResources, resource)
|
||
}
|
||
}
|
||
resources = filteredResources
|
||
total = int64(len(filteredResources))
|
||
}
|
||
|
||
utils.Info("标签搜索到 %d 个相关资源", len(resources))
|
||
|
||
// 获取违禁词配置
|
||
cleanWords, err := utils.GetForbiddenWordsFromConfig(func() (string, error) {
|
||
return repoManager.SystemConfigRepository.GetConfigValue(entity.ConfigKeyForbiddenWords)
|
||
})
|
||
if err != nil {
|
||
utils.Error("获取违禁词配置失败: %v", err)
|
||
cleanWords = []string{}
|
||
}
|
||
|
||
// 处理违禁词并转换为响应格式
|
||
var resourceResponses []gin.H
|
||
for _, resource := range resources {
|
||
// 检查违禁词
|
||
forbiddenInfo := utils.CheckResourceForbiddenWords(resource.Title, resource.Description, cleanWords)
|
||
|
||
resourceResponse := gin.H{
|
||
"id": resource.ID,
|
||
"key": resource.Key,
|
||
"title": forbiddenInfo.ProcessedTitle,
|
||
"url": resource.URL,
|
||
"description": forbiddenInfo.ProcessedDesc,
|
||
"pan_id": resource.PanID,
|
||
"view_count": resource.ViewCount,
|
||
"created_at": resource.CreatedAt.Format("2006-01-02 15:04:05"),
|
||
"updated_at": resource.UpdatedAt.Format("2006-01-02 15:04:05"),
|
||
"cover": resource.Cover,
|
||
"author": resource.Author,
|
||
"file_size": resource.FileSize,
|
||
}
|
||
|
||
// 添加违禁词标记
|
||
resourceResponse["has_forbidden_words"] = forbiddenInfo.HasForbiddenWords
|
||
resourceResponse["forbidden_words"] = forbiddenInfo.ForbiddenWords
|
||
|
||
// 添加标签信息
|
||
var tagResponses []gin.H
|
||
if len(resource.Tags) > 0 {
|
||
for _, tag := range resource.Tags {
|
||
tagResponse := gin.H{
|
||
"id": tag.ID,
|
||
"name": tag.Name,
|
||
"description": tag.Description,
|
||
}
|
||
tagResponses = append(tagResponses, tagResponse)
|
||
}
|
||
}
|
||
resourceResponse["tags"] = tagResponses
|
||
|
||
resourceResponses = append(resourceResponses, resourceResponse)
|
||
}
|
||
|
||
// 构建响应数据
|
||
responseData := gin.H{
|
||
"data": resourceResponses,
|
||
"total": total,
|
||
"page": page,
|
||
"page_size": limit,
|
||
"source": "database",
|
||
}
|
||
|
||
if meilisearchManager != nil && meilisearchManager.IsEnabled() && len(tagIDsList) > 0 {
|
||
responseData["source"] = "meilisearch"
|
||
}
|
||
|
||
SuccessResponse(c, responseData)
|
||
}
|
||
|
||
// CheckResourceValidity 检查资源链接有效性
|
||
func CheckResourceValidity(c *gin.Context) {
|
||
idStr := c.Param("id")
|
||
id, err := strconv.ParseUint(idStr, 10, 32)
|
||
if err != nil {
|
||
ErrorResponse(c, "无效的资源ID", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
// 查询资源信息
|
||
resource, err := repoManager.ResourceRepository.FindByID(uint(id))
|
||
if err != nil {
|
||
ErrorResponse(c, "资源不存在", http.StatusNotFound)
|
||
return
|
||
}
|
||
|
||
utils.Info("开始检测资源有效性 - ID: %d, URL: %s", resource.ID, resource.URL)
|
||
|
||
// 检查缓存
|
||
cacheKey := fmt.Sprintf("resource_validity_%d", resource.ID)
|
||
cacheManager := utils.GetResourceValidityCache()
|
||
ttl := 5 * time.Minute // 5分钟缓存
|
||
|
||
if cachedData, found := cacheManager.Get(cacheKey, ttl); found {
|
||
if result, ok := cachedData.(gin.H); ok {
|
||
utils.Info("使用资源有效性缓存 - ID: %d", resource.ID)
|
||
result["cached"] = true
|
||
SuccessResponse(c, result)
|
||
return
|
||
}
|
||
}
|
||
|
||
// 执行检测：只使用深度检测实现
|
||
isValid, detectionMethod, err := performAdvancedValidityCheck(resource)
|
||
|
||
if err != nil {
|
||
utils.Error("深度检测资源链接失败 - ID: %d, Error: %v", resource.ID, err)
|
||
|
||
// 深度检测失败，但不标记为无效（用户可自行验证）
|
||
result := gin.H{
|
||
"resource_id": resource.ID,
|
||
"url": resource.URL,
|
||
"is_valid": resource.IsValid, // 保持原始状态
|
||
"last_checked": time.Now().Format(time.RFC3339),
|
||
"error": err.Error(),
|
||
"detection_method": detectionMethod,
|
||
"cached": false,
|
||
"note": "当前网盘暂不支持自动检测，建议用户自行验证",
|
||
}
|
||
cacheManager.Set(cacheKey, result)
|
||
SuccessResponse(c, result)
|
||
return
|
||
}
|
||
|
||
// 只有明确检测出无效的资源才更新数据库状态
|
||
// 如果检测成功且结果与数据库状态不同，则更新
|
||
if detectionMethod == "quark_deep" && isValid != resource.IsValid {
|
||
resource.IsValid = isValid
|
||
updateErr := repoManager.ResourceRepository.Update(resource)
|
||
if updateErr != nil {
|
||
utils.Error("更新资源有效性状态失败 - ID: %d, Error: %v", resource.ID, updateErr)
|
||
} else {
|
||
utils.Info("更新资源有效性状态 - ID: %d, Status: %v, Method: %s", resource.ID, isValid, detectionMethod)
|
||
}
|
||
}
|
||
|
||
// 构建检测结果
|
||
result := gin.H{
|
||
"resource_id": resource.ID,
|
||
"url": resource.URL,
|
||
"is_valid": isValid,
|
||
"last_checked": time.Now().Format(time.RFC3339),
|
||
"detection_method": detectionMethod,
|
||
"cached": false,
|
||
}
|
||
|
||
// 缓存检测结果
|
||
cacheManager.Set(cacheKey, result)
|
||
|
||
utils.Info("资源有效性检测完成 - ID: %d, Valid: %v, Method: %s", resource.ID, isValid, detectionMethod)
|
||
SuccessResponse(c, result)
|
||
}
|
||
|
||
// performAdvancedValidityCheck 执行深度检测（只使用具体网盘服务）
|
||
func performAdvancedValidityCheck(resource *entity.Resource) (bool, string, error) {
|
||
// 提取分享ID和服务类型
|
||
shareID, serviceType := panutils.ExtractShareId(resource.URL)
|
||
if serviceType == panutils.NotFound {
|
||
return false, "unsupported", fmt.Errorf("不支持的网盘服务: %s", resource.URL)
|
||
}
|
||
|
||
utils.Info("开始深度检测 - Service: %s, ShareID: %s", serviceType.String(), shareID)
|
||
|
||
// 根据服务类型选择检测策略
|
||
switch serviceType {
|
||
case panutils.Quark:
|
||
return performQuarkValidityCheck(resource, shareID)
|
||
case panutils.Alipan:
|
||
return performAlipanValidityCheck(resource, shareID)
|
||
case panutils.BaiduPan, panutils.UC, panutils.Xunlei, panutils.Tianyi, panutils.Pan123, panutils.Pan115:
|
||
// 这些网盘暂未实现深度检测，返回不支持提示
|
||
return false, "unsupported", fmt.Errorf("当前网盘类型 %s 暂不支持深度检测，请等待后续更新", serviceType.String())
|
||
default:
|
||
return false, "unsupported", fmt.Errorf("未知的网盘服务类型: %s", serviceType.String())
|
||
}
|
||
}
|
||
|
||
// performQuarkValidityCheck 夸克网盘深度检测
|
||
func performQuarkValidityCheck(resource *entity.Resource, shareID string) (bool, string, error) {
|
||
// 获取夸克网盘账号
|
||
panID, err := getQuarkPanID()
|
||
if err != nil {
|
||
return false, "quark_failed", fmt.Errorf("获取夸克平台ID失败: %v", err)
|
||
}
|
||
|
||
accounts, err := repoManager.CksRepository.FindByPanID(panID)
|
||
if err != nil {
|
||
return false, "quark_failed", fmt.Errorf("获取夸克网盘账号失败: %v", err)
|
||
}
|
||
|
||
if len(accounts) == 0 {
|
||
return false, "quark_failed", fmt.Errorf("没有可用的夸克网盘账号")
|
||
}
|
||
|
||
// 选择第一个有效账号
|
||
var selectedAccount *entity.Cks
|
||
for _, account := range accounts {
|
||
if account.IsValid {
|
||
selectedAccount = &account
|
||
break
|
||
}
|
||
}
|
||
|
||
if selectedAccount == nil {
|
||
return false, "quark_failed", fmt.Errorf("没有有效的夸克网盘账号")
|
||
}
|
||
|
||
// 创建网盘服务配置
|
||
config := &pan.PanConfig{
|
||
URL: resource.URL,
|
||
Code: "",
|
||
IsType: 1, // 只获取基本信息，不转存
|
||
ExpiredType: 1,
|
||
AdFid: "",
|
||
Stoken: "",
|
||
Cookie: selectedAccount.Ck,
|
||
}
|
||
|
||
// 创建夸克网盘服务
|
||
factory := pan.NewPanFactory()
|
||
panService, err := factory.CreatePanService(resource.URL, config)
|
||
if err != nil {
|
||
return false, "quark_failed", fmt.Errorf("创建夸克网盘服务失败: %v", err)
|
||
}
|
||
|
||
// 执行深度检测（Transfer方法）
|
||
utils.Info("执行夸克网盘深度检测 - ShareID: %s", shareID)
|
||
result, err := panService.Transfer(shareID)
|
||
if err != nil {
|
||
return false, "quark_failed", fmt.Errorf("夸克网盘检测失败: %v", err)
|
||
}
|
||
|
||
if !result.Success {
|
||
return false, "quark_failed", fmt.Errorf("夸克网盘链接无效: %s", result.Message)
|
||
}
|
||
|
||
utils.Info("夸克网盘深度检测成功 - ShareID: %s", shareID)
|
||
return true, "quark_deep", nil
|
||
}
|
||
|
||
// performAlipanValidityCheck 阿里云盘深度检测
|
||
func performAlipanValidityCheck(resource *entity.Resource, shareID string) (bool, string, error) {
|
||
// 阿里云盘深度检测暂未实现
|
||
utils.Info("阿里云盘暂不支持深度检测 - ShareID: %s", shareID)
|
||
return false, "unsupported", fmt.Errorf("阿里云盘暂不支持深度检测，请等待后续更新")
|
||
}
|
||
|
||
|
||
// BatchCheckResourceValidity 批量检查资源链接有效性
|
||
func BatchCheckResourceValidity(c *gin.Context) {
|
||
var req struct {
|
||
IDs []uint `json:"ids" binding:"required"`
|
||
}
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
ErrorResponse(c, "参数错误: "+err.Error(), http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
if len(req.IDs) == 0 {
|
||
ErrorResponse(c, "ID列表不能为空", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
if len(req.IDs) > 20 {
|
||
ErrorResponse(c, "单次最多检测20个资源", http.StatusBadRequest)
|
||
return
|
||
}
|
||
|
||
utils.Info("开始批量检测资源有效性 - Count: %d", len(req.IDs))
|
||
|
||
cacheManager := utils.GetResourceValidityCache()
|
||
ttl := 5 * time.Minute
|
||
results := make([]gin.H, 0, len(req.IDs))
|
||
|
||
for _, id := range req.IDs {
|
||
// 查询资源信息
|
||
resource, err := repoManager.ResourceRepository.FindByID(id)
|
||
if err != nil {
|
||
results = append(results, gin.H{
|
||
"resource_id": id,
|
||
"is_valid": false,
|
||
"error": "资源不存在",
|
||
"cached": false,
|
||
})
|
||
continue
|
||
}
|
||
|
||
// 检查缓存
|
||
cacheKey := fmt.Sprintf("resource_validity_%d", id)
|
||
if cachedData, found := cacheManager.Get(cacheKey, ttl); found {
|
||
if result, ok := cachedData.(gin.H); ok {
|
||
result["cached"] = true
|
||
results = append(results, result)
|
||
continue
|
||
}
|
||
}
|
||
|
||
// 执行深度检测
|
||
isValid, detectionMethod, err := performAdvancedValidityCheck(resource)
|
||
|
||
if err != nil {
|
||
// 深度检测失败，但不标记为无效（用户可自行验证）
|
||
result := gin.H{
|
||
"resource_id": id,
|
||
"url": resource.URL,
|
||
"is_valid": resource.IsValid, // 保持原始状态
|
||
"last_checked": time.Now().Format(time.RFC3339),
|
||
"error": err.Error(),
|
||
"detection_method": detectionMethod,
|
||
"cached": false,
|
||
"note": "当前网盘暂不支持自动检测，建议用户自行验证",
|
||
}
|
||
cacheManager.Set(cacheKey, result)
|
||
results = append(results, result)
|
||
continue
|
||
}
|
||
|
||
// 只有明确检测出无效的资源才更新数据库状态
|
||
if detectionMethod == "quark_deep" && isValid != resource.IsValid {
|
||
resource.IsValid = isValid
|
||
updateErr := repoManager.ResourceRepository.Update(resource)
|
||
if updateErr != nil {
|
||
utils.Error("更新资源有效性状态失败 - ID: %d, Error: %v", id, updateErr)
|
||
}
|
||
}
|
||
|
||
result := gin.H{
|
||
"resource_id": id,
|
||
"url": resource.URL,
|
||
"is_valid": isValid,
|
||
"last_checked": time.Now().Format(time.RFC3339),
|
||
"detection_method": detectionMethod,
|
||
"cached": false,
|
||
}
|
||
|
||
cacheManager.Set(cacheKey, result)
|
||
results = append(results, result)
|
||
}
|
||
|
||
utils.Info("批量检测资源有效性完成 - Count: %d", len(results))
|
||
SuccessResponse(c, gin.H{
|
||
"results": results,
|
||
"total": len(results),
|
||
})
|
||
}
|
||
|
||
// getQuarkPanID 获取夸克网盘ID
|
||
func getQuarkPanID() (uint, error) {
|
||
// 通过FindAll方法查找所有平台，然后过滤出quark平台
|
||
pans, err := repoManager.PanRepository.FindAll()
|
||
if err != nil {
|
||
return 0, fmt.Errorf("查询平台信息失败: %v", err)
|
||
}
|
||
|
||
for _, p := range pans {
|
||
if p.Name == "quark" {
|
||
return p.ID, nil
|
||
}
|
||
}
|
||
|
||
return 0, fmt.Errorf("未找到quark平台")
|
||
}
|