light-apiengine-feature/controllers/partial/SystemController.go

package partial

import (
	"encoding/json"
	"fmt"
	"strconv"
	"strings"
	"time"

	"git.qianqiusoft.com/qianqiusoft/light-apiengine/db"
	"git.qianqiusoft.com/qianqiusoft/light-apiengine/entitys"
	"git.qianqiusoft.com/qianqiusoft/light-apiengine/models"
	sysmodel "git.qianqiusoft.com/qianqiusoft/light-apiengine/models"
	"git.qianqiusoft.com/qianqiusoft/light-apiengine/utils"
)

//https://www.kancloud.cn/xormplus/xorm/167077

// _Login
// @Title _Login
// @Description 用户登录
// @Param	logininfo      false  "登录信息"
// @Success 200 {object} sysmodel.Account
// @Failure 403 :id is empty
func System_Login(c *entitys.CtrlContext) {
	var logininfo sysmodel.LoginInfo
	c.Ctx.BindJSON(&logininfo)
	__none_func_system__(logininfo)
	//fmt.Println(logininfo)
	var user sysmodel.SysUser
	ret, err := c.Db.SQL(sysmodel.SqlUserLogin, logininfo.Account).Get(&user)
	if ret && err == nil {
		//TODO check password
		timestamp := uint64(time.Now().UnixNano())
		md5Pwd := utils.HashPassword(logininfo.Password, "")

		//密码错误
		if !strings.EqualFold(user.Password, md5Pwd) {
			c.Ctx.JSON(200, sysmodel.SysReturn{400, "passowrd incorrect!", nil})
			return
		}

		token := &entitys.Token{}
		timestamp_str := strconv.FormatUint(timestamp, 10)
		sec_tooken := utils.GenerateToken(logininfo.Account + timestamp_str)

		if v := utils.GetGlobalTokenStore().Get(sec_tooken); v == nil {
			token.AccessToken = sec_tooken
			token.RefreshToken = sec_tooken
			token.LoginID = logininfo.Account
			token.UserId = user.Id
			token.Result = 200
			//token.Password = pwd
			token.ServerIp = ""
			token.Domain = user.Domain
			utils.GetGlobalTokenStore().Set(sec_tooken, token)
		} else {
			token = v
		}

		data := sysmodel.LoginReturnInfo{}
		data.Userid = user.Id
		data.Name = user.LoginId
		data.Token = token.AccessToken
		data.Type = user.Type
		data.SysUserInfo = user
		data.SysUserInfo.Password = ""
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", data})
	} else {
		//fmt.Println(err.Error())
		c.Ctx.JSON(200, sysmodel.SysReturn{400, "username or passowrd incorrect!", nil})
	}

}

// _Logout
// @Title _Logout
// @Description 用户退出
// @Success 200 {object} sysmodel.Account
// @Failure 403 :id is empty
func System_Logout(c *entitys.CtrlContext) {

	token := c.Ctx.GetHeader("token")
	fmt.Println("delete token: ", token)
	utils.GetGlobalTokenStore().Remove(token)

	c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
}

// _GetNavTree
// @Title _GetNavTree
// @Description 获取导航菜单
// @Param	user    string  false  "用户id"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_GetNavTree(c *entitys.CtrlContext) {
	// set in the login_ware.go
	user_id := c.Ctx.GetString("user_id")

	var menus []sysmodel.SysMenuTree
	if user_id == "187c50a4-caad-4557-80c8-aca81af9f370" {
		c.Db.SQL(sysmodel.Selectall_nav_tree_admin).Find(&menus)
	} else {
		c.Db.SQL(sysmodel.Selectall_nav_tree, user_id).Find(&menus)
	}

	var menutree []sysmodel.SysMenuTree
	finChildrenMenu(&menus, "", nil, &menutree)
	for i := 0; i < len(menutree); i++ {
		finChildrenMenu(&menus, menutree[i].Id, &menutree[i], &menutree)
	}
	fmt.Println(menutree)
	c.Ctx.JSON(200, sysmodel.SysReturn{200, "", menutree})
}

