MTP20_IF/controllers/common/menu.go

package common

import (
	"encoding/json"
	"fmt"
	"mtp2_if/global/app"
	"mtp2_if/global/e"
	"mtp2_if/logger"
	"mtp2_if/models"
	"net/http"
	"os"

	"github.com/gin-gonic/gin"
)

// ClientMenu 客户端菜单
type ClientMenu struct {
	Code     string       `json:"code"`     // ID
	Title    string       `json:"title"`    // 标题
	Sort     int          `json:"sort"`     // 排序
	Type     int          `json:"type"`     // 类型，1：菜单 2：按钮
	RuleKey  string       `json:"rulekey"`  // 对应权限主键，对应FUNCMENULIST表RESOURCECODE
	IsShow   bool         `json:"isshow"`   // 是否显示
	URL      string       `json:"url"`      // URL
	Remark   string       `json:"remark"`   // 备注
	Children []ClientMenu `json:"children"` // 子菜单列表
}

// PCWebMenuAuth PC客户端页面（按钮）权限
type PCWebMenuAuth struct {
	Label   string `json:"label"`   // 标题
	Code    string `json:"code"`    // ID，新版本中权限KEY也是这个字段
	Rulekey string `json:"rulekey"` // 权限主键，非空表示需要判断控制，非空值不可重复
	IsShow  bool   `json:"isshow"`  // 是否显示
	Remark  string `json:"remark"`  // 备注
}

// PCWebMenu PC客户端菜单权限
type PCWebMenu struct {
	Title     string          `json:"title"`     // 标题
	Code      string          `json:"code"`      // ID，新版本中权限KEY也是这个字段
	Path      string          `json:"path"`      // 路由路径
	Component string          `json:"component"` // 路由组件
	Sort      int             `json:"sort"`      // 排序
	Rulekey   string          `json:"rulekey"`   // 权限主键，非空表示需要判断控制，非空值不可重复
	IsShow    bool            `json:"isshow"`    // 是否显示
	URL       string          `json:"url"`       // URL
	Remark    string          `json:"remark"`    // 备注
	Children  []PCWebMenu     `json:"children"`  // 子菜单列表
	Auth      []PCWebMenuAuth `json:"auth"`      // 页面权限列表
}

// GetClientMenusReq 获取交易端菜单请求参数
type GetClientMenusReq struct {
	LoginID    int    `form:"loginID" binding:"required"`
	ClientType int    `form:"clientType"`
	Name       string `form:"name"`
}

