bl/modules/dict/service/dict_info.go

package service

import (
	"context"

	"blazing/common/utils"
	"blazing/cool"

	"blazing/modules/dict/model"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gcache"
	"github.com/gogf/gf/v2/util/gconv"
)

type DictInfoService struct {
	*cool.Service
}

// func init() {

// 	t, _ := NewDictInfoService().Data(context.TODO(), []string{"mapid"})
// 	fmt.Println(t)

// }

// Data方法, 用于获取数据
func (s *DictInfoService) Data(ctx context.Context, types []string) (data interface{}, err error) {
	var (
		dictInfoModel = model.NewDictInfo()
		dictTypeModel = model.NewDictType()
	)
	mType := cool.DBM(dictTypeModel)
	// 如果types不为空, 则查询指定类型的数据
	if len(types) > 0 {
		mType = mType.Where("key in (?)", types)
	}
	// 查询所有类型
	typeData, err := mType.All()
	// 如果typeData为空, 则返回空
	if typeData.IsEmpty() {
		return g.Map{}, nil
	}
	data = g.Map{}
	for _, v := range typeData {
		m := cool.DBM(dictInfoModel)
		result, err := m.Where("typeId", v["id"]).FieldsEx("id", "remark").Order("ordernum asc").All()
		if err != nil {
			return nil, err
		}
		if result.IsEmpty() {
			continue
		}
		data.(g.Map)[v["key"].String()] = result
	}
	return
}

func (s *DictInfoService) GetData(types string) (data map[uint32]model.DictInfo) {
	var (
		dictInfoModel = model.NewDictInfo()
		dictTypeModel = model.NewDictType()
	)
	ret, _ := cacheDict.GetOrSetFunc(context.Background(), types, func(context.Context) (interface{}, error) {
		// 如果typeData为空, 则返回空
		var ty *model.DictType
		mType := cool.DBM(dictTypeModel)
		mType.Where("key in (?)", types).Scan(&ty)

		// 如果typeData为空, 则返回空
		if ty == nil {
			return []model.DictInfo{}, nil
		}
		m := cool.DBM(dictInfoModel)
		var ress []model.DictInfo
		m.Where("typeId", ty.ID).Scan(&ress)
		fusions := utils.ToMap(ress, func(t model.DictInfo) uint32 {

			return gconv.Uint32(t.Value) //物品id转id
		})
		return fusions, nil
	}, 0)

	return ret.Interface().(map[uint32]model.DictInfo)

}

var (
	cacheDict = gcache.New()
)

// ModifyAfter 修改后
func (s *DictInfoService) ModifyAfter(ctx context.Context, method string, param map[string]interface{}) (err error) {
	cacheDict.Clear(context.Background())
	if method == "Delete" {
		// 删除后,同时删除子节点
		ids, ok := param["ids"]
		if !ok {
			return
		}
		for _, v := range ids.([]interface{}) {
			err = delChildDict(gconv.Int64(v))
			if err != nil {
				return
			}
		}
	}
	return
}

// delChildDict 删除子字典
func delChildDict(id int64) error {
	var (
		dictInfoModel = model.NewDictInfo()
	)
	m := cool.DBM(dictInfoModel)
	result, err := m.Where("parentId=?", id).Fields("id").All()
	if err != nil {
		return err
	}
	if result.IsEmpty() {
		return nil
	}
	for _, v := range result {
		delChildDict(v["id"].Int64())
	}
	_, err = m.Where("parentId=?", id).Delete()
	return err
}

var DictInfoServiceS = NewDictInfoService()

// NewDictInfoService 初始化 DictInfoService
func NewDictInfoService() *DictInfoService {
	return &DictInfoService{
		&cool.Service{
			UniqueKey: map[string]string{"name": "名称不能重复"},
			Model:     model.NewDictInfo(),
			ListQueryOp: &cool.QueryOp{
				FieldEQ:      []string{"typeId"},
				KeyWordField: []string{"name"},
				AddOrderby:   g.MapStrStr{"createTime": "ASC"},
			},
		},
	}
}