// _GetMenuTree
// @Title _GetMenuTree
// @Description 获取系统菜单
// @Param	user    string  false  "用户id"
// @Success 200 {object} sysmodel.Account
// @Failure 403 :id is empty
func System_GetMenuTree(c *entitys.CtrlContext) {

	user := c.Ctx.Param(":user")
	ret := __none_func_system__(user)
	var menus []sysmodel.SysMenuTree
	c.Db.SQL(sysmodel.Selectall_sys_menu).Find(&menus)

	var menutree []sysmodel.SysMenuTree
	finChildrenMenu(&menus, "", nil, &menutree)

	fmt.Println(menutree)
	for i := 0; i < len(menutree); i++ {
		finChildrenMenu(&menus, menutree[i].Id, &menutree[i], &menutree)
	}
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", menutree})
	}

}

// _GetOrgTree
// @Title _GetOrgTree
// @Description 获取组织架构树
// @Success 200 {object} sysmodel.Account
// @Failure 403 :id is empty
func System_GetOrgTree(c *entitys.CtrlContext) {

	ret := __none_func_system__()

	var orgs []sysmodel.SysOrgTree
	c.Db.SQL(sysmodel.Selectall_sys_org).Find(&orgs)

	var orgtree []sysmodel.SysOrgTree
	finChildrenOrg(&orgs, "", nil, &orgtree)
	for i := 0; i < len(orgtree); i++ {
		finChildrenOrg(&orgs, orgtree[i].Id, &orgtree[i], &orgtree)
	}

	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", orgtree})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

func finChildrenOrg(menus *[]sysmodel.SysOrgTree, parent string, parent_menu *sysmodel.SysOrgTree, menutree *[]sysmodel.SysOrgTree) {
	for _, m := range *menus {
		if m.Parent == parent {
			if parent_menu == nil {
				*menutree = append(*menutree, m)
				//finChildrenMenu(menus, m.Id, menutree[len(*menutree)-1], menutree)
			} else {
				parent_menu.Children = append(parent_menu.Children, m)
				finChildrenOrg(menus, m.Id, &parent_menu.Children[len(parent_menu.Children)-1], menutree)
			}
		}
	}
}

func finChildrenMenu(menus *[]sysmodel.SysMenuTree, parent string, parent_menu *sysmodel.SysMenuTree, menutree *[]sysmodel.SysMenuTree) {
	for _, m := range *menus {
		if m.Parent == parent {
			if parent_menu == nil {
				m.Level = 0
				m.ParentName = ""
				*menutree = append(*menutree, m)
				//finChildrenMenu(menus, m.Id, menutree[len(*menutree)-1], menutree)
			} else {
				m.Level = parent_menu.Level + 1
				m.ParentName = parent_menu.Name
				parent_menu.Children = append(parent_menu.Children, m)
				finChildrenMenu(menus, m.Id, &parent_menu.Children[len(parent_menu.Children)-1], menutree)
			}
		}
	}
}

// _FindUserPage
// @Title _FindUserPage
// @Description 获取用户分布数据
// @Param	page      false  "分页参数"
// @Success 200 {object} sysmodel.Account
// @Failure 403 :id is empty
func System_FindUserPage(c *entitys.CtrlContext) {

	var getpageinfo sysmodel.GetPageInfo
	c.Ctx.BindJSON(&getpageinfo)
	__none_func_system__(getpageinfo)

	page := sysmodel.PageResult{}
	var users []sysmodel.UserInfo

	dbSession := c.Db.Table("sys_user")
	dbSession.Select("sys_user.*, sys_organization.name org_name")

	countSession := c.Db.Table("sys_user")

	JoinTables := []models.Join{}
	//JoinTables = append(JoinTables, models.Join{TabelName: "sys_user_role", Condition: "sys_user_role.user_id = sys_user.id", JoinOperator: "left"})
	//JoinTables = append(JoinTables, models.Join{TabelName: "sys_role", Condition: "sys_user_role.role_id = sys_role.id", JoinOperator: "left"})
	JoinTables = append(JoinTables, models.Join{TabelName: "sys_organization", Condition: "sys_organization.id = sys_user.org_id", JoinOperator: "left"})

	for _, join := range JoinTables {
		dbSession = dbSession.Join(join.JoinOperator, join.TabelName, join.Condition)
		countSession = countSession.Join(join.JoinOperator, join.TabelName, join.Condition)
	}

	whereStr, datas, err := getpageinfo.Filter.Parse("")

	dbSession = dbSession.Where(whereStr, datas...)
	countSession = countSession.Where(whereStr, datas...)

	sidx := strings.Split(getpageinfo.Sidx, ",")
	for _, order := range sidx {
		order = strings.TrimSpace(order)
		if len(order) == 0 {
			continue
		}

		if strings.ToLower(getpageinfo.Sord) == "desc" {
			dbSession = dbSession.OrderBy(order + " desc")
		} else {
			dbSession = dbSession.OrderBy(order + " asc")
		}

	}

	totalPage, _ := countSession.Count()

	dbSession.Limit(getpageinfo.PageSize, (getpageinfo.PageNum-1)*getpageinfo.PageSize).Find(&users)

	//查找每个用户的角色
	for i, user := range users {
		roles := []sysmodel.UserInfo{}
		err := c.Db.SQL(sysmodel.SqlSelectUserRoles, user.Id).Find(&roles)
		if err != nil {
			fmt.Println("----", err.Error())
			continue
		}
		users[i].UserRole = roles[0].UserRole
		users[i].RoleName = roles[0].RoleName
	}

	page.Content = users
	page.PageSize = getpageinfo.PageSize
	page.PageNum = getpageinfo.PageNum
	page.TotalSize = int(totalPage)

	if err == nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", page})
	} else {
		fmt.Println(err.Error())
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}

}

