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

package system

import (
	"context"
	"errors"
	"fmt"
	"strconv"
	"time"

	"management/internal/erpserver/model/dto"
	"management/internal/erpserver/model/form"
	"management/internal/erpserver/model/system"
	"management/internal/erpserver/model/view"
	"management/internal/erpserver/service/util"
	"management/internal/erpserver/service/v1"
	"management/internal/pkg/convertor"
	"management/internal/pkg/database"
	"management/internal/pkg/know"
)

type departmentService struct {
	*v1.Service
	repo system.DepartmentRepository
}

func NewDepartmentService(service *v1.Service, repo system.DepartmentRepository) v1.DepartmentService {
	return &departmentService{
		Service: service,
		repo:    repo,
	}
}

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

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

	arg := &system.Department{
		Name:       req.Name,
		ParentID:   parent.ID,
		ParentPath: convertor.HandleParentPath(fmt.Sprintf("%s,%d,", parent.ParentPath, parent.ID)),
		Status:     *req.Status,
		Sort:       order,
		CreatedAt:  time.Now(),
		UpdatedAt:  time.Now(),
	}
	err := s.repo.Create(ctx, arg)
	if err != nil {
		if database.IsUniqueViolation(err) {
			return errors.New("部门已存在")
		}
		return err
	}
	return nil
}

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

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

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

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

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

func (s *departmentService) All(ctx context.Context) ([]*system.Department, error) {
	var res []*system.Department
	key := know.GetManageKey(ctx, know.AllDepartments)
	err := util.GetOrSetCache(ctx, s.Redis, key, util.GetCacheExpire(), func() (any, error) {
		return s.repo.All(ctx)
	}, &res)
	return res, err
}

func (s *departmentService) List(ctx context.Context, q dto.SearchDto) ([]*system.Department, int64, error) {
	count, err := s.repo.Count(ctx, q)
	if err != nil {
		return nil, 0, err
	}

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

	return res, count, nil
}

func (s *departmentService) RefreshCache(ctx context.Context) error {
	key := know.GetManageKey(ctx, know.AllDepartments)
	return s.Redis.Del(ctx, key)
}

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

func (s *departmentService) 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 *departmentService) 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 *departmentService) toTree(parentId int32, data []*system.Department) []*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.Name
			item.Children = s.toTree(v.ID, data)
			if v.ParentID == 0 {
				item.Spread = true
			}
			res = append(res, &item)
		}
	}

	return res
}

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

	return res
}