kpt-pasture/model/system_menu.go

package model

import (
	"sort"
	"time"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
)

type SystemMenu struct {
	Id              int64                   `json:"id"`
	PastureId       int64                   `json:"pastureId"`
	Name            string                  `json:"name"`
	Title           string                  `json:"title"`
	Path            string                  `json:"path"`
	Icon            string                  `json:"icon"`
	Component       string                  `json:"component"`
	Redirect        string                  `json:"redirect"`
	Auths           string                  `json:"auths"`
	MenuType        pasturePb.MenuType_Kind `json:"menuType"`
	ParentId        int64                   `json:"parentId"`
	Rank            int32                   `json:"rank"`
	ExtraIcon       string                  `json:"extraIcon"`
	EnterTransition string                  `json:"enterTransition"`
	ActivePath      string                  `json:"activePath"`
	FrameSrc        string                  `json:"frameSrc"`
	FrameLoading    pasturePb.IsShow_Kind   `json:"frameLoading"`
	Keepalive       pasturePb.IsShow_Kind   `json:"keepalive"`
	HiddenTag       pasturePb.IsShow_Kind   `json:"hiddenTag"`
	ShowLink        pasturePb.IsShow_Kind   `json:"showLink"`
	ShowParent      pasturePb.IsShow_Kind   `json:"showParent"`
	IsShow          pasturePb.IsShow_Kind   `json:"isShow"`
	IsDelete        pasturePb.IsShow_Kind   `json:"isDelete"`
	CreatedAt       int64                   `json:"createdAt"`
	UpdatedAt       int64                   `json:"updatedAt"`
}

func (s *SystemMenu) TableName() string {
	return "system_menu"
}

func (s *SystemMenu) MenuUpdate(req *pasturePb.SearchMenuRequest) {
	s.Name = req.Name
	s.Path = req.Path
	s.MenuType = req.MenuType
	s.Title = req.Title
	s.ParentId = int64(req.ParentId)
	s.FrameSrc = req.FrameSrc
	s.FrameLoading = BooleanToIsShow(req.FrameLoading)
	s.Keepalive = BooleanToIsShow(req.Keepalive)
	s.HiddenTag = BooleanToIsShow(req.HiddenTag)
	s.ShowLink = BooleanToIsShow(req.ShowLink)
	s.ShowParent = BooleanToIsShow(req.ShowParent)
	s.Icon = req.Icon
	s.Component = req.Component
	s.Redirect = req.Redirect
	s.Auths = req.Auths
	s.Rank = req.Rank
	s.ExtraIcon = req.ExtraIcon
	s.EnterTransition = req.EnterTransition
	s.ActivePath = req.ActivePath
	s.IsShow = req.IsShow
	s.IsDelete = req.IsDelete
}

// NewSystemMenu AddMenuRequest
func NewSystemMenu(pastureId int64, req *pasturePb.SearchMenuRequest) *SystemMenu {
	return &SystemMenu{
		PastureId:       pastureId,
		Name:            req.Name,
		Title:           req.Title,
		Path:            req.Path,
		Icon:            req.Icon,
		Component:       req.Component,
		Redirect:        req.Redirect,
		Auths:           req.Auths,
		MenuType:        req.MenuType,
		ParentId:        int64(req.ParentId),
		Rank:            req.Rank,
		ExtraIcon:       req.ExtraIcon,
		EnterTransition: req.EnterTransition,
		ActivePath:      req.ActivePath,
		FrameSrc:        req.FrameSrc,
		FrameLoading:    BooleanToIsShow(req.FrameLoading),
		Keepalive:       BooleanToIsShow(req.Keepalive),
		HiddenTag:       BooleanToIsShow(req.HiddenTag),
		ShowLink:        BooleanToIsShow(req.ShowLink),
		ShowParent:      BooleanToIsShow(req.ShowParent),
		IsShow:          pasturePb.IsShow_Ok,
		IsDelete:        pasturePb.IsShow_Ok,
	}
}

