backend/internal/service/post_ai_service.go

package service

import (
	"context"
	"strings"

	"carrot_bbs/internal/pkg/openai"

	"go.uber.org/zap"
)

type PostModerationRejectedError struct {
	Reason string
}

func (e *PostModerationRejectedError) Error() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "post rejected by moderation"
	}
	return "post rejected by moderation: " + e.Reason
}

func (e *PostModerationRejectedError) UserMessage() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "内容未通过审核，请修改后重试"
	}
	return strings.TrimSpace(e.Reason)
}

type PostModerationReviewError struct {
	Reason string
}

func (e *PostModerationReviewError) Error() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "post needs manual review"
	}
	return "post needs manual review: " + e.Reason
}

func (e *PostModerationReviewError) UserMessage() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "内容需要人工复审，请耐心等待"
	}
	return strings.TrimSpace(e.Reason)
}

func (e *PostModerationReviewError) IsReview() bool {
	return true
}

type CommentModerationRejectedError struct {
	Reason string
}

func (e *CommentModerationRejectedError) Error() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "comment rejected by moderation"
	}
	return "comment rejected by moderation: " + e.Reason
}

func (e *CommentModerationRejectedError) UserMessage() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "评论未通过审核，请修改后重试"
	}
	return strings.TrimSpace(e.Reason)
}

type CommentModerationReviewError struct {
	Reason string
}

func (e *CommentModerationReviewError) Error() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "comment needs manual review"
	}
	return "comment needs manual review: " + e.Reason
}

func (e *CommentModerationReviewError) UserMessage() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "评论需要人工复审，请耐心等待"
	}
	return strings.TrimSpace(e.Reason)
}

func (e *CommentModerationReviewError) IsReview() bool {
	return true
}

type ImageModerationRejectedError struct {
	Reason string
}

func (e *ImageModerationRejectedError) Error() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "image rejected by moderation"
	}
	return "image rejected by moderation: " + e.Reason
}

func (e *ImageModerationRejectedError) UserMessage() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "图片未通过审核，请更换后重试"
	}
	return strings.TrimSpace(e.Reason)
}

type ImageModerationReviewError struct {
	Reason string
}

func (e *ImageModerationReviewError) Error() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "image needs manual review"
	}
	return "image needs manual review: " + e.Reason
}

func (e *ImageModerationReviewError) UserMessage() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "图片需要人工复审，请耐心等待"
	}
	return strings.TrimSpace(e.Reason)
}

func (e *ImageModerationReviewError) IsReview() bool {
	return true
}

type BioModerationRejectedError struct {
	Reason string
}

func (e *BioModerationRejectedError) Error() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "bio rejected by moderation"
	}
	return "bio rejected by moderation: " + e.Reason
}

func (e *BioModerationRejectedError) UserMessage() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "个性签名未通过审核，请修改后重试"
	}
	return strings.TrimSpace(e.Reason)
}

type BioModerationReviewError struct {
	Reason string
}

func (e *BioModerationReviewError) Error() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "bio needs manual review"
	}
	return "bio needs manual review: " + e.Reason
}

func (e *BioModerationReviewError) UserMessage() string {
	if strings.TrimSpace(e.Reason) == "" {
		return "个性签名需要人工复审，请耐心等待"
	}
	return strings.TrimSpace(e.Reason)
}

func (e *BioModerationReviewError) IsReview() bool {
	return true
}

type PostAIService struct {
	openAIClient openai.Client
}

func NewPostAIService(openAIClient openai.Client) *PostAIService {
	return &PostAIService{
		openAIClient: openAIClient,
	}
}

func (s *PostAIService) IsEnabled() bool {
	return s != nil && s.openAIClient != nil && s.openAIClient.IsEnabled()
}

func (s *PostAIService) ModeratePost(ctx context.Context, title, content string, images []string) error {
	if !s.IsEnabled() {
		return nil
	}

	resp, err := s.openAIClient.ModeratePost(ctx, title, content, images)
	if err != nil {
		if s.openAIClient.Config().StrictModeration {
			return err
		}
		zap.L().Warn("AI moderation failed, fallback allow",
			zap.Error(err),
		)
		return nil
	}

	switch resp.Result {
	case openai.ModerationResultBlock:
		return &PostModerationRejectedError{Reason: resp.Reason}
	case openai.ModerationResultReview:
		return &PostModerationReviewError{Reason: resp.Reason}
	default:
		return nil
	}
}

func (s *PostAIService) ModerateComment(ctx context.Context, content string, images []string) error {
	if !s.IsEnabled() {
		return nil
	}

	resp, err := s.openAIClient.ModerateComment(ctx, content, images)
	if err != nil {
		if s.openAIClient.Config().StrictModeration {
			return err
		}
		zap.L().Warn("AI comment moderation failed, fallback allow",
			zap.Error(err),
		)
		return nil
	}

	switch resp.Result {
	case openai.ModerationResultBlock:
		return &CommentModerationRejectedError{Reason: resp.Reason}
	case openai.ModerationResultReview:
		return &CommentModerationReviewError{Reason: resp.Reason}
	default:
		return nil
	}
}

func (s *PostAIService) ModerateImage(ctx context.Context, imageURL string) error {
	if !s.IsEnabled() {
		return nil
	}

	resp, err := s.openAIClient.ModerateImage(ctx, imageURL)
	if err != nil {
		if s.openAIClient.Config().StrictModeration {
			return err
		}
		zap.L().Warn("AI image moderation failed, fallback allow",
			zap.Error(err),
		)
		return nil
	}

	switch resp.Result {
	case openai.ModerationResultBlock:
		return &ImageModerationRejectedError{Reason: resp.Reason}
	case openai.ModerationResultReview:
		return &ImageModerationReviewError{Reason: resp.Reason}
	default:
		return nil
	}
}

func (s *PostAIService) ModerateBio(ctx context.Context, bio string) error {
	if !s.IsEnabled() {
		return nil
	}

	resp, err := s.openAIClient.ModerateBio(ctx, bio)
	if err != nil {
		if s.openAIClient.Config().StrictModeration {
			return err
		}
		zap.L().Warn("AI bio moderation failed, fallback allow",
			zap.Error(err),
		)
		return nil
	}

	switch resp.Result {
	case openai.ModerationResultBlock:
		return &BioModerationRejectedError{Reason: resp.Reason}
	case openai.ModerationResultReview:
		return &BioModerationReviewError{Reason: resp.Reason}
	default:
		return nil
	}
}