assets/service/asset/private_category_service.go

package service

import (
	dao "assets/dao/asset"
	dto "assets/model/dto/asset"
	"context"

	"github.com/gogf/gf/v2/errors/gerror"
	"go.mongodb.org/mongo-driver/v2/bson"
)

type privateCategory struct{}

// PrivateCategory 私域分类服务
var PrivateCategory = new(privateCategory)

// CreatePrivateCategory 创建私域分类
func (s *privateCategory) CreatePrivateCategory(ctx context.Context, req *dto.CreatePrivateCategoryReq) (*dto.CreatePrivateCategoryRes, error) {
	// 自动设置level
	if !req.ParentID.IsZero() {
		parentCategory, err := dao.PrivateCategory.GetOne(ctx, req.ParentID)
		if err == nil && parentCategory != nil {
			req.Level = parentCategory.Level + 1
			req.Path = parentCategory.Path + "/" + parentCategory.Id.Hex()
		}
	} else {
		req.Level = 0
		req.Path = "/root"
	}

	// 保存到数据库
	ids, err := dao.PrivateCategory.Insert(ctx, req)
	if err != nil {
		return nil, gerror.Wrap(err, "创建私域分类失败")
	}

	var id *bson.ObjectID
	if len(ids) > 0 {
		if objectID, ok := ids[0].(bson.ObjectID); ok {
			id = &objectID
		}
	}

	return &dto.CreatePrivateCategoryRes{ID: id}, nil
}

// BatchCreatePrivateCategory 批量创建私域分类
func (s *privateCategory) BatchCreatePrivateCategory(ctx context.Context, req *dto.BatchCreatePrivateCategoryReq) (*dto.BatchCreatePrivateCategoryRes, error) {
	// 保存到数据库
	ids, err := dao.PrivateCategory.BatchInsert(ctx, req)
	if err != nil {
		return nil, gerror.Wrap(err, "批量创建私域分类失败")
	}

	// 转换ID列表
	idList := make([]*bson.ObjectID, 0, len(ids))
	for _, id := range ids {
		if objectID, ok := id.(bson.ObjectID); ok {
			idList = append(idList, &objectID)
		}
	}

	return &dto.BatchCreatePrivateCategoryRes{IDs: idList}, nil
}

// UpdatePrivateCategory 更新私域分类
func (s *privateCategory) UpdatePrivateCategory(ctx context.Context, req *dto.UpdatePrivateCategoryReq) error {
	// 更新到数据库
	err := dao.PrivateCategory.Update(ctx, req)
	if err != nil {
		return gerror.Wrap(err, "更新私域分类失败")
	}

	return nil
}

// DeletePrivateCategory 删除私域分类
func (s *privateCategory) DeletePrivateCategory(ctx context.Context, id *bson.ObjectID) error {
	return dao.PrivateCategory.DeleteFake(ctx, id)
}

// GetPrivateCategory 获取私域分类详情
func (s *privateCategory) GetPrivateCategory(ctx context.Context, id *bson.ObjectID) (*dto.GetPrivateCategoryRes, error) {
	category, err := dao.PrivateCategory.GetOne(ctx, id)
	if err != nil {
		return nil, gerror.Wrap(err, "获取私域分类失败")
	}

	// 转换为响应
	res := &dto.GetPrivateCategoryRes{
		ID:         category.Id,
		Name:       category.Name,
		ParentID:   category.ParentID,
		Path:       category.Path,
		Level:      category.Level,
		IsLeafNode: category.IsLeafNode,
		Sort:       category.Sort,
		Image:      category.Image,
		CreatedAt:  category.CreatedAt.Format("2006-01-02 15:04:05"),
		UpdatedAt:  category.UpdatedAt.Format("2006-01-02 15:04:05"),
	}

	return res, nil
}

// ListPrivateCategory 获取私域分类列表
func (s *privateCategory) ListPrivateCategory(ctx context.Context, req *dto.ListPrivateCategoryReq) (*dto.ListPrivateCategoryRes, error) {
	// 获取数据
	categories, total, err := dao.PrivateCategory.List(ctx, req)
	if err != nil {
		return nil, gerror.Wrap(err, "获取私域分类列表失败")
	}

	// 转换为响应
	listItems := make([]*dto.PrivateCategoryListItem, 0, len(categories))
	for _, category := range categories {
		listItems = append(listItems, &dto.PrivateCategoryListItem{
			ID:         category.Id,
			Name:       category.Name,
			ParentID:   category.ParentID,
			Path:       category.Path,
			Level:      category.Level,
			IsLeafNode: category.IsLeafNode,
			Sort:       category.Sort,
			Image:      category.Image,
			CreatedAt:  category.CreatedAt.Format("2006-01-02 15:04:05"),
			UpdatedAt:  category.UpdatedAt.Format("2006-01-02 15:04:05"),
		})
	}

	return &dto.ListPrivateCategoryRes{
		List:  listItems,
		Total: total,
	}, nil
}

// GetPrivateCategoryTree 获取私域分类树
func (s *privateCategory) GetPrivateCategoryTree(ctx context.Context) (*dto.GetPrivateCategoryTreeRes, error) {
	categories, err := dao.PrivateCategory.GetTree(ctx)
	if err != nil {
		return nil, gerror.Wrap(err, "获取私域分类树失败")
	}

	// 转换为响应
	treeItems := make([]*dto.PrivateCategoryTreeItem, 0, len(categories))
	for _, category := range categories {
		treeItems = append(treeItems, &dto.PrivateCategoryTreeItem{
			ID:         category.Id,
			Name:       category.Name,
			ParentID:   category.ParentID,
			Path:       category.Path,
			Level:      category.Level,
			IsLeafNode: category.IsLeafNode,
			Sort:       category.Sort,
			Image:      category.Image,
		})
	}

	return &dto.GetPrivateCategoryTreeRes{
		Tree: treeItems,
	}, nil
}

// GenerateTestData 生成测试数据
func (s *privateCategory) GenerateTestData(ctx context.Context) error {
	testData := &dto.BatchCreatePrivateCategoryReq{
		Categories: []dto.CreatePrivateCategoryReq{},
	}

	_, err := s.BatchCreatePrivateCategory(ctx, testData)
	if err != nil {
		return gerror.Wrap(err, "生成测试数据失败")
	}

	return nil
}