type SystemMenuSlice []*SystemMenu

func (s SystemMenuSlice) ToPB() []*pasturePb.SearchMenuRequest {
	res := make([]*pasturePb.SearchMenuRequest, len(s))
	for i, menu := range s {
		var frameLoading, keepalive, hiddenTag, showLink, showParent bool
		if menu.FrameLoading == pasturePb.IsShow_Ok {
			frameLoading = true
		}
		if menu.Keepalive == pasturePb.IsShow_Ok {
			keepalive = true
		}
		if menu.HiddenTag == pasturePb.IsShow_Ok {
			hiddenTag = true
		}
		if menu.ShowLink == pasturePb.IsShow_Ok {
			showLink = true
		}
		if menu.ShowParent == pasturePb.IsShow_Ok {
			showParent = true
		}

		res[i] = &pasturePb.SearchMenuRequest{
			Id:              int32(menu.Id),
			Name:            menu.Name,
			ParentId:        int32(menu.ParentId),
			MenuType:        menu.MenuType,
			Title:           menu.Title,
			Path:            menu.Path,
			IsShow:          menu.IsShow,
			Component:       menu.Component,
			Icon:            menu.Icon,
			Redirect:        menu.Redirect,
			Auths:           menu.Auths,
			Rank:            menu.Rank,
			ExtraIcon:       menu.ExtraIcon,
			EnterTransition: menu.EnterTransition,
			ActivePath:      menu.ActivePath,
			FrameSrc:        menu.FrameSrc,
			FrameLoading:    frameLoading,
			Keepalive:       keepalive,
			HiddenTag:       hiddenTag,
			ShowLink:        showLink,
			ShowParent:      showParent,
			CreatedAtFormat: time.Unix(menu.CreatedAt, 0).Local().Format(LayoutTime),
			UpdatedAtFormat: time.Unix(menu.UpdatedAt, 0).Local().Format(LayoutTime),
		}
	}
	return res
}

func (s SystemMenuSlice) ToTree() []*pasturePb.MenuTree {
	res := make([]*pasturePb.MenuTree, len(s))
	if 0 == len(s) {
		return res
	}
	// 正排序
	sort.Slice(s, func(i, j int) bool {
		return s[i].ParentId < s[j].ParentId
	})

	for i, v := range s {
		res[i] = &pasturePb.MenuTree{
			Id:       int32(v.Id),
			Path:     v.Path,
			ParentId: int32(v.ParentId),
			Name:     v.Name,
			Meta: &pasturePb.MenuMeta{
				Icon:     v.Icon,
				Title:    v.Title,
				Rank:     v.Rank,
				Roles:    []string{"admin"},
				ShowLink: v.ShowLink == pasturePb.IsShow_Ok,
			},
			Children: make([]*pasturePb.MenuTree, 0),
		}
	}
	// 构建树
	return buildTree(res)
}

func buildTree(menuTreeList []*pasturePb.MenuTree) []*pasturePb.MenuTree {
	tree := make([]*pasturePb.MenuTree, 0)
	for _, menu := range menuTreeList {
		if menu.ParentId == 0 {
			tree = append(tree, menu)
		} else {
			parent := findByID(menuTreeList, menu.ParentId)
			if parent != nil {
				parent.Children = append(parent.Children, menu)
			}
		}
	}
	return tree
}

func findByID(menuTreeList []*pasturePb.MenuTree, id int32) *pasturePb.MenuTree {
	for _, v := range menuTreeList {
		if id == v.Id {
			return v
		}
		if child := findByID(v.Children, id); child != nil {
			return child
		}
	}
	return nil
}

func BooleanToIsShow(isShow bool) pasturePb.IsShow_Kind {
	showKind := pasturePb.IsShow_No
	if isShow {
		showKind = pasturePb.IsShow_Ok
	}
	return showKind
}