cls-server/internal/application/price/service.go

package price

import (
	article2 "cls-server/internal/application/article"
	"cls-server/internal/domain/article"
	"cls-server/internal/domain/price"
	"cls-server/pkg/logger"
	"cls-server/pkg/util/page"
	"errors"
	"xorm.io/builder"
)

var (
	ErrInvalidAmount   = errors.New("价格不能小于0")
	ErrInvalidType     = errors.New("无效的价格类型")
	ErrInvalidDuration = errors.New("无效的订阅时长")
)

// PriceService 价格管理服务
type PriceService struct {
	repo        price.PriceRepository
	articleRepo article.ArticleRepository
	log         logger.Logger
}

// NewService 创建价格管理服务
func NewPriceService(repo price.PriceRepository, articleRepo article.ArticleRepository, log logger.New) *PriceService {
	return &PriceService{
		repo:        repo,
		articleRepo: articleRepo,
		log:         log("cls:service:price"),
	}
}

// SetPrice 设置价格
func (s *PriceService) SetPrice(dto *PriceDto) error {
	if dto.Amount < 0 {
		return ErrInvalidAmount
	}

	// 检查是否已存在价格记录
	existingPrice, err := s.repo.FindByTargetID(dto.TargetID, dto.Type)
	if err != nil {
		// 如果记录不存在，创建新记录
		newPrice := dto.ToPrice()
		return s.repo.Save(newPrice)
	}

	// 如果记录存在，更新价格
	existingPrice.Amount = dto.Amount
	existingPrice.OneMonthPrice = dto.OneMonthPrice
	existingPrice.ThreeMonthsPrice = dto.ThreeMonthsPrice
	existingPrice.SixMonthsPrice = dto.SixMonthsPrice
	existingPrice.OneYearPrice = dto.OneYearPrice
	existingPrice.AdminID = dto.AdminID
	return s.repo.Update(existingPrice)
}

// GetPrice 获取价格（如果不存在则使用默认价格）
func (s *PriceService) GetPrice(dto *PriceDto) (*PriceDto, error) {
	// 检查是否已存在价格记录
	existingPrice, err := s.repo.FindByTargetID(dto.TargetID, dto.Type)
	if err != nil {
		// 如果记录不存在，使用默认价格
		var defaultAmount int64
		switch dto.Type {
		case price.TypeArticle:
			defaultAmount = price.DefaultArticlePrice
		case price.TypeColumn:
			defaultAmount = price.DefaultColumnPrice
		default:
			return nil, ErrInvalidType
		}
		// 创建默认价格记录
		newPrice := price.NewPrice(dto.TargetID, dto.Type, defaultAmount, 0)
		if err := s.repo.Save(newPrice); err != nil {
			return nil, err
		}
		if dto.Type == price.TypeArticle {
			return &PriceDto{
				Amount:   newPrice.Amount,
				Discount: newPrice.Discount,
			}, nil
		}
		return &PriceDto{
			OneMonthPrice:    newPrice.OneMonthPrice,
			ThreeMonthsPrice: newPrice.ThreeMonthsPrice,
			SixMonthsPrice:   newPrice.SixMonthsPrice,
			OneYearPrice:     newPrice.OneYearPrice,
			Discount:         0.3,
		}, nil
	}
	priceDto := &PriceDto{
		Discount: existingPrice.Discount,
	}
	if dto.Type == price.TypeArticle {
		priceDto.Amount = existingPrice.Amount
	} else {
		priceDto.OneMonthPrice = existingPrice.OneMonthPrice
		priceDto.ThreeMonthsPrice = existingPrice.ThreeMonthsPrice
		priceDto.SixMonthsPrice = existingPrice.SixMonthsPrice
		priceDto.OneYearPrice = existingPrice.OneYearPrice
	}

	return priceDto, nil
}

func (s *PriceService) GetArticlePricePage(p *page.Page) error {
	conds := make([]builder.Cond, 0)
	conds = append(conds, builder.Eq{"type": price.TypeArticle})
	data := make([]*price.Price, 0)
	p.Content = &data
	err := s.repo.FindAll(p, conds)
	if err != nil {
		s.log.Error(err)
		return err
	}

	ids := make([]uint64, 0, len(data))
	for _, v := range data {
		ids = append(ids, v.TargetID)
	}
	as, err := s.articleRepo.GetArticlesByIds(ids)
	if err != nil {
		s.log.Error(err)
		return err
	}
	asMap := make(map[uint64]*article2.ArticleDto, 0)
	for _, v := range *as {
		asMap[v.Id] = &article2.ArticleDto{
			EventId: v.Id,
			Title:   v.Title,
			Class:   article2.GetClassNameById(v.Type),
			Stocks:  v.Stocks,
			Brief:   v.Brief,
		}
	}
	ids = nil
	dtoData := make([]*ArticlePriceDto, 0, len(data))
	for _, v := range data {
		dtoData = append(dtoData, &ArticlePriceDto{
			Article: asMap[v.TargetID],
			Price: &PriceDto{
				ID:       v.ID,
				TargetID: v.TargetID,
				Amount:   v.Amount,
				Discount: v.Discount,
			},
		})
	}
	p.Content = &dtoData
	return nil
}

func (s *PriceService) GetColumnPricePage(p *page.Page) error {
	conds := make([]builder.Cond, 0)
	conds = append(conds, builder.Eq{"p.type": price.TypeColumn})
	data := make([]*ColumnPriceDto, 0)
	p.Content = &data
	err := s.repo.FindColumnAll(p, conds)
	if err != nil {
		s.log.Error(err.Error())
	}
	return err
}

// DeletePrice 删除价格记录
func (s *PriceService) DeletePrice(id uint64) error {
	return s.repo.Delete(id)
}

func (s *PriceService) UpdatePrice(dto *PriceDto) error {
	if err := dto.Validate(); err != nil {
		return err
	}
	existingPrice, err := s.repo.FindByTargetID(dto.TargetID, dto.Type)
	if err != nil {
		return err
	}
	existingPrice.Amount = dto.Amount
	existingPrice.OneMonthPrice = dto.OneMonthPrice
	existingPrice.ThreeMonthsPrice = dto.ThreeMonthsPrice
	existingPrice.SixMonthsPrice = dto.SixMonthsPrice
	existingPrice.OneYearPrice = dto.OneYearPrice
	existingPrice.AdminID = dto.AdminID
	return s.repo.Update(existingPrice)
}