opms_backend/opms_admin/app/service/sys_post.go

package service

import (
	"context"
	"dashoo.cn/micro/app/dao"
	"dashoo.cn/micro/app/model"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gconv"
)

type PostService struct {
	*contextService
	Dao         *dao.SysPostDao
	postRoleDao *dao.SysPostRoleDao
}

func NewPostService(ctx context.Context) (svc *PostService, err error) {
	svc = new(PostService)
	if svc.contextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = dao.NewSysPostDao(svc.Tenant)
	svc.postRoleDao = dao.NewSysPostRoleDao(svc.Tenant)
	svc.Table = svc.Dao.Table
	return svc, nil
}

func (s *PostService) GetList(req *model.SysPostSearchParams) (total int, list []*model.SysPost, err error) {
	db := s.Dao.M
	if req != nil {
		if req.PostCode != "" {
			db = db.WhereLike(s.Dao.Columns.PostCode, req.PostCode)
		}
		if req.PostName != "" {
			db = db.WhereLike(s.Dao.Columns.PostName, req.PostName)
		}
		if req.Status != "" {
			db = db.Where(s.Dao.Columns.Status, req.Status)
		}
	}

	total, err = db.Count()

	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取总行数失败")
	}

	err = db.Page(req.GetPage()).Order(s.Dao.Columns.Sort + " asc," + s.Dao.Columns.Id + " asc").Scan(&list)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取数据失败")
	}
	return
}

func (s *PostService) GetEntity(id int64) (post *model.SysPostRes, err error) {
	post = new(model.SysPostRes)
	err = s.Dao.WherePri(id).Scan(&post.SysPost)
	if err != nil {
		return nil, err
	}
	result, err := s.postRoleDao.Fields(dao.SysPostRole.Columns.RoleId).WherePri(dao.SysPostRole.Columns.PostId, id).Array()
	if err != nil {
		return nil, err
	}
	post.RoleIds = gconv.Ints(result)
	return
}

func (s *PostService) Create(params *model.SysPostReq) error {
	data := new(model.SysPost)
	if err := gconv.Struct(params, data); err != nil {
		return err
	}
	SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	err := s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		lastId, err := s.Dao.TX(tx).InsertAndGetId(data)
		if err != nil {
			return err
		}
		err = s.AddPostRole(lastId, params.RoleIds, tx)
		return err
	})
	return err
}

// AddPostRole 添加岗位角色
func (s *PostService) AddPostRole(postId int64, roleIds []int, tx *gdb.TX) (err error) {
	//删除旧岗位角色信息
	_, err = s.postRoleDao.TX(tx).Where(dao.SysPostRole.Columns.PostId, postId).Delete()
	if err != nil {
		return
	}
	if len(roleIds) == 0 {
		return
	}
	//添加岗位角色
	data := g.List{}
	for _, v := range roleIds {
		data = append(data, g.Map{
			dao.SysPostRole.Columns.PostId: postId,
			dao.SysPostRole.Columns.RoleId: v,
		})
	}
	_, err = s.postRoleDao.TX(tx).Data(data).Insert()
	if err != nil {
		return
	}
	return
}

func (s *PostService) UpdateById(params *model.UpdateSysPostReq) (err error) {
	data := new(model.SysPost)
	if err := gconv.Struct(params, data); err != nil {
		return err
	}
	SetUpdatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	err = s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		_, err := s.Dao.FieldsEx(UpdateFieldEx...).WherePri(params.Id).Update(data)
		if err != nil {
			return err
		}
		err = s.AddPostRole(params.Id, params.RoleIds, tx)
		return err
	})
	return err
}

func (s *PostService) DeleteByIds(ids []int64) error {
	_, err := s.Dao.WhereIn(s.Dao.Columns.Id, ids).Delete()
	return err
}