projectx/internal/erpserver/service/v1/system/role.go

package system

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"strconv"
	"time"

	"management/internal/db/model/dto"
	db "management/internal/db/sqlc"
	"management/internal/erpserver/model/form"
	"management/internal/erpserver/model/system"
	"management/internal/erpserver/model/view"
	v1 "management/internal/erpserver/service/v1"
	"management/internal/pkg/convertor"
	"management/internal/pkg/know"
	"management/internal/pkg/redis"
)

type roleService struct {
	repo system.RoleRepository
}

var _ v1.RoleService = (*roleService)(nil)

func NewRoleService(repo system.RoleRepository) *roleService {
	return &roleService{
		repo: repo,
	}
}

func (s *roleService) Create(ctx context.Context, req *form.Role) error {
	parent := &system.Role{
		ID:         0,
		ParentID:   0,
		ParentPath: ",0,",
	}
	if *req.ParentID > 0 {
		var err error
		parent, err = s.repo.Get(ctx, *req.ParentID)
		if err != nil {
			return errors.New("父级节点错误")
		}
	}

	var order int32 = 6666
	if *req.Sort > 0 {
		order = *req.Sort
	}

	arg := &system.Role{
		Name:        req.Name,
		DisplayName: req.DisplayName,
		ParentID:    parent.ID,
		ParentPath:  convertor.HandleParentPath(fmt.Sprintf("%s,%d,", parent.ParentPath, parent.ID)),
		Vip:         false,
		Status:      *req.Status,
		Sort:        order,
		CreatedAt:   time.Now(),
		UpdatedAt:   time.Now(),
	}
	err := s.repo.Create(ctx, arg)
	if err != nil {
		if db.IsUniqueViolation(err) {
			return errors.New("角色名称已存在")
		}
		return err
	}
	return nil
}

func (s *roleService) Update(ctx context.Context, req *form.Role) error {
	parent := &system.Role{
		ID:         0,
		ParentID:   0,
		ParentPath: ",0,",
	}
	if *req.ParentID > 0 {
		var err error
		parent, err = s.repo.Get(ctx, *req.ParentID)
		if err != nil {
			return errors.New("父级节点错误")
		}
	}

	role, err := s.repo.Get(ctx, *req.ID)
	if err != nil {
		return err
	}

	var order int32 = 6666
	if *req.Sort > 0 {
		order = *req.Sort
	}

	role.DisplayName = req.DisplayName
	role.Status = *req.Status
	role.ParentID = parent.ID
	role.ParentPath = convertor.HandleParentPath(fmt.Sprintf("%s,%d,", parent.ParentPath, parent.ID))
	role.Sort = order
	role.UpdatedAt = time.Now()
	err = s.repo.Update(ctx, role)
	return err
}

func (s *roleService) Get(ctx context.Context, id int32) (*system.Role, error) {
	return s.repo.Get(ctx, id)
}

func (s *roleService) All(ctx context.Context) ([]*system.Role, error) {
	key := know.GetManageKey(ctx, know.AllRoles)
	bs, err := redis.GetBytes(ctx, key)
	if err == nil {
		var res []*system.Role
		if err := json.Unmarshal(bs, &res); err == nil {
			return res, nil
		}
	}

	res, err := s.repo.All(ctx)
	if err != nil {
		return nil, err
	}

	bs, err = json.Marshal(res)
	if err != nil {
		return nil, err
	}

	_ = redis.Set(ctx, key, bs, time.Hour*6)
	return res, nil
}

func (s *roleService) List(ctx context.Context, q dto.SearchDto) ([]*system.Role, int64, error) {
	return s.repo.List(ctx, q)
}

func (s *roleService) RefreshCache(ctx context.Context) error {
	key := know.GetManageKey(ctx, know.AllRoles)
	res, err := s.All(ctx)
	if err != nil {
		return err
	}

	b, err := json.Marshal(res)
	if err != nil {
		return err
	}

	_ = redis.Set(ctx, key, b, time.Hour*6)
	return nil
}

func (s *roleService) RebuildParentPath(ctx context.Context) error {
	return s.repo.RebuildParentPath(ctx)
}

func (s *roleService) Tree(ctx context.Context, id int32) ([]*view.LayuiTree, error) {
	all, err := s.All(ctx)
	if err != nil {
		return nil, err
	}

	return s.toTree(id, all), nil
}

func (s *roleService) XmSelectTree(ctx context.Context, id int32) ([]*view.XmSelectTree, error) {
	all, err := s.All(ctx)
	if err != nil {
		return nil, err
	}

	return s.toXmSelectTree(id, all), nil
}

func (s *roleService) toTree(parentId int32, data []*system.Role) []*view.LayuiTree {
	var res []*view.LayuiTree
	for _, v := range data {
		if v.ParentID == parentId {
			item := view.LayuiTree{}
			item.ID = strconv.FormatInt(int64(v.ID), 10)
			item.Title = v.DisplayName
			item.Children = s.toTree(v.ID, data)
			if v.ParentID == 0 {
				item.Spread = true
			}
			res = append(res, &item)
		}
	}

	return res
}

func (s *roleService) toXmSelectTree(parentId int32, data []*system.Role) []*view.XmSelectTree {
	var res []*view.XmSelectTree
	for _, v := range data {
		if v.ParentID == parentId {
			item := view.XmSelectTree{
				Name:     v.DisplayName,
				Value:    strconv.FormatInt(int64(v.ID), 10),
				Children: s.toXmSelectTree(v.ID, data),
			}
			res = append(res, &item)
		}
	}

	return res
}