dsbqj_admin/app/service/channel.go

package service

import (
	"context"
	"dsbqj-admin/model/mongo/channel"
	"dsbqj-admin/pkg/serializer"

	"github.com/kamva/mgm/v3"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/options"
)

type GameChannelService struct {
}

func (s *GameChannelService) All() (interface{}, error) {
	filter := bson.M{}
	coll := mgm.Coll(&channel.Channel{})

	var list []channel.Channel
	err := coll.SimpleFindWithCtx(context.Background(), &list, filter)
	if err != nil {
		return nil, err
	}

	return serializer.BuildChannelAll(list), nil
}

// ChannelListService 渠道列表
type ChannelListService struct {
	Name      string `form:"name" json:"name"`
	PageIndex int    `form:"pageIndex" json:"pageIndex"`
	PageSize  int    `form:"pageSize" json:"pageSize"`
}

func (s *ChannelListService) List() (interface{}, error) {
	if s.PageIndex < 1 {
		s.PageIndex = 1
	}
	if s.PageSize < 1 {
		s.PageSize = 10
	}

	filter := bson.M{}
	if s.Name != "" {
		filter["$or"] = []bson.M{
			{"name": bson.M{"$regex": s.Name, "$options": "i"}},
			{"code": bson.M{"$regex": s.Name, "$options": "i"}},
		}
	}

	coll := mgm.Coll(&channel.Channel{})

	// 查询总数
	total, err := coll.CountDocuments(context.Background(), filter)
	if err != nil {
		return nil, err
	}

	// 分页查询
	skip := int64((s.PageIndex - 1) * s.PageSize)
	opts := options.Find().SetSkip(skip).SetLimit(int64(s.PageSize)).SetSort(bson.M{"created_at": -1})

	var list []channel.Channel
	err = coll.SimpleFindWithCtx(context.Background(), &list, filter, opts)
	if err != nil {
		return nil, err
	}

	return serializer.BuildChannelList(list, int(total)), nil
}

// ChannelCreateService 渠道新增
type ChannelCreateService struct {
	Name        string `json:"name" binding:"required"`
	Code        string `json:"code" binding:"required"`
	Description string `json:"description"`
	Status      *bool  `json:"status"`
}

func (s *ChannelCreateService) Create() error {
	c := &channel.Channel{
		Name:        s.Name,
		Code:        s.Code,
		Description: s.Description,
		Status:      true,
	}
	if s.Status != nil {
		c.Status = *s.Status
	}
	return mgm.Coll(c).Create(c)
}

// ChannelUpdateService 渠道修改
type ChannelUpdateService struct {
	ID          string  `json:"id" binding:"required"`
	Name        *string `json:"name"`
	Code        *string `json:"code"`
	Description *string `json:"description"`
	Status      *bool   `json:"status"`
}

func (s *ChannelUpdateService) Update() error {
	objectID, err := primitive.ObjectIDFromHex(s.ID)
	if err != nil {
		return err
	}

	updateDoc := bson.M{}
	if s.Name != nil {
		updateDoc["name"] = *s.Name
	}
	if s.Code != nil {
		updateDoc["code"] = *s.Code
	}
	if s.Description != nil {
		updateDoc["description"] = *s.Description
	}
	if s.Status != nil {
		updateDoc["status"] = *s.Status
	}
	if len(updateDoc) == 0 {
		return nil
	}

	_, err = mgm.Coll(&channel.Channel{}).UpdateOne(
		context.Background(),
		bson.M{"_id": objectID},
		bson.M{"$set": updateDoc},
	)
	return err
}

// ChannelDeleteService 渠道删除
type ChannelDeleteService struct {
	IDs []string `json:"ids" binding:"required"`
}

func (s *ChannelDeleteService) Delete() error {
	objectIDs := make([]primitive.ObjectID, 0, len(s.IDs))
	for _, id := range s.IDs {
		oid, err := primitive.ObjectIDFromHex(id)
		if err != nil {
			continue
		}
		objectIDs = append(objectIDs, oid)
	}
	if len(objectIDs) == 0 {
		return nil
	}
	_, err := mgm.Coll(&channel.Channel{}).DeleteMany(
		context.Background(),
		bson.M{"_id": bson.M{"$in": objectIDs}},
	)
	return err
}