yx-dataset-server/app/bll/impl/internal/b_menu.go

package internal

import (
	"context"
	"github.com/gogf/gf/util/guid"
	"yx-dataset-server/app/errors"
	"yx-dataset-server/app/model"
	"yx-dataset-server/app/schema"
)

// NewMenu 创建Menu
func NewMenu(
	mMenu model.IMenu,
	mTrans model.ITrans,
	mRoleMenu model.IRoleMenu,
	mUser model.IUser,
) *Menu {
	return &Menu{
		MenuModel:     mMenu,
		transModel:    mTrans,
		roleMenuModel: mRoleMenu,
		userModel:     mUser,
	}
}

// Menu 创建Menu对象
type Menu struct {
	MenuModel     model.IMenu
	transModel    model.ITrans
	roleMenuModel model.IRoleMenu
	userModel     model.IUser
}

// Query 查询数据
func (a *Menu) Query(ctx context.Context, params schema.MenuQueryParam, opts ...schema.MenuQueryOptions) (*schema.MenuQueryResult, error) {
	var menuQueryParam schema.MenuQueryParam
	userID := GetUserID(ctx)
	user, err := a.userModel.Get(ctx, userID)
	if err != nil {
		return nil, err
	}
	if !CheckIsRootUser(ctx) {
		roleMenu, err := a.roleMenuModel.Query(ctx, schema.RoleMenuQueryParam{RoleId: user.RoleId})
		if err != nil {
			return nil, err
		}
		menuQueryParam.RecordIDs = roleMenu.Data.ToMenuIds()
	}
	menu, err := a.MenuModel.Query(ctx, menuQueryParam)
	if err != nil {
		return nil, err
	}
	return menu, nil
}

// QueryTree 查询数据
func (a *Menu) QueryTree(ctx context.Context, params schema.MenuQueryParam, opts ...schema.MenuQueryOptions) (schema.MenuTrees, error) {
	var menuQueryParam schema.MenuQueryParam
	userID := GetUserID(ctx)
	user, err := a.userModel.Get(ctx, userID)
	if err != nil {
		return nil, err
	}
	if !CheckIsRootUser(ctx) {
		roleMenu, err := a.roleMenuModel.Query(ctx, schema.RoleMenuQueryParam{RoleId: user.RoleId})
		if err != nil {
			return nil, err
		}
		menuQueryParam.RecordIDs = roleMenu.Data.ToMenuIds()
	}
	menu, err := a.MenuModel.Query(ctx, menuQueryParam)
	if err != nil {
		return nil, err
	}
	return schema.ToTree(menu.Data.ToTrees(), ""), nil
}

// Get 查询指定数据
func (a *Menu) Get(ctx context.Context, recordID string, opts ...schema.MenuQueryOptions) (*schema.Menu, error) {
	item, err := a.MenuModel.Get(ctx, recordID, opts...)
	if err != nil {
		return nil, err
	} else if item == nil {
		return nil, errors.ErrNotFound
	}
	return item, nil
}

func (a *Menu) getUpdate(ctx context.Context, recordID string) (*schema.Menu, error) {
	return a.Get(ctx, recordID)
}

// Create 创建数据
func (a *Menu) Create(ctx context.Context, item schema.Menu) error {
	item.RecordID = guid.S()
	sequence, err := a.MenuModel.GetMaxSequence(ctx)
	if err != nil {
		return err
	}
	if sequence > 0 {
		item.Sequence = sequence + 1
	}
	return a.MenuModel.Create(ctx, item)
}

// Update 更新数据
func (a *Menu) Update(ctx context.Context, recordID string, item schema.Menu) error {
	oldItem, err := a.MenuModel.Get(ctx, recordID)
	if err != nil {
		return err
	} else if oldItem == nil {
		return errors.ErrNotFound
	}
	return a.MenuModel.Update(ctx, recordID, item)
}

// Delete 删除数据
func (a *Menu) Delete(ctx context.Context, recordID string) error {
	oldItem, err := a.MenuModel.Get(ctx, recordID)
	if err != nil {
		return err
	} else if oldItem == nil {
		return errors.ErrNotFound
	}

	return a.MenuModel.Delete(ctx, recordID)
}

func (a *Menu) UpdateSequence(ctx context.Context, recordID string, sequence int) error {
	item, err := a.MenuModel.Get(ctx, recordID)
	if err != nil {
		return err
	} else if item == nil {
		return errors.ErrNotFound
	}
	err = ExecTrans(ctx, a.transModel, func(ctx context.Context) error {
		err = a.MenuModel.UpdateBatchSequenceMinus(ctx, item.Sequence, sequence)
		if err != nil {
			return err
		}
		return a.MenuModel.UpdateSequence(ctx, recordID, sequence)
	})
	return err
}

// UpdateStatus 更新状态
func (a *Menu) UpdateStatus(ctx context.Context, recordID string, status int) error {
	oldItem, err := a.MenuModel.Get(ctx, recordID)
	if err != nil {
		return err
	} else if oldItem == nil {
		return errors.ErrNotFound
	}
	return a.MenuModel.UpdateStatus(ctx, recordID, status)
}