back/internal/api/manage/user/update.go

package user

import (
	"recook/internal/back"
	"recook/internal/cache"
	"recook/internal/dbc"
	"recook/internal/model/manage"
	"recook/internal/model/menu"
	"recook/internal/model/rolemenu"
	"recook/internal/model/vend"
	"recook/tools"
	"strconv"
	"time"

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

type loginParam struct {
	Mobile   string `gorm:"column:mobile" json:"mobile" validate:"required,len=11"`
	Password string `gorm:"column:password" json:"password" validate:"required,len=6"`
}

type logoutParam struct {
	ID uint `json:"id" validate:"required"`
}

// 登录
func Login(c *gin.Context) {
	var p loginParam

	err := tools.Params(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}

	var u manage.UserInfo
	err = dbc.DB.First(&u, "mobile=?", p.Mobile).Error
	if err != nil {
		if gorm.IsRecordNotFoundError(err) {
			back.PasswordErr(c)
		} else {
			back.Err(c, err.Error())
		}
		return
	}

	if u.Password == tools.MD5(p.Password) {
		if u.IsDel == 1 {
			back.LoginErr(c, "账号被禁用")
			return
		}
		if u.RoleID == 0 {
			back.LoginErr(c, "账号未绑定角色")
			return
		}
		var r manage.Role
		dbc.DB.First(&r, "id=?", u.RoleID)
		if r.IsDel == 1 {
			back.LoginErr(c, "角色被禁用")
			return
		}
		token := tools.Token()
		dbc.DB.Model(&u).Update("token", token)
		cache.SetAdminLoginCache(&u)
		u.Code = r.Code
		back.Suc(c, "登录成功", u)
	} else {
		back.PasswordErr(c)
	}
}

type TreeList struct {
	ID        int         `json:"id"`
	Name      string      `json:"name" validate:"required"` //菜单名称
	Parentid  int         `json:"parentid"`                 //父级菜单id
	Path      string      `json:"path"`                     //前端跳转路径
	Action    string      `json:"action"`                   //后台api路径
	Icon      string      `json:"icon"`                     //图标
	Component string      `json:"component"`                //react组件名称
	Listorder int         `json:"listorder"`                //排序
	Display   string      `json:"display"`                  //是否显示，1正常2禁用
	Check     int         `json:"check"`                    //是否选中
	Children  []*TreeList `json:"children"`
}

//获取管理员对应的菜单
func GetManagerMenu(c *gin.Context) {
	id, _ := strconv.Atoi(c.Request.Header.Get("X-Recook-ID"))
	var myManager manage.UserInfo
	dbc.DB.First(&myManager, "id=?", id)

	var MenuId []int
	//超级管理员拥有所有的权限
	//if myManager.NewroleId == 1 {
	//	MenuId = nil
	//} else {
	var myMenuId []struct{ Menuid int }
	var myRole rolemenu.Rolemenu
	dbc.DB.Select("menuid").Model(&myRole).Where("roleid=?", myManager.NewroleId).Scan(&myMenuId)

	for _, item := range myMenuId {
		MenuId = append(MenuId, item.Menuid)
	}
	if len(myMenuId) == 0 {
		MenuId = append(MenuId, 0)
	}

	//}
	//返回权限菜单
	treeList := getMenu(MenuId, 0, 1)
	back.Suc(c, "", treeList)

}

/*
递归获取树形菜单,只获取两层
*/
func getMenu(menuId []int, pid int, level int) []*TreeList {
	var menu []menu.RecookMenu
	if len(menuId) > 0 {
		dbc.DB.Where("parentid = ? and display=1 and id in (?)", pid, menuId).Order("listorder asc").Find(&menu)
	} else {
		dbc.DB.Where("parentid =? and display=1", pid).Order("listorder asc").Find(&menu)
	}
	level = level + 1
	treeList := []*TreeList{}
	if level <= 3 {

		for _, v := range menu {
			child := getMenu(menuId, v.ID, level)
			node := &TreeList{
				Name:      v.Name,
				Parentid:  v.Parentid,
				Path:      v.Path,
				Action:    v.Action,
				Icon:      v.Icon,
				Component: v.Component,
				Listorder: v.Listorder,
				Display:   v.Display,
			}
			node.Children = child
			treeList = append(treeList, node)

		}
	}
	return treeList

}

type loginGysParam struct {
	Username string ` json:"username" validate:"required"`
	Pass     string ` json:"pass" validate:"required"`
	Type     int    ` json:"type"`
}

// 供应商的登录
func LoginGys(c *gin.Context) {
	var p loginGysParam

	err := tools.Params(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}

	var gys vend.GysUsers
	err = dbc.DB.First(&gys, "username=?", p.Username).Error
	if err != nil {
		if gorm.IsRecordNotFoundError(err) {
			back.PasswordErr(c)
		} else {
			back.Err(c, err.Error())
		}
		return
	}
	if p.Type == 1 {
		p.Pass = tools.MD5(p.Pass)
	}
	if tools.MD5(gys.Password) == p.Pass {
		//供应商统一管理
		var u manage.UserInfo
		dbc.DB.First(&u, "name=?", "供应商统一管理")
		var r manage.Role
		dbc.DB.First(&r, "id=?", u.RoleID)

		token := tools.Token()
		//过期时间
		dbc.Rds.Set(token, gys.ID, 24*time.Hour)

		u.Code = r.Code
		back.Suc(c, "登录成功", &gin.H{
			"id":       u.ID,
			"token":    u.Token,
			"code":     u.Code,
			"gysToken": token,
		})

		return

	} else {
		back.PasswordErr(c)
	}
}

// 退出
func Logout(c *gin.Context) {
	var p logoutParam

	err := tools.Params(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}

	var u manage.UserInfo
	dbc.DB.First(&u, "id=?", p.ID)
	dbc.DB.Model(&u).Update("token", tools.Token())

	back.Suc(c, "登出成功", nil)
}