package models

import (
	database "WorldEpcho/src/datasource"
	"errors"
	"fmt"
	"github.com/go-xorm/xorm"
	"strconv"
)

//应用关系组结构体
type AppGroup struct {
	No         string  `json:"No" xorm:"no pk"`
	AppId      int64   `json:"app_id" xorm:"app_id"`
	CreatorId  int64   `json:"creator_id" xorm:"creator_id"`
	GroupName  string  `json:"group_name" xorm:"group_name"`
	GroupMem   []int64 `json:"group_mem" xorm:"group_mem json"` // 修改为JSON类型的数组
	Visibility string  `json:"visibility" xorm:"visibility"`
}

//应用组权限表
type AppGroupPermission struct {
	GroupId    string `json:"group_id"` //这里的群id对应appGroup的No
	UserId     int64  `json:"user_id"`
	Permission int    `json:"permission"` //0为最大权限，权限值越小权限越大，被邀请到组群的用户的权限默认是邀请人的权限值加1
}

// CreateAppGroup 函数会创建一个新的应用组并将其保存至数据库，更新用户应用组的权限
func CreateAppGroup(newGroup *AppGroup) error {
	// 开启事务
	session := database.Engine.NewSession()
	defer session.Close()
	err := session.Begin()
	if err != nil {
		return fmt.Errorf("启动事务失败: %v", err)
	}

	// 将新的组写入数据库
	affected, err := session.Insert(newGroup)
	if err != nil {
		// 发生错误时回滚事务
		session.Rollback()
		return err
	}
	if affected == 0 {
		// 发生错误时回滚事务
		session.Rollback()
		return fmt.Errorf("创建应用组群失败")
	}

	// 创建者的权限应记录到 AppGroupPermission 表中
	perm := AppGroupPermission{
		GroupId:    newGroup.No,
		UserId:     newGroup.CreatorId,
		Permission: 0,
	}

	// 检查权限记录是否存在
	exists, err := session.Exist(&AppGroupPermission{GroupId: newGroup.No, UserId: newGroup.CreatorId})
	if err != nil {
		// 发生错误时回滚事务
		session.Rollback()
		return fmt.Errorf("检查权限失败: %v", err)
	}

	if !exists {
		// 如果权限记录不存在，则添加
		affected, err = session.Insert(&perm)
		if err != nil {
			// 发生错误时回滚事务
			session.Rollback()
			return err
		}
		if affected == 0 {
			// 如果没有行被影响，则回滚事务
			session.Rollback()
			return fmt.Errorf("添加创建者权限失败")
		}
	}

	// 提交事务
	err = session.Commit()
	if err != nil {
		return fmt.Errorf("提交事务失败: %v", err)
	}
	return nil
}

// 查询指定 appid 和包含学校名称的 GroupName 的组群
func FindAppGroupsByAppIdAndSchool(session *xorm.Session, appid int64, schoolName string) ([]AppGroup, bool, error) {
	var groups []AppGroup
	err := session.Where("app_id = ? AND group_name LIKE ?", appid, "%"+schoolName+"%").Find(&groups)
	if err != nil {
		return nil, false, err
	}
	return groups, true, nil
}

//创建应用组群
func CreateAppGroup_Tx1(session *xorm.Session, newGroup *AppGroup) error {
	// 将新的组写入数据库
	affected, err := session.Insert(newGroup)
	if err != nil {

		return err
	}
	if affected == 0 {
		return fmt.Errorf("创建应用组群失败")
	}

	// 创建者的权限应记录到 AppGroupPermission 表中
	perm := AppGroupPermission{
		GroupId:    newGroup.No,
		UserId:     newGroup.CreatorId,
		Permission: 0,
	}

	// 检查权限记录是否存在
	exists, err := session.Exist(&AppGroupPermission{GroupId: newGroup.No, UserId: newGroup.CreatorId})
	if err != nil {
		return fmt.Errorf("检查权限失败: %v", err)
	}

	if !exists {
		// 如果权限记录不存在，则添加
		affected, err = session.Insert(&perm)
		if err != nil {

			return err
		}
		if affected == 0 {
			return fmt.Errorf("添加创建者权限失败")
		}
	}

	return nil
}