// _AddUser
// @Title _AddUser
// @Description 添加用户
// @Param	login_id    string  false  "登录ID"
// @Param	password    string  false  "密码"
// @Param	org_id    string  false  "组织ID"
// @Param	email    string  false  "邮箱"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_AddUser(c *entitys.CtrlContext) {

	var user sysmodel.SysUser
	err := c.Ctx.ShouldBindJSON(&user)
	if err != nil {
		c.Ctx.JSON(500, sysmodel.SysReturn{200, "c.Ctx.ShouldBindJSON error " + err.Error(), nil})
		return
	}

	fmt.Println(user.LoginId, "-----add user-----", user.Password, " --- ", user.OrgId)

	//查找login_id是否存在
	oldUser := new(sysmodel.SysUser)
	count, _ := c.Db.SQL("select * from sys_user").Where("login_id = ?", user.LoginId).Count(&oldUser)

	if count > 1 {
		if oldUser.DelFlag == 1 {
			oldUser.DelFlag = 0
			_, err := c.Db.Id("id").Cols("del_flag").Update(&oldUser)
			if err != nil {
				c.Ctx.JSON(500, sysmodel.SysReturn{500, "login_id exit, update err: " + err.Error(), nil})
			}
			return
		} else {
			c.Ctx.JSON(200, sysmodel.SysReturn{200, "login_id exit", nil})
			return
		}
	}

	user_id := c.Ctx.GetString("user_id")

	user.Id = utils.NewUUID()
	user.Name = user.LoginId
	user.CreateTime = time.Now()
	user.LastUpdateDate = time.Now()
	user.CreateBy = user_id
	user.LastUpdateBy = user_id
	user.DelFlag = 0
	user.Password = utils.HashPassword(user.Password, "")

	_, err = c.Db.Insert(&user)

	ret := __none_func_system__(user.LoginId, user.Password, user.OrgId, user.Email)
	if ret && err == nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(500, sysmodel.SysReturn{500, err.Error(), nil})
	}
}

