geoGo/internal/service/publish.go

package service

import (
	"errors"
	"fmt"
	"geo/internal/data/model"
	"geo/utils"
	"os"
	"path/filepath"

	"time"

	"github.com/gofiber/fiber/v2"

	"geo/internal/biz"
	"geo/internal/config"
	"geo/internal/entitys"
	"geo/internal/manager"
	"geo/pkg"
	"geo/tmpl/errcode"
)

type PublishService struct {
	cfg        *config.Config
	publishBiz *biz.PublishBiz
	db         *utils.Db
}

func NewPublishService(
	cfg *config.Config,
	publishBiz *biz.PublishBiz,
	db *utils.Db,
) *PublishService {
	return &PublishService{
		cfg:        cfg,
		publishBiz: publishBiz,
		db:         db,
	}
}

func (s *PublishService) PublishRecords(c *fiber.Ctx, req *entitys.PublishRecordsRequest) error {
	// 验证token
	tokenInfo, err := s.publishBiz.ValidateAccessToken(c.UserContext(), req.AccessToken)
	if err != nil {
		return err
	}

	// 转换记录
	validRecords := make([]*model.Publish, 0)
	for _, record := range req.Records {
		publishTime, err := time.Parse("2006-01-02 15:04:05", record.PublishTime)
		if err != nil {
			return errcode.ParamErr(fmt.Sprintf("时间格式错误: %v", err))
		}

		validRecords = append(validRecords, &model.Publish{
			UserIndex:   record.UserIndex,
			RequestID:   record.RequestID,
			Title:       record.Title,
			Tag:         record.Tag,
			Type:        record.Type,
			PlatIndex:   record.PlatIndex,
			URL:         record.URL,
			PublishTime: publishTime,
			Img:         record.Img,
			TokenID:     tokenInfo.ID,
		})

	}

	err = s.publishBiz.BatchInsertPublish(c.UserContext(), validRecords)
	if err != nil {
		return err
	}

	return pkg.HandleResponse(c, fiber.Map{
		"total": len(validRecords),
	})
}

func (s *PublishService) PublishOn(c *fiber.Ctx, req *entitys.PublishOnRequest) error {
	tokenInfo, err := s.publishBiz.ValidateAccessToken(c.UserContext(), req.AccessToken)
	if err != nil {
		return err
	}

	pm := manager.GetPublishManager(s.cfg, s.db)
	if pm.Start(int(tokenInfo.ID)) {
		return pkg.HandleResponse(c, fiber.Map{
			"auto_status": pm.AutoStatus,
		})
	}
	return errors.New("自动发布服务已在运行中")
}

func (s *PublishService) PublishOff(c *fiber.Ctx, req *entitys.PublishOffRequest) error {
	_, err := s.publishBiz.ValidateAccessToken(c.UserContext(), req.AccessToken)
	if err != nil {
		return err
	}

	pm := manager.GetPublishManager(s.cfg, s.db)
	if pm.Stop() {
		return pkg.HandleResponse(c, fiber.Map{})
	}
	return errors.New("自动发布服务未运行")
}

func (s *PublishService) PublishStatus(c *fiber.Ctx, req *entitys.PublishStatusRequest) error {
	_, err := s.publishBiz.ValidateAccessToken(c.UserContext(), req.AccessToken)
	if err != nil {
		return err
	}

	pm := manager.GetPublishManager(s.cfg, s.db)

	if req.RequestID != "" {
		// 查询单个任务
		task, err := s.publishBiz.GetTaskByRequestID(c.UserContext(), req.RequestID)
		if err != nil {
			return errcode.NotFound("任务不存在")
		}
		return pkg.HandleResponse(c, task)
	}

	// 查询整体状态
	return pkg.HandleResponse(c, pm.GetStatus())
}

func (s *PublishService) PublishExecuteOnce(c *fiber.Ctx, req *entitys.PublishExecuteOnceRequest) error {
	tokenInfo, err := s.publishBiz.ValidateAccessToken(c.UserContext(), req.AccessToken)
	if err != nil {
		return err
	}

	pm := manager.GetPublishManager(s.cfg, s.db)
	result := pm.ExecuteOnce(tokenInfo.ID)
	return pkg.HandleResponse(c, result)
}

func (s *PublishService) PublishExecuteRetry(c *fiber.Ctx, req *entitys.PublishExecuteRetryRequest) error {
	_, err := s.publishBiz.ValidateAccessToken(c.UserContext(), req.AccessToken)
	if err != nil {
		return err
	}

	pm := manager.GetPublishManager(s.cfg, s.db)
	result := pm.RetryTask(req.RequestID)
	return pkg.HandleResponse(c, result)
}

func (s *PublishService) GetPublishList(c *fiber.Ctx, req *entitys.GetPublishListRequest) error {
	tokenInfo, err := s.publishBiz.ValidateAccessToken(c.UserContext(), req.AccessToken)
	if err != nil {
		return err
	}

	page := req.Page
	if page < 1 {
		page = 1
	}
	pageSize := req.PageSize
	if pageSize < 1 {
		pageSize = 20
	}
	if pageSize > 100 {
		pageSize = 100
	}

	filters := map[string]interface{}{
		"user_index": req.UserIndex,
		"tag":        req.Tag,
		"type":       req.Type,
		"plat_index": req.PlatIndex,
		"status":     req.Status,
		"request_id": req.RequestID,
	}

	list, total, err := s.publishBiz.GetPublishList(c.UserContext(), tokenInfo.ID, page, pageSize, filters)
	if err != nil {
		return err
	}

	return pkg.HandleResponse(c, fiber.Map{
		"list": list,
		"pagination": fiber.Map{
			"page":        page,
			"page_size":   pageSize,
			"total":       total,
			"total_pages": (total + int64(pageSize) - 1) / int64(pageSize),
		},
	})
}

func (s *PublishService) GetLogs(c *fiber.Ctx, requestID string) error {
	logFile := filepath.Join(s.cfg.Sys.LogsDir, requestID+".log")
	content, err := os.ReadFile(logFile)
	if err != nil {
		return errcode.NotFound("日志文件不存在")
	}
	return pkg.HandleResponse(c, fiber.Map{
		"request_id":  requestID,
		"log_content": string(content),
	})
}