func CreateAppGroup_Tx(session *xorm.Session, newGroup *AppGroup) error {
	// 检查组群是否存在
	var appGroup = AppGroup{}
	exists, err := session.Where("group_name=?", newGroup.GroupName).Get(&appGroup)
	if err != nil {
		return fmt.Errorf("检查应用组群是否存在失败: %v", err)
	}

	if !exists {
		// 如果组群不存在，则插入新的组群
		affected, err := session.Insert(newGroup)
		if err != nil {
			return err
		}
		if affected == 0 {
			return fmt.Errorf("创建应用组群失败")
		}

		// 创建者的权限应记录到 AppGroupPermission 表中
		perm := AppGroupPermission{
			GroupId:    newGroup.No,
			UserId:     newGroup.CreatorId,
			Permission: 0,
		}

		// 检查权限记录是否存在
		permExists, err := session.Exist(&AppGroupPermission{GroupId: newGroup.No, UserId: newGroup.CreatorId})
		if err != nil {
			return fmt.Errorf("检查权限失败: %v", err)
		}

		if !permExists {
			// 如果权限记录不存在，则添加
			affected, err = session.Insert(&perm)
			if err != nil {
				return err
			}
			if affected == 0 {
				return fmt.Errorf("添加创建者权限失败")
			}
		}
	}
	// 如果组群存在，不进行插入操作

	return nil
}

//创建应用组群，权限传值
func CreateAppGroup_Permission(session *xorm.Session, newGroup *AppGroup, permission int) error {
	// 检查组群是否存在
	var appGroup = AppGroup{}
	exists, err := session.Where("group_name=?", newGroup.GroupName).Get(&appGroup)
	if err != nil {
		return fmt.Errorf("检查应用组群是否存在失败: %v", err)
	}

	if !exists {
		// 如果组群不存在，则插入新的组群
		affected, err := session.Insert(newGroup)
		if err != nil {
			return err
		}
		if affected == 0 {
			return fmt.Errorf("创建应用组群失败")
		}

		// 创建者的权限应记录到 AppGroupPermission 表中
		perm := AppGroupPermission{
			GroupId:    newGroup.No,
			UserId:     newGroup.CreatorId,
			Permission: permission,
		}

		// 检查权限记录是否存在
		permExists, err := session.Exist(&AppGroupPermission{GroupId: newGroup.No, UserId: newGroup.CreatorId})
		if err != nil {
			return fmt.Errorf("检查权限失败: %v", err)
		}

		if !permExists {
			// 如果权限记录不存在，则添加
			affected, err = session.Insert(&perm)
			if err != nil {
				return err
			}
			if affected == 0 {
				return fmt.Errorf("添加创建者权限失败")
			}
		}
	}
	// 如果组群存在，不进行插入操作

	return nil
}

//根据组名和组群id查询应用组是否存在
func FindAppGroupByGroupName(session *xorm.Session, groupName string) (*AppGroup, bool, error) {
	// 创建一个 AppGroup 对象，用来存放查询结果
	var appGroup AppGroup

	// 根据组名和组群 No 进行查询
	exists, err := session.Where("group_name = ?", groupName).Get(&appGroup)
	if err != nil {
		// 如果有错误，返回错误信息
		return nil, false, err
	}

	// 如果记录存在，返回 AppGroup 对象和 true
	if exists {
		return &appGroup, true, nil
	}

	// 如果记录不存在，返回 nil 和 false
	return nil, false, nil
}

func FindAppGroupByGroupName2(groupName string) (*AppGroup, bool, error) {
	// 创建一个 AppGroup 对象，用来存放查询结果
	var appGroup AppGroup

	// 根据组名和组群 No 进行查询
	exists, err := database.Engine.Where("group_name = ?", groupName).Get(&appGroup)
	if err != nil {
		// 如果有错误，返回错误信息
		return nil, false, err
	}

	// 如果记录存在，返回 AppGroup 对象和 true
	if exists {
		return &appGroup, true, nil
	}

	// 如果记录不存在，返回 nil 和 false
	return nil, false, nil
}

