336 lines
9.9 KiB
Go
336 lines
9.9 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strconv"
|
|
"time"
|
|
|
|
apperrors "carrotskin/internal/errors"
|
|
"carrotskin/internal/model"
|
|
"carrotskin/internal/repository"
|
|
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
// reportService ReportService的实现
|
|
type reportService struct {
|
|
reportRepo repository.ReportRepository
|
|
userRepo repository.UserRepository
|
|
logger *zap.Logger
|
|
}
|
|
|
|
// NewReportService 创建ReportService实例
|
|
func NewReportService(
|
|
reportRepo repository.ReportRepository,
|
|
userRepo repository.UserRepository,
|
|
logger *zap.Logger,
|
|
) ReportService {
|
|
return &reportService{
|
|
reportRepo: reportRepo,
|
|
userRepo: userRepo,
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
// CreateReport 创建举报
|
|
func (s *reportService) CreateReport(ctx context.Context, reporterID int64, targetType model.ReportType, targetID int64, reason string) (*model.Report, error) {
|
|
// 验证举报人存在
|
|
reporter, err := s.userRepo.FindByID(ctx, reporterID)
|
|
if err != nil {
|
|
s.logger.Error("举报人不存在", zap.Int64("reporter_id", reporterID), zap.Error(err))
|
|
return nil, apperrors.ErrUserNotFound
|
|
}
|
|
if reporter == nil {
|
|
return nil, apperrors.ErrUserNotFound
|
|
}
|
|
|
|
// 验证举报原因
|
|
if reason == "" {
|
|
return nil, errors.New("举报原因不能为空")
|
|
}
|
|
if len(reason) > 500 {
|
|
return nil, errors.New("举报原因不能超过500字符")
|
|
}
|
|
|
|
// 验证目标类型
|
|
if targetType != model.ReportTypeTexture && targetType != model.ReportTypeUser {
|
|
return nil, errors.New("无效的举报类型")
|
|
}
|
|
|
|
// 检查是否重复举报
|
|
isDuplicate, err := s.reportRepo.CheckDuplicate(ctx, reporterID, targetType, targetID)
|
|
if err != nil {
|
|
s.logger.Error("检查重复举报失败", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
if isDuplicate {
|
|
return nil, errors.New("您已经举报过该对象，请勿重复举报")
|
|
}
|
|
|
|
// 创建举报记录
|
|
report := &model.Report{
|
|
ReporterID: reporterID,
|
|
TargetType: targetType,
|
|
TargetID: targetID,
|
|
Reason: reason,
|
|
Status: model.ReportStatusPending,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
|
|
if err := s.reportRepo.Create(ctx, report); err != nil {
|
|
s.logger.Error("创建举报失败", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
s.logger.Info("创建举报成功", zap.Int64("report_id", report.ID), zap.Int64("reporter_id", reporterID))
|
|
return report, nil
|
|
}
|
|
|
|
// GetByID 根据ID查询举报
|
|
func (s *reportService) GetByID(ctx context.Context, id int64) (*model.Report, error) {
|
|
report, err := s.reportRepo.FindByID(ctx, id)
|
|
if err != nil {
|
|
s.logger.Error("查询举报失败", zap.Int64("report_id", id), zap.Error(err))
|
|
return nil, err
|
|
}
|
|
return report, nil
|
|
}
|
|
|
|
// GetByReporterID 根据举报人ID查询举报记录
|
|
func (s *reportService) GetByReporterID(ctx context.Context, reporterID, userID int64, page, pageSize int) ([]*model.Report, int64, error) {
|
|
// 验证用户存在
|
|
user, err := s.userRepo.FindByID(ctx, userID)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
if user == nil {
|
|
return nil, 0, apperrors.ErrUserNotFound
|
|
}
|
|
|
|
// 只有本人或管理员可以查看自己的举报记录
|
|
if reporterID != userID && !(user.Role == "admin") {
|
|
return nil, 0, errors.New("无权查看其他用户的举报记录")
|
|
}
|
|
|
|
reports, total, err := s.reportRepo.FindByReporterID(ctx, reporterID, page, pageSize)
|
|
if err != nil {
|
|
s.logger.Error("查询举报记录失败", zap.Error(err))
|
|
return nil, 0, err
|
|
}
|
|
|
|
return reports, total, nil
|
|
}
|
|
|
|
// GetByTarget 根据目标对象查询举报记录
|
|
func (s *reportService) GetByTarget(ctx context.Context, targetType model.ReportType, targetID, userID int64, page, pageSize int) ([]*model.Report, int64, error) {
|
|
// 验证用户存在
|
|
user, err := s.userRepo.FindByID(ctx, userID)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
if user == nil {
|
|
return nil, 0, apperrors.ErrUserNotFound
|
|
}
|
|
|
|
// 只有管理员可以查看目标对象的举报记录
|
|
if !(user.Role == "admin") {
|
|
return nil, 0, errors.New("无权查看举报记录")
|
|
}
|
|
|
|
reports, total, err := s.reportRepo.FindByTarget(ctx, targetType, targetID, page, pageSize)
|
|
if err != nil {
|
|
s.logger.Error("查询举报记录失败", zap.Error(err))
|
|
return nil, 0, err
|
|
}
|
|
|
|
return reports, total, nil
|
|
}
|
|
|
|
// GetByStatus 根据状态查询举报记录
|
|
func (s *reportService) GetByStatus(ctx context.Context, status model.ReportStatus, page, pageSize int) ([]*model.Report, int64, error) {
|
|
reports, total, err := s.reportRepo.FindByStatus(ctx, status, page, pageSize)
|
|
if err != nil {
|
|
s.logger.Error("查询举报记录失败", zap.Error(err))
|
|
return nil, 0, err
|
|
}
|
|
|
|
return reports, total, nil
|
|
}
|
|
|
|
// Search 搜索举报记录
|
|
func (s *reportService) Search(ctx context.Context, keyword, userID int64, page, pageSize int) ([]*model.Report, int64, error) {
|
|
// 验证用户存在
|
|
user, err := s.userRepo.FindByID(ctx, userID)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
if user == nil {
|
|
return nil, 0, apperrors.ErrUserNotFound
|
|
}
|
|
|
|
// 只有管理员可以搜索举报记录
|
|
if !(user.Role == "admin") {
|
|
return nil, 0, errors.New("无权搜索举报记录")
|
|
}
|
|
|
|
reports, total, err := s.reportRepo.Search(ctx, strconv.FormatInt(keyword, 10), page, pageSize)
|
|
if err != nil {
|
|
s.logger.Error("搜索举报记录失败", zap.Error(err))
|
|
return nil, 0, err
|
|
}
|
|
|
|
return reports, total, nil
|
|
}
|
|
|
|
// Review 处理举报记录
|
|
func (s *reportService) Review(ctx context.Context, reportID, reviewerID int64, status model.ReportStatus, reviewNote string) (*model.Report, error) {
|
|
// 验证处理人存在且是管理员
|
|
reviewer, err := s.userRepo.FindByID(ctx, reviewerID)
|
|
if err != nil {
|
|
s.logger.Error("处理人不存在", zap.Int64("reviewer_id", reviewerID), zap.Error(err))
|
|
return nil, apperrors.ErrUserNotFound
|
|
}
|
|
if reviewer == nil || !(reviewer.Role == "admin") {
|
|
return nil, errors.New("只有管理员可以处理举报")
|
|
}
|
|
|
|
// 验证状态
|
|
if status != model.ReportStatusApproved && status != model.ReportStatusRejected {
|
|
return nil, errors.New("无效的举报处理状态")
|
|
}
|
|
|
|
// 处理举报
|
|
if err := s.reportRepo.Review(ctx, reportID, status, reviewerID, reviewNote); err != nil {
|
|
s.logger.Error("处理举报失败", zap.Int64("report_id", reportID), zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
// 返回更新后的举报记录
|
|
report, err := s.reportRepo.FindByID(ctx, reportID)
|
|
if err != nil {
|
|
s.logger.Error("查询举报记录失败", zap.Int64("report_id", reportID), zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
s.logger.Info("处理举报成功", zap.Int64("report_id", reportID), zap.Int64("reviewer_id", reviewerID), zap.String("status", string(status)))
|
|
return report, nil
|
|
}
|
|
|
|
// BatchReview 批量处理举报记录
|
|
func (s *reportService) BatchReview(ctx context.Context, ids []int64, reviewerID int64, status model.ReportStatus, reviewNote string) (int64, error) {
|
|
// 验证处理人存在且是管理员
|
|
reviewer, err := s.userRepo.FindByID(ctx, reviewerID)
|
|
if err != nil {
|
|
s.logger.Error("处理人不存在", zap.Int64("reviewer_id", reviewerID), zap.Error(err))
|
|
return 0, apperrors.ErrUserNotFound
|
|
}
|
|
if reviewer == nil || !(reviewer.Role == "admin") {
|
|
return 0, errors.New("只有管理员可以处理举报")
|
|
}
|
|
|
|
// 验证状态
|
|
if status != model.ReportStatusApproved && status != model.ReportStatusRejected {
|
|
return 0, errors.New("无效的举报处理状态")
|
|
}
|
|
|
|
// 批量处理举报
|
|
affected, err := s.reportRepo.BatchReview(ctx, ids, status, reviewerID, reviewNote)
|
|
if err != nil {
|
|
s.logger.Error("批量处理举报失败", zap.Error(err))
|
|
return 0, err
|
|
}
|
|
|
|
s.logger.Info("批量处理举报成功", zap.Int("count", int(affected)), zap.Int64("reviewer_id", reviewerID), zap.String("status", string(status)))
|
|
return affected, nil
|
|
}
|
|
|
|
// Delete 删除举报记录
|
|
func (s *reportService) Delete(ctx context.Context, reportID, userID int64) error {
|
|
// 验证用户存在
|
|
user, err := s.userRepo.FindByID(ctx, userID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if user == nil {
|
|
return apperrors.ErrUserNotFound
|
|
}
|
|
|
|
// 查询举报记录
|
|
report, err := s.reportRepo.FindByID(ctx, reportID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if report == nil {
|
|
return errors.New("举报记录不存在")
|
|
}
|
|
|
|
// 只有举报人、管理员或处理人可以删除举报记录
|
|
if report.ReporterID != userID && !(user.Role == "admin") && (report.ReviewerID == nil || *report.ReviewerID != userID) {
|
|
return errors.New("无权删除此举报记录")
|
|
}
|
|
|
|
if err := s.reportRepo.Delete(ctx, reportID); err != nil {
|
|
s.logger.Error("删除举报记录失败", zap.Int64("report_id", reportID), zap.Error(err))
|
|
return err
|
|
}
|
|
|
|
s.logger.Info("删除举报记录成功", zap.Int64("report_id", reportID))
|
|
return nil
|
|
}
|
|
|
|
// BatchDelete 批量删除举报记录
|
|
func (s *reportService) BatchDelete(ctx context.Context, ids []int64, userID int64) (int64, error) {
|
|
// 验证用户存在
|
|
user, err := s.userRepo.FindByID(ctx, userID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if user == nil {
|
|
return 0, apperrors.ErrUserNotFound
|
|
}
|
|
|
|
// 只有管理员可以批量删除
|
|
if !(user.Role == "admin") {
|
|
return 0, errors.New("无权批量删除举报记录")
|
|
}
|
|
|
|
affected, err := s.reportRepo.BatchDelete(ctx, ids)
|
|
if err != nil {
|
|
s.logger.Error("批量删除举报记录失败", zap.Error(err))
|
|
return 0, err
|
|
}
|
|
|
|
s.logger.Info("批量删除举报记录成功", zap.Int("count", int(affected)))
|
|
return affected, nil
|
|
}
|
|
|
|
// GetStats 获取举报统计信息
|
|
func (s *reportService) GetStats(ctx context.Context) (map[string]int64, error) {
|
|
stats := make(map[string]int64)
|
|
|
|
// 统计各状态的举报数量
|
|
pendingCount, err := s.reportRepo.CountByStatus(ctx, model.ReportStatusPending)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stats["pending"] = pendingCount
|
|
|
|
approvedCount, err := s.reportRepo.CountByStatus(ctx, model.ReportStatusApproved)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stats["approved"] = approvedCount
|
|
|
|
rejectedCount, err := s.reportRepo.CountByStatus(ctx, model.ReportStatusRejected)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stats["rejected"] = rejectedCount
|
|
|
|
stats["total"] = pendingCount + approvedCount + rejectedCount
|
|
|
|
return stats, nil
|
|
}
|