// GetClientMenus 获取交易端菜单
// @Summary  获取交易端菜单
// @Produce  json
// @Security ApiKeyAuth
// @Param    loginID    query    int    true  "登录账号"
// @Param    clientType query    int    false "终端类型，0：PCWEB 1：Mobile，不传默认返回PC端数据"
// @Param    name       query    string false "分支名称，ermcp-风管云平台;pingan-平安期货;trader-交易所;不传默认返回风管云平台"
// @Success  200        {array}  ClientMenu
// @Failure  500        {object} app.Response
// @Router   /Common/GetClientMenus [get]
// @Tags     通用服务
func GetClientMenus(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req GetClientMenusReq
	if err := c.ShouldBind(&req); err != nil {
		logger.GetLogger().Errorf("GetClientMenus parse query req: %v", err)
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	// 获取菜单数据
	jsonFile := "pc_menu.json"
	if req.ClientType == 1 {
		// Mobile
		jsonFile = "mobile_menu.json"
	}

	// 获取分支名称
	if len(req.Name) > 0 {
		if req.ClientType == 0 {
			// PCWEB
			jsonFile = fmt.Sprintf("pcweb_menu/pcweb_menu_%s.json", req.Name)
		} else {
			// 手机
			jsonFile = fmt.Sprintf("mobile_menu/mobile_menu_%s.json", req.Name)
		}
	}

	// 读取json文件
	filePtr, err := os.Open(fmt.Sprintf("config/%s", jsonFile))
	if err != nil {
		// 读取文件失败
		logger.GetLogger().Errorf("GetClientMenus failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_CFG_FILE_FAIL, nil)
		return
	}
	defer filePtr.Close()

	var datas []interface{}
	// 创建Json编码器
	decoder := json.NewDecoder(filePtr)
	if err = decoder.Decode(&datas); err != nil {
		// Json解码失败
		logger.GetLogger().Errorf("GetClientMenus failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_CFG_JSON_FAIL, nil)
		return
	}

	isTrade, err := models.IsTrader(req.LoginID)
	if err != nil {
		// 判断用户类型失败
		logger.GetLogger().Errorf("GetClientMenus failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	var rst []ClientMenu
	if isTrade && req.ClientType == 1 {
		// 交易所自营会员或投资者, 目前只支持手机
		rst = createTraderMenu(datas)
	} else {
		rst = createMenu(datas, req.LoginID)
	}

	r := make([]ClientMenu, 0)
	if req.ClientType == 0 {
		// PC 去掉第一层没有子项的
		for _, v := range rst {
			if len(v.Children) > 0 {
				r = append(r, v)
			}
		}
	} else {
		r = rst
	}

	// 查询成功
	logger.GetLogger().Debugln("GetPCMenus successed: %v", r)
	appG.Response(http.StatusOK, e.SUCCESS, r)
}

// createMenu 创建菜单数据
func createMenu(datas []interface{}, loginID int) []ClientMenu {
	clientMenus := make([]ClientMenu, 0)
	for _, v := range datas {
		data := v.(map[string]interface{})
		if data["isshow"].(bool) {
			rulekey := data["rulekey"].(string)
			if len(rulekey) != 0 {
				// 判断是否有权限
				funcMenuList, err := models.GetErmcpRoleFuncMenuLists(loginID, rulekey)
				if err != nil {
					continue
				}
				if len(funcMenuList) == 0 {
					continue
				}
			}

			item := ClientMenu{
				Code:     data["code"].(string),
				Title:    data["title"].(string),
				Sort:     int(data["sort"].(float64)),
				Type:     int(data["type"].(float64)),
				RuleKey:  data["rulekey"].(string),
				IsShow:   data["isshow"].(bool),
				Children: createMenu(data["children"].([]interface{}), loginID), // TODO: - 这里为什么可以这样转？
			}
			if data["url"] != nil {
				item.URL = data["url"].(string)
			}
			if data["remark"] != nil {
				item.Remark = data["remark"].(string)
			}
			clientMenus = append(clientMenus, item)
		}
	}

	return clientMenus
}

// createTraderMenu 创建交易所版自营会员和投资者菜单
func createTraderMenu(datas []interface{}) []ClientMenu {
	clientMenus := make([]ClientMenu, 0)
	for _, v := range datas {
		data := v.(map[string]interface{})
		if data["isshow"].(bool) {
			item := ClientMenu{
				Code:     data["code"].(string),
				Title:    data["title"].(string),
				Sort:     int(data["sort"].(float64)),
				Type:     int(data["type"].(float64)),
				RuleKey:  data["rulekey"].(string),
				IsShow:   data["isshow"].(bool),
				Children: createTraderMenu(data["children"].([]interface{})),
			}
			if data["url"] != nil {
				item.URL = data["url"].(string)
			}
			if data["remark"] != nil {
				item.Remark = data["remark"].(string)
			}
			clientMenus = append(clientMenus, item)
		}
	}

	return clientMenus
}

// GetPCWebMenusReq 获取PCWeb交易端菜单请求参数
type GetPCWebMenusReq struct {
	LoginID int    `form:"loginID" binding:"required"`
	Name    string `form:"name"`
}

// GetPCWebMenus 获取PCWeb交易端菜单
// @Summary  获取PCWeb交易端菜单
// @Produce  json
// @Security ApiKeyAuth
// @Param    loginID query    int    true  "登录账号"
// @Param    name    query    string false "分支名称，ermcp：风管云平台，不传默认返回ermcp"
// @Success  200     {array}  PCWebMenu
// @Failure  500     {object} app.Response
// @Router   /Common/GetPCWebMenus [get]
// @Tags     通用服务
func GetPCWebMenus(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req GetPCWebMenusReq
	if err := c.ShouldBind(&req); err != nil {
		logger.GetLogger().Errorf("GetPCWebMenus parse query req: %v", err)
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	// 获取菜单数据
	jsonFile := "pcweb_menu/pcweb_menu_ermcp.json"
	// 获取分支名称
	if len(req.Name) > 0 {
		jsonFile = fmt.Sprintf("pcweb_menu/pcweb_menu_%s.json", req.Name)
	}

	// 读取json文件
	filePtr, err := os.Open(fmt.Sprintf("config/%s", jsonFile))
	if err != nil {
		// 读取文件失败
		logger.GetLogger().Errorf("GetPCWebMenus failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_CFG_FILE_FAIL, nil)
		return
	}
	defer filePtr.Close()

	var datas []interface{}
	// 创建Json编码器
	decoder := json.NewDecoder(filePtr)
	if err = decoder.Decode(&datas); err != nil {
		// Json解码失败
		logger.GetLogger().Errorf("GetPCWebMenus failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_CFG_JSON_FAIL, nil)
		return
	}

	rst := createPCWebMenu(datas, req.LoginID)

	// 查询成功
	logger.GetLogger().Debugf("GetPCWebMenus successed: %v\n", len(rst))
	appG.Response(http.StatusOK, e.SUCCESS, rst)
}

// createPCWebMenu 创建菜单数据
func createPCWebMenu(datas []interface{}, loginID int) []PCWebMenu {
	clientMenus := make([]PCWebMenu, 0)
	for _, v := range datas {
		data := v.(map[string]interface{})
		if data["isshow"].(bool) {
			// 判断权限
			rulekey := ""
			if data["rulekey"] != nil {
				rulekey = data["rulekey"].(string)
				requireAuth := rulekey != ""
				if requireAuth {
					// 判断是否有权限
					funcMenuList, err := models.GetErmcpRoleFuncMenuLists(loginID, rulekey)
					if err != nil {
						continue
					}
					if len(funcMenuList) == 0 {
						continue
					}
				}
			}

			// 构建页面（按钮）权限
			auths := make([]PCWebMenuAuth, 0)
			if data["auth"] != nil {
				list := data["auth"].([]interface{})
				for _, a := range list {
					am := a.(map[string]interface{})
					if am["isshow"].(bool) {
						// 判断权限
						rulekeySub := ""
						if am["rulekey"] != nil {
							rulekeySub = am["rulekey"].(string)
							requireAuth := rulekeySub != ""
							if requireAuth {
								// 判断是否有权限
								funcMenuList, err := models.GetErmcpRoleFuncMenuLists(loginID, rulekeySub)
								if err != nil {
									continue
								}
								if len(funcMenuList) == 0 {
									continue
								}
							}
						}

						auth := PCWebMenuAuth{
							Label:   am["label"].(string),
							Code:    am["code"].(string),
							Rulekey: rulekeySub,
							IsShow:  am["isshow"].(bool),
						}
						if am["remark"] != nil {
							auth.Remark = am["remark"].(string)
						}
						auths = append(auths, auth)
					}
				}
			}

			item := PCWebMenu{
				Title:     toString(data["title"]),
				Code:      toString(data["code"]),
				Path:      toString(data["path"]),
				Component: toString(data["component"]),
				Sort:      int(data["sort"].(float64)),
				Rulekey:   rulekey,
				IsShow:    data["isshow"].(bool),
			}
			if data["url"] != nil {
				item.URL = data["url"].(string)
			}
			if data["remark"] != nil {
				item.Remark = data["remark"].(string)
			}
			if data["children"] != nil {
				item.Children = createPCWebMenu(data["children"].([]interface{}), loginID)
			}
			if len(auths) > 0 {
				item.Auth = auths
			}
			clientMenus = append(clientMenus, item)
		}
	}

	return clientMenus
}

// toString 转换为string类型
func toString(v interface{}) string {
	if d, ok := v.(string); ok {
		return d
	}
	return ""
}

// FindNewFuncmenu 获取菜单表数据
// @Summary  获取菜单表数据
// @Produce  json
// @Security ApiKeyAuth
// @Param    resourcecode query    string false "资源代码"
// @Param    parentcode   query    string false "上级资源代码"
// @Param    resourcename query    string false "资源名(Title), 模糊查询"
// @Param    menutype     query    string false "菜单类型（格式：1,2,3） - 1:管理端 2:PC(C#) 3:移动(云平台) 4:终端(交易所) 5:PC(云平台)"
// @Success  200          {array}  models.NewFuncmenulist
// @Failure  500          {object} app.Response
// @Router   /Common/FindNewFuncmenu [get]
// @Tags     通用服务
func FindNewFuncmenu(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req models.NewFuncmenulistReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("FindNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	newFuncmenulist := models.NewFuncmenulist{}
	rst, err := newFuncmenulist.Find(req)
	if err != nil {
		// 查询失败
		logger.GetLogger().Errorf("FindNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 查询成功
	logger.GetLogger().Debugln("FindNewFuncmenu successed")
	appG.Response(http.StatusOK, e.SUCCESS, rst)
}

// InsertNewFuncmenu 插入菜单表数据
// @Summary  插入菜单表数据
// @accept   application/json
// @Produce  application/json
// @Security ApiKeyAuth
// @Param    data body     models.NewFuncmenulist true "菜单表数据"
// @Success  200  {object} app.Response
// @Failure  500  {object} app.Response
// @Router   /Common/InsertNewFuncmenu [post]
// @Tags     通用服务
func InsertNewFuncmenu(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req models.NewFuncmenulist
	if err := appG.C.ShouldBindJSON(&req); err != nil {
		logger.GetLogger().Errorf("InsertNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	err := req.Insert()
	if err != nil {
		// 失败
		logger.GetLogger().Errorf("InsertNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 成功
	logger.GetLogger().Debugln("InsertNewFuncmenu successed")
	appG.Response(http.StatusOK, e.SUCCESS, struct{}{})
}

// UpdateNewFuncmenu 更新菜单表数据
// @Summary  更新菜单表数据
// @accept   application/json
// @Produce  application/json
// @Security ApiKeyAuth
// @Param    data body     models.NewFuncmenulist true "菜单表数据"
// @Success  200  {object} app.Response
// @Failure  500  {object} app.Response
// @Router   /Common/UpdateNewFuncmenu [put]
// @Tags     通用服务
func UpdateNewFuncmenu(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req models.NewFuncmenulist
	if err := appG.C.ShouldBindJSON(&req); err != nil {
		logger.GetLogger().Errorf("UpdateNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	err := req.Update()
	if err != nil {
		// 失败
		logger.GetLogger().Errorf("UpdateNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 成功
	logger.GetLogger().Debugln("UpdateNewFuncmenu successed")
	appG.Response(http.StatusOK, e.SUCCESS, struct{}{})
}

// DeleteNewFuncmenu 删除菜单表数据
// @Summary  删除菜单表数据
// @accept   application/json
// @Produce  application/json
// @Security ApiKeyAuth
// @Param    data body     models.NewFuncmenulist true "菜单表数据，只需要resourcecode字段即可"
// @Success  200  {object} app.Response
// @Failure  500  {object} app.Response
// @Router   /Common/DeleteNewFuncmenu [delete]
// @Tags     通用服务
func DeleteNewFuncmenu(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req models.NewFuncmenulist
	if err := appG.C.ShouldBindJSON(&req); err != nil {
		logger.GetLogger().Errorf("DeleteNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	err := req.Delete()
	if err != nil {
		// 失败
		logger.GetLogger().Errorf("DeleteNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 成功
	logger.GetLogger().Debugln("DeleteNewFuncmenu successed")
	appG.Response(http.StatusOK, e.SUCCESS, struct{}{})
}

type GetClientNewFuncmenuReq struct {
	LoginID  int `form:"loginid" binding:"required"`
	MenuType int `form:"menutype" binding:"required"`
}

// GetClientNewFuncmenu 获取终端菜单
// @Summary  获取终端菜单
// @Produce  json
// @Security ApiKeyAuth
// @Param    loginid  query    int true "登录账号"
// @Param    menutype query    int true "菜单类型 - 1:管理端 2:PC(C#) 3:移动(云平台) 4:终端(交易所) 5:PC(云平台)"
// @Success  200      {array}  models.NewFuncmenulist
// @Failure  500      {object} app.Response
// @Router   /Common/GetClientNewFuncmenu [get]
// @Tags     通用服务
func GetClientNewFuncmenu(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req GetClientNewFuncmenuReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("GetClientNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	rst, err := models.GetNewErmcpRoleFuncMenuLists(req.LoginID, req.MenuType)
	if err != nil {
		// 查询失败
		logger.GetLogger().Errorf("GetClientNewFuncmenu failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 查询成功
	logger.GetLogger().Debugln("GetClientNewFuncmenu successed")
	appG.Response(http.StatusOK, e.SUCCESS, rst)
}