/*
   根据组群号邀请用户加入组成员
*/
// AppGroupInviteUser 使用组号 No 来向组群中添加用户，并给新用户设置默认权限
func AppGroupInviteUser(groupId string, userId int64) error {
	// 开启事务
	session := database.Engine.NewSession()
	defer session.Close()

	err := session.Begin()
	if err != nil {
		return fmt.Errorf("启动事务失败: %v", err)
	}

	// 获取目标组群
	var group AppGroup
	has, err := session.Where("no = ?", groupId).Get(&group)
	if err != nil {
		session.Rollback()
		return err
	}

	// 确认组存在
	if !has {
		session.Rollback()
		return fmt.Errorf("组群不存在")
	}

	// 检查用户是否已经是组群成员
	for _, member := range group.GroupMem {
		if member == userId {
			// 如果已存在，不需要添加，事务结束
			session.Rollback() // 回滚事务，因为没有要更新的内容
			return fmt.Errorf("用户已是组群成员")
		}
	}
	// 用户不在组群内，将其添加到成员列表
	group.GroupMem = append(group.GroupMem, userId)
	_, err = session.Where("no = ?", groupId).Cols("group_mem").Update(&group)
	if err != nil {
		session.Rollback()
		return fmt.Errorf("更新组成员时出现错误: %v", err)
	}

	// 创建新用户的权限记录
	perm := AppGroupPermission{
		GroupId:    groupId,
		UserId:     userId,
		Permission: 9, // 新用户默认权限设置为9
	}
	_, err = session.Insert(&perm)
	if err != nil {
		session.Rollback()
		return fmt.Errorf("插入新用户权限时出现错误: %v", err)
	}
	// 提交事务
	err = session.Commit()
	if err != nil {
		return fmt.Errorf("提交事务失败: %v", err)
	}

	return nil
}

// 添加用户到应用组群，权限传值
func AppGroupInviteUser_Permission(session *xorm.Session, groupId string, userId int64, permission int) error {
	// 获取目标组群
	var group AppGroup
	has, err := session.Where("no = ?", groupId).Get(&group)
	if err != nil {

		return err
	}

	// 确认组存在
	if !has {
		return fmt.Errorf("组群不存在")
	}

	// 检查用户是否已经是组群成员
	for _, member := range group.GroupMem {
		if member == userId {
			//return fmt.Errorf("用户已是组群成员")
			return nil
		}
	}
	// 用户不在组群内，将其添加到成员列表
	group.GroupMem = append(group.GroupMem, userId)
	_, err = session.Where("no = ?", groupId).Cols("group_mem").Update(&group)
	if err != nil {

		return fmt.Errorf("更新组成员时出现错误: %v", err)
	}

	// 创建新用户的权限记录
	perm := AppGroupPermission{
		GroupId:    groupId,
		UserId:     userId,
		Permission: permission, // 新用户默认权限设置为9
	}
	_, err = session.Insert(&perm)
	if err != nil {

		return fmt.Errorf("插入新用户权限时出现错误: %v", err)
	}

	return nil
}

// RemoveMemberFromGroup 从应用组中移除一个成员
func RemoveMemberFromGroup(groupNo string, memberID int64) error {
	// 启动事务
	session := database.Engine.NewSession()
	defer session.Close()
	if err := session.Begin(); err != nil {
		return fmt.Errorf("failed to start transaction: %v", err)
	}
	// 查找组
	var group AppGroup
	has, err := session.Where("no = ?", groupNo).Get(&group)
	if err != nil {
		session.Rollback()
		return fmt.Errorf("error finding app group: %v", err)
	}
	if !has {
		session.Rollback()
		return fmt.Errorf("app group not found")
	}

	// 从组成员中移除指定成员ID
	newGroupMem := make([]int64, 0)
	for _, id := range group.GroupMem {
		if id != memberID {
			newGroupMem = append(newGroupMem, id)
		}
	}

	// 如果成员ID实际上并不在这个组内，那么newGroupMem将会和group.GroupMem一样。
	// 你可以在这里决定是否在这种情况下返回一个错误或者简单地不作任何数据库上的更改。
	if len(newGroupMem) == len(group.GroupMem) {
		session.Rollback()
		return errors.New("该用户不存在于组群中")
	}

	// 将新的组成员列表更新到数据库
	group.GroupMem = newGroupMem
	if _, err = session.ID(groupNo).Cols("group_mem").Update(&group); err != nil {
		session.Rollback()
		return fmt.Errorf("error updating app group: %v", err)
	}

	// 删除应用组权限表中的记录
	appGroupPermission := &AppGroupPermission{GroupId: groupNo, UserId: memberID}
	if _, err = session.Delete(appGroupPermission); err != nil {
		session.Rollback()
		return fmt.Errorf("error deleting member permissions: %v", err)
	}

	// 提交事务
	if err = session.Commit(); err != nil {
		return fmt.Errorf("failed to commit transaction: %v", err)
	}

	return nil
}