// _DelUser
// @Title _DelUser
// @Description 删除用户
// @Param	id    string  false  "用户ID"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_DelUser(c *entitys.CtrlContext) {
	type Param struct {
		Id string `json:"id"`
	}

	var params []Param
	c.Ctx.BindJSON(&params)

	ids := []string{}
	for _, param := range params {
		ids = append(ids, param.Id)
	}

	session := c.Db.NewSession()
	defer session.Close()

	//_, err := c.Db.Table(new(models.SysUser)).ID(param.Id).Update(map[string]interface{}{"del_flag": 0})
	_, err := c.Db.Table(new(models.SysUser)).In("id", ids).Update(map[string]interface{}{"del_flag": 1})
	if err != nil {
		session.Rollback()
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	_, err = c.Db.Table(new(models.SysUserRole)).In("user_id", ids).Update(map[string]interface{}{"del_flag": 1})
	if err != nil {
		session.Rollback()
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	session.Commit()

	ret := __none_func_system__()
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _UpdateUser
// @Title _UpdateUser
// @Description 修改用户
// @Param	login_id    string  false  "登录ID"
// @Param	password    string  false  "密码"
// @Param	org_id    string  false  "组织ID"
// @Param	email    string  false  "邮箱"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_UpdateUser(c *entitys.CtrlContext) {
	user_id := c.Ctx.GetString("user_id")

	var userInfo sysmodel.UserInfo
	err := c.Ctx.BindJSON(&userInfo)
	if err != nil {
		c.Ctx.JSON(500, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	session := c.Db.NewSession()
	defer session.Close()
	//1、删除用户角色
	_, err = c.Db.SQL(sysmodel.SqlDeleteUserRoles, userInfo.Id).Execute()
	if err != nil {
		session.Rollback()
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	//2、修改角色
	userRoles := []models.SysUserRole{}
	roles := []string{}
	if userInfo.UserRole != "" {
		err = json.Unmarshal([]byte(userInfo.UserRole), &roles)
		if err != nil {
			session.Rollback()
			c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
			return
		}
	}

	for _, role := range roles {
		userRole := models.SysUserRole{}
		userRole.Id = utils.NewUUID()
		userRole.RoleId = role
		userRole.UserId = userInfo.Id
		userRole.CreateBy = user_id
		userRole.LastUpdateBy = user_id
		userRole.CreateTime = time.Now()
		userRole.LastUpdateDate = time.Now()
		userRole.DelFlag = 0
		userRoles = append(userRoles, userRole)
	}
	_, err = c.Db.Insert(userRoles)
	if err != nil {
		session.Rollback()
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	var updateUser models.SysUser

	updateUser.Name = userInfo.Name
	updateUser.FullName = userInfo.FullName
	updateUser.Mobile = userInfo.Mobile
	updateUser.OrgId = userInfo.OrgId
	updateUser.Type = userInfo.Type
	updateUser.Status = userInfo.Status
	updateUser.Domain = userInfo.Domain
	updateUser.OptionA = userInfo.OptionA
	updateUser.OptionB = userInfo.OptionB
	updateUser.LastUpdateBy = user_id
	updateUser.LastUpdateDate = time.Now()

	//3、更新用户信息
	//_, err = c.Db.Table(new(models.SysUser)).ID(userInfo.Id).Update(map[string]interface{}{"name": userInfo.Name, "email": userInfo.Email, "org_id": userInfo.OrgId, "last_update_by": user_id, "last_update_date": time.Now()})

	_,err = c.Db.Id(userInfo.Id).Update(&updateUser)

	if err != nil {
		session.Rollback()
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	session.Commit()

	ret := __none_func_system__()
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _AddRole
// @Title _AddRole
// @Description 添加角色
// @Param	name    string  false  "角色名称"
// @Param	remark    string  false  "备注"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_AddRole(c *entitys.CtrlContext) {
	var role models.SysRole
	c.Ctx.BindJSON(&role)

	user_id := c.Ctx.GetString("user_id")

	role.Id = utils.NewUUID()
	role.DelFlag = 0
	role.CreateBy = user_id
	role.LastUpdateBy = user_id
	role.CreateTime = time.Now()
	role.LastUpdateDate = time.Now()

	_, err := c.Db.Insert(&role)

	ret := __none_func_system__()
	if ret && err == nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
	}
}

// _DelRole
// @Title _DelRole
// @Description 添加角色
// @Param	id    string  false  "角色ID"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_DelRole(c *entitys.CtrlContext) {
	type Param struct {
		Id string `json:"id"`
	}

	var params []Param
	c.Ctx.BindJSON(&params)
	fmt.Println(params, "-----------")
	ids := []string{}
	for _, param := range params {
		ids = append(ids, param.Id)
	}

	_, err := c.Db.Table(new(models.SysRole)).In("id", ids).Update(map[string]interface{}{"del_flag": 1})
	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	ret := __none_func_system__()
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _UpdateRole
// @Title _UpdateRole
// @Description 修改角色
// @Param	id    string  false  "角色ID"
// @Param	name    string  false  "角色名称"
// @Param	remark    string  false  "备注"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_UpdateRole(c *entitys.CtrlContext) {

	var role models.SysRole
	c.Ctx.BindJSON(&role)

	user_id := c.Ctx.GetString("user_id")

	role.LastUpdateBy = user_id
	role.LastUpdateDate = time.Now()

	c.Db.ID(role.Id).Update(&role)

	ret := __none_func_system__()
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _FindRolePage
// @Title _FindRolePage
// @Description 角色分页
// @Param	page      false  "分页参数"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_FindRolePage(c *entitys.CtrlContext) {
	var getpageinfo models.GetPageInfo
	c.Ctx.BindJSON(&getpageinfo)

	page := sysmodel.PageResult{}
	var roles []sysmodel.SysRole
	err := c.Db.SQL(sysmodel.Selectall_sys_role).Limit(getpageinfo.PageSize, (getpageinfo.PageNum-1)*getpageinfo.PageSize).Find(&roles)
	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}
	fmt.Println("-----------", len(roles))
	page.Content = roles
	page.PageSize = getpageinfo.PageSize
	page.PageNum = getpageinfo.PageNum
	page.TotalSize = 1

	ret := __none_func_system__(getpageinfo)
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", page})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _FindRoleMenu
// @Title _FindRoleMenu
// @Description 查找角色权限
// @Param	user    string  false  "用户id"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_FindRoleMenu(c *entitys.CtrlContext) {

	role_id, b := c.Ctx.GetQuery("roleId")
	if !b {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "roleId is null", nil})
		return
	}

	menus := []models.SysMenu{}
	c.Db.SQL(models.SqlFindRoleMenu, role_id).Find(&menus)

	ret := __none_func_system__()
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", menus})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _SaveRoleMenu
// @Title _SaveRoleMenu
// @Description 保存角色权限
// @Param	role_menu    string  false  "角色权限"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_SaveRoleMenu(c *entitys.CtrlContext) {
	var saverolemenu []models.SysRoleMenu

	c.Ctx.BindJSON(&saverolemenu)

	if len(saverolemenu) < 1 {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "role menu length is error", nil})
		return
	}

	session := c.Db.NewSession()
	defer session.Close()
	err := session.Begin()

	//删除角色下的menu
	_, err = c.Db.Exec("delete from sys_role_menu where role_id = ?", saverolemenu[0].RoleId)
	//_, err = c.Db.Exec("delete from sys_role_menu where id = 1")
	if err != nil {
		session.Rollback()
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	for i, _ := range saverolemenu {
		saverolemenu[i].Id = utils.NewUUID()
		saverolemenu[i].DelFlag = 1
	}

	_, err = c.Db.Insert(&saverolemenu)
	if err != nil {
		session.Rollback()
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	session.Commit()

	ret := __none_func_system__(&saverolemenu)
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _RoleAll
// @Title _RoleAll
// @Description 查找所有角色
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_RoleAll(c *entitys.CtrlContext) {

	var roles []sysmodel.SysRole
	err := c.Db.SQL(sysmodel.Selectall_sys_role).Find(&roles)

	ret := __none_func_system__()
	if ret && err == nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", roles})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
	}
}

// _FindPermissions
// @Title _FindPermissions
// @Description 查找用户权限
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_FindPermissions(c *entitys.CtrlContext) {

	user_id := c.Ctx.GetString("user_id")

	//result, err := c.Db.Query(models.SqlFindUserPermissions, op.UserId)

	result, err := c.Db.QueryString(models.SqlFindUserPermissions, user_id)

	strs := []string{}
	for _, v := range result {
		strs = append(strs, v["perms"])
	}

	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
	}

	ret := __none_func_system__()

	//strs = []string{"sys:menu:add", "sys:menu:view", "sys:menu:edit", "sys:menu:delete", "sys:user:edit", "sys:user:delete", "sys:user:add", "sys:role:view", "sys:role:edit", "sys:role:delete", "sys:role:add"}

	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", strs})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _AddMenu
// @Title _AddMenu
// @Description 添加菜单
// @Param	    string  false  "菜单"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_AddMenu(c *entitys.CtrlContext) {
	var sysmenu models.SysMenu
	c.Ctx.BindJSON(&sysmenu)

	user_id := c.Ctx.GetString("user_id")

	sysmenu.Id = utils.NewUUID()
	sysmenu.CreateBy = user_id
	sysmenu.LastUpdateBy = user_id
	sysmenu.LastUpdateDate = time.Now()
	sysmenu.CreateTime = time.Now()
	sysmenu.DelFlag = 0

	_, err := c.Db.Insert(&sysmenu)
	if err != nil {
		c.Ctx.JSON(500, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	ret := __none_func_system__(sysmenu)
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(500, sysmodel.SysReturn{500, "", nil})
	}
}

// _DelMenu
// @Title _DelMenu
// @Description 删除菜单
// @Param	id    string  false  "菜单ID"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_DelMenu(c *entitys.CtrlContext) {
	type Param struct {
		Id string `json:"id"`
	}

	var params []Param
	c.Ctx.BindJSON(&params)
	fmt.Println(params, "-----------")
	ids := []string{}
	for _, param := range params {
		ids = append(ids, param.Id)
	}

	_, err := c.Db.Table(new(models.SysMenu)).In("id", ids).Update(map[string]interface{}{"del_flag": 0})
	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	ret := __none_func_system__()
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _UpdateMenu
// @Title _UpdateMenu
// @Description 更新菜单
// @Param	    string  false  "菜单"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_UpdateMenu(c *entitys.CtrlContext) {
	var sysmenu models.SysMenu
	err := c.Ctx.BindJSON(&sysmenu)
	if err != nil{
		c.Ctx.JSON(500, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	user_id := c.Ctx.GetString("user_id")

	whereMenu := &models.SysMenu{}
	whereMenu.Id = sysmenu.Id

	sysmenu.LastUpdateBy = user_id
	sysmenu.LastUpdateDate = time.Now()

	_, err = c.Db.Update(&sysmenu, whereMenu)

	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	ret := __none_func_system__(sysmenu)
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _AddOrg
// @Title _AddOrg
// @Description 添加组织
// @Param	    string  false  "组织"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_AddOrg(c *entitys.CtrlContext) {
	var sysorg models.SysOrganization
	c.Ctx.BindJSON(&sysorg)

	user_id := c.Ctx.GetString("user_id")

	sysorg.Id = utils.NewUUID()
	sysorg.CreateBy = user_id
	sysorg.LastUpdateBy = user_id
	sysorg.LastUpdateDate = time.Now()
	sysorg.CreateTime = time.Now()
	sysorg.DelFlag = 0

	_, err := c.Db.Insert(&sysorg)
	if err != nil {
		c.Ctx.JSON(500, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	ret := __none_func_system__(sysorg)
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(500, sysmodel.SysReturn{500, "", nil})
	}
}

// _DelOrg
// @Title _DelOrg
// @Description 删除组织
// @Param	id    string  false  "组织ID"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_DelOrg(c *entitys.CtrlContext) {
	type Param struct {
		Id string `json:"id"`
	}

	var params []Param
	c.Ctx.BindJSON(&params)
	fmt.Println(params, "-----------")
	ids := []string{}
	for _, param := range params {
		ids = append(ids, param.Id)
	}

	_, err := c.Db.Table(new(models.SysOrganization)).In("id", ids).Update(map[string]interface{}{"del_flag": 0})
	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	ret := __none_func_system__()
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _UpdateOrg
// @Title _UpdateOrg
// @Description 更新组织
// @Param	    string  false  "组织"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_UpdateOrg(c *entitys.CtrlContext) {
	var sysorg models.SysOrganization
	c.Ctx.BindJSON(&sysorg)

	user_id := c.Ctx.GetString("user_id")

	sysorg.LastUpdateBy = user_id
	sysorg.LastUpdateDate = time.Now()

	_, err := c.Db.ID(sysorg.Id).Update(&sysorg)

	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	ret := __none_func_system__(sysorg)
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nil})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _GetOrg
// @Title _GetOrg
// @Description 根据ID获取组织
// @Param	    string  false  "组织ID"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_GetOrg(c *entitys.CtrlContext) {
	var param struct {
		Id string `json:"id"`
	}

	c.Ctx.BindJSON(&param)
	fmt.Println(param, "-----------")

	org := models.SysOrganization{}
	err := c.Db.Table(new(sysmodel.SysOrganization)).ID(param.Id).Find(&org)
	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	ret := __none_func_system__()
	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", org})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

// _PageOrg
// @Title _PageOrg
// @Description 分页获取组织
// @Param	    string  false  "组织"
// @Success 200 {object} models.Account
// @Failure 403 :id is empty
func System_PageOrg(c *entitys.CtrlContext) {
	var getpageinfo models.GetPageInfo
	c.Ctx.BindJSON(&getpageinfo)

	ret := __none_func_system__(getpageinfo)

	page := sysmodel.PageResult{}
	var orgs []sysmodel.SysOrganization
	dbSession := c.Db.Table("sys_organization")
	dbSession = dbSession.Select("sys_organization.*")

	countSession := c.Db.Table("sys_organization")

	JoinTables := []sysmodel.Join{}
	//JoinTables = append(JoinTables, sysmodel.Join{TabelName: "subject", Condition: "lesson.subject_id = subject.id", JoinOperator: "left"})

	for _, join := range JoinTables {
		dbSession = dbSession.Join(join.JoinOperator, join.TabelName, join.Condition)
		countSession = countSession.Join(join.JoinOperator, join.TabelName, join.Condition)
	}

	whereStr, datas, err := getpageinfo.Filter.Parse("")

	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
		return
	}

	dbSession = dbSession.Where(whereStr, datas...)
	countSession = countSession.Where(whereStr, datas...)

	sidx := strings.Split(getpageinfo.Sidx, ",")
	for _, order := range sidx {
		order = strings.TrimSpace(order)
		if len(order) == 0 {
			continue
		}

		if strings.ToLower(getpageinfo.Sord) == "desc" {
			dbSession = dbSession.OrderBy(order + " desc")
		} else {
			dbSession = dbSession.OrderBy(order + " asc")
		}

	}

	totalPage, _ := countSession.Count()
	err = dbSession.Limit(getpageinfo.PageSize, (getpageinfo.PageNum-1)*getpageinfo.PageSize).Find(&orgs)
	if err != nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, err.Error(), nil})
	}
	page.Content = orgs
	page.PageSize = getpageinfo.PageSize
	page.PageNum = getpageinfo.PageNum
	page.TotalSize = int(totalPage)

	if ret {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", page})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

func System_TreeList(c *entitys.CtrlContext) {
	tbName := c.Ctx.Query("tb_name")
	parentFiled := c.Ctx.Query("parent_filed")
	if parentFiled == "" {
		parentFiled = c.Ctx.Query("parent_field")
	}
	parentValue := c.Ctx.Query("parent_value")
	textFiled := c.Ctx.Query("text_filed")
	if textFiled == "" {
		textFiled = c.Ctx.Query("text_field")
		if textFiled == "" {
			textFiled = c.Ctx.Query("name_field")
		}
	}
	valueFiled := c.Ctx.Query("value_filed")
	if valueFiled == "" {
		valueFiled = c.Ctx.Query("value_field")
		if valueFiled == "" {
			valueFiled = c.Ctx.Query("id_field")
		}
	}
	domainchk := c.Ctx.Query("domainchk")
	if domainchk == "" {
		domainchk = "1" // 默认需要domain过滤
	}
	cntparent := c.Ctx.Query("cnt_parent")
	if cntparent == "" {
		cntparent = "0"
	}
	filter := c.Ctx.Query("filters")
	if filter == "" {
		filter = c.Ctx.Query("filter")
	}
	sord := c.Ctx.Query("sord")

	user, exists := c.Ctx.Get("token")
	if !exists {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "token is not exists", nil})
		return
	}
	nodes, err := sysdb.TreeList(c, user.(*entitys.Token), tbName, parentFiled, parentValue, textFiled, valueFiled, cntparent, domainchk, filter, sord)
	if err == nil {
		c.Ctx.JSON(200, sysmodel.SysReturn{200, "", nodes})
	} else {
		c.Ctx.JSON(200, sysmodel.SysReturn{500, "", nil})
	}
}

func __none_func_system__(params ...interface{}) bool {
	return true
}