blog-server/internal/service/sys_menu.go

package service

import (
	"context"
	db "server/internal/db/sqlc"
	"server/internal/model/common"
	"server/internal/model/enum"
	"server/internal/model/request"
	"server/internal/pkg/dberr"
	"server/internal/pkg/errs"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgxpool"
)

type SysMenuService struct {
	pool    *pgxpool.Pool
	queries *db.Queries
}

func NewSysMenuService(queries *db.Queries, pool *pgxpool.Pool) *SysMenuService {
	return &SysMenuService{
		queries: queries,
		pool:    pool,
	}
}

func (s *SysMenuService) Create(ctx context.Context, req request.CreateSysMenuRequest) error {
	// 开启事务
	tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{})
	if err != nil {
		return err
	}

	defer func(ctx context.Context) {
		_ = tx.Rollback(ctx)
	}(ctx)

	q := db.New(tx)

	menu := db.CreateSysMenuParams{
		Name:      req.Name,
		Path:      req.Path,
		Component: req.Component,
		Type:      *req.Type,
		Status:    *req.Status,
		Hidden:    req.Hidden,
		Sort:      req.Sort,
		Icon:      req.Icon,
	}

	permissionId, err := q.CreateSysPermission(ctx, db.CreateSysPermissionParams{
		Type: int16(enum.PermissionTypeMenu),
		Code: &req.PermissionCode,
	})

	if err != nil {
		return dberr.MapUniqueViolation(err, dberr.SysPermissionsCodeKey, errs.ErrPermissionCodeAlreadyExists)
	}

	menuId, err := q.CreateSysMenu(ctx, menu)
	if err != nil {
		return err
	}

	if err = q.CreateSysMenuPermission(ctx, db.CreateSysMenuPermissionParams{
		MenuID:       menuId,
		PermissionID: permissionId,
	}); err != nil {
		return err
	}

	if err = tx.Commit(ctx); err != nil {
		return err
	}

	return nil
}

func (s *SysMenuService) Update(ctx context.Context, id int32, req request.UpdateSysMenuRequest) error {
	tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{})
	if err != nil {
		return err
	}
	defer tx.Rollback(ctx)

	q := db.New(tx)

	// 构造 menu 参数
	menu := db.UpdateSysMenuParams{
		ID:        id,
		Name:      req.Name,
		Path:      req.Path,
		Component: req.Component,
		Hidden:    req.Hidden,
		Sort:      req.Sort,
		Type:      req.Type,
		Status:    req.Status,
		Icon:      req.Icon,
	}

	if req.ParentID.Set {
		menu.UpdateParentID = true
		if req.ParentID.Valid {
			menu.ParentID = &req.ParentID.Value
		}
	}

	// 执行更新
	rows, err := q.UpdateSysMenu(ctx, menu)

	if err = dberr.MapRowsAffected(rows, err, errs.ErrSysMenuNotFound); err != nil {
		return err
	}

	permission := db.UpdateSysMenuPermissionCodeParams{
		MenuID: id,
		Code:   req.PermissionCode,
	}

	if err = q.UpdateSysMenuPermissionCode(ctx, permission); err != nil {
		return dberr.MapUniqueViolation(err, dberr.SysPermissionsCodeKey, errs.ErrPermissionCodeAlreadyExists)
	}

	return tx.Commit(ctx)
}

func (s *SysMenuService) ListPage(ctx context.Context, p *common.Pagination) ([]db.ListSysMenusRow, int64, error) {
	params := db.ListSysMenusParams{
		Limit:  p.PageSize,
		Offset: (p.Page - 1) * p.PageSize,
	}

	total, err := s.queries.CountSysMenus(ctx)

	if err != nil {
		return nil, 0, err
	}

	list, err := s.queries.ListSysMenus(ctx, params)
	if err != nil {
		return nil, 0, err
	}

	return list, total, nil
}

func (s *SysMenuService) GetMenus(ctx context.Context) ([]db.GetAllSysMenusRow, error) {
	return s.queries.GetAllSysMenus(ctx)
}

func (s *SysMenuService) Delete(ctx context.Context, id int32) error {
	tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{})

	if err != nil {
		return err
	}

	defer tx.Rollback(ctx)

	q := db.New(tx)

	rows, err := q.DeleteSysMenu(ctx, id)

	if err = dberr.MapRowsAffected(rows, err, errs.ErrSysMenuNotFound); err != nil {
		return err
	}

	if err = q.DeleteSysPermissionByMenuID(ctx, id); err != nil {
		return err
	}

	if err = q.DeleteSysMenuPermission(ctx, id); err != nil {
		return err
	}

	return tx.Commit(ctx)
}