// findAppGroupsByMemberID 函数根据组成员ID查询应用组
func FindAppGroupsByMemberID(memberID int64) ([]AppGroup, error) {
	var appGroups []AppGroup
	//构造一个JSON数组字符串，包含我们要查找的参与者ID
	memberId_Str := strconv.FormatInt(memberID, 10) // 将成员ID转换为字符串
	// 构造一个JSON数组字符串，包含我们要查找的参与者ID
	// 将 memberID 转换成 JSON 数组格式，以便与JSON_CONTAINS函数兼容
	memberIDStr := fmt.Sprintf("[%s]", memberId_Str)

	err := database.Engine.Where("JSON_CONTAINS(group_mem, ?)", memberIDStr).Find(&appGroups)
	if err != nil {
		return nil, fmt.Errorf("根据应用组成员查询可用的应用失败: %v", err)
	}

	return appGroups, nil
}

// GetUserApplicationDataByMemberId 根据组id和成员id查询用户应用数据
func GetUserApplicationDataByMemberId(groupId string, memberId int64) ([]UserApplicationData, error) {
	session := database.Engine.NewSession()
	defer session.Close()

	// 开始事务
	if err := session.Begin(); err != nil {
		return nil, err
	}

	// 提交或回滚事务
	defer func() {
		if p := recover(); p != nil {
			session.Rollback()
			panic(p)
		} else if err := session.Commit(); err != nil {
			session.Rollback()
		}
	}()

	// 查询群组信息以得到appId
	var appGroup AppGroup
	if _, err := session.Where("no = ?", groupId).Get(&appGroup); err != nil {
		return nil, err
	}

	// 使用得到的appId及提供的成员ID，查询该成员的用户应用数据
	var memberAppDataList []UserApplicationData
	err := session.Where("user_id = ? AND app_id = ?", memberId, appGroup.AppId).Find(&memberAppDataList)
	if err != nil {
		return nil, err
	}

	// 函数结尾的Commit操作在defer中已经处理
	return memberAppDataList, nil
}

// GetUserApplicationStatusDataByMemberId 根据组id和成员id查询用户状态数据
func GetUserApplicationStatusDataByMemberId(groupId string, memberId int64) ([]string, error) {
	session := database.Engine.NewSession()
	defer session.Close()

	// 开始事务
	if err := session.Begin(); err != nil {
		return nil, err
	}

	// 提交或回滚事务
	defer func() {
		if p := recover(); p != nil {
			session.Rollback()
			panic(p)
		} else if err := session.Commit(); err != nil {
			session.Rollback()
		}
	}()

	// 查询群组信息以得到appId
	var appGroup AppGroup
	if _, err := session.Where("no = ?", groupId).Get(&appGroup); err != nil {
		return nil, err
	}

	// 使用得到的appId及提供的成员ID，查询该成员的用户状态数据
	var memberAppDataList []UserApplicationData
	err := session.Where("user_id = ? AND app_id = ?", memberId, appGroup.AppId).Find(&memberAppDataList)
	if err != nil {
		return nil, err
	}

	// 从查询结果中提取StatusData字段
	var statusDataList []string
	for _, memberAppData := range memberAppDataList {
		statusDataList = append(statusDataList, memberAppData.StatusData)
	}

	// 函数结尾的Commit操作在defer中已经处理
	return statusDataList, nil
}

// GetAppGroupByID 使用xorm根据组群id获取组群对象
func GetAppGroupByID(session *xorm.Session, groupID string) (bool, *AppGroup, error) {
	var group AppGroup
	has, err := session.Where("no = ?", groupID).Get(&group)
	if err != nil {
		// 处理查询过程中可能出现的错误
		return false, nil, err
	}
	if !has {
		// 如果没有找到对应的组群对象
		return false, nil, nil // 或者返回自定义错误，如errors.New("group not found")
	}
	return true, &group, nil
}

// GetAppGroupByID 使用xorm根据组群id获取组群对象
func GetAppGroupByNo(groupID string) (bool, *AppGroup, error) {
	var group AppGroup
	has, err := database.Engine.Where("no = ?", groupID).Get(&group)
	if err != nil {
		// 处理查询过程中可能出现的错误
		return false, nil, err
	}
	if !has {
		// 如果没有找到对应的组群对象
		return false, nil, nil // 或者返回自定义错误，如errors.New("group not found")
	}
	return true, &group, nil
}

