opms_backend/opms_admin/app/service/sys_dept.go

package service

import (
	"context"
	"dashoo.cn/micro/app/dao"
	"dashoo.cn/micro/app/model"
	"dashoo.cn/opms_libary/micro_srv"
	"github.com/gogf/gf/os/glog"
	"github.com/gogf/gf/util/gconv"
)

type deptService struct {
	Dao *dao.SysDeptDao
}

func NewDeptService(ctx context.Context) (*deptService, error) {
	dict := new(deptService)
	// 获取租户码
	tenant, err := micro_srv.GetTenant(ctx)
	if err != nil {
		return nil, err
	}
	reqMethod, _ := micro_srv.GetReqMethod(ctx)
	glog.Info("Received " + reqMethod + " request @ " + tenant)
	dict.Dao = dao.NewSysDeptDao(tenant)
	return dict, err
}

func (s *deptService) GetList(searchParams *model.SysDeptSearchParams) ([]*model.SysDept, error) {
	deptModel := dao.SysDept.M
	if searchParams.DeptName != "" {
		deptModel = deptModel.Where("dept_name like ?", "%"+searchParams.DeptName+"%")
	}
	if searchParams.Status != "" {
		deptModel = deptModel.Where("status", searchParams.Status)
	}
	depts := ([]*model.SysDept)(nil)
	if err := deptModel.Scan(&depts); err != nil {
		return nil, err
	}
	list := make([]*model.SysDept, 0, len(depts))
	if searchParams.ExcludeId != 0 {
		for _, v := range depts {
			if searchParams.ExcludeId != v.Id {
				list = append(list, v)
			}
		}
		return list, nil
	} else {
		return depts, nil
	}
}

func (s *deptService) GetRoleDepts(roleId int) ([]int, error) {
	var entitys []*model.SysRoleDept
	err := dao.SysRoleDept.Where("role_id", roleId).Scan(&entitys)
	if err != nil {
		return nil, err
	}
	result := make([]int, 0)
	for _, v := range entitys {
		result = append(result, v.DeptId)
	}
	return result, nil
}

func (s *deptService) FindSonByParentId(depts []*model.SysDept, deptId int) []*model.SysDept {
	children := make([]*model.SysDept, 0, len(depts))
	for _, v := range depts {
		if v.ParentId == deptId {
			children = append(children, v)
			fChildren := s.FindSonByParentId(depts, v.Id)
			children = append(children, fChildren...)
		}
	}
	return children
}

func (s *deptService) GetDeptListTree(pid int, list []*model.SysDept) []*model.SysDeptTreeRes {
	tree := make([]*model.SysDeptTreeRes, 0, len(list))
	for _, v := range list {
		if v.ParentId == pid {
			t := &model.SysDeptTreeRes{
				SysDept: v,
			}
			child := s.GetDeptListTree(v.Id, list)
			if len(child) > 0 {
				t.Children = child
			}
			tree = append(tree, t)
		}
	}
	return tree
}

func (s *deptService) GetDeptById(id int64) (dept *model.SysDept, err error) {
	err = dao.SysDept.Where("id", id).Scan(&dept)
	return
}

func (s *deptService) Create(req *model.SysDeptReq) (err error) {
	data := new(model.SysDept)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	SetCreatedInfo(data, 1, "")
	_, err = dao.SysDept.Insert(data)
	return
}

func (s *deptService) UpdateById(req *model.UpdateSysDeptReq) error {
	data := new(model.SysDept)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	SetUpdatedInfo(data, 1, "")
	_, err := dao.SysDept.FieldsEx(dao.SysDept.Columns.Id, dao.SysDept.Columns.CreatedBy, dao.SysDept.Columns.CreatedName, dao.SysDept.Columns.CreatedTime).WherePri(data.Id).
		Update(data)
	return err
}

func (s *deptService) DeleteById(id int) error {
	var list []*model.SysDept
	err := dao.SysDept.Scan(&list)
	if err != nil {
		return err
	}
	children := s.FindSonByParentId(list, id)
	ids := make([]int, 0, len(list))
	for _, v := range children {
		ids = append(ids, v.Id)
	}
	ids = append(ids, id)
	_, err = dao.SysDept.Where(dao.SysDept.Columns.Id+" in (?)", ids).Delete()
	return err
}