//获取用户权限
func GetUserPermission(session *xorm.Session, groupId string, userId int64) (int, *AppGroupPermission, error) {

	var groupPermission AppGroupPermission
	// 从数据库中获取权限记录，条件是群组ID和用户ID匹配。
	// 如果找不到记录，has 会是 false。
	has, err := session.Where("group_id = ? AND user_id = ?", groupId, userId).Get(&groupPermission)
	if err != nil {
		return -1, nil, fmt.Errorf("查询组群权限记录失败: %v", err)
	}
	if !has {
		// 如果没有找到记录，可以根据实际情况选择如何处理，这里返回默认权限或错误。
		return -1, nil, fmt.Errorf("未查询到组群权限记录: %v", err)
	}
	return groupPermission.Permission, &groupPermission, nil

}

//判断某个应用组群是否存在某个用户成员
func DoesGroupContainMember(session *xorm.Session, groupId string, groupName string, memberId int64) (*AppGroup, bool, error) {
	var appGroup AppGroup

	// 构建查询，同时满足组群id、组群名和指定成员存在于组群中
	exists, err := session.
		Where("no = ?", groupId).
		And("group_name = ?", groupName).
		And("JSON_CONTAINS(group_mem, ?)", fmt.Sprintf("[%d]", memberId)). // 检查 group_mem JSON数组中是否包含 memberId
		Get(&appGroup)

	if err != nil {
		// 发生错误，返回错误信息
		return nil, false, err
	}

	// 如果 AppGroup 存在，并且包含该成员，则返回 AppGroup 对象和 true
	if exists {
		return &appGroup, true, nil
	}

	// 如果记录不存在，返回 nil 和 false
	return nil, false, nil
}

// UpdateAppGroupPermission 根据传入的 AppGroupPermission 对象更新数据库中的记录
func UpdateAppGroupPermission(session *xorm.Session, permission *AppGroupPermission) (int64, error) {
	// 这里确保传入的对象不是空的
	if permission == nil {
		return 0, fmt.Errorf("UpdateAppGroupPermission: received nil AppGroupPermission")
	}
	//affected, err := session.Id(permission.GroupId).Update(permission)
	// 根据 GroupId 和 UserId 来更新记录，确保更新的是正确的记录
	has, err := session.Where(" group_id=? and user_id =?  ", permission.GroupId, permission.UserId).Get(permission)
	if err != nil {
		return 0, err
	}
	if !has {
		fmt.Println(permission.GroupId, permission.UserId, "permission不存在 ")
	}
	affected, err := session.Where("group_id=? and user_id =?  ", permission.GroupId, permission.UserId).Update(permission)
	return affected, err
}

//根据应用id和组成员ID包含用户id的，且用户权限为0的应用组群
func GetAppGroupsByAppIDAndContainMemberUserID2(session *xorm.Session, appID int64, userID int64, permission int) ([]*AppGroup, bool, error) {
	var appGroups []*AppGroup
	err := session.Table("app_group").
		Join("INNER", "app_group_permission", "app_group.no = app_group_permission.group_id").
		Where("app_group.app_id = ?", appID).
		And("JSON_CONTAINS(app_group.group_mem, CAST(? AS JSON))", userID).
		And("app_group_permission.permission = ?", permission).
		Find(&appGroups)
	if err != nil {
		return nil, false, err
	}
	/*if !exist {
		return nil, false, nil
	}*/
	return appGroups, true, nil
}

//根据应用id和组成员ID包含用户id的，且用户权限为0的应用组群
func GetAppGroupsByAppIDAndContainMemberUserID(appID int64, userID int64, permission int) (*AppGroup, bool, error) {
	var appGroup AppGroup
	exist, err := database.Engine.Table("app_group").
		Join("INNER", "app_group_permission", "app_group.no = app_group_permission.group_id").
		Where("app_group.app_id = ?", appID).
		And("JSON_CONTAINS(app_group.group_mem, CAST(? AS JSON))", userID).
		And("app_group_permission.permission = ?", permission).
		Get(&appGroup)
	if err != nil {
		return nil, false, err
	}
	if !exist {
		return nil, false, nil
	}
	return &appGroup, true, nil
}

//根据组群号，获取组成员中成员用户id，且成员权限为9的用户，给出一个数据库操作的函数
func GetMembersWithUserPermission9(session *xorm.Session, group *AppGroup) ([]int64, error) {
	var permissions []AppGroupPermission
	err := session.Table("app_group_permission").
		Where("group_id = ?", group.No).
		And("permission = ?", 9).
		Find(&permissions)
	if err != nil {
		return nil, err
	}
	var memberIDs []int64
	for _, perm := range permissions {
		memberIDs = append(memberIDs, perm.UserId)
	}

	return memberIDs, nil
}

// GetMembersWithPermission9 根据组群名称获取权限值为9的成员
func GetMembersWithPermission9(session *xorm.Session, groupName string) ([]int64, error) {
	var group AppGroup
	_, err := session.Where("group_name = ?", groupName).Get(&group)
	if err != nil {
		return nil, err
	}

	var permissions []AppGroupPermission
	err = session.Where("group_id = ? AND permission = ?", group.No, 9).Find(&permissions)
	if err != nil {
		return nil, err
	}

	membersWithPermission9 := make([]int64, 0)
	for _, perm := range permissions {
		for _, memId := range group.GroupMem {
			if memId == perm.UserId {
				membersWithPermission9 = append(membersWithPermission9, memId)
				break
			}
		}
	}
	return membersWithPermission9, nil
}

// findGroupOwner 根据群号和权限查找群主
func GetAppGroupMaster(session *xorm.Session, groupId string) (int64, error) {
	var permission AppGroupPermission
	has, err := session.Where("group_id = ? AND permission = ?", groupId, 0).Get(&permission)
	if err != nil {
		return 0, err
	}
	if !has {
		return 0, nil
	}
	return permission.UserId, nil
}

// CheckUserInAppGroup 检查特定用户是否在应用组群内，使用JSON_CONTAINS
func CheckUserInAppGroup(session *xorm.Session, no string, appID int64, userID int64) (bool, error) {
	var appGroup AppGroup
	jsonQuery := fmt.Sprintf("[%d]", userID) // 构造JSON查询字符串

	// JSON_CONTAINS需要group_mem是JSON格式，假设已进行必要的数据转换
	has, err := session.Where("no = ? AND app_id = ?", no, appID).
		And("JSON_CONTAINS(group_mem, ?)", jsonQuery).
		Get(&appGroup)

	if err != nil {
		return false, err
	}

	return has, nil
}

// 检查某用户是否在应用组群中
func CheckUserInAppGroup2(no string, appID int64, userID int64) (bool, error) {
	var appGroup AppGroup
	jsonQuery := fmt.Sprintf("[%d]", userID) // 构造JSON查询字符串

	// JSON_CONTAINS需要group_mem是JSON格式，假设已进行必要的数据转换
	has, err := database.Engine.Where("no = ? AND app_id = ?", no, appID).
		And("JSON_CONTAINS(group_mem, ?)", jsonQuery).
		Get(&appGroup)

	if err != nil {
		return false, err
	}

	return has, nil
}

// 根据应用ID、名称和组主有最高权限的条件查询应用组群
func GetAppGroupsByGroupNameAndUserId(session *xorm.Session, appID int64, userID int64, groupName string, permission int) (*AppGroup, bool, error) {
	var appGroup AppGroup

	// 使用CONVERT(userID, CHAR)确保数字被正确处理
	userIDString := fmt.Sprintf("[%d]", userID) // 将userID转换为JSON数组格式
	exist, err := session.Table("app_group").
		Join("INNER", "app_group_permission", "app_group.no = app_group_permission.group_id").
		Where("app_group.app_id = ?", appID).
		And("app_group.group_name = ?", groupName).
		And("JSON_CONTAINS(app_group.group_mem, ?)", userIDString).
		And("app_group_permission.user_id = ?", userID).
		And("app_group_permission.permission = ?", permission).
		Get(&appGroup)

	if err != nil {
		return nil, false, err
	}
	if !exist {
		return nil, false, nil
	}
	return &appGroup, true, nil
}

// QueryAppGroups 根据appId和groupName查询组群信息
func QueryAppGroup(appId int64, groupName string) (*AppGroup, error) {
	var group AppGroup
	has, err := database.Engine.Where("app_id = ? AND group_name = ?", appId, groupName).Get(&group)
	if err != nil {
		return nil, err
	}
	if !has {
		return nil, err
	}
	return &group, nil
}
